From 6a35bfd2fa9c10cdaf7a755d0bf444dbeb22e4a4 Mon Sep 17 00:00:00 2001
From: mrdudz
Date: Wed, 15 Jun 2022 23:04:57 +0200
Subject: [PATCH 001/139] fix scanning the fractional digits of a float
---
src/cc65/scanner.c | 9 ++++++---
1 file changed, 6 insertions(+), 3 deletions(-)
diff --git a/src/cc65/scanner.c b/src/cc65/scanner.c
index 70203d027..76e7eea23 100644
--- a/src/cc65/scanner.c
+++ b/src/cc65/scanner.c
@@ -629,14 +629,17 @@ static void NumericConst (void)
NextChar ();
/* Read fractional digits */
- Scale = FP_D_Make (1.0);
+ Scale = FP_D_Make (10.0);
while (IsXDigit (CurC) && (DigitVal = HexVal (CurC)) < Base) {
/* Get the value of this digit */
- Double FracVal = FP_D_Div (FP_D_FromInt (DigitVal * Base), Scale);
+ Double FracVal = FP_D_FromInt(0);
+ if (DigitVal != 0) {
+ FracVal = FP_D_Div (FP_D_FromInt (DigitVal), Scale);
+ }
/* Add it to the float value */
FVal = FP_D_Add (FVal, FracVal);
/* Scale base */
- Scale = FP_D_Mul (Scale, FP_D_FromInt (DigitVal));
+ Scale = FP_D_Mul (Scale, FP_D_FromInt (Base));
/* Skip the digit */
NextChar ();
}
From 1fb7c896b4b9a99dedfbe6e43ac24901b08819a6 Mon Sep 17 00:00:00 2001
From: mrdudz
Date: Mon, 20 Jun 2022 01:51:19 +0200
Subject: [PATCH 002/139] beginning of half broken 32bit float support
---
src/cc65/assignment.c | 15 +-
src/cc65/codegen.c | 428 ++++++++++++++++++++++++++++++++++++------
src/cc65/codegen.h | 10 +-
src/cc65/datatype.c | 13 ++
src/cc65/expr.c | 352 ++++++++++++++++++++++++----------
src/cc65/initdata.c | 19 +-
src/cc65/loadexpr.c | 63 +++++--
src/cc65/locals.c | 10 +-
src/cc65/scanner.c | 5 +
src/cc65/typeconv.c | 42 ++++-
src/common/fp.c | 20 +-
src/common/fp.h | 9 +-
12 files changed, 798 insertions(+), 188 deletions(-)
diff --git a/src/cc65/assignment.c b/src/cc65/assignment.c
index e6d1e4526..112db7c10 100644
--- a/src/cc65/assignment.c
+++ b/src/cc65/assignment.c
@@ -434,6 +434,8 @@ static void OpAssignArithmetic (const GenDesc* Gen, ExprDesc* Expr, const char*
unsigned Flags;
int MustScale;
+ printf("OpAssignArithmetic (Gen=%d)\n", (int)Gen);
+
ED_Init (&Expr2);
Expr2.Flags |= Expr->Flags & E_MASK_KEEP_SUBEXPR;
@@ -448,7 +450,9 @@ static void OpAssignArithmetic (const GenDesc* Gen, ExprDesc* Expr, const char*
PushAddr (Expr);
if (Gen == 0) {
-
+// printf("OpAssignArithmetic (gen=0) 1 lhs: %s rhs: %s\n",
+// (TypeOf (Expr->Type) == CF_FLOAT) ? "float" : "int",
+// (TypeOf (Expr2.Type) == CF_FLOAT) ? "float" : "int");
/* Read the expression on the right side of the '=' */
MarkedExprWithCheck (hie1, &Expr2);
@@ -460,6 +464,9 @@ static void OpAssignArithmetic (const GenDesc* Gen, ExprDesc* Expr, const char*
/* If necessary, load the value into the primary register */
LoadExpr (CF_NONE, &Expr2);
+printf("OpAssignArithmetic (0) 2 lhs: %s rhs: %s\n",
+ (TypeOf (Expr->Type) == CF_FLOAT) ? "float" : "int",
+ (TypeOf (Expr2.Type) == CF_FLOAT) ? "float" : "int");
} else {
/* Load the original value if necessary */
@@ -473,7 +480,9 @@ static void OpAssignArithmetic (const GenDesc* Gen, ExprDesc* Expr, const char*
MarkedExprWithCheck (hie1, &Expr2);
/* The rhs must be an integer (or a float, but we don't support that yet */
- if (!IsClassInt (Expr2.Type)) {
+ if (!IsClassInt (Expr2.Type)
+// && !IsClassFloat (Expr2.Type) /* FIXME: float */
+ ) {
Error ("Invalid right operand for binary operator '%s'", Op);
/* Continue. Wrong code will be generated, but the compiler won't
** break, so this is the best error recovery.
@@ -558,6 +567,8 @@ void OpAssign (const GenDesc* Gen, ExprDesc* Expr, const char* Op)
{
const Type* ltype = Expr->Type;
+ printf("OpAssign\n");
+
ExprDesc Expr2;
ED_Init (&Expr2);
Expr2.Flags |= Expr->Flags & E_MASK_KEEP_SUBEXPR;
diff --git a/src/cc65/codegen.c b/src/cc65/codegen.c
index c79863d0e..33781ab34 100644
--- a/src/cc65/codegen.c
+++ b/src/cc65/codegen.c
@@ -72,17 +72,18 @@
-static void typeerror (unsigned type)
+static void _typeerror (char *func, int line, unsigned type)
/* Print an error message about an invalid operand type */
{
/* Special handling for floats here: */
if ((type & CF_TYPEMASK) == CF_FLOAT) {
- Fatal ("Floating point type is currently unsupported");
+ Fatal ("%s:%d Floating point type is currently unsupported", func, line);
} else {
Internal ("Invalid type in CF flags: %04X, type = %u", type, type & CF_TYPEMASK);
}
}
+#define typeerror(t) _typeerror(__FILE__, __LINE__, t)
static void CheckLocalOffs (unsigned Offs)
@@ -688,14 +689,15 @@ void g_restore_regvars (int StackOffs, int RegOffs, unsigned Bytes)
/* Fetching memory cells */
/*****************************************************************************/
+//void _g_getimmed (unsigned Flags, uintptr_t Val, long Offs, char *file, int line);
+#define g_getimmed(a,b,c) _g_getimmed((a),(b),(c),(__FILE__),(__FUNCTION__),(__LINE__))
-
-void g_getimmed (unsigned Flags, uintptr_t Val, long Offs)
+void _g_getimmed(unsigned Flags, uintptr_t Val, long Offs, char *file, char *func, int line)
/* Load a constant into the primary register */
{
unsigned char B1, B2, B3, B4;
unsigned Done;
-
+printf("g_getimmed %s:%d:%s Flags:%04x Val: %08x Offs:%04x\n", file, line, func, Flags, Val, Offs);
if ((Flags & CF_CONST) != 0) {
@@ -713,6 +715,8 @@ void g_getimmed (unsigned Flags, uintptr_t Val, long Offs)
AddCodeLine ("lda #$%02X", (unsigned char) Val);
break;
+ case CF_FLOAT: /* FIXME float - handle like long here */
+printf("g_getimmed CF_FLOAT Val: %08lx\n", Val);
case CF_LONG:
/* Split the value into 4 bytes */
B1 = (unsigned char) (Val >> 0);
@@ -724,7 +728,7 @@ void g_getimmed (unsigned Flags, uintptr_t Val, long Offs)
Done = 0;
/* Load the value */
- AddCodeLine ("ldx #$%02X", B2);
+ AddCodeLine ("ldx #$%02X\t; g_getimmed LONG", B2);
Done |= 0x02;
if (B2 == B3) {
AddCodeLine ("stx sreg");
@@ -810,6 +814,8 @@ void g_getstatic (unsigned flags, uintptr_t label, long offs)
}
break;
+ case CF_FLOAT: /* FIXME: float - can we really use the same as LONG? */
+ /* FIXME: float - what is the CF_TEST about? */
case CF_LONG:
if (flags & CF_TEST) {
AddCodeLine ("lda %s+3", lbuf);
@@ -835,7 +841,7 @@ void g_getstatic (unsigned flags, uintptr_t label, long offs)
void g_getlocal (unsigned Flags, int Offs)
-/* Fetch specified local object (local var). */
+/* Fetch specified local object (local var) into the primary register */
{
Offs -= StackPtr;
switch (Flags & CF_TYPEMASK) {
@@ -870,6 +876,8 @@ void g_getlocal (unsigned Flags, int Offs)
}
break;
+ case CF_FLOAT: /* FIXME: float - can we really use the same as LONG? */
+
case CF_LONG:
CheckLocalOffs (Offs + 3);
AddCodeLine ("ldy #$%02X", (unsigned char) (Offs+3));
@@ -891,6 +899,7 @@ void g_getind (unsigned Flags, unsigned Offs)
** into the primary register
*/
{
+ printf("g_getind flags:%04x offs:%04x\n", Flags, Offs);
/* If the offset is greater than 255, add the part that is > 255 to
** the primary. This way we get an easy addition and use the low byte
** as the offset
@@ -924,6 +933,8 @@ void g_getind (unsigned Flags, unsigned Offs)
}
break;
+ case CF_FLOAT: /* FIXME: float - can we really use the same as LONG here? */
+
case CF_LONG:
AddCodeLine ("ldy #$%02X", Offs+3);
AddCodeLine ("jsr ldeaxidx");
@@ -1073,6 +1084,8 @@ void g_putstatic (unsigned flags, uintptr_t label, long offs)
AddCodeLine ("stx %s+1", lbuf);
break;
+ case CF_FLOAT: /* FIXME: float - can we really use the same as LONG? */
+
case CF_LONG:
AddCodeLine ("sta %s", lbuf);
AddCodeLine ("stx %s+1", lbuf);
@@ -1093,6 +1106,7 @@ void g_putstatic (unsigned flags, uintptr_t label, long offs)
void g_putlocal (unsigned Flags, int Offs, long Val)
/* Put data into local object. */
{
+ printf("g_putlocal Flags:%04x Offs:%d val: %ld\n", Flags, Offs, Val);
Offs -= StackPtr;
CheckLocalOffs (Offs);
switch (Flags & CF_TYPEMASK) {
@@ -1136,6 +1150,8 @@ void g_putlocal (unsigned Flags, int Offs, long Val)
}
break;
+ case CF_FLOAT: /* FIXME: float - can we use the same as LONG here? */
+
case CF_LONG:
if (Flags & CF_CONST) {
g_getimmed (Flags, Val, 0);
@@ -1286,6 +1302,11 @@ static void g_regchar (unsigned Flags)
{
unsigned L;
+ /* FIXME: float */
+ if ((Flags & CF_TYPEMASK) == CF_FLOAT) {
+ typeerror (Flags);
+ }
+
AddCodeLine ("ldx #$00");
if ((Flags & CF_UNSIGNED) == 0) {
@@ -1301,8 +1322,9 @@ static void g_regchar (unsigned Flags)
void g_regint (unsigned Flags)
-/* Make sure, the value in the primary register an int. Convert if necessary */
+/* Make sure, the value in the primary register is an int. Convert if necessary */
{
+ printf("g_regint flags: %04x\n", Flags);
switch (Flags & CF_TYPEMASK) {
case CF_CHAR:
@@ -1316,6 +1338,11 @@ void g_regint (unsigned Flags)
case CF_LONG:
break;
+ /* FIXME: float */
+ case CF_FLOAT:
+ AddCodeLine ("jsr feaxint");
+ break;
+
default:
typeerror (Flags);
}
@@ -1368,11 +1395,57 @@ void g_reglong (unsigned Flags)
case CF_LONG:
break;
+ /* FIXME: float */
+ case CF_FLOAT:
+ AddCodeLine ("jsr feaxlong");
+ break;
+
default:
typeerror (Flags);
}
}
+void g_regfloat (unsigned Flags)
+/* Make sure, the value in the primary register is a float. Convert if necessary */
+{
+ printf("g_regfloat flags: %04x\n", Flags);
+ switch (Flags & CF_TYPEMASK) {
+
+ case CF_CHAR:
+ if (Flags & CF_FORCECHAR) {
+ /* Conversion is from char */
+ if (Flags & CF_UNSIGNED) {
+ AddCodeLine ("jsr aufloat");
+ } else {
+ AddCodeLine ("jsr afloat");
+ }
+ }
+ /* FALLTHROUGH */
+
+ case CF_INT:
+ if (Flags & CF_UNSIGNED) {
+ AddCodeLine ("jsr axufloat");
+ } else {
+ AddCodeLine ("jsr axfloat");
+ }
+ break;
+
+ case CF_LONG:
+ if (Flags & CF_UNSIGNED) {
+ AddCodeLine ("jsr eaxufloat");
+ } else {
+ AddCodeLine ("jsr eaxfloat");
+ }
+ break;
+
+ case CF_FLOAT:
+ /* do nothing */
+ break;
+
+ default:
+ typeerror (Flags);
+ }
+}
static unsigned g_intpromotion (unsigned flags)
@@ -1417,6 +1490,22 @@ unsigned g_typeadjust (unsigned lhs, unsigned rhs)
unsigned ltype = lhs & CF_TYPEMASK;
unsigned rtype = rhs & CF_TYPEMASK;
+ /* Result is const if both operands are const. */
+ unsigned const_flag = (lhs & CF_CONST) & (rhs & CF_CONST);
+
+ /* FIXME: float - this is is much more complicated */
+ if (ltype == CF_FLOAT && rtype == CF_FLOAT) {
+ return const_flag | CF_FLOAT;
+ }
+ if (ltype == CF_FLOAT) {
+ printf("FIXME: conversion to float format missing\n");
+ return (lhs & CF_CONST) | CF_FLOAT;
+ }
+ if (rtype == CF_FLOAT) {
+ printf("FIXME: conversion to float format missing\n");
+ return (rhs & CF_CONST) | CF_FLOAT;
+ }
+
/* Check if a conversion is needed */
if (ltype == CF_LONG && rtype != CF_LONG && (rhs & CF_CONST) == 0) {
/* We must promote the primary register to long */
@@ -1430,9 +1519,6 @@ unsigned g_typeadjust (unsigned lhs, unsigned rhs)
}
}
- /* Result is const if both operands are const. */
- unsigned const_flag = (lhs & CF_CONST) & (rhs & CF_CONST);
-
/* https://port70.net/~nsz/c/c89/c89-draft.html#3.2.1.5
** Many binary operators that expect operands of arithmetic type cause conversions and yield
** result types in a similar way. The purpose is to yield a common type, which is also the type
@@ -1511,10 +1597,21 @@ unsigned g_typecast (unsigned lhs, unsigned rhs)
** by the lhs value. Return the result value.
*/
{
+printf("g_typecast 2 rhs: %s lhs: %s (rhs is %s)\n",
+ ((rhs & CF_TYPEMASK) == CF_FLOAT) ? "float" : "int",
+ ((lhs & CF_TYPEMASK) == CF_FLOAT) ? "float" : "int",
+ ((rhs & CF_CONST) == 0) ? "not const" : "const"
+ );
/* Check if a conversion is needed */
if ((rhs & CF_CONST) == 0) {
switch (lhs & CF_TYPEMASK) {
+ /* FIXME: float */
+ case CF_FLOAT:
+ /* We must promote the primary register to float */
+ g_regfloat (rhs);
+ break;
+
case CF_LONG:
/* We must promote the primary register to long */
g_reglong (rhs);
@@ -2292,7 +2389,12 @@ void g_cmp (unsigned flags, unsigned long val)
}
}
-
+#define OPER_IDX_SINT16 0
+#define OPER_IDX_UINT16 1
+#define OPER_IDX_SINT32 2
+#define OPER_IDX_UINT32 3
+#define OPER_IDX_FLOAT 4
+#define OPER_IDX_NUM 5
static void oper (unsigned Flags, unsigned long Val, const char* const* Subs)
/* Encode a binary operation. subs is a pointer to four strings:
@@ -2300,14 +2402,20 @@ static void oper (unsigned Flags, unsigned long Val, const char* const* Subs)
** 1 --> Operate on unsigneds
** 2 --> Operate on longs
** 3 --> Operate on unsigned longs
+** 4 --> Operate on floats
*/
{
+ int n = 0;
/* Determine the offset into the array */
- if (Flags & CF_UNSIGNED) {
- ++Subs;
- }
- if ((Flags & CF_TYPEMASK) == CF_LONG) {
- Subs += 2;
+ if (Flags & CF_FLOAT) {
+ n = OPER_IDX_FLOAT;
+ } else {
+ if (Flags & CF_UNSIGNED) {
+ n = 1; /* odd means unsigned */
+ }
+ if ((Flags & CF_TYPEMASK) == CF_LONG) {
+ n += 2;
+ }
}
/* Load the value if it is not already in the primary */
@@ -2316,9 +2424,12 @@ static void oper (unsigned Flags, unsigned long Val, const char* const* Subs)
g_getimmed (Flags, Val, 0);
}
- /* Output the operation */
- AddCodeLine ("jsr %s", *Subs);
-
+ if (Subs[n] == NULL) {
+ Internal("oper Subs NULL (%d)", n);
+ } else {
+ /* Output the operation */
+ AddCodeLine ("jsr %s", Subs[n]);
+ }
/* The operation will pop it's argument */
pop (Flags);
}
@@ -2399,6 +2510,8 @@ void g_push (unsigned flags, unsigned long val)
AddCodeLine ("jsr pushax");
break;
+ case CF_FLOAT: /* FIXME: float - handle like long here */
+
case CF_LONG:
AddCodeLine ("jsr pusheax");
break;
@@ -2414,6 +2527,36 @@ void g_push (unsigned flags, unsigned long val)
push (flags);
}
+/* FIXME: float */
+void g_push_float (unsigned flags, float val)
+/* Push the primary register or a constant value onto the stack */
+{
+// printf("g_push_float flags:%04x val:%f\n", flags, val);
+ /* Push the primary register */
+ switch (flags & CF_TYPEMASK) {
+
+ case CF_FLOAT: /* FIXME: float - handle like long here */
+ /* Value is not 16 bit or not constant */
+// if (flags & CF_CONST)
+ {
+ float f = val;
+ uintptr_t *p = &val; /* FIXME: float - we shouldnt do this :) */
+ /* Constant 32 bit value, load into eax */
+ printf("g_push_float flags:%04x f:%p\n", flags, *p);
+ g_getimmed (flags | CF_CONST, *p, 0); // ?? FIXME
+// g_getimmed (0x41,*p,0);
+ }
+ AddCodeLine ("jsr pusheax");
+ break;
+
+ default:
+ typeerror (flags);
+
+ }
+
+ /* Adjust the stack offset */
+ push (flags);
+}
void g_swap (unsigned flags)
@@ -2612,8 +2755,12 @@ void g_stackcheck (void)
void g_add (unsigned flags, unsigned long val)
/* Primary = TOS + Primary */
{
- static const char* const ops[4] = {
- "tosaddax", "tosaddax", "tosaddeax", "tosaddeax"
+ static const char* const ops[OPER_IDX_NUM] = {
+ "tosaddax",
+ "tosaddax", /* unsigned */
+ "tosaddeax",
+ "tosaddeax", /* unsigned, 32bit */
+ "ftosaddeax" /* float, 32bit */
};
if (flags & CF_CONST) {
@@ -2628,8 +2775,12 @@ void g_add (unsigned flags, unsigned long val)
void g_sub (unsigned flags, unsigned long val)
/* Primary = TOS - Primary */
{
- static const char* const ops[4] = {
- "tossubax", "tossubax", "tossubeax", "tossubeax"
+ static const char* const ops[OPER_IDX_NUM] = {
+ "tossubax",
+ "tossubax", /* unsigned */
+ "tossubeax",
+ "tossubeax", /* unsigned, 32bit */
+ "ftossubeax" /* float, 32bit */
};
if (flags & CF_CONST) {
@@ -2644,8 +2795,12 @@ void g_sub (unsigned flags, unsigned long val)
void g_rsub (unsigned flags, unsigned long val)
/* Primary = Primary - TOS */
{
- static const char* const ops[4] = {
- "tosrsubax", "tosrsubax", "tosrsubeax", "tosrsubeax"
+ static const char* const ops[OPER_IDX_NUM] = {
+ "tosrsubax",
+ "tosrsubax",
+ "tosrsubeax",
+ "tosrsubeax",
+ "ftosrsubeax"
};
oper (flags, val, ops);
}
@@ -2655,10 +2810,16 @@ void g_rsub (unsigned flags, unsigned long val)
void g_mul (unsigned flags, unsigned long val)
/* Primary = TOS * Primary */
{
- static const char* const ops[4] = {
- "tosmulax", "tosumulax", "tosmuleax", "tosumuleax"
+ static const char* const ops[OPER_IDX_NUM] = {
+ "tosmulax",
+ "tosumulax",
+ "tosmuleax",
+ "tosumuleax",
+ "ftosmuleax"
};
+ printf("g_mul flags:%04x val:%d\n", flags, val);
+
/* Do strength reduction if the value is constant and a power of two */
if (flags & CF_CONST) {
@@ -2751,6 +2912,8 @@ void g_mul (unsigned flags, unsigned long val)
}
break;
+ case CF_FLOAT: /* FIXME: float: is it the right thing here to do the same as LONG? */
+
case CF_LONG:
break;
@@ -2775,10 +2938,16 @@ void g_mul (unsigned flags, unsigned long val)
void g_div (unsigned flags, unsigned long val)
/* Primary = TOS / Primary */
{
- static const char* const ops[4] = {
- "tosdivax", "tosudivax", "tosdiveax", "tosudiveax"
+ static const char* const ops[OPER_IDX_NUM] = {
+ "tosdivax",
+ "tosudivax",
+ "tosdiveax",
+ "tosudiveax",
+ "ftosdiveax"
};
+ printf("g_div flags:%04x val:%d\n", flags, val);
+
/* Do strength reduction if the value is constant and a power of two */
if (flags & CF_CONST) {
@@ -2886,8 +3055,12 @@ void g_div (unsigned flags, unsigned long val)
void g_mod (unsigned flags, unsigned long val)
/* Primary = TOS % Primary */
{
- static const char* const ops[4] = {
- "tosmodax", "tosumodax", "tosmodeax", "tosumodeax"
+ static const char* const ops[OPER_IDX_NUM] = {
+ "tosmodax",
+ "tosumodax",
+ "tosmodeax",
+ "tosumodeax",
+ NULL /* modulo is invalid for float */
};
int p2;
@@ -2911,8 +3084,8 @@ void g_mod (unsigned flags, unsigned long val)
void g_or (unsigned flags, unsigned long val)
/* Primary = TOS | Primary */
{
- static const char* const ops[4] = {
- "tosorax", "tosorax", "tosoreax", "tosoreax"
+ static const char* const ops[OPER_IDX_NUM] = {
+ "tosorax", "tosorax", "tosoreax", "tosoreax", NULL
};
/* If the right hand side is const, the lhs is not on stack but still
@@ -2981,8 +3154,8 @@ void g_or (unsigned flags, unsigned long val)
void g_xor (unsigned flags, unsigned long val)
/* Primary = TOS ^ Primary */
{
- static const char* const ops[4] = {
- "tosxorax", "tosxorax", "tosxoreax", "tosxoreax"
+ static const char* const ops[OPER_IDX_NUM] = {
+ "tosxorax", "tosxorax", "tosxoreax", "tosxoreax", NULL
};
@@ -3049,8 +3222,8 @@ void g_xor (unsigned flags, unsigned long val)
void g_and (unsigned Flags, unsigned long Val)
/* Primary = TOS & Primary */
{
- static const char* const ops[4] = {
- "tosandax", "tosandax", "tosandeax", "tosandeax"
+ static const char* const ops[OPER_IDX_NUM] = {
+ "tosandax", "tosandax", "tosandeax", "tosandeax", NULL
};
/* If the right hand side is const, the lhs is not on stack but still
@@ -3141,8 +3314,8 @@ void g_and (unsigned Flags, unsigned long Val)
void g_asr (unsigned flags, unsigned long val)
/* Primary = TOS >> Primary */
{
- static const char* const ops[4] = {
- "tosasrax", "tosshrax", "tosasreax", "tosshreax"
+ static const char* const ops[OPER_IDX_NUM] = {
+ "tosasrax", "tosshrax", "tosasreax", "tosshreax", NULL
};
/* If the right hand side is const, the lhs is not on stack, but still
@@ -3315,8 +3488,8 @@ void g_asr (unsigned flags, unsigned long val)
void g_asl (unsigned flags, unsigned long val)
/* Primary = TOS << Primary */
{
- static const char* const ops[4] = {
- "tosaslax", "tosshlax", "tosasleax", "tosshleax"
+ static const char* const ops[OPER_IDX_NUM] = {
+ "tosaslax", "tosshlax", "tosasleax", "tosshleax", NULL
};
/* If the right hand side is const, the lhs is not on stack, but still
@@ -3450,6 +3623,11 @@ void g_neg (unsigned Flags)
AddCodeLine ("jsr negeax");
break;
+ /* FIXME: float */
+ case CF_FLOAT:
+ AddCodeLine ("jsr fnegeax");
+ break;
+
default:
typeerror (Flags);
}
@@ -3474,6 +3652,11 @@ void g_bneg (unsigned flags)
AddCodeLine ("jsr bnegeax");
break;
+ /* FIXME: float */
+ case CF_FLOAT:
+ AddCodeLine ("jsr fbnegeax");
+ break;
+
default:
typeerror (flags);
}
@@ -3509,8 +3692,11 @@ void g_com (unsigned Flags)
void g_inc (unsigned flags, unsigned long val)
-/* Increment the primary register by a given number */
+/* Increment the primary register by a given number
+ if flags contain CF_FLOAT, then val can be a raw binary float.
+*/
{
+ printf("g_inc flags:%04x val:%08lx\n", flags, val);
/* Don't inc by zero */
if (val == 0) {
return;
@@ -3599,6 +3785,11 @@ void g_inc (unsigned flags, unsigned long val)
}
break;
+ /* FIXME: float */
+ case CF_FLOAT:
+ g_add (flags | CF_CONST, val);
+ break;
+
default:
typeerror (flags);
@@ -3608,7 +3799,9 @@ void g_inc (unsigned flags, unsigned long val)
void g_dec (unsigned flags, unsigned long val)
-/* Decrement the primary register by a given number */
+/* Decrement the primary register by a given number
+ if flags contain CF_FLOAT, then val can be a raw binary float.
+*/
{
/* Don't dec by zero */
if (val == 0) {
@@ -3691,6 +3884,11 @@ void g_dec (unsigned flags, unsigned long val)
}
break;
+ /* FIXME: float */
+ case CF_FLOAT:
+ g_sub (flags | CF_CONST, val);
+ break;
+
default:
typeerror (flags);
@@ -3710,12 +3908,16 @@ void g_dec (unsigned flags, unsigned long val)
void g_eq (unsigned flags, unsigned long val)
/* Test for equal */
{
- static const char* const ops[4] = {
- "toseqax", "toseqax", "toseqeax", "toseqeax"
+ static const char* const ops[OPER_IDX_NUM] = {
+ "toseqax",
+ "toseqax",
+ "toseqeax",
+ "toseqeax",
+ "ftoseqeax"
};
unsigned L;
-
+ printf("g_eq flags:%04x val:%ld\n", flags, val);
/* If the right hand side is const, the lhs is not on stack but still
** in the primary register.
*/
@@ -3743,6 +3945,10 @@ void g_eq (unsigned flags, unsigned long val)
case CF_LONG:
break;
+ /* FIXME: float */
+ case CF_FLOAT:
+ break;
+
default:
typeerror (flags);
}
@@ -3764,8 +3970,12 @@ void g_eq (unsigned flags, unsigned long val)
void g_ne (unsigned flags, unsigned long val)
/* Test for not equal */
{
- static const char* const ops[4] = {
- "tosneax", "tosneax", "tosneeax", "tosneeax"
+ static const char* const ops[OPER_IDX_NUM] = {
+ "tosneax",
+ "tosneax",
+ "tosneeax",
+ "tosneeax",
+ "ftosneeax"
};
unsigned L;
@@ -3797,6 +4007,10 @@ void g_ne (unsigned flags, unsigned long val)
case CF_LONG:
break;
+ /* FIXME: float */
+ case CF_FLOAT:
+ break;
+
default:
typeerror (flags);
}
@@ -3818,8 +4032,12 @@ void g_ne (unsigned flags, unsigned long val)
void g_lt (unsigned flags, unsigned long val)
/* Test for less than */
{
- static const char* const ops[4] = {
- "tosltax", "tosultax", "toslteax", "tosulteax"
+ static const char* const ops[OPER_IDX_NUM] = {
+ "tosltax",
+ "tosultax",
+ "toslteax",
+ "tosulteax",
+ "ftoslteax"
};
unsigned Label;
@@ -3913,6 +4131,10 @@ void g_lt (unsigned flags, unsigned long val)
AddCodeLine ("rol a");
return;
+ /* FIXME: float */
+ case CF_FLOAT:
+ break;
+
default:
typeerror (flags);
}
@@ -3957,6 +4179,10 @@ void g_lt (unsigned flags, unsigned long val)
/* This one is too costly */
break;
+ /* FIXME: float */
+ case CF_FLOAT:
+ break;
+
default:
typeerror (flags);
}
@@ -3980,8 +4206,12 @@ void g_lt (unsigned flags, unsigned long val)
void g_le (unsigned flags, unsigned long val)
/* Test for less than or equal to */
{
- static const char* const ops[4] = {
- "tosleax", "tosuleax", "tosleeax", "tosuleeax"
+ static const char* const ops[OPER_IDX_NUM] = {
+ "tosleax",
+ "tosuleax",
+ "tosleeax",
+ "tosuleeax",
+ "ftosleeax"
};
@@ -4074,6 +4304,10 @@ void g_le (unsigned flags, unsigned long val)
}
return;
+ /* FIXME: float */
+ case CF_FLOAT:
+ break;
+
default:
typeerror (flags);
}
@@ -4095,8 +4329,12 @@ void g_le (unsigned flags, unsigned long val)
void g_gt (unsigned flags, unsigned long val)
/* Test for greater than */
{
- static const char* const ops[4] = {
- "tosgtax", "tosugtax", "tosgteax", "tosugteax"
+ static const char* const ops[OPER_IDX_NUM] = {
+ "tosgtax",
+ "tosugtax",
+ "tosgteax",
+ "tosugteax",
+ "ftosgteax"
};
@@ -4205,6 +4443,10 @@ void g_gt (unsigned flags, unsigned long val)
}
return;
+ /* FIXME: float */
+ case CF_FLOAT:
+ break;
+
default:
typeerror (flags);
}
@@ -4226,8 +4468,12 @@ void g_gt (unsigned flags, unsigned long val)
void g_ge (unsigned flags, unsigned long val)
/* Test for greater than or equal to */
{
- static const char* const ops[4] = {
- "tosgeax", "tosugeax", "tosgeeax", "tosugeeax"
+ static const char* const ops[OPER_IDX_NUM] = {
+ "tosgeax",
+ "tosugeax",
+ "tosgeeax",
+ "tosugeeax",
+ "ftosgeeax"
};
unsigned Label;
@@ -4289,6 +4535,10 @@ void g_ge (unsigned flags, unsigned long val)
AddCodeLine ("rol a");
return;
+ /* FIXME: float */
+ case CF_FLOAT:
+ break;
+
default:
typeerror (flags);
}
@@ -4318,6 +4568,10 @@ void g_ge (unsigned flags, unsigned long val)
AddCodeLine ("jsr boolge");
return;
+ /* FIXME: float */
+ case CF_FLOAT:
+ break;
+
default:
typeerror (flags);
}
@@ -4362,6 +4616,10 @@ void g_ge (unsigned flags, unsigned long val)
/* This one is too costly */
break;
+ /* FIXME: float */
+ case CF_FLOAT:
+ break;
+
default:
typeerror (flags);
}
@@ -4414,7 +4672,12 @@ void g_defdata (unsigned flags, uintptr_t val, long offs)
case CF_LONG:
AddDataLine ("\t.dword\t$%08"PRIXPTR, val & 0xFFFFFFFF);
break;
-
+#if 0
+ case CF_FLOAT:
+ /* FIXME: float */
+ AddDataLine ("\t.dword\t$%08"PRIXPTR"\t; float", val & 0xFFFFFFFF);
+ break;
+#endif
default:
typeerror (flags);
break;
@@ -4432,7 +4695,56 @@ void g_defdata (unsigned flags, uintptr_t val, long offs)
}
}
+void g_defdata_float (unsigned flags, uintptr_t val, long offs)
+/* Define data with the size given in flags */
+{
+ printf("g_defdata_float flags:%04x val:%f offs:%04lx\n", flags, (float)val, offs);
+ if (flags & CF_CONST) {
+ /* Numeric constant */
+ switch (flags & CF_TYPEMASK) {
+
+ case CF_CHAR:
+ typeerror (flags);
+ break;
+
+ case CF_INT:
+ typeerror (flags);
+ break;
+
+ case CF_LONG:
+ typeerror (flags);
+ break;
+
+ case CF_FLOAT:
+ /* FIXME: float */
+// AddDataLine ("\t.float\t%f", (float)(val & 0xFFFFFFFF));
+// AddDataLine ("\t.dword\t$%08"PRIXPTR"\t; float", val & 0xFFFFFFFF);
+ {
+ /* FIXME: float - convert to binary format, this is super NOGO :) */
+// float f = (float)(val);
+ unsigned char *p = (unsigned char*)&val;
+ AddDataLine ("\t.dword\t$%02x%02x%02x%02x\t; float",
+ p[3],p[2],p[1],p[0]);
+ }
+ break;
+
+ default:
+ typeerror (flags);
+ break;
+
+ }
+
+ } else {
+
+ /* Create the correct label name */
+ const char* Label = GetLabelName (flags, val, offs);
+
+ /* Labels are always 16 bit */
+ AddDataLine ("\t.addr\t%s\t; float", Label);
+
+ }
+}
void g_defbytes (const void* Bytes, unsigned Count)
/* Output a row of bytes as a constant */
diff --git a/src/cc65/codegen.h b/src/cc65/codegen.h
index cb62d78bd..b5fe6daf1 100644
--- a/src/cc65/codegen.h
+++ b/src/cc65/codegen.h
@@ -271,9 +271,13 @@ void g_restore_regvars (int StackOffs, int RegOffs, unsigned Bytes);
-void g_getimmed (unsigned Flags, uintptr_t Val, long Offs);
+//void g_getimmed (unsigned Flags, uintptr_t Val, long Offs);
/* Load a constant into the primary register */
+#define g_getimmed(a,b,c) _g_getimmed((a),(b),(c),(__FILE__),(__FUNCTION__),(__LINE__))
+void _g_getimmed(unsigned Flags, uintptr_t Val, long Offs, char *file, char *func, int line);
+
+
void g_getstatic (unsigned Flags, uintptr_t Label, long Offs);
/* Fetch an static memory cell into the primary register */
@@ -392,6 +396,8 @@ void g_test (unsigned flags);
void g_push (unsigned flags, unsigned long val);
/* Push the primary register or a constant value onto the stack */
+void g_push_float (unsigned flags, float val);
+/* Push the primary register or a constant value onto the stack */
void g_swap (unsigned flags);
/* Swap the primary register and the top of the stack. flags give the type
@@ -463,6 +469,8 @@ void g_res (unsigned n);
void g_defdata (unsigned flags, uintptr_t val, long offs);
/* Define data with the size given in flags */
+void g_defdata_float (unsigned flags, uintptr_t val, long offs);
+/* Define data with the size given in flags */
void g_defbytes (const void* bytes, unsigned count);
/* Output a row of bytes as a constant */
diff --git a/src/cc65/datatype.c b/src/cc65/datatype.c
index e43af238e..7104ed670 100644
--- a/src/cc65/datatype.c
+++ b/src/cc65/datatype.c
@@ -1060,6 +1060,19 @@ const Type* ArithmeticConvert (const Type* lhst, const Type* rhst)
** of the result. This pattern is called the usual arithmetic conversions.
*/
+ if (IsTypeFloat (lhst) && IsTypeFloat (rhst)) {
+ /* FIXME: float - this needs much more special handling */
+ return type_float;
+ }
+ if (IsTypeFloat (lhst)) {
+ /* FIXME: float - this needs much more special handling */
+ return type_float;
+ }
+ if (IsTypeFloat (rhst)) {
+ /* FIXME: float - this needs much more special handling */
+ return type_float;
+ }
+
/* There are additional rules for floating point types that we don't bother with, since
** floating point types are not (yet) supported.
** The integral promotions are performed on both operands.
diff --git a/src/cc65/expr.c b/src/cc65/expr.c
index 0275e61a3..d9be6a74b 100644
--- a/src/cc65/expr.c
+++ b/src/cc65/expr.c
@@ -232,8 +232,14 @@ void LimitExprValue (ExprDesc* Expr)
Expr->IVal = (uint8_t)Expr->IVal;
break;
+ /* FIXME: float */
+ case T_FLOAT:
+ case T_DOUBLE:
+ Expr->V.FVal.V = (double)Expr->V.FVal.V;
+ break;
+
default:
- Internal ("hie_internal: constant result type %s\n", GetFullTypeName (Expr->Type));
+ Internal ("hie_internal: constant result type '%s' not implemented.\n", GetFullTypeName (Expr->Type));
}
}
@@ -1805,7 +1811,9 @@ static void UnaryOp (ExprDesc* Expr)
hie10 (Expr);
/* We can only handle integer types */
- if (!IsClassInt (Expr->Type)) {
+ if (!IsClassInt (Expr->Type)
+ && !IsClassFloat (Expr->Type) /* FIXME: float */
+ ) {
Error ("Argument must have integer type");
ED_MakeConstAbsInt (Expr, 1);
}
@@ -1813,15 +1821,27 @@ static void UnaryOp (ExprDesc* Expr)
/* Check for a constant numeric expression */
if (ED_IsConstAbs (Expr)) {
/* Value is numeric */
- switch (Tok) {
- case TOK_MINUS: Expr->IVal = -Expr->IVal; break;
- case TOK_PLUS: break;
- case TOK_COMP: Expr->IVal = ~Expr->IVal; break;
- default: Internal ("Unexpected token: %d", Tok);
- }
- /* Adjust the type of the expression */
- Expr->Type = IntPromotion (Expr->Type);
+ /* FIXME: float ---- start new code */
+ if (IsClassFloat (Expr->Type)) {
+ switch (Tok) {
+ case TOK_MINUS: Expr->V.FVal = FP_D_Mul(Expr->V.FVal, FP_D_FromInt(-1)); break;
+ case TOK_PLUS: break;
+ default: Internal ("Unexpected token: %d", Tok);
+ }
+ }
+ else {
+ /* FIXME: float ---- end new code */
+ switch (Tok) {
+ case TOK_MINUS: Expr->IVal = -Expr->IVal; break;
+ case TOK_PLUS: break;
+ case TOK_COMP: Expr->IVal = ~Expr->IVal; break;
+ default: Internal ("Unexpected token: %d", Tok);
+ }
+
+ /* Adjust the type of the expression */
+ Expr->Type = IntPromotion (Expr->Type);
+ }
/* Limit the calculated value to the range of its type */
LimitExprValue (Expr);
@@ -1833,7 +1853,11 @@ static void UnaryOp (ExprDesc* Expr)
LoadExpr (CF_NONE, Expr);
/* Adjust the type of the expression */
- Expr->Type = IntPromotion (Expr->Type);
+ /* FIXME: float */
+ if (!IsClassFloat (Expr->Type)) {
+ Expr->Type = IntPromotion (Expr->Type);
+ }
+// Expr->Type = IntPromotion (Expr->Type);
TypeConversion (Expr, Expr->Type);
/* Get code generation flags */
@@ -1872,6 +1896,7 @@ void hie10 (ExprDesc* Expr)
case TOK_PLUS:
case TOK_MINUS:
case TOK_COMP:
+ /* FIXME: whats with floats? */
UnaryOp (Expr);
break;
@@ -2017,8 +2042,9 @@ static void hie_internal (const GenDesc* Ops, /* List of generators */
unsigned ltype, type;
int lconst; /* Left operand is a constant */
int rconst; /* Right operand is a constant */
+ int floatop = 0;
-
+//printf("hie_internal\n");
ExprWithCheck (hienext, Expr);
*UsedGen = 0;
@@ -2031,16 +2057,33 @@ static void hie_internal (const GenDesc* Ops, /* List of generators */
/* Tell the caller that we handled it's ops */
*UsedGen = 1;
+ /* FIXME: float ---start new code*/
+ /* Remember the operator token, then skip it */
+ Tok = CurTok.Tok;
+ NextToken ();
+
+ switch (Tok) {
+ case TOK_STAR:
+ case TOK_DIV:
+ floatop = 1;
+ break;
+ }
+
+ /* FIXME: float ---start end code*/
+
/* All operators that call this function expect an int on the lhs */
- if (!IsClassInt (Expr->Type)) {
- Error ("Integer expression expected");
+ if (!IsClassInt (Expr->Type) &&
+ /* FIXME: float */
+ !(floatop && IsClassFloat (Expr->Type))
+ ) {
+ Error ("LHS Integer expression expected (hie_internal)");
/* To avoid further errors, make Expr a valid int expression */
ED_MakeConstAbsInt (Expr, 1);
}
- /* Remember the operator token, then skip it */
- Tok = CurTok.Tok;
- NextToken ();
+// /* Remember the operator token, then skip it */
+// Tok = CurTok.Tok;
+// NextToken ();
/* Get the lhs on stack */
GetCodePos (&Mark1);
@@ -2073,10 +2116,13 @@ static void hie_internal (const GenDesc* Ops, /* List of generators */
}
/* Check the type of the rhs */
- if (!IsClassInt (Expr2.Type)) {
- Error ("Integer expression expected");
+ if (!IsClassInt (Expr2.Type) &&
+ /* FIXME: float */
+ !(floatop && IsClassFloat (Expr2.Type))
+ ) {
+ Error ("RHS Integer expression expected (hie_internal)");
}
-
+printf("hie_internal lconst:%d rconst:%d\n", lconst, rconst);
/* Check for const operands */
if (lconst && rconst) {
@@ -2086,80 +2132,124 @@ static void hie_internal (const GenDesc* Ops, /* List of generators */
/* Get the type of the result */
Expr->Type = ArithmeticConvert (Expr->Type, Expr2.Type);
- /* Handle the op differently for signed and unsigned types */
- if (IsSignSigned (Expr->Type)) {
+ /* FIXME: float --- newcode start */
+printf("hie_internal Expr->Type:%s Expr2->Type:%s\n",
+ (IsClassFloat (Expr->Type) == CF_FLOAT) ? "float" : "int",
+ (IsClassFloat (Expr2.Type) == CF_FLOAT) ? "float" : "int"
+ );
+printf("hie_internal Expr->Type:%s Expr2->Type:%s\n",
+ (Expr->Type == type_float) ? "float" : "int",
+ (Expr2.Type == type_float) ? "float" : "int"
+ );
- /* Evaluate the result for signed operands */
- signed long Val1 = Expr->IVal;
- signed long Val2 = Expr2.IVal;
+ /* FIXME: float */
+ /* FIXME: right now this works only when both rhs and lhs are float,
+ this must be extended to handle mixed operations */
+// if ((IsClassFloat (Expr->Type) == CF_FLOAT) &&
+// (IsClassFloat (Expr2.Type) == CF_FLOAT)) {
+ if ((Expr->Type == type_float) &&
+ (Expr2.Type == type_float)) {
+ /* Evaluate the result for float operands */
+ Double Val1 = Expr->V.FVal;
+ Double Val2 = Expr2.V.FVal;
+ printf("hie_internal float X float\n");
switch (Tok) {
- case TOK_OR:
- Expr->IVal = (Val1 | Val2);
- break;
- case TOK_XOR:
- Expr->IVal = (Val1 ^ Val2);
- break;
- case TOK_AND:
- Expr->IVal = (Val1 & Val2);
+ case TOK_DIV:
+#if 0 // TODO
+ if (Val2 == 0.0f) {
+ Error ("Division by zero");
+ Expr->V.FVal = FP_D_FromInt(0);
+ } else
+#endif
+ {
+ Expr->V.FVal = FP_D_Div(Val1, Val2);
+ }
break;
case TOK_STAR:
- Expr->IVal = (Val1 * Val2);
- break;
- case TOK_DIV:
- if (Val2 == 0) {
- Error ("Division by zero");
- Expr->IVal = 0x7FFFFFFF;
- } else {
- Expr->IVal = (Val1 / Val2);
- }
- break;
- case TOK_MOD:
- if (Val2 == 0) {
- Error ("Modulo operation with zero");
- Expr->IVal = 0;
- } else {
- Expr->IVal = (Val1 % Val2);
- }
+ Expr->V.FVal = FP_D_Mul(Val1, Val2);
break;
default:
Internal ("hie_internal: got token 0x%X\n", Tok);
}
+ /* FIXME: float --- newcode end */
} else {
+ printf("hie_internal signed int X signed int\n");
+ /* Handle the op differently for signed and unsigned types */
+ if (IsSignSigned (Expr->Type)) {
- /* Evaluate the result for unsigned operands */
- unsigned long Val1 = Expr->IVal;
- unsigned long Val2 = Expr2.IVal;
- switch (Tok) {
- case TOK_OR:
- Expr->IVal = (Val1 | Val2);
- break;
- case TOK_XOR:
- Expr->IVal = (Val1 ^ Val2);
- break;
- case TOK_AND:
- Expr->IVal = (Val1 & Val2);
- break;
- case TOK_STAR:
- Expr->IVal = (Val1 * Val2);
- break;
- case TOK_DIV:
- if (Val2 == 0) {
- Error ("Division by zero");
- Expr->IVal = 0xFFFFFFFF;
- } else {
- Expr->IVal = (Val1 / Val2);
- }
- break;
- case TOK_MOD:
- if (Val2 == 0) {
- Error ("Modulo operation with zero");
- Expr->IVal = 0;
- } else {
- Expr->IVal = (Val1 % Val2);
- }
- break;
- default:
- Internal ("hie_internal: got token 0x%X\n", Tok);
+ /* Evaluate the result for signed operands */
+ signed long Val1 = Expr->IVal;
+ signed long Val2 = Expr2.IVal;
+ switch (Tok) {
+ case TOK_OR:
+ Expr->IVal = (Val1 | Val2);
+ break;
+ case TOK_XOR:
+ Expr->IVal = (Val1 ^ Val2);
+ break;
+ case TOK_AND:
+ Expr->IVal = (Val1 & Val2);
+ break;
+ case TOK_STAR:
+ Expr->IVal = (Val1 * Val2);
+ break;
+ case TOK_DIV:
+ if (Val2 == 0) {
+ Error ("Division by zero");
+ Expr->IVal = 0x7FFFFFFF;
+ } else {
+ Expr->IVal = (Val1 / Val2);
+ }
+ break;
+ case TOK_MOD:
+ if (Val2 == 0) {
+ Error ("Modulo operation with zero");
+ Expr->IVal = 0;
+ } else {
+ Expr->IVal = (Val1 % Val2);
+ }
+ break;
+ default:
+ Internal ("hie_internal: got token 0x%X\n", Tok);
+ }
+ } else {
+ printf("hie_internal unsigned int X unsigned int\n");
+
+ /* Evaluate the result for unsigned operands */
+ unsigned long Val1 = Expr->IVal;
+ unsigned long Val2 = Expr2.IVal;
+ switch (Tok) {
+ case TOK_OR:
+ Expr->IVal = (Val1 | Val2);
+ break;
+ case TOK_XOR:
+ Expr->IVal = (Val1 ^ Val2);
+ break;
+ case TOK_AND:
+ Expr->IVal = (Val1 & Val2);
+ break;
+ case TOK_STAR:
+ Expr->IVal = (Val1 * Val2);
+ break;
+ case TOK_DIV:
+ if (Val2 == 0) {
+ Error ("Division by zero");
+ Expr->IVal = 0xFFFFFFFF;
+ } else {
+ Expr->IVal = (Val1 / Val2);
+ }
+ break;
+ case TOK_MOD:
+ if (Val2 == 0) {
+ Error ("Modulo operation with zero");
+ Expr->IVal = 0;
+ } else {
+ Expr->IVal = (Val1 % Val2);
+ }
+ break;
+ default:
+ Internal ("hie_internal: got token 0x%X\n", Tok);
+ }
}
}
@@ -2255,7 +2345,6 @@ static void hie_compare (const GenDesc* Ops, /* List of generators */
unsigned ltype;
int rconst; /* Operand is a constant */
-
ExprWithCheck (hienext, Expr);
while ((Gen = FindGen (CurTok.Tok, Ops)) != 0) {
@@ -2282,6 +2371,7 @@ static void hie_compare (const GenDesc* Ops, /* List of generators */
if (ED_IsConstAbs (Expr)) {
/* Numeric constant value */
GetCodePos (&Mark2);
+// printf("iVal:%08x FVal:%f\n", Expr->IVal, Expr->V.FVal.V);
g_push (ltype | CF_CONST, Expr->IVal);
} else {
/* Value not numeric constant */
@@ -2744,7 +2834,13 @@ static void parseadd (ExprDesc* Expr, int DoArrayRef)
} else if (!DoArrayRef && IsClassInt (lhst) && IsClassInt (rhst)) {
/* Integer addition */
flags = CF_INT;
+ } else if (!DoArrayRef && IsClassFloat (lhst) && IsClassFloat (rhst)) {
+ /* FIXME: float addition (const + const) */
+ printf("%s:%d float addition (const + const)\n", __FILE__, __LINE__);
+ /* Integer addition */
+ flags = CF_FLOAT;
} else {
+ printf("%s:%d OOPS\n", __FILE__, __LINE__);
/* OOPS */
AddDone = -1;
/* Avoid further errors */
@@ -2753,24 +2849,35 @@ static void parseadd (ExprDesc* Expr, int DoArrayRef)
if (!AddDone) {
/* Do constant calculation if we can */
- if (ED_IsAbs (&Expr2) &&
- (ED_IsAbs (Expr) || lscale == 1)) {
- if (IsClassInt (lhst) && IsClassInt (rhst)) {
- Expr->Type = ArithmeticConvert (Expr->Type, Expr2.Type);
- }
- Expr->IVal = Expr->IVal * lscale + Expr2.IVal * rscale;
+ if (!DoArrayRef && IsClassFloat (lhst) && IsClassFloat (rhst)) {
+ /* float + float */
+ /* FIXME: float - this is probably completely wrong */
+ Expr->V.FVal.V = Expr->V.FVal.V + Expr2.V.FVal.V;
+ Expr->Type = type_float;
+ //Expr->Type = ArithmeticConvert (Expr->Type, Expr2.Type);
AddDone = 1;
- } else if (ED_IsAbs (Expr) &&
- (ED_IsAbs (&Expr2) || rscale == 1)) {
- if (IsClassInt (lhst) && IsClassInt (rhst)) {
- Expr2.Type = ArithmeticConvert (Expr2.Type, Expr->Type);
+ printf("%s:%d float addition (const + const) res:%f\n", __FILE__, __LINE__, Expr->V.FVal.V);
+ } else {
+ /* integer + integer */
+ if (ED_IsAbs (&Expr2) &&
+ (ED_IsAbs (Expr) || lscale == 1)) {
+ if (IsClassInt (lhst) && IsClassInt (rhst)) {
+ Expr->Type = ArithmeticConvert (Expr->Type, Expr2.Type);
+ }
+ Expr->IVal = Expr->IVal * lscale + Expr2.IVal * rscale;
+ AddDone = 1;
+ } else if (ED_IsAbs (Expr) &&
+ (ED_IsAbs (&Expr2) || rscale == 1)) {
+ if (IsClassInt (lhst) && IsClassInt (rhst)) {
+ Expr2.Type = ArithmeticConvert (Expr2.Type, Expr->Type);
+ }
+ Expr2.IVal = Expr->IVal * lscale + Expr2.IVal * rscale;
+ /* Adjust the flags */
+ Expr2.Flags |= Expr->Flags & ~E_MASK_KEEP_SUBEXPR;
+ /* Get the symbol and the name */
+ *Expr = Expr2;
+ AddDone = 1;
}
- Expr2.IVal = Expr->IVal * lscale + Expr2.IVal * rscale;
- /* Adjust the flags */
- Expr2.Flags |= Expr->Flags & ~E_MASK_KEEP_SUBEXPR;
- /* Get the symbol and the name */
- *Expr = Expr2;
- AddDone = 1;
}
}
@@ -2871,8 +2978,13 @@ static void parseadd (ExprDesc* Expr, int DoArrayRef)
} else if (!DoArrayRef && IsClassInt (lhst) && IsClassInt (rhst)) {
/* Integer addition */
flags |= typeadjust (Expr, &Expr2, 1);
+ } else if (!DoArrayRef && IsClassFloat (lhst) && IsClassFloat (rhst)) {
+ /* Float addition */
+ /*flags |= typeadjust (Expr, &Expr2, 1);*/
+ printf("%s:%d float addition (const + var)\n", __FILE__, __LINE__);
} else {
/* OOPS */
+ printf("%s:%d OOPS\n", __FILE__, __LINE__);
AddDone = -1;
}
@@ -2964,13 +3076,26 @@ static void parseadd (ExprDesc* Expr, int DoArrayRef)
} else if (!DoArrayRef && IsClassInt (lhst) && IsClassInt (rhst)) {
/* Integer addition */
flags = typeadjust (Expr, &Expr2, 1);
+ } else if (!DoArrayRef && IsClassFloat (lhst) && IsClassFloat (rhst)) {
+ /* FIXME: float - what to do here exactly? */
+ printf("%s:%d float addition (Expr2.V.FVal.V:%f)\n", __FILE__, __LINE__, Expr2.V.FVal.V);
+ /* Float addition (variable+constant) */
+ /*flags = typeadjust (Expr, &Expr2, 1);*/
+ flags |= CF_FLOAT;
+ Expr->Type = Expr2.Type;
} else {
/* OOPS */
+ printf("%s:%d OOPS\n", __FILE__, __LINE__);
AddDone = -1;
}
- /* Generate code for the add */
- g_inc (flags | CF_CONST, Expr2.IVal);
+ if (flags & CF_FLOAT) {
+ /* FIXME: float - what to do here exactly? */
+ g_inc (flags | CF_CONST, FP_D_As32bitRaw(Expr2.V.FVal));
+ } else {
+ /* Generate code for the add */
+ g_inc (flags | CF_CONST, Expr2.IVal);
+ }
} else {
@@ -3013,8 +3138,17 @@ static void parseadd (ExprDesc* Expr, int DoArrayRef)
flags = typeadjust (Expr, &Expr2, 0);
/* Load rhs into the primary */
LoadExpr (CF_NONE, &Expr2);
+ } else if (!DoArrayRef && IsClassFloat (lhst) && IsClassFloat (rhst)) {
+ /* FIXME: float - what to do here exactly? */
+ printf("%s:%d float addition (Expr2.V.FVal.V:%f)\n", __FILE__, __LINE__, Expr2.V.FVal.V);
+ /* Float addition */
+ /* flags = typeadjust (Expr, &Expr2, 0); */
+ flags |= CF_FLOAT;
+ /* Load rhs into the primary */
+ LoadExpr (CF_NONE, &Expr2);
} else {
/* OOPS */
+ printf("%s:%d OOPS\n", __FILE__, __LINE__);
AddDone = -1;
/* We can't just goto End as that would leave the stack unbalanced */
}
@@ -3289,6 +3423,11 @@ static void parsesub (ExprDesc* Expr)
/* Pointer subtraction. We've got the scale factor and flags above */
} else if (IsClassInt (lhst) && IsClassInt (rhst)) {
/* Integer subtraction. We'll adjust the types later */
+#if 0
+ } else if (IsClassFloat (lhst) && IsClassFloat (rhst)) {
+ /* Float subtraction. We'll adjust the types later */
+ /* FIXME: float */
+#endif
} else {
/* OOPS */
Error ("Invalid operands for binary operator '-'");
@@ -3335,6 +3474,13 @@ static void parsesub (ExprDesc* Expr)
} else if (IsClassInt (lhst) && IsClassInt (rhst)) {
/* Adjust operand types */
flags = typeadjust (Expr, &Expr2, 0);
+ } else if (IsClassFloat (lhst) && IsClassFloat (rhst)) {
+ /* Float substraction */
+ /* FIXME: float - what to do here exactly? */
+ printf("%s:%d float substraction\n", __FILE__, __LINE__);
+ /* Adjust operand types */
+ /*flags = typeadjust (Expr, &Expr2, 0);*/
+ flags = CF_FLOAT;
} else {
/* OOPS */
Error ("Invalid operands for binary operator '-'");
diff --git a/src/cc65/initdata.c b/src/cc65/initdata.c
index 99dacdca9..18ba45d6c 100644
--- a/src/cc65/initdata.c
+++ b/src/cc65/initdata.c
@@ -164,34 +164,48 @@ static void ClosingCurlyBraces (unsigned BracesExpected)
static void DefineData (ExprDesc* Expr)
/* Output a data definition for the given expression */
{
+ int isfloat = (TypeOf (Expr->Type) == CF_FLOAT);
+
+ printf("%s:%d DefineData IVal: %ld V.FVal: %f isfloat:%d %d\n", __FILE__, __LINE__,
+ Expr->IVal, (double)(Expr->V.FVal.V), isfloat, ED_GetLoc (Expr));
switch (ED_GetLoc (Expr)) {
case E_LOC_NONE:
/* Immediate numeric value with no storage */
- g_defdata (CF_IMM | TypeOf (Expr->Type) | CF_CONST, Expr->IVal, 0);
+ /* FIXME: float */
+ if (isfloat) {
+ g_defdata_float (CF_IMM | TypeOf (Expr->Type) | CF_CONST, FP_D_As32bitRaw(Expr->V.FVal), 0);
+ } else {
+ g_defdata (CF_IMM | TypeOf (Expr->Type) | CF_CONST, Expr->IVal, 0);
+ }
break;
-
+/* FIXME: float - other cases */
case E_LOC_ABS:
+ if (isfloat) { printf("%s:%d FIXME: E_LOC_ABS\n", __FILE__, __LINE__); exit(-1); }
/* Absolute numeric address */
g_defdata (CF_ABSOLUTE | TypeOf (Expr->Type) | CF_CONST, Expr->IVal, 0);
break;
case E_LOC_GLOBAL:
+ if (isfloat) { printf("%s:%d FIXME: E_LOC_GLOBAL\n", __FILE__, __LINE__); exit(-1); }
/* Global variable */
g_defdata (CF_EXTERNAL, Expr->Name, Expr->IVal);
break;
case E_LOC_STATIC:
+ if (isfloat) { printf("%s:%d FIXME: E_LOC_STATIC\n", __FILE__, __LINE__); exit(-1); }
/* Static variable */
g_defdata (CF_STATIC, Expr->Name, Expr->IVal);
break;
case E_LOC_LITERAL:
+ if (isfloat) { printf("%s:%d FIXME: E_LOC_LITERAL\n", __FILE__, __LINE__); exit(-1); }
/* Literal in the literal pool */
g_defdata (CF_LITERAL, Expr->Name, Expr->IVal);
break;
case E_LOC_REGISTER:
+ if (isfloat) { printf("%s:%d FIXME: E_LOC_REGISTER\n", __FILE__, __LINE__); exit(-1); }
/* Register variable. Taking the address is usually not
** allowed.
*/
@@ -202,6 +216,7 @@ static void DefineData (ExprDesc* Expr)
break;
case E_LOC_CODE:
+ if (isfloat) { printf("%s:%d FIXME: E_LOC_CODE\n", __FILE__, __LINE__); exit(-1); }
/* Code label location */
g_defdata (CF_CODE, Expr->Name, Expr->IVal);
break;
diff --git a/src/cc65/loadexpr.c b/src/cc65/loadexpr.c
index 4b7f8e279..fda3c133d 100644
--- a/src/cc65/loadexpr.c
+++ b/src/cc65/loadexpr.c
@@ -51,6 +51,7 @@
static void LoadAddress (unsigned Flags, ExprDesc* Expr)
/* Load the primary register with some address value. */
{
+ printf("LoadAddress flags:%04x\n", Flags);
switch (ED_GetLoc (Expr)) {
case E_LOC_ABS:
@@ -118,6 +119,7 @@ void LoadExpr (unsigned Flags, struct ExprDesc* Expr)
** unfortunately.
*/
{
+ /*printf("LoadExpr flags:%4x\n", Flags);*/
if (!ED_IsAddrExpr (Expr)) {
/* Lvalue. If this is a bit field its type is unsigned. But if the
@@ -170,57 +172,88 @@ void LoadExpr (unsigned Flags, struct ExprDesc* Expr)
}
/* Load the content of Expr */
+ /*printf("LoadExpr ED_GetLoc:%04x\n", ED_GetLoc (Expr));*/
switch (ED_GetLoc (Expr)) {
case E_LOC_NONE:
+ /* FIXME: float */
+ /*printf("LoadExpr E_LOC_NONE (%s)\n", (TypeOf (Expr->Type) == CF_FLOAT) ? "float" : "integer");*/
/* Immediate number constant */
- g_getimmed (Flags | CF_IMM | TypeOf (Expr->Type) | CF_CONST, Expr->IVal, 0);
+ if (TypeOf (Expr->Type) == CF_FLOAT) {
+ g_getimmed (Flags | CF_IMM | TypeOf (Expr->Type) | CF_CONST, FP_D_As32bitRaw(Expr->V.FVal), 0);
+ } else {
+ g_getimmed (Flags | CF_IMM | TypeOf (Expr->Type) | CF_CONST, Expr->IVal, 0);
+ }
break;
case E_LOC_ABS:
+ printf("LoadExpr E_LOC_ABS (%s)\n", (TypeOf (Expr->Type) == CF_FLOAT) ? "float" : "integer");
+ if (TypeOf (Expr->Type) == CF_FLOAT) { printf("%s:%d FIXME: E_LOC_ABS\n", __FILE__, __LINE__); exit(-1); }
/* Absolute numeric addressed variable */
g_getstatic (Flags | CF_ABSOLUTE, Expr->IVal, 0);
break;
case E_LOC_GLOBAL:
- /* Global variable */
+ /* printf("LoadExpr E_LOC_GLOBAL (%s)\n", (TypeOf (Expr->Type) == CF_FLOAT) ? "float" : "integer"); */
+ /* if (TypeOf (Expr->Type) == CF_FLOAT) { printf("%s:%d FIXME: E_LOC_GLOBAL\n", __FILE__, __LINE__); exit(-1); } */
+ /* Global variable, offset in IVal */
g_getstatic (Flags | CF_EXTERNAL, Expr->Name, Expr->IVal);
break;
case E_LOC_STATIC:
- /* Static variable */
+ /* printf("LoadExpr E_LOC_STATIC (%s)\n", (TypeOf (Expr->Type) == CF_FLOAT) ? "float" : "integer"); */
+ /* if (TypeOf (Expr->Type) == CF_FLOAT) { printf("%s:%d FIXME: E_LOC_STATIC\n", __FILE__, __LINE__); exit(-1); } */
+ /* Static variable, offset in IVal */
g_getstatic (Flags | CF_STATIC, Expr->Name, Expr->IVal);
break;
case E_LOC_LITERAL:
- /* Literal in the literal pool */
+ /* printf("LoadExpr E_LOC_LITERAL (%s)\n", (TypeOf (Expr->Type) == CF_FLOAT) ? "float" : "integer"); */
+ /* if (TypeOf (Expr->Type) == CF_FLOAT) { printf("%s:%d FIXME: E_LOC_LITERAL\n", __FILE__, __LINE__); exit(-1); } */
+ /* Literal in the literal pool, offset in IVal */
g_getstatic (Flags | CF_LITERAL, Expr->Name, Expr->IVal);
break;
case E_LOC_REGISTER:
- /* Register variable */
+ /* printf("LoadExpr E_LOC_REGISTER (%s)\n", (TypeOf (Expr->Type) == CF_FLOAT) ? "float" : "integer"); */
+ /* if (TypeOf (Expr->Type) == CF_FLOAT) { printf("%s:%d FIXME: E_LOC_REGISTER\n", __FILE__, __LINE__); exit(-1); } */
+ /* Register variable, offset in IVal */
g_getstatic (Flags | CF_REGVAR, Expr->Name, Expr->IVal);
break;
case E_LOC_CODE:
- /* Code label location */
+ /* printf("LoadExpr E_LOC_CODE (%s)\n", (TypeOf (Expr->Type) == CF_FLOAT) ? "float" : "integer"); */
+ /* if (TypeOf (Expr->Type) == CF_FLOAT) { printf("%s:%d FIXME: E_LOC_CODE\n", __FILE__, __LINE__); exit(-1); } */
+ /* Code label location, offset in IVal */
g_getstatic (Flags | CF_CODE, Expr->Name, Expr->IVal);
break;
case E_LOC_STACK:
- /* Value on the stack */
+ /* printf("LoadExpr E_LOC_STACK (%s)\n", (TypeOf (Expr->Type) == CF_FLOAT) ? "float" : "integer"); */
+ /* if (TypeOf (Expr->Type) == CF_FLOAT) { printf("%s:%d FIXME: E_LOC_STACK\n", __FILE__, __LINE__); exit(-1); } */
+ /* Fetch value on the stack (with offset in IVal) */
g_getlocal (Flags, Expr->IVal);
break;
case E_LOC_PRIMARY:
+ /*printf("LoadExpr E_LOC_PRIMARY (%s)\n", (TypeOf (Expr->Type) == CF_FLOAT) ? "float" : "integer");*/
+ /*if (TypeOf (Expr->Type) == CF_FLOAT) { printf("%s:%d FIXME: E_LOC_PRIMARY\n", __FILE__, __LINE__); exit(-1); }*/
/* The primary register */
- if (Expr->IVal != 0) {
- /* We have an expression in the primary plus a constant
- ** offset. Adjust the value in the primary accordingly.
- */
- g_inc (Flags | CF_CONST, Expr->IVal);
+ if (TypeOf (Expr->Type) == CF_FLOAT) {
+ /* FIXME: float */
+ Flags |= CF_FLOAT;
+ if (Expr->V.FVal.V != 0.0f) {
+ g_inc (Flags | CF_CONST, FP_D_As32bitRaw(Expr->V.FVal));
+ }
+ } else {
+ if (Expr->IVal != 0) {
+ /* We have an expression in the primary plus a constant
+ ** offset. Adjust the value in the primary accordingly.
+ */
+ g_inc (Flags | CF_CONST, Expr->IVal);
- /* We might want to clear the offset, but we can't */
+ /* We might want to clear the offset, but we can't */
+ }
}
if (Flags & CF_TEST) {
g_test (Flags);
@@ -228,7 +261,9 @@ void LoadExpr (unsigned Flags, struct ExprDesc* Expr)
break;
case E_LOC_EXPR:
- /* Reference to address in primary with offset in Expr */
+ /*printf("LoadExpr E_LOC_EXPR (%s)\n", (TypeOf (Expr->Type) == CF_FLOAT) ? "float" : "integer");*/
+ /*if (TypeOf (Expr->Type) == CF_FLOAT) { printf("%s:%d FIXME: E_LOC_EXPR\n", __FILE__, __LINE__); exit(-1); }*/
+ /* Reference to address in primary with offset in IVal */
g_getind (Flags, Expr->IVal);
/* Since the content in primary is now overwritten with the
diff --git a/src/cc65/locals.c b/src/cc65/locals.c
index 297994455..9ee8a27d9 100644
--- a/src/cc65/locals.c
+++ b/src/cc65/locals.c
@@ -198,6 +198,8 @@ static void ParseAutoDecl (Declaration* Decl)
/* Get the size of the variable */
unsigned Size = SizeOf (Decl->Type);
+ printf("ParseAutoDecl SIze:%d IsCompound:%d\n", Size, IsCompound);
+
/* Check if this is a variable on the stack or in static memory */
if (IS_Get (&StaticLocals) == 0) {
@@ -274,7 +276,13 @@ static void ParseAutoDecl (Declaration* Decl)
}
/* Push the value */
- g_push (Flags | TypeOf (Sym->Type), Expr.IVal);
+ if (TypeOf (Sym->Type) == CF_FLOAT) {
+ /* FIXME: float */
+ printf("Expr.V.FVal.V: %f\n", Expr.V.FVal.V);
+ g_push_float (Flags | TypeOf (Sym->Type), Expr.V.FVal.V);
+ } else {
+ g_push (Flags | TypeOf (Sym->Type), Expr.IVal);
+ }
/* This has to be done at sequence point */
DoDeferred (SQP_KEEP_NONE, &Expr);
diff --git a/src/cc65/scanner.c b/src/cc65/scanner.c
index 76e7eea23..020a70033 100644
--- a/src/cc65/scanner.c
+++ b/src/cc65/scanner.c
@@ -620,6 +620,8 @@ static void NumericConst (void)
/* Float constant */
Double FVal = FP_D_FromInt (IVal); /* Convert to double */
+ printf("NumericConst start IVal:%ld FVal: %f\n", IVal, FVal.V);
+
/* Check for a fractional part and read it */
if (CurC == '.') {
@@ -692,6 +694,8 @@ static void NumericConst (void)
}
}
+ printf("NumericConst end FVal: %f\n", FVal.V);
+
/* Check for a suffix and determine the type of the constant */
if (toupper (CurC) == 'F') {
NextChar ();
@@ -705,6 +709,7 @@ static void NumericConst (void)
NextTok.Tok = TOK_FCONST;
}
+ printf("NumericConst exit IsFloat:%d IVal: %ld FVal: %f\n", IsFloat, NextTok.IVal, NextTok.FVal.V);
}
diff --git a/src/cc65/typeconv.c b/src/cc65/typeconv.c
index a7528a2f8..410b8af44 100644
--- a/src/cc65/typeconv.c
+++ b/src/cc65/typeconv.c
@@ -97,7 +97,10 @@ static void DoConversion (ExprDesc* Expr, const Type* NewType)
/* lvalue? */
if (ED_IsLVal (Expr)) {
-
+printf("DoConversion 1 Old: %s New: %s\n",
+ (IsTypeFloat (OldType)) ? "float" : "int",
+ (IsTypeFloat (NewType)) ? "float" : "int"
+ );
/* We have an lvalue. If the new size is smaller than the old one,
** we don't need to do anything. The compiler will generate code
** to load only the portion of the value that is actually needed.
@@ -106,7 +109,10 @@ static void DoConversion (ExprDesc* Expr, const Type* NewType)
** If both sizes are equal, do also leave the value alone.
** If the new size is larger, we must convert the value.
*/
- if (NewBits > OldBits) {
+ if ((NewBits > OldBits) ||
+ /* FIXME: float */
+ /* when either side is float, emit the call to the conversion code */
+ (IsTypeFloat (OldType) || IsTypeFloat (NewType))) {
/* Load the value into the primary */
LoadExpr (CF_NONE, Expr);
@@ -118,15 +124,32 @@ static void DoConversion (ExprDesc* Expr, const Type* NewType)
}
} else if (ED_IsConstAbs (Expr)) {
+printf("DoConversion 2 Old: %s New: %s\n",
+ (IsTypeFloat (OldType)) ? "float" : "int",
+ (IsTypeFloat (NewType)) ? "float" : "int"
+ );
/* A cast of a constant numeric value to another type. Be sure
** to handle sign extension correctly.
*/
+ /* FIXME: float --- start of new code */
+ /* convert from float to (signed) long first */
+ if (IsTypeFloat (OldType) && !IsTypeFloat (NewType)) {
+ OldBits = 32;
+ Expr->IVal = FP_D_ToLong(Expr->V.FVal);
+ printf("DoConversion 2 new ival: %ld\n", Expr->IVal);
+ } else if (!IsTypeFloat (OldType) && IsTypeFloat (NewType)) {
+ OldBits = 0;
+ Expr->V.FVal = FP_D_FromInt(Expr->IVal);
+ printf("DoConversion 2 new fval: %f\n", Expr->V.FVal.V);
+ }
+ /* FIXME: float --- end of new code */
/* Check if the new datatype will have a smaller range. If it
** has a larger range, things are OK, since the value is
** internally already represented by a long.
*/
+ printf("DoConversion 2 NewBits: %d OldBits: %d\n", NewBits, OldBits);
if (NewBits <= OldBits) {
/* Cut the value to the new size */
@@ -141,6 +164,12 @@ static void DoConversion (ExprDesc* Expr, const Type* NewType)
}
}
+ if (IsTypeFloat (NewType)) {
+ printf("DoConversion 2 new fval: %f\n", Expr->V.FVal.V);
+ } else {
+ printf("DoConversion 2 new ival: %ld\n", Expr->IVal);
+ }
+
/* Do the integer constant <-> absolute address conversion if necessary */
if (IsClassPtr (NewType)) {
Expr->Flags &= ~E_LOC_NONE;
@@ -151,12 +180,19 @@ static void DoConversion (ExprDesc* Expr, const Type* NewType)
}
} else {
+printf("DoConversion 3 Old: %s New: %s\n",
+ (IsTypeFloat (OldType)) ? "float" : "int",
+ (IsTypeFloat (NewType)) ? "float" : "int"
+ );
/* The value is not a constant. If the sizes of the types are
** not equal, add conversion code. Be sure to convert chars
** correctly.
*/
- if (OldBits != NewBits) {
+ if ((OldBits != NewBits) ||
+ /* FIXME: float */
+ /* when either side is float, emit the call to the conversion code */
+ (IsTypeFloat (OldType) || IsTypeFloat (NewType))) {
/* Load the value into the primary */
LoadExpr (CF_NONE, Expr);
diff --git a/src/common/fp.c b/src/common/fp.c
index 0682f9f9e..2acdbf9f3 100644
--- a/src/common/fp.c
+++ b/src/common/fp.c
@@ -45,6 +45,7 @@
#include
+#include
/* common */
#include "fp.h"
@@ -189,7 +190,11 @@ Double FP_D_FromInt (long Val)
return D;
}
-
+long FP_D_ToLong (Double Val)
+/* Convert a floating point variable into a long */
+{
+ return (long)Val.V;
+}
double FP_D_ToFloat (Double Val)
/* Convert a Double into a native double */
@@ -236,3 +241,16 @@ Double FP_D_Div (Double Left, Double Right)
D.V = Left.V / Right.V;
return D;
}
+
+
+uint32_t FP_D_As32bitRaw(Double Val)
+/* converts double into 32bit (float) and then returns its raw content as a 32bit int */
+{
+ float f;
+ uint32_t *lptr;
+ uint32_t lval;
+ f = Val.V;
+ lptr = (uint32_t *)&f;
+ lval = *lptr;
+ return lval;
+}
diff --git a/src/common/fp.h b/src/common/fp.h
index 4e89e2316..e3c5abc4c 100644
--- a/src/common/fp.h
+++ b/src/common/fp.h
@@ -52,6 +52,7 @@
#include
+#include
@@ -92,7 +93,7 @@ Float FP_F_Make (float Val);
Float FP_F_FromInt (long Val);
/* Convert an integer into a floating point variable */
-float FP_F_ToFloat (Float Val);
+float FP_F_ToFloat (Float Val); /* FIXME: better name */
/* Convert a Float into a native float */
Float FP_F_Add (Float Left, Float Right);
@@ -118,8 +119,9 @@ Double FP_D_Make (double Val);
Double FP_D_FromInt (long Val);
/* Convert an integer into a floating point variable */
+long FP_D_ToLong (Double Val);
-double FP_D_ToFloat (Double Val);
+double FP_D_ToFloat (Double Val); /* FIXME: better name */
/* Convert a Double into a native double */
Double FP_D_Add (Double Left, Double Right);
@@ -134,7 +136,8 @@ Double FP_D_Mul (Double Left, Double Right);
Double FP_D_Div (Double Left, Double Right);
/* Divide two floats */
-
+uint32_t FP_D_As32bitRaw(Double Val);
+/* converts double into 32bit (float) and then returns its raw content as a 32bit int */
/* End of fp.h */
From 00fabb8caf0f04fc04f4a7f3c6e9d3ff68ccb119 Mon Sep 17 00:00:00 2001
From: mrdudz
Date: Mon, 20 Jun 2022 01:54:03 +0200
Subject: [PATCH 003/139] beginning of float libraries and test programs
---
test/float/.gitignore | 3 +
test/float/Makefile | 197 +++++++
test/float/cbmkernal/cbmfp.h | 121 ++++
test/float/cbmkernal/cc65wrapper.s | 388 ++++++++++++
test/float/cbmkernal/ffloor.c | 24 +
test/float/cbmkernal/float-vic20.inc | 63 ++
test/float/cbmkernal/float.inc | 64 ++
test/float/cbmkernal/float.s | 849 +++++++++++++++++++++++++++
test/float/cbmkernal/ftoa.c | 134 +++++
test/float/float-basic-cmp.c | 161 +++++
test/float/float-basic.c | 183 ++++++
test/float/float-cbm..c | 138 +++++
test/float/float-minimal.c | 160 +++++
test/float/floattest.c | 350 +++++++++++
test/float/gccstubs.c | 49 ++
test/float/ieee754/_ftostr.c | 97 +++
test/float/ieee754/afloat.s | 7 +
test/float/ieee754/aufloat.s | 7 +
test/float/ieee754/axfloat.s | 7 +
test/float/ieee754/axufloat.s | 7 +
test/float/ieee754/eaxfloat.s | 7 +
test/float/ieee754/eaxufloat.s | 7 +
test/float/ieee754/fbnegeax.s | 7 +
test/float/ieee754/feaxint.s | 8 +
test/float/ieee754/feaxlong.s | 8 +
test/float/ieee754/ftosaddeax.s | 637 ++++++++++++++++++++
test/float/ieee754/ftosdiveax.s | 12 +
test/float/ieee754/ftoseqeax.s | 8 +
test/float/ieee754/ftosgeeax.s | 8 +
test/float/ieee754/ftosgteax.s | 8 +
test/float/ieee754/ftosleeax.s | 8 +
test/float/ieee754/ftoslteax.s | 8 +
test/float/ieee754/ftosmuleax.s | 12 +
test/float/ieee754/ftosneeax.s | 8 +
test/float/ieee754/ftossubeax.s | 43 ++
test/float/ieee754/ieee754.inc | 7 +
test/float/include/_float.h | 54 ++
test/float/include/math.h | 46 ++
test/float/quick.c | 25 +
test/float/readme.md | 196 +++++++
test/float/woz/_ftostr.c | 97 +++
test/float/woz/afloat.s | 7 +
test/float/woz/aufloat.s | 7 +
test/float/woz/axfloat.s | 7 +
test/float/woz/axufloat.s | 7 +
test/float/woz/eaxfloat.s | 7 +
test/float/woz/eaxufloat.s | 7 +
test/float/woz/fbnegeax.s | 7 +
test/float/woz/feaxint.s | 8 +
test/float/woz/feaxlong.s | 8 +
test/float/woz/ftosaddeax.s | 9 +
test/float/woz/ftosdiveax.s | 9 +
test/float/woz/ftoseqeax.s | 8 +
test/float/woz/ftosgeeax.s | 8 +
test/float/woz/ftosgteax.s | 8 +
test/float/woz/ftosleeax.s | 8 +
test/float/woz/ftoslteax.s | 8 +
test/float/woz/ftosmuleax.s | 9 +
test/float/woz/ftosneeax.s | 8 +
test/float/woz/ftossubeax.s | 8 +
test/float/woz/wozfp.inc | 16 +
test/float/woz/wozfp.s | 456 ++++++++++++++
62 files changed, 4843 insertions(+)
create mode 100644 test/float/.gitignore
create mode 100644 test/float/Makefile
create mode 100644 test/float/cbmkernal/cbmfp.h
create mode 100644 test/float/cbmkernal/cc65wrapper.s
create mode 100644 test/float/cbmkernal/ffloor.c
create mode 100644 test/float/cbmkernal/float-vic20.inc
create mode 100644 test/float/cbmkernal/float.inc
create mode 100644 test/float/cbmkernal/float.s
create mode 100644 test/float/cbmkernal/ftoa.c
create mode 100644 test/float/float-basic-cmp.c
create mode 100644 test/float/float-basic.c
create mode 100644 test/float/float-cbm..c
create mode 100644 test/float/float-minimal.c
create mode 100644 test/float/floattest.c
create mode 100644 test/float/gccstubs.c
create mode 100644 test/float/ieee754/_ftostr.c
create mode 100644 test/float/ieee754/afloat.s
create mode 100644 test/float/ieee754/aufloat.s
create mode 100644 test/float/ieee754/axfloat.s
create mode 100644 test/float/ieee754/axufloat.s
create mode 100644 test/float/ieee754/eaxfloat.s
create mode 100644 test/float/ieee754/eaxufloat.s
create mode 100644 test/float/ieee754/fbnegeax.s
create mode 100644 test/float/ieee754/feaxint.s
create mode 100644 test/float/ieee754/feaxlong.s
create mode 100644 test/float/ieee754/ftosaddeax.s
create mode 100644 test/float/ieee754/ftosdiveax.s
create mode 100644 test/float/ieee754/ftoseqeax.s
create mode 100644 test/float/ieee754/ftosgeeax.s
create mode 100644 test/float/ieee754/ftosgteax.s
create mode 100644 test/float/ieee754/ftosleeax.s
create mode 100644 test/float/ieee754/ftoslteax.s
create mode 100644 test/float/ieee754/ftosmuleax.s
create mode 100644 test/float/ieee754/ftosneeax.s
create mode 100644 test/float/ieee754/ftossubeax.s
create mode 100644 test/float/ieee754/ieee754.inc
create mode 100644 test/float/include/_float.h
create mode 100644 test/float/include/math.h
create mode 100644 test/float/quick.c
create mode 100644 test/float/readme.md
create mode 100644 test/float/woz/_ftostr.c
create mode 100644 test/float/woz/afloat.s
create mode 100644 test/float/woz/aufloat.s
create mode 100644 test/float/woz/axfloat.s
create mode 100644 test/float/woz/axufloat.s
create mode 100644 test/float/woz/eaxfloat.s
create mode 100644 test/float/woz/eaxufloat.s
create mode 100644 test/float/woz/fbnegeax.s
create mode 100644 test/float/woz/feaxint.s
create mode 100644 test/float/woz/feaxlong.s
create mode 100644 test/float/woz/ftosaddeax.s
create mode 100644 test/float/woz/ftosdiveax.s
create mode 100644 test/float/woz/ftoseqeax.s
create mode 100644 test/float/woz/ftosgeeax.s
create mode 100644 test/float/woz/ftosgteax.s
create mode 100644 test/float/woz/ftosleeax.s
create mode 100644 test/float/woz/ftoslteax.s
create mode 100644 test/float/woz/ftosmuleax.s
create mode 100644 test/float/woz/ftosneeax.s
create mode 100644 test/float/woz/ftossubeax.s
create mode 100644 test/float/woz/wozfp.inc
create mode 100644 test/float/woz/wozfp.s
diff --git a/test/float/.gitignore b/test/float/.gitignore
new file mode 100644
index 000000000..18269f81a
--- /dev/null
+++ b/test/float/.gitignore
@@ -0,0 +1,3 @@
+*.bin
+*.prg
+
diff --git a/test/float/Makefile b/test/float/Makefile
new file mode 100644
index 000000000..f562321c8
--- /dev/null
+++ b/test/float/Makefile
@@ -0,0 +1,197 @@
+
+OPT=
+
+FILES=\
+ quick.prg \
+ \
+ float-minimal.prg \
+ float-minimal.bin \
+ float-minimal.woz.bin \
+ \
+ float-basic.prg \
+ float-basic.bin \
+ float-basic.woz.bin \
+ \
+ float-basic-cmp.prg \
+ float-basic-cmp.bin \
+ float-basic-cmp.woz.bin
+
+#
+# floattest.prg
+
+##############################################################################
+HEADER=\
+ include/_float.h \
+ include/math.h
+
+CBMRUNTIME=\
+ cbmkernal/float.s \
+ cbmkernal/ftoa.c \
+ cbmkernal/ffloor.c \
+ cbmkernal/cc65wrapper.s
+
+IEEERUNTIME=\
+ ieee754/feaxint.s \
+ ieee754/feaxlong.s \
+ ieee754/fbnegeax.s \
+ ieee754/eaxufloat.s \
+ ieee754/eaxfloat.s \
+ ieee754/axufloat.s \
+ ieee754/axfloat.s \
+ ieee754/aufloat.s \
+ ieee754/afloat.s \
+ ieee754/ftosaddeax.s \
+ ieee754/ftossubeax.s \
+ ieee754/ftosdiveax.s \
+ ieee754/ftosmuleax.s \
+ ieee754/ftoseqeax.s \
+ ieee754/ftosneeax.s \
+ ieee754/ftosgteax.s \
+ ieee754/ftoslteax.s \
+ ieee754/ftosgeeax.s \
+ ieee754/ftosleeax.s \
+ ieee754/_ftostr.c
+
+WOZRUNTIME=\
+ woz/feaxint.s \
+ woz/feaxlong.s \
+ woz/fbnegeax.s \
+ woz/eaxufloat.s \
+ woz/eaxfloat.s \
+ woz/axufloat.s \
+ woz/axfloat.s \
+ woz/aufloat.s \
+ woz/afloat.s \
+ woz/ftosaddeax.s \
+ woz/ftossubeax.s \
+ woz/ftosdiveax.s \
+ woz/ftosmuleax.s \
+ woz/ftoseqeax.s \
+ woz/ftosneeax.s \
+ woz/ftosgteax.s \
+ woz/ftoslteax.s \
+ woz/ftosgeeax.s \
+ woz/ftosleeax.s \
+ woz/_ftostr.c \
+ woz/wozfp.s
+
+##############################################################################
+
+all: $(FILES)
+
+float-minimal.s: float-minimal.c $(HEADER) $(IEEERUNTIME)
+ cc65 $(OPT) -t sim6502 -I ./include --add-source -o float-minimal.s float-minimal.c
+float-minimal.bin: float-minimal.s $(HEADER) $(IEEERUNTIME)
+ cl65 $(OPT) -t sim6502 -I ./include -o float-minimal.bin float-minimal.s $(IEEERUNTIME)
+
+float-basic.s: float-basic.c $(HEADER) $(IEEERUNTIME)
+ cc65 $(OPT) -t sim6502 -I ./include --add-source -o float-basic.s float-basic.c
+float-basic.bin: float-basic.s $(HEADER) $(IEEERUNTIME)
+ cl65 $(OPT) -t sim6502 -I ./include -o float-basic.bin float-basic.s $(IEEERUNTIME)
+
+float-basic-cmp.s: float-basic-cmp.c $(HEADER) $(IEEERUNTIME)
+ cc65 $(OPT) -t sim6502 -I ./include --add-source -o float-basic-cmp.s float-basic-cmp.c
+float-basic-cmp.bin: float-basic-cmp.s $(HEADER) $(IEEERUNTIME)
+ cl65 $(OPT) -t sim6502 -I ./include -o float-basic-cmp.bin float-basic-cmp.s $(IEEERUNTIME)
+
+###############################################################################
+float-minimal.woz.s: float-minimal.c $(HEADER) $(WOZRUNTIME)
+ cc65 $(OPT) -t sim6502 -I ./include --add-source -o float-minimal.woz.s float-minimal.c
+float-minimal.woz.bin: float-minimal.woz.s $(HEADER) $(WOZRUNTIME)
+ cl65 $(OPT) -t sim6502 -I ./include -o float-minimal.woz.bin float-minimal.woz.s $(WOZRUNTIME)
+
+float-basic.woz.s: float-basic.c $(HEADER) $(WOZRUNTIME)
+ cc65 $(OPT) -t sim6502 -I ./include --add-source -o float-basic.woz.s float-basic.c
+float-basic.woz.bin: float-basic.woz.s $(HEADER) $(WOZRUNTIME)
+ cl65 $(OPT) -t sim6502 -I ./include -o float-basic.woz.bin float-basic.woz.s $(WOZRUNTIME)
+
+float-basic-cmp.woz.s: float-basic-cmp.c $(HEADER) $(WOZRUNTIME)
+ cc65 $(OPT) -t sim6502 -I ./include --add-source -o float-basic-cmp.woz.s float-basic-cmp.c
+float-basic-cmp.woz.bin: float-basic-cmp.woz.s $(HEADER) $(WOZRUNTIME)
+ cl65 $(OPT) -t sim6502 -I ./include -o float-basic-cmp.woz.bin float-basic-cmp.woz.s $(WOZRUNTIME)
+
+###############################################################################
+float-minimal.c64.s: float-minimal.c $(HEADER) $(CBMRUNTIME)
+ cc65 $(OPT) -DCONIO -t c64 -I ./include -I ./cbmkernal --add-source -o float-minimal.c64.s float-minimal.c
+float-minimal.prg: float-minimal.c64.s $(HEADER) $(CBMRUNTIME)
+ cl65 $(OPT) -t c64 -I ./include -I ./cbmkernal -o float-minimal.prg float-minimal.c64.s $(CBMRUNTIME)
+
+float-basic.c64.s: float-basic.c $(HEADER) $(CBMRUNTIME)
+ cc65 $(OPT) -DCONIO -t c64 -I ./include -I ./cbmkernal --add-source -o float-basic.c64.s float-basic.c
+float-basic.prg: float-basic.c64.s $(HEADER) $(CBMRUNTIME)
+ cl65 $(OPT) -t c64 -I ./include -I ./cbmkernal -o float-basic.prg float-basic.c64.s $(CBMRUNTIME)
+
+float-basic-cmp.c64.s: float-basic-cmp.c $(HEADER) $(CBMRUNTIME)
+ cc65 $(OPT) -DCONIO -t c64 -I ./include -I ./cbmkernal --add-source -o float-basic-cmp.c64.s float-basic-cmp.c
+float-basic-cmp.prg: float-basic-cmp.c64.s $(HEADER) $(CBMRUNTIME)
+ cl65 $(OPT) -t c64 -I ./include -I ./cbmkernal -o float-basic-cmp.prg float-basic-cmp.c64.s $(CBMRUNTIME)
+
+floattest.c64.s: floattest.c $(HEADER) $(CBMRUNTIME)
+ cc65 $(OPT) -DCONIO -t c64 -I ./include -I ./cbmkernal --add-source -o floattest.c64.s floattest.c
+floattest.prg: floattest.c64.s $(HEADER) $(CBMRUNTIME)
+ cl65 $(OPT) -t c64 -I ./include -I ./cbmkernal -o floattest.prg floattest.c64.s $(CBMRUNTIME)
+
+quick.c64.s: quick.c $(HEADER) $(CBMRUNTIME)
+ cc65 $(OPT) -DCONIO -t c64 -I ./include -I ./cbmkernal --add-source -o quick.c64.s quick.c
+quick.prg: quick.c64.s $(HEADER) $(CBMRUNTIME)
+ cl65 $(OPT) -t c64 -I ./include -I ./cbmkernal -o quick.prg quick.c64.s $(CBMRUNTIME)
+runquick: quick.prg
+ x64sc -autostartprgmode 1 quick.prg
+###############################################################################
+gccminimal: float-minimal.c gccstubs.c
+ gcc -I ./include "-D__fastcall__= " -o minimal float-minimal.c gccstubs.c -lm
+gccbasic: float-basic.c gccstubs.c
+ gcc -I ./include "-D__fastcall__= " -o basic float-basic.c gccstubs.c -lm
+gccbasiccmp: float-basic-cmp.c gccstubs.c
+ gcc -I ./include "-D__fastcall__= " -o basiccmp float-basic-cmp.c gccstubs.c -lm
+gccfloattest: floattest.c gccstubs.c
+ gcc -I ./include "-D__fastcall__= " -o floattest floattest.c gccstubs.c -lm
+
+rungcc: gccminimal gccbasic gccbasiccmp gccfloattest
+ ./minimal
+ ./basic
+ ./basiccmp
+ ./floattest
+
+###############################################################################
+
+runminimal: float-minimal.bin
+ sim65 float-minimal.bin
+runbasic: float-basic.bin
+ sim65 float-basic.bin
+runbasiccmp: float-basic-cmp.bin
+ sim65 float-basic-cmp.bin
+
+run: runminimal runbasic runbasiccmp
+ sim65 float-minimal.bin
+ sim65 float-basic.bin
+ sim65 float-basic-cmp.bin
+
+runwoz: float-minimal.woz.bin float-basic.woz.bin float-basic-cmp.woz.bin
+ sim65 float-minimal.woz.bin
+ sim65 float-basic.woz.bin
+ sim65 float-basic-cmp.woz.bin
+
+###############################################################################
+
+clean:
+ $(RM) ./minimal
+ $(RM) ./basic
+ $(RM) ./basiccmp
+ $(RM) ./floattest
+
+ $(RM) $(FILES)
+
+ $(RM) quick.c64.s
+
+ $(RM) float-minimal.s
+ $(RM) float-minimal.c64.s
+ $(RM) float-minimal.woz.s
+
+ $(RM) float-basic.s
+ $(RM) float-basic.c64.s
+ $(RM) float-basic.woz.s
+
+ $(RM) float-basic-cmp.s
+ $(RM) float-basic-cmp.c64.s
+ $(RM) float-basic-cmp.woz.s
diff --git a/test/float/cbmkernal/cbmfp.h b/test/float/cbmkernal/cbmfp.h
new file mode 100644
index 000000000..258eca468
--- /dev/null
+++ b/test/float/cbmkernal/cbmfp.h
@@ -0,0 +1,121 @@
+
+#ifndef _CBMFS_H_
+#define _CBMFS_H_
+
+
+/*
+
+ format used in basic-variables
+
+ we dont use this format, although it saves one byte per variable, since that
+ removes the need of constantly converting between both formats. (someday
+ we may use an entire different (not cbm-specific), more accurate, format anyway)
+
+ sign
+ exponent / /mantissa
+ 33333333 3 3222222222111111111110000000000
+ 98765432 1 0987654321098765432109876543210
+
+ * The exponent can be computed from bits 39-32 by subtracting 129 (!)
+ */
+typedef struct {
+ unsigned char exponent;
+ unsigned char mantissa[4];
+} FLOATBAS;
+
+/* CBM format used in floating-point akku
+ *
+ * this format can be directly used with most CBM BASIC routines
+ *
+ * exponent mantissa sign
+ * 44444444 33333333332222222222111111111100 00000000
+ * 76543210 98765432109876543210987654321098 76543210
+ *
+ * truncated to 32bit:
+ *
+ * exponent mantissa sign
+ * 33222222 2222111111111100 00000000
+ * 10987654 3210987654321098 76543210
+ *
+ * The exponent can be computed from bits 47-40 by subtracting 129 (!) (130 = 2^1)
+ * MSB of the Mantissa must always be 1, if it is 0 the value is 0
+ *
+ * 1.0 = exp=129, mantissa=$80
+ *
+ */
+typedef struct {
+ unsigned char exponent;
+ unsigned char mantissa[4];
+ unsigned char sign;
+} FLOATFAC;
+
+/* integer conversion functions */
+float __fastcall__ _ctof(char v);
+float __fastcall__ _utof(unsigned char v);
+float __fastcall__ _itof(int v);
+float __fastcall__ _stof(unsigned short v);
+
+int __fastcall__ _ftoi(float f);
+
+/* compare two floats, returns 0 if f = a, 1 if f < a, 255 if f > a */
+unsigned char __fastcall__ _fcmp(float f, float a);
+
+/* arithmetic functions */
+float __fastcall__ _fadd(float f, float a); /* ftosaddeax */
+float __fastcall__ _fsub(float f, float a); /* ftossubeax */
+float __fastcall__ _fmul(float f, float a); /* ftosmuleax */
+float __fastcall__ _fdiv(float f, float a); /* ftosdiveax */
+
+/* math functions */
+float __fastcall__ _fpow(float f, float a); /* math.h powf */
+float __fastcall__ _fsin(float s); /* math.h sinf */
+float __fastcall__ _fcos(float s); /* math.h cosf */
+
+float __fastcall__ _flog(float s); /* math.h logf */
+float __fastcall__ _fexp(float s); /* math.h expf */
+float __fastcall__ _fsqr(float s); /* math.h sqrtf */
+
+float __fastcall__ _ftan(float s); /* math.h tanf */
+float __fastcall__ _fatn(float s); /* math.h atanf */
+
+float __fastcall__ _fabs(float s); /* math.h fabsf */
+
+/* logical functions */
+float __fastcall__ _fand(float f, float a);
+float __fastcall__ _for(float f, float a);
+float __fastcall__ _fnot(float f);
+
+/* misc */
+float __fastcall__ _frnd(float s);
+
+float __fastcall__ _fneg(float f); /* negate (flip sign) */
+unsigned char __fastcall__ _ftestsgn(float f); /* FIXME */
+
+float __fastcall__ _fsgn(float s);
+float __fastcall__ _fint(float s);
+
+#if 0
+
+typedef struct {
+ unsigned char exponent;
+ FLOATBAS coffs[8]; /* ? */
+} FLOATPOLY;
+
+#define fpoly FLOATPOLY
+
+/* polynom1 f(x)=a1+a2*x^2+a3*x^3+...+an*x^n */
+void _fpoly1(float *d,fpoly *a,float *x);
+/* polynom2 f(x)=a1+a2*x^3+a3*x^5+...+an*x^(2n-1) */
+void _fpoly2(float *d,fpoly *a,float *x);
+
+#endif
+
+/*
+ todo:
+
+ acos,asin,ceil,cosh,fmod,hypot,ldexp,log10,modf,poly,pow10,sinh
+ tanh,cabs,_matherr,matherr,
+
+*/
+
+#endif
diff --git a/test/float/cbmkernal/cc65wrapper.s b/test/float/cbmkernal/cc65wrapper.s
new file mode 100644
index 000000000..bc60ebdf7
--- /dev/null
+++ b/test/float/cbmkernal/cc65wrapper.s
@@ -0,0 +1,388 @@
+
+ .import __ctof
+ .import __utof
+ .import __itof
+ .import __stof
+
+; 8bit signed -> float
+ .export afloat
+afloat:
+ jmp __ctof
+
+; 8bit unsigned -> float
+ .export aufloat
+aufloat:
+ jmp __utof
+
+; 16bit signed -> float
+ .export axfloat
+axfloat:
+ jmp __itof
+
+; 16bit unsigned -> float
+ .export axufloat
+axufloat:
+ jmp __stof
+
+; FIXME: this might be more accurate when done directly in one step (but the
+; kernal can not do this for 32bit)
+; 32bit signed -> float
+ .importzp sreg, tmp1
+ .import pusheax
+
+ .export eaxfloat
+eaxfloat:
+
+ sta tmp1
+
+ lda sreg
+ pha
+ lda sreg+1
+ pha
+
+ ; get lower 16bit
+ lda tmp1
+
+ ; convert lower 16 bit
+ jsr __stof
+ jsr pusheax ; push eax to stack
+
+ ; / 65536
+ ldx #$00
+ lda #$80
+ sta sreg
+ lda #$47
+ sta sreg+1
+
+ jsr __fdiv
+ jsr pusheax ; push eax to stack
+
+ ; get higher 16bit
+ pla
+ tax
+ pla
+ ; convert higher 16 bit
+ jsr __itof
+
+ jsr __fadd
+
+ jsr pusheax ; push eax to stack
+
+ ; * 65536
+ ldx #$00
+ lda #$80
+ sta sreg
+ lda #$47
+ sta sreg+1
+
+ jmp __fmul
+
+; FIXME: this might be more accurate when done directly in one step (but the
+; kernal can not do this for 32bit)
+; 32bit unsigned -> float
+ .importzp sreg, tmp1
+ .import pusheax
+
+ .export eaxufloat
+eaxufloat:
+
+ sta tmp1
+
+ lda sreg
+ pha
+ lda sreg+1
+ pha
+
+ ; get lower 16bit
+ lda tmp1
+
+ ; convert lower 16 bit
+ jsr __stof
+ jsr pusheax ; push eax to stack
+
+ ; / 65536
+ ldx #$00
+ lda #$80
+ sta sreg
+ lda #$47
+ sta sreg+1
+
+ jsr __fdiv
+ jsr pusheax ; push eax to stack
+
+ ; get higher 16bit
+ pla
+ tax
+ pla
+ ; convert higher 16 bit
+ jsr __stof
+
+ jsr __fadd
+
+ jsr pusheax ; push eax to stack
+
+ ; * 65536
+ ldx #$00
+ lda #$80
+ sta sreg
+ lda #$47
+ sta sreg+1
+
+ jmp __fmul
+
+;--------------------------------------------------------------
+
+ .import __ftoi
+
+; float -> 16bit int
+ .export feaxint
+feaxint:
+ jmp __ftoi
+
+; FIXME: this might be more accurate when done directly in one step (but the
+; kernal can not do this for 32bit)
+; float -> 32bit int
+ .importzp tmp1, tmp2
+ .export feaxlong
+feaxlong:
+
+ jsr pusheax
+
+ ; primary = primary / 65536
+ jsr pusheax ; push eax to stack
+ ldx #$00
+ lda #$80
+ sta sreg
+ lda #$47
+ sta sreg+1
+ jsr __fdiv ; primary / TOS
+ ; convert result to int and save
+ jsr __ftoi
+ sta tmp1
+ stx tmp2
+ ; convert back to float
+ jsr __stof
+ ; primary = primary * 65536
+ jsr pusheax ; push eax to stack
+ ldx #$00
+ lda #$80
+ sta sreg
+ lda #$47
+ sta sreg+1
+ jsr __fmul ; primary * TOS
+ ; substract the result from the total number to get the rest
+ jsr __fsub
+ ; convert rest to int
+ jsr __ftoi
+
+ ldy tmp2
+ sty sreg+1
+ ldy tmp1
+ sty sreg
+ rts
+
+;--------------------------------------------------------------
+ .import __fnot
+ .import __fneg
+
+; binary negate (not) for the ! operator. returns a bool!
+ .export fbnegeax
+ .import bnegax
+fbnegeax:
+ jsr __ftoi
+ jmp bnegax
+
+;--------------------------------------------------------------
+; math ops
+
+ .import __fadd
+ .import __fsub
+ .import __fdiv
+ .import __fmul
+
+; Primary = TOS + Primary (like tosaddeax)
+ .export ftosaddeax
+ftosaddeax:
+ ; arg0: a/x/sreg/sreg+1
+ ; arg1: (sp),y (y=0..3)
+
+ ; FAC: ieee float is in A/X/sreg/sreg+1
+ jmp __fadd
+
+ .export ftossubeax
+ftossubeax:
+ jmp __fsub
+ .export ftosdiveax
+ftosdiveax:
+ jmp __fdiv
+ .export ftosmuleax
+ftosmuleax:
+ jmp __fmul
+
+;--------------------------------------------------------------
+
+ .import __fcmp
+
+ ; test for equal
+ .export ftoseqeax
+ftoseqeax:
+ ; arg0: a/x/sreg/sreg+1
+ ; arg1: (sp),y (y=0..3)
+ jsr __fcmp
+ ; a=0 (==) / a=1 (>) / a=255 (<)
+ cmp #0
+ beq @equal
+ lda #0
+ tax
+ rts
+@equal:
+ ldx #0
+ lda #1
+ rts
+
+ ; test for not equal
+ .export ftosneeax
+ftosneeax:
+ ; arg0: a/x/sreg/sreg+1
+ ; arg1: (sp),y (y=0..3)
+ jsr __fcmp
+ ; a=0 (==) / a=1 (>) / a=255 (<)
+ cmp #0
+ beq @equal
+ ldx #0
+ lda #1
+ rts
+@equal:
+ lda #0
+ tax
+ rts
+
+ ; Test for greater than
+ .export ftosgteax
+ftosgteax:
+ ; arg0: a/x/sreg/sreg+1
+ ; arg1: (sp),y (y=0..3)
+ jsr __fcmp
+ ; a=0 (==) / a=1 (>) / a=255 (<)
+ cmp #255
+ bne @biggerorequal
+ ; less
+ ldx #0
+ lda #1
+ rts
+@biggerorequal:
+ lda #0
+ tax
+ rts
+
+ ; Test for less than
+ .export ftoslteax
+ftoslteax:
+ ; arg0: a/x/sreg/sreg+1
+ ; arg1: (sp),y (y=0..3)
+ jsr __fcmp
+ ; a=0 (==) / a=1 (>) / a=255 (<)
+ cmp #1
+ beq @bigger
+ lda #0
+ tax
+ rts
+@bigger:
+ ldx #0
+ lda #1
+ rts
+
+ ; Test for greater than or equal to
+ .export ftosgeeax
+ftosgeeax:
+ ; arg0: a/x/sreg/sreg+1
+ ; arg1: (sp),y (y=0..3)
+ jsr __fcmp
+ ; a=0 (==) / a=1 (>) / a=255 (<)
+ cmp #1
+ beq @bigger
+ ; less than or equal
+ ldx #0
+ lda #1
+ rts
+@bigger:
+ lda #0
+ tax
+ rts
+
+ ; Test for less than or equal to
+ .export ftosleeax
+ftosleeax:
+ ; arg0: a/x/sreg/sreg+1
+ ; arg1: (sp),y (y=0..3)
+ jsr __fcmp
+ ; a=0 (==) / a=1 (>) / a=255 (<)
+ cmp #255
+ beq @smaller
+ ; greater than or equal
+ ldx #0
+ lda #1
+ rts
+@smaller:
+ lda #0
+ tax
+ rts
+
+;--------------------------------------------------------------
+; math.h
+
+ .import __fpow
+ .import __fsin
+ .import __fcos
+ .import __flog
+ .import __fexp
+ .import __fsqr
+ .import __ftan
+ .import __fatn
+ .import __fabs
+
+ .export _powf
+_powf:
+ ; arg0: a/x/sreg/sreg+1
+ ; arg1: (sp),y (y=0..3)
+ jmp __fpow
+
+ .export _sinf
+_sinf:
+ ; arg0: a/x/sreg/sreg+1
+ jmp __fsin
+
+ .export _cosf
+_cosf:
+ ; arg0: a/x/sreg/sreg+1
+ jmp __fcos
+
+ .export _logf
+_logf:
+ ; arg0: a/x/sreg/sreg+1
+ jmp __flog
+
+ .export _expf
+_expf:
+ ; arg0: a/x/sreg/sreg+1
+ jmp __fexp
+
+ .export _sqrtf
+_sqrtf:
+ ; arg0: a/x/sreg/sreg+1
+ jmp __fsqr
+
+ .export _tanf
+_tanf:
+ ; arg0: a/x/sreg/sreg+1
+ jmp __ftan
+
+ .export _atanf
+_atanf:
+ ; arg0: a/x/sreg/sreg+1
+ jmp __fatn
+
+ .export _fabsf
+_fabsf:
+ ; arg0: a/x/sreg/sreg+1
+ jmp __fabs
diff --git a/test/float/cbmkernal/ffloor.c b/test/float/cbmkernal/ffloor.c
new file mode 100644
index 000000000..f0b7cbd88
--- /dev/null
+++ b/test/float/cbmkernal/ffloor.c
@@ -0,0 +1,24 @@
+
+#include <_float.h>
+#include
+
+#include
+
+#define _fcmplt(_d, _s) (_fcmp((_d), (_s)) == 1)
+#define _fcmpgt(_d, _s) (_fcmp((_d), (_s)) == 255)
+#define _fcmpeq(_d, _s) (_fcmp((_d), (_s)) == 0)
+
+/* FIXME: this is really too simple */
+float ffloor(float x)
+{
+ signed long n;
+ float d;
+
+ n = _ftoi(x); /* FIXME: long */
+ d = _itof(n); /* FIXME: long */
+
+ if (_fcmpeq(d, x) || _fcmplt(_itof(0), x)) {
+ return d;
+ }
+ return _fsub(d, 1);
+}
diff --git a/test/float/cbmkernal/float-vic20.inc b/test/float/cbmkernal/float-vic20.inc
new file mode 100644
index 000000000..6ffb952d3
--- /dev/null
+++ b/test/float/cbmkernal/float-vic20.inc
@@ -0,0 +1,63 @@
+
+FAC_EXPONENT = $61
+FAC_MANTISSA0 = $62
+FAC_MANTISSA1 = $63
+FAC_MANTISSA2 = $64
+FAC_MANTISSA3 = $65
+FAC_SIGN = $66
+
+ARG_EXPONENT = $69
+ARG_MANTISSA0 = $6a
+ARG_MANTISSA1 = $6b
+ARG_MANTISSA2 = $6c
+ARG_MANTISSA3 = $6d
+ARG_SIGN = $6e
+
+FAC_SIGN_COMPARE = $6f
+FAC_ROUNDING = $70
+
+; addresses of the floating point routines in CBM BASIC V2
+
+; the following are the addresses in the VIC-20 ROM - the library can probably be
+; used with other CBM targets just by adjusting these addresses
+
+BASIC_FAC_Not = $ced4 ; in/out: FAC ; yup, c64 & vic are this different
+BASIC_FAC_Cos = $e261 ; in/out: FAC
+BASIC_FAC_Sin = $e268 ; in/out: FAC
+BASIC_FAC_Tan = $e2b1 ; in/out: FAC
+BASIC_FAC_Atn = $e30b ; in/out: FAC
+BASIC_FAC_Rnd = $e094 ; in/out: FAC
+BASIC_FAC_Int = $dccc ; in/out: FAC
+BASIC_FAC_Sqr = $df71 ; in/out: FAC
+BASIC_FAC_Exp = $dfed ; in/out: FAC
+BASIC_FAC_Log = $d9ea ; in/out: FAC
+BASIC_FAC_Round = $dc1b ; in/out: FAC
+BASIC_FAC_Sgn = $dc39 ; in/out: FAC
+BASIC_FAC_Abs = $dc58 ; in/out: FAC
+
+BASIC_ARG_FAC_Or = $cfe6 ; in: ARG,FAC out:FAC
+BASIC_ARG_FAC_And = $cfe9 ; in: ARG,FAC out:FAC
+BASIC_ARG_FAC_Sub = $d853 ; in: ARG,FAC out:FAC
+BASIC_ARG_FAC_Add = $d86a ; in: ARG,FAC out:FAC
+BASIC_ARG_FAC_Mul = $da2b ; in: ARG,FAC out:FAC
+BASIC_ARG_FAC_Div = $db12 ; in: ARG,FAC out:FAC
+BASIC_ARG_FAC_Pow = $df7b ; in: ARG,FAC out:FAC
+
+BASIC_u8_to_FAC = $d3a2 ; y: value
+BASIC_s8_to_FAC = $dc3c ; a: value
+BASIC_u16_to_FAC = $dc49 ; a/y:lo/hi value (sta $62 sty $63 sec ldx#$90 jsr...)
+BASIC_s16_to_FAC = $d395 ; a/y:lo/hi value
+
+BASIC_FAC_to_u16 = $dc9b ; in:FAC out: y/a:lo/hi value
+
+BASIC_string_to_FAC = $d7b5 ; in: $22/$23 ptr to str,a=strlen out: FAC value
+BASIC_FAC_to_string = $dddd ; in: FAC value out: str at $0100 a/y ptr to str
+
+BASIC_LoadARG = $da8c ; a/y:lo/hi ptr to 5-byte float
+BASIC_LoadFAC = $dba2 ; a/y:lo/hi ptr to 5-byte float
+
+BASIC_FAC_testsgn = $dc2b ; in: FAC(x1) out: a=0 (x1=0) a=1 (x1>0) a=255 (x1<0)
+BASIC_FAC_cmp = $dc5b ; in: FAC(x1) a/y ptr lo/hi to x2 out: a=0 (x1=x2) a=1 (x1>x2) a=255 (x10) a=255 (x1<0)
+BASIC_FAC_cmp = $bc5b ; in: FAC(x1) a/y ptr lo/hi to x2 out: a=0 (x1=x2) a=1 (x1>x2) a=255 (x1 $ff or $7f
+ and FAC_MANTISSA0 ; bit7 of mantissa is always 1
+ sta sreg ; 1
+
+ ldx FAC_MANTISSA1 ; 2
+ lda FAC_MANTISSA2 ; 3
+.endif
+.if BINARYFORMAT = BINARYFORMAT_IEEE754
+ ; return float in a/x/sreg/sreg+1
+ lda FAC_EXPONENT
+ sec
+ sbc #2
+ sta sreg+1 ; 0
+
+ lda FAC_MANTISSA0
+ asl
+ sta sreg ; 1
+
+ lda FAC_SIGN ; either $ff or $00
+ asl
+ ror sreg+1 ; exp
+ ror sreg ; mantissa msb
+
+
+ ldx FAC_MANTISSA1 ; 2
+ lda FAC_MANTISSA2 ; 3 lsb
+
+.endif
+ rts
+
+;; store float in memory
+;; in: dest. pointer (a/x), float in FAC
+;__float_fac_to_float: ; UNUSED
+; sta ptr1
+; stx ptr1+1
+; ldy #$00
+; lda FAC_EXPONENT
+; sta (ptr1),y
+; iny
+; lda FAC_MANTISSA0
+; sta (ptr1),y
+; iny
+; lda FAC_MANTISSA1
+; sta (ptr1),y
+; iny
+; lda FAC_MANTISSA2
+; sta (ptr1),y
+; iny
+; lda FAC_MANTISSA3
+; sta (ptr1),y
+; iny
+; lda FAC_SIGN
+; sta (ptr1),y
+; rts
+
+;; store packed float in memory
+;; in: dest. pointer (a/x), float in FAC
+;__float_fac_to_float_packed: ; UNUSED
+; sta ptr1
+; stx ptr1+1
+; ldy #4
+; lda FAC_MANTISSA3
+; sta (ptr1),y
+; dey
+; lda FAC_MANTISSA2
+; sta (ptr1),y
+; dey
+; lda FAC_MANTISSA1
+; sta (ptr1),y
+; dey
+;; use the MSB of the mantissa for the sign
+; lda FAC_SIGN
+; ora #$7f
+; and FAC_MANTISSA0
+; sta (ptr1),y
+; dey
+; lda FAC_EXPONENT
+; sta (ptr1),y
+; rts
+
+;; store packed float in memory
+;; in: dest. pointer (a/x), float in ARG
+__float_arg_to_float_packed:
+ sta ptr1
+ stx ptr1+1
+ ldy #4
+ lda ARG_MANTISSA3
+ sta (ptr1),y
+ dey
+ lda ARG_MANTISSA2
+ sta (ptr1),y
+ dey
+ lda ARG_MANTISSA1
+ sta (ptr1),y
+ dey
+; use the MSB of the mantissa for the sign
+ lda ARG_SIGN
+ ora #$7f
+ and ARG_MANTISSA0
+ sta (ptr1),y
+ dey
+ lda ARG_EXPONENT
+ sta (ptr1),y
+ rts
+
+;---------------------------------------------------------------------------------------------
+
+ .export __ftostr
+ .importzp ptr1
+ .import popax, ldeaxysp, incsp4
+
+; convert float to string
+; char* __fastcall__ _ftostr(char *d, float s);
+;-> char* __fastcall__ _ftostr(char *d, unsigned long s);
+
+__ftostr:
+ jsr ___float_float_to_fac
+ jsr __float_fac_to_str
+
+___float_strbuf_to_string:
+ jsr popax ; ptr to string
+__float_strbuf_to_string:
+ sta ptr1
+ stx ptr1+1
+ ldy #$00
+@l:
+ lda $0100,y
+ sta (ptr1),y
+ beq @s
+ iny
+ bne @l
+@s:
+ lda ptr1
+ ldx ptr1+1
+ rts
+
+ .export __strtof
+
+; convert a string to a float
+; float __fastcall__ _strtof(char *d);
+;-> unsigned long __fastcall__ _strtof(char *d);
+__strtof:
+ jsr ___float_str_to_fac
+ jmp ___float_fac_to_float
+
+ .export __ctof
+
+; convert char to float
+; float __fastcall__ _ctof(char v);
+;-> unsigned long __fastcall__ _ctof(char v);
+ __ctof:
+ jsr ___float_s8_to_fac
+ jmp ___float_fac_to_float
+
+ .export __utof
+
+; convert unsigned char to float
+; float __fastcall__ _utof(unsigned char v);
+;-> unsigned long __fastcall__ _utof(unsigned char v);
+ __utof:
+ jsr ___float_u8_to_fac
+ jmp ___float_fac_to_float
+
+ .export __stof
+
+; convert short to float
+; float __fastcall__ _stof(unsigned short v);
+;-> unsigned long __fastcall__ _stof(unsigned short v);
+ __stof:
+ jsr ___float_u16_to_fac
+ jmp ___float_fac_to_float
+
+ .export __itof
+
+; convert integer to float
+; float __fastcall__ _itof(int v);
+;-> unsigned long __fastcall__ _itof(int v);
+ __itof:
+ ;a: low x: high
+ jsr ___float_s16_to_fac
+ jmp ___float_fac_to_float
+
+ .export __ftoi
+
+; convert float to integer
+; int __fastcall__ _ftoi(float f);
+;-> int __fastcall__ _ftoi(unsigned long f);
+ __ftoi:
+ jsr ___float_float_to_fac
+ jmp __float_fac_to_u16
+
+;---------------------------------------------------------------------------------------------
+; these functions take one arg (in FAC) and return result (in FAC) aswell
+;---------------------------------------------------------------------------------------------
+
+.macro __ffunc1 addr
+ jsr ___float_float_to_fac
+ __enable_basic_if_needed
+ jsr addr
+ __disable_basic_if_needed
+ jmp ___float_fac_to_float
+.endmacro
+
+ .export __fabs, __fatn, __fcos, __fexp, __fint, __flog
+ .export __frnd, __fsgn, __fsin, __fsqr, __ftan, __fnot, __fround
+
+__fabs: __ffunc1 BASIC_FAC_Abs
+__fatn: __ffunc1 BASIC_FAC_Atn
+__fcos: __ffunc1 BASIC_FAC_Cos
+__fexp: __ffunc1 BASIC_FAC_Exp
+;__ffre: __ffunc1 BASIC_FAC_Fre
+__fint: __ffunc1 BASIC_FAC_Int
+__flog: __ffunc1 BASIC_FAC_Log
+;__fpos: __ffunc1 BASIC_FAC_Pos
+__frnd: __ffunc1 BASIC_FAC_Rnd
+__fsgn: __ffunc1 BASIC_FAC_Sgn
+__fsin: __ffunc1 BASIC_FAC_Sin
+__fsqr: __ffunc1 BASIC_FAC_Sqr
+__ftan: __ffunc1 BASIC_FAC_Tan
+__fnot: __ffunc1 BASIC_FAC_Not
+__fround: __ffunc1 BASIC_FAC_Round
+
+;---------------------------------------------------------------------------------------------
+; these functions take two args (in FAC and ARG) and return result (in FAC)
+;---------------------------------------------------------------------------------------------
+
+__float_ret2:
+
+ ;jsr __basicoff
+.if .defined(__C64__)
+ ldx #$36
+ stx $01
+ cli
+.endif
+ jmp ___float_fac_to_float ; also pops pointer to float
+
+.macro __ffunc2a addr
+ jsr ___float_float_to_fac_arg
+ __enable_basic_if_needed
+ lda FAC_EXPONENT
+ jsr addr
+ jmp __float_ret2
+.endmacro
+
+.macro __ffunc2b addr
+ jsr ___float_float_to_fac_arg
+ __enable_basic_if_needed
+ jsr addr
+ jmp __float_ret2
+.endmacro
+
+ .export __fadd, __fsub, __fmul, __fdiv, __fpow
+
+; float __fastcall__ _fadd(float f, float a);
+;-> unsigned long __fastcall__ _fadd(unsigned long f, unsigned long a);
+__fadd: __ffunc2a BASIC_ARG_FAC_Add
+__fsub: __ffunc2a BASIC_ARG_FAC_Sub
+__fmul: __ffunc2a BASIC_ARG_FAC_Mul
+__fdiv: __ffunc2a BASIC_ARG_FAC_Div
+__fpow: __ffunc2a BASIC_ARG_FAC_Pow
+
+ .export __fand, __for
+
+__fand: __ffunc2b BASIC_ARG_FAC_And
+__for: __ffunc2b BASIC_ARG_FAC_Or
+
+__float_ret3:
+ ;jsr __basicoff
+.if .defined(__C64__)
+ ldx #$36
+ stx $01
+ cli
+.endif
+ ldx #0
+ rts
+
+ .bss
+
+tempfloat:
+ .res 5
+
+ .SEGMENT "LOWCODE"
+
+ .export __fcmp
+
+__fcmp:
+ jsr ___float_float_to_fac_arg
+ lda #tempfloat
+ jsr __float_arg_to_float_packed
+ lda #tempfloat
+___float_cmp_fac_arg:
+ __enable_basic_if_needed
+ ; in: FAC=(x1) a/y= ptr lo/hi to x2
+ jsr BASIC_FAC_cmp
+ ; a=0 (==) / a=1 (>) / a=255 (<)
+ jmp __float_ret3
+
+ .export __ftestsgn
+
+__ftestsgn:
+ jsr ___float_float_to_fac
+;___float_testsgn_fac:
+ __enable_basic_if_needed
+ ; in: FAC(x1)
+ jsr BASIC_FAC_testsgn
+ jmp __float_ret3
+
+___float_testsgn_fac:
+ lda FAC_EXPONENT
+ beq @s
+ lda FAC_SIGN
+ rol a
+ lda #$ff
+ bcs @s
+ lda #$01
+@s:
+ rts
+
+___float_testsgn_arg:
+ lda ARG_EXPONENT
+ beq @s
+ lda ARG_SIGN
+ rol a
+ lda #$ff
+ bcs @s
+ lda #$01
+@s:
+ rts
+
+;---------------------------------------------------------------------------------------------
+; polynom1 f(x)=a1+a2*x^2+a3*x^3+...+an*x^n
+;---------------------------------------------------------------------------------------------
+ .export __fpoly1
+__fpoly1:
+ jsr ___float_float_to_fac
+ ;jsr popya
+ jsr popax
+ tay
+ txa
+ __enable_basic_if_needed
+ jsr BASIC_FAC_Poly1
+ jmp __float_ret2
+
+;---------------------------------------------------------------------------------------------
+; polynom2 f(x)=a1+a2*x^3+a3*x^5+...+an*x^(2n-1)
+;---------------------------------------------------------------------------------------------
+ .export __fpoly2
+__fpoly2:
+ jsr ___float_float_to_fac
+ ;jsr popya
+ jsr popax
+ tay
+ txa
+ __enable_basic_if_needed
+ jsr BASIC_FAC_Poly1
+ jmp __float_ret2
+
+;---------------------------------------------------------------------------------------------
+
+__float_atn_fac:
+ __enable_basic_if_needed
+ jsr BASIC_FAC_Atn
+ __return_with_cleanup
+__float_div_fac_arg:
+ __enable_basic_if_needed
+ lda FAC_EXPONENT
+ jsr BASIC_ARG_FAC_Div
+ __return_with_cleanup
+__float_add_fac_arg:
+ __enable_basic_if_needed
+ lda FAC_EXPONENT
+ jsr BASIC_ARG_FAC_Add
+ __return_with_cleanup
+
+__float_swap_fac_arg: ; only used in ATAN2
+ lda FAC_EXPONENT
+ ldx ARG_EXPONENT
+ stx FAC_EXPONENT
+ sta ARG_EXPONENT
+ lda FAC_MANTISSA0
+ ldx ARG_MANTISSA0
+ stx FAC_MANTISSA0
+ sta ARG_MANTISSA0
+ lda FAC_MANTISSA1
+ ldx ARG_MANTISSA1
+ stx FAC_MANTISSA1
+ sta ARG_MANTISSA1
+ lda FAC_MANTISSA2
+ ldx ARG_MANTISSA2
+ stx FAC_MANTISSA2
+ sta ARG_MANTISSA2
+ lda FAC_MANTISSA3
+ ldx ARG_MANTISSA3
+ stx FAC_MANTISSA3
+ sta ARG_MANTISSA3
+ lda FAC_SIGN
+ ldx ARG_SIGN
+ stx FAC_SIGN
+ sta ARG_SIGN
+ rts
+
+ .export __fneg
+__fneg:
+ jsr ___float_float_to_fac
+
+ lda FAC_EXPONENT
+ beq @sk
+ lda FAC_SIGN
+ eor #$FF
+ sta FAC_SIGN
+@sk:
+ jmp ___float_fac_to_float
+
+
+__f_pi2: .byte $81,$80+$49,$0f,$da,$a1,$00
+__f_pi: .byte $82,$80+$49,$0f,$da,$a1,$00
+__f_1pi2: .byte $83,$80+$16,$cb,$e3,$f9,$00
+
+ .export __fatan2
+
+; float _fatan2(float x, float y)
+;-> unsigned long _fatan2(unsigned long x, unsigned long y)
+__fatan2:
+
+ jsr ___float_float_to_fac_arg
+
+ jsr ___float_testsgn_arg
+ beq @s11 ; =0
+ bpl @s12 ; <0
+ ; arg>0
+ ; a=atn(y/x)
+ jsr __float_swap_fac_arg
+ jsr __float_div_fac_arg
+ jsr __float_atn_fac
+ jmp __float_ret2
+@s12: ; arg<0
+ ; a=atn(y/x)+pi
+ jsr __float_swap_fac_arg
+ jsr __float_div_fac_arg
+ jsr __float_atn_fac
+ lda #<__f_pi
+ ldx #>__f_pi
+ jsr __float_float_to_arg
+ jsr __float_add_fac_arg
+ jmp __float_ret2
+
+@s11: ; arg=0
+ jsr ___float_testsgn_fac
+ beq @s21 ; =0
+ bpl @s22 ; <0
+ ; fac >0
+ ; a= 0.5*pi
+ lda #<__f_pi2
+ ldx #>__f_pi2
+ jsr __float_float_to_fac
+ jmp __float_ret2
+ ; fac =0
+@s21:
+ ; a= 0
+ lda #$00
+ sta FAC_MANTISSA0
+ jmp __float_ret2
+ ; fac <0
+@s22:
+ ; a= 1.5*pi
+ lda #<__f_1pi2
+ ldx #>__f_1pi2
+ jsr __float_float_to_fac
+ jmp __float_ret2
+
diff --git a/test/float/cbmkernal/ftoa.c b/test/float/cbmkernal/ftoa.c
new file mode 100644
index 000000000..15d2aa8eb
--- /dev/null
+++ b/test/float/cbmkernal/ftoa.c
@@ -0,0 +1,134 @@
+
+#include <_float.h>
+#include
+
+#include
+
+// convert float into a string. this is surprisingly complex, so we just use
+// the kernal function, and then fix up the result
+
+char *ftoa(char *buf, float n)
+{
+ char i, ii, epos = 0, ex;
+ char tempbuf[0x20];
+ _ftostr(tempbuf, n);
+
+ // find position of the 'e'
+ i=0;while(tempbuf[i]) {
+ if (tempbuf[i] == 69) { /* 'e' */
+ epos = i;
+ break;
+ }
+ i++;
+ }
+
+ if (epos == 0) {
+ i = ii = 0;
+ // no exponent, we can return the number as is
+ if (tempbuf[i] == '-') {
+ buf[ii] = tempbuf[i];
+ i++;ii++;
+ }
+// else {
+// buf[ii] = ' ';
+// ii++;
+// }
+
+ // skip space
+ if (tempbuf[i] == ' ') {
+ i++;
+ }
+
+ if (tempbuf[i] == '.') {
+ i++;
+ buf[ii] = '0'; ii++;
+ buf[ii] = '.'; ii++;
+ }
+ while (tempbuf[i]) {
+ buf[ii] = tempbuf[i];
+ i++;ii++;
+ }
+ buf[ii] = 0;
+ } else {
+ // we have an exponent, get rid of it
+
+ i = ii = 0;
+ if (tempbuf[i] == '-') {
+ buf[ii] = tempbuf[i];
+ i++;ii++;
+ }
+// else {
+// buf[ii] = ' ';
+// ii++;
+// }
+ // skip space
+ if (tempbuf[i] == ' ') {
+ i++;
+ }
+
+ ex = ((tempbuf[epos+2] - '0') * 10) + (tempbuf[epos+3] - '0');
+
+ if (tempbuf[epos+1] == '+') {
+ // positive exponent, move decimal point to right, add zeros to the right
+
+ // first copy until we see either the decimal point, or the 'e'
+ while (tempbuf[i] && tempbuf[i] != '.' && tempbuf[i] != 69) {
+ buf[ii] = tempbuf[i];
+ i++;ii++;
+ }
+
+ // 'e' found, add as many zeros as in the exponent
+ if (tempbuf[i] == 69) {
+ while(ex) {
+ buf[ii] = '0';
+ ii++;
+ ex--;
+ }
+ }
+
+ if (tempbuf[i] == '.') {
+ i++; // skip '.'
+ // copy digits until 'e'
+ while(ex && tempbuf[i] != 69) {
+ buf[ii] = tempbuf[i];
+ ii++;i++;
+ ex--;
+ }
+ // add zeros
+ while(ex) {
+ buf[ii] = '0';
+ ii++;
+ ex--;
+ }
+ }
+
+ } else {
+ // negative exponent, move decimal point to left, add zeros to left
+
+ buf[ii] = '0'; ii++;
+ buf[ii] = '.'; ii++;
+
+ ex--;
+
+ // add zeros
+ while(ex) {
+ buf[ii] = '0';
+ ii++;
+ ex--;
+ }
+
+ while (tempbuf[i] && tempbuf[i] != 69) {
+ if (tempbuf[i] == '.') {
+ i++;
+ }
+ buf[ii] = tempbuf[i];
+ i++;ii++;
+ }
+
+ }
+ buf[ii] = 0;
+ }
+
+ return buf;
+}
+
diff --git a/test/float/float-basic-cmp.c b/test/float/float-basic-cmp.c
new file mode 100644
index 000000000..3f7e75155
--- /dev/null
+++ b/test/float/float-basic-cmp.c
@@ -0,0 +1,161 @@
+
+// test comparison operations
+// WIP WIP WIP
+
+#include
+#include
+#include
+
+#include <_float.h>
+
+float fp1, fp2, fp3, fp4;
+
+char buf[0x10];
+char buf2[0x10];
+char buf3[0x10];
+
+signed char var_schar;
+unsigned char var_uchar;
+signed int var_sint;
+unsigned int var_uint;
+signed long var_slong;
+unsigned long var_ulong;
+
+int main(void)
+{
+ printf("float-basic-cmp\n");
+
+ //-------------------------------------------------------------------------
+ // float variable vs float constant
+ printf("var vs const\n");
+
+//FIXME: compiles, but is wrong, the constant in the comparison becomes 0
+ fp1 = 1.5f;
+ printf("1.5f == 1.6f is ");
+ if (fp1 == 1.6f) {
+ printf("true\n");
+ } else {
+ printf("false\n");
+ }
+ fp1 = 1.5f;
+ printf("1.5f == 1.5f is ");
+ if (1.5f == fp1) {
+ printf("true\n");
+ } else {
+ printf("false\n");
+ }
+
+//FIXME: compiles, but is wrong, the constant in the comparison becomes 0
+ fp1 = 1.5f;
+ printf("1.5f != 1.6f is ");
+ if (fp1 != 1.6f) {
+ printf("true\n");
+ } else {
+ printf("false\n");
+ }
+ fp1 = 1.5f;
+ printf("1.5f != 1.5f is ");
+ if (1.5f != fp1) {
+ printf("true\n");
+ } else {
+ printf("false\n");
+ }
+
+//FIXME: compiles, but is wrong, the constant in the comparison becomes 0
+ fp1 = 1.5f;
+ printf("1.5f < 1.6f is ");
+ if (fp1 < 1.6f) {
+ printf("true\n");
+ } else {
+ printf("false\n");
+ }
+ fp1 = 1.7f;
+ printf("1.7f < 1.5f is ");
+ if (1.7f < fp1) {
+ printf("true\n");
+ } else {
+ printf("false\n");
+ }
+
+ //-------------------------------------------------------------------------
+ // float variable vs float variable
+ printf("var vs var\n");
+ fp1 = 1.5f;
+ fp2 = 1.6f;
+ printf("1.5f == 1.6f is ");
+ if (fp1 == fp2) {
+ printf("true\n");
+ } else {
+ printf("false\n");
+ }
+ printf("1.5f != 1.6f is ");
+ if (fp1 != fp2) {
+ printf("true\n");
+ } else {
+ printf("false\n");
+ }
+ printf("1.5f < 1.6f is ");
+ if (fp1 < fp2) {
+ printf("true\n");
+ } else {
+ printf("false\n");
+ }
+ printf("1.5f > 1.6f is ");
+ if (fp1 > fp2) {
+ printf("true\n");
+ } else {
+ printf("false\n");
+ }
+ printf("1.5f <= 1.6f is ");
+ if (fp1 <= fp2) {
+ printf("true\n");
+ } else {
+ printf("false\n");
+ }
+ printf("1.5f >= 1.6f is ");
+ if (fp1 >= fp2) {
+ printf("true\n");
+ } else {
+ printf("false\n");
+ }
+
+ fp1 = 1.6f;
+ printf("1.6f == 1.6f is ");
+ if (fp1 == fp2) {
+ printf("true\n");
+ } else {
+ printf("false\n");
+ }
+ printf("1.6f != 1.6f is ");
+ if (fp1 != fp2) {
+ printf("true\n");
+ } else {
+ printf("false\n");
+ }
+ printf("1.6f < 1.6f is ");
+ if (fp1 < fp2) {
+ printf("true\n");
+ } else {
+ printf("false\n");
+ }
+ printf("1.6f > 1.6f is ");
+ if (fp1 > fp2) {
+ printf("true\n");
+ } else {
+ printf("false\n");
+ }
+ printf("1.6f <= 1.6f is ");
+ if (fp1 <= fp2) {
+ printf("true\n");
+ } else {
+ printf("false\n");
+ }
+ printf("1.6f >= 1.6f is ");
+ if (fp1 >= fp2) {
+ printf("true\n");
+ } else {
+ printf("false\n");
+ }
+
+ return 0;
+}
diff --git a/test/float/float-basic.c b/test/float/float-basic.c
new file mode 100644
index 000000000..cdf933efb
--- /dev/null
+++ b/test/float/float-basic.c
@@ -0,0 +1,183 @@
+
+// test basic arithmetic operations
+// WIP WIP WIP
+
+#ifdef CONIO
+#include
+#endif
+
+#include
+#include
+#include
+
+#include <_float.h>
+
+float fp1 = 12.34f;
+float fp2; // non initialized
+float fp3, fp4 = 55.55f;
+
+char buf[0x10];
+char buf2[0x10];
+char buf3[0x10];
+
+unsigned long l1,l2;
+
+signed char var_schar;
+unsigned char var_uchar;
+signed int var_sint;
+unsigned int var_uint;
+signed long var_slong;
+unsigned long var_ulong;
+
+int main(void)
+{
+ float fp2 = 43.21f;
+
+ printf("float-basic\n");
+ printf("fp1:0x%08lx [0x414570a4] %s (12.340000)\n", *((uint32_t*)&fp1), _ftostr(buf, fp1));
+ printf("fp2:0x%08lx [0x422cd70a] %s (43.209999)\n", *((uint32_t*)&fp2), _ftostr(buf, fp2));
+
+ /* addition, variable + variable */
+ printf("addition, variable + variable\n");
+ fp1 = 12.34f;
+ fp2 = 43.21f;
+ fp3 = fp1 + fp2;
+ printf("%s+%s=%s\n", _ftostr(buf, fp1), _ftostr(buf2, fp2), _ftostr(buf3, fp3));
+ printf("fp3:0x%08lx [0x425e3333] %s (55.549999)\n", *((uint32_t*)&fp3), _ftostr(buf, fp3));
+
+ /* addition, variable + constant */
+ printf("addition, variable + constant\n");
+ fp3 = 55.549999f;
+ fp1 = fp3 + 0.05f;
+ printf("%s+%s=%s\n", _ftostr(buf, fp3), _ftostr(buf3, 0.05f), _ftostr(buf2, fp1));
+ printf("fp3:0x%08lx [0x425e3333] %s\n", *((uint32_t*)&fp3), _ftostr(buf, fp3));
+ printf("fp1:0x%08lx [0x425e6666] %s\n", *((uint32_t*)&fp1), _ftostr(buf, fp1));
+#if 1
+ /* addition, constant + variable */
+ printf("addition, constant + variable\n");
+ fp2 = 43.21f;
+ fp1 = 12.7f + fp2; // FIXME: wrong, the add is dropped?
+ printf("%s+%s=%s\n", _ftostr(buf3, 12.7f), _ftostr(buf, fp2), _ftostr(buf2, fp1));
+ printf("fp3:0x%08lx [0x425e3333] %s\n", *((uint32_t*)&fp2), _ftostr(buf, fp2));
+ printf("fp1:0x%08lx [0x425e6666] %s\n", *((uint32_t*)&fp1), _ftostr(buf, fp1));
+#endif
+ /* addition, constant + constant (already tested by minimal) (omitted) */
+#ifdef CONIO
+ cgetc();
+#endif
+
+#if 0
+ /* substraction, variable - constant */
+ printf("substraction, variable - constant\n");
+ fp1 = 12.34;
+ fp3 = fp1 - 11.5f; // FIXME: Invalid operands for binary operator '-'
+ printf("%s-%s=%s\n", _ftostr(buf, fp1), _ftostr(buf2, 0x11.5f), _ftostr(buf3, fp3));
+ printf("fp3:0x%08lx [] %s ()\n", *((uint32_t*)&fp3), _ftostr(buf, fp3));
+#endif
+
+#if 1
+ /* substraction, constant - variable */
+ printf("substraction, constant - variable\n");
+ fp2 = 12.34;
+ fp3 = 11.5f - fp2;
+ printf("%s-%s=%s\n", _ftostr(buf, 11.5f), _ftostr(buf2, fp2), _ftostr(buf3, fp3));
+ printf("fp3:0x%08lx [] %s ()\n", *((uint32_t*)&fp3), _ftostr(buf, fp3));
+#endif
+
+#if 1
+ /* substraction, variable - variable */
+ printf("substraction, variable - variable\n");
+ fp3 = fp1 - fp2;
+ printf("%s-%s=%s\n", _ftostr(buf, fp1), _ftostr(buf2, fp2), _ftostr(buf3, fp3));
+ printf("fp3:0x%08lx [0x41463d70] %s (12.389999)\n", *((uint32_t*)&fp3), _ftostr(buf, fp3));
+#endif
+
+#if 1
+ printf("conversions (integer variable to float)\n");
+ var_schar = -12;
+ fp1 = var_schar;
+ var_uchar = 199;
+ fp2 = var_uchar;
+ printf("fp1 0x%08lx [] %s (-12)\n", *((uint32_t*)&fp1), _ftostr(buf, fp1));
+ printf("fp2 0x%08lx [] %s (199)\n", *((uint32_t*)&fp2), _ftostr(buf, fp2));
+ var_sint = -4711;
+ fp1 = var_sint;
+ var_uint = 42000;
+ fp2 = var_uint;
+ printf("fp1 0x%08lx [] %s (-4711)\n", *((uint32_t*)&fp1), _ftostr(buf, fp1));
+ printf("fp2 0x%08lx [] %s (42000)\n", *((uint32_t*)&fp2), _ftostr(buf, fp2));
+ var_slong = -4711456;
+ fp1 = var_slong;
+ var_ulong = 42000456;
+ fp2 = var_ulong;
+ printf("fp1 0x%08lx [] %s (-4711456)\n", *((uint32_t*)&fp1), _ftostr(buf, fp1));
+ printf("fp2 0x%08lx [] %s (42000456)\n", *((uint32_t*)&fp2), _ftostr(buf, fp2));
+#ifdef CONIO
+ cgetc();
+#endif
+#endif
+
+ printf("conversions (float variable to integer)\n");
+ fp1 = -12.3f;
+ var_schar = (signed char)fp1;
+ printf("fp1 0x%08lx %s (12.3) schar:%d (12)\n", *((uint32_t*)&fp1), _ftostr(buf, fp1), (int)var_schar);
+ fp2 = 19.9f;
+ var_uchar = (unsigned char)fp2;
+ printf("fp2 0x%08lx %s (19.9) uchar:%u (19)\n", *((uint32_t*)&fp2), _ftostr(buf, fp2), (int)var_uchar);
+
+ fp1 = 1234.5f;
+ var_sint = (signed short)fp1;
+ printf("fp1 0x%08lx %s (1234.5) sint:%d (1234)\n", *((uint32_t*)&fp1), _ftostr(buf, fp1), var_sint);
+ fp2 = 1999.9f;
+ var_uint = (unsigned short)fp2;
+ printf("fp2 0x%08lx %s (1999.9) uint:%u (1999)\n", *((uint32_t*)&fp2), _ftostr(buf, fp2), var_uint);
+
+ fp1 = 123456.5f;
+ var_slong = (signed long)fp1;
+ printf("fp1 0x%08lx %s (1234.5) slong:%ld (1234)\n", *((uint32_t*)&fp1), _ftostr(buf, fp1), var_slong);
+ fp2 = 199988.9f;
+ var_ulong = (unsigned long)fp2;
+ printf("fp2 0x%08lx %s (1999.9) ulong:%lu (1999)\n", *((uint32_t*)&fp2), _ftostr(buf, fp2), var_ulong);
+
+#if 1
+ printf("multiplication, variable * variable\n");
+ fp1 = 25.2f;
+ fp2 = 2.3f;
+ fp3 = fp1 * fp2;
+ printf("%s*%s=%s\n", _ftostr(buf, fp1), _ftostr(buf2, fp2), _ftostr(buf3, fp3));
+#endif
+
+#if 1
+ printf("division, variable / variable\n");
+ fp1 = 25.2f;
+ fp2 = 2.3f;
+ fp3 = fp1 / fp2;
+ printf("%s/%s=%s\n", _ftostr(buf, fp1), _ftostr(buf2, fp2), _ftostr(buf3, fp3));
+#endif
+
+// FIXME: does not compile
+#if 0
+ fp1 = (fp2 == 2.5f) ? 1.5f : 0.5f;
+#endif
+
+ // NOT
+ printf("binary negate (not)\n");
+ fp1 = 12.6f;
+ fp2 = !fp1;
+ var_sint = !fp1;
+ fp3 = !fp2;
+ printf("fp2 0x%08lx [] %s () %d\n", *((uint32_t*)&fp2), _ftostr(buf, fp2), var_sint);
+ printf("fp3 0x%08lx [] %s ()\n", *((uint32_t*)&fp3), _ftostr(buf, fp3));
+
+ fp1 = -12.6f;
+ fp1 = 0.0f - fp1;
+ fp2 = !fp1;
+ var_sint = !fp1;
+ fp3 = !fp2;
+ printf("fp2 0x%08lx [] %s () %d\n", *((uint32_t*)&fp2), _ftostr(buf, fp2), var_sint);
+ printf("fp2 0x%08lx [] %s ()\n", *((uint32_t*)&fp2), _ftostr(buf, fp2));
+ printf("fp3 0x%08lx [] %s ()\n", *((uint32_t*)&fp3), _ftostr(buf, fp3));
+
+
+ return 0;
+}
diff --git a/test/float/float-cbm..c b/test/float/float-cbm..c
new file mode 100644
index 000000000..77b39e3a9
--- /dev/null
+++ b/test/float/float-cbm..c
@@ -0,0 +1,138 @@
+
+#ifdef __CC65__
+#include
+#endif
+
+#include
+#include
+#include
+
+#include
+#include
+
+#include
+
+char strbuf[0x20];
+char strbuf2[0x20];
+char strbuf3[0x20];
+
+
+
+typedef union {
+ float f;
+ unsigned char b[sizeof (float)];
+} U;
+
+#ifdef __CC65__
+uint32_t ftobin(float f)
+#else
+unsigned long ftobin(float f)
+#endif
+{
+ U u;
+ u.f = f;
+#ifdef __CC65__
+ return ((uint32_t)u.b[0] << 0) | ((uint32_t)u.b[1] << 8) | ((uint32_t)u.b[2] << 16) | ((uint32_t)u.b[3] << 24);
+#else
+ return ((uint32_t)u.b[3] << 0) | ((uint32_t)u.b[2] << 8) | ((uint32_t)u.b[1] << 16) | ((uint32_t)u.b[0] << 24);
+#endif
+}
+
+float fd, fs;
+float a, b, c1;
+int c, i, t;
+int n;
+
+void testconversions(void)
+{
+ printf("\ntestconversions:\n\n");
+ printf("ftobin(0x12345678):0x%08lx\n", ftobin((float)0x12345678));
+
+ /* 42 ieee754: 0x42280000 */
+ b=_ctof(42);
+ printf("b:0x%08lx ", ftobin(b));
+ n=(int)((float)0x42280000);
+ printf("n:%d\n", n);
+
+ b=_ctof(42);
+ printf("b:0x%08lx ", ftobin(b));
+ n=(int)(b);
+ printf("n:%d\n", n);
+
+ b=_utof(42);
+ printf("b:0x%08lx ", ftobin(b));
+ n=(int)(b);
+ printf("n:%d\n", n);
+
+ b=_stof(1234);
+ printf("b:0x%08lx ", ftobin(b));
+ n=(int)(b);
+ printf("n:%d\n", n);
+
+ b=(float)(1234);
+ printf("b:0x%08lx ", ftobin(b));
+ n=(int)(b);
+ printf("n:%d\n", n);
+
+ b=atof("1234");
+ printf("b:0x%08lx ", ftobin(b));
+ n=(int)(b);
+ printf("n:%d\n", n);
+
+ _ftoa(strbuf, b);
+ printf("s:%s\n", strbuf);
+
+ printf("a:%s\n", _ftostr(strbuf, (float)(1234)));
+
+ printf("a:%s b:%s c:%s\n",
+ _ftostr(strbuf, (float)(1234)),
+ _ftostr(strbuf2, (float)(5678)),
+ _ftostr(strbuf3, (float)(9012))
+ );
+#ifdef __CC65__
+ cgetc();
+#endif
+}
+
+void testlogical(void)
+{
+ printf("\ntestlogical:\n\n");
+ a = (float)(0xffa5);
+ b = (float)(0x5aff);
+ printf("a:0x%08lx (0xffa5)\n", ftobin(a));
+ printf("b:0x%08lx (0x5aff)\n", ftobin(b));
+ c1 = _fand(a, b);
+ printf("c1:0x%08lx\n", ftobin(c1));
+ n=(int)(c1);
+ printf("c1:%04x\n", n);
+#ifdef __CC65__
+ cgetc();
+#endif
+}
+
+
+#define _fcmplt(_d, _s) (_fcmp((_d), (_s)) == 1)
+#define _fcmpgt(_d, _s) (_fcmp((_d), (_s)) == 255)
+#define _fcmpeq(_d, _s) (_fcmp((_d), (_s)) == 0)
+
+void testcompare(void)
+{
+ printf("\ntestcompare:\n\n");
+ a=(float)(2);
+ b=(float)(3);
+ printf("cmp 2,3: %3d %d %d %d\n", fcmp(a, b), fcmpgt(a, b), fcmpeq(a, b), fcmplt(a, b));
+ printf("cmp 3,2: %3d %d %d %d\n", fcmp(b, a), fcmpgt(b, a), fcmpeq(b, a), fcmplt(b, a));
+ printf("cmp 2,2: %3d %d %d %d\n", fcmp(a, a), fcmpgt(a, a), fcmpeq(a, a), fcmplt(a, a));
+#ifdef __CC65__
+ cgetc();
+#endif
+}
+
+int main(void)
+{
+ printf("sizeof (float): %d\n", (int)sizeof(float));
+ testconversions();
+ testlogical();
+ testcompare();
+ return EXIT_SUCCESS;
+}
diff --git a/test/float/float-minimal.c b/test/float/float-minimal.c
new file mode 100644
index 000000000..2f2bc93c3
--- /dev/null
+++ b/test/float/float-minimal.c
@@ -0,0 +1,160 @@
+
+// test minimal float support.
+// this should test everything that does NOT require linking a library
+// - float literals in code are recognized as such
+// - float variables are converted into the float binary format
+// - taking address from float and assigning via pointer works
+
+#ifdef CONIO
+#include
+#endif
+
+#include
+#include
+#include
+
+#include <_float.h>
+
+float fp1 = 42.01002f;
+float fp2; // non initialized
+float *fp_p; // non initialized
+
+uintptr_t p;
+
+float fp3;
+float fp4 = 23.12f;
+
+char buf[0x10];
+
+signed char var_schar;
+unsigned char var_uchar;
+signed int var_sint;
+unsigned int var_uint;
+signed long var_slong;
+unsigned long var_ulong;
+
+int main(void)
+{
+ float fp2 = 23.1234f;
+
+ printf("float-minimal\n");
+
+ printf("fp2:0x%08lx [0x41b8f5c3] %s (23.1234)\n", *((uint32_t*)&fp2), _ftostr(buf, fp2));
+ printf("fp4:0x%08lx [0x41b8f5c3] %s (23.12)\n", *((uint32_t*)&fp4), _ftostr(buf, fp4));
+#if 1
+ printf("(global) get address, read via ptr\n");
+ // get address of global (works)
+ p = (uintptr_t)&fp1;
+ fp_p = (float*)p;
+ // read fp via pointer and assign local
+ fp2 = *fp_p;
+
+ printf("fp1:0x%08lx [0x42280a43] %s (42.01002)\n", *((uint32_t*)&fp1), _ftostr(buf, fp1));
+ printf("fp2:0x%08lx [0x42280a43] %s (42.01002)\n", *((uint32_t*)&fp2), _ftostr(buf, fp2));
+#endif
+#if 1
+ printf("(local) get address, read via ptr\n");
+ fp2 = 23.1234f;
+
+ // get address of local
+ p = (uintptr_t)&fp2;
+ fp_p = (float*)p;
+ // read fp via pointer and assign global
+ fp3 = *fp_p;
+
+ printf("fp2:0x%08lx [] %s (23.1234)\n", *((uint32_t*)&fp2), _ftostr(buf, fp2));
+ printf("fp3:0x%08lx [] %s (23.1234)\n", *((uint32_t*)&fp3), _ftostr(buf, fp3));
+#endif
+ // addition
+#if 1
+ printf("constant + constant\n");
+ fp1 = 0.1f;
+ fp2 = 0.2f;
+ printf(" 0x%08lx [] %s (0.1)\n", *((uint32_t*)&fp1), _ftostr(buf, fp1));
+ printf(" 0x%08lx [] %s (0.2)\n", *((uint32_t*)&fp2), _ftostr(buf, fp2));
+
+ fp3 = 0.1f + 0.2f;
+ printf("fp3:0x%08lx [] %s (0.3)\n", *((uint32_t*)&fp3), _ftostr(buf, fp3));
+#endif
+ // substraction
+#if 0
+ printf("constant - constant\n");
+ fp1 = 0.1f;
+ fp2 = 0.2f;
+ fp3 = 0.1f - 0.2f; //FIXME: Invalid operands for binary operator '-'
+
+ printf(" 0x%08lx [] %s (0.1)\n", *((uint32_t*)&fp1), _ftostr(buf, fp1));
+ printf(" 0x%08lx [] %s (0.2)\n", *((uint32_t*)&fp2), _ftostr(buf, fp2));
+ printf("fp3:0x%08lx [] %s (0.3)\n", *((uint32_t*)&fp3), _ftostr(buf, fp3));
+#endif
+ // multiplication
+#if 0
+ printf("constant * constant\n");
+ fp1 = 0.1f;
+ fp2 = 0.2f;
+ fp3 = 0.1f * 0.2f; // FIXME: Precondition violated: IsClassInt (T), file 'cc65/datatype.c', line 1008
+
+ printf(" 0x%08lx [] %s (0.1)\n", *((uint32_t*)&fp1), _ftostr(buf, fp1));
+ printf(" 0x%08lx [] %s (0.2)\n", *((uint32_t*)&fp2), _ftostr(buf, fp2));
+ printf("fp3:0x%08lx [] %s (0.3)\n", *((uint32_t*)&fp3), _ftostr(buf, fp3));
+#endif
+
+ // division
+#if 0
+ printf("constant / constant\n");
+ fp1 = 0.1f;
+ fp2 = 0.2f;
+ fp3 = 0.1f / 0.2f; // FIXME: Precondition violated: IsClassInt (T), file 'cc65/datatype.c', line 1008
+
+ printf(" 0x%08lx [] %s (0.1)\n", *((uint32_t*)&fp1), _ftostr(buf, fp1));
+ printf(" 0x%08lx [] %s (0.2)\n", *((uint32_t*)&fp2), _ftostr(buf, fp2));
+ printf("fp3:0x%08lx [] %s (0.3)\n", *((uint32_t*)&fp3), _ftostr(buf, fp3));
+#endif
+#ifdef CONIO
+ cgetc();
+#endif
+
+ // comparisons
+#if 1
+ /* FIXME: this does not work yet */
+ printf("0.1f == 0.1f is "); if (0.1f == 0.1f) { printf("true\n"); } else { printf("false\n"); }
+ printf("0.2f == 0.1f is "); if (0.2f == 0.1f) { printf("true\n"); } else { printf("false\n"); }
+ printf("0.1f != 0.1f is "); if (0.1f != 0.1f) { printf("true\n"); } else { printf("false\n"); }
+ printf("0.2f != 0.1f is "); if (0.2f != 0.1f) { printf("true\n"); } else { printf("false\n"); }
+#endif
+
+#ifdef CONIO
+ cgetc();
+#endif
+
+ // conversions
+#if 1
+ printf("conversions (integer constant to float)\n");
+ fp1 = -12;
+ fp2 = 199;
+ printf("fp1 0x%08lx [] %s (-12)\n", *((uint32_t*)&fp1), _ftostr(buf, fp1));
+ printf("fp2 0x%08lx [] %s (199)\n", *((uint32_t*)&fp2), _ftostr(buf, fp2));
+ fp1 = -4711;
+ fp2 = 42000;
+ printf("fp1 0x%08lx [] %s (-4711)\n", *((uint32_t*)&fp1), _ftostr(buf, fp1));
+ printf("fp2 0x%08lx [] %s (42000)\n", *((uint32_t*)&fp2), _ftostr(buf, fp2));
+#endif
+#if 1
+ printf("conversions (float constant to integer)\n");
+ var_schar = (signed char)12.3f;
+ printf("%s (12.3) schar:%d (12)\n", _ftostr(buf, 12.3f), (int)var_schar);
+ var_uchar = (unsigned char)19.9f;
+ printf("%s (19.9) uchar:%u (19)\n", _ftostr(buf, 19.9f), (int)var_uchar);
+
+ var_sint = (signed short)1234.5f;
+ printf("%s (1234.5) sint:%d (1234)\n", _ftostr(buf, 1234.5f), var_sint);
+ var_uint = (unsigned short)1999.9f;
+ printf("%s (1999.9) uint:%u (1999)\n", _ftostr(buf, 1999.9f), var_uint);
+
+ var_slong = (signed long)123456.5f;
+ printf("%s (123456.5f) slong:%ld (123456)\n", _ftostr(buf, 123456.5f), var_slong);
+ var_ulong = (unsigned long)199988.9f;
+ printf("%s (199988.9) ulong:%lu (199988)\n", _ftostr(buf, 199988.9f), var_ulong);
+#endif
+ return 0;
+}
diff --git a/test/float/floattest.c b/test/float/floattest.c
new file mode 100644
index 000000000..f70a64f8f
--- /dev/null
+++ b/test/float/floattest.c
@@ -0,0 +1,350 @@
+
+#ifdef __CC65__
+#include
+#endif
+
+#include
+#include
+#include
+
+#include <_float.h>
+#include
+
+char strbuf[0x20];
+char strbuf2[0x20];
+char strbuf3[0x20];
+
+
+
+typedef union {
+ float f;
+ unsigned char b[sizeof (float)];
+} U;
+
+#ifdef __CC65__
+uint32_t ftobin(float f)
+#else
+unsigned long ftobin(float f)
+#endif
+{
+ U u;
+ u.f = f;
+#ifdef __CC65__
+ return ((uint32_t)u.b[0] << 0) | ((uint32_t)u.b[1] << 8) | ((uint32_t)u.b[2] << 16) | ((uint32_t)u.b[3] << 24);
+#else
+ return ((uint32_t)u.b[3] << 0) | ((uint32_t)u.b[2] << 8) | ((uint32_t)u.b[1] << 16) | ((uint32_t)u.b[0] << 24);
+#endif
+}
+
+float fd, fs;
+float a, b, c1;
+int c, i, t;
+int n;
+
+void csetpoint8(unsigned char x)
+{
+ while(x--) {
+ printf(" ");
+ }
+ printf("*\n");
+}
+
+#define YNUM 32
+#define YNUM2 16
+
+#define XNUM 32
+#define XNUM2 16
+
+void calcsin(void)
+{
+ printf("sinus:\n");
+ for(i = 0; i < YNUM; i++) {
+ csetpoint8(XNUM2+((int)(sinf(deg2rad((float)(i),(float)(YNUM))) * (float)(YNUM2))/(YNUM/XNUM)));
+ }
+}
+
+void calccos(void)
+{
+ printf("cosinus:\n");
+ for(i = 0; i < YNUM; i++) {
+ fs=deg2rad((float)(i),(float)(YNUM));
+ fd=cosf(fs) * (float)(YNUM2);
+ csetpoint8(XNUM2+((int)(fd)/(YNUM/XNUM)));
+ }
+}
+
+#ifdef __CC65__
+
+int fx, fy;
+
+#define CYNUM 20
+#define CYNUM2 10
+
+#define CXNUM 20
+#define CXNUM2 10
+
+void cplot(unsigned char x, unsigned char y)
+{
+ gotoxy(x,y);cputc('*');
+}
+
+void testatan2(void)
+{
+ for(i = 0; i < YNUM; i++) {
+ fx = CXNUM2+((int)((sinf(deg2rad((float)(i),(float)(CYNUM)))*(float)(CYNUM2)))/(CYNUM/CXNUM));
+
+ fs = deg2rad((float)(i), (float)(CYNUM));
+ fd = cosf(fs) * (float)(CYNUM2);
+ fy = CXNUM2 + ((int)(fd) / (CYNUM/CXNUM));
+
+ cplot(fx, fy);
+ fd = fatan2((float)(fx-CXNUM2), (float)(fy-CYNUM2));
+ _ftostr(strbuf, fd);
+ cputs(strbuf);
+ }
+}
+#endif
+
+#if 0
+void calcpoly1(void){
+
+ p=malloc(sizeof(fpoly)+((1+3)*sizeof(float)));
+ p.exponent=3;
+
+// _strtof(&(p->coffs[3]),"0.25");
+// _strtof(&(p->coffs[2]),"1");
+// _strtof(&(p->coffs[1]),"-0.5");
+// _strtof(&(p->coffs[0]),"0.25");
+
+// _ftostr(&strbuf,&(p->coffs[3])); printf("a0:%s\n",strbuf);
+// _ftostr(&strbuf,&(p->coffs[2])); printf("a1:%s\n",strbuf);
+// _ftostr(&strbuf,&(p->coffs[1])); printf("a2:%s\n",strbuf);
+// _ftostr(&strbuf,&(p->coffs[0])); printf("a3:%s\n",strbuf);
+
+// _fpoly1(&fd,&p,&_f_pi);
+// _ftostr(&strbuf,&fd); printf("x:%s\n",strbuf);
+
+ for(i=0;i<256;i++){
+ fs=_(float)(i);
+ _ftostr(&strbuf,fs); printf("%s:",strbuf);
+ fd=_fpoly1(&p,&fs);
+ _ftostr(&strbuf,fd); printf("%s\n",strbuf);
+// c=_(int)(&fd);
+// csetpoint8(i/(256/35),12+(c/(256/23)));
+ }
+
+ free(p);
+}
+#endif
+
+unsigned short var_bs;
+unsigned short var_fs;
+float var_i;
+unsigned char var_w;
+unsigned char var_j;
+float var_k;
+unsigned short var_co;
+
+void f1(void)
+{
+ printf("i:0x%08lx\n",ftobin(_ctof(0)));
+
+#if 0
+ printf("exp mantissa sign\n");
+ printf("%02x ",*(unsigned char*)(1024+(40*2)+0));
+ printf("%02x ",*(unsigned char*)(1024+(40*2)+1));
+ printf("%02x ",*(unsigned char*)(1024+(40*2)+2));
+ printf("%02x ",*(unsigned char*)(1024+(40*2)+3));
+ printf("%02x ",*(unsigned char*)(1024+(40*2)+4));
+ printf("%02x ",*(unsigned char*)(1024+(40*2)+5));
+#endif
+
+ var_bs=1024;
+ var_fs=55304;
+
+// var_i=_(float)(var_bs);while(1)
+ var_i=(float)(2);while(1)
+ {
+ printf("i:%d\n",(int)(var_i));
+ var_bs++;if(var_bs==1030)break;
+
+#if 0
+ if(FCMPGT(0x00028000,U16TOF(0)))
+ {
+ if (FCMPGTEQ(var_i,(U16TOF(var_bs+1000)))) break;
+ }
+ else if(FCMPLT(0x00028000,U16TOF(0)))
+ {
+ if (FCMPLTEQ(var_i,(U16TOF(var_bs+1000)))) break;
+ }
+#endif
+// var_i=var_i + 0x00028000;
+ var_i=var_i + 0x00818000; // FIXME: float value?
+// var_i=var_i + _ctof(1);
+ };
+#ifdef __CC65__
+ cgetc();
+#endif
+}
+
+
+void testbinary(void)
+{
+ printf("\ntestbinary:\n\n");
+ n= 5;b=(float)(n);printf("%d:0x%08lx\n", n, ftobin(b));
+ n=-5;b=(float)(n);printf("%d:0x%08lx\n", n, ftobin(b));
+ n= 2;b=(float)(n);printf("%d:0x%08lx\n", n, ftobin(b));
+ n= 3;b=(float)(n);printf("%d:0x%08lx\n", n, ftobin(b));
+#ifdef __CC65__
+ cgetc();
+#endif
+}
+
+void testbasicmath(void)
+{
+ printf("\ntestbasicmath:\n\n");
+ t=123;
+ fd=(float)((int)t);
+ fs=_fneg(fd);
+ _ftostr(strbuf,fd);
+ printf("123:%s\n",strbuf);
+ _ftostr(strbuf,fs);
+ printf("-123:%s\n",strbuf);
+
+ a = (float)(4321);
+ b = (float)(1234);
+ printf("4321:0x%08lx\n", ftobin(a));
+ printf("1234:0x%08lx\n", ftobin(b));
+ c1 = a + b;
+ printf("4321+1234:0x%08lx\n", ftobin(c1));
+ _ftoa(strbuf, c1);
+ printf("4321+1234:%s\n", strbuf);
+
+ a = (float)(1111);
+ b = (float)(2222);
+ printf("1111:0x%08lx\n", ftobin(a));
+ printf("2222:0x%08lx\n", ftobin(b));
+ c1 = a - b;
+ printf("1111-2222:0x%08lx\n", ftobin(c1));
+ _ftoa(strbuf, c1);
+ printf("1111-2222:%s\n", strbuf);
+
+ fd=(float)((int)t);
+ fs=(float)((int)2);
+ fd=fd / fs;
+ _ftostr(strbuf,fd);
+ printf("t:%s\n",strbuf);
+
+ // 1234 / 60 = 20,5666...
+ t=1234;
+ fd=(float)((int)t);
+ fs=(float)((int)60);
+ fd=fd / fs;
+ _ftostr(strbuf,fd);
+ printf("t:%s\n",strbuf);
+
+ // 5678 / 60 = 94,6333...
+ t=5678;
+ fd=(float)((int)t);
+ fs=(float)((int)60);
+ fd=fd / fs;
+ _ftostr(strbuf,fd);
+ printf("t:%s\n",strbuf);
+
+ // ! operator DOES work on floats!
+ fd=(float)((int)4);
+ fd=!fd;
+ _ftostr(strbuf,!fd);
+ printf("!!4:%s\n",strbuf);
+
+ fd=(float)((int)0);
+ fd=!fd;
+ _ftostr(strbuf,!fd);
+ printf("!!0:%s\n",strbuf);
+
+ a = 10.0f;
+ b = powf(a,(float)(1)); printf("0x%08lx %s\n", ftobin(b), _ftoa(strbuf,b));
+ b = powf(a,(float)(2)); printf("0x%08lx %s\n", ftobin(b), _ftoa(strbuf,b));
+ b = powf(a,(float)(3)); printf("0x%08lx %s\n", ftobin(b), _ftoa(strbuf,b));
+#ifdef __CC65__
+ cgetc();
+#endif
+}
+
+#define fcmp(_d, _s) (((_d) < (_s)) ? 1 : (((_d) > (_s)) ? 255 : (0)))
+#define fcmplt(_d, _s) ((_d) < (_s))
+#define fcmpgt(_d, _s) ((_d) > (_s))
+#define fcmpeq(_d, _s) ((_d) == (_s))
+
+void testcompare(void)
+{
+ printf("\ntestcompare:\n\n");
+ a=(float)(2);
+ b=(float)(3);
+ printf("cmp 2,3: %3d %d %d %d\n", fcmp(a, b), fcmpgt(a, b), fcmpeq(a, b), fcmplt(a, b));
+ printf("cmp 3,2: %3d %d %d %d\n", fcmp(b, a), fcmpgt(b, a), fcmpeq(b, a), fcmplt(b, a));
+ printf("cmp 2,2: %3d %d %d %d\n", fcmp(a, a), fcmpgt(a, a), fcmpeq(a, a), fcmplt(a, a));
+#ifdef __CC65__
+ cgetc();
+#endif
+}
+
+
+void testprinting(void)
+{
+ printf("\ntestprinting:\n\n");
+ a = 1.0f;
+ b = (a / 10.0f); printf("0x%08lx %s %s\n", ftobin(b), _ftostr(strbuf, b), _ftoa(strbuf2, b));
+ b = (a / 100.0f); printf("0x%08lx %s %s\n", ftobin(b), _ftostr(strbuf, b), _ftoa(strbuf2, b));
+ b = (a / 1000.0f); printf("0x%08lx %s %s\n", ftobin(b), _ftostr(strbuf, b), _ftoa(strbuf2, b));
+ b = (a / 10000.0f); printf("0x%08lx %s %s\n", ftobin(b), _ftostr(strbuf, b), _ftoa(strbuf2, b));
+// printf("\n");
+ a = 2.0f;
+ b = (a / 10.0f); printf("0x%08lx %s %s\n", ftobin(b), _ftostr(strbuf, b), _ftoa(strbuf2, b));
+ b = (a / 100.0f); printf("0x%08lx %s %s\n", ftobin(b), _ftostr(strbuf, b), _ftoa(strbuf2, b));
+ b = (a / 1000.0f); printf("0x%08lx %s %s\n", ftobin(b), _ftostr(strbuf, b), _ftoa(strbuf2, b));
+ b = (a / 10000.0f); printf("0x%08lx %s %s\n", ftobin(b), _ftostr(strbuf, b), _ftoa(strbuf2, b));
+// printf("\n");
+ a = 400000000.0f;
+ b = (a * 10.0f); printf("0x%08lx %s %s\n", ftobin(b), _ftostr(strbuf, b), _ftoa(strbuf2, b));
+ b = (a * 100.0f); printf("0x%08lx %s %s\n", ftobin(b), _ftostr(strbuf, b), _ftoa(strbuf2, b));
+ b = (a * 1000.0f); printf("0x%08lx %s %s\n", ftobin(b), _ftostr(strbuf, b), _ftoa(strbuf2, b));
+ b = (a * 10000.0f); printf("0x%08lx %s %s\n", ftobin(b), _ftostr(strbuf, b), _ftoa(strbuf2, b));
+// printf("\n");
+ a = -2.0f;
+ b = (a / 10.0f); printf("0x%08lx %s %s\n", ftobin(b), _ftostr(strbuf, b), _ftoa(strbuf2, b));
+ b = (a / 100.0f); printf("0x%08lx %s %s\n", ftobin(b), _ftostr(strbuf, b), _ftoa(strbuf2, b));
+ b = (a / 1000.0f); printf("0x%08lx %s %s\n", ftobin(b), _ftostr(strbuf, b), _ftoa(strbuf2, b));
+ b = (a / 10000.0f); printf("0x%08lx %s %s\n", ftobin(b), _ftostr(strbuf, b), _ftoa(strbuf2, b));
+// printf("\n");
+ a = -400000000.0f;
+ b = (a * 10.0f); printf("0x%08lx %s %s\n", ftobin(b), _ftostr(strbuf, b), _ftoa(strbuf2, b));
+ b = (a * 100.0f); printf("0x%08lx %s %s\n", ftobin(b), _ftostr(strbuf, b), _ftoa(strbuf2, b));
+ b = (a * 1000.0f); printf("0x%08lx %s %s\n", ftobin(b), _ftostr(strbuf, b), _ftoa(strbuf2, b));
+ b = (a * 10000.0f); printf("0x%08lx %s %s\n", ftobin(b), _ftostr(strbuf, b), _ftoa(strbuf2, b));
+#ifdef __CC65__
+ cgetc();
+#endif
+}
+
+int main(void)
+{
+ printf("sizeof (float): %d\n", (int)sizeof(float));
+
+ testbasicmath();
+// testlogical();
+ testbinary();
+ testcompare();
+ testprinting();
+#if 0
+ f1();
+
+ calcsin();
+ calccos();
+ testatan2(); // FIXME
+#endif
+#if 0
+ calcpoly1();
+#endif
+ return EXIT_SUCCESS;
+}
diff --git a/test/float/gccstubs.c b/test/float/gccstubs.c
new file mode 100644
index 000000000..8acc0d7f6
--- /dev/null
+++ b/test/float/gccstubs.c
@@ -0,0 +1,49 @@
+
+#include
+#include
+#include
+
+float _fneg(float f)
+{
+ return f * -1.0f;
+}
+
+float _fand(float f1, float f2)
+{
+ return ((unsigned)f1) & ((unsigned)f2);
+}
+
+char buffer[32];
+
+char *_ftostr(char *d, float s)
+{
+ if (d == NULL) {
+ d = &buffer[0];
+ }
+ sprintf(d, "%f", (double)s);
+ return d;
+}
+
+char *_ftoa(char *d, float s)
+{
+ if (d == NULL) {
+ d = &buffer[0];
+ }
+ sprintf(d, "%f", (double)s);
+ return d;
+}
+
+float _ctof(char c)
+{
+ return (float)c;
+}
+
+float _utof(unsigned int c)
+{
+ return (float)c;
+}
+
+float _stof(signed int c)
+{
+ return (float)c;
+}
diff --git a/test/float/ieee754/_ftostr.c b/test/float/ieee754/_ftostr.c
new file mode 100644
index 000000000..48640f180
--- /dev/null
+++ b/test/float/ieee754/_ftostr.c
@@ -0,0 +1,97 @@
+
+#include
+#include
+
+char buffer[32];
+
+char * __fastcall__ _ftostr(char *d, float s)
+{
+ float f;
+ unsigned char *p;
+ char *bp, *buf;
+ int exp;
+ unsigned long mantissa;
+ unsigned long val;
+ int sign;
+ unsigned char n;
+ static char digits[10]={0,1,2,3,4,5,6,7,8,9};
+
+ unsigned long mantissa_mod = 1000000000;
+ unsigned long mantissa_rest;
+
+ if (d == NULL) {
+ buf = bp = &buffer[0];
+ } else {
+ buf = bp = d;
+ }
+
+ f = s;
+ p = (unsigned char*)&f;
+
+// printf("%02x %02x %02x %02x\n", p[3], p[2], p[1], p[0]);
+
+ sign = (p[3] & 0x80) ? 1 : 0;
+ exp = ((p[3] << 1) & 0xfe) | ((p[2] >> 7) & 1);
+ exp -= 127;
+ mantissa = p[2] & 0x7f;
+ mantissa <<=8;
+ mantissa |= p[1];
+ mantissa <<=8;
+ mantissa |= p[0];
+
+ *bp++ = sign ? '-' : ' ';
+
+ *bp++ = '1';
+ *bp++ = '.';
+
+ val = 0xff;
+// printf("mantissa: %ld\n", mantissa);
+ mantissa_rest = mantissa;
+ for (n = 0; n < 10; n++) {
+// printf("n:%2d rest:%ld mod:%ld\n", n, mantissa_rest, mantissa_mod);
+ if ((mantissa_mod <= mantissa_rest) && (mantissa_rest > 0)) {
+ val = mantissa_rest / mantissa_mod;
+// printf("n:%2d val:%ld\n", n, val);
+// *bp++ = digits[(int)val];
+ *bp++ = '0' + val;
+ mantissa_rest -= (val * mantissa_mod);
+ }
+ mantissa_mod /= 10;
+ }
+ if (val == 0xff) {
+ *bp++ = '0';
+ }
+
+// *bp++ = 'e';
+// *bp++ = 0;
+ *bp++ = '*';
+ *bp++ = '2';
+ *bp++ = '^';
+
+// printf("exp: %ld\n", exp);
+ mantissa_mod = 1000;
+ if (exp < 0) {
+ mantissa_rest = -1 * exp;
+ *bp++ = '-';
+ } else {
+ mantissa_rest = exp;
+ }
+ val = 0xff;
+ for (n = 0; n < 10; n++) {
+// printf("n:%2d rest:%ld mod:%ld\n", n, mantissa_rest, mantissa_mod);
+ if ((mantissa_mod <= mantissa_rest) && (mantissa_rest > 0)) {
+ val = mantissa_rest / mantissa_mod;
+// printf("n:%2d val:%ld\n", n, val);
+// *bp++ = digits[(int)val];
+ *bp++ = '0' + val;
+ mantissa_rest -= (val * mantissa_mod);
+ }
+ mantissa_mod /= 10;
+ }
+ if (val == 0xff) {
+ *bp++ = '0';
+ }
+ *bp++ = 0;
+
+ return buf;
+}
diff --git a/test/float/ieee754/afloat.s b/test/float/ieee754/afloat.s
new file mode 100644
index 000000000..d88ccbb26
--- /dev/null
+++ b/test/float/ieee754/afloat.s
@@ -0,0 +1,7 @@
+
+ .include "ieee754.inc"
+
+ .export afloat
+afloat:
+ ; FIXME
+ rts
diff --git a/test/float/ieee754/aufloat.s b/test/float/ieee754/aufloat.s
new file mode 100644
index 000000000..f8bd735f4
--- /dev/null
+++ b/test/float/ieee754/aufloat.s
@@ -0,0 +1,7 @@
+
+ .include "ieee754.inc"
+
+ .export aufloat
+aufloat:
+ ; FIXME
+ rts
diff --git a/test/float/ieee754/axfloat.s b/test/float/ieee754/axfloat.s
new file mode 100644
index 000000000..3af00ab8c
--- /dev/null
+++ b/test/float/ieee754/axfloat.s
@@ -0,0 +1,7 @@
+
+ .include "ieee754.inc"
+
+ .export axfloat
+axfloat:
+ ; FIXME
+ rts
diff --git a/test/float/ieee754/axufloat.s b/test/float/ieee754/axufloat.s
new file mode 100644
index 000000000..7aaea0e3b
--- /dev/null
+++ b/test/float/ieee754/axufloat.s
@@ -0,0 +1,7 @@
+
+ .include "ieee754.inc"
+
+ .export axufloat
+axufloat:
+ ; FIXME
+ rts
diff --git a/test/float/ieee754/eaxfloat.s b/test/float/ieee754/eaxfloat.s
new file mode 100644
index 000000000..3c91178e1
--- /dev/null
+++ b/test/float/ieee754/eaxfloat.s
@@ -0,0 +1,7 @@
+
+ .include "ieee754.inc"
+
+ .export eaxfloat
+eaxfloat:
+ ; FIXME
+ rts
diff --git a/test/float/ieee754/eaxufloat.s b/test/float/ieee754/eaxufloat.s
new file mode 100644
index 000000000..d03f471cc
--- /dev/null
+++ b/test/float/ieee754/eaxufloat.s
@@ -0,0 +1,7 @@
+
+ .include "ieee754.inc"
+
+ .export eaxufloat
+eaxufloat:
+ ; FIXME
+ rts
diff --git a/test/float/ieee754/fbnegeax.s b/test/float/ieee754/fbnegeax.s
new file mode 100644
index 000000000..bc88e6548
--- /dev/null
+++ b/test/float/ieee754/fbnegeax.s
@@ -0,0 +1,7 @@
+
+ .include "ieee754.inc"
+
+ .export fbnegeax
+fbnegeax:
+ ; FIXME
+ rts
diff --git a/test/float/ieee754/feaxint.s b/test/float/ieee754/feaxint.s
new file mode 100644
index 000000000..9b6f63888
--- /dev/null
+++ b/test/float/ieee754/feaxint.s
@@ -0,0 +1,8 @@
+
+ .include "ieee754.inc"
+
+; float -> 16bit int
+ .export feaxint
+feaxint:
+ ; FIXME
+ rts
diff --git a/test/float/ieee754/feaxlong.s b/test/float/ieee754/feaxlong.s
new file mode 100644
index 000000000..4d6138dc5
--- /dev/null
+++ b/test/float/ieee754/feaxlong.s
@@ -0,0 +1,8 @@
+
+ .include "ieee754.inc"
+
+; float -> 32bit long
+ .export feaxlong
+feaxlong:
+ ; FIXME
+ rts
diff --git a/test/float/ieee754/ftosaddeax.s b/test/float/ieee754/ftosaddeax.s
new file mode 100644
index 000000000..9b766a34b
--- /dev/null
+++ b/test/float/ieee754/ftosaddeax.s
@@ -0,0 +1,637 @@
+
+ .include "ieee754.inc"
+
+ .importzp sp, sreg, tmp1
+ .import addysp1
+ .import addysp
+ .import popax
+
+; Primary = TOS + Primary (like tosaddeax)
+ .export ftosaddeax
+;ftosaddeax:
+ ; FIXME
+; rts
+
+; CC65 runtime: long add
+
+; ; EAX = TOS + EAX
+;
+; ;tosadd0ax:
+; ldy #$00
+; sty sreg
+; sty sreg+1
+;
+; ;tosaddeax:
+; clc
+; ldy #0
+; adc (sp),y ; lo byte
+; iny
+;
+; sta tmp1 ; use as temp storage
+; txa
+; adc (sp),y ; byte 1
+; tax
+; iny
+;
+; lda sreg
+; adc (sp),y ; byte 2
+; sta sreg
+; iny
+;
+; lda sreg+1
+; adc (sp),y ; byte 3
+; sta sreg+1
+; lda tmp1 ; load byte 0
+; jmp addysp1 ; drop TOS
+
+
+; found at https://github.com/CrashAndSideburns/6502ieee754/blob/main/arithmetic/addition.s
+
+;addition:
+ftosaddeax:
+ ; arg0: a/x/sreg/sreg+1
+ ; arg1: (sp),y (y=0..3)
+
+ lda #0
+ sta SIGN_ONE
+ sta SIGN_TWO
+
+ ; Pull 2 LSBs of second parameter off of stack.
+ pha
+ lda sreg+1
+ ASL
+ STA MANTISSA_TWO + 3
+ lda sreg+0
+ ROL
+ STA MANTISSA_TWO + 2
+
+ ; Pull MSB of mantissa off of stack and shift exponent LSB into carry.
+ tax
+ ROL
+ STA MANTISSA_TWO + 1
+
+ ; Pull MSB off of stack, shift in exponent LSB, store sign.
+ PLA
+ ROL
+ STA EXPONENT_TWO
+ ROL SIGN_TWO
+
+ ;-----------------
+
+ ; Pull 2 LSBs of first parameter off of stack.
+ ldy #0
+ lda (sp),y ; lsb
+ ASL
+ STA MANTISSA_ONE + 3
+ iny
+ lda (sp),y
+ ROL
+ STA MANTISSA_ONE + 2
+
+ ; Pull MSB of mantissa off of stack and shift exponent LSB into carry.
+ iny
+ lda (sp),y
+ ROL
+ STA MANTISSA_ONE + 1
+
+ ; Pull MSB off of stack, shift in exponent LSB, store sign.
+ iny
+ lda (sp),y ; msb
+ ROL
+ STA EXPONENT_ONE
+ ROL SIGN_ONE
+
+
+ ; Add implicit 1 to mantissas if appropriate.
+@add_second_implicit_bit:
+ LDA EXPONENT_TWO
+ CMP #$00
+ BEQ @add_first_implicit_bit
+ SEC
+ ROR MANTISSA_TWO + 1
+ ROR MANTISSA_TWO + 2
+ ROR MANTISSA_TWO + 3
+
+@add_first_implicit_bit:
+ LDA EXPONENT_ONE
+ CMP #$00
+ BEQ @manage_special_values
+ SEC
+ ROR MANTISSA_ONE + 1
+ ROR MANTISSA_ONE + 2
+ ROR MANTISSA_ONE + 3
+
+@manage_special_values:
+ ; Check if first parameter has exponent #$ff.
+ ; If it does, first parameter is some special quantity.
+ ; If not, check if second parameter has epxonent #$ff.
+ ; If it does, then it is special and the first parameter is not, so propagate.
+ ; If neither parameter is special, move on to aligning mantissas.
+ LDA EXPONENT_ONE
+ CMP #$ff
+ BEQ @first_parameter_special
+ LDA EXPONENT_TWO
+ CMP #$ff
+ BEQ @propagate_second_parameter
+ JMP @align_mantissas
+
+@first_parameter_special:
+ ; Exponent is non-zero, so an implicit 1 has been added to mantissa.
+ ; Unless the mantissa with added implicit 1 is $800000, return first param.
+ ; If the mantissa is precisely $800000, first param is ±∞.
+ LDA MANTISSA_ONE + 1
+ CMP #$80
+ BNE @propagate_first_parameter
+ LDA MANTISSA_ONE + 2
+ CMP #$00
+ BNE @propagate_first_parameter
+ LDA MANTISSA_ONE + 3
+ CMP #$00
+ BEQ @first_parameter_infinite
+
+@propagate_first_parameter:
+ ; Shift out implicit bit, shift exponent and sign through.
+ ; Push return value onto stack.
+ ; Push return address onto stack.
+ ; Return from subroutine.
+ ASL MANTISSA_ONE + 1
+ LSR SIGN_ONE
+ ROR EXPONENT_ONE
+ ROR MANTISSA_ONE + 1
+
+; LDA EXPONENT_ONE
+; PHA
+; LDA MANTISSA_ONE + 1
+; PHA
+; LDA MANTISSA_ONE + 2
+; PHA
+; LDA MANTISSA_ONE + 3
+; PHA
+
+; LDA $01
+; PHA
+; LDA $00
+; PHA
+
+ LDA EXPONENT_ONE
+ sta sreg+1
+ LDA MANTISSA_ONE + 1
+ sta sreg+0
+ LDX MANTISSA_ONE + 2
+ LDA MANTISSA_ONE + 3
+; ldx #$43
+; lda #$21
+ jmp addysp1 ; drop TOS
+
+ RTS
+
+@first_parameter_infinite:
+ ; Check if second parameter is also ±∞.
+ ; If second param is not special, propagate infinity.
+ ; If second param is NaN, propagate NaN.
+ LDA EXPONENT_TWO
+ CMP #$ff
+ BNE @propagate_first_parameter
+ LDA MANTISSA_TWO + 1
+ CMP #$80
+ BNE @propagate_second_parameter
+ LDA MANTISSA_TWO + 2
+ CMP #$00
+ BNE @propagate_second_parameter
+ LDA MANTISSA_TWO + 3
+ CMP #$00
+ BNE @propagate_second_parameter
+
+@adding_infinities:
+ ; First and second parameters are both ±∞.
+ ; Check if they have opposite sign.
+ ; (+∞)+(-∞) = (-∞)+(+∞) = NaN.
+ ; If they have opposite sign, return a NaN.
+ ; Otherwise, return the first parameter.
+ LDA SIGN_ONE
+ EOR SIGN_TWO
+ BEQ @propagate_first_parameter
+; LDA #$ff
+; PHA
+; PHA
+; PHA
+; PHA
+
+ LDA #$ff
+ sta sreg+1
+ sta sreg
+ tax
+ jmp addysp1 ; drop TOS
+
+; LDA $01
+; PHA
+; LDA $00
+; PHA
+
+ RTS
+
+@propagate_second_parameter:
+ ; Shift out implicit bit, shift exponent and sign through.
+ ; Push return value onto stack.
+ ; Push return address onto stack.
+ ; Return from subroutine.
+ ASL MANTISSA_TWO + 1
+ LSR SIGN_TWO
+ ROR EXPONENT_TWO
+ ROR MANTISSA_TWO + 1
+
+; LDA EXPONENT_TWO
+; PHA
+; LDA MANTISSA_TWO + 1
+; PHA
+; LDA MANTISSA_TWO + 2
+; PHA
+; LDA MANTISSA_TWO + 3
+; PHA
+
+; LDA $01
+; PHA
+; LDA $00
+; PHA
+
+ LDA EXPONENT_TWO
+ sta sreg+1
+ LDA MANTISSA_TWO + 1
+ sta sreg
+ LDX MANTISSA_TWO + 2
+ LDA MANTISSA_TWO + 3
+ jmp addysp1 ; drop TOS
+
+ RTS
+
+@align_mantissas:
+ ; Check if the mantissas differ by 25 or more.
+ ; If they do, propagate the parameter with the larger mantissa.
+ ; If they don't, shift the mantissa of the smaller parameter right.
+ SEC
+ LDA EXPONENT_TWO
+ SBC EXPONENT_ONE
+ BCC @first_difference_underflow
+ CMP #25
+ BCS @propagate_second_parameter
+@first_difference_underflow:
+ SEC
+ LDA EXPONENT_ONE
+ SBC EXPONENT_TWO
+ BCC @second_difference_underflow
+ CMP #25
+ BCS @propagate_first_parameter
+@second_difference_underflow:
+ CMP #$00
+ BEQ @apply_signs
+ TAX
+ BPL @shift_second_mantissa
+@shift_first_mantissa:
+ LSR MANTISSA_ONE + 1
+ ROR MANTISSA_ONE + 2
+ ROR MANTISSA_ONE + 3
+ ROR MANTISSA_ONE + 4
+ ROR MANTISSA_ONE + 5
+ ROR MANTISSA_ONE + 6
+ INX
+ CPX #$00
+ BNE @shift_first_mantissa
+
+ LDA EXPONENT_TWO
+ STA EXPONENT_ONE
+ JMP @apply_signs
+@shift_second_mantissa:
+ LSR MANTISSA_TWO + 1
+ ROR MANTISSA_TWO + 2
+ ROR MANTISSA_TWO + 3
+ ROR MANTISSA_TWO + 4
+ ROR MANTISSA_TWO + 5
+ ROR MANTISSA_TWO + 6
+ DEX
+ CPX #$00
+ BNE @shift_second_mantissa
+
+@apply_signs:
+ ; Check the signs of both floats.
+ ; If a float has a 1 sign bit, take the 2's complement of the mantissa.
+@negate_first_mantissa:
+ LDA SIGN_ONE
+ CMP #$00
+ BEQ @negate_second_mantissa
+ LDA MANTISSA_ONE
+ EOR #$ff
+ STA MANTISSA_ONE
+ LDA MANTISSA_ONE + 1
+ EOR #$ff
+ STA MANTISSA_ONE + 1
+ LDA MANTISSA_ONE + 2
+ EOR #$ff
+ STA MANTISSA_ONE + 2
+ LDA MANTISSA_ONE + 3
+ EOR #$ff
+ STA MANTISSA_ONE + 3
+ LDA MANTISSA_ONE + 4
+ EOR #$ff
+ STA MANTISSA_ONE + 4
+ LDA MANTISSA_ONE + 5
+ EOR #$ff
+ STA MANTISSA_ONE + 5
+ LDA MANTISSA_ONE + 6
+ EOR #$ff
+ CLC
+ ADC #$01
+ STA MANTISSA_ONE + 6
+ LDA MANTISSA_ONE + 5
+ ADC #$00
+ STA MANTISSA_ONE + 5
+ LDA MANTISSA_ONE + 4
+ ADC #$00
+ STA MANTISSA_ONE + 4
+ LDA MANTISSA_ONE + 3
+ ADC #$00
+ STA MANTISSA_ONE + 3
+ LDA MANTISSA_ONE + 2
+ ADC #$00
+ STA MANTISSA_ONE + 2
+ LDA MANTISSA_ONE + 1
+ ADC #$00
+ STA MANTISSA_ONE + 1
+ LDA MANTISSA_ONE
+ ADC #$00
+ STA MANTISSA_ONE
+@negate_second_mantissa:
+ LDA SIGN_TWO
+ CMP #$00
+ BEQ @sum_mantissas
+ LDA MANTISSA_TWO
+ EOR #$ff
+ STA MANTISSA_TWO
+ LDA MANTISSA_TWO + 1
+ EOR #$ff
+ STA MANTISSA_TWO + 1
+ LDA MANTISSA_TWO + 2
+ EOR #$ff
+ STA MANTISSA_TWO + 2
+ LDA MANTISSA_TWO + 3
+ EOR #$ff
+ STA MANTISSA_TWO + 3
+ LDA MANTISSA_TWO + 4
+ EOR #$ff
+ STA MANTISSA_TWO + 4
+ LDA MANTISSA_TWO + 5
+ EOR #$ff
+ STA MANTISSA_TWO + 5
+ LDA MANTISSA_TWO + 6
+ EOR #$ff
+ CLC
+ ADC #$01
+ STA MANTISSA_TWO + 6
+ LDA MANTISSA_TWO + 5
+ ADC #$00
+ STA MANTISSA_TWO + 5
+ LDA MANTISSA_TWO + 4
+ ADC #$00
+ STA MANTISSA_TWO + 4
+ LDA MANTISSA_TWO + 3
+ ADC #$00
+ STA MANTISSA_TWO + 3
+ LDA MANTISSA_TWO + 2
+ ADC #$00
+ STA MANTISSA_TWO + 2
+ LDA MANTISSA_TWO + 1
+ ADC #$00
+ STA MANTISSA_TWO + 1
+ LDA MANTISSA_TWO
+ ADC #$00
+ STA MANTISSA_TWO
+
+@sum_mantissas:
+ ; Sum the mantissas to obtain the mantissa of the return float.
+ ; Check if the resultant mantissa has a 1 MSB.
+ ; If it does, set the result sign to 1 and take the 2's complement of the mantissa.
+ ; If it doesn't, move on to normalising the resultant mantissa.
+ CLC
+ LDA MANTISSA_ONE + 6
+ ADC MANTISSA_TWO + 6
+ STA MANTISSA_ONE + 6
+ LDA MANTISSA_ONE + 5
+ ADC MANTISSA_TWO + 5
+ STA MANTISSA_ONE + 5
+ LDA MANTISSA_ONE + 4
+ ADC MANTISSA_TWO + 4
+ STA MANTISSA_ONE + 4
+ LDA MANTISSA_ONE + 3
+ ADC MANTISSA_TWO + 3
+ STA MANTISSA_ONE + 3
+ LDA MANTISSA_ONE + 2
+ ADC MANTISSA_TWO + 2
+ STA MANTISSA_ONE + 2
+ LDA MANTISSA_ONE + 1
+ ADC MANTISSA_TWO + 1
+ STA MANTISSA_ONE + 1
+ LDA MANTISSA_ONE
+ ADC MANTISSA_TWO
+ STA MANTISSA_ONE
+
+ AND #$80
+ CMP #$00
+ BEQ @positive_sum
+
+ LDA MANTISSA_ONE
+ EOR #$ff
+ STA MANTISSA_ONE
+ LDA MANTISSA_ONE + 1
+ EOR #$ff
+ STA MANTISSA_ONE + 1
+ LDA MANTISSA_ONE + 2
+ EOR #$ff
+ STA MANTISSA_ONE + 2
+ LDA MANTISSA_ONE + 3
+ EOR #$ff
+ STA MANTISSA_ONE + 3
+ LDA MANTISSA_ONE + 4
+ EOR #$ff
+ STA MANTISSA_ONE + 4
+ LDA MANTISSA_ONE + 5
+ EOR #$ff
+ STA MANTISSA_ONE + 5
+ LDA MANTISSA_ONE + 6
+ EOR #$ff
+ CLC
+ ADC #$01
+ STA MANTISSA_ONE + 6
+ LDA MANTISSA_ONE + 5
+ ADC #$00
+ STA MANTISSA_ONE + 5
+ LDA MANTISSA_ONE + 4
+ ADC #$00
+ STA MANTISSA_ONE + 4
+ LDA MANTISSA_ONE + 3
+ ADC #$00
+ STA MANTISSA_ONE + 3
+ LDA MANTISSA_ONE + 2
+ ADC #$00
+ STA MANTISSA_ONE + 2
+ LDA MANTISSA_ONE + 1
+ ADC #$00
+ STA MANTISSA_ONE + 1
+ LDA MANTISSA_ONE
+ ADC #$00
+ STA MANTISSA_ONE
+ LDA #$01
+ STA SIGN_ONE
+ JMP @normalise_mantissa
+@positive_sum:
+ LDA #$00
+ STA SIGN_ONE
+
+@normalise_mantissa:
+ ; Now that the new mantissa has been computed, normalise it.
+ ; Check if the LSB of the byte before the MSB of the mantissa is 1.
+ ; If it is, shift the mantissa down and increment the mantissa.
+ ; If it isn't, move on to checking if we must shift left.
+ LDA MANTISSA_ONE
+ AND #$01
+ CMP #$01
+ BNE @no_overflow
+ LSR MANTISSA_ONE
+ ROR MANTISSA_ONE + 1
+ ROR MANTISSA_ONE + 2
+ ROR MANTISSA_ONE + 3
+ ROR MANTISSA_ONE + 4
+ ROR MANTISSA_ONE + 5
+ ROR MANTISSA_ONE + 6
+ INC EXPONENT_ONE
+ JMP @round
+
+@no_overflow:
+ ; Check if the MSB of the mantissa is 1.
+ ; If it is, move on to rounding.
+ ; If it isn't, shift mantissa left and decrement exponent until MSB is 1 or exponent is 0.
+ LDA MANTISSA_ONE + 1
+ AND #$80
+ CMP #$80
+ BEQ @round
+ LDA EXPONENT_ONE
+ CMP #$00
+ BEQ @round
+ ASL MANTISSA_ONE + 6
+ ROL MANTISSA_ONE + 5
+ ROL MANTISSA_ONE + 4
+ ROL MANTISSA_ONE + 3
+ ROL MANTISSA_ONE + 2
+ ROL MANTISSA_ONE + 1
+ ROL MANTISSA_ONE
+ DEC EXPONENT_ONE
+ JMP @no_overflow
+
+@round:
+ ; Check if we have already produced ±∞ in the event that we decide not to round.
+ ; If we have, return ±∞.
+ ; If we haven't, check if the MSB of the byte after the mantissa is 0.
+ ; If it is, return, trucating the subsequent bits.
+ ; If it isn't, check if any subsequent bits are 1.
+ ; If any are, round up.
+ ; If none are, check if the LSB of the mantissa is 1.
+ ; If it is, round up.
+ ; If it isn't, return.
+ LDA EXPONENT_ONE
+ CMP #$ff
+ BEQ @return_infinity
+ LDA MANTISSA_ONE + 4
+ AND #$80
+ CMP #$00
+ BEQ @return
+ LDA MANTISSA_ONE + 4
+ AND #$7f
+ CMP #$00
+ BNE @round_up
+ LDA MANTISSA_ONE + 5
+ CMP #$00
+ BNE @round_up
+ LDA MANTISSA_ONE + 6
+ CMP #$00
+ BNE @round_up
+ LDA MANTISSA_ONE + 3
+ AND #$01
+ CMP #$00
+ BEQ @return
+
+@round_up:
+ ; Increment the mantissa by 1.
+ ; If the increment doesn't overflow, return.
+ ; If it does, shift the mantissa right and increment the exponent.
+ ; Check if incrementing the exponent left us with an exponent of #$ff.
+ ; If it did, return ±∞.
+ ; If it didn't, round again.
+ CLC
+ LDA MANTISSA_ONE + 3
+ ADC #$01
+ STA MANTISSA_ONE + 3
+ LDA MANTISSA_ONE + 2
+ ADC #$00
+ STA MANTISSA_ONE + 2
+ LDA MANTISSA_ONE + 1
+ ADC #$00
+ STA MANTISSA_ONE + 1
+ BCC @return
+ ROL MANTISSA_ONE + 1
+ ROL MANTISSA_ONE + 2
+ ROL MANTISSA_ONE + 3
+ ROL MANTISSA_ONE + 4
+ ROL MANTISSA_ONE + 5
+ ROL MANTISSA_ONE + 6
+ INC EXPONENT_ONE
+ LDA EXPONENT_ONE
+ CMP #$ff
+ BEQ @return_infinity
+ JMP @round
+
+@return_infinity:
+ ; If we have to return ±∞ due to an over/underflow, clear the mantissa.
+ LDA #$00
+ STA MANTISSA_ONE + 1
+ STA MANTISSA_ONE + 2
+ STA MANTISSA_ONE + 3
+@return:
+ ; Shift out implicit bit, shift exponent and sign through.
+ ; Push return value onto stack.
+ ; Push return address onto stack.
+ ; Return from subroutine.
+ LDA EXPONENT_ONE
+ CMP #$00
+ BNE @return_normal
+ LSR MANTISSA_ONE + 1
+ ROR MANTISSA_ONE + 2
+ ROR MANTISSA_ONE + 3
+ BCS @round_up
+@return_normal:
+ ASL MANTISSA_ONE + 1
+ LSR SIGN_ONE
+ ROR EXPONENT_ONE
+ ROR MANTISSA_ONE + 1
+
+; LDA EXPONENT_ONE
+; PHA
+; LDA MANTISSA_ONE + 1
+; PHA
+; LDA MANTISSA_ONE + 2
+; PHA
+; LDA MANTISSA_ONE + 3
+; PHA
+
+; LDA $01
+; PHA
+; LDA $00
+; PHA
+
+ LDA EXPONENT_ONE
+ sta sreg+1
+ LDA MANTISSA_ONE + 1
+ sta sreg
+ LDX MANTISSA_ONE + 2
+ LDA MANTISSA_ONE + 3
+ jmp addysp1 ; drop TOS
+
+ RTS
+
diff --git a/test/float/ieee754/ftosdiveax.s b/test/float/ieee754/ftosdiveax.s
new file mode 100644
index 000000000..7a9793448
--- /dev/null
+++ b/test/float/ieee754/ftosdiveax.s
@@ -0,0 +1,12 @@
+
+ .include "ieee754.inc"
+
+ .importzp sp, sreg, tmp1
+ .import addysp1
+ .import addysp
+ .import popax
+
+ .export ftosdiveax
+ftosdiveax:
+ ; FIXME
+ rts
diff --git a/test/float/ieee754/ftoseqeax.s b/test/float/ieee754/ftoseqeax.s
new file mode 100644
index 000000000..2d0cb2a71
--- /dev/null
+++ b/test/float/ieee754/ftoseqeax.s
@@ -0,0 +1,8 @@
+ .include "ieee754.inc"
+
+ .export ftoseqeax
+ftoseqeax:
+ ; FIXME
+ lda #0
+ tax
+ rts
diff --git a/test/float/ieee754/ftosgeeax.s b/test/float/ieee754/ftosgeeax.s
new file mode 100644
index 000000000..f0651e61b
--- /dev/null
+++ b/test/float/ieee754/ftosgeeax.s
@@ -0,0 +1,8 @@
+ .include "ieee754.inc"
+
+ .export ftosgeeax
+ftosgeeax:
+ ; FIXME
+ lda #0
+ tax
+ rts
diff --git a/test/float/ieee754/ftosgteax.s b/test/float/ieee754/ftosgteax.s
new file mode 100644
index 000000000..8857911b3
--- /dev/null
+++ b/test/float/ieee754/ftosgteax.s
@@ -0,0 +1,8 @@
+ .include "ieee754.inc"
+
+ .export ftosgteax
+ftosgteax:
+ ; FIXME
+ lda #0
+ tax
+ rts
diff --git a/test/float/ieee754/ftosleeax.s b/test/float/ieee754/ftosleeax.s
new file mode 100644
index 000000000..fe719560a
--- /dev/null
+++ b/test/float/ieee754/ftosleeax.s
@@ -0,0 +1,8 @@
+ .include "ieee754.inc"
+
+ .export ftosleeax
+ftosleeax:
+ ; FIXME
+ lda #0
+ tax
+ rts
diff --git a/test/float/ieee754/ftoslteax.s b/test/float/ieee754/ftoslteax.s
new file mode 100644
index 000000000..39fbb50d1
--- /dev/null
+++ b/test/float/ieee754/ftoslteax.s
@@ -0,0 +1,8 @@
+ .include "ieee754.inc"
+
+ .export ftoslteax
+ftoslteax:
+ ; FIXME
+ lda #0
+ tax
+ rts
diff --git a/test/float/ieee754/ftosmuleax.s b/test/float/ieee754/ftosmuleax.s
new file mode 100644
index 000000000..cf22d6d86
--- /dev/null
+++ b/test/float/ieee754/ftosmuleax.s
@@ -0,0 +1,12 @@
+
+ .include "ieee754.inc"
+
+ .importzp sp, sreg, tmp1
+ .import addysp1
+ .import addysp
+ .import popax
+
+ .export ftosmuleax
+ftosmuleax:
+ ; FIXME
+ rts
diff --git a/test/float/ieee754/ftosneeax.s b/test/float/ieee754/ftosneeax.s
new file mode 100644
index 000000000..9026c9b6d
--- /dev/null
+++ b/test/float/ieee754/ftosneeax.s
@@ -0,0 +1,8 @@
+ .include "ieee754.inc"
+
+ .export ftosneeax
+ftosneeax:
+ ; FIXME
+ lda #0
+ tax
+ rts
diff --git a/test/float/ieee754/ftossubeax.s b/test/float/ieee754/ftossubeax.s
new file mode 100644
index 000000000..6c7167f53
--- /dev/null
+++ b/test/float/ieee754/ftossubeax.s
@@ -0,0 +1,43 @@
+
+ .importzp sp, sreg, tmp1
+ .import addysp1
+ .import addysp
+ .import popax
+
+ .include "ieee754.inc"
+
+ .import ftosaddeax
+
+ .export ftossubeax
+ftossubeax:
+ ; FIXME
+ rts
+
+; found at https://github.com/CrashAndSideburns/6502ieee754/blob/main/arithmetic/addition.s
+; subtraction:
+
+ ; Pull MSB of second parameter off of stack, flip sign bit, and push back to stack.
+ ; Proceed to addition.
+; TSX
+; TXA
+; CLC
+; ADC #$05
+; TAX
+; TXS
+; PLA
+; EOR #$80
+; PHA
+; TXA
+; SEC
+; SBC #$05
+; TAX
+; TXS
+
+ pha
+ ldy #3
+ lda (sp),y ; msb
+ eor #$80
+ sta (sp),y ; msb
+ pla
+
+ jmp ftosaddeax
diff --git a/test/float/ieee754/ieee754.inc b/test/float/ieee754/ieee754.inc
new file mode 100644
index 000000000..76a8b69b1
--- /dev/null
+++ b/test/float/ieee754/ieee754.inc
@@ -0,0 +1,7 @@
+SIGN_ONE = $e2
+EXPONENT_ONE = $e3
+MANTISSA_ONE = $e4 ; e4, e5, e6, e7, e8, e9, ea (7 bytes)
+
+SIGN_TWO = $eb
+EXPONENT_TWO = $ec
+MANTISSA_TWO = $ed
diff --git a/test/float/include/_float.h b/test/float/include/_float.h
new file mode 100644
index 000000000..e490a8b9e
--- /dev/null
+++ b/test/float/include/_float.h
@@ -0,0 +1,54 @@
+
+#ifndef _FLOAT_H_
+#define _FLOAT_H_
+
+/* ieee754 32bit format:
+ *
+ * sign
+ * / /exponent/mantissa
+ * 3 32222222 22211111111110000000000
+ * 1 09876543 21098765432109876543210
+ *
+ * The sign is stored in bit 31.
+ * The exponent can be computed from bits 23-30 by subtracting 127. (128 = 2^1)
+ * The mantissa is stored in bits 0-22.
+ * An invisible leading bit (i.e. it is not actually stored) with value 1.0
+ * is placed in front, then bit 23 has a value of 1/2, bit 22 has value 1/4 etc.
+ * As a result, the mantissa has a value between 1.0 and 2.
+ *
+ * 1.0 = exp=127, mantissa=0
+ *
+ * If the exponent reaches -127 (binary 00000000), the leading 1 is no longer
+ * used to enable gradual underflow.
+ *
+ */
+typedef struct {
+ unsigned char exponent; /* msb is the sign */
+ unsigned char mantissa[3]; /* msb is lsb of exponent */
+} FLOAT754;
+
+/* we dont wanna seriously use double precision eh? ;=P */
+/* #define double float */
+
+/* string to/from float conversion functions */
+char *_ftoa(char *buf, float n);
+
+/* string conversion functions, these use the exponential form */
+char * __fastcall__ _ftostr(char *d, float s); /* for vsprintf */
+float __fastcall__ _strtof(char *d);
+
+/* beware, this is not standard */
+#ifndef M_PI
+#define M_PI 3.14159265358979323846f
+#endif
+
+/* degrees to radiants */
+#define deg2rad(_fs, _n) ((_fs / _n) * (2.0f * M_PI))
+/* radiants to degrees deg = (rad / (2 * pi)) * 256 */
+#define rad2deg(_rad, _n) ((_rad / (2.0f * M_PI)) * _n)
+
+/* resets fp-libs in Turbo-C and M$-C */
+#define _fpreset()
+
+#endif /* _FLOAT_H_ */
+
diff --git a/test/float/include/math.h b/test/float/include/math.h
new file mode 100644
index 000000000..e888a0a22
--- /dev/null
+++ b/test/float/include/math.h
@@ -0,0 +1,46 @@
+
+#ifndef _MATH_H_
+#define _MATH_H_
+
+#include "_float.h"
+
+/* double pow(double x, double y); */
+float __fastcall__ powf(float f, float a); /* C99 */
+
+/* double sin(double x); */
+float __fastcall__ sinf(float s); /* C99 */
+
+/* double cos(double x); */
+float __fastcall__ cosf(float s); /* C99 */
+
+/* double log(double x); */
+float __fastcall__ logf(float x); /* C99 */
+
+/* double exp(double x); */
+float __fastcall__ expf(float x); /* C99 */
+
+/* double sqrt(double x); */
+float __fastcall__ sqrtf(float x); /* C99 */
+
+/* double tan(double x); */
+float __fastcall__ tanf(float x); /* C99 */
+
+/* double atan(double x); */
+float __fastcall__ atanf(float x); /* C99 */
+
+/* double fabs(double x); */
+float __fastcall__ fabsf(float x); /* C99 */
+
+/* beware, this is not standard */
+#ifndef M_PI
+#define M_PI 3.14159265358979323846f
+#endif
+
+/* FIXME */
+float __fastcall__ _fatan2(float x, float y);
+
+
+float ffloor(float x);
+
+#endif /* _MATH_H_ */
+
diff --git a/test/float/quick.c b/test/float/quick.c
new file mode 100644
index 000000000..83e1d10a2
--- /dev/null
+++ b/test/float/quick.c
@@ -0,0 +1,25 @@
+/*
+#include
+#include
+#include
+
+#include <_float.h>
+#include
+
+unsigned char buf[32];*/
+
+//unsigned char var_uchar;
+// float fp2;
+
+float fp1 = 42.0f;
+float fp2 = 23;
+float fp3 = 33.0;
+
+int main(void)
+{
+// fp2 = (float)((unsigned char)19);
+// var_uchar = (unsigned char)fp2;
+// var_uchar = (unsigned char)192.3f;
+// printf("fp2 0x%08lx %s (19.9) uchar:%u (19)\n", *((uint32_t*)&fp2), _ftostr(buf, fp2), (int)var_uchar);
+
+}
diff --git a/test/float/readme.md b/test/float/readme.md
new file mode 100644
index 000000000..802cbf97c
--- /dev/null
+++ b/test/float/readme.md
@@ -0,0 +1,196 @@
+
+## cc65 floating point support
+
+WARNING: the following is just a brain dump after a long weekend of hacking. it
+sure needs cleanup etc :)
+
+The current goal is to implement ieee754 support in the compiler, using the
+"float" datatype as the common 32bit float. ANYTHING ELSE COMES LATER
+
+You can not use any of this to write software yet. Dont bother. This is for
+people who want to help pushing the floating point support further.
+
+- build the compiler/toolchain/libs from this fptest branch
+- now you can build the programs in this directory
+
+right now you'll have to use the cbm kernal wrapper library, as that is pretty
+much the only one that somewhat works :)
+
+feel free to work on "real" ieee754 functions (see below)
+
+## The Compiler
+
+- for the time being i will handle and test only expressions where left and
+ right side are both floats. that will enable me to fix and test a fair portion
+ of what has to be done, before i will have to dive into the ugly areas of type
+ conversion and casting.
+
+NOT WORKING YET:
+
+- float values as in "12.34f" work, but "12.34" does not - should it?
+- compare, float const vs float const
+- substraction, float variable - float constant (compile error)
+- multiplication operator, float const * float const (compile error)
+- division operator, float const / float const
+
+- ternary operator (compile error)
+
+- addition, float constant + float variable (compiles but does not work)
+
+(and probably more :))
+
+TODO (much later):
+
+- add a cmdline option to the compiler to switch the float binary type (754, cbm,
+ woz, ...). -> remember the code in fp.c/h
+
+### Files & Functions
+
+#### codegen.c
+
+g_getimmed Load a constant into the primary register
+g_getstatic Fetch an static memory cell into the primary register
+g_getlocal Fetch specified local object (local var) into the primary register
+g_putstatic
+g_reglong
+g_regfloat Make sure, the value in the primary register a float. Convert if necessary
+g_typeadjust
+g_typecast Cast the value in the primary register to the operand size that is flagged by the lhs value
+oper Encode a binary operation.
+g_push
+g_push_float Push the primary register or a constant value onto the stack
+g_inc
+g_dec
+g_defdata
+g_defdata_float
+
+(see below) g_add, g_sub, g_mul, g_div, g_neg, g_bneg
+(see below) g_eq, g_ne, g_lt, g_gt, g_le, g_ge
+(invalid) g_mod, g_or, g_xor, g_and, g_asr
+
+#### datatype.c
+
+ArithmeticConvert
+
+#### expr.c
+
+LimitExprValue
+parseadd
+parsesub
+
+#### initdata.c
+
+DefineData Output a data definition for the given expression
+
+#### loadexpr.c
+
+LoadExpr
+
+#### locals.c
+
+ParseAutoDecl
+
+#### assignment.c
+
+OpAssignArithmetic Parse an "=" (if 'Gen' is 0) or "op=" operation for arithmetic lhs
+
+#### fp.c
+
+wrapper for doing floating point operations on target floats
+
+FP_D_As32bitRaw converts double into 32bit (float) and then returns its raw content as a 32bit int
+
+--------------------------------------------------------------------------------
+
+## The Library
+
+cbmkernal:
+
+this is a wrapper to the CBM kernal functions
+
+- this one is fairly complete and should be OK to use when fixing/adding basic
+ things in the compiler
+- the only missing functions are ftosrsubeax, fnegeax - which can be easily
+ added once testcode is found that actually triggers it :)
+
+ieee754:
+
+this should become a freestanding ieee754 library
+
+- basically everything missing except addition/substraction
+- compare functions are missing
+- mul, div functions are missing
+- type conversion functions are missing
+
+woz:
+
+historical float routines by woz :) unfortunately not ieee754
+
+- (optionally) converting from/to ieee754 format is missing (compile time option)
+- compare functions are missing
+- type conversion functions are missing
+
+--------------------------------------------------------------------------------
+
+### runtime functions
+
+these must be available in the runtime library
+
+func description cbmfp wozfp 754 codegen.c
+
+aufloat Primary 8bit unsigned -> float * - - g_regfloat
+afloat Primary 8bit signed -> float * - - g_regfloat
+axufloat Primary 16bit unsigned -> float * - - g_regfloat
+axfloat Primary 16bit signed -> float * - - g_regfloat
+eaxufloat Primary 32bit unsigned -> float * - - g_regfloat
+eaxfloat Primary 32bit signed -> float * - - g_regfloat
+
+feaxint Primary float -> 16bit int * - - g_regint
+feaxlong Primary float -> 32bit long * - - g_reglong
+
+ftosaddeax Primary = TOS + Primary * ? ? g_add
+ftossubeax Primary = TOS - Primary * ? ? g_sub
+ftosrsubeax Primary = Primary - TOS - - - g_rsub
+ftosmuleax Primary = TOS * Primary * ? - g_mul
+ftosdiveax Primary = TOS / Primary * ? - g_div
+
+fnegeax Primary = -Primary - - - g_neg
+fbnegeax Primary = !Primary (return bool!) * - - g_bneg
+
+ftosgeeax Test for greater than or equal to * - - g_ge
+ftosgteax Test for greater than * - - g_gt
+ftosleeax Test for less than or equal to * - - g_le
+ftoslteax Test for less than * - - g_lt
+ftosneeax Test for not equal * - - g_ne
+ftoseqeax Test for equal * - - g_eq
+
+### extra functions
+
+optional utility functions.
+
+func description cbmfp wozfp 754
+
+char *_ftostr(char *d, float s) * ? ? for printf family
+float _strtof(char *d) * - - for scanf family
+
+### math.h functions
+
+these are optional, required for standard libm
+
+func description cbmfp wozfp 754
+
+/* C99 */
+float powf(float f, float a); * - -
+float sinf(float s); * - -
+float cosf(float s); * - -
+float logf(float x); * * -
+float expf(float x); * - -
+float sqrtf(float x); * - -
+float tanf(float x); * - -
+float atanf(float x); * - -
+float fabsf(float x); * - -
+
+--------------------------------------------------------------------------------
+
+https://www.geeksforgeeks.org/ieee-standard-754-floating-point-numbers/
+https://www.h-schmidt.net/FloatConverter/IEEE754.html
diff --git a/test/float/woz/_ftostr.c b/test/float/woz/_ftostr.c
new file mode 100644
index 000000000..48640f180
--- /dev/null
+++ b/test/float/woz/_ftostr.c
@@ -0,0 +1,97 @@
+
+#include
+#include
+
+char buffer[32];
+
+char * __fastcall__ _ftostr(char *d, float s)
+{
+ float f;
+ unsigned char *p;
+ char *bp, *buf;
+ int exp;
+ unsigned long mantissa;
+ unsigned long val;
+ int sign;
+ unsigned char n;
+ static char digits[10]={0,1,2,3,4,5,6,7,8,9};
+
+ unsigned long mantissa_mod = 1000000000;
+ unsigned long mantissa_rest;
+
+ if (d == NULL) {
+ buf = bp = &buffer[0];
+ } else {
+ buf = bp = d;
+ }
+
+ f = s;
+ p = (unsigned char*)&f;
+
+// printf("%02x %02x %02x %02x\n", p[3], p[2], p[1], p[0]);
+
+ sign = (p[3] & 0x80) ? 1 : 0;
+ exp = ((p[3] << 1) & 0xfe) | ((p[2] >> 7) & 1);
+ exp -= 127;
+ mantissa = p[2] & 0x7f;
+ mantissa <<=8;
+ mantissa |= p[1];
+ mantissa <<=8;
+ mantissa |= p[0];
+
+ *bp++ = sign ? '-' : ' ';
+
+ *bp++ = '1';
+ *bp++ = '.';
+
+ val = 0xff;
+// printf("mantissa: %ld\n", mantissa);
+ mantissa_rest = mantissa;
+ for (n = 0; n < 10; n++) {
+// printf("n:%2d rest:%ld mod:%ld\n", n, mantissa_rest, mantissa_mod);
+ if ((mantissa_mod <= mantissa_rest) && (mantissa_rest > 0)) {
+ val = mantissa_rest / mantissa_mod;
+// printf("n:%2d val:%ld\n", n, val);
+// *bp++ = digits[(int)val];
+ *bp++ = '0' + val;
+ mantissa_rest -= (val * mantissa_mod);
+ }
+ mantissa_mod /= 10;
+ }
+ if (val == 0xff) {
+ *bp++ = '0';
+ }
+
+// *bp++ = 'e';
+// *bp++ = 0;
+ *bp++ = '*';
+ *bp++ = '2';
+ *bp++ = '^';
+
+// printf("exp: %ld\n", exp);
+ mantissa_mod = 1000;
+ if (exp < 0) {
+ mantissa_rest = -1 * exp;
+ *bp++ = '-';
+ } else {
+ mantissa_rest = exp;
+ }
+ val = 0xff;
+ for (n = 0; n < 10; n++) {
+// printf("n:%2d rest:%ld mod:%ld\n", n, mantissa_rest, mantissa_mod);
+ if ((mantissa_mod <= mantissa_rest) && (mantissa_rest > 0)) {
+ val = mantissa_rest / mantissa_mod;
+// printf("n:%2d val:%ld\n", n, val);
+// *bp++ = digits[(int)val];
+ *bp++ = '0' + val;
+ mantissa_rest -= (val * mantissa_mod);
+ }
+ mantissa_mod /= 10;
+ }
+ if (val == 0xff) {
+ *bp++ = '0';
+ }
+ *bp++ = 0;
+
+ return buf;
+}
diff --git a/test/float/woz/afloat.s b/test/float/woz/afloat.s
new file mode 100644
index 000000000..6d5d1e790
--- /dev/null
+++ b/test/float/woz/afloat.s
@@ -0,0 +1,7 @@
+
+ .include "wozfp.inc"
+
+ .export afloat
+afloat:
+ ; FIXME
+ rts
diff --git a/test/float/woz/aufloat.s b/test/float/woz/aufloat.s
new file mode 100644
index 000000000..fc8c33ae3
--- /dev/null
+++ b/test/float/woz/aufloat.s
@@ -0,0 +1,7 @@
+
+ .include "wozfp.inc"
+
+ .export aufloat
+aufloat:
+ ; FIXME
+ rts
diff --git a/test/float/woz/axfloat.s b/test/float/woz/axfloat.s
new file mode 100644
index 000000000..536d41d55
--- /dev/null
+++ b/test/float/woz/axfloat.s
@@ -0,0 +1,7 @@
+
+ .include "wozfp.inc"
+
+ .export axfloat
+axfloat:
+ ; FIXME
+ rts
diff --git a/test/float/woz/axufloat.s b/test/float/woz/axufloat.s
new file mode 100644
index 000000000..ba3c754fa
--- /dev/null
+++ b/test/float/woz/axufloat.s
@@ -0,0 +1,7 @@
+
+ .include "wozfp.inc"
+
+ .export axufloat
+axufloat:
+ ; FIXME
+ rts
diff --git a/test/float/woz/eaxfloat.s b/test/float/woz/eaxfloat.s
new file mode 100644
index 000000000..966483cb4
--- /dev/null
+++ b/test/float/woz/eaxfloat.s
@@ -0,0 +1,7 @@
+
+ .include "wozfp.inc"
+
+ .export eaxfloat
+eaxfloat:
+ ; FIXME
+ rts
diff --git a/test/float/woz/eaxufloat.s b/test/float/woz/eaxufloat.s
new file mode 100644
index 000000000..1c88f7977
--- /dev/null
+++ b/test/float/woz/eaxufloat.s
@@ -0,0 +1,7 @@
+
+ .include "wozfp.inc"
+
+ .export eaxufloat
+eaxufloat:
+ ; FIXME
+ rts
diff --git a/test/float/woz/fbnegeax.s b/test/float/woz/fbnegeax.s
new file mode 100644
index 000000000..d23935c6b
--- /dev/null
+++ b/test/float/woz/fbnegeax.s
@@ -0,0 +1,7 @@
+
+ .include "wozfp.inc"
+
+ .export fbnegeax
+fbnegeax:
+ ; FIXME
+ rts
diff --git a/test/float/woz/feaxint.s b/test/float/woz/feaxint.s
new file mode 100644
index 000000000..1dd777bf7
--- /dev/null
+++ b/test/float/woz/feaxint.s
@@ -0,0 +1,8 @@
+
+ .include "wozfp.inc"
+
+; float -> 16bit int
+ .export feaxint
+feaxint:
+ ; FIXME
+ rts
diff --git a/test/float/woz/feaxlong.s b/test/float/woz/feaxlong.s
new file mode 100644
index 000000000..99adb12ff
--- /dev/null
+++ b/test/float/woz/feaxlong.s
@@ -0,0 +1,8 @@
+
+ .include "wozfp.inc"
+
+; float -> 32bit long
+ .export feaxlong
+feaxlong:
+ ; FIXME
+ rts
diff --git a/test/float/woz/ftosaddeax.s b/test/float/woz/ftosaddeax.s
new file mode 100644
index 000000000..e37e60254
--- /dev/null
+++ b/test/float/woz/ftosaddeax.s
@@ -0,0 +1,9 @@
+
+ .include "wozfp.inc"
+
+ .export ftosaddeax
+ftosaddeax:
+ ; FIXME
+ lda #0
+ tax
+ rts
diff --git a/test/float/woz/ftosdiveax.s b/test/float/woz/ftosdiveax.s
new file mode 100644
index 000000000..9e45d992f
--- /dev/null
+++ b/test/float/woz/ftosdiveax.s
@@ -0,0 +1,9 @@
+
+ .include "wozfp.inc"
+
+ .export ftosdiveax
+ftosdiveax:
+ ; FIXME
+ lda #0
+ tax
+ rts
diff --git a/test/float/woz/ftoseqeax.s b/test/float/woz/ftoseqeax.s
new file mode 100644
index 000000000..8fc2d2a47
--- /dev/null
+++ b/test/float/woz/ftoseqeax.s
@@ -0,0 +1,8 @@
+ .include "wozfp.inc"
+
+ .export ftoseqeax
+ftoseqeax:
+ ; FIXME
+ lda #0
+ tax
+ rts
diff --git a/test/float/woz/ftosgeeax.s b/test/float/woz/ftosgeeax.s
new file mode 100644
index 000000000..3fce6f942
--- /dev/null
+++ b/test/float/woz/ftosgeeax.s
@@ -0,0 +1,8 @@
+ .include "wozfp.inc"
+
+ .export ftosgeeax
+ftosgeeax:
+ ; FIXME
+ lda #0
+ tax
+ rts
diff --git a/test/float/woz/ftosgteax.s b/test/float/woz/ftosgteax.s
new file mode 100644
index 000000000..f73c4a23c
--- /dev/null
+++ b/test/float/woz/ftosgteax.s
@@ -0,0 +1,8 @@
+ .include "wozfp.inc"
+
+ .export ftosgteax
+ftosgteax:
+ ; FIXME
+ lda #0
+ tax
+ rts
diff --git a/test/float/woz/ftosleeax.s b/test/float/woz/ftosleeax.s
new file mode 100644
index 000000000..f3b7030fe
--- /dev/null
+++ b/test/float/woz/ftosleeax.s
@@ -0,0 +1,8 @@
+ .include "wozfp.inc"
+
+ .export ftosleeax
+ftosleeax:
+ ; FIXME
+ lda #0
+ tax
+ rts
diff --git a/test/float/woz/ftoslteax.s b/test/float/woz/ftoslteax.s
new file mode 100644
index 000000000..5e6c26ac5
--- /dev/null
+++ b/test/float/woz/ftoslteax.s
@@ -0,0 +1,8 @@
+ .include "wozfp.inc"
+
+ .export ftoslteax
+ftoslteax:
+ ; FIXME
+ lda #0
+ tax
+ rts
diff --git a/test/float/woz/ftosmuleax.s b/test/float/woz/ftosmuleax.s
new file mode 100644
index 000000000..ea137065a
--- /dev/null
+++ b/test/float/woz/ftosmuleax.s
@@ -0,0 +1,9 @@
+
+ .include "wozfp.inc"
+
+ .export ftosmuleax
+ftosmuleax:
+ ; FIXME
+ lda #0
+ tax
+ rts
diff --git a/test/float/woz/ftosneeax.s b/test/float/woz/ftosneeax.s
new file mode 100644
index 000000000..faee42aa4
--- /dev/null
+++ b/test/float/woz/ftosneeax.s
@@ -0,0 +1,8 @@
+ .include "wozfp.inc"
+
+ .export ftosneeax
+ftosneeax:
+ ; FIXME
+ lda #0
+ tax
+ rts
diff --git a/test/float/woz/ftossubeax.s b/test/float/woz/ftossubeax.s
new file mode 100644
index 000000000..f66cb7386
--- /dev/null
+++ b/test/float/woz/ftossubeax.s
@@ -0,0 +1,8 @@
+ .include "wozfp.inc"
+
+ .export ftossubeax
+ftossubeax:
+ ; FIXME
+ lda #0
+ tax
+ rts
diff --git a/test/float/woz/wozfp.inc b/test/float/woz/wozfp.inc
new file mode 100644
index 000000000..d53ad5940
--- /dev/null
+++ b/test/float/woz/wozfp.inc
@@ -0,0 +1,16 @@
+; .org $40 ; SET BASE PAGE ADRESSES
+; SIGN = *
+
+ SIGN = $40
+
+ X2 = SIGN+1 ; EXPONENT 2
+ M2 = X2+1 ; MANTISSA 2
+ X1 = M2+3 ; EXPONENT 1
+ M1 = X1+1 ; MANTISSA 1
+ E = M1+3 ; SCRATCH
+ ZZ = E+4
+ T = ZZ+4
+ SEXP = T+4
+ INT = SEXP+4
+;
+
diff --git a/test/float/woz/wozfp.s b/test/float/woz/wozfp.s
new file mode 100644
index 000000000..60c145740
--- /dev/null
+++ b/test/float/woz/wozfp.s
@@ -0,0 +1,456 @@
+; JULY 5, 1976
+; BASIC FLOATING POINT ROUTINES
+; FOR 6502 MICROPROCESSOR
+; BY R. RANKIN AND S. WOZNIAK
+;
+; CONSISTING OF:
+; NATURAL LOG
+; COMMON LOG
+; EXPONENTIAL (E**X)
+; FLOAT FIX
+; FADD FSUB
+; FMUL FDIV
+;
+;
+; FLOATING POINT REPRESENTATION (4-BYTES)
+; EXPONENT BYTE 1
+; MANTISSA BYTES 2-4
+;
+; MANTISSA: TWO'S COMPLEMENT REPRESENTATION WITH SIGN IN
+; MSB OF HIGH-ORDER BYTE. MANTISSA IS NORMALIZED WITH AN
+; ASSUMED DECIMAL POINT BETWEEN BITS 5 AND 6 OF THE HIGH-ORDER
+; BYTE. THUS THE MANTISSA IS IN THE RANGE 1. TO 2. EXCEPT
+; WHEN THE NUMBER IS LESS THAN 2**(-128).
+;
+; EXPONENT: THE EXPONENT REPRESENTS POWERS OF TWO. THE
+; REPRESENTATION IS 2'S COMPLEMENT EXCEPT THAT THE SIGN
+; BIT (BIT 7) IS COMPLEMENTED. THIS ALLOWS DIRECT COMPARISON
+; OF EXPONENTS FOR SIZE SINCE THEY ARE STORED IN INCREASING
+; NUMERICAL SEQUENCE RANGING FROM $00 (-128) TO $FF (+127)
+; ($ MEANS NUMBER IS HEXADECIMAL).
+;
+; REPRESENTATION OF DECIMAL NUMBERS: THE PRESENT FLOATING
+; POINT REPRESENTATION ALLOWS DECIMAL NUMBERS IN THE APPROXIMATE
+; RANGE OF 10**(-38) THROUGH 10**(38) WITH 6 TO 7 SIGNIFICANT
+; DIGITS.
+;
+;
+
+ .include "wozfp.inc"
+
+; .org $1D00 ; STARTING LOCATION FOR LOG
+; .export WOZFP
+;WOZFP:
+;
+;
+; NATURAL LOG OF MANT/EXP1 WITH RESULT IN MANT/EXP1
+;
+LOG: LDA M1
+ BEQ ERROR
+ BPL CONT ; IF ARG>0 OK
+ERROR: BRK ; ERROR ARG<=0
+;
+CONT: JSR SWAP ; MOVE ARG TO EXP/MANT2
+ LDX #0 ; LOAD X FOR HIGH BYTE OF EXPONENT
+ LDA X2 ; HOLD EXPONENT
+ LDY #$80
+ STY X2 ; SET EXPONENT 2 TO 0 ($80)
+ EOR #$80 ; COMPLEMENT SIGN BIT OF ORIGINAL EXPONENT
+ STA M1+1 ; SET EXPONENT INTO MANTISSA 1 FOR FLOAT
+ BPL *+3 ; IS EXPONENT NEGATIVE
+ DEX ; YES, SET X TO $FF
+ STX M1 ; SET UPPER BYTE OF EXPONENT
+ JSR FLOAT ; CONVERT TO FLOATING POINT
+ LDX #3 ; 4 BYTE TRANSFERS
+SEXP1: LDA X2,X
+ STA ZZ,X ; COPY MANTISSA TO Z
+ LDA X1,X
+ STA SEXP,X ; SAVE EXPONENT IN SEXP
+ LDA R22,X ; LOAD EXP/MANT1 WITH SQRT(2)
+ STA X1,X
+ DEX
+ BPL SEXP1
+ JSR FSUB ; Z-SQRT(2)
+ LDX #3 ; 4 BYTE TRANSFER
+SAVET: LDA X1,X ; SAVE EXP/MANT1 AS T
+ STA T,X
+ LDA ZZ,X ; LOAD EXP/MANT1 WITH Z
+ STA X1,X
+ LDA R22,X ; LOAD EXP/MANT2 WITH SQRT(2)
+ STA X2,X
+ DEX
+ BPL SAVET
+ JSR FADD ; Z+SQRT(2)
+ LDX #3 ; 4 BYTE TRANSFER
+TM2: LDA T,X
+ STA X2,X ; LOAD T INTO EXP/MANT2
+ DEX
+ BPL TM2
+ JSR FDIV ; T=(Z-SQRT(2))/(Z+SQRT(2))
+ LDX #3 ; 4 BYTE TRANSFER
+MIT: LDA X1,X
+ STA T,X ; COPY EXP/MANT1 TO T AND
+ STA X2,X ; LOAD EXP/MANT2 WITH T
+ DEX
+ BPL MIT
+ JSR FMUL ; T*T
+ JSR SWAP ; MOVE T*T TO EXP/MANT2
+ LDX #3 ; 4 BYTE TRANSFER
+MIC: LDA C,X
+ STA X1,X ; LOAD EXP/MANT1 WITH C
+ DEX
+ BPL MIC
+ JSR FSUB ; T*T-C
+ LDX #3 ; 4 BYTE TRANSFER
+M2MB: LDA MB,X
+ STA X2,X ; LOAD EXP/MANT2 WITH MB
+ DEX
+ BPL M2MB
+ JSR FDIV ; MB/(T*T-C)
+ LDX #3
+M2A1: LDA A1,X
+ STA X2,X ; LOAD EXP/MANT2 WITH A1
+ DEX
+ BPL M2A1
+ JSR FADD ; MB/(T*T-C)+A1
+ LDX #3 ; 4 BYTE TRANSFER
+M2T: LDA T,X
+ STA X2,X ; LOAD EXP/MANT2 WITH T
+ DEX
+ BPL M2T
+ JSR FMUL ; (MB/(T*T-C)+A1)*T
+ LDX #3 ; 4 BYTE TRANSFER
+M2MHL: LDA MHLF,X
+ STA X2,X ; LOAD EXP/MANT2 WITH MHLF (.5)
+ DEX
+ BPL M2MHL
+ JSR FADD ; +.5
+ LDX #3 ; 4 BYTE TRANSFER
+LDEXP: LDA SEXP,X
+ STA X2,X ; LOAD EXP/MANT2 WITH ORIGINAL EXPONENT
+ DEX
+ BPL LDEXP
+ JSR FADD ; +EXPN
+ LDX #3 ; 4 BYTE TRANSFER
+MLE2: LDA LE2,X
+ STA X2,X ; LOAD EXP/MANT2 WITH LN(2)
+ DEX
+ BPL MLE2
+ JSR FMUL ; *LN(2)
+ RTS ; RETURN RESULT IN MANT/EXP1
+;
+; COMMON LOG OF MANT/EXP1 RESULT IN MANT/EXP1
+;
+LOG10: JSR LOG ; COMPUTE NATURAL LOG
+ LDX #3
+L10: LDA LN10,X
+ STA X2,X ; LOAD EXP/MANT2 WITH 1/LN(10)
+ DEX
+ BPL L10
+ JSR FMUL ; LOG10(X)=LN(X)/LN(10)
+ RTS
+;
+LN10: .byte $7E, $6F, $2D, $ED ; 0.4342945
+
+R22: .byte $80, $5A, $82, $7A ; 1.4142136 SQRT(2)
+
+LE2: .byte $7F, $58, $B9, $0C ; 0.69314718 LOG BASE E OF 2
+
+A1: .byte $80, $52, $B0, 40 ; 1.2920074
+
+MB: .byte $81, $AB, $86, $49 ; -2.6398577
+
+C: .byte $80, $6A, $08, $66 ; 1.6567626
+
+MHLF: .byte $7F, $40, $00, $00 ; 0.5
+
+;
+; .res $1e00-*
+; .org $1E00 ; STARTING LOCATION FOR EXP
+;
+; EXP OF MANT/EXP1 RESULT IN MANT/EXP1
+;
+EXP: LDX #3 ; 4 BYTE TRANSFER
+ LDA L2E,X
+ STA X2,X ; LOAD EXP/MANT2 WITH LOG BASE 2 OF E
+ DEX
+ BPL EXP+2
+ JSR FMUL ; LOG2(3)*X
+ LDX #3 ; 4 BYTE TRANSFER
+FSA: LDA X1,X
+ STA ZZ,X ; STORE EXP/MANT1 IN Z
+ DEX
+ BPL FSA ; SAVE Z=LN(2)*X
+ JSR FIX ; CONVERT CONTENTS OF EXP/MANT1 TO AN INTEGER
+ LDA M1+1
+ STA INT ; SAVE RESULT AS INT
+ SEC ; SET CARRY FOR SUBTRACTION
+ SBC #124 ; INT-124
+ LDA M1
+ SBC #0
+ BPL OVFLW ; OVERFLOW INT>=124
+ CLC ; CLEAR CARRY FOR ADD
+ LDA M1+1
+ ADC #120 ; ADD 120 TO INT
+ LDA M1
+ ADC #0
+ BPL CONTIN ; IF RESULT POSITIVE CONTINUE
+ LDA #0 ; INT<-120 SET RESULT TO ZERO AND RETURN
+ LDX #3 ; 4 BYTE MOVE
+ZERO: STA X1,X ; SET EXP/MANT1 TO ZERO
+ DEX
+ BPL ZERO
+ RTS ; RETURN
+;
+OVFLW: BRK ; OVERFLOW
+;
+CONTIN: JSR FLOAT ; FLOAT INT
+ LDX #3
+ENTD: LDA ZZ,X
+ STA X2,X ; LOAD EXP/MANT2 WITH Z
+ DEX
+ BPL ENTD
+ JSR FSUB ; Z*Z-FLOAT(INT)
+ LDX #3 ; 4 BYTE MOVE
+ZSAV: LDA X1,X
+ STA ZZ,X ; SAVE EXP/MANT1 IN Z
+ STA X2,X ; COPY EXP/MANT1 TO EXP/MANT2
+ DEX
+ BPL ZSAV
+ JSR FMUL ; Z*Z
+ LDX #3 ; 4 BYTE MOVE
+LA2: LDA A2,X
+ STA X2,X ; LOAD EXP/MANT2 WITH A2
+ LDA X1,X
+ STA SEXP,X ; SAVE EXP/MANT1 AS SEXP
+ DEX
+ BPL LA2
+ JSR FADD ; Z*Z+A2
+ LDX #3 ; 4 BYTE MOVE
+LB2: LDA B2,X
+ STA X2,X ; LOAD EXP/MANT2 WITH B2
+ DEX
+ BPL LB2
+ JSR FDIV ; T=B/(Z*Z+A2)
+ LDX #3 ; 4 BYTE MOVE
+DLOAD: LDA X1,X
+ STA T,X ; SAVE EXP/MANT1 AS T
+ LDA C2,X
+ STA X1,X ; LOAD EXP/MANT1 WITH C2
+ LDA SEXP,X
+ STA X2,X ; LOAD EXP/MANT2 WITH SEXP
+ DEX
+ BPL DLOAD
+ JSR FMUL ; Z*Z*C2
+ JSR SWAP ; MOVE EXP/MANT1 TO EXP/MANT2
+ LDX #3 ; 4 BYTE TRANSFER
+LTMP: LDA T,X
+ STA X1,X ; LOAD EXP/MANT1 WITH T
+ DEX
+ BPL LTMP
+ JSR FSUB ; C2*Z*Z-B2/(Z*Z+A2)
+ LDX #3 ; 4 BYTE TRANSFER
+LDD: LDA D,X
+ STA X2,X ; LOAD EXP/MANT2 WITH D
+ DEX
+ BPL LDD
+ JSR FADD ; D+C2*Z*Z-B2/(Z*Z+A2)
+ JSR SWAP ; MOVE EXP/MANT1 TO EXP/MANT2
+ LDX #3 ; 4 BYTE TRANSFER
+LFA: LDA ZZ,X
+ STA X1,X ; LOAD EXP/MANT1 WITH Z
+ DEX
+ BPL LFA
+ JSR FSUB ; -Z+D+C2*Z*Z-B2/(Z*Z+A2)
+ LDX #3 ; 4 BYTE TRANSFER
+LF3: LDA ZZ,X
+ STA X2,X ; LOAD EXP/MANT2 WITH Z
+ DEX
+ BPL LF3
+ JSR FDIV ; Z/(**** )
+ LDX #3 ; 4 BYTE TRANSFER
+LD12: LDA MHLF,X
+ STA X2,X ; LOAD EXP/MANT2 WITH .5
+ DEX
+ BPL LD12
+ JSR FADD ; +Z/(***)+.5
+ SEC ; ADD INT TO EXPONENT WITH CARRY SET
+ LDA INT ; TO MULTIPLY BY
+ ADC X1 ; 2**(INT+1)
+ STA X1 ; RETURN RESULT TO EXPONENT
+ RTS ; RETURN ANS=(.5+Z/(-Z+D+C2*Z*Z-B2/(Z*Z+A2))*2**(INT+1)
+L2E: .byte $80, $5C, $55, $1E ; 1.4426950409 LOG BASE 2 OF E
+
+A2: .byte $86, $57, $6A, $E1 ; 87.417497202
+
+B2: .byte $89, $4D, $3F, $1D ; 617.9722695
+
+C2: .byte $7B, $46, $FA, $70 ; .03465735903
+
+D: .byte $83, $4F, $A3, $03 ; 9.9545957821
+
+;
+;
+; BASIC FLOATING POINT ROUTINES
+;
+; .res $1F00-*
+; .org $1F00 ; START OF BASIC FLOATING POINT ROUTINES
+ADD: CLC ; CLEAR CARRY
+ LDX #$02 ; INDEX FOR 3-BYTE ADD
+ADD1: LDA M1,X
+ ADC M2,X ; ADD A BYTE OF MANT2 TO MANT1
+ STA M1,X
+ DEX ; ADVANCE INDEX TO NEXT MORE SIGNIF.BYTE
+ BPL ADD1 ; LOOP UNTIL DONE.
+ RTS ; RETURN
+MD1: ASL SIGN ; CLEAR LSB OF SIGN
+ JSR ABSWAP ; ABS VAL OF MANT1, THEN SWAP MANT2
+ABSWAP: BIT M1 ; MANT1 NEG?
+ BPL ABSWP1 ; NO,SWAP WITH MANT2 AND RETURN
+ JSR FCOMPL ; YES, COMPLEMENT IT.
+ INC SIGN ; INCR SIGN, COMPLEMENTING LSB
+ABSWP1: SEC ; SET CARRY FOR RETURN TO MUL/DIV
+;
+; SWAP EXP/MANT1 WITH EXP/MANT2
+;
+SWAP: LDX #$04 ; INDEX FOR 4-BYTE SWAP.
+SWAP1: STY E-1,X
+ LDA X1-1,X ; SWAP A BYTE OF EXP/MANT1 WITH
+ LDY X2-1,X ; EXP/MANT2 AND LEAVEA COPY OF
+ STY X1-1,X ; MANT1 IN E(3BYTES). E+3 USED.
+ STA X2-1,X
+ DEX ; ADVANCE INDEX TO NEXT BYTE
+ BNE SWAP1 ; LOOP UNTIL DONE.
+ RTS
+;
+;
+;
+; CONVERT 16 BIT INTEGER IN M1(HIGH) AND M1+1(LOW) TO F.P.
+; RESULT IN EXP/MANT1. EXP/MANT2 UNEFFECTED
+;
+;
+FLOAT: LDA #$8E
+ STA X1 ; SET EXPN TO 14 DEC
+ LDA #0 ; CLEAR LOW ORDER BYTE
+ STA M1+2
+ BEQ NORML ; NORMALIZE RESULT
+NORM1: DEC X1 ; DECREMENT EXP1
+ ASL M1+2
+ ROL M1+1 ; SHIFT MANT1 (3 BYTES) LEFT
+ ROL M1
+NORML: LDA M1 ; HIGH ORDER MANT1 BYTE
+ ASL ; UPPER TWO BITS UNEQUAL?
+ EOR M1
+ BMI RTS1 ; YES,RETURN WITH MANT1 NORMALIZED
+ LDA X1 ; EXP1 ZERO?
+ BNE NORM1 ; NO, CONTINUE NORMALIZING
+RTS1: RTS ; RETURN
+;
+;
+; EXP/MANT2-EXP/MANT1 RESULT IN EXP/MANT1
+;
+FSUB: JSR FCOMPL ; CMPL MANT1 CLEARS CARRY UNLESS ZERO
+SWPALG: JSR ALGNSW ; RIGHT SHIFT MANT1 OR SWAP WITH MANT2 ON CARRY
+;
+; ADD EXP/MANT1 AND EXP/MANT2 RESULT IN EXP/MANT1
+;
+FADD: LDA X2
+ CMP X1 ; COMPARE EXP1 WITH EXP2
+ BNE SWPALG ; IF UNEQUAL, SWAP ADDENDS OR ALIGN MANTISSAS
+ JSR ADD ; ADD ALIGNED MANTISSAS
+ADDEND: BVC NORML ; NO OVERFLOW, NORMALIZE RESULTS
+ BVS RTLOG ; OV: SHIFT MANT1 RIGHT. NOTE CARRY IS CORRECT SIGN
+ALGNSW: BCC SWAP ; SWAP IF CARRY CLEAR, ELSE SHIFT RIGHT ARITH.
+RTAR: LDA M1 ; SIGN OF MANT1 INTO CARRY FOR
+ ASL ; RIGHT ARITH SHIFT
+RTLOG: INC X1 ; INCR EXP1 TO COMPENSATE FOR RT SHIFT
+ BEQ OVFL ; EXP1 OUT OF RANGE.
+RTLOG1: LDX #$FA ; INDEX FOR 6 BYTE RIGHT SHIFT
+ROR1: LDA #$80
+ BCS ROR2
+ ASL
+ROR2: LSR E+3,X ; SIMULATE ROR E+3,X
+ ORA E+3,X
+ STA E+3,X
+ INX ; NEXT BYTE OF SHIFT
+ BNE ROR1 ; LOOP UNTIL DONE
+ RTS ; RETURN
+;
+;
+; EXP/MANT1 X EXP/MANT2 RESULT IN EXP/MANT1
+;
+FMUL: JSR MD1 ; ABS. VAL OF MANT1, MANT2
+ ADC X1 ; ADD EXP1 TO EXP2 FOR PRODUCT EXPONENT
+ JSR MD2 ; CHECK PRODUCT EXP AND PREPARE FOR MUL
+ CLC ; CLEAR CARRY
+MUL1: JSR RTLOG1 ; MANT1 AND E RIGHT.(PRODUCT AND MPLIER)
+ BCC MUL2 ; IF CARRY CLEAR, SKIP PARTIAL PRODUCT
+ JSR ADD ; ADD MULTIPLICAN TO PRODUCT
+MUL2: DEY ; NEXT MUL ITERATION
+ BPL MUL1 ; LOOP UNTIL DONE
+MDEND: LSR SIGN ; TEST SIGN (EVEN/ODD)
+NORMX: BCC NORML ; IF EXEN, NORMALIZE PRODUCT, ELSE COMPLEMENT
+FCOMPL: SEC ; SET CARRY FOR SUBTRACT
+ LDX #$03 ; INDEX FOR 3 BYTE SUBTRACTION
+COMPL1: LDA #$00 ; CLEAR A
+ SBC X1,X ; SUBTRACT BYTE OF EXP1
+ STA X1,X ; RESTORE IT
+ DEX ; NEXT MORE SIGNIFICANT BYTE
+ BNE COMPL1 ; LOOP UNTIL DONE
+ BEQ ADDEND ; NORMALIZE (OR SHIFT RIGHT IF OVERFLOW)
+;
+;
+; EXP/MANT2 / EXP/MANT1 RESULT IN EXP/MANT1
+;
+FDIV: JSR MD1 ; TAKE ABS VAL OF MANT1, MANT2
+ SBC X1 ; SUBTRACT EXP1 FROM EXP2
+ JSR MD2 ; SAVE AS QUOTIENT EXP
+DIV1: SEC ; SET CARRY FOR SUBTRACT
+ LDX #$02 ; INDEX FOR 3-BYTE INSTRUCTION
+DIV2: LDA M2,X
+ SBC E,X ; SUBTRACT A BYTE OF E FROM MANT2
+ PHA ; SAVE ON STACK
+ DEX ; NEXT MORE SIGNIF BYTE
+ BPL DIV2 ; LOOP UNTIL DONE
+ LDX #$FD ; INDEX FOR 3-BYTE CONDITIONAL MOVE
+DIV3: PLA ; PULL A BYTE OF DIFFERENCE OFF STACK
+ BCC DIV4 ; IF MANT2
Date: Mon, 20 Jun 2022 02:00:43 +0200
Subject: [PATCH 004/139] fixup readme
---
test/float/.gitignore | 6 +++++-
test/float/readme.md | 20 ++++++++++----------
2 files changed, 15 insertions(+), 11 deletions(-)
diff --git a/test/float/.gitignore b/test/float/.gitignore
index 18269f81a..20b1e7785 100644
--- a/test/float/.gitignore
+++ b/test/float/.gitignore
@@ -1,3 +1,7 @@
*.bin
*.prg
-
+*.c64.s
+*.woz.s
+float-basic.s
+float-basic-cmp.s
+float-minimal.s
diff --git a/test/float/readme.md b/test/float/readme.md
index 802cbf97c..3fae9b389 100644
--- a/test/float/readme.md
+++ b/test/float/readme.md
@@ -47,7 +47,7 @@ TODO (much later):
### Files & Functions
#### codegen.c
-
+```
g_getimmed Load a constant into the primary register
g_getstatic Fetch an static memory cell into the primary register
g_getlocal Fetch specified local object (local var) into the primary register
@@ -67,7 +67,7 @@ g_defdata_float
(see below) g_add, g_sub, g_mul, g_div, g_neg, g_bneg
(see below) g_eq, g_ne, g_lt, g_gt, g_le, g_ge
(invalid) g_mod, g_or, g_xor, g_and, g_asr
-
+```
#### datatype.c
ArithmeticConvert
@@ -135,7 +135,7 @@ historical float routines by woz :) unfortunately not ieee754
### runtime functions
these must be available in the runtime library
-
+```
func description cbmfp wozfp 754 codegen.c
aufloat Primary 8bit unsigned -> float * - - g_regfloat
@@ -163,20 +163,20 @@ ftosleeax Test for less than or equal to * - - g_le
ftoslteax Test for less than * - - g_lt
ftosneeax Test for not equal * - - g_ne
ftoseqeax Test for equal * - - g_eq
-
+```
### extra functions
optional utility functions.
-
+```
func description cbmfp wozfp 754
char *_ftostr(char *d, float s) * ? ? for printf family
float _strtof(char *d) * - - for scanf family
-
+```
### math.h functions
these are optional, required for standard libm
-
+```
func description cbmfp wozfp 754
/* C99 */
@@ -189,8 +189,8 @@ float sqrtf(float x); * - -
float tanf(float x); * - -
float atanf(float x); * - -
float fabsf(float x); * - -
-
+```
--------------------------------------------------------------------------------
-https://www.geeksforgeeks.org/ieee-standard-754-floating-point-numbers/
-https://www.h-schmidt.net/FloatConverter/IEEE754.html
+- https://www.geeksforgeeks.org/ieee-standard-754-floating-point-numbers/
+- https://www.h-schmidt.net/FloatConverter/IEEE754.html
From 96ee7022200a3ff94069e5284e2a7a19d949b767 Mon Sep 17 00:00:00 2001
From: mrdudz
Date: Mon, 20 Jun 2022 04:31:51 +0200
Subject: [PATCH 005/139] update some basic functions
---
test/float/cbmkernal/cbmfp.h | 27 +++++++++++++++------------
test/float/cbmkernal/cc65wrapper.s | 19 +++++++++++++++++++
test/float/cbmkernal/float.inc | 2 +-
test/float/cbmkernal/float.s | 8 ++++----
test/float/floattest.c | 18 ++++++++----------
test/float/include/math.h | 6 ++++++
6 files changed, 53 insertions(+), 27 deletions(-)
diff --git a/test/float/cbmkernal/cbmfp.h b/test/float/cbmkernal/cbmfp.h
index 258eca468..05a29261d 100644
--- a/test/float/cbmkernal/cbmfp.h
+++ b/test/float/cbmkernal/cbmfp.h
@@ -16,6 +16,8 @@
33333333 3 3222222222111111111110000000000
98765432 1 0987654321098765432109876543210
+ (the above seems to match wozniacs format)
+
* The exponent can be computed from bits 39-32 by subtracting 129 (!)
*/
typedef struct {
@@ -50,15 +52,15 @@ typedef struct {
} FLOATFAC;
/* integer conversion functions */
-float __fastcall__ _ctof(char v);
-float __fastcall__ _utof(unsigned char v);
-float __fastcall__ _itof(int v);
-float __fastcall__ _stof(unsigned short v);
+float __fastcall__ _ctof(char v); /* afloat */
+float __fastcall__ _utof(unsigned char v); /* aufloat */
+float __fastcall__ _itof(int v); /* axfloat */
+float __fastcall__ _stof(unsigned short v); /* axufloat */
-int __fastcall__ _ftoi(float f);
+int __fastcall__ _ftoi(float f); /* feaxint */
/* compare two floats, returns 0 if f = a, 1 if f < a, 255 if f > a */
-unsigned char __fastcall__ _fcmp(float f, float a);
+unsigned char __fastcall__ _fcmp(float f, float a); /* ftos..eax */
/* arithmetic functions */
float __fastcall__ _fadd(float f, float a); /* ftosaddeax */
@@ -80,22 +82,23 @@ float __fastcall__ _fatn(float s); /* math.h atanf */
float __fastcall__ _fabs(float s); /* math.h fabsf */
+float __fastcall__ _fint(float s); /* math.h truncf */ /* truncate decimal fraction */
+float __fastcall__ _fround(float s); /* math.h roundf */ /* rounding */
+
/* logical functions */
float __fastcall__ _fand(float f, float a);
float __fastcall__ _for(float f, float a);
float __fastcall__ _fnot(float f);
/* misc */
-float __fastcall__ _frnd(float s);
+float __fastcall__ _frnd(float s); /* random number */
+float __fastcall__ _fsgn(float s); /* "signum" returns 1 if positive, 0 if 0, -1 if negative */
+
+float __fastcall__ _fneg(float f); /* negate (flip sign) FIXME: fnegeax */
-float __fastcall__ _fneg(float f); /* negate (flip sign) */
unsigned char __fastcall__ _ftestsgn(float f); /* FIXME */
-float __fastcall__ _fsgn(float s);
-float __fastcall__ _fint(float s);
-
#if 0
-
typedef struct {
unsigned char exponent;
FLOATBAS coffs[8]; /* ? */
diff --git a/test/float/cbmkernal/cc65wrapper.s b/test/float/cbmkernal/cc65wrapper.s
index bc60ebdf7..4f3c2ed8b 100644
--- a/test/float/cbmkernal/cc65wrapper.s
+++ b/test/float/cbmkernal/cc65wrapper.s
@@ -189,9 +189,16 @@ feaxlong:
.export fbnegeax
.import bnegax
fbnegeax:
+; FIXME: why does this not work with __fnot?
jsr __ftoi
jmp bnegax
+.if 0 = 1
+ .export fnegeax
+ fnegeax:
+ jmp __fneg
+.endif
+
;--------------------------------------------------------------
; math ops
@@ -340,6 +347,8 @@ ftosleeax:
.import __ftan
.import __fatn
.import __fabs
+ .import __fround
+ .import __fint
.export _powf
_powf:
@@ -386,3 +395,13 @@ _atanf:
_fabsf:
; arg0: a/x/sreg/sreg+1
jmp __fabs
+
+ .export _roundf
+_roundf:
+ ; arg0: a/x/sreg/sreg+1
+ jmp __fround
+
+ .export _truncf
+_truncf:
+ ; arg0: a/x/sreg/sreg+1
+ jmp __fint
diff --git a/test/float/cbmkernal/float.inc b/test/float/cbmkernal/float.inc
index 6a212afcf..962902d85 100644
--- a/test/float/cbmkernal/float.inc
+++ b/test/float/cbmkernal/float.inc
@@ -32,7 +32,7 @@ BASIC_FAC_Sqr = $bf71 ; in/out: FAC
BASIC_FAC_Exp = $bfed ; in/out: FAC
BASIC_FAC_Log = $b9ea ; in/out: FAC
BASIC_FAC_Round = $bc1b ; in/out: FAC
-BASIC_FAC_Sgn = $bc39 ; in/out: FAC
+BASIC_FAC_Sgn = $bc39 ; in/out: FAC "signum" returns 1 if positive, 0 if 0, -1 if negative
BASIC_FAC_Abs = $bc58 ; in/out: FAC
BASIC_ARG_FAC_Or = $afe6 ; in: ARG,FAC out:FAC
diff --git a/test/float/cbmkernal/float.s b/test/float/cbmkernal/float.s
index 8a8fc1ae8..6435b315e 100644
--- a/test/float/cbmkernal/float.s
+++ b/test/float/cbmkernal/float.s
@@ -586,16 +586,16 @@ __fatn: __ffunc1 BASIC_FAC_Atn
__fcos: __ffunc1 BASIC_FAC_Cos
__fexp: __ffunc1 BASIC_FAC_Exp
;__ffre: __ffunc1 BASIC_FAC_Fre
-__fint: __ffunc1 BASIC_FAC_Int
+__fint: __ffunc1 BASIC_FAC_Int ; truncate fractions
__flog: __ffunc1 BASIC_FAC_Log
;__fpos: __ffunc1 BASIC_FAC_Pos
-__frnd: __ffunc1 BASIC_FAC_Rnd
-__fsgn: __ffunc1 BASIC_FAC_Sgn
+__frnd: __ffunc1 BASIC_FAC_Rnd ; random numbers
+__fsgn: __ffunc1 BASIC_FAC_Sgn ;"signum" returns 1 if positive, 0 if 0, -1 if negative
__fsin: __ffunc1 BASIC_FAC_Sin
__fsqr: __ffunc1 BASIC_FAC_Sqr
__ftan: __ffunc1 BASIC_FAC_Tan
__fnot: __ffunc1 BASIC_FAC_Not
-__fround: __ffunc1 BASIC_FAC_Round
+__fround: __ffunc1 BASIC_FAC_Round ; rounding
;---------------------------------------------------------------------------------------------
; these functions take two args (in FAC and ARG) and return result (in FAC)
diff --git a/test/float/floattest.c b/test/float/floattest.c
index f70a64f8f..38b0f50c8 100644
--- a/test/float/floattest.c
+++ b/test/float/floattest.c
@@ -14,8 +14,6 @@ char strbuf[0x20];
char strbuf2[0x20];
char strbuf3[0x20];
-
-
typedef union {
float f;
unsigned char b[sizeof (float)];
@@ -92,11 +90,11 @@ void testatan2(void)
{
for(i = 0; i < YNUM; i++) {
fx = CXNUM2+((int)((sinf(deg2rad((float)(i),(float)(CYNUM)))*(float)(CYNUM2)))/(CYNUM/CXNUM));
-
+
fs = deg2rad((float)(i), (float)(CYNUM));
fd = cosf(fs) * (float)(CYNUM2);
fy = CXNUM2 + ((int)(fd) / (CYNUM/CXNUM));
-
+
cplot(fx, fy);
fd = fatan2((float)(fx-CXNUM2), (float)(fy-CYNUM2));
_ftostr(strbuf, fd);
@@ -210,7 +208,7 @@ void testbasicmath(void)
printf("123:%s\n",strbuf);
_ftostr(strbuf,fs);
printf("-123:%s\n",strbuf);
-
+
a = (float)(4321);
b = (float)(1234);
printf("4321:0x%08lx\n", ftobin(a));
@@ -219,7 +217,7 @@ void testbasicmath(void)
printf("4321+1234:0x%08lx\n", ftobin(c1));
_ftoa(strbuf, c1);
printf("4321+1234:%s\n", strbuf);
-
+
a = (float)(1111);
b = (float)(2222);
printf("1111:0x%08lx\n", ftobin(a));
@@ -234,7 +232,7 @@ void testbasicmath(void)
fd=fd / fs;
_ftostr(strbuf,fd);
printf("t:%s\n",strbuf);
-
+
// 1234 / 60 = 20,5666...
t=1234;
fd=(float)((int)t);
@@ -261,7 +259,7 @@ void testbasicmath(void)
fd=!fd;
_ftostr(strbuf,!fd);
printf("!!0:%s\n",strbuf);
-
+
a = 10.0f;
b = powf(a,(float)(1)); printf("0x%08lx %s\n", ftobin(b), _ftoa(strbuf,b));
b = powf(a,(float)(2)); printf("0x%08lx %s\n", ftobin(b), _ftoa(strbuf,b));
@@ -336,9 +334,9 @@ int main(void)
testbinary();
testcompare();
testprinting();
-#if 0
+#if 0
f1();
-
+
calcsin();
calccos();
testatan2(); // FIXME
diff --git a/test/float/include/math.h b/test/float/include/math.h
index e888a0a22..99117b8be 100644
--- a/test/float/include/math.h
+++ b/test/float/include/math.h
@@ -31,6 +31,12 @@ float __fastcall__ atanf(float x); /* C99 */
/* double fabs(double x); */
float __fastcall__ fabsf(float x); /* C99 */
+/* double round(double x); */ /* C99 */
+float __fastcall__ roundf(float x); /* C99 */
+
+/* double trunc(double x); */ /* C99 */
+float __fastcall__ truncf(float x); /* C99 */
+
/* beware, this is not standard */
#ifndef M_PI
#define M_PI 3.14159265358979323846f
From 6818fef71f9b2cc5c65771e95ac5fa73be7dcef6 Mon Sep 17 00:00:00 2001
From: mrdudz
Date: Mon, 20 Jun 2022 04:32:07 +0200
Subject: [PATCH 006/139] update readme
---
test/float/readme.md | 34 +++++++++++++++++++++++++---------
1 file changed, 25 insertions(+), 9 deletions(-)
diff --git a/test/float/readme.md b/test/float/readme.md
index 3fae9b389..efe9bf3de 100644
--- a/test/float/readme.md
+++ b/test/float/readme.md
@@ -70,35 +70,49 @@ g_defdata_float
```
#### datatype.c
+```
ArithmeticConvert
+```
#### expr.c
+```
LimitExprValue
parseadd
parsesub
+```
#### initdata.c
+```
DefineData Output a data definition for the given expression
+```
#### loadexpr.c
+```
LoadExpr
+```
#### locals.c
+```
ParseAutoDecl
+```
#### assignment.c
+```
OpAssignArithmetic Parse an "=" (if 'Gen' is 0) or "op=" operation for arithmetic lhs
+```
#### fp.c
wrapper for doing floating point operations on target floats
+```
FP_D_As32bitRaw converts double into 32bit (float) and then returns its raw content as a 32bit int
+```
--------------------------------------------------------------------------------
@@ -180,15 +194,17 @@ these are optional, required for standard libm
func description cbmfp wozfp 754
/* C99 */
-float powf(float f, float a); * - -
-float sinf(float s); * - -
-float cosf(float s); * - -
-float logf(float x); * * -
-float expf(float x); * - -
-float sqrtf(float x); * - -
-float tanf(float x); * - -
-float atanf(float x); * - -
-float fabsf(float x); * - -
+float powf(float f, float a) * - -
+float sinf(float s) * - -
+float cosf(float s) * - -
+float logf(float x) * * -
+float expf(float x) * - -
+float sqrtf(float x) * - -
+float tanf(float x) * - -
+float atanf(float x) * - -
+float fabsf(float x) * - -
+float roundf(float x) * - -
+float truncf(float x) * - -
```
--------------------------------------------------------------------------------
From b9bdcc51e02e7e8513f1cd8d6e237d7ba508a3c8 Mon Sep 17 00:00:00 2001
From: mrdudz
Date: Thu, 21 Jul 2022 00:51:28 +0200
Subject: [PATCH 007/139] some cleanup
---
src/cc65/expr.c | 4 +-
test/float/cbmkernal/cbmfp.h | 2 +-
test/float/cbmkernal/float.s | 120 ++++++++++++++++----------------
test/float/cbmkernal/ftoa.c | 34 ++++-----
test/float/float-basic.c | 2 +-
test/float/float-cbm..c | 6 +-
test/float/float-minimal.c | 2 +-
test/float/floattest.c | 36 +++++-----
test/float/gccstubs.c | 2 +-
test/float/ieee754/ftosaddeax.s | 28 ++++----
test/float/ieee754/ftosdiveax.s | 4 +-
test/float/ieee754/ftosmuleax.s | 4 +-
test/float/ieee754/ftossubeax.s | 4 +-
test/float/ieee754/ieee754.inc | 2 +-
test/float/include/_float.h | 6 +-
test/float/include/math.h | 2 +-
test/float/woz/ftoseqeax.s | 2 +-
test/float/woz/ftosgeeax.s | 2 +-
test/float/woz/ftosgteax.s | 2 +-
test/float/woz/ftosleeax.s | 2 +-
test/float/woz/ftoslteax.s | 2 +-
test/float/woz/ftosneeax.s | 2 +-
test/float/woz/ftossubeax.s | 2 +-
test/float/woz/wozfp.inc | 2 +-
24 files changed, 137 insertions(+), 137 deletions(-)
diff --git a/src/cc65/expr.c b/src/cc65/expr.c
index d9be6a74b..fe7e2ad82 100644
--- a/src/cc65/expr.c
+++ b/src/cc65/expr.c
@@ -1811,7 +1811,7 @@ static void UnaryOp (ExprDesc* Expr)
hie10 (Expr);
/* We can only handle integer types */
- if (!IsClassInt (Expr->Type)
+ if (!IsClassInt (Expr->Type)
&& !IsClassFloat (Expr->Type) /* FIXME: float */
) {
Error ("Argument must have integer type");
@@ -2159,7 +2159,7 @@ printf("hie_internal Expr->Type:%s Expr2->Type:%s\n",
if (Val2 == 0.0f) {
Error ("Division by zero");
Expr->V.FVal = FP_D_FromInt(0);
- } else
+ } else
#endif
{
Expr->V.FVal = FP_D_Div(Val1, Val2);
diff --git a/test/float/cbmkernal/cbmfp.h b/test/float/cbmkernal/cbmfp.h
index 05a29261d..a384fa08e 100644
--- a/test/float/cbmkernal/cbmfp.h
+++ b/test/float/cbmkernal/cbmfp.h
@@ -41,7 +41,7 @@ typedef struct {
*
* The exponent can be computed from bits 47-40 by subtracting 129 (!) (130 = 2^1)
* MSB of the Mantissa must always be 1, if it is 0 the value is 0
- *
+ *
* 1.0 = exp=129, mantissa=$80
*
*/
diff --git a/test/float/cbmkernal/float.s b/test/float/cbmkernal/float.s
index 6435b315e..6f4bf4e75 100644
--- a/test/float/cbmkernal/float.s
+++ b/test/float/cbmkernal/float.s
@@ -56,7 +56,7 @@ __basicoff:
.else
.include "float.inc"
.endif
-
+
.importzp sreg, ptr1
;---------------------------------------------------------------------------------------------
@@ -78,27 +78,27 @@ __float_u8_to_fac:
__enable_basic_if_needed
jsr BASIC_u8_to_FAC
__return_with_cleanup
-
+
; get C-parameter (signed int), convert to FAC
___float_s16_to_fac:
;a: low x: high
tay
txa
;y: low a: high
-
+
; convert signed int (YA) to FAC
__float_s16_to_fac:
__enable_basic_if_needed ; enable BASIC (trashes X)
jsr BASIC_s16_to_FAC
__return_with_cleanup
-
-; get C-parameter (unsigned short), convert to FAC
+
+; get C-parameter (unsigned short), convert to FAC
___float_u16_to_fac:
;a: low x: high
tay
txa
;y: low a: high
-
+
__float_u16_to_fac:
sta FAC_MANTISSA0
sty FAC_MANTISSA1
@@ -116,7 +116,7 @@ __float_fac_to_u16:
ldx FAC_MANTISSA2
lda FAC_MANTISSA3
rts
-
+
;---------------------------------------------------------------------------------------------
; converter float to string and back
;---------------------------------------------------------------------------------------------
@@ -150,9 +150,9 @@ ___float_float_to_fac:
sta FAC_MANTISSA1 ; 3
stx FAC_MANTISSA0 ; 2
ldy sreg ; 1
- sty FAC_EXPONENT
+ sty FAC_EXPONENT
ldy sreg+1 ; 0
- sty FAC_SIGN
+ sty FAC_SIGN
ldx #$00
stx FAC_MANTISSA2
@@ -164,7 +164,7 @@ ___float_float_to_fac:
stx FAC_MANTISSA1 ; 2
lda sreg ; 1
ora #$80
- sta FAC_MANTISSA0
+ sta FAC_MANTISSA0
; bit7=0 sign=0
; bit7=1 sign=$ff
@@ -176,7 +176,7 @@ ___float_float_to_fac:
stx FAC_SIGN
ldy sreg+1 ; 0
- sty FAC_EXPONENT
+ sty FAC_EXPONENT
ldx #$00
stx FAC_MANTISSA3
@@ -213,9 +213,9 @@ ___float_float_to_fac:
stx FAC_ROUNDING
.endif
rts
-
-; load BASIC float into FAC
-; in: pointer (a/x) to BASIC float (not packed)
+
+; load BASIC float into FAC
+; in: pointer (a/x) to BASIC float (not packed)
__float_float_to_fac: ; only used in ATAN2?
sta ptr1
stx ptr1+1
@@ -251,7 +251,7 @@ ___float_float_to_fac_arg:
___float_float_to_arg:
ldy #$03
jsr ldeaxysp
-
+
.if BINARYFORMAT = BINARYFORMAT_CBM_UNPACKED
sta ARG_MANTISSA1 ; 3
stx ARG_MANTISSA0 ; 2
@@ -273,8 +273,8 @@ ___float_float_to_arg:
stx ARG_MANTISSA1 ; 2
lda sreg ; 1
ora #$80
- sta ARG_MANTISSA0
-
+ sta ARG_MANTISSA0
+
; bit7=0 sign=0
; bit7=1 sign=$ff
ldx #0
@@ -283,13 +283,13 @@ ___float_float_to_arg:
dex
@pos:
stx ARG_SIGN
-
+
ldy sreg+1 ; 0
- sty ARG_EXPONENT
+ sty ARG_EXPONENT
ldx #$00
stx ARG_MANTISSA3
-
+
lda ARG_SIGN
eor FAC_SIGN
sta FAC_SIGN_COMPARE ; sign compare
@@ -332,7 +332,7 @@ ___float_float_to_arg:
jmp incsp4
; load BASIC float into ARG
-; in: pointer (a/x) to BASIC float (not packed)
+; in: pointer (a/x) to BASIC float (not packed)
__float_float_to_arg: ; only used in ATAN2?
sta ptr1
stx ptr1+1
@@ -358,7 +358,7 @@ __float_float_to_arg: ; only used in ATAN2?
eor FAC_SIGN
sta FAC_SIGN_COMPARE
rts
-
+
; return to C, float as unsigned long
___float_fac_to_float:
.if BINARYFORMAT = BINARYFORMAT_CBM_UNPACKED
@@ -368,11 +368,11 @@ ___float_fac_to_float:
sta sreg ; 1
ldx FAC_MANTISSA0 ; 2
lda FAC_MANTISSA1 ; 3
-.endif
+.endif
.if BINARYFORMAT = BINARYFORMAT_CBM_PACKED
lda FAC_EXPONENT
sta sreg+1 ; 0
-
+
; use the MSB of the mantissa for the sign
lda FAC_SIGN ; either $ff or $00
ora #$7f ; -> $ff or $7f
@@ -381,7 +381,7 @@ ___float_fac_to_float:
ldx FAC_MANTISSA1 ; 2
lda FAC_MANTISSA2 ; 3
-.endif
+.endif
.if BINARYFORMAT = BINARYFORMAT_IEEE754
; return float in a/x/sreg/sreg+1
lda FAC_EXPONENT
@@ -402,10 +402,10 @@ ___float_fac_to_float:
ldx FAC_MANTISSA1 ; 2
lda FAC_MANTISSA2 ; 3 lsb
-.endif
- rts
+.endif
+ rts
-;; store float in memory
+;; store float in memory
;; in: dest. pointer (a/x), float in FAC
;__float_fac_to_float: ; UNUSED
; sta ptr1
@@ -430,8 +430,8 @@ ___float_fac_to_float:
; sta (ptr1),y
; rts
-;; store packed float in memory
-;; in: dest. pointer (a/x), float in FAC
+;; store packed float in memory
+;; in: dest. pointer (a/x), float in FAC
;__float_fac_to_float_packed: ; UNUSED
; sta ptr1
; stx ptr1+1
@@ -454,8 +454,8 @@ ___float_fac_to_float:
; lda FAC_EXPONENT
; sta (ptr1),y
; rts
-
-;; store packed float in memory
+
+;; store packed float in memory
;; in: dest. pointer (a/x), float in ARG
__float_arg_to_float_packed:
sta ptr1
@@ -479,7 +479,7 @@ __float_arg_to_float_packed:
lda ARG_EXPONENT
sta (ptr1),y
rts
-
+
;---------------------------------------------------------------------------------------------
.export __ftostr
@@ -512,10 +512,10 @@ __float_strbuf_to_string:
rts
.export __strtof
-
-; convert a string to a float
-; float __fastcall__ _strtof(char *d);
-;-> unsigned long __fastcall__ _strtof(char *d);
+
+; convert a string to a float
+; float __fastcall__ _strtof(char *d);
+;-> unsigned long __fastcall__ _strtof(char *d);
__strtof:
jsr ___float_str_to_fac
jmp ___float_fac_to_float
@@ -530,7 +530,7 @@ __strtof:
jmp ___float_fac_to_float
.export __utof
-
+
; convert unsigned char to float
; float __fastcall__ _utof(unsigned char v);
;-> unsigned long __fastcall__ _utof(unsigned char v);
@@ -539,7 +539,7 @@ __strtof:
jmp ___float_fac_to_float
.export __stof
-
+
; convert short to float
; float __fastcall__ _stof(unsigned short v);
;-> unsigned long __fastcall__ _stof(unsigned short v);
@@ -558,7 +558,7 @@ __strtof:
jmp ___float_fac_to_float
.export __ftoi
-
+
; convert float to integer
; int __fastcall__ _ftoi(float f);
;-> int __fastcall__ _ftoi(unsigned long f);
@@ -596,11 +596,11 @@ __fsqr: __ffunc1 BASIC_FAC_Sqr
__ftan: __ffunc1 BASIC_FAC_Tan
__fnot: __ffunc1 BASIC_FAC_Not
__fround: __ffunc1 BASIC_FAC_Round ; rounding
-
+
;---------------------------------------------------------------------------------------------
; these functions take two args (in FAC and ARG) and return result (in FAC)
;---------------------------------------------------------------------------------------------
-
+
__float_ret2:
;jsr __basicoff
@@ -625,11 +625,11 @@ __float_ret2:
jsr addr
jmp __float_ret2
.endmacro
-
+
.export __fadd, __fsub, __fmul, __fdiv, __fpow
-; float __fastcall__ _fadd(float f, float a);
-;-> unsigned long __fastcall__ _fadd(unsigned long f, unsigned long a);
+; float __fastcall__ _fadd(float f, float a);
+;-> unsigned long __fastcall__ _fadd(unsigned long f, unsigned long a);
__fadd: __ffunc2a BASIC_ARG_FAC_Add
__fsub: __ffunc2a BASIC_ARG_FAC_Sub
__fmul: __ffunc2a BASIC_ARG_FAC_Mul
@@ -640,7 +640,7 @@ __fpow: __ffunc2a BASIC_ARG_FAC_Pow
__fand: __ffunc2b BASIC_ARG_FAC_And
__for: __ffunc2b BASIC_ARG_FAC_Or
-
+
__float_ret3:
;jsr __basicoff
.if .defined(__C64__)
@@ -649,17 +649,17 @@ __float_ret3:
cli
.endif
ldx #0
- rts
-
+ rts
+
.bss
-
+
tempfloat:
.res 5
.SEGMENT "LOWCODE"
-
+
.export __fcmp
-
+
__fcmp:
jsr ___float_float_to_fac_arg
lda #__f_1pi2
jsr __float_float_to_fac
jmp __float_ret2
-
+
diff --git a/test/float/cbmkernal/ftoa.c b/test/float/cbmkernal/ftoa.c
index 15d2aa8eb..c80cdf52b 100644
--- a/test/float/cbmkernal/ftoa.c
+++ b/test/float/cbmkernal/ftoa.c
@@ -7,12 +7,12 @@
// convert float into a string. this is surprisingly complex, so we just use
// the kernal function, and then fix up the result
-char *ftoa(char *buf, float n)
-{
+char *ftoa(char *buf, float n)
+{
char i, ii, epos = 0, ex;
char tempbuf[0x20];
_ftostr(tempbuf, n);
-
+
// find position of the 'e'
i=0;while(tempbuf[i]) {
if (tempbuf[i] == 69) { /* 'e' */
@@ -21,14 +21,14 @@ char *ftoa(char *buf, float n)
}
i++;
}
-
+
if (epos == 0) {
i = ii = 0;
// no exponent, we can return the number as is
if (tempbuf[i] == '-') {
buf[ii] = tempbuf[i];
i++;ii++;
- }
+ }
// else {
// buf[ii] = ' ';
// ii++;
@@ -51,12 +51,12 @@ char *ftoa(char *buf, float n)
buf[ii] = 0;
} else {
// we have an exponent, get rid of it
-
+
i = ii = 0;
if (tempbuf[i] == '-') {
buf[ii] = tempbuf[i];
i++;ii++;
- }
+ }
// else {
// buf[ii] = ' ';
// ii++;
@@ -65,18 +65,18 @@ char *ftoa(char *buf, float n)
if (tempbuf[i] == ' ') {
i++;
}
-
+
ex = ((tempbuf[epos+2] - '0') * 10) + (tempbuf[epos+3] - '0');
if (tempbuf[epos+1] == '+') {
// positive exponent, move decimal point to right, add zeros to the right
-
+
// first copy until we see either the decimal point, or the 'e'
while (tempbuf[i] && tempbuf[i] != '.' && tempbuf[i] != 69) {
buf[ii] = tempbuf[i];
i++;ii++;
}
-
+
// 'e' found, add as many zeros as in the exponent
if (tempbuf[i] == 69) {
while(ex) {
@@ -101,15 +101,15 @@ char *ftoa(char *buf, float n)
ex--;
}
}
-
+
} else {
// negative exponent, move decimal point to left, add zeros to left
-
+
buf[ii] = '0'; ii++;
buf[ii] = '.'; ii++;
ex--;
-
+
// add zeros
while(ex) {
buf[ii] = '0';
@@ -124,11 +124,11 @@ char *ftoa(char *buf, float n)
buf[ii] = tempbuf[i];
i++;ii++;
}
-
+
}
buf[ii] = 0;
}
-
- return buf;
+
+ return buf;
}
-
+
diff --git a/test/float/float-basic.c b/test/float/float-basic.c
index cdf933efb..f8ba23aa5 100644
--- a/test/float/float-basic.c
+++ b/test/float/float-basic.c
@@ -178,6 +178,6 @@ int main(void)
printf("fp2 0x%08lx [] %s ()\n", *((uint32_t*)&fp2), _ftostr(buf, fp2));
printf("fp3 0x%08lx [] %s ()\n", *((uint32_t*)&fp3), _ftostr(buf, fp3));
-
+
return 0;
}
diff --git a/test/float/float-cbm..c b/test/float/float-cbm..c
index 77b39e3a9..8337622f3 100644
--- a/test/float/float-cbm..c
+++ b/test/float/float-cbm..c
@@ -73,7 +73,7 @@ void testconversions(void)
printf("b:0x%08lx ", ftobin(b));
n=(int)(b);
printf("n:%d\n", n);
-
+
b=atof("1234");
printf("b:0x%08lx ", ftobin(b));
n=(int)(b);
@@ -83,7 +83,7 @@ void testconversions(void)
printf("s:%s\n", strbuf);
printf("a:%s\n", _ftostr(strbuf, (float)(1234)));
-
+
printf("a:%s b:%s c:%s\n",
_ftostr(strbuf, (float)(1234)),
_ftostr(strbuf2, (float)(5678)),
@@ -127,7 +127,7 @@ void testcompare(void)
cgetc();
#endif
}
-
+
int main(void)
{
printf("sizeof (float): %d\n", (int)sizeof(float));
diff --git a/test/float/float-minimal.c b/test/float/float-minimal.c
index 2f2bc93c3..12408e9ab 100644
--- a/test/float/float-minimal.c
+++ b/test/float/float-minimal.c
@@ -55,7 +55,7 @@ int main(void)
#if 1
printf("(local) get address, read via ptr\n");
fp2 = 23.1234f;
-
+
// get address of local
p = (uintptr_t)&fp2;
fp_p = (float*)p;
diff --git a/test/float/floattest.c b/test/float/floattest.c
index 38b0f50c8..c100e2256 100644
--- a/test/float/floattest.c
+++ b/test/float/floattest.c
@@ -169,11 +169,11 @@ void f1(void)
#if 0
if(FCMPGT(0x00028000,U16TOF(0)))
{
- if (FCMPGTEQ(var_i,(U16TOF(var_bs+1000)))) break;
+ if (FCMPGTEQ(var_i,(U16TOF(var_bs+1000)))) break;
}
else if(FCMPLT(0x00028000,U16TOF(0)))
{
- if (FCMPLTEQ(var_i,(U16TOF(var_bs+1000)))) break;
+ if (FCMPLTEQ(var_i,(U16TOF(var_bs+1000)))) break;
}
#endif
// var_i=var_i + 0x00028000;
@@ -202,11 +202,11 @@ void testbasicmath(void)
{
printf("\ntestbasicmath:\n\n");
t=123;
- fd=(float)((int)t);
+ fd=(float)((int)t);
fs=_fneg(fd);
- _ftostr(strbuf,fd);
+ _ftostr(strbuf,fd);
printf("123:%s\n",strbuf);
- _ftostr(strbuf,fs);
+ _ftostr(strbuf,fs);
printf("-123:%s\n",strbuf);
a = (float)(4321);
@@ -227,37 +227,37 @@ void testbasicmath(void)
_ftoa(strbuf, c1);
printf("1111-2222:%s\n", strbuf);
- fd=(float)((int)t);
- fs=(float)((int)2);
+ fd=(float)((int)t);
+ fs=(float)((int)2);
fd=fd / fs;
- _ftostr(strbuf,fd);
+ _ftostr(strbuf,fd);
printf("t:%s\n",strbuf);
// 1234 / 60 = 20,5666...
t=1234;
- fd=(float)((int)t);
- fs=(float)((int)60);
+ fd=(float)((int)t);
+ fs=(float)((int)60);
fd=fd / fs;
- _ftostr(strbuf,fd);
+ _ftostr(strbuf,fd);
printf("t:%s\n",strbuf);
// 5678 / 60 = 94,6333...
t=5678;
- fd=(float)((int)t);
- fs=(float)((int)60);
+ fd=(float)((int)t);
+ fs=(float)((int)60);
fd=fd / fs;
- _ftostr(strbuf,fd);
+ _ftostr(strbuf,fd);
printf("t:%s\n",strbuf);
// ! operator DOES work on floats!
- fd=(float)((int)4);
+ fd=(float)((int)4);
fd=!fd;
- _ftostr(strbuf,!fd);
+ _ftostr(strbuf,!fd);
printf("!!4:%s\n",strbuf);
- fd=(float)((int)0);
+ fd=(float)((int)0);
fd=!fd;
- _ftostr(strbuf,!fd);
+ _ftostr(strbuf,!fd);
printf("!!0:%s\n",strbuf);
a = 10.0f;
diff --git a/test/float/gccstubs.c b/test/float/gccstubs.c
index 8acc0d7f6..701c9db8d 100644
--- a/test/float/gccstubs.c
+++ b/test/float/gccstubs.c
@@ -24,7 +24,7 @@ char *_ftostr(char *d, float s)
return d;
}
-char *_ftoa(char *d, float s)
+char *_ftoa(char *d, float s)
{
if (d == NULL) {
d = &buffer[0];
diff --git a/test/float/ieee754/ftosaddeax.s b/test/float/ieee754/ftosaddeax.s
index 9b766a34b..0a5287e84 100644
--- a/test/float/ieee754/ftosaddeax.s
+++ b/test/float/ieee754/ftosaddeax.s
@@ -8,42 +8,42 @@
; Primary = TOS + Primary (like tosaddeax)
.export ftosaddeax
-;ftosaddeax:
+;ftosaddeax:
; FIXME
-; rts
+; rts
; CC65 runtime: long add
; ; EAX = TOS + EAX
-;
+;
; ;tosadd0ax:
; ldy #$00
; sty sreg
; sty sreg+1
-;
+;
; ;tosaddeax:
; clc
; ldy #0
; adc (sp),y ; lo byte
; iny
-;
+;
; sta tmp1 ; use as temp storage
; txa
; adc (sp),y ; byte 1
; tax
; iny
-;
+;
; lda sreg
; adc (sp),y ; byte 2
; sta sreg
; iny
-;
+;
; lda sreg+1
; adc (sp),y ; byte 3
; sta sreg+1
; lda tmp1 ; load byte 0
; jmp addysp1 ; drop TOS
-
+
; found at https://github.com/CrashAndSideburns/6502ieee754/blob/main/arithmetic/addition.s
@@ -51,7 +51,7 @@
ftosaddeax:
; arg0: a/x/sreg/sreg+1
; arg1: (sp),y (y=0..3)
-
+
lda #0
sta SIGN_ONE
sta SIGN_TWO
@@ -64,7 +64,7 @@ ftosaddeax:
lda sreg+0
ROL
STA MANTISSA_TWO + 2
-
+
; Pull MSB of mantissa off of stack and shift exponent LSB into carry.
tax
ROL
@@ -111,7 +111,7 @@ ftosaddeax:
ROR MANTISSA_TWO + 1
ROR MANTISSA_TWO + 2
ROR MANTISSA_TWO + 3
-
+
@add_first_implicit_bit:
LDA EXPONENT_ONE
CMP #$00
@@ -216,7 +216,7 @@ ftosaddeax:
; PHA
; PHA
; PHA
-
+
LDA #$ff
sta sreg+1
sta sreg
@@ -633,5 +633,5 @@ ftosaddeax:
LDA MANTISSA_ONE + 3
jmp addysp1 ; drop TOS
- RTS
-
+ RTS
+
diff --git a/test/float/ieee754/ftosdiveax.s b/test/float/ieee754/ftosdiveax.s
index 7a9793448..f878c8295 100644
--- a/test/float/ieee754/ftosdiveax.s
+++ b/test/float/ieee754/ftosdiveax.s
@@ -7,6 +7,6 @@
.import popax
.export ftosdiveax
-ftosdiveax:
+ftosdiveax:
; FIXME
- rts
+ rts
diff --git a/test/float/ieee754/ftosmuleax.s b/test/float/ieee754/ftosmuleax.s
index cf22d6d86..1f28e7d39 100644
--- a/test/float/ieee754/ftosmuleax.s
+++ b/test/float/ieee754/ftosmuleax.s
@@ -7,6 +7,6 @@
.import popax
.export ftosmuleax
-ftosmuleax:
+ftosmuleax:
; FIXME
- rts
+ rts
diff --git a/test/float/ieee754/ftossubeax.s b/test/float/ieee754/ftossubeax.s
index 6c7167f53..e5bd636d4 100644
--- a/test/float/ieee754/ftossubeax.s
+++ b/test/float/ieee754/ftossubeax.s
@@ -7,11 +7,11 @@
.include "ieee754.inc"
.import ftosaddeax
-
+
.export ftossubeax
ftossubeax:
; FIXME
- rts
+ rts
; found at https://github.com/CrashAndSideburns/6502ieee754/blob/main/arithmetic/addition.s
; subtraction:
diff --git a/test/float/ieee754/ieee754.inc b/test/float/ieee754/ieee754.inc
index 76a8b69b1..bc612046a 100644
--- a/test/float/ieee754/ieee754.inc
+++ b/test/float/ieee754/ieee754.inc
@@ -4,4 +4,4 @@ MANTISSA_ONE = $e4 ; e4, e5, e6, e7, e8, e9, ea (7 bytes)
SIGN_TWO = $eb
EXPONENT_TWO = $ec
-MANTISSA_TWO = $ed
+MANTISSA_TWO = $ed
diff --git a/test/float/include/_float.h b/test/float/include/_float.h
index e490a8b9e..9bef30b40 100644
--- a/test/float/include/_float.h
+++ b/test/float/include/_float.h
@@ -3,12 +3,12 @@
#define _FLOAT_H_
/* ieee754 32bit format:
- *
+ *
* sign
* / /exponent/mantissa
* 3 32222222 22211111111110000000000
* 1 09876543 21098765432109876543210
- *
+ *
* The sign is stored in bit 31.
* The exponent can be computed from bits 23-30 by subtracting 127. (128 = 2^1)
* The mantissa is stored in bits 0-22.
@@ -51,4 +51,4 @@ float __fastcall__ _strtof(char *d);
#define _fpreset()
#endif /* _FLOAT_H_ */
-
+
diff --git a/test/float/include/math.h b/test/float/include/math.h
index 99117b8be..e0c82d917 100644
--- a/test/float/include/math.h
+++ b/test/float/include/math.h
@@ -49,4 +49,4 @@ float __fastcall__ _fatan2(float x, float y);
float ffloor(float x);
#endif /* _MATH_H_ */
-
+
diff --git a/test/float/woz/ftoseqeax.s b/test/float/woz/ftoseqeax.s
index 8fc2d2a47..0892f9cbe 100644
--- a/test/float/woz/ftoseqeax.s
+++ b/test/float/woz/ftoseqeax.s
@@ -1,5 +1,5 @@
.include "wozfp.inc"
-
+
.export ftoseqeax
ftoseqeax:
; FIXME
diff --git a/test/float/woz/ftosgeeax.s b/test/float/woz/ftosgeeax.s
index 3fce6f942..3451f234c 100644
--- a/test/float/woz/ftosgeeax.s
+++ b/test/float/woz/ftosgeeax.s
@@ -1,5 +1,5 @@
.include "wozfp.inc"
-
+
.export ftosgeeax
ftosgeeax:
; FIXME
diff --git a/test/float/woz/ftosgteax.s b/test/float/woz/ftosgteax.s
index f73c4a23c..c4593c051 100644
--- a/test/float/woz/ftosgteax.s
+++ b/test/float/woz/ftosgteax.s
@@ -1,5 +1,5 @@
.include "wozfp.inc"
-
+
.export ftosgteax
ftosgteax:
; FIXME
diff --git a/test/float/woz/ftosleeax.s b/test/float/woz/ftosleeax.s
index f3b7030fe..796de511e 100644
--- a/test/float/woz/ftosleeax.s
+++ b/test/float/woz/ftosleeax.s
@@ -1,5 +1,5 @@
.include "wozfp.inc"
-
+
.export ftosleeax
ftosleeax:
; FIXME
diff --git a/test/float/woz/ftoslteax.s b/test/float/woz/ftoslteax.s
index 5e6c26ac5..7c6af14db 100644
--- a/test/float/woz/ftoslteax.s
+++ b/test/float/woz/ftoslteax.s
@@ -1,5 +1,5 @@
.include "wozfp.inc"
-
+
.export ftoslteax
ftoslteax:
; FIXME
diff --git a/test/float/woz/ftosneeax.s b/test/float/woz/ftosneeax.s
index faee42aa4..95f85df7b 100644
--- a/test/float/woz/ftosneeax.s
+++ b/test/float/woz/ftosneeax.s
@@ -1,5 +1,5 @@
.include "wozfp.inc"
-
+
.export ftosneeax
ftosneeax:
; FIXME
diff --git a/test/float/woz/ftossubeax.s b/test/float/woz/ftossubeax.s
index f66cb7386..34d6ba012 100644
--- a/test/float/woz/ftossubeax.s
+++ b/test/float/woz/ftossubeax.s
@@ -5,4 +5,4 @@ ftossubeax:
; FIXME
lda #0
tax
- rts
+ rts
diff --git a/test/float/woz/wozfp.inc b/test/float/woz/wozfp.inc
index d53ad5940..272e42e9e 100644
--- a/test/float/woz/wozfp.inc
+++ b/test/float/woz/wozfp.inc
@@ -13,4 +13,4 @@
SEXP = T+4
INT = SEXP+4
;
-
+
From 63024cd0563b66e6de01d737f9474c8efb9a1174 Mon Sep 17 00:00:00 2001
From: mrdudz
Date: Thu, 21 Jul 2022 00:54:53 +0200
Subject: [PATCH 008/139] cleanup
---
test/float/floattest.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/test/float/floattest.c b/test/float/floattest.c
index c100e2256..56aa30225 100644
--- a/test/float/floattest.c
+++ b/test/float/floattest.c
@@ -97,7 +97,7 @@ void testatan2(void)
cplot(fx, fy);
fd = fatan2((float)(fx-CXNUM2), (float)(fy-CYNUM2));
- _ftostr(strbuf, fd);
+ _ftostr(strbuf, fd);
cputs(strbuf);
}
}
From 77ce005d0a18e15b468b249f094b7a4a774516fc Mon Sep 17 00:00:00 2001
From: mrdudz
Date: Thu, 21 Jul 2022 02:06:47 +0200
Subject: [PATCH 009/139] more cleanup
---
src/cc65/assignment.c | 20 +++++++-----
src/cc65/codegen.c | 68 ++++++++++++++++++++++++++--------------
src/cc65/codegen.h | 11 ++++---
src/cc65/expr.c | 2 ++
src/cc65/initdata.c | 15 ++++++---
src/cc65/loadexpr.c | 2 +-
test/float/Makefile | 67 +++++++++++++++++++++------------------
test/float/float-basic.c | 2 +-
8 files changed, 114 insertions(+), 73 deletions(-)
diff --git a/src/cc65/assignment.c b/src/cc65/assignment.c
index 112db7c10..fef4e1c1f 100644
--- a/src/cc65/assignment.c
+++ b/src/cc65/assignment.c
@@ -31,7 +31,7 @@
/* */
/*****************************************************************************/
-
+//#define DEBUG
/* cc65 */
#include "asmcode.h"
@@ -47,7 +47,13 @@
#include "typecmp.h"
#include "typeconv.h"
-
+#ifdef DEBUG
+#define LOG(x) printf x
+#define FIXME(x) printf x
+#else
+#define LOG(x)
+#define FIXME(x)
+#endif
/*****************************************************************************/
/* Data */
@@ -434,7 +440,7 @@ static void OpAssignArithmetic (const GenDesc* Gen, ExprDesc* Expr, const char*
unsigned Flags;
int MustScale;
- printf("OpAssignArithmetic (Gen=%d)\n", (int)Gen);
+ LOG(("OpAssignArithmetic (Gen=%d)\n", (int)Gen));
ED_Init (&Expr2);
Expr2.Flags |= Expr->Flags & E_MASK_KEEP_SUBEXPR;
@@ -464,9 +470,9 @@ static void OpAssignArithmetic (const GenDesc* Gen, ExprDesc* Expr, const char*
/* If necessary, load the value into the primary register */
LoadExpr (CF_NONE, &Expr2);
-printf("OpAssignArithmetic (0) 2 lhs: %s rhs: %s\n",
- (TypeOf (Expr->Type) == CF_FLOAT) ? "float" : "int",
- (TypeOf (Expr2.Type) == CF_FLOAT) ? "float" : "int");
+ LOG(("OpAssignArithmetic (0) 2 lhs: %s rhs: %s\n",
+ (TypeOf (Expr->Type) == CF_FLOAT) ? "float" : "int",
+ (TypeOf (Expr2.Type) == CF_FLOAT) ? "float" : "int"));
} else {
/* Load the original value if necessary */
@@ -567,7 +573,7 @@ void OpAssign (const GenDesc* Gen, ExprDesc* Expr, const char* Op)
{
const Type* ltype = Expr->Type;
- printf("OpAssign\n");
+ LOG(("OpAssign\n"));
ExprDesc Expr2;
ED_Init (&Expr2);
diff --git a/src/cc65/codegen.c b/src/cc65/codegen.c
index 33781ab34..d043a1c96 100644
--- a/src/cc65/codegen.c
+++ b/src/cc65/codegen.c
@@ -39,6 +39,8 @@
#include
#include
+//#define DEBUG
+
/* common */
#include "addrsize.h"
#include "check.h"
@@ -64,7 +66,13 @@
#include "util.h"
#include "codegen.h"
-
+#ifdef DEBUG
+#define LOG(x) printf x
+#define FIXME(x) printf x
+#else
+#define LOG(x)
+#define FIXME(x)
+#endif
/*****************************************************************************/
/* Helpers */
@@ -689,15 +697,19 @@ void g_restore_regvars (int StackOffs, int RegOffs, unsigned Bytes)
/* Fetching memory cells */
/*****************************************************************************/
-//void _g_getimmed (unsigned Flags, uintptr_t Val, long Offs, char *file, int line);
+#ifdef DEBUG
#define g_getimmed(a,b,c) _g_getimmed((a),(b),(c),(__FILE__),(__FUNCTION__),(__LINE__))
-
void _g_getimmed(unsigned Flags, uintptr_t Val, long Offs, char *file, char *func, int line)
+#else
+#define g_getimmed(a,b,c) _g_getimmed((a),(b),(c))
+void _g_getimmed(unsigned Flags, uintptr_t Val, long Offs)
+#endif
/* Load a constant into the primary register */
{
unsigned char B1, B2, B3, B4;
unsigned Done;
-printf("g_getimmed %s:%d:%s Flags:%04x Val: %08x Offs:%04x\n", file, line, func, Flags, Val, Offs);
+
+ LOG(("g_getimmed %s:%d:%s Flags:%04x Val: %08x Offs:%04x\n", file, line, func, Flags, Val, Offs));
if ((Flags & CF_CONST) != 0) {
@@ -716,7 +728,8 @@ printf("g_getimmed %s:%d:%s Flags:%04x Val: %08x Offs:%04x\n", file, line, func,
break;
case CF_FLOAT: /* FIXME float - handle like long here */
-printf("g_getimmed CF_FLOAT Val: %08lx\n", Val);
+
+ LOG(("g_getimmed CF_FLOAT Val: %08lx\n", Val));
case CF_LONG:
/* Split the value into 4 bytes */
B1 = (unsigned char) (Val >> 0);
@@ -899,7 +912,7 @@ void g_getind (unsigned Flags, unsigned Offs)
** into the primary register
*/
{
- printf("g_getind flags:%04x offs:%04x\n", Flags, Offs);
+ LOG(("g_getind flags:%04x offs:%04x\n", Flags, Offs));
/* If the offset is greater than 255, add the part that is > 255 to
** the primary. This way we get an easy addition and use the low byte
** as the offset
@@ -1106,7 +1119,7 @@ void g_putstatic (unsigned flags, uintptr_t label, long offs)
void g_putlocal (unsigned Flags, int Offs, long Val)
/* Put data into local object. */
{
- printf("g_putlocal Flags:%04x Offs:%d val: %ld\n", Flags, Offs, Val);
+ LOG(("g_putlocal Flags:%04x Offs:%d val: %ld\n", Flags, Offs, Val));
Offs -= StackPtr;
CheckLocalOffs (Offs);
switch (Flags & CF_TYPEMASK) {
@@ -1324,7 +1337,7 @@ static void g_regchar (unsigned Flags)
void g_regint (unsigned Flags)
/* Make sure, the value in the primary register is an int. Convert if necessary */
{
- printf("g_regint flags: %04x\n", Flags);
+ LOG(("g_regint flags: %04x\n", Flags));
switch (Flags & CF_TYPEMASK) {
case CF_CHAR:
@@ -1408,7 +1421,7 @@ void g_reglong (unsigned Flags)
void g_regfloat (unsigned Flags)
/* Make sure, the value in the primary register is a float. Convert if necessary */
{
- printf("g_regfloat flags: %04x\n", Flags);
+ LOG(("g_regfloat flags: %04x\n", Flags));
switch (Flags & CF_TYPEMASK) {
case CF_CHAR:
@@ -1498,11 +1511,11 @@ unsigned g_typeadjust (unsigned lhs, unsigned rhs)
return const_flag | CF_FLOAT;
}
if (ltype == CF_FLOAT) {
- printf("FIXME: conversion to float format missing\n");
+ FIXME(("FIXME: conversion to float format missing\n"));
return (lhs & CF_CONST) | CF_FLOAT;
}
if (rtype == CF_FLOAT) {
- printf("FIXME: conversion to float format missing\n");
+ FIXME("FIXME: conversion to float format missing\n");
return (rhs & CF_CONST) | CF_FLOAT;
}
@@ -1597,11 +1610,11 @@ unsigned g_typecast (unsigned lhs, unsigned rhs)
** by the lhs value. Return the result value.
*/
{
-printf("g_typecast 2 rhs: %s lhs: %s (rhs is %s)\n",
- ((rhs & CF_TYPEMASK) == CF_FLOAT) ? "float" : "int",
- ((lhs & CF_TYPEMASK) == CF_FLOAT) ? "float" : "int",
- ((rhs & CF_CONST) == 0) ? "not const" : "const"
- );
+ LOG(("g_typecast 2 rhs: %s lhs: %s (rhs is %s)\n",
+ ((rhs & CF_TYPEMASK) == CF_FLOAT) ? "float" : "int",
+ ((lhs & CF_TYPEMASK) == CF_FLOAT) ? "float" : "int",
+ ((rhs & CF_CONST) == 0) ? "not const" : "const"
+ ));
/* Check if a conversion is needed */
if ((rhs & CF_CONST) == 0) {
switch (lhs & CF_TYPEMASK) {
@@ -2531,7 +2544,7 @@ void g_push (unsigned flags, unsigned long val)
void g_push_float (unsigned flags, float val)
/* Push the primary register or a constant value onto the stack */
{
-// printf("g_push_float flags:%04x val:%f\n", flags, val);
+// LOG(("g_push_float flags:%04x val:%f\n", flags, val));
/* Push the primary register */
switch (flags & CF_TYPEMASK) {
@@ -2539,11 +2552,18 @@ void g_push_float (unsigned flags, float val)
/* Value is not 16 bit or not constant */
// if (flags & CF_CONST)
{
- float f = val;
+// float f = val;
+#if 0
uintptr_t *p = &val; /* FIXME: float - we shouldnt do this :) */
/* Constant 32 bit value, load into eax */
- printf("g_push_float flags:%04x f:%p\n", flags, *p);
+ LOG(("g_push_float flags:%04x f:%p\n", flags, *p));
g_getimmed (flags | CF_CONST, *p, 0); // ?? FIXME
+#else
+ uint32_t *p = ((uint32_t*)&val); /* FIXME: float - we shouldnt do this :) */
+ /* Constant 32 bit value, load into eax */
+ LOG(("g_push_float flags:%04x f:%p\n", flags, *p));
+ g_getimmed (flags | CF_CONST, *p, 0); // ?? FIXME
+#endif
// g_getimmed (0x41,*p,0);
}
AddCodeLine ("jsr pusheax");
@@ -2818,7 +2838,7 @@ void g_mul (unsigned flags, unsigned long val)
"ftosmuleax"
};
- printf("g_mul flags:%04x val:%d\n", flags, val);
+ LOG(("g_mul flags:%04x val:%d\n", flags, val));
/* Do strength reduction if the value is constant and a power of two */
if (flags & CF_CONST) {
@@ -2946,7 +2966,7 @@ void g_div (unsigned flags, unsigned long val)
"ftosdiveax"
};
- printf("g_div flags:%04x val:%d\n", flags, val);
+ LOG(("g_div flags:%04x val:%d\n", flags, val));
/* Do strength reduction if the value is constant and a power of two */
if (flags & CF_CONST) {
@@ -3696,7 +3716,7 @@ void g_inc (unsigned flags, unsigned long val)
if flags contain CF_FLOAT, then val can be a raw binary float.
*/
{
- printf("g_inc flags:%04x val:%08lx\n", flags, val);
+ LOG(("g_inc flags:%04x val:%08lx\n", flags, val));
/* Don't inc by zero */
if (val == 0) {
return;
@@ -3917,7 +3937,7 @@ void g_eq (unsigned flags, unsigned long val)
};
unsigned L;
- printf("g_eq flags:%04x val:%ld\n", flags, val);
+ LOG(("g_eq flags:%04x val:%ld\n", flags, val));
/* If the right hand side is const, the lhs is not on stack but still
** in the primary register.
*/
@@ -4698,7 +4718,7 @@ void g_defdata (unsigned flags, uintptr_t val, long offs)
void g_defdata_float (unsigned flags, uintptr_t val, long offs)
/* Define data with the size given in flags */
{
- printf("g_defdata_float flags:%04x val:%f offs:%04lx\n", flags, (float)val, offs);
+ LOG(("g_defdata_float flags:%04x val:%f offs:%04lx\n", flags, (float)val, offs));
if (flags & CF_CONST) {
/* Numeric constant */
diff --git a/src/cc65/codegen.h b/src/cc65/codegen.h
index b5fe6daf1..ddc7832ac 100644
--- a/src/cc65/codegen.h
+++ b/src/cc65/codegen.h
@@ -270,13 +270,14 @@ void g_restore_regvars (int StackOffs, int RegOffs, unsigned Bytes);
/*****************************************************************************/
-
-//void g_getimmed (unsigned Flags, uintptr_t Val, long Offs);
-/* Load a constant into the primary register */
-
+#ifdef DEBUG
#define g_getimmed(a,b,c) _g_getimmed((a),(b),(c),(__FILE__),(__FUNCTION__),(__LINE__))
void _g_getimmed(unsigned Flags, uintptr_t Val, long Offs, char *file, char *func, int line);
-
+#else
+#define g_getimmed(a,b,c) _g_getimmed((a),(b),(c))
+void _g_getimmed (unsigned Flags, uintptr_t Val, long Offs);
+#endif
+/* Load a constant into the primary register */
void g_getstatic (unsigned Flags, uintptr_t Label, long Offs);
/* Fetch an static memory cell into the primary register */
diff --git a/src/cc65/expr.c b/src/cc65/expr.c
index fe7e2ad82..cf7d26f23 100644
--- a/src/cc65/expr.c
+++ b/src/cc65/expr.c
@@ -2067,6 +2067,8 @@ static void hie_internal (const GenDesc* Ops, /* List of generators */
case TOK_DIV:
floatop = 1;
break;
+ default:
+ break;
}
/* FIXME: float ---start end code*/
diff --git a/src/cc65/initdata.c b/src/cc65/initdata.c
index 18ba45d6c..1cf9318ca 100644
--- a/src/cc65/initdata.c
+++ b/src/cc65/initdata.c
@@ -31,10 +31,11 @@
/* */
/*****************************************************************************/
-
+//#define DEBUG
#include
#include
+#include
#include
#include
@@ -65,7 +66,13 @@
#include "typeconv.h"
#include "initdata.h"
-
+#ifdef DEBUG
+#define LOG(x) printf x
+#define FIXME(x) printf x
+#else
+#define LOG(x)
+#define FIXME(x)
+#endif
/*****************************************************************************/
/* Data */
@@ -166,8 +173,8 @@ static void DefineData (ExprDesc* Expr)
{
int isfloat = (TypeOf (Expr->Type) == CF_FLOAT);
- printf("%s:%d DefineData IVal: %ld V.FVal: %f isfloat:%d %d\n", __FILE__, __LINE__,
- Expr->IVal, (double)(Expr->V.FVal.V), isfloat, ED_GetLoc (Expr));
+ LOG(("%s:%d DefineData IVal: %ld V.FVal: %f isfloat:%d %d\n", __FILE__, __LINE__,
+ Expr->IVal, (double)(Expr->V.FVal.V), isfloat, ED_GetLoc (Expr)));
switch (ED_GetLoc (Expr)) {
case E_LOC_NONE:
diff --git a/src/cc65/loadexpr.c b/src/cc65/loadexpr.c
index fda3c133d..90f973827 100644
--- a/src/cc65/loadexpr.c
+++ b/src/cc65/loadexpr.c
@@ -31,7 +31,7 @@
/* */
/*****************************************************************************/
-
+#include
/* cc65 */
#include "codegen.h"
diff --git a/test/float/Makefile b/test/float/Makefile
index f562321c8..7b5e75d92 100644
--- a/test/float/Makefile
+++ b/test/float/Makefile
@@ -1,4 +1,9 @@
+CC65=../../bin/cc65
+CL65=../../bin/cl65
+CA65=../../bin/ca65
+SIM65=../../bin/sim65
+
OPT=
FILES=\
@@ -80,61 +85,61 @@ WOZRUNTIME=\
all: $(FILES)
float-minimal.s: float-minimal.c $(HEADER) $(IEEERUNTIME)
- cc65 $(OPT) -t sim6502 -I ./include --add-source -o float-minimal.s float-minimal.c
+ $(CC65) $(OPT) -t sim6502 -I ./include --add-source -o float-minimal.s float-minimal.c
float-minimal.bin: float-minimal.s $(HEADER) $(IEEERUNTIME)
- cl65 $(OPT) -t sim6502 -I ./include -o float-minimal.bin float-minimal.s $(IEEERUNTIME)
+ $(CL65) $(OPT) -t sim6502 -I ./include -o float-minimal.bin float-minimal.s $(IEEERUNTIME)
float-basic.s: float-basic.c $(HEADER) $(IEEERUNTIME)
- cc65 $(OPT) -t sim6502 -I ./include --add-source -o float-basic.s float-basic.c
+ $(CC65) $(OPT) -t sim6502 -I ./include --add-source -o float-basic.s float-basic.c
float-basic.bin: float-basic.s $(HEADER) $(IEEERUNTIME)
- cl65 $(OPT) -t sim6502 -I ./include -o float-basic.bin float-basic.s $(IEEERUNTIME)
+ $(CL65) $(OPT) -t sim6502 -I ./include -o float-basic.bin float-basic.s $(IEEERUNTIME)
float-basic-cmp.s: float-basic-cmp.c $(HEADER) $(IEEERUNTIME)
- cc65 $(OPT) -t sim6502 -I ./include --add-source -o float-basic-cmp.s float-basic-cmp.c
+ $(CC65) $(OPT) -t sim6502 -I ./include --add-source -o float-basic-cmp.s float-basic-cmp.c
float-basic-cmp.bin: float-basic-cmp.s $(HEADER) $(IEEERUNTIME)
- cl65 $(OPT) -t sim6502 -I ./include -o float-basic-cmp.bin float-basic-cmp.s $(IEEERUNTIME)
+ $(CL65) $(OPT) -t sim6502 -I ./include -o float-basic-cmp.bin float-basic-cmp.s $(IEEERUNTIME)
###############################################################################
float-minimal.woz.s: float-minimal.c $(HEADER) $(WOZRUNTIME)
- cc65 $(OPT) -t sim6502 -I ./include --add-source -o float-minimal.woz.s float-minimal.c
+ $(CC65) $(OPT) -t sim6502 -I ./include --add-source -o float-minimal.woz.s float-minimal.c
float-minimal.woz.bin: float-minimal.woz.s $(HEADER) $(WOZRUNTIME)
- cl65 $(OPT) -t sim6502 -I ./include -o float-minimal.woz.bin float-minimal.woz.s $(WOZRUNTIME)
+ $(CL65) $(OPT) -t sim6502 -I ./include -o float-minimal.woz.bin float-minimal.woz.s $(WOZRUNTIME)
float-basic.woz.s: float-basic.c $(HEADER) $(WOZRUNTIME)
- cc65 $(OPT) -t sim6502 -I ./include --add-source -o float-basic.woz.s float-basic.c
+ $(CC65) $(OPT) -t sim6502 -I ./include --add-source -o float-basic.woz.s float-basic.c
float-basic.woz.bin: float-basic.woz.s $(HEADER) $(WOZRUNTIME)
- cl65 $(OPT) -t sim6502 -I ./include -o float-basic.woz.bin float-basic.woz.s $(WOZRUNTIME)
+ $(CL65) $(OPT) -t sim6502 -I ./include -o float-basic.woz.bin float-basic.woz.s $(WOZRUNTIME)
float-basic-cmp.woz.s: float-basic-cmp.c $(HEADER) $(WOZRUNTIME)
- cc65 $(OPT) -t sim6502 -I ./include --add-source -o float-basic-cmp.woz.s float-basic-cmp.c
+ $(CC65) $(OPT) -t sim6502 -I ./include --add-source -o float-basic-cmp.woz.s float-basic-cmp.c
float-basic-cmp.woz.bin: float-basic-cmp.woz.s $(HEADER) $(WOZRUNTIME)
- cl65 $(OPT) -t sim6502 -I ./include -o float-basic-cmp.woz.bin float-basic-cmp.woz.s $(WOZRUNTIME)
+ $(CL65) $(OPT) -t sim6502 -I ./include -o float-basic-cmp.woz.bin float-basic-cmp.woz.s $(WOZRUNTIME)
###############################################################################
float-minimal.c64.s: float-minimal.c $(HEADER) $(CBMRUNTIME)
- cc65 $(OPT) -DCONIO -t c64 -I ./include -I ./cbmkernal --add-source -o float-minimal.c64.s float-minimal.c
+ $(CC65) $(OPT) -DCONIO -t c64 -I ./include -I ./cbmkernal --add-source -o float-minimal.c64.s float-minimal.c
float-minimal.prg: float-minimal.c64.s $(HEADER) $(CBMRUNTIME)
- cl65 $(OPT) -t c64 -I ./include -I ./cbmkernal -o float-minimal.prg float-minimal.c64.s $(CBMRUNTIME)
+ $(CL65) $(OPT) -t c64 -I ./include -I ./cbmkernal -o float-minimal.prg float-minimal.c64.s $(CBMRUNTIME)
float-basic.c64.s: float-basic.c $(HEADER) $(CBMRUNTIME)
- cc65 $(OPT) -DCONIO -t c64 -I ./include -I ./cbmkernal --add-source -o float-basic.c64.s float-basic.c
+ $(CC65) $(OPT) -DCONIO -t c64 -I ./include -I ./cbmkernal --add-source -o float-basic.c64.s float-basic.c
float-basic.prg: float-basic.c64.s $(HEADER) $(CBMRUNTIME)
- cl65 $(OPT) -t c64 -I ./include -I ./cbmkernal -o float-basic.prg float-basic.c64.s $(CBMRUNTIME)
+ $(CL65) $(OPT) -t c64 -I ./include -I ./cbmkernal -o float-basic.prg float-basic.c64.s $(CBMRUNTIME)
float-basic-cmp.c64.s: float-basic-cmp.c $(HEADER) $(CBMRUNTIME)
- cc65 $(OPT) -DCONIO -t c64 -I ./include -I ./cbmkernal --add-source -o float-basic-cmp.c64.s float-basic-cmp.c
+ $(CC65) $(OPT) -DCONIO -t c64 -I ./include -I ./cbmkernal --add-source -o float-basic-cmp.c64.s float-basic-cmp.c
float-basic-cmp.prg: float-basic-cmp.c64.s $(HEADER) $(CBMRUNTIME)
- cl65 $(OPT) -t c64 -I ./include -I ./cbmkernal -o float-basic-cmp.prg float-basic-cmp.c64.s $(CBMRUNTIME)
+ $(CL65) $(OPT) -t c64 -I ./include -I ./cbmkernal -o float-basic-cmp.prg float-basic-cmp.c64.s $(CBMRUNTIME)
floattest.c64.s: floattest.c $(HEADER) $(CBMRUNTIME)
- cc65 $(OPT) -DCONIO -t c64 -I ./include -I ./cbmkernal --add-source -o floattest.c64.s floattest.c
+ $(CC65) $(OPT) -DCONIO -t c64 -I ./include -I ./cbmkernal --add-source -o floattest.c64.s floattest.c
floattest.prg: floattest.c64.s $(HEADER) $(CBMRUNTIME)
- cl65 $(OPT) -t c64 -I ./include -I ./cbmkernal -o floattest.prg floattest.c64.s $(CBMRUNTIME)
+ $(CL65) $(OPT) -t c64 -I ./include -I ./cbmkernal -o floattest.prg floattest.c64.s $(CBMRUNTIME)
quick.c64.s: quick.c $(HEADER) $(CBMRUNTIME)
- cc65 $(OPT) -DCONIO -t c64 -I ./include -I ./cbmkernal --add-source -o quick.c64.s quick.c
+ $(CC65) $(OPT) -DCONIO -t c64 -I ./include -I ./cbmkernal --add-source -o quick.c64.s quick.c
quick.prg: quick.c64.s $(HEADER) $(CBMRUNTIME)
- cl65 $(OPT) -t c64 -I ./include -I ./cbmkernal -o quick.prg quick.c64.s $(CBMRUNTIME)
+ $(CL65) $(OPT) -t c64 -I ./include -I ./cbmkernal -o quick.prg quick.c64.s $(CBMRUNTIME)
runquick: quick.prg
x64sc -autostartprgmode 1 quick.prg
###############################################################################
@@ -156,21 +161,21 @@ rungcc: gccminimal gccbasic gccbasiccmp gccfloattest
###############################################################################
runminimal: float-minimal.bin
- sim65 float-minimal.bin
+ $(SIM65) float-minimal.bin
runbasic: float-basic.bin
- sim65 float-basic.bin
+ $(SIM65) float-basic.bin
runbasiccmp: float-basic-cmp.bin
- sim65 float-basic-cmp.bin
+ $(SIM65) float-basic-cmp.bin
run: runminimal runbasic runbasiccmp
- sim65 float-minimal.bin
- sim65 float-basic.bin
- sim65 float-basic-cmp.bin
+ $(SIM65) float-minimal.bin
+ $(SIM65) float-basic.bin
+ $(SIM65) float-basic-cmp.bin
runwoz: float-minimal.woz.bin float-basic.woz.bin float-basic-cmp.woz.bin
- sim65 float-minimal.woz.bin
- sim65 float-basic.woz.bin
- sim65 float-basic-cmp.woz.bin
+ $(SIM65) float-minimal.woz.bin
+ $(SIM65) float-basic.woz.bin
+ $(SIM65) float-basic-cmp.woz.bin
###############################################################################
diff --git a/test/float/float-basic.c b/test/float/float-basic.c
index f8ba23aa5..5ee4e0a7f 100644
--- a/test/float/float-basic.c
+++ b/test/float/float-basic.c
@@ -63,7 +63,7 @@ int main(void)
#endif
/* addition, constant + constant (already tested by minimal) (omitted) */
#ifdef CONIO
- cgetc();
+ printf("\n");cgetc();
#endif
#if 0
From 6001f5d0e08942e8aa83c5d8cf4e7d04f2e9c0a0 Mon Sep 17 00:00:00 2001
From: mrdudz
Date: Thu, 21 Jul 2022 02:31:55 +0200
Subject: [PATCH 010/139] silence more debug stuff
---
src/cc65/expr.c | 50 +++++++++++++++++++++++++--------------------
src/cc65/loadexpr.c | 36 +++++++++++++++++++-------------
src/cc65/locals.c | 14 +++++++++----
src/cc65/scanner.c | 16 ++++++++++-----
src/cc65/typeconv.c | 44 ++++++++++++++++++++++-----------------
5 files changed, 96 insertions(+), 64 deletions(-)
diff --git a/src/cc65/expr.c b/src/cc65/expr.c
index cf7d26f23..0285fab1b 100644
--- a/src/cc65/expr.c
+++ b/src/cc65/expr.c
@@ -4,7 +4,7 @@
** 2020-11-20, Greg King
*/
-
+//#define DEBUG
#include
#include
@@ -40,7 +40,13 @@
#include "typeconv.h"
#include "expr.h"
-
+#ifdef DEBUG
+#define LOG(x) printf x
+#define FIXME(x) printf x
+#else
+#define LOG(x)
+#define FIXME(x)
+#endif
/*****************************************************************************/
/* Data */
@@ -2044,7 +2050,7 @@ static void hie_internal (const GenDesc* Ops, /* List of generators */
int rconst; /* Right operand is a constant */
int floatop = 0;
-//printf("hie_internal\n");
+//LOG(("hie_internal\n"));
ExprWithCheck (hienext, Expr);
*UsedGen = 0;
@@ -2124,7 +2130,7 @@ static void hie_internal (const GenDesc* Ops, /* List of generators */
) {
Error ("RHS Integer expression expected (hie_internal)");
}
-printf("hie_internal lconst:%d rconst:%d\n", lconst, rconst);
+ LOG(("hie_internal lconst:%d rconst:%d\n", lconst, rconst));
/* Check for const operands */
if (lconst && rconst) {
@@ -2135,14 +2141,14 @@ printf("hie_internal lconst:%d rconst:%d\n", lconst, rconst);
Expr->Type = ArithmeticConvert (Expr->Type, Expr2.Type);
/* FIXME: float --- newcode start */
-printf("hie_internal Expr->Type:%s Expr2->Type:%s\n",
+LOG(("hie_internal Expr->Type:%s Expr2->Type:%s\n",
(IsClassFloat (Expr->Type) == CF_FLOAT) ? "float" : "int",
(IsClassFloat (Expr2.Type) == CF_FLOAT) ? "float" : "int"
- );
-printf("hie_internal Expr->Type:%s Expr2->Type:%s\n",
+ ));
+LOG(("hie_internal Expr->Type:%s Expr2->Type:%s\n",
(Expr->Type == type_float) ? "float" : "int",
(Expr2.Type == type_float) ? "float" : "int"
- );
+ ));
/* FIXME: float */
/* FIXME: right now this works only when both rhs and lhs are float,
@@ -2154,7 +2160,7 @@ printf("hie_internal Expr->Type:%s Expr2->Type:%s\n",
/* Evaluate the result for float operands */
Double Val1 = Expr->V.FVal;
Double Val2 = Expr2.V.FVal;
- printf("hie_internal float X float\n");
+ LOG(("hie_internal float X float\n"));
switch (Tok) {
case TOK_DIV:
#if 0 // TODO
@@ -2175,7 +2181,7 @@ printf("hie_internal Expr->Type:%s Expr2->Type:%s\n",
}
/* FIXME: float --- newcode end */
} else {
- printf("hie_internal signed int X signed int\n");
+ LOG(("hie_internal signed int X signed int\n"));
/* Handle the op differently for signed and unsigned types */
if (IsSignSigned (Expr->Type)) {
@@ -2215,7 +2221,7 @@ printf("hie_internal Expr->Type:%s Expr2->Type:%s\n",
Internal ("hie_internal: got token 0x%X\n", Tok);
}
} else {
- printf("hie_internal unsigned int X unsigned int\n");
+ LOG(("hie_internal unsigned int X unsigned int\n"));
/* Evaluate the result for unsigned operands */
unsigned long Val1 = Expr->IVal;
@@ -2373,7 +2379,7 @@ static void hie_compare (const GenDesc* Ops, /* List of generators */
if (ED_IsConstAbs (Expr)) {
/* Numeric constant value */
GetCodePos (&Mark2);
-// printf("iVal:%08x FVal:%f\n", Expr->IVal, Expr->V.FVal.V);
+// LOG(("iVal:%08x FVal:%f\n", Expr->IVal, Expr->V.FVal.V));
g_push (ltype | CF_CONST, Expr->IVal);
} else {
/* Value not numeric constant */
@@ -2838,11 +2844,11 @@ static void parseadd (ExprDesc* Expr, int DoArrayRef)
flags = CF_INT;
} else if (!DoArrayRef && IsClassFloat (lhst) && IsClassFloat (rhst)) {
/* FIXME: float addition (const + const) */
- printf("%s:%d float addition (const + const)\n", __FILE__, __LINE__);
+ LOG(("%s:%d float addition (const + const)\n", __FILE__, __LINE__));
/* Integer addition */
flags = CF_FLOAT;
} else {
- printf("%s:%d OOPS\n", __FILE__, __LINE__);
+ LOG(("%s:%d OOPS\n", __FILE__, __LINE__));
/* OOPS */
AddDone = -1;
/* Avoid further errors */
@@ -2858,7 +2864,7 @@ static void parseadd (ExprDesc* Expr, int DoArrayRef)
Expr->Type = type_float;
//Expr->Type = ArithmeticConvert (Expr->Type, Expr2.Type);
AddDone = 1;
- printf("%s:%d float addition (const + const) res:%f\n", __FILE__, __LINE__, Expr->V.FVal.V);
+ LOG(("%s:%d float addition (const + const) res:%f\n", __FILE__, __LINE__, Expr->V.FVal.V));
} else {
/* integer + integer */
if (ED_IsAbs (&Expr2) &&
@@ -2983,10 +2989,10 @@ static void parseadd (ExprDesc* Expr, int DoArrayRef)
} else if (!DoArrayRef && IsClassFloat (lhst) && IsClassFloat (rhst)) {
/* Float addition */
/*flags |= typeadjust (Expr, &Expr2, 1);*/
- printf("%s:%d float addition (const + var)\n", __FILE__, __LINE__);
+ LOG(("%s:%d float addition (const + var)\n", __FILE__, __LINE__));
} else {
/* OOPS */
- printf("%s:%d OOPS\n", __FILE__, __LINE__);
+ LOG(("%s:%d OOPS\n", __FILE__, __LINE__));
AddDone = -1;
}
@@ -3080,14 +3086,14 @@ static void parseadd (ExprDesc* Expr, int DoArrayRef)
flags = typeadjust (Expr, &Expr2, 1);
} else if (!DoArrayRef && IsClassFloat (lhst) && IsClassFloat (rhst)) {
/* FIXME: float - what to do here exactly? */
- printf("%s:%d float addition (Expr2.V.FVal.V:%f)\n", __FILE__, __LINE__, Expr2.V.FVal.V);
+ LOG(("%s:%d float addition (Expr2.V.FVal.V:%f)\n", __FILE__, __LINE__, Expr2.V.FVal.V));
/* Float addition (variable+constant) */
/*flags = typeadjust (Expr, &Expr2, 1);*/
flags |= CF_FLOAT;
Expr->Type = Expr2.Type;
} else {
/* OOPS */
- printf("%s:%d OOPS\n", __FILE__, __LINE__);
+ LOG(("%s:%d OOPS\n", __FILE__, __LINE__));
AddDone = -1;
}
@@ -3142,7 +3148,7 @@ static void parseadd (ExprDesc* Expr, int DoArrayRef)
LoadExpr (CF_NONE, &Expr2);
} else if (!DoArrayRef && IsClassFloat (lhst) && IsClassFloat (rhst)) {
/* FIXME: float - what to do here exactly? */
- printf("%s:%d float addition (Expr2.V.FVal.V:%f)\n", __FILE__, __LINE__, Expr2.V.FVal.V);
+ LOG(("%s:%d float addition (Expr2.V.FVal.V:%f)\n", __FILE__, __LINE__, Expr2.V.FVal.V));
/* Float addition */
/* flags = typeadjust (Expr, &Expr2, 0); */
flags |= CF_FLOAT;
@@ -3150,7 +3156,7 @@ static void parseadd (ExprDesc* Expr, int DoArrayRef)
LoadExpr (CF_NONE, &Expr2);
} else {
/* OOPS */
- printf("%s:%d OOPS\n", __FILE__, __LINE__);
+ LOG(("%s:%d OOPS\n", __FILE__, __LINE__));
AddDone = -1;
/* We can't just goto End as that would leave the stack unbalanced */
}
@@ -3479,7 +3485,7 @@ static void parsesub (ExprDesc* Expr)
} else if (IsClassFloat (lhst) && IsClassFloat (rhst)) {
/* Float substraction */
/* FIXME: float - what to do here exactly? */
- printf("%s:%d float substraction\n", __FILE__, __LINE__);
+ LOG(("%s:%d float substraction\n", __FILE__, __LINE__));
/* Adjust operand types */
/*flags = typeadjust (Expr, &Expr2, 0);*/
flags = CF_FLOAT;
diff --git a/src/cc65/loadexpr.c b/src/cc65/loadexpr.c
index 90f973827..3c8ee053f 100644
--- a/src/cc65/loadexpr.c
+++ b/src/cc65/loadexpr.c
@@ -31,6 +31,8 @@
/* */
/*****************************************************************************/
+//#define DEBUG
+
#include
/* cc65 */
@@ -40,7 +42,13 @@
#include "global.h"
#include "loadexpr.h"
-
+#ifdef DEBUG
+#define LOG(x) printf x
+#define FIXME(x) printf x
+#else
+#define LOG(x)
+#define FIXME(x)
+#endif
/*****************************************************************************/
/* Code */
@@ -51,7 +59,7 @@
static void LoadAddress (unsigned Flags, ExprDesc* Expr)
/* Load the primary register with some address value. */
{
- printf("LoadAddress flags:%04x\n", Flags);
+ LOG(("LoadAddress flags:%04x\n", Flags));
switch (ED_GetLoc (Expr)) {
case E_LOC_ABS:
@@ -119,7 +127,7 @@ void LoadExpr (unsigned Flags, struct ExprDesc* Expr)
** unfortunately.
*/
{
- /*printf("LoadExpr flags:%4x\n", Flags);*/
+ /*LOG(("LoadExpr flags:%4x\n", Flags));*/
if (!ED_IsAddrExpr (Expr)) {
/* Lvalue. If this is a bit field its type is unsigned. But if the
@@ -172,12 +180,12 @@ void LoadExpr (unsigned Flags, struct ExprDesc* Expr)
}
/* Load the content of Expr */
- /*printf("LoadExpr ED_GetLoc:%04x\n", ED_GetLoc (Expr));*/
+ /*LOG(("LoadExpr ED_GetLoc:%04x\n", ED_GetLoc (Expr)));*/
switch (ED_GetLoc (Expr)) {
case E_LOC_NONE:
/* FIXME: float */
- /*printf("LoadExpr E_LOC_NONE (%s)\n", (TypeOf (Expr->Type) == CF_FLOAT) ? "float" : "integer");*/
+ /*LOG(("LoadExpr E_LOC_NONE (%s)\n", (TypeOf (Expr->Type) == CF_FLOAT) ? "float" : "integer"));*/
/* Immediate number constant */
if (TypeOf (Expr->Type) == CF_FLOAT) {
g_getimmed (Flags | CF_IMM | TypeOf (Expr->Type) | CF_CONST, FP_D_As32bitRaw(Expr->V.FVal), 0);
@@ -187,56 +195,56 @@ void LoadExpr (unsigned Flags, struct ExprDesc* Expr)
break;
case E_LOC_ABS:
- printf("LoadExpr E_LOC_ABS (%s)\n", (TypeOf (Expr->Type) == CF_FLOAT) ? "float" : "integer");
+ LOG(("LoadExpr E_LOC_ABS (%s)\n", (TypeOf (Expr->Type) == CF_FLOAT) ? "float" : "integer"));
if (TypeOf (Expr->Type) == CF_FLOAT) { printf("%s:%d FIXME: E_LOC_ABS\n", __FILE__, __LINE__); exit(-1); }
/* Absolute numeric addressed variable */
g_getstatic (Flags | CF_ABSOLUTE, Expr->IVal, 0);
break;
case E_LOC_GLOBAL:
- /* printf("LoadExpr E_LOC_GLOBAL (%s)\n", (TypeOf (Expr->Type) == CF_FLOAT) ? "float" : "integer"); */
+ /* LOG(("LoadExpr E_LOC_GLOBAL (%s)\n", (TypeOf (Expr->Type) == CF_FLOAT) ? "float" : "integer")); */
/* if (TypeOf (Expr->Type) == CF_FLOAT) { printf("%s:%d FIXME: E_LOC_GLOBAL\n", __FILE__, __LINE__); exit(-1); } */
/* Global variable, offset in IVal */
g_getstatic (Flags | CF_EXTERNAL, Expr->Name, Expr->IVal);
break;
case E_LOC_STATIC:
- /* printf("LoadExpr E_LOC_STATIC (%s)\n", (TypeOf (Expr->Type) == CF_FLOAT) ? "float" : "integer"); */
+ /* LOG(("LoadExpr E_LOC_STATIC (%s)\n", (TypeOf (Expr->Type) == CF_FLOAT) ? "float" : "integer")); */
/* if (TypeOf (Expr->Type) == CF_FLOAT) { printf("%s:%d FIXME: E_LOC_STATIC\n", __FILE__, __LINE__); exit(-1); } */
/* Static variable, offset in IVal */
g_getstatic (Flags | CF_STATIC, Expr->Name, Expr->IVal);
break;
case E_LOC_LITERAL:
- /* printf("LoadExpr E_LOC_LITERAL (%s)\n", (TypeOf (Expr->Type) == CF_FLOAT) ? "float" : "integer"); */
+ /* LOG(("LoadExpr E_LOC_LITERAL (%s)\n", (TypeOf (Expr->Type) == CF_FLOAT) ? "float" : "integer")); */
/* if (TypeOf (Expr->Type) == CF_FLOAT) { printf("%s:%d FIXME: E_LOC_LITERAL\n", __FILE__, __LINE__); exit(-1); } */
/* Literal in the literal pool, offset in IVal */
g_getstatic (Flags | CF_LITERAL, Expr->Name, Expr->IVal);
break;
case E_LOC_REGISTER:
- /* printf("LoadExpr E_LOC_REGISTER (%s)\n", (TypeOf (Expr->Type) == CF_FLOAT) ? "float" : "integer"); */
+ /* LOG(("LoadExpr E_LOC_REGISTER (%s)\n", (TypeOf (Expr->Type) == CF_FLOAT) ? "float" : "integer")); */
/* if (TypeOf (Expr->Type) == CF_FLOAT) { printf("%s:%d FIXME: E_LOC_REGISTER\n", __FILE__, __LINE__); exit(-1); } */
/* Register variable, offset in IVal */
g_getstatic (Flags | CF_REGVAR, Expr->Name, Expr->IVal);
break;
case E_LOC_CODE:
- /* printf("LoadExpr E_LOC_CODE (%s)\n", (TypeOf (Expr->Type) == CF_FLOAT) ? "float" : "integer"); */
+ /* LOG(("LoadExpr E_LOC_CODE (%s)\n", (TypeOf (Expr->Type) == CF_FLOAT) ? "float" : "integer")); */
/* if (TypeOf (Expr->Type) == CF_FLOAT) { printf("%s:%d FIXME: E_LOC_CODE\n", __FILE__, __LINE__); exit(-1); } */
/* Code label location, offset in IVal */
g_getstatic (Flags | CF_CODE, Expr->Name, Expr->IVal);
break;
case E_LOC_STACK:
- /* printf("LoadExpr E_LOC_STACK (%s)\n", (TypeOf (Expr->Type) == CF_FLOAT) ? "float" : "integer"); */
+ /* LOG(("LoadExpr E_LOC_STACK (%s)\n", (TypeOf (Expr->Type) == CF_FLOAT) ? "float" : "integer")); */
/* if (TypeOf (Expr->Type) == CF_FLOAT) { printf("%s:%d FIXME: E_LOC_STACK\n", __FILE__, __LINE__); exit(-1); } */
/* Fetch value on the stack (with offset in IVal) */
g_getlocal (Flags, Expr->IVal);
break;
case E_LOC_PRIMARY:
- /*printf("LoadExpr E_LOC_PRIMARY (%s)\n", (TypeOf (Expr->Type) == CF_FLOAT) ? "float" : "integer");*/
+ /*LOG(("LoadExpr E_LOC_PRIMARY (%s)\n", (TypeOf (Expr->Type) == CF_FLOAT) ? "float" : "integer"));*/
/*if (TypeOf (Expr->Type) == CF_FLOAT) { printf("%s:%d FIXME: E_LOC_PRIMARY\n", __FILE__, __LINE__); exit(-1); }*/
/* The primary register */
if (TypeOf (Expr->Type) == CF_FLOAT) {
@@ -261,7 +269,7 @@ void LoadExpr (unsigned Flags, struct ExprDesc* Expr)
break;
case E_LOC_EXPR:
- /*printf("LoadExpr E_LOC_EXPR (%s)\n", (TypeOf (Expr->Type) == CF_FLOAT) ? "float" : "integer");*/
+ /*LOG(("LoadExpr E_LOC_EXPR (%s)\n", (TypeOf (Expr->Type) == CF_FLOAT) ? "float" : "integer"));*/
/*if (TypeOf (Expr->Type) == CF_FLOAT) { printf("%s:%d FIXME: E_LOC_EXPR\n", __FILE__, __LINE__); exit(-1); }*/
/* Reference to address in primary with offset in IVal */
g_getind (Flags, Expr->IVal);
diff --git a/src/cc65/locals.c b/src/cc65/locals.c
index 9ee8a27d9..d11608ab2 100644
--- a/src/cc65/locals.c
+++ b/src/cc65/locals.c
@@ -31,7 +31,7 @@
/* */
/*****************************************************************************/
-
+//#define DEBUG
/* common */
#include "xmalloc.h"
@@ -56,7 +56,13 @@
#include "typeconv.h"
#include "input.h"
-
+#ifdef DEBUG
+#define LOG(x) printf x
+#define FIXME(x) printf x
+#else
+#define LOG(x)
+#define FIXME(x)
+#endif
/*****************************************************************************/
/* Code */
@@ -198,7 +204,7 @@ static void ParseAutoDecl (Declaration* Decl)
/* Get the size of the variable */
unsigned Size = SizeOf (Decl->Type);
- printf("ParseAutoDecl SIze:%d IsCompound:%d\n", Size, IsCompound);
+ LOG(("ParseAutoDecl SIze:%d IsCompound:%d\n", Size, IsCompound));
/* Check if this is a variable on the stack or in static memory */
if (IS_Get (&StaticLocals) == 0) {
@@ -278,7 +284,7 @@ static void ParseAutoDecl (Declaration* Decl)
/* Push the value */
if (TypeOf (Sym->Type) == CF_FLOAT) {
/* FIXME: float */
- printf("Expr.V.FVal.V: %f\n", Expr.V.FVal.V);
+ LOG(("ParseAutoDecl Expr.V.FVal.V: %f\n", Expr.V.FVal.V));
g_push_float (Flags | TypeOf (Sym->Type), Expr.V.FVal.V);
} else {
g_push (Flags | TypeOf (Sym->Type), Expr.IVal);
diff --git a/src/cc65/scanner.c b/src/cc65/scanner.c
index 020a70033..9d9671e4d 100644
--- a/src/cc65/scanner.c
+++ b/src/cc65/scanner.c
@@ -31,7 +31,7 @@
/* */
/*****************************************************************************/
-
+//#define DEBUG
#include
#include
@@ -59,7 +59,13 @@
#include "standard.h"
#include "symtab.h"
-
+#ifdef DEBUG
+#define LOG(x) printf x
+#define FIXME(x) printf x
+#else
+#define LOG(x)
+#define FIXME(x)
+#endif
/*****************************************************************************/
/* data */
@@ -620,7 +626,7 @@ static void NumericConst (void)
/* Float constant */
Double FVal = FP_D_FromInt (IVal); /* Convert to double */
- printf("NumericConst start IVal:%ld FVal: %f\n", IVal, FVal.V);
+ LOG(("NumericConst start IVal:%ld FVal: %f\n", IVal, FVal.V));
/* Check for a fractional part and read it */
if (CurC == '.') {
@@ -694,7 +700,7 @@ static void NumericConst (void)
}
}
- printf("NumericConst end FVal: %f\n", FVal.V);
+ LOG(("NumericConst end FVal: %f\n", FVal.V));
/* Check for a suffix and determine the type of the constant */
if (toupper (CurC) == 'F') {
@@ -709,7 +715,7 @@ static void NumericConst (void)
NextTok.Tok = TOK_FCONST;
}
- printf("NumericConst exit IsFloat:%d IVal: %ld FVal: %f\n", IsFloat, NextTok.IVal, NextTok.FVal.V);
+ LOG(("NumericConst exit IsFloat:%d IVal: %ld FVal: %f\n", IsFloat, NextTok.IVal, NextTok.FVal.V));
}
diff --git a/src/cc65/typeconv.c b/src/cc65/typeconv.c
index 410b8af44..201f796b8 100644
--- a/src/cc65/typeconv.c
+++ b/src/cc65/typeconv.c
@@ -31,7 +31,7 @@
/* */
/*****************************************************************************/
-
+//#define DEBUG
/* common */
#include "shift.h"
@@ -47,7 +47,13 @@
#include "typecmp.h"
#include "typeconv.h"
-
+#ifdef DEBUG
+#define LOG(x) printf x
+#define FIXME(x) printf x
+#else
+#define LOG(x)
+#define FIXME(x)
+#endif
/*****************************************************************************/
/* Code */
@@ -97,10 +103,10 @@ static void DoConversion (ExprDesc* Expr, const Type* NewType)
/* lvalue? */
if (ED_IsLVal (Expr)) {
-printf("DoConversion 1 Old: %s New: %s\n",
- (IsTypeFloat (OldType)) ? "float" : "int",
- (IsTypeFloat (NewType)) ? "float" : "int"
- );
+ LOG(("DoConversion 1 Old: %s New: %s\n",
+ (IsTypeFloat (OldType)) ? "float" : "int",
+ (IsTypeFloat (NewType)) ? "float" : "int"
+ ));
/* We have an lvalue. If the new size is smaller than the old one,
** we don't need to do anything. The compiler will generate code
** to load only the portion of the value that is actually needed.
@@ -124,10 +130,10 @@ printf("DoConversion 1 Old: %s New: %s\n",
}
} else if (ED_IsConstAbs (Expr)) {
-printf("DoConversion 2 Old: %s New: %s\n",
- (IsTypeFloat (OldType)) ? "float" : "int",
- (IsTypeFloat (NewType)) ? "float" : "int"
- );
+ LOG(("DoConversion 2 Old: %s New: %s\n",
+ (IsTypeFloat (OldType)) ? "float" : "int",
+ (IsTypeFloat (NewType)) ? "float" : "int"
+ ));
/* A cast of a constant numeric value to another type. Be sure
** to handle sign extension correctly.
@@ -137,11 +143,11 @@ printf("DoConversion 2 Old: %s New: %s\n",
if (IsTypeFloat (OldType) && !IsTypeFloat (NewType)) {
OldBits = 32;
Expr->IVal = FP_D_ToLong(Expr->V.FVal);
- printf("DoConversion 2 new ival: %ld\n", Expr->IVal);
+ LOG(("DoConversion 2 new ival: %ld\n", Expr->IVal));
} else if (!IsTypeFloat (OldType) && IsTypeFloat (NewType)) {
OldBits = 0;
Expr->V.FVal = FP_D_FromInt(Expr->IVal);
- printf("DoConversion 2 new fval: %f\n", Expr->V.FVal.V);
+ LOG(("DoConversion 2 new fval: %f\n", Expr->V.FVal.V));
}
/* FIXME: float --- end of new code */
@@ -149,7 +155,7 @@ printf("DoConversion 2 Old: %s New: %s\n",
** has a larger range, things are OK, since the value is
** internally already represented by a long.
*/
- printf("DoConversion 2 NewBits: %d OldBits: %d\n", NewBits, OldBits);
+ LOG(("DoConversion 2 NewBits: %d OldBits: %d\n", NewBits, OldBits));
if (NewBits <= OldBits) {
/* Cut the value to the new size */
@@ -165,9 +171,9 @@ printf("DoConversion 2 Old: %s New: %s\n",
}
if (IsTypeFloat (NewType)) {
- printf("DoConversion 2 new fval: %f\n", Expr->V.FVal.V);
+ LOG(("DoConversion 2 new fval: %f\n", Expr->V.FVal.V));
} else {
- printf("DoConversion 2 new ival: %ld\n", Expr->IVal);
+ LOG(("DoConversion 2 new ival: %ld\n", Expr->IVal));
}
/* Do the integer constant <-> absolute address conversion if necessary */
@@ -180,10 +186,10 @@ printf("DoConversion 2 Old: %s New: %s\n",
}
} else {
-printf("DoConversion 3 Old: %s New: %s\n",
- (IsTypeFloat (OldType)) ? "float" : "int",
- (IsTypeFloat (NewType)) ? "float" : "int"
- );
+ LOG(("DoConversion 3 Old: %s New: %s\n",
+ (IsTypeFloat (OldType)) ? "float" : "int",
+ (IsTypeFloat (NewType)) ? "float" : "int"
+ ));
/* The value is not a constant. If the sizes of the types are
** not equal, add conversion code. Be sure to convert chars
From 978bdedf3338a6389e552ab7ccad17956d55d0e9 Mon Sep 17 00:00:00 2001
From: mrdudz
Date: Thu, 21 Jul 2022 02:38:20 +0200
Subject: [PATCH 011/139] switch off msvc warning
---
src/common/fp.c | 4 +++-
1 file changed, 3 insertions(+), 1 deletion(-)
diff --git a/src/common/fp.c b/src/common/fp.c
index 2acdbf9f3..02762a11e 100644
--- a/src/common/fp.c
+++ b/src/common/fp.c
@@ -242,7 +242,8 @@ Double FP_D_Div (Double Left, Double Right)
return D;
}
-
+#pragma warning( push )
+#pragma warning( disable : 4244 ) // conversion from double to float
uint32_t FP_D_As32bitRaw(Double Val)
/* converts double into 32bit (float) and then returns its raw content as a 32bit int */
{
@@ -254,3 +255,4 @@ uint32_t FP_D_As32bitRaw(Double Val)
lval = *lptr;
return lval;
}
+#pragma warning( pop )
From 543c1c3889444bb33efe4049d5efafd68b3efeee Mon Sep 17 00:00:00 2001
From: mrdudz
Date: Thu, 21 Jul 2022 02:41:20 +0200
Subject: [PATCH 012/139] another warning pragma
---
src/cc65/locals.c | 3 +++
1 file changed, 3 insertions(+)
diff --git a/src/cc65/locals.c b/src/cc65/locals.c
index d11608ab2..5645b2d42 100644
--- a/src/cc65/locals.c
+++ b/src/cc65/locals.c
@@ -283,9 +283,12 @@ static void ParseAutoDecl (Declaration* Decl)
/* Push the value */
if (TypeOf (Sym->Type) == CF_FLOAT) {
+#pragma warning( push )
+#pragma warning( disable : 4244 ) // conversion from double to float
/* FIXME: float */
LOG(("ParseAutoDecl Expr.V.FVal.V: %f\n", Expr.V.FVal.V));
g_push_float (Flags | TypeOf (Sym->Type), Expr.V.FVal.V);
+#pragma warning( pop )
} else {
g_push (Flags | TypeOf (Sym->Type), Expr.IVal);
}
From 9ccb4a281a653bcf65756d4907db596d15947d63 Mon Sep 17 00:00:00 2001
From: mrdudz
Date: Thu, 21 Jul 2022 02:46:01 +0200
Subject: [PATCH 013/139] put pragmas into ifdefs for msvc
---
src/cc65/locals.c | 4 ++++
src/common/fp.c | 4 ++++
2 files changed, 8 insertions(+)
diff --git a/src/cc65/locals.c b/src/cc65/locals.c
index 5645b2d42..13da22cca 100644
--- a/src/cc65/locals.c
+++ b/src/cc65/locals.c
@@ -283,12 +283,16 @@ static void ParseAutoDecl (Declaration* Decl)
/* Push the value */
if (TypeOf (Sym->Type) == CF_FLOAT) {
+#if defined(_MSC_VER)
#pragma warning( push )
#pragma warning( disable : 4244 ) // conversion from double to float
+#endif
/* FIXME: float */
LOG(("ParseAutoDecl Expr.V.FVal.V: %f\n", Expr.V.FVal.V));
g_push_float (Flags | TypeOf (Sym->Type), Expr.V.FVal.V);
+#if defined(_MSC_VER)
#pragma warning( pop )
+#endif
} else {
g_push (Flags | TypeOf (Sym->Type), Expr.IVal);
}
diff --git a/src/common/fp.c b/src/common/fp.c
index 02762a11e..9e52acefa 100644
--- a/src/common/fp.c
+++ b/src/common/fp.c
@@ -242,8 +242,10 @@ Double FP_D_Div (Double Left, Double Right)
return D;
}
+#if defined(_MSC_VER)
#pragma warning( push )
#pragma warning( disable : 4244 ) // conversion from double to float
+#endif
uint32_t FP_D_As32bitRaw(Double Val)
/* converts double into 32bit (float) and then returns its raw content as a 32bit int */
{
@@ -255,4 +257,6 @@ uint32_t FP_D_As32bitRaw(Double Val)
lval = *lptr;
return lval;
}
+#if defined(_MSC_VER)
#pragma warning( pop )
+#endif
From e7d7ad7df01f3edaa427e7b3d25434baeb5ef69a Mon Sep 17 00:00:00 2001
From: mrdudz
Date: Sun, 21 Aug 2022 19:31:32 +0200
Subject: [PATCH 014/139] added Berkeley softfloat library - lets see if this
can be ported
---
test/float/softfloat/COPYING.txt | 37 +
test/float/softfloat/README.html | 49 +
test/float/softfloat/README.txt | 21 +
.../softfloat/build/Linux-386-GCC/Makefile | 325 ++++
.../softfloat/build/Linux-386-GCC/platform.h | 53 +
.../build/Linux-386-SSE2-GCC/Makefile | 325 ++++
.../build/Linux-386-SSE2-GCC/platform.h | 53 +
.../build/Linux-ARM-VFPv2-GCC/Makefile | 323 ++++
.../build/Linux-ARM-VFPv2-GCC/platform.h | 53 +
.../softfloat/build/Linux-x86_64-GCC/Makefile | 390 +++++
.../build/Linux-x86_64-GCC/platform.h | 54 +
.../softfloat/build/Win32-MinGW/Makefile | 325 ++++
.../softfloat/build/Win32-MinGW/platform.h | 53 +
.../softfloat/build/Win32-SSE2-MinGW/Makefile | 325 ++++
.../build/Win32-SSE2-MinGW/platform.h | 53 +
.../softfloat/build/Win64-MinGW-w64/Makefile | 390 +++++
.../build/Win64-MinGW-w64/platform.h | 54 +
.../build/template-FAST_INT64/Makefile | 391 +++++
.../build/template-FAST_INT64/platform.h | 50 +
.../build/template-not-FAST_INT64/Makefile | 325 ++++
.../build/template-not-FAST_INT64/platform.h | 50 +
.../softfloat/doc/SoftFloat-history.html | 258 +++
.../float/softfloat/doc/SoftFloat-source.html | 686 ++++++++
test/float/softfloat/doc/SoftFloat.html | 1527 +++++++++++++++++
.../source/8086-SSE/extF80M_isSignalingNaN.c | 57 +
.../source/8086-SSE/f128M_isSignalingNaN.c | 60 +
.../source/8086-SSE/s_commonNaNToExtF80M.c | 56 +
.../source/8086-SSE/s_commonNaNToExtF80UI.c | 56 +
.../source/8086-SSE/s_commonNaNToF128M.c | 56 +
.../source/8086-SSE/s_commonNaNToF128UI.c | 55 +
.../source/8086-SSE/s_commonNaNToF16UI.c | 51 +
.../source/8086-SSE/s_commonNaNToF32UI.c | 51 +
.../source/8086-SSE/s_commonNaNToF64UI.c | 53 +
.../source/8086-SSE/s_extF80MToCommonNaN.c | 62 +
.../source/8086-SSE/s_extF80UIToCommonNaN.c | 62 +
.../source/8086-SSE/s_f128MToCommonNaN.c | 62 +
.../source/8086-SSE/s_f128UIToCommonNaN.c | 65 +
.../source/8086-SSE/s_f16UIToCommonNaN.c | 59 +
.../source/8086-SSE/s_f32UIToCommonNaN.c | 59 +
.../source/8086-SSE/s_f64UIToCommonNaN.c | 59 +
.../source/8086-SSE/s_propagateNaNExtF80M.c | 107 ++
.../source/8086-SSE/s_propagateNaNExtF80UI.c | 106 ++
.../source/8086-SSE/s_propagateNaNF128M.c | 76 +
.../source/8086-SSE/s_propagateNaNF128UI.c | 81 +
.../source/8086-SSE/s_propagateNaNF16UI.c | 63 +
.../source/8086-SSE/s_propagateNaNF32UI.c | 63 +
.../source/8086-SSE/s_propagateNaNF64UI.c | 63 +
.../source/8086-SSE/softfloat_raiseFlags.c | 52 +
.../softfloat/source/8086-SSE/specialize.h | 376 ++++
.../source/8086/extF80M_isSignalingNaN.c | 57 +
.../source/8086/f128M_isSignalingNaN.c | 60 +
.../source/8086/s_commonNaNToExtF80M.c | 56 +
.../source/8086/s_commonNaNToExtF80UI.c | 56 +
.../source/8086/s_commonNaNToF128M.c | 56 +
.../source/8086/s_commonNaNToF128UI.c | 55 +
.../source/8086/s_commonNaNToF16UI.c | 51 +
.../source/8086/s_commonNaNToF32UI.c | 51 +
.../source/8086/s_commonNaNToF64UI.c | 53 +
.../source/8086/s_extF80MToCommonNaN.c | 62 +
.../source/8086/s_extF80UIToCommonNaN.c | 62 +
.../source/8086/s_f128MToCommonNaN.c | 62 +
.../source/8086/s_f128UIToCommonNaN.c | 65 +
.../source/8086/s_f16UIToCommonNaN.c | 59 +
.../source/8086/s_f32UIToCommonNaN.c | 59 +
.../source/8086/s_f64UIToCommonNaN.c | 59 +
.../source/8086/s_propagateNaNExtF80M.c | 107 ++
.../source/8086/s_propagateNaNExtF80UI.c | 106 ++
.../source/8086/s_propagateNaNF128M.c | 108 ++
.../source/8086/s_propagateNaNF128UI.c | 105 ++
.../source/8086/s_propagateNaNF16UI.c | 84 +
.../source/8086/s_propagateNaNF32UI.c | 84 +
.../source/8086/s_propagateNaNF64UI.c | 84 +
.../source/8086/softfloat_raiseFlags.c | 52 +
test/float/softfloat/source/8086/specialize.h | 376 ++++
.../extF80M_isSignalingNaN.c | 57 +
.../f128M_isSignalingNaN.c | 60 +
.../s_commonNaNToExtF80M.c | 57 +
.../s_commonNaNToExtF80UI.c | 57 +
.../ARM-VFPv2-defaultNaN/s_commonNaNToF128M.c | 60 +
.../s_commonNaNToF128UI.c | 56 +
.../ARM-VFPv2-defaultNaN/s_commonNaNToF16UI.c | 5 +
.../ARM-VFPv2-defaultNaN/s_commonNaNToF32UI.c | 5 +
.../ARM-VFPv2-defaultNaN/s_commonNaNToF64UI.c | 5 +
.../s_extF80MToCommonNaN.c | 5 +
.../s_extF80UIToCommonNaN.c | 5 +
.../ARM-VFPv2-defaultNaN/s_f128MToCommonNaN.c | 5 +
.../s_f128UIToCommonNaN.c | 5 +
.../ARM-VFPv2-defaultNaN/s_f16UIToCommonNaN.c | 5 +
.../ARM-VFPv2-defaultNaN/s_f32UIToCommonNaN.c | 5 +
.../ARM-VFPv2-defaultNaN/s_f64UIToCommonNaN.c | 5 +
.../s_propagateNaNExtF80M.c | 74 +
.../s_propagateNaNExtF80UI.c | 73 +
.../s_propagateNaNF128M.c | 68 +
.../s_propagateNaNF128UI.c | 73 +
.../s_propagateNaNF16UI.c | 58 +
.../s_propagateNaNF32UI.c | 58 +
.../s_propagateNaNF64UI.c | 58 +
.../softfloat_raiseFlags.c | 52 +
.../source/ARM-VFPv2-defaultNaN/specialize.h | 407 +++++
.../source/ARM-VFPv2/extF80M_isSignalingNaN.c | 57 +
.../source/ARM-VFPv2/f128M_isSignalingNaN.c | 60 +
.../source/ARM-VFPv2/s_commonNaNToExtF80M.c | 56 +
.../source/ARM-VFPv2/s_commonNaNToExtF80UI.c | 56 +
.../source/ARM-VFPv2/s_commonNaNToF128M.c | 56 +
.../source/ARM-VFPv2/s_commonNaNToF128UI.c | 55 +
.../source/ARM-VFPv2/s_commonNaNToF16UI.c | 51 +
.../source/ARM-VFPv2/s_commonNaNToF32UI.c | 51 +
.../source/ARM-VFPv2/s_commonNaNToF64UI.c | 53 +
.../source/ARM-VFPv2/s_extF80MToCommonNaN.c | 62 +
.../source/ARM-VFPv2/s_extF80UIToCommonNaN.c | 62 +
.../source/ARM-VFPv2/s_f128MToCommonNaN.c | 62 +
.../source/ARM-VFPv2/s_f128UIToCommonNaN.c | 65 +
.../source/ARM-VFPv2/s_f16UIToCommonNaN.c | 59 +
.../source/ARM-VFPv2/s_f32UIToCommonNaN.c | 59 +
.../source/ARM-VFPv2/s_f64UIToCommonNaN.c | 59 +
.../source/ARM-VFPv2/s_propagateNaNExtF80M.c | 86 +
.../source/ARM-VFPv2/s_propagateNaNExtF80UI.c | 83 +
.../source/ARM-VFPv2/s_propagateNaNF128M.c | 77 +
.../source/ARM-VFPv2/s_propagateNaNF128UI.c | 83 +
.../source/ARM-VFPv2/s_propagateNaNF16UI.c | 63 +
.../source/ARM-VFPv2/s_propagateNaNF32UI.c | 63 +
.../source/ARM-VFPv2/s_propagateNaNF64UI.c | 63 +
.../source/ARM-VFPv2/softfloat_raiseFlags.c | 52 +
.../softfloat/source/ARM-VFPv2/specialize.h | 376 ++++
test/float/softfloat/source/extF80M_add.c | 100 ++
test/float/softfloat/source/extF80M_div.c | 194 +++
test/float/softfloat/source/extF80M_eq.c | 98 ++
.../softfloat/source/extF80M_eq_signaling.c | 92 +
test/float/softfloat/source/extF80M_le.c | 106 ++
.../float/softfloat/source/extF80M_le_quiet.c | 112 ++
test/float/softfloat/source/extF80M_lt.c | 106 ++
.../float/softfloat/source/extF80M_lt_quiet.c | 112 ++
test/float/softfloat/source/extF80M_mul.c | 139 ++
test/float/softfloat/source/extF80M_rem.c | 204 +++
.../softfloat/source/extF80M_roundToInt.c | 176 ++
test/float/softfloat/source/extF80M_sqrt.c | 180 ++
test/float/softfloat/source/extF80M_sub.c | 100 ++
.../float/softfloat/source/extF80M_to_f128M.c | 125 ++
test/float/softfloat/source/extF80M_to_f16.c | 112 ++
test/float/softfloat/source/extF80M_to_f32.c | 112 ++
test/float/softfloat/source/extF80M_to_f64.c | 112 ++
test/float/softfloat/source/extF80M_to_i32.c | 100 ++
.../source/extF80M_to_i32_r_minMag.c | 120 ++
test/float/softfloat/source/extF80M_to_i64.c | 97 ++
.../source/extF80M_to_i64_r_minMag.c | 115 ++
test/float/softfloat/source/extF80M_to_ui32.c | 101 ++
.../source/extF80M_to_ui32_r_minMag.c | 111 ++
test/float/softfloat/source/extF80M_to_ui64.c | 97 ++
.../source/extF80M_to_ui64_r_minMag.c | 108 ++
test/float/softfloat/source/extF80_add.c | 80 +
test/float/softfloat/source/extF80_div.c | 203 +++
test/float/softfloat/source/extF80_eq.c | 73 +
.../softfloat/source/extF80_eq_signaling.c | 67 +
.../softfloat/source/extF80_isSignalingNaN.c | 51 +
test/float/softfloat/source/extF80_le.c | 73 +
test/float/softfloat/source/extF80_le_quiet.c | 78 +
test/float/softfloat/source/extF80_lt.c | 73 +
test/float/softfloat/source/extF80_lt_quiet.c | 78 +
test/float/softfloat/source/extF80_mul.c | 158 ++
test/float/softfloat/source/extF80_rem.c | 225 +++
.../softfloat/source/extF80_roundToInt.c | 154 ++
test/float/softfloat/source/extF80_sqrt.c | 176 ++
test/float/softfloat/source/extF80_sub.c | 80 +
test/float/softfloat/source/extF80_to_f128.c | 75 +
test/float/softfloat/source/extF80_to_f16.c | 96 ++
test/float/softfloat/source/extF80_to_f32.c | 96 ++
test/float/softfloat/source/extF80_to_f64.c | 96 ++
test/float/softfloat/source/extF80_to_i32.c | 83 +
.../softfloat/source/extF80_to_i32_r_minMag.c | 97 ++
test/float/softfloat/source/extF80_to_i64.c | 89 +
.../softfloat/source/extF80_to_i64_r_minMag.c | 94 +
test/float/softfloat/source/extF80_to_ui32.c | 83 +
.../source/extF80_to_ui32_r_minMag.c | 88 +
test/float/softfloat/source/extF80_to_ui64.c | 84 +
.../source/extF80_to_ui64_r_minMag.c | 88 +
test/float/softfloat/source/f128M_add.c | 97 ++
test/float/softfloat/source/f128M_div.c | 187 ++
test/float/softfloat/source/f128M_eq.c | 100 ++
.../softfloat/source/f128M_eq_signaling.c | 92 +
test/float/softfloat/source/f128M_le.c | 93 +
test/float/softfloat/source/f128M_le_quiet.c | 96 ++
test/float/softfloat/source/f128M_lt.c | 93 +
test/float/softfloat/source/f128M_lt_quiet.c | 96 ++
test/float/softfloat/source/f128M_mul.c | 158 ++
test/float/softfloat/source/f128M_mulAdd.c | 92 +
test/float/softfloat/source/f128M_rem.c | 182 ++
.../float/softfloat/source/f128M_roundToInt.c | 223 +++
test/float/softfloat/source/f128M_sqrt.c | 228 +++
test/float/softfloat/source/f128M_sub.c | 97 ++
.../float/softfloat/source/f128M_to_extF80M.c | 101 ++
test/float/softfloat/source/f128M_to_f16.c | 113 ++
test/float/softfloat/source/f128M_to_f32.c | 109 ++
test/float/softfloat/source/f128M_to_f64.c | 112 ++
test/float/softfloat/source/f128M_to_i32.c | 98 ++
.../softfloat/source/f128M_to_i32_r_minMag.c | 106 ++
test/float/softfloat/source/f128M_to_i64.c | 102 ++
.../softfloat/source/f128M_to_i64_r_minMag.c | 124 ++
test/float/softfloat/source/f128M_to_ui32.c | 98 ++
.../softfloat/source/f128M_to_ui32_r_minMag.c | 102 ++
test/float/softfloat/source/f128M_to_ui64.c | 102 ++
.../softfloat/source/f128M_to_ui64_r_minMag.c | 114 ++
test/float/softfloat/source/f128_add.c | 78 +
test/float/softfloat/source/f128_div.c | 199 +++
test/float/softfloat/source/f128_eq.c | 73 +
.../softfloat/source/f128_eq_signaling.c | 67 +
.../softfloat/source/f128_isSignalingNaN.c | 51 +
test/float/softfloat/source/f128_le.c | 72 +
test/float/softfloat/source/f128_le_quiet.c | 78 +
test/float/softfloat/source/f128_lt.c | 72 +
test/float/softfloat/source/f128_lt_quiet.c | 78 +
test/float/softfloat/source/f128_mul.c | 163 ++
test/float/softfloat/source/f128_mulAdd.c | 63 +
test/float/softfloat/source/f128_rem.c | 190 ++
test/float/softfloat/source/f128_roundToInt.c | 172 ++
test/float/softfloat/source/f128_sqrt.c | 201 +++
test/float/softfloat/source/f128_sub.c | 78 +
test/float/softfloat/source/f128_to_extF80.c | 109 ++
test/float/softfloat/source/f128_to_f16.c | 95 +
test/float/softfloat/source/f128_to_f32.c | 95 +
test/float/softfloat/source/f128_to_f64.c | 100 ++
test/float/softfloat/source/f128_to_i32.c | 85 +
.../softfloat/source/f128_to_i32_r_minMag.c | 100 ++
test/float/softfloat/source/f128_to_i64.c | 95 +
.../softfloat/source/f128_to_i64_r_minMag.c | 113 ++
test/float/softfloat/source/f128_to_ui32.c | 86 +
.../softfloat/source/f128_to_ui32_r_minMag.c | 89 +
test/float/softfloat/source/f128_to_ui64.c | 96 ++
.../softfloat/source/f128_to_ui64_r_minMag.c | 105 ++
test/float/softfloat/source/f16_add.c | 70 +
test/float/softfloat/source/f16_div.c | 186 ++
test/float/softfloat/source/f16_eq.c | 66 +
.../float/softfloat/source/f16_eq_signaling.c | 61 +
.../softfloat/source/f16_isSignalingNaN.c | 51 +
test/float/softfloat/source/f16_le.c | 66 +
test/float/softfloat/source/f16_le_quiet.c | 71 +
test/float/softfloat/source/f16_lt.c | 66 +
test/float/softfloat/source/f16_lt_quiet.c | 71 +
test/float/softfloat/source/f16_mul.c | 140 ++
test/float/softfloat/source/f16_mulAdd.c | 60 +
test/float/softfloat/source/f16_rem.c | 171 ++
test/float/softfloat/source/f16_roundToInt.c | 120 ++
test/float/softfloat/source/f16_sqrt.c | 136 ++
test/float/softfloat/source/f16_sub.c | 70 +
test/float/softfloat/source/f16_to_extF80.c | 101 ++
test/float/softfloat/source/f16_to_extF80M.c | 111 ++
test/float/softfloat/source/f16_to_f128.c | 96 ++
test/float/softfloat/source/f16_to_f128M.c | 111 ++
test/float/softfloat/source/f16_to_f32.c | 93 +
test/float/softfloat/source/f16_to_f64.c | 93 +
test/float/softfloat/source/f16_to_i32.c | 87 +
.../softfloat/source/f16_to_i32_r_minMag.c | 88 +
test/float/softfloat/source/f16_to_i64.c | 87 +
.../softfloat/source/f16_to_i64_r_minMag.c | 88 +
test/float/softfloat/source/f16_to_ui32.c | 84 +
.../softfloat/source/f16_to_ui32_r_minMag.c | 87 +
test/float/softfloat/source/f16_to_ui64.c | 96 ++
.../softfloat/source/f16_to_ui64_r_minMag.c | 87 +
test/float/softfloat/source/f32_add.c | 70 +
test/float/softfloat/source/f32_div.c | 180 ++
test/float/softfloat/source/f32_eq.c | 66 +
.../float/softfloat/source/f32_eq_signaling.c | 61 +
.../softfloat/source/f32_isSignalingNaN.c | 51 +
test/float/softfloat/source/f32_le.c | 66 +
test/float/softfloat/source/f32_le_quiet.c | 71 +
test/float/softfloat/source/f32_lt.c | 66 +
test/float/softfloat/source/f32_lt_quiet.c | 71 +
test/float/softfloat/source/f32_mul.c | 137 ++
test/float/softfloat/source/f32_mulAdd.c | 60 +
test/float/softfloat/source/f32_rem.c | 168 ++
test/float/softfloat/source/f32_roundToInt.c | 120 ++
test/float/softfloat/source/f32_sqrt.c | 121 ++
test/float/softfloat/source/f32_sub.c | 70 +
test/float/softfloat/source/f32_to_extF80.c | 101 ++
test/float/softfloat/source/f32_to_extF80M.c | 111 ++
test/float/softfloat/source/f32_to_f128.c | 96 ++
test/float/softfloat/source/f32_to_f128M.c | 115 ++
test/float/softfloat/source/f32_to_f16.c | 88 +
test/float/softfloat/source/f32_to_f64.c | 93 +
test/float/softfloat/source/f32_to_i32.c | 84 +
.../softfloat/source/f32_to_i32_r_minMag.c | 89 +
test/float/softfloat/source/f32_to_i64.c | 96 ++
.../softfloat/source/f32_to_i64_r_minMag.c | 94 +
test/float/softfloat/source/f32_to_ui32.c | 84 +
.../softfloat/source/f32_to_ui32_r_minMag.c | 88 +
test/float/softfloat/source/f32_to_ui64.c | 96 ++
.../softfloat/source/f32_to_ui64_r_minMag.c | 90 +
test/float/softfloat/source/f64_add.c | 74 +
test/float/softfloat/source/f64_div.c | 172 ++
test/float/softfloat/source/f64_eq.c | 66 +
.../float/softfloat/source/f64_eq_signaling.c | 61 +
.../softfloat/source/f64_isSignalingNaN.c | 51 +
test/float/softfloat/source/f64_le.c | 67 +
test/float/softfloat/source/f64_le_quiet.c | 72 +
test/float/softfloat/source/f64_lt.c | 67 +
test/float/softfloat/source/f64_lt_quiet.c | 72 +
test/float/softfloat/source/f64_mul.c | 150 ++
test/float/softfloat/source/f64_mulAdd.c | 60 +
test/float/softfloat/source/f64_rem.c | 189 ++
test/float/softfloat/source/f64_roundToInt.c | 120 ++
test/float/softfloat/source/f64_sqrt.c | 133 ++
test/float/softfloat/source/f64_sub.c | 74 +
test/float/softfloat/source/f64_to_extF80.c | 101 ++
test/float/softfloat/source/f64_to_extF80M.c | 111 ++
test/float/softfloat/source/f64_to_f128.c | 98 ++
test/float/softfloat/source/f64_to_f128M.c | 117 ++
test/float/softfloat/source/f64_to_f16.c | 88 +
test/float/softfloat/source/f64_to_f32.c | 88 +
test/float/softfloat/source/f64_to_i32.c | 82 +
.../softfloat/source/f64_to_i32_r_minMag.c | 96 ++
test/float/softfloat/source/f64_to_i64.c | 103 ++
.../softfloat/source/f64_to_i64_r_minMag.c | 100 ++
test/float/softfloat/source/f64_to_ui32.c | 82 +
.../softfloat/source/f64_to_ui32_r_minMag.c | 88 +
test/float/softfloat/source/f64_to_ui64.c | 103 ++
.../softfloat/source/f64_to_ui64_r_minMag.c | 93 +
test/float/softfloat/source/i32_to_extF80.c | 65 +
test/float/softfloat/source/i32_to_extF80M.c | 78 +
test/float/softfloat/source/i32_to_f128.c | 64 +
test/float/softfloat/source/i32_to_f128M.c | 81 +
test/float/softfloat/source/i32_to_f16.c | 71 +
test/float/softfloat/source/i32_to_f32.c | 58 +
test/float/softfloat/source/i32_to_f64.c | 65 +
test/float/softfloat/source/i64_to_extF80.c | 65 +
test/float/softfloat/source/i64_to_extF80M.c | 78 +
test/float/softfloat/source/i64_to_f128.c | 72 +
test/float/softfloat/source/i64_to_f128M.c | 92 +
test/float/softfloat/source/i64_to_f16.c | 70 +
test/float/softfloat/source/i64_to_f32.c | 70 +
test/float/softfloat/source/i64_to_f64.c | 58 +
.../softfloat/source/include/internals.h | 278 +++
.../float/softfloat/source/include/opts-GCC.h | 114 ++
.../softfloat/source/include/primitiveTypes.h | 85 +
.../softfloat/source/include/primitives.h | 1160 +++++++++++++
.../softfloat/source/include/softfloat.h | 372 ++++
.../source/include/softfloat_types.h | 81 +
test/float/softfloat/source/s_add128.c | 55 +
test/float/softfloat/source/s_add256M.c | 65 +
test/float/softfloat/source/s_addCarryM.c | 70 +
.../float/softfloat/source/s_addComplCarryM.c | 70 +
test/float/softfloat/source/s_addExtF80M.c | 186 ++
test/float/softfloat/source/s_addF128M.c | 211 +++
test/float/softfloat/source/s_addM.c | 70 +
test/float/softfloat/source/s_addMagsExtF80.c | 156 ++
test/float/softfloat/source/s_addMagsF128.c | 154 ++
test/float/softfloat/source/s_addMagsF16.c | 183 ++
test/float/softfloat/source/s_addMagsF32.c | 126 ++
test/float/softfloat/source/s_addMagsF64.c | 128 ++
.../softfloat/source/s_approxRecip32_1.c | 66 +
.../softfloat/source/s_approxRecipSqrt32_1.c | 73 +
.../softfloat/source/s_approxRecipSqrt_1Ks.c | 49 +
.../softfloat/source/s_approxRecip_1Ks.c | 49 +
test/float/softfloat/source/s_compare128M.c | 62 +
test/float/softfloat/source/s_compare96M.c | 62 +
.../source/s_compareNonnormExtF80M.c | 111 ++
.../softfloat/source/s_countLeadingZeros16.c | 60 +
.../softfloat/source/s_countLeadingZeros32.c | 64 +
.../softfloat/source/s_countLeadingZeros64.c | 73 +
.../softfloat/source/s_countLeadingZeros8.c | 59 +
test/float/softfloat/source/s_eq128.c | 51 +
.../float/softfloat/source/s_invalidExtF80M.c | 49 +
test/float/softfloat/source/s_invalidF128M.c | 53 +
test/float/softfloat/source/s_isNaNF128M.c | 57 +
test/float/softfloat/source/s_le128.c | 51 +
test/float/softfloat/source/s_lt128.c | 51 +
test/float/softfloat/source/s_mul128By32.c | 58 +
test/float/softfloat/source/s_mul128MTo256M.c | 100 ++
test/float/softfloat/source/s_mul128To256M.c | 71 +
.../source/s_mul64ByShifted32To128.c | 56 +
test/float/softfloat/source/s_mul64To128.c | 66 +
test/float/softfloat/source/s_mul64To128M.c | 68 +
test/float/softfloat/source/s_mulAddF128.c | 350 ++++
test/float/softfloat/source/s_mulAddF128M.c | 382 +++++
test/float/softfloat/source/s_mulAddF16.c | 226 +++
test/float/softfloat/source/s_mulAddF32.c | 224 +++
test/float/softfloat/source/s_mulAddF64.c | 496 ++++++
test/float/softfloat/source/s_negXM.c | 63 +
.../float/softfloat/source/s_normExtF80SigM.c | 52 +
.../source/s_normRoundPackMToExtF80M.c | 78 +
.../source/s_normRoundPackMToF128M.c | 73 +
.../source/s_normRoundPackToExtF80.c | 71 +
.../softfloat/source/s_normRoundPackToF128.c | 81 +
.../softfloat/source/s_normRoundPackToF16.c | 58 +
.../softfloat/source/s_normRoundPackToF32.c | 58 +
.../softfloat/source/s_normRoundPackToF64.c | 58 +
.../source/s_normSubnormalExtF80Sig.c | 52 +
.../softfloat/source/s_normSubnormalF128Sig.c | 65 +
.../source/s_normSubnormalF128SigM.c | 61 +
.../softfloat/source/s_normSubnormalF16Sig.c | 52 +
.../softfloat/source/s_normSubnormalF32Sig.c | 52 +
.../softfloat/source/s_normSubnormalF64Sig.c | 52 +
test/float/softfloat/source/s_remStepMBy32.c | 86 +
test/float/softfloat/source/s_roundMToI64.c | 102 ++
test/float/softfloat/source/s_roundMToUI64.c | 98 ++
.../softfloat/source/s_roundPackMToExtF80M.c | 256 +++
.../softfloat/source/s_roundPackMToF128M.c | 178 ++
.../softfloat/source/s_roundPackToExtF80.c | 256 +++
.../softfloat/source/s_roundPackToF128.c | 171 ++
.../float/softfloat/source/s_roundPackToF16.c | 113 ++
.../float/softfloat/source/s_roundPackToF32.c | 113 ++
.../float/softfloat/source/s_roundPackToF64.c | 117 ++
test/float/softfloat/source/s_roundToI32.c | 98 ++
test/float/softfloat/source/s_roundToI64.c | 101 ++
test/float/softfloat/source/s_roundToUI32.c | 93 +
test/float/softfloat/source/s_roundToUI64.c | 97 ++
test/float/softfloat/source/s_shiftLeftM.c | 91 +
.../softfloat/source/s_shiftNormSigF128M.c | 78 +
.../softfloat/source/s_shiftRightJam128.c | 69 +
.../source/s_shiftRightJam128Extra.c | 77 +
.../softfloat/source/s_shiftRightJam256M.c | 126 ++
.../softfloat/source/s_shiftRightJam32.c | 51 +
.../softfloat/source/s_shiftRightJam64.c | 51 +
.../softfloat/source/s_shiftRightJam64Extra.c | 62 +
.../float/softfloat/source/s_shiftRightJamM.c | 101 ++
test/float/softfloat/source/s_shiftRightM.c | 91 +
.../softfloat/source/s_shortShiftLeft128.c | 55 +
.../source/s_shortShiftLeft64To96M.c | 56 +
.../softfloat/source/s_shortShiftLeftM.c | 70 +
.../softfloat/source/s_shortShiftRight128.c | 55 +
.../source/s_shortShiftRightExtendM.c | 73 +
.../source/s_shortShiftRightJam128.c | 60 +
.../source/s_shortShiftRightJam128Extra.c | 59 +
.../softfloat/source/s_shortShiftRightJam64.c | 50 +
.../source/s_shortShiftRightJam64Extra.c | 56 +
.../softfloat/source/s_shortShiftRightJamM.c | 72 +
.../softfloat/source/s_shortShiftRightM.c | 70 +
test/float/softfloat/source/s_sub128.c | 55 +
test/float/softfloat/source/s_sub1XM.c | 60 +
test/float/softfloat/source/s_sub256M.c | 65 +
test/float/softfloat/source/s_subM.c | 70 +
test/float/softfloat/source/s_subMagsExtF80.c | 158 ++
test/float/softfloat/source/s_subMagsF128.c | 139 ++
test/float/softfloat/source/s_subMagsF16.c | 187 ++
test/float/softfloat/source/s_subMagsF32.c | 143 ++
test/float/softfloat/source/s_subMagsF64.c | 141 ++
.../source/s_tryPropagateNaNExtF80M.c | 64 +
.../softfloat/source/s_tryPropagateNaNF128M.c | 55 +
test/float/softfloat/source/softfloat_state.c | 52 +
test/float/softfloat/source/ui32_to_extF80.c | 59 +
test/float/softfloat/source/ui32_to_extF80M.c | 74 +
test/float/softfloat/source/ui32_to_f128.c | 60 +
test/float/softfloat/source/ui32_to_f128M.c | 76 +
test/float/softfloat/source/ui32_to_f16.c | 65 +
test/float/softfloat/source/ui32_to_f32.c | 57 +
test/float/softfloat/source/ui32_to_f64.c | 59 +
test/float/softfloat/source/ui64_to_extF80.c | 59 +
test/float/softfloat/source/ui64_to_extF80M.c | 74 +
test/float/softfloat/source/ui64_to_f128.c | 68 +
test/float/softfloat/source/ui64_to_f128M.c | 86 +
test/float/softfloat/source/ui64_to_f16.c | 64 +
test/float/softfloat/source/ui64_to_f32.c | 64 +
test/float/softfloat/source/ui64_to_f64.c | 59 +
451 files changed, 47155 insertions(+)
create mode 100644 test/float/softfloat/COPYING.txt
create mode 100644 test/float/softfloat/README.html
create mode 100644 test/float/softfloat/README.txt
create mode 100644 test/float/softfloat/build/Linux-386-GCC/Makefile
create mode 100644 test/float/softfloat/build/Linux-386-GCC/platform.h
create mode 100644 test/float/softfloat/build/Linux-386-SSE2-GCC/Makefile
create mode 100644 test/float/softfloat/build/Linux-386-SSE2-GCC/platform.h
create mode 100644 test/float/softfloat/build/Linux-ARM-VFPv2-GCC/Makefile
create mode 100644 test/float/softfloat/build/Linux-ARM-VFPv2-GCC/platform.h
create mode 100644 test/float/softfloat/build/Linux-x86_64-GCC/Makefile
create mode 100644 test/float/softfloat/build/Linux-x86_64-GCC/platform.h
create mode 100644 test/float/softfloat/build/Win32-MinGW/Makefile
create mode 100644 test/float/softfloat/build/Win32-MinGW/platform.h
create mode 100644 test/float/softfloat/build/Win32-SSE2-MinGW/Makefile
create mode 100644 test/float/softfloat/build/Win32-SSE2-MinGW/platform.h
create mode 100644 test/float/softfloat/build/Win64-MinGW-w64/Makefile
create mode 100644 test/float/softfloat/build/Win64-MinGW-w64/platform.h
create mode 100644 test/float/softfloat/build/template-FAST_INT64/Makefile
create mode 100644 test/float/softfloat/build/template-FAST_INT64/platform.h
create mode 100644 test/float/softfloat/build/template-not-FAST_INT64/Makefile
create mode 100644 test/float/softfloat/build/template-not-FAST_INT64/platform.h
create mode 100644 test/float/softfloat/doc/SoftFloat-history.html
create mode 100644 test/float/softfloat/doc/SoftFloat-source.html
create mode 100644 test/float/softfloat/doc/SoftFloat.html
create mode 100644 test/float/softfloat/source/8086-SSE/extF80M_isSignalingNaN.c
create mode 100644 test/float/softfloat/source/8086-SSE/f128M_isSignalingNaN.c
create mode 100644 test/float/softfloat/source/8086-SSE/s_commonNaNToExtF80M.c
create mode 100644 test/float/softfloat/source/8086-SSE/s_commonNaNToExtF80UI.c
create mode 100644 test/float/softfloat/source/8086-SSE/s_commonNaNToF128M.c
create mode 100644 test/float/softfloat/source/8086-SSE/s_commonNaNToF128UI.c
create mode 100644 test/float/softfloat/source/8086-SSE/s_commonNaNToF16UI.c
create mode 100644 test/float/softfloat/source/8086-SSE/s_commonNaNToF32UI.c
create mode 100644 test/float/softfloat/source/8086-SSE/s_commonNaNToF64UI.c
create mode 100644 test/float/softfloat/source/8086-SSE/s_extF80MToCommonNaN.c
create mode 100644 test/float/softfloat/source/8086-SSE/s_extF80UIToCommonNaN.c
create mode 100644 test/float/softfloat/source/8086-SSE/s_f128MToCommonNaN.c
create mode 100644 test/float/softfloat/source/8086-SSE/s_f128UIToCommonNaN.c
create mode 100644 test/float/softfloat/source/8086-SSE/s_f16UIToCommonNaN.c
create mode 100644 test/float/softfloat/source/8086-SSE/s_f32UIToCommonNaN.c
create mode 100644 test/float/softfloat/source/8086-SSE/s_f64UIToCommonNaN.c
create mode 100644 test/float/softfloat/source/8086-SSE/s_propagateNaNExtF80M.c
create mode 100644 test/float/softfloat/source/8086-SSE/s_propagateNaNExtF80UI.c
create mode 100644 test/float/softfloat/source/8086-SSE/s_propagateNaNF128M.c
create mode 100644 test/float/softfloat/source/8086-SSE/s_propagateNaNF128UI.c
create mode 100644 test/float/softfloat/source/8086-SSE/s_propagateNaNF16UI.c
create mode 100644 test/float/softfloat/source/8086-SSE/s_propagateNaNF32UI.c
create mode 100644 test/float/softfloat/source/8086-SSE/s_propagateNaNF64UI.c
create mode 100644 test/float/softfloat/source/8086-SSE/softfloat_raiseFlags.c
create mode 100644 test/float/softfloat/source/8086-SSE/specialize.h
create mode 100644 test/float/softfloat/source/8086/extF80M_isSignalingNaN.c
create mode 100644 test/float/softfloat/source/8086/f128M_isSignalingNaN.c
create mode 100644 test/float/softfloat/source/8086/s_commonNaNToExtF80M.c
create mode 100644 test/float/softfloat/source/8086/s_commonNaNToExtF80UI.c
create mode 100644 test/float/softfloat/source/8086/s_commonNaNToF128M.c
create mode 100644 test/float/softfloat/source/8086/s_commonNaNToF128UI.c
create mode 100644 test/float/softfloat/source/8086/s_commonNaNToF16UI.c
create mode 100644 test/float/softfloat/source/8086/s_commonNaNToF32UI.c
create mode 100644 test/float/softfloat/source/8086/s_commonNaNToF64UI.c
create mode 100644 test/float/softfloat/source/8086/s_extF80MToCommonNaN.c
create mode 100644 test/float/softfloat/source/8086/s_extF80UIToCommonNaN.c
create mode 100644 test/float/softfloat/source/8086/s_f128MToCommonNaN.c
create mode 100644 test/float/softfloat/source/8086/s_f128UIToCommonNaN.c
create mode 100644 test/float/softfloat/source/8086/s_f16UIToCommonNaN.c
create mode 100644 test/float/softfloat/source/8086/s_f32UIToCommonNaN.c
create mode 100644 test/float/softfloat/source/8086/s_f64UIToCommonNaN.c
create mode 100644 test/float/softfloat/source/8086/s_propagateNaNExtF80M.c
create mode 100644 test/float/softfloat/source/8086/s_propagateNaNExtF80UI.c
create mode 100644 test/float/softfloat/source/8086/s_propagateNaNF128M.c
create mode 100644 test/float/softfloat/source/8086/s_propagateNaNF128UI.c
create mode 100644 test/float/softfloat/source/8086/s_propagateNaNF16UI.c
create mode 100644 test/float/softfloat/source/8086/s_propagateNaNF32UI.c
create mode 100644 test/float/softfloat/source/8086/s_propagateNaNF64UI.c
create mode 100644 test/float/softfloat/source/8086/softfloat_raiseFlags.c
create mode 100644 test/float/softfloat/source/8086/specialize.h
create mode 100644 test/float/softfloat/source/ARM-VFPv2-defaultNaN/extF80M_isSignalingNaN.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2-defaultNaN/f128M_isSignalingNaN.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToExtF80M.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToExtF80UI.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF128M.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF128UI.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF16UI.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF32UI.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF64UI.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_extF80MToCommonNaN.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_extF80UIToCommonNaN.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_f128MToCommonNaN.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_f128UIToCommonNaN.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_f16UIToCommonNaN.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_f32UIToCommonNaN.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_f64UIToCommonNaN.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80M.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80UI.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128M.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128UI.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF16UI.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF32UI.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF64UI.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2-defaultNaN/softfloat_raiseFlags.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2-defaultNaN/specialize.h
create mode 100644 test/float/softfloat/source/ARM-VFPv2/extF80M_isSignalingNaN.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2/f128M_isSignalingNaN.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2/s_commonNaNToExtF80M.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2/s_commonNaNToExtF80UI.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2/s_commonNaNToF128M.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2/s_commonNaNToF128UI.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2/s_commonNaNToF16UI.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2/s_commonNaNToF32UI.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2/s_commonNaNToF64UI.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2/s_extF80MToCommonNaN.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2/s_extF80UIToCommonNaN.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2/s_f128MToCommonNaN.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2/s_f128UIToCommonNaN.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2/s_f16UIToCommonNaN.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2/s_f32UIToCommonNaN.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2/s_f64UIToCommonNaN.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2/s_propagateNaNExtF80M.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2/s_propagateNaNExtF80UI.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2/s_propagateNaNF128M.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2/s_propagateNaNF128UI.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2/s_propagateNaNF16UI.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2/s_propagateNaNF32UI.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2/s_propagateNaNF64UI.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2/softfloat_raiseFlags.c
create mode 100644 test/float/softfloat/source/ARM-VFPv2/specialize.h
create mode 100644 test/float/softfloat/source/extF80M_add.c
create mode 100644 test/float/softfloat/source/extF80M_div.c
create mode 100644 test/float/softfloat/source/extF80M_eq.c
create mode 100644 test/float/softfloat/source/extF80M_eq_signaling.c
create mode 100644 test/float/softfloat/source/extF80M_le.c
create mode 100644 test/float/softfloat/source/extF80M_le_quiet.c
create mode 100644 test/float/softfloat/source/extF80M_lt.c
create mode 100644 test/float/softfloat/source/extF80M_lt_quiet.c
create mode 100644 test/float/softfloat/source/extF80M_mul.c
create mode 100644 test/float/softfloat/source/extF80M_rem.c
create mode 100644 test/float/softfloat/source/extF80M_roundToInt.c
create mode 100644 test/float/softfloat/source/extF80M_sqrt.c
create mode 100644 test/float/softfloat/source/extF80M_sub.c
create mode 100644 test/float/softfloat/source/extF80M_to_f128M.c
create mode 100644 test/float/softfloat/source/extF80M_to_f16.c
create mode 100644 test/float/softfloat/source/extF80M_to_f32.c
create mode 100644 test/float/softfloat/source/extF80M_to_f64.c
create mode 100644 test/float/softfloat/source/extF80M_to_i32.c
create mode 100644 test/float/softfloat/source/extF80M_to_i32_r_minMag.c
create mode 100644 test/float/softfloat/source/extF80M_to_i64.c
create mode 100644 test/float/softfloat/source/extF80M_to_i64_r_minMag.c
create mode 100644 test/float/softfloat/source/extF80M_to_ui32.c
create mode 100644 test/float/softfloat/source/extF80M_to_ui32_r_minMag.c
create mode 100644 test/float/softfloat/source/extF80M_to_ui64.c
create mode 100644 test/float/softfloat/source/extF80M_to_ui64_r_minMag.c
create mode 100644 test/float/softfloat/source/extF80_add.c
create mode 100644 test/float/softfloat/source/extF80_div.c
create mode 100644 test/float/softfloat/source/extF80_eq.c
create mode 100644 test/float/softfloat/source/extF80_eq_signaling.c
create mode 100644 test/float/softfloat/source/extF80_isSignalingNaN.c
create mode 100644 test/float/softfloat/source/extF80_le.c
create mode 100644 test/float/softfloat/source/extF80_le_quiet.c
create mode 100644 test/float/softfloat/source/extF80_lt.c
create mode 100644 test/float/softfloat/source/extF80_lt_quiet.c
create mode 100644 test/float/softfloat/source/extF80_mul.c
create mode 100644 test/float/softfloat/source/extF80_rem.c
create mode 100644 test/float/softfloat/source/extF80_roundToInt.c
create mode 100644 test/float/softfloat/source/extF80_sqrt.c
create mode 100644 test/float/softfloat/source/extF80_sub.c
create mode 100644 test/float/softfloat/source/extF80_to_f128.c
create mode 100644 test/float/softfloat/source/extF80_to_f16.c
create mode 100644 test/float/softfloat/source/extF80_to_f32.c
create mode 100644 test/float/softfloat/source/extF80_to_f64.c
create mode 100644 test/float/softfloat/source/extF80_to_i32.c
create mode 100644 test/float/softfloat/source/extF80_to_i32_r_minMag.c
create mode 100644 test/float/softfloat/source/extF80_to_i64.c
create mode 100644 test/float/softfloat/source/extF80_to_i64_r_minMag.c
create mode 100644 test/float/softfloat/source/extF80_to_ui32.c
create mode 100644 test/float/softfloat/source/extF80_to_ui32_r_minMag.c
create mode 100644 test/float/softfloat/source/extF80_to_ui64.c
create mode 100644 test/float/softfloat/source/extF80_to_ui64_r_minMag.c
create mode 100644 test/float/softfloat/source/f128M_add.c
create mode 100644 test/float/softfloat/source/f128M_div.c
create mode 100644 test/float/softfloat/source/f128M_eq.c
create mode 100644 test/float/softfloat/source/f128M_eq_signaling.c
create mode 100644 test/float/softfloat/source/f128M_le.c
create mode 100644 test/float/softfloat/source/f128M_le_quiet.c
create mode 100644 test/float/softfloat/source/f128M_lt.c
create mode 100644 test/float/softfloat/source/f128M_lt_quiet.c
create mode 100644 test/float/softfloat/source/f128M_mul.c
create mode 100644 test/float/softfloat/source/f128M_mulAdd.c
create mode 100644 test/float/softfloat/source/f128M_rem.c
create mode 100644 test/float/softfloat/source/f128M_roundToInt.c
create mode 100644 test/float/softfloat/source/f128M_sqrt.c
create mode 100644 test/float/softfloat/source/f128M_sub.c
create mode 100644 test/float/softfloat/source/f128M_to_extF80M.c
create mode 100644 test/float/softfloat/source/f128M_to_f16.c
create mode 100644 test/float/softfloat/source/f128M_to_f32.c
create mode 100644 test/float/softfloat/source/f128M_to_f64.c
create mode 100644 test/float/softfloat/source/f128M_to_i32.c
create mode 100644 test/float/softfloat/source/f128M_to_i32_r_minMag.c
create mode 100644 test/float/softfloat/source/f128M_to_i64.c
create mode 100644 test/float/softfloat/source/f128M_to_i64_r_minMag.c
create mode 100644 test/float/softfloat/source/f128M_to_ui32.c
create mode 100644 test/float/softfloat/source/f128M_to_ui32_r_minMag.c
create mode 100644 test/float/softfloat/source/f128M_to_ui64.c
create mode 100644 test/float/softfloat/source/f128M_to_ui64_r_minMag.c
create mode 100644 test/float/softfloat/source/f128_add.c
create mode 100644 test/float/softfloat/source/f128_div.c
create mode 100644 test/float/softfloat/source/f128_eq.c
create mode 100644 test/float/softfloat/source/f128_eq_signaling.c
create mode 100644 test/float/softfloat/source/f128_isSignalingNaN.c
create mode 100644 test/float/softfloat/source/f128_le.c
create mode 100644 test/float/softfloat/source/f128_le_quiet.c
create mode 100644 test/float/softfloat/source/f128_lt.c
create mode 100644 test/float/softfloat/source/f128_lt_quiet.c
create mode 100644 test/float/softfloat/source/f128_mul.c
create mode 100644 test/float/softfloat/source/f128_mulAdd.c
create mode 100644 test/float/softfloat/source/f128_rem.c
create mode 100644 test/float/softfloat/source/f128_roundToInt.c
create mode 100644 test/float/softfloat/source/f128_sqrt.c
create mode 100644 test/float/softfloat/source/f128_sub.c
create mode 100644 test/float/softfloat/source/f128_to_extF80.c
create mode 100644 test/float/softfloat/source/f128_to_f16.c
create mode 100644 test/float/softfloat/source/f128_to_f32.c
create mode 100644 test/float/softfloat/source/f128_to_f64.c
create mode 100644 test/float/softfloat/source/f128_to_i32.c
create mode 100644 test/float/softfloat/source/f128_to_i32_r_minMag.c
create mode 100644 test/float/softfloat/source/f128_to_i64.c
create mode 100644 test/float/softfloat/source/f128_to_i64_r_minMag.c
create mode 100644 test/float/softfloat/source/f128_to_ui32.c
create mode 100644 test/float/softfloat/source/f128_to_ui32_r_minMag.c
create mode 100644 test/float/softfloat/source/f128_to_ui64.c
create mode 100644 test/float/softfloat/source/f128_to_ui64_r_minMag.c
create mode 100644 test/float/softfloat/source/f16_add.c
create mode 100644 test/float/softfloat/source/f16_div.c
create mode 100644 test/float/softfloat/source/f16_eq.c
create mode 100644 test/float/softfloat/source/f16_eq_signaling.c
create mode 100644 test/float/softfloat/source/f16_isSignalingNaN.c
create mode 100644 test/float/softfloat/source/f16_le.c
create mode 100644 test/float/softfloat/source/f16_le_quiet.c
create mode 100644 test/float/softfloat/source/f16_lt.c
create mode 100644 test/float/softfloat/source/f16_lt_quiet.c
create mode 100644 test/float/softfloat/source/f16_mul.c
create mode 100644 test/float/softfloat/source/f16_mulAdd.c
create mode 100644 test/float/softfloat/source/f16_rem.c
create mode 100644 test/float/softfloat/source/f16_roundToInt.c
create mode 100644 test/float/softfloat/source/f16_sqrt.c
create mode 100644 test/float/softfloat/source/f16_sub.c
create mode 100644 test/float/softfloat/source/f16_to_extF80.c
create mode 100644 test/float/softfloat/source/f16_to_extF80M.c
create mode 100644 test/float/softfloat/source/f16_to_f128.c
create mode 100644 test/float/softfloat/source/f16_to_f128M.c
create mode 100644 test/float/softfloat/source/f16_to_f32.c
create mode 100644 test/float/softfloat/source/f16_to_f64.c
create mode 100644 test/float/softfloat/source/f16_to_i32.c
create mode 100644 test/float/softfloat/source/f16_to_i32_r_minMag.c
create mode 100644 test/float/softfloat/source/f16_to_i64.c
create mode 100644 test/float/softfloat/source/f16_to_i64_r_minMag.c
create mode 100644 test/float/softfloat/source/f16_to_ui32.c
create mode 100644 test/float/softfloat/source/f16_to_ui32_r_minMag.c
create mode 100644 test/float/softfloat/source/f16_to_ui64.c
create mode 100644 test/float/softfloat/source/f16_to_ui64_r_minMag.c
create mode 100644 test/float/softfloat/source/f32_add.c
create mode 100644 test/float/softfloat/source/f32_div.c
create mode 100644 test/float/softfloat/source/f32_eq.c
create mode 100644 test/float/softfloat/source/f32_eq_signaling.c
create mode 100644 test/float/softfloat/source/f32_isSignalingNaN.c
create mode 100644 test/float/softfloat/source/f32_le.c
create mode 100644 test/float/softfloat/source/f32_le_quiet.c
create mode 100644 test/float/softfloat/source/f32_lt.c
create mode 100644 test/float/softfloat/source/f32_lt_quiet.c
create mode 100644 test/float/softfloat/source/f32_mul.c
create mode 100644 test/float/softfloat/source/f32_mulAdd.c
create mode 100644 test/float/softfloat/source/f32_rem.c
create mode 100644 test/float/softfloat/source/f32_roundToInt.c
create mode 100644 test/float/softfloat/source/f32_sqrt.c
create mode 100644 test/float/softfloat/source/f32_sub.c
create mode 100644 test/float/softfloat/source/f32_to_extF80.c
create mode 100644 test/float/softfloat/source/f32_to_extF80M.c
create mode 100644 test/float/softfloat/source/f32_to_f128.c
create mode 100644 test/float/softfloat/source/f32_to_f128M.c
create mode 100644 test/float/softfloat/source/f32_to_f16.c
create mode 100644 test/float/softfloat/source/f32_to_f64.c
create mode 100644 test/float/softfloat/source/f32_to_i32.c
create mode 100644 test/float/softfloat/source/f32_to_i32_r_minMag.c
create mode 100644 test/float/softfloat/source/f32_to_i64.c
create mode 100644 test/float/softfloat/source/f32_to_i64_r_minMag.c
create mode 100644 test/float/softfloat/source/f32_to_ui32.c
create mode 100644 test/float/softfloat/source/f32_to_ui32_r_minMag.c
create mode 100644 test/float/softfloat/source/f32_to_ui64.c
create mode 100644 test/float/softfloat/source/f32_to_ui64_r_minMag.c
create mode 100644 test/float/softfloat/source/f64_add.c
create mode 100644 test/float/softfloat/source/f64_div.c
create mode 100644 test/float/softfloat/source/f64_eq.c
create mode 100644 test/float/softfloat/source/f64_eq_signaling.c
create mode 100644 test/float/softfloat/source/f64_isSignalingNaN.c
create mode 100644 test/float/softfloat/source/f64_le.c
create mode 100644 test/float/softfloat/source/f64_le_quiet.c
create mode 100644 test/float/softfloat/source/f64_lt.c
create mode 100644 test/float/softfloat/source/f64_lt_quiet.c
create mode 100644 test/float/softfloat/source/f64_mul.c
create mode 100644 test/float/softfloat/source/f64_mulAdd.c
create mode 100644 test/float/softfloat/source/f64_rem.c
create mode 100644 test/float/softfloat/source/f64_roundToInt.c
create mode 100644 test/float/softfloat/source/f64_sqrt.c
create mode 100644 test/float/softfloat/source/f64_sub.c
create mode 100644 test/float/softfloat/source/f64_to_extF80.c
create mode 100644 test/float/softfloat/source/f64_to_extF80M.c
create mode 100644 test/float/softfloat/source/f64_to_f128.c
create mode 100644 test/float/softfloat/source/f64_to_f128M.c
create mode 100644 test/float/softfloat/source/f64_to_f16.c
create mode 100644 test/float/softfloat/source/f64_to_f32.c
create mode 100644 test/float/softfloat/source/f64_to_i32.c
create mode 100644 test/float/softfloat/source/f64_to_i32_r_minMag.c
create mode 100644 test/float/softfloat/source/f64_to_i64.c
create mode 100644 test/float/softfloat/source/f64_to_i64_r_minMag.c
create mode 100644 test/float/softfloat/source/f64_to_ui32.c
create mode 100644 test/float/softfloat/source/f64_to_ui32_r_minMag.c
create mode 100644 test/float/softfloat/source/f64_to_ui64.c
create mode 100644 test/float/softfloat/source/f64_to_ui64_r_minMag.c
create mode 100644 test/float/softfloat/source/i32_to_extF80.c
create mode 100644 test/float/softfloat/source/i32_to_extF80M.c
create mode 100644 test/float/softfloat/source/i32_to_f128.c
create mode 100644 test/float/softfloat/source/i32_to_f128M.c
create mode 100644 test/float/softfloat/source/i32_to_f16.c
create mode 100644 test/float/softfloat/source/i32_to_f32.c
create mode 100644 test/float/softfloat/source/i32_to_f64.c
create mode 100644 test/float/softfloat/source/i64_to_extF80.c
create mode 100644 test/float/softfloat/source/i64_to_extF80M.c
create mode 100644 test/float/softfloat/source/i64_to_f128.c
create mode 100644 test/float/softfloat/source/i64_to_f128M.c
create mode 100644 test/float/softfloat/source/i64_to_f16.c
create mode 100644 test/float/softfloat/source/i64_to_f32.c
create mode 100644 test/float/softfloat/source/i64_to_f64.c
create mode 100644 test/float/softfloat/source/include/internals.h
create mode 100644 test/float/softfloat/source/include/opts-GCC.h
create mode 100644 test/float/softfloat/source/include/primitiveTypes.h
create mode 100644 test/float/softfloat/source/include/primitives.h
create mode 100644 test/float/softfloat/source/include/softfloat.h
create mode 100644 test/float/softfloat/source/include/softfloat_types.h
create mode 100644 test/float/softfloat/source/s_add128.c
create mode 100644 test/float/softfloat/source/s_add256M.c
create mode 100644 test/float/softfloat/source/s_addCarryM.c
create mode 100644 test/float/softfloat/source/s_addComplCarryM.c
create mode 100644 test/float/softfloat/source/s_addExtF80M.c
create mode 100644 test/float/softfloat/source/s_addF128M.c
create mode 100644 test/float/softfloat/source/s_addM.c
create mode 100644 test/float/softfloat/source/s_addMagsExtF80.c
create mode 100644 test/float/softfloat/source/s_addMagsF128.c
create mode 100644 test/float/softfloat/source/s_addMagsF16.c
create mode 100644 test/float/softfloat/source/s_addMagsF32.c
create mode 100644 test/float/softfloat/source/s_addMagsF64.c
create mode 100644 test/float/softfloat/source/s_approxRecip32_1.c
create mode 100644 test/float/softfloat/source/s_approxRecipSqrt32_1.c
create mode 100644 test/float/softfloat/source/s_approxRecipSqrt_1Ks.c
create mode 100644 test/float/softfloat/source/s_approxRecip_1Ks.c
create mode 100644 test/float/softfloat/source/s_compare128M.c
create mode 100644 test/float/softfloat/source/s_compare96M.c
create mode 100644 test/float/softfloat/source/s_compareNonnormExtF80M.c
create mode 100644 test/float/softfloat/source/s_countLeadingZeros16.c
create mode 100644 test/float/softfloat/source/s_countLeadingZeros32.c
create mode 100644 test/float/softfloat/source/s_countLeadingZeros64.c
create mode 100644 test/float/softfloat/source/s_countLeadingZeros8.c
create mode 100644 test/float/softfloat/source/s_eq128.c
create mode 100644 test/float/softfloat/source/s_invalidExtF80M.c
create mode 100644 test/float/softfloat/source/s_invalidF128M.c
create mode 100644 test/float/softfloat/source/s_isNaNF128M.c
create mode 100644 test/float/softfloat/source/s_le128.c
create mode 100644 test/float/softfloat/source/s_lt128.c
create mode 100644 test/float/softfloat/source/s_mul128By32.c
create mode 100644 test/float/softfloat/source/s_mul128MTo256M.c
create mode 100644 test/float/softfloat/source/s_mul128To256M.c
create mode 100644 test/float/softfloat/source/s_mul64ByShifted32To128.c
create mode 100644 test/float/softfloat/source/s_mul64To128.c
create mode 100644 test/float/softfloat/source/s_mul64To128M.c
create mode 100644 test/float/softfloat/source/s_mulAddF128.c
create mode 100644 test/float/softfloat/source/s_mulAddF128M.c
create mode 100644 test/float/softfloat/source/s_mulAddF16.c
create mode 100644 test/float/softfloat/source/s_mulAddF32.c
create mode 100644 test/float/softfloat/source/s_mulAddF64.c
create mode 100644 test/float/softfloat/source/s_negXM.c
create mode 100644 test/float/softfloat/source/s_normExtF80SigM.c
create mode 100644 test/float/softfloat/source/s_normRoundPackMToExtF80M.c
create mode 100644 test/float/softfloat/source/s_normRoundPackMToF128M.c
create mode 100644 test/float/softfloat/source/s_normRoundPackToExtF80.c
create mode 100644 test/float/softfloat/source/s_normRoundPackToF128.c
create mode 100644 test/float/softfloat/source/s_normRoundPackToF16.c
create mode 100644 test/float/softfloat/source/s_normRoundPackToF32.c
create mode 100644 test/float/softfloat/source/s_normRoundPackToF64.c
create mode 100644 test/float/softfloat/source/s_normSubnormalExtF80Sig.c
create mode 100644 test/float/softfloat/source/s_normSubnormalF128Sig.c
create mode 100644 test/float/softfloat/source/s_normSubnormalF128SigM.c
create mode 100644 test/float/softfloat/source/s_normSubnormalF16Sig.c
create mode 100644 test/float/softfloat/source/s_normSubnormalF32Sig.c
create mode 100644 test/float/softfloat/source/s_normSubnormalF64Sig.c
create mode 100644 test/float/softfloat/source/s_remStepMBy32.c
create mode 100644 test/float/softfloat/source/s_roundMToI64.c
create mode 100644 test/float/softfloat/source/s_roundMToUI64.c
create mode 100644 test/float/softfloat/source/s_roundPackMToExtF80M.c
create mode 100644 test/float/softfloat/source/s_roundPackMToF128M.c
create mode 100644 test/float/softfloat/source/s_roundPackToExtF80.c
create mode 100644 test/float/softfloat/source/s_roundPackToF128.c
create mode 100644 test/float/softfloat/source/s_roundPackToF16.c
create mode 100644 test/float/softfloat/source/s_roundPackToF32.c
create mode 100644 test/float/softfloat/source/s_roundPackToF64.c
create mode 100644 test/float/softfloat/source/s_roundToI32.c
create mode 100644 test/float/softfloat/source/s_roundToI64.c
create mode 100644 test/float/softfloat/source/s_roundToUI32.c
create mode 100644 test/float/softfloat/source/s_roundToUI64.c
create mode 100644 test/float/softfloat/source/s_shiftLeftM.c
create mode 100644 test/float/softfloat/source/s_shiftNormSigF128M.c
create mode 100644 test/float/softfloat/source/s_shiftRightJam128.c
create mode 100644 test/float/softfloat/source/s_shiftRightJam128Extra.c
create mode 100644 test/float/softfloat/source/s_shiftRightJam256M.c
create mode 100644 test/float/softfloat/source/s_shiftRightJam32.c
create mode 100644 test/float/softfloat/source/s_shiftRightJam64.c
create mode 100644 test/float/softfloat/source/s_shiftRightJam64Extra.c
create mode 100644 test/float/softfloat/source/s_shiftRightJamM.c
create mode 100644 test/float/softfloat/source/s_shiftRightM.c
create mode 100644 test/float/softfloat/source/s_shortShiftLeft128.c
create mode 100644 test/float/softfloat/source/s_shortShiftLeft64To96M.c
create mode 100644 test/float/softfloat/source/s_shortShiftLeftM.c
create mode 100644 test/float/softfloat/source/s_shortShiftRight128.c
create mode 100644 test/float/softfloat/source/s_shortShiftRightExtendM.c
create mode 100644 test/float/softfloat/source/s_shortShiftRightJam128.c
create mode 100644 test/float/softfloat/source/s_shortShiftRightJam128Extra.c
create mode 100644 test/float/softfloat/source/s_shortShiftRightJam64.c
create mode 100644 test/float/softfloat/source/s_shortShiftRightJam64Extra.c
create mode 100644 test/float/softfloat/source/s_shortShiftRightJamM.c
create mode 100644 test/float/softfloat/source/s_shortShiftRightM.c
create mode 100644 test/float/softfloat/source/s_sub128.c
create mode 100644 test/float/softfloat/source/s_sub1XM.c
create mode 100644 test/float/softfloat/source/s_sub256M.c
create mode 100644 test/float/softfloat/source/s_subM.c
create mode 100644 test/float/softfloat/source/s_subMagsExtF80.c
create mode 100644 test/float/softfloat/source/s_subMagsF128.c
create mode 100644 test/float/softfloat/source/s_subMagsF16.c
create mode 100644 test/float/softfloat/source/s_subMagsF32.c
create mode 100644 test/float/softfloat/source/s_subMagsF64.c
create mode 100644 test/float/softfloat/source/s_tryPropagateNaNExtF80M.c
create mode 100644 test/float/softfloat/source/s_tryPropagateNaNF128M.c
create mode 100644 test/float/softfloat/source/softfloat_state.c
create mode 100644 test/float/softfloat/source/ui32_to_extF80.c
create mode 100644 test/float/softfloat/source/ui32_to_extF80M.c
create mode 100644 test/float/softfloat/source/ui32_to_f128.c
create mode 100644 test/float/softfloat/source/ui32_to_f128M.c
create mode 100644 test/float/softfloat/source/ui32_to_f16.c
create mode 100644 test/float/softfloat/source/ui32_to_f32.c
create mode 100644 test/float/softfloat/source/ui32_to_f64.c
create mode 100644 test/float/softfloat/source/ui64_to_extF80.c
create mode 100644 test/float/softfloat/source/ui64_to_extF80M.c
create mode 100644 test/float/softfloat/source/ui64_to_f128.c
create mode 100644 test/float/softfloat/source/ui64_to_f128M.c
create mode 100644 test/float/softfloat/source/ui64_to_f16.c
create mode 100644 test/float/softfloat/source/ui64_to_f32.c
create mode 100644 test/float/softfloat/source/ui64_to_f64.c
diff --git a/test/float/softfloat/COPYING.txt b/test/float/softfloat/COPYING.txt
new file mode 100644
index 000000000..b5690face
--- /dev/null
+++ b/test/float/softfloat/COPYING.txt
@@ -0,0 +1,37 @@
+
+License for Berkeley SoftFloat Release 3e
+
+John R. Hauser
+2018 January 20
+
+The following applies to the whole of SoftFloat Release 3e as well as to
+each source file individually.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 The Regents of the
+University of California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions, and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
diff --git a/test/float/softfloat/README.html b/test/float/softfloat/README.html
new file mode 100644
index 000000000..e695c2bd8
--- /dev/null
+++ b/test/float/softfloat/README.html
@@ -0,0 +1,49 @@
+
+
+
+
+Berkeley SoftFloat Package Overview
+
+
+
+
+Package Overview for Berkeley SoftFloat Release 3e
+
+
+John R. Hauser
+2018 January 20
+
+
+
+Berkeley SoftFloat is a software implementation of binary floating-point that
+conforms to the IEEE Standard for Floating-Point Arithmetic.
+SoftFloat is distributed in the form of C source code.
+Building the SoftFloat sources generates a library file (typically
+softfloat.a
or libsoftfloat.a
) containing the
+floating-point subroutines.
+
+
+
+The SoftFloat package is documented in the following files in the
+doc
subdirectory:
+
+
+
+Other files in the package comprise the source code for SoftFloat.
+
+
+
+
diff --git a/test/float/softfloat/README.txt b/test/float/softfloat/README.txt
new file mode 100644
index 000000000..1613c7671
--- /dev/null
+++ b/test/float/softfloat/README.txt
@@ -0,0 +1,21 @@
+
+Package Overview for Berkeley SoftFloat Release 3e
+
+John R. Hauser
+2018 January 20
+
+Berkeley SoftFloat is a software implementation of binary floating-point
+that conforms to the IEEE Standard for Floating-Point Arithmetic. SoftFloat
+is distributed in the form of C source code. Building the SoftFloat sources
+generates a library file (typically "softfloat.a" or "libsoftfloat.a")
+containing the floating-point subroutines.
+
+The SoftFloat package is documented in the following files in the "doc"
+subdirectory:
+
+ SoftFloat.html Documentation for using the SoftFloat functions.
+ SoftFloat-source.html Documentation for building SoftFloat.
+ SoftFloat-history.html History of the major changes to SoftFloat.
+
+Other files in the package comprise the source code for SoftFloat.
+
diff --git a/test/float/softfloat/build/Linux-386-GCC/Makefile b/test/float/softfloat/build/Linux-386-GCC/Makefile
new file mode 100644
index 000000000..faeb39728
--- /dev/null
+++ b/test/float/softfloat/build/Linux-386-GCC/Makefile
@@ -0,0 +1,325 @@
+
+#=============================================================================
+#
+# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic
+# Package, Release 3e, by John R. Hauser.
+#
+# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+# University of California. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice,
+# this list of conditions, and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions, and the following disclaimer in the
+# documentation and/or other materials provided with the distribution.
+#
+# 3. Neither the name of the University nor the names of its contributors
+# may be used to endorse or promote products derived from this software
+# without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+#=============================================================================
+
+SOURCE_DIR ?= ../../source
+SPECIALIZE_TYPE ?= 8086
+
+SOFTFLOAT_OPTS ?= \
+ -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
+ -DSOFTFLOAT_FAST_DIV64TO32
+
+DELETE = rm -f
+C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
+COMPILE_C = \
+ gcc -c -Werror-implicit-function-declaration $(SOFTFLOAT_OPTS) \
+ $(C_INCLUDES) -O2 -o $@
+MAKELIB = ar crs $@
+
+OBJ = .o
+LIB = .a
+
+OTHER_HEADERS =
+
+.PHONY: all
+all: softfloat$(LIB)
+
+OBJS_PRIMITIVES = \
+ s_compare96M$(OBJ) \
+ s_compare128M$(OBJ) \
+ s_shortShiftLeft64To96M$(OBJ) \
+ s_shortShiftLeftM$(OBJ) \
+ s_shiftLeftM$(OBJ) \
+ s_shortShiftRightM$(OBJ) \
+ s_shortShiftRightJam64$(OBJ) \
+ s_shortShiftRightJamM$(OBJ) \
+ s_shiftRightJam32$(OBJ) \
+ s_shiftRightJam64$(OBJ) \
+ s_shiftRightJamM$(OBJ) \
+ s_shiftRightM$(OBJ) \
+ s_countLeadingZeros8$(OBJ) \
+ s_countLeadingZeros16$(OBJ) \
+ s_countLeadingZeros32$(OBJ) \
+ s_countLeadingZeros64$(OBJ) \
+ s_addM$(OBJ) \
+ s_addCarryM$(OBJ) \
+ s_addComplCarryM$(OBJ) \
+ s_negXM$(OBJ) \
+ s_sub1XM$(OBJ) \
+ s_subM$(OBJ) \
+ s_mul64To128M$(OBJ) \
+ s_mul128MTo256M$(OBJ) \
+ s_approxRecip_1Ks$(OBJ) \
+ s_approxRecip32_1$(OBJ) \
+ s_approxRecipSqrt_1Ks$(OBJ) \
+ s_approxRecipSqrt32_1$(OBJ) \
+ s_remStepMBy32$(OBJ) \
+
+OBJS_SPECIALIZE = \
+ softfloat_raiseFlags$(OBJ) \
+ s_f16UIToCommonNaN$(OBJ) \
+ s_commonNaNToF16UI$(OBJ) \
+ s_propagateNaNF16UI$(OBJ) \
+ s_f32UIToCommonNaN$(OBJ) \
+ s_commonNaNToF32UI$(OBJ) \
+ s_propagateNaNF32UI$(OBJ) \
+ s_f64UIToCommonNaN$(OBJ) \
+ s_commonNaNToF64UI$(OBJ) \
+ s_propagateNaNF64UI$(OBJ) \
+ extF80M_isSignalingNaN$(OBJ) \
+ s_extF80MToCommonNaN$(OBJ) \
+ s_commonNaNToExtF80M$(OBJ) \
+ s_propagateNaNExtF80M$(OBJ) \
+ f128M_isSignalingNaN$(OBJ) \
+ s_f128MToCommonNaN$(OBJ) \
+ s_commonNaNToF128M$(OBJ) \
+ s_propagateNaNF128M$(OBJ) \
+
+OBJS_OTHERS = \
+ s_roundToUI32$(OBJ) \
+ s_roundMToUI64$(OBJ) \
+ s_roundToI32$(OBJ) \
+ s_roundMToI64$(OBJ) \
+ s_normSubnormalF16Sig$(OBJ) \
+ s_roundPackToF16$(OBJ) \
+ s_normRoundPackToF16$(OBJ) \
+ s_addMagsF16$(OBJ) \
+ s_subMagsF16$(OBJ) \
+ s_mulAddF16$(OBJ) \
+ s_normSubnormalF32Sig$(OBJ) \
+ s_roundPackToF32$(OBJ) \
+ s_normRoundPackToF32$(OBJ) \
+ s_addMagsF32$(OBJ) \
+ s_subMagsF32$(OBJ) \
+ s_mulAddF32$(OBJ) \
+ s_normSubnormalF64Sig$(OBJ) \
+ s_roundPackToF64$(OBJ) \
+ s_normRoundPackToF64$(OBJ) \
+ s_addMagsF64$(OBJ) \
+ s_subMagsF64$(OBJ) \
+ s_mulAddF64$(OBJ) \
+ s_tryPropagateNaNExtF80M$(OBJ) \
+ s_invalidExtF80M$(OBJ) \
+ s_normExtF80SigM$(OBJ) \
+ s_roundPackMToExtF80M$(OBJ) \
+ s_normRoundPackMToExtF80M$(OBJ) \
+ s_addExtF80M$(OBJ) \
+ s_compareNonnormExtF80M$(OBJ) \
+ s_isNaNF128M$(OBJ) \
+ s_tryPropagateNaNF128M$(OBJ) \
+ s_invalidF128M$(OBJ) \
+ s_shiftNormSigF128M$(OBJ) \
+ s_roundPackMToF128M$(OBJ) \
+ s_normRoundPackMToF128M$(OBJ) \
+ s_addF128M$(OBJ) \
+ s_mulAddF128M$(OBJ) \
+ softfloat_state$(OBJ) \
+ ui32_to_f16$(OBJ) \
+ ui32_to_f32$(OBJ) \
+ ui32_to_f64$(OBJ) \
+ ui32_to_extF80M$(OBJ) \
+ ui32_to_f128M$(OBJ) \
+ ui64_to_f16$(OBJ) \
+ ui64_to_f32$(OBJ) \
+ ui64_to_f64$(OBJ) \
+ ui64_to_extF80M$(OBJ) \
+ ui64_to_f128M$(OBJ) \
+ i32_to_f16$(OBJ) \
+ i32_to_f32$(OBJ) \
+ i32_to_f64$(OBJ) \
+ i32_to_extF80M$(OBJ) \
+ i32_to_f128M$(OBJ) \
+ i64_to_f16$(OBJ) \
+ i64_to_f32$(OBJ) \
+ i64_to_f64$(OBJ) \
+ i64_to_extF80M$(OBJ) \
+ i64_to_f128M$(OBJ) \
+ f16_to_ui32$(OBJ) \
+ f16_to_ui64$(OBJ) \
+ f16_to_i32$(OBJ) \
+ f16_to_i64$(OBJ) \
+ f16_to_ui32_r_minMag$(OBJ) \
+ f16_to_ui64_r_minMag$(OBJ) \
+ f16_to_i32_r_minMag$(OBJ) \
+ f16_to_i64_r_minMag$(OBJ) \
+ f16_to_f32$(OBJ) \
+ f16_to_f64$(OBJ) \
+ f16_to_extF80M$(OBJ) \
+ f16_to_f128M$(OBJ) \
+ f16_roundToInt$(OBJ) \
+ f16_add$(OBJ) \
+ f16_sub$(OBJ) \
+ f16_mul$(OBJ) \
+ f16_mulAdd$(OBJ) \
+ f16_div$(OBJ) \
+ f16_rem$(OBJ) \
+ f16_sqrt$(OBJ) \
+ f16_eq$(OBJ) \
+ f16_le$(OBJ) \
+ f16_lt$(OBJ) \
+ f16_eq_signaling$(OBJ) \
+ f16_le_quiet$(OBJ) \
+ f16_lt_quiet$(OBJ) \
+ f16_isSignalingNaN$(OBJ) \
+ f32_to_ui32$(OBJ) \
+ f32_to_ui64$(OBJ) \
+ f32_to_i32$(OBJ) \
+ f32_to_i64$(OBJ) \
+ f32_to_ui32_r_minMag$(OBJ) \
+ f32_to_ui64_r_minMag$(OBJ) \
+ f32_to_i32_r_minMag$(OBJ) \
+ f32_to_i64_r_minMag$(OBJ) \
+ f32_to_f16$(OBJ) \
+ f32_to_f64$(OBJ) \
+ f32_to_extF80M$(OBJ) \
+ f32_to_f128M$(OBJ) \
+ f32_roundToInt$(OBJ) \
+ f32_add$(OBJ) \
+ f32_sub$(OBJ) \
+ f32_mul$(OBJ) \
+ f32_mulAdd$(OBJ) \
+ f32_div$(OBJ) \
+ f32_rem$(OBJ) \
+ f32_sqrt$(OBJ) \
+ f32_eq$(OBJ) \
+ f32_le$(OBJ) \
+ f32_lt$(OBJ) \
+ f32_eq_signaling$(OBJ) \
+ f32_le_quiet$(OBJ) \
+ f32_lt_quiet$(OBJ) \
+ f32_isSignalingNaN$(OBJ) \
+ f64_to_ui32$(OBJ) \
+ f64_to_ui64$(OBJ) \
+ f64_to_i32$(OBJ) \
+ f64_to_i64$(OBJ) \
+ f64_to_ui32_r_minMag$(OBJ) \
+ f64_to_ui64_r_minMag$(OBJ) \
+ f64_to_i32_r_minMag$(OBJ) \
+ f64_to_i64_r_minMag$(OBJ) \
+ f64_to_f16$(OBJ) \
+ f64_to_f32$(OBJ) \
+ f64_to_extF80M$(OBJ) \
+ f64_to_f128M$(OBJ) \
+ f64_roundToInt$(OBJ) \
+ f64_add$(OBJ) \
+ f64_sub$(OBJ) \
+ f64_mul$(OBJ) \
+ f64_mulAdd$(OBJ) \
+ f64_div$(OBJ) \
+ f64_rem$(OBJ) \
+ f64_sqrt$(OBJ) \
+ f64_eq$(OBJ) \
+ f64_le$(OBJ) \
+ f64_lt$(OBJ) \
+ f64_eq_signaling$(OBJ) \
+ f64_le_quiet$(OBJ) \
+ f64_lt_quiet$(OBJ) \
+ f64_isSignalingNaN$(OBJ) \
+ extF80M_to_ui32$(OBJ) \
+ extF80M_to_ui64$(OBJ) \
+ extF80M_to_i32$(OBJ) \
+ extF80M_to_i64$(OBJ) \
+ extF80M_to_ui32_r_minMag$(OBJ) \
+ extF80M_to_ui64_r_minMag$(OBJ) \
+ extF80M_to_i32_r_minMag$(OBJ) \
+ extF80M_to_i64_r_minMag$(OBJ) \
+ extF80M_to_f16$(OBJ) \
+ extF80M_to_f32$(OBJ) \
+ extF80M_to_f64$(OBJ) \
+ extF80M_to_f128M$(OBJ) \
+ extF80M_roundToInt$(OBJ) \
+ extF80M_add$(OBJ) \
+ extF80M_sub$(OBJ) \
+ extF80M_mul$(OBJ) \
+ extF80M_div$(OBJ) \
+ extF80M_rem$(OBJ) \
+ extF80M_sqrt$(OBJ) \
+ extF80M_eq$(OBJ) \
+ extF80M_le$(OBJ) \
+ extF80M_lt$(OBJ) \
+ extF80M_eq_signaling$(OBJ) \
+ extF80M_le_quiet$(OBJ) \
+ extF80M_lt_quiet$(OBJ) \
+ f128M_to_ui32$(OBJ) \
+ f128M_to_ui64$(OBJ) \
+ f128M_to_i32$(OBJ) \
+ f128M_to_i64$(OBJ) \
+ f128M_to_ui32_r_minMag$(OBJ) \
+ f128M_to_ui64_r_minMag$(OBJ) \
+ f128M_to_i32_r_minMag$(OBJ) \
+ f128M_to_i64_r_minMag$(OBJ) \
+ f128M_to_f16$(OBJ) \
+ f128M_to_f32$(OBJ) \
+ f128M_to_f64$(OBJ) \
+ f128M_to_extF80M$(OBJ) \
+ f128M_roundToInt$(OBJ) \
+ f128M_add$(OBJ) \
+ f128M_sub$(OBJ) \
+ f128M_mul$(OBJ) \
+ f128M_mulAdd$(OBJ) \
+ f128M_div$(OBJ) \
+ f128M_rem$(OBJ) \
+ f128M_sqrt$(OBJ) \
+ f128M_eq$(OBJ) \
+ f128M_le$(OBJ) \
+ f128M_lt$(OBJ) \
+ f128M_eq_signaling$(OBJ) \
+ f128M_le_quiet$(OBJ) \
+ f128M_lt_quiet$(OBJ) \
+
+OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
+
+$(OBJS_ALL): \
+ $(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
+ $(SOURCE_DIR)/include/primitives.h
+$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
+ $(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
+ $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
+ $(SOURCE_DIR)/include/softfloat.h
+
+$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
+ $(COMPILE_C) $(SOURCE_DIR)/$*.c
+
+$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
+ $(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
+
+softfloat$(LIB): $(OBJS_ALL)
+ $(DELETE) $@
+ $(MAKELIB) $^
+
+.PHONY: clean
+clean:
+ $(DELETE) $(OBJS_ALL) softfloat$(LIB)
+
diff --git a/test/float/softfloat/build/Linux-386-GCC/platform.h b/test/float/softfloat/build/Linux-386-GCC/platform.h
new file mode 100644
index 000000000..d514dbc40
--- /dev/null
+++ b/test/float/softfloat/build/Linux-386-GCC/platform.h
@@ -0,0 +1,53 @@
+
+/*============================================================================
+
+This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#define LITTLEENDIAN 1
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#ifdef __GNUC_STDC_INLINE__
+#define INLINE inline
+#else
+#define INLINE extern inline
+#endif
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#define SOFTFLOAT_BUILTIN_CLZ 1
+#include "opts-GCC.h"
+
diff --git a/test/float/softfloat/build/Linux-386-SSE2-GCC/Makefile b/test/float/softfloat/build/Linux-386-SSE2-GCC/Makefile
new file mode 100644
index 000000000..ced977b69
--- /dev/null
+++ b/test/float/softfloat/build/Linux-386-SSE2-GCC/Makefile
@@ -0,0 +1,325 @@
+
+#=============================================================================
+#
+# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic
+# Package, Release 3e, by John R. Hauser.
+#
+# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+# University of California. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice,
+# this list of conditions, and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions, and the following disclaimer in the
+# documentation and/or other materials provided with the distribution.
+#
+# 3. Neither the name of the University nor the names of its contributors
+# may be used to endorse or promote products derived from this software
+# without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+#=============================================================================
+
+SOURCE_DIR ?= ../../source
+SPECIALIZE_TYPE ?= 8086-SSE
+
+SOFTFLOAT_OPTS ?= \
+ -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
+ -DSOFTFLOAT_FAST_DIV64TO32
+
+DELETE = rm -f
+C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
+COMPILE_C = \
+ gcc -c -Werror-implicit-function-declaration $(SOFTFLOAT_OPTS) \
+ $(C_INCLUDES) -O2 -o $@
+MAKELIB = ar crs $@
+
+OBJ = .o
+LIB = .a
+
+OTHER_HEADERS =
+
+.PHONY: all
+all: softfloat$(LIB)
+
+OBJS_PRIMITIVES = \
+ s_compare96M$(OBJ) \
+ s_compare128M$(OBJ) \
+ s_shortShiftLeft64To96M$(OBJ) \
+ s_shortShiftLeftM$(OBJ) \
+ s_shiftLeftM$(OBJ) \
+ s_shortShiftRightM$(OBJ) \
+ s_shortShiftRightJam64$(OBJ) \
+ s_shortShiftRightJamM$(OBJ) \
+ s_shiftRightJam32$(OBJ) \
+ s_shiftRightJam64$(OBJ) \
+ s_shiftRightJamM$(OBJ) \
+ s_shiftRightM$(OBJ) \
+ s_countLeadingZeros8$(OBJ) \
+ s_countLeadingZeros16$(OBJ) \
+ s_countLeadingZeros32$(OBJ) \
+ s_countLeadingZeros64$(OBJ) \
+ s_addM$(OBJ) \
+ s_addCarryM$(OBJ) \
+ s_addComplCarryM$(OBJ) \
+ s_negXM$(OBJ) \
+ s_sub1XM$(OBJ) \
+ s_subM$(OBJ) \
+ s_mul64To128M$(OBJ) \
+ s_mul128MTo256M$(OBJ) \
+ s_approxRecip_1Ks$(OBJ) \
+ s_approxRecip32_1$(OBJ) \
+ s_approxRecipSqrt_1Ks$(OBJ) \
+ s_approxRecipSqrt32_1$(OBJ) \
+ s_remStepMBy32$(OBJ) \
+
+OBJS_SPECIALIZE = \
+ softfloat_raiseFlags$(OBJ) \
+ s_f16UIToCommonNaN$(OBJ) \
+ s_commonNaNToF16UI$(OBJ) \
+ s_propagateNaNF16UI$(OBJ) \
+ s_f32UIToCommonNaN$(OBJ) \
+ s_commonNaNToF32UI$(OBJ) \
+ s_propagateNaNF32UI$(OBJ) \
+ s_f64UIToCommonNaN$(OBJ) \
+ s_commonNaNToF64UI$(OBJ) \
+ s_propagateNaNF64UI$(OBJ) \
+ extF80M_isSignalingNaN$(OBJ) \
+ s_extF80MToCommonNaN$(OBJ) \
+ s_commonNaNToExtF80M$(OBJ) \
+ s_propagateNaNExtF80M$(OBJ) \
+ f128M_isSignalingNaN$(OBJ) \
+ s_f128MToCommonNaN$(OBJ) \
+ s_commonNaNToF128M$(OBJ) \
+ s_propagateNaNF128M$(OBJ) \
+
+OBJS_OTHERS = \
+ s_roundToUI32$(OBJ) \
+ s_roundMToUI64$(OBJ) \
+ s_roundToI32$(OBJ) \
+ s_roundMToI64$(OBJ) \
+ s_normSubnormalF16Sig$(OBJ) \
+ s_roundPackToF16$(OBJ) \
+ s_normRoundPackToF16$(OBJ) \
+ s_addMagsF16$(OBJ) \
+ s_subMagsF16$(OBJ) \
+ s_mulAddF16$(OBJ) \
+ s_normSubnormalF32Sig$(OBJ) \
+ s_roundPackToF32$(OBJ) \
+ s_normRoundPackToF32$(OBJ) \
+ s_addMagsF32$(OBJ) \
+ s_subMagsF32$(OBJ) \
+ s_mulAddF32$(OBJ) \
+ s_normSubnormalF64Sig$(OBJ) \
+ s_roundPackToF64$(OBJ) \
+ s_normRoundPackToF64$(OBJ) \
+ s_addMagsF64$(OBJ) \
+ s_subMagsF64$(OBJ) \
+ s_mulAddF64$(OBJ) \
+ s_tryPropagateNaNExtF80M$(OBJ) \
+ s_invalidExtF80M$(OBJ) \
+ s_normExtF80SigM$(OBJ) \
+ s_roundPackMToExtF80M$(OBJ) \
+ s_normRoundPackMToExtF80M$(OBJ) \
+ s_addExtF80M$(OBJ) \
+ s_compareNonnormExtF80M$(OBJ) \
+ s_isNaNF128M$(OBJ) \
+ s_tryPropagateNaNF128M$(OBJ) \
+ s_invalidF128M$(OBJ) \
+ s_shiftNormSigF128M$(OBJ) \
+ s_roundPackMToF128M$(OBJ) \
+ s_normRoundPackMToF128M$(OBJ) \
+ s_addF128M$(OBJ) \
+ s_mulAddF128M$(OBJ) \
+ softfloat_state$(OBJ) \
+ ui32_to_f16$(OBJ) \
+ ui32_to_f32$(OBJ) \
+ ui32_to_f64$(OBJ) \
+ ui32_to_extF80M$(OBJ) \
+ ui32_to_f128M$(OBJ) \
+ ui64_to_f16$(OBJ) \
+ ui64_to_f32$(OBJ) \
+ ui64_to_f64$(OBJ) \
+ ui64_to_extF80M$(OBJ) \
+ ui64_to_f128M$(OBJ) \
+ i32_to_f16$(OBJ) \
+ i32_to_f32$(OBJ) \
+ i32_to_f64$(OBJ) \
+ i32_to_extF80M$(OBJ) \
+ i32_to_f128M$(OBJ) \
+ i64_to_f16$(OBJ) \
+ i64_to_f32$(OBJ) \
+ i64_to_f64$(OBJ) \
+ i64_to_extF80M$(OBJ) \
+ i64_to_f128M$(OBJ) \
+ f16_to_ui32$(OBJ) \
+ f16_to_ui64$(OBJ) \
+ f16_to_i32$(OBJ) \
+ f16_to_i64$(OBJ) \
+ f16_to_ui32_r_minMag$(OBJ) \
+ f16_to_ui64_r_minMag$(OBJ) \
+ f16_to_i32_r_minMag$(OBJ) \
+ f16_to_i64_r_minMag$(OBJ) \
+ f16_to_f32$(OBJ) \
+ f16_to_f64$(OBJ) \
+ f16_to_extF80M$(OBJ) \
+ f16_to_f128M$(OBJ) \
+ f16_roundToInt$(OBJ) \
+ f16_add$(OBJ) \
+ f16_sub$(OBJ) \
+ f16_mul$(OBJ) \
+ f16_mulAdd$(OBJ) \
+ f16_div$(OBJ) \
+ f16_rem$(OBJ) \
+ f16_sqrt$(OBJ) \
+ f16_eq$(OBJ) \
+ f16_le$(OBJ) \
+ f16_lt$(OBJ) \
+ f16_eq_signaling$(OBJ) \
+ f16_le_quiet$(OBJ) \
+ f16_lt_quiet$(OBJ) \
+ f16_isSignalingNaN$(OBJ) \
+ f32_to_ui32$(OBJ) \
+ f32_to_ui64$(OBJ) \
+ f32_to_i32$(OBJ) \
+ f32_to_i64$(OBJ) \
+ f32_to_ui32_r_minMag$(OBJ) \
+ f32_to_ui64_r_minMag$(OBJ) \
+ f32_to_i32_r_minMag$(OBJ) \
+ f32_to_i64_r_minMag$(OBJ) \
+ f32_to_f16$(OBJ) \
+ f32_to_f64$(OBJ) \
+ f32_to_extF80M$(OBJ) \
+ f32_to_f128M$(OBJ) \
+ f32_roundToInt$(OBJ) \
+ f32_add$(OBJ) \
+ f32_sub$(OBJ) \
+ f32_mul$(OBJ) \
+ f32_mulAdd$(OBJ) \
+ f32_div$(OBJ) \
+ f32_rem$(OBJ) \
+ f32_sqrt$(OBJ) \
+ f32_eq$(OBJ) \
+ f32_le$(OBJ) \
+ f32_lt$(OBJ) \
+ f32_eq_signaling$(OBJ) \
+ f32_le_quiet$(OBJ) \
+ f32_lt_quiet$(OBJ) \
+ f32_isSignalingNaN$(OBJ) \
+ f64_to_ui32$(OBJ) \
+ f64_to_ui64$(OBJ) \
+ f64_to_i32$(OBJ) \
+ f64_to_i64$(OBJ) \
+ f64_to_ui32_r_minMag$(OBJ) \
+ f64_to_ui64_r_minMag$(OBJ) \
+ f64_to_i32_r_minMag$(OBJ) \
+ f64_to_i64_r_minMag$(OBJ) \
+ f64_to_f16$(OBJ) \
+ f64_to_f32$(OBJ) \
+ f64_to_extF80M$(OBJ) \
+ f64_to_f128M$(OBJ) \
+ f64_roundToInt$(OBJ) \
+ f64_add$(OBJ) \
+ f64_sub$(OBJ) \
+ f64_mul$(OBJ) \
+ f64_mulAdd$(OBJ) \
+ f64_div$(OBJ) \
+ f64_rem$(OBJ) \
+ f64_sqrt$(OBJ) \
+ f64_eq$(OBJ) \
+ f64_le$(OBJ) \
+ f64_lt$(OBJ) \
+ f64_eq_signaling$(OBJ) \
+ f64_le_quiet$(OBJ) \
+ f64_lt_quiet$(OBJ) \
+ f64_isSignalingNaN$(OBJ) \
+ extF80M_to_ui32$(OBJ) \
+ extF80M_to_ui64$(OBJ) \
+ extF80M_to_i32$(OBJ) \
+ extF80M_to_i64$(OBJ) \
+ extF80M_to_ui32_r_minMag$(OBJ) \
+ extF80M_to_ui64_r_minMag$(OBJ) \
+ extF80M_to_i32_r_minMag$(OBJ) \
+ extF80M_to_i64_r_minMag$(OBJ) \
+ extF80M_to_f16$(OBJ) \
+ extF80M_to_f32$(OBJ) \
+ extF80M_to_f64$(OBJ) \
+ extF80M_to_f128M$(OBJ) \
+ extF80M_roundToInt$(OBJ) \
+ extF80M_add$(OBJ) \
+ extF80M_sub$(OBJ) \
+ extF80M_mul$(OBJ) \
+ extF80M_div$(OBJ) \
+ extF80M_rem$(OBJ) \
+ extF80M_sqrt$(OBJ) \
+ extF80M_eq$(OBJ) \
+ extF80M_le$(OBJ) \
+ extF80M_lt$(OBJ) \
+ extF80M_eq_signaling$(OBJ) \
+ extF80M_le_quiet$(OBJ) \
+ extF80M_lt_quiet$(OBJ) \
+ f128M_to_ui32$(OBJ) \
+ f128M_to_ui64$(OBJ) \
+ f128M_to_i32$(OBJ) \
+ f128M_to_i64$(OBJ) \
+ f128M_to_ui32_r_minMag$(OBJ) \
+ f128M_to_ui64_r_minMag$(OBJ) \
+ f128M_to_i32_r_minMag$(OBJ) \
+ f128M_to_i64_r_minMag$(OBJ) \
+ f128M_to_f16$(OBJ) \
+ f128M_to_f32$(OBJ) \
+ f128M_to_f64$(OBJ) \
+ f128M_to_extF80M$(OBJ) \
+ f128M_roundToInt$(OBJ) \
+ f128M_add$(OBJ) \
+ f128M_sub$(OBJ) \
+ f128M_mul$(OBJ) \
+ f128M_mulAdd$(OBJ) \
+ f128M_div$(OBJ) \
+ f128M_rem$(OBJ) \
+ f128M_sqrt$(OBJ) \
+ f128M_eq$(OBJ) \
+ f128M_le$(OBJ) \
+ f128M_lt$(OBJ) \
+ f128M_eq_signaling$(OBJ) \
+ f128M_le_quiet$(OBJ) \
+ f128M_lt_quiet$(OBJ) \
+
+OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
+
+$(OBJS_ALL): \
+ $(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
+ $(SOURCE_DIR)/include/primitives.h
+$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
+ $(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
+ $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
+ $(SOURCE_DIR)/include/softfloat.h
+
+$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
+ $(COMPILE_C) $(SOURCE_DIR)/$*.c
+
+$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
+ $(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
+
+softfloat$(LIB): $(OBJS_ALL)
+ $(DELETE) $@
+ $(MAKELIB) $^
+
+.PHONY: clean
+clean:
+ $(DELETE) $(OBJS_ALL) softfloat$(LIB)
+
diff --git a/test/float/softfloat/build/Linux-386-SSE2-GCC/platform.h b/test/float/softfloat/build/Linux-386-SSE2-GCC/platform.h
new file mode 100644
index 000000000..d514dbc40
--- /dev/null
+++ b/test/float/softfloat/build/Linux-386-SSE2-GCC/platform.h
@@ -0,0 +1,53 @@
+
+/*============================================================================
+
+This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#define LITTLEENDIAN 1
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#ifdef __GNUC_STDC_INLINE__
+#define INLINE inline
+#else
+#define INLINE extern inline
+#endif
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#define SOFTFLOAT_BUILTIN_CLZ 1
+#include "opts-GCC.h"
+
diff --git a/test/float/softfloat/build/Linux-ARM-VFPv2-GCC/Makefile b/test/float/softfloat/build/Linux-ARM-VFPv2-GCC/Makefile
new file mode 100644
index 000000000..a1e7c8303
--- /dev/null
+++ b/test/float/softfloat/build/Linux-ARM-VFPv2-GCC/Makefile
@@ -0,0 +1,323 @@
+
+#=============================================================================
+#
+# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic
+# Package, Release 3e, by John R. Hauser.
+#
+# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+# University of California. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice,
+# this list of conditions, and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions, and the following disclaimer in the
+# documentation and/or other materials provided with the distribution.
+#
+# 3. Neither the name of the University nor the names of its contributors
+# may be used to endorse or promote products derived from this software
+# without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+#=============================================================================
+
+SOURCE_DIR ?= ../../source
+SPECIALIZE_TYPE ?= ARM-VFPv2
+
+SOFTFLOAT_OPTS ?= -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5
+
+DELETE = rm -f
+C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
+COMPILE_C = \
+ gcc -c -Werror-implicit-function-declaration $(SOFTFLOAT_OPTS) \
+ $(C_INCLUDES) -O2 -o $@
+MAKELIB = ar crs $@
+
+OBJ = .o
+LIB = .a
+
+OTHER_HEADERS =
+
+.PHONY: all
+all: softfloat$(LIB)
+
+OBJS_PRIMITIVES = \
+ s_compare96M$(OBJ) \
+ s_compare128M$(OBJ) \
+ s_shortShiftLeft64To96M$(OBJ) \
+ s_shortShiftLeftM$(OBJ) \
+ s_shiftLeftM$(OBJ) \
+ s_shortShiftRightM$(OBJ) \
+ s_shortShiftRightJam64$(OBJ) \
+ s_shortShiftRightJamM$(OBJ) \
+ s_shiftRightJam32$(OBJ) \
+ s_shiftRightJam64$(OBJ) \
+ s_shiftRightJamM$(OBJ) \
+ s_shiftRightM$(OBJ) \
+ s_countLeadingZeros8$(OBJ) \
+ s_countLeadingZeros16$(OBJ) \
+ s_countLeadingZeros32$(OBJ) \
+ s_countLeadingZeros64$(OBJ) \
+ s_addM$(OBJ) \
+ s_addCarryM$(OBJ) \
+ s_addComplCarryM$(OBJ) \
+ s_negXM$(OBJ) \
+ s_sub1XM$(OBJ) \
+ s_subM$(OBJ) \
+ s_mul64To128M$(OBJ) \
+ s_mul128MTo256M$(OBJ) \
+ s_approxRecip_1Ks$(OBJ) \
+ s_approxRecip32_1$(OBJ) \
+ s_approxRecipSqrt_1Ks$(OBJ) \
+ s_approxRecipSqrt32_1$(OBJ) \
+ s_remStepMBy32$(OBJ) \
+
+OBJS_SPECIALIZE = \
+ softfloat_raiseFlags$(OBJ) \
+ s_f16UIToCommonNaN$(OBJ) \
+ s_commonNaNToF16UI$(OBJ) \
+ s_propagateNaNF16UI$(OBJ) \
+ s_f32UIToCommonNaN$(OBJ) \
+ s_commonNaNToF32UI$(OBJ) \
+ s_propagateNaNF32UI$(OBJ) \
+ s_f64UIToCommonNaN$(OBJ) \
+ s_commonNaNToF64UI$(OBJ) \
+ s_propagateNaNF64UI$(OBJ) \
+ extF80M_isSignalingNaN$(OBJ) \
+ s_extF80MToCommonNaN$(OBJ) \
+ s_commonNaNToExtF80M$(OBJ) \
+ s_propagateNaNExtF80M$(OBJ) \
+ f128M_isSignalingNaN$(OBJ) \
+ s_f128MToCommonNaN$(OBJ) \
+ s_commonNaNToF128M$(OBJ) \
+ s_propagateNaNF128M$(OBJ) \
+
+OBJS_OTHERS = \
+ s_roundToUI32$(OBJ) \
+ s_roundMToUI64$(OBJ) \
+ s_roundToI32$(OBJ) \
+ s_roundMToI64$(OBJ) \
+ s_normSubnormalF16Sig$(OBJ) \
+ s_roundPackToF16$(OBJ) \
+ s_normRoundPackToF16$(OBJ) \
+ s_addMagsF16$(OBJ) \
+ s_subMagsF16$(OBJ) \
+ s_mulAddF16$(OBJ) \
+ s_normSubnormalF32Sig$(OBJ) \
+ s_roundPackToF32$(OBJ) \
+ s_normRoundPackToF32$(OBJ) \
+ s_addMagsF32$(OBJ) \
+ s_subMagsF32$(OBJ) \
+ s_mulAddF32$(OBJ) \
+ s_normSubnormalF64Sig$(OBJ) \
+ s_roundPackToF64$(OBJ) \
+ s_normRoundPackToF64$(OBJ) \
+ s_addMagsF64$(OBJ) \
+ s_subMagsF64$(OBJ) \
+ s_mulAddF64$(OBJ) \
+ s_tryPropagateNaNExtF80M$(OBJ) \
+ s_invalidExtF80M$(OBJ) \
+ s_normExtF80SigM$(OBJ) \
+ s_roundPackMToExtF80M$(OBJ) \
+ s_normRoundPackMToExtF80M$(OBJ) \
+ s_addExtF80M$(OBJ) \
+ s_compareNonnormExtF80M$(OBJ) \
+ s_isNaNF128M$(OBJ) \
+ s_tryPropagateNaNF128M$(OBJ) \
+ s_invalidF128M$(OBJ) \
+ s_shiftNormSigF128M$(OBJ) \
+ s_roundPackMToF128M$(OBJ) \
+ s_normRoundPackMToF128M$(OBJ) \
+ s_addF128M$(OBJ) \
+ s_mulAddF128M$(OBJ) \
+ softfloat_state$(OBJ) \
+ ui32_to_f16$(OBJ) \
+ ui32_to_f32$(OBJ) \
+ ui32_to_f64$(OBJ) \
+ ui32_to_extF80M$(OBJ) \
+ ui32_to_f128M$(OBJ) \
+ ui64_to_f16$(OBJ) \
+ ui64_to_f32$(OBJ) \
+ ui64_to_f64$(OBJ) \
+ ui64_to_extF80M$(OBJ) \
+ ui64_to_f128M$(OBJ) \
+ i32_to_f16$(OBJ) \
+ i32_to_f32$(OBJ) \
+ i32_to_f64$(OBJ) \
+ i32_to_extF80M$(OBJ) \
+ i32_to_f128M$(OBJ) \
+ i64_to_f16$(OBJ) \
+ i64_to_f32$(OBJ) \
+ i64_to_f64$(OBJ) \
+ i64_to_extF80M$(OBJ) \
+ i64_to_f128M$(OBJ) \
+ f16_to_ui32$(OBJ) \
+ f16_to_ui64$(OBJ) \
+ f16_to_i32$(OBJ) \
+ f16_to_i64$(OBJ) \
+ f16_to_ui32_r_minMag$(OBJ) \
+ f16_to_ui64_r_minMag$(OBJ) \
+ f16_to_i32_r_minMag$(OBJ) \
+ f16_to_i64_r_minMag$(OBJ) \
+ f16_to_f32$(OBJ) \
+ f16_to_f64$(OBJ) \
+ f16_to_extF80M$(OBJ) \
+ f16_to_f128M$(OBJ) \
+ f16_roundToInt$(OBJ) \
+ f16_add$(OBJ) \
+ f16_sub$(OBJ) \
+ f16_mul$(OBJ) \
+ f16_mulAdd$(OBJ) \
+ f16_div$(OBJ) \
+ f16_rem$(OBJ) \
+ f16_sqrt$(OBJ) \
+ f16_eq$(OBJ) \
+ f16_le$(OBJ) \
+ f16_lt$(OBJ) \
+ f16_eq_signaling$(OBJ) \
+ f16_le_quiet$(OBJ) \
+ f16_lt_quiet$(OBJ) \
+ f16_isSignalingNaN$(OBJ) \
+ f32_to_ui32$(OBJ) \
+ f32_to_ui64$(OBJ) \
+ f32_to_i32$(OBJ) \
+ f32_to_i64$(OBJ) \
+ f32_to_ui32_r_minMag$(OBJ) \
+ f32_to_ui64_r_minMag$(OBJ) \
+ f32_to_i32_r_minMag$(OBJ) \
+ f32_to_i64_r_minMag$(OBJ) \
+ f32_to_f16$(OBJ) \
+ f32_to_f64$(OBJ) \
+ f32_to_extF80M$(OBJ) \
+ f32_to_f128M$(OBJ) \
+ f32_roundToInt$(OBJ) \
+ f32_add$(OBJ) \
+ f32_sub$(OBJ) \
+ f32_mul$(OBJ) \
+ f32_mulAdd$(OBJ) \
+ f32_div$(OBJ) \
+ f32_rem$(OBJ) \
+ f32_sqrt$(OBJ) \
+ f32_eq$(OBJ) \
+ f32_le$(OBJ) \
+ f32_lt$(OBJ) \
+ f32_eq_signaling$(OBJ) \
+ f32_le_quiet$(OBJ) \
+ f32_lt_quiet$(OBJ) \
+ f32_isSignalingNaN$(OBJ) \
+ f64_to_ui32$(OBJ) \
+ f64_to_ui64$(OBJ) \
+ f64_to_i32$(OBJ) \
+ f64_to_i64$(OBJ) \
+ f64_to_ui32_r_minMag$(OBJ) \
+ f64_to_ui64_r_minMag$(OBJ) \
+ f64_to_i32_r_minMag$(OBJ) \
+ f64_to_i64_r_minMag$(OBJ) \
+ f64_to_f16$(OBJ) \
+ f64_to_f32$(OBJ) \
+ f64_to_extF80M$(OBJ) \
+ f64_to_f128M$(OBJ) \
+ f64_roundToInt$(OBJ) \
+ f64_add$(OBJ) \
+ f64_sub$(OBJ) \
+ f64_mul$(OBJ) \
+ f64_mulAdd$(OBJ) \
+ f64_div$(OBJ) \
+ f64_rem$(OBJ) \
+ f64_sqrt$(OBJ) \
+ f64_eq$(OBJ) \
+ f64_le$(OBJ) \
+ f64_lt$(OBJ) \
+ f64_eq_signaling$(OBJ) \
+ f64_le_quiet$(OBJ) \
+ f64_lt_quiet$(OBJ) \
+ f64_isSignalingNaN$(OBJ) \
+ extF80M_to_ui32$(OBJ) \
+ extF80M_to_ui64$(OBJ) \
+ extF80M_to_i32$(OBJ) \
+ extF80M_to_i64$(OBJ) \
+ extF80M_to_ui32_r_minMag$(OBJ) \
+ extF80M_to_ui64_r_minMag$(OBJ) \
+ extF80M_to_i32_r_minMag$(OBJ) \
+ extF80M_to_i64_r_minMag$(OBJ) \
+ extF80M_to_f16$(OBJ) \
+ extF80M_to_f32$(OBJ) \
+ extF80M_to_f64$(OBJ) \
+ extF80M_to_f128M$(OBJ) \
+ extF80M_roundToInt$(OBJ) \
+ extF80M_add$(OBJ) \
+ extF80M_sub$(OBJ) \
+ extF80M_mul$(OBJ) \
+ extF80M_div$(OBJ) \
+ extF80M_rem$(OBJ) \
+ extF80M_sqrt$(OBJ) \
+ extF80M_eq$(OBJ) \
+ extF80M_le$(OBJ) \
+ extF80M_lt$(OBJ) \
+ extF80M_eq_signaling$(OBJ) \
+ extF80M_le_quiet$(OBJ) \
+ extF80M_lt_quiet$(OBJ) \
+ f128M_to_ui32$(OBJ) \
+ f128M_to_ui64$(OBJ) \
+ f128M_to_i32$(OBJ) \
+ f128M_to_i64$(OBJ) \
+ f128M_to_ui32_r_minMag$(OBJ) \
+ f128M_to_ui64_r_minMag$(OBJ) \
+ f128M_to_i32_r_minMag$(OBJ) \
+ f128M_to_i64_r_minMag$(OBJ) \
+ f128M_to_f16$(OBJ) \
+ f128M_to_f32$(OBJ) \
+ f128M_to_f64$(OBJ) \
+ f128M_to_extF80M$(OBJ) \
+ f128M_roundToInt$(OBJ) \
+ f128M_add$(OBJ) \
+ f128M_sub$(OBJ) \
+ f128M_mul$(OBJ) \
+ f128M_mulAdd$(OBJ) \
+ f128M_div$(OBJ) \
+ f128M_rem$(OBJ) \
+ f128M_sqrt$(OBJ) \
+ f128M_eq$(OBJ) \
+ f128M_le$(OBJ) \
+ f128M_lt$(OBJ) \
+ f128M_eq_signaling$(OBJ) \
+ f128M_le_quiet$(OBJ) \
+ f128M_lt_quiet$(OBJ) \
+
+OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
+
+$(OBJS_ALL): \
+ $(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
+ $(SOURCE_DIR)/include/primitives.h
+$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
+ $(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
+ $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
+ $(SOURCE_DIR)/include/softfloat.h
+
+$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
+ $(COMPILE_C) $(SOURCE_DIR)/$*.c
+
+$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
+ $(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
+
+softfloat$(LIB): $(OBJS_ALL)
+ $(DELETE) $@
+ $(MAKELIB) $^
+
+.PHONY: clean
+clean:
+ $(DELETE) $(OBJS_ALL) softfloat$(LIB)
+
diff --git a/test/float/softfloat/build/Linux-ARM-VFPv2-GCC/platform.h b/test/float/softfloat/build/Linux-ARM-VFPv2-GCC/platform.h
new file mode 100644
index 000000000..d514dbc40
--- /dev/null
+++ b/test/float/softfloat/build/Linux-ARM-VFPv2-GCC/platform.h
@@ -0,0 +1,53 @@
+
+/*============================================================================
+
+This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#define LITTLEENDIAN 1
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#ifdef __GNUC_STDC_INLINE__
+#define INLINE inline
+#else
+#define INLINE extern inline
+#endif
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#define SOFTFLOAT_BUILTIN_CLZ 1
+#include "opts-GCC.h"
+
diff --git a/test/float/softfloat/build/Linux-x86_64-GCC/Makefile b/test/float/softfloat/build/Linux-x86_64-GCC/Makefile
new file mode 100644
index 000000000..2ee5dad84
--- /dev/null
+++ b/test/float/softfloat/build/Linux-x86_64-GCC/Makefile
@@ -0,0 +1,390 @@
+
+#=============================================================================
+#
+# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic
+# Package, Release 3e, by John R. Hauser.
+#
+# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+# University of California. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice,
+# this list of conditions, and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions, and the following disclaimer in the
+# documentation and/or other materials provided with the distribution.
+#
+# 3. Neither the name of the University nor the names of its contributors
+# may be used to endorse or promote products derived from this software
+# without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+#=============================================================================
+
+SOURCE_DIR ?= ../../source
+SPECIALIZE_TYPE ?= 8086-SSE
+
+SOFTFLOAT_OPTS ?= \
+ -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
+ -DSOFTFLOAT_FAST_DIV64TO32
+
+DELETE = rm -f
+C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
+COMPILE_C = \
+ gcc -c -Werror-implicit-function-declaration -DSOFTFLOAT_FAST_INT64 \
+ $(SOFTFLOAT_OPTS) $(C_INCLUDES) -O2 -o $@
+MAKELIB = ar crs $@
+
+OBJ = .o
+LIB = .a
+
+OTHER_HEADERS = $(SOURCE_DIR)/include/opts-GCC.h
+
+.PHONY: all
+all: softfloat$(LIB)
+
+OBJS_PRIMITIVES = \
+ s_eq128$(OBJ) \
+ s_le128$(OBJ) \
+ s_lt128$(OBJ) \
+ s_shortShiftLeft128$(OBJ) \
+ s_shortShiftRight128$(OBJ) \
+ s_shortShiftRightJam64$(OBJ) \
+ s_shortShiftRightJam64Extra$(OBJ) \
+ s_shortShiftRightJam128$(OBJ) \
+ s_shortShiftRightJam128Extra$(OBJ) \
+ s_shiftRightJam32$(OBJ) \
+ s_shiftRightJam64$(OBJ) \
+ s_shiftRightJam64Extra$(OBJ) \
+ s_shiftRightJam128$(OBJ) \
+ s_shiftRightJam128Extra$(OBJ) \
+ s_shiftRightJam256M$(OBJ) \
+ s_countLeadingZeros8$(OBJ) \
+ s_countLeadingZeros16$(OBJ) \
+ s_countLeadingZeros32$(OBJ) \
+ s_countLeadingZeros64$(OBJ) \
+ s_add128$(OBJ) \
+ s_add256M$(OBJ) \
+ s_sub128$(OBJ) \
+ s_sub256M$(OBJ) \
+ s_mul64ByShifted32To128$(OBJ) \
+ s_mul64To128$(OBJ) \
+ s_mul128By32$(OBJ) \
+ s_mul128To256M$(OBJ) \
+ s_approxRecip_1Ks$(OBJ) \
+ s_approxRecip32_1$(OBJ) \
+ s_approxRecipSqrt_1Ks$(OBJ) \
+ s_approxRecipSqrt32_1$(OBJ) \
+
+OBJS_SPECIALIZE = \
+ softfloat_raiseFlags$(OBJ) \
+ s_f16UIToCommonNaN$(OBJ) \
+ s_commonNaNToF16UI$(OBJ) \
+ s_propagateNaNF16UI$(OBJ) \
+ s_f32UIToCommonNaN$(OBJ) \
+ s_commonNaNToF32UI$(OBJ) \
+ s_propagateNaNF32UI$(OBJ) \
+ s_f64UIToCommonNaN$(OBJ) \
+ s_commonNaNToF64UI$(OBJ) \
+ s_propagateNaNF64UI$(OBJ) \
+ extF80M_isSignalingNaN$(OBJ) \
+ s_extF80UIToCommonNaN$(OBJ) \
+ s_commonNaNToExtF80UI$(OBJ) \
+ s_propagateNaNExtF80UI$(OBJ) \
+ f128M_isSignalingNaN$(OBJ) \
+ s_f128UIToCommonNaN$(OBJ) \
+ s_commonNaNToF128UI$(OBJ) \
+ s_propagateNaNF128UI$(OBJ) \
+
+OBJS_OTHERS = \
+ s_roundToUI32$(OBJ) \
+ s_roundToUI64$(OBJ) \
+ s_roundToI32$(OBJ) \
+ s_roundToI64$(OBJ) \
+ s_normSubnormalF16Sig$(OBJ) \
+ s_roundPackToF16$(OBJ) \
+ s_normRoundPackToF16$(OBJ) \
+ s_addMagsF16$(OBJ) \
+ s_subMagsF16$(OBJ) \
+ s_mulAddF16$(OBJ) \
+ s_normSubnormalF32Sig$(OBJ) \
+ s_roundPackToF32$(OBJ) \
+ s_normRoundPackToF32$(OBJ) \
+ s_addMagsF32$(OBJ) \
+ s_subMagsF32$(OBJ) \
+ s_mulAddF32$(OBJ) \
+ s_normSubnormalF64Sig$(OBJ) \
+ s_roundPackToF64$(OBJ) \
+ s_normRoundPackToF64$(OBJ) \
+ s_addMagsF64$(OBJ) \
+ s_subMagsF64$(OBJ) \
+ s_mulAddF64$(OBJ) \
+ s_normSubnormalExtF80Sig$(OBJ) \
+ s_roundPackToExtF80$(OBJ) \
+ s_normRoundPackToExtF80$(OBJ) \
+ s_addMagsExtF80$(OBJ) \
+ s_subMagsExtF80$(OBJ) \
+ s_normSubnormalF128Sig$(OBJ) \
+ s_roundPackToF128$(OBJ) \
+ s_normRoundPackToF128$(OBJ) \
+ s_addMagsF128$(OBJ) \
+ s_subMagsF128$(OBJ) \
+ s_mulAddF128$(OBJ) \
+ softfloat_state$(OBJ) \
+ ui32_to_f16$(OBJ) \
+ ui32_to_f32$(OBJ) \
+ ui32_to_f64$(OBJ) \
+ ui32_to_extF80$(OBJ) \
+ ui32_to_extF80M$(OBJ) \
+ ui32_to_f128$(OBJ) \
+ ui32_to_f128M$(OBJ) \
+ ui64_to_f16$(OBJ) \
+ ui64_to_f32$(OBJ) \
+ ui64_to_f64$(OBJ) \
+ ui64_to_extF80$(OBJ) \
+ ui64_to_extF80M$(OBJ) \
+ ui64_to_f128$(OBJ) \
+ ui64_to_f128M$(OBJ) \
+ i32_to_f16$(OBJ) \
+ i32_to_f32$(OBJ) \
+ i32_to_f64$(OBJ) \
+ i32_to_extF80$(OBJ) \
+ i32_to_extF80M$(OBJ) \
+ i32_to_f128$(OBJ) \
+ i32_to_f128M$(OBJ) \
+ i64_to_f16$(OBJ) \
+ i64_to_f32$(OBJ) \
+ i64_to_f64$(OBJ) \
+ i64_to_extF80$(OBJ) \
+ i64_to_extF80M$(OBJ) \
+ i64_to_f128$(OBJ) \
+ i64_to_f128M$(OBJ) \
+ f16_to_ui32$(OBJ) \
+ f16_to_ui64$(OBJ) \
+ f16_to_i32$(OBJ) \
+ f16_to_i64$(OBJ) \
+ f16_to_ui32_r_minMag$(OBJ) \
+ f16_to_ui64_r_minMag$(OBJ) \
+ f16_to_i32_r_minMag$(OBJ) \
+ f16_to_i64_r_minMag$(OBJ) \
+ f16_to_f32$(OBJ) \
+ f16_to_f64$(OBJ) \
+ f16_to_extF80$(OBJ) \
+ f16_to_extF80M$(OBJ) \
+ f16_to_f128$(OBJ) \
+ f16_to_f128M$(OBJ) \
+ f16_roundToInt$(OBJ) \
+ f16_add$(OBJ) \
+ f16_sub$(OBJ) \
+ f16_mul$(OBJ) \
+ f16_mulAdd$(OBJ) \
+ f16_div$(OBJ) \
+ f16_rem$(OBJ) \
+ f16_sqrt$(OBJ) \
+ f16_eq$(OBJ) \
+ f16_le$(OBJ) \
+ f16_lt$(OBJ) \
+ f16_eq_signaling$(OBJ) \
+ f16_le_quiet$(OBJ) \
+ f16_lt_quiet$(OBJ) \
+ f16_isSignalingNaN$(OBJ) \
+ f32_to_ui32$(OBJ) \
+ f32_to_ui64$(OBJ) \
+ f32_to_i32$(OBJ) \
+ f32_to_i64$(OBJ) \
+ f32_to_ui32_r_minMag$(OBJ) \
+ f32_to_ui64_r_minMag$(OBJ) \
+ f32_to_i32_r_minMag$(OBJ) \
+ f32_to_i64_r_minMag$(OBJ) \
+ f32_to_f16$(OBJ) \
+ f32_to_f64$(OBJ) \
+ f32_to_extF80$(OBJ) \
+ f32_to_extF80M$(OBJ) \
+ f32_to_f128$(OBJ) \
+ f32_to_f128M$(OBJ) \
+ f32_roundToInt$(OBJ) \
+ f32_add$(OBJ) \
+ f32_sub$(OBJ) \
+ f32_mul$(OBJ) \
+ f32_mulAdd$(OBJ) \
+ f32_div$(OBJ) \
+ f32_rem$(OBJ) \
+ f32_sqrt$(OBJ) \
+ f32_eq$(OBJ) \
+ f32_le$(OBJ) \
+ f32_lt$(OBJ) \
+ f32_eq_signaling$(OBJ) \
+ f32_le_quiet$(OBJ) \
+ f32_lt_quiet$(OBJ) \
+ f32_isSignalingNaN$(OBJ) \
+ f64_to_ui32$(OBJ) \
+ f64_to_ui64$(OBJ) \
+ f64_to_i32$(OBJ) \
+ f64_to_i64$(OBJ) \
+ f64_to_ui32_r_minMag$(OBJ) \
+ f64_to_ui64_r_minMag$(OBJ) \
+ f64_to_i32_r_minMag$(OBJ) \
+ f64_to_i64_r_minMag$(OBJ) \
+ f64_to_f16$(OBJ) \
+ f64_to_f32$(OBJ) \
+ f64_to_extF80$(OBJ) \
+ f64_to_extF80M$(OBJ) \
+ f64_to_f128$(OBJ) \
+ f64_to_f128M$(OBJ) \
+ f64_roundToInt$(OBJ) \
+ f64_add$(OBJ) \
+ f64_sub$(OBJ) \
+ f64_mul$(OBJ) \
+ f64_mulAdd$(OBJ) \
+ f64_div$(OBJ) \
+ f64_rem$(OBJ) \
+ f64_sqrt$(OBJ) \
+ f64_eq$(OBJ) \
+ f64_le$(OBJ) \
+ f64_lt$(OBJ) \
+ f64_eq_signaling$(OBJ) \
+ f64_le_quiet$(OBJ) \
+ f64_lt_quiet$(OBJ) \
+ f64_isSignalingNaN$(OBJ) \
+ extF80_to_ui32$(OBJ) \
+ extF80_to_ui64$(OBJ) \
+ extF80_to_i32$(OBJ) \
+ extF80_to_i64$(OBJ) \
+ extF80_to_ui32_r_minMag$(OBJ) \
+ extF80_to_ui64_r_minMag$(OBJ) \
+ extF80_to_i32_r_minMag$(OBJ) \
+ extF80_to_i64_r_minMag$(OBJ) \
+ extF80_to_f16$(OBJ) \
+ extF80_to_f32$(OBJ) \
+ extF80_to_f64$(OBJ) \
+ extF80_to_f128$(OBJ) \
+ extF80_roundToInt$(OBJ) \
+ extF80_add$(OBJ) \
+ extF80_sub$(OBJ) \
+ extF80_mul$(OBJ) \
+ extF80_div$(OBJ) \
+ extF80_rem$(OBJ) \
+ extF80_sqrt$(OBJ) \
+ extF80_eq$(OBJ) \
+ extF80_le$(OBJ) \
+ extF80_lt$(OBJ) \
+ extF80_eq_signaling$(OBJ) \
+ extF80_le_quiet$(OBJ) \
+ extF80_lt_quiet$(OBJ) \
+ extF80_isSignalingNaN$(OBJ) \
+ extF80M_to_ui32$(OBJ) \
+ extF80M_to_ui64$(OBJ) \
+ extF80M_to_i32$(OBJ) \
+ extF80M_to_i64$(OBJ) \
+ extF80M_to_ui32_r_minMag$(OBJ) \
+ extF80M_to_ui64_r_minMag$(OBJ) \
+ extF80M_to_i32_r_minMag$(OBJ) \
+ extF80M_to_i64_r_minMag$(OBJ) \
+ extF80M_to_f16$(OBJ) \
+ extF80M_to_f32$(OBJ) \
+ extF80M_to_f64$(OBJ) \
+ extF80M_to_f128M$(OBJ) \
+ extF80M_roundToInt$(OBJ) \
+ extF80M_add$(OBJ) \
+ extF80M_sub$(OBJ) \
+ extF80M_mul$(OBJ) \
+ extF80M_div$(OBJ) \
+ extF80M_rem$(OBJ) \
+ extF80M_sqrt$(OBJ) \
+ extF80M_eq$(OBJ) \
+ extF80M_le$(OBJ) \
+ extF80M_lt$(OBJ) \
+ extF80M_eq_signaling$(OBJ) \
+ extF80M_le_quiet$(OBJ) \
+ extF80M_lt_quiet$(OBJ) \
+ f128_to_ui32$(OBJ) \
+ f128_to_ui64$(OBJ) \
+ f128_to_i32$(OBJ) \
+ f128_to_i64$(OBJ) \
+ f128_to_ui32_r_minMag$(OBJ) \
+ f128_to_ui64_r_minMag$(OBJ) \
+ f128_to_i32_r_minMag$(OBJ) \
+ f128_to_i64_r_minMag$(OBJ) \
+ f128_to_f16$(OBJ) \
+ f128_to_f32$(OBJ) \
+ f128_to_extF80$(OBJ) \
+ f128_to_f64$(OBJ) \
+ f128_roundToInt$(OBJ) \
+ f128_add$(OBJ) \
+ f128_sub$(OBJ) \
+ f128_mul$(OBJ) \
+ f128_mulAdd$(OBJ) \
+ f128_div$(OBJ) \
+ f128_rem$(OBJ) \
+ f128_sqrt$(OBJ) \
+ f128_eq$(OBJ) \
+ f128_le$(OBJ) \
+ f128_lt$(OBJ) \
+ f128_eq_signaling$(OBJ) \
+ f128_le_quiet$(OBJ) \
+ f128_lt_quiet$(OBJ) \
+ f128_isSignalingNaN$(OBJ) \
+ f128M_to_ui32$(OBJ) \
+ f128M_to_ui64$(OBJ) \
+ f128M_to_i32$(OBJ) \
+ f128M_to_i64$(OBJ) \
+ f128M_to_ui32_r_minMag$(OBJ) \
+ f128M_to_ui64_r_minMag$(OBJ) \
+ f128M_to_i32_r_minMag$(OBJ) \
+ f128M_to_i64_r_minMag$(OBJ) \
+ f128M_to_f16$(OBJ) \
+ f128M_to_f32$(OBJ) \
+ f128M_to_extF80M$(OBJ) \
+ f128M_to_f64$(OBJ) \
+ f128M_roundToInt$(OBJ) \
+ f128M_add$(OBJ) \
+ f128M_sub$(OBJ) \
+ f128M_mul$(OBJ) \
+ f128M_mulAdd$(OBJ) \
+ f128M_div$(OBJ) \
+ f128M_rem$(OBJ) \
+ f128M_sqrt$(OBJ) \
+ f128M_eq$(OBJ) \
+ f128M_le$(OBJ) \
+ f128M_lt$(OBJ) \
+ f128M_eq_signaling$(OBJ) \
+ f128M_le_quiet$(OBJ) \
+ f128M_lt_quiet$(OBJ) \
+
+OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
+
+$(OBJS_ALL): \
+ $(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
+ $(SOURCE_DIR)/include/primitives.h
+$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
+ $(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
+ $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
+ $(SOURCE_DIR)/include/softfloat.h
+
+$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
+ $(COMPILE_C) $(SOURCE_DIR)/$*.c
+
+$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
+ $(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
+
+softfloat$(LIB): $(OBJS_ALL)
+ $(DELETE) $@
+ $(MAKELIB) $^
+
+.PHONY: clean
+clean:
+ $(DELETE) $(OBJS_ALL) softfloat$(LIB)
+
diff --git a/test/float/softfloat/build/Linux-x86_64-GCC/platform.h b/test/float/softfloat/build/Linux-x86_64-GCC/platform.h
new file mode 100644
index 000000000..c5e06f8e9
--- /dev/null
+++ b/test/float/softfloat/build/Linux-x86_64-GCC/platform.h
@@ -0,0 +1,54 @@
+
+/*============================================================================
+
+This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#define LITTLEENDIAN 1
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#ifdef __GNUC_STDC_INLINE__
+#define INLINE inline
+#else
+#define INLINE extern inline
+#endif
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#define SOFTFLOAT_BUILTIN_CLZ 1
+#define SOFTFLOAT_INTRINSIC_INT128 1
+#include "opts-GCC.h"
+
diff --git a/test/float/softfloat/build/Win32-MinGW/Makefile b/test/float/softfloat/build/Win32-MinGW/Makefile
new file mode 100644
index 000000000..faeb39728
--- /dev/null
+++ b/test/float/softfloat/build/Win32-MinGW/Makefile
@@ -0,0 +1,325 @@
+
+#=============================================================================
+#
+# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic
+# Package, Release 3e, by John R. Hauser.
+#
+# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+# University of California. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice,
+# this list of conditions, and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions, and the following disclaimer in the
+# documentation and/or other materials provided with the distribution.
+#
+# 3. Neither the name of the University nor the names of its contributors
+# may be used to endorse or promote products derived from this software
+# without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+#=============================================================================
+
+SOURCE_DIR ?= ../../source
+SPECIALIZE_TYPE ?= 8086
+
+SOFTFLOAT_OPTS ?= \
+ -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
+ -DSOFTFLOAT_FAST_DIV64TO32
+
+DELETE = rm -f
+C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
+COMPILE_C = \
+ gcc -c -Werror-implicit-function-declaration $(SOFTFLOAT_OPTS) \
+ $(C_INCLUDES) -O2 -o $@
+MAKELIB = ar crs $@
+
+OBJ = .o
+LIB = .a
+
+OTHER_HEADERS =
+
+.PHONY: all
+all: softfloat$(LIB)
+
+OBJS_PRIMITIVES = \
+ s_compare96M$(OBJ) \
+ s_compare128M$(OBJ) \
+ s_shortShiftLeft64To96M$(OBJ) \
+ s_shortShiftLeftM$(OBJ) \
+ s_shiftLeftM$(OBJ) \
+ s_shortShiftRightM$(OBJ) \
+ s_shortShiftRightJam64$(OBJ) \
+ s_shortShiftRightJamM$(OBJ) \
+ s_shiftRightJam32$(OBJ) \
+ s_shiftRightJam64$(OBJ) \
+ s_shiftRightJamM$(OBJ) \
+ s_shiftRightM$(OBJ) \
+ s_countLeadingZeros8$(OBJ) \
+ s_countLeadingZeros16$(OBJ) \
+ s_countLeadingZeros32$(OBJ) \
+ s_countLeadingZeros64$(OBJ) \
+ s_addM$(OBJ) \
+ s_addCarryM$(OBJ) \
+ s_addComplCarryM$(OBJ) \
+ s_negXM$(OBJ) \
+ s_sub1XM$(OBJ) \
+ s_subM$(OBJ) \
+ s_mul64To128M$(OBJ) \
+ s_mul128MTo256M$(OBJ) \
+ s_approxRecip_1Ks$(OBJ) \
+ s_approxRecip32_1$(OBJ) \
+ s_approxRecipSqrt_1Ks$(OBJ) \
+ s_approxRecipSqrt32_1$(OBJ) \
+ s_remStepMBy32$(OBJ) \
+
+OBJS_SPECIALIZE = \
+ softfloat_raiseFlags$(OBJ) \
+ s_f16UIToCommonNaN$(OBJ) \
+ s_commonNaNToF16UI$(OBJ) \
+ s_propagateNaNF16UI$(OBJ) \
+ s_f32UIToCommonNaN$(OBJ) \
+ s_commonNaNToF32UI$(OBJ) \
+ s_propagateNaNF32UI$(OBJ) \
+ s_f64UIToCommonNaN$(OBJ) \
+ s_commonNaNToF64UI$(OBJ) \
+ s_propagateNaNF64UI$(OBJ) \
+ extF80M_isSignalingNaN$(OBJ) \
+ s_extF80MToCommonNaN$(OBJ) \
+ s_commonNaNToExtF80M$(OBJ) \
+ s_propagateNaNExtF80M$(OBJ) \
+ f128M_isSignalingNaN$(OBJ) \
+ s_f128MToCommonNaN$(OBJ) \
+ s_commonNaNToF128M$(OBJ) \
+ s_propagateNaNF128M$(OBJ) \
+
+OBJS_OTHERS = \
+ s_roundToUI32$(OBJ) \
+ s_roundMToUI64$(OBJ) \
+ s_roundToI32$(OBJ) \
+ s_roundMToI64$(OBJ) \
+ s_normSubnormalF16Sig$(OBJ) \
+ s_roundPackToF16$(OBJ) \
+ s_normRoundPackToF16$(OBJ) \
+ s_addMagsF16$(OBJ) \
+ s_subMagsF16$(OBJ) \
+ s_mulAddF16$(OBJ) \
+ s_normSubnormalF32Sig$(OBJ) \
+ s_roundPackToF32$(OBJ) \
+ s_normRoundPackToF32$(OBJ) \
+ s_addMagsF32$(OBJ) \
+ s_subMagsF32$(OBJ) \
+ s_mulAddF32$(OBJ) \
+ s_normSubnormalF64Sig$(OBJ) \
+ s_roundPackToF64$(OBJ) \
+ s_normRoundPackToF64$(OBJ) \
+ s_addMagsF64$(OBJ) \
+ s_subMagsF64$(OBJ) \
+ s_mulAddF64$(OBJ) \
+ s_tryPropagateNaNExtF80M$(OBJ) \
+ s_invalidExtF80M$(OBJ) \
+ s_normExtF80SigM$(OBJ) \
+ s_roundPackMToExtF80M$(OBJ) \
+ s_normRoundPackMToExtF80M$(OBJ) \
+ s_addExtF80M$(OBJ) \
+ s_compareNonnormExtF80M$(OBJ) \
+ s_isNaNF128M$(OBJ) \
+ s_tryPropagateNaNF128M$(OBJ) \
+ s_invalidF128M$(OBJ) \
+ s_shiftNormSigF128M$(OBJ) \
+ s_roundPackMToF128M$(OBJ) \
+ s_normRoundPackMToF128M$(OBJ) \
+ s_addF128M$(OBJ) \
+ s_mulAddF128M$(OBJ) \
+ softfloat_state$(OBJ) \
+ ui32_to_f16$(OBJ) \
+ ui32_to_f32$(OBJ) \
+ ui32_to_f64$(OBJ) \
+ ui32_to_extF80M$(OBJ) \
+ ui32_to_f128M$(OBJ) \
+ ui64_to_f16$(OBJ) \
+ ui64_to_f32$(OBJ) \
+ ui64_to_f64$(OBJ) \
+ ui64_to_extF80M$(OBJ) \
+ ui64_to_f128M$(OBJ) \
+ i32_to_f16$(OBJ) \
+ i32_to_f32$(OBJ) \
+ i32_to_f64$(OBJ) \
+ i32_to_extF80M$(OBJ) \
+ i32_to_f128M$(OBJ) \
+ i64_to_f16$(OBJ) \
+ i64_to_f32$(OBJ) \
+ i64_to_f64$(OBJ) \
+ i64_to_extF80M$(OBJ) \
+ i64_to_f128M$(OBJ) \
+ f16_to_ui32$(OBJ) \
+ f16_to_ui64$(OBJ) \
+ f16_to_i32$(OBJ) \
+ f16_to_i64$(OBJ) \
+ f16_to_ui32_r_minMag$(OBJ) \
+ f16_to_ui64_r_minMag$(OBJ) \
+ f16_to_i32_r_minMag$(OBJ) \
+ f16_to_i64_r_minMag$(OBJ) \
+ f16_to_f32$(OBJ) \
+ f16_to_f64$(OBJ) \
+ f16_to_extF80M$(OBJ) \
+ f16_to_f128M$(OBJ) \
+ f16_roundToInt$(OBJ) \
+ f16_add$(OBJ) \
+ f16_sub$(OBJ) \
+ f16_mul$(OBJ) \
+ f16_mulAdd$(OBJ) \
+ f16_div$(OBJ) \
+ f16_rem$(OBJ) \
+ f16_sqrt$(OBJ) \
+ f16_eq$(OBJ) \
+ f16_le$(OBJ) \
+ f16_lt$(OBJ) \
+ f16_eq_signaling$(OBJ) \
+ f16_le_quiet$(OBJ) \
+ f16_lt_quiet$(OBJ) \
+ f16_isSignalingNaN$(OBJ) \
+ f32_to_ui32$(OBJ) \
+ f32_to_ui64$(OBJ) \
+ f32_to_i32$(OBJ) \
+ f32_to_i64$(OBJ) \
+ f32_to_ui32_r_minMag$(OBJ) \
+ f32_to_ui64_r_minMag$(OBJ) \
+ f32_to_i32_r_minMag$(OBJ) \
+ f32_to_i64_r_minMag$(OBJ) \
+ f32_to_f16$(OBJ) \
+ f32_to_f64$(OBJ) \
+ f32_to_extF80M$(OBJ) \
+ f32_to_f128M$(OBJ) \
+ f32_roundToInt$(OBJ) \
+ f32_add$(OBJ) \
+ f32_sub$(OBJ) \
+ f32_mul$(OBJ) \
+ f32_mulAdd$(OBJ) \
+ f32_div$(OBJ) \
+ f32_rem$(OBJ) \
+ f32_sqrt$(OBJ) \
+ f32_eq$(OBJ) \
+ f32_le$(OBJ) \
+ f32_lt$(OBJ) \
+ f32_eq_signaling$(OBJ) \
+ f32_le_quiet$(OBJ) \
+ f32_lt_quiet$(OBJ) \
+ f32_isSignalingNaN$(OBJ) \
+ f64_to_ui32$(OBJ) \
+ f64_to_ui64$(OBJ) \
+ f64_to_i32$(OBJ) \
+ f64_to_i64$(OBJ) \
+ f64_to_ui32_r_minMag$(OBJ) \
+ f64_to_ui64_r_minMag$(OBJ) \
+ f64_to_i32_r_minMag$(OBJ) \
+ f64_to_i64_r_minMag$(OBJ) \
+ f64_to_f16$(OBJ) \
+ f64_to_f32$(OBJ) \
+ f64_to_extF80M$(OBJ) \
+ f64_to_f128M$(OBJ) \
+ f64_roundToInt$(OBJ) \
+ f64_add$(OBJ) \
+ f64_sub$(OBJ) \
+ f64_mul$(OBJ) \
+ f64_mulAdd$(OBJ) \
+ f64_div$(OBJ) \
+ f64_rem$(OBJ) \
+ f64_sqrt$(OBJ) \
+ f64_eq$(OBJ) \
+ f64_le$(OBJ) \
+ f64_lt$(OBJ) \
+ f64_eq_signaling$(OBJ) \
+ f64_le_quiet$(OBJ) \
+ f64_lt_quiet$(OBJ) \
+ f64_isSignalingNaN$(OBJ) \
+ extF80M_to_ui32$(OBJ) \
+ extF80M_to_ui64$(OBJ) \
+ extF80M_to_i32$(OBJ) \
+ extF80M_to_i64$(OBJ) \
+ extF80M_to_ui32_r_minMag$(OBJ) \
+ extF80M_to_ui64_r_minMag$(OBJ) \
+ extF80M_to_i32_r_minMag$(OBJ) \
+ extF80M_to_i64_r_minMag$(OBJ) \
+ extF80M_to_f16$(OBJ) \
+ extF80M_to_f32$(OBJ) \
+ extF80M_to_f64$(OBJ) \
+ extF80M_to_f128M$(OBJ) \
+ extF80M_roundToInt$(OBJ) \
+ extF80M_add$(OBJ) \
+ extF80M_sub$(OBJ) \
+ extF80M_mul$(OBJ) \
+ extF80M_div$(OBJ) \
+ extF80M_rem$(OBJ) \
+ extF80M_sqrt$(OBJ) \
+ extF80M_eq$(OBJ) \
+ extF80M_le$(OBJ) \
+ extF80M_lt$(OBJ) \
+ extF80M_eq_signaling$(OBJ) \
+ extF80M_le_quiet$(OBJ) \
+ extF80M_lt_quiet$(OBJ) \
+ f128M_to_ui32$(OBJ) \
+ f128M_to_ui64$(OBJ) \
+ f128M_to_i32$(OBJ) \
+ f128M_to_i64$(OBJ) \
+ f128M_to_ui32_r_minMag$(OBJ) \
+ f128M_to_ui64_r_minMag$(OBJ) \
+ f128M_to_i32_r_minMag$(OBJ) \
+ f128M_to_i64_r_minMag$(OBJ) \
+ f128M_to_f16$(OBJ) \
+ f128M_to_f32$(OBJ) \
+ f128M_to_f64$(OBJ) \
+ f128M_to_extF80M$(OBJ) \
+ f128M_roundToInt$(OBJ) \
+ f128M_add$(OBJ) \
+ f128M_sub$(OBJ) \
+ f128M_mul$(OBJ) \
+ f128M_mulAdd$(OBJ) \
+ f128M_div$(OBJ) \
+ f128M_rem$(OBJ) \
+ f128M_sqrt$(OBJ) \
+ f128M_eq$(OBJ) \
+ f128M_le$(OBJ) \
+ f128M_lt$(OBJ) \
+ f128M_eq_signaling$(OBJ) \
+ f128M_le_quiet$(OBJ) \
+ f128M_lt_quiet$(OBJ) \
+
+OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
+
+$(OBJS_ALL): \
+ $(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
+ $(SOURCE_DIR)/include/primitives.h
+$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
+ $(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
+ $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
+ $(SOURCE_DIR)/include/softfloat.h
+
+$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
+ $(COMPILE_C) $(SOURCE_DIR)/$*.c
+
+$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
+ $(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
+
+softfloat$(LIB): $(OBJS_ALL)
+ $(DELETE) $@
+ $(MAKELIB) $^
+
+.PHONY: clean
+clean:
+ $(DELETE) $(OBJS_ALL) softfloat$(LIB)
+
diff --git a/test/float/softfloat/build/Win32-MinGW/platform.h b/test/float/softfloat/build/Win32-MinGW/platform.h
new file mode 100644
index 000000000..d514dbc40
--- /dev/null
+++ b/test/float/softfloat/build/Win32-MinGW/platform.h
@@ -0,0 +1,53 @@
+
+/*============================================================================
+
+This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#define LITTLEENDIAN 1
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#ifdef __GNUC_STDC_INLINE__
+#define INLINE inline
+#else
+#define INLINE extern inline
+#endif
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#define SOFTFLOAT_BUILTIN_CLZ 1
+#include "opts-GCC.h"
+
diff --git a/test/float/softfloat/build/Win32-SSE2-MinGW/Makefile b/test/float/softfloat/build/Win32-SSE2-MinGW/Makefile
new file mode 100644
index 000000000..ced977b69
--- /dev/null
+++ b/test/float/softfloat/build/Win32-SSE2-MinGW/Makefile
@@ -0,0 +1,325 @@
+
+#=============================================================================
+#
+# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic
+# Package, Release 3e, by John R. Hauser.
+#
+# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+# University of California. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice,
+# this list of conditions, and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions, and the following disclaimer in the
+# documentation and/or other materials provided with the distribution.
+#
+# 3. Neither the name of the University nor the names of its contributors
+# may be used to endorse or promote products derived from this software
+# without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+#=============================================================================
+
+SOURCE_DIR ?= ../../source
+SPECIALIZE_TYPE ?= 8086-SSE
+
+SOFTFLOAT_OPTS ?= \
+ -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
+ -DSOFTFLOAT_FAST_DIV64TO32
+
+DELETE = rm -f
+C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
+COMPILE_C = \
+ gcc -c -Werror-implicit-function-declaration $(SOFTFLOAT_OPTS) \
+ $(C_INCLUDES) -O2 -o $@
+MAKELIB = ar crs $@
+
+OBJ = .o
+LIB = .a
+
+OTHER_HEADERS =
+
+.PHONY: all
+all: softfloat$(LIB)
+
+OBJS_PRIMITIVES = \
+ s_compare96M$(OBJ) \
+ s_compare128M$(OBJ) \
+ s_shortShiftLeft64To96M$(OBJ) \
+ s_shortShiftLeftM$(OBJ) \
+ s_shiftLeftM$(OBJ) \
+ s_shortShiftRightM$(OBJ) \
+ s_shortShiftRightJam64$(OBJ) \
+ s_shortShiftRightJamM$(OBJ) \
+ s_shiftRightJam32$(OBJ) \
+ s_shiftRightJam64$(OBJ) \
+ s_shiftRightJamM$(OBJ) \
+ s_shiftRightM$(OBJ) \
+ s_countLeadingZeros8$(OBJ) \
+ s_countLeadingZeros16$(OBJ) \
+ s_countLeadingZeros32$(OBJ) \
+ s_countLeadingZeros64$(OBJ) \
+ s_addM$(OBJ) \
+ s_addCarryM$(OBJ) \
+ s_addComplCarryM$(OBJ) \
+ s_negXM$(OBJ) \
+ s_sub1XM$(OBJ) \
+ s_subM$(OBJ) \
+ s_mul64To128M$(OBJ) \
+ s_mul128MTo256M$(OBJ) \
+ s_approxRecip_1Ks$(OBJ) \
+ s_approxRecip32_1$(OBJ) \
+ s_approxRecipSqrt_1Ks$(OBJ) \
+ s_approxRecipSqrt32_1$(OBJ) \
+ s_remStepMBy32$(OBJ) \
+
+OBJS_SPECIALIZE = \
+ softfloat_raiseFlags$(OBJ) \
+ s_f16UIToCommonNaN$(OBJ) \
+ s_commonNaNToF16UI$(OBJ) \
+ s_propagateNaNF16UI$(OBJ) \
+ s_f32UIToCommonNaN$(OBJ) \
+ s_commonNaNToF32UI$(OBJ) \
+ s_propagateNaNF32UI$(OBJ) \
+ s_f64UIToCommonNaN$(OBJ) \
+ s_commonNaNToF64UI$(OBJ) \
+ s_propagateNaNF64UI$(OBJ) \
+ extF80M_isSignalingNaN$(OBJ) \
+ s_extF80MToCommonNaN$(OBJ) \
+ s_commonNaNToExtF80M$(OBJ) \
+ s_propagateNaNExtF80M$(OBJ) \
+ f128M_isSignalingNaN$(OBJ) \
+ s_f128MToCommonNaN$(OBJ) \
+ s_commonNaNToF128M$(OBJ) \
+ s_propagateNaNF128M$(OBJ) \
+
+OBJS_OTHERS = \
+ s_roundToUI32$(OBJ) \
+ s_roundMToUI64$(OBJ) \
+ s_roundToI32$(OBJ) \
+ s_roundMToI64$(OBJ) \
+ s_normSubnormalF16Sig$(OBJ) \
+ s_roundPackToF16$(OBJ) \
+ s_normRoundPackToF16$(OBJ) \
+ s_addMagsF16$(OBJ) \
+ s_subMagsF16$(OBJ) \
+ s_mulAddF16$(OBJ) \
+ s_normSubnormalF32Sig$(OBJ) \
+ s_roundPackToF32$(OBJ) \
+ s_normRoundPackToF32$(OBJ) \
+ s_addMagsF32$(OBJ) \
+ s_subMagsF32$(OBJ) \
+ s_mulAddF32$(OBJ) \
+ s_normSubnormalF64Sig$(OBJ) \
+ s_roundPackToF64$(OBJ) \
+ s_normRoundPackToF64$(OBJ) \
+ s_addMagsF64$(OBJ) \
+ s_subMagsF64$(OBJ) \
+ s_mulAddF64$(OBJ) \
+ s_tryPropagateNaNExtF80M$(OBJ) \
+ s_invalidExtF80M$(OBJ) \
+ s_normExtF80SigM$(OBJ) \
+ s_roundPackMToExtF80M$(OBJ) \
+ s_normRoundPackMToExtF80M$(OBJ) \
+ s_addExtF80M$(OBJ) \
+ s_compareNonnormExtF80M$(OBJ) \
+ s_isNaNF128M$(OBJ) \
+ s_tryPropagateNaNF128M$(OBJ) \
+ s_invalidF128M$(OBJ) \
+ s_shiftNormSigF128M$(OBJ) \
+ s_roundPackMToF128M$(OBJ) \
+ s_normRoundPackMToF128M$(OBJ) \
+ s_addF128M$(OBJ) \
+ s_mulAddF128M$(OBJ) \
+ softfloat_state$(OBJ) \
+ ui32_to_f16$(OBJ) \
+ ui32_to_f32$(OBJ) \
+ ui32_to_f64$(OBJ) \
+ ui32_to_extF80M$(OBJ) \
+ ui32_to_f128M$(OBJ) \
+ ui64_to_f16$(OBJ) \
+ ui64_to_f32$(OBJ) \
+ ui64_to_f64$(OBJ) \
+ ui64_to_extF80M$(OBJ) \
+ ui64_to_f128M$(OBJ) \
+ i32_to_f16$(OBJ) \
+ i32_to_f32$(OBJ) \
+ i32_to_f64$(OBJ) \
+ i32_to_extF80M$(OBJ) \
+ i32_to_f128M$(OBJ) \
+ i64_to_f16$(OBJ) \
+ i64_to_f32$(OBJ) \
+ i64_to_f64$(OBJ) \
+ i64_to_extF80M$(OBJ) \
+ i64_to_f128M$(OBJ) \
+ f16_to_ui32$(OBJ) \
+ f16_to_ui64$(OBJ) \
+ f16_to_i32$(OBJ) \
+ f16_to_i64$(OBJ) \
+ f16_to_ui32_r_minMag$(OBJ) \
+ f16_to_ui64_r_minMag$(OBJ) \
+ f16_to_i32_r_minMag$(OBJ) \
+ f16_to_i64_r_minMag$(OBJ) \
+ f16_to_f32$(OBJ) \
+ f16_to_f64$(OBJ) \
+ f16_to_extF80M$(OBJ) \
+ f16_to_f128M$(OBJ) \
+ f16_roundToInt$(OBJ) \
+ f16_add$(OBJ) \
+ f16_sub$(OBJ) \
+ f16_mul$(OBJ) \
+ f16_mulAdd$(OBJ) \
+ f16_div$(OBJ) \
+ f16_rem$(OBJ) \
+ f16_sqrt$(OBJ) \
+ f16_eq$(OBJ) \
+ f16_le$(OBJ) \
+ f16_lt$(OBJ) \
+ f16_eq_signaling$(OBJ) \
+ f16_le_quiet$(OBJ) \
+ f16_lt_quiet$(OBJ) \
+ f16_isSignalingNaN$(OBJ) \
+ f32_to_ui32$(OBJ) \
+ f32_to_ui64$(OBJ) \
+ f32_to_i32$(OBJ) \
+ f32_to_i64$(OBJ) \
+ f32_to_ui32_r_minMag$(OBJ) \
+ f32_to_ui64_r_minMag$(OBJ) \
+ f32_to_i32_r_minMag$(OBJ) \
+ f32_to_i64_r_minMag$(OBJ) \
+ f32_to_f16$(OBJ) \
+ f32_to_f64$(OBJ) \
+ f32_to_extF80M$(OBJ) \
+ f32_to_f128M$(OBJ) \
+ f32_roundToInt$(OBJ) \
+ f32_add$(OBJ) \
+ f32_sub$(OBJ) \
+ f32_mul$(OBJ) \
+ f32_mulAdd$(OBJ) \
+ f32_div$(OBJ) \
+ f32_rem$(OBJ) \
+ f32_sqrt$(OBJ) \
+ f32_eq$(OBJ) \
+ f32_le$(OBJ) \
+ f32_lt$(OBJ) \
+ f32_eq_signaling$(OBJ) \
+ f32_le_quiet$(OBJ) \
+ f32_lt_quiet$(OBJ) \
+ f32_isSignalingNaN$(OBJ) \
+ f64_to_ui32$(OBJ) \
+ f64_to_ui64$(OBJ) \
+ f64_to_i32$(OBJ) \
+ f64_to_i64$(OBJ) \
+ f64_to_ui32_r_minMag$(OBJ) \
+ f64_to_ui64_r_minMag$(OBJ) \
+ f64_to_i32_r_minMag$(OBJ) \
+ f64_to_i64_r_minMag$(OBJ) \
+ f64_to_f16$(OBJ) \
+ f64_to_f32$(OBJ) \
+ f64_to_extF80M$(OBJ) \
+ f64_to_f128M$(OBJ) \
+ f64_roundToInt$(OBJ) \
+ f64_add$(OBJ) \
+ f64_sub$(OBJ) \
+ f64_mul$(OBJ) \
+ f64_mulAdd$(OBJ) \
+ f64_div$(OBJ) \
+ f64_rem$(OBJ) \
+ f64_sqrt$(OBJ) \
+ f64_eq$(OBJ) \
+ f64_le$(OBJ) \
+ f64_lt$(OBJ) \
+ f64_eq_signaling$(OBJ) \
+ f64_le_quiet$(OBJ) \
+ f64_lt_quiet$(OBJ) \
+ f64_isSignalingNaN$(OBJ) \
+ extF80M_to_ui32$(OBJ) \
+ extF80M_to_ui64$(OBJ) \
+ extF80M_to_i32$(OBJ) \
+ extF80M_to_i64$(OBJ) \
+ extF80M_to_ui32_r_minMag$(OBJ) \
+ extF80M_to_ui64_r_minMag$(OBJ) \
+ extF80M_to_i32_r_minMag$(OBJ) \
+ extF80M_to_i64_r_minMag$(OBJ) \
+ extF80M_to_f16$(OBJ) \
+ extF80M_to_f32$(OBJ) \
+ extF80M_to_f64$(OBJ) \
+ extF80M_to_f128M$(OBJ) \
+ extF80M_roundToInt$(OBJ) \
+ extF80M_add$(OBJ) \
+ extF80M_sub$(OBJ) \
+ extF80M_mul$(OBJ) \
+ extF80M_div$(OBJ) \
+ extF80M_rem$(OBJ) \
+ extF80M_sqrt$(OBJ) \
+ extF80M_eq$(OBJ) \
+ extF80M_le$(OBJ) \
+ extF80M_lt$(OBJ) \
+ extF80M_eq_signaling$(OBJ) \
+ extF80M_le_quiet$(OBJ) \
+ extF80M_lt_quiet$(OBJ) \
+ f128M_to_ui32$(OBJ) \
+ f128M_to_ui64$(OBJ) \
+ f128M_to_i32$(OBJ) \
+ f128M_to_i64$(OBJ) \
+ f128M_to_ui32_r_minMag$(OBJ) \
+ f128M_to_ui64_r_minMag$(OBJ) \
+ f128M_to_i32_r_minMag$(OBJ) \
+ f128M_to_i64_r_minMag$(OBJ) \
+ f128M_to_f16$(OBJ) \
+ f128M_to_f32$(OBJ) \
+ f128M_to_f64$(OBJ) \
+ f128M_to_extF80M$(OBJ) \
+ f128M_roundToInt$(OBJ) \
+ f128M_add$(OBJ) \
+ f128M_sub$(OBJ) \
+ f128M_mul$(OBJ) \
+ f128M_mulAdd$(OBJ) \
+ f128M_div$(OBJ) \
+ f128M_rem$(OBJ) \
+ f128M_sqrt$(OBJ) \
+ f128M_eq$(OBJ) \
+ f128M_le$(OBJ) \
+ f128M_lt$(OBJ) \
+ f128M_eq_signaling$(OBJ) \
+ f128M_le_quiet$(OBJ) \
+ f128M_lt_quiet$(OBJ) \
+
+OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
+
+$(OBJS_ALL): \
+ $(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
+ $(SOURCE_DIR)/include/primitives.h
+$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
+ $(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
+ $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
+ $(SOURCE_DIR)/include/softfloat.h
+
+$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
+ $(COMPILE_C) $(SOURCE_DIR)/$*.c
+
+$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
+ $(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
+
+softfloat$(LIB): $(OBJS_ALL)
+ $(DELETE) $@
+ $(MAKELIB) $^
+
+.PHONY: clean
+clean:
+ $(DELETE) $(OBJS_ALL) softfloat$(LIB)
+
diff --git a/test/float/softfloat/build/Win32-SSE2-MinGW/platform.h b/test/float/softfloat/build/Win32-SSE2-MinGW/platform.h
new file mode 100644
index 000000000..d514dbc40
--- /dev/null
+++ b/test/float/softfloat/build/Win32-SSE2-MinGW/platform.h
@@ -0,0 +1,53 @@
+
+/*============================================================================
+
+This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#define LITTLEENDIAN 1
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#ifdef __GNUC_STDC_INLINE__
+#define INLINE inline
+#else
+#define INLINE extern inline
+#endif
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#define SOFTFLOAT_BUILTIN_CLZ 1
+#include "opts-GCC.h"
+
diff --git a/test/float/softfloat/build/Win64-MinGW-w64/Makefile b/test/float/softfloat/build/Win64-MinGW-w64/Makefile
new file mode 100644
index 000000000..cc5bc0c5b
--- /dev/null
+++ b/test/float/softfloat/build/Win64-MinGW-w64/Makefile
@@ -0,0 +1,390 @@
+
+#=============================================================================
+#
+# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic
+# Package, Release 3e, by John R. Hauser.
+#
+# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+# University of California. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice,
+# this list of conditions, and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions, and the following disclaimer in the
+# documentation and/or other materials provided with the distribution.
+#
+# 3. Neither the name of the University nor the names of its contributors
+# may be used to endorse or promote products derived from this software
+# without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+#=============================================================================
+
+SOURCE_DIR ?= ../../source
+SPECIALIZE_TYPE ?= 8086-SSE
+
+SOFTFLOAT_OPTS ?= \
+ -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
+ -DSOFTFLOAT_FAST_DIV64TO32
+
+DELETE = rm -f
+C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
+COMPILE_C = \
+ x86_64-w64-mingw32-gcc -c -Werror-implicit-function-declaration \
+ -DSOFTFLOAT_FAST_INT64 $(SOFTFLOAT_OPTS) $(C_INCLUDES) -O2 -o $@
+MAKELIB = x86_64-w64-mingw32-ar crs $@
+
+OBJ = .o
+LIB = .a
+
+OTHER_HEADERS = $(SOURCE_DIR)/include/opts-GCC.h
+
+.PHONY: all
+all: softfloat$(LIB)
+
+OBJS_PRIMITIVES = \
+ s_eq128$(OBJ) \
+ s_le128$(OBJ) \
+ s_lt128$(OBJ) \
+ s_shortShiftLeft128$(OBJ) \
+ s_shortShiftRight128$(OBJ) \
+ s_shortShiftRightJam64$(OBJ) \
+ s_shortShiftRightJam64Extra$(OBJ) \
+ s_shortShiftRightJam128$(OBJ) \
+ s_shortShiftRightJam128Extra$(OBJ) \
+ s_shiftRightJam32$(OBJ) \
+ s_shiftRightJam64$(OBJ) \
+ s_shiftRightJam64Extra$(OBJ) \
+ s_shiftRightJam128$(OBJ) \
+ s_shiftRightJam128Extra$(OBJ) \
+ s_shiftRightJam256M$(OBJ) \
+ s_countLeadingZeros8$(OBJ) \
+ s_countLeadingZeros16$(OBJ) \
+ s_countLeadingZeros32$(OBJ) \
+ s_countLeadingZeros64$(OBJ) \
+ s_add128$(OBJ) \
+ s_add256M$(OBJ) \
+ s_sub128$(OBJ) \
+ s_sub256M$(OBJ) \
+ s_mul64ByShifted32To128$(OBJ) \
+ s_mul64To128$(OBJ) \
+ s_mul128By32$(OBJ) \
+ s_mul128To256M$(OBJ) \
+ s_approxRecip_1Ks$(OBJ) \
+ s_approxRecip32_1$(OBJ) \
+ s_approxRecipSqrt_1Ks$(OBJ) \
+ s_approxRecipSqrt32_1$(OBJ) \
+
+OBJS_SPECIALIZE = \
+ softfloat_raiseFlags$(OBJ) \
+ s_f16UIToCommonNaN$(OBJ) \
+ s_commonNaNToF16UI$(OBJ) \
+ s_propagateNaNF16UI$(OBJ) \
+ s_f32UIToCommonNaN$(OBJ) \
+ s_commonNaNToF32UI$(OBJ) \
+ s_propagateNaNF32UI$(OBJ) \
+ s_f64UIToCommonNaN$(OBJ) \
+ s_commonNaNToF64UI$(OBJ) \
+ s_propagateNaNF64UI$(OBJ) \
+ extF80M_isSignalingNaN$(OBJ) \
+ s_extF80UIToCommonNaN$(OBJ) \
+ s_commonNaNToExtF80UI$(OBJ) \
+ s_propagateNaNExtF80UI$(OBJ) \
+ f128M_isSignalingNaN$(OBJ) \
+ s_f128UIToCommonNaN$(OBJ) \
+ s_commonNaNToF128UI$(OBJ) \
+ s_propagateNaNF128UI$(OBJ) \
+
+OBJS_OTHERS = \
+ s_roundToUI32$(OBJ) \
+ s_roundToUI64$(OBJ) \
+ s_roundToI32$(OBJ) \
+ s_roundToI64$(OBJ) \
+ s_normSubnormalF16Sig$(OBJ) \
+ s_roundPackToF16$(OBJ) \
+ s_normRoundPackToF16$(OBJ) \
+ s_addMagsF16$(OBJ) \
+ s_subMagsF16$(OBJ) \
+ s_mulAddF16$(OBJ) \
+ s_normSubnormalF32Sig$(OBJ) \
+ s_roundPackToF32$(OBJ) \
+ s_normRoundPackToF32$(OBJ) \
+ s_addMagsF32$(OBJ) \
+ s_subMagsF32$(OBJ) \
+ s_mulAddF32$(OBJ) \
+ s_normSubnormalF64Sig$(OBJ) \
+ s_roundPackToF64$(OBJ) \
+ s_normRoundPackToF64$(OBJ) \
+ s_addMagsF64$(OBJ) \
+ s_subMagsF64$(OBJ) \
+ s_mulAddF64$(OBJ) \
+ s_normSubnormalExtF80Sig$(OBJ) \
+ s_roundPackToExtF80$(OBJ) \
+ s_normRoundPackToExtF80$(OBJ) \
+ s_addMagsExtF80$(OBJ) \
+ s_subMagsExtF80$(OBJ) \
+ s_normSubnormalF128Sig$(OBJ) \
+ s_roundPackToF128$(OBJ) \
+ s_normRoundPackToF128$(OBJ) \
+ s_addMagsF128$(OBJ) \
+ s_subMagsF128$(OBJ) \
+ s_mulAddF128$(OBJ) \
+ softfloat_state$(OBJ) \
+ ui32_to_f16$(OBJ) \
+ ui32_to_f32$(OBJ) \
+ ui32_to_f64$(OBJ) \
+ ui32_to_extF80$(OBJ) \
+ ui32_to_extF80M$(OBJ) \
+ ui32_to_f128$(OBJ) \
+ ui32_to_f128M$(OBJ) \
+ ui64_to_f16$(OBJ) \
+ ui64_to_f32$(OBJ) \
+ ui64_to_f64$(OBJ) \
+ ui64_to_extF80$(OBJ) \
+ ui64_to_extF80M$(OBJ) \
+ ui64_to_f128$(OBJ) \
+ ui64_to_f128M$(OBJ) \
+ i32_to_f16$(OBJ) \
+ i32_to_f32$(OBJ) \
+ i32_to_f64$(OBJ) \
+ i32_to_extF80$(OBJ) \
+ i32_to_extF80M$(OBJ) \
+ i32_to_f128$(OBJ) \
+ i32_to_f128M$(OBJ) \
+ i64_to_f16$(OBJ) \
+ i64_to_f32$(OBJ) \
+ i64_to_f64$(OBJ) \
+ i64_to_extF80$(OBJ) \
+ i64_to_extF80M$(OBJ) \
+ i64_to_f128$(OBJ) \
+ i64_to_f128M$(OBJ) \
+ f16_to_ui32$(OBJ) \
+ f16_to_ui64$(OBJ) \
+ f16_to_i32$(OBJ) \
+ f16_to_i64$(OBJ) \
+ f16_to_ui32_r_minMag$(OBJ) \
+ f16_to_ui64_r_minMag$(OBJ) \
+ f16_to_i32_r_minMag$(OBJ) \
+ f16_to_i64_r_minMag$(OBJ) \
+ f16_to_f32$(OBJ) \
+ f16_to_f64$(OBJ) \
+ f16_to_extF80$(OBJ) \
+ f16_to_extF80M$(OBJ) \
+ f16_to_f128$(OBJ) \
+ f16_to_f128M$(OBJ) \
+ f16_roundToInt$(OBJ) \
+ f16_add$(OBJ) \
+ f16_sub$(OBJ) \
+ f16_mul$(OBJ) \
+ f16_mulAdd$(OBJ) \
+ f16_div$(OBJ) \
+ f16_rem$(OBJ) \
+ f16_sqrt$(OBJ) \
+ f16_eq$(OBJ) \
+ f16_le$(OBJ) \
+ f16_lt$(OBJ) \
+ f16_eq_signaling$(OBJ) \
+ f16_le_quiet$(OBJ) \
+ f16_lt_quiet$(OBJ) \
+ f16_isSignalingNaN$(OBJ) \
+ f32_to_ui32$(OBJ) \
+ f32_to_ui64$(OBJ) \
+ f32_to_i32$(OBJ) \
+ f32_to_i64$(OBJ) \
+ f32_to_ui32_r_minMag$(OBJ) \
+ f32_to_ui64_r_minMag$(OBJ) \
+ f32_to_i32_r_minMag$(OBJ) \
+ f32_to_i64_r_minMag$(OBJ) \
+ f32_to_f16$(OBJ) \
+ f32_to_f64$(OBJ) \
+ f32_to_extF80$(OBJ) \
+ f32_to_extF80M$(OBJ) \
+ f32_to_f128$(OBJ) \
+ f32_to_f128M$(OBJ) \
+ f32_roundToInt$(OBJ) \
+ f32_add$(OBJ) \
+ f32_sub$(OBJ) \
+ f32_mul$(OBJ) \
+ f32_mulAdd$(OBJ) \
+ f32_div$(OBJ) \
+ f32_rem$(OBJ) \
+ f32_sqrt$(OBJ) \
+ f32_eq$(OBJ) \
+ f32_le$(OBJ) \
+ f32_lt$(OBJ) \
+ f32_eq_signaling$(OBJ) \
+ f32_le_quiet$(OBJ) \
+ f32_lt_quiet$(OBJ) \
+ f32_isSignalingNaN$(OBJ) \
+ f64_to_ui32$(OBJ) \
+ f64_to_ui64$(OBJ) \
+ f64_to_i32$(OBJ) \
+ f64_to_i64$(OBJ) \
+ f64_to_ui32_r_minMag$(OBJ) \
+ f64_to_ui64_r_minMag$(OBJ) \
+ f64_to_i32_r_minMag$(OBJ) \
+ f64_to_i64_r_minMag$(OBJ) \
+ f64_to_f16$(OBJ) \
+ f64_to_f32$(OBJ) \
+ f64_to_extF80$(OBJ) \
+ f64_to_extF80M$(OBJ) \
+ f64_to_f128$(OBJ) \
+ f64_to_f128M$(OBJ) \
+ f64_roundToInt$(OBJ) \
+ f64_add$(OBJ) \
+ f64_sub$(OBJ) \
+ f64_mul$(OBJ) \
+ f64_mulAdd$(OBJ) \
+ f64_div$(OBJ) \
+ f64_rem$(OBJ) \
+ f64_sqrt$(OBJ) \
+ f64_eq$(OBJ) \
+ f64_le$(OBJ) \
+ f64_lt$(OBJ) \
+ f64_eq_signaling$(OBJ) \
+ f64_le_quiet$(OBJ) \
+ f64_lt_quiet$(OBJ) \
+ f64_isSignalingNaN$(OBJ) \
+ extF80_to_ui32$(OBJ) \
+ extF80_to_ui64$(OBJ) \
+ extF80_to_i32$(OBJ) \
+ extF80_to_i64$(OBJ) \
+ extF80_to_ui32_r_minMag$(OBJ) \
+ extF80_to_ui64_r_minMag$(OBJ) \
+ extF80_to_i32_r_minMag$(OBJ) \
+ extF80_to_i64_r_minMag$(OBJ) \
+ extF80_to_f16$(OBJ) \
+ extF80_to_f32$(OBJ) \
+ extF80_to_f64$(OBJ) \
+ extF80_to_f128$(OBJ) \
+ extF80_roundToInt$(OBJ) \
+ extF80_add$(OBJ) \
+ extF80_sub$(OBJ) \
+ extF80_mul$(OBJ) \
+ extF80_div$(OBJ) \
+ extF80_rem$(OBJ) \
+ extF80_sqrt$(OBJ) \
+ extF80_eq$(OBJ) \
+ extF80_le$(OBJ) \
+ extF80_lt$(OBJ) \
+ extF80_eq_signaling$(OBJ) \
+ extF80_le_quiet$(OBJ) \
+ extF80_lt_quiet$(OBJ) \
+ extF80_isSignalingNaN$(OBJ) \
+ extF80M_to_ui32$(OBJ) \
+ extF80M_to_ui64$(OBJ) \
+ extF80M_to_i32$(OBJ) \
+ extF80M_to_i64$(OBJ) \
+ extF80M_to_ui32_r_minMag$(OBJ) \
+ extF80M_to_ui64_r_minMag$(OBJ) \
+ extF80M_to_i32_r_minMag$(OBJ) \
+ extF80M_to_i64_r_minMag$(OBJ) \
+ extF80M_to_f16$(OBJ) \
+ extF80M_to_f32$(OBJ) \
+ extF80M_to_f64$(OBJ) \
+ extF80M_to_f128M$(OBJ) \
+ extF80M_roundToInt$(OBJ) \
+ extF80M_add$(OBJ) \
+ extF80M_sub$(OBJ) \
+ extF80M_mul$(OBJ) \
+ extF80M_div$(OBJ) \
+ extF80M_rem$(OBJ) \
+ extF80M_sqrt$(OBJ) \
+ extF80M_eq$(OBJ) \
+ extF80M_le$(OBJ) \
+ extF80M_lt$(OBJ) \
+ extF80M_eq_signaling$(OBJ) \
+ extF80M_le_quiet$(OBJ) \
+ extF80M_lt_quiet$(OBJ) \
+ f128_to_ui32$(OBJ) \
+ f128_to_ui64$(OBJ) \
+ f128_to_i32$(OBJ) \
+ f128_to_i64$(OBJ) \
+ f128_to_ui32_r_minMag$(OBJ) \
+ f128_to_ui64_r_minMag$(OBJ) \
+ f128_to_i32_r_minMag$(OBJ) \
+ f128_to_i64_r_minMag$(OBJ) \
+ f128_to_f16$(OBJ) \
+ f128_to_f32$(OBJ) \
+ f128_to_extF80$(OBJ) \
+ f128_to_f64$(OBJ) \
+ f128_roundToInt$(OBJ) \
+ f128_add$(OBJ) \
+ f128_sub$(OBJ) \
+ f128_mul$(OBJ) \
+ f128_mulAdd$(OBJ) \
+ f128_div$(OBJ) \
+ f128_rem$(OBJ) \
+ f128_sqrt$(OBJ) \
+ f128_eq$(OBJ) \
+ f128_le$(OBJ) \
+ f128_lt$(OBJ) \
+ f128_eq_signaling$(OBJ) \
+ f128_le_quiet$(OBJ) \
+ f128_lt_quiet$(OBJ) \
+ f128_isSignalingNaN$(OBJ) \
+ f128M_to_ui32$(OBJ) \
+ f128M_to_ui64$(OBJ) \
+ f128M_to_i32$(OBJ) \
+ f128M_to_i64$(OBJ) \
+ f128M_to_ui32_r_minMag$(OBJ) \
+ f128M_to_ui64_r_minMag$(OBJ) \
+ f128M_to_i32_r_minMag$(OBJ) \
+ f128M_to_i64_r_minMag$(OBJ) \
+ f128M_to_f16$(OBJ) \
+ f128M_to_f32$(OBJ) \
+ f128M_to_extF80M$(OBJ) \
+ f128M_to_f64$(OBJ) \
+ f128M_roundToInt$(OBJ) \
+ f128M_add$(OBJ) \
+ f128M_sub$(OBJ) \
+ f128M_mul$(OBJ) \
+ f128M_mulAdd$(OBJ) \
+ f128M_div$(OBJ) \
+ f128M_rem$(OBJ) \
+ f128M_sqrt$(OBJ) \
+ f128M_eq$(OBJ) \
+ f128M_le$(OBJ) \
+ f128M_lt$(OBJ) \
+ f128M_eq_signaling$(OBJ) \
+ f128M_le_quiet$(OBJ) \
+ f128M_lt_quiet$(OBJ) \
+
+OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
+
+$(OBJS_ALL): \
+ $(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
+ $(SOURCE_DIR)/include/primitives.h
+$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
+ $(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
+ $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
+ $(SOURCE_DIR)/include/softfloat.h
+
+$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
+ $(COMPILE_C) $(SOURCE_DIR)/$*.c
+
+$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
+ $(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
+
+softfloat$(LIB): $(OBJS_ALL)
+ $(DELETE) $@
+ $(MAKELIB) $^
+
+.PHONY: clean
+clean:
+ $(DELETE) $(OBJS_ALL) softfloat$(LIB)
+
diff --git a/test/float/softfloat/build/Win64-MinGW-w64/platform.h b/test/float/softfloat/build/Win64-MinGW-w64/platform.h
new file mode 100644
index 000000000..c5e06f8e9
--- /dev/null
+++ b/test/float/softfloat/build/Win64-MinGW-w64/platform.h
@@ -0,0 +1,54 @@
+
+/*============================================================================
+
+This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#define LITTLEENDIAN 1
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#ifdef __GNUC_STDC_INLINE__
+#define INLINE inline
+#else
+#define INLINE extern inline
+#endif
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#define SOFTFLOAT_BUILTIN_CLZ 1
+#define SOFTFLOAT_INTRINSIC_INT128 1
+#include "opts-GCC.h"
+
diff --git a/test/float/softfloat/build/template-FAST_INT64/Makefile b/test/float/softfloat/build/template-FAST_INT64/Makefile
new file mode 100644
index 000000000..78e7ff5aa
--- /dev/null
+++ b/test/float/softfloat/build/template-FAST_INT64/Makefile
@@ -0,0 +1,391 @@
+
+#=============================================================================
+#
+# This Makefile template is part of the SoftFloat IEEE Floating-Point
+# Arithmetic Package, Release 3e, by John R. Hauser.
+#
+# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+# University of California. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice,
+# this list of conditions, and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions, and the following disclaimer in the
+# documentation and/or other materials provided with the distribution.
+#
+# 3. Neither the name of the University nor the names of its contributors
+# may be used to endorse or promote products derived from this software
+# without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+#=============================================================================
+
+# Edit lines marked with `==>'. See "SoftFloat-source.html".
+
+==> SOURCE_DIR ?= ../../source
+==> SPECIALIZE_TYPE ?= 8086
+
+==> SOFTFLOAT_OPTS ?= \
+==> -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
+==> -DSOFTFLOAT_FAST_DIV64TO32
+
+==> DELETE = rm -f
+==> C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
+==> COMPILE_C = \
+==> cc -c -DSOFTFLOAT_FAST_INT64 $(SOFTFLOAT_OPTS) $(C_INCLUDES) -O2 -o $@
+==> MAKELIB = ar crs $@
+
+==> OBJ = .o
+==> LIB = .a
+
+==> OTHER_HEADERS =
+
+.PHONY: all
+all: softfloat$(LIB)
+
+OBJS_PRIMITIVES = \
+ s_eq128$(OBJ) \
+ s_le128$(OBJ) \
+ s_lt128$(OBJ) \
+ s_shortShiftLeft128$(OBJ) \
+ s_shortShiftRight128$(OBJ) \
+ s_shortShiftRightJam64$(OBJ) \
+ s_shortShiftRightJam64Extra$(OBJ) \
+ s_shortShiftRightJam128$(OBJ) \
+ s_shortShiftRightJam128Extra$(OBJ) \
+ s_shiftRightJam32$(OBJ) \
+ s_shiftRightJam64$(OBJ) \
+ s_shiftRightJam64Extra$(OBJ) \
+ s_shiftRightJam128$(OBJ) \
+ s_shiftRightJam128Extra$(OBJ) \
+ s_shiftRightJam256M$(OBJ) \
+ s_countLeadingZeros8$(OBJ) \
+ s_countLeadingZeros16$(OBJ) \
+ s_countLeadingZeros32$(OBJ) \
+ s_countLeadingZeros64$(OBJ) \
+ s_add128$(OBJ) \
+ s_add256M$(OBJ) \
+ s_sub128$(OBJ) \
+ s_sub256M$(OBJ) \
+ s_mul64ByShifted32To128$(OBJ) \
+ s_mul64To128$(OBJ) \
+ s_mul128By32$(OBJ) \
+ s_mul128To256M$(OBJ) \
+ s_approxRecip_1Ks$(OBJ) \
+ s_approxRecip32_1$(OBJ) \
+ s_approxRecipSqrt_1Ks$(OBJ) \
+ s_approxRecipSqrt32_1$(OBJ) \
+
+OBJS_SPECIALIZE = \
+ softfloat_raiseFlags$(OBJ) \
+ s_f16UIToCommonNaN$(OBJ) \
+ s_commonNaNToF16UI$(OBJ) \
+ s_propagateNaNF16UI$(OBJ) \
+ s_f32UIToCommonNaN$(OBJ) \
+ s_commonNaNToF32UI$(OBJ) \
+ s_propagateNaNF32UI$(OBJ) \
+ s_f64UIToCommonNaN$(OBJ) \
+ s_commonNaNToF64UI$(OBJ) \
+ s_propagateNaNF64UI$(OBJ) \
+ extF80M_isSignalingNaN$(OBJ) \
+ s_extF80UIToCommonNaN$(OBJ) \
+ s_commonNaNToExtF80UI$(OBJ) \
+ s_propagateNaNExtF80UI$(OBJ) \
+ f128M_isSignalingNaN$(OBJ) \
+ s_f128UIToCommonNaN$(OBJ) \
+ s_commonNaNToF128UI$(OBJ) \
+ s_propagateNaNF128UI$(OBJ) \
+
+OBJS_OTHERS = \
+ s_roundToUI32$(OBJ) \
+ s_roundToUI64$(OBJ) \
+ s_roundToI32$(OBJ) \
+ s_roundToI64$(OBJ) \
+ s_normSubnormalF16Sig$(OBJ) \
+ s_roundPackToF16$(OBJ) \
+ s_normRoundPackToF16$(OBJ) \
+ s_addMagsF16$(OBJ) \
+ s_subMagsF16$(OBJ) \
+ s_mulAddF16$(OBJ) \
+ s_normSubnormalF32Sig$(OBJ) \
+ s_roundPackToF32$(OBJ) \
+ s_normRoundPackToF32$(OBJ) \
+ s_addMagsF32$(OBJ) \
+ s_subMagsF32$(OBJ) \
+ s_mulAddF32$(OBJ) \
+ s_normSubnormalF64Sig$(OBJ) \
+ s_roundPackToF64$(OBJ) \
+ s_normRoundPackToF64$(OBJ) \
+ s_addMagsF64$(OBJ) \
+ s_subMagsF64$(OBJ) \
+ s_mulAddF64$(OBJ) \
+ s_normSubnormalExtF80Sig$(OBJ) \
+ s_roundPackToExtF80$(OBJ) \
+ s_normRoundPackToExtF80$(OBJ) \
+ s_addMagsExtF80$(OBJ) \
+ s_subMagsExtF80$(OBJ) \
+ s_normSubnormalF128Sig$(OBJ) \
+ s_roundPackToF128$(OBJ) \
+ s_normRoundPackToF128$(OBJ) \
+ s_addMagsF128$(OBJ) \
+ s_subMagsF128$(OBJ) \
+ s_mulAddF128$(OBJ) \
+ softfloat_state$(OBJ) \
+ ui32_to_f16$(OBJ) \
+ ui32_to_f32$(OBJ) \
+ ui32_to_f64$(OBJ) \
+ ui32_to_extF80$(OBJ) \
+ ui32_to_extF80M$(OBJ) \
+ ui32_to_f128$(OBJ) \
+ ui32_to_f128M$(OBJ) \
+ ui64_to_f16$(OBJ) \
+ ui64_to_f32$(OBJ) \
+ ui64_to_f64$(OBJ) \
+ ui64_to_extF80$(OBJ) \
+ ui64_to_extF80M$(OBJ) \
+ ui64_to_f128$(OBJ) \
+ ui64_to_f128M$(OBJ) \
+ i32_to_f16$(OBJ) \
+ i32_to_f32$(OBJ) \
+ i32_to_f64$(OBJ) \
+ i32_to_extF80$(OBJ) \
+ i32_to_extF80M$(OBJ) \
+ i32_to_f128$(OBJ) \
+ i32_to_f128M$(OBJ) \
+ i64_to_f16$(OBJ) \
+ i64_to_f32$(OBJ) \
+ i64_to_f64$(OBJ) \
+ i64_to_extF80$(OBJ) \
+ i64_to_extF80M$(OBJ) \
+ i64_to_f128$(OBJ) \
+ i64_to_f128M$(OBJ) \
+ f16_to_ui32$(OBJ) \
+ f16_to_ui64$(OBJ) \
+ f16_to_i32$(OBJ) \
+ f16_to_i64$(OBJ) \
+ f16_to_ui32_r_minMag$(OBJ) \
+ f16_to_ui64_r_minMag$(OBJ) \
+ f16_to_i32_r_minMag$(OBJ) \
+ f16_to_i64_r_minMag$(OBJ) \
+ f16_to_f32$(OBJ) \
+ f16_to_f64$(OBJ) \
+ f16_to_extF80$(OBJ) \
+ f16_to_extF80M$(OBJ) \
+ f16_to_f128$(OBJ) \
+ f16_to_f128M$(OBJ) \
+ f16_roundToInt$(OBJ) \
+ f16_add$(OBJ) \
+ f16_sub$(OBJ) \
+ f16_mul$(OBJ) \
+ f16_mulAdd$(OBJ) \
+ f16_div$(OBJ) \
+ f16_rem$(OBJ) \
+ f16_sqrt$(OBJ) \
+ f16_eq$(OBJ) \
+ f16_le$(OBJ) \
+ f16_lt$(OBJ) \
+ f16_eq_signaling$(OBJ) \
+ f16_le_quiet$(OBJ) \
+ f16_lt_quiet$(OBJ) \
+ f16_isSignalingNaN$(OBJ) \
+ f32_to_ui32$(OBJ) \
+ f32_to_ui64$(OBJ) \
+ f32_to_i32$(OBJ) \
+ f32_to_i64$(OBJ) \
+ f32_to_ui32_r_minMag$(OBJ) \
+ f32_to_ui64_r_minMag$(OBJ) \
+ f32_to_i32_r_minMag$(OBJ) \
+ f32_to_i64_r_minMag$(OBJ) \
+ f32_to_f16$(OBJ) \
+ f32_to_f64$(OBJ) \
+ f32_to_extF80$(OBJ) \
+ f32_to_extF80M$(OBJ) \
+ f32_to_f128$(OBJ) \
+ f32_to_f128M$(OBJ) \
+ f32_roundToInt$(OBJ) \
+ f32_add$(OBJ) \
+ f32_sub$(OBJ) \
+ f32_mul$(OBJ) \
+ f32_mulAdd$(OBJ) \
+ f32_div$(OBJ) \
+ f32_rem$(OBJ) \
+ f32_sqrt$(OBJ) \
+ f32_eq$(OBJ) \
+ f32_le$(OBJ) \
+ f32_lt$(OBJ) \
+ f32_eq_signaling$(OBJ) \
+ f32_le_quiet$(OBJ) \
+ f32_lt_quiet$(OBJ) \
+ f32_isSignalingNaN$(OBJ) \
+ f64_to_ui32$(OBJ) \
+ f64_to_ui64$(OBJ) \
+ f64_to_i32$(OBJ) \
+ f64_to_i64$(OBJ) \
+ f64_to_ui32_r_minMag$(OBJ) \
+ f64_to_ui64_r_minMag$(OBJ) \
+ f64_to_i32_r_minMag$(OBJ) \
+ f64_to_i64_r_minMag$(OBJ) \
+ f64_to_f16$(OBJ) \
+ f64_to_f32$(OBJ) \
+ f64_to_extF80$(OBJ) \
+ f64_to_extF80M$(OBJ) \
+ f64_to_f128$(OBJ) \
+ f64_to_f128M$(OBJ) \
+ f64_roundToInt$(OBJ) \
+ f64_add$(OBJ) \
+ f64_sub$(OBJ) \
+ f64_mul$(OBJ) \
+ f64_mulAdd$(OBJ) \
+ f64_div$(OBJ) \
+ f64_rem$(OBJ) \
+ f64_sqrt$(OBJ) \
+ f64_eq$(OBJ) \
+ f64_le$(OBJ) \
+ f64_lt$(OBJ) \
+ f64_eq_signaling$(OBJ) \
+ f64_le_quiet$(OBJ) \
+ f64_lt_quiet$(OBJ) \
+ f64_isSignalingNaN$(OBJ) \
+ extF80_to_ui32$(OBJ) \
+ extF80_to_ui64$(OBJ) \
+ extF80_to_i32$(OBJ) \
+ extF80_to_i64$(OBJ) \
+ extF80_to_ui32_r_minMag$(OBJ) \
+ extF80_to_ui64_r_minMag$(OBJ) \
+ extF80_to_i32_r_minMag$(OBJ) \
+ extF80_to_i64_r_minMag$(OBJ) \
+ extF80_to_f16$(OBJ) \
+ extF80_to_f32$(OBJ) \
+ extF80_to_f64$(OBJ) \
+ extF80_to_f128$(OBJ) \
+ extF80_roundToInt$(OBJ) \
+ extF80_add$(OBJ) \
+ extF80_sub$(OBJ) \
+ extF80_mul$(OBJ) \
+ extF80_div$(OBJ) \
+ extF80_rem$(OBJ) \
+ extF80_sqrt$(OBJ) \
+ extF80_eq$(OBJ) \
+ extF80_le$(OBJ) \
+ extF80_lt$(OBJ) \
+ extF80_eq_signaling$(OBJ) \
+ extF80_le_quiet$(OBJ) \
+ extF80_lt_quiet$(OBJ) \
+ extF80_isSignalingNaN$(OBJ) \
+ extF80M_to_ui32$(OBJ) \
+ extF80M_to_ui64$(OBJ) \
+ extF80M_to_i32$(OBJ) \
+ extF80M_to_i64$(OBJ) \
+ extF80M_to_ui32_r_minMag$(OBJ) \
+ extF80M_to_ui64_r_minMag$(OBJ) \
+ extF80M_to_i32_r_minMag$(OBJ) \
+ extF80M_to_i64_r_minMag$(OBJ) \
+ extF80M_to_f16$(OBJ) \
+ extF80M_to_f32$(OBJ) \
+ extF80M_to_f64$(OBJ) \
+ extF80M_to_f128M$(OBJ) \
+ extF80M_roundToInt$(OBJ) \
+ extF80M_add$(OBJ) \
+ extF80M_sub$(OBJ) \
+ extF80M_mul$(OBJ) \
+ extF80M_div$(OBJ) \
+ extF80M_rem$(OBJ) \
+ extF80M_sqrt$(OBJ) \
+ extF80M_eq$(OBJ) \
+ extF80M_le$(OBJ) \
+ extF80M_lt$(OBJ) \
+ extF80M_eq_signaling$(OBJ) \
+ extF80M_le_quiet$(OBJ) \
+ extF80M_lt_quiet$(OBJ) \
+ f128_to_ui32$(OBJ) \
+ f128_to_ui64$(OBJ) \
+ f128_to_i32$(OBJ) \
+ f128_to_i64$(OBJ) \
+ f128_to_ui32_r_minMag$(OBJ) \
+ f128_to_ui64_r_minMag$(OBJ) \
+ f128_to_i32_r_minMag$(OBJ) \
+ f128_to_i64_r_minMag$(OBJ) \
+ f128_to_f16$(OBJ) \
+ f128_to_f32$(OBJ) \
+ f128_to_extF80$(OBJ) \
+ f128_to_f64$(OBJ) \
+ f128_roundToInt$(OBJ) \
+ f128_add$(OBJ) \
+ f128_sub$(OBJ) \
+ f128_mul$(OBJ) \
+ f128_mulAdd$(OBJ) \
+ f128_div$(OBJ) \
+ f128_rem$(OBJ) \
+ f128_sqrt$(OBJ) \
+ f128_eq$(OBJ) \
+ f128_le$(OBJ) \
+ f128_lt$(OBJ) \
+ f128_eq_signaling$(OBJ) \
+ f128_le_quiet$(OBJ) \
+ f128_lt_quiet$(OBJ) \
+ f128_isSignalingNaN$(OBJ) \
+ f128M_to_ui32$(OBJ) \
+ f128M_to_ui64$(OBJ) \
+ f128M_to_i32$(OBJ) \
+ f128M_to_i64$(OBJ) \
+ f128M_to_ui32_r_minMag$(OBJ) \
+ f128M_to_ui64_r_minMag$(OBJ) \
+ f128M_to_i32_r_minMag$(OBJ) \
+ f128M_to_i64_r_minMag$(OBJ) \
+ f128M_to_f16$(OBJ) \
+ f128M_to_f32$(OBJ) \
+ f128M_to_extF80M$(OBJ) \
+ f128M_to_f64$(OBJ) \
+ f128M_roundToInt$(OBJ) \
+ f128M_add$(OBJ) \
+ f128M_sub$(OBJ) \
+ f128M_mul$(OBJ) \
+ f128M_mulAdd$(OBJ) \
+ f128M_div$(OBJ) \
+ f128M_rem$(OBJ) \
+ f128M_sqrt$(OBJ) \
+ f128M_eq$(OBJ) \
+ f128M_le$(OBJ) \
+ f128M_lt$(OBJ) \
+ f128M_eq_signaling$(OBJ) \
+ f128M_le_quiet$(OBJ) \
+ f128M_lt_quiet$(OBJ) \
+
+OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
+
+$(OBJS_ALL): \
+ $(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
+ $(SOURCE_DIR)/include/primitives.h
+$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
+ $(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
+ $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
+ $(SOURCE_DIR)/include/softfloat.h
+
+$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
+ $(COMPILE_C) $(SOURCE_DIR)/$*.c
+
+$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
+ $(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
+
+softfloat$(LIB): $(OBJS_ALL)
+ $(DELETE) $@
+ $(MAKELIB) $^
+
+.PHONY: clean
+clean:
+ $(DELETE) $(OBJS_ALL) softfloat$(LIB)
+
diff --git a/test/float/softfloat/build/template-FAST_INT64/platform.h b/test/float/softfloat/build/template-FAST_INT64/platform.h
new file mode 100644
index 000000000..20946587b
--- /dev/null
+++ b/test/float/softfloat/build/template-FAST_INT64/platform.h
@@ -0,0 +1,50 @@
+
+/*============================================================================
+
+This C header template is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+// Edit lines marked with `==>'. See "SoftFloat-source.html".
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+==> #define LITTLEENDIAN 1
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+==> #define INLINE inline
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+==> #define THREAD_LOCAL _Thread_local
+
diff --git a/test/float/softfloat/build/template-not-FAST_INT64/Makefile b/test/float/softfloat/build/template-not-FAST_INT64/Makefile
new file mode 100644
index 000000000..48b2cd6bf
--- /dev/null
+++ b/test/float/softfloat/build/template-not-FAST_INT64/Makefile
@@ -0,0 +1,325 @@
+
+#=============================================================================
+#
+# This Makefile template is part of the SoftFloat IEEE Floating-Point
+# Arithmetic Package, Release 3e, by John R. Hauser.
+#
+# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+# University of California. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice,
+# this list of conditions, and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions, and the following disclaimer in the
+# documentation and/or other materials provided with the distribution.
+#
+# 3. Neither the name of the University nor the names of its contributors
+# may be used to endorse or promote products derived from this software
+# without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+#=============================================================================
+
+# Edit lines marked with `==>'. See "SoftFloat-source.html".
+
+==> SOURCE_DIR ?= ../../source
+==> SPECIALIZE_TYPE ?= 8086
+
+==> SOFTFLOAT_OPTS ?= \
+==> -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
+==> -DSOFTFLOAT_FAST_DIV64TO32
+
+==> DELETE = rm -f
+==> C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
+==> COMPILE_C = cc -c $(SOFTFLOAT_OPTS) $(C_INCLUDES) -O2 -o $@
+==> MAKELIB = ar crs $@
+
+==> OBJ = .o
+==> LIB = .a
+
+==> OTHER_HEADERS =
+
+.PHONY: all
+all: softfloat$(LIB)
+
+OBJS_PRIMITIVES = \
+ s_compare96M$(OBJ) \
+ s_compare128M$(OBJ) \
+ s_shortShiftLeft64To96M$(OBJ) \
+ s_shortShiftLeftM$(OBJ) \
+ s_shiftLeftM$(OBJ) \
+ s_shortShiftRightM$(OBJ) \
+ s_shortShiftRightJam64$(OBJ) \
+ s_shortShiftRightJamM$(OBJ) \
+ s_shiftRightJam32$(OBJ) \
+ s_shiftRightJam64$(OBJ) \
+ s_shiftRightJamM$(OBJ) \
+ s_shiftRightM$(OBJ) \
+ s_countLeadingZeros8$(OBJ) \
+ s_countLeadingZeros16$(OBJ) \
+ s_countLeadingZeros32$(OBJ) \
+ s_countLeadingZeros64$(OBJ) \
+ s_addM$(OBJ) \
+ s_addCarryM$(OBJ) \
+ s_addComplCarryM$(OBJ) \
+ s_negXM$(OBJ) \
+ s_sub1XM$(OBJ) \
+ s_subM$(OBJ) \
+ s_mul64To128M$(OBJ) \
+ s_mul128MTo256M$(OBJ) \
+ s_approxRecip_1Ks$(OBJ) \
+ s_approxRecip32_1$(OBJ) \
+ s_approxRecipSqrt_1Ks$(OBJ) \
+ s_approxRecipSqrt32_1$(OBJ) \
+ s_remStepMBy32$(OBJ) \
+
+OBJS_SPECIALIZE = \
+ softfloat_raiseFlags$(OBJ) \
+ s_f16UIToCommonNaN$(OBJ) \
+ s_commonNaNToF16UI$(OBJ) \
+ s_propagateNaNF16UI$(OBJ) \
+ s_f32UIToCommonNaN$(OBJ) \
+ s_commonNaNToF32UI$(OBJ) \
+ s_propagateNaNF32UI$(OBJ) \
+ s_f64UIToCommonNaN$(OBJ) \
+ s_commonNaNToF64UI$(OBJ) \
+ s_propagateNaNF64UI$(OBJ) \
+ extF80M_isSignalingNaN$(OBJ) \
+ s_extF80MToCommonNaN$(OBJ) \
+ s_commonNaNToExtF80M$(OBJ) \
+ s_propagateNaNExtF80M$(OBJ) \
+ f128M_isSignalingNaN$(OBJ) \
+ s_f128MToCommonNaN$(OBJ) \
+ s_commonNaNToF128M$(OBJ) \
+ s_propagateNaNF128M$(OBJ) \
+
+OBJS_OTHERS = \
+ s_roundToUI32$(OBJ) \
+ s_roundMToUI64$(OBJ) \
+ s_roundToI32$(OBJ) \
+ s_roundMToI64$(OBJ) \
+ s_normSubnormalF16Sig$(OBJ) \
+ s_roundPackToF16$(OBJ) \
+ s_normRoundPackToF16$(OBJ) \
+ s_addMagsF16$(OBJ) \
+ s_subMagsF16$(OBJ) \
+ s_mulAddF16$(OBJ) \
+ s_normSubnormalF32Sig$(OBJ) \
+ s_roundPackToF32$(OBJ) \
+ s_normRoundPackToF32$(OBJ) \
+ s_addMagsF32$(OBJ) \
+ s_subMagsF32$(OBJ) \
+ s_mulAddF32$(OBJ) \
+ s_normSubnormalF64Sig$(OBJ) \
+ s_roundPackToF64$(OBJ) \
+ s_normRoundPackToF64$(OBJ) \
+ s_addMagsF64$(OBJ) \
+ s_subMagsF64$(OBJ) \
+ s_mulAddF64$(OBJ) \
+ s_tryPropagateNaNExtF80M$(OBJ) \
+ s_invalidExtF80M$(OBJ) \
+ s_normExtF80SigM$(OBJ) \
+ s_roundPackMToExtF80M$(OBJ) \
+ s_normRoundPackMToExtF80M$(OBJ) \
+ s_addExtF80M$(OBJ) \
+ s_compareNonnormExtF80M$(OBJ) \
+ s_isNaNF128M$(OBJ) \
+ s_tryPropagateNaNF128M$(OBJ) \
+ s_invalidF128M$(OBJ) \
+ s_shiftNormSigF128M$(OBJ) \
+ s_roundPackMToF128M$(OBJ) \
+ s_normRoundPackMToF128M$(OBJ) \
+ s_addF128M$(OBJ) \
+ s_mulAddF128M$(OBJ) \
+ softfloat_state$(OBJ) \
+ ui32_to_f16$(OBJ) \
+ ui32_to_f32$(OBJ) \
+ ui32_to_f64$(OBJ) \
+ ui32_to_extF80M$(OBJ) \
+ ui32_to_f128M$(OBJ) \
+ ui64_to_f16$(OBJ) \
+ ui64_to_f32$(OBJ) \
+ ui64_to_f64$(OBJ) \
+ ui64_to_extF80M$(OBJ) \
+ ui64_to_f128M$(OBJ) \
+ i32_to_f16$(OBJ) \
+ i32_to_f32$(OBJ) \
+ i32_to_f64$(OBJ) \
+ i32_to_extF80M$(OBJ) \
+ i32_to_f128M$(OBJ) \
+ i64_to_f16$(OBJ) \
+ i64_to_f32$(OBJ) \
+ i64_to_f64$(OBJ) \
+ i64_to_extF80M$(OBJ) \
+ i64_to_f128M$(OBJ) \
+ f16_to_ui32$(OBJ) \
+ f16_to_ui64$(OBJ) \
+ f16_to_i32$(OBJ) \
+ f16_to_i64$(OBJ) \
+ f16_to_ui32_r_minMag$(OBJ) \
+ f16_to_ui64_r_minMag$(OBJ) \
+ f16_to_i32_r_minMag$(OBJ) \
+ f16_to_i64_r_minMag$(OBJ) \
+ f16_to_f32$(OBJ) \
+ f16_to_f64$(OBJ) \
+ f16_to_extF80M$(OBJ) \
+ f16_to_f128M$(OBJ) \
+ f16_roundToInt$(OBJ) \
+ f16_add$(OBJ) \
+ f16_sub$(OBJ) \
+ f16_mul$(OBJ) \
+ f16_mulAdd$(OBJ) \
+ f16_div$(OBJ) \
+ f16_rem$(OBJ) \
+ f16_sqrt$(OBJ) \
+ f16_eq$(OBJ) \
+ f16_le$(OBJ) \
+ f16_lt$(OBJ) \
+ f16_eq_signaling$(OBJ) \
+ f16_le_quiet$(OBJ) \
+ f16_lt_quiet$(OBJ) \
+ f16_isSignalingNaN$(OBJ) \
+ f32_to_ui32$(OBJ) \
+ f32_to_ui64$(OBJ) \
+ f32_to_i32$(OBJ) \
+ f32_to_i64$(OBJ) \
+ f32_to_ui32_r_minMag$(OBJ) \
+ f32_to_ui64_r_minMag$(OBJ) \
+ f32_to_i32_r_minMag$(OBJ) \
+ f32_to_i64_r_minMag$(OBJ) \
+ f32_to_f16$(OBJ) \
+ f32_to_f64$(OBJ) \
+ f32_to_extF80M$(OBJ) \
+ f32_to_f128M$(OBJ) \
+ f32_roundToInt$(OBJ) \
+ f32_add$(OBJ) \
+ f32_sub$(OBJ) \
+ f32_mul$(OBJ) \
+ f32_mulAdd$(OBJ) \
+ f32_div$(OBJ) \
+ f32_rem$(OBJ) \
+ f32_sqrt$(OBJ) \
+ f32_eq$(OBJ) \
+ f32_le$(OBJ) \
+ f32_lt$(OBJ) \
+ f32_eq_signaling$(OBJ) \
+ f32_le_quiet$(OBJ) \
+ f32_lt_quiet$(OBJ) \
+ f32_isSignalingNaN$(OBJ) \
+ f64_to_ui32$(OBJ) \
+ f64_to_ui64$(OBJ) \
+ f64_to_i32$(OBJ) \
+ f64_to_i64$(OBJ) \
+ f64_to_ui32_r_minMag$(OBJ) \
+ f64_to_ui64_r_minMag$(OBJ) \
+ f64_to_i32_r_minMag$(OBJ) \
+ f64_to_i64_r_minMag$(OBJ) \
+ f64_to_f16$(OBJ) \
+ f64_to_f32$(OBJ) \
+ f64_to_extF80M$(OBJ) \
+ f64_to_f128M$(OBJ) \
+ f64_roundToInt$(OBJ) \
+ f64_add$(OBJ) \
+ f64_sub$(OBJ) \
+ f64_mul$(OBJ) \
+ f64_mulAdd$(OBJ) \
+ f64_div$(OBJ) \
+ f64_rem$(OBJ) \
+ f64_sqrt$(OBJ) \
+ f64_eq$(OBJ) \
+ f64_le$(OBJ) \
+ f64_lt$(OBJ) \
+ f64_eq_signaling$(OBJ) \
+ f64_le_quiet$(OBJ) \
+ f64_lt_quiet$(OBJ) \
+ f64_isSignalingNaN$(OBJ) \
+ extF80M_to_ui32$(OBJ) \
+ extF80M_to_ui64$(OBJ) \
+ extF80M_to_i32$(OBJ) \
+ extF80M_to_i64$(OBJ) \
+ extF80M_to_ui32_r_minMag$(OBJ) \
+ extF80M_to_ui64_r_minMag$(OBJ) \
+ extF80M_to_i32_r_minMag$(OBJ) \
+ extF80M_to_i64_r_minMag$(OBJ) \
+ extF80M_to_f16$(OBJ) \
+ extF80M_to_f32$(OBJ) \
+ extF80M_to_f64$(OBJ) \
+ extF80M_to_f128M$(OBJ) \
+ extF80M_roundToInt$(OBJ) \
+ extF80M_add$(OBJ) \
+ extF80M_sub$(OBJ) \
+ extF80M_mul$(OBJ) \
+ extF80M_div$(OBJ) \
+ extF80M_rem$(OBJ) \
+ extF80M_sqrt$(OBJ) \
+ extF80M_eq$(OBJ) \
+ extF80M_le$(OBJ) \
+ extF80M_lt$(OBJ) \
+ extF80M_eq_signaling$(OBJ) \
+ extF80M_le_quiet$(OBJ) \
+ extF80M_lt_quiet$(OBJ) \
+ f128M_to_ui32$(OBJ) \
+ f128M_to_ui64$(OBJ) \
+ f128M_to_i32$(OBJ) \
+ f128M_to_i64$(OBJ) \
+ f128M_to_ui32_r_minMag$(OBJ) \
+ f128M_to_ui64_r_minMag$(OBJ) \
+ f128M_to_i32_r_minMag$(OBJ) \
+ f128M_to_i64_r_minMag$(OBJ) \
+ f128M_to_f16$(OBJ) \
+ f128M_to_f32$(OBJ) \
+ f128M_to_f64$(OBJ) \
+ f128M_to_extF80M$(OBJ) \
+ f128M_roundToInt$(OBJ) \
+ f128M_add$(OBJ) \
+ f128M_sub$(OBJ) \
+ f128M_mul$(OBJ) \
+ f128M_mulAdd$(OBJ) \
+ f128M_div$(OBJ) \
+ f128M_rem$(OBJ) \
+ f128M_sqrt$(OBJ) \
+ f128M_eq$(OBJ) \
+ f128M_le$(OBJ) \
+ f128M_lt$(OBJ) \
+ f128M_eq_signaling$(OBJ) \
+ f128M_le_quiet$(OBJ) \
+ f128M_lt_quiet$(OBJ) \
+
+OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
+
+$(OBJS_ALL): \
+ $(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
+ $(SOURCE_DIR)/include/primitives.h
+$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
+ $(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
+ $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
+ $(SOURCE_DIR)/include/softfloat.h
+
+$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
+ $(COMPILE_C) $(SOURCE_DIR)/$*.c
+
+$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
+ $(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
+
+softfloat$(LIB): $(OBJS_ALL)
+ $(DELETE) $@
+ $(MAKELIB) $^
+
+.PHONY: clean
+clean:
+ $(DELETE) $(OBJS_ALL) softfloat$(LIB)
+
diff --git a/test/float/softfloat/build/template-not-FAST_INT64/platform.h b/test/float/softfloat/build/template-not-FAST_INT64/platform.h
new file mode 100644
index 000000000..20946587b
--- /dev/null
+++ b/test/float/softfloat/build/template-not-FAST_INT64/platform.h
@@ -0,0 +1,50 @@
+
+/*============================================================================
+
+This C header template is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+// Edit lines marked with `==>'. See "SoftFloat-source.html".
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+==> #define LITTLEENDIAN 1
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+==> #define INLINE inline
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+==> #define THREAD_LOCAL _Thread_local
+
diff --git a/test/float/softfloat/doc/SoftFloat-history.html b/test/float/softfloat/doc/SoftFloat-history.html
new file mode 100644
index 000000000..d81c6bc5a
--- /dev/null
+++ b/test/float/softfloat/doc/SoftFloat-history.html
@@ -0,0 +1,258 @@
+
+
+
+
+Berkeley SoftFloat History
+
+
+
+
+History of Berkeley SoftFloat, to Release 3e
+
+
+John R. Hauser
+2018 January 20
+
+
+
+Release 3e (2018 January)
+
+
+
+-
+Changed the default numeric code for optional rounding mode
odd
+(round to odd, also known as jamming) from 5 to 6.
+
+ -
+Modified the behavior of rounding mode
odd
when rounding to an
+integer value (either conversion to an integer format or a
+‘roundToInt
’ function).
+Previously, for those cases only, rounding mode odd
acted the same
+as rounding to minimum magnitude.
+Now all operations are rounded consistently.
+
+ -
+Fixed some errors in the specialization code modeling Intel x86 floating-point,
+specifically the integers returned on invalid operations and the propagation of
+NaN payloads in a few rare cases.
+
+
-
+Added specialization code modeling ARM floating-point, conforming to VFPv2 or
+later.
+
+
-
+Added an example target for ARM processors.
+
+
-
+Fixed a minor bug whereby function
f16_to_ui64
might return a
+different integer than expected in the case that the floating-point operand is
+negative.
+
+ -
+Added example target-specific optimization for GCC, employing GCC instrinsics
+and support for 128-bit integer arithmetic.
+
+
-
+Made other minor improvements.
+
+
+
+
+Release 3d (2017 August)
+
+
+
+-
+Fixed bugs in the square root functions for 64-bit
+double-precision, 80-bit double-extended-precision, and
+128-bit quadruple-precision.
+For 64-bit double-precision (
f64_sqrt
), the result
+could sometimes be off by 1 unit in the last place
+(1 ulp) from what it should be.
+For the larger formats, the square root could be wrong in a large portion of
+the less-significant bits.
+(A bug in f128_sqrt
was first reported by Alexei Sibidanov.)
+
+
+
+
+Release 3c (2017 February)
+
+
+
+-
+Added optional rounding mode
odd
(round to odd, also known as
+jamming).
+
+ -
+Corrected the documentation concerning non-canonical representations in
+80-bit double-extended-precision.
+
+
+
+
+Release 3b (2016 July)
+
+
+
+-
+Implemented the common 16-bit “half-precision”
+floating-point format (
float16_t
).
+
+ -
+Made the integer values returned on invalid conversions to integer formats
+be determined by the port-specific specialization instead of being the same for
+all ports.
+
+
-
+Added preprocessor macro
THREAD_LOCAL
to allow the floating-point
+state (modes and exception flags) to be made per-thread.
+
+ -
+Modified the provided Makefiles to allow some options to be overridden from the
+
make
command.
+
+ -
+Made other minor improvements.
+
+
+
+
+Release 3a (2015 October)
+
+
+
+-
+Replaced the license text supplied by the University of California, Berkeley.
+
+
+
+
+Release 3 (2015 February)
+
+
+
+-
+Complete rewrite, funded by the University of California, Berkeley, and
+consequently having a different use license than earlier releases.
+Major changes included renaming most types and functions, upgrading some
+algorithms, restructuring the source files, and making SoftFloat into a true
+library.
+
+
-
+Added functions to convert between floating-point and unsigned integers, both
+32-bit and 64-bit (
uint32_t
and
+uint64_t
).
+
+ -
+Added functions for fused multiply-add, for all supported floating-point
+formats except 80-bit double-extended-precision.
+
+
-
+Added support for a fifth rounding mode,
near_maxMag
(round to
+nearest, with ties to maximum magnitude, away from zero).
+
+ -
+Dropped the
timesoftfloat
program (now part of the Berkeley
+TestFloat package).
+
+
+
+
+Release 2c (2015 January)
+
+
+
+-
+Fixed mistakes affecting some 64-bit processors.
+
+
-
+Further improved the documentation and the wording for the legal restrictions
+on using SoftFloat releases through 2c (not applicable to
+Release 3 or later).
+
+
+
+
+Release 2b (2002 May)
+
+
+
+-
+Made minor updates to the documentation, including improved wording for the
+legal restrictions on using SoftFloat.
+
+
+
+
+Release 2a (1998 December)
+
+
+
+-
+Added functions to convert between 64-bit integers
+(
int64
) and all supported floating-point formats.
+
+ -
+Fixed a bug in all 64-bit-version square root functions except
+
float32_sqrt
that caused the result sometimes to be off by
+1 unit in the last place (1 ulp) from what it should
+be.
+(Bug discovered by Paul Donahue.)
+
+ -
+Improved the Makefiles.
+
+
+
+Release 2 (1997 June)
+
+
+
+-
+Created the 64-bit (
bits64
) version, adding the
+floatx80
and float128
formats.
+
+ -
+Changed the source directory structure, splitting the sources into a
+
bits32
and a bits64
version.
+Renamed environment.h
to milieu.h
to avoid confusion
+with environment variables.
+
+ -
+Fixed a small error that caused
float64_round_to_int
often to
+round the wrong way in nearest/even mode when the operand was between
+220 and 221 and halfway between two integers.
+
+
+
+
+Release 1a (1996 July)
+
+
+
+-
+Corrected a mistake that caused borderline underflow cases not to raise the
+underflow flag when they should have.
+(Problem reported by Doug Priest.)
+
+
-
+Added the
float_detect_tininess
variable to control whether
+tininess is detected before or after rounding.
+
+
+
+
+Release 1 (1996 July)
+
+
+
+-
+Original release, based on work done for the International Computer Science
+Institute (ICSI) in Berkeley, California.
+
+
+
+
+
+
diff --git a/test/float/softfloat/doc/SoftFloat-source.html b/test/float/softfloat/doc/SoftFloat-source.html
new file mode 100644
index 000000000..4ff9d4c45
--- /dev/null
+++ b/test/float/softfloat/doc/SoftFloat-source.html
@@ -0,0 +1,686 @@
+
+
+
+
+Berkeley SoftFloat Source Documentation
+
+
+
+
+Berkeley SoftFloat Release 3e: Source Documentation
+
+
+John R. Hauser
+2018 January 20
+
+
+
+Contents
+
+
+
+
+
+1. Introduction |
+2. Limitations |
+3. Acknowledgments and License |
+4. SoftFloat Package Directory Structure |
+5. Issues for Porting SoftFloat to a New Target |
+
+ |
+ 5.1. Standard Headers <stdbool.h> and
+ <stdint.h> |
+
+ | 5.2. Specializing Floating-Point Behavior |
+ | 5.3. Macros for Build Options |
+ | 5.4. Adapting a Template Target Directory |
+
+ | 5.5. Target-Specific Optimization of Primitive Functions |
+
+6. Testing SoftFloat |
+
+ 7. Providing SoftFloat as a Common Library for Applications |
+
+8. Contact Information |
+
+
+
+
+1. Introduction
+
+
+This document gives information needed for compiling and/or porting Berkeley
+SoftFloat, a library of C functions implementing binary floating-point
+conforming to the IEEE Standard for Floating-Point Arithmetic.
+For basic documentation about SoftFloat refer to
+SoftFloat.html
.
+
+
+
+The source code for SoftFloat is intended to be relatively machine-independent
+and should be compilable with any ISO-Standard C compiler that also supports
+64-bit integers.
+SoftFloat has been successfully compiled with the GNU C Compiler
+(gcc
) for several platforms.
+
+
+
+Release 3 of SoftFloat was a complete rewrite relative to
+Release 2 or earlier.
+Changes to the interface of SoftFloat functions are documented in
+SoftFloat.html
.
+The current version of SoftFloat is Release 3e.
+
+
+
+2. Limitations
+
+
+SoftFloat assumes the computer has an addressable byte size of either 8 or
+16 bits.
+(Nearly all computers in use today have 8-bit bytes.)
+
+
+
+SoftFloat is written in C and is designed to work with other C code.
+The C compiler used must conform at a minimum to the 1989 ANSI standard for the
+C language (same as the 1990 ISO standard) and must in addition support basic
+arithmetic on 64-bit integers.
+Earlier releases of SoftFloat included implementations of 32-bit
+single-precision and 64-bit double-precision floating-point that
+did not require 64-bit integers, but this option is not supported
+starting with Release 3.
+Since 1999, ISO standards for C have mandated compiler support for
+64-bit integers.
+A compiler conforming to the 1999 C Standard or later is recommended but not
+strictly required.
+
+
+
+C Standard header files <stdbool.h>
and
+<stdint.h>
are required for defining standard Boolean and
+integer types.
+If these headers are not supplied with the C compiler, minimal substitutes must
+be provided.
+SoftFloat’s dependence on these headers is detailed later in
+section 5.1, Standard Headers <stdbool.h>
+and <stdint.h>
.
+
+
+
+3. Acknowledgments and License
+
+
+The SoftFloat package was written by me, John R. Hauser.
+Release 3 of SoftFloat was a completely new implementation
+supplanting earlier releases.
+The project to create Release 3 (now through 3e) was
+done in the employ of the University of California, Berkeley, within the
+Department of Electrical Engineering and Computer Sciences, first for the
+Parallel Computing Laboratory (Par Lab) and then for the ASPIRE Lab.
+The work was officially overseen by Prof. Krste Asanovic, with funding provided
+by these sources:
+
+
+
+
+
+
+Par Lab: |
+ |
+
+Microsoft (Award #024263), Intel (Award #024894), and U.C. Discovery
+(Award #DIG07-10227), with additional support from Par Lab affiliates Nokia,
+NVIDIA, Oracle, and Samsung.
+ |
+
+
+ASPIRE Lab: |
+ |
+
+DARPA PERFECT program (Award #HR0011-12-2-0016), with additional support from
+ASPIRE industrial sponsor Intel and ASPIRE affiliates Google, Nokia, NVIDIA,
+Oracle, and Samsung.
+ |
+
+
+
+
+
+
+The following applies to the whole of SoftFloat Release 3e as well
+as to each source file individually.
+
+
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 The Regents of the
+University of California.
+All rights reserved.
+
+
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+
+-
+
+Redistributions of source code must retain the above copyright notice, this
+list of conditions, and the following disclaimer.
+
+
+ -
+
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions, and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+
+ -
+
+Neither the name of the University nor the names of its contributors may be
+used to endorse or promote products derived from this software without specific
+prior written permission.
+
+
+
+
+
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS “AS IS”,
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.
+IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+
+4. SoftFloat Package Directory Structure
+
+
+Because SoftFloat is targeted to multiple platforms, its source code is
+slightly scattered between target-specific and target-independent directories
+and files.
+The supplied directory structure is as follows:
+
+
+doc
+source
+ include
+ 8086
+ 8086-SSE
+ ARM-VFPv2
+ ARM-VFPv2-defaultNaN
+build
+ template-FAST_INT64
+ template-not-FAST_INT64
+ Linux-386-GCC
+ Linux-386-SSE2-GCC
+ Linux-x86_64-GCC
+ Linux-ARM-VFPv2-GCC
+ Win32-MinGW
+ Win32-SSE2-MinGW
+ Win64-MinGW-w64
+
+
+The majority of the SoftFloat sources are provided in the source
+directory.
+The include
subdirectory contains several header files
+(unsurprisingly), while the other subdirectories of source
contain
+source files that specialize the floating-point behavior to match particular
+processor families:
+
+
+8086
+-
+Intel’s older, 8087-derived floating-point, extended to all supported
+floating-point types
+
+8086-SSE
+-
+Intel’s x86 processors with Streaming SIMD Extensions (SSE) and later
+compatible extensions, having 8087 behavior for 80-bit
+double-extended-precision (
extFloat80_t
) and SSE behavior for
+other floating-point types
+
+ARM-VFPv2
+-
+ARM’s VFPv2 or later floating-point, with NaN payload propagation
+
+ARM-VFPv2-defaultNaN
+-
+ARM’s VFPv2 or later floating-point, with the “default NaN”
+option
+
+
+
+If other specializations are attempted, these would be expected to be other
+subdirectories of source
alongside the ones listed above.
+Specialization is covered later, in section 5.2, Specializing
+Floating-Point Behavior.
+
+
+
+The build
directory is intended to contain a subdirectory for each
+target platform for which a build of the SoftFloat library may be created.
+For each build target, the target’s subdirectory is where all derived
+object files and the completed SoftFloat library (typically
+softfloat.a
or libsoftfloat.a
) are created.
+The two template
subdirectories are not actual build targets but
+contain sample files for creating new target directories.
+(The meaning of FAST_INT64
will be explained later.)
+
+
+
+Ignoring the template
directories, the supplied target directories
+are intended to follow a naming system of
+<execution-environment>-<compiler>
.
+For the example targets,
+<execution-environment>
is
+Linux-386
, Linux-386-SSE2
,
+Linux-x86_64
,
+Linux-ARM-VFPv2
, Win32
,
+Win32-SSE2
, or Win64
, and
+<compiler>
is GCC
,
+MinGW
, or MinGW-w64
.
+
+
+
+All of the supplied target directories are merely examples that may or may not
+be correct for compiling on any particular system.
+Despite requests, there are currently no plans to include and maintain in the
+SoftFloat package the build files needed for a great many users’
+compilation environments, which can span a huge range of operating systems,
+compilers, and other tools.
+
+
+
+As supplied, each target directory contains two files:
+
+
+Makefile
+platform.h
+
+
+The provided Makefile
is written for GNU make
.
+A build of SoftFloat for the specific target is begun by executing the
+make
command with the target directory as the current directory.
+A completely different build tool can be used if an appropriate
+Makefile
equivalent is created.
+
+
+
+The platform.h
header file exists to provide a location for
+additional C declarations specific to the build target.
+Every C source file of SoftFloat contains a #include
for
+platform.h
.
+In many cases, the contents of platform.h
can be as simple as one
+or two lines of code.
+At the other extreme, to get maximal performance from SoftFloat, it may be
+desirable to include in header platform.h
(directly or via
+#include
) declarations for numerous target-specific optimizations.
+Such possibilities are discussed in the next section, Issues for Porting
+SoftFloat to a New Target.
+If the target’s compiler or library has bugs or other shortcomings,
+workarounds for these issues may also be possible with target-specific
+declarations in platform.h
, avoiding the need to modify the main
+SoftFloat sources.
+
+
+
+5. Issues for Porting SoftFloat to a New Target
+
+5.1. Standard Headers <stdbool.h>
and <stdint.h>
+
+
+The SoftFloat sources make use of standard headers
+<stdbool.h>
and <stdint.h>
, which have
+been part of the ISO C Standard Library since 1999.
+With any recent compiler, these standard headers are likely to be supported,
+even if the compiler does not claim complete conformance to the latest ISO C
+Standard.
+For older or nonstandard compilers, substitutes for
+<stdbool.h>
and <stdint.h>
may need to be
+created.
+SoftFloat depends on these names from <stdbool.h>
:
+
+
+bool
+true
+false
+
+
+and on these names from <stdint.h>
:
+
+
+uint16_t
+uint32_t
+uint64_t
+int32_t
+int64_t
+UINT64_C
+INT64_C
+uint_least8_t
+uint_fast8_t
+uint_fast16_t
+uint_fast32_t
+uint_fast64_t
+int_fast8_t
+int_fast16_t
+int_fast32_t
+int_fast64_t
+
+
+
+
+
+5.2. Specializing Floating-Point Behavior
+
+
+The IEEE Floating-Point Standard allows for some flexibility in a conforming
+implementation, particularly concerning NaNs.
+The SoftFloat source
directory is supplied with some
+specialization subdirectories containing possible definitions for this
+implementation-specific behavior.
+For example, the 8086
and 8086-SSE
+subdirectories have source files that specialize SoftFloat’s behavior to
+match that of Intel’s x86 line of processors.
+The files in a specialization subdirectory must determine:
+
+-
+whether tininess for underflow is detected before or after rounding by default;
+
-
+how signaling NaNs are distinguished from quiet NaNs;
+
-
+what (if anything) special happens when exceptions are raised;
+
-
+the default generated quiet NaNs;
+
-
+how NaNs are propagated from function inputs to output; and
+
-
+the integer results returned when conversions to integer type raise the
+invalid exception.
+
+
+
+
+As provided, the build process for a target expects to involve exactly
+one specialization directory that defines all of these
+implementation-specific details for the target.
+A specialization directory such as 8086
is expected to contain a
+header file called specialize.h
, together with whatever other
+source files are needed to complete the specialization.
+
+
+
+A new build target may use an existing specialization, such as the ones
+provided by the 8086
and 8086-SSE
+subdirectories.
+If a build target needs a new specialization, different from any existing ones,
+it is recommended that a new specialization directory be created for this
+purpose.
+The specialize.h
header file from any of the provided
+specialization subdirectories can be used as a model for what definitions are
+needed.
+
+
+
+5.3. Macros for Build Options
+
+
+The SoftFloat source files adapt the floating-point implementation according to
+several C preprocessor macros:
+
+
+LITTLEENDIAN
+-
+Must be defined for little-endian machines; must not be defined for big-endian
+machines.
+
INLINE
+-
+Specifies the sequence of tokens used to indicate that a C function should be
+inlined.
+If macro
INLINE_LEVEL
is defined with a value of 1 or higher, this
+macro must be defined; otherwise, this macro is ignored and need not be
+defined.
+For compilers that conform to the C Standard’s rules for inline
+functions, this macro can be defined as the single keyword inline
.
+For other compilers that follow a convention pre-dating the standardization of
+inline
, this macro may need to be defined to extern
+inline
.
+ THREAD_LOCAL
+-
+Can be defined to a sequence of tokens that, when appearing at the start of a
+variable declaration, indicates to the C compiler that the variable is
+per-thread, meaning that each execution thread gets its own separate
+instance of the variable.
+This macro is used in header
softfloat.h
in the declarations of
+variables softfloat_roundingMode
,
+softfloat_detectTininess
, extF80_roundingPrecision
,
+and softfloat_exceptionFlags
.
+If macro THREAD_LOCAL
is left undefined, these variables will
+default to being ordinary global variables.
+Depending on the compiler, possible valid definitions of this macro include
+_Thread_local
and __thread
.
+
+
+SOFTFLOAT_ROUND_ODD
+-
+Can be defined to enable support for optional rounding mode
+
softfloat_round_odd
.
+
+
+INLINE_LEVEL
+-
+Can be defined to an integer to determine the degree of inlining requested of
+the compiler.
+Larger numbers request that more inlining be done.
+If this macro is not defined or is defined to a value less than 1
+(zero or negative), no inlining is requested.
+The maximum effective value is no higher than 5.
+Defining this macro to a value greater than 5 is the same as defining it
+to 5.
+
SOFTFLOAT_FAST_INT64
+-
+Can be defined to indicate that the build target’s implementation of
+64-bit arithmetic is efficient.
+For newer 64-bit processors, this macro should usually be defined.
+For very small microprocessors whose buses and registers are 8-bit
+or 16-bit in size, this macro should usually not be defined.
+Whether this macro should be defined for a 32-bit processor may
+depend on the target machine and the applications that will use SoftFloat.
+
SOFTFLOAT_FAST_DIV32TO16
+-
+Can be defined to indicate that the target’s division operator
+in C (written as
/
) is reasonably efficient for
+dividing a 32-bit unsigned integer by a 16-bit
+unsigned integer.
+Setting this macro may affect the performance of function f16_div
.
+ SOFTFLOAT_FAST_DIV64TO32
+-
+Can be defined to indicate that the target’s division operator
+in C (written as
/
) is reasonably efficient for
+dividing a 64-bit unsigned integer by a 32-bit
+unsigned integer.
+Setting this macro may affect the performance of division, remainder, and
+square root operations other than f16_div
.
+
+
+
+
+
+Following the usual custom for C, for most of these macros (all
+except INLINE
, THREAD_LOCAL
, and
+INLINE_LEVEL
), the content of any definition is irrelevant;
+what matters is a macro’s effect on #ifdef
directives.
+
+
+
+It is recommended that any definitions of macros LITTLEENDIAN
,
+INLINE
, and THREAD_LOCAL
be made in a build
+target’s platform.h
header file, because these macros are
+expected to be determined inflexibly by the target machine and compiler.
+The other five macros select options and control optimization, and thus might
+be better located in the target’s Makefile (or its equivalent).
+
+
+
+5.4. Adapting a Template Target Directory
+
+
+In the build
directory, two template
subdirectories
+provide models for new target directories.
+Two different templates exist because different functions are needed in the
+SoftFloat library depending on whether macro SOFTFLOAT_FAST_INT64
+is defined.
+If macro SOFTFLOAT_FAST_INT64
will be defined,
+template-FAST_INT64
is the template to use;
+otherwise, template-not-FAST_INT64
is the appropriate
+template.
+A new target directory can be created by copying the correct template directory
+and editing the files inside.
+To avoid confusion, it would be wise to refrain from editing the files within a
+template directory directly.
+
+
+
+5.5. Target-Specific Optimization of Primitive Functions
+
+
+Header file primitives.h
(in directory
+source/include
) declares macros and functions for numerous
+underlying arithmetic operations upon which many of SoftFloat’s
+floating-point functions are ultimately built.
+The SoftFloat sources include implementations of all of these functions/macros,
+written as standard C code, so a complete and correct SoftFloat library can be
+created using only the supplied code for all functions.
+However, for many targets, SoftFloat’s performance can be improved by
+substituting target-specific implementations of some of the functions/macros
+declared in primitives.h
.
+
+
+
+For example, primitives.h
declares a function called
+softfloat_countLeadingZeros32
that takes an unsigned
+32-bit integer as an argument and returns the number of the
+integer’s most-significant bits that are zeros.
+While the SoftFloat sources include an implementation of this function written
+in standard C, many processors can perform this same function
+directly in only one or two machine instructions.
+An alternative, target-specific implementation that maps to those instructions
+is likely to be more efficient than the generic C code from the SoftFloat
+package.
+
+
+
+A build target can replace the supplied version of any function or macro of
+primitives.h
by defining a macro with the same name in the
+target’s platform.h
header file.
+For this purpose, it may be helpful for platform.h
to
+#include
header file primitiveTypes.h
, which defines
+types used for arguments and results of functions declared in
+primitives.h
.
+When a desired replacement implementation is a function, not a macro, it is
+sufficient for platform.h
to include the line
+
+
+#define <function-name> <function-name>
+
+
+where <function-name>
is the name of the
+function.
+This technically defines <function-name>
+as a macro, but one that resolves to the same name, which may then be a
+function.
+(A preprocessor that conforms to the C Standard is required to limit recursive
+macro expansion from being applied more than once.)
+
+
+
+The supplied header file opts-GCC.h
(in directory
+source/include
) provides an example of target-specific
+optimization for the GCC compiler.
+Each GCC target example in the build
directory has
+
+#include "opts-GCC.h"
+
+in its platform.h
header file.
+Before opts-GCC.h
is included, the following macros must be
+defined (or not) to control which features are invoked:
+
+
+SOFTFLOAT_BUILTIN_CLZ
+-
+If defined, SoftFloat’s internal
+‘
countLeadingZeros
’ functions use intrinsics
+__builtin_clz
and __builtin_clzll
.
+
+SOFTFLOAT_INTRINSIC_INT128
+-
+If defined, SoftFloat makes use of GCC’s nonstandard 128-bit
+integer type
__int128
.
+
+
+
+On some machines, these improvements are observed to increase the speeds of
+f64_mul
and f128_mul
by around 20 to 25%, although
+other functions receive less dramatic boosts, or none at all.
+Results can vary greatly across different platforms.
+
+
+
+6. Testing SoftFloat
+
+
+SoftFloat can be tested using the testsoftfloat
program by the
+same author.
+This program is part of the Berkeley TestFloat package available at the Web
+page
+http://www.jhauser.us/arithmetic/TestFloat.html
.
+The TestFloat package also has a program called timesoftfloat
that
+measures the speed of SoftFloat’s floating-point functions.
+
+
+
+7. Providing SoftFloat as a Common Library for Applications
+
+
+Header file softfloat.h
defines the SoftFloat interface as seen by
+clients.
+If the SoftFloat library will be made a common library for programs on a
+system, the supplied softfloat.h
has a couple of deficiencies for
+this purpose:
+
+-
+As supplied,
softfloat.h
depends on another header,
+softfloat_types.h
, that is not intended for public use but which
+must also be visible to the programmer’s compiler.
+ -
+More troubling, at the time
softfloat.h
is included in a C source
+file, macros SOFTFLOAT_FAST_INT64
and THREAD_LOCAL
+must be defined, or not defined, consistent with how these macro were defined
+when the SoftFloat library was built.
+
+In the situation that new programs may regularly #include
header
+file softfloat.h
, it is recommended that a custom, self-contained
+version of this header file be created that eliminates these issues.
+
+
+
+8. Contact Information
+
+
+At the time of this writing, the most up-to-date information about SoftFloat
+and the latest release can be found at the Web page
+http://www.jhauser.us/arithmetic/SoftFloat.html
.
+
+
+
+
+
diff --git a/test/float/softfloat/doc/SoftFloat.html b/test/float/softfloat/doc/SoftFloat.html
new file mode 100644
index 000000000..b72b407f4
--- /dev/null
+++ b/test/float/softfloat/doc/SoftFloat.html
@@ -0,0 +1,1527 @@
+
+
+
+
+Berkeley SoftFloat Library Interface
+
+
+
+
+Berkeley SoftFloat Release 3e: Library Interface
+
+
+John R. Hauser
+2018 January 20
+
+
+
+Contents
+
+
+
+
+
+1. Introduction |
+2. Limitations |
+3. Acknowledgments and License |
+4. Types and Functions |
+ | 4.1. Boolean and Integer Types |
+ | 4.2. Floating-Point Types |
+ | 4.3. Supported Floating-Point Functions |
+
+ |
+ 4.4. Non-canonical Representations in extFloat80_t |
+
+ | 4.5. Conventions for Passing Arguments and Results |
+5. Reserved Names |
+6. Mode Variables |
+ | 6.1. Rounding Mode |
+ | 6.2. Underflow Detection |
+
+ |
+ 6.3. Rounding Precision for the 80-Bit Extended Format |
+
+7. Exceptions and Exception Flags |
+8. Function Details |
+ | 8.1. Conversions from Integer to Floating-Point |
+ | 8.2. Conversions from Floating-Point to Integer |
+ | 8.3. Conversions Among Floating-Point Types |
+ | 8.4. Basic Arithmetic Functions |
+ | 8.5. Fused Multiply-Add Functions |
+ | 8.6. Remainder Functions |
+ | 8.7. Round-to-Integer Functions |
+ | 8.8. Comparison Functions |
+ | 8.9. Signaling NaN Test Functions |
+ | 8.10. Raise-Exception Function |
+9. Changes from SoftFloat Release 2 |
+ | 9.1. Name Changes |
+ | 9.2. Changes to Function Arguments |
+ | 9.3. Added Capabilities |
+ | 9.4. Better Compatibility with the C Language |
+ | 9.5. New Organization as a Library |
+ | 9.6. Optimization Gains (and Losses) |
+10. Future Directions |
+11. Contact Information |
+
+
+
+
+1. Introduction
+
+
+Berkeley SoftFloat is a software implementation of binary floating-point that
+conforms to the IEEE Standard for Floating-Point Arithmetic.
+The current release supports five binary formats: 16-bit
+half-precision, 32-bit single-precision, 64-bit
+double-precision, 80-bit double-extended-precision, and
+128-bit quadruple-precision.
+The following functions are supported for each format:
+
+-
+addition, subtraction, multiplication, division, and square root;
+
-
+fused multiply-add as defined by the IEEE Standard, except for
+80-bit double-extended-precision;
+
-
+remainder as defined by the IEEE Standard;
+
-
+round to integral value;
+
-
+comparisons;
+
-
+conversions to/from other supported formats; and
+
-
+conversions to/from 32-bit and 64-bit integers,
+signed and unsigned.
+
+All operations required by the original 1985 version of the IEEE Floating-Point
+Standard are implemented, except for conversions to and from decimal.
+
+
+
+This document gives information about the types defined and the routines
+implemented by SoftFloat.
+It does not attempt to define or explain the IEEE Floating-Point Standard.
+Information about the standard is available elsewhere.
+
+
+
+The current version of SoftFloat is Release 3e.
+This release modifies the behavior of the rarely used odd rounding mode
+(round to odd, also known as jamming), and also adds some new
+specialization and optimization examples for those compiling SoftFloat.
+
+
+
+The previous Release 3d fixed bugs that were found in the square
+root functions for the 64-bit, 80-bit, and
+128-bit floating-point formats.
+(Thanks to Alexei Sibidanov at the University of Victoria for reporting an
+incorrect result.)
+The bugs affected all prior Release-3 versions of SoftFloat
+through 3c.
+The flaw in the 64-bit floating-point square root function was of
+very minor impact, causing a 1-ulp error (1 unit in
+the last place) a few times out of a billion.
+The bugs in the 80-bit and 128-bit square root
+functions were more serious.
+Although incorrect results again occurred only a few times out of a billion,
+when they did occur a large portion of the less-significant bits could be
+wrong.
+
+
+
+Among earlier releases, 3b was notable for adding support for the
+16-bit half-precision format.
+For more about the evolution of SoftFloat releases, see
+SoftFloat-history.html
.
+
+
+
+The functional interface of SoftFloat Release 3 and later differs
+in many details from the releases that came before.
+For specifics of these differences, see section 9 below,
+Changes from SoftFloat Release 2.
+
+
+
+2. Limitations
+
+
+SoftFloat assumes the computer has an addressable byte size of 8 or
+16 bits.
+(Nearly all computers in use today have 8-bit bytes.)
+
+
+
+SoftFloat is written in C and is designed to work with other C code.
+The C compiler used must conform at a minimum to the 1989 ANSI standard for the
+C language (same as the 1990 ISO standard) and must in addition support basic
+arithmetic on 64-bit integers.
+Earlier releases of SoftFloat included implementations of 32-bit
+single-precision and 64-bit double-precision floating-point that
+did not require 64-bit integers, but this option is not supported
+starting with Release 3.
+Since 1999, ISO standards for C have mandated compiler support for
+64-bit integers.
+A compiler conforming to the 1999 C Standard or later is recommended but not
+strictly required.
+
+
+
+Most operations not required by the original 1985 version of the IEEE
+Floating-Point Standard but added in the 2008 version are not yet supported in
+SoftFloat Release 3e.
+
+
+
+3. Acknowledgments and License
+
+
+The SoftFloat package was written by me, John R. Hauser.
+Release 3 of SoftFloat was a completely new implementation
+supplanting earlier releases.
+The project to create Release 3 (now through 3e) was
+done in the employ of the University of California, Berkeley, within the
+Department of Electrical Engineering and Computer Sciences, first for the
+Parallel Computing Laboratory (Par Lab) and then for the ASPIRE Lab.
+The work was officially overseen by Prof. Krste Asanovic, with funding provided
+by these sources:
+
+
+
+
+
+
+Par Lab: |
+ |
+
+Microsoft (Award #024263), Intel (Award #024894), and U.C. Discovery
+(Award #DIG07-10227), with additional support from Par Lab affiliates Nokia,
+NVIDIA, Oracle, and Samsung.
+ |
+
+
+ASPIRE Lab: |
+ |
+
+DARPA PERFECT program (Award #HR0011-12-2-0016), with additional support from
+ASPIRE industrial sponsor Intel and ASPIRE affiliates Google, Nokia, NVIDIA,
+Oracle, and Samsung.
+ |
+
+
+
+
+
+
+The following applies to the whole of SoftFloat Release 3e as well
+as to each source file individually.
+
+
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 The Regents of the
+University of California.
+All rights reserved.
+
+
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+
+-
+
+Redistributions of source code must retain the above copyright notice, this
+list of conditions, and the following disclaimer.
+
+
+ -
+
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions, and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+
+ -
+
+Neither the name of the University nor the names of its contributors may be
+used to endorse or promote products derived from this software without specific
+prior written permission.
+
+
+
+
+
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS “AS IS”,
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.
+IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+
+4. Types and Functions
+
+
+The types and functions of SoftFloat are declared in header file
+softfloat.h
.
+
+
+4.1. Boolean and Integer Types
+
+
+Header file softfloat.h
depends on standard headers
+<stdbool.h>
and <stdint.h>
to define type
+bool
and several integer types.
+These standard headers have been part of the ISO C Standard Library since 1999.
+With any recent compiler, they are likely to be supported, even if the compiler
+does not claim complete conformance to the latest ISO C Standard.
+For older or nonstandard compilers, a port of SoftFloat may have substitutes
+for these headers.
+Header softfloat.h
depends only on the name bool
from
+<stdbool.h>
and on these type names from
+<stdint.h>
:
+
+
+uint16_t
+uint32_t
+uint64_t
+int32_t
+int64_t
+uint_fast8_t
+uint_fast32_t
+uint_fast64_t
+int_fast32_t
+int_fast64_t
+
+
+
+
+
+4.2. Floating-Point Types
+
+
+The softfloat.h
header defines five floating-point types:
+
+
+
+float16_t |
+16-bit half-precision binary format |
+
+
+float32_t |
+32-bit single-precision binary format |
+
+
+float64_t |
+64-bit double-precision binary format |
+
+
+extFloat80_t |
+80-bit double-extended-precision binary format (old Intel or
+Motorola format) |
+
+
+float128_t |
+128-bit quadruple-precision binary format |
+
+
+
+The non-extended types are each exactly the size specified:
+16 bits for float16_t
, 32 bits for
+float32_t
, 64 bits for float64_t
, and
+128 bits for float128_t
.
+Aside from these size requirements, the definitions of all these types may
+differ for different ports of SoftFloat to specific systems.
+A given port of SoftFloat may or may not define some of the floating-point
+types as aliases for the C standard types float
,
+double
, and long
double
.
+
+
+
+Header file softfloat.h
also defines a structure,
+struct
extFloat80M
, for the representation of
+80-bit double-extended-precision floating-point values in memory.
+This structure is the same size as type extFloat80_t
and contains
+at least these two fields (not necessarily in this order):
+
+
+uint16_t signExp;
+uint64_t signif;
+
+
+Field signExp
contains the sign and exponent of the floating-point
+value, with the sign in the most significant bit (bit 15) and the
+encoded exponent in the other 15 bits.
+Field signif
is the complete 64-bit significand of
+the floating-point value.
+(In the usual encoding for 80-bit extended floating-point, the
+leading 1 bit of normalized numbers is not implicit but is stored
+in the most significant bit of the significand.)
+
+
+4.3. Supported Floating-Point Functions
+
+
+SoftFloat implements these arithmetic operations for its floating-point types:
+
+-
+conversions between any two floating-point formats;
+
-
+for each floating-point format, conversions to and from signed and unsigned
+32-bit and 64-bit integers;
+
-
+for each format, the usual addition, subtraction, multiplication, division, and
+square root operations;
+
-
+for each format except
extFloat80_t
, the fused multiply-add
+operation defined by the IEEE Standard;
+ -
+for each format, the floating-point remainder operation defined by the IEEE
+Standard;
+
-
+for each format, a “round to integer” operation that rounds to the
+nearest integer value in the same format; and
+
-
+comparisons between two values in the same floating-point format.
+
+
+
+
+The following operations required by the 2008 IEEE Floating-Point Standard are
+not supported in SoftFloat Release 3e:
+
+-
+nextUp, nextDown, minNum, maxNum, minNumMag,
+maxNumMag, scaleB, and logB;
+
-
+conversions between floating-point formats and decimal or hexadecimal character
+sequences;
+
-
+all “quiet-computation” operations (copy, negate,
+abs, and copySign, which all involve only simple copying and/or
+manipulation of the floating-point sign bit); and
+
-
+all “non-computational” operations other than isSignaling
+(which is supported).
+
+
+
+4.4. Non-canonical Representations in extFloat80_t
+
+
+Because the 80-bit double-extended-precision format,
+extFloat80_t
, stores an explicit leading significand bit, many
+finite floating-point numbers are encodable in this type in multiple equivalent
+forms.
+Of these multiple encodings, there is always a unique one with the least
+encoded exponent value, and this encoding is considered the canonical
+representation of the floating-point number.
+Any other equivalent representations (having a higher encoded exponent value)
+are non-canonical.
+For a value in the subnormal range (including zero), the canonical
+representation always has an encoded exponent of zero and a leading significand
+bit of 0.
+For finite values outside the subnormal range, the canonical representation
+always has an encoded exponent that is nonzero and a leading significand bit
+of 1.
+
+
+
+For an infinity or NaN, the leading significand bit is similarly expected to
+be 1.
+An infinity or NaN with a leading significand bit of 0 is again
+considered non-canonical.
+Hence, altogether, to be canonical, a value of type extFloat80_t
+must have a leading significand bit of 1, unless the value is
+subnormal or zero, in which case the leading significand bit and the encoded
+exponent must both be zero.
+
+
+
+SoftFloat’s functions are not guaranteed to operate as expected when
+inputs of type extFloat80_t
are non-canonical.
+Assuming all of a function’s extFloat80_t
inputs (if any)
+are canonical, function outputs of type extFloat80_t
will always
+be canonical.
+
+
+4.5. Conventions for Passing Arguments and Results
+
+
+Values that are at most 64 bits in size (i.e., not the
+80-bit or 128-bit floating-point formats) are in all
+cases passed as function arguments by value.
+Likewise, when an output of a function is no more than 64 bits, it
+is always returned directly as the function result.
+Thus, for example, the SoftFloat function for adding two 64-bit
+floating-point values has this simple signature:
+
+float64_t f64_add( float64_t, float64_t );
+
+
+
+
+The story is more complex when function inputs and outputs are
+80-bit and 128-bit floating-point.
+For these types, SoftFloat always provides a function that passes these larger
+values into or out of the function indirectly, via pointers.
+For example, for adding two 128-bit floating-point values,
+SoftFloat supplies this function:
+
+void f128M_add( const float128_t *, const float128_t *, float128_t * );
+
+The first two arguments point to the values to be added, and the last argument
+points to the location where the sum will be stored.
+The M
in the name f128M_add
is mnemonic for the fact
+that the 128-bit inputs and outputs are “in memory”,
+pointed to by pointer arguments.
+
+
+
+All ports of SoftFloat implement these pass-by-pointer functions for
+types extFloat80_t
and float128_t
.
+At the same time, SoftFloat ports may also implement alternate versions of
+these same functions that pass extFloat80_t
and
+float128_t
by value, like the smaller formats.
+Thus, besides the function with name f128M_add
shown above, a
+SoftFloat port may also supply an equivalent function with this signature:
+
+float128_t f128_add( float128_t, float128_t );
+
+
+
+
+As a general rule, on computers where the machine word size is
+32 bits or smaller, only the pass-by-pointer versions of functions
+(e.g., f128M_add
) are provided for types extFloat80_t
+and float128_t
, because passing such large types directly can have
+significant extra cost.
+On computers where the word size is 64 bits or larger, both
+function versions (f128M_add
and f128_add
) are
+provided, because the cost of passing by value is then more reasonable.
+Applications that must be portable accross both classes of computers must use
+the pointer-based functions, as these are always implemented.
+However, if it is known that SoftFloat includes the by-value functions for all
+platforms of interest, programmers can use whichever version they prefer.
+
+
+
+5. Reserved Names
+
+
+In addition to the variables and functions documented here, SoftFloat defines
+some symbol names for its own private use.
+These private names always begin with the prefix
+‘softfloat_
’.
+When a program includes header softfloat.h
or links with the
+SoftFloat library, all names with prefix ‘softfloat_
’
+are reserved for possible use by SoftFloat.
+Applications that use SoftFloat should not define their own names with this
+prefix, and should reference only such names as are documented.
+
+
+
+6. Mode Variables
+
+
+The following global variables control rounding mode, underflow detection, and
+the 80-bit extended format’s rounding precision:
+
+softfloat_roundingMode
+softfloat_detectTininess
+extF80_roundingPrecision
+
+These mode variables are covered in the next several subsections.
+For some SoftFloat ports, these variables may be per-thread (declared
+thread_local
), meaning that different execution threads have their
+own separate copies of the variables.
+
+
+6.1. Rounding Mode
+
+
+All five rounding modes defined by the 2008 IEEE Floating-Point Standard are
+implemented for all operations that require rounding.
+Some ports of SoftFloat may also implement the round-to-odd mode.
+
+
+
+The rounding mode is selected by the global variable
+
+uint_fast8_t softfloat_roundingMode;
+
+This variable may be set to one of the values
+
+
+
+softfloat_round_near_even |
+round to nearest, with ties to even |
+
+
+softfloat_round_near_maxMag |
+round to nearest, with ties to maximum magnitude (away from zero) |
+
+
+softfloat_round_minMag |
+round to minimum magnitude (toward zero) |
+
+
+softfloat_round_min |
+round to minimum (down) |
+
+
+softfloat_round_max |
+round to maximum (up) |
+
+
+softfloat_round_odd |
+round to odd (jamming), if supported by the SoftFloat port |
+
+
+
+Variable softfloat_roundingMode
is initialized to
+softfloat_round_near_even
.
+
+
+
+When softfloat_round_odd
is the rounding mode for a function that
+rounds to an integer value (either conversion to an integer format or a
+‘roundToInt
’ function), if the input is not already an
+integer, the rounded result is the closest odd integer.
+For other operations, this rounding mode acts as though the floating-point
+result is first rounded to minimum magnitude, the same as
+softfloat_round_minMag
, and then, if the result is inexact, the
+least-significant bit of the result is set to 1.
+Rounding to odd is also known as jamming.
+
+
+6.2. Underflow Detection
+
+
+In the terminology of the IEEE Standard, SoftFloat can detect tininess for
+underflow either before or after rounding.
+The choice is made by the global variable
+
+uint_fast8_t softfloat_detectTininess;
+
+which can be set to either
+
+softfloat_tininess_beforeRounding
+softfloat_tininess_afterRounding
+
+Detecting tininess after rounding is usually better because it results in fewer
+spurious underflow signals.
+The other option is provided for compatibility with some systems.
+Like most systems (and as required by the newer 2008 IEEE Standard), SoftFloat
+always detects loss of accuracy for underflow as an inexact result.
+
+
+6.3. Rounding Precision for the 80-Bit Extended Format
+
+
+For extFloat80_t
only, the rounding precision of the basic
+arithmetic operations is controlled by the global variable
+
+uint_fast8_t extF80_roundingPrecision;
+
+The operations affected are:
+
+extF80_add
+extF80_sub
+extF80_mul
+extF80_div
+extF80_sqrt
+
+When extF80_roundingPrecision
is set to its default value of 80,
+these operations are rounded to the full precision of the 80-bit
+double-extended-precision format, like occurs for other formats.
+Setting extF80_roundingPrecision
to 32 or to 64 causes the
+operations listed to be rounded to 32-bit precision (equivalent to
+float32_t
) or to 64-bit precision (equivalent to
+float64_t
), respectively.
+When rounding to reduced precision, additional bits in the result significand
+beyond the rounding point are set to zero.
+The consequences of setting extF80_roundingPrecision
to a value
+other than 32, 64, or 80 is not specified.
+Operations other than the ones listed above are not affected by
+extF80_roundingPrecision
.
+
+
+
+7. Exceptions and Exception Flags
+
+
+All five exception flags required by the IEEE Floating-Point Standard are
+implemented.
+Each flag is stored as a separate bit in the global variable
+
+uint_fast8_t softfloat_exceptionFlags;
+
+The positions of the exception flag bits within this variable are determined by
+the bit masks
+
+softfloat_flag_inexact
+softfloat_flag_underflow
+softfloat_flag_overflow
+softfloat_flag_infinite
+softfloat_flag_invalid
+
+Variable softfloat_exceptionFlags
is initialized to all zeros,
+meaning no exceptions.
+
+
+
+For some SoftFloat ports, softfloat_exceptionFlags
may be
+per-thread (declared thread_local
), meaning that different
+execution threads have their own separate instances of it.
+
+
+
+An individual exception flag can be cleared with the statement
+
+softfloat_exceptionFlags &= ~softfloat_flag_<exception>;
+
+where <exception>
is the appropriate name.
+To raise a floating-point exception, function softfloat_raiseFlags
+should normally be used.
+
+
+
+When SoftFloat detects an exception other than inexact, it calls
+softfloat_raiseFlags
.
+The default version of this function simply raises the corresponding exception
+flags.
+Particular ports of SoftFloat may support alternate behavior, such as exception
+traps, by modifying the default softfloat_raiseFlags
.
+A program may also supply its own softfloat_raiseFlags
function to
+override the one from the SoftFloat library.
+
+
+
+Because inexact results occur frequently under most circumstances (and thus are
+hardly exceptional), SoftFloat does not ordinarily call
+softfloat_raiseFlags
for inexact exceptions.
+It does always raise the inexact exception flag as required.
+
+
+
+8. Function Details
+
+
+In this section, <float>
appears in function names as
+a substitute for one of these abbreviations:
+
+
+
+f16 |
+indicates float16_t , passed by value |
+
+
+f32 |
+indicates float32_t , passed by value |
+
+
+f64 |
+indicates float64_t , passed by value |
+
+
+extF80M |
+indicates extFloat80_t , passed indirectly via pointers |
+
+
+extF80 |
+indicates extFloat80_t , passed by value |
+
+
+f128M |
+indicates float128_t , passed indirectly via pointers |
+
+
+f128 |
+indicates float128_t , passed by value |
+
+
+
+The circumstances under which values of floating-point types
+extFloat80_t
and float128_t
may be passed either by
+value or indirectly via pointers was discussed earlier in
+section 4.5, Conventions for Passing Arguments and Results.
+
+
+8.1. Conversions from Integer to Floating-Point
+
+
+All conversions from a 32-bit or 64-bit integer,
+signed or unsigned, to a floating-point format are supported.
+Functions performing these conversions have these names:
+
+ui32_to_<float>
+ui64_to_<float>
+i32_to_<float>
+i64_to_<float>
+
+Conversions from 32-bit integers to 64-bit
+double-precision and larger formats are always exact, and likewise conversions
+from 64-bit integers to 80-bit
+double-extended-precision and 128-bit quadruple-precision are also
+always exact.
+
+
+
+Each conversion function takes one input of the appropriate type and generates
+one output.
+The following illustrates the signatures of these functions in cases when the
+floating-point result is passed either by value or via pointers:
+
+
+float64_t i32_to_f64( int32_t a );
+
+
+void i32_to_f128M( int32_t a, float128_t *destPtr );
+
+
+
+
+8.2. Conversions from Floating-Point to Integer
+
+
+Conversions from a floating-point format to a 32-bit or
+64-bit integer, signed or unsigned, are supported with these
+functions:
+
+<float>_to_ui32
+<float>_to_ui64
+<float>_to_i32
+<float>_to_i64
+
+The functions have signatures as follows, depending on whether the
+floating-point input is passed by value or via pointers:
+
+
+int_fast32_t f64_to_i32( float64_t a, uint_fast8_t roundingMode, bool exact );
+
+
+int_fast32_t
+ f128M_to_i32( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact );
+
+
+
+
+
+The roundingMode
argument specifies the rounding mode for
+the conversion.
+The variable that usually indicates rounding mode,
+softfloat_roundingMode
, is ignored.
+Argument exact
determines whether the inexact
+exception flag is raised if the conversion is not exact.
+If exact
is true
, the inexact flag may
+be raised;
+otherwise, it will not be, even if the conversion is inexact.
+
+
+
+A conversion from floating-point to integer format raises the invalid
+exception if the source value cannot be rounded to a representable integer of
+the desired size (32 or 64 bits).
+In such circumstances, the integer result returned is determined by the
+particular port of SoftFloat, although typically this value will be either the
+maximum or minimum value of the integer format.
+The functions that convert to integer types never raise the floating-point
+overflow exception.
+
+
+
+Because languages such as C require that conversions to integers
+be rounded toward zero, the following functions are provided for improved speed
+and convenience:
+
+<float>_to_ui32_r_minMag
+<float>_to_ui64_r_minMag
+<float>_to_i32_r_minMag
+<float>_to_i64_r_minMag
+
+These functions round only toward zero (to minimum magnitude).
+The signatures for these functions are the same as above without the redundant
+roundingMode
argument:
+
+
+int_fast32_t f64_to_i32_r_minMag( float64_t a, bool exact );
+
+
+int_fast32_t f128M_to_i32_r_minMag( const float128_t *aPtr, bool exact );
+
+
+
+
+8.3. Conversions Among Floating-Point Types
+
+
+Conversions between floating-point formats are done by functions with these
+names:
+
+<float>_to_<float>
+
+All combinations of source and result type are supported where the source and
+result are different formats.
+There are four different styles of signature for these functions, depending on
+whether the input and the output floating-point values are passed by value or
+via pointers:
+
+
+float32_t f64_to_f32( float64_t a );
+
+
+float32_t f128M_to_f32( const float128_t *aPtr );
+
+
+void f32_to_f128M( float32_t a, float128_t *destPtr );
+
+
+void extF80M_to_f128M( const extFloat80_t *aPtr, float128_t *destPtr );
+
+
+
+
+
+Conversions from a smaller to a larger floating-point format are always exact
+and so require no rounding.
+
+
+8.4. Basic Arithmetic Functions
+
+
+The following basic arithmetic functions are provided:
+
+<float>_add
+<float>_sub
+<float>_mul
+<float>_div
+<float>_sqrt
+
+Each floating-point operation takes two operands, except for sqrt
+(square root) which takes only one.
+The operands and result are all of the same floating-point format.
+Signatures for these functions take the following forms:
+
+
+float64_t f64_add( float64_t a, float64_t b );
+
+
+void
+ f128M_add(
+ const float128_t *aPtr, const float128_t *bPtr, float128_t *destPtr );
+
+
+float64_t f64_sqrt( float64_t a );
+
+
+void f128M_sqrt( const float128_t *aPtr, float128_t *destPtr );
+
+
+When floating-point values are passed indirectly through pointers, arguments
+aPtr
and bPtr
point to the input
+operands, and the last argument, destPtr
, points to the
+location where the result is stored.
+
+
+
+Rounding of the 80-bit double-extended-precision
+(extFloat80_t
) functions is affected by variable
+extF80_roundingPrecision
, as explained earlier in
+section 6.3,
+Rounding Precision for the 80-Bit Extended Format.
+
+
+8.5. Fused Multiply-Add Functions
+
+
+The 2008 version of the IEEE Floating-Point Standard defines a fused
+multiply-add operation that does a combined multiplication and addition
+with only a single rounding.
+SoftFloat implements fused multiply-add with functions
+
+<float>_mulAdd
+
+Unlike other operations, fused multiple-add is not supported for the
+80-bit double-extended-precision format,
+extFloat80_t
.
+
+
+
+Depending on whether floating-point values are passed by value or via pointers,
+the fused multiply-add functions have signatures of these forms:
+
+
+float64_t f64_mulAdd( float64_t a, float64_t b, float64_t c );
+
+
+void
+ f128M_mulAdd(
+ const float128_t *aPtr,
+ const float128_t *bPtr,
+ const float128_t *cPtr,
+ float128_t *destPtr
+ );
+
+
+The functions compute
+(a
× b
)
+ + c
+with a single rounding.
+When floating-point values are passed indirectly through pointers, arguments
+aPtr
, bPtr
, and
+cPtr
point to operands a
,
+b
, and c
respectively, and
+destPtr
points to the location where the result is stored.
+
+
+
+If one of the multiplication operands a
and
+b
is infinite and the other is zero, these functions raise
+the invalid exception even if operand c
is a quiet NaN.
+
+
+8.6. Remainder Functions
+
+
+For each format, SoftFloat implements the remainder operation defined by the
+IEEE Floating-Point Standard.
+The remainder functions have names
+
+<float>_rem
+
+Each remainder operation takes two floating-point operands of the same format
+and returns a result in the same format.
+Depending on whether floating-point values are passed by value or via pointers,
+the remainder functions have signatures of these forms:
+
+
+float64_t f64_rem( float64_t a, float64_t b );
+
+
+void
+ f128M_rem(
+ const float128_t *aPtr, const float128_t *bPtr, float128_t *destPtr );
+
+
+When floating-point values are passed indirectly through pointers, arguments
+aPtr
and bPtr
point to operands
+a
and b
respectively, and
+destPtr
points to the location where the result is stored.
+
+
+
+The IEEE Standard remainder operation computes the value
+a
+ − n × b
,
+where n is the integer closest to
+a
÷ b
.
+If a
÷ b
is exactly
+halfway between two integers, n is the even integer closest to
+a
÷ b
.
+The IEEE Standard’s remainder operation is always exact and so requires
+no rounding.
+
+
+
+Depending on the relative magnitudes of the operands, the remainder
+functions can take considerably longer to execute than the other SoftFloat
+functions.
+This is an inherent characteristic of the remainder operation itself and is not
+a flaw in the SoftFloat implementation.
+
+
+8.7. Round-to-Integer Functions
+
+
+For each format, SoftFloat implements the round-to-integer operation specified
+by the IEEE Floating-Point Standard.
+These functions are named
+
+<float>_roundToInt
+
+Each round-to-integer operation takes a single floating-point operand.
+This operand is rounded to an integer according to a specified rounding mode,
+and the resulting integer value is returned in the same floating-point format.
+(Note that the result is not an integer type.)
+
+
+
+The signatures of the round-to-integer functions are similar to those for
+conversions to an integer type:
+
+
+float64_t f64_roundToInt( float64_t a, uint_fast8_t roundingMode, bool exact );
+
+
+void
+ f128M_roundToInt(
+ const float128_t *aPtr,
+ uint_fast8_t roundingMode,
+ bool exact,
+ float128_t *destPtr
+ );
+
+
+When floating-point values are passed indirectly through pointers,
+aPtr
points to the input operand and
+destPtr
points to the location where the result is stored.
+
+
+
+The roundingMode
argument specifies the rounding mode to
+apply.
+The variable that usually indicates rounding mode,
+softfloat_roundingMode
, is ignored.
+Argument exact
determines whether the inexact
+exception flag is raised if the conversion is not exact.
+If exact
is true
, the inexact flag may
+be raised;
+otherwise, it will not be, even if the conversion is inexact.
+
+
+8.8. Comparison Functions
+
+
+For each format, the following floating-point comparison functions are
+provided:
+
+<float>_eq
+<float>_le
+<float>_lt
+
+Each comparison takes two operands of the same type and returns a Boolean.
+The abbreviation eq
stands for “equal” (=);
+le
stands for “less than or equal” (≤);
+and lt
stands for “less than” (<).
+Depending on whether the floating-point operands are passed by value or via
+pointers, the comparison functions have signatures of these forms:
+
+
+bool f64_eq( float64_t a, float64_t b );
+
+
+bool f128M_eq( const float128_t *aPtr, const float128_t *bPtr );
+
+
+
+
+
+The usual greater-than (>), greater-than-or-equal (≥), and not-equal
+(≠) comparisons are easily obtained from the functions provided.
+The not-equal function is just the logical complement of the equal function.
+The greater-than-or-equal function is identical to the less-than-or-equal
+function with the arguments in reverse order, and likewise the greater-than
+function is identical to the less-than function with the arguments reversed.
+
+
+
+The IEEE Floating-Point Standard specifies that the less-than-or-equal and
+less-than comparisons by default raise the invalid exception if either
+operand is any kind of NaN.
+Equality comparisons, on the other hand, are defined by default to raise the
+invalid exception only for signaling NaNs, not quiet NaNs.
+For completeness, SoftFloat provides these complementary functions:
+
+<float>_eq_signaling
+<float>_le_quiet
+<float>_lt_quiet
+
+The signaling
equality comparisons are identical to the default
+equality comparisons except that the invalid exception is raised for any
+NaN input, not just for signaling NaNs.
+Similarly, the quiet
comparison functions are identical to their
+default counterparts except that the invalid exception is not raised for
+quiet NaNs.
+
+
+8.9. Signaling NaN Test Functions
+
+
+Functions for testing whether a floating-point value is a signaling NaN are
+provided with these names:
+
+<float>_isSignalingNaN
+
+The functions take one floating-point operand and return a Boolean indicating
+whether the operand is a signaling NaN.
+Accordingly, the functions have the forms
+
+
+bool f64_isSignalingNaN( float64_t a );
+
+
+bool f128M_isSignalingNaN( const float128_t *aPtr );
+
+
+
+
+8.10. Raise-Exception Function
+
+
+SoftFloat provides a single function for raising floating-point exceptions:
+
+
+void softfloat_raiseFlags( uint_fast8_t exceptions );
+
+
+The exceptions
argument is a mask indicating the set of
+exceptions to raise.
+(See earlier section 7, Exceptions and Exception Flags.)
+In addition to setting the specified exception flags in variable
+softfloat_exceptionFlags
, the softfloat_raiseFlags
+function may cause a trap or abort appropriate for the current system.
+
+
+
+9. Changes from SoftFloat Release 2
+
+
+Apart from a change in the legal use license, Release 3 of
+SoftFloat introduced numerous technical differences compared to earlier
+releases.
+
+
+9.1. Name Changes
+
+
+The most obvious and pervasive difference compared to Release 2
+is that the names of most functions and variables have changed, even when the
+behavior has not.
+First, the floating-point types, the mode variables, the exception flags
+variable, the function to raise exceptions, and various associated constants
+have been renamed as follows:
+
+
+
+old name, Release 2: |
+new name, Release 3: |
+
+
+float32 |
+float32_t |
+
+
+float64 |
+float64_t |
+
+
+floatx80 |
+extFloat80_t |
+
+
+float128 |
+float128_t |
+
+
+float_rounding_mode |
+softfloat_roundingMode |
+
+
+float_round_nearest_even |
+softfloat_round_near_even |
+
+
+float_round_to_zero |
+softfloat_round_minMag |
+
+
+float_round_down |
+softfloat_round_min |
+
+
+float_round_up |
+softfloat_round_max |
+
+
+float_detect_tininess |
+softfloat_detectTininess |
+
+
+float_tininess_before_rounding |
+softfloat_tininess_beforeRounding |
+
+
+float_tininess_after_rounding |
+softfloat_tininess_afterRounding |
+
+
+floatx80_rounding_precision |
+extF80_roundingPrecision |
+
+
+float_exception_flags |
+softfloat_exceptionFlags |
+
+
+float_flag_inexact |
+softfloat_flag_inexact |
+
+
+float_flag_underflow |
+softfloat_flag_underflow |
+
+
+float_flag_overflow |
+softfloat_flag_overflow |
+
+
+float_flag_divbyzero |
+softfloat_flag_infinite |
+
+
+float_flag_invalid |
+softfloat_flag_invalid |
+
+
+float_raise |
+softfloat_raiseFlags |
+
+
+
+
+
+
+Furthermore, Release 3 adopted the following new abbreviations for
+function names:
+
+
+
+used in names in Release 2: |
+used in names in Release 3: |
+
+ int32 | i32 |
+ int64 | i64 |
+ float32 | f32 |
+ float64 | f64 |
+ floatx80 | extF80 |
+ float128 | f128 |
+
+
+Thus, for example, the function to add two 32-bit floating-point
+numbers, previously called float32_add
in Release 2,
+is now f32_add
.
+Lastly, there have been a few other changes to function names:
+
+
+
+used in names in Release 2: |
+used in names in Release 3: |
+relevant functions: |
+
+
+_round_to_zero |
+_r_minMag |
+conversions from floating-point to integer (section 8.2) |
+
+
+round_to_int |
+roundToInt |
+round-to-integer functions (section 8.7) |
+
+
+is_signaling_nan |
+isSignalingNaN |
+signaling NaN test functions (section 8.9) |
+
+
+
+
+
+9.2. Changes to Function Arguments
+
+
+Besides simple name changes, some operations were given a different interface
+in Release 3 than they had in Release 2:
+
+
+-
+
+Since Release 3, integer arguments and results of functions have
+standard types from header <stdint.h>
, such as
+uint32_t
, whereas previously their types could be defined
+differently for each port of SoftFloat, usually using traditional C types such
+as unsigned
int
.
+Likewise, functions in Release 3 and later pass Booleans as
+standard type bool
from <stdbool.h>
, whereas
+previously these were again passed as a port-specific type (usually
+int
).
+
+
+ -
+
+As explained earlier in section 4.5, Conventions for Passing
+Arguments and Results, SoftFloat functions in Release 3 and
+later may pass 80-bit and 128-bit floating-point
+values through pointers, meaning that functions take pointer arguments and then
+read or write floating-point values at the locations indicated by the pointers.
+In Release 2, floating-point arguments and results were always
+passed by value, regardless of their size.
+
+
+ -
+
+Functions that round to an integer have additional
+roundingMode
and exact
arguments that
+they did not have in Release 2.
+Refer to sections 8.2 and 8.7 for descriptions of these functions
+since Release 3.
+For Release 2, the rounding mode, when needed, was taken from the
+same global variable that affects the basic arithmetic operations (now called
+softfloat_roundingMode
but previously known as
+float_rounding_mode
).
+Also, for Release 2, if the original floating-point input was not
+an exact integer value, and if the invalid exception was not raised by
+the function, the inexact exception was always raised.
+Release 2 had no option to suppress raising inexact in this
+case.
+Applications using SoftFloat Release 3 or later can get the same
+effect as Release 2 by passing variable
+softfloat_roundingMode
for argument
+roundingMode
and true
for argument
+exact
.
+
+
+
+
+
+9.3. Added Capabilities
+
+
+With Release 3, some new features have been added that were not
+present in Release 2:
+
+
+-
+
+A port of SoftFloat can now define any of the floating-point types
+float32_t
, float64_t
, extFloat80_t
, and
+float128_t
as aliases for C’s standard floating-point types
+float
, double
, and long
+double
, using either #define
or typedef
.
+This potential convenience was not supported under Release 2.
+
+
+
+(Note, however, that there may be a performance cost to defining
+SoftFloat’s floating-point types this way, depending on the platform and
+the applications using SoftFloat.
+Ports of SoftFloat may choose to forgo the convenience in favor of better
+speed.)
+
+
+
+
-
+As of Release 3b, 16-bit half-precision,
+
float16_t
, is supported.
+
+
+
+
-
+Functions have been added for converting between the floating-point types and
+unsigned integers.
+Release 2 supported only signed integers, not unsigned.
+
+
+
+
-
+Fused multiply-add functions have been added for all floating-point formats
+except 80-bit double-extended-precision,
+
extFloat80_t
.
+
+
+
+
-
+New rounding modes are supported:
+
softfloat_round_near_maxMag
(round to nearest, with ties to
+maximum magnitude, away from zero), and, as of Release 3c,
+optional softfloat_round_odd
(round to odd, also known as
+jamming).
+
+
+
+
+
+9.4. Better Compatibility with the C Language
+
+
+Release 3 of SoftFloat was written to conform better to the ISO C
+Standard’s rules for portability.
+For example, older releases of SoftFloat employed type conversions in ways
+that, while commonly practiced, are not fully defined by the C Standard.
+Such problematic type conversions have generally been replaced by the use of
+unions, the behavior around which is more strictly regulated these days.
+
+
+9.5. New Organization as a Library
+
+
+Starting with Release 3, SoftFloat now builds as a library.
+Previously, SoftFloat compiled into a single, monolithic object file containing
+all the SoftFloat functions, with the consequence that a program linking with
+SoftFloat would get every SoftFloat function in its binary file even if only a
+few functions were actually used.
+With SoftFloat in the form of a library, a program that is linked by a standard
+linker will include only those functions of SoftFloat that it needs and no
+others.
+
+
+9.6. Optimization Gains (and Losses)
+
+
+Individual SoftFloat functions have been variously improved in
+Release 3 compared to earlier releases.
+In particular, better, faster algorithms have been deployed for the operations
+of division, square root, and remainder.
+For functions operating on the larger 80-bit and
+128-bit formats, extFloat80_t
and
+float128_t
, code size has also generally been reduced.
+
+
+
+However, because Release 2 compiled all of SoftFloat together as a
+single object file, compilers could make optimizations across function calls
+when one SoftFloat function calls another.
+Now that the functions of SoftFloat are compiled separately and only afterward
+linked together into a program, there is not usually the same opportunity to
+optimize across function calls.
+Some loss of speed has been observed due to this change.
+
+
+
+10. Future Directions
+
+
+The following improvements are anticipated for future releases of SoftFloat:
+
+-
+more functions from the 2008 version of the IEEE Floating-Point Standard;
+
-
+consistent, defined behavior for non-canonical representations of extended
+format
extFloat80_t
(discussed in section 4.4,
+Non-canonical Representations in extFloat80_t
).
+
+
+
+
+
+11. Contact Information
+
+
+At the time of this writing, the most up-to-date information about SoftFloat
+and the latest release can be found at the Web page
+http://www.jhauser.us/arithmetic/SoftFloat.html
.
+
+
+
+
+
diff --git a/test/float/softfloat/source/8086-SSE/extF80M_isSignalingNaN.c b/test/float/softfloat/source/8086-SSE/extF80M_isSignalingNaN.c
new file mode 100644
index 000000000..c2cca65c9
--- /dev/null
+++ b/test/float/softfloat/source/8086-SSE/extF80M_isSignalingNaN.c
@@ -0,0 +1,57 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+bool extF80M_isSignalingNaN( const extFloat80_t *aPtr )
+{
+ const struct extFloat80M *aSPtr;
+ uint64_t uiA0;
+
+ aSPtr = (const struct extFloat80M *) aPtr;
+ if ( (aSPtr->signExp & 0x7FFF) != 0x7FFF ) return false;
+ uiA0 = aSPtr->signif;
+ return
+ ! (uiA0 & UINT64_C( 0x4000000000000000 ))
+ && (uiA0 & UINT64_C( 0x3FFFFFFFFFFFFFFF));
+
+}
+
diff --git a/test/float/softfloat/source/8086-SSE/f128M_isSignalingNaN.c b/test/float/softfloat/source/8086-SSE/f128M_isSignalingNaN.c
new file mode 100644
index 000000000..9ff83d726
--- /dev/null
+++ b/test/float/softfloat/source/8086-SSE/f128M_isSignalingNaN.c
@@ -0,0 +1,60 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "primitives.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+bool f128M_isSignalingNaN( const float128_t *aPtr )
+{
+ const uint32_t *aWPtr;
+ uint32_t uiA96;
+
+ aWPtr = (const uint32_t *) aPtr;
+ uiA96 = aWPtr[indexWordHi( 4 )];
+ if ( (uiA96 & 0x7FFF8000) != 0x7FFF0000 ) return false;
+ return
+ ((uiA96 & 0x00007FFF) != 0)
+ || ((aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
+ | aWPtr[indexWord( 4, 0 )])
+ != 0);
+
+}
+
diff --git a/test/float/softfloat/source/8086-SSE/s_commonNaNToExtF80M.c b/test/float/softfloat/source/8086-SSE/s_commonNaNToExtF80M.c
new file mode 100644
index 000000000..06302aa15
--- /dev/null
+++ b/test/float/softfloat/source/8086-SSE/s_commonNaNToExtF80M.c
@@ -0,0 +1,56 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by `aPtr' into an 80-bit extended
+| floating-point NaN, and stores this NaN at the location pointed to by
+| `zSPtr'.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_commonNaNToExtF80M(
+ const struct commonNaN *aPtr, struct extFloat80M *zSPtr )
+{
+
+ zSPtr->signExp = packToExtF80UI64( aPtr->sign, 0x7FFF );
+ zSPtr->signif = UINT64_C( 0xC000000000000000 ) | aPtr->v64>>1;
+
+}
+
diff --git a/test/float/softfloat/source/8086-SSE/s_commonNaNToExtF80UI.c b/test/float/softfloat/source/8086-SSE/s_commonNaNToExtF80UI.c
new file mode 100644
index 000000000..7325468ff
--- /dev/null
+++ b/test/float/softfloat/source/8086-SSE/s_commonNaNToExtF80UI.c
@@ -0,0 +1,56 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "primitives.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by `aPtr' into an 80-bit extended
+| floating-point NaN, and returns the bit pattern of this value as an unsigned
+| integer.
+*----------------------------------------------------------------------------*/
+struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr )
+{
+ struct uint128 uiZ;
+
+ uiZ.v64 = (uint_fast16_t) aPtr->sign<<15 | 0x7FFF;
+ uiZ.v0 = UINT64_C( 0xC000000000000000 ) | aPtr->v64>>1;
+ return uiZ;
+
+}
+
diff --git a/test/float/softfloat/source/8086-SSE/s_commonNaNToF128M.c b/test/float/softfloat/source/8086-SSE/s_commonNaNToF128M.c
new file mode 100644
index 000000000..e2940bb77
--- /dev/null
+++ b/test/float/softfloat/source/8086-SSE/s_commonNaNToF128M.c
@@ -0,0 +1,56 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "primitives.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by `aPtr' into a 128-bit floating-point
+| NaN, and stores this NaN at the location pointed to by `zWPtr'. Argument
+| `zWPtr' points to an array of four 32-bit elements that concatenate in the
+| platform's normal endian order to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr )
+{
+
+ softfloat_shortShiftRight128M( (const uint32_t *) &aPtr->v0, 16, zWPtr );
+ zWPtr[indexWordHi( 4 )] |= (uint32_t) aPtr->sign<<31 | 0x7FFF8000;
+
+}
+
diff --git a/test/float/softfloat/source/8086-SSE/s_commonNaNToF128UI.c b/test/float/softfloat/source/8086-SSE/s_commonNaNToF128UI.c
new file mode 100644
index 000000000..ac8ea7b70
--- /dev/null
+++ b/test/float/softfloat/source/8086-SSE/s_commonNaNToF128UI.c
@@ -0,0 +1,55 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "primitives.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by `aPtr' into a 128-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN *aPtr )
+{
+ struct uint128 uiZ;
+
+ uiZ = softfloat_shortShiftRight128( aPtr->v64, aPtr->v0, 16 );
+ uiZ.v64 |= (uint_fast64_t) aPtr->sign<<63 | UINT64_C( 0x7FFF800000000000 );
+ return uiZ;
+
+}
+
diff --git a/test/float/softfloat/source/8086-SSE/s_commonNaNToF16UI.c b/test/float/softfloat/source/8086-SSE/s_commonNaNToF16UI.c
new file mode 100644
index 000000000..07679d717
--- /dev/null
+++ b/test/float/softfloat/source/8086-SSE/s_commonNaNToF16UI.c
@@ -0,0 +1,51 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by `aPtr' into a 16-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr )
+{
+
+ return (uint_fast16_t) aPtr->sign<<15 | 0x7E00 | aPtr->v64>>54;
+
+}
+
diff --git a/test/float/softfloat/source/8086-SSE/s_commonNaNToF32UI.c b/test/float/softfloat/source/8086-SSE/s_commonNaNToF32UI.c
new file mode 100644
index 000000000..982c1edf6
--- /dev/null
+++ b/test/float/softfloat/source/8086-SSE/s_commonNaNToF32UI.c
@@ -0,0 +1,51 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by `aPtr' into a 32-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr )
+{
+
+ return (uint_fast32_t) aPtr->sign<<31 | 0x7FC00000 | aPtr->v64>>41;
+
+}
+
diff --git a/test/float/softfloat/source/8086-SSE/s_commonNaNToF64UI.c b/test/float/softfloat/source/8086-SSE/s_commonNaNToF64UI.c
new file mode 100644
index 000000000..d88c68ade
--- /dev/null
+++ b/test/float/softfloat/source/8086-SSE/s_commonNaNToF64UI.c
@@ -0,0 +1,53 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by `aPtr' into a 64-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr )
+{
+
+ return
+ (uint_fast64_t) aPtr->sign<<63 | UINT64_C( 0x7FF8000000000000 )
+ | aPtr->v64>>12;
+
+}
+
diff --git a/test/float/softfloat/source/8086-SSE/s_extF80MToCommonNaN.c b/test/float/softfloat/source/8086-SSE/s_extF80MToCommonNaN.c
new file mode 100644
index 000000000..6bf45cf86
--- /dev/null
+++ b/test/float/softfloat/source/8086-SSE/s_extF80MToCommonNaN.c
@@ -0,0 +1,62 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming the 80-bit extended floating-point value pointed to by `aSPtr' is
+| a NaN, converts this NaN to the common NaN form, and stores the resulting
+| common NaN at the location pointed to by `zPtr'. If the NaN is a signaling
+| NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_extF80MToCommonNaN(
+ const struct extFloat80M *aSPtr, struct commonNaN *zPtr )
+{
+
+ if ( extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ }
+ zPtr->sign = signExtF80UI64( aSPtr->signExp );
+ zPtr->v64 = aSPtr->signif<<1;
+ zPtr->v0 = 0;
+
+}
+
diff --git a/test/float/softfloat/source/8086-SSE/s_extF80UIToCommonNaN.c b/test/float/softfloat/source/8086-SSE/s_extF80UIToCommonNaN.c
new file mode 100644
index 000000000..8b8c92780
--- /dev/null
+++ b/test/float/softfloat/source/8086-SSE/s_extF80UIToCommonNaN.c
@@ -0,0 +1,62 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming the unsigned integer formed from concatenating `uiA64' and `uiA0'
+| has the bit pattern of an 80-bit extended floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_extF80UIToCommonNaN(
+ uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
+{
+
+ if ( softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ }
+ zPtr->sign = uiA64>>15;
+ zPtr->v64 = uiA0<<1;
+ zPtr->v0 = 0;
+
+}
+
diff --git a/test/float/softfloat/source/8086-SSE/s_f128MToCommonNaN.c b/test/float/softfloat/source/8086-SSE/s_f128MToCommonNaN.c
new file mode 100644
index 000000000..22152145a
--- /dev/null
+++ b/test/float/softfloat/source/8086-SSE/s_f128MToCommonNaN.c
@@ -0,0 +1,62 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "primitives.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming the 128-bit floating-point value pointed to by `aWPtr' is a NaN,
+| converts this NaN to the common NaN form, and stores the resulting common
+| NaN at the location pointed to by `zPtr'. If the NaN is a signaling NaN,
+| the invalid exception is raised. Argument `aWPtr' points to an array of
+| four 32-bit elements that concatenate in the platform's normal endian order
+| to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr )
+{
+
+ if ( f128M_isSignalingNaN( (const float128_t *) aWPtr ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ }
+ zPtr->sign = aWPtr[indexWordHi( 4 )]>>31;
+ softfloat_shortShiftLeft128M( aWPtr, 16, (uint32_t *) &zPtr->v0 );
+
+}
+
diff --git a/test/float/softfloat/source/8086-SSE/s_f128UIToCommonNaN.c b/test/float/softfloat/source/8086-SSE/s_f128UIToCommonNaN.c
new file mode 100644
index 000000000..2510c0707
--- /dev/null
+++ b/test/float/softfloat/source/8086-SSE/s_f128UIToCommonNaN.c
@@ -0,0 +1,65 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "primitives.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming the unsigned integer formed from concatenating `uiA64' and `uiA0'
+| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to
+| the common NaN form, and stores the resulting common NaN at the location
+| pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid exception
+| is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_f128UIToCommonNaN(
+ uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
+{
+ struct uint128 NaNSig;
+
+ if ( softfloat_isSigNaNF128UI( uiA64, uiA0 ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ }
+ NaNSig = softfloat_shortShiftLeft128( uiA64, uiA0, 16 );
+ zPtr->sign = uiA64>>63;
+ zPtr->v64 = NaNSig.v64;
+ zPtr->v0 = NaNSig.v0;
+
+}
+
diff --git a/test/float/softfloat/source/8086-SSE/s_f16UIToCommonNaN.c b/test/float/softfloat/source/8086-SSE/s_f16UIToCommonNaN.c
new file mode 100644
index 000000000..4d5003f6a
--- /dev/null
+++ b/test/float/softfloat/source/8086-SSE/s_f16UIToCommonNaN.c
@@ -0,0 +1,59 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming `uiA' has the bit pattern of a 16-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr )
+{
+
+ if ( softfloat_isSigNaNF16UI( uiA ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ }
+ zPtr->sign = uiA>>15;
+ zPtr->v64 = (uint_fast64_t) uiA<<54;
+ zPtr->v0 = 0;
+
+}
+
diff --git a/test/float/softfloat/source/8086-SSE/s_f32UIToCommonNaN.c b/test/float/softfloat/source/8086-SSE/s_f32UIToCommonNaN.c
new file mode 100644
index 000000000..f4734db7a
--- /dev/null
+++ b/test/float/softfloat/source/8086-SSE/s_f32UIToCommonNaN.c
@@ -0,0 +1,59 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming `uiA' has the bit pattern of a 32-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr )
+{
+
+ if ( softfloat_isSigNaNF32UI( uiA ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ }
+ zPtr->sign = uiA>>31;
+ zPtr->v64 = (uint_fast64_t) uiA<<41;
+ zPtr->v0 = 0;
+
+}
+
diff --git a/test/float/softfloat/source/8086-SSE/s_f64UIToCommonNaN.c b/test/float/softfloat/source/8086-SSE/s_f64UIToCommonNaN.c
new file mode 100644
index 000000000..9a481a74f
--- /dev/null
+++ b/test/float/softfloat/source/8086-SSE/s_f64UIToCommonNaN.c
@@ -0,0 +1,59 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming `uiA' has the bit pattern of a 64-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr )
+{
+
+ if ( softfloat_isSigNaNF64UI( uiA ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ }
+ zPtr->sign = uiA>>63;
+ zPtr->v64 = uiA<<12;
+ zPtr->v0 = 0;
+
+}
+
diff --git a/test/float/softfloat/source/8086-SSE/s_propagateNaNExtF80M.c b/test/float/softfloat/source/8086-SSE/s_propagateNaNExtF80M.c
new file mode 100644
index 000000000..f35e06654
--- /dev/null
+++ b/test/float/softfloat/source/8086-SSE/s_propagateNaNExtF80M.c
@@ -0,0 +1,107 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming at least one of the two 80-bit extended floating-point values
+| pointed to by `aSPtr' and `bSPtr' is a NaN, stores the combined NaN result
+| at the location pointed to by `zSPtr'. If either original floating-point
+| value is a signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_propagateNaNExtF80M(
+ const struct extFloat80M *aSPtr,
+ const struct extFloat80M *bSPtr,
+ struct extFloat80M *zSPtr
+ )
+{
+ bool isSigNaNA;
+ const struct extFloat80M *sPtr;
+ bool isSigNaNB;
+ uint_fast16_t uiB64;
+ uint64_t uiB0;
+ uint_fast16_t uiA64;
+ uint64_t uiA0;
+ uint_fast16_t uiMagA64, uiMagB64;
+
+ isSigNaNA = extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr );
+ sPtr = aSPtr;
+ if ( ! bSPtr ) {
+ if ( isSigNaNA ) softfloat_raiseFlags( softfloat_flag_invalid );
+ goto copy;
+ }
+ isSigNaNB = extF80M_isSignalingNaN( (const extFloat80_t *) bSPtr );
+ if ( isSigNaNA | isSigNaNB ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ if ( isSigNaNA ) {
+ uiB64 = bSPtr->signExp;
+ if ( isSigNaNB ) goto returnLargerUIMag;
+ uiB0 = bSPtr->signif;
+ if ( isNaNExtF80UI( uiB64, uiB0 ) ) goto copyB;
+ goto copy;
+ } else {
+ uiA64 = aSPtr->signExp;
+ uiA0 = aSPtr->signif;
+ if ( isNaNExtF80UI( uiA64, uiA0 ) ) goto copy;
+ goto copyB;
+ }
+ }
+ uiB64 = bSPtr->signExp;
+ returnLargerUIMag:
+ uiA64 = aSPtr->signExp;
+ uiMagA64 = uiA64 & 0x7FFF;
+ uiMagB64 = uiB64 & 0x7FFF;
+ if ( uiMagA64 < uiMagB64 ) goto copyB;
+ if ( uiMagB64 < uiMagA64 ) goto copy;
+ uiA0 = aSPtr->signif;
+ uiB0 = bSPtr->signif;
+ if ( uiA0 < uiB0 ) goto copyB;
+ if ( uiB0 < uiA0 ) goto copy;
+ if ( uiA64 < uiB64 ) goto copy;
+ copyB:
+ sPtr = bSPtr;
+ copy:
+ zSPtr->signExp = sPtr->signExp;
+ zSPtr->signif = sPtr->signif | UINT64_C( 0xC000000000000000 );
+
+}
+
diff --git a/test/float/softfloat/source/8086-SSE/s_propagateNaNExtF80UI.c b/test/float/softfloat/source/8086-SSE/s_propagateNaNExtF80UI.c
new file mode 100644
index 000000000..fa2daae2e
--- /dev/null
+++ b/test/float/softfloat/source/8086-SSE/s_propagateNaNExtF80UI.c
@@ -0,0 +1,106 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting the unsigned integer formed from concatenating 'uiA64' and
+| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting
+| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
+| 80-bit extended floating-point value, and assuming at least on of these
+| floating-point values is a NaN, returns the bit pattern of the combined NaN
+| result. If either original floating-point value is a signaling NaN, the
+| invalid exception is raised.
+*----------------------------------------------------------------------------*/
+struct uint128
+ softfloat_propagateNaNExtF80UI(
+ uint_fast16_t uiA64,
+ uint_fast64_t uiA0,
+ uint_fast16_t uiB64,
+ uint_fast64_t uiB0
+ )
+{
+ bool isSigNaNA, isSigNaNB;
+ uint_fast64_t uiNonsigA0, uiNonsigB0;
+ uint_fast16_t uiMagA64, uiMagB64;
+ struct uint128 uiZ;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ isSigNaNA = softfloat_isSigNaNExtF80UI( uiA64, uiA0 );
+ isSigNaNB = softfloat_isSigNaNExtF80UI( uiB64, uiB0 );
+ /*------------------------------------------------------------------------
+ | Make NaNs non-signaling.
+ *------------------------------------------------------------------------*/
+ uiNonsigA0 = uiA0 | UINT64_C( 0xC000000000000000 );
+ uiNonsigB0 = uiB0 | UINT64_C( 0xC000000000000000 );
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( isSigNaNA | isSigNaNB ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ if ( isSigNaNA ) {
+ if ( isSigNaNB ) goto returnLargerMag;
+ if ( isNaNExtF80UI( uiB64, uiB0 ) ) goto returnB;
+ goto returnA;
+ } else {
+ if ( isNaNExtF80UI( uiA64, uiA0 ) ) goto returnA;
+ goto returnB;
+ }
+ }
+ returnLargerMag:
+ uiMagA64 = uiA64 & 0x7FFF;
+ uiMagB64 = uiB64 & 0x7FFF;
+ if ( uiMagA64 < uiMagB64 ) goto returnB;
+ if ( uiMagB64 < uiMagA64 ) goto returnA;
+ if ( uiA0 < uiB0 ) goto returnB;
+ if ( uiB0 < uiA0 ) goto returnA;
+ if ( uiA64 < uiB64 ) goto returnA;
+ returnB:
+ uiZ.v64 = uiB64;
+ uiZ.v0 = uiNonsigB0;
+ return uiZ;
+ returnA:
+ uiZ.v64 = uiA64;
+ uiZ.v0 = uiNonsigA0;
+ return uiZ;
+
+}
+
diff --git a/test/float/softfloat/source/8086-SSE/s_propagateNaNF128M.c b/test/float/softfloat/source/8086-SSE/s_propagateNaNF128M.c
new file mode 100644
index 000000000..e8872742c
--- /dev/null
+++ b/test/float/softfloat/source/8086-SSE/s_propagateNaNF128M.c
@@ -0,0 +1,76 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming at least one of the two 128-bit floating-point values pointed to by
+| `aWPtr' and `bWPtr' is a NaN, stores the combined NaN result at the location
+| pointed to by `zWPtr'. If either original floating-point value is a
+| signaling NaN, the invalid exception is raised. Each of `aWPtr', `bWPtr',
+| and `zWPtr' points to an array of four 32-bit elements that concatenate in
+| the platform's normal endian order to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_propagateNaNF128M(
+ const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr )
+{
+ bool isSigNaNA;
+ const uint32_t *ptr;
+
+ ptr = aWPtr;
+ isSigNaNA = f128M_isSignalingNaN( (const float128_t *) aWPtr );
+ if (
+ isSigNaNA
+ || (bWPtr && f128M_isSignalingNaN( (const float128_t *) bWPtr ))
+ ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ if ( isSigNaNA ) goto copy;
+ }
+ if ( ! softfloat_isNaNF128M( aWPtr ) ) ptr = bWPtr;
+ copy:
+ zWPtr[indexWordHi( 4 )] = ptr[indexWordHi( 4 )] | 0x00008000;
+ zWPtr[indexWord( 4, 2 )] = ptr[indexWord( 4, 2 )];
+ zWPtr[indexWord( 4, 1 )] = ptr[indexWord( 4, 1 )];
+ zWPtr[indexWord( 4, 0 )] = ptr[indexWord( 4, 0 )];
+
+}
+
diff --git a/test/float/softfloat/source/8086-SSE/s_propagateNaNF128UI.c b/test/float/softfloat/source/8086-SSE/s_propagateNaNF128UI.c
new file mode 100644
index 000000000..fb0e862dc
--- /dev/null
+++ b/test/float/softfloat/source/8086-SSE/s_propagateNaNF128UI.c
@@ -0,0 +1,81 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting the unsigned integer formed from concatenating `uiA64' and
+| `uiA0' as a 128-bit floating-point value, and likewise interpreting the
+| unsigned integer formed from concatenating `uiB64' and `uiB0' as another
+| 128-bit floating-point value, and assuming at least on of these floating-
+| point values is a NaN, returns the bit pattern of the combined NaN result.
+| If either original floating-point value is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+struct uint128
+ softfloat_propagateNaNF128UI(
+ uint_fast64_t uiA64,
+ uint_fast64_t uiA0,
+ uint_fast64_t uiB64,
+ uint_fast64_t uiB0
+ )
+{
+ bool isSigNaNA;
+ struct uint128 uiZ;
+
+ isSigNaNA = softfloat_isSigNaNF128UI( uiA64, uiA0 );
+ if ( isSigNaNA || softfloat_isSigNaNF128UI( uiB64, uiB0 ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ if ( isSigNaNA ) goto returnNonsigA;
+ }
+ if ( isNaNF128UI( uiA64, uiA0 ) ) {
+ returnNonsigA:
+ uiZ.v64 = uiA64;
+ uiZ.v0 = uiA0;
+ } else {
+ uiZ.v64 = uiB64;
+ uiZ.v0 = uiB0;
+ }
+ uiZ.v64 |= UINT64_C( 0x0000800000000000 );
+ return uiZ;
+
+}
+
diff --git a/test/float/softfloat/source/8086-SSE/s_propagateNaNF16UI.c b/test/float/softfloat/source/8086-SSE/s_propagateNaNF16UI.c
new file mode 100644
index 000000000..8e19e4301
--- /dev/null
+++ b/test/float/softfloat/source/8086-SSE/s_propagateNaNF16UI.c
@@ -0,0 +1,63 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting `uiA' and `uiB' as the bit patterns of two 16-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result. If either `uiA' or `uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast16_t
+ softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB )
+{
+ bool isSigNaNA;
+
+ isSigNaNA = softfloat_isSigNaNF16UI( uiA );
+ if ( isSigNaNA || softfloat_isSigNaNF16UI( uiB ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ if ( isSigNaNA ) return uiA | 0x0200;
+ }
+ return (isNaNF16UI( uiA ) ? uiA : uiB) | 0x0200;
+
+}
+
diff --git a/test/float/softfloat/source/8086-SSE/s_propagateNaNF32UI.c b/test/float/softfloat/source/8086-SSE/s_propagateNaNF32UI.c
new file mode 100644
index 000000000..6e423cac6
--- /dev/null
+++ b/test/float/softfloat/source/8086-SSE/s_propagateNaNF32UI.c
@@ -0,0 +1,63 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting `uiA' and `uiB' as the bit patterns of two 32-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result. If either `uiA' or `uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast32_t
+ softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB )
+{
+ bool isSigNaNA;
+
+ isSigNaNA = softfloat_isSigNaNF32UI( uiA );
+ if ( isSigNaNA || softfloat_isSigNaNF32UI( uiB ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ if ( isSigNaNA ) return uiA | 0x00400000;
+ }
+ return (isNaNF32UI( uiA ) ? uiA : uiB) | 0x00400000;
+
+}
+
diff --git a/test/float/softfloat/source/8086-SSE/s_propagateNaNF64UI.c b/test/float/softfloat/source/8086-SSE/s_propagateNaNF64UI.c
new file mode 100644
index 000000000..474c1967d
--- /dev/null
+++ b/test/float/softfloat/source/8086-SSE/s_propagateNaNF64UI.c
@@ -0,0 +1,63 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting `uiA' and `uiB' as the bit patterns of two 64-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result. If either `uiA' or `uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast64_t
+ softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB )
+{
+ bool isSigNaNA;
+
+ isSigNaNA = softfloat_isSigNaNF64UI( uiA );
+ if ( isSigNaNA || softfloat_isSigNaNF64UI( uiB ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ if ( isSigNaNA ) return uiA | UINT64_C( 0x0008000000000000 );
+ }
+ return (isNaNF64UI( uiA ) ? uiA : uiB) | UINT64_C( 0x0008000000000000 );
+
+}
+
diff --git a/test/float/softfloat/source/8086-SSE/softfloat_raiseFlags.c b/test/float/softfloat/source/8086-SSE/softfloat_raiseFlags.c
new file mode 100644
index 000000000..7a1aee930
--- /dev/null
+++ b/test/float/softfloat/source/8086-SSE/softfloat_raiseFlags.c
@@ -0,0 +1,52 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include "platform.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Raises the exceptions specified by `flags'. Floating-point traps can be
+| defined here if desired. It is currently not possible for such a trap
+| to substitute a result value. If traps are not implemented, this routine
+| should be simply `softfloat_exceptionFlags |= flags;'.
+*----------------------------------------------------------------------------*/
+void softfloat_raiseFlags( uint_fast8_t flags )
+{
+
+ softfloat_exceptionFlags |= flags;
+
+}
+
diff --git a/test/float/softfloat/source/8086-SSE/specialize.h b/test/float/softfloat/source/8086-SSE/specialize.h
new file mode 100644
index 000000000..a9166e170
--- /dev/null
+++ b/test/float/softfloat/source/8086-SSE/specialize.h
@@ -0,0 +1,376 @@
+
+/*============================================================================
+
+This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2018 The Regents of the
+University of California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#ifndef specialize_h
+#define specialize_h 1
+
+#include
+#include
+#include "primitiveTypes.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Default value for 'softfloat_detectTininess'.
+*----------------------------------------------------------------------------*/
+#define init_detectTininess softfloat_tininess_afterRounding
+
+/*----------------------------------------------------------------------------
+| The values to return on conversions to 32-bit integer formats that raise an
+| invalid exception.
+*----------------------------------------------------------------------------*/
+#define ui32_fromPosOverflow 0xFFFFFFFF
+#define ui32_fromNegOverflow 0xFFFFFFFF
+#define ui32_fromNaN 0xFFFFFFFF
+#define i32_fromPosOverflow (-0x7FFFFFFF - 1)
+#define i32_fromNegOverflow (-0x7FFFFFFF - 1)
+#define i32_fromNaN (-0x7FFFFFFF - 1)
+
+/*----------------------------------------------------------------------------
+| The values to return on conversions to 64-bit integer formats that raise an
+| invalid exception.
+*----------------------------------------------------------------------------*/
+#define ui64_fromPosOverflow UINT64_C( 0xFFFFFFFFFFFFFFFF )
+#define ui64_fromNegOverflow UINT64_C( 0xFFFFFFFFFFFFFFFF )
+#define ui64_fromNaN UINT64_C( 0xFFFFFFFFFFFFFFFF )
+#define i64_fromPosOverflow (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
+#define i64_fromNegOverflow (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
+#define i64_fromNaN (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
+
+/*----------------------------------------------------------------------------
+| "Common NaN" structure, used to transfer NaN representations from one format
+| to another.
+*----------------------------------------------------------------------------*/
+struct commonNaN {
+ bool sign;
+#ifdef LITTLEENDIAN
+ uint64_t v0, v64;
+#else
+ uint64_t v64, v0;
+#endif
+};
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 16-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF16UI 0xFE00
+
+/*----------------------------------------------------------------------------
+| Returns true when 16-bit unsigned integer 'uiA' has the bit pattern of a
+| 16-bit floating-point signaling NaN.
+| Note: This macro evaluates its argument more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNF16UI( uiA ) ((((uiA) & 0x7E00) == 0x7C00) && ((uiA) & 0x01FF))
+
+/*----------------------------------------------------------------------------
+| Assuming 'uiA' has the bit pattern of a 16-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr );
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast16_t
+ softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 32-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF32UI 0xFFC00000
+
+/*----------------------------------------------------------------------------
+| Returns true when 32-bit unsigned integer 'uiA' has the bit pattern of a
+| 32-bit floating-point signaling NaN.
+| Note: This macro evaluates its argument more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNF32UI( uiA ) ((((uiA) & 0x7FC00000) == 0x7F800000) && ((uiA) & 0x003FFFFF))
+
+/*----------------------------------------------------------------------------
+| Assuming 'uiA' has the bit pattern of a 32-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr );
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast32_t
+ softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 64-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF64UI UINT64_C( 0xFFF8000000000000 )
+
+/*----------------------------------------------------------------------------
+| Returns true when 64-bit unsigned integer 'uiA' has the bit pattern of a
+| 64-bit floating-point signaling NaN.
+| Note: This macro evaluates its argument more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNF64UI( uiA ) ((((uiA) & UINT64_C( 0x7FF8000000000000 )) == UINT64_C( 0x7FF0000000000000 )) && ((uiA) & UINT64_C( 0x0007FFFFFFFFFFFF )))
+
+/*----------------------------------------------------------------------------
+| Assuming 'uiA' has the bit pattern of a 64-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr );
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast64_t
+ softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 80-bit extended floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNExtF80UI64 0xFFFF
+#define defaultNaNExtF80UI0 UINT64_C( 0xC000000000000000 )
+
+/*----------------------------------------------------------------------------
+| Returns true when the 80-bit unsigned integer formed from concatenating
+| 16-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of an 80-bit extended
+| floating-point signaling NaN.
+| Note: This macro evaluates its arguments more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ((((uiA64) & 0x7FFF) == 0x7FFF) && ! ((uiA0) & UINT64_C( 0x4000000000000000 )) && ((uiA0) & UINT64_C( 0x3FFFFFFFFFFFFFFF )))
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+/*----------------------------------------------------------------------------
+| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is
+| defined.
+*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
+| has the bit pattern of an 80-bit extended floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_extF80UIToCommonNaN(
+ uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
+| floating-point NaN, and returns the bit pattern of this value as an unsigned
+| integer.
+*----------------------------------------------------------------------------*/
+struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr );
+
+/*----------------------------------------------------------------------------
+| Interpreting the unsigned integer formed from concatenating 'uiA64' and
+| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting
+| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
+| 80-bit extended floating-point value, and assuming at least on of these
+| floating-point values is a NaN, returns the bit pattern of the combined NaN
+| result. If either original floating-point value is a signaling NaN, the
+| invalid exception is raised.
+*----------------------------------------------------------------------------*/
+struct uint128
+ softfloat_propagateNaNExtF80UI(
+ uint_fast16_t uiA64,
+ uint_fast64_t uiA0,
+ uint_fast16_t uiB64,
+ uint_fast64_t uiB0
+ );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 128-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF128UI64 UINT64_C( 0xFFFF800000000000 )
+#define defaultNaNF128UI0 UINT64_C( 0 )
+
+/*----------------------------------------------------------------------------
+| Returns true when the 128-bit unsigned integer formed from concatenating
+| 64-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of a 128-bit floating-
+| point signaling NaN.
+| Note: This macro evaluates its arguments more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNF128UI( uiA64, uiA0 ) ((((uiA64) & UINT64_C( 0x7FFF800000000000 )) == UINT64_C( 0x7FFF000000000000 )) && ((uiA0) || ((uiA64) & UINT64_C( 0x00007FFFFFFFFFFF ))))
+
+/*----------------------------------------------------------------------------
+| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
+| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to
+| the common NaN form, and stores the resulting common NaN at the location
+| pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid exception
+| is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_f128UIToCommonNaN(
+ uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN * );
+
+/*----------------------------------------------------------------------------
+| Interpreting the unsigned integer formed from concatenating 'uiA64' and
+| 'uiA0' as a 128-bit floating-point value, and likewise interpreting the
+| unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
+| 128-bit floating-point value, and assuming at least on of these floating-
+| point values is a NaN, returns the bit pattern of the combined NaN result.
+| If either original floating-point value is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+struct uint128
+ softfloat_propagateNaNF128UI(
+ uint_fast64_t uiA64,
+ uint_fast64_t uiA0,
+ uint_fast64_t uiB64,
+ uint_fast64_t uiB0
+ );
+
+#else
+
+/*----------------------------------------------------------------------------
+| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is not
+| defined.
+*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+| Assuming the 80-bit extended floating-point value pointed to by 'aSPtr' is
+| a NaN, converts this NaN to the common NaN form, and stores the resulting
+| common NaN at the location pointed to by 'zPtr'. If the NaN is a signaling
+| NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_extF80MToCommonNaN(
+ const struct extFloat80M *aSPtr, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
+| floating-point NaN, and stores this NaN at the location pointed to by
+| 'zSPtr'.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_commonNaNToExtF80M(
+ const struct commonNaN *aPtr, struct extFloat80M *zSPtr );
+
+/*----------------------------------------------------------------------------
+| Assuming at least one of the two 80-bit extended floating-point values
+| pointed to by 'aSPtr' and 'bSPtr' is a NaN, stores the combined NaN result
+| at the location pointed to by 'zSPtr'. If either original floating-point
+| value is a signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_propagateNaNExtF80M(
+ const struct extFloat80M *aSPtr,
+ const struct extFloat80M *bSPtr,
+ struct extFloat80M *zSPtr
+ );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 128-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF128UI96 0xFFFF8000
+#define defaultNaNF128UI64 0
+#define defaultNaNF128UI32 0
+#define defaultNaNF128UI0 0
+
+/*----------------------------------------------------------------------------
+| Assuming the 128-bit floating-point value pointed to by 'aWPtr' is a NaN,
+| converts this NaN to the common NaN form, and stores the resulting common
+| NaN at the location pointed to by 'zPtr'. If the NaN is a signaling NaN,
+| the invalid exception is raised. Argument 'aWPtr' points to an array of
+| four 32-bit elements that concatenate in the platform's normal endian order
+| to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
+| NaN, and stores this NaN at the location pointed to by 'zWPtr'. Argument
+| 'zWPtr' points to an array of four 32-bit elements that concatenate in the
+| platform's normal endian order to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr );
+
+/*----------------------------------------------------------------------------
+| Assuming at least one of the two 128-bit floating-point values pointed to by
+| 'aWPtr' and 'bWPtr' is a NaN, stores the combined NaN result at the location
+| pointed to by 'zWPtr'. If either original floating-point value is a
+| signaling NaN, the invalid exception is raised. Each of 'aWPtr', 'bWPtr',
+| and 'zWPtr' points to an array of four 32-bit elements that concatenate in
+| the platform's normal endian order to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_propagateNaNF128M(
+ const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr );
+
+#endif
+
+#endif
+
diff --git a/test/float/softfloat/source/8086/extF80M_isSignalingNaN.c b/test/float/softfloat/source/8086/extF80M_isSignalingNaN.c
new file mode 100644
index 000000000..c2cca65c9
--- /dev/null
+++ b/test/float/softfloat/source/8086/extF80M_isSignalingNaN.c
@@ -0,0 +1,57 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+bool extF80M_isSignalingNaN( const extFloat80_t *aPtr )
+{
+ const struct extFloat80M *aSPtr;
+ uint64_t uiA0;
+
+ aSPtr = (const struct extFloat80M *) aPtr;
+ if ( (aSPtr->signExp & 0x7FFF) != 0x7FFF ) return false;
+ uiA0 = aSPtr->signif;
+ return
+ ! (uiA0 & UINT64_C( 0x4000000000000000 ))
+ && (uiA0 & UINT64_C( 0x3FFFFFFFFFFFFFFF));
+
+}
+
diff --git a/test/float/softfloat/source/8086/f128M_isSignalingNaN.c b/test/float/softfloat/source/8086/f128M_isSignalingNaN.c
new file mode 100644
index 000000000..9ff83d726
--- /dev/null
+++ b/test/float/softfloat/source/8086/f128M_isSignalingNaN.c
@@ -0,0 +1,60 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "primitives.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+bool f128M_isSignalingNaN( const float128_t *aPtr )
+{
+ const uint32_t *aWPtr;
+ uint32_t uiA96;
+
+ aWPtr = (const uint32_t *) aPtr;
+ uiA96 = aWPtr[indexWordHi( 4 )];
+ if ( (uiA96 & 0x7FFF8000) != 0x7FFF0000 ) return false;
+ return
+ ((uiA96 & 0x00007FFF) != 0)
+ || ((aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
+ | aWPtr[indexWord( 4, 0 )])
+ != 0);
+
+}
+
diff --git a/test/float/softfloat/source/8086/s_commonNaNToExtF80M.c b/test/float/softfloat/source/8086/s_commonNaNToExtF80M.c
new file mode 100644
index 000000000..06302aa15
--- /dev/null
+++ b/test/float/softfloat/source/8086/s_commonNaNToExtF80M.c
@@ -0,0 +1,56 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by `aPtr' into an 80-bit extended
+| floating-point NaN, and stores this NaN at the location pointed to by
+| `zSPtr'.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_commonNaNToExtF80M(
+ const struct commonNaN *aPtr, struct extFloat80M *zSPtr )
+{
+
+ zSPtr->signExp = packToExtF80UI64( aPtr->sign, 0x7FFF );
+ zSPtr->signif = UINT64_C( 0xC000000000000000 ) | aPtr->v64>>1;
+
+}
+
diff --git a/test/float/softfloat/source/8086/s_commonNaNToExtF80UI.c b/test/float/softfloat/source/8086/s_commonNaNToExtF80UI.c
new file mode 100644
index 000000000..7325468ff
--- /dev/null
+++ b/test/float/softfloat/source/8086/s_commonNaNToExtF80UI.c
@@ -0,0 +1,56 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "primitives.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by `aPtr' into an 80-bit extended
+| floating-point NaN, and returns the bit pattern of this value as an unsigned
+| integer.
+*----------------------------------------------------------------------------*/
+struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr )
+{
+ struct uint128 uiZ;
+
+ uiZ.v64 = (uint_fast16_t) aPtr->sign<<15 | 0x7FFF;
+ uiZ.v0 = UINT64_C( 0xC000000000000000 ) | aPtr->v64>>1;
+ return uiZ;
+
+}
+
diff --git a/test/float/softfloat/source/8086/s_commonNaNToF128M.c b/test/float/softfloat/source/8086/s_commonNaNToF128M.c
new file mode 100644
index 000000000..e2940bb77
--- /dev/null
+++ b/test/float/softfloat/source/8086/s_commonNaNToF128M.c
@@ -0,0 +1,56 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "primitives.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by `aPtr' into a 128-bit floating-point
+| NaN, and stores this NaN at the location pointed to by `zWPtr'. Argument
+| `zWPtr' points to an array of four 32-bit elements that concatenate in the
+| platform's normal endian order to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr )
+{
+
+ softfloat_shortShiftRight128M( (const uint32_t *) &aPtr->v0, 16, zWPtr );
+ zWPtr[indexWordHi( 4 )] |= (uint32_t) aPtr->sign<<31 | 0x7FFF8000;
+
+}
+
diff --git a/test/float/softfloat/source/8086/s_commonNaNToF128UI.c b/test/float/softfloat/source/8086/s_commonNaNToF128UI.c
new file mode 100644
index 000000000..ac8ea7b70
--- /dev/null
+++ b/test/float/softfloat/source/8086/s_commonNaNToF128UI.c
@@ -0,0 +1,55 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "primitives.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by `aPtr' into a 128-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN *aPtr )
+{
+ struct uint128 uiZ;
+
+ uiZ = softfloat_shortShiftRight128( aPtr->v64, aPtr->v0, 16 );
+ uiZ.v64 |= (uint_fast64_t) aPtr->sign<<63 | UINT64_C( 0x7FFF800000000000 );
+ return uiZ;
+
+}
+
diff --git a/test/float/softfloat/source/8086/s_commonNaNToF16UI.c b/test/float/softfloat/source/8086/s_commonNaNToF16UI.c
new file mode 100644
index 000000000..07679d717
--- /dev/null
+++ b/test/float/softfloat/source/8086/s_commonNaNToF16UI.c
@@ -0,0 +1,51 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by `aPtr' into a 16-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr )
+{
+
+ return (uint_fast16_t) aPtr->sign<<15 | 0x7E00 | aPtr->v64>>54;
+
+}
+
diff --git a/test/float/softfloat/source/8086/s_commonNaNToF32UI.c b/test/float/softfloat/source/8086/s_commonNaNToF32UI.c
new file mode 100644
index 000000000..982c1edf6
--- /dev/null
+++ b/test/float/softfloat/source/8086/s_commonNaNToF32UI.c
@@ -0,0 +1,51 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by `aPtr' into a 32-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr )
+{
+
+ return (uint_fast32_t) aPtr->sign<<31 | 0x7FC00000 | aPtr->v64>>41;
+
+}
+
diff --git a/test/float/softfloat/source/8086/s_commonNaNToF64UI.c b/test/float/softfloat/source/8086/s_commonNaNToF64UI.c
new file mode 100644
index 000000000..d88c68ade
--- /dev/null
+++ b/test/float/softfloat/source/8086/s_commonNaNToF64UI.c
@@ -0,0 +1,53 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by `aPtr' into a 64-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr )
+{
+
+ return
+ (uint_fast64_t) aPtr->sign<<63 | UINT64_C( 0x7FF8000000000000 )
+ | aPtr->v64>>12;
+
+}
+
diff --git a/test/float/softfloat/source/8086/s_extF80MToCommonNaN.c b/test/float/softfloat/source/8086/s_extF80MToCommonNaN.c
new file mode 100644
index 000000000..6bf45cf86
--- /dev/null
+++ b/test/float/softfloat/source/8086/s_extF80MToCommonNaN.c
@@ -0,0 +1,62 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming the 80-bit extended floating-point value pointed to by `aSPtr' is
+| a NaN, converts this NaN to the common NaN form, and stores the resulting
+| common NaN at the location pointed to by `zPtr'. If the NaN is a signaling
+| NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_extF80MToCommonNaN(
+ const struct extFloat80M *aSPtr, struct commonNaN *zPtr )
+{
+
+ if ( extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ }
+ zPtr->sign = signExtF80UI64( aSPtr->signExp );
+ zPtr->v64 = aSPtr->signif<<1;
+ zPtr->v0 = 0;
+
+}
+
diff --git a/test/float/softfloat/source/8086/s_extF80UIToCommonNaN.c b/test/float/softfloat/source/8086/s_extF80UIToCommonNaN.c
new file mode 100644
index 000000000..8b8c92780
--- /dev/null
+++ b/test/float/softfloat/source/8086/s_extF80UIToCommonNaN.c
@@ -0,0 +1,62 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming the unsigned integer formed from concatenating `uiA64' and `uiA0'
+| has the bit pattern of an 80-bit extended floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_extF80UIToCommonNaN(
+ uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
+{
+
+ if ( softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ }
+ zPtr->sign = uiA64>>15;
+ zPtr->v64 = uiA0<<1;
+ zPtr->v0 = 0;
+
+}
+
diff --git a/test/float/softfloat/source/8086/s_f128MToCommonNaN.c b/test/float/softfloat/source/8086/s_f128MToCommonNaN.c
new file mode 100644
index 000000000..22152145a
--- /dev/null
+++ b/test/float/softfloat/source/8086/s_f128MToCommonNaN.c
@@ -0,0 +1,62 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "primitives.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming the 128-bit floating-point value pointed to by `aWPtr' is a NaN,
+| converts this NaN to the common NaN form, and stores the resulting common
+| NaN at the location pointed to by `zPtr'. If the NaN is a signaling NaN,
+| the invalid exception is raised. Argument `aWPtr' points to an array of
+| four 32-bit elements that concatenate in the platform's normal endian order
+| to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr )
+{
+
+ if ( f128M_isSignalingNaN( (const float128_t *) aWPtr ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ }
+ zPtr->sign = aWPtr[indexWordHi( 4 )]>>31;
+ softfloat_shortShiftLeft128M( aWPtr, 16, (uint32_t *) &zPtr->v0 );
+
+}
+
diff --git a/test/float/softfloat/source/8086/s_f128UIToCommonNaN.c b/test/float/softfloat/source/8086/s_f128UIToCommonNaN.c
new file mode 100644
index 000000000..2510c0707
--- /dev/null
+++ b/test/float/softfloat/source/8086/s_f128UIToCommonNaN.c
@@ -0,0 +1,65 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "primitives.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming the unsigned integer formed from concatenating `uiA64' and `uiA0'
+| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to
+| the common NaN form, and stores the resulting common NaN at the location
+| pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid exception
+| is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_f128UIToCommonNaN(
+ uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
+{
+ struct uint128 NaNSig;
+
+ if ( softfloat_isSigNaNF128UI( uiA64, uiA0 ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ }
+ NaNSig = softfloat_shortShiftLeft128( uiA64, uiA0, 16 );
+ zPtr->sign = uiA64>>63;
+ zPtr->v64 = NaNSig.v64;
+ zPtr->v0 = NaNSig.v0;
+
+}
+
diff --git a/test/float/softfloat/source/8086/s_f16UIToCommonNaN.c b/test/float/softfloat/source/8086/s_f16UIToCommonNaN.c
new file mode 100644
index 000000000..4d5003f6a
--- /dev/null
+++ b/test/float/softfloat/source/8086/s_f16UIToCommonNaN.c
@@ -0,0 +1,59 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming `uiA' has the bit pattern of a 16-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr )
+{
+
+ if ( softfloat_isSigNaNF16UI( uiA ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ }
+ zPtr->sign = uiA>>15;
+ zPtr->v64 = (uint_fast64_t) uiA<<54;
+ zPtr->v0 = 0;
+
+}
+
diff --git a/test/float/softfloat/source/8086/s_f32UIToCommonNaN.c b/test/float/softfloat/source/8086/s_f32UIToCommonNaN.c
new file mode 100644
index 000000000..f4734db7a
--- /dev/null
+++ b/test/float/softfloat/source/8086/s_f32UIToCommonNaN.c
@@ -0,0 +1,59 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming `uiA' has the bit pattern of a 32-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr )
+{
+
+ if ( softfloat_isSigNaNF32UI( uiA ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ }
+ zPtr->sign = uiA>>31;
+ zPtr->v64 = (uint_fast64_t) uiA<<41;
+ zPtr->v0 = 0;
+
+}
+
diff --git a/test/float/softfloat/source/8086/s_f64UIToCommonNaN.c b/test/float/softfloat/source/8086/s_f64UIToCommonNaN.c
new file mode 100644
index 000000000..9a481a74f
--- /dev/null
+++ b/test/float/softfloat/source/8086/s_f64UIToCommonNaN.c
@@ -0,0 +1,59 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming `uiA' has the bit pattern of a 64-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr )
+{
+
+ if ( softfloat_isSigNaNF64UI( uiA ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ }
+ zPtr->sign = uiA>>63;
+ zPtr->v64 = uiA<<12;
+ zPtr->v0 = 0;
+
+}
+
diff --git a/test/float/softfloat/source/8086/s_propagateNaNExtF80M.c b/test/float/softfloat/source/8086/s_propagateNaNExtF80M.c
new file mode 100644
index 000000000..f35e06654
--- /dev/null
+++ b/test/float/softfloat/source/8086/s_propagateNaNExtF80M.c
@@ -0,0 +1,107 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming at least one of the two 80-bit extended floating-point values
+| pointed to by `aSPtr' and `bSPtr' is a NaN, stores the combined NaN result
+| at the location pointed to by `zSPtr'. If either original floating-point
+| value is a signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_propagateNaNExtF80M(
+ const struct extFloat80M *aSPtr,
+ const struct extFloat80M *bSPtr,
+ struct extFloat80M *zSPtr
+ )
+{
+ bool isSigNaNA;
+ const struct extFloat80M *sPtr;
+ bool isSigNaNB;
+ uint_fast16_t uiB64;
+ uint64_t uiB0;
+ uint_fast16_t uiA64;
+ uint64_t uiA0;
+ uint_fast16_t uiMagA64, uiMagB64;
+
+ isSigNaNA = extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr );
+ sPtr = aSPtr;
+ if ( ! bSPtr ) {
+ if ( isSigNaNA ) softfloat_raiseFlags( softfloat_flag_invalid );
+ goto copy;
+ }
+ isSigNaNB = extF80M_isSignalingNaN( (const extFloat80_t *) bSPtr );
+ if ( isSigNaNA | isSigNaNB ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ if ( isSigNaNA ) {
+ uiB64 = bSPtr->signExp;
+ if ( isSigNaNB ) goto returnLargerUIMag;
+ uiB0 = bSPtr->signif;
+ if ( isNaNExtF80UI( uiB64, uiB0 ) ) goto copyB;
+ goto copy;
+ } else {
+ uiA64 = aSPtr->signExp;
+ uiA0 = aSPtr->signif;
+ if ( isNaNExtF80UI( uiA64, uiA0 ) ) goto copy;
+ goto copyB;
+ }
+ }
+ uiB64 = bSPtr->signExp;
+ returnLargerUIMag:
+ uiA64 = aSPtr->signExp;
+ uiMagA64 = uiA64 & 0x7FFF;
+ uiMagB64 = uiB64 & 0x7FFF;
+ if ( uiMagA64 < uiMagB64 ) goto copyB;
+ if ( uiMagB64 < uiMagA64 ) goto copy;
+ uiA0 = aSPtr->signif;
+ uiB0 = bSPtr->signif;
+ if ( uiA0 < uiB0 ) goto copyB;
+ if ( uiB0 < uiA0 ) goto copy;
+ if ( uiA64 < uiB64 ) goto copy;
+ copyB:
+ sPtr = bSPtr;
+ copy:
+ zSPtr->signExp = sPtr->signExp;
+ zSPtr->signif = sPtr->signif | UINT64_C( 0xC000000000000000 );
+
+}
+
diff --git a/test/float/softfloat/source/8086/s_propagateNaNExtF80UI.c b/test/float/softfloat/source/8086/s_propagateNaNExtF80UI.c
new file mode 100644
index 000000000..fa2daae2e
--- /dev/null
+++ b/test/float/softfloat/source/8086/s_propagateNaNExtF80UI.c
@@ -0,0 +1,106 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting the unsigned integer formed from concatenating 'uiA64' and
+| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting
+| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
+| 80-bit extended floating-point value, and assuming at least on of these
+| floating-point values is a NaN, returns the bit pattern of the combined NaN
+| result. If either original floating-point value is a signaling NaN, the
+| invalid exception is raised.
+*----------------------------------------------------------------------------*/
+struct uint128
+ softfloat_propagateNaNExtF80UI(
+ uint_fast16_t uiA64,
+ uint_fast64_t uiA0,
+ uint_fast16_t uiB64,
+ uint_fast64_t uiB0
+ )
+{
+ bool isSigNaNA, isSigNaNB;
+ uint_fast64_t uiNonsigA0, uiNonsigB0;
+ uint_fast16_t uiMagA64, uiMagB64;
+ struct uint128 uiZ;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ isSigNaNA = softfloat_isSigNaNExtF80UI( uiA64, uiA0 );
+ isSigNaNB = softfloat_isSigNaNExtF80UI( uiB64, uiB0 );
+ /*------------------------------------------------------------------------
+ | Make NaNs non-signaling.
+ *------------------------------------------------------------------------*/
+ uiNonsigA0 = uiA0 | UINT64_C( 0xC000000000000000 );
+ uiNonsigB0 = uiB0 | UINT64_C( 0xC000000000000000 );
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( isSigNaNA | isSigNaNB ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ if ( isSigNaNA ) {
+ if ( isSigNaNB ) goto returnLargerMag;
+ if ( isNaNExtF80UI( uiB64, uiB0 ) ) goto returnB;
+ goto returnA;
+ } else {
+ if ( isNaNExtF80UI( uiA64, uiA0 ) ) goto returnA;
+ goto returnB;
+ }
+ }
+ returnLargerMag:
+ uiMagA64 = uiA64 & 0x7FFF;
+ uiMagB64 = uiB64 & 0x7FFF;
+ if ( uiMagA64 < uiMagB64 ) goto returnB;
+ if ( uiMagB64 < uiMagA64 ) goto returnA;
+ if ( uiA0 < uiB0 ) goto returnB;
+ if ( uiB0 < uiA0 ) goto returnA;
+ if ( uiA64 < uiB64 ) goto returnA;
+ returnB:
+ uiZ.v64 = uiB64;
+ uiZ.v0 = uiNonsigB0;
+ return uiZ;
+ returnA:
+ uiZ.v64 = uiA64;
+ uiZ.v0 = uiNonsigA0;
+ return uiZ;
+
+}
+
diff --git a/test/float/softfloat/source/8086/s_propagateNaNF128M.c b/test/float/softfloat/source/8086/s_propagateNaNF128M.c
new file mode 100644
index 000000000..7ac2e5f63
--- /dev/null
+++ b/test/float/softfloat/source/8086/s_propagateNaNF128M.c
@@ -0,0 +1,108 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming at least one of the two 128-bit floating-point values pointed to by
+| `aWPtr' and `bWPtr' is a NaN, stores the combined NaN result at the location
+| pointed to by `zWPtr'. If either original floating-point value is a
+| signaling NaN, the invalid exception is raised. Each of `aWPtr', `bWPtr',
+| and `zWPtr' points to an array of four 32-bit elements that concatenate in
+| the platform's normal endian order to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_propagateNaNF128M(
+ const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr )
+{
+ bool isSigNaNA;
+ const uint32_t *ptr;
+ bool isSigNaNB;
+ uint32_t uiA96, uiB96, wordMagA, wordMagB;
+
+ isSigNaNA = f128M_isSignalingNaN( (const float128_t *) aWPtr );
+ ptr = aWPtr;
+ if ( ! bWPtr ) {
+ if ( isSigNaNA ) softfloat_raiseFlags( softfloat_flag_invalid );
+ goto copy;
+ }
+ isSigNaNB = f128M_isSignalingNaN( (const float128_t *) bWPtr );
+ if ( isSigNaNA | isSigNaNB ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ if ( isSigNaNA ) {
+ if ( isSigNaNB ) goto returnLargerUIMag;
+ if ( softfloat_isNaNF128M( bWPtr ) ) goto copyB;
+ goto copy;
+ } else {
+ if ( softfloat_isNaNF128M( aWPtr ) ) goto copy;
+ goto copyB;
+ }
+ }
+ returnLargerUIMag:
+ uiA96 = aWPtr[indexWordHi( 4 )];
+ uiB96 = bWPtr[indexWordHi( 4 )];
+ wordMagA = uiA96 & 0x7FFFFFFF;
+ wordMagB = uiB96 & 0x7FFFFFFF;
+ if ( wordMagA < wordMagB ) goto copyB;
+ if ( wordMagB < wordMagA ) goto copy;
+ wordMagA = aWPtr[indexWord( 4, 2 )];
+ wordMagB = bWPtr[indexWord( 4, 2 )];
+ if ( wordMagA < wordMagB ) goto copyB;
+ if ( wordMagB < wordMagA ) goto copy;
+ wordMagA = aWPtr[indexWord( 4, 1 )];
+ wordMagB = bWPtr[indexWord( 4, 1 )];
+ if ( wordMagA < wordMagB ) goto copyB;
+ if ( wordMagB < wordMagA ) goto copy;
+ wordMagA = aWPtr[indexWord( 4, 0 )];
+ wordMagB = bWPtr[indexWord( 4, 0 )];
+ if ( wordMagA < wordMagB ) goto copyB;
+ if ( wordMagB < wordMagA ) goto copy;
+ if ( uiA96 < uiB96 ) goto copy;
+ copyB:
+ ptr = bWPtr;
+ copy:
+ zWPtr[indexWordHi( 4 )] = ptr[indexWordHi( 4 )] | 0x00008000;
+ zWPtr[indexWord( 4, 2 )] = ptr[indexWord( 4, 2 )];
+ zWPtr[indexWord( 4, 1 )] = ptr[indexWord( 4, 1 )];
+ zWPtr[indexWord( 4, 0 )] = ptr[indexWord( 4, 0 )];
+
+}
+
diff --git a/test/float/softfloat/source/8086/s_propagateNaNF128UI.c b/test/float/softfloat/source/8086/s_propagateNaNF128UI.c
new file mode 100644
index 000000000..6caecd205
--- /dev/null
+++ b/test/float/softfloat/source/8086/s_propagateNaNF128UI.c
@@ -0,0 +1,105 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting the unsigned integer formed from concatenating 'uiA64' and
+| 'uiA0' as a 128-bit floating-point value, and likewise interpreting the
+| unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
+| 128-bit floating-point value, and assuming at least on of these floating-
+| point values is a NaN, returns the bit pattern of the combined NaN result.
+| If either original floating-point value is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+struct uint128
+ softfloat_propagateNaNF128UI(
+ uint_fast64_t uiA64,
+ uint_fast64_t uiA0,
+ uint_fast64_t uiB64,
+ uint_fast64_t uiB0
+ )
+{
+ bool isSigNaNA, isSigNaNB;
+ uint_fast64_t uiNonsigA64, uiNonsigB64, uiMagA64, uiMagB64;
+ struct uint128 uiZ;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ isSigNaNA = softfloat_isSigNaNF128UI( uiA64, uiA0 );
+ isSigNaNB = softfloat_isSigNaNF128UI( uiB64, uiB0 );
+ /*------------------------------------------------------------------------
+ | Make NaNs non-signaling.
+ *------------------------------------------------------------------------*/
+ uiNonsigA64 = uiA64 | UINT64_C( 0x0000800000000000 );
+ uiNonsigB64 = uiB64 | UINT64_C( 0x0000800000000000 );
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( isSigNaNA | isSigNaNB ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ if ( isSigNaNA ) {
+ if ( isSigNaNB ) goto returnLargerMag;
+ if ( isNaNF128UI( uiB64, uiB0 ) ) goto returnB;
+ goto returnA;
+ } else {
+ if ( isNaNF128UI( uiA64, uiA0 ) ) goto returnA;
+ goto returnB;
+ }
+ }
+ returnLargerMag:
+ uiMagA64 = uiA64 & UINT64_C( 0x7FFFFFFFFFFFFFFF );
+ uiMagB64 = uiB64 & UINT64_C( 0x7FFFFFFFFFFFFFFF );
+ if ( uiMagA64 < uiMagB64 ) goto returnB;
+ if ( uiMagB64 < uiMagA64 ) goto returnA;
+ if ( uiA0 < uiB0 ) goto returnB;
+ if ( uiB0 < uiA0 ) goto returnA;
+ if ( uiNonsigA64 < uiNonsigB64 ) goto returnA;
+ returnB:
+ uiZ.v64 = uiNonsigB64;
+ uiZ.v0 = uiB0;
+ return uiZ;
+ returnA:
+ uiZ.v64 = uiNonsigA64;
+ uiZ.v0 = uiA0;
+ return uiZ;
+
+}
+
diff --git a/test/float/softfloat/source/8086/s_propagateNaNF16UI.c b/test/float/softfloat/source/8086/s_propagateNaNF16UI.c
new file mode 100644
index 000000000..f9d80d6ac
--- /dev/null
+++ b/test/float/softfloat/source/8086/s_propagateNaNF16UI.c
@@ -0,0 +1,84 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2018 The Regents of the
+University of California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast16_t
+ softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB )
+{
+ bool isSigNaNA, isSigNaNB;
+ uint_fast16_t uiNonsigA, uiNonsigB, uiMagA, uiMagB;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ isSigNaNA = softfloat_isSigNaNF16UI( uiA );
+ isSigNaNB = softfloat_isSigNaNF16UI( uiB );
+ /*------------------------------------------------------------------------
+ | Make NaNs non-signaling.
+ *------------------------------------------------------------------------*/
+ uiNonsigA = uiA | 0x0200;
+ uiNonsigB = uiB | 0x0200;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( isSigNaNA | isSigNaNB ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ if ( isSigNaNA ) {
+ if ( isSigNaNB ) goto returnLargerMag;
+ return isNaNF16UI( uiB ) ? uiNonsigB : uiNonsigA;
+ } else {
+ return isNaNF16UI( uiA ) ? uiNonsigA : uiNonsigB;
+ }
+ }
+ returnLargerMag:
+ uiMagA = uiA & 0x7FFF;
+ uiMagB = uiB & 0x7FFF;
+ if ( uiMagA < uiMagB ) return uiNonsigB;
+ if ( uiMagB < uiMagA ) return uiNonsigA;
+ return (uiNonsigA < uiNonsigB) ? uiNonsigA : uiNonsigB;
+
+}
+
diff --git a/test/float/softfloat/source/8086/s_propagateNaNF32UI.c b/test/float/softfloat/source/8086/s_propagateNaNF32UI.c
new file mode 100644
index 000000000..2350ad7c0
--- /dev/null
+++ b/test/float/softfloat/source/8086/s_propagateNaNF32UI.c
@@ -0,0 +1,84 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast32_t
+ softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB )
+{
+ bool isSigNaNA, isSigNaNB;
+ uint_fast32_t uiNonsigA, uiNonsigB, uiMagA, uiMagB;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ isSigNaNA = softfloat_isSigNaNF32UI( uiA );
+ isSigNaNB = softfloat_isSigNaNF32UI( uiB );
+ /*------------------------------------------------------------------------
+ | Make NaNs non-signaling.
+ *------------------------------------------------------------------------*/
+ uiNonsigA = uiA | 0x00400000;
+ uiNonsigB = uiB | 0x00400000;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( isSigNaNA | isSigNaNB ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ if ( isSigNaNA ) {
+ if ( isSigNaNB ) goto returnLargerMag;
+ return isNaNF32UI( uiB ) ? uiNonsigB : uiNonsigA;
+ } else {
+ return isNaNF32UI( uiA ) ? uiNonsigA : uiNonsigB;
+ }
+ }
+ returnLargerMag:
+ uiMagA = uiA & 0x7FFFFFFF;
+ uiMagB = uiB & 0x7FFFFFFF;
+ if ( uiMagA < uiMagB ) return uiNonsigB;
+ if ( uiMagB < uiMagA ) return uiNonsigA;
+ return (uiNonsigA < uiNonsigB) ? uiNonsigA : uiNonsigB;
+
+}
+
diff --git a/test/float/softfloat/source/8086/s_propagateNaNF64UI.c b/test/float/softfloat/source/8086/s_propagateNaNF64UI.c
new file mode 100644
index 000000000..a4013d489
--- /dev/null
+++ b/test/float/softfloat/source/8086/s_propagateNaNF64UI.c
@@ -0,0 +1,84 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast64_t
+ softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB )
+{
+ bool isSigNaNA, isSigNaNB;
+ uint_fast64_t uiNonsigA, uiNonsigB, uiMagA, uiMagB;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ isSigNaNA = softfloat_isSigNaNF64UI( uiA );
+ isSigNaNB = softfloat_isSigNaNF64UI( uiB );
+ /*------------------------------------------------------------------------
+ | Make NaNs non-signaling.
+ *------------------------------------------------------------------------*/
+ uiNonsigA = uiA | UINT64_C( 0x0008000000000000 );
+ uiNonsigB = uiB | UINT64_C( 0x0008000000000000 );
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( isSigNaNA | isSigNaNB ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ if ( isSigNaNA ) {
+ if ( isSigNaNB ) goto returnLargerMag;
+ return isNaNF64UI( uiB ) ? uiNonsigB : uiNonsigA;
+ } else {
+ return isNaNF64UI( uiA ) ? uiNonsigA : uiNonsigB;
+ }
+ }
+ returnLargerMag:
+ uiMagA = uiA & UINT64_C( 0x7FFFFFFFFFFFFFFF );
+ uiMagB = uiB & UINT64_C( 0x7FFFFFFFFFFFFFFF );
+ if ( uiMagA < uiMagB ) return uiNonsigB;
+ if ( uiMagB < uiMagA ) return uiNonsigA;
+ return (uiNonsigA < uiNonsigB) ? uiNonsigA : uiNonsigB;
+
+}
+
diff --git a/test/float/softfloat/source/8086/softfloat_raiseFlags.c b/test/float/softfloat/source/8086/softfloat_raiseFlags.c
new file mode 100644
index 000000000..7a1aee930
--- /dev/null
+++ b/test/float/softfloat/source/8086/softfloat_raiseFlags.c
@@ -0,0 +1,52 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include "platform.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Raises the exceptions specified by `flags'. Floating-point traps can be
+| defined here if desired. It is currently not possible for such a trap
+| to substitute a result value. If traps are not implemented, this routine
+| should be simply `softfloat_exceptionFlags |= flags;'.
+*----------------------------------------------------------------------------*/
+void softfloat_raiseFlags( uint_fast8_t flags )
+{
+
+ softfloat_exceptionFlags |= flags;
+
+}
+
diff --git a/test/float/softfloat/source/8086/specialize.h b/test/float/softfloat/source/8086/specialize.h
new file mode 100644
index 000000000..a9166e170
--- /dev/null
+++ b/test/float/softfloat/source/8086/specialize.h
@@ -0,0 +1,376 @@
+
+/*============================================================================
+
+This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2018 The Regents of the
+University of California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#ifndef specialize_h
+#define specialize_h 1
+
+#include
+#include
+#include "primitiveTypes.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Default value for 'softfloat_detectTininess'.
+*----------------------------------------------------------------------------*/
+#define init_detectTininess softfloat_tininess_afterRounding
+
+/*----------------------------------------------------------------------------
+| The values to return on conversions to 32-bit integer formats that raise an
+| invalid exception.
+*----------------------------------------------------------------------------*/
+#define ui32_fromPosOverflow 0xFFFFFFFF
+#define ui32_fromNegOverflow 0xFFFFFFFF
+#define ui32_fromNaN 0xFFFFFFFF
+#define i32_fromPosOverflow (-0x7FFFFFFF - 1)
+#define i32_fromNegOverflow (-0x7FFFFFFF - 1)
+#define i32_fromNaN (-0x7FFFFFFF - 1)
+
+/*----------------------------------------------------------------------------
+| The values to return on conversions to 64-bit integer formats that raise an
+| invalid exception.
+*----------------------------------------------------------------------------*/
+#define ui64_fromPosOverflow UINT64_C( 0xFFFFFFFFFFFFFFFF )
+#define ui64_fromNegOverflow UINT64_C( 0xFFFFFFFFFFFFFFFF )
+#define ui64_fromNaN UINT64_C( 0xFFFFFFFFFFFFFFFF )
+#define i64_fromPosOverflow (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
+#define i64_fromNegOverflow (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
+#define i64_fromNaN (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
+
+/*----------------------------------------------------------------------------
+| "Common NaN" structure, used to transfer NaN representations from one format
+| to another.
+*----------------------------------------------------------------------------*/
+struct commonNaN {
+ bool sign;
+#ifdef LITTLEENDIAN
+ uint64_t v0, v64;
+#else
+ uint64_t v64, v0;
+#endif
+};
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 16-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF16UI 0xFE00
+
+/*----------------------------------------------------------------------------
+| Returns true when 16-bit unsigned integer 'uiA' has the bit pattern of a
+| 16-bit floating-point signaling NaN.
+| Note: This macro evaluates its argument more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNF16UI( uiA ) ((((uiA) & 0x7E00) == 0x7C00) && ((uiA) & 0x01FF))
+
+/*----------------------------------------------------------------------------
+| Assuming 'uiA' has the bit pattern of a 16-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr );
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast16_t
+ softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 32-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF32UI 0xFFC00000
+
+/*----------------------------------------------------------------------------
+| Returns true when 32-bit unsigned integer 'uiA' has the bit pattern of a
+| 32-bit floating-point signaling NaN.
+| Note: This macro evaluates its argument more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNF32UI( uiA ) ((((uiA) & 0x7FC00000) == 0x7F800000) && ((uiA) & 0x003FFFFF))
+
+/*----------------------------------------------------------------------------
+| Assuming 'uiA' has the bit pattern of a 32-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr );
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast32_t
+ softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 64-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF64UI UINT64_C( 0xFFF8000000000000 )
+
+/*----------------------------------------------------------------------------
+| Returns true when 64-bit unsigned integer 'uiA' has the bit pattern of a
+| 64-bit floating-point signaling NaN.
+| Note: This macro evaluates its argument more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNF64UI( uiA ) ((((uiA) & UINT64_C( 0x7FF8000000000000 )) == UINT64_C( 0x7FF0000000000000 )) && ((uiA) & UINT64_C( 0x0007FFFFFFFFFFFF )))
+
+/*----------------------------------------------------------------------------
+| Assuming 'uiA' has the bit pattern of a 64-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr );
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast64_t
+ softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 80-bit extended floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNExtF80UI64 0xFFFF
+#define defaultNaNExtF80UI0 UINT64_C( 0xC000000000000000 )
+
+/*----------------------------------------------------------------------------
+| Returns true when the 80-bit unsigned integer formed from concatenating
+| 16-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of an 80-bit extended
+| floating-point signaling NaN.
+| Note: This macro evaluates its arguments more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ((((uiA64) & 0x7FFF) == 0x7FFF) && ! ((uiA0) & UINT64_C( 0x4000000000000000 )) && ((uiA0) & UINT64_C( 0x3FFFFFFFFFFFFFFF )))
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+/*----------------------------------------------------------------------------
+| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is
+| defined.
+*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
+| has the bit pattern of an 80-bit extended floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_extF80UIToCommonNaN(
+ uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
+| floating-point NaN, and returns the bit pattern of this value as an unsigned
+| integer.
+*----------------------------------------------------------------------------*/
+struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr );
+
+/*----------------------------------------------------------------------------
+| Interpreting the unsigned integer formed from concatenating 'uiA64' and
+| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting
+| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
+| 80-bit extended floating-point value, and assuming at least on of these
+| floating-point values is a NaN, returns the bit pattern of the combined NaN
+| result. If either original floating-point value is a signaling NaN, the
+| invalid exception is raised.
+*----------------------------------------------------------------------------*/
+struct uint128
+ softfloat_propagateNaNExtF80UI(
+ uint_fast16_t uiA64,
+ uint_fast64_t uiA0,
+ uint_fast16_t uiB64,
+ uint_fast64_t uiB0
+ );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 128-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF128UI64 UINT64_C( 0xFFFF800000000000 )
+#define defaultNaNF128UI0 UINT64_C( 0 )
+
+/*----------------------------------------------------------------------------
+| Returns true when the 128-bit unsigned integer formed from concatenating
+| 64-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of a 128-bit floating-
+| point signaling NaN.
+| Note: This macro evaluates its arguments more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNF128UI( uiA64, uiA0 ) ((((uiA64) & UINT64_C( 0x7FFF800000000000 )) == UINT64_C( 0x7FFF000000000000 )) && ((uiA0) || ((uiA64) & UINT64_C( 0x00007FFFFFFFFFFF ))))
+
+/*----------------------------------------------------------------------------
+| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
+| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to
+| the common NaN form, and stores the resulting common NaN at the location
+| pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid exception
+| is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_f128UIToCommonNaN(
+ uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN * );
+
+/*----------------------------------------------------------------------------
+| Interpreting the unsigned integer formed from concatenating 'uiA64' and
+| 'uiA0' as a 128-bit floating-point value, and likewise interpreting the
+| unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
+| 128-bit floating-point value, and assuming at least on of these floating-
+| point values is a NaN, returns the bit pattern of the combined NaN result.
+| If either original floating-point value is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+struct uint128
+ softfloat_propagateNaNF128UI(
+ uint_fast64_t uiA64,
+ uint_fast64_t uiA0,
+ uint_fast64_t uiB64,
+ uint_fast64_t uiB0
+ );
+
+#else
+
+/*----------------------------------------------------------------------------
+| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is not
+| defined.
+*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+| Assuming the 80-bit extended floating-point value pointed to by 'aSPtr' is
+| a NaN, converts this NaN to the common NaN form, and stores the resulting
+| common NaN at the location pointed to by 'zPtr'. If the NaN is a signaling
+| NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_extF80MToCommonNaN(
+ const struct extFloat80M *aSPtr, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
+| floating-point NaN, and stores this NaN at the location pointed to by
+| 'zSPtr'.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_commonNaNToExtF80M(
+ const struct commonNaN *aPtr, struct extFloat80M *zSPtr );
+
+/*----------------------------------------------------------------------------
+| Assuming at least one of the two 80-bit extended floating-point values
+| pointed to by 'aSPtr' and 'bSPtr' is a NaN, stores the combined NaN result
+| at the location pointed to by 'zSPtr'. If either original floating-point
+| value is a signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_propagateNaNExtF80M(
+ const struct extFloat80M *aSPtr,
+ const struct extFloat80M *bSPtr,
+ struct extFloat80M *zSPtr
+ );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 128-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF128UI96 0xFFFF8000
+#define defaultNaNF128UI64 0
+#define defaultNaNF128UI32 0
+#define defaultNaNF128UI0 0
+
+/*----------------------------------------------------------------------------
+| Assuming the 128-bit floating-point value pointed to by 'aWPtr' is a NaN,
+| converts this NaN to the common NaN form, and stores the resulting common
+| NaN at the location pointed to by 'zPtr'. If the NaN is a signaling NaN,
+| the invalid exception is raised. Argument 'aWPtr' points to an array of
+| four 32-bit elements that concatenate in the platform's normal endian order
+| to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
+| NaN, and stores this NaN at the location pointed to by 'zWPtr'. Argument
+| 'zWPtr' points to an array of four 32-bit elements that concatenate in the
+| platform's normal endian order to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr );
+
+/*----------------------------------------------------------------------------
+| Assuming at least one of the two 128-bit floating-point values pointed to by
+| 'aWPtr' and 'bWPtr' is a NaN, stores the combined NaN result at the location
+| pointed to by 'zWPtr'. If either original floating-point value is a
+| signaling NaN, the invalid exception is raised. Each of 'aWPtr', 'bWPtr',
+| and 'zWPtr' points to an array of four 32-bit elements that concatenate in
+| the platform's normal endian order to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_propagateNaNF128M(
+ const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr );
+
+#endif
+
+#endif
+
diff --git a/test/float/softfloat/source/ARM-VFPv2-defaultNaN/extF80M_isSignalingNaN.c b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/extF80M_isSignalingNaN.c
new file mode 100644
index 000000000..c2cca65c9
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/extF80M_isSignalingNaN.c
@@ -0,0 +1,57 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+bool extF80M_isSignalingNaN( const extFloat80_t *aPtr )
+{
+ const struct extFloat80M *aSPtr;
+ uint64_t uiA0;
+
+ aSPtr = (const struct extFloat80M *) aPtr;
+ if ( (aSPtr->signExp & 0x7FFF) != 0x7FFF ) return false;
+ uiA0 = aSPtr->signif;
+ return
+ ! (uiA0 & UINT64_C( 0x4000000000000000 ))
+ && (uiA0 & UINT64_C( 0x3FFFFFFFFFFFFFFF));
+
+}
+
diff --git a/test/float/softfloat/source/ARM-VFPv2-defaultNaN/f128M_isSignalingNaN.c b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/f128M_isSignalingNaN.c
new file mode 100644
index 000000000..9ff83d726
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/f128M_isSignalingNaN.c
@@ -0,0 +1,60 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "primitives.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+bool f128M_isSignalingNaN( const float128_t *aPtr )
+{
+ const uint32_t *aWPtr;
+ uint32_t uiA96;
+
+ aWPtr = (const uint32_t *) aPtr;
+ uiA96 = aWPtr[indexWordHi( 4 )];
+ if ( (uiA96 & 0x7FFF8000) != 0x7FFF0000 ) return false;
+ return
+ ((uiA96 & 0x00007FFF) != 0)
+ || ((aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
+ | aWPtr[indexWord( 4, 0 )])
+ != 0);
+
+}
+
diff --git a/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToExtF80M.c b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToExtF80M.c
new file mode 100644
index 000000000..2e6bf7c75
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToExtF80M.c
@@ -0,0 +1,57 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include "platform.h"
+#include "softfloat_types.h"
+
+#define softfloat_commonNaNToExtF80M softfloat_commonNaNToExtF80M
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
+| floating-point NaN, and stores this NaN at the location pointed to by
+| 'zSPtr'.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_commonNaNToExtF80M(
+ const struct commonNaN *aPtr, struct extFloat80M *zSPtr )
+{
+
+ zSPtr->signExp = defaultNaNExtF80UI64;
+ zSPtr->signif = defaultNaNExtF80UI0;
+
+}
+
diff --git a/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToExtF80UI.c b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToExtF80UI.c
new file mode 100644
index 000000000..e37004f7f
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToExtF80UI.c
@@ -0,0 +1,57 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#define softfloat_commonNaNToExtF80UI softfloat_commonNaNToExtF80UI
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
+| floating-point NaN, and returns the bit pattern of this value as an unsigned
+| integer.
+*----------------------------------------------------------------------------*/
+struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr )
+{
+ struct uint128 uiZ;
+
+ uiZ.v64 = defaultNaNExtF80UI64;
+ uiZ.v0 = defaultNaNExtF80UI0;
+ return uiZ;
+
+}
+
diff --git a/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF128M.c b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF128M.c
new file mode 100644
index 000000000..2ff4c1631
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF128M.c
@@ -0,0 +1,60 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#define softfloat_commonNaNToF128M softfloat_commonNaNToF128M
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
+| NaN, and stores this NaN at the location pointed to by 'zWPtr'. Argument
+| 'zWPtr' points to an array of four 32-bit elements that concatenate in the
+| platform's normal endian order to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr )
+{
+
+ zWPtr[indexWord( 4, 3 )] = defaultNaNF128UI96;
+ zWPtr[indexWord( 4, 2 )] = defaultNaNF128UI64;
+ zWPtr[indexWord( 4, 1 )] = defaultNaNF128UI32;
+ zWPtr[indexWord( 4, 0 )] = defaultNaNF128UI0;
+
+}
+
diff --git a/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF128UI.c b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF128UI.c
new file mode 100644
index 000000000..05dfb5f14
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF128UI.c
@@ -0,0 +1,56 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#define softfloat_commonNaNToF128UI softfloat_commonNaNToF128UI
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN *aPtr )
+{
+ struct uint128 uiZ;
+
+ uiZ.v64 = defaultNaNF128UI64;
+ uiZ.v0 = defaultNaNF128UI0;
+ return uiZ;
+
+}
+
diff --git a/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF16UI.c b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF16UI.c
new file mode 100644
index 000000000..861b26965
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF16UI.c
@@ -0,0 +1,5 @@
+
+/*----------------------------------------------------------------------------
+| This file intentionally contains no code.
+*----------------------------------------------------------------------------*/
+
diff --git a/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF32UI.c b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF32UI.c
new file mode 100644
index 000000000..861b26965
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF32UI.c
@@ -0,0 +1,5 @@
+
+/*----------------------------------------------------------------------------
+| This file intentionally contains no code.
+*----------------------------------------------------------------------------*/
+
diff --git a/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF64UI.c b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF64UI.c
new file mode 100644
index 000000000..861b26965
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF64UI.c
@@ -0,0 +1,5 @@
+
+/*----------------------------------------------------------------------------
+| This file intentionally contains no code.
+*----------------------------------------------------------------------------*/
+
diff --git a/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_extF80MToCommonNaN.c b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_extF80MToCommonNaN.c
new file mode 100644
index 000000000..861b26965
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_extF80MToCommonNaN.c
@@ -0,0 +1,5 @@
+
+/*----------------------------------------------------------------------------
+| This file intentionally contains no code.
+*----------------------------------------------------------------------------*/
+
diff --git a/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_extF80UIToCommonNaN.c b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_extF80UIToCommonNaN.c
new file mode 100644
index 000000000..861b26965
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_extF80UIToCommonNaN.c
@@ -0,0 +1,5 @@
+
+/*----------------------------------------------------------------------------
+| This file intentionally contains no code.
+*----------------------------------------------------------------------------*/
+
diff --git a/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_f128MToCommonNaN.c b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_f128MToCommonNaN.c
new file mode 100644
index 000000000..861b26965
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_f128MToCommonNaN.c
@@ -0,0 +1,5 @@
+
+/*----------------------------------------------------------------------------
+| This file intentionally contains no code.
+*----------------------------------------------------------------------------*/
+
diff --git a/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_f128UIToCommonNaN.c b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_f128UIToCommonNaN.c
new file mode 100644
index 000000000..861b26965
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_f128UIToCommonNaN.c
@@ -0,0 +1,5 @@
+
+/*----------------------------------------------------------------------------
+| This file intentionally contains no code.
+*----------------------------------------------------------------------------*/
+
diff --git a/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_f16UIToCommonNaN.c b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_f16UIToCommonNaN.c
new file mode 100644
index 000000000..861b26965
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_f16UIToCommonNaN.c
@@ -0,0 +1,5 @@
+
+/*----------------------------------------------------------------------------
+| This file intentionally contains no code.
+*----------------------------------------------------------------------------*/
+
diff --git a/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_f32UIToCommonNaN.c b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_f32UIToCommonNaN.c
new file mode 100644
index 000000000..861b26965
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_f32UIToCommonNaN.c
@@ -0,0 +1,5 @@
+
+/*----------------------------------------------------------------------------
+| This file intentionally contains no code.
+*----------------------------------------------------------------------------*/
+
diff --git a/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_f64UIToCommonNaN.c b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_f64UIToCommonNaN.c
new file mode 100644
index 000000000..861b26965
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_f64UIToCommonNaN.c
@@ -0,0 +1,5 @@
+
+/*----------------------------------------------------------------------------
+| This file intentionally contains no code.
+*----------------------------------------------------------------------------*/
+
diff --git a/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80M.c b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80M.c
new file mode 100644
index 000000000..827ed5e3a
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80M.c
@@ -0,0 +1,74 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "primitiveTypes.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming at least one of the two 80-bit extended floating-point values
+| pointed to by 'aSPtr' and 'bSPtr' is a NaN, stores the combined NaN result
+| at the location pointed to by 'zSPtr'. If either original floating-point
+| value is a signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_propagateNaNExtF80M(
+ const struct extFloat80M *aSPtr,
+ const struct extFloat80M *bSPtr,
+ struct extFloat80M *zSPtr
+ )
+{
+ uint_fast16_t ui64;
+ uint_fast64_t ui0;
+
+ ui64 = aSPtr->signExp;
+ ui0 = aSPtr->signif;
+ if (
+ softfloat_isSigNaNExtF80UI( ui64, ui0 )
+ || (bSPtr
+ && (ui64 = bSPtr->signExp,
+ ui0 = bSPtr->signif,
+ softfloat_isSigNaNExtF80UI( ui64, ui0 )))
+ ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ }
+ zSPtr->signExp = defaultNaNExtF80UI64;
+ zSPtr->signif = defaultNaNExtF80UI0;
+
+}
+
diff --git a/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80UI.c b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80UI.c
new file mode 100644
index 000000000..e2ddd937e
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80UI.c
@@ -0,0 +1,73 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "primitiveTypes.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting the unsigned integer formed from concatenating 'uiA64' and
+| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting
+| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
+| 80-bit extended floating-point value, and assuming at least on of these
+| floating-point values is a NaN, returns the bit pattern of the combined NaN
+| result. If either original floating-point value is a signaling NaN, the
+| invalid exception is raised.
+*----------------------------------------------------------------------------*/
+struct uint128
+ softfloat_propagateNaNExtF80UI(
+ uint_fast16_t uiA64,
+ uint_fast64_t uiA0,
+ uint_fast16_t uiB64,
+ uint_fast64_t uiB0
+ )
+{
+ struct uint128 uiZ;
+
+ if (
+ softfloat_isSigNaNExtF80UI( uiA64, uiA0 )
+ || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
+ ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ }
+ uiZ.v64 = defaultNaNExtF80UI64;
+ uiZ.v0 = defaultNaNExtF80UI0;
+ return uiZ;
+
+}
+
diff --git a/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128M.c b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128M.c
new file mode 100644
index 000000000..b876ae1f1
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128M.c
@@ -0,0 +1,68 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "primitiveTypes.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming at least one of the two 128-bit floating-point values pointed to by
+| 'aWPtr' and 'bWPtr' is a NaN, stores the combined NaN result at the location
+| pointed to by 'zWPtr'. If either original floating-point value is a
+| signaling NaN, the invalid exception is raised. Each of 'aWPtr', 'bWPtr',
+| and 'zWPtr' points to an array of four 32-bit elements that concatenate in
+| the platform's normal endian order to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_propagateNaNF128M(
+ const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr )
+{
+
+ if (
+ f128M_isSignalingNaN( (const float128_t *) aWPtr );
+ || (bWPtr && f128M_isSignalingNaN( (const float128_t *) bWPtr ))
+ ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ }
+ zWPtr[indexWord( 4, 3 )] = defaultNaNF128UI96;
+ zWPtr[indexWord( 4, 2 )] = defaultNaNF128UI64;
+ zWPtr[indexWord( 4, 1 )] = defaultNaNF128UI32;
+ zWPtr[indexWord( 4, 0 )] = defaultNaNF128UI0;
+
+}
+
diff --git a/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128UI.c b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128UI.c
new file mode 100644
index 000000000..31b788e0c
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128UI.c
@@ -0,0 +1,73 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "primitiveTypes.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting the unsigned integer formed from concatenating 'uiA64' and
+| 'uiA0' as a 128-bit floating-point value, and likewise interpreting the
+| unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
+| 128-bit floating-point value, and assuming at least on of these floating-
+| point values is a NaN, returns the bit pattern of the combined NaN result.
+| If either original floating-point value is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+struct uint128
+ softfloat_propagateNaNF128UI(
+ uint_fast64_t uiA64,
+ uint_fast64_t uiA0,
+ uint_fast64_t uiB64,
+ uint_fast64_t uiB0
+ )
+{
+ struct uint128 uiZ;
+
+ if (
+ softfloat_isSigNaNF128UI( uiA64, uiA0 )
+ || softfloat_isSigNaNF128UI( uiB64, uiB0 )
+ ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ }
+ uiZ.v64 = defaultNaNF128UI64;
+ uiZ.v0 = defaultNaNF128UI0;
+ return uiZ;
+
+}
+
diff --git a/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF16UI.c b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF16UI.c
new file mode 100644
index 000000000..17618fc2e
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF16UI.c
@@ -0,0 +1,58 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast16_t
+ softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB )
+{
+
+ if ( softfloat_isSigNaNF16UI( uiA ) || softfloat_isSigNaNF16UI( uiB ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ }
+ return defaultNaNF16UI;
+
+}
+
diff --git a/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF32UI.c b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF32UI.c
new file mode 100644
index 000000000..e4c3fc1a8
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF32UI.c
@@ -0,0 +1,58 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast32_t
+ softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB )
+{
+
+ if ( softfloat_isSigNaNF32UI( uiA ) || softfloat_isSigNaNF32UI( uiB ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ }
+ return defaultNaNF32UI;
+
+}
+
diff --git a/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF64UI.c b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF64UI.c
new file mode 100644
index 000000000..75361b8e2
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF64UI.c
@@ -0,0 +1,58 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast64_t
+ softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB )
+{
+
+ if ( softfloat_isSigNaNF64UI( uiA ) || softfloat_isSigNaNF64UI( uiB ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ }
+ return defaultNaNF64UI;
+
+}
+
diff --git a/test/float/softfloat/source/ARM-VFPv2-defaultNaN/softfloat_raiseFlags.c b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/softfloat_raiseFlags.c
new file mode 100644
index 000000000..f8f106570
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/softfloat_raiseFlags.c
@@ -0,0 +1,52 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include "platform.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Raises the exceptions specified by 'flags'. Floating-point traps can be
+| defined here if desired. It is currently not possible for such a trap
+| to substitute a result value. If traps are not implemented, this routine
+| should be simply 'softfloat_exceptionFlags |= flags;'.
+*----------------------------------------------------------------------------*/
+void softfloat_raiseFlags( uint_fast8_t flags )
+{
+
+ softfloat_exceptionFlags |= flags;
+
+}
+
diff --git a/test/float/softfloat/source/ARM-VFPv2-defaultNaN/specialize.h b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/specialize.h
new file mode 100644
index 000000000..e4ea15d14
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2-defaultNaN/specialize.h
@@ -0,0 +1,407 @@
+
+/*============================================================================
+
+This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 The Regents of the
+University of California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#ifndef specialize_h
+#define specialize_h 1
+
+#include
+#include
+#include "primitiveTypes.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Default value for 'softfloat_detectTininess'.
+*----------------------------------------------------------------------------*/
+#define init_detectTininess softfloat_tininess_beforeRounding
+
+/*----------------------------------------------------------------------------
+| The values to return on conversions to 32-bit integer formats that raise an
+| invalid exception.
+*----------------------------------------------------------------------------*/
+#define ui32_fromPosOverflow 0xFFFFFFFF
+#define ui32_fromNegOverflow 0
+#define ui32_fromNaN 0
+#define i32_fromPosOverflow 0x7FFFFFFF
+#define i32_fromNegOverflow (-0x7FFFFFFF - 1)
+#define i32_fromNaN 0
+
+/*----------------------------------------------------------------------------
+| The values to return on conversions to 64-bit integer formats that raise an
+| invalid exception.
+*----------------------------------------------------------------------------*/
+#define ui64_fromPosOverflow UINT64_C( 0xFFFFFFFFFFFFFFFF )
+#define ui64_fromNegOverflow 0
+#define ui64_fromNaN 0
+#define i64_fromPosOverflow INT64_C( 0x7FFFFFFFFFFFFFFF )
+#define i64_fromNegOverflow (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
+#define i64_fromNaN 0
+
+/*----------------------------------------------------------------------------
+| "Common NaN" structure, used to transfer NaN representations from one format
+| to another.
+*----------------------------------------------------------------------------*/
+struct commonNaN { char _unused; };
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 16-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF16UI 0x7E00
+
+/*----------------------------------------------------------------------------
+| Returns true when 16-bit unsigned integer 'uiA' has the bit pattern of a
+| 16-bit floating-point signaling NaN.
+| Note: This macro evaluates its argument more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNF16UI( uiA ) ((((uiA) & 0x7E00) == 0x7C00) && ((uiA) & 0x01FF))
+
+/*----------------------------------------------------------------------------
+| Assuming 'uiA' has the bit pattern of a 16-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+#define softfloat_f16UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & 0x0200) ) softfloat_raiseFlags( softfloat_flag_invalid )
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+#define softfloat_commonNaNToF16UI( aPtr ) ((uint_fast16_t) defaultNaNF16UI)
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast16_t
+ softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 32-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF32UI 0x7FC00000
+
+/*----------------------------------------------------------------------------
+| Returns true when 32-bit unsigned integer 'uiA' has the bit pattern of a
+| 32-bit floating-point signaling NaN.
+| Note: This macro evaluates its argument more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNF32UI( uiA ) ((((uiA) & 0x7FC00000) == 0x7F800000) && ((uiA) & 0x003FFFFF))
+
+/*----------------------------------------------------------------------------
+| Assuming 'uiA' has the bit pattern of a 32-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+#define softfloat_f32UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & 0x00400000) ) softfloat_raiseFlags( softfloat_flag_invalid )
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+#define softfloat_commonNaNToF32UI( aPtr ) ((uint_fast32_t) defaultNaNF32UI)
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast32_t
+ softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 64-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF64UI UINT64_C( 0x7FF8000000000000 )
+
+/*----------------------------------------------------------------------------
+| Returns true when 64-bit unsigned integer 'uiA' has the bit pattern of a
+| 64-bit floating-point signaling NaN.
+| Note: This macro evaluates its argument more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNF64UI( uiA ) ((((uiA) & UINT64_C( 0x7FF8000000000000 )) == UINT64_C( 0x7FF0000000000000 )) && ((uiA) & UINT64_C( 0x0007FFFFFFFFFFFF )))
+
+/*----------------------------------------------------------------------------
+| Assuming 'uiA' has the bit pattern of a 64-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+#define softfloat_f64UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & UINT64_C( 0x0008000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+#define softfloat_commonNaNToF64UI( aPtr ) ((uint_fast64_t) defaultNaNF64UI)
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast64_t
+ softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 80-bit extended floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNExtF80UI64 0x7FFF
+#define defaultNaNExtF80UI0 UINT64_C( 0xC000000000000000 )
+
+/*----------------------------------------------------------------------------
+| Returns true when the 80-bit unsigned integer formed from concatenating
+| 16-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of an 80-bit extended
+| floating-point signaling NaN.
+| Note: This macro evaluates its arguments more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ((((uiA64) & 0x7FFF) == 0x7FFF) && ! ((uiA0) & UINT64_C( 0x4000000000000000 )) && ((uiA0) & UINT64_C( 0x3FFFFFFFFFFFFFFF )))
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+/*----------------------------------------------------------------------------
+| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is
+| defined.
+*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
+| has the bit pattern of an 80-bit extended floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+#define softfloat_extF80UIToCommonNaN( uiA64, uiA0, zPtr ) if ( ! ((uiA0) & UINT64_C( 0x4000000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
+| floating-point NaN, and returns the bit pattern of this value as an unsigned
+| integer.
+*----------------------------------------------------------------------------*/
+#if defined INLINE && ! defined softfloat_commonNaNToExtF80UI
+INLINE
+struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr )
+{
+ struct uint128 uiZ;
+ uiZ.v64 = defaultNaNExtF80UI64;
+ uiZ.v0 = defaultNaNExtF80UI0;
+ return uiZ;
+}
+#else
+struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr );
+#endif
+
+/*----------------------------------------------------------------------------
+| Interpreting the unsigned integer formed from concatenating 'uiA64' and
+| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting
+| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
+| 80-bit extended floating-point value, and assuming at least on of these
+| floating-point values is a NaN, returns the bit pattern of the combined NaN
+| result. If either original floating-point value is a signaling NaN, the
+| invalid exception is raised.
+*----------------------------------------------------------------------------*/
+struct uint128
+ softfloat_propagateNaNExtF80UI(
+ uint_fast16_t uiA64,
+ uint_fast64_t uiA0,
+ uint_fast16_t uiB64,
+ uint_fast64_t uiB0
+ );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 128-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF128UI64 UINT64_C( 0x7FFF800000000000 )
+#define defaultNaNF128UI0 UINT64_C( 0 )
+
+/*----------------------------------------------------------------------------
+| Returns true when the 128-bit unsigned integer formed from concatenating
+| 64-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of a 128-bit floating-
+| point signaling NaN.
+| Note: This macro evaluates its arguments more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNF128UI( uiA64, uiA0 ) ((((uiA64) & UINT64_C( 0x7FFF800000000000 )) == UINT64_C( 0x7FFF000000000000 )) && ((uiA0) || ((uiA64) & UINT64_C( 0x00007FFFFFFFFFFF ))))
+
+/*----------------------------------------------------------------------------
+| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
+| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to
+| the common NaN form, and stores the resulting common NaN at the location
+| pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid exception
+| is raised.
+*----------------------------------------------------------------------------*/
+#define softfloat_f128UIToCommonNaN( uiA64, uiA0, zPtr ) if ( ! ((uiA64) & UINT64_C( 0x0000800000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+#if defined INLINE && ! defined softfloat_commonNaNToF128UI
+INLINE
+struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN *aPtr )
+{
+ struct uint128 uiZ;
+ uiZ.v64 = defaultNaNF128UI64;
+ uiZ.v0 = defaultNaNF128UI0;
+ return uiZ;
+}
+#else
+struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN * );
+#endif
+
+/*----------------------------------------------------------------------------
+| Interpreting the unsigned integer formed from concatenating 'uiA64' and
+| 'uiA0' as a 128-bit floating-point value, and likewise interpreting the
+| unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
+| 128-bit floating-point value, and assuming at least on of these floating-
+| point values is a NaN, returns the bit pattern of the combined NaN result.
+| If either original floating-point value is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+struct uint128
+ softfloat_propagateNaNF128UI(
+ uint_fast64_t uiA64,
+ uint_fast64_t uiA0,
+ uint_fast64_t uiB64,
+ uint_fast64_t uiB0
+ );
+
+#else
+
+/*----------------------------------------------------------------------------
+| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is not
+| defined.
+*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+| Assuming the 80-bit extended floating-point value pointed to by 'aSPtr' is
+| a NaN, converts this NaN to the common NaN form, and stores the resulting
+| common NaN at the location pointed to by 'zPtr'. If the NaN is a signaling
+| NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+#define softfloat_extF80MToCommonNaN( aSPtr, zPtr ) if ( ! ((aSPtr)->signif & UINT64_C( 0x4000000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
+| floating-point NaN, and stores this NaN at the location pointed to by
+| 'zSPtr'.
+*----------------------------------------------------------------------------*/
+#if defined INLINE && ! defined softfloat_commonNaNToExtF80M
+INLINE
+void
+ softfloat_commonNaNToExtF80M(
+ const struct commonNaN *aPtr, struct extFloat80M *zSPtr )
+{
+ zSPtr->signExp = defaultNaNExtF80UI64;
+ zSPtr->signif = defaultNaNExtF80UI0;
+}
+#else
+void
+ softfloat_commonNaNToExtF80M(
+ const struct commonNaN *aPtr, struct extFloat80M *zSPtr );
+#endif
+
+/*----------------------------------------------------------------------------
+| Assuming at least one of the two 80-bit extended floating-point values
+| pointed to by 'aSPtr' and 'bSPtr' is a NaN, stores the combined NaN result
+| at the location pointed to by 'zSPtr'. If either original floating-point
+| value is a signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_propagateNaNExtF80M(
+ const struct extFloat80M *aSPtr,
+ const struct extFloat80M *bSPtr,
+ struct extFloat80M *zSPtr
+ );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 128-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF128UI96 0x7FFF8000
+#define defaultNaNF128UI64 0
+#define defaultNaNF128UI32 0
+#define defaultNaNF128UI0 0
+
+/*----------------------------------------------------------------------------
+| Assuming the 128-bit floating-point value pointed to by 'aWPtr' is a NaN,
+| converts this NaN to the common NaN form, and stores the resulting common
+| NaN at the location pointed to by 'zPtr'. If the NaN is a signaling NaN,
+| the invalid exception is raised. Argument 'aWPtr' points to an array of
+| four 32-bit elements that concatenate in the platform's normal endian order
+| to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+#define softfloat_f128MToCommonNaN( aWPtr, zPtr ) if ( ! ((aWPtr)[indexWordHi( 4 )] & UINT64_C( 0x0000800000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
+| NaN, and stores this NaN at the location pointed to by 'zWPtr'. Argument
+| 'zWPtr' points to an array of four 32-bit elements that concatenate in the
+| platform's normal endian order to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+#if defined INLINE && ! defined softfloat_commonNaNToF128M
+INLINE
+void
+ softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr )
+{
+ zWPtr[indexWord( 4, 3 )] = defaultNaNF128UI96;
+ zWPtr[indexWord( 4, 2 )] = defaultNaNF128UI64;
+ zWPtr[indexWord( 4, 1 )] = defaultNaNF128UI32;
+ zWPtr[indexWord( 4, 0 )] = defaultNaNF128UI0;
+}
+#else
+void
+ softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr );
+#endif
+
+/*----------------------------------------------------------------------------
+| Assuming at least one of the two 128-bit floating-point values pointed to by
+| 'aWPtr' and 'bWPtr' is a NaN, stores the combined NaN result at the location
+| pointed to by 'zWPtr'. If either original floating-point value is a
+| signaling NaN, the invalid exception is raised. Each of 'aWPtr', 'bWPtr',
+| and 'zWPtr' points to an array of four 32-bit elements that concatenate in
+| the platform's normal endian order to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_propagateNaNF128M(
+ const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr );
+
+#endif
+
+#endif
+
diff --git a/test/float/softfloat/source/ARM-VFPv2/extF80M_isSignalingNaN.c b/test/float/softfloat/source/ARM-VFPv2/extF80M_isSignalingNaN.c
new file mode 100644
index 000000000..c2cca65c9
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2/extF80M_isSignalingNaN.c
@@ -0,0 +1,57 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+bool extF80M_isSignalingNaN( const extFloat80_t *aPtr )
+{
+ const struct extFloat80M *aSPtr;
+ uint64_t uiA0;
+
+ aSPtr = (const struct extFloat80M *) aPtr;
+ if ( (aSPtr->signExp & 0x7FFF) != 0x7FFF ) return false;
+ uiA0 = aSPtr->signif;
+ return
+ ! (uiA0 & UINT64_C( 0x4000000000000000 ))
+ && (uiA0 & UINT64_C( 0x3FFFFFFFFFFFFFFF));
+
+}
+
diff --git a/test/float/softfloat/source/ARM-VFPv2/f128M_isSignalingNaN.c b/test/float/softfloat/source/ARM-VFPv2/f128M_isSignalingNaN.c
new file mode 100644
index 000000000..9ff83d726
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2/f128M_isSignalingNaN.c
@@ -0,0 +1,60 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "primitives.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+bool f128M_isSignalingNaN( const float128_t *aPtr )
+{
+ const uint32_t *aWPtr;
+ uint32_t uiA96;
+
+ aWPtr = (const uint32_t *) aPtr;
+ uiA96 = aWPtr[indexWordHi( 4 )];
+ if ( (uiA96 & 0x7FFF8000) != 0x7FFF0000 ) return false;
+ return
+ ((uiA96 & 0x00007FFF) != 0)
+ || ((aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
+ | aWPtr[indexWord( 4, 0 )])
+ != 0);
+
+}
+
diff --git a/test/float/softfloat/source/ARM-VFPv2/s_commonNaNToExtF80M.c b/test/float/softfloat/source/ARM-VFPv2/s_commonNaNToExtF80M.c
new file mode 100644
index 000000000..6bb922a1d
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2/s_commonNaNToExtF80M.c
@@ -0,0 +1,56 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
+| floating-point NaN, and stores this NaN at the location pointed to by
+| 'zSPtr'.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_commonNaNToExtF80M(
+ const struct commonNaN *aPtr, struct extFloat80M *zSPtr )
+{
+
+ zSPtr->signExp = packToExtF80UI64( aPtr->sign, 0x7FFF );
+ zSPtr->signif = UINT64_C( 0xC000000000000000 ) | aPtr->v64>>1;
+
+}
+
diff --git a/test/float/softfloat/source/ARM-VFPv2/s_commonNaNToExtF80UI.c b/test/float/softfloat/source/ARM-VFPv2/s_commonNaNToExtF80UI.c
new file mode 100644
index 000000000..5e841b253
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2/s_commonNaNToExtF80UI.c
@@ -0,0 +1,56 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "primitives.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
+| floating-point NaN, and returns the bit pattern of this value as an unsigned
+| integer.
+*----------------------------------------------------------------------------*/
+struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr )
+{
+ struct uint128 uiZ;
+
+ uiZ.v64 = (uint_fast16_t) aPtr->sign<<15 | 0x7FFF;
+ uiZ.v0 = UINT64_C( 0xC000000000000000 ) | aPtr->v64>>1;
+ return uiZ;
+
+}
+
diff --git a/test/float/softfloat/source/ARM-VFPv2/s_commonNaNToF128M.c b/test/float/softfloat/source/ARM-VFPv2/s_commonNaNToF128M.c
new file mode 100644
index 000000000..02e234853
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2/s_commonNaNToF128M.c
@@ -0,0 +1,56 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "primitives.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
+| NaN, and stores this NaN at the location pointed to by 'zWPtr'. Argument
+| 'zWPtr' points to an array of four 32-bit elements that concatenate in the
+| platform's normal endian order to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr )
+{
+
+ softfloat_shortShiftRight128M( (const uint32_t *) &aPtr->v0, 16, zWPtr );
+ zWPtr[indexWordHi( 4 )] |= (uint32_t) aPtr->sign<<31 | 0x7FFF8000;
+
+}
+
diff --git a/test/float/softfloat/source/ARM-VFPv2/s_commonNaNToF128UI.c b/test/float/softfloat/source/ARM-VFPv2/s_commonNaNToF128UI.c
new file mode 100644
index 000000000..fa87d75fa
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2/s_commonNaNToF128UI.c
@@ -0,0 +1,55 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "primitives.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN *aPtr )
+{
+ struct uint128 uiZ;
+
+ uiZ = softfloat_shortShiftRight128( aPtr->v64, aPtr->v0, 16 );
+ uiZ.v64 |= (uint_fast64_t) aPtr->sign<<63 | UINT64_C( 0x7FFF800000000000 );
+ return uiZ;
+
+}
+
diff --git a/test/float/softfloat/source/ARM-VFPv2/s_commonNaNToF16UI.c b/test/float/softfloat/source/ARM-VFPv2/s_commonNaNToF16UI.c
new file mode 100644
index 000000000..6d5bf9ab3
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2/s_commonNaNToF16UI.c
@@ -0,0 +1,51 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr )
+{
+
+ return (uint_fast16_t) aPtr->sign<<15 | 0x7E00 | aPtr->v64>>54;
+
+}
+
diff --git a/test/float/softfloat/source/ARM-VFPv2/s_commonNaNToF32UI.c b/test/float/softfloat/source/ARM-VFPv2/s_commonNaNToF32UI.c
new file mode 100644
index 000000000..e45d63b3b
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2/s_commonNaNToF32UI.c
@@ -0,0 +1,51 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr )
+{
+
+ return (uint_fast32_t) aPtr->sign<<31 | 0x7FC00000 | aPtr->v64>>41;
+
+}
+
diff --git a/test/float/softfloat/source/ARM-VFPv2/s_commonNaNToF64UI.c b/test/float/softfloat/source/ARM-VFPv2/s_commonNaNToF64UI.c
new file mode 100644
index 000000000..bfde88bbc
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2/s_commonNaNToF64UI.c
@@ -0,0 +1,53 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr )
+{
+
+ return
+ (uint_fast64_t) aPtr->sign<<63 | UINT64_C( 0x7FF8000000000000 )
+ | aPtr->v64>>12;
+
+}
+
diff --git a/test/float/softfloat/source/ARM-VFPv2/s_extF80MToCommonNaN.c b/test/float/softfloat/source/ARM-VFPv2/s_extF80MToCommonNaN.c
new file mode 100644
index 000000000..5fd54dbbd
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2/s_extF80MToCommonNaN.c
@@ -0,0 +1,62 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming the 80-bit extended floating-point value pointed to by 'aSPtr' is
+| a NaN, converts this NaN to the common NaN form, and stores the resulting
+| common NaN at the location pointed to by 'zPtr'. If the NaN is a signaling
+| NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_extF80MToCommonNaN(
+ const struct extFloat80M *aSPtr, struct commonNaN *zPtr )
+{
+
+ if ( extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ }
+ zPtr->sign = signExtF80UI64( aSPtr->signExp );
+ zPtr->v64 = aSPtr->signif<<1;
+ zPtr->v0 = 0;
+
+}
+
diff --git a/test/float/softfloat/source/ARM-VFPv2/s_extF80UIToCommonNaN.c b/test/float/softfloat/source/ARM-VFPv2/s_extF80UIToCommonNaN.c
new file mode 100644
index 000000000..9c0f0ca08
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2/s_extF80UIToCommonNaN.c
@@ -0,0 +1,62 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
+| has the bit pattern of an 80-bit extended floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_extF80UIToCommonNaN(
+ uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
+{
+
+ if ( softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ }
+ zPtr->sign = uiA64>>15;
+ zPtr->v64 = uiA0<<1;
+ zPtr->v0 = 0;
+
+}
+
diff --git a/test/float/softfloat/source/ARM-VFPv2/s_f128MToCommonNaN.c b/test/float/softfloat/source/ARM-VFPv2/s_f128MToCommonNaN.c
new file mode 100644
index 000000000..e54756b10
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2/s_f128MToCommonNaN.c
@@ -0,0 +1,62 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "primitives.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming the 128-bit floating-point value pointed to by 'aWPtr' is a NaN,
+| converts this NaN to the common NaN form, and stores the resulting common
+| NaN at the location pointed to by 'zPtr'. If the NaN is a signaling NaN,
+| the invalid exception is raised. Argument 'aWPtr' points to an array of
+| four 32-bit elements that concatenate in the platform's normal endian order
+| to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr )
+{
+
+ if ( f128M_isSignalingNaN( (const float128_t *) aWPtr ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ }
+ zPtr->sign = aWPtr[indexWordHi( 4 )]>>31;
+ softfloat_shortShiftLeft128M( aWPtr, 16, (uint32_t *) &zPtr->v0 );
+
+}
+
diff --git a/test/float/softfloat/source/ARM-VFPv2/s_f128UIToCommonNaN.c b/test/float/softfloat/source/ARM-VFPv2/s_f128UIToCommonNaN.c
new file mode 100644
index 000000000..27952a775
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2/s_f128UIToCommonNaN.c
@@ -0,0 +1,65 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "primitives.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
+| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to
+| the common NaN form, and stores the resulting common NaN at the location
+| pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid exception
+| is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_f128UIToCommonNaN(
+ uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
+{
+ struct uint128 NaNSig;
+
+ if ( softfloat_isSigNaNF128UI( uiA64, uiA0 ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ }
+ NaNSig = softfloat_shortShiftLeft128( uiA64, uiA0, 16 );
+ zPtr->sign = uiA64>>63;
+ zPtr->v64 = NaNSig.v64;
+ zPtr->v0 = NaNSig.v0;
+
+}
+
diff --git a/test/float/softfloat/source/ARM-VFPv2/s_f16UIToCommonNaN.c b/test/float/softfloat/source/ARM-VFPv2/s_f16UIToCommonNaN.c
new file mode 100644
index 000000000..ee1928eb3
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2/s_f16UIToCommonNaN.c
@@ -0,0 +1,59 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming 'uiA' has the bit pattern of a 16-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr )
+{
+
+ if ( softfloat_isSigNaNF16UI( uiA ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ }
+ zPtr->sign = uiA>>15;
+ zPtr->v64 = (uint_fast64_t) uiA<<54;
+ zPtr->v0 = 0;
+
+}
+
diff --git a/test/float/softfloat/source/ARM-VFPv2/s_f32UIToCommonNaN.c b/test/float/softfloat/source/ARM-VFPv2/s_f32UIToCommonNaN.c
new file mode 100644
index 000000000..249e47825
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2/s_f32UIToCommonNaN.c
@@ -0,0 +1,59 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming 'uiA' has the bit pattern of a 32-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr )
+{
+
+ if ( softfloat_isSigNaNF32UI( uiA ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ }
+ zPtr->sign = uiA>>31;
+ zPtr->v64 = (uint_fast64_t) uiA<<41;
+ zPtr->v0 = 0;
+
+}
+
diff --git a/test/float/softfloat/source/ARM-VFPv2/s_f64UIToCommonNaN.c b/test/float/softfloat/source/ARM-VFPv2/s_f64UIToCommonNaN.c
new file mode 100644
index 000000000..adca2d047
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2/s_f64UIToCommonNaN.c
@@ -0,0 +1,59 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming 'uiA' has the bit pattern of a 64-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr )
+{
+
+ if ( softfloat_isSigNaNF64UI( uiA ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ }
+ zPtr->sign = uiA>>63;
+ zPtr->v64 = uiA<<12;
+ zPtr->v0 = 0;
+
+}
+
diff --git a/test/float/softfloat/source/ARM-VFPv2/s_propagateNaNExtF80M.c b/test/float/softfloat/source/ARM-VFPv2/s_propagateNaNExtF80M.c
new file mode 100644
index 000000000..1c142562e
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2/s_propagateNaNExtF80M.c
@@ -0,0 +1,86 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming at least one of the two 80-bit extended floating-point values
+| pointed to by 'aSPtr' and 'bSPtr' is a NaN, stores the combined NaN result
+| at the location pointed to by 'zSPtr'. If either original floating-point
+| value is a signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_propagateNaNExtF80M(
+ const struct extFloat80M *aSPtr,
+ const struct extFloat80M *bSPtr,
+ struct extFloat80M *zSPtr
+ )
+{
+ const struct extFloat80M *sPtr;
+ bool isSigNaNA;
+ uint_fast16_t uiZ64;
+ uint_fast64_t uiZ0;
+
+ sPtr = aSPtr;
+ isSigNaNA = extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr );
+ if (
+ isSigNaNA
+ || (bSPtr
+ && extF80M_isSignalingNaN( (const extFloat80_t *) bSPtr ))
+ ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ if ( isSigNaNA ) goto copyNonsig;
+ goto copyNonsigB;
+ }
+ uiZ64 = sPtr->signExp;
+ uiZ0 = sPtr->signif;
+ if ( isNaNExtF80UI( uiZ64, uiZ0 ) ) goto returnNonsig;
+ copyNonsigB:
+ sPtr = bSPtr;
+ copyNonsig:
+ uiZ64 = sPtr->signExp;
+ uiZ0 = sPtr->signif;
+ returnNonsig:
+ zSPtr->signExp = uiZ64;
+ zSPtr->signif = uiZ0 | UINT64_C( 0xC000000000000000 );
+
+}
+
diff --git a/test/float/softfloat/source/ARM-VFPv2/s_propagateNaNExtF80UI.c b/test/float/softfloat/source/ARM-VFPv2/s_propagateNaNExtF80UI.c
new file mode 100644
index 000000000..be95414ac
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2/s_propagateNaNExtF80UI.c
@@ -0,0 +1,83 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting the unsigned integer formed from concatenating 'uiA64' and
+| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting
+| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
+| 80-bit extended floating-point value, and assuming at least on of these
+| floating-point values is a NaN, returns the bit pattern of the combined NaN
+| result. If either original floating-point value is a signaling NaN, the
+| invalid exception is raised.
+*----------------------------------------------------------------------------*/
+struct uint128
+ softfloat_propagateNaNExtF80UI(
+ uint_fast16_t uiA64,
+ uint_fast64_t uiA0,
+ uint_fast16_t uiB64,
+ uint_fast64_t uiB0
+ )
+{
+ bool isSigNaNA;
+ struct uint128 uiZ;
+
+ isSigNaNA = softfloat_isSigNaNExtF80UI( uiA64, uiA0 );
+ if ( isSigNaNA || softfloat_isSigNaNExtF80UI( uiB64, uiB0 ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ if ( isSigNaNA ) goto returnNonsigA;
+ goto returnNonsigB;
+ }
+ if ( isNaNExtF80UI( uiA64, uiA0 ) ) {
+ returnNonsigA:
+ uiZ.v64 = uiA64;
+ uiZ.v0 = uiA0;
+ } else {
+ returnNonsigB:
+ uiZ.v64 = uiB64;
+ uiZ.v0 = uiB0;
+ }
+ uiZ.v0 | UINT64_C( 0xC000000000000000 );
+ return uiZ;
+
+}
+
diff --git a/test/float/softfloat/source/ARM-VFPv2/s_propagateNaNF128M.c b/test/float/softfloat/source/ARM-VFPv2/s_propagateNaNF128M.c
new file mode 100644
index 000000000..6a30052cb
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2/s_propagateNaNF128M.c
@@ -0,0 +1,77 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming at least one of the two 128-bit floating-point values pointed to by
+| 'aWPtr' and 'bWPtr' is a NaN, stores the combined NaN result at the location
+| pointed to by 'zWPtr'. If either original floating-point value is a
+| signaling NaN, the invalid exception is raised. Each of 'aWPtr', 'bWPtr',
+| and 'zWPtr' points to an array of four 32-bit elements that concatenate in
+| the platform's normal endian order to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_propagateNaNF128M(
+ const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr )
+{
+ const uint32_t *ptr;
+ bool isSigNaNA;
+
+ ptr = aWPtr;
+ isSigNaNA = f128M_isSignalingNaN( (const float128_t *) aWPtr );
+ if (
+ isSigNaNA
+ || (bWPtr && f128M_isSignalingNaN( (const float128_t *) bWPtr ))
+ ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ if ( ! isSigNaNA ) ptr = bWPtr;
+ goto copyNonsig;
+ }
+ if ( ! softfloat_isNaNF128M( aWPtr ) ) ptr = bWPtr;
+ copyNonsig:
+ zWPtr[indexWordHi( 4 )] = ptr[indexWordHi( 4 )] | 0x00008000;
+ zWPtr[indexWord( 4, 2 )] = ptr[indexWord( 4, 2 )];
+ zWPtr[indexWord( 4, 1 )] = ptr[indexWord( 4, 1 )];
+ zWPtr[indexWord( 4, 0 )] = ptr[indexWord( 4, 0 )];
+
+}
+
diff --git a/test/float/softfloat/source/ARM-VFPv2/s_propagateNaNF128UI.c b/test/float/softfloat/source/ARM-VFPv2/s_propagateNaNF128UI.c
new file mode 100644
index 000000000..5aece622e
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2/s_propagateNaNF128UI.c
@@ -0,0 +1,83 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting the unsigned integer formed from concatenating 'uiA64' and
+| 'uiA0' as a 128-bit floating-point value, and likewise interpreting the
+| unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
+| 128-bit floating-point value, and assuming at least on of these floating-
+| point values is a NaN, returns the bit pattern of the combined NaN result.
+| If either original floating-point value is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+struct uint128
+ softfloat_propagateNaNF128UI(
+ uint_fast64_t uiA64,
+ uint_fast64_t uiA0,
+ uint_fast64_t uiB64,
+ uint_fast64_t uiB0
+ )
+{
+ bool isSigNaNA;
+ struct uint128 uiZ;
+
+ isSigNaNA = softfloat_isSigNaNF128UI( uiA64, uiA0 );
+ if ( isSigNaNA || softfloat_isSigNaNF128UI( uiB64, uiB0 ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ if ( isSigNaNA ) goto returnNonsigA;
+ goto returnNonsigB;
+ }
+ if ( isNaNF128UI( uiA64, uiA0 ) ) {
+ returnNonsigA:
+ uiZ.v64 = uiA64;
+ uiZ.v0 = uiA0;
+ } else {
+ returnNonsigB:
+ uiZ.v64 = uiB64;
+ uiZ.v0 = uiB0;
+ }
+ uiZ.v64 |= UINT64_C( 0x0000800000000000 );
+ return uiZ;
+
+}
+
diff --git a/test/float/softfloat/source/ARM-VFPv2/s_propagateNaNF16UI.c b/test/float/softfloat/source/ARM-VFPv2/s_propagateNaNF16UI.c
new file mode 100644
index 000000000..880146033
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2/s_propagateNaNF16UI.c
@@ -0,0 +1,63 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast16_t
+ softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB )
+{
+ bool isSigNaNA;
+
+ isSigNaNA = softfloat_isSigNaNF16UI( uiA );
+ if ( isSigNaNA || softfloat_isSigNaNF16UI( uiB ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ return (isSigNaNA ? uiA : uiB) | 0x0200;
+ }
+ return isNaNF16UI( uiA ) ? uiA : uiB;
+
+}
+
diff --git a/test/float/softfloat/source/ARM-VFPv2/s_propagateNaNF32UI.c b/test/float/softfloat/source/ARM-VFPv2/s_propagateNaNF32UI.c
new file mode 100644
index 000000000..31b289e9d
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2/s_propagateNaNF32UI.c
@@ -0,0 +1,63 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast32_t
+ softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB )
+{
+ bool isSigNaNA;
+
+ isSigNaNA = softfloat_isSigNaNF32UI( uiA );
+ if ( isSigNaNA || softfloat_isSigNaNF32UI( uiB ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ return (isSigNaNA ? uiA : uiB) | 0x00400000;
+ }
+ return isNaNF32UI( uiA ) ? uiA : uiB;
+
+}
+
diff --git a/test/float/softfloat/source/ARM-VFPv2/s_propagateNaNF64UI.c b/test/float/softfloat/source/ARM-VFPv2/s_propagateNaNF64UI.c
new file mode 100644
index 000000000..224049ab1
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2/s_propagateNaNF64UI.c
@@ -0,0 +1,63 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast64_t
+ softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB )
+{
+ bool isSigNaNA;
+
+ isSigNaNA = softfloat_isSigNaNF64UI( uiA );
+ if ( isSigNaNA || softfloat_isSigNaNF64UI( uiB ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ return (isSigNaNA ? uiA : uiB) | UINT64_C( 0x0008000000000000 );
+ }
+ return isNaNF64UI( uiA ) ? uiA : uiB;
+
+}
+
diff --git a/test/float/softfloat/source/ARM-VFPv2/softfloat_raiseFlags.c b/test/float/softfloat/source/ARM-VFPv2/softfloat_raiseFlags.c
new file mode 100644
index 000000000..f8f106570
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2/softfloat_raiseFlags.c
@@ -0,0 +1,52 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include "platform.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Raises the exceptions specified by 'flags'. Floating-point traps can be
+| defined here if desired. It is currently not possible for such a trap
+| to substitute a result value. If traps are not implemented, this routine
+| should be simply 'softfloat_exceptionFlags |= flags;'.
+*----------------------------------------------------------------------------*/
+void softfloat_raiseFlags( uint_fast8_t flags )
+{
+
+ softfloat_exceptionFlags |= flags;
+
+}
+
diff --git a/test/float/softfloat/source/ARM-VFPv2/specialize.h b/test/float/softfloat/source/ARM-VFPv2/specialize.h
new file mode 100644
index 000000000..10b0b357f
--- /dev/null
+++ b/test/float/softfloat/source/ARM-VFPv2/specialize.h
@@ -0,0 +1,376 @@
+
+/*============================================================================
+
+This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 The Regents of the
+University of California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#ifndef specialize_h
+#define specialize_h 1
+
+#include
+#include
+#include "primitiveTypes.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Default value for 'softfloat_detectTininess'.
+*----------------------------------------------------------------------------*/
+#define init_detectTininess softfloat_tininess_beforeRounding
+
+/*----------------------------------------------------------------------------
+| The values to return on conversions to 32-bit integer formats that raise an
+| invalid exception.
+*----------------------------------------------------------------------------*/
+#define ui32_fromPosOverflow 0xFFFFFFFF
+#define ui32_fromNegOverflow 0
+#define ui32_fromNaN 0
+#define i32_fromPosOverflow 0x7FFFFFFF
+#define i32_fromNegOverflow (-0x7FFFFFFF - 1)
+#define i32_fromNaN 0
+
+/*----------------------------------------------------------------------------
+| The values to return on conversions to 64-bit integer formats that raise an
+| invalid exception.
+*----------------------------------------------------------------------------*/
+#define ui64_fromPosOverflow UINT64_C( 0xFFFFFFFFFFFFFFFF )
+#define ui64_fromNegOverflow 0
+#define ui64_fromNaN 0
+#define i64_fromPosOverflow INT64_C( 0x7FFFFFFFFFFFFFFF )
+#define i64_fromNegOverflow (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
+#define i64_fromNaN 0
+
+/*----------------------------------------------------------------------------
+| "Common NaN" structure, used to transfer NaN representations from one format
+| to another.
+*----------------------------------------------------------------------------*/
+struct commonNaN {
+ bool sign;
+#ifdef LITTLEENDIAN
+ uint64_t v0, v64;
+#else
+ uint64_t v64, v0;
+#endif
+};
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 16-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF16UI 0x7E00
+
+/*----------------------------------------------------------------------------
+| Returns true when 16-bit unsigned integer 'uiA' has the bit pattern of a
+| 16-bit floating-point signaling NaN.
+| Note: This macro evaluates its argument more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNF16UI( uiA ) ((((uiA) & 0x7E00) == 0x7C00) && ((uiA) & 0x01FF))
+
+/*----------------------------------------------------------------------------
+| Assuming 'uiA' has the bit pattern of a 16-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr );
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast16_t
+ softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 32-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF32UI 0x7FC00000
+
+/*----------------------------------------------------------------------------
+| Returns true when 32-bit unsigned integer 'uiA' has the bit pattern of a
+| 32-bit floating-point signaling NaN.
+| Note: This macro evaluates its argument more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNF32UI( uiA ) ((((uiA) & 0x7FC00000) == 0x7F800000) && ((uiA) & 0x003FFFFF))
+
+/*----------------------------------------------------------------------------
+| Assuming 'uiA' has the bit pattern of a 32-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr );
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast32_t
+ softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 64-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF64UI UINT64_C( 0x7FF8000000000000 )
+
+/*----------------------------------------------------------------------------
+| Returns true when 64-bit unsigned integer 'uiA' has the bit pattern of a
+| 64-bit floating-point signaling NaN.
+| Note: This macro evaluates its argument more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNF64UI( uiA ) ((((uiA) & UINT64_C( 0x7FF8000000000000 )) == UINT64_C( 0x7FF0000000000000 )) && ((uiA) & UINT64_C( 0x0007FFFFFFFFFFFF )))
+
+/*----------------------------------------------------------------------------
+| Assuming 'uiA' has the bit pattern of a 64-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr );
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast64_t
+ softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 80-bit extended floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNExtF80UI64 0x7FFF
+#define defaultNaNExtF80UI0 UINT64_C( 0xC000000000000000 )
+
+/*----------------------------------------------------------------------------
+| Returns true when the 80-bit unsigned integer formed from concatenating
+| 16-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of an 80-bit extended
+| floating-point signaling NaN.
+| Note: This macro evaluates its arguments more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ((((uiA64) & 0x7FFF) == 0x7FFF) && ! ((uiA0) & UINT64_C( 0x4000000000000000 )) && ((uiA0) & UINT64_C( 0x3FFFFFFFFFFFFFFF )))
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+/*----------------------------------------------------------------------------
+| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is
+| defined.
+*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
+| has the bit pattern of an 80-bit extended floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_extF80UIToCommonNaN(
+ uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
+| floating-point NaN, and returns the bit pattern of this value as an unsigned
+| integer.
+*----------------------------------------------------------------------------*/
+struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr );
+
+/*----------------------------------------------------------------------------
+| Interpreting the unsigned integer formed from concatenating 'uiA64' and
+| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting
+| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
+| 80-bit extended floating-point value, and assuming at least on of these
+| floating-point values is a NaN, returns the bit pattern of the combined NaN
+| result. If either original floating-point value is a signaling NaN, the
+| invalid exception is raised.
+*----------------------------------------------------------------------------*/
+struct uint128
+ softfloat_propagateNaNExtF80UI(
+ uint_fast16_t uiA64,
+ uint_fast64_t uiA0,
+ uint_fast16_t uiB64,
+ uint_fast64_t uiB0
+ );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 128-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF128UI64 UINT64_C( 0x7FFF800000000000 )
+#define defaultNaNF128UI0 UINT64_C( 0 )
+
+/*----------------------------------------------------------------------------
+| Returns true when the 128-bit unsigned integer formed from concatenating
+| 64-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of a 128-bit floating-
+| point signaling NaN.
+| Note: This macro evaluates its arguments more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNF128UI( uiA64, uiA0 ) ((((uiA64) & UINT64_C( 0x7FFF800000000000 )) == UINT64_C( 0x7FFF000000000000 )) && ((uiA0) || ((uiA64) & UINT64_C( 0x00007FFFFFFFFFFF ))))
+
+/*----------------------------------------------------------------------------
+| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
+| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to
+| the common NaN form, and stores the resulting common NaN at the location
+| pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid exception
+| is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_f128UIToCommonNaN(
+ uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN * );
+
+/*----------------------------------------------------------------------------
+| Interpreting the unsigned integer formed from concatenating 'uiA64' and
+| 'uiA0' as a 128-bit floating-point value, and likewise interpreting the
+| unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
+| 128-bit floating-point value, and assuming at least on of these floating-
+| point values is a NaN, returns the bit pattern of the combined NaN result.
+| If either original floating-point value is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+struct uint128
+ softfloat_propagateNaNF128UI(
+ uint_fast64_t uiA64,
+ uint_fast64_t uiA0,
+ uint_fast64_t uiB64,
+ uint_fast64_t uiB0
+ );
+
+#else
+
+/*----------------------------------------------------------------------------
+| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is not
+| defined.
+*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+| Assuming the 80-bit extended floating-point value pointed to by 'aSPtr' is
+| a NaN, converts this NaN to the common NaN form, and stores the resulting
+| common NaN at the location pointed to by 'zPtr'. If the NaN is a signaling
+| NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_extF80MToCommonNaN(
+ const struct extFloat80M *aSPtr, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
+| floating-point NaN, and stores this NaN at the location pointed to by
+| 'zSPtr'.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_commonNaNToExtF80M(
+ const struct commonNaN *aPtr, struct extFloat80M *zSPtr );
+
+/*----------------------------------------------------------------------------
+| Assuming at least one of the two 80-bit extended floating-point values
+| pointed to by 'aSPtr' and 'bSPtr' is a NaN, stores the combined NaN result
+| at the location pointed to by 'zSPtr'. If either original floating-point
+| value is a signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_propagateNaNExtF80M(
+ const struct extFloat80M *aSPtr,
+ const struct extFloat80M *bSPtr,
+ struct extFloat80M *zSPtr
+ );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 128-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF128UI96 0x7FFF8000
+#define defaultNaNF128UI64 0
+#define defaultNaNF128UI32 0
+#define defaultNaNF128UI0 0
+
+/*----------------------------------------------------------------------------
+| Assuming the 128-bit floating-point value pointed to by 'aWPtr' is a NaN,
+| converts this NaN to the common NaN form, and stores the resulting common
+| NaN at the location pointed to by 'zPtr'. If the NaN is a signaling NaN,
+| the invalid exception is raised. Argument 'aWPtr' points to an array of
+| four 32-bit elements that concatenate in the platform's normal endian order
+| to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
+| NaN, and stores this NaN at the location pointed to by 'zWPtr'. Argument
+| 'zWPtr' points to an array of four 32-bit elements that concatenate in the
+| platform's normal endian order to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr );
+
+/*----------------------------------------------------------------------------
+| Assuming at least one of the two 128-bit floating-point values pointed to by
+| 'aWPtr' and 'bWPtr' is a NaN, stores the combined NaN result at the location
+| pointed to by 'zWPtr'. If either original floating-point value is a
+| signaling NaN, the invalid exception is raised. Each of 'aWPtr', 'bWPtr',
+| and 'zWPtr' points to an array of four 32-bit elements that concatenate in
+| the platform's normal endian order to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_propagateNaNF128M(
+ const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr );
+
+#endif
+
+#endif
+
diff --git a/test/float/softfloat/source/extF80M_add.c b/test/float/softfloat/source/extF80M_add.c
new file mode 100644
index 000000000..4ba6a311c
--- /dev/null
+++ b/test/float/softfloat/source/extF80M_add.c
@@ -0,0 +1,100 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void
+ extF80M_add(
+ const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+{
+ const struct extFloat80M *aSPtr, *bSPtr;
+ uint_fast16_t uiA64;
+ uint_fast64_t uiA0;
+ bool signA;
+ uint_fast16_t uiB64;
+ uint_fast64_t uiB0;
+ bool signB;
+#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
+ extFloat80_t
+ (*magsFuncPtr)(
+ uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool );
+#endif
+
+ aSPtr = (const struct extFloat80M *) aPtr;
+ bSPtr = (const struct extFloat80M *) bPtr;
+ uiA64 = aSPtr->signExp;
+ uiA0 = aSPtr->signif;
+ signA = signExtF80UI64( uiA64 );
+ uiB64 = bSPtr->signExp;
+ uiB0 = bSPtr->signif;
+ signB = signExtF80UI64( uiB64 );
+#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
+ if ( signA == signB ) {
+ *zPtr = softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
+ } else {
+ *zPtr = softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
+ }
+#else
+ magsFuncPtr =
+ (signA == signB) ? softfloat_addMagsExtF80 : softfloat_subMagsExtF80;
+ *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
+#endif
+
+}
+
+#else
+
+void
+ extF80M_add(
+ const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+{
+
+ softfloat_addExtF80M(
+ (const struct extFloat80M *) aPtr,
+ (const struct extFloat80M *) bPtr,
+ (struct extFloat80M *) zPtr,
+ false
+ );
+
+}
+
+#endif
+
diff --git a/test/float/softfloat/source/extF80M_div.c b/test/float/softfloat/source/extF80M_div.c
new file mode 100644
index 000000000..24c069a98
--- /dev/null
+++ b/test/float/softfloat/source/extF80M_div.c
@@ -0,0 +1,194 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void
+ extF80M_div(
+ const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+{
+
+ *zPtr = extF80_div( *aPtr, *bPtr );
+
+}
+
+#else
+
+void
+ extF80M_div(
+ const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+{
+ const struct extFloat80M *aSPtr, *bSPtr;
+ struct extFloat80M *zSPtr;
+ uint_fast16_t uiA64;
+ int32_t expA;
+ uint_fast16_t uiB64;
+ int32_t expB;
+ bool signZ;
+ uint64_t sigA, x64;
+ int32_t expZ;
+ int shiftDist;
+ uint32_t y[3], recip32, sigB[3];
+ int ix;
+ uint32_t q, qs[2];
+ uint_fast16_t uiZ64;
+ uint64_t uiZ0;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ aSPtr = (const struct extFloat80M *) aPtr;
+ bSPtr = (const struct extFloat80M *) bPtr;
+ zSPtr = (struct extFloat80M *) zPtr;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uiA64 = aSPtr->signExp;
+ expA = expExtF80UI64( uiA64 );
+ uiB64 = bSPtr->signExp;
+ expB = expExtF80UI64( uiB64 );
+ signZ = signExtF80UI64( uiA64 ) ^ signExtF80UI64( uiB64 );
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
+ if ( softfloat_tryPropagateNaNExtF80M( aSPtr, bSPtr, zSPtr ) ) return;
+ if ( expA == 0x7FFF ) {
+ if ( expB == 0x7FFF ) goto invalid;
+ goto infinity;
+ }
+ goto zero;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ sigA = aSPtr->signif;
+ x64 = bSPtr->signif;
+ if ( ! expB ) expB = 1;
+ if ( ! (x64 & UINT64_C( 0x8000000000000000 )) ) {
+ if ( ! x64 ) {
+ if ( ! sigA ) goto invalid;
+ softfloat_raiseFlags( softfloat_flag_infinite );
+ goto infinity;
+ }
+ expB += softfloat_normExtF80SigM( &x64 );
+ }
+ if ( ! expA ) expA = 1;
+ if ( ! (sigA & UINT64_C( 0x8000000000000000 )) ) {
+ if ( ! sigA ) goto zero;
+ expA += softfloat_normExtF80SigM( &sigA );
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ expZ = expA - expB + 0x3FFF;
+ shiftDist = 29;
+ if ( sigA < x64 ) {
+ --expZ;
+ shiftDist = 30;
+ }
+ softfloat_shortShiftLeft64To96M( sigA, shiftDist, y );
+ recip32 = softfloat_approxRecip32_1( x64>>32 );
+ sigB[indexWord( 3, 0 )] = (uint32_t) x64<<30;
+ x64 >>= 2;
+ sigB[indexWord( 3, 2 )] = x64>>32;
+ sigB[indexWord( 3, 1 )] = x64;
+ ix = 2;
+ for (;;) {
+ x64 = (uint64_t) y[indexWordHi( 3 )] * recip32;
+ q = (x64 + 0x80000000)>>32;
+ --ix;
+ if ( ix < 0 ) break;
+ softfloat_remStep96MBy32( y, 29, sigB, q, y );
+ if ( y[indexWordHi( 3 )] & 0x80000000 ) {
+ --q;
+ softfloat_add96M( y, sigB, y );
+ }
+ qs[ix] = q;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( ((q + 1) & 0x3FFFFF) < 2 ) {
+ softfloat_remStep96MBy32( y, 29, sigB, q, y );
+ if ( y[indexWordHi( 3 )] & 0x80000000 ) {
+ --q;
+ softfloat_add96M( y, sigB, y );
+ } else if ( softfloat_compare96M( sigB, y ) <= 0 ) {
+ ++q;
+ softfloat_sub96M( y, sigB, y );
+ }
+ if (
+ y[indexWordLo( 3 )] || y[indexWord( 3, 1 )] || y[indexWord( 3, 2 )]
+ ) {
+ q |= 1;
+ }
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ x64 = (uint64_t) q<<9;
+ y[indexWord( 3, 0 )] = x64;
+ x64 = ((uint64_t) qs[0]<<6) + (x64>>32);
+ y[indexWord( 3, 1 )] = x64;
+ y[indexWord( 3, 2 )] = (qs[1]<<3) + (x64>>32);
+ softfloat_roundPackMToExtF80M(
+ signZ, expZ, y, extF80_roundingPrecision, zSPtr );
+ return;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ invalid:
+ softfloat_invalidExtF80M( zSPtr );
+ return;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ infinity:
+ uiZ64 = packToExtF80UI64( signZ, 0x7FFF );
+ uiZ0 = UINT64_C( 0x8000000000000000 );
+ goto uiZ;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ zero:
+ uiZ64 = packToExtF80UI64( signZ, 0 );
+ uiZ0 = 0;
+ uiZ:
+ zSPtr->signExp = uiZ64;
+ zSPtr->signif = uiZ0;
+
+}
+
+#endif
+
diff --git a/test/float/softfloat/source/extF80M_eq.c b/test/float/softfloat/source/extF80M_eq.c
new file mode 100644
index 000000000..248003710
--- /dev/null
+++ b/test/float/softfloat/source/extF80M_eq.c
@@ -0,0 +1,98 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+bool extF80M_eq( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+{
+
+ return extF80_eq( *aPtr, *bPtr );
+
+}
+
+#else
+
+bool extF80M_eq( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+{
+ const struct extFloat80M *aSPtr, *bSPtr;
+ uint_fast16_t uiA64;
+ uint64_t uiA0;
+ uint_fast16_t uiB64;
+ uint64_t uiB0;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ aSPtr = (const struct extFloat80M *) aPtr;
+ bSPtr = (const struct extFloat80M *) bPtr;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uiA64 = aSPtr->signExp;
+ uiA0 = aSPtr->signif;
+ uiB64 = bSPtr->signExp;
+ uiB0 = bSPtr->signif;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
+ if (
+ softfloat_isSigNaNExtF80UI( uiA64, uiA0 )
+ || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
+ ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ }
+ return false;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( uiA0 == uiB0 ) {
+ return (uiA64 == uiB64) || ! uiA0;
+ } else {
+ if ( ! ((uiA0 & uiB0) & UINT64_C( 0x8000000000000000 )) ) {
+ return ! softfloat_compareNonnormExtF80M( aSPtr, bSPtr );
+ }
+ return false;
+ }
+
+}
+
+#endif
+
diff --git a/test/float/softfloat/source/extF80M_eq_signaling.c b/test/float/softfloat/source/extF80M_eq_signaling.c
new file mode 100644
index 000000000..785eba1eb
--- /dev/null
+++ b/test/float/softfloat/source/extF80M_eq_signaling.c
@@ -0,0 +1,92 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+bool extF80M_eq_signaling( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+{
+
+ return extF80_eq_signaling( *aPtr, *bPtr );
+
+}
+
+#else
+
+bool extF80M_eq_signaling( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+{
+ const struct extFloat80M *aSPtr, *bSPtr;
+ uint_fast16_t uiA64;
+ uint64_t uiA0;
+ uint_fast16_t uiB64;
+ uint64_t uiB0;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ aSPtr = (const struct extFloat80M *) aPtr;
+ bSPtr = (const struct extFloat80M *) bPtr;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uiA64 = aSPtr->signExp;
+ uiA0 = aSPtr->signif;
+ uiB64 = bSPtr->signExp;
+ uiB0 = bSPtr->signif;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ return false;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( uiA0 == uiB0 ) {
+ return (uiA64 == uiB64) || ! uiA0;
+ } else {
+ if ( ! ((uiA0 & uiB0) & UINT64_C( 0x8000000000000000 )) ) {
+ return ! softfloat_compareNonnormExtF80M( aSPtr, bSPtr );
+ }
+ return false;
+ }
+
+}
+
+#endif
+
diff --git a/test/float/softfloat/source/extF80M_le.c b/test/float/softfloat/source/extF80M_le.c
new file mode 100644
index 000000000..24edae877
--- /dev/null
+++ b/test/float/softfloat/source/extF80M_le.c
@@ -0,0 +1,106 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+bool extF80M_le( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+{
+
+ return extF80_le( *aPtr, *bPtr );
+
+}
+
+#else
+
+bool extF80M_le( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+{
+ const struct extFloat80M *aSPtr, *bSPtr;
+ uint_fast16_t uiA64;
+ uint64_t uiA0;
+ uint_fast16_t uiB64;
+ uint64_t uiB0;
+ bool signA, ltMags;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ aSPtr = (const struct extFloat80M *) aPtr;
+ bSPtr = (const struct extFloat80M *) bPtr;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uiA64 = aSPtr->signExp;
+ uiA0 = aSPtr->signif;
+ uiB64 = bSPtr->signExp;
+ uiB0 = bSPtr->signif;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ return false;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ signA = signExtF80UI64( uiA64 );
+ if ( (uiA64 ^ uiB64) & 0x8000 ) {
+ /*--------------------------------------------------------------------
+ | Signs are different.
+ *--------------------------------------------------------------------*/
+ return signA || ! (uiA0 | uiB0);
+ } else {
+ /*--------------------------------------------------------------------
+ | Signs are the same.
+ *--------------------------------------------------------------------*/
+ if ( ! ((uiA0 & uiB0) & UINT64_C( 0x8000000000000000 )) ) {
+ return (softfloat_compareNonnormExtF80M( aSPtr, bSPtr ) <= 0);
+ }
+ if ( uiA64 == uiB64 ) {
+ if ( uiA0 == uiB0 ) return true;
+ ltMags = (uiA0 < uiB0);
+ } else {
+ ltMags = (uiA64 < uiB64);
+ }
+ return signA ^ ltMags;
+ }
+
+}
+
+#endif
+
diff --git a/test/float/softfloat/source/extF80M_le_quiet.c b/test/float/softfloat/source/extF80M_le_quiet.c
new file mode 100644
index 000000000..3880e36d5
--- /dev/null
+++ b/test/float/softfloat/source/extF80M_le_quiet.c
@@ -0,0 +1,112 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+bool extF80M_le_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+{
+
+ return extF80_le_quiet( *aPtr, *bPtr );
+
+}
+
+#else
+
+bool extF80M_le_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+{
+ const struct extFloat80M *aSPtr, *bSPtr;
+ uint_fast16_t uiA64;
+ uint64_t uiA0;
+ uint_fast16_t uiB64;
+ uint64_t uiB0;
+ bool signA, ltMags;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ aSPtr = (const struct extFloat80M *) aPtr;
+ bSPtr = (const struct extFloat80M *) bPtr;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uiA64 = aSPtr->signExp;
+ uiA0 = aSPtr->signif;
+ uiB64 = bSPtr->signExp;
+ uiB0 = bSPtr->signif;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
+ if (
+ softfloat_isSigNaNExtF80UI( uiA64, uiA0 )
+ || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
+ ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ }
+ return false;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ signA = signExtF80UI64( uiA64 );
+ if ( (uiA64 ^ uiB64) & 0x8000 ) {
+ /*--------------------------------------------------------------------
+ | Signs are different.
+ *--------------------------------------------------------------------*/
+ return signA || ! (uiA0 | uiB0);
+ } else {
+ /*--------------------------------------------------------------------
+ | Signs are the same.
+ *--------------------------------------------------------------------*/
+ if ( ! ((uiA0 & uiB0) & UINT64_C( 0x8000000000000000 )) ) {
+ return (softfloat_compareNonnormExtF80M( aSPtr, bSPtr ) <= 0);
+ }
+ if ( uiA64 == uiB64 ) {
+ if ( uiA0 == uiB0 ) return true;
+ ltMags = (uiA0 < uiB0);
+ } else {
+ ltMags = (uiA64 < uiB64);
+ }
+ return signA ^ ltMags;
+ }
+
+}
+
+#endif
+
diff --git a/test/float/softfloat/source/extF80M_lt.c b/test/float/softfloat/source/extF80M_lt.c
new file mode 100644
index 000000000..70fa8f05d
--- /dev/null
+++ b/test/float/softfloat/source/extF80M_lt.c
@@ -0,0 +1,106 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+bool extF80M_lt( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+{
+
+ return extF80_lt( *aPtr, *bPtr );
+
+}
+
+#else
+
+bool extF80M_lt( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+{
+ const struct extFloat80M *aSPtr, *bSPtr;
+ uint_fast16_t uiA64;
+ uint64_t uiA0;
+ uint_fast16_t uiB64;
+ uint64_t uiB0;
+ bool signA, ltMags;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ aSPtr = (const struct extFloat80M *) aPtr;
+ bSPtr = (const struct extFloat80M *) bPtr;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uiA64 = aSPtr->signExp;
+ uiA0 = aSPtr->signif;
+ uiB64 = bSPtr->signExp;
+ uiB0 = bSPtr->signif;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ return false;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ signA = signExtF80UI64( uiA64 );
+ if ( (uiA64 ^ uiB64) & 0x8000 ) {
+ /*--------------------------------------------------------------------
+ | Signs are different.
+ *--------------------------------------------------------------------*/
+ return signA && ((uiA0 | uiB0) != 0);
+ } else {
+ /*--------------------------------------------------------------------
+ | Signs are the same.
+ *--------------------------------------------------------------------*/
+ if ( ! ((uiA0 & uiB0) & UINT64_C( 0x8000000000000000 )) ) {
+ return (softfloat_compareNonnormExtF80M( aSPtr, bSPtr ) < 0);
+ }
+ if ( uiA64 == uiB64 ) {
+ if ( uiA0 == uiB0 ) return false;
+ ltMags = (uiA0 < uiB0);
+ } else {
+ ltMags = (uiA64 < uiB64);
+ }
+ return signA ^ ltMags;
+ }
+
+}
+
+#endif
+
diff --git a/test/float/softfloat/source/extF80M_lt_quiet.c b/test/float/softfloat/source/extF80M_lt_quiet.c
new file mode 100644
index 000000000..b119af308
--- /dev/null
+++ b/test/float/softfloat/source/extF80M_lt_quiet.c
@@ -0,0 +1,112 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+bool extF80M_lt_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+{
+
+ return extF80_lt_quiet( *aPtr, *bPtr );
+
+}
+
+#else
+
+bool extF80M_lt_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+{
+ const struct extFloat80M *aSPtr, *bSPtr;
+ uint_fast16_t uiA64;
+ uint64_t uiA0;
+ uint_fast16_t uiB64;
+ uint64_t uiB0;
+ bool signA, ltMags;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ aSPtr = (const struct extFloat80M *) aPtr;
+ bSPtr = (const struct extFloat80M *) bPtr;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uiA64 = aSPtr->signExp;
+ uiA0 = aSPtr->signif;
+ uiB64 = bSPtr->signExp;
+ uiB0 = bSPtr->signif;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
+ if (
+ softfloat_isSigNaNExtF80UI( uiA64, uiA0 )
+ || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
+ ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ }
+ return false;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ signA = signExtF80UI64( uiA64 );
+ if ( (uiA64 ^ uiB64) & 0x8000 ) {
+ /*--------------------------------------------------------------------
+ | Signs are different.
+ *--------------------------------------------------------------------*/
+ return signA && ((uiA0 | uiB0) != 0);
+ } else {
+ /*--------------------------------------------------------------------
+ | Signs are the same.
+ *--------------------------------------------------------------------*/
+ if ( ! ((uiA0 & uiB0) & UINT64_C( 0x8000000000000000 )) ) {
+ return (softfloat_compareNonnormExtF80M( aSPtr, bSPtr ) < 0);
+ }
+ if ( uiA64 == uiB64 ) {
+ if ( uiA0 == uiB0 ) return false;
+ ltMags = (uiA0 < uiB0);
+ } else {
+ ltMags = (uiA64 < uiB64);
+ }
+ return signA ^ ltMags;
+ }
+
+}
+
+#endif
+
diff --git a/test/float/softfloat/source/extF80M_mul.c b/test/float/softfloat/source/extF80M_mul.c
new file mode 100644
index 000000000..273444900
--- /dev/null
+++ b/test/float/softfloat/source/extF80M_mul.c
@@ -0,0 +1,139 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void
+ extF80M_mul(
+ const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+{
+
+ *zPtr = extF80_mul( *aPtr, *bPtr );
+
+}
+
+#else
+
+void
+ extF80M_mul(
+ const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+{
+ const struct extFloat80M *aSPtr, *bSPtr;
+ struct extFloat80M *zSPtr;
+ uint_fast16_t uiA64;
+ int32_t expA;
+ uint_fast16_t uiB64;
+ int32_t expB;
+ bool signZ;
+ uint_fast16_t exp, uiZ64;
+ uint64_t uiZ0, sigA, sigB;
+ int32_t expZ;
+ uint32_t sigProd[4], *extSigZPtr;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ aSPtr = (const struct extFloat80M *) aPtr;
+ bSPtr = (const struct extFloat80M *) bPtr;
+ zSPtr = (struct extFloat80M *) zPtr;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uiA64 = aSPtr->signExp;
+ expA = expExtF80UI64( uiA64 );
+ uiB64 = bSPtr->signExp;
+ expB = expExtF80UI64( uiB64 );
+ signZ = signExtF80UI64( uiA64 ) ^ signExtF80UI64( uiB64 );
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
+ if ( softfloat_tryPropagateNaNExtF80M( aSPtr, bSPtr, zSPtr ) ) return;
+ if (
+ (! aSPtr->signif && (expA != 0x7FFF))
+ || (! bSPtr->signif && (expB != 0x7FFF))
+ ) {
+ softfloat_invalidExtF80M( zSPtr );
+ return;
+ }
+ uiZ64 = packToExtF80UI64( signZ, 0x7FFF );
+ uiZ0 = UINT64_C( 0x8000000000000000 );
+ goto uiZ;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( ! expA ) expA = 1;
+ sigA = aSPtr->signif;
+ if ( ! (sigA & UINT64_C( 0x8000000000000000 )) ) {
+ if ( ! sigA ) goto zero;
+ expA += softfloat_normExtF80SigM( &sigA );
+ }
+ if ( ! expB ) expB = 1;
+ sigB = bSPtr->signif;
+ if ( ! (sigB & UINT64_C( 0x8000000000000000 )) ) {
+ if ( ! sigB ) goto zero;
+ expB += softfloat_normExtF80SigM( &sigB );
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ expZ = expA + expB - 0x3FFE;
+ softfloat_mul64To128M( sigA, sigB, sigProd );
+ if ( sigProd[indexWordLo( 4 )] ) sigProd[indexWord( 4, 1 )] |= 1;
+ extSigZPtr = &sigProd[indexMultiwordHi( 4, 3 )];
+ if ( sigProd[indexWordHi( 4 )] < 0x80000000 ) {
+ --expZ;
+ softfloat_add96M( extSigZPtr, extSigZPtr, extSigZPtr );
+ }
+ softfloat_roundPackMToExtF80M(
+ signZ, expZ, extSigZPtr, extF80_roundingPrecision, zSPtr );
+ return;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ zero:
+ uiZ64 = packToExtF80UI64( signZ, 0 );
+ uiZ0 = 0;
+ uiZ:
+ zSPtr->signExp = uiZ64;
+ zSPtr->signif = uiZ0;
+
+}
+
+#endif
+
diff --git a/test/float/softfloat/source/extF80M_rem.c b/test/float/softfloat/source/extF80M_rem.c
new file mode 100644
index 000000000..065e271a7
--- /dev/null
+++ b/test/float/softfloat/source/extF80M_rem.c
@@ -0,0 +1,204 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void
+ extF80M_rem(
+ const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+{
+
+ *zPtr = extF80_rem( *aPtr, *bPtr );
+
+}
+
+#else
+
+void
+ extF80M_rem(
+ const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+{
+ const struct extFloat80M *aSPtr, *bSPtr;
+ struct extFloat80M *zSPtr;
+ uint_fast16_t uiA64;
+ int32_t expA, expB;
+ uint64_t x64;
+ bool signRem;
+ uint64_t sigA;
+ int32_t expDiff;
+ uint32_t rem[3], x[3], sig32B, q, recip32, rem2[3], *remPtr, *altRemPtr;
+ uint32_t *newRemPtr, wordMeanRem;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ aSPtr = (const struct extFloat80M *) aPtr;
+ bSPtr = (const struct extFloat80M *) bPtr;
+ zSPtr = (struct extFloat80M *) zPtr;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uiA64 = aSPtr->signExp;
+ expA = expExtF80UI64( uiA64 );
+ expB = expExtF80UI64( bSPtr->signExp );
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
+ if ( softfloat_tryPropagateNaNExtF80M( aSPtr, bSPtr, zSPtr ) ) return;
+ if ( expA == 0x7FFF ) goto invalid;
+ /*--------------------------------------------------------------------
+ | If we get here, then argument b is an infinity and `expB' is 0x7FFF;
+ | Doubling `expB' is an easy way to ensure that `expDiff' later is
+ | less than -1, which will result in returning a canonicalized version
+ | of argument a.
+ *--------------------------------------------------------------------*/
+ expB += expB;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( ! expB ) expB = 1;
+ x64 = bSPtr->signif;
+ if ( ! (x64 & UINT64_C( 0x8000000000000000 )) ) {
+ if ( ! x64 ) goto invalid;
+ expB += softfloat_normExtF80SigM( &x64 );
+ }
+ signRem = signExtF80UI64( uiA64 );
+ if ( ! expA ) expA = 1;
+ sigA = aSPtr->signif;
+ if ( ! (sigA & UINT64_C( 0x8000000000000000 )) ) {
+ if ( ! sigA ) {
+ expA = 0;
+ goto copyA;
+ }
+ expA += softfloat_normExtF80SigM( &sigA );
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ expDiff = expA - expB;
+ if ( expDiff < -1 ) goto copyA;
+ rem[indexWord( 3, 2 )] = sigA>>34;
+ rem[indexWord( 3, 1 )] = sigA>>2;
+ rem[indexWord( 3, 0 )] = (uint32_t) sigA<<30;
+ x[indexWord( 3, 0 )] = (uint32_t) x64<<30;
+ sig32B = x64>>32;
+ x64 >>= 2;
+ x[indexWord( 3, 2 )] = x64>>32;
+ x[indexWord( 3, 1 )] = x64;
+ if ( expDiff < 1 ) {
+ if ( expDiff ) {
+ --expB;
+ softfloat_add96M( x, x, x );
+ q = 0;
+ } else {
+ q = (softfloat_compare96M( x, rem ) <= 0);
+ if ( q ) softfloat_sub96M( rem, x, rem );
+ }
+ } else {
+ recip32 = softfloat_approxRecip32_1( sig32B );
+ expDiff -= 30;
+ for (;;) {
+ x64 = (uint64_t) rem[indexWordHi( 3 )] * recip32;
+ if ( expDiff < 0 ) break;
+ q = (x64 + 0x80000000)>>32;
+ softfloat_remStep96MBy32( rem, 29, x, q, rem );
+ if ( rem[indexWordHi( 3 )] & 0x80000000 ) {
+ softfloat_add96M( rem, x, rem );
+ }
+ expDiff -= 29;
+ }
+ /*--------------------------------------------------------------------
+ | (`expDiff' cannot be less than -29 here.)
+ *--------------------------------------------------------------------*/
+ q = (uint32_t) (x64>>32)>>(~expDiff & 31);
+ softfloat_remStep96MBy32( rem, expDiff + 30, x, q, rem );
+ if ( rem[indexWordHi( 3 )] & 0x80000000 ) {
+ remPtr = rem;
+ altRemPtr = rem2;
+ softfloat_add96M( remPtr, x, altRemPtr );
+ goto selectRem;
+ }
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ remPtr = rem;
+ altRemPtr = rem2;
+ do {
+ ++q;
+ newRemPtr = altRemPtr;
+ softfloat_sub96M( remPtr, x, newRemPtr );
+ altRemPtr = remPtr;
+ remPtr = newRemPtr;
+ } while ( ! (remPtr[indexWordHi( 3 )] & 0x80000000) );
+ selectRem:
+ softfloat_add96M( remPtr, altRemPtr, x );
+ wordMeanRem = x[indexWordHi( 3 )];
+ if (
+ (wordMeanRem & 0x80000000)
+ || (! wordMeanRem && (q & 1) && ! x[indexWord( 3, 0 )]
+ && ! x[indexWord( 3, 1 )])
+ ) {
+ remPtr = altRemPtr;
+ }
+ if ( remPtr[indexWordHi( 3 )] & 0x80000000 ) {
+ signRem = ! signRem;
+ softfloat_negX96M( remPtr );
+ }
+ softfloat_normRoundPackMToExtF80M( signRem, expB + 2, remPtr, 80, zSPtr );
+ return;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ invalid:
+ softfloat_invalidExtF80M( zSPtr );
+ return;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ copyA:
+ if ( expA < 1 ) {
+ sigA >>= 1 - expA;
+ expA = 0;
+ }
+ zSPtr->signExp = packToExtF80UI64( signRem, expA );
+ zSPtr->signif = sigA;
+
+}
+
+#endif
+
diff --git a/test/float/softfloat/source/extF80M_roundToInt.c b/test/float/softfloat/source/extF80M_roundToInt.c
new file mode 100644
index 000000000..ff4ae876a
--- /dev/null
+++ b/test/float/softfloat/source/extF80M_roundToInt.c
@@ -0,0 +1,176 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void
+ extF80M_roundToInt(
+ const extFloat80_t *aPtr,
+ uint_fast8_t roundingMode,
+ bool exact,
+ extFloat80_t *zPtr
+ )
+{
+
+ *zPtr = extF80_roundToInt( *aPtr, roundingMode, exact );
+
+}
+
+#else
+
+void
+ extF80M_roundToInt(
+ const extFloat80_t *aPtr,
+ uint_fast8_t roundingMode,
+ bool exact,
+ extFloat80_t *zPtr
+ )
+{
+ const struct extFloat80M *aSPtr;
+ struct extFloat80M *zSPtr;
+ uint_fast16_t uiA64, signUI64;
+ int32_t exp;
+ uint64_t sigA;
+ uint_fast16_t uiZ64;
+ uint64_t sigZ, lastBitMask, roundBitsMask;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ aSPtr = (const struct extFloat80M *) aPtr;
+ zSPtr = (struct extFloat80M *) zPtr;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uiA64 = aSPtr->signExp;
+ signUI64 = uiA64 & packToExtF80UI64( 1, 0 );
+ exp = expExtF80UI64( uiA64 );
+ sigA = aSPtr->signif;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( !(sigA & UINT64_C( 0x8000000000000000 )) && (exp != 0x7FFF) ) {
+ if ( !sigA ) {
+ uiZ64 = signUI64;
+ sigZ = 0;
+ goto uiZ;
+ }
+ exp += softfloat_normExtF80SigM( &sigA );
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( exp <= 0x3FFE ) {
+ if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+ switch ( roundingMode ) {
+ case softfloat_round_near_even:
+ if ( !(sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ) break;
+ case softfloat_round_near_maxMag:
+ if ( exp == 0x3FFE ) goto mag1;
+ break;
+ case softfloat_round_min:
+ if ( signUI64 ) goto mag1;
+ break;
+ case softfloat_round_max:
+ if ( !signUI64 ) goto mag1;
+ break;
+#ifdef SOFTFLOAT_ROUND_ODD
+ case softfloat_round_odd:
+ goto mag1;
+#endif
+ }
+ uiZ64 = signUI64;
+ sigZ = 0;
+ goto uiZ;
+ mag1:
+ uiZ64 = signUI64 | 0x3FFF;
+ sigZ = UINT64_C( 0x8000000000000000 );
+ goto uiZ;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( 0x403E <= exp ) {
+ if ( exp == 0x7FFF ) {
+ if ( sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
+ softfloat_propagateNaNExtF80M( aSPtr, 0, zSPtr );
+ return;
+ }
+ sigZ = UINT64_C( 0x8000000000000000 );
+ } else {
+ sigZ = sigA;
+ }
+ uiZ64 = signUI64 | exp;
+ goto uiZ;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uiZ64 = signUI64 | exp;
+ lastBitMask = (uint64_t) 1<<(0x403E - exp);
+ roundBitsMask = lastBitMask - 1;
+ sigZ = sigA;
+ if ( roundingMode == softfloat_round_near_maxMag ) {
+ sigZ += lastBitMask>>1;
+ } else if ( roundingMode == softfloat_round_near_even ) {
+ sigZ += lastBitMask>>1;
+ if ( !(sigZ & roundBitsMask) ) sigZ &= ~lastBitMask;
+ } else if (
+ roundingMode == (signUI64 ? softfloat_round_min : softfloat_round_max)
+ ) {
+ sigZ += roundBitsMask;
+ }
+ sigZ &= ~roundBitsMask;
+ if ( !sigZ ) {
+ ++uiZ64;
+ sigZ = UINT64_C( 0x8000000000000000 );
+ }
+ if ( sigZ != sigA ) {
+#ifdef SOFTFLOAT_ROUND_ODD
+ if ( roundingMode == softfloat_round_odd ) sigZ |= lastBitMask;
+#endif
+ if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+ }
+ uiZ:
+ zSPtr->signExp = uiZ64;
+ zSPtr->signif = sigZ;
+ return;
+
+}
+
+#endif
+
diff --git a/test/float/softfloat/source/extF80M_sqrt.c b/test/float/softfloat/source/extF80M_sqrt.c
new file mode 100644
index 000000000..21c15da07
--- /dev/null
+++ b/test/float/softfloat/source/extF80M_sqrt.c
@@ -0,0 +1,180 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void extF80M_sqrt( const extFloat80_t *aPtr, extFloat80_t *zPtr )
+{
+
+ *zPtr = extF80_sqrt( *aPtr );
+
+}
+
+#else
+
+void extF80M_sqrt( const extFloat80_t *aPtr, extFloat80_t *zPtr )
+{
+ const struct extFloat80M *aSPtr;
+ struct extFloat80M *zSPtr;
+ uint_fast16_t uiA64, signUI64;
+ int32_t expA;
+ uint64_t rem64;
+ int32_t expZ;
+ uint32_t rem96[3], sig32A, recipSqrt32, sig32Z, q;
+ uint64_t sig64Z, x64;
+ uint32_t rem32, term[4], rem[4], extSigZ[3];
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ aSPtr = (const struct extFloat80M *) aPtr;
+ zSPtr = (struct extFloat80M *) zPtr;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uiA64 = aSPtr->signExp;
+ signUI64 = uiA64 & packToExtF80UI64( 1, 0 );
+ expA = expExtF80UI64( uiA64 );
+ rem64 = aSPtr->signif;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( expA == 0x7FFF ) {
+ if ( rem64 & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
+ softfloat_propagateNaNExtF80M( aSPtr, 0, zSPtr );
+ return;
+ }
+ if ( signUI64 ) goto invalid;
+ rem64 = UINT64_C( 0x8000000000000000 );
+ goto copyA;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( ! expA ) expA = 1;
+ if ( ! (rem64 & UINT64_C( 0x8000000000000000 )) ) {
+ if ( ! rem64 ) {
+ uiA64 = signUI64;
+ goto copyA;
+ }
+ expA += softfloat_normExtF80SigM( &rem64 );
+ }
+ if ( signUI64 ) goto invalid;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ expZ = ((expA - 0x3FFF)>>1) + 0x3FFF;
+ expA &= 1;
+ softfloat_shortShiftLeft64To96M( rem64, 30 - expA, rem96 );
+ sig32A = rem64>>32;
+ recipSqrt32 = softfloat_approxRecipSqrt32_1( expA, sig32A );
+ sig32Z = ((uint64_t) sig32A * recipSqrt32)>>32;
+ if ( expA ) sig32Z >>= 1;
+ rem64 =
+ ((uint64_t) rem96[indexWord( 3, 2 )]<<32 | rem96[indexWord( 3, 1 )])
+ - (uint64_t) sig32Z * sig32Z;
+ rem96[indexWord( 3, 2 )] = rem64>>32;
+ rem96[indexWord( 3, 1 )] = rem64;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ q = ((uint32_t) (rem64>>2) * (uint64_t) recipSqrt32)>>32;
+ sig64Z = ((uint64_t) sig32Z<<32) + ((uint64_t) q<<3);
+ term[indexWord( 3, 2 )] = 0;
+ /*------------------------------------------------------------------------
+ | (Repeating this loop is a rare occurrence.)
+ *------------------------------------------------------------------------*/
+ for (;;) {
+ x64 = ((uint64_t) sig32Z<<32) + sig64Z;
+ term[indexWord( 3, 1 )] = x64>>32;
+ term[indexWord( 3, 0 )] = x64;
+ softfloat_remStep96MBy32(
+ rem96, 29, term, q, &rem[indexMultiwordHi( 4, 3 )] );
+ rem32 = rem[indexWord( 4, 3 )];
+ if ( ! (rem32 & 0x80000000) ) break;
+ --q;
+ sig64Z -= 1<<3;
+ }
+ rem64 = (uint64_t) rem32<<32 | rem[indexWord( 4, 2 )];
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ q = (((uint32_t) (rem64>>2) * (uint64_t) recipSqrt32)>>32) + 2;
+ if ( rem64>>34 ) q += recipSqrt32;
+ x64 = (uint64_t) q<<7;
+ extSigZ[indexWord( 3, 0 )] = x64;
+ x64 = (sig64Z<<1) + (x64>>32);
+ extSigZ[indexWord( 3, 2 )] = x64>>32;
+ extSigZ[indexWord( 3, 1 )] = x64;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( (q & 0xFFFFFF) <= 2 ) {
+ q &= ~(uint32_t) 0xFFFF;
+ extSigZ[indexWordLo( 3 )] = q<<7;
+ x64 = sig64Z + (q>>27);
+ term[indexWord( 4, 3 )] = 0;
+ term[indexWord( 4, 2 )] = x64>>32;
+ term[indexWord( 4, 1 )] = x64;
+ term[indexWord( 4, 0 )] = q<<5;
+ rem[indexWord( 4, 0 )] = 0;
+ softfloat_remStep128MBy32( rem, 28, term, q, rem );
+ q = rem[indexWordHi( 4 )];
+ if ( q & 0x80000000 ) {
+ softfloat_sub1X96M( extSigZ );
+ } else {
+ if ( q || rem[indexWord( 4, 1 )] || rem[indexWord( 4, 2 )] ) {
+ extSigZ[indexWordLo( 3 )] |= 1;
+ }
+ }
+ }
+ softfloat_roundPackMToExtF80M(
+ 0, expZ, extSigZ, extF80_roundingPrecision, zSPtr );
+ return;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ invalid:
+ softfloat_invalidExtF80M( zSPtr );
+ return;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ copyA:
+ zSPtr->signExp = uiA64;
+ zSPtr->signif = rem64;
+
+}
+
+#endif
+
diff --git a/test/float/softfloat/source/extF80M_sub.c b/test/float/softfloat/source/extF80M_sub.c
new file mode 100644
index 000000000..4f9f1a623
--- /dev/null
+++ b/test/float/softfloat/source/extF80M_sub.c
@@ -0,0 +1,100 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void
+ extF80M_sub(
+ const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+{
+ const struct extFloat80M *aSPtr, *bSPtr;
+ uint_fast16_t uiA64;
+ uint_fast64_t uiA0;
+ bool signA;
+ uint_fast16_t uiB64;
+ uint_fast64_t uiB0;
+ bool signB;
+#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
+ extFloat80_t
+ (*magsFuncPtr)(
+ uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool );
+#endif
+
+ aSPtr = (const struct extFloat80M *) aPtr;
+ bSPtr = (const struct extFloat80M *) bPtr;
+ uiA64 = aSPtr->signExp;
+ uiA0 = aSPtr->signif;
+ signA = signExtF80UI64( uiA64 );
+ uiB64 = bSPtr->signExp;
+ uiB0 = bSPtr->signif;
+ signB = signExtF80UI64( uiB64 );
+#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
+ if ( signA == signB ) {
+ *zPtr = softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
+ } else {
+ *zPtr = softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
+ }
+#else
+ magsFuncPtr =
+ (signA == signB) ? softfloat_subMagsExtF80 : softfloat_addMagsExtF80;
+ *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
+#endif
+
+}
+
+#else
+
+void
+ extF80M_sub(
+ const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+{
+
+ softfloat_addExtF80M(
+ (const struct extFloat80M *) aPtr,
+ (const struct extFloat80M *) bPtr,
+ (struct extFloat80M *) zPtr,
+ true
+ );
+
+}
+
+#endif
+
diff --git a/test/float/softfloat/source/extF80M_to_f128M.c b/test/float/softfloat/source/extF80M_to_f128M.c
new file mode 100644
index 000000000..c0306af82
--- /dev/null
+++ b/test/float/softfloat/source/extF80M_to_f128M.c
@@ -0,0 +1,125 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void extF80M_to_f128M( const extFloat80_t *aPtr, float128_t *zPtr )
+{
+
+ *zPtr = extF80_to_f128( *aPtr );
+
+}
+
+#else
+
+void extF80M_to_f128M( const extFloat80_t *aPtr, float128_t *zPtr )
+{
+ const struct extFloat80M *aSPtr;
+ uint32_t *zWPtr;
+ uint_fast16_t uiA64;
+ bool sign;
+ int32_t exp;
+ uint64_t sig;
+ struct commonNaN commonNaN;
+ uint32_t uiZ96;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ aSPtr = (const struct extFloat80M *) aPtr;
+ zWPtr = (uint32_t *) zPtr;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uiA64 = aSPtr->signExp;
+ sign = signExtF80UI64( uiA64 );
+ exp = expExtF80UI64( uiA64 );
+ sig = aSPtr->signif;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ zWPtr[indexWord( 4, 0 )] = 0;
+ if ( exp == 0x7FFF ) {
+ if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
+ softfloat_extF80MToCommonNaN( aSPtr, &commonNaN );
+ softfloat_commonNaNToF128M( &commonNaN, zWPtr );
+ return;
+ }
+ uiZ96 = packToF128UI96( sign, 0x7FFF, 0 );
+ goto uiZ;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( exp ) --exp;
+ if ( ! (sig & UINT64_C( 0x8000000000000000 )) ) {
+ if ( ! sig ) {
+ uiZ96 = packToF128UI96( sign, 0, 0 );
+ goto uiZ;
+ }
+ exp += softfloat_normExtF80SigM( &sig );
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ zWPtr[indexWord( 4, 1 )] = (uint32_t) sig<<17;
+ sig >>= 15;
+ zWPtr[indexWord( 4, 2 )] = sig;
+ if ( exp < 0 ) {
+ zWPtr[indexWordHi( 4 )] = sig>>32;
+ softfloat_shiftRight96M(
+ &zWPtr[indexMultiwordHi( 4, 3 )],
+ -exp,
+ &zWPtr[indexMultiwordHi( 4, 3 )]
+ );
+ exp = 0;
+ sig = (uint64_t) zWPtr[indexWordHi( 4 )]<<32;
+ }
+ zWPtr[indexWordHi( 4 )] = packToF128UI96( sign, exp, sig>>32 );
+ return;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uiZ:
+ zWPtr[indexWord( 4, 3 )] = uiZ96;
+ zWPtr[indexWord( 4, 2 )] = 0;
+ zWPtr[indexWord( 4, 1 )] = 0;
+
+}
+
+#endif
+
diff --git a/test/float/softfloat/source/extF80M_to_f16.c b/test/float/softfloat/source/extF80M_to_f16.c
new file mode 100644
index 000000000..7ff56de2d
--- /dev/null
+++ b/test/float/softfloat/source/extF80M_to_f16.c
@@ -0,0 +1,112 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+float16_t extF80M_to_f16( const extFloat80_t *aPtr )
+{
+
+ return extF80_to_f16( *aPtr );
+
+}
+
+#else
+
+float16_t extF80M_to_f16( const extFloat80_t *aPtr )
+{
+ const struct extFloat80M *aSPtr;
+ uint_fast16_t uiA64;
+ bool sign;
+ int32_t exp;
+ uint64_t sig;
+ struct commonNaN commonNaN;
+ uint16_t uiZ, sig16;
+ union ui16_f16 uZ;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ aSPtr = (const struct extFloat80M *) aPtr;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uiA64 = aSPtr->signExp;
+ sign = signExtF80UI64( uiA64 );
+ exp = expExtF80UI64( uiA64 );
+ sig = aSPtr->signif;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( exp == 0x7FFF ) {
+ if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
+ softfloat_extF80MToCommonNaN( aSPtr, &commonNaN );
+ uiZ = softfloat_commonNaNToF16UI( &commonNaN );
+ } else {
+ uiZ = packToF16UI( sign, 0x1F, 0 );
+ }
+ goto uiZ;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( ! (sig & UINT64_C( 0x8000000000000000 )) ) {
+ if ( ! sig ) {
+ uiZ = packToF16UI( sign, 0, 0 );
+ goto uiZ;
+ }
+ exp += softfloat_normExtF80SigM( &sig );
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ sig16 = softfloat_shortShiftRightJam64( sig, 49 );
+ exp -= 0x3FF1;
+ if ( sizeof (int_fast16_t) < sizeof (int32_t) ) {
+ if ( exp < -0x40 ) exp = -0x40;
+ }
+ return softfloat_roundPackToF16( sign, exp, sig16 );
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uiZ:
+ uZ.ui = uiZ;
+ return uZ.f;
+
+}
+
+#endif
+
diff --git a/test/float/softfloat/source/extF80M_to_f32.c b/test/float/softfloat/source/extF80M_to_f32.c
new file mode 100644
index 000000000..bb1166f97
--- /dev/null
+++ b/test/float/softfloat/source/extF80M_to_f32.c
@@ -0,0 +1,112 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+float32_t extF80M_to_f32( const extFloat80_t *aPtr )
+{
+
+ return extF80_to_f32( *aPtr );
+
+}
+
+#else
+
+float32_t extF80M_to_f32( const extFloat80_t *aPtr )
+{
+ const struct extFloat80M *aSPtr;
+ uint_fast16_t uiA64;
+ bool sign;
+ int32_t exp;
+ uint64_t sig;
+ struct commonNaN commonNaN;
+ uint32_t uiZ, sig32;
+ union ui32_f32 uZ;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ aSPtr = (const struct extFloat80M *) aPtr;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uiA64 = aSPtr->signExp;
+ sign = signExtF80UI64( uiA64 );
+ exp = expExtF80UI64( uiA64 );
+ sig = aSPtr->signif;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( exp == 0x7FFF ) {
+ if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
+ softfloat_extF80MToCommonNaN( aSPtr, &commonNaN );
+ uiZ = softfloat_commonNaNToF32UI( &commonNaN );
+ } else {
+ uiZ = packToF32UI( sign, 0xFF, 0 );
+ }
+ goto uiZ;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( ! (sig & UINT64_C( 0x8000000000000000 )) ) {
+ if ( ! sig ) {
+ uiZ = packToF32UI( sign, 0, 0 );
+ goto uiZ;
+ }
+ exp += softfloat_normExtF80SigM( &sig );
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ sig32 = softfloat_shortShiftRightJam64( sig, 33 );
+ exp -= 0x3F81;
+ if ( sizeof (int_fast16_t) < sizeof (int32_t) ) {
+ if ( exp < -0x1000 ) exp = -0x1000;
+ }
+ return softfloat_roundPackToF32( sign, exp, sig32 );
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uiZ:
+ uZ.ui = uiZ;
+ return uZ.f;
+
+}
+
+#endif
+
diff --git a/test/float/softfloat/source/extF80M_to_f64.c b/test/float/softfloat/source/extF80M_to_f64.c
new file mode 100644
index 000000000..696255f87
--- /dev/null
+++ b/test/float/softfloat/source/extF80M_to_f64.c
@@ -0,0 +1,112 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+float64_t extF80M_to_f64( const extFloat80_t *aPtr )
+{
+
+ return extF80_to_f64( *aPtr );
+
+}
+
+#else
+
+float64_t extF80M_to_f64( const extFloat80_t *aPtr )
+{
+ const struct extFloat80M *aSPtr;
+ uint_fast16_t uiA64;
+ bool sign;
+ int32_t exp;
+ uint64_t sig;
+ struct commonNaN commonNaN;
+ uint64_t uiZ;
+ union ui64_f64 uZ;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ aSPtr = (const struct extFloat80M *) aPtr;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uiA64 = aSPtr->signExp;
+ sign = signExtF80UI64( uiA64 );
+ exp = expExtF80UI64( uiA64 );
+ sig = aSPtr->signif;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( exp == 0x7FFF ) {
+ if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
+ softfloat_extF80MToCommonNaN( aSPtr, &commonNaN );
+ uiZ = softfloat_commonNaNToF64UI( &commonNaN );
+ } else {
+ uiZ = packToF64UI( sign, 0x7FF, 0 );
+ }
+ goto uiZ;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( ! (sig & UINT64_C( 0x8000000000000000 )) ) {
+ if ( ! sig ) {
+ uiZ = packToF64UI( sign, 0, 0 );
+ goto uiZ;
+ }
+ exp += softfloat_normExtF80SigM( &sig );
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ sig = softfloat_shortShiftRightJam64( sig, 1 );
+ exp -= 0x3C01;
+ if ( sizeof (int_fast16_t) < sizeof (int32_t) ) {
+ if ( exp < -0x1000 ) exp = -0x1000;
+ }
+ return softfloat_roundPackToF64( sign, exp, sig );
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uiZ:
+ uZ.ui = uiZ;
+ return uZ.f;
+
+}
+
+#endif
+
diff --git a/test/float/softfloat/source/extF80M_to_i32.c b/test/float/softfloat/source/extF80M_to_i32.c
new file mode 100644
index 000000000..c0464b138
--- /dev/null
+++ b/test/float/softfloat/source/extF80M_to_i32.c
@@ -0,0 +1,100 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+int_fast32_t
+ extF80M_to_i32(
+ const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
+{
+
+ return extF80_to_i32( *aPtr, roundingMode, exact );
+
+}
+
+#else
+
+int_fast32_t
+ extF80M_to_i32(
+ const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
+{
+ const struct extFloat80M *aSPtr;
+ uint_fast16_t uiA64;
+ bool sign;
+ int32_t exp;
+ uint64_t sig;
+ int32_t shiftDist;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ aSPtr = (const struct extFloat80M *) aPtr;
+ uiA64 = aSPtr->signExp;
+ sign = signExtF80UI64( uiA64 );
+ exp = expExtF80UI64( uiA64 );
+ sig = aSPtr->signif;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ shiftDist = 0x4032 - exp;
+ if ( shiftDist <= 0 ) {
+ if ( sig>>32 ) goto invalid;
+ if ( -32 < shiftDist ) {
+ sig <<= -shiftDist;
+ } else {
+ if ( (uint32_t) sig ) goto invalid;
+ }
+ } else {
+ sig = softfloat_shiftRightJam64( sig, shiftDist );
+ }
+ return softfloat_roundToI32( sign, sig, roundingMode, exact );
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ invalid:
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ return
+ (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ? i32_fromNaN
+ : sign ? i32_fromNegOverflow : i32_fromPosOverflow;
+
+}
+
+#endif
+
diff --git a/test/float/softfloat/source/extF80M_to_i32_r_minMag.c b/test/float/softfloat/source/extF80M_to_i32_r_minMag.c
new file mode 100644
index 000000000..9a803cc23
--- /dev/null
+++ b/test/float/softfloat/source/extF80M_to_i32_r_minMag.c
@@ -0,0 +1,120 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+int_fast32_t extF80M_to_i32_r_minMag( const extFloat80_t *aPtr, bool exact )
+{
+
+ return extF80_to_i32_r_minMag( *aPtr, exact );
+
+}
+
+#else
+
+int_fast32_t extF80M_to_i32_r_minMag( const extFloat80_t *aPtr, bool exact )
+{
+ const struct extFloat80M *aSPtr;
+ uint_fast16_t uiA64;
+ int32_t exp;
+ uint64_t sig;
+ int32_t shiftDist;
+ bool sign, raiseInexact;
+ int32_t z;
+ uint64_t shiftedSig;
+ uint32_t absZ;
+ union { uint32_t ui; int32_t i; } u;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ aSPtr = (const struct extFloat80M *) aPtr;
+ uiA64 = aSPtr->signExp;
+ exp = expExtF80UI64( uiA64 );
+ sig = aSPtr->signif;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( ! sig && (exp != 0x7FFF) ) return 0;
+ shiftDist = 0x403E - exp;
+ if ( 64 <= shiftDist ) {
+ raiseInexact = exact;
+ z = 0;
+ } else {
+ sign = signExtF80UI64( uiA64 );
+ raiseInexact = false;
+ if ( shiftDist < 0 ) {
+ if ( sig>>32 || (shiftDist <= -31) ) goto invalid;
+ shiftedSig = (uint64_t) (uint32_t) sig<<-shiftDist;
+ if ( shiftedSig>>32 ) goto invalid;
+ absZ = shiftedSig;
+ } else {
+ shiftedSig = sig;
+ if ( shiftDist ) shiftedSig >>= shiftDist;
+ if ( shiftedSig>>32 ) goto invalid;
+ absZ = shiftedSig;
+ if ( exact && shiftDist ) {
+ raiseInexact = ((uint64_t) absZ<
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+int_fast64_t
+ extF80M_to_i64(
+ const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
+{
+
+ return extF80_to_i64( *aPtr, roundingMode, exact );
+
+}
+
+#else
+
+int_fast64_t
+ extF80M_to_i64(
+ const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
+{
+ const struct extFloat80M *aSPtr;
+ uint_fast16_t uiA64;
+ bool sign;
+ int32_t exp;
+ uint64_t sig;
+ int32_t shiftDist;
+ uint32_t extSig[3];
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ aSPtr = (const struct extFloat80M *) aPtr;
+ uiA64 = aSPtr->signExp;
+ sign = signExtF80UI64( uiA64 );
+ exp = expExtF80UI64( uiA64 );
+ sig = aSPtr->signif;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ shiftDist = 0x403E - exp;
+ if ( shiftDist < 0 ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ return
+ (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
+ ? i64_fromNaN
+ : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ extSig[indexWord( 3, 2 )] = sig>>32;
+ extSig[indexWord( 3, 1 )] = sig;
+ extSig[indexWord( 3, 0 )] = 0;
+ if ( shiftDist ) softfloat_shiftRightJam96M( extSig, shiftDist, extSig );
+ return softfloat_roundMToI64( sign, extSig, roundingMode, exact );
+
+}
+
+#endif
+
diff --git a/test/float/softfloat/source/extF80M_to_i64_r_minMag.c b/test/float/softfloat/source/extF80M_to_i64_r_minMag.c
new file mode 100644
index 000000000..07282cd42
--- /dev/null
+++ b/test/float/softfloat/source/extF80M_to_i64_r_minMag.c
@@ -0,0 +1,115 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+int_fast64_t extF80M_to_i64_r_minMag( const extFloat80_t *aPtr, bool exact )
+{
+
+ return extF80_to_i64_r_minMag( *aPtr, exact );
+
+}
+
+#else
+
+int_fast64_t extF80M_to_i64_r_minMag( const extFloat80_t *aPtr, bool exact )
+{
+ const struct extFloat80M *aSPtr;
+ uint_fast16_t uiA64;
+ int32_t exp;
+ uint64_t sig;
+ int32_t shiftDist;
+ bool sign, raiseInexact;
+ int64_t z;
+ uint64_t absZ;
+ union { uint64_t ui; int64_t i; } u;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ aSPtr = (const struct extFloat80M *) aPtr;
+ uiA64 = aSPtr->signExp;
+ exp = expExtF80UI64( uiA64 );
+ sig = aSPtr->signif;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( ! sig && (exp != 0x7FFF) ) return 0;
+ shiftDist = 0x403E - exp;
+ if ( 64 <= shiftDist ) {
+ raiseInexact = exact;
+ z = 0;
+ } else {
+ sign = signExtF80UI64( uiA64 );
+ raiseInexact = false;
+ if ( shiftDist < 0 ) {
+ if ( shiftDist <= -63 ) goto invalid;
+ shiftDist = -shiftDist;
+ absZ = sig<>shiftDist != sig ) goto invalid;
+ } else {
+ absZ = sig;
+ if ( shiftDist ) absZ >>= shiftDist;
+ if ( exact && shiftDist ) raiseInexact = (absZ<
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+uint_fast32_t
+ extF80M_to_ui32(
+ const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
+{
+
+ return extF80_to_ui32( *aPtr, roundingMode, exact );
+
+}
+
+#else
+
+uint_fast32_t
+ extF80M_to_ui32(
+ const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
+{
+ const struct extFloat80M *aSPtr;
+ uint_fast16_t uiA64;
+ bool sign;
+ int32_t exp;
+ uint64_t sig;
+ int32_t shiftDist;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ aSPtr = (const struct extFloat80M *) aPtr;
+ uiA64 = aSPtr->signExp;
+ sign = signExtF80UI64( uiA64 );
+ exp = expExtF80UI64( uiA64 );
+ sig = aSPtr->signif;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ shiftDist = 0x4032 - exp;
+ if ( shiftDist <= 0 ) {
+ if ( sig>>32 ) goto invalid;
+ if ( -32 < shiftDist ) {
+ sig <<= -shiftDist;
+ } else {
+ if ( (uint32_t) sig ) goto invalid;
+ }
+ } else {
+ sig = softfloat_shiftRightJam64( sig, shiftDist );
+ }
+ return softfloat_roundToUI32( sign, sig, roundingMode, exact );
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ invalid:
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ return
+ (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
+ ? ui32_fromNaN
+ : sign ? ui32_fromNegOverflow : ui32_fromPosOverflow;
+
+}
+
+#endif
+
diff --git a/test/float/softfloat/source/extF80M_to_ui32_r_minMag.c b/test/float/softfloat/source/extF80M_to_ui32_r_minMag.c
new file mode 100644
index 000000000..c09e48341
--- /dev/null
+++ b/test/float/softfloat/source/extF80M_to_ui32_r_minMag.c
@@ -0,0 +1,111 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+uint_fast32_t extF80M_to_ui32_r_minMag( const extFloat80_t *aPtr, bool exact )
+{
+
+ return extF80_to_ui32_r_minMag( *aPtr, exact );
+
+}
+
+#else
+
+uint_fast32_t extF80M_to_ui32_r_minMag( const extFloat80_t *aPtr, bool exact )
+{
+ const struct extFloat80M *aSPtr;
+ uint_fast16_t uiA64;
+ int32_t exp;
+ uint64_t sig;
+ int32_t shiftDist;
+ bool sign;
+ uint64_t shiftedSig;
+ uint32_t z;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ aSPtr = (const struct extFloat80M *) aPtr;
+ uiA64 = aSPtr->signExp;
+ exp = expExtF80UI64( uiA64 );
+ sig = aSPtr->signif;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( ! sig && (exp != 0x7FFF) ) return 0;
+ shiftDist = 0x403E - exp;
+ if ( 64 <= shiftDist ) {
+ if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+ return 0;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ sign = signExtF80UI64( uiA64 );
+ if ( shiftDist < 0 ) {
+ if ( sign || sig>>32 || (shiftDist <= -31) ) goto invalid;
+ shiftedSig = (uint64_t) (uint32_t) sig<<-shiftDist;
+ if ( shiftedSig>>32 ) goto invalid;
+ z = shiftedSig;
+ } else {
+ shiftedSig = sig;
+ if ( shiftDist ) shiftedSig >>= shiftDist;
+ if ( shiftedSig>>32 ) goto invalid;
+ z = shiftedSig;
+ if ( sign && z ) goto invalid;
+ if ( exact && shiftDist && ((uint64_t) z<
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+uint_fast64_t
+ extF80M_to_ui64(
+ const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
+{
+
+ return extF80_to_ui64( *aPtr, roundingMode, exact );
+
+}
+
+#else
+
+uint_fast64_t
+ extF80M_to_ui64(
+ const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
+{
+ const struct extFloat80M *aSPtr;
+ uint_fast16_t uiA64;
+ bool sign;
+ int32_t exp;
+ uint64_t sig;
+ int32_t shiftDist;
+ uint32_t extSig[3];
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ aSPtr = (const struct extFloat80M *) aPtr;
+ uiA64 = aSPtr->signExp;
+ sign = signExtF80UI64( uiA64 );
+ exp = expExtF80UI64( uiA64 );
+ sig = aSPtr->signif;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ shiftDist = 0x403E - exp;
+ if ( shiftDist < 0 ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ return
+ (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
+ ? ui64_fromNaN
+ : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ extSig[indexWord( 3, 2 )] = sig>>32;
+ extSig[indexWord( 3, 1 )] = sig;
+ extSig[indexWord( 3, 0 )] = 0;
+ if ( shiftDist ) softfloat_shiftRightJam96M( extSig, shiftDist, extSig );
+ return softfloat_roundMToUI64( sign, extSig, roundingMode, exact );
+
+}
+
+#endif
+
diff --git a/test/float/softfloat/source/extF80M_to_ui64_r_minMag.c b/test/float/softfloat/source/extF80M_to_ui64_r_minMag.c
new file mode 100644
index 000000000..bf4839032
--- /dev/null
+++ b/test/float/softfloat/source/extF80M_to_ui64_r_minMag.c
@@ -0,0 +1,108 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+uint_fast64_t extF80M_to_ui64_r_minMag( const extFloat80_t *aPtr, bool exact )
+{
+
+ return extF80_to_ui64_r_minMag( *aPtr, exact );
+
+}
+
+#else
+
+uint_fast64_t extF80M_to_ui64_r_minMag( const extFloat80_t *aPtr, bool exact )
+{
+ const struct extFloat80M *aSPtr;
+ uint_fast16_t uiA64;
+ int32_t exp;
+ uint64_t sig;
+ int32_t shiftDist;
+ bool sign;
+ uint64_t z;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ aSPtr = (const struct extFloat80M *) aPtr;
+ uiA64 = aSPtr->signExp;
+ exp = expExtF80UI64( uiA64 );
+ sig = aSPtr->signif;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( ! sig && (exp != 0x7FFF) ) return 0;
+ shiftDist = 0x403E - exp;
+ if ( 64 <= shiftDist ) {
+ if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+ return 0;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ sign = signExtF80UI64( uiA64 );
+ if ( shiftDist < 0 ) {
+ if ( sign || (shiftDist <= -63) ) goto invalid;
+ shiftDist = -shiftDist;
+ z = sig<>shiftDist != sig ) goto invalid;
+ } else {
+ z = sig;
+ if ( shiftDist ) z >>= shiftDist;
+ if ( sign && z ) goto invalid;
+ if ( exact && shiftDist && (z<
+#include
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+extFloat80_t extF80_add( extFloat80_t a, extFloat80_t b )
+{
+ union { struct extFloat80M s; extFloat80_t f; } uA;
+ uint_fast16_t uiA64;
+ uint_fast64_t uiA0;
+ bool signA;
+ union { struct extFloat80M s; extFloat80_t f; } uB;
+ uint_fast16_t uiB64;
+ uint_fast64_t uiB0;
+ bool signB;
+#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
+ extFloat80_t
+ (*magsFuncPtr)(
+ uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool );
+#endif
+
+ uA.f = a;
+ uiA64 = uA.s.signExp;
+ uiA0 = uA.s.signif;
+ signA = signExtF80UI64( uiA64 );
+ uB.f = b;
+ uiB64 = uB.s.signExp;
+ uiB0 = uB.s.signif;
+ signB = signExtF80UI64( uiB64 );
+#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
+ if ( signA == signB ) {
+ return softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
+ } else {
+ return softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
+ }
+#else
+ magsFuncPtr =
+ (signA == signB) ? softfloat_addMagsExtF80 : softfloat_subMagsExtF80;
+ return (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
+#endif
+
+}
+
diff --git a/test/float/softfloat/source/extF80_div.c b/test/float/softfloat/source/extF80_div.c
new file mode 100644
index 000000000..7d649c549
--- /dev/null
+++ b/test/float/softfloat/source/extF80_div.c
@@ -0,0 +1,203 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+extFloat80_t extF80_div( extFloat80_t a, extFloat80_t b )
+{
+ union { struct extFloat80M s; extFloat80_t f; } uA;
+ uint_fast16_t uiA64;
+ uint_fast64_t uiA0;
+ bool signA;
+ int_fast32_t expA;
+ uint_fast64_t sigA;
+ union { struct extFloat80M s; extFloat80_t f; } uB;
+ uint_fast16_t uiB64;
+ uint_fast64_t uiB0;
+ bool signB;
+ int_fast32_t expB;
+ uint_fast64_t sigB;
+ bool signZ;
+ struct exp32_sig64 normExpSig;
+ int_fast32_t expZ;
+ struct uint128 rem;
+ uint_fast32_t recip32;
+ uint_fast64_t sigZ;
+ int ix;
+ uint_fast64_t q64;
+ uint_fast32_t q;
+ struct uint128 term;
+ uint_fast64_t sigZExtra;
+ struct uint128 uiZ;
+ uint_fast16_t uiZ64;
+ uint_fast64_t uiZ0;
+ union { struct extFloat80M s; extFloat80_t f; } uZ;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uA.f = a;
+ uiA64 = uA.s.signExp;
+ uiA0 = uA.s.signif;
+ signA = signExtF80UI64( uiA64 );
+ expA = expExtF80UI64( uiA64 );
+ sigA = uiA0;
+ uB.f = b;
+ uiB64 = uB.s.signExp;
+ uiB0 = uB.s.signif;
+ signB = signExtF80UI64( uiB64 );
+ expB = expExtF80UI64( uiB64 );
+ sigB = uiB0;
+ signZ = signA ^ signB;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( expA == 0x7FFF ) {
+ if ( sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) goto propagateNaN;
+ if ( expB == 0x7FFF ) {
+ if ( sigB & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) goto propagateNaN;
+ goto invalid;
+ }
+ goto infinity;
+ }
+ if ( expB == 0x7FFF ) {
+ if ( sigB & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) goto propagateNaN;
+ goto zero;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( ! expB ) expB = 1;
+ if ( ! (sigB & UINT64_C( 0x8000000000000000 )) ) {
+ if ( ! sigB ) {
+ if ( ! sigA ) goto invalid;
+ softfloat_raiseFlags( softfloat_flag_infinite );
+ goto infinity;
+ }
+ normExpSig = softfloat_normSubnormalExtF80Sig( sigB );
+ expB += normExpSig.exp;
+ sigB = normExpSig.sig;
+ }
+ if ( ! expA ) expA = 1;
+ if ( ! (sigA & UINT64_C( 0x8000000000000000 )) ) {
+ if ( ! sigA ) goto zero;
+ normExpSig = softfloat_normSubnormalExtF80Sig( sigA );
+ expA += normExpSig.exp;
+ sigA = normExpSig.sig;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ expZ = expA - expB + 0x3FFF;
+ if ( sigA < sigB ) {
+ --expZ;
+ rem = softfloat_shortShiftLeft128( 0, sigA, 32 );
+ } else {
+ rem = softfloat_shortShiftLeft128( 0, sigA, 31 );
+ }
+ recip32 = softfloat_approxRecip32_1( sigB>>32 );
+ sigZ = 0;
+ ix = 2;
+ for (;;) {
+ q64 = (uint_fast64_t) (uint32_t) (rem.v64>>2) * recip32;
+ q = (q64 + 0x80000000)>>32;
+ --ix;
+ if ( ix < 0 ) break;
+ rem = softfloat_shortShiftLeft128( rem.v64, rem.v0, 29 );
+ term = softfloat_mul64ByShifted32To128( sigB, q );
+ rem = softfloat_sub128( rem.v64, rem.v0, term.v64, term.v0 );
+ if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) {
+ --q;
+ rem = softfloat_add128( rem.v64, rem.v0, sigB>>32, sigB<<32 );
+ }
+ sigZ = (sigZ<<29) + q;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( ((q + 1) & 0x3FFFFF) < 2 ) {
+ rem = softfloat_shortShiftLeft128( rem.v64, rem.v0, 29 );
+ term = softfloat_mul64ByShifted32To128( sigB, q );
+ rem = softfloat_sub128( rem.v64, rem.v0, term.v64, term.v0 );
+ term = softfloat_shortShiftLeft128( 0, sigB, 32 );
+ if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) {
+ --q;
+ rem = softfloat_add128( rem.v64, rem.v0, term.v64, term.v0 );
+ } else if ( softfloat_le128( term.v64, term.v0, rem.v64, rem.v0 ) ) {
+ ++q;
+ rem = softfloat_sub128( rem.v64, rem.v0, term.v64, term.v0 );
+ }
+ if ( rem.v64 | rem.v0 ) q |= 1;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ sigZ = (sigZ<<6) + (q>>23);
+ sigZExtra = (uint64_t) ((uint_fast64_t) q<<41);
+ return
+ softfloat_roundPackToExtF80(
+ signZ, expZ, sigZ, sigZExtra, extF80_roundingPrecision );
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ propagateNaN:
+ uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 );
+ uiZ64 = uiZ.v64;
+ uiZ0 = uiZ.v0;
+ goto uiZ;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ invalid:
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ uiZ64 = defaultNaNExtF80UI64;
+ uiZ0 = defaultNaNExtF80UI0;
+ goto uiZ;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ infinity:
+ uiZ64 = packToExtF80UI64( signZ, 0x7FFF );
+ uiZ0 = UINT64_C( 0x8000000000000000 );
+ goto uiZ;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ zero:
+ uiZ64 = packToExtF80UI64( signZ, 0 );
+ uiZ0 = 0;
+ uiZ:
+ uZ.s.signExp = uiZ64;
+ uZ.s.signif = uiZ0;
+ return uZ.f;
+
+}
+
diff --git a/test/float/softfloat/source/extF80_eq.c b/test/float/softfloat/source/extF80_eq.c
new file mode 100644
index 000000000..60f29dafa
--- /dev/null
+++ b/test/float/softfloat/source/extF80_eq.c
@@ -0,0 +1,73 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+bool extF80_eq( extFloat80_t a, extFloat80_t b )
+{
+ union { struct extFloat80M s; extFloat80_t f; } uA;
+ uint_fast16_t uiA64;
+ uint_fast64_t uiA0;
+ union { struct extFloat80M s; extFloat80_t f; } uB;
+ uint_fast16_t uiB64;
+ uint_fast64_t uiB0;
+
+ uA.f = a;
+ uiA64 = uA.s.signExp;
+ uiA0 = uA.s.signif;
+ uB.f = b;
+ uiB64 = uB.s.signExp;
+ uiB0 = uB.s.signif;
+ if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
+ if (
+ softfloat_isSigNaNExtF80UI( uiA64, uiA0 )
+ || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
+ ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ }
+ return false;
+ }
+ return
+ (uiA0 == uiB0)
+ && ((uiA64 == uiB64) || (! uiA0 && ! ((uiA64 | uiB64) & 0x7FFF)));
+
+}
+
diff --git a/test/float/softfloat/source/extF80_eq_signaling.c b/test/float/softfloat/source/extF80_eq_signaling.c
new file mode 100644
index 000000000..5a0dfe4aa
--- /dev/null
+++ b/test/float/softfloat/source/extF80_eq_signaling.c
@@ -0,0 +1,67 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+bool extF80_eq_signaling( extFloat80_t a, extFloat80_t b )
+{
+ union { struct extFloat80M s; extFloat80_t f; } uA;
+ uint_fast16_t uiA64;
+ uint_fast64_t uiA0;
+ union { struct extFloat80M s; extFloat80_t f; } uB;
+ uint_fast16_t uiB64;
+ uint_fast64_t uiB0;
+
+ uA.f = a;
+ uiA64 = uA.s.signExp;
+ uiA0 = uA.s.signif;
+ uB.f = b;
+ uiB64 = uB.s.signExp;
+ uiB0 = uB.s.signif;
+ if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ return false;
+ }
+ return
+ (uiA0 == uiB0)
+ && ((uiA64 == uiB64) || (! uiA0 && ! ((uiA64 | uiB64) & 0x7FFF)));
+
+}
+
diff --git a/test/float/softfloat/source/extF80_isSignalingNaN.c b/test/float/softfloat/source/extF80_isSignalingNaN.c
new file mode 100644
index 000000000..6086f4b70
--- /dev/null
+++ b/test/float/softfloat/source/extF80_isSignalingNaN.c
@@ -0,0 +1,51 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+bool extF80_isSignalingNaN( extFloat80_t a )
+{
+ union { struct extFloat80M s; extFloat80_t f; } uA;
+
+ uA.f = a;
+ return softfloat_isSigNaNExtF80UI( uA.s.signExp, uA.s.signif );
+
+}
+
diff --git a/test/float/softfloat/source/extF80_le.c b/test/float/softfloat/source/extF80_le.c
new file mode 100644
index 000000000..2a1ee60f6
--- /dev/null
+++ b/test/float/softfloat/source/extF80_le.c
@@ -0,0 +1,73 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+bool extF80_le( extFloat80_t a, extFloat80_t b )
+{
+ union { struct extFloat80M s; extFloat80_t f; } uA;
+ uint_fast16_t uiA64;
+ uint_fast64_t uiA0;
+ union { struct extFloat80M s; extFloat80_t f; } uB;
+ uint_fast16_t uiB64;
+ uint_fast64_t uiB0;
+ bool signA, signB;
+
+ uA.f = a;
+ uiA64 = uA.s.signExp;
+ uiA0 = uA.s.signif;
+ uB.f = b;
+ uiB64 = uB.s.signExp;
+ uiB0 = uB.s.signif;
+ if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ return false;
+ }
+ signA = signExtF80UI64( uiA64 );
+ signB = signExtF80UI64( uiB64 );
+ return
+ (signA != signB)
+ ? signA || ! (((uiA64 | uiB64) & 0x7FFF) | uiA0 | uiB0)
+ : ((uiA64 == uiB64) && (uiA0 == uiB0))
+ || (signA ^ softfloat_lt128( uiA64, uiA0, uiB64, uiB0 ));
+
+}
+
diff --git a/test/float/softfloat/source/extF80_le_quiet.c b/test/float/softfloat/source/extF80_le_quiet.c
new file mode 100644
index 000000000..5d0c3ae73
--- /dev/null
+++ b/test/float/softfloat/source/extF80_le_quiet.c
@@ -0,0 +1,78 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+bool extF80_le_quiet( extFloat80_t a, extFloat80_t b )
+{
+ union { struct extFloat80M s; extFloat80_t f; } uA;
+ uint_fast16_t uiA64;
+ uint_fast64_t uiA0;
+ union { struct extFloat80M s; extFloat80_t f; } uB;
+ uint_fast16_t uiB64;
+ uint_fast64_t uiB0;
+ bool signA, signB;
+
+ uA.f = a;
+ uiA64 = uA.s.signExp;
+ uiA0 = uA.s.signif;
+ uB.f = b;
+ uiB64 = uB.s.signExp;
+ uiB0 = uB.s.signif;
+ if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
+ if (
+ softfloat_isSigNaNExtF80UI( uiA64, uiA0 )
+ || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
+ ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ }
+ return false;
+ }
+ signA = signExtF80UI64( uiA64 );
+ signB = signExtF80UI64( uiB64 );
+ return
+ (signA != signB)
+ ? signA || ! (((uiA64 | uiB64) & 0x7FFF) | uiA0 | uiB0)
+ : ((uiA64 == uiB64) && (uiA0 == uiB0))
+ || (signA ^ softfloat_lt128( uiA64, uiA0, uiB64, uiB0 ));
+
+}
+
diff --git a/test/float/softfloat/source/extF80_lt.c b/test/float/softfloat/source/extF80_lt.c
new file mode 100644
index 000000000..9560d8ecc
--- /dev/null
+++ b/test/float/softfloat/source/extF80_lt.c
@@ -0,0 +1,73 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+bool extF80_lt( extFloat80_t a, extFloat80_t b )
+{
+ union { struct extFloat80M s; extFloat80_t f; } uA;
+ uint_fast16_t uiA64;
+ uint_fast64_t uiA0;
+ union { struct extFloat80M s; extFloat80_t f; } uB;
+ uint_fast16_t uiB64;
+ uint_fast64_t uiB0;
+ bool signA, signB;
+
+ uA.f = a;
+ uiA64 = uA.s.signExp;
+ uiA0 = uA.s.signif;
+ uB.f = b;
+ uiB64 = uB.s.signExp;
+ uiB0 = uB.s.signif;
+ if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ return false;
+ }
+ signA = signExtF80UI64( uiA64 );
+ signB = signExtF80UI64( uiB64 );
+ return
+ (signA != signB)
+ ? signA && (((uiA64 | uiB64) & 0x7FFF) | uiA0 | uiB0)
+ : ((uiA64 != uiB64) || (uiA0 != uiB0))
+ && (signA ^ softfloat_lt128( uiA64, uiA0, uiB64, uiB0 ));
+
+}
+
diff --git a/test/float/softfloat/source/extF80_lt_quiet.c b/test/float/softfloat/source/extF80_lt_quiet.c
new file mode 100644
index 000000000..711652c7d
--- /dev/null
+++ b/test/float/softfloat/source/extF80_lt_quiet.c
@@ -0,0 +1,78 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+bool extF80_lt_quiet( extFloat80_t a, extFloat80_t b )
+{
+ union { struct extFloat80M s; extFloat80_t f; } uA;
+ uint_fast16_t uiA64;
+ uint_fast64_t uiA0;
+ union { struct extFloat80M s; extFloat80_t f; } uB;
+ uint_fast16_t uiB64;
+ uint_fast64_t uiB0;
+ bool signA, signB;
+
+ uA.f = a;
+ uiA64 = uA.s.signExp;
+ uiA0 = uA.s.signif;
+ uB.f = b;
+ uiB64 = uB.s.signExp;
+ uiB0 = uB.s.signif;
+ if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
+ if (
+ softfloat_isSigNaNExtF80UI( uiA64, uiA0 )
+ || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
+ ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ }
+ return false;
+ }
+ signA = signExtF80UI64( uiA64 );
+ signB = signExtF80UI64( uiB64 );
+ return
+ (signA != signB)
+ ? signA && (((uiA64 | uiB64) & 0x7FFF) | uiA0 | uiB0)
+ : ((uiA64 != uiB64) || (uiA0 != uiB0))
+ && (signA ^ softfloat_lt128( uiA64, uiA0, uiB64, uiB0 ));
+
+}
+
diff --git a/test/float/softfloat/source/extF80_mul.c b/test/float/softfloat/source/extF80_mul.c
new file mode 100644
index 000000000..c0c50a6ca
--- /dev/null
+++ b/test/float/softfloat/source/extF80_mul.c
@@ -0,0 +1,158 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+extFloat80_t extF80_mul( extFloat80_t a, extFloat80_t b )
+{
+ union { struct extFloat80M s; extFloat80_t f; } uA;
+ uint_fast16_t uiA64;
+ uint_fast64_t uiA0;
+ bool signA;
+ int_fast32_t expA;
+ uint_fast64_t sigA;
+ union { struct extFloat80M s; extFloat80_t f; } uB;
+ uint_fast16_t uiB64;
+ uint_fast64_t uiB0;
+ bool signB;
+ int_fast32_t expB;
+ uint_fast64_t sigB;
+ bool signZ;
+ uint_fast64_t magBits;
+ struct exp32_sig64 normExpSig;
+ int_fast32_t expZ;
+ struct uint128 sig128Z, uiZ;
+ uint_fast16_t uiZ64;
+ uint_fast64_t uiZ0;
+ union { struct extFloat80M s; extFloat80_t f; } uZ;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uA.f = a;
+ uiA64 = uA.s.signExp;
+ uiA0 = uA.s.signif;
+ signA = signExtF80UI64( uiA64 );
+ expA = expExtF80UI64( uiA64 );
+ sigA = uiA0;
+ uB.f = b;
+ uiB64 = uB.s.signExp;
+ uiB0 = uB.s.signif;
+ signB = signExtF80UI64( uiB64 );
+ expB = expExtF80UI64( uiB64 );
+ sigB = uiB0;
+ signZ = signA ^ signB;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( expA == 0x7FFF ) {
+ if (
+ (sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
+ || ((expB == 0x7FFF) && (sigB & UINT64_C( 0x7FFFFFFFFFFFFFFF )))
+ ) {
+ goto propagateNaN;
+ }
+ magBits = expB | sigB;
+ goto infArg;
+ }
+ if ( expB == 0x7FFF ) {
+ if ( sigB & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) goto propagateNaN;
+ magBits = expA | sigA;
+ goto infArg;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( ! expA ) expA = 1;
+ if ( ! (sigA & UINT64_C( 0x8000000000000000 )) ) {
+ if ( ! sigA ) goto zero;
+ normExpSig = softfloat_normSubnormalExtF80Sig( sigA );
+ expA += normExpSig.exp;
+ sigA = normExpSig.sig;
+ }
+ if ( ! expB ) expB = 1;
+ if ( ! (sigB & UINT64_C( 0x8000000000000000 )) ) {
+ if ( ! sigB ) goto zero;
+ normExpSig = softfloat_normSubnormalExtF80Sig( sigB );
+ expB += normExpSig.exp;
+ sigB = normExpSig.sig;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ expZ = expA + expB - 0x3FFE;
+ sig128Z = softfloat_mul64To128( sigA, sigB );
+ if ( sig128Z.v64 < UINT64_C( 0x8000000000000000 ) ) {
+ --expZ;
+ sig128Z =
+ softfloat_add128(
+ sig128Z.v64, sig128Z.v0, sig128Z.v64, sig128Z.v0 );
+ }
+ return
+ softfloat_roundPackToExtF80(
+ signZ, expZ, sig128Z.v64, sig128Z.v0, extF80_roundingPrecision );
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ propagateNaN:
+ uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 );
+ uiZ64 = uiZ.v64;
+ uiZ0 = uiZ.v0;
+ goto uiZ;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ infArg:
+ if ( ! magBits ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ uiZ64 = defaultNaNExtF80UI64;
+ uiZ0 = defaultNaNExtF80UI0;
+ } else {
+ uiZ64 = packToExtF80UI64( signZ, 0x7FFF );
+ uiZ0 = UINT64_C( 0x8000000000000000 );
+ }
+ goto uiZ;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ zero:
+ uiZ64 = packToExtF80UI64( signZ, 0 );
+ uiZ0 = 0;
+ uiZ:
+ uZ.s.signExp = uiZ64;
+ uZ.s.signif = uiZ0;
+ return uZ.f;
+
+}
+
diff --git a/test/float/softfloat/source/extF80_rem.c b/test/float/softfloat/source/extF80_rem.c
new file mode 100644
index 000000000..a2ebaad81
--- /dev/null
+++ b/test/float/softfloat/source/extF80_rem.c
@@ -0,0 +1,225 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+extFloat80_t extF80_rem( extFloat80_t a, extFloat80_t b )
+{
+ union { struct extFloat80M s; extFloat80_t f; } uA;
+ uint_fast16_t uiA64;
+ uint_fast64_t uiA0;
+ bool signA;
+ int_fast32_t expA;
+ uint_fast64_t sigA;
+ union { struct extFloat80M s; extFloat80_t f; } uB;
+ uint_fast16_t uiB64;
+ uint_fast64_t uiB0;
+ int_fast32_t expB;
+ uint_fast64_t sigB;
+ struct exp32_sig64 normExpSig;
+ int_fast32_t expDiff;
+ struct uint128 rem, shiftedSigB;
+ uint_fast32_t q, recip32;
+ uint_fast64_t q64;
+ struct uint128 term, altRem, meanRem;
+ bool signRem;
+ struct uint128 uiZ;
+ uint_fast16_t uiZ64;
+ uint_fast64_t uiZ0;
+ union { struct extFloat80M s; extFloat80_t f; } uZ;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uA.f = a;
+ uiA64 = uA.s.signExp;
+ uiA0 = uA.s.signif;
+ signA = signExtF80UI64( uiA64 );
+ expA = expExtF80UI64( uiA64 );
+ sigA = uiA0;
+ uB.f = b;
+ uiB64 = uB.s.signExp;
+ uiB0 = uB.s.signif;
+ expB = expExtF80UI64( uiB64 );
+ sigB = uiB0;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( expA == 0x7FFF ) {
+ if (
+ (sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
+ || ((expB == 0x7FFF) && (sigB & UINT64_C( 0x7FFFFFFFFFFFFFFF )))
+ ) {
+ goto propagateNaN;
+ }
+ goto invalid;
+ }
+ if ( expB == 0x7FFF ) {
+ if ( sigB & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) goto propagateNaN;
+ /*--------------------------------------------------------------------
+ | Argument b is an infinity. Doubling `expB' is an easy way to ensure
+ | that `expDiff' later is less than -1, which will result in returning
+ | a canonicalized version of argument a.
+ *--------------------------------------------------------------------*/
+ expB += expB;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( ! expB ) expB = 1;
+ if ( ! (sigB & UINT64_C( 0x8000000000000000 )) ) {
+ if ( ! sigB ) goto invalid;
+ normExpSig = softfloat_normSubnormalExtF80Sig( sigB );
+ expB += normExpSig.exp;
+ sigB = normExpSig.sig;
+ }
+ if ( ! expA ) expA = 1;
+ if ( ! (sigA & UINT64_C( 0x8000000000000000 )) ) {
+ if ( ! sigA ) {
+ expA = 0;
+ goto copyA;
+ }
+ normExpSig = softfloat_normSubnormalExtF80Sig( sigA );
+ expA += normExpSig.exp;
+ sigA = normExpSig.sig;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ expDiff = expA - expB;
+ if ( expDiff < -1 ) goto copyA;
+ rem = softfloat_shortShiftLeft128( 0, sigA, 32 );
+ shiftedSigB = softfloat_shortShiftLeft128( 0, sigB, 32 );
+ if ( expDiff < 1 ) {
+ if ( expDiff ) {
+ --expB;
+ shiftedSigB = softfloat_shortShiftLeft128( 0, sigB, 33 );
+ q = 0;
+ } else {
+ q = (sigB <= sigA);
+ if ( q ) {
+ rem =
+ softfloat_sub128(
+ rem.v64, rem.v0, shiftedSigB.v64, shiftedSigB.v0 );
+ }
+ }
+ } else {
+ recip32 = softfloat_approxRecip32_1( sigB>>32 );
+ expDiff -= 30;
+ for (;;) {
+ q64 = (uint_fast64_t) (uint32_t) (rem.v64>>2) * recip32;
+ if ( expDiff < 0 ) break;
+ q = (q64 + 0x80000000)>>32;
+ rem = softfloat_shortShiftLeft128( rem.v64, rem.v0, 29 );
+ term = softfloat_mul64ByShifted32To128( sigB, q );
+ rem = softfloat_sub128( rem.v64, rem.v0, term.v64, term.v0 );
+ if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) {
+ rem =
+ softfloat_add128(
+ rem.v64, rem.v0, shiftedSigB.v64, shiftedSigB.v0 );
+ }
+ expDiff -= 29;
+ }
+ /*--------------------------------------------------------------------
+ | (`expDiff' cannot be less than -29 here.)
+ *--------------------------------------------------------------------*/
+ q = (uint32_t) (q64>>32)>>(~expDiff & 31);
+ rem = softfloat_shortShiftLeft128( rem.v64, rem.v0, expDiff + 30 );
+ term = softfloat_mul64ByShifted32To128( sigB, q );
+ rem = softfloat_sub128( rem.v64, rem.v0, term.v64, term.v0 );
+ if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) {
+ altRem =
+ softfloat_add128(
+ rem.v64, rem.v0, shiftedSigB.v64, shiftedSigB.v0 );
+ goto selectRem;
+ }
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ do {
+ altRem = rem;
+ ++q;
+ rem =
+ softfloat_sub128(
+ rem.v64, rem.v0, shiftedSigB.v64, shiftedSigB.v0 );
+ } while ( ! (rem.v64 & UINT64_C( 0x8000000000000000 )) );
+ selectRem:
+ meanRem = softfloat_add128( rem.v64, rem.v0, altRem.v64, altRem.v0 );
+ if (
+ (meanRem.v64 & UINT64_C( 0x8000000000000000 ))
+ || (! (meanRem.v64 | meanRem.v0) && (q & 1))
+ ) {
+ rem = altRem;
+ }
+ signRem = signA;
+ if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) {
+ signRem = ! signRem;
+ rem = softfloat_sub128( 0, 0, rem.v64, rem.v0 );
+ }
+ return
+ softfloat_normRoundPackToExtF80(
+ signRem, rem.v64 | rem.v0 ? expB + 32 : 0, rem.v64, rem.v0, 80 );
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ propagateNaN:
+ uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 );
+ uiZ64 = uiZ.v64;
+ uiZ0 = uiZ.v0;
+ goto uiZ;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ invalid:
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ uiZ64 = defaultNaNExtF80UI64;
+ uiZ0 = defaultNaNExtF80UI0;
+ goto uiZ;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ copyA:
+ if ( expA < 1 ) {
+ sigA >>= 1 - expA;
+ expA = 0;
+ }
+ uiZ64 = packToExtF80UI64( signA, expA );
+ uiZ0 = sigA;
+ uiZ:
+ uZ.s.signExp = uiZ64;
+ uZ.s.signif = uiZ0;
+ return uZ.f;
+
+}
+
diff --git a/test/float/softfloat/source/extF80_roundToInt.c b/test/float/softfloat/source/extF80_roundToInt.c
new file mode 100644
index 000000000..8103dae8f
--- /dev/null
+++ b/test/float/softfloat/source/extF80_roundToInt.c
@@ -0,0 +1,154 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+extFloat80_t
+ extF80_roundToInt( extFloat80_t a, uint_fast8_t roundingMode, bool exact )
+{
+ union { struct extFloat80M s; extFloat80_t f; } uA;
+ uint_fast16_t uiA64, signUI64;
+ int_fast32_t exp;
+ uint_fast64_t sigA;
+ uint_fast16_t uiZ64;
+ uint_fast64_t sigZ;
+ struct exp32_sig64 normExpSig;
+ struct uint128 uiZ;
+ uint_fast64_t lastBitMask, roundBitsMask;
+ union { struct extFloat80M s; extFloat80_t f; } uZ;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uA.f = a;
+ uiA64 = uA.s.signExp;
+ signUI64 = uiA64 & packToExtF80UI64( 1, 0 );
+ exp = expExtF80UI64( uiA64 );
+ sigA = uA.s.signif;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( !(sigA & UINT64_C( 0x8000000000000000 )) && (exp != 0x7FFF) ) {
+ if ( !sigA ) {
+ uiZ64 = signUI64;
+ sigZ = 0;
+ goto uiZ;
+ }
+ normExpSig = softfloat_normSubnormalExtF80Sig( sigA );
+ exp += normExpSig.exp;
+ sigA = normExpSig.sig;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( 0x403E <= exp ) {
+ if ( exp == 0x7FFF ) {
+ if ( sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
+ uiZ = softfloat_propagateNaNExtF80UI( uiA64, sigA, 0, 0 );
+ uiZ64 = uiZ.v64;
+ sigZ = uiZ.v0;
+ goto uiZ;
+ }
+ sigZ = UINT64_C( 0x8000000000000000 );
+ } else {
+ sigZ = sigA;
+ }
+ uiZ64 = signUI64 | exp;
+ goto uiZ;
+ }
+ if ( exp <= 0x3FFE ) {
+ if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+ switch ( roundingMode ) {
+ case softfloat_round_near_even:
+ if ( !(sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ) break;
+ case softfloat_round_near_maxMag:
+ if ( exp == 0x3FFE ) goto mag1;
+ break;
+ case softfloat_round_min:
+ if ( signUI64 ) goto mag1;
+ break;
+ case softfloat_round_max:
+ if ( !signUI64 ) goto mag1;
+ break;
+#ifdef SOFTFLOAT_ROUND_ODD
+ case softfloat_round_odd:
+ goto mag1;
+#endif
+ }
+ uiZ64 = signUI64;
+ sigZ = 0;
+ goto uiZ;
+ mag1:
+ uiZ64 = signUI64 | 0x3FFF;
+ sigZ = UINT64_C( 0x8000000000000000 );
+ goto uiZ;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uiZ64 = signUI64 | exp;
+ lastBitMask = (uint_fast64_t) 1<<(0x403E - exp);
+ roundBitsMask = lastBitMask - 1;
+ sigZ = sigA;
+ if ( roundingMode == softfloat_round_near_maxMag ) {
+ sigZ += lastBitMask>>1;
+ } else if ( roundingMode == softfloat_round_near_even ) {
+ sigZ += lastBitMask>>1;
+ if ( !(sigZ & roundBitsMask) ) sigZ &= ~lastBitMask;
+ } else if (
+ roundingMode == (signUI64 ? softfloat_round_min : softfloat_round_max)
+ ) {
+ sigZ += roundBitsMask;
+ }
+ sigZ &= ~roundBitsMask;
+ if ( !sigZ ) {
+ ++uiZ64;
+ sigZ = UINT64_C( 0x8000000000000000 );
+ }
+ if ( sigZ != sigA ) {
+#ifdef SOFTFLOAT_ROUND_ODD
+ if ( roundingMode == softfloat_round_odd ) sigZ |= lastBitMask;
+#endif
+ if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+ }
+ uiZ:
+ uZ.s.signExp = uiZ64;
+ uZ.s.signif = sigZ;
+ return uZ.f;
+
+}
+
diff --git a/test/float/softfloat/source/extF80_sqrt.c b/test/float/softfloat/source/extF80_sqrt.c
new file mode 100644
index 000000000..5d328a0e4
--- /dev/null
+++ b/test/float/softfloat/source/extF80_sqrt.c
@@ -0,0 +1,176 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+extFloat80_t extF80_sqrt( extFloat80_t a )
+{
+ union { struct extFloat80M s; extFloat80_t f; } uA;
+ uint_fast16_t uiA64;
+ uint_fast64_t uiA0;
+ bool signA;
+ int_fast32_t expA;
+ uint_fast64_t sigA;
+ struct uint128 uiZ;
+ uint_fast16_t uiZ64;
+ uint_fast64_t uiZ0;
+ struct exp32_sig64 normExpSig;
+ int_fast32_t expZ;
+ uint_fast32_t sig32A, recipSqrt32, sig32Z;
+ struct uint128 rem;
+ uint_fast64_t q, x64, sigZ;
+ struct uint128 y, term;
+ uint_fast64_t sigZExtra;
+ union { struct extFloat80M s; extFloat80_t f; } uZ;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uA.f = a;
+ uiA64 = uA.s.signExp;
+ uiA0 = uA.s.signif;
+ signA = signExtF80UI64( uiA64 );
+ expA = expExtF80UI64( uiA64 );
+ sigA = uiA0;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( expA == 0x7FFF ) {
+ if ( sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
+ uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, 0, 0 );
+ uiZ64 = uiZ.v64;
+ uiZ0 = uiZ.v0;
+ goto uiZ;
+ }
+ if ( ! signA ) return a;
+ goto invalid;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( signA ) {
+ if ( ! sigA ) goto zero;
+ goto invalid;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( ! expA ) expA = 1;
+ if ( ! (sigA & UINT64_C( 0x8000000000000000 )) ) {
+ if ( ! sigA ) goto zero;
+ normExpSig = softfloat_normSubnormalExtF80Sig( sigA );
+ expA += normExpSig.exp;
+ sigA = normExpSig.sig;
+ }
+ /*------------------------------------------------------------------------
+ | (`sig32Z' is guaranteed to be a lower bound on the square root of
+ | `sig32A', which makes `sig32Z' also a lower bound on the square root of
+ | `sigA'.)
+ *------------------------------------------------------------------------*/
+ expZ = ((expA - 0x3FFF)>>1) + 0x3FFF;
+ expA &= 1;
+ sig32A = sigA>>32;
+ recipSqrt32 = softfloat_approxRecipSqrt32_1( expA, sig32A );
+ sig32Z = ((uint_fast64_t) sig32A * recipSqrt32)>>32;
+ if ( expA ) {
+ sig32Z >>= 1;
+ rem = softfloat_shortShiftLeft128( 0, sigA, 61 );
+ } else {
+ rem = softfloat_shortShiftLeft128( 0, sigA, 62 );
+ }
+ rem.v64 -= (uint_fast64_t) sig32Z * sig32Z;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ q = ((uint32_t) (rem.v64>>2) * (uint_fast64_t) recipSqrt32)>>32;
+ x64 = (uint_fast64_t) sig32Z<<32;
+ sigZ = x64 + (q<<3);
+ y = softfloat_shortShiftLeft128( rem.v64, rem.v0, 29 );
+ /*------------------------------------------------------------------------
+ | (Repeating this loop is a rare occurrence.)
+ *------------------------------------------------------------------------*/
+ for (;;) {
+ term = softfloat_mul64ByShifted32To128( x64 + sigZ, q );
+ rem = softfloat_sub128( y.v64, y.v0, term.v64, term.v0 );
+ if ( ! (rem.v64 & UINT64_C( 0x8000000000000000 )) ) break;
+ --q;
+ sigZ -= 1<<3;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ q = (((rem.v64>>2) * recipSqrt32)>>32) + 2;
+ x64 = sigZ;
+ sigZ = (sigZ<<1) + (q>>25);
+ sigZExtra = (uint64_t) (q<<39);
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( (q & 0xFFFFFF) <= 2 ) {
+ q &= ~(uint_fast64_t) 0xFFFF;
+ sigZExtra = (uint64_t) (q<<39);
+ term = softfloat_mul64ByShifted32To128( x64 + (q>>27), q );
+ x64 = (uint32_t) (q<<5) * (uint_fast64_t) (uint32_t) q;
+ term = softfloat_add128( term.v64, term.v0, 0, x64 );
+ rem = softfloat_shortShiftLeft128( rem.v64, rem.v0, 28 );
+ rem = softfloat_sub128( rem.v64, rem.v0, term.v64, term.v0 );
+ if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) {
+ if ( ! sigZExtra ) --sigZ;
+ --sigZExtra;
+ } else {
+ if ( rem.v64 | rem.v0 ) sigZExtra |= 1;
+ }
+ }
+ return
+ softfloat_roundPackToExtF80(
+ 0, expZ, sigZ, sigZExtra, extF80_roundingPrecision );
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ invalid:
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ uiZ64 = defaultNaNExtF80UI64;
+ uiZ0 = defaultNaNExtF80UI0;
+ goto uiZ;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ zero:
+ uiZ64 = packToExtF80UI64( signA, 0 );
+ uiZ0 = 0;
+ uiZ:
+ uZ.s.signExp = uiZ64;
+ uZ.s.signif = uiZ0;
+ return uZ.f;
+
+}
+
diff --git a/test/float/softfloat/source/extF80_sub.c b/test/float/softfloat/source/extF80_sub.c
new file mode 100644
index 000000000..494d3162c
--- /dev/null
+++ b/test/float/softfloat/source/extF80_sub.c
@@ -0,0 +1,80 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+extFloat80_t extF80_sub( extFloat80_t a, extFloat80_t b )
+{
+ union { struct extFloat80M s; extFloat80_t f; } uA;
+ uint_fast16_t uiA64;
+ uint_fast64_t uiA0;
+ bool signA;
+ union { struct extFloat80M s; extFloat80_t f; } uB;
+ uint_fast16_t uiB64;
+ uint_fast64_t uiB0;
+ bool signB;
+#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
+ extFloat80_t
+ (*magsFuncPtr)(
+ uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool );
+#endif
+
+ uA.f = a;
+ uiA64 = uA.s.signExp;
+ uiA0 = uA.s.signif;
+ signA = signExtF80UI64( uiA64 );
+ uB.f = b;
+ uiB64 = uB.s.signExp;
+ uiB0 = uB.s.signif;
+ signB = signExtF80UI64( uiB64 );
+#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
+ if ( signA == signB ) {
+ return softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
+ } else {
+ return softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
+ }
+#else
+ magsFuncPtr =
+ (signA == signB) ? softfloat_subMagsExtF80 : softfloat_addMagsExtF80;
+ return (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
+#endif
+
+}
+
diff --git a/test/float/softfloat/source/extF80_to_f128.c b/test/float/softfloat/source/extF80_to_f128.c
new file mode 100644
index 000000000..7fbc9cb69
--- /dev/null
+++ b/test/float/softfloat/source/extF80_to_f128.c
@@ -0,0 +1,75 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float128_t extF80_to_f128( extFloat80_t a )
+{
+ union { struct extFloat80M s; extFloat80_t f; } uA;
+ uint_fast16_t uiA64;
+ uint_fast64_t uiA0;
+ uint_fast16_t exp;
+ uint_fast64_t frac;
+ struct commonNaN commonNaN;
+ struct uint128 uiZ;
+ bool sign;
+ struct uint128 frac128;
+ union ui128_f128 uZ;
+
+ uA.f = a;
+ uiA64 = uA.s.signExp;
+ uiA0 = uA.s.signif;
+ exp = expExtF80UI64( uiA64 );
+ frac = uiA0 & UINT64_C( 0x7FFFFFFFFFFFFFFF );
+ if ( (exp == 0x7FFF) && frac ) {
+ softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN );
+ uiZ = softfloat_commonNaNToF128UI( &commonNaN );
+ } else {
+ sign = signExtF80UI64( uiA64 );
+ frac128 = softfloat_shortShiftLeft128( 0, frac, 49 );
+ uiZ.v64 = packToF128UI64( sign, exp, frac128.v64 );
+ uiZ.v0 = frac128.v0;
+ }
+ uZ.ui = uiZ;
+ return uZ.f;
+
+}
+
diff --git a/test/float/softfloat/source/extF80_to_f16.c b/test/float/softfloat/source/extF80_to_f16.c
new file mode 100644
index 000000000..ca5050f4c
--- /dev/null
+++ b/test/float/softfloat/source/extF80_to_f16.c
@@ -0,0 +1,96 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float16_t extF80_to_f16( extFloat80_t a )
+{
+ union { struct extFloat80M s; extFloat80_t f; } uA;
+ uint_fast16_t uiA64;
+ uint_fast64_t uiA0;
+ bool sign;
+ int_fast32_t exp;
+ uint_fast64_t sig;
+ struct commonNaN commonNaN;
+ uint_fast16_t uiZ, sig16;
+ union ui16_f16 uZ;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uA.f = a;
+ uiA64 = uA.s.signExp;
+ uiA0 = uA.s.signif;
+ sign = signExtF80UI64( uiA64 );
+ exp = expExtF80UI64( uiA64 );
+ sig = uiA0;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( exp == 0x7FFF ) {
+ if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
+ softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN );
+ uiZ = softfloat_commonNaNToF16UI( &commonNaN );
+ } else {
+ uiZ = packToF16UI( sign, 0x1F, 0 );
+ }
+ goto uiZ;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ sig16 = softfloat_shortShiftRightJam64( sig, 49 );
+ if ( ! (exp | sig16) ) {
+ uiZ = packToF16UI( sign, 0, 0 );
+ goto uiZ;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ exp -= 0x3FF1;
+ if ( sizeof (int_fast16_t) < sizeof (int_fast32_t) ) {
+ if ( exp < -0x40 ) exp = -0x40;
+ }
+ return softfloat_roundPackToF16( sign, exp, sig16 );
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uiZ:
+ uZ.ui = uiZ;
+ return uZ.f;
+
+}
+
diff --git a/test/float/softfloat/source/extF80_to_f32.c b/test/float/softfloat/source/extF80_to_f32.c
new file mode 100644
index 000000000..357f56e9d
--- /dev/null
+++ b/test/float/softfloat/source/extF80_to_f32.c
@@ -0,0 +1,96 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float32_t extF80_to_f32( extFloat80_t a )
+{
+ union { struct extFloat80M s; extFloat80_t f; } uA;
+ uint_fast16_t uiA64;
+ uint_fast64_t uiA0;
+ bool sign;
+ int_fast32_t exp;
+ uint_fast64_t sig;
+ struct commonNaN commonNaN;
+ uint_fast32_t uiZ, sig32;
+ union ui32_f32 uZ;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uA.f = a;
+ uiA64 = uA.s.signExp;
+ uiA0 = uA.s.signif;
+ sign = signExtF80UI64( uiA64 );
+ exp = expExtF80UI64( uiA64 );
+ sig = uiA0;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( exp == 0x7FFF ) {
+ if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
+ softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN );
+ uiZ = softfloat_commonNaNToF32UI( &commonNaN );
+ } else {
+ uiZ = packToF32UI( sign, 0xFF, 0 );
+ }
+ goto uiZ;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ sig32 = softfloat_shortShiftRightJam64( sig, 33 );
+ if ( ! (exp | sig32) ) {
+ uiZ = packToF32UI( sign, 0, 0 );
+ goto uiZ;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ exp -= 0x3F81;
+ if ( sizeof (int_fast16_t) < sizeof (int_fast32_t) ) {
+ if ( exp < -0x1000 ) exp = -0x1000;
+ }
+ return softfloat_roundPackToF32( sign, exp, sig32 );
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uiZ:
+ uZ.ui = uiZ;
+ return uZ.f;
+
+}
+
diff --git a/test/float/softfloat/source/extF80_to_f64.c b/test/float/softfloat/source/extF80_to_f64.c
new file mode 100644
index 000000000..c38739925
--- /dev/null
+++ b/test/float/softfloat/source/extF80_to_f64.c
@@ -0,0 +1,96 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float64_t extF80_to_f64( extFloat80_t a )
+{
+ union { struct extFloat80M s; extFloat80_t f; } uA;
+ uint_fast16_t uiA64;
+ uint_fast64_t uiA0;
+ bool sign;
+ int_fast32_t exp;
+ uint_fast64_t sig;
+ struct commonNaN commonNaN;
+ uint_fast64_t uiZ;
+ union ui64_f64 uZ;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uA.f = a;
+ uiA64 = uA.s.signExp;
+ uiA0 = uA.s.signif;
+ sign = signExtF80UI64( uiA64 );
+ exp = expExtF80UI64( uiA64 );
+ sig = uiA0;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( ! (exp | sig) ) {
+ uiZ = packToF64UI( sign, 0, 0 );
+ goto uiZ;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( exp == 0x7FFF ) {
+ if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
+ softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN );
+ uiZ = softfloat_commonNaNToF64UI( &commonNaN );
+ } else {
+ uiZ = packToF64UI( sign, 0x7FF, 0 );
+ }
+ goto uiZ;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ sig = softfloat_shortShiftRightJam64( sig, 1 );
+ exp -= 0x3C01;
+ if ( sizeof (int_fast16_t) < sizeof (int_fast32_t) ) {
+ if ( exp < -0x1000 ) exp = -0x1000;
+ }
+ return softfloat_roundPackToF64( sign, exp, sig );
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uiZ:
+ uZ.ui = uiZ;
+ return uZ.f;
+
+}
+
diff --git a/test/float/softfloat/source/extF80_to_i32.c b/test/float/softfloat/source/extF80_to_i32.c
new file mode 100644
index 000000000..549ca7659
--- /dev/null
+++ b/test/float/softfloat/source/extF80_to_i32.c
@@ -0,0 +1,83 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+int_fast32_t
+ extF80_to_i32( extFloat80_t a, uint_fast8_t roundingMode, bool exact )
+{
+ union { struct extFloat80M s; extFloat80_t f; } uA;
+ uint_fast16_t uiA64;
+ bool sign;
+ int_fast32_t exp;
+ uint_fast64_t sig;
+ int_fast32_t shiftDist;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uA.f = a;
+ uiA64 = uA.s.signExp;
+ sign = signExtF80UI64( uiA64 );
+ exp = expExtF80UI64( uiA64 );
+ sig = uA.s.signif;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+#if (i32_fromNaN != i32_fromPosOverflow) || (i32_fromNaN != i32_fromNegOverflow)
+ if ( (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ) {
+#if (i32_fromNaN == i32_fromPosOverflow)
+ sign = 0;
+#elif (i32_fromNaN == i32_fromNegOverflow)
+ sign = 1;
+#else
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ return i32_fromNaN;
+#endif
+ }
+#endif
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ shiftDist = 0x4032 - exp;
+ if ( shiftDist <= 0 ) shiftDist = 1;
+ sig = softfloat_shiftRightJam64( sig, shiftDist );
+ return softfloat_roundToI32( sign, sig, roundingMode, exact );
+
+}
+
diff --git a/test/float/softfloat/source/extF80_to_i32_r_minMag.c b/test/float/softfloat/source/extF80_to_i32_r_minMag.c
new file mode 100644
index 000000000..2b7b9e2b2
--- /dev/null
+++ b/test/float/softfloat/source/extF80_to_i32_r_minMag.c
@@ -0,0 +1,97 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+int_fast32_t extF80_to_i32_r_minMag( extFloat80_t a, bool exact )
+{
+ union { struct extFloat80M s; extFloat80_t f; } uA;
+ uint_fast16_t uiA64;
+ int_fast32_t exp;
+ uint_fast64_t sig;
+ int_fast32_t shiftDist;
+ bool sign;
+ int_fast32_t absZ;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uA.f = a;
+ uiA64 = uA.s.signExp;
+ exp = expExtF80UI64( uiA64 );
+ sig = uA.s.signif;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ shiftDist = 0x403E - exp;
+ if ( 64 <= shiftDist ) {
+ if ( exact && (exp | sig) ) {
+ softfloat_exceptionFlags |= softfloat_flag_inexact;
+ }
+ return 0;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ sign = signExtF80UI64( uiA64 );
+ if ( shiftDist < 33 ) {
+ if (
+ (uiA64 == packToExtF80UI64( 1, 0x401E ))
+ && (sig < UINT64_C( 0x8000000100000000 ))
+ ) {
+ if ( exact && (sig & UINT64_C( 0x00000000FFFFFFFF )) ) {
+ softfloat_exceptionFlags |= softfloat_flag_inexact;
+ }
+ return -0x7FFFFFFF - 1;
+ }
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ return
+ (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
+ ? i32_fromNaN
+ : sign ? i32_fromNegOverflow : i32_fromPosOverflow;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ absZ = sig>>shiftDist;
+ if ( exact && ((uint_fast64_t) (uint_fast32_t) absZ<
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+int_fast64_t
+ extF80_to_i64( extFloat80_t a, uint_fast8_t roundingMode, bool exact )
+{
+ union { struct extFloat80M s; extFloat80_t f; } uA;
+ uint_fast16_t uiA64;
+ bool sign;
+ int_fast32_t exp;
+ uint_fast64_t sig;
+ int_fast32_t shiftDist;
+ uint_fast64_t sigExtra;
+ struct uint64_extra sig64Extra;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uA.f = a;
+ uiA64 = uA.s.signExp;
+ sign = signExtF80UI64( uiA64 );
+ exp = expExtF80UI64( uiA64 );
+ sig = uA.s.signif;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ shiftDist = 0x403E - exp;
+ if ( shiftDist <= 0 ) {
+ /*--------------------------------------------------------------------
+ *--------------------------------------------------------------------*/
+ if ( shiftDist ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ return
+ (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
+ ? i64_fromNaN
+ : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
+ }
+ /*--------------------------------------------------------------------
+ *--------------------------------------------------------------------*/
+ sigExtra = 0;
+ } else {
+ /*--------------------------------------------------------------------
+ *--------------------------------------------------------------------*/
+ sig64Extra = softfloat_shiftRightJam64Extra( sig, 0, shiftDist );
+ sig = sig64Extra.v;
+ sigExtra = sig64Extra.extra;
+ }
+ return softfloat_roundToI64( sign, sig, sigExtra, roundingMode, exact );
+
+}
+
diff --git a/test/float/softfloat/source/extF80_to_i64_r_minMag.c b/test/float/softfloat/source/extF80_to_i64_r_minMag.c
new file mode 100644
index 000000000..215876da7
--- /dev/null
+++ b/test/float/softfloat/source/extF80_to_i64_r_minMag.c
@@ -0,0 +1,94 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+int_fast64_t extF80_to_i64_r_minMag( extFloat80_t a, bool exact )
+{
+ union { struct extFloat80M s; extFloat80_t f; } uA;
+ uint_fast16_t uiA64;
+ int_fast32_t exp;
+ uint_fast64_t sig;
+ int_fast32_t shiftDist;
+ bool sign;
+ int_fast64_t absZ;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uA.f = a;
+ uiA64 = uA.s.signExp;
+ exp = expExtF80UI64( uiA64 );
+ sig = uA.s.signif;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ shiftDist = 0x403E - exp;
+ if ( 64 <= shiftDist ) {
+ if ( exact && (exp | sig) ) {
+ softfloat_exceptionFlags |= softfloat_flag_inexact;
+ }
+ return 0;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ sign = signExtF80UI64( uiA64 );
+ if ( shiftDist <= 0 ) {
+ if (
+ (uiA64 == packToExtF80UI64( 1, 0x403E ))
+ && (sig == UINT64_C( 0x8000000000000000 ))
+ ) {
+ return -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1;
+ }
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ return
+ (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
+ ? i64_fromNaN
+ : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ absZ = sig>>shiftDist;
+ if ( exact && (uint64_t) (sig<<(-shiftDist & 63)) ) {
+ softfloat_exceptionFlags |= softfloat_flag_inexact;
+ }
+ return sign ? -absZ : absZ;
+
+}
+
diff --git a/test/float/softfloat/source/extF80_to_ui32.c b/test/float/softfloat/source/extF80_to_ui32.c
new file mode 100644
index 000000000..d121c4801
--- /dev/null
+++ b/test/float/softfloat/source/extF80_to_ui32.c
@@ -0,0 +1,83 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+uint_fast32_t
+ extF80_to_ui32( extFloat80_t a, uint_fast8_t roundingMode, bool exact )
+{
+ union { struct extFloat80M s; extFloat80_t f; } uA;
+ uint_fast16_t uiA64;
+ bool sign;
+ int_fast32_t exp;
+ uint_fast64_t sig;
+ int_fast32_t shiftDist;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uA.f = a;
+ uiA64 = uA.s.signExp;
+ sign = signExtF80UI64( uiA64 );
+ exp = expExtF80UI64( uiA64 );
+ sig = uA.s.signif;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+#if (ui32_fromNaN != ui32_fromPosOverflow) || (ui32_fromNaN != ui32_fromNegOverflow)
+ if ( (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ) {
+#if (ui32_fromNaN == ui32_fromPosOverflow)
+ sign = 0;
+#elif (ui32_fromNaN == ui32_fromNegOverflow)
+ sign = 1;
+#else
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ return ui32_fromNaN;
+#endif
+ }
+#endif
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ shiftDist = 0x4032 - exp;
+ if ( shiftDist <= 0 ) shiftDist = 1;
+ sig = softfloat_shiftRightJam64( sig, shiftDist );
+ return softfloat_roundToUI32( sign, sig, roundingMode, exact );
+
+}
+
diff --git a/test/float/softfloat/source/extF80_to_ui32_r_minMag.c b/test/float/softfloat/source/extF80_to_ui32_r_minMag.c
new file mode 100644
index 000000000..ad3048340
--- /dev/null
+++ b/test/float/softfloat/source/extF80_to_ui32_r_minMag.c
@@ -0,0 +1,88 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+uint_fast32_t extF80_to_ui32_r_minMag( extFloat80_t a, bool exact )
+{
+ union { struct extFloat80M s; extFloat80_t f; } uA;
+ uint_fast16_t uiA64;
+ int_fast32_t exp;
+ uint_fast64_t sig;
+ int_fast32_t shiftDist;
+ bool sign;
+ uint_fast32_t z;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uA.f = a;
+ uiA64 = uA.s.signExp;
+ exp = expExtF80UI64( uiA64 );
+ sig = uA.s.signif;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ shiftDist = 0x403E - exp;
+ if ( 64 <= shiftDist ) {
+ if ( exact && (exp | sig) ) {
+ softfloat_exceptionFlags |= softfloat_flag_inexact;
+ }
+ return 0;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ sign = signExtF80UI64( uiA64 );
+ if ( sign || (shiftDist < 32) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ return
+ (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
+ ? ui32_fromNaN
+ : sign ? ui32_fromNegOverflow : ui32_fromPosOverflow;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ z = sig>>shiftDist;
+ if ( exact && ((uint_fast64_t) z<
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+uint_fast64_t
+ extF80_to_ui64( extFloat80_t a, uint_fast8_t roundingMode, bool exact )
+{
+ union { struct extFloat80M s; extFloat80_t f; } uA;
+ uint_fast16_t uiA64;
+ bool sign;
+ int_fast32_t exp;
+ uint_fast64_t sig;
+ int_fast32_t shiftDist;
+ uint_fast64_t sigExtra;
+ struct uint64_extra sig64Extra;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uA.f = a;
+ uiA64 = uA.s.signExp;
+ sign = signExtF80UI64( uiA64 );
+ exp = expExtF80UI64( uiA64 );
+ sig = uA.s.signif;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ shiftDist = 0x403E - exp;
+ if ( shiftDist < 0 ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ return
+ (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
+ ? ui64_fromNaN
+ : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ sigExtra = 0;
+ if ( shiftDist ) {
+ sig64Extra = softfloat_shiftRightJam64Extra( sig, 0, shiftDist );
+ sig = sig64Extra.v;
+ sigExtra = sig64Extra.extra;
+ }
+ return softfloat_roundToUI64( sign, sig, sigExtra, roundingMode, exact );
+
+}
+
diff --git a/test/float/softfloat/source/extF80_to_ui64_r_minMag.c b/test/float/softfloat/source/extF80_to_ui64_r_minMag.c
new file mode 100644
index 000000000..65adfe7e8
--- /dev/null
+++ b/test/float/softfloat/source/extF80_to_ui64_r_minMag.c
@@ -0,0 +1,88 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+uint_fast64_t extF80_to_ui64_r_minMag( extFloat80_t a, bool exact )
+{
+ union { struct extFloat80M s; extFloat80_t f; } uA;
+ uint_fast16_t uiA64;
+ int_fast32_t exp;
+ uint_fast64_t sig;
+ int_fast32_t shiftDist;
+ bool sign;
+ uint_fast64_t z;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uA.f = a;
+ uiA64 = uA.s.signExp;
+ exp = expExtF80UI64( uiA64 );
+ sig = uA.s.signif;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ shiftDist = 0x403E - exp;
+ if ( 64 <= shiftDist ) {
+ if ( exact && (exp | sig) ) {
+ softfloat_exceptionFlags |= softfloat_flag_inexact;
+ }
+ return 0;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ sign = signExtF80UI64( uiA64 );
+ if ( sign || (shiftDist < 0) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ return
+ (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
+ ? ui64_fromNaN
+ : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ z = sig>>shiftDist;
+ if ( exact && (z<
+#include
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void
+ f128M_add( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+{
+ const uint64_t *aWPtr, *bWPtr;
+ uint_fast64_t uiA64, uiA0;
+ bool signA;
+ uint_fast64_t uiB64, uiB0;
+ bool signB;
+#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
+ float128_t
+ (*magsFuncPtr)(
+ uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool );
+#endif
+
+ aWPtr = (const uint64_t *) aPtr;
+ bWPtr = (const uint64_t *) bPtr;
+ uiA64 = aWPtr[indexWord( 2, 1 )];
+ uiA0 = aWPtr[indexWord( 2, 0 )];
+ signA = signF128UI64( uiA64 );
+ uiB64 = bWPtr[indexWord( 2, 1 )];
+ uiB0 = bWPtr[indexWord( 2, 0 )];
+ signB = signF128UI64( uiB64 );
+#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
+ if ( signA == signB ) {
+ *zPtr = softfloat_addMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
+ } else {
+ *zPtr = softfloat_subMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
+ }
+#else
+ magsFuncPtr =
+ (signA == signB) ? softfloat_addMagsF128 : softfloat_subMagsF128;
+ *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
+#endif
+
+}
+
+#else
+
+void
+ f128M_add( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+{
+
+ softfloat_addF128M(
+ (const uint32_t *) aPtr,
+ (const uint32_t *) bPtr,
+ (uint32_t *) zPtr,
+ false
+ );
+
+}
+
+#endif
+
diff --git a/test/float/softfloat/source/f128M_div.c b/test/float/softfloat/source/f128M_div.c
new file mode 100644
index 000000000..8355dc20a
--- /dev/null
+++ b/test/float/softfloat/source/f128M_div.c
@@ -0,0 +1,187 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void
+ f128M_div( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+{
+
+ *zPtr = f128_div( *aPtr, *bPtr );
+
+}
+
+#else
+
+void
+ f128M_div( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+{
+ const uint32_t *aWPtr, *bWPtr;
+ uint32_t *zWPtr, uiA96;
+ bool signA;
+ int32_t expA;
+ uint32_t uiB96;
+ bool signB;
+ int32_t expB;
+ bool signZ;
+ uint32_t y[5], sigB[4];
+ int32_t expZ;
+ uint32_t recip32;
+ int ix;
+ uint64_t q64;
+ uint32_t q, qs[3], uiZ96;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ aWPtr = (const uint32_t *) aPtr;
+ bWPtr = (const uint32_t *) bPtr;
+ zWPtr = (uint32_t *) zPtr;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uiA96 = aWPtr[indexWordHi( 4 )];
+ signA = signF128UI96( uiA96 );
+ expA = expF128UI96( uiA96 );
+ uiB96 = bWPtr[indexWordHi( 4 )];
+ signB = signF128UI96( uiB96 );
+ expB = expF128UI96( uiB96 );
+ signZ = signA ^ signB;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
+ if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr ) ) return;
+ if ( expA == 0x7FFF ) {
+ if ( expB == 0x7FFF ) goto invalid;
+ goto infinity;
+ }
+ goto zero;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ expA = softfloat_shiftNormSigF128M( aWPtr, 13, y );
+ expB = softfloat_shiftNormSigF128M( bWPtr, 13, sigB );
+ if ( expA == -128 ) {
+ if ( expB == -128 ) goto invalid;
+ goto zero;
+ }
+ if ( expB == -128 ) {
+ softfloat_raiseFlags( softfloat_flag_infinite );
+ goto infinity;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ expZ = expA - expB + 0x3FFE;
+ if ( softfloat_compare128M( y, sigB ) < 0 ) {
+ --expZ;
+ softfloat_add128M( y, y, y );
+ }
+ recip32 =
+ softfloat_approxRecip32_1(
+ ((uint64_t) sigB[indexWord( 4, 3 )]<<32 | sigB[indexWord( 4, 2 )])
+ >>30
+ );
+ ix = 3;
+ for (;;) {
+ q64 = (uint64_t) y[indexWordHi( 4 )] * recip32;
+ q = (q64 + 0x80000000)>>32;
+ --ix;
+ if ( ix < 0 ) break;
+ softfloat_remStep128MBy32( y, 29, sigB, q, y );
+ if ( y[indexWordHi( 4 )] & 0x80000000 ) {
+ --q;
+ softfloat_add128M( y, sigB, y );
+ }
+ qs[ix] = q;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( ((q + 1) & 7) < 2 ) {
+ softfloat_remStep128MBy32( y, 29, sigB, q, y );
+ if ( y[indexWordHi( 4 )] & 0x80000000 ) {
+ --q;
+ softfloat_add128M( y, sigB, y );
+ } else if ( softfloat_compare128M( sigB, y ) <= 0 ) {
+ ++q;
+ softfloat_sub128M( y, sigB, y );
+ }
+ if (
+ y[indexWordLo( 4 )] || y[indexWord( 4, 1 )]
+ || (y[indexWord( 4, 2 )] | y[indexWord( 4, 3 )])
+ ) {
+ q |= 1;
+ }
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ q64 = (uint64_t) q<<28;
+ y[indexWord( 5, 0 )] = q64;
+ q64 = ((uint64_t) qs[0]<<25) + (q64>>32);
+ y[indexWord( 5, 1 )] = q64;
+ q64 = ((uint64_t) qs[1]<<22) + (q64>>32);
+ y[indexWord( 5, 2 )] = q64;
+ q64 = ((uint64_t) qs[2]<<19) + (q64>>32);
+ y[indexWord( 5, 3 )] = q64;
+ y[indexWord( 5, 4 )] = q64>>32;
+ softfloat_roundPackMToF128M( signZ, expZ, y, zWPtr );
+ return;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ invalid:
+ softfloat_invalidF128M( zWPtr );
+ return;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ infinity:
+ uiZ96 = packToF128UI96( signZ, 0x7FFF, 0 );
+ goto uiZ96;
+ zero:
+ uiZ96 = packToF128UI96( signZ, 0, 0 );
+ uiZ96:
+ zWPtr[indexWordHi( 4 )] = uiZ96;
+ zWPtr[indexWord( 4, 2 )] = 0;
+ zWPtr[indexWord( 4, 1 )] = 0;
+ zWPtr[indexWord( 4, 0 )] = 0;
+
+}
+
+#endif
+
diff --git a/test/float/softfloat/source/f128M_eq.c b/test/float/softfloat/source/f128M_eq.c
new file mode 100644
index 000000000..4f28f5f31
--- /dev/null
+++ b/test/float/softfloat/source/f128M_eq.c
@@ -0,0 +1,100 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+bool f128M_eq( const float128_t *aPtr, const float128_t *bPtr )
+{
+
+ return f128_eq( *aPtr, *bPtr );
+
+}
+
+#else
+
+bool f128M_eq( const float128_t *aPtr, const float128_t *bPtr )
+{
+ const uint32_t *aWPtr, *bWPtr;
+ uint32_t wordA, wordB, uiA96, uiB96;
+ bool possibleOppositeZeros;
+ uint32_t mashWord;
+
+ aWPtr = (const uint32_t *) aPtr;
+ bWPtr = (const uint32_t *) bPtr;
+ wordA = aWPtr[indexWord( 4, 2 )];
+ wordB = bWPtr[indexWord( 4, 2 )];
+ if ( wordA != wordB ) goto false_checkSigNaNs;
+ uiA96 = aWPtr[indexWordHi( 4 )];
+ uiB96 = bWPtr[indexWordHi( 4 )];
+ possibleOppositeZeros = false;
+ if ( uiA96 != uiB96 ) {
+ possibleOppositeZeros = (((uiA96 | uiB96) & 0x7FFFFFFF) == 0);
+ if ( ! possibleOppositeZeros ) goto false_checkSigNaNs;
+ }
+ mashWord = wordA | wordB;
+ wordA = aWPtr[indexWord( 4, 1 )];
+ wordB = bWPtr[indexWord( 4, 1 )];
+ if ( wordA != wordB ) goto false_checkSigNaNs;
+ mashWord |= wordA | wordB;
+ wordA = aWPtr[indexWord( 4, 0 )];
+ wordB = bWPtr[indexWord( 4, 0 )];
+ if ( wordA != wordB ) goto false_checkSigNaNs;
+ if ( possibleOppositeZeros && ((mashWord | wordA | wordB) != 0) ) {
+ goto false_checkSigNaNs;
+ }
+ if ( ! softfloat_isNaNF128M( aWPtr ) && ! softfloat_isNaNF128M( bWPtr ) ) {
+ return true;
+ }
+ false_checkSigNaNs:
+ if (
+ f128M_isSignalingNaN( (const float128_t *) aWPtr )
+ || f128M_isSignalingNaN( (const float128_t *) bWPtr )
+ ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ }
+ return false;
+
+}
+
+#endif
+
diff --git a/test/float/softfloat/source/f128M_eq_signaling.c b/test/float/softfloat/source/f128M_eq_signaling.c
new file mode 100644
index 000000000..d2ea5f434
--- /dev/null
+++ b/test/float/softfloat/source/f128M_eq_signaling.c
@@ -0,0 +1,92 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+bool f128M_eq_signaling( const float128_t *aPtr, const float128_t *bPtr )
+{
+
+ return f128_eq_signaling( *aPtr, *bPtr );
+
+}
+
+#else
+
+bool f128M_eq_signaling( const float128_t *aPtr, const float128_t *bPtr )
+{
+ const uint32_t *aWPtr, *bWPtr;
+ uint32_t wordA, wordB, uiA96, uiB96;
+ bool possibleOppositeZeros;
+ uint32_t mashWord;
+
+ aWPtr = (const uint32_t *) aPtr;
+ bWPtr = (const uint32_t *) bPtr;
+ if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ return false;
+ }
+ wordA = aWPtr[indexWord( 4, 2 )];
+ wordB = bWPtr[indexWord( 4, 2 )];
+ if ( wordA != wordB ) return false;
+ uiA96 = aWPtr[indexWordHi( 4 )];
+ uiB96 = bWPtr[indexWordHi( 4 )];
+ possibleOppositeZeros = false;
+ if ( uiA96 != uiB96 ) {
+ possibleOppositeZeros = (((uiA96 | uiB96) & 0x7FFFFFFF) == 0);
+ if ( ! possibleOppositeZeros ) return false;
+ }
+ mashWord = wordA | wordB;
+ wordA = aWPtr[indexWord( 4, 1 )];
+ wordB = bWPtr[indexWord( 4, 1 )];
+ if ( wordA != wordB ) return false;
+ mashWord |= wordA | wordB;
+ wordA = aWPtr[indexWord( 4, 0 )];
+ wordB = bWPtr[indexWord( 4, 0 )];
+ return
+ (wordA == wordB)
+ && (! possibleOppositeZeros || ((mashWord | wordA | wordB) == 0));
+
+}
+
+#endif
+
diff --git a/test/float/softfloat/source/f128M_le.c b/test/float/softfloat/source/f128M_le.c
new file mode 100644
index 000000000..af1dcba74
--- /dev/null
+++ b/test/float/softfloat/source/f128M_le.c
@@ -0,0 +1,93 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+bool f128M_le( const float128_t *aPtr, const float128_t *bPtr )
+{
+
+ return f128_le( *aPtr, *bPtr );
+
+}
+
+#else
+
+bool f128M_le( const float128_t *aPtr, const float128_t *bPtr )
+{
+ const uint32_t *aWPtr, *bWPtr;
+ uint32_t uiA96, uiB96;
+ bool signA, signB;
+ uint32_t wordA, wordB;
+
+ aWPtr = (const uint32_t *) aPtr;
+ bWPtr = (const uint32_t *) bPtr;
+ if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ return false;
+ }
+ uiA96 = aWPtr[indexWordHi( 4 )];
+ uiB96 = bWPtr[indexWordHi( 4 )];
+ signA = signF128UI96( uiA96 );
+ signB = signF128UI96( uiB96 );
+ if ( signA != signB ) {
+ if ( signA ) return true;
+ if ( (uiA96 | uiB96) & 0x7FFFFFFF ) return false;
+ wordA = aWPtr[indexWord( 4, 2 )];
+ wordB = bWPtr[indexWord( 4, 2 )];
+ if ( wordA | wordB ) return false;
+ wordA = aWPtr[indexWord( 4, 1 )];
+ wordB = bWPtr[indexWord( 4, 1 )];
+ if ( wordA | wordB ) return false;
+ wordA = aWPtr[indexWord( 4, 0 )];
+ wordB = bWPtr[indexWord( 4, 0 )];
+ return ((wordA | wordB) == 0);
+ }
+ if ( signA ) {
+ aWPtr = (const uint32_t *) bPtr;
+ bWPtr = (const uint32_t *) aPtr;
+ }
+ return (softfloat_compare128M( aWPtr, bWPtr ) <= 0);
+
+}
+
+#endif
+
diff --git a/test/float/softfloat/source/f128M_le_quiet.c b/test/float/softfloat/source/f128M_le_quiet.c
new file mode 100644
index 000000000..0d051b656
--- /dev/null
+++ b/test/float/softfloat/source/f128M_le_quiet.c
@@ -0,0 +1,96 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+bool f128M_le_quiet( const float128_t *aPtr, const float128_t *bPtr )
+{
+
+ return f128_le_quiet( *aPtr, *bPtr );
+
+}
+
+#else
+
+bool f128M_le_quiet( const float128_t *aPtr, const float128_t *bPtr )
+{
+ const uint32_t *aWPtr, *bWPtr;
+ uint32_t uiA96, uiB96;
+ bool signA, signB;
+ uint32_t wordA, wordB;
+
+ aWPtr = (const uint32_t *) aPtr;
+ bWPtr = (const uint32_t *) bPtr;
+ if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) {
+ if ( f128M_isSignalingNaN( aPtr ) || f128M_isSignalingNaN( bPtr ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ }
+ return false;
+ }
+ uiA96 = aWPtr[indexWordHi( 4 )];
+ uiB96 = bWPtr[indexWordHi( 4 )];
+ signA = signF128UI96( uiA96 );
+ signB = signF128UI96( uiB96 );
+ if ( signA != signB ) {
+ if ( signA ) return true;
+ if ( (uiA96 | uiB96) & 0x7FFFFFFF ) return false;
+ wordA = aWPtr[indexWord( 4, 2 )];
+ wordB = bWPtr[indexWord( 4, 2 )];
+ if ( wordA | wordB ) return false;
+ wordA = aWPtr[indexWord( 4, 1 )];
+ wordB = bWPtr[indexWord( 4, 1 )];
+ if ( wordA | wordB ) return false;
+ wordA = aWPtr[indexWord( 4, 0 )];
+ wordB = bWPtr[indexWord( 4, 0 )];
+ return ((wordA | wordB) == 0);
+ }
+ if ( signA ) {
+ aWPtr = (const uint32_t *) bPtr;
+ bWPtr = (const uint32_t *) aPtr;
+ }
+ return (softfloat_compare128M( aWPtr, bWPtr ) <= 0);
+
+}
+
+#endif
+
diff --git a/test/float/softfloat/source/f128M_lt.c b/test/float/softfloat/source/f128M_lt.c
new file mode 100644
index 000000000..64ff9b45d
--- /dev/null
+++ b/test/float/softfloat/source/f128M_lt.c
@@ -0,0 +1,93 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+bool f128M_lt( const float128_t *aPtr, const float128_t *bPtr )
+{
+
+ return f128_lt( *aPtr, *bPtr );
+
+}
+
+#else
+
+bool f128M_lt( const float128_t *aPtr, const float128_t *bPtr )
+{
+ const uint32_t *aWPtr, *bWPtr;
+ uint32_t uiA96, uiB96;
+ bool signA, signB;
+ uint32_t wordA, wordB;
+
+ aWPtr = (const uint32_t *) aPtr;
+ bWPtr = (const uint32_t *) bPtr;
+ if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ return false;
+ }
+ uiA96 = aWPtr[indexWordHi( 4 )];
+ uiB96 = bWPtr[indexWordHi( 4 )];
+ signA = signF128UI96( uiA96 );
+ signB = signF128UI96( uiB96 );
+ if ( signA != signB ) {
+ if ( signB ) return false;
+ if ( (uiA96 | uiB96) & 0x7FFFFFFF ) return true;
+ wordA = aWPtr[indexWord( 4, 2 )];
+ wordB = bWPtr[indexWord( 4, 2 )];
+ if ( wordA | wordB ) return true;
+ wordA = aWPtr[indexWord( 4, 1 )];
+ wordB = bWPtr[indexWord( 4, 1 )];
+ if ( wordA | wordB ) return true;
+ wordA = aWPtr[indexWord( 4, 0 )];
+ wordB = bWPtr[indexWord( 4, 0 )];
+ return ((wordA | wordB) != 0);
+ }
+ if ( signA ) {
+ aWPtr = (const uint32_t *) bPtr;
+ bWPtr = (const uint32_t *) aPtr;
+ }
+ return (softfloat_compare128M( aWPtr, bWPtr ) < 0);
+
+}
+
+#endif
+
diff --git a/test/float/softfloat/source/f128M_lt_quiet.c b/test/float/softfloat/source/f128M_lt_quiet.c
new file mode 100644
index 000000000..6ccf3c861
--- /dev/null
+++ b/test/float/softfloat/source/f128M_lt_quiet.c
@@ -0,0 +1,96 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+bool f128M_lt_quiet( const float128_t *aPtr, const float128_t *bPtr )
+{
+
+ return f128_lt_quiet( *aPtr, *bPtr );
+
+}
+
+#else
+
+bool f128M_lt_quiet( const float128_t *aPtr, const float128_t *bPtr )
+{
+ const uint32_t *aWPtr, *bWPtr;
+ uint32_t uiA96, uiB96;
+ bool signA, signB;
+ uint32_t wordA, wordB;
+
+ aWPtr = (const uint32_t *) aPtr;
+ bWPtr = (const uint32_t *) bPtr;
+ if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) {
+ if ( f128M_isSignalingNaN( aPtr ) || f128M_isSignalingNaN( bPtr ) ) {
+ softfloat_raiseFlags( softfloat_flag_invalid );
+ }
+ return false;
+ }
+ uiA96 = aWPtr[indexWordHi( 4 )];
+ uiB96 = bWPtr[indexWordHi( 4 )];
+ signA = signF128UI96( uiA96 );
+ signB = signF128UI96( uiB96 );
+ if ( signA != signB ) {
+ if ( signB ) return false;
+ if ( (uiA96 | uiB96) & 0x7FFFFFFF ) return true;
+ wordA = aWPtr[indexWord( 4, 2 )];
+ wordB = bWPtr[indexWord( 4, 2 )];
+ if ( wordA | wordB ) return true;
+ wordA = aWPtr[indexWord( 4, 1 )];
+ wordB = bWPtr[indexWord( 4, 1 )];
+ if ( wordA | wordB ) return true;
+ wordA = aWPtr[indexWord( 4, 0 )];
+ wordB = bWPtr[indexWord( 4, 0 )];
+ return ((wordA | wordB) != 0);
+ }
+ if ( signA ) {
+ aWPtr = (const uint32_t *) bPtr;
+ bWPtr = (const uint32_t *) aPtr;
+ }
+ return (softfloat_compare128M( aWPtr, bWPtr ) < 0);
+
+}
+
+#endif
+
diff --git a/test/float/softfloat/source/f128M_mul.c b/test/float/softfloat/source/f128M_mul.c
new file mode 100644
index 000000000..f2d6051e0
--- /dev/null
+++ b/test/float/softfloat/source/f128M_mul.c
@@ -0,0 +1,158 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void
+ f128M_mul( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+{
+
+ *zPtr = f128_mul( *aPtr, *bPtr );
+
+}
+
+#else
+
+void
+ f128M_mul( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+{
+ const uint32_t *aWPtr, *bWPtr;
+ uint32_t *zWPtr;
+ uint32_t uiA96;
+ int32_t expA;
+ uint32_t uiB96;
+ int32_t expB;
+ bool signZ;
+ const uint32_t *ptr;
+ uint32_t uiZ96, sigA[4];
+ uint_fast8_t shiftDist;
+ uint32_t sigB[4];
+ int32_t expZ;
+ uint32_t sigProd[8], *extSigZPtr;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ aWPtr = (const uint32_t *) aPtr;
+ bWPtr = (const uint32_t *) bPtr;
+ zWPtr = (uint32_t *) zPtr;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uiA96 = aWPtr[indexWordHi( 4 )];
+ expA = expF128UI96( uiA96 );
+ uiB96 = bWPtr[indexWordHi( 4 )];
+ expB = expF128UI96( uiB96 );
+ signZ = signF128UI96( uiA96 ) ^ signF128UI96( uiB96 );
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
+ if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr ) ) return;
+ ptr = aWPtr;
+ if ( ! expA ) goto possiblyInvalid;
+ if ( ! expB ) {
+ ptr = bWPtr;
+ possiblyInvalid:
+ if (
+ ! fracF128UI96( ptr[indexWordHi( 4 )] )
+ && ! (ptr[indexWord( 4, 2 )] | ptr[indexWord( 4, 1 )]
+ | ptr[indexWord( 4, 0 )])
+ ) {
+ softfloat_invalidF128M( zWPtr );
+ return;
+ }
+ }
+ uiZ96 = packToF128UI96( signZ, 0x7FFF, 0 );
+ goto uiZ96;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( expA ) {
+ sigA[indexWordHi( 4 )] = fracF128UI96( uiA96 ) | 0x00010000;
+ sigA[indexWord( 4, 2 )] = aWPtr[indexWord( 4, 2 )];
+ sigA[indexWord( 4, 1 )] = aWPtr[indexWord( 4, 1 )];
+ sigA[indexWord( 4, 0 )] = aWPtr[indexWord( 4, 0 )];
+ } else {
+ expA = softfloat_shiftNormSigF128M( aWPtr, 0, sigA );
+ if ( expA == -128 ) goto zero;
+ }
+ if ( expB ) {
+ sigB[indexWordHi( 4 )] = fracF128UI96( uiB96 ) | 0x00010000;
+ sigB[indexWord( 4, 2 )] = bWPtr[indexWord( 4, 2 )];
+ sigB[indexWord( 4, 1 )] = bWPtr[indexWord( 4, 1 )];
+ sigB[indexWord( 4, 0 )] = bWPtr[indexWord( 4, 0 )];
+ } else {
+ expB = softfloat_shiftNormSigF128M( bWPtr, 0, sigB );
+ if ( expB == -128 ) goto zero;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ expZ = expA + expB - 0x4000;
+ softfloat_mul128MTo256M( sigA, sigB, sigProd );
+ if (
+ sigProd[indexWord( 8, 2 )]
+ || (sigProd[indexWord( 8, 1 )] | sigProd[indexWord( 8, 0 )])
+ ) {
+ sigProd[indexWord( 8, 3 )] |= 1;
+ }
+ extSigZPtr = &sigProd[indexMultiwordHi( 8, 5 )];
+ shiftDist = 16;
+ if ( extSigZPtr[indexWordHi( 5 )] & 2 ) {
+ ++expZ;
+ shiftDist = 15;
+ }
+ softfloat_shortShiftLeft160M( extSigZPtr, shiftDist, extSigZPtr );
+ softfloat_roundPackMToF128M( signZ, expZ, extSigZPtr, zWPtr );
+ return;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ zero:
+ uiZ96 = packToF128UI96( signZ, 0, 0 );
+ uiZ96:
+ zWPtr[indexWordHi( 4 )] = uiZ96;
+ zWPtr[indexWord( 4, 2 )] = 0;
+ zWPtr[indexWord( 4, 1 )] = 0;
+ zWPtr[indexWord( 4, 0 )] = 0;
+
+}
+
+#endif
+
diff --git a/test/float/softfloat/source/f128M_mulAdd.c b/test/float/softfloat/source/f128M_mulAdd.c
new file mode 100644
index 000000000..e2f95df01
--- /dev/null
+++ b/test/float/softfloat/source/f128M_mulAdd.c
@@ -0,0 +1,92 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void
+ f128M_mulAdd(
+ const float128_t *aPtr,
+ const float128_t *bPtr,
+ const float128_t *cPtr,
+ float128_t *zPtr
+ )
+{
+ const uint64_t *aWPtr, *bWPtr, *cWPtr;
+ uint_fast64_t uiA64, uiA0;
+ uint_fast64_t uiB64, uiB0;
+ uint_fast64_t uiC64, uiC0;
+
+ aWPtr = (const uint64_t *) aPtr;
+ bWPtr = (const uint64_t *) bPtr;
+ cWPtr = (const uint64_t *) cPtr;
+ uiA64 = aWPtr[indexWord( 2, 1 )];
+ uiA0 = aWPtr[indexWord( 2, 0 )];
+ uiB64 = bWPtr[indexWord( 2, 1 )];
+ uiB0 = bWPtr[indexWord( 2, 0 )];
+ uiC64 = cWPtr[indexWord( 2, 1 )];
+ uiC0 = cWPtr[indexWord( 2, 0 )];
+ *zPtr = softfloat_mulAddF128( uiA64, uiA0, uiB64, uiB0, uiC64, uiC0, 0 );
+
+}
+
+#else
+
+void
+ f128M_mulAdd(
+ const float128_t *aPtr,
+ const float128_t *bPtr,
+ const float128_t *cPtr,
+ float128_t *zPtr
+ )
+{
+
+ softfloat_mulAddF128M(
+ (const uint32_t *) aPtr,
+ (const uint32_t *) bPtr,
+ (const uint32_t *) cPtr,
+ (uint32_t *) zPtr,
+ 0
+ );
+
+}
+
+#endif
+
diff --git a/test/float/softfloat/source/f128M_rem.c b/test/float/softfloat/source/f128M_rem.c
new file mode 100644
index 000000000..645ec9938
--- /dev/null
+++ b/test/float/softfloat/source/f128M_rem.c
@@ -0,0 +1,182 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void
+ f128M_rem( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+{
+
+ *zPtr = f128_rem( *aPtr, *bPtr );
+
+}
+
+#else
+
+void
+ f128M_rem( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+{
+ const uint32_t *aWPtr, *bWPtr;
+ uint32_t *zWPtr, uiA96;
+ int32_t expA, expB;
+ uint32_t x[4], rem1[5], *remPtr;
+ bool signRem;
+ int32_t expDiff;
+ uint32_t q, recip32;
+ uint64_t q64;
+ uint32_t rem2[5], *altRemPtr, *newRemPtr, wordMeanRem;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ aWPtr = (const uint32_t *) aPtr;
+ bWPtr = (const uint32_t *) bPtr;
+ zWPtr = (uint32_t *) zPtr;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uiA96 = aWPtr[indexWordHi( 4 )];
+ expA = expF128UI96( uiA96 );
+ expB = expF128UI96( bWPtr[indexWordHi( 4 )] );
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
+ if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr ) ) return;
+ if ( expA == 0x7FFF ) goto invalid;
+ goto copyA;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( expA < expB - 1 ) goto copyA;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ expB = softfloat_shiftNormSigF128M( bWPtr, 13, x );
+ if ( expB == -128 ) goto invalid;
+ remPtr = &rem1[indexMultiwordLo( 5, 4 )];
+ expA = softfloat_shiftNormSigF128M( aWPtr, 13, remPtr );
+ if ( expA == -128 ) goto copyA;
+ signRem = signF128UI96( uiA96 );
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ expDiff = expA - expB;
+ if ( expDiff < 1 ) {
+ if ( expDiff < -1 ) goto copyA;
+ if ( expDiff ) {
+ --expB;
+ softfloat_add128M( x, x, x );
+ q = 0;
+ } else {
+ q = (softfloat_compare128M( x, remPtr ) <= 0);
+ if ( q ) softfloat_sub128M( remPtr, x, remPtr );
+ }
+ } else {
+ recip32 =
+ softfloat_approxRecip32_1(
+ ((uint64_t) x[indexWord( 4, 3 )]<<32 | x[indexWord( 4, 2 )])
+ >>30
+ );
+ expDiff -= 30;
+ for (;;) {
+ q64 = (uint64_t) remPtr[indexWordHi( 4 )] * recip32;
+ if ( expDiff < 0 ) break;
+ q = (q64 + 0x80000000)>>32;
+ softfloat_remStep128MBy32( remPtr, 29, x, q, remPtr );
+ if ( remPtr[indexWordHi( 4 )] & 0x80000000 ) {
+ softfloat_add128M( remPtr, x, remPtr );
+ }
+ expDiff -= 29;
+ }
+ /*--------------------------------------------------------------------
+ | (`expDiff' cannot be less than -29 here.)
+ *--------------------------------------------------------------------*/
+ q = (uint32_t) (q64>>32)>>(~expDiff & 31);
+ softfloat_remStep128MBy32( remPtr, expDiff + 30, x, q, remPtr );
+ if ( remPtr[indexWordHi( 4 )] & 0x80000000 ) {
+ altRemPtr = &rem2[indexMultiwordLo( 5, 4 )];
+ softfloat_add128M( remPtr, x, altRemPtr );
+ goto selectRem;
+ }
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ altRemPtr = &rem2[indexMultiwordLo( 5, 4 )];
+ do {
+ ++q;
+ newRemPtr = altRemPtr;
+ softfloat_sub128M( remPtr, x, newRemPtr );
+ altRemPtr = remPtr;
+ remPtr = newRemPtr;
+ } while ( ! (remPtr[indexWordHi( 4 )] & 0x80000000) );
+ selectRem:
+ softfloat_add128M( remPtr, altRemPtr, x );
+ wordMeanRem = x[indexWordHi( 4 )];
+ if (
+ (wordMeanRem & 0x80000000)
+ || (! wordMeanRem && (q & 1) && ! x[indexWord( 4, 0 )]
+ && ! (x[indexWord( 4, 2 )] | x[indexWord( 4, 1 )]))
+ ) {
+ remPtr = altRemPtr;
+ }
+ if ( remPtr[indexWordHi( 4 )] & 0x80000000 ) {
+ signRem = ! signRem;
+ softfloat_negX128M( remPtr );
+ }
+ remPtr -= indexMultiwordLo( 5, 4 );
+ remPtr[indexWordHi( 5 )] = 0;
+ softfloat_normRoundPackMToF128M( signRem, expB + 18, remPtr, zWPtr );
+ return;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ invalid:
+ softfloat_invalidF128M( zWPtr );
+ return;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ copyA:
+ zWPtr[indexWordHi( 4 )] = uiA96;
+ zWPtr[indexWord( 4, 2 )] = aWPtr[indexWord( 4, 2 )];
+ zWPtr[indexWord( 4, 1 )] = aWPtr[indexWord( 4, 1 )];
+ zWPtr[indexWord( 4, 0 )] = aWPtr[indexWord( 4, 0 )];
+
+}
+
+#endif
+
diff --git a/test/float/softfloat/source/f128M_roundToInt.c b/test/float/softfloat/source/f128M_roundToInt.c
new file mode 100644
index 000000000..c46712656
--- /dev/null
+++ b/test/float/softfloat/source/f128M_roundToInt.c
@@ -0,0 +1,223 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void
+ f128M_roundToInt(
+ const float128_t *aPtr,
+ uint_fast8_t roundingMode,
+ bool exact,
+ float128_t *zPtr
+ )
+{
+
+ *zPtr = f128_roundToInt( *aPtr, roundingMode, exact );
+
+}
+
+#else
+
+void
+ f128M_roundToInt(
+ const float128_t *aPtr,
+ uint_fast8_t roundingMode,
+ bool exact,
+ float128_t *zPtr
+ )
+{
+ const uint32_t *aWPtr;
+ uint32_t *zWPtr;
+ uint32_t ui96;
+ int32_t exp;
+ uint32_t sigExtra;
+ bool sign;
+ uint_fast8_t bitPos;
+ bool roundNear;
+ unsigned int index, lastIndex;
+ bool extra;
+ uint32_t wordA, bit, wordZ;
+ uint_fast8_t carry;
+ uint32_t extrasMask;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ aWPtr = (const uint32_t *) aPtr;
+ zWPtr = (uint32_t *) zPtr;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ ui96 = aWPtr[indexWordHi( 4 )];
+ exp = expF128UI96( ui96 );
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( exp < 0x3FFF ) {
+ zWPtr[indexWord( 4, 2 )] = 0;
+ zWPtr[indexWord( 4, 1 )] = 0;
+ zWPtr[indexWord( 4, 0 )] = 0;
+ sigExtra = aWPtr[indexWord( 4, 2 )];
+ if ( !sigExtra ) {
+ sigExtra = aWPtr[indexWord( 4, 1 )] | aWPtr[indexWord( 4, 0 )];
+ }
+ if ( !sigExtra && !(ui96 & 0x7FFFFFFF) ) goto ui96;
+ if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+ sign = signF128UI96( ui96 );
+ switch ( roundingMode ) {
+ case softfloat_round_near_even:
+ if ( !fracF128UI96( ui96 ) && !sigExtra ) break;
+ case softfloat_round_near_maxMag:
+ if ( exp == 0x3FFE ) goto mag1;
+ break;
+ case softfloat_round_min:
+ if ( sign ) goto mag1;
+ break;
+ case softfloat_round_max:
+ if ( !sign ) goto mag1;
+ break;
+#ifdef SOFTFLOAT_ROUND_ODD
+ case softfloat_round_odd:
+ goto mag1;
+#endif
+ }
+ ui96 = packToF128UI96( sign, 0, 0 );
+ goto ui96;
+ mag1:
+ ui96 = packToF128UI96( sign, 0x3FFF, 0 );
+ goto ui96;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( 0x406F <= exp ) {
+ if (
+ (exp == 0x7FFF)
+ && (fracF128UI96( ui96 )
+ || (aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
+ | aWPtr[indexWord( 4, 0 )]))
+ ) {
+ softfloat_propagateNaNF128M( aWPtr, 0, zWPtr );
+ return;
+ }
+ zWPtr[indexWord( 4, 2 )] = aWPtr[indexWord( 4, 2 )];
+ zWPtr[indexWord( 4, 1 )] = aWPtr[indexWord( 4, 1 )];
+ zWPtr[indexWord( 4, 0 )] = aWPtr[indexWord( 4, 0 )];
+ goto ui96;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ bitPos = 0x406F - exp;
+ roundNear =
+ (roundingMode == softfloat_round_near_maxMag)
+ || (roundingMode == softfloat_round_near_even);
+ bitPos -= roundNear;
+ index = indexWordLo( 4 );
+ lastIndex = indexWordHi( 4 );
+ extra = 0;
+ for (;;) {
+ wordA = aWPtr[index];
+ if ( bitPos < 32 ) break;
+ if ( wordA ) extra = 1;
+ zWPtr[index] = 0;
+ index += wordIncr;
+ bitPos -= 32;
+ }
+ bit = (uint32_t) 1<
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void f128M_sqrt( const float128_t *aPtr, float128_t *zPtr )
+{
+
+ *zPtr = f128_sqrt( *aPtr );
+
+}
+
+#else
+
+void f128M_sqrt( const float128_t *aPtr, float128_t *zPtr )
+{
+ const uint32_t *aWPtr;
+ uint32_t *zWPtr;
+ uint32_t uiA96;
+ bool signA;
+ int32_t rawExpA;
+ uint32_t rem[6];
+ int32_t expA, expZ;
+ uint64_t rem64;
+ uint32_t sig32A, recipSqrt32, sig32Z, qs[3], q;
+ uint64_t sig64Z;
+ uint32_t term[5];
+ uint64_t x64;
+ uint32_t y[5], rem32;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ aWPtr = (const uint32_t *) aPtr;
+ zWPtr = (uint32_t *) zPtr;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uiA96 = aWPtr[indexWordHi( 4 )];
+ signA = signF128UI96( uiA96 );
+ rawExpA = expF128UI96( uiA96 );
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( rawExpA == 0x7FFF ) {
+ if (
+ fracF128UI96( uiA96 )
+ || (aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
+ | aWPtr[indexWord( 4, 0 )])
+ ) {
+ softfloat_propagateNaNF128M( aWPtr, 0, zWPtr );
+ return;
+ }
+ if ( ! signA ) goto copyA;
+ goto invalid;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ expA = softfloat_shiftNormSigF128M( aWPtr, 13 - (rawExpA & 1), rem );
+ if ( expA == -128 ) goto copyA;
+ if ( signA ) goto invalid;
+ /*------------------------------------------------------------------------
+ | (`sig32Z' is guaranteed to be a lower bound on the square root of
+ | `sig32A', which makes `sig32Z' also a lower bound on the square root of
+ | `sigA'.)
+ *------------------------------------------------------------------------*/
+ expZ = ((expA - 0x3FFF)>>1) + 0x3FFE;
+ expA &= 1;
+ rem64 = (uint64_t) rem[indexWord( 4, 3 )]<<32 | rem[indexWord( 4, 2 )];
+ if ( expA ) {
+ if ( ! rawExpA ) {
+ softfloat_shortShiftRight128M( rem, 1, rem );
+ rem64 >>= 1;
+ }
+ sig32A = rem64>>29;
+ } else {
+ sig32A = rem64>>30;
+ }
+ recipSqrt32 = softfloat_approxRecipSqrt32_1( expA, sig32A );
+ sig32Z = ((uint64_t) sig32A * recipSqrt32)>>32;
+ if ( expA ) sig32Z >>= 1;
+ qs[2] = sig32Z;
+ rem64 -= (uint64_t) sig32Z * sig32Z;
+ rem[indexWord( 4, 3 )] = rem64>>32;
+ rem[indexWord( 4, 2 )] = rem64;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ q = ((uint32_t) (rem64>>2) * (uint64_t) recipSqrt32)>>32;
+ sig64Z = ((uint64_t) sig32Z<<32) + ((uint64_t) q<<3);
+ term[indexWord( 4, 3 )] = 0;
+ term[indexWord( 4, 0 )] = 0;
+ /*------------------------------------------------------------------------
+ | (Repeating this loop is a rare occurrence.)
+ *------------------------------------------------------------------------*/
+ for (;;) {
+ x64 = ((uint64_t) sig32Z<<32) + sig64Z;
+ term[indexWord( 4, 2 )] = x64>>32;
+ term[indexWord( 4, 1 )] = x64;
+ softfloat_remStep128MBy32( rem, 29, term, q, y );
+ rem32 = y[indexWord( 4, 3 )];
+ if ( ! (rem32 & 0x80000000) ) break;
+ --q;
+ sig64Z -= 1<<3;
+ }
+ qs[1] = q;
+ rem64 = (uint64_t) rem32<<32 | y[indexWord( 4, 2 )];
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ q = ((uint32_t) (rem64>>2) * (uint64_t) recipSqrt32)>>32;
+ if ( rem64>>34 ) q += recipSqrt32;
+ sig64Z <<= 1;
+ /*------------------------------------------------------------------------
+ | (Repeating this loop is a rare occurrence.)
+ *------------------------------------------------------------------------*/
+ for (;;) {
+ x64 = sig64Z + (q>>26);
+ term[indexWord( 4, 2 )] = x64>>32;
+ term[indexWord( 4, 1 )] = x64;
+ term[indexWord( 4, 0 )] = q<<6;
+ softfloat_remStep128MBy32(
+ y, 29, term, q, &rem[indexMultiwordHi( 6, 4 )] );
+ rem32 = rem[indexWordHi( 6 )];
+ if ( ! (rem32 & 0x80000000) ) break;
+ --q;
+ }
+ qs[0] = q;
+ rem64 = (uint64_t) rem32<<32 | rem[indexWord( 6, 4 )];
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ q = (((uint32_t) (rem64>>2) * (uint64_t) recipSqrt32)>>32) + 2;
+ if ( rem64>>34 ) q += recipSqrt32;
+ x64 = (uint64_t) q<<27;
+ y[indexWord( 5, 0 )] = x64;
+ x64 = ((uint64_t) qs[0]<<24) + (x64>>32);
+ y[indexWord( 5, 1 )] = x64;
+ x64 = ((uint64_t) qs[1]<<21) + (x64>>32);
+ y[indexWord( 5, 2 )] = x64;
+ x64 = ((uint64_t) qs[2]<<18) + (x64>>32);
+ y[indexWord( 5, 3 )] = x64;
+ y[indexWord( 5, 4 )] = x64>>32;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( (q & 0xF) <= 2 ) {
+ q &= ~3;
+ y[indexWordLo( 5 )] = q<<27;
+ term[indexWord( 5, 4 )] = 0;
+ term[indexWord( 5, 3 )] = 0;
+ term[indexWord( 5, 2 )] = 0;
+ term[indexWord( 5, 1 )] = q>>6;
+ term[indexWord( 5, 0 )] = q<<26;
+ softfloat_sub160M( y, term, term );
+ rem[indexWord( 6, 1 )] = 0;
+ rem[indexWord( 6, 0 )] = 0;
+ softfloat_remStep160MBy32(
+ &rem[indexMultiwordLo( 6, 5 )],
+ 14,
+ term,
+ q,
+ &rem[indexMultiwordLo( 6, 5 )]
+ );
+ rem32 = rem[indexWord( 6, 4 )];
+ if ( rem32 & 0x80000000 ) {
+ softfloat_sub1X160M( y );
+ } else {
+ if (
+ rem32 || rem[indexWord( 6, 0 )] || rem[indexWord( 6, 1 )]
+ || (rem[indexWord( 6, 3 )] | rem[indexWord( 6, 2 )])
+ ) {
+ y[indexWordLo( 5 )] |= 1;
+ }
+ }
+ }
+ softfloat_roundPackMToF128M( 0, expZ, y, zWPtr );
+ return;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ invalid:
+ softfloat_invalidF128M( zWPtr );
+ return;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ copyA:
+ zWPtr[indexWordHi( 4 )] = uiA96;
+ zWPtr[indexWord( 4, 2 )] = aWPtr[indexWord( 4, 2 )];
+ zWPtr[indexWord( 4, 1 )] = aWPtr[indexWord( 4, 1 )];
+ zWPtr[indexWord( 4, 0 )] = aWPtr[indexWord( 4, 0 )];
+
+}
+
+#endif
+
diff --git a/test/float/softfloat/source/f128M_sub.c b/test/float/softfloat/source/f128M_sub.c
new file mode 100644
index 000000000..1b609fdab
--- /dev/null
+++ b/test/float/softfloat/source/f128M_sub.c
@@ -0,0 +1,97 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void
+ f128M_sub( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+{
+ const uint64_t *aWPtr, *bWPtr;
+ uint_fast64_t uiA64, uiA0;
+ bool signA;
+ uint_fast64_t uiB64, uiB0;
+ bool signB;
+#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
+ float128_t
+ (*magsFuncPtr)(
+ uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool );
+#endif
+
+ aWPtr = (const uint64_t *) aPtr;
+ bWPtr = (const uint64_t *) bPtr;
+ uiA64 = aWPtr[indexWord( 2, 1 )];
+ uiA0 = aWPtr[indexWord( 2, 0 )];
+ signA = signF128UI64( uiA64 );
+ uiB64 = bWPtr[indexWord( 2, 1 )];
+ uiB0 = bWPtr[indexWord( 2, 0 )];
+ signB = signF128UI64( uiB64 );
+#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
+ if ( signA == signB ) {
+ *zPtr = softfloat_subMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
+ } else {
+ *zPtr = softfloat_addMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
+ }
+#else
+ magsFuncPtr =
+ (signA == signB) ? softfloat_subMagsF128 : softfloat_addMagsF128;
+ *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
+#endif
+
+}
+
+#else
+
+void
+ f128M_sub( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+{
+
+ softfloat_addF128M(
+ (const uint32_t *) aPtr,
+ (const uint32_t *) bPtr,
+ (uint32_t *) zPtr,
+ true
+ );
+
+}
+
+#endif
+
diff --git a/test/float/softfloat/source/f128M_to_extF80M.c b/test/float/softfloat/source/f128M_to_extF80M.c
new file mode 100644
index 000000000..fe8b0fc81
--- /dev/null
+++ b/test/float/softfloat/source/f128M_to_extF80M.c
@@ -0,0 +1,101 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void f128M_to_extF80M( const float128_t *aPtr, extFloat80_t *zPtr )
+{
+
+ *zPtr = f128_to_extF80( *aPtr );
+
+}
+
+#else
+
+void f128M_to_extF80M( const float128_t *aPtr, extFloat80_t *zPtr )
+{
+ const uint32_t *aWPtr;
+ struct extFloat80M *zSPtr;
+ uint32_t uiA96;
+ bool sign;
+ int32_t exp;
+ struct commonNaN commonNaN;
+ uint32_t sig[4];
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ aWPtr = (const uint32_t *) aPtr;
+ zSPtr = (struct extFloat80M *) zPtr;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uiA96 = aWPtr[indexWordHi( 4 )];
+ sign = signF128UI96( uiA96 );
+ exp = expF128UI96( uiA96 );
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( exp == 0x7FFF ) {
+ if ( softfloat_isNaNF128M( aWPtr ) ) {
+ softfloat_f128MToCommonNaN( aWPtr, &commonNaN );
+ softfloat_commonNaNToExtF80M( &commonNaN, zSPtr );
+ return;
+ }
+ zSPtr->signExp = packToExtF80UI64( sign, 0x7FFF );
+ zSPtr->signif = UINT64_C( 0x8000000000000000 );
+ return;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ exp = softfloat_shiftNormSigF128M( aWPtr, 15, sig );
+ if ( exp == -128 ) {
+ zSPtr->signExp = packToExtF80UI64( sign, 0 );
+ zSPtr->signif = 0;
+ return;
+ }
+ if ( sig[indexWord( 4, 0 )] ) sig[indexWord( 4, 1 )] |= 1;
+ softfloat_roundPackMToExtF80M(
+ sign, exp, &sig[indexMultiwordHi( 4, 3 )], 80, zSPtr );
+
+}
+
+#endif
+
diff --git a/test/float/softfloat/source/f128M_to_f16.c b/test/float/softfloat/source/f128M_to_f16.c
new file mode 100644
index 000000000..4f0c5bb2a
--- /dev/null
+++ b/test/float/softfloat/source/f128M_to_f16.c
@@ -0,0 +1,113 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+float16_t f128M_to_f16( const float128_t *aPtr )
+{
+
+ return f128_to_f16( *aPtr );
+
+}
+
+#else
+
+float16_t f128M_to_f16( const float128_t *aPtr )
+{
+ const uint32_t *aWPtr;
+ uint32_t uiA96;
+ bool sign;
+ int32_t exp;
+ uint32_t frac32;
+ struct commonNaN commonNaN;
+ uint16_t uiZ, frac16;
+ union ui16_f16 uZ;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ aWPtr = (const uint32_t *) aPtr;
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uiA96 = aWPtr[indexWordHi( 4 )];
+ sign = signF128UI96( uiA96 );
+ exp = expF128UI96( uiA96 );
+ frac32 =
+ fracF128UI96( uiA96 )
+ | ((aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
+ | aWPtr[indexWord( 4, 0 )])
+ != 0);
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( exp == 0x7FFF ) {
+ if ( frac32 ) {
+ softfloat_f128MToCommonNaN( aWPtr, &commonNaN );
+ uiZ = softfloat_commonNaNToF16UI( &commonNaN );
+ } else {
+ uiZ = packToF16UI( sign, 0x1F, 0 );
+ }
+ goto uiZ;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ frac16 = frac32>>2 | (frac32 & 3);
+ if ( ! (exp | frac16) ) {
+ uiZ = packToF16UI( sign, 0, 0 );
+ goto uiZ;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ exp -= 0x3FF1;
+ if ( sizeof (int_fast16_t) < sizeof (int32_t) ) {
+ if ( exp < -0x40 ) exp = -0x40;
+ }
+ return softfloat_roundPackToF16( sign, exp, frac16 | 0x4000 );
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uiZ:
+ uZ.ui = uiZ;
+ return uZ.f;
+
+}
+
+#endif
+
diff --git a/test/float/softfloat/source/f128M_to_f32.c b/test/float/softfloat/source/f128M_to_f32.c
new file mode 100644
index 000000000..8b73de08e
--- /dev/null
+++ b/test/float/softfloat/source/f128M_to_f32.c
@@ -0,0 +1,109 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+float32_t f128M_to_f32( const float128_t *aPtr )
+{
+
+ return f128_to_f32( *aPtr );
+
+}
+
+#else
+
+float32_t f128M_to_f32( const float128_t *aPtr )
+{
+ const uint32_t *aWPtr;
+ uint32_t uiA96;
+ bool sign;
+ int32_t exp;
+ uint64_t frac64;
+ struct commonNaN commonNaN;
+ uint32_t uiZ, frac32;
+ union ui32_f32 uZ;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ aWPtr = (const uint32_t *) aPtr;
+ uiA96 = aWPtr[indexWordHi( 4 )];
+ sign = signF128UI96( uiA96 );
+ exp = expF128UI96( uiA96 );
+ frac64 =
+ (uint64_t) fracF128UI96( uiA96 )<<32 | aWPtr[indexWord( 4, 2 )]
+ | ((aWPtr[indexWord( 4, 1 )] | aWPtr[indexWord( 4, 0 )]) != 0);
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( exp == 0x7FFF ) {
+ if ( frac64 ) {
+ softfloat_f128MToCommonNaN( aWPtr, &commonNaN );
+ uiZ = softfloat_commonNaNToF32UI( &commonNaN );
+ } else {
+ uiZ = packToF32UI( sign, 0xFF, 0 );
+ }
+ goto uiZ;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ frac32 = softfloat_shortShiftRightJam64( frac64, 18 );
+ if ( ! (exp | frac32) ) {
+ uiZ = packToF32UI( sign, 0, 0 );
+ goto uiZ;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ exp -= 0x3F81;
+ if ( sizeof (int_fast16_t) < sizeof (int32_t) ) {
+ if ( exp < -0x1000 ) exp = -0x1000;
+ }
+ return softfloat_roundPackToF32( sign, exp, frac32 | 0x40000000 );
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uiZ:
+ uZ.ui = uiZ;
+ return uZ.f;
+
+}
+
+#endif
+
diff --git a/test/float/softfloat/source/f128M_to_f64.c b/test/float/softfloat/source/f128M_to_f64.c
new file mode 100644
index 000000000..1cddd347a
--- /dev/null
+++ b/test/float/softfloat/source/f128M_to_f64.c
@@ -0,0 +1,112 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+float64_t f128M_to_f64( const float128_t *aPtr )
+{
+
+ return f128_to_f64( *aPtr );
+
+}
+
+#else
+
+float64_t f128M_to_f64( const float128_t *aPtr )
+{
+ const uint32_t *aWPtr;
+ uint32_t uiA96;
+ bool sign;
+ int32_t exp;
+ uint64_t frac64;
+ struct commonNaN commonNaN;
+ uint64_t uiZ;
+ uint32_t frac32;
+ union ui64_f64 uZ;
+
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ aWPtr = (const uint32_t *) aPtr;
+ uiA96 = aWPtr[indexWordHi( 4 )];
+ sign = signF128UI96( uiA96 );
+ exp = expF128UI96( uiA96 );
+ frac64 = (uint64_t) fracF128UI96( uiA96 )<<32 | aWPtr[indexWord( 4, 2 )];
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ if ( exp == 0x7FFF ) {
+ if ( frac64 || aWPtr[indexWord( 4, 1 )] | aWPtr[indexWord( 4, 0 )] ) {
+ softfloat_f128MToCommonNaN( aWPtr, &commonNaN );
+ uiZ = softfloat_commonNaNToF64UI( &commonNaN );
+ } else {
+ uiZ = packToF64UI( sign, 0x7FF, 0 );
+ }
+ goto uiZ;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ frac32 = aWPtr[indexWord( 4, 1 )];
+ frac64 = frac64<<14 | frac32>>18;
+ if ( (frac32 & 0x0003FFFF) || aWPtr[indexWord( 4, 0 )] ) frac64 |= 1;
+ if ( ! (exp | frac64) ) {
+ uiZ = packToF64UI( sign, 0, 0 );
+ goto uiZ;
+ }
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ exp -= 0x3C01;
+ if ( sizeof (int_fast16_t) < sizeof (int32_t) ) {
+ if ( exp < -0x1000 ) exp = -0x1000;
+ }
+ return
+ softfloat_roundPackToF64(
+ sign, exp, frac64 | UINT64_C( 0x4000000000000000 ) );
+ /*------------------------------------------------------------------------
+ *------------------------------------------------------------------------*/
+ uiZ:
+ uZ.ui = uiZ;
+ return uZ.f;
+
+}
+
+#endif
+
diff --git a/test/float/softfloat/source/f128M_to_i32.c b/test/float/softfloat/source/f128M_to_i32.c
new file mode 100644
index 000000000..1265c60ad
--- /dev/null
+++ b/test/float/softfloat/source/f128M_to_i32.c
@@ -0,0 +1,98 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions, and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include
+#include