Added FPU emulation to SPARC port
authorAndrew Waterman <waterman@r53.millennium.berkeley.edu>
Tue, 27 Oct 2009 05:27:14 +0000 (22:27 -0700)
committerAndrew Waterman <waterman@r53.millennium.berkeley.edu>
Tue, 27 Oct 2009 05:27:14 +0000 (22:27 -0700)
Our HW FPU does not execute all instructions (namely div, sqrt),
and it doesn't handle IEEE-754 exceptions or denorms.  So we
emulate instructions in a few cases.  The SPARC FP decoder is
borrowed from my functional simulator, and the generic soft FP
code is from SoftFloat, courtesy John Hauser.

16 files changed:
kern/arch/sparc/Makefrag
kern/arch/sparc/arch.h
kern/arch/sparc/env.c
kern/arch/sparc/fpu.c [new file with mode: 0644]
kern/arch/sparc/frontend.c
kern/arch/sparc/softfloat-macros.h [new file with mode: 0644]
kern/arch/sparc/softfloat-specialize.h [new file with mode: 0644]
kern/arch/sparc/softfloat.c [new file with mode: 0644]
kern/arch/sparc/softfloat.h [new file with mode: 0644]
kern/arch/sparc/sparcfpu.c [new file with mode: 0644]
kern/arch/sparc/sparcfpu.h [new file with mode: 0644]
kern/arch/sparc/trap.c
kern/arch/sparc/trap.h
kern/arch/sparc/trap_table.S
kern/include/env.h
kern/src/manager.c

index 00c8863..fe199d3 100644 (file)
@@ -27,4 +27,7 @@ KERN_ARCH_SRCFILES := $(KERN_ARCH_SRC_DIR)/entry.S \
                       $(KERN_ARCH_SRC_DIR)/timer.c \
                       $(KERN_ARCH_SRC_DIR)/env.c \
                       $(KERN_ARCH_SRC_DIR)/init.c \
-                      $(KERN_ARCH_SRC_DIR)/smp.c
+                      $(KERN_ARCH_SRC_DIR)/smp.c \
+                      $(KERN_ARCH_SRC_DIR)/fpu.c \
+                      $(KERN_ARCH_SRC_DIR)/sparcfpu.c \
+                      $(KERN_ARCH_SRC_DIR)/softfloat.c
index 962b5e5..e2575cd 100644 (file)
@@ -152,6 +152,8 @@ cache_flush(void)
 static __inline void
 reboot(void)
 {
+       extern void appserver_die(int code);
+       appserver_die(0);
        while(1);
 }
 
index 937eb1c..845a04c 100644 (file)
 void
 ( env_push_ancillary_state)(env_t* e)
 {
-       static_assert(offsetof(ancillary_state_t,fpr) % 8 == 0);
+       if(e->env_tf.psr & PSR_EF)
+               save_fp_state(&e->env_ancillary_state);
+}
 
+void
+save_fp_state(ancillary_state_t* silly)
+{
        #define push_two_fp_regs(pdest,n) \
            __asm__ __volatile__ ("std  %%f" XSTR(n) ",[%0+4*" XSTR(n) "]" \
                              : : "r"(pdest) : "memory");
 
-       if(e->env_tf.psr & PSR_EF)
-       {
-               write_psr(read_psr() | PSR_EF);
-
-               e->env_ancillary_state.fsr = read_fsr();
-
-               push_two_fp_regs(e->env_ancillary_state.fpr,0);
-               push_two_fp_regs(e->env_ancillary_state.fpr,2);
-               push_two_fp_regs(e->env_ancillary_state.fpr,4);
-               push_two_fp_regs(e->env_ancillary_state.fpr,6);
-               push_two_fp_regs(e->env_ancillary_state.fpr,8);
-               push_two_fp_regs(e->env_ancillary_state.fpr,10);
-               push_two_fp_regs(e->env_ancillary_state.fpr,12);
-               push_two_fp_regs(e->env_ancillary_state.fpr,14);
-               push_two_fp_regs(e->env_ancillary_state.fpr,16);
-               push_two_fp_regs(e->env_ancillary_state.fpr,18);
-               push_two_fp_regs(e->env_ancillary_state.fpr,20);
-               push_two_fp_regs(e->env_ancillary_state.fpr,22);
-               push_two_fp_regs(e->env_ancillary_state.fpr,24);
-               push_two_fp_regs(e->env_ancillary_state.fpr,26);
-               push_two_fp_regs(e->env_ancillary_state.fpr,28);
-               push_two_fp_regs(e->env_ancillary_state.fpr,30);
-
-               write_psr(read_psr() & ~PSR_EF);
-       }
+       write_psr(read_psr() | PSR_EF);
+
+       silly->fsr = read_fsr();
+
+       push_two_fp_regs(silly->fpr,0);
+       push_two_fp_regs(silly->fpr,2);
+       push_two_fp_regs(silly->fpr,4);
+       push_two_fp_regs(silly->fpr,6);
+       push_two_fp_regs(silly->fpr,8);
+       push_two_fp_regs(silly->fpr,10);
+       push_two_fp_regs(silly->fpr,12);
+       push_two_fp_regs(silly->fpr,14);
+       push_two_fp_regs(silly->fpr,16);
+       push_two_fp_regs(silly->fpr,18);
+       push_two_fp_regs(silly->fpr,20);
+       push_two_fp_regs(silly->fpr,22);
+       push_two_fp_regs(silly->fpr,24);
+       push_two_fp_regs(silly->fpr,26);
+       push_two_fp_regs(silly->fpr,28);
+       push_two_fp_regs(silly->fpr,30);
+
+       write_psr(read_psr() & ~PSR_EF);
 }
 
 void
 ( env_pop_ancillary_state)(env_t* e)
 { 
+       if(e->env_tf.psr & PSR_EF)
+               restore_fp_state(&e->env_ancillary_state);
+}
 
+void
+restore_fp_state(ancillary_state_t* silly)
+{
        #define pop_two_fp_regs(pdest,n) \
            __asm__ __volatile__ ("ldd  [%0+4*" XSTR(n) "], %%f" XSTR(n) \
                              : : "r"(pdest) : "memory");
 
-       if(e->env_tf.psr & PSR_EF)
-       {
-               write_psr(read_psr() | PSR_EF);
-
-               pop_two_fp_regs(e->env_ancillary_state.fpr,0);
-               pop_two_fp_regs(e->env_ancillary_state.fpr,2);
-               pop_two_fp_regs(e->env_ancillary_state.fpr,4);
-               pop_two_fp_regs(e->env_ancillary_state.fpr,6);
-               pop_two_fp_regs(e->env_ancillary_state.fpr,8);
-               pop_two_fp_regs(e->env_ancillary_state.fpr,10);
-               pop_two_fp_regs(e->env_ancillary_state.fpr,12);
-               pop_two_fp_regs(e->env_ancillary_state.fpr,14);
-               pop_two_fp_regs(e->env_ancillary_state.fpr,16);
-               pop_two_fp_regs(e->env_ancillary_state.fpr,18);
-               pop_two_fp_regs(e->env_ancillary_state.fpr,20);
-               pop_two_fp_regs(e->env_ancillary_state.fpr,22);
-               pop_two_fp_regs(e->env_ancillary_state.fpr,24);
-               pop_two_fp_regs(e->env_ancillary_state.fpr,26);
-               pop_two_fp_regs(e->env_ancillary_state.fpr,28);
-               pop_two_fp_regs(e->env_ancillary_state.fpr,30);
-
-               write_fsr(e->env_ancillary_state.fsr);
-
-               write_psr(read_psr() & ~PSR_EF);
-       }
+       write_psr(read_psr() | PSR_EF);
+
+       pop_two_fp_regs(silly->fpr,0);
+       pop_two_fp_regs(silly->fpr,2);
+       pop_two_fp_regs(silly->fpr,4);
+       pop_two_fp_regs(silly->fpr,6);
+       pop_two_fp_regs(silly->fpr,8);
+       pop_two_fp_regs(silly->fpr,10);
+       pop_two_fp_regs(silly->fpr,12);
+       pop_two_fp_regs(silly->fpr,14);
+       pop_two_fp_regs(silly->fpr,16);
+       pop_two_fp_regs(silly->fpr,18);
+       pop_two_fp_regs(silly->fpr,20);
+       pop_two_fp_regs(silly->fpr,22);
+       pop_two_fp_regs(silly->fpr,24);
+       pop_two_fp_regs(silly->fpr,26);
+       pop_two_fp_regs(silly->fpr,28);
+       pop_two_fp_regs(silly->fpr,30);
+
+       write_fsr(silly->fsr);
+
+       write_psr(read_psr() & ~PSR_EF);
 }
 
 
diff --git a/kern/arch/sparc/fpu.c b/kern/arch/sparc/fpu.c
new file mode 100644 (file)
index 0000000..3d43108
--- /dev/null
@@ -0,0 +1,182 @@
+#include <arch/sparcfpu.h>
+#include <arch/arch.h>
+#include <arch/trap.h>
+#include <pmap.h>
+
+static inline uint32_t* effective_address(trapframe_t* state, uint32_t insn)
+{
+       uint32_t rs1 = state->gpr[(insn>>14)&0x1F];
+       uint32_t rs2 = state->gpr[insn&0x1F];
+       struct { signed int x:13; } s;
+       int32_t imm = s.x = insn&0x1FFF;
+
+       return (uint32_t*)((insn & 0x2000) ? rs1+imm : rs1+rs2);
+}
+
+void fp_access_exception(trapframe_t* state, void* addr)
+{
+       state->fault_status = 1;
+       state->fault_addr = (uint32_t)addr;
+       access_exception(state);
+}
+
+static inline uint32_t fp_load_word(trapframe_t* state, uint32_t* addr)
+{
+       uint32_t word;
+       if((long)addr % sizeof(word))
+               address_unaligned(state);
+       if(memcpy_from_user(current,&word,addr,sizeof(word)))
+               fp_access_exception(state,addr);
+       return word;
+}
+
+static inline uint64_t fp_load_dword(trapframe_t* state, uint64_t* addr)
+{
+       uint64_t word;
+       if((long)addr % sizeof(word))
+               address_unaligned(state);
+       if(memcpy_from_user(current,&word,addr,sizeof(word)))
+               fp_access_exception(state,addr);
+       return word;
+}
+
+static inline void fp_store_word(trapframe_t* state, uint32_t* addr, uint32_t word)
+{
+       if((long)addr % sizeof(word))
+               address_unaligned(state);
+       if(memcpy_to_user(current,addr,&word,sizeof(word)))
+               fp_access_exception(state,addr);
+}
+
+static inline void fp_store_dword(trapframe_t* state, uint64_t* addr, uint64_t word)
+{
+       if((long)addr % sizeof(word))
+               address_unaligned(state);
+       if(memcpy_to_user(current,addr,&word,sizeof(word)))
+               fp_access_exception(state,addr);
+}
+
+void emulate_fpu(trapframe_t* state, ancillary_state_t* astate)
+{
+       sparcfpu_t thefpu;
+       sparcfpu_t* fpu = &thefpu;
+       sparcfpu_init(fpu);
+
+       // pretend there are no FP exceptions right now.
+       // we should catch them again after emulation 
+       sparcfpu_setFSR(fpu,astate->fsr & ~0x1C000);
+       memcpy(fpu->freg,astate->fpr,sizeof(astate->fpr));
+
+       int annul = 0;
+       uint32_t nnpc = state->npc+4;
+
+       uint64_t dword;
+       uint32_t reg,word;
+       int32_t disp;
+       uint32_t* addr;
+       struct { signed int x:22; } disp22;
+
+       uint32_t insn = fp_load_word(state,(uint32_t*)state->pc);
+       fp_insn_t* fpi = (fp_insn_t*)&insn;
+
+       switch(insn >> 30)
+       {
+               case 0:
+                       switch((insn >> 22) & 0x7)
+                       {
+                               case 6:
+                               {
+                                       int cond = (insn>>25)&0xF;
+                                       if(check_fcc[cond][fpu->FSR.fcc])
+                                       {
+                                               annul = (cond == fccA || cond == fccN) && ((insn>>29)&1);
+                                               disp = disp22.x = insn & 0x3FFFFF;
+                                               nnpc = state->pc + 4*disp;
+                                       }
+                                       else annul = (insn>>29)&1;
+                                       break;
+                               }
+                               default:
+                                       illegal_instruction(state);
+                                       break;
+                       }
+                       break;
+               case 1:
+                       illegal_instruction(state);
+                       break;
+               case 2:
+                       switch((insn >> 19) & 0x3F)
+                       {
+                               case 0x34:
+                                       sparcfpu_fpop1(fpu,*fpi);
+                                       break;
+                               case 0x35:
+                                       sparcfpu_fpop2(fpu,*fpi);
+                                       break;
+                               default:
+                                       illegal_instruction(state);
+                                       break;
+                       }
+                       break;
+               case 3:
+                       switch((insn >> 19) & 0x3F)
+                       {
+                               case 0x20:
+                                       sparcfpu_wrregs(fpu,(insn>>25)&0x1F,fp_load_word(state,effective_address(state,insn)));
+                                       break;
+                               case 0x21: // ldfsr
+                                       addr = effective_address(state,insn);
+                                       word = fp_load_word(state,addr);
+                                       sparcfpu_setFSR(fpu,word);
+                                       break;
+                               case 0x23:
+                                       addr = effective_address(state,insn);
+                                       reg = (insn>>25)&0x1F;
+                                       dword = fp_load_dword(state,(uint64_t*)addr);
+                                       sparcfpu_wrregs(fpu,reg,(uint32_t)(dword>>32));
+                                       sparcfpu_wrregs(fpu,reg+1,(uint32_t)dword);
+                                       break;
+                               case 0x24:
+                                       addr = effective_address(state,insn);
+                                       fp_store_word(state,addr,sparcfpu_regs(fpu,(insn>>25)&0x1F));
+                                       break;
+                               case 0x25: // stfsr
+                                       addr = effective_address(state,insn);
+                                       fp_store_word(state,addr,sparcfpu_getFSR(fpu));
+                                       fpu->FSR.ftt = 0;
+                                       break;
+                               case 0x27:
+                                       addr = effective_address(state,insn);
+                                       reg = (insn>>25)&0x1F;
+                                       dword = (((uint64_t)sparcfpu_regs(fpu,reg))<<32)|(uint64_t)sparcfpu_regs(fpu,reg+1);
+                                       fp_store_dword(state,(uint64_t*)addr,dword);
+                                       break;
+                               default:
+                                       illegal_instruction(state);
+                                       break;
+                       }
+                       break;
+       }
+
+       astate->fsr = sparcfpu_getFSR(fpu);
+
+       // got an FP exception after re-execution
+       if(fpu->FSR.ftt)
+               real_fp_exception(state,astate);
+       else
+       {
+               if(!annul)
+               {
+                       state->pc = state->npc;
+                       state->npc = nnpc;
+               }
+               else
+               {
+                       state->pc = nnpc;
+                       state->npc = nnpc+1;
+               }
+       }
+
+       static_assert(sizeof(astate->fpr) == sizeof(fpu->freg));
+       memcpy(astate->fpr,fpu->freg,sizeof(astate->fpr));
+}
index 539b88f..938cb00 100644 (file)
@@ -9,6 +9,7 @@
 #include <atomic.h>
 #include <pmap.h>
 #include <arch/frontend.h>
+#include <smp.h>
 
 volatile int magic_mem[10];
 
@@ -181,3 +182,20 @@ int32_t sys_nbgetch()
        spin_unlock_irqsave(&getch_lock);
        return result;
 }
+
+void __diediedie(trapframe_t* tf, uint32_t srcid, uint32_t code, uint32_t a1, uint32_t a2)
+{
+       frontend_syscall(RAMP_SYSCALL_exit,(int)code,0,0);
+       while(1);
+}
+
+void appserver_die(int code)
+{
+       int i;
+       for(i = 0; i < num_cpus; i++)
+               if(i != core_id())
+                       while(send_active_message(i,(amr_t)&__diediedie,(void*)code,0,0));
+
+       // just in case.
+       __diediedie(0,0,code,0,0);
+}
diff --git a/kern/arch/sparc/softfloat-macros.h b/kern/arch/sparc/softfloat-macros.h
new file mode 100644 (file)
index 0000000..a707c8d
--- /dev/null
@@ -0,0 +1,720 @@
+\r
+/*============================================================================\r
+\r
+This C source fragment is part of the SoftFloat IEC/IEEE Floating-point\r
+Arithmetic Package, Release 2b.\r
+\r
+Written by John R. Hauser.  This work was made possible in part by the\r
+International Computer Science Institute, located at Suite 600, 1947 Center\r
+Street, Berkeley, California 94704.  Funding was partially provided by the\r
+National Science Foundation under grant MIP-9311980.  The original version\r
+of this code was written as part of a project to build a fixed-point vector\r
+processor in collaboration with the University of California at Berkeley,\r
+overseen by Profs. Nelson Morgan and John Wawrzynek.  More information\r
+is available through the Web page `http://www.cs.berkeley.edu/~jhauser/\r
+arithmetic/SoftFloat.html'.\r
+\r
+THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort has\r
+been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES\r
+RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS\r
+AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES,\r
+COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE\r
+EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE\r
+INSTITUTE (possibly via similar legal notice) AGAINST ALL LOSSES, COSTS, OR\r
+OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE.\r
+\r
+Derivative works are acceptable, even for commercial purposes, so long as\r
+(1) the source code for the derivative work includes prominent notice that\r
+the work is derivative, and (2) the source code includes prominent notice with\r
+these four paragraphs for those parts of this code that are retained.\r
+\r
+=============================================================================*/\r
+\r
+/*----------------------------------------------------------------------------\r
+| Shifts `a' right by the number of bits given in `count'.  If any nonzero\r
+| bits are shifted off, they are ``jammed'' into the least significant bit of\r
+| the result by setting the least significant bit to 1.  The value of `count'\r
+| can be arbitrarily large; in particular, if `count' is greater than 32, the\r
+| result will be either 0 or 1, depending on whether `a' is zero or nonzero.\r
+| The result is stored in the location pointed to by `zPtr'.\r
+*----------------------------------------------------------------------------*/\r
+\r
+INLINE void shift32RightJamming( bits32 a, int16_t count, bits32 *zPtr )\r
+{\r
+    bits32 z;\r
+\r
+    if ( count == 0 ) {\r
+        z = a;\r
+    }\r
+    else if ( count < 32 ) {\r
+        z = ( a>>count ) | ( ( a<<( ( - count ) & 31 ) ) != 0 );\r
+    }\r
+    else {\r
+        z = ( a != 0 );\r
+    }\r
+    *zPtr = z;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Shifts `a' right by the number of bits given in `count'.  If any nonzero\r
+| bits are shifted off, they are ``jammed'' into the least significant bit of\r
+| the result by setting the least significant bit to 1.  The value of `count'\r
+| can be arbitrarily large; in particular, if `count' is greater than 64, the\r
+| result will be either 0 or 1, depending on whether `a' is zero or nonzero.\r
+| The result is stored in the location pointed to by `zPtr'.\r
+*----------------------------------------------------------------------------*/\r
+\r
+INLINE void shift64RightJamming( bits64 a, int16_t count, bits64 *zPtr )\r
+{\r
+    bits64 z;\r
+\r
+    if ( count == 0 ) {\r
+        z = a;\r
+    }\r
+    else if ( count < 64 ) {\r
+        z = ( a>>count ) | ( ( a<<( ( - count ) & 63 ) ) != 0 );\r
+    }\r
+    else {\r
+        z = ( a != 0 );\r
+    }\r
+    *zPtr = z;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Shifts the 128-bit value formed by concatenating `a0' and `a1' right by 64\r
+| _plus_ the number of bits given in `count'.  The shifted result is at most\r
+| 64 nonzero bits; this is stored at the location pointed to by `z0Ptr'.  The\r
+| bits shifted off form a second 64-bit result as follows:  The _last_ bit\r
+| shifted off is the most-significant bit of the extra result, and the other\r
+| 63 bits of the extra result are all zero if and only if _all_but_the_last_\r
+| bits shifted off were all zero.  This extra result is stored in the location\r
+| pointed to by `z1Ptr'.  The value of `count' can be arbitrarily large.\r
+|     (This routine makes more sense if `a0' and `a1' are considered to form\r
+| a fixed-point value with binary point between `a0' and `a1'.  This fixed-\r
+| point value is shifted right by the number of bits given in `count', and\r
+| the integer part of the result is returned at the location pointed to by\r
+| `z0Ptr'.  The fractional part of the result may be slightly corrupted as\r
+| described above, and is returned at the location pointed to by `z1Ptr'.)\r
+*----------------------------------------------------------------------------*/\r
+\r
+INLINE void\r
+ shift64ExtraRightJamming(\r
+     bits64 a0, bits64 a1, int16_t count, bits64 *z0Ptr, bits64 *z1Ptr )\r
+{\r
+    bits64 z0, z1;\r
+    int8_t negCount = ( - count ) & 63;\r
+\r
+    if ( count == 0 ) {\r
+        z1 = a1;\r
+        z0 = a0;\r
+    }\r
+    else if ( count < 64 ) {\r
+        z1 = ( a0<<negCount ) | ( a1 != 0 );\r
+        z0 = a0>>count;\r
+    }\r
+    else {\r
+        if ( count == 64 ) {\r
+            z1 = a0 | ( a1 != 0 );\r
+        }\r
+        else {\r
+            z1 = ( ( a0 | a1 ) != 0 );\r
+        }\r
+        z0 = 0;\r
+    }\r
+    *z1Ptr = z1;\r
+    *z0Ptr = z0;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Shifts the 128-bit value formed by concatenating `a0' and `a1' right by the\r
+| number of bits given in `count'.  Any bits shifted off are lost.  The value\r
+| of `count' can be arbitrarily large; in particular, if `count' is greater\r
+| than 128, the result will be 0.  The result is broken into two 64-bit pieces\r
+| which are stored at the locations pointed to by `z0Ptr' and `z1Ptr'.\r
+*----------------------------------------------------------------------------*/\r
+\r
+INLINE void\r
+ shift128Right(\r
+     bits64 a0, bits64 a1, int16_t count, bits64 *z0Ptr, bits64 *z1Ptr )\r
+{\r
+    bits64 z0, z1;\r
+    int8_t negCount = ( - count ) & 63;\r
+\r
+    if ( count == 0 ) {\r
+        z1 = a1;\r
+        z0 = a0;\r
+    }\r
+    else if ( count < 64 ) {\r
+        z1 = ( a0<<negCount ) | ( a1>>count );\r
+        z0 = a0>>count;\r
+    }\r
+    else {\r
+        z1 = ( count < 64 ) ? ( a0>>( count & 63 ) ) : 0;\r
+        z0 = 0;\r
+    }\r
+    *z1Ptr = z1;\r
+    *z0Ptr = z0;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Shifts the 128-bit value formed by concatenating `a0' and `a1' right by the\r
+| number of bits given in `count'.  If any nonzero bits are shifted off, they\r
+| are ``jammed'' into the least significant bit of the result by setting the\r
+| least significant bit to 1.  The value of `count' can be arbitrarily large;\r
+| in particular, if `count' is greater than 128, the result will be either\r
+| 0 or 1, depending on whether the concatenation of `a0' and `a1' is zero or\r
+| nonzero.  The result is broken into two 64-bit pieces which are stored at\r
+| the locations pointed to by `z0Ptr' and `z1Ptr'.\r
+*----------------------------------------------------------------------------*/\r
+\r
+INLINE void\r
+ shift128RightJamming(\r
+     bits64 a0, bits64 a1, int16_t count, bits64 *z0Ptr, bits64 *z1Ptr )\r
+{\r
+    bits64 z0, z1;\r
+    int8_t negCount = ( - count ) & 63;\r
+\r
+    if ( count == 0 ) {\r
+        z1 = a1;\r
+        z0 = a0;\r
+    }\r
+    else if ( count < 64 ) {\r
+        z1 = ( a0<<negCount ) | ( a1>>count ) | ( ( a1<<negCount ) != 0 );\r
+        z0 = a0>>count;\r
+    }\r
+    else {\r
+        if ( count == 64 ) {\r
+            z1 = a0 | ( a1 != 0 );\r
+        }\r
+        else if ( count < 128 ) {\r
+            z1 = ( a0>>( count & 63 ) ) | ( ( ( a0<<negCount ) | a1 ) != 0 );\r
+        }\r
+        else {\r
+            z1 = ( ( a0 | a1 ) != 0 );\r
+        }\r
+        z0 = 0;\r
+    }\r
+    *z1Ptr = z1;\r
+    *z0Ptr = z0;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Shifts the 192-bit value formed by concatenating `a0', `a1', and `a2' right\r
+| by 64 _plus_ the number of bits given in `count'.  The shifted result is\r
+| at most 128 nonzero bits; these are broken into two 64-bit pieces which are\r
+| stored at the locations pointed to by `z0Ptr' and `z1Ptr'.  The bits shifted\r
+| off form a third 64-bit result as follows:  The _last_ bit shifted off is\r
+| the most-significant bit of the extra result, and the other 63 bits of the\r
+| extra result are all zero if and only if _all_but_the_last_ bits shifted off\r
+| were all zero.  This extra result is stored in the location pointed to by\r
+| `z2Ptr'.  The value of `count' can be arbitrarily large.\r
+|     (This routine makes more sense if `a0', `a1', and `a2' are considered\r
+| to form a fixed-point value with binary point between `a1' and `a2'.  This\r
+| fixed-point value is shifted right by the number of bits given in `count',\r
+| and the integer part of the result is returned at the locations pointed to\r
+| by `z0Ptr' and `z1Ptr'.  The fractional part of the result may be slightly\r
+| corrupted as described above, and is returned at the location pointed to by\r
+| `z2Ptr'.)\r
+*----------------------------------------------------------------------------*/\r
+\r
+INLINE void\r
+ shift128ExtraRightJamming(\r
+     bits64 a0,\r
+     bits64 a1,\r
+     bits64 a2,\r
+     int16_t count,\r
+     bits64 *z0Ptr,\r
+     bits64 *z1Ptr,\r
+     bits64 *z2Ptr\r
+ )\r
+{\r
+    bits64 z0, z1, z2;\r
+    int8_t negCount = ( - count ) & 63;\r
+\r
+    if ( count == 0 ) {\r
+        z2 = a2;\r
+        z1 = a1;\r
+        z0 = a0;\r
+    }\r
+    else {\r
+        if ( count < 64 ) {\r
+            z2 = a1<<negCount;\r
+            z1 = ( a0<<negCount ) | ( a1>>count );\r
+            z0 = a0>>count;\r
+        }\r
+        else {\r
+            if ( count == 64 ) {\r
+                z2 = a1;\r
+                z1 = a0;\r
+            }\r
+            else {\r
+                a2 |= a1;\r
+                if ( count < 128 ) {\r
+                    z2 = a0<<negCount;\r
+                    z1 = a0>>( count & 63 );\r
+                }\r
+                else {\r
+                    z2 = ( count == 128 ) ? a0 : ( a0 != 0 );\r
+                    z1 = 0;\r
+                }\r
+            }\r
+            z0 = 0;\r
+        }\r
+        z2 |= ( a2 != 0 );\r
+    }\r
+    *z2Ptr = z2;\r
+    *z1Ptr = z1;\r
+    *z0Ptr = z0;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Shifts the 128-bit value formed by concatenating `a0' and `a1' left by the\r
+| number of bits given in `count'.  Any bits shifted off are lost.  The value\r
+| of `count' must be less than 64.  The result is broken into two 64-bit\r
+| pieces which are stored at the locations pointed to by `z0Ptr' and `z1Ptr'.\r
+*----------------------------------------------------------------------------*/\r
+\r
+INLINE void\r
+ shortShift128Left(\r
+     bits64 a0, bits64 a1, int16_t count, bits64 *z0Ptr, bits64 *z1Ptr )\r
+{\r
+\r
+    *z1Ptr = a1<<count;\r
+    *z0Ptr =\r
+        ( count == 0 ) ? a0 : ( a0<<count ) | ( a1>>( ( - count ) & 63 ) );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Shifts the 192-bit value formed by concatenating `a0', `a1', and `a2' left\r
+| by the number of bits given in `count'.  Any bits shifted off are lost.\r
+| The value of `count' must be less than 64.  The result is broken into three\r
+| 64-bit pieces which are stored at the locations pointed to by `z0Ptr',\r
+| `z1Ptr', and `z2Ptr'.\r
+*----------------------------------------------------------------------------*/\r
+\r
+INLINE void\r
+ shortShift192Left(\r
+     bits64 a0,\r
+     bits64 a1,\r
+     bits64 a2,\r
+     int16_t count,\r
+     bits64 *z0Ptr,\r
+     bits64 *z1Ptr,\r
+     bits64 *z2Ptr\r
+ )\r
+{\r
+    bits64 z0, z1, z2;\r
+    int8_t negCount;\r
+\r
+    z2 = a2<<count;\r
+    z1 = a1<<count;\r
+    z0 = a0<<count;\r
+    if ( 0 < count ) {\r
+        negCount = ( ( - count ) & 63 );\r
+        z1 |= a2>>negCount;\r
+        z0 |= a1>>negCount;\r
+    }\r
+    *z2Ptr = z2;\r
+    *z1Ptr = z1;\r
+    *z0Ptr = z0;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Adds the 128-bit value formed by concatenating `a0' and `a1' to the 128-bit\r
+| value formed by concatenating `b0' and `b1'.  Addition is modulo 2^128, so\r
+| any carry out is lost.  The result is broken into two 64-bit pieces which\r
+| are stored at the locations pointed to by `z0Ptr' and `z1Ptr'.\r
+*----------------------------------------------------------------------------*/\r
+\r
+INLINE void\r
+ add128(\r
+     bits64 a0, bits64 a1, bits64 b0, bits64 b1, bits64 *z0Ptr, bits64 *z1Ptr )\r
+{\r
+    bits64 z1;\r
+\r
+    z1 = a1 + b1;\r
+    *z1Ptr = z1;\r
+    *z0Ptr = a0 + b0 + ( z1 < a1 );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Adds the 192-bit value formed by concatenating `a0', `a1', and `a2' to the\r
+| 192-bit value formed by concatenating `b0', `b1', and `b2'.  Addition is\r
+| modulo 2^192, so any carry out is lost.  The result is broken into three\r
+| 64-bit pieces which are stored at the locations pointed to by `z0Ptr',\r
+| `z1Ptr', and `z2Ptr'.\r
+*----------------------------------------------------------------------------*/\r
+\r
+INLINE void\r
+ add192(\r
+     bits64 a0,\r
+     bits64 a1,\r
+     bits64 a2,\r
+     bits64 b0,\r
+     bits64 b1,\r
+     bits64 b2,\r
+     bits64 *z0Ptr,\r
+     bits64 *z1Ptr,\r
+     bits64 *z2Ptr\r
+ )\r
+{\r
+    bits64 z0, z1, z2;\r
+    int8_t carry0, carry1;\r
+\r
+    z2 = a2 + b2;\r
+    carry1 = ( z2 < a2 );\r
+    z1 = a1 + b1;\r
+    carry0 = ( z1 < a1 );\r
+    z0 = a0 + b0;\r
+    z1 += carry1;\r
+    z0 += ( z1 < carry1 );\r
+    z0 += carry0;\r
+    *z2Ptr = z2;\r
+    *z1Ptr = z1;\r
+    *z0Ptr = z0;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Subtracts the 128-bit value formed by concatenating `b0' and `b1' from the\r
+| 128-bit value formed by concatenating `a0' and `a1'.  Subtraction is modulo\r
+| 2^128, so any borrow out (carry out) is lost.  The result is broken into two\r
+| 64-bit pieces which are stored at the locations pointed to by `z0Ptr' and\r
+| `z1Ptr'.\r
+*----------------------------------------------------------------------------*/\r
+\r
+INLINE void\r
+ sub128(\r
+     bits64 a0, bits64 a1, bits64 b0, bits64 b1, bits64 *z0Ptr, bits64 *z1Ptr )\r
+{\r
+\r
+    *z1Ptr = a1 - b1;\r
+    *z0Ptr = a0 - b0 - ( a1 < b1 );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Subtracts the 192-bit value formed by concatenating `b0', `b1', and `b2'\r
+| from the 192-bit value formed by concatenating `a0', `a1', and `a2'.\r
+| Subtraction is modulo 2^192, so any borrow out (carry out) is lost.  The\r
+| result is broken into three 64-bit pieces which are stored at the locations\r
+| pointed to by `z0Ptr', `z1Ptr', and `z2Ptr'.\r
+*----------------------------------------------------------------------------*/\r
+\r
+INLINE void\r
+ sub192(\r
+     bits64 a0,\r
+     bits64 a1,\r
+     bits64 a2,\r
+     bits64 b0,\r
+     bits64 b1,\r
+     bits64 b2,\r
+     bits64 *z0Ptr,\r
+     bits64 *z1Ptr,\r
+     bits64 *z2Ptr\r
+ )\r
+{\r
+    bits64 z0, z1, z2;\r
+    int8_t borrow0, borrow1;\r
+\r
+    z2 = a2 - b2;\r
+    borrow1 = ( a2 < b2 );\r
+    z1 = a1 - b1;\r
+    borrow0 = ( a1 < b1 );\r
+    z0 = a0 - b0;\r
+    z0 -= ( z1 < borrow1 );\r
+    z1 -= borrow1;\r
+    z0 -= borrow0;\r
+    *z2Ptr = z2;\r
+    *z1Ptr = z1;\r
+    *z0Ptr = z0;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Multiplies `a' by `b' to obtain a 128-bit product.  The product is broken\r
+| into two 64-bit pieces which are stored at the locations pointed to by\r
+| `z0Ptr' and `z1Ptr'.\r
+*----------------------------------------------------------------------------*/\r
+\r
+INLINE void mul64To128( bits64 a, bits64 b, bits64 *z0Ptr, bits64 *z1Ptr )\r
+{\r
+    bits32 aHigh, aLow, bHigh, bLow;\r
+    bits64 z0, zMiddleA, zMiddleB, z1;\r
+\r
+    aLow = a;\r
+    aHigh = a>>32;\r
+    bLow = b;\r
+    bHigh = b>>32;\r
+    z1 = ( (bits64) aLow ) * bLow;\r
+    zMiddleA = ( (bits64) aLow ) * bHigh;\r
+    zMiddleB = ( (bits64) aHigh ) * bLow;\r
+    z0 = ( (bits64) aHigh ) * bHigh;\r
+    zMiddleA += zMiddleB;\r
+    z0 += ( ( (bits64) ( zMiddleA < zMiddleB ) )<<32 ) + ( zMiddleA>>32 );\r
+    zMiddleA <<= 32;\r
+    z1 += zMiddleA;\r
+    z0 += ( z1 < zMiddleA );\r
+    *z1Ptr = z1;\r
+    *z0Ptr = z0;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Multiplies the 128-bit value formed by concatenating `a0' and `a1' by\r
+| `b' to obtain a 192-bit product.  The product is broken into three 64-bit\r
+| pieces which are stored at the locations pointed to by `z0Ptr', `z1Ptr', and\r
+| `z2Ptr'.\r
+*----------------------------------------------------------------------------*/\r
+\r
+INLINE void\r
+ mul128By64To192(\r
+     bits64 a0,\r
+     bits64 a1,\r
+     bits64 b,\r
+     bits64 *z0Ptr,\r
+     bits64 *z1Ptr,\r
+     bits64 *z2Ptr\r
+ )\r
+{\r
+    bits64 z0, z1, z2, more1;\r
+\r
+    mul64To128( a1, b, &z1, &z2 );\r
+    mul64To128( a0, b, &z0, &more1 );\r
+    add128( z0, more1, 0, z1, &z0, &z1 );\r
+    *z2Ptr = z2;\r
+    *z1Ptr = z1;\r
+    *z0Ptr = z0;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Multiplies the 128-bit value formed by concatenating `a0' and `a1' to the\r
+| 128-bit value formed by concatenating `b0' and `b1' to obtain a 256-bit\r
+| product.  The product is broken into four 64-bit pieces which are stored at\r
+| the locations pointed to by `z0Ptr', `z1Ptr', `z2Ptr', and `z3Ptr'.\r
+*----------------------------------------------------------------------------*/\r
+\r
+INLINE void\r
+ mul128To256(\r
+     bits64 a0,\r
+     bits64 a1,\r
+     bits64 b0,\r
+     bits64 b1,\r
+     bits64 *z0Ptr,\r
+     bits64 *z1Ptr,\r
+     bits64 *z2Ptr,\r
+     bits64 *z3Ptr\r
+ )\r
+{\r
+    bits64 z0, z1, z2, z3;\r
+    bits64 more1, more2;\r
+\r
+    mul64To128( a1, b1, &z2, &z3 );\r
+    mul64To128( a1, b0, &z1, &more2 );\r
+    add128( z1, more2, 0, z2, &z1, &z2 );\r
+    mul64To128( a0, b0, &z0, &more1 );\r
+    add128( z0, more1, 0, z1, &z0, &z1 );\r
+    mul64To128( a0, b1, &more1, &more2 );\r
+    add128( more1, more2, 0, z2, &more1, &z2 );\r
+    add128( z0, z1, 0, more1, &z0, &z1 );\r
+    *z3Ptr = z3;\r
+    *z2Ptr = z2;\r
+    *z1Ptr = z1;\r
+    *z0Ptr = z0;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns an approximation to the 64-bit integer quotient obtained by dividing\r
+| `b' into the 128-bit value formed by concatenating `a0' and `a1'.  The\r
+| divisor `b' must be at least 2^63.  If q is the exact quotient truncated\r
+| toward zero, the approximation returned lies between q and q + 2 inclusive.\r
+| If the exact quotient q is larger than 64 bits, the maximum positive 64-bit\r
+| unsigned integer is returned.\r
+*----------------------------------------------------------------------------*/\r
+\r
+static bits64 estimateDiv128To64( bits64 a0, bits64 a1, bits64 b )\r
+{\r
+    bits64 b0, b1;\r
+    bits64 rem0, rem1, term0, term1;\r
+    bits64 z;\r
+\r
+    if ( b <= a0 ) return LIT64( 0xFFFFFFFFFFFFFFFF );\r
+    b0 = b>>32;\r
+    z = ( b0<<32 <= a0 ) ? LIT64( 0xFFFFFFFF00000000 ) : ( a0 / b0 )<<32;\r
+    mul64To128( b, z, &term0, &term1 );\r
+    sub128( a0, a1, term0, term1, &rem0, &rem1 );\r
+    while ( ( (sbits64) rem0 ) < 0 ) {\r
+        z -= LIT64( 0x100000000 );\r
+        b1 = b<<32;\r
+        add128( rem0, rem1, b0, b1, &rem0, &rem1 );\r
+    }\r
+    rem0 = ( rem0<<32 ) | ( rem1>>32 );\r
+    z |= ( b0<<32 <= rem0 ) ? 0xFFFFFFFF : rem0 / b0;\r
+    return z;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns an approximation to the square root of the 32-bit significand given\r
+| by `a'.  Considered as an integer, `a' must be at least 2^31.  If bit 0 of\r
+| `aExp' (the least significant bit) is 1, the integer returned approximates\r
+| 2^31*sqrt(`a'/2^31), where `a' is considered an integer.  If bit 0 of `aExp'\r
+| is 0, the integer returned approximates 2^31*sqrt(`a'/2^30).  In either\r
+| case, the approximation returned lies strictly within +/-2 of the exact\r
+| value.\r
+*----------------------------------------------------------------------------*/\r
+\r
+static bits32 estimateSqrt32( int16_t aExp, bits32 a )\r
+{\r
+    static const bits16 sqrtOddAdjustments[] = {\r
+        0x0004, 0x0022, 0x005D, 0x00B1, 0x011D, 0x019F, 0x0236, 0x02E0,\r
+        0x039C, 0x0468, 0x0545, 0x0631, 0x072B, 0x0832, 0x0946, 0x0A67\r
+    };\r
+    static const bits16 sqrtEvenAdjustments[] = {\r
+        0x0A2D, 0x08AF, 0x075A, 0x0629, 0x051A, 0x0429, 0x0356, 0x029E,\r
+        0x0200, 0x0179, 0x0109, 0x00AF, 0x0068, 0x0034, 0x0012, 0x0002\r
+    };\r
+    int8_t index;\r
+    bits32 z;\r
+\r
+    index = ( a>>27 ) & 15;\r
+    if ( aExp & 1 ) {\r
+        z = 0x4000 + ( a>>17 ) - sqrtOddAdjustments[ index ];\r
+        z = ( ( a / z )<<14 ) + ( z<<15 );\r
+        a >>= 1;\r
+    }\r
+    else {\r
+        z = 0x8000 + ( a>>17 ) - sqrtEvenAdjustments[ index ];\r
+        z = a / z + z;\r
+        z = ( 0x20000 <= z ) ? 0xFFFF8000 : ( z<<15 );\r
+        if ( z <= a ) return (bits32) ( ( (sbits32) a )>>1 );\r
+    }\r
+    return ( (bits32) ( ( ( (bits64) a )<<31 ) / z ) ) + ( z>>1 );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the number of leading 0 bits before the most-significant 1 bit of\r
+| `a'.  If `a' is zero, 32 is returned.\r
+*----------------------------------------------------------------------------*/\r
+\r
+static int8_t countLeadingZeros32( bits32 a )\r
+{\r
+    static const int8_t countLeadingZerosHigh[] = {\r
+        8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,\r
+        3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,\r
+        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\r
+        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\r
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\r
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\r
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\r
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\r
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\r
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\r
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\r
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\r
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0\r
+    };\r
+    int8_t shiftCount;\r
+\r
+    shiftCount = 0;\r
+    if ( a < 0x10000 ) {\r
+        shiftCount += 16;\r
+        a <<= 16;\r
+    }\r
+    if ( a < 0x1000000 ) {\r
+        shiftCount += 8;\r
+        a <<= 8;\r
+    }\r
+    shiftCount += countLeadingZerosHigh[ a>>24 ];\r
+    return shiftCount;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the number of leading 0 bits before the most-significant 1 bit of\r
+| `a'.  If `a' is zero, 64 is returned.\r
+*----------------------------------------------------------------------------*/\r
+\r
+static int8_t countLeadingZeros64( bits64 a )\r
+{\r
+    int8_t shiftCount;\r
+\r
+    shiftCount = 0;\r
+    if ( a < ( (bits64) 1 )<<32 ) {\r
+        shiftCount += 32;\r
+    }\r
+    else {\r
+        a >>= 32;\r
+    }\r
+    shiftCount += countLeadingZeros32( a );\r
+    return shiftCount;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns 1 if the 128-bit value formed by concatenating `a0' and `a1'\r
+| is equal to the 128-bit value formed by concatenating `b0' and `b1'.\r
+| Otherwise, returns 0.\r
+*----------------------------------------------------------------------------*/\r
+\r
+INLINE flag eq128( bits64 a0, bits64 a1, bits64 b0, bits64 b1 )\r
+{\r
+\r
+    return ( a0 == b0 ) && ( a1 == b1 );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns 1 if the 128-bit value formed by concatenating `a0' and `a1' is less\r
+| than or equal to the 128-bit value formed by concatenating `b0' and `b1'.\r
+| Otherwise, returns 0.\r
+*----------------------------------------------------------------------------*/\r
+\r
+INLINE flag le128( bits64 a0, bits64 a1, bits64 b0, bits64 b1 )\r
+{\r
+\r
+    return ( a0 < b0 ) || ( ( a0 == b0 ) && ( a1 <= b1 ) );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns 1 if the 128-bit value formed by concatenating `a0' and `a1' is less\r
+| than the 128-bit value formed by concatenating `b0' and `b1'.  Otherwise,\r
+| returns 0.\r
+*----------------------------------------------------------------------------*/\r
+\r
+INLINE flag lt128( bits64 a0, bits64 a1, bits64 b0, bits64 b1 )\r
+{\r
+\r
+    return ( a0 < b0 ) || ( ( a0 == b0 ) && ( a1 < b1 ) );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns 1 if the 128-bit value formed by concatenating `a0' and `a1' is\r
+| not equal to the 128-bit value formed by concatenating `b0' and `b1'.\r
+| Otherwise, returns 0.\r
+*----------------------------------------------------------------------------*/\r
+\r
+INLINE flag ne128( bits64 a0, bits64 a1, bits64 b0, bits64 b1 )\r
+{\r
+\r
+    return ( a0 != b0 ) || ( a1 != b1 );\r
+\r
+}\r
+\r
diff --git a/kern/arch/sparc/softfloat-specialize.h b/kern/arch/sparc/softfloat-specialize.h
new file mode 100644 (file)
index 0000000..25673ee
--- /dev/null
@@ -0,0 +1,402 @@
+
+/*============================================================================
+
+This C source fragment is part of the SoftFloat IEC/IEEE Floating-point
+Arithmetic Package, Release 2b.
+
+Written by John R. Hauser.  This work was made possible in part by the
+International Computer Science Institute, located at Suite 600, 1947 Center
+Street, Berkeley, California 94704.  Funding was partially provided by the
+National Science Foundation under grant MIP-9311980.  The original version
+of this code was written as part of a project to build a fixed-point vector
+processor in collaboration with the University of California at Berkeley,
+overseen by Profs. Nelson Morgan and John Wawrzynek.  More information
+is available through the Web page `http://www.cs.berkeley.edu/~jhauser/
+arithmetic/SoftFloat.html'.
+
+THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort has
+been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES
+RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS
+AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES,
+COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE
+EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE
+INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR
+OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE.
+
+Derivative works are acceptable, even for commercial purposes, so long as
+(1) the source code for the derivative work includes prominent notice that
+the work is derivative, and (2) the source code includes prominent notice with
+these four paragraphs for those parts of this code that are retained.
+
+=============================================================================*/
+
+/*----------------------------------------------------------------------------
+| Underflow tininess-detection mode, statically initialized to default value.
+| (The declaration in `softfloat.h' must match the `int8' type here.)
+*----------------------------------------------------------------------------*/
+//int8 float_detect_tininess = float_tininess_before_rounding;
+
+/*----------------------------------------------------------------------------
+| 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 `float_exception_flags |= flags;'.
+*----------------------------------------------------------------------------*/
+
+INLINE void float_raise( softfloat_t* sf, int flags )
+{
+  sf->float_exception_flags |= flags;
+}
+
+/*----------------------------------------------------------------------------
+| The pattern for a default generated single-precision NaN.
+*----------------------------------------------------------------------------*/
+#define float32_default_nan 0x7FFFFFFF
+
+/*----------------------------------------------------------------------------
+| Returns 1 if the single-precision floating-point value `a' is a NaN;
+| otherwise returns 0.
+*----------------------------------------------------------------------------*/
+
+INLINE flag float32_is_nan( softfloat_t* sf, float32 a )
+{
+
+    return ( 0xFF000000 < (bits32) ( a<<1 ) );
+
+}
+
+/*----------------------------------------------------------------------------
+| Returns 1 if the single-precision floating-point value `a' is a signaling
+| NaN; otherwise returns 0.
+*----------------------------------------------------------------------------*/
+
+INLINE flag float32_is_signaling_nan( softfloat_t* sf, float32 a )
+{
+
+    return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF );
+
+}
+
+/*----------------------------------------------------------------------------
+| Returns the result of converting the single-precision floating-point NaN
+| `a' to the canonical NaN format.  If `a' is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+
+commonNaNT float32ToCommonNaN( softfloat_t* sf, float32 a )
+{
+    commonNaNT z;
+
+    if ( float32_is_signaling_nan( sf, a ) ) float_raise( sf, float_flag_invalid );
+    z.sign = a>>31;
+    z.low = 0;
+    z.high = ( (bits64) a )<<41;
+    return z;
+
+}
+
+/*----------------------------------------------------------------------------
+| Returns the result of converting the canonical NaN `a' to the single-
+| precision floating-point format.
+*----------------------------------------------------------------------------*/
+
+float32 commonNaNToFloat32( softfloat_t* sf, commonNaNT a )
+{
+
+    return ( ( (bits32) a.sign )<<31 ) | 0x7FC00000 | ( a.high>>41 );
+
+}
+
+/*----------------------------------------------------------------------------
+| Takes two single-precision floating-point values `a' and `b', one of which
+| is a NaN, and returns the appropriate NaN result.  If either `a' or `b' is a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+
+float32 propagateFloat32NaN( softfloat_t* sf, float32 a, float32 b )
+{
+    flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
+
+    aIsNaN = float32_is_nan( sf, a );
+    aIsSignalingNaN = float32_is_signaling_nan( sf, a );
+    bIsNaN = float32_is_nan( sf, b );
+    bIsSignalingNaN = float32_is_signaling_nan( sf, b );
+    a |= 0x00400000;
+    b |= 0x00400000;
+    if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( sf, float_flag_invalid );
+    return bIsSignalingNaN ? b : aIsSignalingNaN ? a : bIsNaN ? b : a;
+
+}
+
+/*----------------------------------------------------------------------------
+| The pattern for a default generated double-precision NaN.
+*----------------------------------------------------------------------------*/
+#define float64_default_nan LIT64( 0x7FFFFFFFFFFFFFFF )
+
+/*----------------------------------------------------------------------------
+| Returns 1 if the double-precision floating-point value `a' is a NaN;
+| otherwise returns 0.
+*----------------------------------------------------------------------------*/
+
+flag float64_is_nan( softfloat_t* sf, float64 a )
+{
+
+    return ( LIT64( 0xFFE0000000000000 ) < (bits64) ( a<<1 ) );
+
+}
+
+/*----------------------------------------------------------------------------
+| Returns 1 if the double-precision floating-point value `a' is a signaling
+| NaN; otherwise returns 0.
+*----------------------------------------------------------------------------*/
+
+flag float64_is_signaling_nan( softfloat_t* sf, float64 a )
+{
+
+    return
+           ( ( ( a>>51 ) & 0xFFF ) == 0xFFE )
+        && ( a & LIT64( 0x0007FFFFFFFFFFFF ) );
+
+}
+
+/*----------------------------------------------------------------------------
+| Returns the result of converting the double-precision floating-point NaN
+| `a' to the canonical NaN format.  If `a' is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+
+commonNaNT float64ToCommonNaN( softfloat_t* sf, float64 a )
+{
+    commonNaNT z;
+
+    if ( float64_is_signaling_nan( sf, a ) ) float_raise( sf, float_flag_invalid );
+    z.sign = a>>63;
+    z.low = 0;
+    z.high = a<<12;
+    return z;
+
+}
+
+/*----------------------------------------------------------------------------
+| Returns the result of converting the canonical NaN `a' to the double-
+| precision floating-point format.
+*----------------------------------------------------------------------------*/
+
+float64 commonNaNToFloat64( softfloat_t* sf, commonNaNT a )
+{
+
+    return
+          ( ( (bits64) a.sign )<<63 )
+        | LIT64( 0x7FF8000000000000 )
+        | ( a.high>>12 );
+
+}
+
+/*----------------------------------------------------------------------------
+| Takes two double-precision floating-point values `a' and `b', one of which
+| is a NaN, and returns the appropriate NaN result.  If either `a' or `b' is a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+
+float64 propagateFloat64NaN( softfloat_t* sf, float64 a, float64 b )
+{
+    flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
+
+    aIsNaN = float64_is_nan( sf, a );
+    aIsSignalingNaN = float64_is_signaling_nan( sf, a );
+    bIsNaN = float64_is_nan( sf, b );
+    bIsSignalingNaN = float64_is_signaling_nan( sf, b );
+    a |= LIT64( 0x0008000000000000 );
+    b |= LIT64( 0x0008000000000000 );
+    if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( sf, float_flag_invalid );
+    return bIsSignalingNaN ? b : aIsSignalingNaN ? a : bIsNaN ? b : a;
+
+}
+
+#ifdef FLOATX80
+
+/*----------------------------------------------------------------------------
+| The pattern for a default generated extended double-precision NaN.  The
+| `high' and `low' values hold the most- and least-significant bits,
+| respectively.
+*----------------------------------------------------------------------------*/
+#define floatx80_default_nan_high 0x7FFF
+#define floatx80_default_nan_low  LIT64( 0xFFFFFFFFFFFFFFFF )
+
+/*----------------------------------------------------------------------------
+| Returns 1 if the extended double-precision floating-point value `a' is a
+| NaN; otherwise returns 0.
+*----------------------------------------------------------------------------*/
+
+flag floatx80_is_nan( softfloat_t* sf, floatx80 a )
+{
+
+    return ( ( a.high & 0x7FFF ) == 0x7FFF ) && (bits64) ( a.low<<1 );
+
+}
+
+/*----------------------------------------------------------------------------
+| Returns 1 if the extended double-precision floating-point value `a' is a
+| signaling NaN; otherwise returns 0.
+*----------------------------------------------------------------------------*/
+
+flag floatx80_is_signaling_nan( softfloat_t* sf, floatx80 a )
+{
+    bits64 aLow;
+
+    aLow = a.low & ~ LIT64( 0x4000000000000000 );
+    return
+           ( ( a.high & 0x7FFF ) == 0x7FFF )
+        && (bits64) ( aLow<<1 )
+        && ( a.low == aLow );
+
+}
+
+/*----------------------------------------------------------------------------
+| Returns the result of converting the extended double-precision floating-
+| point NaN `a' to the canonical NaN format.  If `a' is a signaling NaN, the
+| invalid exception is raised.
+*----------------------------------------------------------------------------*/
+
+commonNaNT floatx80ToCommonNaN( softfloat_t* sf, floatx80 a )
+{
+    commonNaNT z;
+
+    if ( floatx80_is_signaling_nan( sf, a ) ) float_raise( sf, float_flag_invalid );
+    z.sign = a.high>>15;
+    z.low = 0;
+    z.high = a.low<<1;
+    return z;
+
+}
+
+/*----------------------------------------------------------------------------
+| Returns the result of converting the canonical NaN `a' to the extended
+| double-precision floating-point format.
+*----------------------------------------------------------------------------*/
+
+floatx80 commonNaNToFloatx80( softfloat_t* sf, commonNaNT a )
+{
+    floatx80 z;
+
+    z.low = LIT64( 0xC000000000000000 ) | ( a.high>>1 );
+    z.high = ( ( (bits16) a.sign )<<15 ) | 0x7FFF;
+    return z;
+
+}
+
+/*----------------------------------------------------------------------------
+| Takes two extended double-precision floating-point values `a' and `b', one
+| of which is a NaN, and returns the appropriate NaN result.  If either `a' or
+| `b' is a signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+
+floatx80 propagateFloatx80NaN( softfloat_t* sf, floatx80 a, floatx80 b )
+{
+    flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
+
+    aIsNaN = floatx80_is_nan( sf, a );
+    aIsSignalingNaN = floatx80_is_signaling_nan( sf, a );
+    bIsNaN = floatx80_is_nan( sf, b );
+    bIsSignalingNaN = floatx80_is_signaling_nan( sf, b );
+    a.low |= LIT64( 0xC000000000000000 );
+    b.low |= LIT64( 0xC000000000000000 );
+    if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( sf, float_flag_invalid );
+    return bIsSignalingNaN ? b : aIsSignalingNaN ? a : bIsNaN ? b : a;
+
+}
+
+#endif
+
+#ifdef FLOAT128
+
+/*----------------------------------------------------------------------------
+| The pattern for a default generated quadruple-precision NaN.  The `high' and
+| `low' values hold the most- and least-significant bits, respectively.
+*----------------------------------------------------------------------------*/
+#define float128_default_nan_high LIT64( 0x7FFFFFFFFFFFFFFF )
+#define float128_default_nan_low  LIT64( 0xFFFFFFFFFFFFFFFF )
+
+/*----------------------------------------------------------------------------
+| Returns 1 if the quadruple-precision floating-point value `a' is a NaN;
+| otherwise returns 0.
+*----------------------------------------------------------------------------*/
+
+flag float128_is_nan( softfloat_t* sf, float128 a )
+{
+
+    return
+           ( LIT64( 0xFFFE000000000000 ) <= (bits64) ( a.high<<1 ) )
+        && ( a.low || ( a.high & LIT64( 0x0000FFFFFFFFFFFF ) ) );
+
+}
+
+/*----------------------------------------------------------------------------
+| Returns 1 if the quadruple-precision floating-point value `a' is a
+| signaling NaN; otherwise returns 0.
+*----------------------------------------------------------------------------*/
+
+flag float128_is_signaling_nan( softfloat_t* sf, float128 a )
+{
+
+    return
+           ( ( ( a.high>>47 ) & 0xFFFF ) == 0xFFFE )
+        && ( a.low || ( a.high & LIT64( 0x00007FFFFFFFFFFF ) ) );
+
+}
+
+/*----------------------------------------------------------------------------
+| Returns the result of converting the quadruple-precision floating-point NaN
+| `a' to the canonical NaN format.  If `a' is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+
+commonNaNT float128ToCommonNaN( softfloat_t* sf, float128 a )
+{
+    commonNaNT z;
+
+    if ( float128_is_signaling_nan( sf, a ) ) float_raise( sf, float_flag_invalid );
+    z.sign = a.high>>63;
+    shortShift128Left( a.high, a.low, 16, &z.high, &z.low );
+    return z;
+
+}
+
+/*----------------------------------------------------------------------------
+| Returns the result of converting the canonical NaN `a' to the quadruple-
+| precision floating-point format.
+*----------------------------------------------------------------------------*/
+
+float128 commonNaNToFloat128( softfloat_t* sf, commonNaNT a )
+{
+    float128 z;
+
+    shift128Right( a.high, a.low, 16, &z.high, &z.low );
+    z.high |= ( ( (bits64) a.sign )<<63 ) | LIT64( 0x7FFF800000000000 );
+    return z;
+
+}
+
+/*----------------------------------------------------------------------------
+| Takes two quadruple-precision floating-point values `a' and `b', one of
+| which is a NaN, and returns the appropriate NaN result.  If either `a' or
+| `b' is a signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+
+float128 propagateFloat128NaN( softfloat_t* sf, float128 a, float128 b )
+{
+    flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
+
+    aIsNaN = float128_is_nan( sf, a );
+    aIsSignalingNaN = float128_is_signaling_nan( sf, a );
+    bIsNaN = float128_is_nan( sf, b );
+    bIsSignalingNaN = float128_is_signaling_nan( sf, b );
+    a.high |= LIT64( 0x0000800000000000 );
+    b.high |= LIT64( 0x0000800000000000 );
+    if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( sf, float_flag_invalid );
+    return bIsSignalingNaN ? b : aIsSignalingNaN ? a : bIsNaN ? b : a;
+
+}
+
+#endif
+
diff --git a/kern/arch/sparc/softfloat.c b/kern/arch/sparc/softfloat.c
new file mode 100644 (file)
index 0000000..3ee7574
--- /dev/null
@@ -0,0 +1,5189 @@
+\r
+/*============================================================================\r
+\r
+This C source file is part of the SoftFloat IEC/IEEE Floating-point Arithmetic\r
+Package, Release 2b.\r
+\r
+Written by John R. Hauser.  This work was made possible in part by the\r
+International Computer Science Institute, located at Suite 600, 1947 Center\r
+Street, Berkeley, California 94704.  Funding was partially provided by the\r
+National Science Foundation under grant MIP-9311980.  The original version\r
+of this code was written as part of a project to build a fixed-point vector\r
+processor in collaboration with the University of California at Berkeley,\r
+overseen by Profs. Nelson Morgan and John Wawrzynek.  More information\r
+is available through the Web page `http://www.cs.berkeley.edu/~jhauser/\r
+arithmetic/SoftFloat.html'.\r
+\r
+THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort has\r
+been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES\r
+RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS\r
+AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES,\r
+COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE\r
+EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE\r
+INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR\r
+OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE.\r
+\r
+Derivative works are acceptable, even for commercial purposes, so long as\r
+(1) the source code for the derivative work includes prominent notice that\r
+the work is derivative, and (2) the source code includes prominent notice with\r
+these four paragraphs for those parts of this code that are retained.\r
+\r
+=============================================================================*/\r
+\r
+//#include "milieu.h"\r
+#include "softfloat.h"\r
+\r
+void softfloat_init(softfloat_t* sf)\r
+{\r
+  sf->float_detect_tininess = float_tininess_before_rounding;\r
+  sf->float_rounding_mode = float_round_nearest_even;\r
+  sf->float_exception_flags = 0;\r
+  #ifdef FLOATX80\r
+    sf->floatx80_rounding_precision = 80;\r
+  #endif\r
+};\r
+\r
+\r
+/*----------------------------------------------------------------------------\r
+| Floating-point rounding mode, extended double-precision rounding precision,\r
+| and exception flags.\r
+*----------------------------------------------------------------------------*/\r
+//int8_t sf->float_rounding_mode = float_round_nearest_even;\r
+//int8_t sf->float_exception_flags = 0;\r
+#ifdef FLOATX80\r
+//int sf->floatx80_rounding_precision = 80;\r
+#endif\r
+\r
+/*----------------------------------------------------------------------------\r
+| Primitive arithmetic functions, including multi-word arithmetic, and\r
+| division and square root approximations.  (Can be specialized to target if\r
+| desired.)\r
+*----------------------------------------------------------------------------*/\r
+#include "softfloat-macros.h"\r
+\r
+/*----------------------------------------------------------------------------\r
+| Functions and definitions to determine:  (1) whether tininess for underflow\r
+| is detected before or after rounding by default, (2) what (if anything)\r
+| happens when exceptions are raised, (3) how signaling NaNs are distinguished\r
+| from quiet NaNs, (4) the default generated quiet NaNs, and (5) how NaNs\r
+| are propagated from function inputs to output.  These details are target-\r
+| specific.\r
+*----------------------------------------------------------------------------*/\r
+#include "softfloat-specialize.h"\r
+\r
+/*----------------------------------------------------------------------------\r
+| Takes a 64-bit fixed-point value `absZ' with binary point between bits 6\r
+| and 7, and returns the properly rounded 32-bit integer corresponding to the\r
+| input.  If `zSign' is 1, the input is negated before being converted to an\r
+| integer.  Bit 63 of `absZ' must be zero.  Ordinarily, the fixed-point input\r
+| is simply rounded to an integer, with the inexact exception raised if the\r
+| input cannot be represented exactly as an integer.  However, if the fixed-\r
+| point input is too large, the invalid exception is raised and the largest\r
+| positive or negative integer is returned.\r
+*----------------------------------------------------------------------------*/\r
+\r
+int32_t roundAndPackInt32( softfloat_t* sf, flag zSign, bits64 absZ )\r
+{\r
+    int8_t roundingMode;\r
+    flag roundNearestEven;\r
+    int8_t roundIncrement, roundBits;\r
+    int32_t z;\r
+\r
+    roundingMode = sf->float_rounding_mode;\r
+    roundNearestEven = ( roundingMode == float_round_nearest_even );\r
+    roundIncrement = 0x40;\r
+    if ( ! roundNearestEven ) {\r
+        if ( roundingMode == float_round_to_zero ) {\r
+            roundIncrement = 0;\r
+        }\r
+        else {\r
+            roundIncrement = 0x7F;\r
+            if ( zSign ) {\r
+                if ( roundingMode == float_round_up ) roundIncrement = 0;\r
+            }\r
+            else {\r
+                if ( roundingMode == float_round_down ) roundIncrement = 0;\r
+            }\r
+        }\r
+    }\r
+    roundBits = absZ & 0x7F;\r
+    absZ = ( absZ + roundIncrement )>>7;\r
+    absZ &= ~ ( ( ( roundBits ^ 0x40 ) == 0 ) & roundNearestEven );\r
+    z = absZ;\r
+    if ( zSign ) z = - z;\r
+    if ( ( absZ>>32 ) || ( z && ( ( z < 0 ) ^ zSign ) ) ) {\r
+        float_raise( sf, float_flag_invalid );\r
+        return zSign ? (sbits32) 0x80000000 : 0x7FFFFFFF;\r
+    }\r
+    if ( roundBits ) sf->float_exception_flags |= float_flag_inexact;\r
+    return z;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Takes the 128-bit fixed-point value formed by concatenating `absZ0' and\r
+| `absZ1', with binary point between bits 63 and 64 (between the input words),\r
+| and returns the properly rounded 64-bit integer corresponding to the input.\r
+| If `zSign' is 1, the input is negated before being converted to an integer.\r
+| Ordinarily, the fixed-point input is simply rounded to an integer, with\r
+| the inexact exception raised if the input cannot be represented exactly as\r
+| an integer.  However, if the fixed-point input is too large, the invalid\r
+| exception is raised and the largest positive or negative integer is\r
+| returned.\r
+*----------------------------------------------------------------------------*/\r
+\r
+int64_t roundAndPackInt64( softfloat_t* sf, flag zSign, bits64 absZ0, bits64 absZ1 )\r
+{\r
+    int8_t roundingMode;\r
+    flag roundNearestEven, increment;\r
+    int64_t z;\r
+\r
+    roundingMode = sf->float_rounding_mode;\r
+    roundNearestEven = ( roundingMode == float_round_nearest_even );\r
+    increment = ( (sbits64) absZ1 < 0 );\r
+    if ( ! roundNearestEven ) {\r
+        if ( roundingMode == float_round_to_zero ) {\r
+            increment = 0;\r
+        }\r
+        else {\r
+            if ( zSign ) {\r
+                increment = ( roundingMode == float_round_down ) && absZ1;\r
+            }\r
+            else {\r
+                increment = ( roundingMode == float_round_up ) && absZ1;\r
+            }\r
+        }\r
+    }\r
+    if ( increment ) {\r
+        ++absZ0;\r
+        if ( absZ0 == 0 ) goto overflow;\r
+        absZ0 &= ~ ( ( (bits64) ( absZ1<<1 ) == 0 ) & roundNearestEven );\r
+    }\r
+    z = absZ0;\r
+    if ( zSign ) z = - z;\r
+    if ( z && ( ( z < 0 ) ^ zSign ) ) {\r
+ overflow:\r
+        float_raise( sf, float_flag_invalid );\r
+        return\r
+              zSign ? (sbits64) LIT64( 0x8000000000000000 )\r
+            : LIT64( 0x7FFFFFFFFFFFFFFF );\r
+    }\r
+    if ( absZ1 ) sf->float_exception_flags |= float_flag_inexact;\r
+    return z;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the fraction bits of the single-precision floating-point value `a'.\r
+*----------------------------------------------------------------------------*/\r
+\r
+INLINE bits32 extractFloat32Frac( float32 a )\r
+{\r
+\r
+    return a & 0x007FFFFF;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the exponent bits of the single-precision floating-point value `a'.\r
+*----------------------------------------------------------------------------*/\r
+\r
+INLINE int16_t extractFloat32Exp( float32 a )\r
+{\r
+\r
+    return ( a>>23 ) & 0xFF;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the sign bit of the single-precision floating-point value `a'.\r
+*----------------------------------------------------------------------------*/\r
+\r
+INLINE flag extractFloat32Sign( float32 a )\r
+{\r
+\r
+    return a>>31;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Normalizes the subnormal single-precision floating-point value represented\r
+| by the denormalized significand `aSig'.  The normalized exponent and\r
+| significand are stored at the locations pointed to by `zExpPtr' and\r
+| `zSigPtr', respectively.\r
+*----------------------------------------------------------------------------*/\r
+\r
+void normalizeFloat32Subnormal( bits32 aSig, int16_t *zExpPtr, bits32 *zSigPtr )\r
+{\r
+    int8_t shiftCount;\r
+\r
+    shiftCount = countLeadingZeros32( aSig ) - 8;\r
+    *zSigPtr = aSig<<shiftCount;\r
+    *zExpPtr = 1 - shiftCount;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Packs the sign `zSign', exponent `zExp', and significand `zSig' into a\r
+| single-precision floating-point value, returning the result.  After being\r
+| shifted into the proper positions, the three fields are simply added\r
+| together to form the result.  This means that any integer portion of `zSig'\r
+| will be added into the exponent.  Since a properly normalized significand\r
+| will have an integer portion equal to 1, the `zExp' input should be 1 less\r
+| than the desired result exponent whenever `zSig' is a complete, normalized\r
+| significand.\r
+*----------------------------------------------------------------------------*/\r
+\r
+INLINE float32 packFloat32( flag zSign, int16_t zExp, bits32 zSig )\r
+{\r
+\r
+    return ( ( (bits32) zSign )<<31 ) + ( ( (bits32) zExp )<<23 ) + zSig;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Takes an abstract floating-point value having sign `zSign', exponent `zExp',\r
+| and significand `zSig', and returns the proper single-precision floating-\r
+| point value corresponding to the abstract input.  Ordinarily, the abstract\r
+| value is simply rounded and packed into the single-precision format, with\r
+| the inexact exception raised if the abstract input cannot be represented\r
+| exactly.  However, if the abstract value is too large, the overflow and\r
+| inexact exceptions are raised and an infinity or maximal finite value is\r
+| returned.  If the abstract value is too small, the input value is rounded to\r
+| a subnormal number, and the underflow and inexact exceptions are raised if\r
+| the abstract input cannot be represented exactly as a subnormal single-\r
+| precision floating-point number.\r
+|     The input significand `zSig' has its binary point between bits 30\r
+| and 29, which is 7 bits to the left of the usual location.  This shifted\r
+| significand must be normalized or smaller.  If `zSig' is not normalized,\r
+| `zExp' must be 0; in that case, the result returned is a subnormal number,\r
+| and it must not require rounding.  In the usual case that `zSig' is\r
+| normalized, `zExp' must be 1 less than the ``true'' floating-point exponent.\r
+| The handling of underflow and overflow follows the IEC/IEEE Standard for\r
+| Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float32 roundAndPackFloat32( softfloat_t* sf, flag zSign, int16_t zExp, bits32 zSig )\r
+{\r
+    int8_t roundingMode;\r
+    flag roundNearestEven;\r
+    int8_t roundIncrement, roundBits;\r
+    flag isTiny;\r
+\r
+    roundingMode = sf->float_rounding_mode;\r
+    roundNearestEven = ( roundingMode == float_round_nearest_even );\r
+    roundIncrement = 0x40;\r
+    if ( ! roundNearestEven ) {\r
+        if ( roundingMode == float_round_to_zero ) {\r
+            roundIncrement = 0;\r
+        }\r
+        else {\r
+            roundIncrement = 0x7F;\r
+            if ( zSign ) {\r
+                if ( roundingMode == float_round_up ) roundIncrement = 0;\r
+            }\r
+            else {\r
+                if ( roundingMode == float_round_down ) roundIncrement = 0;\r
+            }\r
+        }\r
+    }\r
+    roundBits = zSig & 0x7F;\r
+    if ( 0xFD <= (bits16) zExp ) {\r
+        if (    ( 0xFD < zExp )\r
+             || (    ( zExp == 0xFD )\r
+                  && ( (sbits32) ( zSig + roundIncrement ) < 0 ) )\r
+           ) {\r
+            float_raise( sf, float_flag_overflow | float_flag_inexact );\r
+            return packFloat32( zSign, 0xFF, 0 ) - ( roundIncrement == 0 );\r
+        }\r
+        if ( zExp < 0 ) {\r
+            isTiny =\r
+                   ( sf->float_detect_tininess == float_tininess_before_rounding )\r
+                || ( zExp < -1 )\r
+                || ( zSig + roundIncrement < 0x80000000 );\r
+            shift32RightJamming( zSig, - zExp, &zSig );\r
+            zExp = 0;\r
+            roundBits = zSig & 0x7F;\r
+            if ( isTiny && roundBits ) float_raise( sf, float_flag_underflow );\r
+        }\r
+    }\r
+    if ( roundBits ) sf->float_exception_flags |= float_flag_inexact;\r
+    zSig = ( zSig + roundIncrement )>>7;\r
+    zSig &= ~ ( ( ( roundBits ^ 0x40 ) == 0 ) & roundNearestEven );\r
+    if ( zSig == 0 ) zExp = 0;\r
+    return packFloat32( zSign, zExp, zSig );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Takes an abstract floating-point value having sign `zSign', exponent `zExp',\r
+| and significand `zSig', and returns the proper single-precision floating-\r
+| point value corresponding to the abstract input.  This routine is just like\r
+| `roundAndPackFloat32' except that `zSig' does not have to be normalized.\r
+| Bit 31 of `zSig' must be zero, and `zExp' must be 1 less than the ``true''\r
+| floating-point exponent.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float32 normalizeRoundAndPackFloat32( softfloat_t* sf, flag zSign, int16_t zExp, bits32 zSig )\r
+{\r
+    int8_t shiftCount;\r
+\r
+    shiftCount = countLeadingZeros32( zSig ) - 1;\r
+    return roundAndPackFloat32( sf, zSign, zExp - shiftCount, zSig<<shiftCount );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the fraction bits of the double-precision floating-point value `a'.\r
+*----------------------------------------------------------------------------*/\r
+\r
+INLINE bits64 extractFloat64Frac( float64 a )\r
+{\r
+\r
+    return a & LIT64( 0x000FFFFFFFFFFFFF );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the exponent bits of the double-precision floating-point value `a'.\r
+*----------------------------------------------------------------------------*/\r
+\r
+INLINE int16_t extractFloat64Exp( float64 a )\r
+{\r
+\r
+    return ( a>>52 ) & 0x7FF;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the sign bit of the double-precision floating-point value `a'.\r
+*----------------------------------------------------------------------------*/\r
+\r
+INLINE flag extractFloat64Sign( float64 a )\r
+{\r
+\r
+    return a>>63;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Normalizes the subnormal double-precision floating-point value represented\r
+| by the denormalized significand `aSig'.  The normalized exponent and\r
+| significand are stored at the locations pointed to by `zExpPtr' and\r
+| `zSigPtr', respectively.\r
+*----------------------------------------------------------------------------*/\r
+\r
+void normalizeFloat64Subnormal( bits64 aSig, int16_t *zExpPtr, bits64 *zSigPtr )\r
+{\r
+    int8_t shiftCount;\r
+\r
+    shiftCount = countLeadingZeros64( aSig ) - 11;\r
+    *zSigPtr = aSig<<shiftCount;\r
+    *zExpPtr = 1 - shiftCount;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Packs the sign `zSign', exponent `zExp', and significand `zSig' into a\r
+| double-precision floating-point value, returning the result.  After being\r
+| shifted into the proper positions, the three fields are simply added\r
+| together to form the result.  This means that any integer portion of `zSig'\r
+| will be added into the exponent.  Since a properly normalized significand\r
+| will have an integer portion equal to 1, the `zExp' input should be 1 less\r
+| than the desired result exponent whenever `zSig' is a complete, normalized\r
+| significand.\r
+*----------------------------------------------------------------------------*/\r
+\r
+INLINE float64 packFloat64( flag zSign, int16_t zExp, bits64 zSig )\r
+{\r
+\r
+    return ( ( (bits64) zSign )<<63 ) + ( ( (bits64) zExp )<<52 ) + zSig;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Takes an abstract floating-point value having sign `zSign', exponent `zExp',\r
+| and significand `zSig', and returns the proper double-precision floating-\r
+| point value corresponding to the abstract input.  Ordinarily, the abstract\r
+| value is simply rounded and packed into the double-precision format, with\r
+| the inexact exception raised if the abstract input cannot be represented\r
+| exactly.  However, if the abstract value is too large, the overflow and\r
+| inexact exceptions are raised and an infinity or maximal finite value is\r
+| returned.  If the abstract value is too small, the input value is rounded\r
+| to a subnormal number, and the underflow and inexact exceptions are raised\r
+| if the abstract input cannot be represented exactly as a subnormal double-\r
+| precision floating-point number.\r
+|     The input significand `zSig' has its binary point between bits 62\r
+| and 61, which is 10 bits to the left of the usual location.  This shifted\r
+| significand must be normalized or smaller.  If `zSig' is not normalized,\r
+| `zExp' must be 0; in that case, the result returned is a subnormal number,\r
+| and it must not require rounding.  In the usual case that `zSig' is\r
+| normalized, `zExp' must be 1 less than the ``true'' floating-point exponent.\r
+| The handling of underflow and overflow follows the IEC/IEEE Standard for\r
+| Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float64 roundAndPackFloat64( softfloat_t* sf, flag zSign, int16_t zExp, bits64 zSig )\r
+{\r
+    int8_t roundingMode;\r
+    flag roundNearestEven;\r
+    int16_t roundIncrement, roundBits;\r
+    flag isTiny;\r
+\r
+    roundingMode = sf->float_rounding_mode;\r
+    roundNearestEven = ( roundingMode == float_round_nearest_even );\r
+    roundIncrement = 0x200;\r
+    if ( ! roundNearestEven ) {\r
+        if ( roundingMode == float_round_to_zero ) {\r
+            roundIncrement = 0;\r
+        }\r
+        else {\r
+            roundIncrement = 0x3FF;\r
+            if ( zSign ) {\r
+                if ( roundingMode == float_round_up ) roundIncrement = 0;\r
+            }\r
+            else {\r
+                if ( roundingMode == float_round_down ) roundIncrement = 0;\r
+            }\r
+        }\r
+    }\r
+    roundBits = zSig & 0x3FF;\r
+    if ( 0x7FD <= (bits16) zExp ) {\r
+        if (    ( 0x7FD < zExp )\r
+             || (    ( zExp == 0x7FD )\r
+                  && ( (sbits64) ( zSig + roundIncrement ) < 0 ) )\r
+           ) {\r
+            float_raise( sf, float_flag_overflow | float_flag_inexact );\r
+            return packFloat64( zSign, 0x7FF, 0 ) - ( roundIncrement == 0 );\r
+        }\r
+        if ( zExp < 0 ) {\r
+            isTiny =\r
+                   ( sf->float_detect_tininess == float_tininess_before_rounding )\r
+                || ( zExp < -1 )\r
+                || ( zSig + roundIncrement < LIT64( 0x8000000000000000 ) );\r
+            shift64RightJamming( zSig, - zExp, &zSig );\r
+            zExp = 0;\r
+            roundBits = zSig & 0x3FF;\r
+            if ( isTiny && roundBits ) float_raise( sf, float_flag_underflow );\r
+        }\r
+    }\r
+    if ( roundBits ) sf->float_exception_flags |= float_flag_inexact;\r
+    zSig = ( zSig + roundIncrement )>>10;\r
+    zSig &= ~ ( ( ( roundBits ^ 0x200 ) == 0 ) & roundNearestEven );\r
+    if ( zSig == 0 ) zExp = 0;\r
+    return packFloat64( zSign, zExp, zSig );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Takes an abstract floating-point value having sign `zSign', exponent `zExp',\r
+| and significand `zSig', and returns the proper double-precision floating-\r
+| point value corresponding to the abstract input.  This routine is just like\r
+| `roundAndPackFloat64' except that `zSig' does not have to be normalized.\r
+| Bit 63 of `zSig' must be zero, and `zExp' must be 1 less than the ``true''\r
+| floating-point exponent.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float64 normalizeRoundAndPackFloat64( softfloat_t* sf, flag zSign, int16_t zExp, bits64 zSig )\r
+{\r
+    int8_t shiftCount;\r
+\r
+    shiftCount = countLeadingZeros64( zSig ) - 1;\r
+    return roundAndPackFloat64( sf, zSign, zExp - shiftCount, zSig<<shiftCount );\r
+\r
+}\r
+\r
+#ifdef FLOATX80\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the fraction bits of the extended double-precision floating-point\r
+| value `a'.\r
+*----------------------------------------------------------------------------*/\r
+\r
+INLINE bits64 extractFloatx80Frac( floatx80 a )\r
+{\r
+\r
+    return a.low;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the exponent bits of the extended double-precision floating-point\r
+| value `a'.\r
+*----------------------------------------------------------------------------*/\r
+\r
+INLINE int32_t extractFloatx80Exp( floatx80 a )\r
+{\r
+\r
+    return a.high & 0x7FFF;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the sign bit of the extended double-precision floating-point value\r
+| `a'.\r
+*----------------------------------------------------------------------------*/\r
+\r
+INLINE flag extractFloatx80Sign( floatx80 a )\r
+{\r
+\r
+    return a.high>>15;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Normalizes the subnormal extended double-precision floating-point value\r
+| represented by the denormalized significand `aSig'.  The normalized exponent\r
+| and significand are stored at the locations pointed to by `zExpPtr' and\r
+| `zSigPtr', respectively.\r
+*----------------------------------------------------------------------------*/\r
+\r
+void normalizeFloatx80Subnormal( bits64 aSig, int32_t *zExpPtr, bits64 *zSigPtr )\r
+{\r
+    int8_t shiftCount;\r
+\r
+    shiftCount = countLeadingZeros64( aSig );\r
+    *zSigPtr = aSig<<shiftCount;\r
+    *zExpPtr = 1 - shiftCount;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Packs the sign `zSign', exponent `zExp', and significand `zSig' into an\r
+| extended double-precision floating-point value, returning the result.\r
+*----------------------------------------------------------------------------*/\r
+\r
+INLINE floatx80 packFloatx80( flag zSign, int32_t zExp, bits64 zSig )\r
+{\r
+    floatx80 z;\r
+\r
+    z.low = zSig;\r
+    z.high = ( ( (bits16) zSign )<<15 ) + zExp;\r
+    return z;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Takes an abstract floating-point value having sign `zSign', exponent `zExp',\r
+| and extended significand formed by the concatenation of `zSig0' and `zSig1',\r
+| and returns the proper extended double-precision floating-point value\r
+| corresponding to the abstract input.  Ordinarily, the abstract value is\r
+| rounded and packed into the extended double-precision format, with the\r
+| inexact exception raised if the abstract input cannot be represented\r
+| exactly.  However, if the abstract value is too large, the overflow and\r
+| inexact exceptions are raised and an infinity or maximal finite value is\r
+| returned.  If the abstract value is too small, the input value is rounded to\r
+| a subnormal number, and the underflow and inexact exceptions are raised if\r
+| the abstract input cannot be represented exactly as a subnormal extended\r
+| double-precision floating-point number.\r
+|     If `roundingPrecision' is 32 or 64, the result is rounded to the same\r
+| number of bits as single or double precision, respectively.  Otherwise, the\r
+| result is rounded to the full precision of the extended double-precision\r
+| format.\r
+|     The input significand must be normalized or smaller.  If the input\r
+| significand is not normalized, `zExp' must be 0; in that case, the result\r
+| returned is a subnormal number, and it must not require rounding.  The\r
+| handling of underflow and overflow follows the IEC/IEEE Standard for Binary\r
+| Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+floatx80 roundAndPackFloatx80( softfloat_t* sf,\r
+     int8_t roundingPrecision, flag zSign, int32_t zExp, bits64 zSig0, bits64 zSig1\r
+ )\r
+{\r
+    int8_t roundingMode;\r
+    flag roundNearestEven, increment, isTiny;\r
+    int64_t roundIncrement, roundMask, roundBits;\r
+\r
+    roundingMode = sf->float_rounding_mode;\r
+    roundNearestEven = ( roundingMode == float_round_nearest_even );\r
+    if ( roundingPrecision == 80 ) goto precision80;\r
+    if ( roundingPrecision == 64 ) {\r
+        roundIncrement = LIT64( 0x0000000000000400 );\r
+        roundMask = LIT64( 0x00000000000007FF );\r
+    }\r
+    else if ( roundingPrecision == 32 ) {\r
+        roundIncrement = LIT64( 0x0000008000000000 );\r
+        roundMask = LIT64( 0x000000FFFFFFFFFF );\r
+    }\r
+    else {\r
+        goto precision80;\r
+    }\r
+    zSig0 |= ( zSig1 != 0 );\r
+    if ( ! roundNearestEven ) {\r
+        if ( roundingMode == float_round_to_zero ) {\r
+            roundIncrement = 0;\r
+        }\r
+        else {\r
+            roundIncrement = roundMask;\r
+            if ( zSign ) {\r
+                if ( roundingMode == float_round_up ) roundIncrement = 0;\r
+            }\r
+            else {\r
+                if ( roundingMode == float_round_down ) roundIncrement = 0;\r
+            }\r
+        }\r
+    }\r
+    roundBits = zSig0 & roundMask;\r
+    if ( 0x7FFD <= (bits32) ( zExp - 1 ) ) {\r
+        if (    ( 0x7FFE < zExp )\r
+             || ( ( zExp == 0x7FFE ) && ( zSig0 + roundIncrement < zSig0 ) )\r
+           ) {\r
+            goto overflow;\r
+        }\r
+        if ( zExp <= 0 ) {\r
+            isTiny =\r
+                   ( sf->float_detect_tininess == float_tininess_before_rounding )\r
+                || ( zExp < 0 )\r
+                || ( zSig0 <= zSig0 + roundIncrement );\r
+            shift64RightJamming( zSig0, 1 - zExp, &zSig0 );\r
+            zExp = 0;\r
+            roundBits = zSig0 & roundMask;\r
+            if ( isTiny && roundBits ) float_raise( sf, float_flag_underflow );\r
+            if ( roundBits ) sf->float_exception_flags |= float_flag_inexact;\r
+            zSig0 += roundIncrement;\r
+            if ( (sbits64) zSig0 < 0 ) zExp = 1;\r
+            roundIncrement = roundMask + 1;\r
+            if ( roundNearestEven && ( roundBits<<1 == roundIncrement ) ) {\r
+                roundMask |= roundIncrement;\r
+            }\r
+            zSig0 &= ~ roundMask;\r
+            return packFloatx80( zSign, zExp, zSig0 );\r
+        }\r
+    }\r
+    if ( roundBits ) sf->float_exception_flags |= float_flag_inexact;\r
+    zSig0 += roundIncrement;\r
+    if ( zSig0 < roundIncrement ) {\r
+        ++zExp;\r
+        zSig0 = LIT64( 0x8000000000000000 );\r
+    }\r
+    roundIncrement = roundMask + 1;\r
+    if ( roundNearestEven && ( roundBits<<1 == roundIncrement ) ) {\r
+        roundMask |= roundIncrement;\r
+    }\r
+    zSig0 &= ~ roundMask;\r
+    if ( zSig0 == 0 ) zExp = 0;\r
+    return packFloatx80( zSign, zExp, zSig0 );\r
+ precision80:\r
+    increment = ( (sbits64) zSig1 < 0 );\r
+    if ( ! roundNearestEven ) {\r
+        if ( roundingMode == float_round_to_zero ) {\r
+            increment = 0;\r
+        }\r
+        else {\r
+            if ( zSign ) {\r
+                increment = ( roundingMode == float_round_down ) && zSig1;\r
+            }\r
+            else {\r
+                increment = ( roundingMode == float_round_up ) && zSig1;\r
+            }\r
+        }\r
+    }\r
+    if ( 0x7FFD <= (bits32) ( zExp - 1 ) ) {\r
+        if (    ( 0x7FFE < zExp )\r
+             || (    ( zExp == 0x7FFE )\r
+                  && ( zSig0 == LIT64( 0xFFFFFFFFFFFFFFFF ) )\r
+                  && increment\r
+                )\r
+           ) {\r
+            roundMask = 0;\r
+ overflow:\r
+            float_raise( sf, float_flag_overflow | float_flag_inexact );\r
+            if (    ( roundingMode == float_round_to_zero )\r
+                 || ( zSign && ( roundingMode == float_round_up ) )\r
+                 || ( ! zSign && ( roundingMode == float_round_down ) )\r
+               ) {\r
+                return packFloatx80( zSign, 0x7FFE, ~ roundMask );\r
+            }\r
+            return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) );\r
+        }\r
+        if ( zExp <= 0 ) {\r
+            isTiny =\r
+                   ( sf->float_detect_tininess == float_tininess_before_rounding )\r
+                || ( zExp < 0 )\r
+                || ! increment\r
+                || ( zSig0 < LIT64( 0xFFFFFFFFFFFFFFFF ) );\r
+            shift64ExtraRightJamming( zSig0, zSig1, 1 - zExp, &zSig0, &zSig1 );\r
+            zExp = 0;\r
+            if ( isTiny && zSig1 ) float_raise( sf, float_flag_underflow );\r
+            if ( zSig1 ) sf->float_exception_flags |= float_flag_inexact;\r
+            if ( roundNearestEven ) {\r
+                increment = ( (sbits64) zSig1 < 0 );\r
+            }\r
+            else {\r
+                if ( zSign ) {\r
+                    increment = ( roundingMode == float_round_down ) && zSig1;\r
+                }\r
+                else {\r
+                    increment = ( roundingMode == float_round_up ) && zSig1;\r
+                }\r
+            }\r
+            if ( increment ) {\r
+                ++zSig0;\r
+                zSig0 &=\r
+                    ~ ( ( (bits64) ( zSig1<<1 ) == 0 ) & roundNearestEven );\r
+                if ( (sbits64) zSig0 < 0 ) zExp = 1;\r
+            }\r
+            return packFloatx80( zSign, zExp, zSig0 );\r
+        }\r
+    }\r
+    if ( zSig1 ) sf->float_exception_flags |= float_flag_inexact;\r
+    if ( increment ) {\r
+        ++zSig0;\r
+        if ( zSig0 == 0 ) {\r
+            ++zExp;\r
+            zSig0 = LIT64( 0x8000000000000000 );\r
+        }\r
+        else {\r
+            zSig0 &= ~ ( ( (bits64) ( zSig1<<1 ) == 0 ) & roundNearestEven );\r
+        }\r
+    }\r
+    else {\r
+        if ( zSig0 == 0 ) zExp = 0;\r
+    }\r
+    return packFloatx80( zSign, zExp, zSig0 );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Takes an abstract floating-point value having sign `zSign', exponent\r
+| `zExp', and significand formed by the concatenation of `zSig0' and `zSig1',\r
+| and returns the proper extended double-precision floating-point value\r
+| corresponding to the abstract input.  This routine is just like\r
+| `roundAndPackFloatx80' except that the input significand does not have to be\r
+| normalized.\r
+*----------------------------------------------------------------------------*/\r
+\r
+floatx80 normalizeRoundAndPackFloatx80( softfloat_t* sf, \r
+     int8_t roundingPrecision, flag zSign, int32_t zExp, bits64 zSig0, bits64 zSig1\r
+ )\r
+{\r
+    int8_t shiftCount;\r
+\r
+    if ( zSig0 == 0 ) {\r
+        zSig0 = zSig1;\r
+        zSig1 = 0;\r
+        zExp -= 64;\r
+    }\r
+    shiftCount = countLeadingZeros64( zSig0 );\r
+    shortShift128Left( zSig0, zSig1, shiftCount, &zSig0, &zSig1 );\r
+    zExp -= shiftCount;\r
+    return\r
+        roundAndPackFloatx80( sf,  roundingPrecision, zSign, zExp, zSig0, zSig1 );\r
+\r
+}\r
+\r
+#endif\r
+\r
+#ifdef FLOAT128\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the least-significant 64 fraction bits of the quadruple-precision\r
+| floating-point value `a'.\r
+*----------------------------------------------------------------------------*/\r
+\r
+INLINE bits64 extractFloat128Frac1( float128 a )\r
+{\r
+\r
+    return a.low;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the most-significant 48 fraction bits of the quadruple-precision\r
+| floating-point value `a'.\r
+*----------------------------------------------------------------------------*/\r
+\r
+INLINE bits64 extractFloat128Frac0( float128 a )\r
+{\r
+\r
+    return a.high & LIT64( 0x0000FFFFFFFFFFFF );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the exponent bits of the quadruple-precision floating-point value\r
+| `a'.\r
+*----------------------------------------------------------------------------*/\r
+\r
+INLINE int32_t extractFloat128Exp( float128 a )\r
+{\r
+\r
+    return ( a.high>>48 ) & 0x7FFF;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the sign bit of the quadruple-precision floating-point value `a'.\r
+*----------------------------------------------------------------------------*/\r
+\r
+INLINE flag extractFloat128Sign( float128 a )\r
+{\r
+\r
+    return a.high>>63;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Normalizes the subnormal quadruple-precision floating-point value\r
+| represented by the denormalized significand formed by the concatenation of\r
+| `aSig0' and `aSig1'.  The normalized exponent is stored at the location\r
+| pointed to by `zExpPtr'.  The most significant 49 bits of the normalized\r
+| significand are stored at the location pointed to by `zSig0Ptr', and the\r
+| least significant 64 bits of the normalized significand are stored at the\r
+| location pointed to by `zSig1Ptr'.\r
+*----------------------------------------------------------------------------*/\r
+\r
+void normalizeFloat128Subnormal(\r
+     bits64 aSig0,\r
+     bits64 aSig1,\r
+     int32_t *zExpPtr,\r
+     bits64 *zSig0Ptr,\r
+     bits64 *zSig1Ptr\r
+ )\r
+{\r
+    int8_t shiftCount;\r
+\r
+    if ( aSig0 == 0 ) {\r
+        shiftCount = countLeadingZeros64( aSig1 ) - 15;\r
+        if ( shiftCount < 0 ) {\r
+            *zSig0Ptr = aSig1>>( - shiftCount );\r
+            *zSig1Ptr = aSig1<<( shiftCount & 63 );\r
+        }\r
+        else {\r
+            *zSig0Ptr = aSig1<<shiftCount;\r
+            *zSig1Ptr = 0;\r
+        }\r
+        *zExpPtr = - shiftCount - 63;\r
+    }\r
+    else {\r
+        shiftCount = countLeadingZeros64( aSig0 ) - 15;\r
+        shortShift128Left( aSig0, aSig1, shiftCount, zSig0Ptr, zSig1Ptr );\r
+        *zExpPtr = 1 - shiftCount;\r
+    }\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Packs the sign `zSign', the exponent `zExp', and the significand formed\r
+| by the concatenation of `zSig0' and `zSig1' into a quadruple-precision\r
+| floating-point value, returning the result.  After being shifted into the\r
+| proper positions, the three fields `zSign', `zExp', and `zSig0' are simply\r
+| added together to form the most significant 32 bits of the result.  This\r
+| means that any integer portion of `zSig0' will be added into the exponent.\r
+| Since a properly normalized significand will have an integer portion equal\r
+| to 1, the `zExp' input should be 1 less than the desired result exponent\r
+| whenever `zSig0' and `zSig1' concatenated form a complete, normalized\r
+| significand.\r
+*----------------------------------------------------------------------------*/\r
+\r
+INLINE float128 packFloat128( flag zSign, int32_t zExp, bits64 zSig0, bits64 zSig1 )\r
+{\r
+    float128 z;\r
+\r
+    z.low = zSig1;\r
+    z.high = ( ( (bits64) zSign )<<63 ) + ( ( (bits64) zExp )<<48 ) + zSig0;\r
+    return z;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Takes an abstract floating-point value having sign `zSign', exponent `zExp',\r
+| and extended significand formed by the concatenation of `zSig0', `zSig1',\r
+| and `zSig2', and returns the proper quadruple-precision floating-point value\r
+| corresponding to the abstract input.  Ordinarily, the abstract value is\r
+| simply rounded and packed into the quadruple-precision format, with the\r
+| inexact exception raised if the abstract input cannot be represented\r
+| exactly.  However, if the abstract value is too large, the overflow and\r
+| inexact exceptions are raised and an infinity or maximal finite value is\r
+| returned.  If the abstract value is too small, the input value is rounded to\r
+| a subnormal number, and the underflow and inexact exceptions are raised if\r
+| the abstract input cannot be represented exactly as a subnormal quadruple-\r
+| precision floating-point number.\r
+|     The input significand must be normalized or smaller.  If the input\r
+| significand is not normalized, `zExp' must be 0; in that case, the result\r
+| returned is a subnormal number, and it must not require rounding.  In the\r
+| usual case that the input significand is normalized, `zExp' must be 1 less\r
+| than the ``true'' floating-point exponent.  The handling of underflow and\r
+| overflow follows the IEC/IEEE Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float128 roundAndPackFloat128( softfloat_t* sf,\r
+     flag zSign, int32_t zExp, bits64 zSig0, bits64 zSig1, bits64 zSig2 )\r
+{\r
+    int8_t roundingMode;\r
+    flag roundNearestEven, increment, isTiny;\r
+\r
+    roundingMode = sf->float_rounding_mode;\r
+    roundNearestEven = ( roundingMode == float_round_nearest_even );\r
+    increment = ( (sbits64) zSig2 < 0 );\r
+    if ( ! roundNearestEven ) {\r
+        if ( roundingMode == float_round_to_zero ) {\r
+            increment = 0;\r
+        }\r
+        else {\r
+            if ( zSign ) {\r
+                increment = ( roundingMode == float_round_down ) && zSig2;\r
+            }\r
+            else {\r
+                increment = ( roundingMode == float_round_up ) && zSig2;\r
+            }\r
+        }\r
+    }\r
+    if ( 0x7FFD <= (bits32) zExp ) {\r
+        if (    ( 0x7FFD < zExp )\r
+             || (    ( zExp == 0x7FFD )\r
+                  && eq128(\r
+                         LIT64( 0x0001FFFFFFFFFFFF ),\r
+                         LIT64( 0xFFFFFFFFFFFFFFFF ),\r
+                         zSig0,\r
+                         zSig1\r
+                     )\r
+                  && increment\r
+                )\r
+           ) {\r
+            float_raise( sf, float_flag_overflow | float_flag_inexact );\r
+            if (    ( roundingMode == float_round_to_zero )\r
+                 || ( zSign && ( roundingMode == float_round_up ) )\r
+                 || ( ! zSign && ( roundingMode == float_round_down ) )\r
+               ) {\r
+                return\r
+                    packFloat128(\r
+                        zSign,\r
+                        0x7FFE,\r
+                        LIT64( 0x0000FFFFFFFFFFFF ),\r
+                        LIT64( 0xFFFFFFFFFFFFFFFF )\r
+                    );\r
+            }\r
+            return packFloat128( zSign, 0x7FFF, 0, 0 );\r
+        }\r
+        if ( zExp < 0 ) {\r
+            isTiny =\r
+                   ( sf->float_detect_tininess == float_tininess_before_rounding )\r
+                || ( zExp < -1 )\r
+                || ! increment\r
+                || lt128(\r
+                       zSig0,\r
+                       zSig1,\r
+                       LIT64( 0x0001FFFFFFFFFFFF ),\r
+                       LIT64( 0xFFFFFFFFFFFFFFFF )\r
+                   );\r
+            shift128ExtraRightJamming(\r
+                zSig0, zSig1, zSig2, - zExp, &zSig0, &zSig1, &zSig2 );\r
+            zExp = 0;\r
+            if ( isTiny && zSig2 ) float_raise( sf, float_flag_underflow );\r
+            if ( roundNearestEven ) {\r
+                increment = ( (sbits64) zSig2 < 0 );\r
+            }\r
+            else {\r
+                if ( zSign ) {\r
+                    increment = ( roundingMode == float_round_down ) && zSig2;\r
+                }\r
+                else {\r
+                    increment = ( roundingMode == float_round_up ) && zSig2;\r
+                }\r
+            }\r
+        }\r
+    }\r
+    if ( zSig2 ) sf->float_exception_flags |= float_flag_inexact;\r
+    if ( increment ) {\r
+        add128( zSig0, zSig1, 0, 1, &zSig0, &zSig1 );\r
+        zSig1 &= ~ ( ( zSig2 + zSig2 == 0 ) & roundNearestEven );\r
+    }\r
+    else {\r
+        if ( ( zSig0 | zSig1 ) == 0 ) zExp = 0;\r
+    }\r
+    return packFloat128( zSign, zExp, zSig0, zSig1 );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Takes an abstract floating-point value having sign `zSign', exponent `zExp',\r
+| and significand formed by the concatenation of `zSig0' and `zSig1', and\r
+| returns the proper quadruple-precision floating-point value corresponding\r
+| to the abstract input.  This routine is just like `roundAndPackFloat128'\r
+| except that the input significand has fewer bits and does not have to be\r
+| normalized.  In all cases, `zExp' must be 1 less than the ``true'' floating-\r
+| point exponent.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float128 normalizeRoundAndPackFloat128( softfloat_t* sf, \r
+     flag zSign, int32_t zExp, bits64 zSig0, bits64 zSig1 )\r
+{\r
+    int8_t shiftCount;\r
+    bits64 zSig2;\r
+\r
+    if ( zSig0 == 0 ) {\r
+        zSig0 = zSig1;\r
+        zSig1 = 0;\r
+        zExp -= 64;\r
+    }\r
+    shiftCount = countLeadingZeros64( zSig0 ) - 15;\r
+    if ( 0 <= shiftCount ) {\r
+        zSig2 = 0;\r
+        shortShift128Left( zSig0, zSig1, shiftCount, &zSig0, &zSig1 );\r
+    }\r
+    else {\r
+        shift128ExtraRightJamming(\r
+            zSig0, zSig1, 0, - shiftCount, &zSig0, &zSig1, &zSig2 );\r
+    }\r
+    zExp -= shiftCount;\r
+    return roundAndPackFloat128( sf,  zSign, zExp, zSig0, zSig1, zSig2 );\r
+\r
+}\r
+\r
+#endif\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the 32-bit two's complement integer `a'\r
+| to the single-precision floating-point format.  The conversion is performed\r
+| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float32 int32_to_float32( softfloat_t* sf, int32_t a )\r
+{\r
+    flag zSign;\r
+\r
+    if ( a == 0 ) return 0;\r
+    if ( a == (sbits32) 0x80000000 ) return packFloat32( 1, 0x9E, 0 );\r
+    zSign = ( a < 0 );\r
+    return normalizeRoundAndPackFloat32( sf, zSign, 0x9C, zSign ? - a : a );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the 32-bit two's complement integer `a'\r
+| to the double-precision floating-point format.  The conversion is performed\r
+| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float64 int32_to_float64( softfloat_t* sf, int32_t a )\r
+{\r
+    flag zSign;\r
+    uint32_t absA;\r
+    int8_t shiftCount;\r
+    bits64 zSig;\r
+\r
+    if ( a == 0 ) return 0;\r
+    zSign = ( a < 0 );\r
+    absA = zSign ? - a : a;\r
+    shiftCount = countLeadingZeros32( absA ) + 21;\r
+    zSig = absA;\r
+    return packFloat64( zSign, 0x432 - shiftCount, zSig<<shiftCount );\r
+\r
+}\r
+\r
+#ifdef FLOATX80\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the 32-bit two's complement integer `a'\r
+| to the extended double-precision floating-point format.  The conversion\r
+| is performed according to the IEC/IEEE Standard for Binary Floating-Point\r
+| Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+floatx80 int32_to_floatx80( softfloat_t* sf, int32_t a )\r
+{\r
+    flag zSign;\r
+    uint32_t absA;\r
+    int8_t shiftCount;\r
+    bits64 zSig;\r
+\r
+    if ( a == 0 ) return packFloatx80( 0, 0, 0 );\r
+    zSign = ( a < 0 );\r
+    absA = zSign ? - a : a;\r
+    shiftCount = countLeadingZeros32( absA ) + 32;\r
+    zSig = absA;\r
+    return packFloatx80( zSign, 0x403E - shiftCount, zSig<<shiftCount );\r
+\r
+}\r
+\r
+#endif\r
+\r
+#ifdef FLOAT128\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the 32-bit two's complement integer `a' to\r
+| the quadruple-precision floating-point format.  The conversion is performed\r
+| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float128 int32_to_float128( softfloat_t* sf, int32_t a )\r
+{\r
+    flag zSign;\r
+    uint32_t absA;\r
+    int8_t shiftCount;\r
+    bits64 zSig0;\r
+\r
+    if ( a == 0 ) return packFloat128( 0, 0, 0, 0 );\r
+    zSign = ( a < 0 );\r
+    absA = zSign ? - a : a;\r
+    shiftCount = countLeadingZeros32( absA ) + 17;\r
+    zSig0 = absA;\r
+    return packFloat128( zSign, 0x402E - shiftCount, zSig0<<shiftCount, 0 );\r
+\r
+}\r
+\r
+#endif\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the 64-bit two's complement integer `a'\r
+| to the single-precision floating-point format.  The conversion is performed\r
+| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float32 int64_to_float32( softfloat_t* sf, int64_t a )\r
+{\r
+    flag zSign;\r
+    uint64_t absA;\r
+    int8_t shiftCount;\r
+    bits32 zSig;\r
+\r
+    if ( a == 0 ) return 0;\r
+    zSign = ( a < 0 );\r
+    absA = zSign ? - a : a;\r
+    shiftCount = countLeadingZeros64( absA ) - 40;\r
+    if ( 0 <= shiftCount ) {\r
+        return packFloat32( zSign, 0x95 - shiftCount, absA<<shiftCount );\r
+    }\r
+    else {\r
+        shiftCount += 7;\r
+        if ( shiftCount < 0 ) {\r
+            shift64RightJamming( absA, - shiftCount, &absA );\r
+        }\r
+        else {\r
+            absA <<= shiftCount;\r
+        }\r
+        return roundAndPackFloat32( sf, zSign, 0x9C - shiftCount, absA );\r
+    }\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the 64-bit two's complement integer `a'\r
+| to the double-precision floating-point format.  The conversion is performed\r
+| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float64 int64_to_float64( softfloat_t* sf, int64_t a )\r
+{\r
+    flag zSign;\r
+\r
+    if ( a == 0 ) return 0;\r
+    if ( a == (sbits64) LIT64( 0x8000000000000000 ) ) {\r
+        return packFloat64( 1, 0x43E, 0 );\r
+    }\r
+    zSign = ( a < 0 );\r
+    return normalizeRoundAndPackFloat64( sf, zSign, 0x43C, zSign ? - a : a );\r
+\r
+}\r
+\r
+#ifdef FLOATX80\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the 64-bit two's complement integer `a'\r
+| to the extended double-precision floating-point format.  The conversion\r
+| is performed according to the IEC/IEEE Standard for Binary Floating-Point\r
+| Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+floatx80 int64_to_floatx80( softfloat_t* sf, int64_t a )\r
+{\r
+    flag zSign;\r
+    uint64_t absA;\r
+    int8_t shiftCount;\r
+\r
+    if ( a == 0 ) return packFloatx80( 0, 0, 0 );\r
+    zSign = ( a < 0 );\r
+    absA = zSign ? - a : a;\r
+    shiftCount = countLeadingZeros64( absA );\r
+    return packFloatx80( zSign, 0x403E - shiftCount, absA<<shiftCount );\r
+\r
+}\r
+\r
+#endif\r
+\r
+#ifdef FLOAT128\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the 64-bit two's complement integer `a' to\r
+| the quadruple-precision floating-point format.  The conversion is performed\r
+| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float128 int64_to_float128( softfloat_t* sf, int64_t a )\r
+{\r
+    flag zSign;\r
+    uint64_t absA;\r
+    int8_t shiftCount;\r
+    int32_t zExp;\r
+    bits64 zSig0, zSig1;\r
+\r
+    if ( a == 0 ) return packFloat128( 0, 0, 0, 0 );\r
+    zSign = ( a < 0 );\r
+    absA = zSign ? - a : a;\r
+    shiftCount = countLeadingZeros64( absA ) + 49;\r
+    zExp = 0x406E - shiftCount;\r
+    if ( 64 <= shiftCount ) {\r
+        zSig1 = 0;\r
+        zSig0 = absA;\r
+        shiftCount -= 64;\r
+    }\r
+    else {\r
+        zSig1 = absA;\r
+        zSig0 = 0;\r
+    }\r
+    shortShift128Left( zSig0, zSig1, shiftCount, &zSig0, &zSig1 );\r
+    return packFloat128( zSign, zExp, zSig0, zSig1 );\r
+\r
+}\r
+\r
+#endif\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the single-precision floating-point value\r
+| `a' to the 32-bit two's complement integer format.  The conversion is\r
+| performed according to the IEC/IEEE Standard for Binary Floating-Point\r
+| Arithmetic---which means in particular that the conversion is rounded\r
+| according to the current rounding mode.  If `a' is a NaN, the largest\r
+| positive integer is returned.  Otherwise, if the conversion overflows, the\r
+| largest integer with the same sign as `a' is returned.\r
+*----------------------------------------------------------------------------*/\r
+\r
+int32_t float32_to_int32( softfloat_t* sf, float32 a )\r
+{\r
+    flag aSign;\r
+    int16_t aExp, shiftCount;\r
+    bits32 aSig;\r
+    bits64 aSig64;\r
+\r
+    aSig = extractFloat32Frac( a );\r
+    aExp = extractFloat32Exp( a );\r
+    aSign = extractFloat32Sign( a );\r
+    if ( ( aExp == 0xFF ) && aSig ) aSign = 0;\r
+    if ( aExp ) aSig |= 0x00800000;\r
+    shiftCount = 0xAF - aExp;\r
+    aSig64 = aSig;\r
+    aSig64 <<= 32;\r
+    if ( 0 < shiftCount ) shift64RightJamming( aSig64, shiftCount, &aSig64 );\r
+    return roundAndPackInt32( sf, aSign, aSig64 );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the single-precision floating-point value\r
+| `a' to the 32-bit two's complement integer format.  The conversion is\r
+| performed according to the IEC/IEEE Standard for Binary Floating-Point\r
+| Arithmetic, except that the conversion is always rounded toward zero.\r
+| If `a' is a NaN, the largest positive integer is returned.  Otherwise, if\r
+| the conversion overflows, the largest integer with the same sign as `a' is\r
+| returned.\r
+*----------------------------------------------------------------------------*/\r
+\r
+int32_t float32_to_int32_round_to_zero( softfloat_t* sf, float32 a )\r
+{\r
+    flag aSign;\r
+    int16_t aExp, shiftCount;\r
+    bits32 aSig;\r
+    int32_t z;\r
+\r
+    aSig = extractFloat32Frac( a );\r
+    aExp = extractFloat32Exp( a );\r
+    aSign = extractFloat32Sign( a );\r
+    shiftCount = aExp - 0x9E;\r
+    if ( 0 <= shiftCount ) {\r
+        if ( a != 0xCF000000 ) {\r
+            float_raise( sf, float_flag_invalid );\r
+            if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) return 0x7FFFFFFF;\r
+        }\r
+        return (sbits32) 0x80000000;\r
+    }\r
+    else if ( aExp <= 0x7E ) {\r
+        if ( aExp | aSig ) sf->float_exception_flags |= float_flag_inexact;\r
+        return 0;\r
+    }\r
+    aSig = ( aSig | 0x00800000 )<<8;\r
+    z = aSig>>( - shiftCount );\r
+    if ( (bits32) ( aSig<<( shiftCount & 31 ) ) ) {\r
+        sf->float_exception_flags |= float_flag_inexact;\r
+    }\r
+    if ( aSign ) z = - z;\r
+    return z;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the single-precision floating-point value\r
+| `a' to the 64-bit two's complement integer format.  The conversion is\r
+| performed according to the IEC/IEEE Standard for Binary Floating-Point\r
+| Arithmetic---which means in particular that the conversion is rounded\r
+| according to the current rounding mode.  If `a' is a NaN, the largest\r
+| positive integer is returned.  Otherwise, if the conversion overflows, the\r
+| largest integer with the same sign as `a' is returned.\r
+*----------------------------------------------------------------------------*/\r
+\r
+int64_t float32_to_int64( softfloat_t* sf, float32 a )\r
+{\r
+    flag aSign;\r
+    int16_t aExp, shiftCount;\r
+    bits32 aSig;\r
+    bits64 aSig64, aSigExtra;\r
+\r
+    aSig = extractFloat32Frac( a );\r
+    aExp = extractFloat32Exp( a );\r
+    aSign = extractFloat32Sign( a );\r
+    shiftCount = 0xBE - aExp;\r
+    if ( shiftCount < 0 ) {\r
+        float_raise( sf, float_flag_invalid );\r
+        if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) {\r
+            return LIT64( 0x7FFFFFFFFFFFFFFF );\r
+        }\r
+        return (sbits64) LIT64( 0x8000000000000000 );\r
+    }\r
+    if ( aExp ) aSig |= 0x00800000;\r
+    aSig64 = aSig;\r
+    aSig64 <<= 40;\r
+    shift64ExtraRightJamming( aSig64, 0, shiftCount, &aSig64, &aSigExtra );\r
+    return roundAndPackInt64( sf, aSign, aSig64, aSigExtra );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the single-precision floating-point value\r
+| `a' to the 64-bit two's complement integer format.  The conversion is\r
+| performed according to the IEC/IEEE Standard for Binary Floating-Point\r
+| Arithmetic, except that the conversion is always rounded toward zero.  If\r
+| `a' is a NaN, the largest positive integer is returned.  Otherwise, if the\r
+| conversion overflows, the largest integer with the same sign as `a' is\r
+| returned.\r
+*----------------------------------------------------------------------------*/\r
+\r
+int64_t float32_to_int64_round_to_zero( softfloat_t* sf, float32 a )\r
+{\r
+    flag aSign;\r
+    int16_t aExp, shiftCount;\r
+    bits32 aSig;\r
+    bits64 aSig64;\r
+    int64_t z;\r
+\r
+    aSig = extractFloat32Frac( a );\r
+    aExp = extractFloat32Exp( a );\r
+    aSign = extractFloat32Sign( a );\r
+    shiftCount = aExp - 0xBE;\r
+    if ( 0 <= shiftCount ) {\r
+        if ( a != 0xDF000000 ) {\r
+            float_raise( sf, float_flag_invalid );\r
+            if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) {\r
+                return LIT64( 0x7FFFFFFFFFFFFFFF );\r
+            }\r
+        }\r
+        return (sbits64) LIT64( 0x8000000000000000 );\r
+    }\r
+    else if ( aExp <= 0x7E ) {\r
+        if ( aExp | aSig ) sf->float_exception_flags |= float_flag_inexact;\r
+        return 0;\r
+    }\r
+    aSig64 = aSig | 0x00800000;\r
+    aSig64 <<= 40;\r
+    z = aSig64>>( - shiftCount );\r
+    if ( (bits64) ( aSig64<<( shiftCount & 63 ) ) ) {\r
+        sf->float_exception_flags |= float_flag_inexact;\r
+    }\r
+    if ( aSign ) z = - z;\r
+    return z;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the single-precision floating-point value\r
+| `a' to the double-precision floating-point format.  The conversion is\r
+| performed according to the IEC/IEEE Standard for Binary Floating-Point\r
+| Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float64 float32_to_float64( softfloat_t* sf, float32 a )\r
+{\r
+    flag aSign;\r
+    int16_t aExp;\r
+    bits32 aSig;\r
+\r
+    aSig = extractFloat32Frac( a );\r
+    aExp = extractFloat32Exp( a );\r
+    aSign = extractFloat32Sign( a );\r
+    if ( aExp == 0xFF ) {\r
+        if ( aSig ) return commonNaNToFloat64( sf, float32ToCommonNaN( sf, a ) );\r
+        return packFloat64( aSign, 0x7FF, 0 );\r
+    }\r
+    if ( aExp == 0 ) {\r
+        if ( aSig == 0 ) return packFloat64( aSign, 0, 0 );\r
+        normalizeFloat32Subnormal( aSig, &aExp, &aSig );\r
+        --aExp;\r
+    }\r
+    return packFloat64( aSign, aExp + 0x380, ( (bits64) aSig )<<29 );\r
+\r
+}\r
+\r
+#ifdef FLOATX80\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the single-precision floating-point value\r
+| `a' to the extended double-precision floating-point format.  The conversion\r
+| is performed according to the IEC/IEEE Standard for Binary Floating-Point\r
+| Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+floatx80 float32_to_floatx80( softfloat_t* sf, float32 a )\r
+{\r
+    flag aSign;\r
+    int16_t aExp;\r
+    bits32 aSig;\r
+\r
+    aSig = extractFloat32Frac( a );\r
+    aExp = extractFloat32Exp( a );\r
+    aSign = extractFloat32Sign( a );\r
+    if ( aExp == 0xFF ) {\r
+        if ( aSig ) return commonNaNToFloatx80( sf, float32ToCommonNaN( sf, a ) );\r
+        return packFloatx80( aSign, 0x7FFF, LIT64( 0x8000000000000000 ) );\r
+    }\r
+    if ( aExp == 0 ) {\r
+        if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );\r
+        normalizeFloat32Subnormal( aSig, &aExp, &aSig );\r
+    }\r
+    aSig |= 0x00800000;\r
+    return packFloatx80( aSign, aExp + 0x3F80, ( (bits64) aSig )<<40 );\r
+\r
+}\r
+\r
+#endif\r
+\r
+#ifdef FLOAT128\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the single-precision floating-point value\r
+| `a' to the double-precision floating-point format.  The conversion is\r
+| performed according to the IEC/IEEE Standard for Binary Floating-Point\r
+| Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float128 float32_to_float128( softfloat_t* sf, float32 a )\r
+{\r
+    flag aSign;\r
+    int16_t aExp;\r
+    bits32 aSig;\r
+\r
+    aSig = extractFloat32Frac( a );\r
+    aExp = extractFloat32Exp( a );\r
+    aSign = extractFloat32Sign( a );\r
+    if ( aExp == 0xFF ) {\r
+        if ( aSig ) return commonNaNToFloat128( sf, float32ToCommonNaN( sf, a ) );\r
+        return packFloat128( aSign, 0x7FFF, 0, 0 );\r
+    }\r
+    if ( aExp == 0 ) {\r
+        if ( aSig == 0 ) return packFloat128( aSign, 0, 0, 0 );\r
+        normalizeFloat32Subnormal( aSig, &aExp, &aSig );\r
+        --aExp;\r
+    }\r
+    return packFloat128( aSign, aExp + 0x3F80, ( (bits64) aSig )<<25, 0 );\r
+\r
+}\r
+\r
+#endif\r
+\r
+/*----------------------------------------------------------------------------\r
+| Rounds the single-precision floating-point value `a' to an integer, and\r
+| returns the result as a single-precision floating-point value.  The\r
+| operation is performed according to the IEC/IEEE Standard for Binary\r
+| Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float32 float32_round_to_int( softfloat_t* sf, float32 a )\r
+{\r
+    flag aSign;\r
+    int16_t aExp;\r
+    bits32 lastBitMask, roundBitsMask;\r
+    int8_t roundingMode;\r
+    float32 z;\r
+\r
+    aExp = extractFloat32Exp( a );\r
+    if ( 0x96 <= aExp ) {\r
+        if ( ( aExp == 0xFF ) && extractFloat32Frac( a ) ) {\r
+            return propagateFloat32NaN( sf, a, a );\r
+        }\r
+        return a;\r
+    }\r
+    if ( aExp <= 0x7E ) {\r
+        if ( (bits32) ( a<<1 ) == 0 ) return a;\r
+        sf->float_exception_flags |= float_flag_inexact;\r
+        aSign = extractFloat32Sign( a );\r
+        switch ( sf->float_rounding_mode ) {\r
+         case float_round_nearest_even:\r
+            if ( ( aExp == 0x7E ) && extractFloat32Frac( a ) ) {\r
+                return packFloat32( aSign, 0x7F, 0 );\r
+            }\r
+            break;\r
+         case float_round_down:\r
+            return aSign ? 0xBF800000 : 0;\r
+         case float_round_up:\r
+            return aSign ? 0x80000000 : 0x3F800000;\r
+        }\r
+        return packFloat32( aSign, 0, 0 );\r
+    }\r
+    lastBitMask = 1;\r
+    lastBitMask <<= 0x96 - aExp;\r
+    roundBitsMask = lastBitMask - 1;\r
+    z = a;\r
+    roundingMode = sf->float_rounding_mode;\r
+    if ( roundingMode == float_round_nearest_even ) {\r
+        z += lastBitMask>>1;\r
+        if ( ( z & roundBitsMask ) == 0 ) z &= ~ lastBitMask;\r
+    }\r
+    else if ( roundingMode != float_round_to_zero ) {\r
+        if ( extractFloat32Sign( z ) ^ ( roundingMode == float_round_up ) ) {\r
+            z += roundBitsMask;\r
+        }\r
+    }\r
+    z &= ~ roundBitsMask;\r
+    if ( z != a ) sf->float_exception_flags |= float_flag_inexact;\r
+    return z;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of adding the absolute values of the single-precision\r
+| floating-point values `a' and `b'.  If `zSign' is 1, the sum is negated\r
+| before being returned.  `zSign' is ignored if the result is a NaN.\r
+| The addition is performed according to the IEC/IEEE Standard for Binary\r
+| Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float32 addFloat32Sigs( softfloat_t* sf, float32 a, float32 b, flag zSign )\r
+{\r
+    int16_t aExp, bExp, zExp;\r
+    bits32 aSig, bSig, zSig;\r
+    int16_t expDiff;\r
+\r
+    aSig = extractFloat32Frac( a );\r
+    aExp = extractFloat32Exp( a );\r
+    bSig = extractFloat32Frac( b );\r
+    bExp = extractFloat32Exp( b );\r
+    expDiff = aExp - bExp;\r
+    aSig <<= 6;\r
+    bSig <<= 6;\r
+    if ( 0 < expDiff ) {\r
+        if ( aExp == 0xFF ) {\r
+            if ( aSig ) return propagateFloat32NaN( sf, a, b );\r
+            return a;\r
+        }\r
+        if ( bExp == 0 ) {\r
+            --expDiff;\r
+        }\r
+        else {\r
+            bSig |= 0x20000000;\r
+        }\r
+        shift32RightJamming( bSig, expDiff, &bSig );\r
+        zExp = aExp;\r
+    }\r
+    else if ( expDiff < 0 ) {\r
+        if ( bExp == 0xFF ) {\r
+            if ( bSig ) return propagateFloat32NaN( sf, a, b );\r
+            return packFloat32( zSign, 0xFF, 0 );\r
+        }\r
+        if ( aExp == 0 ) {\r
+            ++expDiff;\r
+        }\r
+        else {\r
+            aSig |= 0x20000000;\r
+        }\r
+        shift32RightJamming( aSig, - expDiff, &aSig );\r
+        zExp = bExp;\r
+    }\r
+    else {\r
+        if ( aExp == 0xFF ) {\r
+            if ( aSig | bSig ) return propagateFloat32NaN( sf, a, b );\r
+            return a;\r
+        }\r
+        if ( aExp == 0 ) return packFloat32( zSign, 0, ( aSig + bSig )>>6 );\r
+        zSig = 0x40000000 + aSig + bSig;\r
+        zExp = aExp;\r
+        goto roundAndPack;\r
+    }\r
+    aSig |= 0x20000000;\r
+    zSig = ( aSig + bSig )<<1;\r
+    --zExp;\r
+    if ( (sbits32) zSig < 0 ) {\r
+        zSig = aSig + bSig;\r
+        ++zExp;\r
+    }\r
+ roundAndPack:\r
+    return roundAndPackFloat32( sf, zSign, zExp, zSig );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of subtracting the absolute values of the single-\r
+| precision floating-point values `a' and `b'.  If `zSign' is 1, the\r
+| difference is negated before being returned.  `zSign' is ignored if the\r
+| result is a NaN.  The subtraction is performed according to the IEC/IEEE\r
+| Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float32 subFloat32Sigs( softfloat_t* sf, float32 a, float32 b, flag zSign )\r
+{\r
+    int16_t aExp, bExp, zExp;\r
+    bits32 aSig, bSig, zSig;\r
+    int16_t expDiff;\r
+\r
+    aSig = extractFloat32Frac( a );\r
+    aExp = extractFloat32Exp( a );\r
+    bSig = extractFloat32Frac( b );\r
+    bExp = extractFloat32Exp( b );\r
+    expDiff = aExp - bExp;\r
+    aSig <<= 7;\r
+    bSig <<= 7;\r
+    if ( 0 < expDiff ) goto aExpBigger;\r
+    if ( expDiff < 0 ) goto bExpBigger;\r
+    if ( aExp == 0xFF ) {\r
+        if ( aSig | bSig ) return propagateFloat32NaN( sf, a, b );\r
+        float_raise( sf, float_flag_invalid );\r
+        return float32_default_nan;\r
+    }\r
+    if ( aExp == 0 ) {\r
+        aExp = 1;\r
+        bExp = 1;\r
+    }\r
+    if ( bSig < aSig ) goto aBigger;\r
+    if ( aSig < bSig ) goto bBigger;\r
+    return packFloat32( sf->float_rounding_mode == float_round_down, 0, 0 );\r
+ bExpBigger:\r
+    if ( bExp == 0xFF ) {\r
+        if ( bSig ) return propagateFloat32NaN( sf, a, b );\r
+        return packFloat32( zSign ^ 1, 0xFF, 0 );\r
+    }\r
+    if ( aExp == 0 ) {\r
+        ++expDiff;\r
+    }\r
+    else {\r
+        aSig |= 0x40000000;\r
+    }\r
+    shift32RightJamming( aSig, - expDiff, &aSig );\r
+    bSig |= 0x40000000;\r
+ bBigger:\r
+    zSig = bSig - aSig;\r
+    zExp = bExp;\r
+    zSign ^= 1;\r
+    goto normalizeRoundAndPack;\r
+ aExpBigger:\r
+    if ( aExp == 0xFF ) {\r
+        if ( aSig ) return propagateFloat32NaN( sf, a, b );\r
+        return a;\r
+    }\r
+    if ( bExp == 0 ) {\r
+        --expDiff;\r
+    }\r
+    else {\r
+        bSig |= 0x40000000;\r
+    }\r
+    shift32RightJamming( bSig, expDiff, &bSig );\r
+    aSig |= 0x40000000;\r
+ aBigger:\r
+    zSig = aSig - bSig;\r
+    zExp = aExp;\r
+ normalizeRoundAndPack:\r
+    --zExp;\r
+    return normalizeRoundAndPackFloat32( sf, zSign, zExp, zSig );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of adding the single-precision floating-point values `a'\r
+| and `b'.  The operation is performed according to the IEC/IEEE Standard for\r
+| Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float32 float32_add( softfloat_t* sf, float32 a, float32 b )\r
+{\r
+    flag aSign, bSign;\r
+\r
+    aSign = extractFloat32Sign( a );\r
+    bSign = extractFloat32Sign( b );\r
+    if ( aSign == bSign ) {\r
+        return addFloat32Sigs( sf, a, b, aSign );\r
+    }\r
+    else {\r
+        return subFloat32Sigs( sf, a, b, aSign );\r
+    }\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of subtracting the single-precision floating-point values\r
+| `a' and `b'.  The operation is performed according to the IEC/IEEE Standard\r
+| for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float32 float32_sub( softfloat_t* sf, float32 a, float32 b )\r
+{\r
+    flag aSign, bSign;\r
+\r
+    aSign = extractFloat32Sign( a );\r
+    bSign = extractFloat32Sign( b );\r
+    if ( aSign == bSign ) {\r
+        return subFloat32Sigs( sf, a, b, aSign );\r
+    }\r
+    else {\r
+        return addFloat32Sigs( sf, a, b, aSign );\r
+    }\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of multiplying the single-precision floating-point values\r
+| `a' and `b'.  The operation is performed according to the IEC/IEEE Standard\r
+| for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float32 float32_mul( softfloat_t* sf, float32 a, float32 b )\r
+{\r
+    flag aSign, bSign, zSign;\r
+    int16_t aExp, bExp, zExp;\r
+    bits32 aSig, bSig;\r
+    bits64 zSig64;\r
+    bits32 zSig;\r
+\r
+    aSig = extractFloat32Frac( a );\r
+    aExp = extractFloat32Exp( a );\r
+    aSign = extractFloat32Sign( a );\r
+    bSig = extractFloat32Frac( b );\r
+    bExp = extractFloat32Exp( b );\r
+    bSign = extractFloat32Sign( b );\r
+    zSign = aSign ^ bSign;\r
+    if ( aExp == 0xFF ) {\r
+        if ( aSig || ( ( bExp == 0xFF ) && bSig ) ) {\r
+            return propagateFloat32NaN( sf, a, b );\r
+        }\r
+        if ( ( bExp | bSig ) == 0 ) {\r
+            float_raise( sf, float_flag_invalid );\r
+            return float32_default_nan;\r
+        }\r
+        return packFloat32( zSign, 0xFF, 0 );\r
+    }\r
+    if ( bExp == 0xFF ) {\r
+        if ( bSig ) return propagateFloat32NaN( sf, a, b );\r
+        if ( ( aExp | aSig ) == 0 ) {\r
+            float_raise( sf, float_flag_invalid );\r
+            return float32_default_nan;\r
+        }\r
+        return packFloat32( zSign, 0xFF, 0 );\r
+    }\r
+    if ( aExp == 0 ) {\r
+        if ( aSig == 0 ) return packFloat32( zSign, 0, 0 );\r
+        normalizeFloat32Subnormal( aSig, &aExp, &aSig );\r
+    }\r
+    if ( bExp == 0 ) {\r
+        if ( bSig == 0 ) return packFloat32( zSign, 0, 0 );\r
+        normalizeFloat32Subnormal( bSig, &bExp, &bSig );\r
+    }\r
+    zExp = aExp + bExp - 0x7F;\r
+    aSig = ( aSig | 0x00800000 )<<7;\r
+    bSig = ( bSig | 0x00800000 )<<8;\r
+    shift64RightJamming( ( (bits64) aSig ) * bSig, 32, &zSig64 );\r
+    zSig = zSig64;\r
+    if ( 0 <= (sbits32) ( zSig<<1 ) ) {\r
+        zSig <<= 1;\r
+        --zExp;\r
+    }\r
+    return roundAndPackFloat32( sf, zSign, zExp, zSig );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of dividing the single-precision floating-point value `a'\r
+| by the corresponding value `b'.  The operation is performed according to the\r
+| IEC/IEEE Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float32 float32_div( softfloat_t* sf, float32 a, float32 b )\r
+{\r
+    flag aSign, bSign, zSign;\r
+    int16_t aExp, bExp, zExp;\r
+    bits32 aSig, bSig, zSig;\r
+\r
+    aSig = extractFloat32Frac( a );\r
+    aExp = extractFloat32Exp( a );\r
+    aSign = extractFloat32Sign( a );\r
+    bSig = extractFloat32Frac( b );\r
+    bExp = extractFloat32Exp( b );\r
+    bSign = extractFloat32Sign( b );\r
+    zSign = aSign ^ bSign;\r
+    if ( aExp == 0xFF ) {\r
+        if ( aSig ) return propagateFloat32NaN( sf, a, b );\r
+        if ( bExp == 0xFF ) {\r
+            if ( bSig ) return propagateFloat32NaN( sf, a, b );\r
+            float_raise( sf, float_flag_invalid );\r
+            return float32_default_nan;\r
+        }\r
+        return packFloat32( zSign, 0xFF, 0 );\r
+    }\r
+    if ( bExp == 0xFF ) {\r
+        if ( bSig ) return propagateFloat32NaN( sf, a, b );\r
+        return packFloat32( zSign, 0, 0 );\r
+    }\r
+    if ( bExp == 0 ) {\r
+        if ( bSig == 0 ) {\r
+            if ( ( aExp | aSig ) == 0 ) {\r
+                float_raise( sf, float_flag_invalid );\r
+                return float32_default_nan;\r
+            }\r
+            float_raise( sf, float_flag_divbyzero );\r
+            return packFloat32( zSign, 0xFF, 0 );\r
+        }\r
+        normalizeFloat32Subnormal( bSig, &bExp, &bSig );\r
+    }\r
+    if ( aExp == 0 ) {\r
+        if ( aSig == 0 ) return packFloat32( zSign, 0, 0 );\r
+        normalizeFloat32Subnormal( aSig, &aExp, &aSig );\r
+    }\r
+    zExp = aExp - bExp + 0x7D;\r
+    aSig = ( aSig | 0x00800000 )<<7;\r
+    bSig = ( bSig | 0x00800000 )<<8;\r
+    if ( bSig <= ( aSig + aSig ) ) {\r
+        aSig >>= 1;\r
+        ++zExp;\r
+    }\r
+    zSig = ( ( (bits64) aSig )<<32 ) / bSig;\r
+    if ( ( zSig & 0x3F ) == 0 ) {\r
+        zSig |= ( (bits64) bSig * zSig != ( (bits64) aSig )<<32 );\r
+    }\r
+    return roundAndPackFloat32( sf, zSign, zExp, zSig );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the remainder of the single-precision floating-point value `a'\r
+| with respect to the corresponding value `b'.  The operation is performed\r
+| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float32 float32_rem( softfloat_t* sf, float32 a, float32 b )\r
+{\r
+    flag aSign, bSign, zSign;\r
+    int16_t aExp, bExp, expDiff;\r
+    bits32 aSig, bSig;\r
+    bits32 q;\r
+    bits64 aSig64, bSig64, q64;\r
+    bits32 alternateASig;\r
+    sbits32 sigMean;\r
+\r
+    aSig = extractFloat32Frac( a );\r
+    aExp = extractFloat32Exp( a );\r
+    aSign = extractFloat32Sign( a );\r
+    bSig = extractFloat32Frac( b );\r
+    bExp = extractFloat32Exp( b );\r
+    bSign = extractFloat32Sign( b );\r
+    if ( aExp == 0xFF ) {\r
+        if ( aSig || ( ( bExp == 0xFF ) && bSig ) ) {\r
+            return propagateFloat32NaN( sf, a, b );\r
+        }\r
+        float_raise( sf, float_flag_invalid );\r
+        return float32_default_nan;\r
+    }\r
+    if ( bExp == 0xFF ) {\r
+        if ( bSig ) return propagateFloat32NaN( sf, a, b );\r
+        return a;\r
+    }\r
+    if ( bExp == 0 ) {\r
+        if ( bSig == 0 ) {\r
+            float_raise( sf, float_flag_invalid );\r
+            return float32_default_nan;\r
+        }\r
+        normalizeFloat32Subnormal( bSig, &bExp, &bSig );\r
+    }\r
+    if ( aExp == 0 ) {\r
+        if ( aSig == 0 ) return a;\r
+        normalizeFloat32Subnormal( aSig, &aExp, &aSig );\r
+    }\r
+    expDiff = aExp - bExp;\r
+    aSig |= 0x00800000;\r
+    bSig |= 0x00800000;\r
+    if ( expDiff < 32 ) {\r
+        aSig <<= 8;\r
+        bSig <<= 8;\r
+        if ( expDiff < 0 ) {\r
+            if ( expDiff < -1 ) return a;\r
+            aSig >>= 1;\r
+        }\r
+        q = ( bSig <= aSig );\r
+        if ( q ) aSig -= bSig;\r
+        if ( 0 < expDiff ) {\r
+            q = ( ( (bits64) aSig )<<32 ) / bSig;\r
+            q >>= 32 - expDiff;\r
+            bSig >>= 2;\r
+            aSig = ( ( aSig>>1 )<<( expDiff - 1 ) ) - bSig * q;\r
+        }\r
+        else {\r
+            aSig >>= 2;\r
+            bSig >>= 2;\r
+        }\r
+    }\r
+    else {\r
+        if ( bSig <= aSig ) aSig -= bSig;\r
+        aSig64 = ( (bits64) aSig )<<40;\r
+        bSig64 = ( (bits64) bSig )<<40;\r
+        expDiff -= 64;\r
+        while ( 0 < expDiff ) {\r
+            q64 = estimateDiv128To64( aSig64, 0, bSig64 );\r
+            q64 = ( 2 < q64 ) ? q64 - 2 : 0;\r
+            aSig64 = - ( ( bSig * q64 )<<38 );\r
+            expDiff -= 62;\r
+        }\r
+        expDiff += 64;\r
+        q64 = estimateDiv128To64( aSig64, 0, bSig64 );\r
+        q64 = ( 2 < q64 ) ? q64 - 2 : 0;\r
+        q = q64>>( 64 - expDiff );\r
+        bSig <<= 6;\r
+        aSig = ( ( aSig64>>33 )<<( expDiff - 1 ) ) - bSig * q;\r
+    }\r
+    do {\r
+        alternateASig = aSig;\r
+        ++q;\r
+        aSig -= bSig;\r
+    } while ( 0 <= (sbits32) aSig );\r
+    sigMean = aSig + alternateASig;\r
+    if ( ( sigMean < 0 ) || ( ( sigMean == 0 ) && ( q & 1 ) ) ) {\r
+        aSig = alternateASig;\r
+    }\r
+    zSign = ( (sbits32) aSig < 0 );\r
+    if ( zSign ) aSig = - aSig;\r
+    return normalizeRoundAndPackFloat32( sf, aSign ^ zSign, bExp, aSig );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the square root of the single-precision floating-point value `a'.\r
+| The operation is performed according to the IEC/IEEE Standard for Binary\r
+| Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float32 float32_sqrt( softfloat_t* sf, float32 a )\r
+{\r
+    flag aSign;\r
+    int16_t aExp, zExp;\r
+    bits32 aSig, zSig;\r
+    bits64 rem, term;\r
+\r
+    aSig = extractFloat32Frac( a );\r
+    aExp = extractFloat32Exp( a );\r
+    aSign = extractFloat32Sign( a );\r
+    if ( aExp == 0xFF ) {\r
+        if ( aSig ) return propagateFloat32NaN( sf, a, 0 );\r
+        if ( ! aSign ) return a;\r
+        float_raise( sf, float_flag_invalid );\r
+        return float32_default_nan;\r
+    }\r
+    if ( aSign ) {\r
+        if ( ( aExp | aSig ) == 0 ) return a;\r
+        float_raise( sf, float_flag_invalid );\r
+        return float32_default_nan;\r
+    }\r
+    if ( aExp == 0 ) {\r
+        if ( aSig == 0 ) return 0;\r
+        normalizeFloat32Subnormal( aSig, &aExp, &aSig );\r
+    }\r
+    zExp = ( ( aExp - 0x7F )>>1 ) + 0x7E;\r
+    aSig = ( aSig | 0x00800000 )<<8;\r
+    zSig = estimateSqrt32( aExp, aSig ) + 2;\r
+    if ( ( zSig & 0x7F ) <= 5 ) {\r
+        if ( zSig < 2 ) {\r
+            zSig = 0x7FFFFFFF;\r
+            goto roundAndPack;\r
+        }\r
+        aSig >>= aExp & 1;\r
+        term = ( (bits64) zSig ) * zSig;\r
+        rem = ( ( (bits64) aSig )<<32 ) - term;\r
+        while ( (sbits64) rem < 0 ) {\r
+            --zSig;\r
+            rem += ( ( (bits64) zSig )<<1 ) | 1;\r
+        }\r
+        zSig |= ( rem != 0 );\r
+    }\r
+    shift32RightJamming( zSig, 1, &zSig );\r
+ roundAndPack:\r
+    return roundAndPackFloat32( sf, 0, zExp, zSig );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns 1 if the single-precision floating-point value `a' is equal to\r
+| the corresponding value `b', and 0 otherwise.  The comparison is performed\r
+| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+flag float32_eq( softfloat_t* sf, float32 a, float32 b )\r
+{\r
+\r
+    if (    ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) )\r
+         || ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) )\r
+       ) {\r
+        if ( float32_is_signaling_nan( sf, a ) || float32_is_signaling_nan( sf, b ) ) {\r
+            float_raise( sf, float_flag_invalid );\r
+        }\r
+        return 0;\r
+    }\r
+    return ( a == b ) || ( (bits32) ( ( a | b )<<1 ) == 0 );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns 1 if the single-precision floating-point value `a' is less than\r
+| or equal to the corresponding value `b', and 0 otherwise.  The comparison\r
+| is performed according to the IEC/IEEE Standard for Binary Floating-Point\r
+| Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+flag float32_le( softfloat_t* sf, float32 a, float32 b )\r
+{\r
+    flag aSign, bSign;\r
+\r
+    if (    ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) )\r
+         || ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) )\r
+       ) {\r
+        float_raise( sf, float_flag_invalid );\r
+        return 0;\r
+    }\r
+    aSign = extractFloat32Sign( a );\r
+    bSign = extractFloat32Sign( b );\r
+    if ( aSign != bSign ) return aSign || ( (bits32) ( ( a | b )<<1 ) == 0 );\r
+    return ( a == b ) || ( aSign ^ ( a < b ) );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns 1 if the single-precision floating-point value `a' is less than\r
+| the corresponding value `b', and 0 otherwise.  The comparison is performed\r
+| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+flag float32_lt( softfloat_t* sf, float32 a, float32 b )\r
+{\r
+    flag aSign, bSign;\r
+\r
+    if (    ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) )\r
+         || ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) )\r
+       ) {\r
+        float_raise( sf, float_flag_invalid );\r
+        return 0;\r
+    }\r
+    aSign = extractFloat32Sign( a );\r
+    bSign = extractFloat32Sign( b );\r
+    if ( aSign != bSign ) return aSign && ( (bits32) ( ( a | b )<<1 ) != 0 );\r
+    return ( a != b ) && ( aSign ^ ( a < b ) );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns 1 if the single-precision floating-point value `a' is equal to\r
+| the corresponding value `b', and 0 otherwise.  The invalid exception is\r
+| raised if either operand is a NaN.  Otherwise, the comparison is performed\r
+| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+flag float32_eq_signaling( softfloat_t* sf, float32 a, float32 b )\r
+{\r
+\r
+    if (    ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) )\r
+         || ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) )\r
+       ) {\r
+        float_raise( sf, float_flag_invalid );\r
+        return 0;\r
+    }\r
+    return ( a == b ) || ( (bits32) ( ( a | b )<<1 ) == 0 );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns 1 if the single-precision floating-point value `a' is less than or\r
+| equal to the corresponding value `b', and 0 otherwise.  Quiet NaNs do not\r
+| cause an exception.  Otherwise, the comparison is performed according to the\r
+| IEC/IEEE Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+flag float32_le_quiet( softfloat_t* sf, float32 a, float32 b )\r
+{\r
+    flag aSign, bSign;\r
+    int16_t aExp, bExp;\r
+\r
+    if (    ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) )\r
+         || ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) )\r
+       ) {\r
+        if ( float32_is_signaling_nan( sf, a ) || float32_is_signaling_nan( sf, b ) ) {\r
+            float_raise( sf, float_flag_invalid );\r
+        }\r
+        return 0;\r
+    }\r
+    aSign = extractFloat32Sign( a );\r
+    bSign = extractFloat32Sign( b );\r
+    if ( aSign != bSign ) return aSign || ( (bits32) ( ( a | b )<<1 ) == 0 );\r
+    return ( a == b ) || ( aSign ^ ( a < b ) );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns 1 if the single-precision floating-point value `a' is less than\r
+| the corresponding value `b', and 0 otherwise.  Quiet NaNs do not cause an\r
+| exception.  Otherwise, the comparison is performed according to the IEC/IEEE\r
+| Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+flag float32_lt_quiet( softfloat_t* sf, float32 a, float32 b )\r
+{\r
+    flag aSign, bSign;\r
+\r
+    if (    ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) )\r
+         || ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) )\r
+       ) {\r
+        if ( float32_is_signaling_nan( sf, a ) || float32_is_signaling_nan( sf, b ) ) {\r
+            float_raise( sf, float_flag_invalid );\r
+        }\r
+        return 0;\r
+    }\r
+    aSign = extractFloat32Sign( a );\r
+    bSign = extractFloat32Sign( b );\r
+    if ( aSign != bSign ) return aSign && ( (bits32) ( ( a | b )<<1 ) != 0 );\r
+    return ( a != b ) && ( aSign ^ ( a < b ) );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the double-precision floating-point value\r
+| `a' to the 32-bit two's complement integer format.  The conversion is\r
+| performed according to the IEC/IEEE Standard for Binary Floating-Point\r
+| Arithmetic---which means in particular that the conversion is rounded\r
+| according to the current rounding mode.  If `a' is a NaN, the largest\r
+| positive integer is returned.  Otherwise, if the conversion overflows, the\r
+| largest integer with the same sign as `a' is returned.\r
+*----------------------------------------------------------------------------*/\r
+\r
+int32_t float64_to_int32( softfloat_t* sf, float64 a )\r
+{\r
+    flag aSign;\r
+    int16_t aExp, shiftCount;\r
+    bits64 aSig;\r
+\r
+    aSig = extractFloat64Frac( a );\r
+    aExp = extractFloat64Exp( a );\r
+    aSign = extractFloat64Sign( a );\r
+    if ( ( aExp == 0x7FF ) && aSig ) aSign = 0;\r
+    if ( aExp ) aSig |= LIT64( 0x0010000000000000 );\r
+    shiftCount = 0x42C - aExp;\r
+    if ( 0 < shiftCount ) shift64RightJamming( aSig, shiftCount, &aSig );\r
+    return roundAndPackInt32( sf, aSign, aSig );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the double-precision floating-point value\r
+| `a' to the 32-bit two's complement integer format.  The conversion is\r
+| performed according to the IEC/IEEE Standard for Binary Floating-Point\r
+| Arithmetic, except that the conversion is always rounded toward zero.\r
+| If `a' is a NaN, the largest positive integer is returned.  Otherwise, if\r
+| the conversion overflows, the largest integer with the same sign as `a' is\r
+| returned.\r
+*----------------------------------------------------------------------------*/\r
+\r
+int32_t float64_to_int32_round_to_zero( softfloat_t* sf, float64 a )\r
+{\r
+    flag aSign;\r
+    int16_t aExp, shiftCount;\r
+    bits64 aSig, savedASig;\r
+    int32_t z;\r
+\r
+    aSig = extractFloat64Frac( a );\r
+    aExp = extractFloat64Exp( a );\r
+    aSign = extractFloat64Sign( a );\r
+    if ( 0x41E < aExp ) {\r
+        if ( ( aExp == 0x7FF ) && aSig ) aSign = 0;\r
+        goto invalid;\r
+    }\r
+    else if ( aExp < 0x3FF ) {\r
+        if ( aExp || aSig ) sf->float_exception_flags |= float_flag_inexact;\r
+        return 0;\r
+    }\r
+    aSig |= LIT64( 0x0010000000000000 );\r
+    shiftCount = 0x433 - aExp;\r
+    savedASig = aSig;\r
+    aSig >>= shiftCount;\r
+    z = aSig;\r
+    if ( aSign ) z = - z;\r
+    if ( ( z < 0 ) ^ aSign ) {\r
+ invalid:\r
+        float_raise( sf, float_flag_invalid );\r
+        return aSign ? (sbits32) 0x80000000 : 0x7FFFFFFF;\r
+    }\r
+    if ( ( aSig<<shiftCount ) != savedASig ) {\r
+        sf->float_exception_flags |= float_flag_inexact;\r
+    }\r
+    return z;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the double-precision floating-point value\r
+| `a' to the 64-bit two's complement integer format.  The conversion is\r
+| performed according to the IEC/IEEE Standard for Binary Floating-Point\r
+| Arithmetic---which means in particular that the conversion is rounded\r
+| according to the current rounding mode.  If `a' is a NaN, the largest\r
+| positive integer is returned.  Otherwise, if the conversion overflows, the\r
+| largest integer with the same sign as `a' is returned.\r
+*----------------------------------------------------------------------------*/\r
+\r
+int64_t float64_to_int64( softfloat_t* sf, float64 a )\r
+{\r
+    flag aSign;\r
+    int16_t aExp, shiftCount;\r
+    bits64 aSig, aSigExtra;\r
+\r
+    aSig = extractFloat64Frac( a );\r
+    aExp = extractFloat64Exp( a );\r
+    aSign = extractFloat64Sign( a );\r
+    if ( aExp ) aSig |= LIT64( 0x0010000000000000 );\r
+    shiftCount = 0x433 - aExp;\r
+    if ( shiftCount <= 0 ) {\r
+        if ( 0x43E < aExp ) {\r
+            float_raise( sf, float_flag_invalid );\r
+            if (    ! aSign\r
+                 || (    ( aExp == 0x7FF )\r
+                      && ( aSig != LIT64( 0x0010000000000000 ) ) )\r
+               ) {\r
+                return LIT64( 0x7FFFFFFFFFFFFFFF );\r
+            }\r
+            return (sbits64) LIT64( 0x8000000000000000 );\r
+        }\r
+        aSigExtra = 0;\r
+        aSig <<= - shiftCount;\r
+    }\r
+    else {\r
+        shift64ExtraRightJamming( aSig, 0, shiftCount, &aSig, &aSigExtra );\r
+    }\r
+    return roundAndPackInt64( sf, aSign, aSig, aSigExtra );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the double-precision floating-point value\r
+| `a' to the 64-bit two's complement integer format.  The conversion is\r
+| performed according to the IEC/IEEE Standard for Binary Floating-Point\r
+| Arithmetic, except that the conversion is always rounded toward zero.\r
+| If `a' is a NaN, the largest positive integer is returned.  Otherwise, if\r
+| the conversion overflows, the largest integer with the same sign as `a' is\r
+| returned.\r
+*----------------------------------------------------------------------------*/\r
+\r
+int64_t float64_to_int64_round_to_zero( softfloat_t* sf, float64 a )\r
+{\r
+    flag aSign;\r
+    int16_t aExp, shiftCount;\r
+    bits64 aSig;\r
+    int64_t z;\r
+\r
+    aSig = extractFloat64Frac( a );\r
+    aExp = extractFloat64Exp( a );\r
+    aSign = extractFloat64Sign( a );\r
+    if ( aExp ) aSig |= LIT64( 0x0010000000000000 );\r
+    shiftCount = aExp - 0x433;\r
+    if ( 0 <= shiftCount ) {\r
+        if ( 0x43E <= aExp ) {\r
+            if ( a != LIT64( 0xC3E0000000000000 ) ) {\r
+                float_raise( sf, float_flag_invalid );\r
+                if (    ! aSign\r
+                     || (    ( aExp == 0x7FF )\r
+                          && ( aSig != LIT64( 0x0010000000000000 ) ) )\r
+                   ) {\r
+                    return LIT64( 0x7FFFFFFFFFFFFFFF );\r
+                }\r
+            }\r
+            return (sbits64) LIT64( 0x8000000000000000 );\r
+        }\r
+        z = aSig<<shiftCount;\r
+    }\r
+    else {\r
+        if ( aExp < 0x3FE ) {\r
+            if ( aExp | aSig ) sf->float_exception_flags |= float_flag_inexact;\r
+            return 0;\r
+        }\r
+        z = aSig>>( - shiftCount );\r
+        if ( (bits64) ( aSig<<( shiftCount & 63 ) ) ) {\r
+            sf->float_exception_flags |= float_flag_inexact;\r
+        }\r
+    }\r
+    if ( aSign ) z = - z;\r
+    return z;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the double-precision floating-point value\r
+| `a' to the single-precision floating-point format.  The conversion is\r
+| performed according to the IEC/IEEE Standard for Binary Floating-Point\r
+| Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float32 float64_to_float32( softfloat_t* sf, float64 a )\r
+{\r
+    flag aSign;\r
+    int16_t aExp;\r
+    bits64 aSig;\r
+    bits32 zSig;\r
+\r
+    aSig = extractFloat64Frac( a );\r
+    aExp = extractFloat64Exp( a );\r
+    aSign = extractFloat64Sign( a );\r
+    if ( aExp == 0x7FF ) {\r
+        if ( aSig ) return commonNaNToFloat32( sf, float64ToCommonNaN( sf, a ) );\r
+        return packFloat32( aSign, 0xFF, 0 );\r
+    }\r
+    shift64RightJamming( aSig, 22, &aSig );\r
+    zSig = aSig;\r
+    if ( aExp || zSig ) {\r
+        zSig |= 0x40000000;\r
+        aExp -= 0x381;\r
+    }\r
+    return roundAndPackFloat32( sf, aSign, aExp, zSig );\r
+\r
+}\r
+\r
+#ifdef FLOATX80\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the double-precision floating-point value\r
+| `a' to the extended double-precision floating-point format.  The conversion\r
+| is performed according to the IEC/IEEE Standard for Binary Floating-Point\r
+| Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+floatx80 float64_to_floatx80( softfloat_t* sf, float64 a )\r
+{\r
+    flag aSign;\r
+    int16_t aExp;\r
+    bits64 aSig;\r
+\r
+    aSig = extractFloat64Frac( a );\r
+    aExp = extractFloat64Exp( a );\r
+    aSign = extractFloat64Sign( a );\r
+    if ( aExp == 0x7FF ) {\r
+        if ( aSig ) return commonNaNToFloatx80( sf, float64ToCommonNaN( sf, a ) );\r
+        return packFloatx80( aSign, 0x7FFF, LIT64( 0x8000000000000000 ) );\r
+    }\r
+    if ( aExp == 0 ) {\r
+        if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );\r
+        normalizeFloat64Subnormal( aSig, &aExp, &aSig );\r
+    }\r
+    return\r
+        packFloatx80(\r
+            aSign, aExp + 0x3C00, ( aSig | LIT64( 0x0010000000000000 ) )<<11 );\r
+\r
+}\r
+\r
+#endif\r
+\r
+#ifdef FLOAT128\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the double-precision floating-point value\r
+| `a' to the quadruple-precision floating-point format.  The conversion is\r
+| performed according to the IEC/IEEE Standard for Binary Floating-Point\r
+| Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float128 float64_to_float128( softfloat_t* sf, float64 a )\r
+{\r
+    flag aSign;\r
+    int16_t aExp;\r
+    bits64 aSig, zSig0, zSig1;\r
+\r
+    aSig = extractFloat64Frac( a );\r
+    aExp = extractFloat64Exp( a );\r
+    aSign = extractFloat64Sign( a );\r
+    if ( aExp == 0x7FF ) {\r
+        if ( aSig ) return commonNaNToFloat128( sf, float64ToCommonNaN( sf, a ) );\r
+        return packFloat128( aSign, 0x7FFF, 0, 0 );\r
+    }\r
+    if ( aExp == 0 ) {\r
+        if ( aSig == 0 ) return packFloat128( aSign, 0, 0, 0 );\r
+        normalizeFloat64Subnormal( aSig, &aExp, &aSig );\r
+        --aExp;\r
+    }\r
+    shift128Right( aSig, 0, 4, &zSig0, &zSig1 );\r
+    return packFloat128( aSign, aExp + 0x3C00, zSig0, zSig1 );\r
+\r
+}\r
+\r
+#endif\r
+\r
+/*----------------------------------------------------------------------------\r
+| Rounds the double-precision floating-point value `a' to an integer, and\r
+| returns the result as a double-precision floating-point value.  The\r
+| operation is performed according to the IEC/IEEE Standard for Binary\r
+| Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float64 float64_round_to_int( softfloat_t* sf, float64 a )\r
+{\r
+    flag aSign;\r
+    int16_t aExp;\r
+    bits64 lastBitMask, roundBitsMask;\r
+    int8_t roundingMode;\r
+    float64 z;\r
+\r
+    aExp = extractFloat64Exp( a );\r
+    if ( 0x433 <= aExp ) {\r
+        if ( ( aExp == 0x7FF ) && extractFloat64Frac( a ) ) {\r
+            return propagateFloat64NaN( sf, a, a );\r
+        }\r
+        return a;\r
+    }\r
+    if ( aExp < 0x3FF ) {\r
+        if ( (bits64) ( a<<1 ) == 0 ) return a;\r
+        sf->float_exception_flags |= float_flag_inexact;\r
+        aSign = extractFloat64Sign( a );\r
+        switch ( sf->float_rounding_mode ) {\r
+         case float_round_nearest_even:\r
+            if ( ( aExp == 0x3FE ) && extractFloat64Frac( a ) ) {\r
+                return packFloat64( aSign, 0x3FF, 0 );\r
+            }\r
+            break;\r
+         case float_round_down:\r
+            return aSign ? LIT64( 0xBFF0000000000000 ) : 0;\r
+         case float_round_up:\r
+            return\r
+            aSign ? LIT64( 0x8000000000000000 ) : LIT64( 0x3FF0000000000000 );\r
+        }\r
+        return packFloat64( aSign, 0, 0 );\r
+    }\r
+    lastBitMask = 1;\r
+    lastBitMask <<= 0x433 - aExp;\r
+    roundBitsMask = lastBitMask - 1;\r
+    z = a;\r
+    roundingMode = sf->float_rounding_mode;\r
+    if ( roundingMode == float_round_nearest_even ) {\r
+        z += lastBitMask>>1;\r
+        if ( ( z & roundBitsMask ) == 0 ) z &= ~ lastBitMask;\r
+    }\r
+    else if ( roundingMode != float_round_to_zero ) {\r
+        if ( extractFloat64Sign( z ) ^ ( roundingMode == float_round_up ) ) {\r
+            z += roundBitsMask;\r
+        }\r
+    }\r
+    z &= ~ roundBitsMask;\r
+    if ( z != a ) sf->float_exception_flags |= float_flag_inexact;\r
+    return z;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of adding the absolute values of the double-precision\r
+| floating-point values `a' and `b'.  If `zSign' is 1, the sum is negated\r
+| before being returned.  `zSign' is ignored if the result is a NaN.\r
+| The addition is performed according to the IEC/IEEE Standard for Binary\r
+| Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float64 addFloat64Sigs( softfloat_t* sf, float64 a, float64 b, flag zSign )\r
+{\r
+    int16_t aExp, bExp, zExp;\r
+    bits64 aSig, bSig, zSig;\r
+    int16_t expDiff;\r
+\r
+    aSig = extractFloat64Frac( a );\r
+    aExp = extractFloat64Exp( a );\r
+    bSig = extractFloat64Frac( b );\r
+    bExp = extractFloat64Exp( b );\r
+    expDiff = aExp - bExp;\r
+    aSig <<= 9;\r
+    bSig <<= 9;\r
+    if ( 0 < expDiff ) {\r
+        if ( aExp == 0x7FF ) {\r
+            if ( aSig ) return propagateFloat64NaN( sf, a, b );\r
+            return a;\r
+        }\r
+        if ( bExp == 0 ) {\r
+            --expDiff;\r
+        }\r
+        else {\r
+            bSig |= LIT64( 0x2000000000000000 );\r
+        }\r
+        shift64RightJamming( bSig, expDiff, &bSig );\r
+        zExp = aExp;\r
+    }\r
+    else if ( expDiff < 0 ) {\r
+        if ( bExp == 0x7FF ) {\r
+            if ( bSig ) return propagateFloat64NaN( sf, a, b );\r
+            return packFloat64( zSign, 0x7FF, 0 );\r
+        }\r
+        if ( aExp == 0 ) {\r
+            ++expDiff;\r
+        }\r
+        else {\r
+            aSig |= LIT64( 0x2000000000000000 );\r
+        }\r
+        shift64RightJamming( aSig, - expDiff, &aSig );\r
+        zExp = bExp;\r
+    }\r
+    else {\r
+        if ( aExp == 0x7FF ) {\r
+            if ( aSig | bSig ) return propagateFloat64NaN( sf, a, b );\r
+            return a;\r
+        }\r
+        if ( aExp == 0 ) return packFloat64( zSign, 0, ( aSig + bSig )>>9 );\r
+        zSig = LIT64( 0x4000000000000000 ) + aSig + bSig;\r
+        zExp = aExp;\r
+        goto roundAndPack;\r
+    }\r
+    aSig |= LIT64( 0x2000000000000000 );\r
+    zSig = ( aSig + bSig )<<1;\r
+    --zExp;\r
+    if ( (sbits64) zSig < 0 ) {\r
+        zSig = aSig + bSig;\r
+        ++zExp;\r
+    }\r
+ roundAndPack:\r
+    return roundAndPackFloat64( sf, zSign, zExp, zSig );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of subtracting the absolute values of the double-\r
+| precision floating-point values `a' and `b'.  If `zSign' is 1, the\r
+| difference is negated before being returned.  `zSign' is ignored if the\r
+| result is a NaN.  The subtraction is performed according to the IEC/IEEE\r
+| Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float64 subFloat64Sigs( softfloat_t* sf, float64 a, float64 b, flag zSign )\r
+{\r
+    int16_t aExp, bExp, zExp;\r
+    bits64 aSig, bSig, zSig;\r
+    int16_t expDiff;\r
+\r
+    aSig = extractFloat64Frac( a );\r
+    aExp = extractFloat64Exp( a );\r
+    bSig = extractFloat64Frac( b );\r
+    bExp = extractFloat64Exp( b );\r
+    expDiff = aExp - bExp;\r
+    aSig <<= 10;\r
+    bSig <<= 10;\r
+    if ( 0 < expDiff ) goto aExpBigger;\r
+    if ( expDiff < 0 ) goto bExpBigger;\r
+    if ( aExp == 0x7FF ) {\r
+        if ( aSig | bSig ) return propagateFloat64NaN( sf, a, b );\r
+        float_raise( sf, float_flag_invalid );\r
+        return float64_default_nan;\r
+    }\r
+    if ( aExp == 0 ) {\r
+        aExp = 1;\r
+        bExp = 1;\r
+    }\r
+    if ( bSig < aSig ) goto aBigger;\r
+    if ( aSig < bSig ) goto bBigger;\r
+    return packFloat64( sf->float_rounding_mode == float_round_down, 0, 0 );\r
+ bExpBigger:\r
+    if ( bExp == 0x7FF ) {\r
+        if ( bSig ) return propagateFloat64NaN( sf, a, b );\r
+        return packFloat64( zSign ^ 1, 0x7FF, 0 );\r
+    }\r
+    if ( aExp == 0 ) {\r
+        ++expDiff;\r
+    }\r
+    else {\r
+        aSig |= LIT64( 0x4000000000000000 );\r
+    }\r
+    shift64RightJamming( aSig, - expDiff, &aSig );\r
+    bSig |= LIT64( 0x4000000000000000 );\r
+ bBigger:\r
+    zSig = bSig - aSig;\r
+    zExp = bExp;\r
+    zSign ^= 1;\r
+    goto normalizeRoundAndPack;\r
+ aExpBigger:\r
+    if ( aExp == 0x7FF ) {\r
+        if ( aSig ) return propagateFloat64NaN( sf, a, b );\r
+        return a;\r
+    }\r
+    if ( bExp == 0 ) {\r
+        --expDiff;\r
+    }\r
+    else {\r
+        bSig |= LIT64( 0x4000000000000000 );\r
+    }\r
+    shift64RightJamming( bSig, expDiff, &bSig );\r
+    aSig |= LIT64( 0x4000000000000000 );\r
+ aBigger:\r
+    zSig = aSig - bSig;\r
+    zExp = aExp;\r
+ normalizeRoundAndPack:\r
+    --zExp;\r
+    return normalizeRoundAndPackFloat64( sf, zSign, zExp, zSig );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of adding the double-precision floating-point values `a'\r
+| and `b'.  The operation is performed according to the IEC/IEEE Standard for\r
+| Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float64 float64_add( softfloat_t* sf, float64 a, float64 b )\r
+{\r
+    flag aSign, bSign;\r
+\r
+    aSign = extractFloat64Sign( a );\r
+    bSign = extractFloat64Sign( b );\r
+    if ( aSign == bSign ) {\r
+        return addFloat64Sigs( sf, a, b, aSign );\r
+    }\r
+    else {\r
+        return subFloat64Sigs( sf, a, b, aSign );\r
+    }\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of subtracting the double-precision floating-point values\r
+| `a' and `b'.  The operation is performed according to the IEC/IEEE Standard\r
+| for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float64 float64_sub( softfloat_t* sf, float64 a, float64 b )\r
+{\r
+    flag aSign, bSign;\r
+\r
+    aSign = extractFloat64Sign( a );\r
+    bSign = extractFloat64Sign( b );\r
+    if ( aSign == bSign ) {\r
+        return subFloat64Sigs( sf, a, b, aSign );\r
+    }\r
+    else {\r
+        return addFloat64Sigs( sf, a, b, aSign );\r
+    }\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of multiplying the double-precision floating-point values\r
+| `a' and `b'.  The operation is performed according to the IEC/IEEE Standard\r
+| for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float64 float64_mul( softfloat_t* sf, float64 a, float64 b )\r
+{\r
+    flag aSign, bSign, zSign;\r
+    int16_t aExp, bExp, zExp;\r
+    bits64 aSig, bSig, zSig0, zSig1;\r
+\r
+    aSig = extractFloat64Frac( a );\r
+    aExp = extractFloat64Exp( a );\r
+    aSign = extractFloat64Sign( a );\r
+    bSig = extractFloat64Frac( b );\r
+    bExp = extractFloat64Exp( b );\r
+    bSign = extractFloat64Sign( b );\r
+    zSign = aSign ^ bSign;\r
+    if ( aExp == 0x7FF ) {\r
+        if ( aSig || ( ( bExp == 0x7FF ) && bSig ) ) {\r
+            return propagateFloat64NaN( sf, a, b );\r
+        }\r
+        if ( ( bExp | bSig ) == 0 ) {\r
+            float_raise( sf, float_flag_invalid );\r
+            return float64_default_nan;\r
+        }\r
+        return packFloat64( zSign, 0x7FF, 0 );\r
+    }\r
+    if ( bExp == 0x7FF ) {\r
+        if ( bSig ) return propagateFloat64NaN( sf, a, b );\r
+        if ( ( aExp | aSig ) == 0 ) {\r
+            float_raise( sf, float_flag_invalid );\r
+            return float64_default_nan;\r
+        }\r
+        return packFloat64( zSign, 0x7FF, 0 );\r
+    }\r
+    if ( aExp == 0 ) {\r
+        if ( aSig == 0 ) return packFloat64( zSign, 0, 0 );\r
+        normalizeFloat64Subnormal( aSig, &aExp, &aSig );\r
+    }\r
+    if ( bExp == 0 ) {\r
+        if ( bSig == 0 ) return packFloat64( zSign, 0, 0 );\r
+        normalizeFloat64Subnormal( bSig, &bExp, &bSig );\r
+    }\r
+    zExp = aExp + bExp - 0x3FF;\r
+    aSig = ( aSig | LIT64( 0x0010000000000000 ) )<<10;\r
+    bSig = ( bSig | LIT64( 0x0010000000000000 ) )<<11;\r
+    mul64To128( aSig, bSig, &zSig0, &zSig1 );\r
+    zSig0 |= ( zSig1 != 0 );\r
+    if ( 0 <= (sbits64) ( zSig0<<1 ) ) {\r
+        zSig0 <<= 1;\r
+        --zExp;\r
+    }\r
+\r
+    return roundAndPackFloat64( sf, zSign, zExp, zSig0 );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of dividing the double-precision floating-point value `a'\r
+| by the corresponding value `b'.  The operation is performed according to\r
+| the IEC/IEEE Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float64 float64_div( softfloat_t* sf, float64 a, float64 b )\r
+{\r
+    flag aSign, bSign, zSign;\r
+    int16_t aExp, bExp, zExp;\r
+    bits64 aSig, bSig, zSig;\r
+    bits64 rem0, rem1;\r
+    bits64 term0, term1;\r
+\r
+    aSig = extractFloat64Frac( a );\r
+    aExp = extractFloat64Exp( a );\r
+    aSign = extractFloat64Sign( a );\r
+    bSig = extractFloat64Frac( b );\r
+    bExp = extractFloat64Exp( b );\r
+    bSign = extractFloat64Sign( b );\r
+    zSign = aSign ^ bSign;\r
+    if ( aExp == 0x7FF ) {\r
+        if ( aSig ) return propagateFloat64NaN( sf, a, b );\r
+        if ( bExp == 0x7FF ) {\r
+            if ( bSig ) return propagateFloat64NaN( sf, a, b );\r
+            float_raise( sf, float_flag_invalid );\r
+            return float64_default_nan;\r
+        }\r
+        return packFloat64( zSign, 0x7FF, 0 );\r
+    }\r
+    if ( bExp == 0x7FF ) {\r
+        if ( bSig ) return propagateFloat64NaN( sf, a, b );\r
+        return packFloat64( zSign, 0, 0 );\r
+    }\r
+    if ( bExp == 0 ) {\r
+        if ( bSig == 0 ) {\r
+            if ( ( aExp | aSig ) == 0 ) {\r
+                float_raise( sf, float_flag_invalid );\r
+                return float64_default_nan;\r
+            }\r
+            float_raise( sf, float_flag_divbyzero );\r
+            return packFloat64( zSign, 0x7FF, 0 );\r
+        }\r
+        normalizeFloat64Subnormal( bSig, &bExp, &bSig );\r
+    }\r
+    if ( aExp == 0 ) {\r
+        if ( aSig == 0 ) return packFloat64( zSign, 0, 0 );\r
+        normalizeFloat64Subnormal( aSig, &aExp, &aSig );\r
+    }\r
+    zExp = aExp - bExp + 0x3FD;\r
+    aSig = ( aSig | LIT64( 0x0010000000000000 ) )<<10;\r
+    bSig = ( bSig | LIT64( 0x0010000000000000 ) )<<11;\r
+    if ( bSig <= ( aSig + aSig ) ) {\r
+        aSig >>= 1;\r
+        ++zExp;\r
+    }\r
+    zSig = estimateDiv128To64( aSig, 0, bSig );\r
+    if ( ( zSig & 0x1FF ) <= 2 ) {\r
+        mul64To128( bSig, zSig, &term0, &term1 );\r
+        sub128( aSig, 0, term0, term1, &rem0, &rem1 );\r
+        while ( (sbits64) rem0 < 0 ) {\r
+            --zSig;\r
+            add128( rem0, rem1, 0, bSig, &rem0, &rem1 );\r
+        }\r
+        zSig |= ( rem1 != 0 );\r
+    }\r
+    return roundAndPackFloat64( sf, zSign, zExp, zSig );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the remainder of the double-precision floating-point value `a'\r
+| with respect to the corresponding value `b'.  The operation is performed\r
+| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float64 float64_rem( softfloat_t* sf, float64 a, float64 b )\r
+{\r
+    flag aSign, bSign, zSign;\r
+    int16_t aExp, bExp, expDiff;\r
+    bits64 aSig, bSig;\r
+    bits64 q, alternateASig;\r
+    sbits64 sigMean;\r
+\r
+    aSig = extractFloat64Frac( a );\r
+    aExp = extractFloat64Exp( a );\r
+    aSign = extractFloat64Sign( a );\r
+    bSig = extractFloat64Frac( b );\r
+    bExp = extractFloat64Exp( b );\r
+    bSign = extractFloat64Sign( b );\r
+    if ( aExp == 0x7FF ) {\r
+        if ( aSig || ( ( bExp == 0x7FF ) && bSig ) ) {\r
+            return propagateFloat64NaN( sf, a, b );\r
+        }\r
+        float_raise( sf, float_flag_invalid );\r
+        return float64_default_nan;\r
+    }\r
+    if ( bExp == 0x7FF ) {\r
+        if ( bSig ) return propagateFloat64NaN( sf, a, b );\r
+        return a;\r
+    }\r
+    if ( bExp == 0 ) {\r
+        if ( bSig == 0 ) {\r
+            float_raise( sf, float_flag_invalid );\r
+            return float64_default_nan;\r
+        }\r
+        normalizeFloat64Subnormal( bSig, &bExp, &bSig );\r
+    }\r
+    if ( aExp == 0 ) {\r
+        if ( aSig == 0 ) return a;\r
+        normalizeFloat64Subnormal( aSig, &aExp, &aSig );\r
+    }\r
+    expDiff = aExp - bExp;\r
+    aSig = ( aSig | LIT64( 0x0010000000000000 ) )<<11;\r
+    bSig = ( bSig | LIT64( 0x0010000000000000 ) )<<11;\r
+    if ( expDiff < 0 ) {\r
+        if ( expDiff < -1 ) return a;\r
+        aSig >>= 1;\r
+    }\r
+    q = ( bSig <= aSig );\r
+    if ( q ) aSig -= bSig;\r
+    expDiff -= 64;\r
+    while ( 0 < expDiff ) {\r
+        q = estimateDiv128To64( aSig, 0, bSig );\r
+        q = ( 2 < q ) ? q - 2 : 0;\r
+        aSig = - ( ( bSig>>2 ) * q );\r
+        expDiff -= 62;\r
+    }\r
+    expDiff += 64;\r
+    if ( 0 < expDiff ) {\r
+        q = estimateDiv128To64( aSig, 0, bSig );\r
+        q = ( 2 < q ) ? q - 2 : 0;\r
+        q >>= 64 - expDiff;\r
+        bSig >>= 2;\r
+        aSig = ( ( aSig>>1 )<<( expDiff - 1 ) ) - bSig * q;\r
+    }\r
+    else {\r
+        aSig >>= 2;\r
+        bSig >>= 2;\r
+    }\r
+    do {\r
+        alternateASig = aSig;\r
+        ++q;\r
+        aSig -= bSig;\r
+    } while ( 0 <= (sbits64) aSig );\r
+    sigMean = aSig + alternateASig;\r
+    if ( ( sigMean < 0 ) || ( ( sigMean == 0 ) && ( q & 1 ) ) ) {\r
+        aSig = alternateASig;\r
+    }\r
+    zSign = ( (sbits64) aSig < 0 );\r
+    if ( zSign ) aSig = - aSig;\r
+    return normalizeRoundAndPackFloat64( sf, aSign ^ zSign, bExp, aSig );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the square root of the double-precision floating-point value `a'.\r
+| The operation is performed according to the IEC/IEEE Standard for Binary\r
+| Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float64 float64_sqrt( softfloat_t* sf, float64 a )\r
+{\r
+    flag aSign;\r
+    int16_t aExp, zExp;\r
+    bits64 aSig, zSig, doubleZSig;\r
+    bits64 rem0, rem1, term0, term1;\r
+    float64 z;\r
+\r
+    aSig = extractFloat64Frac( a );\r
+    aExp = extractFloat64Exp( a );\r
+    aSign = extractFloat64Sign( a );\r
+    if ( aExp == 0x7FF ) {\r
+        if ( aSig ) return propagateFloat64NaN( sf, a, a );\r
+        if ( ! aSign ) return a;\r
+        float_raise( sf, float_flag_invalid );\r
+        return float64_default_nan;\r
+    }\r
+    if ( aSign ) {\r
+        if ( ( aExp | aSig ) == 0 ) return a;\r
+        float_raise( sf, float_flag_invalid );\r
+        return float64_default_nan;\r
+    }\r
+    if ( aExp == 0 ) {\r
+        if ( aSig == 0 ) return 0;\r
+        normalizeFloat64Subnormal( aSig, &aExp, &aSig );\r
+    }\r
+    zExp = ( ( aExp - 0x3FF )>>1 ) + 0x3FE;\r
+    aSig |= LIT64( 0x0010000000000000 );\r
+    zSig = estimateSqrt32( aExp, aSig>>21 );\r
+    aSig <<= 9 - ( aExp & 1 );\r
+    zSig = estimateDiv128To64( aSig, 0, zSig<<32 ) + ( zSig<<30 );\r
+    if ( ( zSig & 0x1FF ) <= 5 ) {\r
+        doubleZSig = zSig<<1;\r
+        mul64To128( zSig, zSig, &term0, &term1 );\r
+        sub128( aSig, 0, term0, term1, &rem0, &rem1 );\r
+        while ( (sbits64) rem0 < 0 ) {\r
+            --zSig;\r
+            doubleZSig -= 2;\r
+            add128( rem0, rem1, zSig>>63, doubleZSig | 1, &rem0, &rem1 );\r
+        }\r
+        zSig |= ( ( rem0 | rem1 ) != 0 );\r
+    }\r
+    return roundAndPackFloat64( sf, 0, zExp, zSig );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns 1 if the double-precision floating-point value `a' is equal to the\r
+| corresponding value `b', and 0 otherwise.  The comparison is performed\r
+| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+flag float64_eq( softfloat_t* sf, float64 a, float64 b )\r
+{\r
+\r
+    if (    ( ( extractFloat64Exp( a ) == 0x7FF ) && extractFloat64Frac( a ) )\r
+         || ( ( extractFloat64Exp( b ) == 0x7FF ) && extractFloat64Frac( b ) )\r
+       ) {\r
+        if ( float64_is_signaling_nan( sf, a ) || float64_is_signaling_nan( sf, b ) ) {\r
+            float_raise( sf, float_flag_invalid );\r
+        }\r
+        return 0;\r
+    }\r
+    return ( a == b ) || ( (bits64) ( ( a | b )<<1 ) == 0 );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns 1 if the double-precision floating-point value `a' is less than or\r
+| equal to the corresponding value `b', and 0 otherwise.  The comparison is\r
+| performed according to the IEC/IEEE Standard for Binary Floating-Point\r
+| Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+flag float64_le( softfloat_t* sf, float64 a, float64 b )\r
+{\r
+    flag aSign, bSign;\r
+\r
+    if (    ( ( extractFloat64Exp( a ) == 0x7FF ) && extractFloat64Frac( a ) )\r
+         || ( ( extractFloat64Exp( b ) == 0x7FF ) && extractFloat64Frac( b ) )\r
+       ) {\r
+        float_raise( sf, float_flag_invalid );\r
+        return 0;\r
+    }\r
+    aSign = extractFloat64Sign( a );\r
+    bSign = extractFloat64Sign( b );\r
+    if ( aSign != bSign ) return aSign || ( (bits64) ( ( a | b )<<1 ) == 0 );\r
+    return ( a == b ) || ( aSign ^ ( a < b ) );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns 1 if the double-precision floating-point value `a' is less than\r
+| the corresponding value `b', and 0 otherwise.  The comparison is performed\r
+| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+flag float64_lt( softfloat_t* sf, float64 a, float64 b )\r
+{\r
+    flag aSign, bSign;\r
+\r
+    if (    ( ( extractFloat64Exp( a ) == 0x7FF ) && extractFloat64Frac( a ) )\r
+         || ( ( extractFloat64Exp( b ) == 0x7FF ) && extractFloat64Frac( b ) )\r
+       ) {\r
+        float_raise( sf, float_flag_invalid );\r
+        return 0;\r
+    }\r
+    aSign = extractFloat64Sign( a );\r
+    bSign = extractFloat64Sign( b );\r
+    if ( aSign != bSign ) return aSign && ( (bits64) ( ( a | b )<<1 ) != 0 );\r
+    return ( a != b ) && ( aSign ^ ( a < b ) );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns 1 if the double-precision floating-point value `a' is equal to the\r
+| corresponding value `b', and 0 otherwise.  The invalid exception is raised\r
+| if either operand is a NaN.  Otherwise, the comparison is performed\r
+| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+flag float64_eq_signaling( softfloat_t* sf, float64 a, float64 b )\r
+{\r
+\r
+    if (    ( ( extractFloat64Exp( a ) == 0x7FF ) && extractFloat64Frac( a ) )\r
+         || ( ( extractFloat64Exp( b ) == 0x7FF ) && extractFloat64Frac( b ) )\r
+       ) {\r
+        float_raise( sf, float_flag_invalid );\r
+        return 0;\r
+    }\r
+    return ( a == b ) || ( (bits64) ( ( a | b )<<1 ) == 0 );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns 1 if the double-precision floating-point value `a' is less than or\r
+| equal to the corresponding value `b', and 0 otherwise.  Quiet NaNs do not\r
+| cause an exception.  Otherwise, the comparison is performed according to the\r
+| IEC/IEEE Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+flag float64_le_quiet( softfloat_t* sf, float64 a, float64 b )\r
+{\r
+    flag aSign, bSign;\r
+    int16_t aExp, bExp;\r
+\r
+    if (    ( ( extractFloat64Exp( a ) == 0x7FF ) && extractFloat64Frac( a ) )\r
+         || ( ( extractFloat64Exp( b ) == 0x7FF ) && extractFloat64Frac( b ) )\r
+       ) {\r
+        if ( float64_is_signaling_nan( sf, a ) || float64_is_signaling_nan( sf, b ) ) {\r
+            float_raise( sf, float_flag_invalid );\r
+        }\r
+        return 0;\r
+    }\r
+    aSign = extractFloat64Sign( a );\r
+    bSign = extractFloat64Sign( b );\r
+    if ( aSign != bSign ) return aSign || ( (bits64) ( ( a | b )<<1 ) == 0 );\r
+    return ( a == b ) || ( aSign ^ ( a < b ) );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns 1 if the double-precision floating-point value `a' is less than\r
+| the corresponding value `b', and 0 otherwise.  Quiet NaNs do not cause an\r
+| exception.  Otherwise, the comparison is performed according to the IEC/IEEE\r
+| Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+flag float64_lt_quiet( softfloat_t* sf, float64 a, float64 b )\r
+{\r
+    flag aSign, bSign;\r
+\r
+    if (    ( ( extractFloat64Exp( a ) == 0x7FF ) && extractFloat64Frac( a ) )\r
+         || ( ( extractFloat64Exp( b ) == 0x7FF ) && extractFloat64Frac( b ) )\r
+       ) {\r
+        if ( float64_is_signaling_nan( sf, a ) || float64_is_signaling_nan( sf, b ) ) {\r
+            float_raise( sf, float_flag_invalid );\r
+        }\r
+        return 0;\r
+    }\r
+    aSign = extractFloat64Sign( a );\r
+    bSign = extractFloat64Sign( b );\r
+    if ( aSign != bSign ) return aSign && ( (bits64) ( ( a | b )<<1 ) != 0 );\r
+    return ( a != b ) && ( aSign ^ ( a < b ) );\r
+\r
+}\r
+\r
+#ifdef FLOATX80\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the extended double-precision floating-\r
+| point value `a' to the 32-bit two's complement integer format.  The\r
+| conversion is performed according to the IEC/IEEE Standard for Binary\r
+| Floating-Point Arithmetic---which means in particular that the conversion\r
+| is rounded according to the current rounding mode.  If `a' is a NaN, the\r
+| largest positive integer is returned.  Otherwise, if the conversion\r
+| overflows, the largest integer with the same sign as `a' is returned.\r
+*----------------------------------------------------------------------------*/\r
+\r
+int32_t floatx80_to_int32( softfloat_t* sf, floatx80 a )\r
+{\r
+    flag aSign;\r
+    int32_t aExp, shiftCount;\r
+    bits64 aSig;\r
+\r
+    aSig = extractFloatx80Frac( a );\r
+    aExp = extractFloatx80Exp( a );\r
+    aSign = extractFloatx80Sign( a );\r
+    if ( ( aExp == 0x7FFF ) && (bits64) ( aSig<<1 ) ) aSign = 0;\r
+    shiftCount = 0x4037 - aExp;\r
+    if ( shiftCount <= 0 ) shiftCount = 1;\r
+    shift64RightJamming( aSig, shiftCount, &aSig );\r
+    return roundAndPackInt32( sf, aSign, aSig );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the extended double-precision floating-\r
+| point value `a' to the 32-bit two's complement integer format.  The\r
+| conversion is performed according to the IEC/IEEE Standard for Binary\r
+| Floating-Point Arithmetic, except that the conversion is always rounded\r
+| toward zero.  If `a' is a NaN, the largest positive integer is returned.\r
+| Otherwise, if the conversion overflows, the largest integer with the same\r
+| sign as `a' is returned.\r
+*----------------------------------------------------------------------------*/\r
+\r
+int32_t floatx80_to_int32_round_to_zero( softfloat_t* sf, floatx80 a )\r
+{\r
+    flag aSign;\r
+    int32_t aExp, shiftCount;\r
+    bits64 aSig, savedASig;\r
+    int32_t z;\r
+\r
+    aSig = extractFloatx80Frac( a );\r
+    aExp = extractFloatx80Exp( a );\r
+    aSign = extractFloatx80Sign( a );\r
+    if ( 0x401E < aExp ) {\r
+        if ( ( aExp == 0x7FFF ) && (bits64) ( aSig<<1 ) ) aSign = 0;\r
+        goto invalid;\r
+    }\r
+    else if ( aExp < 0x3FFF ) {\r
+        if ( aExp || aSig ) sf->float_exception_flags |= float_flag_inexact;\r
+        return 0;\r
+    }\r
+    shiftCount = 0x403E - aExp;\r
+    savedASig = aSig;\r
+    aSig >>= shiftCount;\r
+    z = aSig;\r
+    if ( aSign ) z = - z;\r
+    if ( ( z < 0 ) ^ aSign ) {\r
+ invalid:\r
+        float_raise( sf, float_flag_invalid );\r
+        return aSign ? (sbits32) 0x80000000 : 0x7FFFFFFF;\r
+    }\r
+    if ( ( aSig<<shiftCount ) != savedASig ) {\r
+        sf->float_exception_flags |= float_flag_inexact;\r
+    }\r
+    return z;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the extended double-precision floating-\r
+| point value `a' to the 64-bit two's complement integer format.  The\r
+| conversion is performed according to the IEC/IEEE Standard for Binary\r
+| Floating-Point Arithmetic---which means in particular that the conversion\r
+| is rounded according to the current rounding mode.  If `a' is a NaN,\r
+| the largest positive integer is returned.  Otherwise, if the conversion\r
+| overflows, the largest integer with the same sign as `a' is returned.\r
+*----------------------------------------------------------------------------*/\r
+\r
+int64_t floatx80_to_int64( softfloat_t* sf, floatx80 a )\r
+{\r
+    flag aSign;\r
+    int32_t aExp, shiftCount;\r
+    bits64 aSig, aSigExtra;\r
+\r
+    aSig = extractFloatx80Frac( a );\r
+    aExp = extractFloatx80Exp( a );\r
+    aSign = extractFloatx80Sign( a );\r
+    shiftCount = 0x403E - aExp;\r
+    if ( shiftCount <= 0 ) {\r
+        if ( shiftCount ) {\r
+            float_raise( sf, float_flag_invalid );\r
+            if (    ! aSign\r
+                 || (    ( aExp == 0x7FFF )\r
+                      && ( aSig != LIT64( 0x8000000000000000 ) ) )\r
+               ) {\r
+                return LIT64( 0x7FFFFFFFFFFFFFFF );\r
+            }\r
+            return (sbits64) LIT64( 0x8000000000000000 );\r
+        }\r
+        aSigExtra = 0;\r
+    }\r
+    else {\r
+        shift64ExtraRightJamming( aSig, 0, shiftCount, &aSig, &aSigExtra );\r
+    }\r
+    return roundAndPackInt64( sf, aSign, aSig, aSigExtra );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the extended double-precision floating-\r
+| point value `a' to the 64-bit two's complement integer format.  The\r
+| conversion is performed according to the IEC/IEEE Standard for Binary\r
+| Floating-Point Arithmetic, except that the conversion is always rounded\r
+| toward zero.  If `a' is a NaN, the largest positive integer is returned.\r
+| Otherwise, if the conversion overflows, the largest integer with the same\r
+| sign as `a' is returned.\r
+*----------------------------------------------------------------------------*/\r
+\r
+int64_t floatx80_to_int64_round_to_zero( softfloat_t* sf, floatx80 a )\r
+{\r
+    flag aSign;\r
+    int32_t aExp, shiftCount;\r
+    bits64 aSig;\r
+    int64_t z;\r
+\r
+    aSig = extractFloatx80Frac( a );\r
+    aExp = extractFloatx80Exp( a );\r
+    aSign = extractFloatx80Sign( a );\r
+    shiftCount = aExp - 0x403E;\r
+    if ( 0 <= shiftCount ) {\r
+        aSig &= LIT64( 0x7FFFFFFFFFFFFFFF );\r
+        if ( ( a.high != 0xC03E ) || aSig ) {\r
+            float_raise( sf, float_flag_invalid );\r
+            if ( ! aSign || ( ( aExp == 0x7FFF ) && aSig ) ) {\r
+                return LIT64( 0x7FFFFFFFFFFFFFFF );\r
+            }\r
+        }\r
+        return (sbits64) LIT64( 0x8000000000000000 );\r
+    }\r
+    else if ( aExp < 0x3FFF ) {\r
+        if ( aExp | aSig ) sf->float_exception_flags |= float_flag_inexact;\r
+        return 0;\r
+    }\r
+    z = aSig>>( - shiftCount );\r
+    if ( (bits64) ( aSig<<( shiftCount & 63 ) ) ) {\r
+        sf->float_exception_flags |= float_flag_inexact;\r
+    }\r
+    if ( aSign ) z = - z;\r
+    return z;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the extended double-precision floating-\r
+| point value `a' to the single-precision floating-point format.  The\r
+| conversion is performed according to the IEC/IEEE Standard for Binary\r
+| Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float32 floatx80_to_float32( softfloat_t* sf, floatx80 a )\r
+{\r
+    flag aSign;\r
+    int32_t aExp;\r
+    bits64 aSig;\r
+\r
+    aSig = extractFloatx80Frac( a );\r
+    aExp = extractFloatx80Exp( a );\r
+    aSign = extractFloatx80Sign( a );\r
+    if ( aExp == 0x7FFF ) {\r
+        if ( (bits64) ( aSig<<1 ) ) {\r
+            return commonNaNToFloat32( sf, floatx80ToCommonNaN( sf, a ) );\r
+        }\r
+        return packFloat32( aSign, 0xFF, 0 );\r
+    }\r
+    shift64RightJamming( aSig, 33, &aSig );\r
+    if ( aExp || aSig ) aExp -= 0x3F81;\r
+    return roundAndPackFloat32( sf, aSign, aExp, aSig );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the extended double-precision floating-\r
+| point value `a' to the double-precision floating-point format.  The\r
+| conversion is performed according to the IEC/IEEE Standard for Binary\r
+| Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float64 floatx80_to_float64( softfloat_t* sf, floatx80 a )\r
+{\r
+    flag aSign;\r
+    int32_t aExp;\r
+    bits64 aSig, zSig;\r
+\r
+    aSig = extractFloatx80Frac( a );\r
+    aExp = extractFloatx80Exp( a );\r
+    aSign = extractFloatx80Sign( a );\r
+    if ( aExp == 0x7FFF ) {\r
+        if ( (bits64) ( aSig<<1 ) ) {\r
+            return commonNaNToFloat64( sf, floatx80ToCommonNaN( sf, a ) );\r
+        }\r
+        return packFloat64( aSign, 0x7FF, 0 );\r
+    }\r
+    shift64RightJamming( aSig, 1, &zSig );\r
+    if ( aExp || aSig ) aExp -= 0x3C01;\r
+    return roundAndPackFloat64( sf, aSign, aExp, zSig );\r
+\r
+}\r
+\r
+#ifdef FLOAT128\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the extended double-precision floating-\r
+| point value `a' to the quadruple-precision floating-point format.  The\r
+| conversion is performed according to the IEC/IEEE Standard for Binary\r
+| Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float128 floatx80_to_float128( softfloat_t* sf, floatx80 a )\r
+{\r
+    flag aSign;\r
+    int16_t aExp;\r
+    bits64 aSig, zSig0, zSig1;\r
+\r
+    aSig = extractFloatx80Frac( a );\r
+    aExp = extractFloatx80Exp( a );\r
+    aSign = extractFloatx80Sign( a );\r
+    if ( ( aExp == 0x7FFF ) && (bits64) ( aSig<<1 ) ) {\r
+        return commonNaNToFloat128( sf, floatx80ToCommonNaN( sf, a ) );\r
+    }\r
+    shift128Right( aSig<<1, 0, 16, &zSig0, &zSig1 );\r
+    return packFloat128( aSign, aExp, zSig0, zSig1 );\r
+\r
+}\r
+\r
+#endif\r
+\r
+/*----------------------------------------------------------------------------\r
+| Rounds the extended double-precision floating-point value `a' to an integer,\r
+| and returns the result as an extended quadruple-precision floating-point\r
+| value.  The operation is performed according to the IEC/IEEE Standard for\r
+| Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+floatx80 floatx80_round_to_int( softfloat_t* sf, floatx80 a )\r
+{\r
+    flag aSign;\r
+    int32_t aExp;\r
+    bits64 lastBitMask, roundBitsMask;\r
+    int8_t roundingMode;\r
+    floatx80 z;\r
+\r
+    aExp = extractFloatx80Exp( a );\r
+    if ( 0x403E <= aExp ) {\r
+        if ( ( aExp == 0x7FFF ) && (bits64) ( extractFloatx80Frac( a )<<1 ) ) {\r
+            return propagateFloatx80NaN( sf, a, a );\r
+        }\r
+        return a;\r
+    }\r
+    if ( aExp < 0x3FFF ) {\r
+        if (    ( aExp == 0 )\r
+             && ( (bits64) ( extractFloatx80Frac( a )<<1 ) == 0 ) ) {\r
+            return a;\r
+        }\r
+        sf->float_exception_flags |= float_flag_inexact;\r
+        aSign = extractFloatx80Sign( a );\r
+        switch ( sf->float_rounding_mode ) {\r
+         case float_round_nearest_even:\r
+            if ( ( aExp == 0x3FFE ) && (bits64) ( extractFloatx80Frac( a )<<1 )\r
+               ) {\r
+                return\r
+                    packFloatx80( aSign, 0x3FFF, LIT64( 0x8000000000000000 ) );\r
+            }\r
+            break;\r
+         case float_round_down:\r
+            return\r
+                  aSign ?\r
+                      packFloatx80( 1, 0x3FFF, LIT64( 0x8000000000000000 ) )\r
+                : packFloatx80( 0, 0, 0 );\r
+         case float_round_up:\r
+            return\r
+                  aSign ? packFloatx80( 1, 0, 0 )\r
+                : packFloatx80( 0, 0x3FFF, LIT64( 0x8000000000000000 ) );\r
+        }\r
+        return packFloatx80( aSign, 0, 0 );\r
+    }\r
+    lastBitMask = 1;\r
+    lastBitMask <<= 0x403E - aExp;\r
+    roundBitsMask = lastBitMask - 1;\r
+    z = a;\r
+    roundingMode = sf->float_rounding_mode;\r
+    if ( roundingMode == float_round_nearest_even ) {\r
+        z.low += lastBitMask>>1;\r
+        if ( ( z.low & roundBitsMask ) == 0 ) z.low &= ~ lastBitMask;\r
+    }\r
+    else if ( roundingMode != float_round_to_zero ) {\r
+        if ( extractFloatx80Sign( z ) ^ ( roundingMode == float_round_up ) ) {\r
+            z.low += roundBitsMask;\r
+        }\r
+    }\r
+    z.low &= ~ roundBitsMask;\r
+    if ( z.low == 0 ) {\r
+        ++z.high;\r
+        z.low = LIT64( 0x8000000000000000 );\r
+    }\r
+    if ( z.low != a.low ) sf->float_exception_flags |= float_flag_inexact;\r
+    return z;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of adding the absolute values of the extended double-\r
+| precision floating-point values `a' and `b'.  If `zSign' is 1, the sum is\r
+| negated before being returned.  `zSign' is ignored if the result is a NaN.\r
+| The addition is performed according to the IEC/IEEE Standard for Binary\r
+| Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+floatx80 addFloatx80Sigs( softfloat_t* sf, floatx80 a, floatx80 b, flag zSign )\r
+{\r
+    int32_t aExp, bExp, zExp;\r
+    bits64 aSig, bSig, zSig0, zSig1;\r
+    int32_t expDiff;\r
+\r
+    aSig = extractFloatx80Frac( a );\r
+    aExp = extractFloatx80Exp( a );\r
+    bSig = extractFloatx80Frac( b );\r
+    bExp = extractFloatx80Exp( b );\r
+    expDiff = aExp - bExp;\r
+    if ( 0 < expDiff ) {\r
+        if ( aExp == 0x7FFF ) {\r
+            if ( (bits64) ( aSig<<1 ) ) return propagateFloatx80NaN( sf, a, b );\r
+            return a;\r
+        }\r
+        if ( bExp == 0 ) --expDiff;\r
+        shift64ExtraRightJamming( bSig, 0, expDiff, &bSig, &zSig1 );\r
+        zExp = aExp;\r
+    }\r
+    else if ( expDiff < 0 ) {\r
+        if ( bExp == 0x7FFF ) {\r
+            if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( sf, a, b );\r
+            return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) );\r
+        }\r
+        if ( aExp == 0 ) ++expDiff;\r
+        shift64ExtraRightJamming( aSig, 0, - expDiff, &aSig, &zSig1 );\r
+        zExp = bExp;\r
+    }\r
+    else {\r
+        if ( aExp == 0x7FFF ) {\r
+            if ( (bits64) ( ( aSig | bSig )<<1 ) ) {\r
+                return propagateFloatx80NaN( sf, a, b );\r
+            }\r
+            return a;\r
+        }\r
+        zSig1 = 0;\r
+        zSig0 = aSig + bSig;\r
+        if ( aExp == 0 ) {\r
+            normalizeFloatx80Subnormal( zSig0, &zExp, &zSig0 );\r
+            goto roundAndPack;\r
+        }\r
+        zExp = aExp;\r
+        goto shiftRight1;\r
+    }\r
+    zSig0 = aSig + bSig;\r
+    if ( (sbits64) zSig0 < 0 ) goto roundAndPack;\r
+ shiftRight1:\r
+    shift64ExtraRightJamming( zSig0, zSig1, 1, &zSig0, &zSig1 );\r
+    zSig0 |= LIT64( 0x8000000000000000 );\r
+    ++zExp;\r
+ roundAndPack:\r
+    return\r
+        roundAndPackFloatx80( sf, \r
+            sf->floatx80_rounding_precision, zSign, zExp, zSig0, zSig1 );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of subtracting the absolute values of the extended\r
+| double-precision floating-point values `a' and `b'.  If `zSign' is 1, the\r
+| difference is negated before being returned.  `zSign' is ignored if the\r
+| result is a NaN.  The subtraction is performed according to the IEC/IEEE\r
+| Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+floatx80 subFloatx80Sigs( softfloat_t* sf, floatx80 a, floatx80 b, flag zSign )\r
+{\r
+    int32_t aExp, bExp, zExp;\r
+    bits64 aSig, bSig, zSig0, zSig1;\r
+    int32_t expDiff;\r
+    floatx80 z;\r
+\r
+    aSig = extractFloatx80Frac( a );\r
+    aExp = extractFloatx80Exp( a );\r
+    bSig = extractFloatx80Frac( b );\r
+    bExp = extractFloatx80Exp( b );\r
+    expDiff = aExp - bExp;\r
+    if ( 0 < expDiff ) goto aExpBigger;\r
+    if ( expDiff < 0 ) goto bExpBigger;\r
+    if ( aExp == 0x7FFF ) {\r
+        if ( (bits64) ( ( aSig | bSig )<<1 ) ) {\r
+            return propagateFloatx80NaN( sf, a, b );\r
+        }\r
+        float_raise( sf, float_flag_invalid );\r
+        z.low = floatx80_default_nan_low;\r
+        z.high = floatx80_default_nan_high;\r
+        return z;\r
+    }\r
+    if ( aExp == 0 ) {\r
+        aExp = 1;\r
+        bExp = 1;\r
+    }\r
+    zSig1 = 0;\r
+    if ( bSig < aSig ) goto aBigger;\r
+    if ( aSig < bSig ) goto bBigger;\r
+    return packFloatx80( sf->float_rounding_mode == float_round_down, 0, 0 );\r
+ bExpBigger:\r
+    if ( bExp == 0x7FFF ) {\r
+        if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( sf, a, b );\r
+        return packFloatx80( zSign ^ 1, 0x7FFF, LIT64( 0x8000000000000000 ) );\r
+    }\r
+    if ( aExp == 0 ) ++expDiff;\r
+    shift128RightJamming( aSig, 0, - expDiff, &aSig, &zSig1 );\r
+ bBigger:\r
+    sub128( bSig, 0, aSig, zSig1, &zSig0, &zSig1 );\r
+    zExp = bExp;\r
+    zSign ^= 1;\r
+    goto normalizeRoundAndPack;\r
+ aExpBigger:\r
+    if ( aExp == 0x7FFF ) {\r
+        if ( (bits64) ( aSig<<1 ) ) return propagateFloatx80NaN( sf, a, b );\r
+        return a;\r
+    }\r
+    if ( bExp == 0 ) --expDiff;\r
+    shift128RightJamming( bSig, 0, expDiff, &bSig, &zSig1 );\r
+ aBigger:\r
+    sub128( aSig, 0, bSig, zSig1, &zSig0, &zSig1 );\r
+    zExp = aExp;\r
+ normalizeRoundAndPack:\r
+    return\r
+        normalizeRoundAndPackFloatx80( sf, \r
+            sf->floatx80_rounding_precision, zSign, zExp, zSig0, zSig1 );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of adding the extended double-precision floating-point\r
+| values `a' and `b'.  The operation is performed according to the IEC/IEEE\r
+| Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+floatx80 floatx80_add( softfloat_t* sf, floatx80 a, floatx80 b )\r
+{\r
+    flag aSign, bSign;\r
+\r
+    aSign = extractFloatx80Sign( a );\r
+    bSign = extractFloatx80Sign( b );\r
+    if ( aSign == bSign ) {\r
+        return addFloatx80Sigs( sf, a, b, aSign );\r
+    }\r
+    else {\r
+        return subFloatx80Sigs( sf, a, b, aSign );\r
+    }\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of subtracting the extended double-precision floating-\r
+| point values `a' and `b'.  The operation is performed according to the\r
+| IEC/IEEE Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+floatx80 floatx80_sub( softfloat_t* sf, floatx80 a, floatx80 b )\r
+{\r
+    flag aSign, bSign;\r
+\r
+    aSign = extractFloatx80Sign( a );\r
+    bSign = extractFloatx80Sign( b );\r
+    if ( aSign == bSign ) {\r
+        return subFloatx80Sigs( sf, a, b, aSign );\r
+    }\r
+    else {\r
+        return addFloatx80Sigs( sf, a, b, aSign );\r
+    }\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of multiplying the extended double-precision floating-\r
+| point values `a' and `b'.  The operation is performed according to the\r
+| IEC/IEEE Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+floatx80 floatx80_mul( softfloat_t* sf, floatx80 a, floatx80 b )\r
+{\r
+    flag aSign, bSign, zSign;\r
+    int32_t aExp, bExp, zExp;\r
+    bits64 aSig, bSig, zSig0, zSig1;\r
+    floatx80 z;\r
+\r
+    aSig = extractFloatx80Frac( a );\r
+    aExp = extractFloatx80Exp( a );\r
+    aSign = extractFloatx80Sign( a );\r
+    bSig = extractFloatx80Frac( b );\r
+    bExp = extractFloatx80Exp( b );\r
+    bSign = extractFloatx80Sign( b );\r
+    zSign = aSign ^ bSign;\r
+    if ( aExp == 0x7FFF ) {\r
+        if (    (bits64) ( aSig<<1 )\r
+             || ( ( bExp == 0x7FFF ) && (bits64) ( bSig<<1 ) ) ) {\r
+            return propagateFloatx80NaN( sf, a, b );\r
+        }\r
+        if ( ( bExp | bSig ) == 0 ) goto invalid;\r
+        return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) );\r
+    }\r
+    if ( bExp == 0x7FFF ) {\r
+        if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( sf, a, b );\r
+        if ( ( aExp | aSig ) == 0 ) {\r
+ invalid:\r
+            float_raise( sf, float_flag_invalid );\r
+            z.low = floatx80_default_nan_low;\r
+            z.high = floatx80_default_nan_high;\r
+            return z;\r
+        }\r
+        return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) );\r
+    }\r
+    if ( aExp == 0 ) {\r
+        if ( aSig == 0 ) return packFloatx80( zSign, 0, 0 );\r
+        normalizeFloatx80Subnormal( aSig, &aExp, &aSig );\r
+    }\r
+    if ( bExp == 0 ) {\r
+        if ( bSig == 0 ) return packFloatx80( zSign, 0, 0 );\r
+        normalizeFloatx80Subnormal( bSig, &bExp, &bSig );\r
+    }\r
+    zExp = aExp + bExp - 0x3FFE;\r
+    mul64To128( aSig, bSig, &zSig0, &zSig1 );\r
+    if ( 0 < (sbits64) zSig0 ) {\r
+        shortShift128Left( zSig0, zSig1, 1, &zSig0, &zSig1 );\r
+        --zExp;\r
+    }\r
+    return\r
+        roundAndPackFloatx80( sf, \r
+            sf->floatx80_rounding_precision, zSign, zExp, zSig0, zSig1 );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of dividing the extended double-precision floating-point\r
+| value `a' by the corresponding value `b'.  The operation is performed\r
+| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+floatx80 floatx80_div( softfloat_t* sf, floatx80 a, floatx80 b )\r
+{\r
+    flag aSign, bSign, zSign;\r
+    int32_t aExp, bExp, zExp;\r
+    bits64 aSig, bSig, zSig0, zSig1;\r
+    bits64 rem0, rem1, rem2, term0, term1, term2;\r
+    floatx80 z;\r
+\r
+    aSig = extractFloatx80Frac( a );\r
+    aExp = extractFloatx80Exp( a );\r
+    aSign = extractFloatx80Sign( a );\r
+    bSig = extractFloatx80Frac( b );\r
+    bExp = extractFloatx80Exp( b );\r
+    bSign = extractFloatx80Sign( b );\r
+    zSign = aSign ^ bSign;\r
+    if ( aExp == 0x7FFF ) {\r
+        if ( (bits64) ( aSig<<1 ) ) return propagateFloatx80NaN( sf, a, b );\r
+        if ( bExp == 0x7FFF ) {\r
+            if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( sf, a, b );\r
+            goto invalid;\r
+        }\r
+        return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) );\r
+    }\r
+    if ( bExp == 0x7FFF ) {\r
+        if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( sf, a, b );\r
+        return packFloatx80( zSign, 0, 0 );\r
+    }\r
+    if ( bExp == 0 ) {\r
+        if ( bSig == 0 ) {\r
+            if ( ( aExp | aSig ) == 0 ) {\r
+ invalid:\r
+                float_raise( sf, float_flag_invalid );\r
+                z.low = floatx80_default_nan_low;\r
+                z.high = floatx80_default_nan_high;\r
+                return z;\r
+            }\r
+            float_raise( sf, float_flag_divbyzero );\r
+            return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) );\r
+        }\r
+        normalizeFloatx80Subnormal( bSig, &bExp, &bSig );\r
+    }\r
+    if ( aExp == 0 ) {\r
+        if ( aSig == 0 ) return packFloatx80( zSign, 0, 0 );\r
+        normalizeFloatx80Subnormal( aSig, &aExp, &aSig );\r
+    }\r
+    zExp = aExp - bExp + 0x3FFE;\r
+    rem1 = 0;\r
+    if ( bSig <= aSig ) {\r
+        shift128Right( aSig, 0, 1, &aSig, &rem1 );\r
+        ++zExp;\r
+    }\r
+    zSig0 = estimateDiv128To64( aSig, rem1, bSig );\r
+    mul64To128( bSig, zSig0, &term0, &term1 );\r
+    sub128( aSig, rem1, term0, term1, &rem0, &rem1 );\r
+    while ( (sbits64) rem0 < 0 ) {\r
+        --zSig0;\r
+        add128( rem0, rem1, 0, bSig, &rem0, &rem1 );\r
+    }\r
+    zSig1 = estimateDiv128To64( rem1, 0, bSig );\r
+    if ( (bits64) ( zSig1<<1 ) <= 8 ) {\r
+        mul64To128( bSig, zSig1, &term1, &term2 );\r
+        sub128( rem1, 0, term1, term2, &rem1, &rem2 );\r
+        while ( (sbits64) rem1 < 0 ) {\r
+            --zSig1;\r
+            add128( rem1, rem2, 0, bSig, &rem1, &rem2 );\r
+        }\r
+        zSig1 |= ( ( rem1 | rem2 ) != 0 );\r
+    }\r
+    return\r
+        roundAndPackFloatx80( sf, \r
+            sf->floatx80_rounding_precision, zSign, zExp, zSig0, zSig1 );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the remainder of the extended double-precision floating-point value\r
+| `a' with respect to the corresponding value `b'.  The operation is performed\r
+| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+floatx80 floatx80_rem( softfloat_t* sf, floatx80 a, floatx80 b )\r
+{\r
+    flag aSign, bSign, zSign;\r
+    int32_t aExp, bExp, expDiff;\r
+    bits64 aSig0, aSig1, bSig;\r
+    bits64 q, term0, term1, alternateASig0, alternateASig1;\r
+    floatx80 z;\r
+\r
+    aSig0 = extractFloatx80Frac( a );\r
+    aExp = extractFloatx80Exp( a );\r
+    aSign = extractFloatx80Sign( a );\r
+    bSig = extractFloatx80Frac( b );\r
+    bExp = extractFloatx80Exp( b );\r
+    bSign = extractFloatx80Sign( b );\r
+    if ( aExp == 0x7FFF ) {\r
+        if (    (bits64) ( aSig0<<1 )\r
+             || ( ( bExp == 0x7FFF ) && (bits64) ( bSig<<1 ) ) ) {\r
+            return propagateFloatx80NaN( sf, a, b );\r
+        }\r
+        goto invalid;\r
+    }\r
+    if ( bExp == 0x7FFF ) {\r
+        if ( (bits64) ( bSig<<1 ) ) return propagateFloatx80NaN( sf, a, b );\r
+        return a;\r
+    }\r
+    if ( bExp == 0 ) {\r
+        if ( bSig == 0 ) {\r
+ invalid:\r
+            float_raise( sf, float_flag_invalid );\r
+            z.low = floatx80_default_nan_low;\r
+            z.high = floatx80_default_nan_high;\r
+            return z;\r
+        }\r
+        normalizeFloatx80Subnormal( bSig, &bExp, &bSig );\r
+    }\r
+    if ( aExp == 0 ) {\r
+        if ( (bits64) ( aSig0<<1 ) == 0 ) return a;\r
+        normalizeFloatx80Subnormal( aSig0, &aExp, &aSig0 );\r
+    }\r
+    bSig |= LIT64( 0x8000000000000000 );\r
+    zSign = aSign;\r
+    expDiff = aExp - bExp;\r
+    aSig1 = 0;\r
+    if ( expDiff < 0 ) {\r
+        if ( expDiff < -1 ) return a;\r
+        shift128Right( aSig0, 0, 1, &aSig0, &aSig1 );\r
+        expDiff = 0;\r
+    }\r
+    q = ( bSig <= aSig0 );\r
+    if ( q ) aSig0 -= bSig;\r
+    expDiff -= 64;\r
+    while ( 0 < expDiff ) {\r
+        q = estimateDiv128To64( aSig0, aSig1, bSig );\r
+        q = ( 2 < q ) ? q - 2 : 0;\r
+        mul64To128( bSig, q, &term0, &term1 );\r
+        sub128( aSig0, aSig1, term0, term1, &aSig0, &aSig1 );\r
+        shortShift128Left( aSig0, aSig1, 62, &aSig0, &aSig1 );\r
+        expDiff -= 62;\r
+    }\r
+    expDiff += 64;\r
+    if ( 0 < expDiff ) {\r
+        q = estimateDiv128To64( aSig0, aSig1, bSig );\r
+        q = ( 2 < q ) ? q - 2 : 0;\r
+        q >>= 64 - expDiff;\r
+        mul64To128( bSig, q<<( 64 - expDiff ), &term0, &term1 );\r
+        sub128( aSig0, aSig1, term0, term1, &aSig0, &aSig1 );\r
+        shortShift128Left( 0, bSig, 64 - expDiff, &term0, &term1 );\r
+        while ( le128( term0, term1, aSig0, aSig1 ) ) {\r
+            ++q;\r
+            sub128( aSig0, aSig1, term0, term1, &aSig0, &aSig1 );\r
+        }\r
+    }\r
+    else {\r
+        term1 = 0;\r
+        term0 = bSig;\r
+    }\r
+    sub128( term0, term1, aSig0, aSig1, &alternateASig0, &alternateASig1 );\r
+    if (    lt128( alternateASig0, alternateASig1, aSig0, aSig1 )\r
+         || (    eq128( alternateASig0, alternateASig1, aSig0, aSig1 )\r
+              && ( q & 1 ) )\r
+       ) {\r
+        aSig0 = alternateASig0;\r
+        aSig1 = alternateASig1;\r
+        zSign = ! zSign;\r
+    }\r
+    return\r
+        normalizeRoundAndPackFloatx80( sf, \r
+            80, zSign, bExp + expDiff, aSig0, aSig1 );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the square root of the extended double-precision floating-point\r
+| value `a'.  The operation is performed according to the IEC/IEEE Standard\r
+| for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+floatx80 floatx80_sqrt( softfloat_t* sf, floatx80 a )\r
+{\r
+    flag aSign;\r
+    int32_t aExp, zExp;\r
+    bits64 aSig0, aSig1, zSig0, zSig1, doubleZSig0;\r
+    bits64 rem0, rem1, rem2, rem3, term0, term1, term2, term3;\r
+    floatx80 z;\r
+\r
+    aSig0 = extractFloatx80Frac( a );\r
+    aExp = extractFloatx80Exp( a );\r
+    aSign = extractFloatx80Sign( a );\r
+    if ( aExp == 0x7FFF ) {\r
+        if ( (bits64) ( aSig0<<1 ) ) return propagateFloatx80NaN( sf, a, a );\r
+        if ( ! aSign ) return a;\r
+        goto invalid;\r
+    }\r
+    if ( aSign ) {\r
+        if ( ( aExp | aSig0 ) == 0 ) return a;\r
+ invalid:\r
+        float_raise( sf, float_flag_invalid );\r
+        z.low = floatx80_default_nan_low;\r
+        z.high = floatx80_default_nan_high;\r
+        return z;\r
+    }\r
+    if ( aExp == 0 ) {\r
+        if ( aSig0 == 0 ) return packFloatx80( 0, 0, 0 );\r
+        normalizeFloatx80Subnormal( aSig0, &aExp, &aSig0 );\r
+    }\r
+    zExp = ( ( aExp - 0x3FFF )>>1 ) + 0x3FFF;\r
+    zSig0 = estimateSqrt32( aExp, aSig0>>32 );\r
+    shift128Right( aSig0, 0, 2 + ( aExp & 1 ), &aSig0, &aSig1 );\r
+    zSig0 = estimateDiv128To64( aSig0, aSig1, zSig0<<32 ) + ( zSig0<<30 );\r
+    doubleZSig0 = zSig0<<1;\r
+    mul64To128( zSig0, zSig0, &term0, &term1 );\r
+    sub128( aSig0, aSig1, term0, term1, &rem0, &rem1 );\r
+    while ( (sbits64) rem0 < 0 ) {\r
+        --zSig0;\r
+        doubleZSig0 -= 2;\r
+        add128( rem0, rem1, zSig0>>63, doubleZSig0 | 1, &rem0, &rem1 );\r
+    }\r
+    zSig1 = estimateDiv128To64( rem1, 0, doubleZSig0 );\r
+    if ( ( zSig1 & LIT64( 0x3FFFFFFFFFFFFFFF ) ) <= 5 ) {\r
+        if ( zSig1 == 0 ) zSig1 = 1;\r
+        mul64To128( doubleZSig0, zSig1, &term1, &term2 );\r
+        sub128( rem1, 0, term1, term2, &rem1, &rem2 );\r
+        mul64To128( zSig1, zSig1, &term2, &term3 );\r
+        sub192( rem1, rem2, 0, 0, term2, term3, &rem1, &rem2, &rem3 );\r
+        while ( (sbits64) rem1 < 0 ) {\r
+            --zSig1;\r
+            shortShift128Left( 0, zSig1, 1, &term2, &term3 );\r
+            term3 |= 1;\r
+            term2 |= doubleZSig0;\r
+            add192( rem1, rem2, rem3, 0, term2, term3, &rem1, &rem2, &rem3 );\r
+        }\r
+        zSig1 |= ( ( rem1 | rem2 | rem3 ) != 0 );\r
+    }\r
+    shortShift128Left( 0, zSig1, 1, &zSig0, &zSig1 );\r
+    zSig0 |= doubleZSig0;\r
+    return\r
+        roundAndPackFloatx80( sf, \r
+            sf->floatx80_rounding_precision, 0, zExp, zSig0, zSig1 );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns 1 if the extended double-precision floating-point value `a' is\r
+| equal to the corresponding value `b', and 0 otherwise.  The comparison is\r
+| performed according to the IEC/IEEE Standard for Binary Floating-Point\r
+| Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+flag floatx80_eq( softfloat_t* sf, floatx80 a, floatx80 b )\r
+{\r
+\r
+    if (    (    ( extractFloatx80Exp( a ) == 0x7FFF )\r
+              && (bits64) ( extractFloatx80Frac( a )<<1 ) )\r
+         || (    ( extractFloatx80Exp( b ) == 0x7FFF )\r
+              && (bits64) ( extractFloatx80Frac( b )<<1 ) )\r
+       ) {\r
+        if (    floatx80_is_signaling_nan( sf, a )\r
+             || floatx80_is_signaling_nan( sf, b ) ) {\r
+            float_raise( sf, float_flag_invalid );\r
+        }\r
+        return 0;\r
+    }\r
+    return\r
+           ( a.low == b.low )\r
+        && (    ( a.high == b.high )\r
+             || (    ( a.low == 0 )\r
+                  && ( (bits16) ( ( a.high | b.high )<<1 ) == 0 ) )\r
+           );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns 1 if the extended double-precision floating-point value `a' is\r
+| less than or equal to the corresponding value `b', and 0 otherwise.  The\r
+| comparison is performed according to the IEC/IEEE Standard for Binary\r
+| Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+flag floatx80_le( softfloat_t* sf, floatx80 a, floatx80 b )\r
+{\r
+    flag aSign, bSign;\r
+\r
+    if (    (    ( extractFloatx80Exp( a ) == 0x7FFF )\r
+              && (bits64) ( extractFloatx80Frac( a )<<1 ) )\r
+         || (    ( extractFloatx80Exp( b ) == 0x7FFF )\r
+              && (bits64) ( extractFloatx80Frac( b )<<1 ) )\r
+       ) {\r
+        float_raise( sf, float_flag_invalid );\r
+        return 0;\r
+    }\r
+    aSign = extractFloatx80Sign( a );\r
+    bSign = extractFloatx80Sign( b );\r
+    if ( aSign != bSign ) {\r
+        return\r
+               aSign\r
+            || (    ( ( (bits16) ( ( a.high | b.high )<<1 ) ) | a.low | b.low )\r
+                 == 0 );\r
+    }\r
+    return\r
+          aSign ? le128( b.high, b.low, a.high, a.low )\r
+        : le128( a.high, a.low, b.high, b.low );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns 1 if the extended double-precision floating-point value `a' is\r
+| less than the corresponding value `b', and 0 otherwise.  The comparison\r
+| is performed according to the IEC/IEEE Standard for Binary Floating-Point\r
+| Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+flag floatx80_lt( softfloat_t* sf, floatx80 a, floatx80 b )\r
+{\r
+    flag aSign, bSign;\r
+\r
+    if (    (    ( extractFloatx80Exp( a ) == 0x7FFF )\r
+              && (bits64) ( extractFloatx80Frac( a )<<1 ) )\r
+         || (    ( extractFloatx80Exp( b ) == 0x7FFF )\r
+              && (bits64) ( extractFloatx80Frac( b )<<1 ) )\r
+       ) {\r
+        float_raise( sf, float_flag_invalid );\r
+        return 0;\r
+    }\r
+    aSign = extractFloatx80Sign( a );\r
+    bSign = extractFloatx80Sign( b );\r
+    if ( aSign != bSign ) {\r
+        return\r
+               aSign\r
+            && (    ( ( (bits16) ( ( a.high | b.high )<<1 ) ) | a.low | b.low )\r
+                 != 0 );\r
+    }\r
+    return\r
+          aSign ? lt128( b.high, b.low, a.high, a.low )\r
+        : lt128( a.high, a.low, b.high, b.low );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns 1 if the extended double-precision floating-point value `a' is equal\r
+| to the corresponding value `b', and 0 otherwise.  The invalid exception is\r
+| raised if either operand is a NaN.  Otherwise, the comparison is performed\r
+| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+flag floatx80_eq_signaling( softfloat_t* sf, floatx80 a, floatx80 b )\r
+{\r
+\r
+    if (    (    ( extractFloatx80Exp( a ) == 0x7FFF )\r
+              && (bits64) ( extractFloatx80Frac( a )<<1 ) )\r
+         || (    ( extractFloatx80Exp( b ) == 0x7FFF )\r
+              && (bits64) ( extractFloatx80Frac( b )<<1 ) )\r
+       ) {\r
+        float_raise( sf, float_flag_invalid );\r
+        return 0;\r
+    }\r
+    return\r
+           ( a.low == b.low )\r
+        && (    ( a.high == b.high )\r
+             || (    ( a.low == 0 )\r
+                  && ( (bits16) ( ( a.high | b.high )<<1 ) == 0 ) )\r
+           );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns 1 if the extended double-precision floating-point value `a' is less\r
+| than or equal to the corresponding value `b', and 0 otherwise.  Quiet NaNs\r
+| do not cause an exception.  Otherwise, the comparison is performed according\r
+| to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+flag floatx80_le_quiet( softfloat_t* sf, floatx80 a, floatx80 b )\r
+{\r
+    flag aSign, bSign;\r
+\r
+    if (    (    ( extractFloatx80Exp( a ) == 0x7FFF )\r
+              && (bits64) ( extractFloatx80Frac( a )<<1 ) )\r
+         || (    ( extractFloatx80Exp( b ) == 0x7FFF )\r
+              && (bits64) ( extractFloatx80Frac( b )<<1 ) )\r
+       ) {\r
+        if (    floatx80_is_signaling_nan( sf, a )\r
+             || floatx80_is_signaling_nan( sf, b ) ) {\r
+            float_raise( sf, float_flag_invalid );\r
+        }\r
+        return 0;\r
+    }\r
+    aSign = extractFloatx80Sign( a );\r
+    bSign = extractFloatx80Sign( b );\r
+    if ( aSign != bSign ) {\r
+        return\r
+               aSign\r
+            || (    ( ( (bits16) ( ( a.high | b.high )<<1 ) ) | a.low | b.low )\r
+                 == 0 );\r
+    }\r
+    return\r
+          aSign ? le128( b.high, b.low, a.high, a.low )\r
+        : le128( a.high, a.low, b.high, b.low );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns 1 if the extended double-precision floating-point value `a' is less\r
+| than the corresponding value `b', and 0 otherwise.  Quiet NaNs do not cause\r
+| an exception.  Otherwise, the comparison is performed according to the\r
+| IEC/IEEE Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+flag floatx80_lt_quiet( softfloat_t* sf, floatx80 a, floatx80 b )\r
+{\r
+    flag aSign, bSign;\r
+\r
+    if (    (    ( extractFloatx80Exp( a ) == 0x7FFF )\r
+              && (bits64) ( extractFloatx80Frac( a )<<1 ) )\r
+         || (    ( extractFloatx80Exp( b ) == 0x7FFF )\r
+              && (bits64) ( extractFloatx80Frac( b )<<1 ) )\r
+       ) {\r
+        if (    floatx80_is_signaling_nan( sf, a )\r
+             || floatx80_is_signaling_nan( sf, b ) ) {\r
+            float_raise( sf, float_flag_invalid );\r
+        }\r
+        return 0;\r
+    }\r
+    aSign = extractFloatx80Sign( a );\r
+    bSign = extractFloatx80Sign( b );\r
+    if ( aSign != bSign ) {\r
+        return\r
+               aSign\r
+            && (    ( ( (bits16) ( ( a.high | b.high )<<1 ) ) | a.low | b.low )\r
+                 != 0 );\r
+    }\r
+    return\r
+          aSign ? lt128( b.high, b.low, a.high, a.low )\r
+        : lt128( a.high, a.low, b.high, b.low );\r
+\r
+}\r
+\r
+#endif\r
+\r
+#ifdef FLOAT128\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the quadruple-precision floating-point\r
+| value `a' to the 32-bit two's complement integer format.  The conversion\r
+| is performed according to the IEC/IEEE Standard for Binary Floating-Point\r
+| Arithmetic---which means in particular that the conversion is rounded\r
+| according to the current rounding mode.  If `a' is a NaN, the largest\r
+| positive integer is returned.  Otherwise, if the conversion overflows, the\r
+| largest integer with the same sign as `a' is returned.\r
+*----------------------------------------------------------------------------*/\r
+\r
+int32_t float128_to_int32( softfloat_t* sf, float128 a )\r
+{\r
+    flag aSign;\r
+    int32_t aExp, shiftCount;\r
+    bits64 aSig0, aSig1;\r
+\r
+    aSig1 = extractFloat128Frac1( a );\r
+    aSig0 = extractFloat128Frac0( a );\r
+    aExp = extractFloat128Exp( a );\r
+    aSign = extractFloat128Sign( a );\r
+    if ( ( aExp == 0x7FFF ) && ( aSig0 | aSig1 ) ) aSign = 0;\r
+    if ( aExp ) aSig0 |= LIT64( 0x0001000000000000 );\r
+    aSig0 |= ( aSig1 != 0 );\r
+    shiftCount = 0x4028 - aExp;\r
+    if ( 0 < shiftCount ) shift64RightJamming( aSig0, shiftCount, &aSig0 );\r
+    return roundAndPackInt32( sf, aSign, aSig0 );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the quadruple-precision floating-point\r
+| value `a' to the 32-bit two's complement integer format.  The conversion\r
+| is performed according to the IEC/IEEE Standard for Binary Floating-Point\r
+| Arithmetic, except that the conversion is always rounded toward zero.  If\r
+| `a' is a NaN, the largest positive integer is returned.  Otherwise, if the\r
+| conversion overflows, the largest integer with the same sign as `a' is\r
+| returned.\r
+*----------------------------------------------------------------------------*/\r
+\r
+int32_t float128_to_int32_round_to_zero( softfloat_t* sf, float128 a )\r
+{\r
+    flag aSign;\r
+    int32_t aExp, shiftCount;\r
+    bits64 aSig0, aSig1, savedASig;\r
+    int32_t z;\r
+\r
+    aSig1 = extractFloat128Frac1( a );\r
+    aSig0 = extractFloat128Frac0( a );\r
+    aExp = extractFloat128Exp( a );\r
+    aSign = extractFloat128Sign( a );\r
+    aSig0 |= ( aSig1 != 0 );\r
+    if ( 0x401E < aExp ) {\r
+        if ( ( aExp == 0x7FFF ) && aSig0 ) aSign = 0;\r
+        goto invalid;\r
+    }\r
+    else if ( aExp < 0x3FFF ) {\r
+        if ( aExp || aSig0 ) sf->float_exception_flags |= float_flag_inexact;\r
+        return 0;\r
+    }\r
+    aSig0 |= LIT64( 0x0001000000000000 );\r
+    shiftCount = 0x402F - aExp;\r
+    savedASig = aSig0;\r
+    aSig0 >>= shiftCount;\r
+    z = aSig0;\r
+    if ( aSign ) z = - z;\r
+    if ( ( z < 0 ) ^ aSign ) {\r
+ invalid:\r
+        float_raise( sf, float_flag_invalid );\r
+        return aSign ? (sbits32) 0x80000000 : 0x7FFFFFFF;\r
+    }\r
+    if ( ( aSig0<<shiftCount ) != savedASig ) {\r
+        sf->float_exception_flags |= float_flag_inexact;\r
+    }\r
+    return z;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the quadruple-precision floating-point\r
+| value `a' to the 64-bit two's complement integer format.  The conversion\r
+| is performed according to the IEC/IEEE Standard for Binary Floating-Point\r
+| Arithmetic---which means in particular that the conversion is rounded\r
+| according to the current rounding mode.  If `a' is a NaN, the largest\r
+| positive integer is returned.  Otherwise, if the conversion overflows, the\r
+| largest integer with the same sign as `a' is returned.\r
+*----------------------------------------------------------------------------*/\r
+\r
+int64_t float128_to_int64( softfloat_t* sf, float128 a )\r
+{\r
+    flag aSign;\r
+    int32_t aExp, shiftCount;\r
+    bits64 aSig0, aSig1;\r
+\r
+    aSig1 = extractFloat128Frac1( a );\r
+    aSig0 = extractFloat128Frac0( a );\r
+    aExp = extractFloat128Exp( a );\r
+    aSign = extractFloat128Sign( a );\r
+    if ( aExp ) aSig0 |= LIT64( 0x0001000000000000 );\r
+    shiftCount = 0x402F - aExp;\r
+    if ( shiftCount <= 0 ) {\r
+        if ( 0x403E < aExp ) {\r
+            float_raise( sf, float_flag_invalid );\r
+            if (    ! aSign\r
+                 || (    ( aExp == 0x7FFF )\r
+                      && ( aSig1 || ( aSig0 != LIT64( 0x0001000000000000 ) ) )\r
+                    )\r
+               ) {\r
+                return LIT64( 0x7FFFFFFFFFFFFFFF );\r
+            }\r
+            return (sbits64) LIT64( 0x8000000000000000 );\r
+        }\r
+        shortShift128Left( aSig0, aSig1, - shiftCount, &aSig0, &aSig1 );\r
+    }\r
+    else {\r
+        shift64ExtraRightJamming( aSig0, aSig1, shiftCount, &aSig0, &aSig1 );\r
+    }\r
+    return roundAndPackInt64( sf, aSign, aSig0, aSig1 );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the quadruple-precision floating-point\r
+| value `a' to the 64-bit two's complement integer format.  The conversion\r
+| is performed according to the IEC/IEEE Standard for Binary Floating-Point\r
+| Arithmetic, except that the conversion is always rounded toward zero.\r
+| If `a' is a NaN, the largest positive integer is returned.  Otherwise, if\r
+| the conversion overflows, the largest integer with the same sign as `a' is\r
+| returned.\r
+*----------------------------------------------------------------------------*/\r
+\r
+int64_t float128_to_int64_round_to_zero( softfloat_t* sf, float128 a )\r
+{\r
+    flag aSign;\r
+    int32_t aExp, shiftCount;\r
+    bits64 aSig0, aSig1;\r
+    int64_t z;\r
+\r
+    aSig1 = extractFloat128Frac1( a );\r
+    aSig0 = extractFloat128Frac0( a );\r
+    aExp = extractFloat128Exp( a );\r
+    aSign = extractFloat128Sign( a );\r
+    if ( aExp ) aSig0 |= LIT64( 0x0001000000000000 );\r
+    shiftCount = aExp - 0x402F;\r
+    if ( 0 < shiftCount ) {\r
+        if ( 0x403E <= aExp ) {\r
+            aSig0 &= LIT64( 0x0000FFFFFFFFFFFF );\r
+            if (    ( a.high == LIT64( 0xC03E000000000000 ) )\r
+                 && ( aSig1 < LIT64( 0x0002000000000000 ) ) ) {\r
+                if ( aSig1 ) sf->float_exception_flags |= float_flag_inexact;\r
+            }\r
+            else {\r
+                float_raise( sf, float_flag_invalid );\r
+                if ( ! aSign || ( ( aExp == 0x7FFF ) && ( aSig0 | aSig1 ) ) ) {\r
+                    return LIT64( 0x7FFFFFFFFFFFFFFF );\r
+                }\r
+            }\r
+            return (sbits64) LIT64( 0x8000000000000000 );\r
+        }\r
+        z = ( aSig0<<shiftCount ) | ( aSig1>>( ( - shiftCount ) & 63 ) );\r
+        if ( (bits64) ( aSig1<<shiftCount ) ) {\r
+            sf->float_exception_flags |= float_flag_inexact;\r
+        }\r
+    }\r
+    else {\r
+        if ( aExp < 0x3FFF ) {\r
+            if ( aExp | aSig0 | aSig1 ) {\r
+                sf->float_exception_flags |= float_flag_inexact;\r
+            }\r
+            return 0;\r
+        }\r
+        z = aSig0>>( - shiftCount );\r
+        if (    aSig1\r
+             || ( shiftCount && (bits64) ( aSig0<<( shiftCount & 63 ) ) ) ) {\r
+            sf->float_exception_flags |= float_flag_inexact;\r
+        }\r
+    }\r
+    if ( aSign ) z = - z;\r
+    return z;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the quadruple-precision floating-point\r
+| value `a' to the single-precision floating-point format.  The conversion\r
+| is performed according to the IEC/IEEE Standard for Binary Floating-Point\r
+| Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float32 float128_to_float32( softfloat_t* sf, float128 a )\r
+{\r
+    flag aSign;\r
+    int32_t aExp;\r
+    bits64 aSig0, aSig1;\r
+    bits32 zSig;\r
+\r
+    aSig1 = extractFloat128Frac1( a );\r
+    aSig0 = extractFloat128Frac0( a );\r
+    aExp = extractFloat128Exp( a );\r
+    aSign = extractFloat128Sign( a );\r
+    if ( aExp == 0x7FFF ) {\r
+        if ( aSig0 | aSig1 ) {\r
+            return commonNaNToFloat32( sf, float128ToCommonNaN( sf, a ) );\r
+        }\r
+        return packFloat32( aSign, 0xFF, 0 );\r
+    }\r
+    aSig0 |= ( aSig1 != 0 );\r
+    shift64RightJamming( aSig0, 18, &aSig0 );\r
+    zSig = aSig0;\r
+    if ( aExp || zSig ) {\r
+        zSig |= 0x40000000;\r
+        aExp -= 0x3F81;\r
+    }\r
+    return roundAndPackFloat32( sf, aSign, aExp, zSig );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the quadruple-precision floating-point\r
+| value `a' to the double-precision floating-point format.  The conversion\r
+| is performed according to the IEC/IEEE Standard for Binary Floating-Point\r
+| Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float64 float128_to_float64( softfloat_t* sf, float128 a )\r
+{\r
+    flag aSign;\r
+    int32_t aExp;\r
+    bits64 aSig0, aSig1;\r
+\r
+    aSig1 = extractFloat128Frac1( a );\r
+    aSig0 = extractFloat128Frac0( a );\r
+    aExp = extractFloat128Exp( a );\r
+    aSign = extractFloat128Sign( a );\r
+    if ( aExp == 0x7FFF ) {\r
+        if ( aSig0 | aSig1 ) {\r
+            return commonNaNToFloat64( sf, float128ToCommonNaN( sf, a ) );\r
+        }\r
+        return packFloat64( aSign, 0x7FF, 0 );\r
+    }\r
+    shortShift128Left( aSig0, aSig1, 14, &aSig0, &aSig1 );\r
+    aSig0 |= ( aSig1 != 0 );\r
+    if ( aExp || aSig0 ) {\r
+        aSig0 |= LIT64( 0x4000000000000000 );\r
+        aExp -= 0x3C01;\r
+    }\r
+    return roundAndPackFloat64( sf, aSign, aExp, aSig0 );\r
+\r
+}\r
+\r
+#ifdef FLOATX80\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the quadruple-precision floating-point\r
+| value `a' to the extended double-precision floating-point format.  The\r
+| conversion is performed according to the IEC/IEEE Standard for Binary\r
+| Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+floatx80 float128_to_floatx80( softfloat_t* sf, float128 a )\r
+{\r
+    flag aSign;\r
+    int32_t aExp;\r
+    bits64 aSig0, aSig1;\r
+\r
+    aSig1 = extractFloat128Frac1( a );\r
+    aSig0 = extractFloat128Frac0( a );\r
+    aExp = extractFloat128Exp( a );\r
+    aSign = extractFloat128Sign( a );\r
+    if ( aExp == 0x7FFF ) {\r
+        if ( aSig0 | aSig1 ) {\r
+            return commonNaNToFloatx80( sf, float128ToCommonNaN( sf, a ) );\r
+        }\r
+        return packFloatx80( aSign, 0x7FFF, LIT64( 0x8000000000000000 ) );\r
+    }\r
+    if ( aExp == 0 ) {\r
+        if ( ( aSig0 | aSig1 ) == 0 ) return packFloatx80( aSign, 0, 0 );\r
+        normalizeFloat128Subnormal( aSig0, aSig1, &aExp, &aSig0, &aSig1 );\r
+    }\r
+    else {\r
+        aSig0 |= LIT64( 0x0001000000000000 );\r
+    }\r
+    shortShift128Left( aSig0, aSig1, 15, &aSig0, &aSig1 );\r
+    return roundAndPackFloatx80( sf,  80, aSign, aExp, aSig0, aSig1 );\r
+\r
+}\r
+\r
+#endif\r
+\r
+/*----------------------------------------------------------------------------\r
+| Rounds the quadruple-precision floating-point value `a' to an integer, and\r
+| returns the result as a quadruple-precision floating-point value.  The\r
+| operation is performed according to the IEC/IEEE Standard for Binary\r
+| Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float128 float128_round_to_int( softfloat_t* sf, float128 a )\r
+{\r
+    flag aSign;\r
+    int32_t aExp;\r
+    bits64 lastBitMask, roundBitsMask;\r
+    int8_t roundingMode;\r
+    float128 z;\r
+\r
+    aExp = extractFloat128Exp( a );\r
+    if ( 0x402F <= aExp ) {\r
+        if ( 0x406F <= aExp ) {\r
+            if (    ( aExp == 0x7FFF )\r
+                 && ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) )\r
+               ) {\r
+                return propagateFloat128NaN( sf, a, a );\r
+            }\r
+            return a;\r
+        }\r
+        lastBitMask = 1;\r
+        lastBitMask = ( lastBitMask<<( 0x406E - aExp ) )<<1;\r
+        roundBitsMask = lastBitMask - 1;\r
+        z = a;\r
+        roundingMode = sf->float_rounding_mode;\r
+        if ( roundingMode == float_round_nearest_even ) {\r
+            if ( lastBitMask ) {\r
+                add128( z.high, z.low, 0, lastBitMask>>1, &z.high, &z.low );\r
+                if ( ( z.low & roundBitsMask ) == 0 ) z.low &= ~ lastBitMask;\r
+            }\r
+            else {\r
+                if ( (sbits64) z.low < 0 ) {\r
+                    ++z.high;\r
+                    if ( (bits64) ( z.low<<1 ) == 0 ) z.high &= ~1;\r
+                }\r
+            }\r
+        }\r
+        else if ( roundingMode != float_round_to_zero ) {\r
+            if (   extractFloat128Sign( z )\r
+                 ^ ( roundingMode == float_round_up ) ) {\r
+                add128( z.high, z.low, 0, roundBitsMask, &z.high, &z.low );\r
+            }\r
+        }\r
+        z.low &= ~ roundBitsMask;\r
+    }\r
+    else {\r
+        if ( aExp < 0x3FFF ) {\r
+            if ( ( ( (bits64) ( a.high<<1 ) ) | a.low ) == 0 ) return a;\r
+            sf->float_exception_flags |= float_flag_inexact;\r
+            aSign = extractFloat128Sign( a );\r
+            switch ( sf->float_rounding_mode ) {\r
+             case float_round_nearest_even:\r
+                if (    ( aExp == 0x3FFE )\r
+                     && (   extractFloat128Frac0( a )\r
+                          | extractFloat128Frac1( a ) )\r
+                   ) {\r
+                    return packFloat128( aSign, 0x3FFF, 0, 0 );\r
+                }\r
+                break;\r
+             case float_round_down:\r
+                return\r
+                      aSign ? packFloat128( 1, 0x3FFF, 0, 0 )\r
+                    : packFloat128( 0, 0, 0, 0 );\r
+             case float_round_up:\r
+                return\r
+                      aSign ? packFloat128( 1, 0, 0, 0 )\r
+                    : packFloat128( 0, 0x3FFF, 0, 0 );\r
+            }\r
+            return packFloat128( aSign, 0, 0, 0 );\r
+        }\r
+        lastBitMask = 1;\r
+        lastBitMask <<= 0x402F - aExp;\r
+        roundBitsMask = lastBitMask - 1;\r
+        z.low = 0;\r
+        z.high = a.high;\r
+        roundingMode = sf->float_rounding_mode;\r
+        if ( roundingMode == float_round_nearest_even ) {\r
+            z.high += lastBitMask>>1;\r
+            if ( ( ( z.high & roundBitsMask ) | a.low ) == 0 ) {\r
+                z.high &= ~ lastBitMask;\r
+            }\r
+        }\r
+        else if ( roundingMode != float_round_to_zero ) {\r
+            if (   extractFloat128Sign( z )\r
+                 ^ ( roundingMode == float_round_up ) ) {\r
+                z.high |= ( a.low != 0 );\r
+                z.high += roundBitsMask;\r
+            }\r
+        }\r
+        z.high &= ~ roundBitsMask;\r
+    }\r
+    if ( ( z.low != a.low ) || ( z.high != a.high ) ) {\r
+        sf->float_exception_flags |= float_flag_inexact;\r
+    }\r
+    return z;\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of adding the absolute values of the quadruple-precision\r
+| floating-point values `a' and `b'.  If `zSign' is 1, the sum is negated\r
+| before being returned.  `zSign' is ignored if the result is a NaN.\r
+| The addition is performed according to the IEC/IEEE Standard for Binary\r
+| Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float128 addFloat128Sigs( softfloat_t* sf, float128 a, float128 b, flag zSign )\r
+{\r
+    int32_t aExp, bExp, zExp;\r
+    bits64 aSig0, aSig1, bSig0, bSig1, zSig0, zSig1, zSig2;\r
+    int32_t expDiff;\r
+\r
+    aSig1 = extractFloat128Frac1( a );\r
+    aSig0 = extractFloat128Frac0( a );\r
+    aExp = extractFloat128Exp( a );\r
+    bSig1 = extractFloat128Frac1( b );\r
+    bSig0 = extractFloat128Frac0( b );\r
+    bExp = extractFloat128Exp( b );\r
+    expDiff = aExp - bExp;\r
+    if ( 0 < expDiff ) {\r
+        if ( aExp == 0x7FFF ) {\r
+            if ( aSig0 | aSig1 ) return propagateFloat128NaN( sf, a, b );\r
+            return a;\r
+        }\r
+        if ( bExp == 0 ) {\r
+            --expDiff;\r
+        }\r
+        else {\r
+            bSig0 |= LIT64( 0x0001000000000000 );\r
+        }\r
+        shift128ExtraRightJamming(\r
+            bSig0, bSig1, 0, expDiff, &bSig0, &bSig1, &zSig2 );\r
+        zExp = aExp;\r
+    }\r
+    else if ( expDiff < 0 ) {\r
+        if ( bExp == 0x7FFF ) {\r
+            if ( bSig0 | bSig1 ) return propagateFloat128NaN( sf, a, b );\r
+            return packFloat128( zSign, 0x7FFF, 0, 0 );\r
+        }\r
+        if ( aExp == 0 ) {\r
+            ++expDiff;\r
+        }\r
+        else {\r
+            aSig0 |= LIT64( 0x0001000000000000 );\r
+        }\r
+        shift128ExtraRightJamming(\r
+            aSig0, aSig1, 0, - expDiff, &aSig0, &aSig1, &zSig2 );\r
+        zExp = bExp;\r
+    }\r
+    else {\r
+        if ( aExp == 0x7FFF ) {\r
+            if ( aSig0 | aSig1 | bSig0 | bSig1 ) {\r
+                return propagateFloat128NaN( sf, a, b );\r
+            }\r
+            return a;\r
+        }\r
+        add128( aSig0, aSig1, bSig0, bSig1, &zSig0, &zSig1 );\r
+        if ( aExp == 0 ) return packFloat128( zSign, 0, zSig0, zSig1 );\r
+        zSig2 = 0;\r
+        zSig0 |= LIT64( 0x0002000000000000 );\r
+        zExp = aExp;\r
+        goto shiftRight1;\r
+    }\r
+    aSig0 |= LIT64( 0x0001000000000000 );\r
+    add128( aSig0, aSig1, bSig0, bSig1, &zSig0, &zSig1 );\r
+    --zExp;\r
+    if ( zSig0 < LIT64( 0x0002000000000000 ) ) goto roundAndPack;\r
+    ++zExp;\r
+ shiftRight1:\r
+    shift128ExtraRightJamming(\r
+        zSig0, zSig1, zSig2, 1, &zSig0, &zSig1, &zSig2 );\r
+ roundAndPack:\r
+    return roundAndPackFloat128( sf,  zSign, zExp, zSig0, zSig1, zSig2 );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of subtracting the absolute values of the quadruple-\r
+| precision floating-point values `a' and `b'.  If `zSign' is 1, the\r
+| difference is negated before being returned.  `zSign' is ignored if the\r
+| result is a NaN.  The subtraction is performed according to the IEC/IEEE\r
+| Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float128 subFloat128Sigs( softfloat_t* sf, float128 a, float128 b, flag zSign )\r
+{\r
+    int32_t aExp, bExp, zExp;\r
+    bits64 aSig0, aSig1, bSig0, bSig1, zSig0, zSig1;\r
+    int32_t expDiff;\r
+    float128 z;\r
+\r
+    aSig1 = extractFloat128Frac1( a );\r
+    aSig0 = extractFloat128Frac0( a );\r
+    aExp = extractFloat128Exp( a );\r
+    bSig1 = extractFloat128Frac1( b );\r
+    bSig0 = extractFloat128Frac0( b );\r
+    bExp = extractFloat128Exp( b );\r
+    expDiff = aExp - bExp;\r
+    shortShift128Left( aSig0, aSig1, 14, &aSig0, &aSig1 );\r
+    shortShift128Left( bSig0, bSig1, 14, &bSig0, &bSig1 );\r
+    if ( 0 < expDiff ) goto aExpBigger;\r
+    if ( expDiff < 0 ) goto bExpBigger;\r
+    if ( aExp == 0x7FFF ) {\r
+        if ( aSig0 | aSig1 | bSig0 | bSig1 ) {\r
+            return propagateFloat128NaN( sf, a, b );\r
+        }\r
+        float_raise( sf, float_flag_invalid );\r
+        z.low = float128_default_nan_low;\r
+        z.high = float128_default_nan_high;\r
+        return z;\r
+    }\r
+    if ( aExp == 0 ) {\r
+        aExp = 1;\r
+        bExp = 1;\r
+    }\r
+    if ( bSig0 < aSig0 ) goto aBigger;\r
+    if ( aSig0 < bSig0 ) goto bBigger;\r
+    if ( bSig1 < aSig1 ) goto aBigger;\r
+    if ( aSig1 < bSig1 ) goto bBigger;\r
+    return packFloat128( sf->float_rounding_mode == float_round_down, 0, 0, 0 );\r
+ bExpBigger:\r
+    if ( bExp == 0x7FFF ) {\r
+        if ( bSig0 | bSig1 ) return propagateFloat128NaN( sf, a, b );\r
+        return packFloat128( zSign ^ 1, 0x7FFF, 0, 0 );\r
+    }\r
+    if ( aExp == 0 ) {\r
+        ++expDiff;\r
+    }\r
+    else {\r
+        aSig0 |= LIT64( 0x4000000000000000 );\r
+    }\r
+    shift128RightJamming( aSig0, aSig1, - expDiff, &aSig0, &aSig1 );\r
+    bSig0 |= LIT64( 0x4000000000000000 );\r
+ bBigger:\r
+    sub128( bSig0, bSig1, aSig0, aSig1, &zSig0, &zSig1 );\r
+    zExp = bExp;\r
+    zSign ^= 1;\r
+    goto normalizeRoundAndPack;\r
+ aExpBigger:\r
+    if ( aExp == 0x7FFF ) {\r
+        if ( aSig0 | aSig1 ) return propagateFloat128NaN( sf, a, b );\r
+        return a;\r
+    }\r
+    if ( bExp == 0 ) {\r
+        --expDiff;\r
+    }\r
+    else {\r
+        bSig0 |= LIT64( 0x4000000000000000 );\r
+    }\r
+    shift128RightJamming( bSig0, bSig1, expDiff, &bSig0, &bSig1 );\r
+    aSig0 |= LIT64( 0x4000000000000000 );\r
+ aBigger:\r
+    sub128( aSig0, aSig1, bSig0, bSig1, &zSig0, &zSig1 );\r
+    zExp = aExp;\r
+ normalizeRoundAndPack:\r
+    --zExp;\r
+    return normalizeRoundAndPackFloat128( sf,  zSign, zExp - 14, zSig0, zSig1 );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of adding the quadruple-precision floating-point values\r
+| `a' and `b'.  The operation is performed according to the IEC/IEEE Standard\r
+| for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float128 float128_add( softfloat_t* sf, float128 a, float128 b )\r
+{\r
+    flag aSign, bSign;\r
+\r
+    aSign = extractFloat128Sign( a );\r
+    bSign = extractFloat128Sign( b );\r
+    if ( aSign == bSign ) {\r
+        return addFloat128Sigs( sf, a, b, aSign );\r
+    }\r
+    else {\r
+        return subFloat128Sigs( sf, a, b, aSign );\r
+    }\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of subtracting the quadruple-precision floating-point\r
+| values `a' and `b'.  The operation is performed according to the IEC/IEEE\r
+| Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float128 float128_sub( softfloat_t* sf, float128 a, float128 b )\r
+{\r
+    flag aSign, bSign;\r
+\r
+    aSign = extractFloat128Sign( a );\r
+    bSign = extractFloat128Sign( b );\r
+    if ( aSign == bSign ) {\r
+        return subFloat128Sigs( sf, a, b, aSign );\r
+    }\r
+    else {\r
+        return addFloat128Sigs( sf, a, b, aSign );\r
+    }\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of multiplying the quadruple-precision floating-point\r
+| values `a' and `b'.  The operation is performed according to the IEC/IEEE\r
+| Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float128 float128_mul( softfloat_t* sf, float128 a, float128 b )\r
+{\r
+    flag aSign, bSign, zSign;\r
+    int32_t aExp, bExp, zExp;\r
+    bits64 aSig0, aSig1, bSig0, bSig1, zSig0, zSig1, zSig2, zSig3;\r
+    float128 z;\r
+\r
+    aSig1 = extractFloat128Frac1( a );\r
+    aSig0 = extractFloat128Frac0( a );\r
+    aExp = extractFloat128Exp( a );\r
+    aSign = extractFloat128Sign( a );\r
+    bSig1 = extractFloat128Frac1( b );\r
+    bSig0 = extractFloat128Frac0( b );\r
+    bExp = extractFloat128Exp( b );\r
+    bSign = extractFloat128Sign( b );\r
+    zSign = aSign ^ bSign;\r
+    if ( aExp == 0x7FFF ) {\r
+        if (    ( aSig0 | aSig1 )\r
+             || ( ( bExp == 0x7FFF ) && ( bSig0 | bSig1 ) ) ) {\r
+            return propagateFloat128NaN( sf, a, b );\r
+        }\r
+        if ( ( bExp | bSig0 | bSig1 ) == 0 ) goto invalid;\r
+        return packFloat128( zSign, 0x7FFF, 0, 0 );\r
+    }\r
+    if ( bExp == 0x7FFF ) {\r
+        if ( bSig0 | bSig1 ) return propagateFloat128NaN( sf, a, b );\r
+        if ( ( aExp | aSig0 | aSig1 ) == 0 ) {\r
+ invalid:\r
+            float_raise( sf, float_flag_invalid );\r
+            z.low = float128_default_nan_low;\r
+            z.high = float128_default_nan_high;\r
+            return z;\r
+        }\r
+        return packFloat128( zSign, 0x7FFF, 0, 0 );\r
+    }\r
+    if ( aExp == 0 ) {\r
+        if ( ( aSig0 | aSig1 ) == 0 ) return packFloat128( zSign, 0, 0, 0 );\r
+        normalizeFloat128Subnormal( aSig0, aSig1, &aExp, &aSig0, &aSig1 );\r
+    }\r
+    if ( bExp == 0 ) {\r
+        if ( ( bSig0 | bSig1 ) == 0 ) return packFloat128( zSign, 0, 0, 0 );\r
+        normalizeFloat128Subnormal( bSig0, bSig1, &bExp, &bSig0, &bSig1 );\r
+    }\r
+    zExp = aExp + bExp - 0x4000;\r
+    aSig0 |= LIT64( 0x0001000000000000 );\r
+    shortShift128Left( bSig0, bSig1, 16, &bSig0, &bSig1 );\r
+    mul128To256( aSig0, aSig1, bSig0, bSig1, &zSig0, &zSig1, &zSig2, &zSig3 );\r
+    add128( zSig0, zSig1, aSig0, aSig1, &zSig0, &zSig1 );\r
+    zSig2 |= ( zSig3 != 0 );\r
+    if ( LIT64( 0x0002000000000000 ) <= zSig0 ) {\r
+        shift128ExtraRightJamming(\r
+            zSig0, zSig1, zSig2, 1, &zSig0, &zSig1, &zSig2 );\r
+        ++zExp;\r
+    }\r
+    return roundAndPackFloat128( sf,  zSign, zExp, zSig0, zSig1, zSig2 );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of dividing the quadruple-precision floating-point value\r
+| `a' by the corresponding value `b'.  The operation is performed according to\r
+| the IEC/IEEE Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float128 float128_div( softfloat_t* sf, float128 a, float128 b )\r
+{\r
+    flag aSign, bSign, zSign;\r
+    int32_t aExp, bExp, zExp;\r
+    bits64 aSig0, aSig1, bSig0, bSig1, zSig0, zSig1, zSig2;\r
+    bits64 rem0, rem1, rem2, rem3, term0, term1, term2, term3;\r
+    float128 z;\r
+\r
+    aSig1 = extractFloat128Frac1( a );\r
+    aSig0 = extractFloat128Frac0( a );\r
+    aExp = extractFloat128Exp( a );\r
+    aSign = extractFloat128Sign( a );\r
+    bSig1 = extractFloat128Frac1( b );\r
+    bSig0 = extractFloat128Frac0( b );\r
+    bExp = extractFloat128Exp( b );\r
+    bSign = extractFloat128Sign( b );\r
+    zSign = aSign ^ bSign;\r
+    if ( aExp == 0x7FFF ) {\r
+        if ( aSig0 | aSig1 ) return propagateFloat128NaN( sf, a, b );\r
+        if ( bExp == 0x7FFF ) {\r
+            if ( bSig0 | bSig1 ) return propagateFloat128NaN( sf, a, b );\r
+            goto invalid;\r
+        }\r
+        return packFloat128( zSign, 0x7FFF, 0, 0 );\r
+    }\r
+    if ( bExp == 0x7FFF ) {\r
+        if ( bSig0 | bSig1 ) return propagateFloat128NaN( sf, a, b );\r
+        return packFloat128( zSign, 0, 0, 0 );\r
+    }\r
+    if ( bExp == 0 ) {\r
+        if ( ( bSig0 | bSig1 ) == 0 ) {\r
+            if ( ( aExp | aSig0 | aSig1 ) == 0 ) {\r
+ invalid:\r
+                float_raise( sf, float_flag_invalid );\r
+                z.low = float128_default_nan_low;\r
+                z.high = float128_default_nan_high;\r
+                return z;\r
+            }\r
+            float_raise( sf, float_flag_divbyzero );\r
+            return packFloat128( zSign, 0x7FFF, 0, 0 );\r
+        }\r
+        normalizeFloat128Subnormal( bSig0, bSig1, &bExp, &bSig0, &bSig1 );\r
+    }\r
+    if ( aExp == 0 ) {\r
+        if ( ( aSig0 | aSig1 ) == 0 ) return packFloat128( zSign, 0, 0, 0 );\r
+        normalizeFloat128Subnormal( aSig0, aSig1, &aExp, &aSig0, &aSig1 );\r
+    }\r
+    zExp = aExp - bExp + 0x3FFD;\r
+    shortShift128Left(\r
+        aSig0 | LIT64( 0x0001000000000000 ), aSig1, 15, &aSig0, &aSig1 );\r
+    shortShift128Left(\r
+        bSig0 | LIT64( 0x0001000000000000 ), bSig1, 15, &bSig0, &bSig1 );\r
+    if ( le128( bSig0, bSig1, aSig0, aSig1 ) ) {\r
+        shift128Right( aSig0, aSig1, 1, &aSig0, &aSig1 );\r
+        ++zExp;\r
+    }\r
+    zSig0 = estimateDiv128To64( aSig0, aSig1, bSig0 );\r
+    mul128By64To192( bSig0, bSig1, zSig0, &term0, &term1, &term2 );\r
+    sub192( aSig0, aSig1, 0, term0, term1, term2, &rem0, &rem1, &rem2 );\r
+    while ( (sbits64) rem0 < 0 ) {\r
+        --zSig0;\r
+        add192( rem0, rem1, rem2, 0, bSig0, bSig1, &rem0, &rem1, &rem2 );\r
+    }\r
+    zSig1 = estimateDiv128To64( rem1, rem2, bSig0 );\r
+    if ( ( zSig1 & 0x3FFF ) <= 4 ) {\r
+        mul128By64To192( bSig0, bSig1, zSig1, &term1, &term2, &term3 );\r
+        sub192( rem1, rem2, 0, term1, term2, term3, &rem1, &rem2, &rem3 );\r
+        while ( (sbits64) rem1 < 0 ) {\r
+            --zSig1;\r
+            add192( rem1, rem2, rem3, 0, bSig0, bSig1, &rem1, &rem2, &rem3 );\r
+        }\r
+        zSig1 |= ( ( rem1 | rem2 | rem3 ) != 0 );\r
+    }\r
+    shift128ExtraRightJamming( zSig0, zSig1, 0, 15, &zSig0, &zSig1, &zSig2 );\r
+    return roundAndPackFloat128( sf,  zSign, zExp, zSig0, zSig1, zSig2 );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the remainder of the quadruple-precision floating-point value `a'\r
+| with respect to the corresponding value `b'.  The operation is performed\r
+| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float128 float128_rem( softfloat_t* sf, float128 a, float128 b )\r
+{\r
+    flag aSign, bSign, zSign;\r
+    int32_t aExp, bExp, expDiff;\r
+    bits64 aSig0, aSig1, bSig0, bSig1, q, term0, term1, term2;\r
+    bits64 allZero, alternateASig0, alternateASig1, sigMean1;\r
+    sbits64 sigMean0;\r
+    float128 z;\r
+\r
+    aSig1 = extractFloat128Frac1( a );\r
+    aSig0 = extractFloat128Frac0( a );\r
+    aExp = extractFloat128Exp( a );\r
+    aSign = extractFloat128Sign( a );\r
+    bSig1 = extractFloat128Frac1( b );\r
+    bSig0 = extractFloat128Frac0( b );\r
+    bExp = extractFloat128Exp( b );\r
+    bSign = extractFloat128Sign( b );\r
+    if ( aExp == 0x7FFF ) {\r
+        if (    ( aSig0 | aSig1 )\r
+             || ( ( bExp == 0x7FFF ) && ( bSig0 | bSig1 ) ) ) {\r
+            return propagateFloat128NaN( sf, a, b );\r
+        }\r
+        goto invalid;\r
+    }\r
+    if ( bExp == 0x7FFF ) {\r
+        if ( bSig0 | bSig1 ) return propagateFloat128NaN( sf, a, b );\r
+        return a;\r
+    }\r
+    if ( bExp == 0 ) {\r
+        if ( ( bSig0 | bSig1 ) == 0 ) {\r
+ invalid:\r
+            float_raise( sf, float_flag_invalid );\r
+            z.low = float128_default_nan_low;\r
+            z.high = float128_default_nan_high;\r
+            return z;\r
+        }\r
+        normalizeFloat128Subnormal( bSig0, bSig1, &bExp, &bSig0, &bSig1 );\r
+    }\r
+    if ( aExp == 0 ) {\r
+        if ( ( aSig0 | aSig1 ) == 0 ) return a;\r
+        normalizeFloat128Subnormal( aSig0, aSig1, &aExp, &aSig0, &aSig1 );\r
+    }\r
+    expDiff = aExp - bExp;\r
+    if ( expDiff < -1 ) return a;\r
+    shortShift128Left(\r
+        aSig0 | LIT64( 0x0001000000000000 ),\r
+        aSig1,\r
+        15 - ( expDiff < 0 ),\r
+        &aSig0,\r
+        &aSig1\r
+    );\r
+    shortShift128Left(\r
+        bSig0 | LIT64( 0x0001000000000000 ), bSig1, 15, &bSig0, &bSig1 );\r
+    q = le128( bSig0, bSig1, aSig0, aSig1 );\r
+    if ( q ) sub128( aSig0, aSig1, bSig0, bSig1, &aSig0, &aSig1 );\r
+    expDiff -= 64;\r
+    while ( 0 < expDiff ) {\r
+        q = estimateDiv128To64( aSig0, aSig1, bSig0 );\r
+        q = ( 4 < q ) ? q - 4 : 0;\r
+        mul128By64To192( bSig0, bSig1, q, &term0, &term1, &term2 );\r
+        shortShift192Left( term0, term1, term2, 61, &term1, &term2, &allZero );\r
+        shortShift128Left( aSig0, aSig1, 61, &aSig0, &allZero );\r
+        sub128( aSig0, 0, term1, term2, &aSig0, &aSig1 );\r
+        expDiff -= 61;\r
+    }\r
+    if ( -64 < expDiff ) {\r
+        q = estimateDiv128To64( aSig0, aSig1, bSig0 );\r
+        q = ( 4 < q ) ? q - 4 : 0;\r
+        q >>= - expDiff;\r
+        shift128Right( bSig0, bSig1, 12, &bSig0, &bSig1 );\r
+        expDiff += 52;\r
+        if ( expDiff < 0 ) {\r
+            shift128Right( aSig0, aSig1, - expDiff, &aSig0, &aSig1 );\r
+        }\r
+        else {\r
+            shortShift128Left( aSig0, aSig1, expDiff, &aSig0, &aSig1 );\r
+        }\r
+        mul128By64To192( bSig0, bSig1, q, &term0, &term1, &term2 );\r
+        sub128( aSig0, aSig1, term1, term2, &aSig0, &aSig1 );\r
+    }\r
+    else {\r
+        shift128Right( aSig0, aSig1, 12, &aSig0, &aSig1 );\r
+        shift128Right( bSig0, bSig1, 12, &bSig0, &bSig1 );\r
+    }\r
+    do {\r
+        alternateASig0 = aSig0;\r
+        alternateASig1 = aSig1;\r
+        ++q;\r
+        sub128( aSig0, aSig1, bSig0, bSig1, &aSig0, &aSig1 );\r
+    } while ( 0 <= (sbits64) aSig0 );\r
+    add128(\r
+        aSig0, aSig1, alternateASig0, alternateASig1, (bits64*)&sigMean0, &sigMean1 );\r
+    if (    ( sigMean0 < 0 )\r
+         || ( ( ( sigMean0 | sigMean1 ) == 0 ) && ( q & 1 ) ) ) {\r
+        aSig0 = alternateASig0;\r
+        aSig1 = alternateASig1;\r
+    }\r
+    zSign = ( (sbits64) aSig0 < 0 );\r
+    if ( zSign ) sub128( 0, 0, aSig0, aSig1, &aSig0, &aSig1 );\r
+    return\r
+        normalizeRoundAndPackFloat128( sf,  aSign ^ zSign, bExp - 4, aSig0, aSig1 );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the square root of the quadruple-precision floating-point value `a'.\r
+| The operation is performed according to the IEC/IEEE Standard for Binary\r
+| Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+float128 float128_sqrt( softfloat_t* sf, float128 a )\r
+{\r
+    flag aSign;\r
+    int32_t aExp, zExp;\r
+    bits64 aSig0, aSig1, zSig0, zSig1, zSig2, doubleZSig0;\r
+    bits64 rem0, rem1, rem2, rem3, term0, term1, term2, term3;\r
+    float128 z;\r
+\r
+    aSig1 = extractFloat128Frac1( a );\r
+    aSig0 = extractFloat128Frac0( a );\r
+    aExp = extractFloat128Exp( a );\r
+    aSign = extractFloat128Sign( a );\r
+    if ( aExp == 0x7FFF ) {\r
+        if ( aSig0 | aSig1 ) return propagateFloat128NaN( sf, a, a );\r
+        if ( ! aSign ) return a;\r
+        goto invalid;\r
+    }\r
+    if ( aSign ) {\r
+        if ( ( aExp | aSig0 | aSig1 ) == 0 ) return a;\r
+ invalid:\r
+        float_raise( sf, float_flag_invalid );\r
+        z.low = float128_default_nan_low;\r
+        z.high = float128_default_nan_high;\r
+        return z;\r
+    }\r
+    if ( aExp == 0 ) {\r
+        if ( ( aSig0 | aSig1 ) == 0 ) return packFloat128( 0, 0, 0, 0 );\r
+        normalizeFloat128Subnormal( aSig0, aSig1, &aExp, &aSig0, &aSig1 );\r
+    }\r
+    zExp = ( ( aExp - 0x3FFF )>>1 ) + 0x3FFE;\r
+    aSig0 |= LIT64( 0x0001000000000000 );\r
+    zSig0 = estimateSqrt32( aExp, aSig0>>17 );\r
+    shortShift128Left( aSig0, aSig1, 13 - ( aExp & 1 ), &aSig0, &aSig1 );\r
+    zSig0 = estimateDiv128To64( aSig0, aSig1, zSig0<<32 ) + ( zSig0<<30 );\r
+    doubleZSig0 = zSig0<<1;\r
+    mul64To128( zSig0, zSig0, &term0, &term1 );\r
+    sub128( aSig0, aSig1, term0, term1, &rem0, &rem1 );\r
+    while ( (sbits64) rem0 < 0 ) {\r
+        --zSig0;\r
+        doubleZSig0 -= 2;\r
+        add128( rem0, rem1, zSig0>>63, doubleZSig0 | 1, &rem0, &rem1 );\r
+    }\r
+    zSig1 = estimateDiv128To64( rem1, 0, doubleZSig0 );\r
+    if ( ( zSig1 & 0x1FFF ) <= 5 ) {\r
+        if ( zSig1 == 0 ) zSig1 = 1;\r
+        mul64To128( doubleZSig0, zSig1, &term1, &term2 );\r
+        sub128( rem1, 0, term1, term2, &rem1, &rem2 );\r
+        mul64To128( zSig1, zSig1, &term2, &term3 );\r
+        sub192( rem1, rem2, 0, 0, term2, term3, &rem1, &rem2, &rem3 );\r
+        while ( (sbits64) rem1 < 0 ) {\r
+            --zSig1;\r
+            shortShift128Left( 0, zSig1, 1, &term2, &term3 );\r
+            term3 |= 1;\r
+            term2 |= doubleZSig0;\r
+            add192( rem1, rem2, rem3, 0, term2, term3, &rem1, &rem2, &rem3 );\r
+        }\r
+        zSig1 |= ( ( rem1 | rem2 | rem3 ) != 0 );\r
+    }\r
+    shift128ExtraRightJamming( zSig0, zSig1, 0, 14, &zSig0, &zSig1, &zSig2 );\r
+    return roundAndPackFloat128( sf,  0, zExp, zSig0, zSig1, zSig2 );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns 1 if the quadruple-precision floating-point value `a' is equal to\r
+| the corresponding value `b', and 0 otherwise.  The comparison is performed\r
+| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+flag float128_eq( softfloat_t* sf, float128 a, float128 b )\r
+{\r
+\r
+    if (    (    ( extractFloat128Exp( a ) == 0x7FFF )\r
+              && ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )\r
+         || (    ( extractFloat128Exp( b ) == 0x7FFF )\r
+              && ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )\r
+       ) {\r
+        if (    float128_is_signaling_nan( sf, a )\r
+             || float128_is_signaling_nan( sf, b ) ) {\r
+            float_raise( sf, float_flag_invalid );\r
+        }\r
+        return 0;\r
+    }\r
+    return\r
+           ( a.low == b.low )\r
+        && (    ( a.high == b.high )\r
+             || (    ( a.low == 0 )\r
+                  && ( (bits64) ( ( a.high | b.high )<<1 ) == 0 ) )\r
+           );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns 1 if the quadruple-precision floating-point value `a' is less than\r
+| or equal to the corresponding value `b', and 0 otherwise.  The comparison\r
+| is performed according to the IEC/IEEE Standard for Binary Floating-Point\r
+| Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+flag float128_le( softfloat_t* sf, float128 a, float128 b )\r
+{\r
+    flag aSign, bSign;\r
+\r
+    if (    (    ( extractFloat128Exp( a ) == 0x7FFF )\r
+              && ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )\r
+         || (    ( extractFloat128Exp( b ) == 0x7FFF )\r
+              && ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )\r
+       ) {\r
+        float_raise( sf, float_flag_invalid );\r
+        return 0;\r
+    }\r
+    aSign = extractFloat128Sign( a );\r
+    bSign = extractFloat128Sign( b );\r
+    if ( aSign != bSign ) {\r
+        return\r
+               aSign\r
+            || (    ( ( (bits64) ( ( a.high | b.high )<<1 ) ) | a.low | b.low )\r
+                 == 0 );\r
+    }\r
+    return\r
+          aSign ? le128( b.high, b.low, a.high, a.low )\r
+        : le128( a.high, a.low, b.high, b.low );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns 1 if the quadruple-precision floating-point value `a' is less than\r
+| the corresponding value `b', and 0 otherwise.  The comparison is performed\r
+| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+flag float128_lt( softfloat_t* sf, float128 a, float128 b )\r
+{\r
+    flag aSign, bSign;\r
+\r
+    if (    (    ( extractFloat128Exp( a ) == 0x7FFF )\r
+              && ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )\r
+         || (    ( extractFloat128Exp( b ) == 0x7FFF )\r
+              && ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )\r
+       ) {\r
+        float_raise( sf, float_flag_invalid );\r
+        return 0;\r
+    }\r
+    aSign = extractFloat128Sign( a );\r
+    bSign = extractFloat128Sign( b );\r
+    if ( aSign != bSign ) {\r
+        return\r
+               aSign\r
+            && (    ( ( (bits64) ( ( a.high | b.high )<<1 ) ) | a.low | b.low )\r
+                 != 0 );\r
+    }\r
+    return\r
+          aSign ? lt128( b.high, b.low, a.high, a.low )\r
+        : lt128( a.high, a.low, b.high, b.low );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns 1 if the quadruple-precision floating-point value `a' is equal to\r
+| the corresponding value `b', and 0 otherwise.  The invalid exception is\r
+| raised if either operand is a NaN.  Otherwise, the comparison is performed\r
+| according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+flag float128_eq_signaling( softfloat_t* sf, float128 a, float128 b )\r
+{\r
+\r
+    if (    (    ( extractFloat128Exp( a ) == 0x7FFF )\r
+              && ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )\r
+         || (    ( extractFloat128Exp( b ) == 0x7FFF )\r
+              && ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )\r
+       ) {\r
+        float_raise( sf, float_flag_invalid );\r
+        return 0;\r
+    }\r
+    return\r
+           ( a.low == b.low )\r
+        && (    ( a.high == b.high )\r
+             || (    ( a.low == 0 )\r
+                  && ( (bits64) ( ( a.high | b.high )<<1 ) == 0 ) )\r
+           );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns 1 if the quadruple-precision floating-point value `a' is less than\r
+| or equal to the corresponding value `b', and 0 otherwise.  Quiet NaNs do not\r
+| cause an exception.  Otherwise, the comparison is performed according to the\r
+| IEC/IEEE Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+flag float128_le_quiet( softfloat_t* sf, float128 a, float128 b )\r
+{\r
+    flag aSign, bSign;\r
+\r
+    if (    (    ( extractFloat128Exp( a ) == 0x7FFF )\r
+              && ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )\r
+         || (    ( extractFloat128Exp( b ) == 0x7FFF )\r
+              && ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )\r
+       ) {\r
+        if (    float128_is_signaling_nan( sf, a )\r
+             || float128_is_signaling_nan( sf, b ) ) {\r
+            float_raise( sf, float_flag_invalid );\r
+        }\r
+        return 0;\r
+    }\r
+    aSign = extractFloat128Sign( a );\r
+    bSign = extractFloat128Sign( b );\r
+    if ( aSign != bSign ) {\r
+        return\r
+               aSign\r
+            || (    ( ( (bits64) ( ( a.high | b.high )<<1 ) ) | a.low | b.low )\r
+                 == 0 );\r
+    }\r
+    return\r
+          aSign ? le128( b.high, b.low, a.high, a.low )\r
+        : le128( a.high, a.low, b.high, b.low );\r
+\r
+}\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns 1 if the quadruple-precision floating-point value `a' is less than\r
+| the corresponding value `b', and 0 otherwise.  Quiet NaNs do not cause an\r
+| exception.  Otherwise, the comparison is performed according to the IEC/IEEE\r
+| Standard for Binary Floating-Point Arithmetic.\r
+*----------------------------------------------------------------------------*/\r
+\r
+flag float128_lt_quiet( softfloat_t* sf, float128 a, float128 b )\r
+{\r
+    flag aSign, bSign;\r
+\r
+    if (    (    ( extractFloat128Exp( a ) == 0x7FFF )\r
+              && ( extractFloat128Frac0( a ) | extractFloat128Frac1( a ) ) )\r
+         || (    ( extractFloat128Exp( b ) == 0x7FFF )\r
+              && ( extractFloat128Frac0( b ) | extractFloat128Frac1( b ) ) )\r
+       ) {\r
+        if (    float128_is_signaling_nan( sf, a )\r
+             || float128_is_signaling_nan( sf, b ) ) {\r
+            float_raise( sf, float_flag_invalid );\r
+        }\r
+        return 0;\r
+    }\r
+    aSign = extractFloat128Sign( a );\r
+    bSign = extractFloat128Sign( b );\r
+    if ( aSign != bSign ) {\r
+        return\r
+               aSign\r
+            && (    ( ( (bits64) ( ( a.high | b.high )<<1 ) ) | a.low | b.low )\r
+                 != 0 );\r
+    }\r
+    return\r
+          aSign ? lt128( b.high, b.low, a.high, a.low )\r
+        : lt128( a.high, a.low, b.high, b.low );\r
+\r
+}\r
+\r
+#endif\r
+\r
diff --git a/kern/arch/sparc/softfloat.h b/kern/arch/sparc/softfloat.h
new file mode 100644 (file)
index 0000000..7a766a7
--- /dev/null
@@ -0,0 +1,358 @@
+#ifndef _SOFTFLOAT_H
+#define _SOFTFLOAT_H
+
+#ifdef __cplusplus
+  extern "C" {
+#endif
+
+/*============================================================================
+
+This C header file is part of the SoftFloat IEC/IEEE Floating-point Arithmetic
+Package, Release 2b.
+
+Written by John R. Hauser.  This work was made possible in part by the
+International Computer Science Institute, located at Suite 600, 1947 Center
+Street, Berkeley, California 94704.  Funding was partially provided by the
+National Science Foundation under grant MIP-9311980.  The original version
+of this code was written as part of a project to build a fixed-point vector
+processor in collaboration with the University of California at Berkeley,
+overseen by Profs. Nelson Morgan and John Wawrzynek.  More information
+is available through the Web page `http://www.cs.berkeley.edu/~jhauser/
+arithmetic/SoftFloat.html'.
+
+THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort has
+been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES
+RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS
+AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES,
+COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE
+EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE
+INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR
+OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE.
+
+Derivative works are acceptable, even for commercial purposes, so long as
+(1) the source code for the derivative work includes prominent notice that
+the work is derivative, and (2) the source code includes prominent notice with
+these four paragraphs for those parts of this code that are retained.
+
+=============================================================================*/
+
+/*----------------------------------------------------------------------------
+| The macro `FLOATX80' must be defined to enable the extended double-precision
+| floating-point format `floatx80'.  If this macro is not defined, the
+| `floatx80' type will not be defined, and none of the functions that either
+| input or output the `floatx80' type will be defined.  The same applies to
+| the `FLOAT128' macro and the quadruple-precision format `float128'.
+*----------------------------------------------------------------------------*/
+#define FLOATX80
+#define FLOAT128
+
+#include <arch/types.h>
+
+/* asw */
+typedef uint8_t flag;
+typedef uint8_t bits8;
+typedef int8_t sbits8;
+typedef uint16_t bits16;
+typedef int16_t sbits16;
+typedef uint32_t bits32;
+typedef int32_t sbits32;
+typedef uint64_t bits64;
+typedef int64_t sbits64;
+
+#define INLINE
+#define LIT64( a ) a##LL
+
+/*----------------------------------------------------------------------------
+| Software IEC/IEEE floating-point types.
+*----------------------------------------------------------------------------*/
+typedef unsigned int float32;
+typedef unsigned long long float64;
+#ifdef FLOATX80
+typedef struct {
+    unsigned short high;
+    unsigned long long low;
+} floatx80;
+#endif
+#ifdef FLOAT128
+typedef struct {
+    unsigned long long high, low;
+} float128;
+#endif
+
+/*----------------------------------------------------------------------------
+| Internal canonical NaN format.
+*----------------------------------------------------------------------------*/
+typedef struct {
+    flag sign;
+    bits64 high, low;
+} commonNaNT;
+
+INLINE bits32 extractFloat32Frac( float32 a );
+INLINE int16_t extractFloat32Exp( float32 a );
+INLINE flag extractFloat32Sign( float32 a );
+INLINE float32 packFloat32( flag zSign, int16_t zExp, bits32 zSig );
+INLINE bits64 extractFloat64Frac( float64 a );
+INLINE int16_t extractFloat64Exp( float64 a );
+INLINE flag extractFloat64Sign( float64 a );
+INLINE float64 packFloat64( flag zSign, int16_t zExp, bits64 zSig );
+INLINE bits64 extractFloatx80Frac( floatx80 a );
+INLINE int32_t extractFloatx80Exp( floatx80 a );
+INLINE flag extractFloatx80Sign( floatx80 a );
+INLINE floatx80 packFloatx80( flag zSign, int32_t zExp, bits64 zSig );
+INLINE bits64 extractFloat128Frac1( float128 a );
+INLINE bits64 extractFloat128Frac0( float128 a );
+INLINE int32_t extractFloat128Exp( float128 a );
+INLINE flag extractFloat128Sign( float128 a );
+INLINE float128 packFloat128( flag zSign, int32_t zExp, bits64 zSig0, bits64 zSig1 );
+
+typedef struct
+{
+  int8_t float_detect_tininess;
+  int8_t float_rounding_mode;
+  int8_t float_exception_flags;
+  #ifdef FLOATX80
+    int floatx80_rounding_precision;
+  #endif
+} softfloat_t;
+
+float32 subFloat32Sigs( softfloat_t* sf, float32 a, float32 b, flag zSign );
+float64 subFloat64Sigs( softfloat_t* sf, float64 a, float64 b, flag zSign );
+floatx80 subFloatx80Sigs( softfloat_t* sf, floatx80 a, floatx80 b, flag zSign );
+float128 subFloat128Sigs( softfloat_t* sf, float128 a, float128 b, flag zSign );
+float32 addFloat32Sigs( softfloat_t* sf, float32 a, float32 b, flag zSign );
+float64 addFloat64Sigs( softfloat_t* sf, float64 a, float64 b, flag zSign );
+floatx80 addFloatx80Sigs( softfloat_t* sf, floatx80 a, floatx80 b, flag zSign );
+float128 addFloat128Sigs( softfloat_t* sf, float128 a, float128 b, flag zSign );
+float32 normalizeRoundAndPackFloat32( softfloat_t* sf, flag zSign, int16_t zExp, bits32 zSig );
+float64 normalizeRoundAndPackFloat64( softfloat_t* sf, flag zSign, int16_t zExp, bits64 zSig );
+floatx80 normalizeRoundAndPackFloatx80( softfloat_t* sf,
+     int8_t roundingPrecision, flag zSign, int32_t zExp, bits64 zSig0, bits64 zSig1);
+float128 normalizeRoundAndPackFloat128( softfloat_t* sf,
+     flag zSign, int32_t zExp, bits64 zSig0, bits64 zSig1 );
+int32_t roundAndPackInt32( softfloat_t* sf, flag zSign, bits64 absZ );
+int64_t roundAndPackInt64( softfloat_t* sf, flag zSign, bits64 absZ0, bits64 absZ1 );
+float32 roundAndPackFloat32( softfloat_t* sf, flag zSign, int16_t zExp, bits32 zSig );
+float64 roundAndPackFloat64( softfloat_t* sf, flag zSign, int16_t zExp, bits64 zSig );
+floatx80 roundAndPackFloatx80( softfloat_t* sf,
+     int8_t roundingPrecision, flag zSign, int32_t zExp, bits64 zSig0, bits64 zSig1);
+float128 roundAndPackFloat128( softfloat_t* sf,
+     flag zSign, int32_t zExp, bits64 zSig0, bits64 zSig1, bits64 zSig2 );
+void normalizeFloat32Subnormal( bits32 aSig, int16_t *zExpPtr, bits32 *zSigPtr );
+void normalizeFloat64Subnormal( bits64 aSig, int16_t *zExpPtr, bits64 *zSigPtr );
+void normalizeFloatx80Subnormal( bits64 aSig, int32_t *zExpPtr, bits64 *zSigPtr );
+void normalizeFloat128Subnormal(
+     bits64 aSig0,
+     bits64 aSig1,
+     int32_t *zExpPtr,
+     bits64 *zSig0Ptr,
+     bits64 *zSig1Ptr
+ );
+
+INLINE flag float32_is_nan( softfloat_t* sf, float32 a );
+commonNaNT float32ToCommonNaN( softfloat_t* sf, float32 a );
+float32 commonNaNToFloat32( softfloat_t* sf, commonNaNT a );
+float32 propagateFloat32NaN( softfloat_t* sf, float32 a, float32 b );
+flag float64_is_nan( softfloat_t* sf, float64 a );
+commonNaNT float64ToCommonNaN( softfloat_t* sf, float64 a );
+float64 commonNaNToFloat64( softfloat_t* sf, commonNaNT a );
+float64 propagateFloat64NaN( softfloat_t* sf, float64 a, float64 b );
+flag floatx80_is_nan( softfloat_t* sf, floatx80 a );
+commonNaNT floatx80ToCommonNaN( softfloat_t* sf, floatx80 a );
+floatx80 commonNaNToFloatx80( softfloat_t* sf, commonNaNT a );
+floatx80 propagateFloatx80NaN( softfloat_t* sf, floatx80 a, floatx80 b );
+flag float128_is_nan( softfloat_t* sf, float128 a );
+commonNaNT float128ToCommonNaN( softfloat_t* sf, float128 a );
+float128 commonNaNToFloat128( softfloat_t* sf, commonNaNT a );
+float128 propagateFloat128NaN( softfloat_t* sf, float128 a, float128 b );
+
+/*----------------------------------------------------------------------------
+| Routine to raise any or all of the software IEC/IEEE floating-point
+| exception flags.
+*----------------------------------------------------------------------------*/
+INLINE void float_raise( softfloat_t* sf, int );
+
+/*----------------------------------------------------------------------------
+| Software IEC/IEEE integer-to-floating-point conversion routines.
+*----------------------------------------------------------------------------*/
+float32 int32_to_float32( softfloat_t* sf, int );
+float64 int32_to_float64( softfloat_t* sf, int );
+#ifdef FLOATX80
+floatx80 int32_to_floatx80( softfloat_t* sf, int );
+#endif
+#ifdef FLOAT128
+float128 int32_to_float128( softfloat_t* sf, int );
+#endif
+float32 int64_to_float32( softfloat_t* sf, long long );
+float64 int64_to_float64( softfloat_t* sf, long long );
+#ifdef FLOATX80
+floatx80 int64_to_floatx80( softfloat_t* sf, long long );
+#endif
+#ifdef FLOAT128
+float128 int64_to_float128( softfloat_t* sf, long long );
+#endif
+
+/*----------------------------------------------------------------------------
+| Software IEC/IEEE single-precision conversion routines.
+*----------------------------------------------------------------------------*/
+int float32_to_int32( softfloat_t* sf, float32 );
+int float32_to_int32_round_to_zero( softfloat_t* sf, float32 );
+long long float32_to_int64( softfloat_t* sf, float32 );
+long long float32_to_int64_round_to_zero( softfloat_t* sf, float32 );
+float64 float32_to_float64( softfloat_t* sf, float32 );
+#ifdef FLOATX80
+floatx80 float32_to_floatx80( softfloat_t* sf, float32 );
+#endif
+#ifdef FLOAT128
+float128 float32_to_float128( softfloat_t* sf, float32 );
+#endif
+
+/*----------------------------------------------------------------------------
+| Software IEC/IEEE single-precision operations.
+*----------------------------------------------------------------------------*/
+float32 float32_round_to_int( softfloat_t* sf, float32 );
+float32 float32_add( softfloat_t* sf, float32, float32 );
+float32 float32_sub( softfloat_t* sf, float32, float32 );
+float32 float32_mul( softfloat_t* sf, float32, float32 );
+float32 float32_div( softfloat_t* sf, float32, float32 );
+float32 float32_rem( softfloat_t* sf, float32, float32 );
+float32 float32_sqrt( softfloat_t* sf, float32 );
+flag float32_eq( softfloat_t* sf, float32, float32 );
+flag float32_le( softfloat_t* sf, float32, float32 );
+flag float32_lt( softfloat_t* sf, float32, float32 );
+flag float32_eq_signaling( softfloat_t* sf, float32, float32 );
+flag float32_le_quiet( softfloat_t* sf, float32, float32 );
+flag float32_lt_quiet( softfloat_t* sf, float32, float32 );
+flag float32_is_signaling_nan( softfloat_t* sf, float32 );
+
+/*----------------------------------------------------------------------------
+| Software IEC/IEEE double-precision conversion routines.
+*----------------------------------------------------------------------------*/
+int float64_to_int32( softfloat_t* sf, float64 );
+int float64_to_int32_round_to_zero( softfloat_t* sf, float64 );
+long long float64_to_int64( softfloat_t* sf, float64 );
+long long float64_to_int64_round_to_zero( softfloat_t* sf, float64 );
+float32 float64_to_float32( softfloat_t* sf, float64 );
+#ifdef FLOATX80
+floatx80 float64_to_floatx80( softfloat_t* sf, float64 );
+#endif
+#ifdef FLOAT128
+float128 float64_to_float128( softfloat_t* sf, float64 );
+#endif
+
+/*----------------------------------------------------------------------------
+| Software IEC/IEEE double-precision operations.
+*----------------------------------------------------------------------------*/
+float64 float64_round_to_int( softfloat_t* sf, float64 );
+float64 float64_add( softfloat_t* sf, float64, float64 );
+float64 float64_sub( softfloat_t* sf, float64, float64 );
+float64 float64_mul( softfloat_t* sf, float64, float64 );
+float64 float64_div( softfloat_t* sf, float64, float64 );
+float64 float64_rem( softfloat_t* sf, float64, float64 );
+float64 float64_sqrt( softfloat_t* sf, float64 );
+flag float64_eq( softfloat_t* sf, float64, float64 );
+flag float64_le( softfloat_t* sf, float64, float64 );
+flag float64_lt( softfloat_t* sf, float64, float64 );
+flag float64_eq_signaling( softfloat_t* sf, float64, float64 );
+flag float64_le_quiet( softfloat_t* sf, float64, float64 );
+flag float64_lt_quiet( softfloat_t* sf, float64, float64 );
+flag float64_is_signaling_nan( softfloat_t* sf, float64 );
+
+#ifdef FLOATX80
+
+/*----------------------------------------------------------------------------
+| Software IEC/IEEE extended double-precision conversion routines.
+*----------------------------------------------------------------------------*/
+int floatx80_to_int32( softfloat_t* sf, floatx80 );
+int floatx80_to_int32_round_to_zero( softfloat_t* sf, floatx80 );
+long long floatx80_to_int64( softfloat_t* sf, floatx80 );
+long long floatx80_to_int64_round_to_zero( softfloat_t* sf, floatx80 );
+float32 floatx80_to_float32( softfloat_t* sf, floatx80 );
+float64 floatx80_to_float64( softfloat_t* sf, floatx80 );
+#ifdef FLOAT128
+float128 floatx80_to_float128( softfloat_t* sf, floatx80 );
+#endif
+
+#endif
+
+#ifdef FLOATX80
+/*----------------------------------------------------------------------------
+| Software IEC/IEEE extended double-precision operations.
+*----------------------------------------------------------------------------*/
+floatx80 floatx80_round_to_int( softfloat_t* sf, floatx80 );
+floatx80 floatx80_add( softfloat_t* sf, floatx80, floatx80 );
+floatx80 floatx80_sub( softfloat_t* sf, floatx80, floatx80 );
+floatx80 floatx80_mul( softfloat_t* sf, floatx80, floatx80 );
+floatx80 floatx80_div( softfloat_t* sf, floatx80, floatx80 );
+floatx80 floatx80_rem( softfloat_t* sf, floatx80, floatx80 );
+floatx80 floatx80_sqrt( softfloat_t* sf, floatx80 );
+flag floatx80_eq( softfloat_t* sf, floatx80, floatx80 );
+flag floatx80_le( softfloat_t* sf, floatx80, floatx80 );
+flag floatx80_lt( softfloat_t* sf, floatx80, floatx80 );
+flag floatx80_eq_signaling( softfloat_t* sf, floatx80, floatx80 );
+flag floatx80_le_quiet( softfloat_t* sf, floatx80, floatx80 );
+flag floatx80_lt_quiet( softfloat_t* sf, floatx80, floatx80 );
+flag floatx80_is_signaling_nan( softfloat_t* sf, floatx80 );
+#endif
+
+#ifdef FLOAT128
+
+/*----------------------------------------------------------------------------
+| Software IEC/IEEE quadruple-precision conversion routines.
+*----------------------------------------------------------------------------*/
+int float128_to_int32( softfloat_t* sf, float128 );
+int float128_to_int32_round_to_zero( softfloat_t* sf, float128 );
+long long float128_to_int64( softfloat_t* sf, float128 );
+long long float128_to_int64_round_to_zero( softfloat_t* sf, float128 );
+float32 float128_to_float32( softfloat_t* sf, float128 );
+float64 float128_to_float64( softfloat_t* sf, float128 );
+#ifdef FLOATX80
+floatx80 float128_to_floatx80( softfloat_t* sf, float128 );
+#endif
+
+/*----------------------------------------------------------------------------
+| Software IEC/IEEE quadruple-precision operations.
+*----------------------------------------------------------------------------*/
+float128 float128_round_to_int( softfloat_t* sf, float128 );
+float128 float128_add( softfloat_t* sf, float128, float128 );
+float128 float128_sub( softfloat_t* sf, float128, float128 );
+float128 float128_mul( softfloat_t* sf, float128, float128 );
+float128 float128_div( softfloat_t* sf, float128, float128 );
+float128 float128_rem( softfloat_t* sf, float128, float128 );
+float128 float128_sqrt( softfloat_t* sf, float128 );
+flag float128_eq( softfloat_t* sf, float128, float128 );
+flag float128_le( softfloat_t* sf, float128, float128 );
+flag float128_lt( softfloat_t* sf, float128, float128 );
+flag float128_eq_signaling( softfloat_t* sf, float128, float128 );
+flag float128_le_quiet( softfloat_t* sf, float128, float128 );
+flag float128_lt_quiet( softfloat_t* sf, float128, float128 );
+flag float128_is_signaling_nan( softfloat_t* sf, float128 );
+
+#endif
+
+void softfloat_init(softfloat_t* sf);
+
+enum {
+    float_tininess_after_rounding  = 0,
+    float_tininess_before_rounding = 1
+};
+
+enum {
+    float_round_nearest_even = 0,
+    float_round_to_zero      = 1,
+    float_round_up           = 2,
+    float_round_down         = 3
+};
+
+enum {
+    float_flag_inexact   =  1,
+    float_flag_divbyzero =  2,
+    float_flag_underflow =  4,
+    float_flag_overflow  =  8,
+    float_flag_invalid   = 16
+};
+
+#ifdef __cplusplus
+ }
+#endif
+
+#endif
diff --git a/kern/arch/sparc/sparcfpu.c b/kern/arch/sparc/sparcfpu.c
new file mode 100644 (file)
index 0000000..d0663c4
--- /dev/null
@@ -0,0 +1,443 @@
+/* Author: Andrew S. Waterman
+ *         Parallel Computing Laboratory
+ *         Electrical Engineering and Computer Sciences
+ *         University of California, Berkeley
+ *
+ * Copyright (c) 2008, 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 of California, Berkeley 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 ''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 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 <arch/sparcfpu.h>
+#include <assert.h>
+#include <string.h>
+
+void sparcfpu_init(sparcfpu_t* fpu)
+{
+  memset(fpu->freg,0,sizeof(fpu->freg));
+  memset(&fpu->FSR,0,sizeof(fpu->FSR));
+  static_assert(sizeof(fpu->FSR) == 4);
+  softfloat_init(&fpu->softfloat);
+}
+
+void sparcfpu_setFSR(sparcfpu_t* fpu, uint32_t newFSR)
+{
+  fpu->FSR.rd = newFSR >> 30;
+  fpu->FSR.TEM = newFSR >> 23;
+  fpu->FSR.ftt = newFSR >> 14;
+  fpu->FSR.aexc = newFSR >> 5;
+  fpu->FSR.cexc = newFSR;
+}
+
+uint32_t sparcfpu_getFSR(sparcfpu_t* fpu)
+{
+  return fpu->FSR.rd   << 30 |
+         fpu->FSR.TEM  << 23 |
+         fpu->FSR.ftt  << 14 |
+         fpu->FSR.aexc <<  5 |
+         fpu->FSR.cexc;
+}
+
+#define fpop1_trap_if(cond,code) do { if(cond) { fpu->FSR.ftt = (code); goto fpop1_done; } } while(0)
+#define fpop2_trap_if(cond,code) do { if(cond) { fpu->FSR.ftt = (code); goto fpop2_done; } } while(0)
+
+#define handle_exceptions(fpop,allowed) do { \
+  assert(!(fpu->softfloat.float_exception_flags & ~(allowed))); \
+  if(fpu->FSR.TEM & fpu->softfloat.float_exception_flags) \
+  { \
+    fpu->FSR.cexc = fpu->softfloat.float_exception_flags; \
+    fpop##_trap_if(1,fp_trap_IEEE_754_exception); \
+  } \
+  fpu->FSR.aexc |= fpu->softfloat.float_exception_flags; \
+  } while(0)
+
+#define fpop1_handle_exceptions(allowed) handle_exceptions(fpop1,allowed)
+#define fpop2_handle_exceptions(allowed) handle_exceptions(fpop2,allowed)
+
+#define fpop1_check_double_align(reg) fpop1_trap_if((reg)&1,fp_trap_invalid_fp_register)
+#define fpop2_check_double_align(reg) fpop2_trap_if((reg)&1,fp_trap_invalid_fp_register)
+#define fpop1_check_quad_align(reg) fpop1_trap_if((reg)&3,fp_trap_invalid_fp_register)
+#define fpop2_check_quad_align(reg) fpop2_trap_if((reg)&3,fp_trap_invalid_fp_register)
+
+void sparcfpu_fpop1(sparcfpu_t* fpu, fp_insn_t insn)
+{
+  fpu->FSR.ftt = 0;
+  fpu->softfloat.float_exception_flags = 0;
+  fpu->softfloat.float_rounding_mode = fpu->FSR.rd;
+
+  switch(insn.opf)
+  {
+    case opFiTOs: {
+      float32 f = int32_to_float32(&fpu->softfloat,sparcfpu_regs(fpu,insn.rs2));
+      fpop1_handle_exceptions(float_flag_inexact);
+      sparcfpu_wrregs(fpu,insn.rd,f);
+      break;
+    }
+    case opFiTOd: {
+      fpop1_check_double_align(insn.rd);
+      float64 f = int32_to_float64(&fpu->softfloat,sparcfpu_regs(fpu,insn.rs2));
+      fpop1_handle_exceptions(0);
+      sparcfpu_wrregd(fpu,insn.rd,f);
+      break;
+    }
+    case opFiTOq: {
+      fpop1_check_quad_align(insn.rd);
+      float128 f = int32_to_float128(&fpu->softfloat,sparcfpu_regs(fpu,insn.rs2));
+      fpop1_handle_exceptions(0);
+      sparcfpu_wrregq(fpu,insn.rd,f);
+      break;
+    }
+    case opFsTOi: {
+      fpu->softfloat.float_rounding_mode = float_round_to_zero;
+      int32_t i = float32_to_int32(&fpu->softfloat,sparcfpu_regs(fpu,insn.rs2));
+      fpop1_handle_exceptions(float_flag_inexact | float_flag_invalid);
+      sparcfpu_wrregs(fpu,insn.rd,i);
+      break;
+    }
+    case opFdTOi: {
+      fpu->softfloat.float_rounding_mode = float_round_to_zero;
+      fpop1_check_double_align(insn.rs2);
+      int32_t i = float64_to_int32(&fpu->softfloat,sparcfpu_regd(fpu,insn.rs2));
+      fpop1_handle_exceptions(float_flag_inexact | float_flag_invalid);
+      sparcfpu_wrregs(fpu,insn.rd,i);
+      break;
+    }
+    case opFqTOi: {
+      fpu->softfloat.float_rounding_mode = float_round_to_zero;
+      fpop1_check_quad_align(insn.rs2);
+      int32_t i = float128_to_int32(&fpu->softfloat,sparcfpu_regq(fpu,insn.rs2));
+      fpop1_handle_exceptions(float_flag_inexact | float_flag_invalid);
+      sparcfpu_wrregs(fpu,insn.rd,i);
+      break;
+    }
+    case opFsTOd: {
+      fpop1_check_double_align(insn.rd);
+      float64 f = float32_to_float64(&fpu->softfloat,sparcfpu_regs(fpu,insn.rs2));
+      fpop1_handle_exceptions(float_flag_invalid);
+      sparcfpu_wrregd(fpu,insn.rd,f);
+      break;
+    }
+    case opFsTOq: {
+      fpop1_check_quad_align(insn.rd);
+      float128 f = float32_to_float128(&fpu->softfloat,sparcfpu_regs(fpu,insn.rs2));
+      fpop1_handle_exceptions(float_flag_inexact | float_flag_overflow | float_flag_underflow | float_flag_invalid);
+      sparcfpu_wrregq(fpu,insn.rd,f);
+      break;
+    }
+    case opFdTOs: {
+      fpop1_check_double_align(insn.rs2);
+      float32 f = float64_to_float32(&fpu->softfloat,sparcfpu_regd(fpu,insn.rs2));
+      fpop1_handle_exceptions(float_flag_inexact | float_flag_overflow | float_flag_underflow | float_flag_invalid);
+      sparcfpu_wrregs(fpu,insn.rd,f);
+      break;
+    }
+    case opFdTOq: {
+      fpop1_check_double_align(insn.rs2);
+      fpop1_check_quad_align(insn.rd);
+      float128 f = float64_to_float128(&fpu->softfloat,sparcfpu_regd(fpu,insn.rs2));
+      fpop1_handle_exceptions(float_flag_invalid);
+      sparcfpu_wrregq(fpu,insn.rd,f);
+      break;
+    }
+    case opFqTOs: {
+      fpop1_check_quad_align(insn.rs2);
+      float32 f = float128_to_float32(&fpu->softfloat,sparcfpu_regq(fpu,insn.rs2));
+      fpop1_handle_exceptions(float_flag_inexact | float_flag_overflow | float_flag_underflow | float_flag_invalid);
+      sparcfpu_wrregs(fpu,insn.rd,f);
+      break;
+    }
+    case opFqTOd: {
+      fpop1_check_quad_align(insn.rs2);
+      fpop1_check_double_align(insn.rd);
+      float64 f = float128_to_float64(&fpu->softfloat,sparcfpu_regq(fpu,insn.rs2));
+      fpop1_handle_exceptions(float_flag_inexact | float_flag_overflow | float_flag_underflow | float_flag_invalid);
+      sparcfpu_wrregd(fpu,insn.rd,f);
+      break;
+    }
+    case opFMOVs:
+      sparcfpu_wrregs(fpu,insn.rd,sparcfpu_regs(fpu,insn.rs2));
+      break;
+    case opFNEGs:
+      sparcfpu_wrregs(fpu,insn.rd,sparcfpu_regs(fpu,insn.rs2) ^ 0x80000000);
+      break;
+    case opFABSs:
+      sparcfpu_wrregs(fpu,insn.rd,sparcfpu_regs(fpu,insn.rs2) &~0x80000000);
+      break;
+    case opFSQRTs: {
+      float32 f = float32_sqrt(&fpu->softfloat,sparcfpu_regs(fpu,insn.rs2));
+      fpop1_handle_exceptions(float_flag_inexact | float_flag_invalid);
+      sparcfpu_wrregs(fpu,insn.rd,f);
+      break;
+    }
+    case opFSQRTd: {
+      fpop1_check_double_align(insn.rs2);      
+      fpop1_check_double_align(insn.rd);      
+      float64 f = float64_sqrt(&fpu->softfloat,sparcfpu_regd(fpu,insn.rs2));
+      fpop1_handle_exceptions(float_flag_inexact | float_flag_invalid);
+      sparcfpu_wrregd(fpu,insn.rd,f);
+      break;
+    }
+    case opFSQRTq: {
+      fpop1_check_quad_align(insn.rs2);      
+      fpop1_check_quad_align(insn.rd);      
+      float128 f = float128_sqrt(&fpu->softfloat,sparcfpu_regq(fpu,insn.rs2));
+      fpop1_handle_exceptions(float_flag_inexact | float_flag_invalid);
+      sparcfpu_wrregq(fpu,insn.rd,f);
+      break;
+    }
+    case opFADDs: {
+      float32 f = float32_add(&fpu->softfloat,sparcfpu_regs(fpu,insn.rs1),sparcfpu_regs(fpu,insn.rs2));
+      fpop1_handle_exceptions(float_flag_inexact | float_flag_overflow | float_flag_underflow | float_flag_invalid);
+      sparcfpu_wrregs(fpu,insn.rd,f);
+      break;
+    }
+    case opFADDd: {
+      fpop1_check_double_align(insn.rs1);
+      fpop1_check_double_align(insn.rs2);
+      fpop1_check_double_align(insn.rd);      
+      float64 f = float64_add(&fpu->softfloat,sparcfpu_regd(fpu,insn.rs1),sparcfpu_regd(fpu,insn.rs2));
+      fpop1_handle_exceptions(float_flag_inexact | float_flag_overflow | float_flag_underflow | float_flag_invalid);
+      sparcfpu_wrregd(fpu,insn.rd,f);
+      break;
+    }
+    case opFADDq: {
+      fpop1_check_quad_align(insn.rs1);
+      fpop1_check_quad_align(insn.rs2);
+      fpop1_check_quad_align(insn.rd);      
+      float128 f = float128_add(&fpu->softfloat,sparcfpu_regq(fpu,insn.rs1),sparcfpu_regq(fpu,insn.rs2));
+      fpop1_handle_exceptions(float_flag_inexact | float_flag_overflow | float_flag_underflow | float_flag_invalid);
+      sparcfpu_wrregq(fpu,insn.rd,f);
+      break;
+    }
+    case opFSUBs: {
+      float32 f = float32_sub(&fpu->softfloat,sparcfpu_regs(fpu,insn.rs1),sparcfpu_regs(fpu,insn.rs2));
+      fpop1_handle_exceptions(float_flag_inexact | float_flag_overflow | float_flag_underflow | float_flag_invalid);
+      sparcfpu_wrregs(fpu,insn.rd,f);
+      break;
+    }
+    case opFSUBd: {
+      fpop1_check_double_align(insn.rs1);
+      fpop1_check_double_align(insn.rs2);
+      fpop1_check_double_align(insn.rd);      
+      float64 f = float64_sub(&fpu->softfloat,sparcfpu_regd(fpu,insn.rs1),sparcfpu_regd(fpu,insn.rs2));
+      fpop1_handle_exceptions(float_flag_inexact | float_flag_overflow | float_flag_underflow | float_flag_invalid);
+      sparcfpu_wrregd(fpu,insn.rd,f);
+      break;
+    }
+    case opFSUBq: {
+      fpop1_check_quad_align(insn.rs1);
+      fpop1_check_quad_align(insn.rs2);
+      fpop1_check_quad_align(insn.rd);      
+      float128 f = float128_sub(&fpu->softfloat,sparcfpu_regq(fpu,insn.rs1),sparcfpu_regq(fpu,insn.rs2));
+      fpop1_handle_exceptions(float_flag_inexact | float_flag_overflow | float_flag_underflow | float_flag_invalid);
+      sparcfpu_wrregq(fpu,insn.rd,f);
+      break;
+    }
+    case opFMULs: {
+      float32 f = float32_mul(&fpu->softfloat,sparcfpu_regs(fpu,insn.rs1),sparcfpu_regs(fpu,insn.rs2));
+      fpop1_handle_exceptions(float_flag_inexact | float_flag_overflow | float_flag_underflow | float_flag_invalid);
+      sparcfpu_wrregs(fpu,insn.rd,f);
+      break;
+    }
+    case opFMULd: {
+      fpop1_check_double_align(insn.rs1);
+      fpop1_check_double_align(insn.rs2);
+      fpop1_check_double_align(insn.rd);      
+      float64 f = float64_mul(&fpu->softfloat,sparcfpu_regd(fpu,insn.rs1),sparcfpu_regd(fpu,insn.rs2));
+      fpop1_handle_exceptions(float_flag_inexact | float_flag_overflow | float_flag_underflow | float_flag_invalid);
+      sparcfpu_wrregd(fpu,insn.rd,f);
+      break;
+    }
+    case opFMULq: {
+      fpop1_check_quad_align(insn.rs1);
+      fpop1_check_quad_align(insn.rs2);
+      fpop1_check_quad_align(insn.rd);      
+      float128 f = float128_mul(&fpu->softfloat,sparcfpu_regq(fpu,insn.rs1),sparcfpu_regq(fpu,insn.rs2));
+      fpop1_handle_exceptions(float_flag_inexact | float_flag_overflow | float_flag_underflow | float_flag_invalid);
+      sparcfpu_wrregq(fpu,insn.rd,f);
+      break;
+    }
+    case opFsMULd: {
+      fpop1_check_double_align(insn.rd);      
+      float64 f = float64_mul(&fpu->softfloat,float32_to_float64(&fpu->softfloat,sparcfpu_regs(fpu,insn.rs1)),float32_to_float64(&fpu->softfloat,sparcfpu_regs(fpu,insn.rs2)));
+      fpop1_handle_exceptions(float_flag_inexact | float_flag_overflow | float_flag_underflow | float_flag_invalid);
+      sparcfpu_wrregd(fpu,insn.rd,f);
+      break;
+    }
+    case opFdMULq: {
+      fpop1_check_double_align(insn.rs1);
+      fpop1_check_double_align(insn.rs2);
+      fpop1_check_quad_align(insn.rd);      
+      float128 f = float128_mul(&fpu->softfloat,float64_to_float128(&fpu->softfloat,sparcfpu_regd(fpu,insn.rs1)),float64_to_float128(&fpu->softfloat,sparcfpu_regd(fpu,insn.rs2)));
+      fpop1_handle_exceptions(float_flag_inexact | float_flag_overflow | float_flag_underflow | float_flag_invalid);
+      sparcfpu_wrregq(fpu,insn.rd,f);
+      break;
+    }
+    case opFDIVs: {
+      float32 f = float32_div(&fpu->softfloat,sparcfpu_regs(fpu,insn.rs1),sparcfpu_regs(fpu,insn.rs2));
+      fpop1_handle_exceptions(float_flag_inexact | float_flag_divbyzero | float_flag_overflow | float_flag_underflow | float_flag_invalid);
+      sparcfpu_wrregs(fpu,insn.rd,f);
+      break;
+    }
+    case opFDIVd: {
+      fpop1_check_double_align(insn.rs1);
+      fpop1_check_double_align(insn.rs2);
+      fpop1_check_double_align(insn.rd);      
+      float64 f = float64_div(&fpu->softfloat,sparcfpu_regd(fpu,insn.rs1),sparcfpu_regd(fpu,insn.rs2));
+      fpop1_handle_exceptions(float_flag_inexact | float_flag_divbyzero | float_flag_overflow | float_flag_underflow | float_flag_invalid);
+      sparcfpu_wrregd(fpu,insn.rd,f);
+      break;
+    }
+    case opFDIVq: {
+      fpop1_check_quad_align(insn.rs1);
+      fpop1_check_quad_align(insn.rs2);
+      fpop1_check_quad_align(insn.rd);      
+      float128 f = float128_div(&fpu->softfloat,sparcfpu_regq(fpu,insn.rs1),sparcfpu_regq(fpu,insn.rs2));
+      fpop1_handle_exceptions(float_flag_inexact | float_flag_divbyzero | float_flag_overflow | float_flag_underflow | float_flag_invalid);
+      sparcfpu_wrregq(fpu,insn.rd,f);
+      break;
+    }
+  }
+
+  fpop1_done:
+  ;
+}
+
+void sparcfpu_fpop2(sparcfpu_t* fpu, fp_insn_t insn)
+{
+  fpu->FSR.ftt = 0;
+  fpu->softfloat.float_exception_flags = 0;
+  fpu->softfloat.float_rounding_mode = fpu->FSR.rd;
+
+  switch(insn.opf)
+  {
+    case opFCMPs: {
+      int eq = float32_eq(&fpu->softfloat,sparcfpu_regs(fpu,insn.rs1),sparcfpu_regs(fpu,insn.rs2));
+      fpop2_handle_exceptions(float_flag_invalid);
+      int lt = float32_lt(&fpu->softfloat,sparcfpu_regs(fpu,insn.rs1),sparcfpu_regs(fpu,insn.rs2));
+      int gt = float32_lt(&fpu->softfloat,sparcfpu_regs(fpu,insn.rs2),sparcfpu_regs(fpu,insn.rs1));
+      assert(eq+lt+gt <= 1);
+      fpu->FSR.fcc = eq ? 0 : (lt ? 1 : (gt ? 2 : 3));
+      break;
+    }
+    case opFCMPEs: {
+      int eq = float32_eq_signaling(&fpu->softfloat,sparcfpu_regs(fpu,insn.rs1),sparcfpu_regs(fpu,insn.rs2));
+      fpop2_handle_exceptions(float_flag_invalid);
+      int lt = float32_lt(&fpu->softfloat,sparcfpu_regs(fpu,insn.rs1),sparcfpu_regs(fpu,insn.rs2));
+      int gt = float32_lt(&fpu->softfloat,sparcfpu_regs(fpu,insn.rs2),sparcfpu_regs(fpu,insn.rs1));
+      assert(eq+lt+gt <= 1);
+      fpu->FSR.fcc = eq ? 0 : (lt ? 1 : (gt ? 2 : 3));
+      break;
+    }
+    case opFCMPd: {
+      fpop2_check_double_align(insn.rs1);
+      fpop2_check_double_align(insn.rs2);
+      int eq = float64_eq(&fpu->softfloat,sparcfpu_regd(fpu,insn.rs1),sparcfpu_regd(fpu,insn.rs2));
+      fpop2_handle_exceptions(float_flag_invalid);
+      int lt = float64_lt(&fpu->softfloat,sparcfpu_regd(fpu,insn.rs1),sparcfpu_regd(fpu,insn.rs2));
+      int gt = float64_lt(&fpu->softfloat,sparcfpu_regd(fpu,insn.rs2),sparcfpu_regd(fpu,insn.rs1));
+      assert(eq+lt+gt <= 1);
+      fpu->FSR.fcc = eq ? 0 : (lt ? 1 : (gt ? 2 : 3));
+      break;
+    }
+    case opFCMPEd: {
+      fpop2_check_double_align(insn.rs1);
+      fpop2_check_double_align(insn.rs2);
+      int eq = float64_eq_signaling(&fpu->softfloat,sparcfpu_regd(fpu,insn.rs1),sparcfpu_regd(fpu,insn.rs2));
+      fpop2_handle_exceptions(float_flag_invalid);
+      int lt = float64_lt(&fpu->softfloat,sparcfpu_regd(fpu,insn.rs1),sparcfpu_regd(fpu,insn.rs2));
+      int gt = float64_lt(&fpu->softfloat,sparcfpu_regd(fpu,insn.rs2),sparcfpu_regd(fpu,insn.rs1));
+      assert(eq+lt+gt <= 1);
+      fpu->FSR.fcc = eq ? 0 : (lt ? 1 : (gt ? 2 : 3));
+      break;
+    }
+    case opFCMPq: {
+      fpop2_check_quad_align(insn.rs1);
+      fpop2_check_quad_align(insn.rs2);
+      int eq = float128_eq(&fpu->softfloat,sparcfpu_regq(fpu,insn.rs1),sparcfpu_regq(fpu,insn.rs2));
+      fpop2_handle_exceptions(float_flag_invalid);
+      int lt = float128_lt(&fpu->softfloat,sparcfpu_regq(fpu,insn.rs1),sparcfpu_regq(fpu,insn.rs2));
+      int gt = float128_lt(&fpu->softfloat,sparcfpu_regq(fpu,insn.rs2),sparcfpu_regq(fpu,insn.rs1));
+      assert(eq+lt+gt <= 1);
+      fpu->FSR.fcc = eq ? 0 : (lt ? 1 : (gt ? 2 : 3));
+      break;
+    }
+    case opFCMPEq: {
+      fpop2_check_quad_align(insn.rs1);
+      fpop2_check_quad_align(insn.rs2);
+      int eq = float128_eq_signaling(&fpu->softfloat,sparcfpu_regq(fpu,insn.rs1),sparcfpu_regq(fpu,insn.rs2));
+      fpop2_handle_exceptions(float_flag_invalid);
+      int lt = float128_lt(&fpu->softfloat,sparcfpu_regq(fpu,insn.rs1),sparcfpu_regq(fpu,insn.rs2));
+      int gt = float128_lt(&fpu->softfloat,sparcfpu_regq(fpu,insn.rs2),sparcfpu_regq(fpu,insn.rs1));
+      assert(eq+lt+gt <= 1);
+      fpu->FSR.fcc = eq ? 0 : (lt ? 1 : (gt ? 2 : 3));
+      break;
+    }
+  }
+
+  fpop2_done:
+  ;
+}
+
+void sparcfpu_wrregs(sparcfpu_t* fpu, uint32_t reg, float32 val)
+{
+  assert(reg < 32);
+  fpu->freg[reg] = val;
+}
+
+void sparcfpu_wrregd(sparcfpu_t* fpu, uint32_t reg, float64 val)
+{
+  assert(reg < 32 && !(reg&1));
+  sparcfpu_wrregs(fpu,reg,(uint32_t)(val>>32));
+  sparcfpu_wrregs(fpu,reg+1,(uint32_t)val);
+}
+
+void sparcfpu_wrregq(sparcfpu_t* fpu, uint32_t reg, float128 val)
+{
+  assert(reg < 32 && !(reg&3));
+  sparcfpu_wrregd(fpu,reg,val.high);
+  sparcfpu_wrregd(fpu,reg+2,val.low);
+}
+
+float32 sparcfpu_regs(sparcfpu_t* fpu, uint32_t reg)
+{
+  assert(reg < 32);
+  return fpu->freg[reg];
+}
+
+float64 sparcfpu_regd(sparcfpu_t* fpu, uint32_t reg)
+{
+  assert(reg < 32 && !(reg&1));
+  return (((float64)sparcfpu_regs(fpu,reg))<<32) | (float64)sparcfpu_regs(fpu,reg+1);
+}
+
+float128 sparcfpu_regq(sparcfpu_t* fpu, uint32_t reg)
+{
+  assert(reg < 32 && !(reg&3));
+  float128 f;
+  f.high = sparcfpu_regd(fpu,reg);
+  f.low = sparcfpu_regd(fpu,reg+2);
+  return f;
+}
diff --git a/kern/arch/sparc/sparcfpu.h b/kern/arch/sparc/sparcfpu.h
new file mode 100644 (file)
index 0000000..6aa9b6c
--- /dev/null
@@ -0,0 +1,214 @@
+/* Author: Andrew S. Waterman
+ *         Parallel Computing Laboratory
+ *         Electrical Engineering and Computer Sciences
+ *         University of California, Berkeley
+ *
+ * Copyright (c) 2008, 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 of California, Berkeley 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 ''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 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 _SPARCFPU_H
+#define _SPARCFPU_H
+
+#ifdef __cplusplus
+  extern "C" {
+#endif
+
+#include <arch/arch.h>
+#include <arch/softfloat.h>
+
+typedef struct
+{
+#ifdef BIG_ENDIAN
+  uint32_t rd : 2;
+  uint32_t unused : 2;
+  uint32_t TEM : 5;
+  uint32_t NS : 1;
+  uint32_t res : 2;
+  uint32_t ver : 3;
+  uint32_t ftt : 3;
+  uint32_t qne : 1;
+  uint32_t unused2 : 1;
+  uint32_t fcc : 2;
+  uint32_t aexc : 5;
+  uint32_t cexc : 5;
+#else
+  uint32_t cexc : 5;
+  uint32_t aexc : 5;
+  uint32_t fcc : 2;
+  uint32_t unused2 : 1;
+  uint32_t qne : 1;
+  uint32_t ftt : 3;
+  uint32_t ver : 3;
+  uint32_t res : 2;
+  uint32_t NS : 1;
+  uint32_t TEM : 5;
+  uint32_t unused : 2;
+  uint32_t rd : 2;
+#endif
+} fsr_t;
+
+typedef struct
+{
+#ifdef BIG_ENDIAN
+  uint32_t op : 2;
+  uint32_t rd : 5;
+  uint32_t op3 : 6;
+  uint32_t rs1 : 5;
+  uint32_t opf : 9;
+  uint32_t rs2 : 5;
+#else
+  uint32_t rs2 : 5;
+  uint32_t opf : 9;
+  uint32_t rs1 : 5;
+  uint32_t op3 : 6;
+  uint32_t rd : 5;
+  uint32_t op : 2;
+#endif
+} fp_insn_t;
+
+typedef struct
+{
+  uint64_t dummy; /* force 8-byte alignment*/
+  uint32_t freg[32];
+  fsr_t FSR;
+  softfloat_t softfloat;
+} sparcfpu_t;
+
+enum FPop1opcodes
+{
+  opFMOVs=0x01,
+  opFNEGs=0x05,
+  opFABSs=0x09,
+  opFSQRTs=0x29,
+  opFSQRTd=0x2A,
+  opFSQRTq=0x2B,
+  opFADDs=0x41,
+  opFADDd=0x42,
+  opFADDq=0x43,
+  opFSUBs=0x45,
+  opFSUBd=0x46,
+  opFSUBq=0x47,
+  opFMULs=0x49,
+  opFMULd=0x4A,
+  opFMULq=0x4B,
+  opFDIVs=0x4D,
+  opFDIVd=0x4E,
+  opFDIVq=0x4F,
+  opFsMULd=0x69,
+  opFdMULq=0x6E,
+  opFiTOs=0xC4,
+  opFdTOs=0xC6,
+  opFqTOs=0xC7,
+  opFiTOd=0xC8,
+  opFsTOd=0xC9,
+  opFqTOd=0xCB,
+  opFiTOq=0xCC,
+  opFsTOq=0xCD,
+  opFdTOq=0xCE,
+  opFsTOi=0xD1,
+  opFdTOi=0xD2,
+  opFqTOi=0xD3
+};
+
+enum FPop2opcodes
+{
+  opFCMPs=0x51,
+  opFCMPd=0x52,
+  opFCMPq=0x53,
+  opFCMPEs=0x55,
+  opFCMPEd=0x56,
+  opFCMPEq=0x57
+};
+
+enum fp_traps
+{
+  fp_trap_none,
+  fp_trap_IEEE_754_exception,
+  fp_trap_unfinished_FPop,
+  fp_trap_unimplemented_FPop,
+  fp_trap_sequence_error,
+  fp_trap_hardware_error,
+  fp_trap_invalid_fp_register,
+  fp_trap_reserved
+};
+
+enum ieee_754_exceptions
+{
+  ieee_754_exception_inexact=1,
+  ieee_754_exception_division_by_zero=2,
+  ieee_754_exception_underflow=4,
+  ieee_754_exception_overflow=8,
+  ieee_754_exception_invalid=16,
+};
+
+enum fconds
+{
+  fccN,fccNE,fccLG,fccUL,fccL,fccUG,fccG,fccU,
+  fccA,fccE,fccUE,fccGE,fccUGE,fccLE,fccULE,fccO
+};
+
+// check if a branch is taken based upon condition (outer dimension)
+// and current FP condition code value (inner dimension)
+static const uint8_t check_fcc[16][4] = {
+  {0,0,0,0},
+  {0,1,1,1},
+  {0,1,1,0},
+  {0,1,0,1},
+  {0,1,0,0},
+  {0,0,1,1},
+  {0,0,1,0},
+  {0,0,0,1},
+  {1,1,1,1},
+  {1,0,0,0},
+  {1,0,0,1},
+  {1,0,1,0},
+  {1,0,1,1},
+  {1,1,0,0},
+  {1,1,0,1},
+  {1,1,1,0}
+};
+
+void sparcfpu_init(sparcfpu_t* fpu);
+
+void sparcfpu_fpop1(sparcfpu_t* fpu, fp_insn_t insn);
+void sparcfpu_fpop2(sparcfpu_t* fpu, fp_insn_t insn);
+void sparcfpu_setFSR(sparcfpu_t* fpu, uint32_t newFSR); 
+uint32_t sparcfpu_getFSR(sparcfpu_t* fpu); 
+
+void sparcfpu_wrregs(sparcfpu_t* fpu, uint32_t reg, float32 val);
+void sparcfpu_wrregd(sparcfpu_t* fpu, uint32_t reg, float64 val);
+void sparcfpu_wrregq(sparcfpu_t* fpu, uint32_t reg, float128 val);
+float32 sparcfpu_regs(sparcfpu_t* fpu, uint32_t reg);
+float64 sparcfpu_regd(sparcfpu_t* fpu, uint32_t reg);
+float128 sparcfpu_regq(sparcfpu_t* fpu, uint32_t reg);
+
+#ifdef __cplusplus
+  }
+#endif
+
+#endif
+
index 10028af..761d362 100644 (file)
@@ -217,12 +217,34 @@ access_exception(trapframe_t* state)
 }
 
 void
-fp_exception(trapframe_t* state)
+illegal_instruction(trapframe_t* state)
+{
+       unhandled_trap(state);
+}
+
+void
+real_fp_exception(trapframe_t* state, ancillary_state_t* sillystate)
 {
        unhandled_trap(state);
 }
 
 void
+fp_exception(trapframe_t* state)
+{
+       ancillary_state_t sillystate;
+       save_fp_state(&sillystate);     
+
+       // since our FP HW exception behavior is sketchy, reexecute
+       // any faulting FP instruction in SW, which may call
+       // real_fp_exception above
+       emulate_fpu(state,&sillystate);
+
+       restore_fp_state(&sillystate);
+
+       env_pop_tf(state);
+}
+
+void
 fp_disabled(trapframe_t* state)
 {
        if(state->psr & PSR_PS)
index ab57870..5f583f1 100644 (file)
@@ -10,7 +10,7 @@
 
 typedef struct
 {
-       uint32_t gpr[32];
+       uint32_t gpr[32] __attribute__((aligned (8)));
        uint32_t psr;
        uint32_t pc;
        uint32_t npc;
@@ -24,10 +24,19 @@ typedef struct
 
 typedef struct
 {
-       uint32_t fpr[32];
+       uint32_t fpr[32] __attribute__((aligned (8)));
        uint32_t fsr;
 } ancillary_state_t;
 
+void access_exception(trapframe_t* state);
+void real_fp_exception(trapframe_t* state, ancillary_state_t* astate);
+void address_unaligned(trapframe_t* state);
+void illegal_instruction(trapframe_t* state);
+
+void save_fp_state(ancillary_state_t* silly);
+void restore_fp_state(ancillary_state_t* silly);
+void emulate_fpu(trapframe_t* state, ancillary_state_t* astate);
+
 #endif /* !__ASSEMBLER__ */
 
 #endif /* !ROS_INC_ARCH_TRAP_H */
index 770712e..da41de8 100644 (file)
@@ -7,7 +7,7 @@ trap_table:
 
        UNHANDLED_TRAP                          ! 0x00
        TRAP_TABLE_ENTRY(access_exception)      ! 0x01
-       UNHANDLED_TRAP                          ! 0x02
+       TRAP_TABLE_ENTRY(illegal_instruction)   ! 0x02
        UNHANDLED_TRAP                          ! 0x03
        TRAP_TABLE_ENTRY(fp_disabled)           ! 0x04
        JMP(handle_window_overflow)             ! 0x05
@@ -15,9 +15,9 @@ trap_table:
 
 #ifndef TINY_MEM
 
-       TRAP_TABLE_ENTRY(address_unaligned)     ! 0x01
+       TRAP_TABLE_ENTRY(address_unaligned)     ! 0x07
        TRAP_TABLE_ENTRY(fp_exception)          ! 0x08
-       TRAP_TABLE_ENTRY(access_exception)      ! 0x01
+       TRAP_TABLE_ENTRY(access_exception)      ! 0x09
        UNHANDLED_TRAP                          ! 0x0A
        UNHANDLED_TRAP                          ! 0x0B
        UNHANDLED_TRAP                          ! 0x0C
index 2d7d128..cbba634 100644 (file)
@@ -44,10 +44,8 @@ typedef int32_t envid_t;
 struct Env {
        TAILQ_ENTRY(Env) proc_link NOINIT;      // Free list link pointers
        spinlock_t proc_lock;
-       trapframe_t env_tf                                              // Saved registers
-         __attribute__((aligned (8)));                 // for sparc --asw
-       ancillary_state_t env_ancillary_state   // State saved when descheduled
-         __attribute__((aligned (8)));                 // for sparc --asw
+       trapframe_t env_tf;                                             // Saved registers
+       ancillary_state_t env_ancillary_state;  // State saved when descheduled
        envid_t env_id;                         // Unique environment identifier
        envid_t env_parent_id;          // env_id of this env's parent
        uint32_t state;                         // Status of the process
index 55f0072..d90d99d 100644 (file)
@@ -45,7 +45,7 @@ void manager_brho(void)
 {
        static uint8_t RACY progress = 0;
 
-       struct proc *envs[256];
+       static struct proc *envs[256];
        static struct proc *p ;
 
        uint32_t corelist[MAX_NUM_CPUS];
@@ -183,7 +183,7 @@ void manager_brho(void)
 
 void manager_klueska()
 {
-       struct proc *envs[256];
+       static struct proc *envs[256];
        static uint8_t progress = 0;
 
        if (progress++ == 0) {
@@ -196,42 +196,76 @@ void manager_klueska()
        panic("DON'T PANIC");
 }
 
+static char*
+itoa(int num, char* buf0, size_t base)
+{
+       if(base > 16)
+               return NULL;
+
+       char* buf = buf0;
+       int len = 0, i;
+
+       if(num < 0)
+       {
+               *buf++ = '-';
+               num = -num;
+       }
+
+       do {
+               buf[len++] = "0123456789abcdef"[num%base];
+               num /= base;
+       } while(num);
+
+       for(i = 0; i < len/2; i++)
+       {
+               char temp = buf[i];
+               buf[i] = buf[len-i-1];
+               buf[len-i-1] = temp;
+       }
+       buf[len] = 0;
+
+       return buf0;
+}
+
 void manager_waterman()
 {
-       struct proc *envs[256];
+       static struct proc *envs[256];
        static uint8_t progress = 0;
+       char buf0[32],buf1[32];
+
+       #define RUN_APP(name,nargs,args...) \
+               do { \
+                       envs[progress-1] = kfs_proc_create(kfs_lookup_path(name)); \
+                       proc_set_state(envs[progress-1], PROC_RUNNABLE_S); \
+                       if(nargs) proc_init_argc_argv(envs[progress-1],nargs,##args); \
+                       proc_run(envs[progress-1]); \
+               } while(0)
+       
 
        switch(progress++)
        {
                case 0:
-                       printk("got here\n");
-                       envs[progress] = kfs_proc_create(kfs_lookup_path("parlib_draw_nanwan_standalone"));
-                       proc_set_state(envs[progress], PROC_RUNNABLE_S);
-                       proc_run(envs[progress]);
+                       RUN_APP("parlib_draw_nanwan_standalone",0);
                        break;
-
                case 1:
-                       envs[progress] = kfs_proc_create(kfs_lookup_path("parlib_manycore_test"));
-                       proc_set_state(envs[progress], PROC_RUNNABLE_S);
- &