Removes sparc; it's hard to believe (XCC)
authorBarret Rhoden <brho@cs.berkeley.edu>
Fri, 7 Jun 2013 00:30:58 +0000 (17:30 -0700)
committerBarret Rhoden <brho@cs.berkeley.edu>
Fri, 7 Jun 2013 17:59:55 +0000 (10:59 -0700)
Rebuild the cross-compiler, if you want to help check for bugs.

79 files changed:
Documentation/CodingPolicy
Documentation/kthreads.txt
Makelocal.template
kern/arch/riscv/ros/mmu.h
kern/arch/riscv/smp.c
kern/arch/sparc/Kbuild [deleted file]
kern/arch/sparc/Kconfig [deleted file]
kern/arch/sparc/Makefile [deleted file]
kern/arch/sparc/arch.h [deleted file]
kern/arch/sparc/atomic.h [deleted file]
kern/arch/sparc/bitmask.h [deleted file]
kern/arch/sparc/boot.c [deleted file]
kern/arch/sparc/boot/Makefrag [deleted file]
kern/arch/sparc/colored_caches.c [deleted file]
kern/arch/sparc/colored_page_alloc.h [deleted file]
kern/arch/sparc/configs/defconfig [deleted symlink]
kern/arch/sparc/console.c [deleted file]
kern/arch/sparc/console.h [deleted file]
kern/arch/sparc/cpuinfo.c [deleted file]
kern/arch/sparc/endian.h [deleted file]
kern/arch/sparc/entry.S [deleted file]
kern/arch/sparc/env.c [deleted file]
kern/arch/sparc/fpu.c [deleted file]
kern/arch/sparc/init.c [deleted file]
kern/arch/sparc/init.h [deleted file]
kern/arch/sparc/kbdreg.h [deleted file]
kern/arch/sparc/kdebug.c [deleted file]
kern/arch/sparc/kdebug.h [deleted file]
kern/arch/sparc/kernel.ld [deleted file]
kern/arch/sparc/mmu.h [deleted file]
kern/arch/sparc/page_alloc.c [deleted file]
kern/arch/sparc/pmap.c [deleted file]
kern/arch/sparc/process.c [deleted file]
kern/arch/sparc/recip.S [deleted file]
kern/arch/sparc/ros/arch.h [deleted file]
kern/arch/sparc/ros/membar.h [deleted file]
kern/arch/sparc/ros/mmu.h [deleted file]
kern/arch/sparc/ros/syscall.h [deleted file]
kern/arch/sparc/ros/trapframe.h [deleted file]
kern/arch/sparc/smp.c [deleted file]
kern/arch/sparc/smp.h [deleted file]
kern/arch/sparc/softfloat-macros.h [deleted file]
kern/arch/sparc/softfloat-specialize.h [deleted file]
kern/arch/sparc/softfloat.c [deleted file]
kern/arch/sparc/softfloat.h [deleted file]
kern/arch/sparc/sparc.h [deleted file]
kern/arch/sparc/sparcfpu.c [deleted file]
kern/arch/sparc/sparcfpu.h [deleted file]
kern/arch/sparc/spillfill.S [deleted file]
kern/arch/sparc/time.c [deleted file]
kern/arch/sparc/time.h [deleted file]
kern/arch/sparc/trap.c [deleted file]
kern/arch/sparc/trap.h [deleted file]
kern/arch/sparc/trap_entry.S [deleted file]
kern/arch/sparc/trap_table.S [deleted file]
kern/arch/sparc/trap_table.h [deleted file]
kern/arch/sparc/types.h [deleted file]
kern/include/ros/syscall.h
kern/include/trap.h
kern/src/alarm.c
kern/src/elf.c
kern/src/manager.c
kern/src/testing.c
tests/mhello.c
tests/mproctests.c
tests/msr_cycling_vcores.c
tests/msr_get_cores.c
tests/msr_get_singlecore.c
tools/compilers/gcc-glibc/Makefile
tools/compilers/gcc-glibc/binutils-2.21.1-ros.patch
tools/compilers/gcc-glibc/glibc-2.14.1-ros/sysdeps/sparc/fpu/bits/mathinline.h [deleted file]
tools/compilers/gcc-glibc/glibc-2.14.1-ros/sysdeps/sparc/sparc32/Implies [deleted file]
tools/compilers/gcc-glibc/glibc-2.14.1-ros/sysdeps/sparc/sparc32/dl-machine.h [deleted file]
user/parlib/include/riscv/atomic.h
user/parlib/include/sparc/arch.h [deleted file]
user/parlib/include/sparc/atomic.h [deleted file]
user/parlib/include/sparc/bitmask.h [deleted file]
user/parlib/include/sparc/vcore.h [deleted file]
user/parlib/mcs.c

index 6bb4397..5cb68ba 100644 (file)
@@ -109,7 +109,7 @@ Contributing:
   personnel.
 
 - Expect your code to be audited by the appropriate subsystem maintainer.
-  Basically, this means that if it is related to the sparc port, you need to
+  Basically, this means that if it is related to the riscv port, you need to
   make Andrew happy.  Otherwise, you need to make Barret happy.
 
 - Despite being a research project, we make every effort to do things the
index d108d40..dab2798 100644 (file)
@@ -130,11 +130,11 @@ pcpui->spare and move the disable_irq() down to right before save_kernel_ctx().
 What's the Deal with Stacks/Stacktops?
 -------------------------------
 When the kernel traps from userspace, it needs to know what to set the kernel
-stack pointer to.  In x86, it looks in the TSS.  In sparc, we have a data
+stack pointer to.  In x86, it looks in the TSS.  In riscv, we have a data
 structure tracking that info (core_stacktops).  One thing I considered was
-migrating the kernel from its boot stacks (x86, just core0, sparc, all the cores
+migrating the kernel from its boot stacks (x86, just core0, riscv, all the cores
 have one).  Instead, we just make sure the tables/TSS are up to date right away
-(before interrupts or traps can come in for x86, and right away for sparc).
+(before interrupts or traps can come in for x86, and right away for riscv).
 These boot stacks aren't particularly special, just note they are in the program
 data/bss sections and were never originally added to a free list.  But they can
 be freed later on.  This might be an issue in some places, but those places
index 6523269..b1369ab 100644 (file)
 #
 #pxe: $(OBJDIR)/kern/.pxe.touch ;
 
-# various sparc functional simulator configurations
-NP ?= 1
-fs: all
-       sparc_app -p$(NP) -fappserver_ros.conf fs $(KERNEL_OBJ) none
-fsd: all
-       sparc_app_debug -p$(NP) -fappserver_ros.conf fs $(KERNEL_OBJ) none
-hw: all
-       sparc_app -p$(NP) -fappserver_ros.conf hw $(KERNEL_OBJ) none
-
 # risc-v functional simulator
 rvfs: all
        fesvr -p$(NP) -nopk $(KERNEL_OBJ)
index a962cd1..14ebc79 100644 (file)
@@ -26,7 +26,7 @@
 # define KERNBASE               0x80000000
 # define ULIM                   0x7F000000
 # define KERN_LOAD_ADDR           KERNBASE
-# define KERN_VMAP_TOP                 0xfec00000 /* using sparc's upper limit */
+# define KERN_VMAP_TOP                 0xfec00000
 # define NPTLEVELS                       2
 # define L1PGSHIFT                 (13+11)
 # define L1PGSIZE         (1 << L1PGSHIFT)
index e6f88c2..89d3a10 100644 (file)
@@ -132,8 +132,8 @@ int smp_call_wait(handler_wrapper_t* wrapper)
 }
 
 /* Perform any initialization needed by per_cpu_info.  Right now, this just
- * inits the amsg list (which sparc will probably also want).  Make sure every
- * core calls this at some point in the smp_boot process. */
+ * inits the amsg list.  Make sure every core calls this at some point in the
+ * smp_boot process. */
 void __arch_pcpu_init(uint32_t coreid)
 {
        // Switch to the real L1 page table, rather than the boot page table which
diff --git a/kern/arch/sparc/Kbuild b/kern/arch/sparc/Kbuild
deleted file mode 100644 (file)
index df24785..0000000
+++ /dev/null
@@ -1,23 +0,0 @@
-obj-y                                          += boot.o
-obj-y                                          += colored_caches.o
-obj-y                                          += console.o
-obj-y                                          += cpuinfo.o
-obj-y                                          += entry.o
-obj-y                                          += env.o
-obj-y                                          += fpu.o
-obj-y                                          += init.o
-obj-y                                          += kdebug.o
-obj-y                                          += page_alloc.o
-obj-y                                          += pmap.o
-obj-y                                          += process.o
-obj-y                                          += recip.o
-obj-y                                          += smp.o
-obj-y                                          += softfloat.o
-obj-y                                          += sparc.h
-obj-y                                          += sparcfpu.o
-obj-y                                          += spillfill.o
-obj-y                                          += time.o
-obj-y                                          += trap.o
-obj-y                                          += trap.h
-obj-y                                          += trap_entry.o
-obj-y                                          += trap_table.o
diff --git a/kern/arch/sparc/Kconfig b/kern/arch/sparc/Kconfig
deleted file mode 100644 (file)
index e91f2fa..0000000
+++ /dev/null
@@ -1,3 +0,0 @@
-config SPARC
-       def_bool y
-       select APPSERVER
diff --git a/kern/arch/sparc/Makefile b/kern/arch/sparc/Makefile
deleted file mode 100644 (file)
index 869f988..0000000
+++ /dev/null
@@ -1 +0,0 @@
-CROSS_COMPILE := sparc-ros-
diff --git a/kern/arch/sparc/arch.h b/kern/arch/sparc/arch.h
deleted file mode 100644 (file)
index 81222fd..0000000
+++ /dev/null
@@ -1,212 +0,0 @@
-#ifndef ROS_INC_ARCH_H
-#define ROS_INC_ARCH_H
-
-#include <ros/arch/arch.h>
-
-/* Arch Constants */
-#define ARCH_CL_SIZE           64
-#define KERN_VMAP_TOP          0xFEC00000 // max virtual address
-
-#include <arch/mmu.h>
-#include <arch/sparc.h>
-
-#ifndef __ASSEMBLER__
-
-#include <ros/common.h>
-#include <arch/time.h>
-
-static __inline void breakpoint(void) __attribute__((always_inline));
-static __inline void invlpg(void *addr) __attribute__((always_inline));
-static __inline uint64_t read_tsc(void) __attribute__((always_inline));
-static __inline uint64_t read_tsc_serialized(void) __attribute__((always_inline));
-static __inline void enable_irq(void) __attribute__((always_inline));
-static __inline void disable_irq(void) __attribute__((always_inline));
-static __inline void enable_irqsave(int8_t* state) __attribute__((always_inline));
-static __inline void disable_irqsave(int8_t* state) __attribute__((always_inline));
-static __inline void cpu_relax(void) __attribute__((always_inline));
-static __inline void cpu_halt(void) __attribute__((always_inline));
-static __inline void tlbflush(void) __attribute__((always_inline));
-static __inline void icache_flush_page(void* va, void* pa)__attribute__((always_inline));
-static __inline void clflush(uintptr_t* addr) __attribute__((always_inline));
-static __inline int irq_is_enabled(void) __attribute__((always_inline));
-static __inline uint32_t core_id(void) __attribute__((always_inline));
-static __inline void cache_flush(void) __attribute__((always_inline));
-static __inline void reboot(void) __attribute__((always_inline)) __attribute__((noreturn));
-static __inline void lcr3(uint32_t val) __attribute__((always_inline));
-static __inline uint32_t rcr3(void) __attribute__((always_inline));
-
-void print_cpuinfo(void);
-void show_mapping(uintptr_t start, size_t size);
-void __cpu_halt(void);
-
-extern uintptr_t mmu_context_tables[MAX_NUM_CPUS][NCONTEXTS+CONTEXT_TABLE_PAD];
-
-static __inline void
-breakpoint(void)
-{
-       asm volatile ("ta 0x7f");
-}
-
-static __inline void 
-invlpg(void *addr)
-{ 
-       store_alternate(((uintptr_t)addr) & ~0xFFF,3,0);
-}  
-
-static __inline void
-tlbflush(void)
-{
-       store_alternate(0x400,3,0);
-}
-
-static __inline void
-icache_flush_page(void* va, void* kva)
-{
-       for(int i = 0; i < PGSIZE; i+=32) // functional pipeline line size
-               clflush((uintptr_t*)((char*)kva+i));
-}
-
-static __inline uint64_t
-read_tsc(void)
-{
-       return read_perfctr(0,0);
-}
-
-static __inline uint64_t
-read_tscp(void)
-{
-       return read_tsc();
-}
-
-static __inline uint64_t 
-read_tsc_serialized(void)
-{
-       return read_tsc();
-}
-
-static __inline void
-enable_irq(void)
-{
-       write_psr(read_psr() & ~PSR_PIL);
-}
-
-static __inline void
-disable_irq(void)
-{
-       write_psr(read_psr() | PSR_PIL);
-}
-
-static __inline void
-enable_irqsave(int8_t* state)
-{
-       // *state tracks the number of nested enables and disables
-       // initial value of state: 0 = first run / no favorite
-       // > 0 means more enabled calls have been made
-       // < 0 means more disabled calls have been made
-       // Mostly doing this so we can call disable_irqsave first if we want
-
-       // one side or another "gets a point" if interrupts were already the
-       // way it wanted to go.  o/w, state stays at 0.  if the state was not 0
-       // then, enabling/disabling isn't even an option.  just increment/decrement
-
-       // if enabling is winning or tied, make sure it's enabled
-       if ((*state == 0) && !irq_is_enabled())
-               enable_irq();
-       else
-               (*state)++;
-}
-
-static __inline void
-disable_irqsave(int8_t* state)
-{
-       if ((*state == 0) && irq_is_enabled())
-               disable_irq();
-       else 
-               (*state)--;
-}
-
-static __inline uint64_t
-read_perfctr(uint32_t cpu, uint32_t which)
-{
-       register uint32_t hi asm("o0"), lo asm("o1");
-       uintptr_t addr = cpu<<10 | which<<3;
-
-       #ifdef ROS_KERNEL
-               int8_t state = 0;
-               disable_irqsave(&state);
-               hi = load_iobus(0,addr);
-               lo = load_iobus(0,addr+4);
-               enable_irqsave(&state);
-       #else
-               // can't use two load_iobuses in userspace because of atomicity
-               asm volatile("mov %2,%%o0; ta 9"
-                            : "=r"(hi),"=r"(lo) : "r"(addr));
-       #endif
-       return (((uint64_t)hi) << 32) | lo;
-}
-
-static __inline void
-cpu_relax(void)
-{
-       int ctr = 8;
-       asm volatile("1: deccc %0; bne 1b; nop" :
-                    "=r"(ctr) : "0"(ctr) : "cc","memory");
-}
-
-static __inline void
-cpu_halt(void)
-{
-       /* TODO: this isn't atomic, but we want it to be. */
-       enable_irq();
-       __cpu_halt();
-}
-
-static __inline void
-clflush(uintptr_t* addr)
-{
-       asm volatile("flush %0" : : "r"(addr));
-}
-
-static __inline int
-irq_is_enabled(void)
-{
-       return (read_psr() & PSR_PIL) == 0;
-}
-
-static __inline uint32_t
-core_id(void)
-{
-       uint32_t reg;
-       asm ("mov %" XSTR(CORE_ID_REG) ",%0" : "=r"(reg));
-       return reg;
-}
-
-static __inline void
-cache_flush(void)
-{
-}
-
-static __inline void
-reboot(void)
-{
-       extern void appserver_die(uintptr_t code);
-       appserver_die(0);
-       while(1);
-}
-
-static __inline void
-lcr3(uint32_t val)
-{
-       mmu_context_tables[core_id()][0] = val >> 4 | PTE_PTD;
-       tlbflush();
-}
-
-static __inline uint32_t
-rcr3(void)
-{
-       return (mmu_context_tables[core_id()][0] & ~0x3) << 4;
-}
-
-#endif /* !__ASSEMBLER__ */
-
-#endif /* !ROS_INC_X86_H */
diff --git a/kern/arch/sparc/atomic.h b/kern/arch/sparc/atomic.h
deleted file mode 100644 (file)
index 4612e49..0000000
+++ /dev/null
@@ -1,198 +0,0 @@
-#ifndef ROS_KERN_ARCH_ATOMIC_H
-#define ROS_KERN_ARCH_ATOMIC_H
-
-#include <ros/common.h>
-#include <ros/arch/membar.h>
-
-/* This needs to be declared over here so that comp_and_swap down below can use
- * it.  Remove this when RAMP has a proper atomic compare and swap.  (TODO) */
-static inline void spin_lock_irqsave(spinlock_t *lock);
-static inline void spin_unlock_irqsave(spinlock_t *lock);
-/* Same deal with spin locks.  Note that Sparc can deadlock on an atomic op
- * called from interrupt context (TODO) */
-static inline void __spin_lock(spinlock_t *lock);
-
-/* Actual functions */
-static inline void atomic_init(atomic_t *number, long val)
-{
-       val <<= 8;
-       __asm__ __volatile__ ("st %0,[%1]" : : "r"(val), "r"(number) : "memory");
-}
-
-static inline long atomic_read(atomic_t *number)
-{
-       long val;
-       __asm__ __volatile__ ("ld [%1],%0" : "=r"(val) : "r"(number));
-       return val >> 8;
-}
-
-/* Adds val to number, returning number's original value */
-static inline long atomic_fetch_and_add(atomic_t *number, long val)
-{
-       long retval;
-       /* this is pretty clever.  the lower 8 bits (i.e byte 3)
-        * of the atomic_t serve as a spinlock.  let's acquire it. */
-       __spin_lock((spinlock_t*)number);
-       retval = atomic_read(number);
-       /* compute new counter value. */
-       val += retval;
-       /* set the new counter value.  the lock is cleared (for free) */
-       atomic_init(number, val);
-       return retval;
-}
-
-static inline void atomic_add(atomic_t *number, long val)
-{
-       atomic_fetch_and_add(number, val);
-}
-
-static inline void atomic_set(atomic_t *number, long val)
-{
-       // this works basically the same as atomic_add... but without the add
-       __spin_lock((spinlock_t*)number);
-       atomic_init(number,val);
-}
-
-static inline void atomic_inc(atomic_t *number)
-{
-       atomic_add(number,1);
-}
-
-static inline void atomic_dec(atomic_t *number)
-{
-       atomic_add(number,-1);
-}
-
-/* Adds val to number, so long as number was not zero.  Returns TRUE if the
- * operation succeeded (added, not zero), returns FALSE if number is zero. */
-static inline bool atomic_add_not_zero(atomic_t *number, long val)
-{
-       long num;
-       bool retval = FALSE;
-       /* this is pretty clever.  the lower 8 bits (i.e byte 3)
-        * of the atomic_t serve as a spinlock.  let's acquire it. */
-       __spin_lock((spinlock_t*)number);
-       num = atomic_read(number);
-       if (num) {
-               num += val;
-               retval = TRUE;
-       }
-       /* set the new (maybe old) counter value.  the lock is cleared (for free) */
-       atomic_init(number, num);
-       return retval;
-}
-
-/* Subtraces val from number, returning True if the new value is 0. */
-static inline bool atomic_sub_and_test(atomic_t *number, long val)
-{
-       long num;
-       bool retval = FALSE;
-       /* this is pretty clever.  the lower 8 bits (i.e byte 3)
-        * of the atomic_t serve as a spinlock.  let's acquire it. */
-       __spin_lock((spinlock_t*)number);
-       num = atomic_read(number);
-       num -= val;
-       retval = num ? FALSE : TRUE;
-       /* set the new counter value.  the lock is cleared (for free) */
-       atomic_init(number, num);
-       return retval;
-}
-
-static inline void atomic_and(atomic_t *number, long mask)
-{
-       long val;
-       /* this is pretty clever.  the lower 8 bits (i.e byte 3)
-        * of the atomic_t serve as a spinlock.  let's acquire it. */
-       __spin_lock((spinlock_t*)number);
-       val = atomic_read(number);
-       /* compute new counter value. */
-       val &= mask;
-       /* set the new counter value.  the lock is cleared (for free) */
-       atomic_init(number, val);
-}
-
-static inline void atomic_or(atomic_t *number, long mask)
-{
-       long val;
-       /* this is pretty clever.  the lower 8 bits (i.e byte 3)
-        * of the atomic_t serve as a spinlock.  let's acquire it. */
-       __spin_lock((spinlock_t*)number);
-       val = atomic_read(number);
-       /* compute new counter value. */
-       val |= mask;
-       /* set the new counter value.  the lock is cleared (for free) */
-       atomic_init(number, val);
-}
-
-static inline long atomic_swap(atomic_t *addr, long val)
-{
-       __asm__ __volatile__ ("swap [%2],%0" : "=r"(val) : "0"(val),"r"(addr) : "memory");
-       return val;
-}
-
-// TODO: make this better! (no global locks, etc)
-static inline bool atomic_cas(atomic_t *addr, long exp_val, long new_val)
-{
-       bool retval = 0;
-       long temp;
-       static spinlock_t cas_lock = SPINLOCK_INITIALIZER_IRQSAVE;
-
-       if ((long)*addr != exp_val)
-               return 0;
-       spin_lock_irqsave(&cas_lock);
-       if ((long)*addr == exp_val) {
-               atomic_swap(addr, new_val);
-               retval = 1;
-       }
-       spin_unlock_irqsave(&cas_lock);
-       return retval;
-}
-
-static inline bool atomic_cas_ptr(void **addr, void *exp_val, void *new_val)
-{
-       return atomic_cas((atomic_t*)addr, (long)exp_val, (long)new_val);
-}
-
-static inline bool atomic_cas_u32(uint32_t *addr, uint32_t exp_val,
-                                  uint32_t new_val)
-{
-       return atomic_cas((atomic_t*)addr, (long)exp_val, (long)new_val);
-}
-
-static inline uint32_t spin_trylock(spinlock_t*SAFE lock)
-{
-       uint32_t reg;
-       __asm__ __volatile__ ("ldstub [%1+3],%0" : "=r"(reg) : "r"(&lock->rlock) : "memory");
-       return reg;
-}
-
-static inline bool spin_locked(spinlock_t*SAFE lock)
-{
-       uint32_t reg;
-       __asm__ __volatile__ ("ldub [%1+3],%0" : "=r"(reg) : "r"(&lock->rlock));
-       return (bool)reg;
-}
-
-static inline void __spin_lock(spinlock_t*SAFE lock)
-{
-       while(spin_trylock(lock))
-               while(spin_locked(lock));
-       cmb();
-}
-
-static inline void __spin_unlock(spinlock_t*SAFE lock)
-{
-       mb();
-       lock->rlock = 0;
-}
-
-static inline void __spinlock_init(spinlock_t* lock)
-{
-       lock->rlock = 0;
-}
-
-static inline void spinlock_debug(spinlock_t* lock)
-{
-}
-
-#endif /* ROS_KERN_ARCH_ATOMIC_H */
diff --git a/kern/arch/sparc/bitmask.h b/kern/arch/sparc/bitmask.h
deleted file mode 100644 (file)
index 63d4ef1..0000000
+++ /dev/null
@@ -1,78 +0,0 @@
-#ifndef ROS_ARCH_BITMASK_H
-#define ROS_ARCH_BITMASK_H
-
-#ifndef __IVY__
-#include <ros/noivy.h>
-#endif
-
-#include <string.h>
-#include <sys/types.h>
-#include <atomic.h>
-#include <stdio.h>
-
-#define BYTES_FOR_BITMASK(size) (size)
-#define BYTES_FOR_BITMASK_WITH_CHECK(size) (size)
-#define DECL_BITMASK(name, size) uint8_t (name)[BYTES_FOR_BITMASK((size))]
-
-#define GET_BITMASK_BIT(name, bit) ((name)[(bit)])
-#define SET_BITMASK_BIT(name, bit) ((name)[(bit)] = 1)
-#define CLR_BITMASK_BIT(name, bit) ((name)[(bit)] = 0)
-#define SET_BITMASK_BIT_ATOMIC SET_BITMASK_BIT
-#define CLR_BITMASK_BIT_ATOMIC CLR_BITMASK_BIT
-
-#define CLR_BITMASK(name, size) \
-({ \
-       {TRUSTEDBLOCK \
-       memset((void*)((uintptr_t)(name)), 0, BYTES_FOR_BITMASK((size))); \
-       } \
-})
-
-#define FILL_BITMASK(name, size) \
-({ \
-       {TRUSTEDBLOCK \
-       memset((void*)((uintptr_t)(name)), 1, BYTES_FOR_BITMASK((size))); \
-       } \
-}) 
-
-#define COPY_BITMASK(newmask, oldmask, size) \
-({ \
-       {TRUSTEDBLOCK \
-       memcpy((void*)((uintptr_t)(newmask)), \
-           (void*)((uintptr_t)(oldmask)), \
-           BYTES_FOR_BITMASK((size))); \
-       } \
-})
-
-// this checks the entire last byte, so keep it 0 in the other macros
-#define BITMASK_IS_CLEAR(name, size) ({ \
-       uint32_t __n = BYTES_FOR_BITMASK((size)); \
-       bool clear = 1; \
-       while (__n-- > 0) { \
-               if ((name)[__n]) { \
-                       clear = 0; \
-                       break;\
-               }\
-       } \
-       clear; })
-
-static inline bool BITMASK_IS_FULL(uint8_t* map, size_t size)
-{
-       int _size = size;
-       for (int i = 0; i < BYTES_FOR_BITMASK(size); i++) {
-               for (int j = 0; j < MIN(8,_size); j++)
-                       if(!GET_BITMASK_BIT(map, i))
-                               return FALSE;
-                       _size--;
-       }
-       return TRUE;
-}
-
-#define PRINT_BITMASK(name, size) { \
-       int i;  \
-       for (i = 0; i < BYTES_FOR_BITMASK(size); i++) { \
-               printk("%x", (name)[i] );       \
-       } \
-       printk("\n"); \
-}
-
-#endif /* ROS_ARCH_BITMASK_H */
diff --git a/kern/arch/sparc/boot.c b/kern/arch/sparc/boot.c
deleted file mode 100644 (file)
index 36d806c..0000000
+++ /dev/null
@@ -1,103 +0,0 @@
-#include <multiboot.h>
-#include <arch/mmu.h>
-#include <arch/arch.h>
-#include <ros/common.h>
-#include <ros/memlayout.h>
-#include <string.h>
-
-#ifdef __SHARC__
-#pragma nosharc
-#endif
-
-#ifdef __DEPUTY__
-#pragma nodeputy
-#endif
-
-void
-build_multiboot_info(multiboot_info_t* mbi)
-{
-       uint32_t memsize_kb = memsize_mb()*1024;
-       uint32_t basemem_kb = EXTPHYSMEM/1024;
-
-       memset(mbi,0,sizeof(mbi));
-
-       mbi->flags = 0x00000001;
-       mbi->mem_lower = basemem_kb;
-       mbi->mem_upper = memsize_kb-basemem_kb;
-}
-
-// set up a basic virtual -> physical mapping so we can boot the kernel
-void
-pagetable_init(void)
-{
-       extern uintptr_t l1_page_table[NL1ENTRIES];
-
-       // relocate symbols
-       uintptr_t* l1 = (uintptr_t*)((uint8_t*)l1_page_table-KERNBASE);
-
-       uintptr_t kernsize = /* 4GB */ - KERNBASE;
-
-       // make all L1 PTEs invalid by default
-       int i;
-       for(i = 0; i < NL1ENTRIES; i++)
-               l1[i] = 0;
-
-       // Retain the identity mapping
-       // [0,4GB-KERNBASE] -> [0,4GB-KERNBASE]
-       // so we don't nuke ourselveswhen we turn on protection!!
-       for(i = 0; i < kernsize/L1PGSIZE; i++)
-               l1[i] = (i << 20) | PTE_KERN_RW | PTE_PTE;
-
-       // make the relocated mapping
-       // [KERNBASE,4GB] -> [0,4GB-KERNBASE]
-       for(i = 0; i < kernsize/L1PGSIZE; i++)
-               l1[i+KERNBASE/L1PGSIZE] = (i << 20) | PTE_KERN_RW | PTE_PTE;
-}
-
-void
-mmu_init(void)
-{
-       extern uintptr_t l1_page_table[NL1ENTRIES];
-       uintptr_t* l1 = (uintptr_t*)((uint8_t*)l1_page_table-KERNBASE);
-
-       int zero = 0;
-       uintptr_t* mmuctxtbl = (uintptr_t*)((uint8_t*)(mmu_context_tables[core_id()])-KERNBASE);
-
-       // make all context table entries invalid
-       int i;
-       for(i = 0; i < NCONTEXTS; i++)
-               mmuctxtbl[i] = 0;
-
-       // except for the zeroth one, which points to our L1 PT
-       *mmuctxtbl = PTD((uintptr_t)l1);
-
-       // set current context (== 0)
-       store_alternate(0x200,4,zero);
-
-       // set physical address of context table
-       store_alternate(0x100,4,(uintptr_t)mmuctxtbl>>4);
-
-       // turn on MMU
-       tlbflush();
-       store_alternate(0x000,4,1);
-}
-
-// delete temporary mappings used by the entry code
-void
-mmu_boot_cleanup_core0(void)
-{
-       extern uintptr_t l1_page_table[NL1ENTRIES];
-       uintptr_t kernsize = -KERNBASE;
-
-       // make the temporary mapping invalid
-       int i;
-       for(i = 0; i < kernsize/L1PGSIZE; i++)
-               l1_page_table[i] = 0;
-}
-
-void
-mmu_boot_cleanup_all(void)
-{
-       // nothing special here
-       tlbflush();
-}
diff --git a/kern/arch/sparc/boot/Makefrag b/kern/arch/sparc/boot/Makefrag
deleted file mode 100644 (file)
index 3caa20a..0000000
+++ /dev/null
@@ -1,6 +0,0 @@
-#\r
-# Makefile fragment for the ROS kernel.\r
-# This is NOT a complete makefile;\r
-# you must run GNU make in the top-level directory\r
-# where the GNUmakefile is located.\r
-#\r
diff --git a/kern/arch/sparc/colored_caches.c b/kern/arch/sparc/colored_caches.c
deleted file mode 100644 (file)
index e2143ac..0000000
+++ /dev/null
@@ -1,42 +0,0 @@
-/* Copyright (c) 2009 The Regents of the University  of California. 
- * See the COPYRIGHT files at the top of this source tree for full 
- * license information.
- * 
- * Kevin Klues <klueska@cs.berkeley.edu>    
- */
-
-#include <colored_caches.h>
-#include <stdio.h>
-
-#ifdef __SHARC__
-#pragma nosharc
-#endif
-
-// Global variables
-static cache_t l1,l2,l3;
-cache_t* llc_cache;
-available_caches_t available_caches;
-
-/************** Cache Related Functions  *****************/
-void cache_init() 
-{
-       // Initialize the caches available on this system.
-       // TODO: Should call out to something reading the acpi tables from 
-       // memory, or something similar.  For now, just initialize them inline
-       available_caches.l1 = SINIT(&l1);
-       available_caches.l2 = SINIT(&l2);
-       available_caches.l3 = SINIT(&l3);
-       llc_cache = &l3;
-       init_cache_properties(&l1,   32,  8, 64);
-       init_cache_properties(&l2,  256,  8, 64);
-       init_cache_properties(&l3, 8192, 16, 64);
-       printk("Cache init successful\n");
-}
-
-void cache_color_alloc_init()
-{
-       init_free_cache_colors_map(&l1);
-       init_free_cache_colors_map(&l2);
-       init_free_cache_colors_map(&l3);
-}
-
diff --git a/kern/arch/sparc/colored_page_alloc.h b/kern/arch/sparc/colored_page_alloc.h
deleted file mode 100644 (file)
index 4aa5813..0000000
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * Copyright (c) 2009 The Regents of the University  of California.  
- * See the COPYRIGHT files at the top of this source tree for full 
- * license information.
- */
-/**
- * @author Kevin Klues <klueska@cs.berkeley.edu>
- */
-#ifndef ROS_KERN_ARCH_COLORED_PAGE_ALLOC_H
-#define ROS_KERN_ARCH_COLORED_PAGE_ALLOC_H
-
-/********** Page Coloring Related Macros ************/
-// Define these to make sure that each level of the cache
-// is initialized and managed properly
-#define DECLARE_CACHE_COLORED_PAGE_LINKS()                    \
-       DECLARE_CACHE_COLORED_PAGE_LINK(l1)                       \
-       DECLARE_CACHE_COLORED_PAGE_LINK(l2)                       \
-       DECLARE_CACHE_COLORED_PAGE_LINK(l3)
-
-#define DECLARE_CACHE_COLORED_PAGE_FREE_LISTS()               \
-       DECLARE_CACHE_COLORED_PAGE_FREE_LIST(l1)                  \
-       DECLARE_CACHE_COLORED_PAGE_FREE_LIST(l2)                  \
-       DECLARE_CACHE_COLORED_PAGE_FREE_LIST(l3)
-       
-#define DECLARE_EXTERN_CACHE_COLORED_PAGE_FREE_LISTS()        \
-       DECLARE_EXTERN_CACHE_COLORED_PAGE_FREE_LIST(l1)           \
-       DECLARE_EXTERN_CACHE_COLORED_PAGE_FREE_LIST(l2)           \
-       DECLARE_EXTERN_CACHE_COLORED_PAGE_FREE_LIST(l3)
-       
-#define DECLARE_CACHE_COLORED_PAGE_ALLOC_FUNCTIONS()          \
-       DECLARE_CACHE_COLORED_PAGE_ALLOC_FUNCTION(l1)             \
-       DECLARE_CACHE_COLORED_PAGE_ALLOC_FUNCTION(l2)             \
-       DECLARE_CACHE_COLORED_PAGE_ALLOC_FUNCTION(l3)
-
-#define INIT_CACHE_COLORED_PAGE_FREE_LISTS()                  \
-       INIT_CACHE_COLORED_PAGE_FREE_LIST(l1)                     \
-       INIT_CACHE_COLORED_PAGE_FREE_LIST(l2)                     \
-       INIT_CACHE_COLORED_PAGE_FREE_LIST(l3)
-
-#define REMOVE_CACHE_COLORING_PAGE_FROM_FREE_LISTS(page)      \
-       REMOVE_CACHE_COLORING_PAGE_FROM_FREE_LIST(page, l1)       \
-       REMOVE_CACHE_COLORING_PAGE_FROM_FREE_LIST(page, l2)       \
-       REMOVE_CACHE_COLORING_PAGE_FROM_FREE_LIST(page, l3)
-       
-#define INSERT_CACHE_COLORING_PAGE_ONTO_FREE_LISTS(page)      \
-       INSERT_CACHE_COLORING_PAGE_ONTO_FREE_LIST(page, l1)       \
-       INSERT_CACHE_COLORING_PAGE_ONTO_FREE_LIST(page, l2)       \
-       INSERT_CACHE_COLORING_PAGE_ONTO_FREE_LIST(page, l3)
-
-#endif // CACHE_COLORING_PAGE_ALLOC_H
diff --git a/kern/arch/sparc/configs/defconfig b/kern/arch/sparc/configs/defconfig
deleted file mode 120000 (symlink)
index b98ff45..0000000
+++ /dev/null
@@ -1 +0,0 @@
-../../../../config-default
\ No newline at end of file
diff --git a/kern/arch/sparc/console.c b/kern/arch/sparc/console.c
deleted file mode 100644 (file)
index 4f117df..0000000
+++ /dev/null
@@ -1,74 +0,0 @@
-#include <frontend.h>
-#include <pmap.h>
-
-void
-cons_init(void)
-{
-}
-
-// `High'-level console I/O.  Used by readline and cprintf.
-
-void
-cputbuf(const char*COUNT(len) buf, int len)
-{
-       frontend_syscall(0,APPSERVER_SYSCALL_write,1,PADDR((int32_t)buf),len,0,0);
-}
-
-// Low-level console I/O
-
-inline void
-cons_putc(int c)
-{
-       if(c == '\b' || c == 0x7F)
-       {
-       #ifdef CONFIG_PRINTK_NO_BACKSPACE
-               char buf[2] = {'^', 'H'};
-               cputbuf(buf, 2);
-       #else
-               char buf[3] = {'\b', ' ', '\b'};
-               cputbuf(buf, 3);
-       #endif /* CONFIG_PRINTK_NO_BACKSPACE */
-       }
-       else
-       {
-               char ch = c;
-               cputbuf(&ch,1);
-       }
-}
-
-void
-cputchar(int c)
-{
-       char ch = c;
-       cputbuf(&ch,1);
-}
-
-int
-cons_getc()
-{
-       char ch;
-       uintptr_t paddr = PADDR((uintptr_t)&ch);
-       int32_t ret = frontend_syscall(0,APPSERVER_SYSCALL_read,0,paddr,1,0,0);
-       if(ch == 0x7F)
-               ch = '\b';
-       return ret <= 0 ? 0 : ch;
-       //int ret = sys_nbgetch();
-       //return ret < 0 ? 0 : ret;
-}
-
-int
-getchar(void)
-{
-        int c;
-
-        while ((c = cons_getc()) == 0)
-                /* do nothing */;
-        return c;
-}
-
-int
-iscons(int fdnum)
-{
-        // used by readline
-        return 1;
-}
diff --git a/kern/arch/sparc/console.h b/kern/arch/sparc/console.h
deleted file mode 100644 (file)
index c12e8fc..0000000
+++ /dev/null
@@ -1,19 +0,0 @@
-/* See COPYRIGHT for copyright information. */
-
-#ifndef _CONSOLE_H_
-#define _CONSOLE_H_
-#ifndef ROS_KERNEL
-# error "This is a ROS kernel header; user programs should not #include it"
-#endif
-
-#include <ros/common.h>
-
-#define CRT_ROWS       25
-#define CRT_COLS       80
-#define CRT_SIZE       (CRT_ROWS * CRT_COLS)
-
-void cons_init(void);
-void cons_putc(int c);
-int cons_getc(void);
-
-#endif /* _CONSOLE_H_ */
diff --git a/kern/arch/sparc/cpuinfo.c b/kern/arch/sparc/cpuinfo.c
deleted file mode 100644 (file)
index 9e89d21..0000000
+++ /dev/null
@@ -1,83 +0,0 @@
-#include <arch/sparc.h>
-#include <arch/arch.h>
-#include <arch/mmu.h>
-#include <stdio.h>
-#include <assert.h>
-#include <smp.h>
-#include <umem.h>
-#include <pmap.h>
-
-#ifdef __SHARC__
-#pragma nosharc
-#endif
-
-#ifdef __DEPUTY__
-#pragma nodeputy
-#endif
-
-void
-static_asserts_can_go_here()
-{
-       static_assert(SIZEOF_HW_TRAPFRAME == sizeof(struct hw_trapframe));
-       static_assert(SIZEOF_HW_TRAPFRAME % 8 == 0);
-       static_assert(SIZEOF_KERNEL_MESSAGE_T == sizeof(kernel_message_t));
-       static_assert(SIZEOF_KERNEL_MESSAGE_T % 8 == 0);
-       static_assert(offsetof(env_t,scp_ctx) % 8 == 0);
-}
-
-void
-print_cpuinfo(void)
-{
-       uint32_t psr = read_psr();
-       uint32_t wim = read_wim();
-       uint32_t tbr = read_tbr();
-
-       uint32_t mmucr  = read_mmu_reg(MMU_REG_CTRL);
-       uint32_t mmuctp = read_mmu_reg(MMU_REG_CTXTBL);
-       uint32_t mmuctx = read_mmu_reg(MMU_REG_CTX);
-       uint32_t mmufsr = read_mmu_reg(MMU_REG_FSR);
-       uint32_t mmufar = read_mmu_reg(MMU_REG_FAR);
-
-       cprintf("CPU Info:\n");
-       cprintf("ISA:             SPARC V8\n");
-       cprintf("Number of cores: %d\n",num_cpus);
-       cprintf("Implementation:  0x%x\n",(psr >> 28) & 0xF);
-       cprintf("Version:         0x%x\n",(psr >> 24) & 0xF);
-       cprintf("Current PSR:     0x%08x\n",psr);
-       cprintf("Current WIM:     0x%08x\n",wim);
-       cprintf("Current TBR:     0x%08x\n",tbr);
-
-       cprintf("SRMMU Info:\n");
-       cprintf("Implementation:  0x%x\n",(mmucr >> 28) & 0xF);
-       cprintf("Version:         0x%x\n",(mmucr >> 24) & 0xF);
-       cprintf("Current CR:      0x%08x\n",mmucr);
-       cprintf("Current CTP:     0x%08x\n",mmuctp);
-       cprintf("Current CTX:     0x%08x\n",mmuctx);
-       cprintf("Current FSR:     0x%08x\n",mmufsr);
-       cprintf("Current FAR:     0x%08x\n",mmufar);
-}
-
-void show_mapping(uintptr_t start, size_t size)
-{
-       extern pde_t l1_page_table[NL1ENTRIES];
-       pte_t* pte;
-       uintptr_t i;
-       page_t* page;
-
-       cprintf("   Virtual    Physical  C M R ACC P\n");
-       cprintf("------------------------------------------\n");
-       for(i = 0; i < size; i += PGSIZE, start += PGSIZE)
-       {
-               page = page_lookup(l1_page_table,(void*)start,&pte);
-               cprintf("%p  ",start);
-               if(page)
-               {
-                       cprintf("%p  %1d %1d %1d  %1x  %1d\n",page2pa(page),
-                               !!(*pte & PTE_C),!!(*pte & PTE_M),
-                               !!(*pte & PTE_R),(*pte & PTE_ACC) >> 2,
-                               !!(*pte & PTE_PTE));
-               }
-               else
-                       cprintf("%p\n",0);
-       }
-}
diff --git a/kern/arch/sparc/endian.h b/kern/arch/sparc/endian.h
deleted file mode 100644 (file)
index e4ed150..0000000
+++ /dev/null
@@ -1,30 +0,0 @@
-/* Copyright (c) 2010 The Regents of the University of California
- * Barret Rhoden <brho@cs.berkeley.edu>
- * See LICENSE for details.
- *
- * Endian #def and byte_swapping functions */
-
-#ifndef ROS_KERN_ARCH_ENDIAN_H
-#define ROS_KERN_ARCH_ENDIAN_H
-
-#include <ros/common.h>
-#include <arch/types.h>
-
-static inline uint16_t byte_swap16(uint16_t x)
-{
-       return (uint16_t)(x << 8 | x >> 8);
-}
-
-static inline uint32_t byte_swap32(uint32_t x)
-{
-       return (uint32_t)(((uint32_t)byte_swap16(x & 0xffff) << 16) |
-                         (byte_swap16(x >> 16)));
-}
-
-static inline uint64_t byte_swap64(uint64_t x)
-{
-       return (uint64_t)(((uint64_t)byte_swap32(x & 0xffffffff) << 32) |
-                         (byte_swap32(x >> 32)));
-}
-
-#endif /* ROS_KERN_ARCH_ENDIAN_H */
diff --git a/kern/arch/sparc/entry.S b/kern/arch/sparc/entry.S
deleted file mode 100644 (file)
index 11244a3..0000000
+++ /dev/null
@@ -1,261 +0,0 @@
-/* See COPYRIGHT for copyright information. */
-
-#include <arch/mmu.h>
-#include <arch/sparc.h>
-#include <arch/arch.h>
-#include <ros/memlayout.h>
-
-///////////////////////////////////////////////////////////////////
-// The kernel (this code) is linked at address (KERNBASE + 0x00000000),
-// but we tell the bootloader to load it at physical address 
-// 0x00000000, which is the start of extended memory.
-// (See kernel.ld)
-///////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////
-// RELOC(x) maps a symbol x from its link address to its actual
-// location in physical memory (its load address).      
-///////////////////////////////////////////////////////////////////
-#define        RELOC(x) ((x) - KERNBASE)
-
-///////////////////////////////////////////////////////////////////
-// entry point
-///////////////////////////////////////////////////////////////////
-
-.text
-
-.global                _start
-_start:
-       // This is the first code that ever executes.  It executes on all
-       // cores (RAMP Gold-specific).  All we know is that PSR.S (supervisor)
-       // and PSR.ET (enable traps) are both 0.  Before we can enable traps,
-       // we must determine how many register windows we have, set up the
-       // trap table, and set up a stack frame.
-
-       // compute NWINDOWS
-
-       mov     0,%wim                          ! mark all windows valid
-       mov (PSR_PIL|PSR_S|PSR_PS),%psr ! CWP = 0
-       nop; nop; nop                   ! 3 insns between write -> read state reg
-       save                                    ! CWP = (CWP-1) % NWINDOWS = NWINDOWS-1
-       mov     %psr,%g2
-       and     %g2,PSR_CWP,%g2         ! g2 = NWINDOWS-1
-       restore                                 ! CWP = 0
-       mov     1<<1,%wim                       ! mark window 1 invalid (trap on restore)
-
-       // now g2 = NWINDOWS - 1.  Patch the window spill trap handler.
-       set     RELOC(spill_patchme),%g1
-       ld      [%g1],%g3
-       or      %g2,%g3,%g3
-       st      %g3,[%g1]
-       flush   %g1
-
-       // and patch the window fill trap handler.
-       set     RELOC(fill_patchme),%g1
-       ld      [%g1],%g3
-       or      %g2,%g3,%g3
-       st      %g3,[%g1]
-       flush   %g1
-
-       // and patch the trap entry point.
-       set     RELOC(trap_patchme),%g1
-       ld      [%g1],%g3
-       or      %g2,%g3,%g3
-       st      %g3,[%g1]
-       flush   %g1
-
-       // store NWINDOWS away for safekeeping
-       set     RELOC(NWINDOWS),%g1
-       inc     %g2
-       st      %g2,[%g1]
-
-       // set up the TBR (trap base register)
-       set     RELOC(trap_table),%g1
-       mov     %g1,%tbr
-
-       // clear frame pointer for backtrace termination
-       mov     0,%fp
-
-       // set stack pointer (-64 is space for window spill)
-       // sp = bootstacktop - core_id*KSTKSIZE - 64
-       set     RELOC(bootstacktop)-64,%sp
-       mov     CORE_ID_REG,%g1
-       sll     %g1,KSTKSHIFT,%g2
-       sub     %sp,%g2,%sp
-
-       // set up a virtual->physical mapping
-       tst     %g1
-       set     RELOC(pagetable_init_done),%l0
-       bne pagetable_init_wait
-        nop
-
-       // core 0 initializes the pagetable
-       call    pagetable_init
-        nop
-       mov     1,%g2
-       st      %g2,[%l0]
-
-pagetable_init_wait:
-       ld      [%l0],%g1
-       tst     %g1
-       be      pagetable_init_wait
-        nop
-
-       call    mmu_init
-        nop
-
-       // relocate
-       set     trap_table,%g1
-       mov     %g1,%tbr
-       set     reloc,%g1
-       set     KERNBASE,%g2
-       jmp     %g1
-        add    %g2,%sp,%sp
-reloc:
-       call    mmu_boot_cleanup_all
-        nop
-
-       mov     1,%g1
-       set     cores_relocated,%g2
-       set     cores_relocated_lock,%g3
-       swap    [%g3],%g1
-       tst     %g1
-       bne     reloc
-        nop
-       ld      [%g2],%g1
-       inc     %g1
-       st      %g1,[%g2]
-       st      %g0,[%g3]
-
-wait_for_reloc:
-       ld      [%g2],%g1
-       mov     NUM_CORES_REG,%g3
-       cmp     %g1,%g3
-       bl      wait_for_reloc
-        nop
-
-       // Set our stacktop so we can find it on a trap or spill/fill
-       mov     CORE_ID_REG,%l1
-       sll     %l1,KSTKSHIFT,%l1
-       set     bootstacktop,%l2
-       sub     %l2,%l1,%l1             // %l1 now holds our current stacktop
-       mov     CORE_ID_REG,%l0
-       sll     %l0,2,%l0
-       set     core_stacktops,%l2
-       st      %l1,[%l2 + %l0]         // store the stacktop in its slot
-
-       // now it's safe to enable traps
-       mov     %psr,%g1
-       wr      %g1,PSR_ET,%psr
-       nop; nop; nop
-
-       // am i core 0?  (do i run BSD?!?)
-       mov     CORE_ID_REG,%g1
-       tst     %g1
-       bne     4f
-        nop
-
-       // only core 0 gets here
-       call    mmu_boot_cleanup_core0
-        nop
-
-       // set num_cpus
-       set     num_cpus,%l0
-       mov     NUM_CORES_REG,%l1
-       st      %l1,[%l0]
-
-       cmp     %l1,MAX_NUM_CPUS
-       tg      0x7f
-
-       // use a stack in the data section (as opposed to bss) here,
-       // since kernel_init will zero the stack
-       set     core0_bootstacktop-64,%sp
-       // reset core0's stacktop to core0_bootstacktop
-       set     core0_bootstacktop,%l1
-       set     core_stacktops,%l2
-       st      %l1,[%l2]               // store the stacktop in its slot
-
-       sub     %sp,64,%sp              ! 64 >= sizeof(multiboot_header_t)
-       call    build_multiboot_info
-        add    %sp,64,%o0
-
-       // kernel_init time!
-       // first arg is pointer to multiboot_info_t, but kernel_init
-       // expects it to be a pre-relocation address, so lop off KERNBASE
-       set     KERNBASE,%l0
-       add     %sp,64,%o0
-       call    kernel_init
-        sub    %o0,%l0,%o0
-
-       // shouldn't get here
-3:     ba      3b
-        nop
-
-       // i'm not core 0, so i'll call smp_init when the time is nigh
-4:     set     time_for_smp_init,%l1
-       ld      [%l1],%l0
-       tst     %l0
-       be      4b
-        nop
-
-       call    smp_init
-        nop
-
-       // shouldn't get here
-5:     ba      5b
-        nop
-
-///////////////////////////////////////////////////////////////////
-// various data
-///////////////////////////////////////////////////////////////////
-.data
-
-pagetable_init_done:
-       .word 0
-
-cores_relocated:
-       .word 0
-cores_relocated_lock:
-       .word 0
-
-       .global         time_for_smp_init
-time_for_smp_init:
-       .word           0
-
-       .global         NWINDOWS
-NWINDOWS:
-       .word           0
-
-       .global         num_cpus
-num_cpus:
-       .word           0
-
-///////////////////////////////////////////////////////////////////
-// boot stack
-///////////////////////////////////////////////////////////////////
-
-.section ".bss"
-       .align          PGSIZE
-       .space          KSTKSIZE*MAX_NUM_CPUS
-       .global         bootstacktop   
-bootstacktop:
-
-.data
-       .align          PGSIZE
-       .space          KSTKSIZE
-       .global         core0_bootstacktop
-core0_bootstacktop:
-
-///////////////////////////////////////////////////////////////////
-// page tables
-///////////////////////////////////////////////////////////////////
-       .align          (NCONTEXTS+CONTEXT_TABLE_PAD)*4
-       .global         mmu_context_tables
-mmu_context_tables:
-       .skip           MAX_NUM_CPUS*(NCONTEXTS+CONTEXT_TABLE_PAD)*4
-
-       .align          1024
-       .global         l1_page_table
-l1_page_table:
-       .skip           1024
diff --git a/kern/arch/sparc/env.c b/kern/arch/sparc/env.c
deleted file mode 100644 (file)
index adcd098..0000000
+++ /dev/null
@@ -1,159 +0,0 @@
-/* See COPYRIGHT for copyright information. */
-#ifdef __SHARC__
-#pragma nosharc
-#endif
-
-#ifdef __DEPUTY__
-#pragma noasync
-#endif
-
-#include <trap.h>
-#include <env.h>
-#include <assert.h>
-#include <arch/arch.h>
-#include <pmap.h>
-
-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");
-
-       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
-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");
-
-       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);
-}
-
-void init_fp_state(void)
-{
-       /* TODO: implement me! */
-}
-
-// Flush all mapped pages in the user portion of the address space
-// TODO: only supports L3 user pages
-int
-env_user_mem_walk(env_t* e, void* start, size_t len,
-                  mem_walk_callback_t callback, void* arg)
-{
-       pte_t *l1pt = e->env_pgdir;
-
-       assert((uintptr_t)start % PGSIZE == 0 && len % PGSIZE == 0);
-       void* end = (char*)start+len;
-
-       int l1x_start = L1X(start);
-       int l1x_end = L1X(ROUNDUP(end,L1PGSIZE));
-       for(int l1x = l1x_start; l1x < l1x_end; l1x++)
-       {
-               if(!(l1pt[l1x] & PTE_PTD))
-                       continue;
-
-               physaddr_t l2ptpa = PTD_ADDR(l1pt[l1x]);
-               pte_t* l2pt = (pte_t*)KADDR(l2ptpa);
-
-               int l2x_start = l1x == l1x_start ? L2X(start) : 0;
-               int l2x_end = l1x == l1x_end-1 && L2X(ROUNDUP(end,L2PGSIZE)) ?
-                             L2X(ROUNDUP(end,L2PGSIZE)) : NL2ENTRIES;
-               for(int l2x = l2x_start; l2x < l2x_end; l2x++)
-               {
-                       if(!(l2pt[l2x] & PTE_PTD))
-                               continue;
-
-                       physaddr_t l3ptpa = PTD_ADDR(l2pt[l2x]);
-                       pte_t* l3pt = (pte_t*)KADDR(l3ptpa);
-
-                       int l3x_start = l1x == l1x_start && l2x == l2x_start ?
-                                       L3X(start) : 0;
-                       int l3x_end = l1x == l1x_end-1 && l2x == l2x_end-1 && L3X(end) ?
-                                     L3X(end) : NL3ENTRIES;
-                       for(int l3x = l3x_start, ret; l3x < l3x_end; l3x++)
-                               if(!PAGE_UNMAPPED(l3pt[l3x]))
-                                       if((ret = callback(e,&l3pt[l3x],PGADDR(l1x,l2x,l3x,0),arg)))
-                                               return ret;
-               }
-       }
-
-       return 0;
-}
-
-void
-env_pagetable_free(env_t* e)
-{
-       static_assert(L2X(KERNBASE) == 0 && L3X(KERNBASE) == 0);
-       pte_t *l1pt = e->env_pgdir;
-
-       for(int l1x = 0; l1x < L1X(KERNBASE); l1x++)
-       {
-               if(!(l1pt[l1x] & PTE_PTD))
-                       continue;
-
-               physaddr_t l2ptpa = PTD_ADDR(l1pt[l1x]);
-               pte_t* l2pt = (pte_t*)KADDR(l2ptpa);
-
-               for(int l2x = 0; l2x < NL2ENTRIES; l2x++)
-               {
-                       if(!(l2pt[l2x] & PTE_PTD))
-                               continue;
-
-                       physaddr_t l3ptpa = PTD_ADDR(l2pt[l2x]);
-                       l2pt[l2x] = 0;
-                       page_decref(pa2page(l3ptpa));
-               }
-
-               l1pt[l1x] = 0;
-               page_decref(pa2page(l2ptpa));
-       }
-
-       page_decref(pa2page(e->env_cr3));
-       tlbflush();
-}
diff --git a/kern/arch/sparc/fpu.c b/kern/arch/sparc/fpu.c
deleted file mode 100644 (file)
index 883391e..0000000
+++ /dev/null
@@ -1,187 +0,0 @@
-#include <arch/sparcfpu.h>
-#include <arch/arch.h>
-#include <trap.h>
-#include <umem.h>
-#include <pmap.h>
-#include <smp.h>
-
-static inline uint32_t *effective_address(struct hw_trapframe *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(struct hw_trapframe *state, void *addr)
-{
-       state->fault_status = 1;
-       state->fault_addr = (uint32_t)addr;
-       data_access_exception(state);
-}
-
-static inline uint32_t fp_load_word(struct hw_trapframe *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(struct hw_trapframe *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(struct hw_trapframe *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(struct hw_trapframe *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(struct hw_trapframe *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));
-}
diff --git a/kern/arch/sparc/init.c b/kern/arch/sparc/init.c
deleted file mode 100644 (file)
index df76f79..0000000
+++ /dev/null
@@ -1,38 +0,0 @@
-/* See COPYRIGHT for copyright information. */
-
-#ifdef __SHARC__
-#pragma nosharc
-#endif
-
-#include <smp.h>
-#include <arch/init.h>
-
-size_t argc;
-char** argv;
-// dummy values to avoid putting this in the BSS section
-void* __args[(4096+8)/sizeof(void*)] __attribute__((aligned(8))) = {(void*)1};
-
-static void
-init_argc_argv()
-{
-        argc = (size_t)__args[2];
-        argv = (char**)&__args[3];
-
-        //argv[0] should be "none" for ROS.  we'll ignore it.
-        if(argc > 0)
-        {
-                argc--;
-                argv++;
-        }
-
-        for(size_t i = 0; i < argc; i++)
-                argv[i] += (char*)(&__args[2])-(char*)NULL;
-}
-
-void arch_init()
-{              
-       // this returns when all other cores are done and ready to receive IPIs
-       init_argc_argv();
-       smp_boot();
-       proc_init();
-}
diff --git a/kern/arch/sparc/init.h b/kern/arch/sparc/init.h
deleted file mode 100644 (file)
index f412030..0000000
+++ /dev/null
@@ -1,11 +0,0 @@
-/* See COPYRIGHT for copyright information. */
-
-#ifndef ROS_ARCH_INIT_H
-#define ROS_ARCH_INIT_H
-
-extern size_t argc;
-extern char** argv;
-
-void arch_init();
-
-#endif // !ROS_ARCH_INIT_H
diff --git a/kern/arch/sparc/kbdreg.h b/kern/arch/sparc/kbdreg.h
deleted file mode 100644 (file)
index 0c7ffea..0000000
+++ /dev/null
@@ -1,83 +0,0 @@
-#ifndef ROS_KBDREG_H
-#define ROS_KBDREG_H
-
-// Special keycodes
-#define KEY_HOME       0xE0
-#define KEY_END                0xE1
-#define KEY_UP         0xE2
-#define KEY_DN         0xE3
-#define KEY_LF         0xE4
-#define KEY_RT         0xE5
-#define KEY_PGUP       0xE6
-#define KEY_PGDN       0xE7
-#define KEY_INS                0xE8
-#define KEY_DEL                0xE9
-
-
-/* This is i8042reg.h + kbdreg.h from NetBSD. */
-
-#define        KBSTATP         0x64    /* kbd controller status port(I) */
-#define         KBS_DIB        0x01    /* kbd data in buffer */
-#define         KBS_IBF        0x02    /* kbd input buffer low */
-#define         KBS_WARM       0x04    /* kbd input buffer low */
-#define         KBS_OCMD       0x08    /* kbd output buffer has command */
-#define         KBS_NOSEC      0x10    /* kbd security lock not engaged */
-#define         KBS_TERR       0x20    /* kbd transmission error */
-#define         KBS_RERR       0x40    /* kbd receive error */
-#define         KBS_PERR       0x80    /* kbd parity error */
-
-#define        KBCMDP          0x64    /* kbd controller port(O) */
-#define         KBC_RAMREAD    0x20    /* read from RAM */
-#define         KBC_RAMWRITE   0x60    /* write to RAM */
-#define         KBC_AUXDISABLE 0xa7    /* disable auxiliary port */
-#define         KBC_AUXENABLE  0xa8    /* enable auxiliary port */
-#define         KBC_AUXTEST    0xa9    /* test auxiliary port */
-#define         KBC_KBDECHO    0xd2    /* echo to keyboard port */
-#define         KBC_AUXECHO    0xd3    /* echo to auxiliary port */
-#define         KBC_AUXWRITE   0xd4    /* write to auxiliary port */
-#define         KBC_SELFTEST   0xaa    /* start self-test */
-#define         KBC_KBDTEST    0xab    /* test keyboard port */
-#define         KBC_KBDDISABLE 0xad    /* disable keyboard port */
-#define         KBC_KBDENABLE  0xae    /* enable keyboard port */
-#define         KBC_PULSE0     0xfe    /* pulse output bit 0 */
-#define         KBC_PULSE1     0xfd    /* pulse output bit 1 */
-#define         KBC_PULSE2     0xfb    /* pulse output bit 2 */
-#define         KBC_PULSE3     0xf7    /* pulse output bit 3 */
-
-#define        KBDATAP         0x60    /* kbd data port(I) */
-#define        KBOUTP          0x60    /* kbd data port(O) */
-
-#define        K_RDCMDBYTE     0x20
-#define        K_LDCMDBYTE     0x60
-
-#define        KC8_TRANS       0x40    /* convert to old scan codes */
-#define        KC8_MDISABLE    0x20    /* disable mouse */
-#define        KC8_KDISABLE    0x10    /* disable keyboard */
-#define        KC8_IGNSEC      0x08    /* ignore security lock */
-#define        KC8_CPU         0x04    /* exit from protected mode reset */
-#define        KC8_MENABLE     0x02    /* enable mouse interrupt */
-#define        KC8_KENABLE     0x01    /* enable keyboard interrupt */
-#define        CMDBYTE         (KC8_TRANS|KC8_CPU|KC8_MENABLE|KC8_KENABLE)
-
-/* keyboard commands */
-#define        KBC_RESET       0xFF    /* reset the keyboard */
-#define        KBC_RESEND      0xFE    /* request the keyboard resend the last byte */
-#define        KBC_SETDEFAULT  0xF6    /* resets keyboard to its power-on defaults */
-#define        KBC_DISABLE     0xF5    /* as per KBC_SETDEFAULT, but also disable key scanning */
-#define        KBC_ENABLE      0xF4    /* enable key scanning */
-#define        KBC_TYPEMATIC   0xF3    /* set typematic rate and delay */
-#define        KBC_SETTABLE    0xF0    /* set scancode translation table */
-#define        KBC_MODEIND     0xED    /* set mode indicators(i.e. LEDs) */
-#define        KBC_ECHO        0xEE    /* request an echo from the keyboard */
-
-/* keyboard responses */
-#define        KBR_EXTENDED    0xE0    /* extended key sequence */
-#define        KBR_RESEND      0xFE    /* needs resend of command */
-#define        KBR_ACK         0xFA    /* received a valid command */
-#define        KBR_OVERRUN     0x00    /* flooded */
-#define        KBR_FAILURE     0xFD    /* diagnosic failure */
-#define        KBR_BREAK       0xF0    /* break code prefix - sent on key release */
-#define        KBR_RSTDONE     0xAA    /* reset complete */
-#define        KBR_ECHO        0xEE    /* echo response */
-
-#endif /* !ROS_KBDREG_H */
diff --git a/kern/arch/sparc/kdebug.c b/kern/arch/sparc/kdebug.c
deleted file mode 100644 (file)
index 60cc923..0000000
+++ /dev/null
@@ -1,71 +0,0 @@
-#include <arch/sparc.h>
-#include <arch/arch.h>
-#include <arch/mmu.h>
-#include <stdio.h>
-#include <assert.h>
-#include <smp.h>
-#include <umem.h>
-#include <pmap.h>
-#include <kdebug.h>
-
-int debuginfo_eip(uintptr_t eip, struct eipdebuginfo *info)
-{
-       static bool once = TRUE;
-       if (once) {
-               warn("Not implemented for sparc");
-               once = FALSE;
-       }
-       return 0;
-}
-
-void backtrace(void)
-{
-       int i = 0, j;
-
-       flush_windows();
-
-       cprintf("Backtrace:\n");
-
-       // hack: assumes (correctly) we aren't a leaf routine
-       void *sp, *pc, *newsp;
-       __asm__ __volatile__ ("mov %%sp,%0" : "=r"(sp));
-
-       assert(sp >= (void*)KERNBASE);
-
-       newsp = *((void**)sp+14);
-       pc = *((void**)sp+15);
-
-       cprintf("initial sp = %x, newsp = %x, pc = %x\n",sp,newsp,pc);
-       assert(newsp >= (void*)KERNBASE);
-
-       while(newsp)
-       {
-               cprintf("#%02d [<%x>]:\n",++i,pc);
-               cprintf("    %%sp: %x   Args:",newsp);
-               for(j = 8; j < 14; j++)
-                       cprintf(" %x",*((void**)sp+j));
-               cprintf("\n");
-
-               sp = newsp;
-
-               if(sp >= (void*)KERNBASE && (void**)sp+16 > ((void**)0+16))
-               {
-                       newsp = *((void**)sp+14);
-                       pc = *((void**)sp+15);
-               }
-               else if(current)
-               {
-                       error_t ret;
-                       ret  = memcpy_from_user(current,&newsp,(void**)sp+14,sizeof(void*));
-                       ret |= memcpy_from_user(current,&pc,(void**)sp+15,sizeof(void*));
-                       if(ret)
-                       {
-                               warn("Backtrace would have caused access exception;"
-                                    "corrupt user stack?");
-                               break;
-                       }
-               }
-               else
-                       break;
-       }
-}
diff --git a/kern/arch/sparc/kdebug.h b/kern/arch/sparc/kdebug.h
deleted file mode 100644 (file)
index 3ac5c5f..0000000
+++ /dev/null
@@ -1,25 +0,0 @@
-/* Copyright (c) 2011 The Regents of the University of California
- * Barret Rhoden <brho@cs.berkeley.edu>
- * See LICENSE for details.
- *
- * Sparc-specific Kernel debugging headers and static inlines */
-
-#ifndef ROS_KERN_ARCH_KDEBUG_H
-#define ROS_KERN_ARCH_KDEBUG_H
-
-#include <ros/common.h>
-#include <assert.h>
-
-/* Returns a PC/EIP in the function that called us, preferably near the call
- * site. */
-static inline uintptr_t get_caller_pc(void)
-{
-       static bool once = TRUE;
-       if (once) {
-               warn("Not implemented for sparc");
-               once = FALSE;
-       }
-       return 0;
-}
-
-#endif /* ROS_KERN_ARCH_KDEBUG_H */
diff --git a/kern/arch/sparc/kernel.ld b/kern/arch/sparc/kernel.ld
deleted file mode 100644 (file)
index 92d3336..0000000
+++ /dev/null
@@ -1,62 +0,0 @@
-/* Simple linker script for the ROS kernel.
-   See the GNU ld 'info' manual ("info ld") to learn the syntax. */
-
-OUTPUT_FORMAT("elf32-sparc", "elf32-sparc", "elf32-sparc")
-OUTPUT_ARCH(sparc)
-ENTRY(_start)
-
-SECTIONS
-{
-       /* Link the kernel for 0xC01000C0, but load it at 0x001000C0) */
-
-       .text 0x80000000 : AT(0x00000000) {
-               *(.text .stub .text.* .gnu.linkonce.t.*)
-       }
-
-       PROVIDE(etext = .);     /* Define the 'etext' symbol to this value */
-
-       .rodata : {
-               *(.rodata .rodata.* .gnu.linkonce.r.*)
-       }
-
-       /* Include debugging information in kernel memory */
-       .stab : {
-               PROVIDE(stab = .);
-               PROVIDE(__STAB_BEGIN__ = .);
-               *(.stab);
-               PROVIDE(estab = .);
-               PROVIDE(__STAB_END__ = .);
-               BYTE(0)         /* Force the linker to allocate space
-                                  for this section */
-       }
-
-       .stabstr : {
-               PROVIDE(stabstr = .);
-               PROVIDE(__STABSTR_BEGIN__ = .);
-               *(.stabstr);
-               PROVIDE(estabstr = .);
-               PROVIDE(__STABSTR_END__ = .);
-               BYTE(0)         /* Force the linker to allocate space
-                                  for this section */
-       }
-
-       /* Adjust the address for the data segment to the next page */
-       . = ALIGN(0x1000);
-
-       /* The data segment */
-       .data : {
-               *(.data)
-       }
-
-       PROVIDE(edata = .);
-
-       .bss : {
-               *(.bss)
-       }
-
-       PROVIDE(end = .);
-
-       /DISCARD/ : {
-               *(.eh_frame .note.GNU-stack)
-       }
-}
diff --git a/kern/arch/sparc/mmu.h b/kern/arch/sparc/mmu.h
deleted file mode 100644 (file)
index ad91d34..0000000
+++ /dev/null
@@ -1,7 +0,0 @@
-#ifndef ROS_ARCH_MMU_H
-#define ROS_ARCH_MMU_H
-
-/* til we remove this file, unless we have some kernel-only stuff later */
-#include <ros/arch/mmu.h>
-
-#endif /* ROS_ARCH_MMU_H */
diff --git a/kern/arch/sparc/page_alloc.c b/kern/arch/sparc/page_alloc.c
deleted file mode 100644 (file)
index 89165a2..0000000
+++ /dev/null
@@ -1,83 +0,0 @@
-/* Copyright (c) 2009 The Regents of the University  of California. 
- * See the COPYRIGHT files at the top of this source tree for full 
- * license information.
- * 
- * Kevin Klues <klueska@cs.berkeley.edu>    
- */
-#ifdef __SHARC__
-#pragma nosharc
-#endif
-
-#ifdef __DEPUTY__
-#pragma nodeputy
-#endif
-
-#include <sys/queue.h>
-#include <page_alloc.h>
-#include <pmap.h>
-#include <kmalloc.h>
-#include <multiboot.h>
-#include <colored_caches.h>
-
-page_list_t *COUNT(llc_cache->num_colors) colored_page_free_list = NULL;
-spinlock_t colored_page_free_list_lock = SPINLOCK_INITIALIZER_IRQSAVE;
-
-void page_alloc_bootstrap() {
-        // Allocate space for the array required to manage the free lists
-        size_t list_size = llc_cache->num_colors*sizeof(page_list_t);
-        colored_page_free_list = (page_list_t*) boot_alloc(list_size, PGSIZE);
-}
-
-/*
- * Initialize the memory free lists.
- * After this point, ONLY use the functions below
- * to allocate and deallocate physical memory via the 
- * page_free_lists. 
- */
-void page_alloc_init() 
-{
-        // First Bootstrap the page alloc process
-        static bool bootstrapped = FALSE;
-        if(!bootstrapped) {
-                bootstrapped = TRUE;
-                page_alloc_bootstrap();
-        }
-
-        // Then, initialize the array required to manage the 
-               // colored page free list
-        for(int i=0; i<llc_cache->num_colors; i++) {
-                LIST_INIT(&(colored_page_free_list[i]));
-        }
-       
-       //  Finally, mark the pages already in use by the kernel. 
-       //  1) Mark page 0 as in use.
-       //     This way we preserve the real-mode IDT and BIOS structures
-       //     in case we ever need them.  (Currently we don't, but...)
-       //  2) Mark the rest of base memory as free.
-       //  3) Then comes the IO hole [IOPHYSMEM, EXTPHYSMEM).
-       //     Mark it as in use so that it can never be allocated.      
-       //  4) Then extended memory [EXTPHYSMEM, ...).
-       //     Some of it is in use, some is free.
-       int i;
-       physaddr_t physaddr_after_kernel = PADDR(ROUNDUP(boot_freemem, PGSIZE));
-
-       // mark [0, physaddr_after_kernel) as in-use
-       for(i = 0; i < LA2PPN(physaddr_after_kernel); i++)
-               page_setref(&pages[i], 1);
-
-       // mark [physaddr_after_kernel, maxaddrpa) as free
-       for(i = LA2PPN(physaddr_after_kernel); i < LA2PPN(maxaddrpa); i++)
-       {
-               page_setref(&pages[i], 0);
-                LIST_INSERT_HEAD(
-                   &(colored_page_free_list[get_page_color(i,llc_cache)]),
-                   &pages[i],
-                   pg_link
-                );
-       }
-
-       // mark [maxaddrpa, ...) as in-use (as they are invalid)
-       for(i = LA2PPN(maxaddrpa); i < npages; i++)
-               page_setref(&pages[i], 1);
-}
diff --git a/kern/arch/sparc/pmap.c b/kern/arch/sparc/pmap.c
deleted file mode 100644 (file)
index bf7d22a..0000000
+++ /dev/null
@@ -1,127 +0,0 @@
-#ifdef __SHARC__
-#pragma nosharc
-#endif
-
-#ifdef __DEPUTY__
-#pragma nodeputy
-#endif
-
-#include <arch/mmu.h>
-#include <ros/memlayout.h>
-#include <pmap.h>
-#include <string.h>
-#include <kmalloc.h>
-
-physaddr_t boot_cr3;
-pde_t* boot_pgdir;
-page_t* pages;
-page_list_t page_free_list;
-
-void
-vm_init(void)
-{
-       // we already set up our page tables before jumping
-       // into the kernel, so there's not much going on here
-
-       extern pde_t l1_page_table[NL1ENTRIES];
-       boot_pgdir = l1_page_table;
-       boot_cr3 = PADDR(boot_pgdir);
-}
-
-error_t
-pagetable_remove(pde_t* l1pt, void* va)
-{
-       panic("pagetable_remove doesn't work yet... -asw");
-       return 0;
-}
-
-pte_t*
-pgdir_walk(pde_t* l1pt, const void*SNT va, int create)
-{
-       pte_t *l1pte, *l2pt, *l2pte, *l3pt, *l3pte;
-       page_t* new_table;
-
-       l1pte = &l1pt[L1X(va)];
-       if(*l1pte & PTE_PTE)
-               return l1pte;
-       if(!(*l1pte & PTE_PTD))
-       {
-               int i, l1x_start, l2_tables_per_page;
-               physaddr_t pa;
-
-               if(!create)
-                       return NULL;
-
-               // create a new L2 PT.  we actually allocated way more
-               // space than needed, so also use it for the adjacent
-               // l2_tables_per_page-1 pages (if they're unmapped)
-
-               if(kpage_alloc(&new_table))
-                       return NULL;
-               memset(page2kva(new_table),0,PGSIZE);
-
-               l2_tables_per_page = PGSIZE/(sizeof(pte_t)*NL2ENTRIES);
-               l1x_start = L1X(va)/l2_tables_per_page*l2_tables_per_page;
-
-               for(i = 0; i < l2_tables_per_page; i++)
-               {
-                       if(l1pt[l1x_start+i] != 0)
-                               continue;
-
-                       page_incref(new_table);
-                       pa = page2pa(new_table) + i*sizeof(pte_t)*NL2ENTRIES;
-                       l1pt[l1x_start+i] = PTD(pa);
-               }
-
-               l1pte = &l1pt[L1X(va)];
-       }
-
-       l2pt = (pte_t*)KADDR(PTD_ADDR(*l1pte));
-       l2pte = &l2pt[L2X(va)];
-       if(*l2pte & PTE_PTE)
-               return l2pte;
-       if(!(*l2pte & PTE_PTD))
-       {
-               int i, l2x_start, l3_tables_per_page;
-               physaddr_t pa;
-
-               if(!create)
-                       return NULL;
-
-               if(kpage_alloc(&new_table))
-                       return NULL;
-               memset(page2kva(new_table),0,PGSIZE);
-
-               l3_tables_per_page = PGSIZE/(sizeof(pte_t)*NL3ENTRIES);
-               l2x_start = L2X(va)/l3_tables_per_page*l3_tables_per_page;
-
-               for(i = 0; i < l3_tables_per_page; i++)
-               {
-                       if(l2pt[l2x_start+i] != 0)
-                               continue;
-
-                       page_incref(new_table);
-                       pa = page2pa(new_table) + i*sizeof(pte_t)*NL3ENTRIES;
-                       l2pt[l2x_start+i] = PTD(pa);
-               }
-
-               l2pte = &l2pt[L2X(va)];
-       }
-
-       l3pt = (pte_t*)KADDR(PTD_ADDR(*l2pte));
-       l3pte = &l3pt[L3X(va)];
-       return l3pte;
-}
-
-/* TODO: this is probably wrong, since it only returns the pte as if it were the
- * perms. */
-int get_va_perms(pde_t *pgdir, const void *SNT va)
-{
-       pte_t* pte = pgdir_walk(pgdir, va, 0);
-       return pte == NULL ? 0 : (*pte & (PTE_ACC | PTE_PTE));
-}
-
-void
-page_check(void)
-{
-}
diff --git a/kern/arch/sparc/process.c b/kern/arch/sparc/process.c
deleted file mode 100644 (file)
index 4ce449c..0000000
+++ /dev/null
@@ -1,62 +0,0 @@
-#include <arch/arch.h>
-#include <trap.h>
-#include <process.h>
-#include <frontend.h>
-#include <pmap.h>
-#include <smp.h>
-
-#include <string.h>
-#include <assert.h>
-#include <stdio.h>
-
-#ifdef __SHARC__
-#pragma nosharc
-#endif
-
-/* TODO: handle user and kernel contexts */
-void proc_pop_ctx(struct user_context *ctx)
-{
-       struct hw_trapframe *tf = &ctx->tf.hw_tf;
-       assert(ctx->type == ROS_HW_CTX);
-       extern void env_pop_tf(struct hw_trapframe *tf);        /* in asm */
-       env_pop_tf(tf);
-}
-
-/* TODO: consider using a SW context */
-void proc_init_ctx(struct user_context *ctx, uint32_t vcoreid, uintptr_t entryp,
-                   uintptr_t stack_top)
-{
-       struct hw_trapframe *tf = &ctx->tf.hw_tf;
-       ctx->type = ROS_HW_CTX;
-
-       memset(tf,0,sizeof(*tf));
-
-       tf->psr = PSR_S; // but PS = 0
-       tf->gpr[14] = stack_top-96;
-
-       tf->pc = entryp;
-       tf->npc = entryp+4;
-
-       tf->gpr[6] = vcoreid;
-}
-
-/* TODO: handle both HW and SW contexts */
-void proc_secure_ctx(struct user_context *ctx)
-{
-       struct hw_trapframe *tf = &ctx->tf.hw_tf;
-       ctx->type = ROS_HW_CTX;
-       // only take the condition codes from the user.  we set S=1, PS=0
-       tf->psr = (tf->psr & PSR_ICC) | PSR_S;
-}
-
-/* Called when we are currently running an address space on our core and want to
- * abandon it.  We need a known good pgdir before releasing the old one.  We
- * decref, since current no longer tracks the proc (and current no longer
- * protects the cr3). */
-void __abandon_core(void)
-{
-       struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
-       lcr3(boot_cr3);
-       proc_decref(pcpui->cur_proc);
-       pcpui->cur_proc = 0;
-}
diff --git a/kern/arch/sparc/recip.S b/kern/arch/sparc/recip.S
deleted file mode 100644 (file)
index 8415e31..0000000
+++ /dev/null
@@ -1,465 +0,0 @@
-// Very convoluted FP sqrt/div emulation code.
-// Newton-Raphson method.
-
-#include <arch/trap_table.h>
-#include <arch/arch.h>
-#include <ros/memlayout.h>
-
-#define SET_RDD(src)            \
-       srl     %l0,25,%l3      ;\
-       and     %l3,0x1E,%l3    ;\
-       sll     %l3,2,%l3       ;\
-       add     %l6,%l3,%l3     ;\
-       std     src,[%l3+0x80]
-
-#define GET_RS1D(dest)          \
-       srl     %l0,14,%l3      ;\
-       and     %l3,0x1E,%l3    ;\
-       sll     %l3,2,%l3       ;\
-       add     %l6,%l3,%l3     ;\
-       WEIRDD_ADDR(%l3+0x80)   ;\
-       ldd     [%l3+0x80],dest
-
-#define GET_RS2D(dest)          \
-       and     %l0,0x1E,%l3    ;\
-       sll     %l3,2,%l3       ;\
-       add     %l6,%l3,%l3     ;\
-       WEIRDD_ADDR(%l3+0x80)   ;\
-       ldd     [%l3+0x80],dest
-
-#define SET_RD(src)             \
-       srl     %l0,25,%l3      ;\
-       and     %l3,0x1F,%l3    ;\
-       sll     %l3,2,%l3       ;\
-       add     %l6,%l3,%l3     ;\
-       st      src,[%l3+0x80]
-
-#define GET_RS1(dest)           \
-       srl     %l0,14,%l3      ;\
-       and     %l3,0x1F,%l3    ;\
-       sll     %l3,2,%l3       ;\
-       add     %l6,%l3,%l3     ;\
-       WEIRD_ADDR(%l3+0x80)    ;\
-       ld      [%l3+0x80],dest
-
-#define GET_RS2(dest)           \
-       and     %l0,0x1F,%l3    ;\
-       sll     %l3,2,%l3       ;\
-       add     %l6,%l3,%l3     ;\
-       WEIRD_ADDR(%l3+0x80)    ;\
-       ld      [%l3+0x80],dest
-
-#define RESTORE_STATE           \
-       ld      [%l6+64],%l1    ;\
-       ld      [%l6+68],%l2    ;\
-       ld      [%l6+72],%l3    ;\
-       ld      [%l6+76],%fsr   ;\
-       mov     %l3,%psr        ;\
-
-#define SAVE_FP_REGS            \
-       std     %f0, [%l6+0x80] ;\
-       std     %f2, [%l6+0x88] ;\
-       std     %f4, [%l6+0x90] ;\
-       std     %f6, [%l6+0x98] ;\
-       std     %f8, [%l6+0xA0] ;\
-       std     %f10,[%l6+0xA8] ;\
-       std     %f12,[%l6+0xB0] ;\
-       std     %f14,[%l6+0xB8] ;\
-       std     %f16,[%l6+0xC0] ;\
-       std     %f18,[%l6+0xC8] ;\
-       std     %f20,[%l6+0xD0] ;\
-       std     %f22,[%l6+0xD8] ;\
-       std     %f24,[%l6+0xE0] ;\
-       std     %f26,[%l6+0xE8] ;\
-       std     %f28,[%l6+0xF0] ;\
-       std     %f30,[%l6+0xF8]
-
-#define RESTORE_FP_REGS                 \
-       ldd     [%l6+0x80],%f0  ;\
-       ldd     [%l6+0x88],%f2  ;\
-       ldd     [%l6+0x90],%f4  ;\
-       ldd     [%l6+0x98],%f6  ;\
-       ldd     [%l6+0xA0],%f8  ;\
-       ldd     [%l6+0xA8],%f10 ;\
-       ldd     [%l6+0xB0],%f12 ;\
-       ldd     [%l6+0xB8],%f14 ;\
-       ldd     [%l6+0xC0],%f16 ;\
-       ldd     [%l6+0xC8],%f18 ;\
-       ldd     [%l6+0xD0],%f20 ;\
-       ldd     [%l6+0xD8],%f22 ;\
-       ldd     [%l6+0xE0],%f24 ;\
-       ldd     [%l6+0xE8],%f26 ;\
-       ldd     [%l6+0xF0],%f28 ;\
-       ldd     [%l6+0xF8],%f30
-
-// under odd circumstances, emulate it
-#define WEIRDD(reg)             \
-       std     reg,[%l6+112]   ;\
-       WEIRDD_ADDR(%l6+112)
-
-#define WEIRDD_ADDR(addr)       \
-       ld      [addr],%l1      ;\
-       sll     %l1,1,%l1       ;\
-       srl     %l1,21,%l1      ;\
-       cmp     %l1,0x7FF       ;\
-       be      giveup          ;\
-       tst     %l1             ;\
-       be      giveup
-
-#define WEIRD_ADDR(addr)        \
-       ld      [addr],%l1      ;\
-       sll     %l1,1,%l1       ;\
-       srl     %l1,24,%l1      ;\
-       cmp     %l1,0xFF        ;\
-       be      giveup          ;\
-       tst     %l1             ;\
-       be      giveup
-
-.global fast_fp_exception
-fast_fp_exception:
-
-       // get the instruction (no fault mode)
-       lda     [%g0] 4, %l3
-       or      %l3,2,%l0
-       sta     %l0, [%g0] 4
-       ld      [%l1], %l0
-       sta     %l3, [%g0] 4
-
-       set     bootstacktop-256,%l6
-       mov     CORE_ID_REG,%l7
-       sll     %l7,KSTKSHIFT,%l7
-       sub     %l6,%l7,%l6
-
-       mov     %psr,%l3
-       st      %l1,[%l6+64]
-       st      %l2,[%l6+68]
-       st      %l3,[%l6+72]
-       st      %fsr,[%l6+76]
-
-       // decode the instruction
-       set     0x81F83FE0, %l3         ! opcode mask
-       and     %l3,%l0,%l3             !
-       set     0x81A009A0, %l4         ! fdivs?
-       set     0x81A009C0, %l5         ! fdivd?
-       set     0x81A00520, %l1         ! fsqrts?
-       set     0x81A00540, %l7         ! fsqrtd?
-       cmp     %l3,%l4
-       be      do_fdivs
-       cmp     %l3,%l5
-       be      do_fdivd
-       cmp     %l3,%l1
-       be      do_fsqrts
-       cmp     %l3,%l7
-       be      do_fsqrtd
-
-       b,a     getout
-       // nothing we can handle fast; call fp_exception
-giveup:
-       RESTORE_FP_REGS
-getout:
-       RESTORE_STATE
-       TRAP_TABLE_ENTRY(fp_exception)
-
-do_fdivs:
-       SAVE_FP_REGS
-       st      %g0,[%l6+124]
-       ld      [%l6+124],%fsr
-       GET_RS2(%f0)
-       fstod   %f0,%f0
-       sethi   %hi(recip_asm),%l1
-       jmpl    %l1+%lo(recip_asm),%l7
-        nop
-       GET_RS1(%f2)
-       fstod   %f2,%f2
-       fmuld   %f2,%f0,%f0
-       WEIRDD(%f0)
-       fdtos   %f0,%f0
-       SET_RD(%f0)
-       RESTORE_FP_REGS
-       RESTORE_STATE
-       jmp     %l2
-        rett   %l2+4
-
-do_fdivd:
-       SAVE_FP_REGS
-       st      %g0,[%l6+124]
-       ld      [%l6+124],%fsr
-       GET_RS2D(%f0)
-       sethi   %hi(recip_asm),%l1
-       jmpl    %l1+%lo(recip_asm),%l7
-        nop
-       GET_RS1D(%f2)
-       fmuld   %f2,%f0,%f0
-       WEIRDD(%f0)
-       SET_RDD(%f0)
-       RESTORE_FP_REGS
-       RESTORE_STATE
-       jmp     %l2
-        rett   %l2+4
-
-do_fsqrts:
-       SAVE_FP_REGS
-       st      %g0,[%l6+124]
-       ld      [%l6+124],%fsr
-       GET_RS2(%f0)
-       fstod   %f0,%f0
-       sethi   %hi(recip_sqrt_asm),%l1
-       jmpl    %l1+%lo(recip_sqrt_asm),%l7
-        nop
-       GET_RS2(%f2)
-       fstod   %f2,%f2
-       fmuld   %f2,%f0,%f0
-       WEIRDD(%f0)
-       fdtos   %f0,%f0
-       SET_RD(%f0)
-       RESTORE_FP_REGS
-       RESTORE_STATE
-       jmp     %l2
-        rett   %l2+4
-
-do_fsqrtd:
-       SAVE_FP_REGS
-       st      %g0,[%l6+124]
-       ld      [%l6+124],%fsr
-       GET_RS2D(%f0)
-       sethi   %hi(recip_sqrt_asm),%l1
-       jmpl    %l1+%lo(recip_sqrt_asm),%l7
-        nop
-       GET_RS2D(%f2)
-       fmuld   %f2,%f0,%f0
-       WEIRDD(%f0)
-       SET_RDD(%f0)
-       RESTORE_FP_REGS
-       RESTORE_STATE
-       jmp     %l2
-        rett   %l2+4
-
-
-.align 8
-divlut:
-.double 1.0,0.8,0.666666,0.571428
-
-sqrtlut:
-.double 1.414214,1.264911,1.154701,1.069045
-.double 1.0,0.894427,0.816497,0.755929
-
-zero:  .double 0.0
-nzero: .double -0.0
-half:  .double 0.5
-two:   .double 2.0
-three: .double 3.0
-nan:    .double nan
-infty: .double inf
-ninfty:        .double -inf
-
-recip_asm:
-       std     %f0,[%l6+120]   ! stow input
-       ld      [%l6+120],%l3   ! l3 = MSW
-       srl     %l3,20,%l4      ! l4 = {sign,exp}
-       andn    %l4,0x800,%l5   ! l5 = exp
-!      tst     %l5             ! denorm?
-!      be      recip_asm_denorm!
-!      cmp     %l5,0x7FF       ! inf?
-!      be      recip_asm_inf   !
-       sub     %l5,2046,%l5    !
-       neg     %l5             ! l5 = -exp
-       and     %l4,0x800,%l2   ! l2 = sign
-       or      %l5,%l2,%l4     ! l4 = {sign,-exp}
-       sll     %l4,20,%l4      ! l4 = MSW
-       st      %l4,[%l6+112]   ! 
-       st      %g0,[%l6+116]   ! sp+112 = the exponent of the approx
-       srl     %l3,15,%l3      !
-       and     %l3,0x18,%l3    ! l3 = offset into LUT
-       set     divlut,%l4      !
-       ldd     [%l3+%l4],%f0   ! f0 = mantissa of approx
-       ldd     [%l6+112],%f2   ! f2 = exponent of approx
-       fmuld   %f0,%f2,%f0     ! f0 = approx
-       ldd     [%l6+120],%f2   ! f2 = b
-       sethi   %hi(two),%l3    ! f4 = two
-       ldd     [%l3+%lo(two)],%f4
-
-       fmuld   %f0,%f2,%f6     ! f6 = x*b
-       fsubd   %f4,%f6,%f6     ! f6 = 2-x*b
-       fmuld   %f0,%f6,%f0     ! f0 = x*(2-x*b)        
-
-       fmuld   %f0,%f2,%f6     ! f6 = x*b
-       fsubd   %f4,%f6,%f6     ! f6 = 2-x*b
-       fmuld   %f0,%f6,%f0     ! f0 = x*(2-x*b)        
-
-       fmuld   %f0,%f2,%f6     ! f6 = x*b
-       fsubd   %f4,%f6,%f6     ! f6 = 2-x*b
-       fmuld   %f0,%f6,%f0     ! f0 = x*(2-x*b)        
-
-       fmuld   %f0,%f2,%f6     ! f6 = x*b
-       fsubd   %f4,%f6,%f6     ! f6 = 2-x*b
-       fmuld   %f0,%f6,%f0     ! f0 = x*(2-x*b)        
-
-       fmuld   %f0,%f2,%f6     ! f6 = x*b
-       fsubd   %f4,%f6,%f6     ! f6 = 2-x*b
-       fmuld   %f0,%f6,%f0     ! f0 = x*(2-x*b)        
-
-       fmuld   %f0,%f2,%f6     ! f6 = x*b
-       fsubd   %f4,%f6,%f6     ! f6 = 2-x*b
-       fmuld   %f0,%f6,%f0     ! f0 = x*(2-x*b)        
-recip_asm_out:
-       jmp     %l7+8
-        nop
-
-recip_asm_inf:
-       b       giveup
-       cmp     %l3,-1          ! nan?
-       sethi   %hi(nan),%l2
-       be      recip_asm_out   ! if so, result = nan
-        ldd    [%l2+%lo(nan)],%f0
-       cmp     %l4,0x000       ! positive inf?
-       sethi   %hi(zero),%l2   !
-       be      recip_asm_out   ! if so, result = zero
-        ldd    [%l2+%lo(zero)],%f0
-       sethi   %hi(nzero),%l2  ! else, result = -zero
-       ldd     [%l2+%lo(nzero)],%f0
-       b,a     recip_asm_out
-
-recip_asm_denorm:
-       b       giveup
-       cmp     %l4,0x000       ! positive denorm?
-       sethi   %hi(infty),%l2  !
-       be      recip_asm_out   ! if so, result = inf
-        ldd    [%l2+%lo(infty)],%f0
-       sethi   %hi(ninfty),%l2 ! else, result = -inf
-       ldd     [%l2+%lo(ninfty)],%f0
-       b,a     recip_asm_out
-       
-recip_sqrt_asm:
-       std     %f0,[%l6+120]   ! stow input
-       ld      [%l6+120],%l3   ! l3 = MSW
-       srl     %l3,20,%l4      ! l4 = {sign,exp}
-       andn    %l4,0x800,%l5   ! l5 = exp
-!      tst     %l5             ! denorm?
-!      be      recip_sqrt_asm_denorm
-!      cmp     %l5,0x7FF       ! inf?
-!      be      recip_sqrt_asm_inf      !
-       btst    0x800,%l4       ! negative?
-       sethi   %hi(nan),%l2    !
-       bne     recip_sqrt_asm_out      ! if so, result = NaN
-        ldd    [%l2+%lo(nan)],%f0
-       sub     %l5,3069,%l5    !
-       neg     %l5             ! l5 = -exp
-       srl     %l5,1,%l5       ! l5 = -exp/2
-       sll     %l5,20,%l4      ! l4 = MSW (sign guaranteed to be 0)
-       st      %l4,[%l6+112]   ! 
-       st      %g0,[%l6+116]   ! sp+112 = the exponent of the approx
-       srl     %l3,15,%l3      !
-       and     %l3,0x38,%l3    ! l3 = offset into LUT
-       set     sqrtlut,%l4     !
-       ldd     [%l3+%l4],%f0   ! f0 = mantissa of approx
-       ldd     [%l6+112],%f2   ! f2 = exponent of approx
-       fmuld   %f0,%f2,%f0     ! f0 = approx
-       ldd     [%l6+120],%f2   ! f2 = b
-       sethi   %hi(three),%l3  ! f4 = three
-       ldd     [%l3+%lo(three)],%f4
-       sethi   %hi(half),%l3   ! f8 = half
-       ldd     [%l3+%lo(half)],%f8
-
-       fmuld   %f0,%f2,%f6     ! f6 = x*b
-       fmuld   %f0,%f6,%f6     ! f6 = x*x*b
-       fsubd   %f4,%f6,%f6     ! f6 = 3-x*x*b
-       fmuld   %f0,%f6,%f0     ! f0 = x*(3-x*x*b)
-       fmuld   %f0,%f8,%f0     ! f0 = 0.5*x*(3-x*x*b)
-
-       fmuld   %f0,%f2,%f6     ! f6 = x*b
-       fmuld   %f0,%f6,%f6     ! f6 = x*x*b
-       fsubd   %f4,%f6,%f6     ! f6 = 3-x*x*b
-       fmuld   %f0,%f6,%f0     ! f0 = x*(3-x*x*b)
-       fmuld   %f0,%f8,%f0     ! f0 = 0.5*x*(3-x*x*b)
-
-       fmuld   %f0,%f2,%f6     ! f6 = x*b
-       fmuld   %f0,%f6,%f6     ! f6 = x*x*b
-       fsubd   %f4,%f6,%f6     ! f6 = 3-x*x*b
-       fmuld   %f0,%f6,%f0     ! f0 = x*(3-x*x*b)
-       fmuld   %f0,%f8,%f0     ! f0 = 0.5*x*(3-x*x*b)
-
-       fmuld   %f0,%f2,%f6     ! f6 = x*b
-       fmuld   %f0,%f6,%f6     ! f6 = x*x*b
-       fsubd   %f4,%f6,%f6     ! f6 = 3-x*x*b
-       fmuld   %f0,%f6,%f0     ! f0 = x*(3-x*x*b)
-       fmuld   %f0,%f8,%f0     ! f0 = 0.5*x*(3-x*x*b)
-
-       fmuld   %f0,%f2,%f6     ! f6 = x*b
-       fmuld   %f0,%f6,%f6     ! f6 = x*x*b
-       fsubd   %f4,%f6,%f6     ! f6 = 3-x*x*b
-       fmuld   %f0,%f6,%f0     ! f0 = x*(3-x*x*b)
-       fmuld   %f0,%f8,%f0     ! f0 = 0.5*x*(3-x*x*b)
-
-       fmuld   %f0,%f2,%f6     ! f6 = x*b
-       fmuld   %f0,%f6,%f6     ! f6 = x*x*b
-       fsubd   %f4,%f6,%f6     ! f6 = 3-x*x*b
-       fmuld   %f0,%f6,%f0     ! f0 = x*(3-x*x*b)
-       fmuld   %f0,%f8,%f0     ! f0 = 0.5*x*(3-x*x*b)
-recip_sqrt_asm_out:
-       jmp     %l7+8
-        nop
-
-recip_sqrt_asm_inf:
-       b       giveup
-       cmp     %l3,-1          ! nan?
-       sethi   %hi(nan),%l2
-       be      recip_asm_out   ! if so, result = nan
-        ldd    [%l2+%lo(nan)],%f0
-       cmp     %l4,0x000       ! positive inf?
-       sethi   %hi(zero),%l2   !
-       be      recip_sqrt_asm_out      ! if so, result = zero
-        ldd    [%l2+%lo(zero)],%f0
-       sethi   %hi(nan),%l2    ! else, result = nan
-       ldd     [%l2+%lo(nan)],%f0
-       b,a     recip_sqrt_asm_out
-
-recip_sqrt_asm_denorm:
-       b       giveup
-       cmp     %l4,0x000       ! positive denorm?
-       sethi   %hi(infty),%l2  !
-       be      recip_sqrt_asm_out      ! if so, result = inf
-        ldd    [%l2+%lo(infty)],%f0
-       sethi   %hi(nan),%l2    ! else, result = nan
-       ldd     [%l2+%lo(nan)],%f0
-       b,a     recip_sqrt_asm_out
-       
-/*
-
-// d2i and i2d are just wrappers to get/set the bits of a float
-
-double recip(double b)
-{
-  uint64_t i = d2i(b);
-  uint64_t i2 = ((2046-((i>>52)&~0x800)) | (i>>52)&0x800) << 52;
-  uint64_t i3 = (i >> 50) & 3;
-  static const double divlut[4] = {1.0,0.8,0.666,0.571};
-  double x = i2d(i2)*divlut[i3];
-
-  x = x*(2.0-b*x);
-  x = x*(2.0-b*x);
-  x = x*(2.0-b*x);
-  x = x*(2.0-b*x);
-  x = x*(2.0-b*x);
-
-  return x;
-}
-
-double recip_sqrt(double b)
-{
-  uint64_t i = d2i(b);
-  uint64_t i2 = ((3069-((i>>52)&~0x800))>>1 | (i>>52)&0x800) << 52;
-  uint64_t i3 = (i >> 50) & 7;
-  double x = i2d(i2);
-
-  static const double sqrtlut[8] = {1.4142,1.264,1.155,1.069, 1.0,0.894,0.816,0.756};
-  x *= sqrtlut[i3];
-
-  x = 0.5*x*(3.0-b*x*x);
-  x = 0.5*x*(3.0-b*x*x);
-  x = 0.5*x*(3.0-b*x*x);
-  x = 0.5*x*(3.0-b*x*x);
-  x = 0.5*x*(3.0-b*x*x);
-
-  return x;
-}
-*/
diff --git a/kern/arch/sparc/ros/arch.h b/kern/arch/sparc/ros/arch.h
deleted file mode 100644 (file)
index 6c32ea5..0000000
+++ /dev/null
@@ -1,6 +0,0 @@
-#ifndef _ROS_ARCH_ARCH_H
-#define _ROS_ARCH_ARCH_H
-
-#define MAX_NUM_CPUS                           64
-
-#endif
diff --git a/kern/arch/sparc/ros/membar.h b/kern/arch/sparc/ros/membar.h
deleted file mode 100644 (file)
index 1850b58..0000000
+++ /dev/null
@@ -1,23 +0,0 @@
-#ifndef ROS_INC_ARCH_MEMBAR_H
-#define ROS_INC_ARCH_MEMBAR_H
-
-/* Full CPU memory barrier */
-#define mb() {rmb(); wmb();}
-/* Compiler memory barrier (optimization barrier) */
-#define cmb() ({ asm volatile("" ::: "memory"); })
-/* Partial CPU memory barriers */
-#define rmb() cmb()
-#define wmb() ({ __asm__ __volatile__ ("stbar" ::: "memory"); })
-#define wrmb() mb()
-#define rwmb() mb()
-
-/* Forced barriers, used for string ops, SSE ops, dealing with hardware, or
- * other places where you avoid 'normal' x86 read/writes (like having an IPI
- * beat a write) */
-#define mb_f() mb()
-#define rmb_f() rmb()
-#define wmb_f() wmb()
-#define wrmb_f() wrmb()
-#define rwmb_f() rwmb()
-
-#endif /* ROS_INC_ARCH_MEMBAR_H */
diff --git a/kern/arch/sparc/ros/mmu.h b/kern/arch/sparc/ros/mmu.h
deleted file mode 100644 (file)
index 0c5eb2b..0000000
+++ /dev/null
@@ -1,157 +0,0 @@
-/* Contains macros and constants for the kernel VM mapping, page tables,
- * definitions for the SRMMU, etc. */
-
-#ifndef ROS_INC_ARCH_MMU_H
-#define ROS_INC_ARCH_MMU_H
-
-/* **************************************** */
-/* Kernel Virtual Memory Mapping  (not really an MMU thing) */
-
-// All physical memory mapped at this address
-#define KERNBASE        0x80000000
-#define KERN_LOAD_ADDR  KERNBASE
-#define ULIM            0x70000000
-
-/* All arches must define this, which is the lower limit of their static
- * mappings, and where the dynamic mappings will start. */
-#define KERN_DYN_TOP    KERNBASE
-
-// Use this if needed in annotations
-#define IVY_KERNBASE (0x8000U << 16)
-
-#define L3PGSHIFT   12
-#define L3PGSIZE    (1<<L3PGSHIFT)
-
-#define L2PGSHIFT   (12+6)
-#define L2PGSIZE    (1<<L2PGSHIFT)
-
-#define L1PGSHIFT   (12+6+6)
-#define L1PGSIZE    (1<<L1PGSHIFT)
-
-#define PGSHIFT L3PGSHIFT
-#define PGSIZE (1 << PGSHIFT)
-#define PTSIZE L1PGSIZE
-
-#define NOVPT
-
-#ifndef __ASSEMBLER__
-typedef unsigned long pte_t;
-typedef unsigned long pde_t;
-#endif
-
-/* **************************************** */
-/* Page table constants, macros, etc */
-
-// A linear address 'la' has a four-part structure as follows:
-//
-// +--------8--------+------6------+------6------+-----------12----------+
-// |  L1 Page Table  |    L2 PT    |    L3 PT    |  Offset within Page   |
-// |      Index      |    Index    |    Index    |                       |
-// +-----------------+-------------+-------------+-----------------------+
-//  \--- L1X(la) --/  \- L2X(la) -/ \- L3X(la) -/ \----- PGOFF(la) -----/
-//  \----------- PPN(la) -----------------------/
-//
-// The L1X, L2X, L3X, PGOFF, and PPN macros decompose linear addresses
-// as shown.  To construct a linear address la from L1X(la), L2X(la),
-// and PGOFF(la), use PGADDR(L1X(la), L2X(la), L3X(la), PGOFF(la)).
-
-// page number field of address
-#define LA2PPN(la)     (((uintptr_t) (la)) >> L3PGSHIFT)
-
-// page number field of PPN
-#define PTE2PPN(pte)   (((uintptr_t) (pte)) >> 8)
-
-// index into L1 PT
-#define L1X(la)                ((((uintptr_t) (la)) >> L1PGSHIFT) & 0xFF)
-
-// index into L2 PT
-#define L2X(la)                ((((uintptr_t) (la)) >> L2PGSHIFT) & 0x3F)
-
-// index into L3 PT
-#define L3X(la)                ((((uintptr_t) (la)) >> L3PGSHIFT) & 0x3F)
-
-// offset in page
-#define PGOFF(la)      (((uintptr_t) (la)) & 0xFFF)
-
-// construct linear address from indexes and offset
-#define PGADDR(l1, l2, l3, o) ((void*SNT) ((l1) << L1PGSHIFT | (l2) << L2PGSHIFT | (l3) << L3PGSHIFT | (o)))
-
-// construct PTE from PPN and flags
-#define PTE(ppn, flags) ((ppn) << 8 | (flags))
-
-// construct PTD from physical address
-#define PTD(pa) ((pa) >> 4 | PTE_PTD)
-
-// Number of L1 page tables (contexts) the MMU can store at any time
-#define NCONTEXTS      8
-#define CONTEXT_TABLE_PAD 8 // we require NCONTEXTS+CONTEXT_TBALE_PAD % 16 == 0
-
-// Page directory and page table constants.
-#define NL3ENTRIES     64              // # entries in an L3 page table
-#define NL2ENTRIES     64              // # entries in an L2 page table
-#define NL1ENTRIES     256             // # entries in an L1 page table
-
-// Page table/directory entry flags.
-#define PTE_PTD                0x001   // Entry is a Page Table Descriptor
-#define PTE_PTE                0x002   // Entry is a Page Table Entry
-#define PTE_ACC                0x01C   // Access modes (aka permissions, see below)
-#define PTE_R          0x020   // Referenced
-#define PTE_M          0x040   // Modified
-#define PTE_C          0x080   // Cacheable
-
-// commly used access modes
-#define PTE_KERN_RW    (7 << 2)                // Kernel Read/Write
-#define PTE_KERN_RO    (6 << 2)                // Kernel Read-Only
-#define PTE_USER_RW    (3 << 2)                // Kernel/User Read/Write
-#define PTE_USER_RO    (2 << 2)                // Kernel/User Read-Only
-
-// x86 equivalencies
-#define PTE_P          PTE_PTE                 // present <=> PTE
-#define PTE_PERM       PTE_ACC                 // perms <=> ACC
-#define NPDENTRIES     NL1ENTRIES              // to calculate size of pgdir
-#define PDX(la)                L1X(la)                 // for env stuff
-
-// +-----+-------------------+
-// |     |   Allowed Access  |
-// | ACC +------+------------+
-// |     | User | Supervisor |
-// +-----+------+------------+
-// |  0  |  R-- |  R--       |
-// |  1  |  RW- |  RW-       |
-// |  2  |  R-X |  R-X       |
-// |  3  |  RWX |  RWX       |
-// |  4  |  --X |  --X       |
-// |  5  |  R-- |  RW-       |
-// |  6  |  --- |  R-X       |
-// |  7  |  --- |  RWX       |
-// +-----+------+------------+
-
-// address in page table entry
-#define PTE_ADDR(pte)  (((physaddr_t) (pte) & ~0xFF) << 4)
-
-// address in page table descriptor
-#define PTD_ADDR(ptd)  (((physaddr_t) (ptd) & ~0x3) << 4)
-
-// MMU Control Register flags
-#define MMU_CR_E       0x00000001      // Protection Enable
-#define MMU_CR_NF      0x00000002      // No Fault mode
-#define MMU_CR_PSO     0x00000080      // Partial Store Order (TSO disabled)
-
-// MMU Fault Status Register flags
-#define MMU_FSR_USER   0x00000020      // Fault caused by user-space access
-#define MMU_FSR_EX     0x00000040      // Fault occured in instruction-space
-#define MMU_FSR_WR     0x00000080      // Fault caused by a store
-
-// MMU Register Addresses
-#define MMU_REG_CTRL   0x00000000      // MMU Control Register
-#define MMU_REG_CTXTBL 0x00000100      // MMU Context Table Pointer Register
-#define MMU_REG_CTX    0x00000200      // MMU Context Register
-#define MMU_REG_FSR    0x00000300      // MMU Fault Status Register
-#define MMU_REG_FAR    0x00000400      // MMU Fault Address Register
-
-// we must guarantee that for any PTE, exactly one of the following is true
-#define PAGE_PRESENT(pte) ((pte) & PTE_P)
-#define PAGE_UNMAPPED(pte) ((pte) == 0)
-#define PAGE_PAGED_OUT(pte) (!PAGE_PRESENT(pte) && !PAGE_UNMAPPED(pte))
-
-#endif /* ROS_INC_ARCH_MMU_H */
diff --git a/kern/arch/sparc/ros/syscall.h b/kern/arch/sparc/ros/syscall.h
deleted file mode 100644 (file)
index 9644df9..0000000
+++ /dev/null
@@ -1,21 +0,0 @@
-#ifndef _ROS_ARCH_SYSCALL_H
-#define _ROS_ARCH_SYSCALL_H
-
-#ifndef ROS_KERNEL
-
-#include <errno.h>
-
-static inline long __attribute__((always_inline))
-__ros_arch_syscall(long _a0, long _a1)
-{
-       register long a0 asm("g1") = _a0;
-       register long a1 asm("o0") = _a1;
-
-       asm volatile("ta 8" : "=r"(a0) : "0"(a0),"r"(a1) : "memory");
-
-       return a0;
-}
-
-#endif /* ifndef ROS_KERNEL */
-
-#endif
diff --git a/kern/arch/sparc/ros/trapframe.h b/kern/arch/sparc/ros/trapframe.h
deleted file mode 100644 (file)
index de6cb0b..0000000
+++ /dev/null
@@ -1,35 +0,0 @@
-#ifndef ROS_INC_ARCH_TRAPFRAME_H
-#define ROS_INC_ARCH_TRAPFRAME_H
-
-#ifndef ROS_INC_TRAPFRAME_H
-#error "Do not include include ros/arch/trapframe.h directly"
-#endif
-
-#include <ros/common.h>
-#include <stdint.h>
-
-struct hw_trapframe
-{
-       uint32_t gpr[32] __attribute__((aligned (8)));
-       uint32_t psr;
-       uint32_t pc;
-       uint32_t npc;
-       uint32_t wim;
-       uint32_t tbr;
-       uint32_t y;
-       uint32_t fault_status;
-       uint32_t fault_addr;
-       uint64_t timestamp;
-};
-
-struct sw_trapframe {
-       /* TODO */
-};
-
-typedef struct ancillary_state
-{
-       uint32_t fpr[32] __attribute__((aligned (8)));
-       uint32_t fsr;
-} ancillary_state_t;
-
-#endif /* ROS_INC_ARCH_TRAPFRAME_H */
diff --git a/kern/arch/sparc/smp.c b/kern/arch/sparc/smp.c
deleted file mode 100644 (file)
index 1503125..0000000
+++ /dev/null
@@ -1,157 +0,0 @@
-#include <smp.h>
-#include <arch/arch.h>
-#include <arch/smp.h>
-#include <stdio.h>
-#include <string.h>
-#include <error.h>
-#include <assert.h>
-#include <atomic.h>
-
-#ifdef __SHARC__
-#pragma nosharc
-#endif
-
-#ifdef __DEPUTY__
-#pragma nodeputy
-#endif
-
-void
-smp_boot(void)
-{
-       extern int time_for_smp_init;
-       num_cpus = 1;
-       printd("Cores, report in!\n");
-       time_for_smp_init = 1;
-
-       smp_percpu_init();
-
-       while(*(volatile uint32_t*)&num_cpus < num_cores());
-
-       printd("%d cores reporting!\n",num_cpus);
-}
-
-void
-smp_init(void)
-{
-       static spinlock_t report_in_lock = SPINLOCK_INITIALIZER;
-
-       smp_percpu_init();
-       spin_lock(&report_in_lock);
-       num_cpus++;
-       spin_unlock(&report_in_lock);
-
-       printd("Good morning, Vietnam! (core id = %d)\n",core_id());
-
-       smp_idle();
-}
-
-handler_wrapper_t
-wrapper_pool[MAX_NUM_CPUS*8] = {{{0},SPINLOCK_INITIALIZER}};
-
-handler_wrapper_t*
-smp_make_wrapper()
-{
-       int i;
-       for(i = 0; i < sizeof(wrapper_pool)/sizeof(wrapper_pool[0]); i++)
-               if(spin_trylock(&wrapper_pool[i].lock) == 0)
-                       return &wrapper_pool[i];
-       return NULL;
-}
-
-void smp_call_wrapper(uint32_t src, isr_t handler, handler_wrapper_t *wrapper,
-                      void *data)
-{
-       if(wrapper)
-               wrapper->wait_list[core_id()] = 0;
-       handler(0, data);
-}
-
-int smp_call_function_self(isr_t handler, void* data,
-                           handler_wrapper_t** wait_wrapper)
-{
-       return smp_call_function_single(core_id(),handler,data,wait_wrapper);
-}
-
-int smp_call_function_all(isr_t handler, void* data,
-                          handler_wrapper_t** wait_wrapper)
-{
-       int8_t state = 0;
-       int i;
-       handler_wrapper_t* wrapper = 0;
-       if(wait_wrapper)
-       {
-               wrapper = *wait_wrapper = smp_make_wrapper();
-               if(!wrapper)
-                       return -ENOMEM;
-
-               for(i = 0; i < num_cores(); i++)
-                       wrapper->wait_list[i] = 1;
-       }
-
-       enable_irqsave(&state);
-
-       // send to others
-       for(i = 0; i < num_cores(); i++)
-       {
-               if(i == core_id())
-                       continue;
-
-               send_kernel_message(i, (amr_t)smp_call_wrapper,
-                                         (long)handler, (long)wrapper, 
-                                         (long)data, KMSG_IMMEDIATE);
-       }
-
-       // send to me
-       send_kernel_message(core_id(), (amr_t)smp_call_wrapper,
-                                 (long)handler, (long)wrapper,
-                                 (long)data, KMSG_IMMEDIATE);
-
-       cpu_relax(); // wait to get the interrupt
-
-       disable_irqsave(&state);
-
-       return 0;
-}
-
-int smp_call_function_single(uint32_t dest, isr_t handler, void* data,
-                             handler_wrapper_t** wait_wrapper)
-{
-       int8_t state = 0;
-       handler_wrapper_t* wrapper = 0;
-       if(wait_wrapper)
-       {
-               wrapper = *wait_wrapper = smp_make_wrapper();
-               if(!wrapper)
-                       return -ENOMEM;
-               wrapper->wait_list[dest] = 1;
-       }
-
-       enable_irqsave(&state);
-
-       send_kernel_message(dest, (amr_t)smp_call_wrapper,
-                                 (long)handler, (long)wrapper,
-                                 (long)data, KMSG_IMMEDIATE);
-
-       cpu_relax(); // wait to get the interrupt, if it's to this core
-
-       disable_irqsave(&state);
-
-       return 0;
-}
-
-int smp_call_wait(handler_wrapper_t* wrapper)
-{
-       int i;
-       for(i = 0; i < num_cores(); i++)
-               while(wrapper->wait_list[i]);
-
-       spin_unlock(&wrapper->lock);
-       return 0;
-}
-
-/* Perform any initialization needed by per_cpu_info.  Right now, this just
- * inits the amsg list (which sparc will probably also want).  Make sure every
- * core calls this at some point in the smp_boot process. */
-void __arch_pcpu_init(uint32_t coreid)
-{
-}
diff --git a/kern/arch/sparc/smp.h b/kern/arch/sparc/smp.h
deleted file mode 100644 (file)
index b71f0de..0000000
+++ /dev/null
@@ -1,16 +0,0 @@
-#ifndef ROS_ARCH_SMP_H
-#define ROS_ARCH_SMP_H
-
-#include <ros/common.h>
-#include <arch/arch.h>
-#include <atomic.h>
-
-typedef volatile uint8_t wait_list_t[MAX_NUM_CPUS];
-
-typedef struct
-{
-       wait_list_t wait_list;
-       spinlock_t lock;
-} handler_wrapper_t;
-
-#endif /* !ROS_ARCH_SMP_H */
diff --git a/kern/arch/sparc/softfloat-macros.h b/kern/arch/sparc/softfloat-macros.h
deleted file mode 100644 (file)
index a707c8d..0000000
+++ /dev/null
@@ -1,720 +0,0 @@
-\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
deleted file mode 100644 (file)
index 25673ee..0000000
+++ /dev/null
@@ -1,402 +0,0 @@
-
-/*============================================================================
-
-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
deleted file mode 100644 (file)
index 3ee7574..0000000
+++ /dev/null
@@ -1,5189 +0,0 @@
-\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 propaga