Merge softfloat_riscv into softfloat

They really aren't independent libraries.

diff --git a/configure b/configure
index 77eef2fb4e00343a3f88c2ae3cab7d2e9271cae7..7da38cf7a1cabfa7f8243524571aa29fbd8ca6d3 100755 (executable)
--- a/configure
+++ b/configure
@@ -4358,51 +4358,6 @@ $as_echo "#define SOFTFLOAT_ENABLED /**/" >>confdefs.h
 
 
 
-    # Determine if this is a required or an optional subproject
-
-
-
-    # Determine if there is a group with the same name
-
-
-
-    # Create variations of the subproject name suitable for use as a CPP
-    # enabled define, a shell enabled variable, and a shell function
-
-
-
-
-
-
-
-
-
-
-
-    # Add subproject to our running list
-
-    subprojects="$subprojects softfloat_riscv"
-
-    # Process the subproject appropriately. If enabled add it to the
-    # $enabled_subprojects running shell variable, set a
-    # SUBPROJECT_ENABLED C define, and include the appropriate
-    # 'subproject.ac'.
-
-
-      { $as_echo "$as_me:${as_lineno-$LINENO}: configuring default subproject : softfloat_riscv" >&5
-$as_echo "$as_me: configuring default subproject : softfloat_riscv" >&6;}
-      ac_config_files="$ac_config_files softfloat_riscv.mk:softfloat_riscv/softfloat_riscv.mk.in"
-
-      enable_softfloat_riscv_sproj="yes"
-      subprojects_enabled="$subprojects_enabled softfloat_riscv"
-
-$as_echo "#define SOFTFLOAT_RISCV_ENABLED /**/" >>confdefs.h
-
-
-
-
-
-
   # Output make variables
 
 
@@ -5134,7 +5089,6 @@ do
     "riscv.mk") CONFIG_FILES="$CONFIG_FILES riscv.mk:riscv/riscv.mk.in" ;;
     "hwacha.mk") CONFIG_FILES="$CONFIG_FILES hwacha.mk:hwacha/hwacha.mk.in" ;;
     "softfloat.mk") CONFIG_FILES="$CONFIG_FILES softfloat.mk:softfloat/softfloat.mk.in" ;;
-    "softfloat_riscv.mk") CONFIG_FILES="$CONFIG_FILES softfloat_riscv.mk:softfloat_riscv/softfloat_riscv.mk.in" ;;
     "config.h") CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;;
     "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
 

diff --git a/configure.ac b/configure.ac
index d683cc51dbaf9367a95b6d74532959a0372f4e39..bf358079038700e16cf6f687055b54592bd12304 100644 (file)
--- a/configure.ac
+++ b/configure.ac
@@ -82,7 +82,7 @@ AC_SUBST([CXXFLAGS],["-Wall -O2 -std=c++11"])
 # The '*' suffix indicates an optional subproject. The '**' suffix
 # indicates an optional subproject which is also the name of a group.
 
-MCPPBS_SUBPROJECTS([ riscv, hwacha, softfloat, softfloat_riscv ])
+MCPPBS_SUBPROJECTS([ riscv, hwacha, softfloat ])
 
 #-------------------------------------------------------------------------
 # MCPPBS subproject groups

diff --git a/riscv/riscv.mk.in b/riscv/riscv.mk.in
index 45c5ee7acc73c5ae8732890a2caae9ce9bee200e..92adb8f71c0894e0b7bf18249e82d472867741c0 100644 (file)
--- a/riscv/riscv.mk.in
+++ b/riscv/riscv.mk.in
@@ -2,7 +2,6 @@ get_insn_list = $(shell grep ^DECLARE_INSN $(1) | sed 's/DECLARE_INSN(\(.*\),.*,
 get_opcode = $(shell grep ^DECLARE_INSN.*\\\<$(2)\\\> $(1) | sed 's/DECLARE_INSN(.*,\(.*\),.*)/\1/')
 
 riscv_subproject_deps = \
-       softfloat_riscv \
        softfloat \
        hwacha \
 

diff --git a/softfloat/platform.h b/softfloat/platform.h
new file mode 100755 (executable)
index 0000000..6c54313
--- /dev/null
+++ b/softfloat/platform.h
@@ -0,0 +1,42 @@
+
+/*============================================================================
+
+*** FIX.
+
+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.
+
+=============================================================================*/
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#define LITTLEENDIAN
+
+#ifndef UINT64_C
+# define UINT64_C(x) (x ## ULL)
+# define INT64_C(x) (x ## LL)
+#endif

diff --git a/softfloat/s_commonNaNToF32UI.c b/softfloat/s_commonNaNToF32UI.c
new file mode 100755 (executable)
index 0000000..61f2735
--- /dev/null
+++ b/softfloat/s_commonNaNToF32UI.c
@@ -0,0 +1,17 @@
+\r
+#include <stdint.h>\r
+#include "platform.h"\r
+#include "specialize.h"\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the canonical NaN `a' to the single-\r
+| precision floating-point format.\r
+*----------------------------------------------------------------------------*/\r
+\r
+uint_fast32_t softfloat_commonNaNToF32UI( struct commonNaN a )\r
+{\r
+\r
+    return (uint_fast32_t) a.sign<<31 | 0x7FFFFFFF;\r
+\r
+}\r
+\r

diff --git a/softfloat/s_commonNaNToF64UI.c b/softfloat/s_commonNaNToF64UI.c
new file mode 100755 (executable)
index 0000000..da36c04
--- /dev/null
+++ b/softfloat/s_commonNaNToF64UI.c
@@ -0,0 +1,18 @@
+
+#include <stdint.h>
+#include "platform.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Returns the result of converting the canonical NaN `a' to the double-
+| precision floating-point format.
+*----------------------------------------------------------------------------*/
+
+uint_fast64_t softfloat_commonNaNToF64UI( struct commonNaN a )
+{
+
+    return
+        (uint_fast64_t) a.sign<<63 | UINT64_C( 0x7FFFFFFFFFFFFFFF );
+
+}
+

diff --git a/softfloat/s_f32UIToCommonNaN.c b/softfloat/s_f32UIToCommonNaN.c
new file mode 100755 (executable)
index 0000000..9ee0db9
--- /dev/null
+++ b/softfloat/s_f32UIToCommonNaN.c
@@ -0,0 +1,25 @@
+\r
+#include <stdint.h>\r
+#include "platform.h"\r
+#include "specialize.h"\r
+#include "softfloat.h"\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the single-precision floating-point NaN\r
+| `a' to the canonical NaN format.  If `a' is a signaling NaN, the invalid\r
+| exception is raised.\r
+*----------------------------------------------------------------------------*/\r
+struct commonNaN softfloat_f32UIToCommonNaN( uint_fast32_t uiA )\r
+{\r
+    struct commonNaN z;\r
+\r
+    if ( softfloat_isSigNaNF32UI( uiA ) ) {\r
+        softfloat_raiseFlags( softfloat_flag_invalid );\r
+    }\r
+    z.sign = uiA>>31;\r
+    z.v64 = (uint_fast64_t) 0x7FFFF <<41;\r
+    z.v0 = 0;\r
+    return z;\r
+\r
+}\r
+\r

diff --git a/softfloat/s_f64UIToCommonNaN.c b/softfloat/s_f64UIToCommonNaN.c
new file mode 100755 (executable)
index 0000000..84d8ca0
--- /dev/null
+++ b/softfloat/s_f64UIToCommonNaN.c
@@ -0,0 +1,25 @@
+\r
+#include <stdint.h>\r
+#include "platform.h"\r
+#include "specialize.h"\r
+#include "softfloat.h"\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns the result of converting the double-precision floating-point NaN\r
+| `a' to the canonical NaN format.  If `a' is a signaling NaN, the invalid\r
+| exception is raised.\r
+*----------------------------------------------------------------------------*/\r
+struct commonNaN softfloat_f64UIToCommonNaN( uint_fast64_t uiA )\r
+{\r
+    struct commonNaN z;\r
+\r
+    if ( softfloat_isSigNaNF64UI( uiA ) ) {\r
+        softfloat_raiseFlags( softfloat_flag_invalid );\r
+    }\r
+    z.sign = uiA>>63;\r
+    z.v64 = (uint_fast64_t) 0xFFFFFFFFFFFFF <<12;\r
+    z.v0 = 0;\r
+    return z;\r
+\r
+}\r
+\r

diff --git a/softfloat/s_isSigNaNF32UI.c b/softfloat/s_isSigNaNF32UI.c
new file mode 100755 (executable)
index 0000000..0a9c33f
--- /dev/null
+++ b/softfloat/s_isSigNaNF32UI.c
@@ -0,0 +1,13 @@
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "specialize.h"
+
+bool softfloat_isSigNaNF32UI( uint_fast32_t ui )
+{
+
+    return ( ( ui>>22 & 0x1FF ) == 0x1FE ) && ( ui & 0x003FFFFF );
+
+}
+

diff --git a/softfloat/s_isSigNaNF64UI.c b/softfloat/s_isSigNaNF64UI.c
new file mode 100755 (executable)
index 0000000..d255213
--- /dev/null
+++ b/softfloat/s_isSigNaNF64UI.c
@@ -0,0 +1,15 @@
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "specialize.h"
+
+bool softfloat_isSigNaNF64UI( uint_fast64_t ui )
+{
+
+    return
+        ( ( ui>>51 & 0xFFF ) == 0xFFE )
+            && ( ui & UINT64_C( 0x0007FFFFFFFFFFFF ) );
+
+}
+

diff --git a/softfloat/s_propagateNaNF32UI.c b/softfloat/s_propagateNaNF32UI.c
new file mode 100755 (executable)
index 0000000..d8738d1
--- /dev/null
+++ b/softfloat/s_propagateNaNF32UI.c
@@ -0,0 +1,25 @@
+\r
+/*** UPDATE COMMENTS. ***/\r
+\r
+#include <stdbool.h>\r
+#include <stdint.h>\r
+#include "platform.h"\r
+#include "internals.h"\r
+#include "specialize.h"\r
+#include "softfloat.h"\r
+\r
+/*----------------------------------------------------------------------------\r
+| Takes two single-precision floating-point values `a' and `b', one of which\r
+| is a NaN, and returns the appropriate NaN result.  If either `a' or `b' is a\r
+| signaling NaN, the invalid exception is raised.\r
+*----------------------------------------------------------------------------*/\r
+\r
+uint_fast32_t\r
+ softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB )\r
+{\r
+    if ( softfloat_isSigNaNF32UI( uiA ) | softfloat_isSigNaNF32UI( uiB ) ) {\r
+        softfloat_raiseFlags( softfloat_flag_invalid );\r
+    }\r
+    return defaultNaNF32UI;\r
+}\r
+\r

diff --git a/softfloat/s_propagateNaNF64UI.c b/softfloat/s_propagateNaNF64UI.c
new file mode 100755 (executable)
index 0000000..871989d
--- /dev/null
+++ b/softfloat/s_propagateNaNF64UI.c
@@ -0,0 +1,25 @@
+
+/*** UPDATE COMMENTS. ***/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| 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.
+*----------------------------------------------------------------------------*/
+
+uint_fast64_t
+ softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB )
+{
+    if ( softfloat_isSigNaNF64UI( uiA ) | softfloat_isSigNaNF64UI( uiB ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+    }
+    return defaultNaNF64UI;
+}
+

diff --git a/softfloat/softfloat.mk.in b/softfloat/softfloat.mk.in
index 59993cb0fd49154e743c4a60841e49d0ba7e42e7..2b29f9213756c601d0b0e1741a7788158e60de2f 100644 (file)
--- a/softfloat/softfloat.mk.in
+++ b/softfloat/softfloat.mk.in
@@ -1,10 +1,12 @@
 softfloat_subproject_deps = \
-       sotfloat_riscv \
 
 softfloat_hdrs = \
        internals.h \
        primitives.h \
        softfloat.h \
+       softfloat_types.h \
+       platform.h \
+       specialize.h \
 
 softfloat_c_srcs = \
        f32_add.c                      \
@@ -107,6 +109,15 @@ softfloat_c_srcs = \
        ui32_to_f64.c                  \
        ui64_to_f32.c                  \
        ui64_to_f64.c                  \
+       softfloat_raiseFlags.c         \
+       s_commonNaNToF32UI.c           \
+       s_commonNaNToF64UI.c           \
+       s_f32UIToCommonNaN.c           \
+       s_f64UIToCommonNaN.c           \
+       s_isSigNaNF32UI.c              \
+       s_isSigNaNF64UI.c              \
+       s_propagateNaNF32UI.c          \
+       s_propagateNaNF64UI.c          \
 
 softfloat_test_srcs =
 

diff --git a/softfloat/softfloat_raiseFlags.c b/softfloat/softfloat_raiseFlags.c
new file mode 100755 (executable)
index 0000000..c0c0dc8
--- /dev/null
+++ b/softfloat/softfloat_raiseFlags.c
@@ -0,0 +1,51 @@
+
+/*============================================================================
+
+*** FIX.
+
+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.
+
+=============================================================================*/
+
+#include "platform.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Raises the exceptions specified by `flags'.  Floating-point traps can be
+| defined here if desired.  It is currently not possible for such a trap
+| to substitute a result value.  If traps are not implemented, this routine
+| should be simply `float_exception_flags |= flags;'.
+*----------------------------------------------------------------------------*/
+
+void softfloat_raiseFlags( int_fast8_t flags )
+{
+
+    softfloat_exceptionFlags |= flags;
+
+}
+

diff --git a/softfloat/softfloat_types.h b/softfloat/softfloat_types.h
new file mode 100755 (executable)
index 0000000..9fada89
--- /dev/null
+++ b/softfloat/softfloat_types.h
@@ -0,0 +1,16 @@
+
+#ifndef softfloat_types_h
+#define softfloat_types_h
+
+/*** COMMENTS. ***/
+
+#include <stdbool.h>
+#include <stdint.h>
+
+typedef uint32_t float32_t;
+typedef uint64_t float64_t;
+typedef struct { uint64_t v; uint16_t x; } floatx80_t;
+typedef struct { uint64_t v[ 2 ]; } float128_t;
+
+#endif
+

diff --git a/softfloat/specialize.h b/softfloat/specialize.h
new file mode 100755 (executable)
index 0000000..1793c46
--- /dev/null
+++ b/softfloat/specialize.h
@@ -0,0 +1,113 @@
+\r
+/*============================================================================\r
+\r
+*** FIX.\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 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 <stdbool.h>\r
+#include <stdint.h>\r
+\r
+/*----------------------------------------------------------------------------\r
+*----------------------------------------------------------------------------*/\r
+#define init_detectTininess softfloat_tininess_beforeRounding;\r
+\r
+/*----------------------------------------------------------------------------\r
+| Structure used to transfer NaN representations from one format to another.\r
+*----------------------------------------------------------------------------*/\r
+struct commonNaN {\r
+    bool sign;\r
+    uint64_t v64, v0;\r
+};\r
+\r
+/*----------------------------------------------------------------------------\r
+| The pattern for a default generated single-precision NaN.\r
+*----------------------------------------------------------------------------*/\r
+#define defaultNaNF32UI 0xFFFFFFFF\r
+\r
+/*----------------------------------------------------------------------------\r
+| Returns 1 if the single-precision floating-point value `a' is a signaling\r
+| NaN; otherwise, returns 0.\r
+*----------------------------------------------------------------------------*/\r
+#if defined INLINE_LEVEL && ( 1 <= INLINE_LEVEL )\r
+INLINE bool softfloat_isSigNaNF32UI( uint_fast32_t ui )\r
+    { return ( ( ui>>22 & 0x1FF ) == 0x1FE ) && ( ui & 0x003FFFFF ); }\r
+#else\r
+bool softfloat_isSigNaNF32UI( uint_fast32_t );\r
+#endif\r
+\r
+/*----------------------------------------------------------------------------\r
+*----------------------------------------------------------------------------*/\r
+struct commonNaN softfloat_f32UIToCommonNaN( uint_fast32_t );\r
+#if defined INLINE_LEVEL && ( 1 <= INLINE_LEVEL )\r
+INLINE uint_fast32_t softfloat_commonNaNToF32UI( struct commonNaN a )\r
+    { return (uint_fast32_t) a.sign<<31 | 0x7FFFFFFF; }\r
+#else\r
+uint_fast32_t softfloat_commonNaNToF32UI( struct commonNaN );\r
+#endif\r
+\r
+/*----------------------------------------------------------------------------\r
+| Takes two single-precision floating-point values `a' and `b', one of which\r
+| is a NaN, and returns the appropriate NaN result.  If either `a' or `b' is a\r
+| signaling NaN, the invalid exception is raised.\r
+*----------------------------------------------------------------------------*/\r
+uint_fast32_t softfloat_propagateNaNF32UI( uint_fast32_t, uint_fast32_t );\r
+\r
+/*----------------------------------------------------------------------------\r
+| The pattern for a default generated double-precision NaN.\r
+*----------------------------------------------------------------------------*/\r
+#define defaultNaNF64UI UINT64_C(0xFFFFFFFFFFFFFFFF)\r
+\r
+/*----------------------------------------------------------------------------\r
+*----------------------------------------------------------------------------*/\r
+#if defined INLINE_LEVEL && ( 1 <= INLINE_LEVEL )\r
+INLINE bool softfloat_isSigNaNF64UI( uint_fast64_t ui )\r
+{\r
+    return\r
+        ( ( ui>>51 & 0xFFF ) == 0xFFE )\r
+            && ( ui & UINT64_C( 0x0007FFFFFFFFFFFF ) );\r
+}\r
+#else\r
+bool softfloat_isSigNaNF64UI( uint_fast64_t );\r
+#endif\r
+\r
+/*----------------------------------------------------------------------------\r
+*----------------------------------------------------------------------------*/\r
+/*** MIGHT BE INLINE'D. ***/\r
+struct commonNaN softfloat_f64UIToCommonNaN( uint_fast64_t );\r
+uint_fast64_t softfloat_commonNaNToF64UI( struct commonNaN );\r
+\r
+/*----------------------------------------------------------------------------\r
+| Takes two double-precision floating-point values `a' and `b', one of which\r
+| is a NaN, and returns the appropriate NaN result.  If either `a' or `b' is a\r
+| signaling NaN, the invalid exception is raised.\r
+*----------------------------------------------------------------------------*/\r
+uint_fast64_t softfloat_propagateNaNF64UI( uint_fast64_t, uint_fast64_t );\r
+\r

diff --git a/softfloat_riscv/platform.h b/softfloat_riscv/platform.h
deleted file mode 100755 (executable)
index 6c54313..0000000
--- a/softfloat_riscv/platform.h
+++ /dev/null
@@ -1,42 +0,0 @@
-
-/*============================================================================
-
-*** FIX.
-
-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.
-
-=============================================================================*/
-
-/*----------------------------------------------------------------------------
-*----------------------------------------------------------------------------*/
-#define LITTLEENDIAN
-
-#ifndef UINT64_C
-# define UINT64_C(x) (x ## ULL)
-# define INT64_C(x) (x ## LL)
-#endif

diff --git a/softfloat_riscv/s_commonNaNToF32UI.c b/softfloat_riscv/s_commonNaNToF32UI.c
deleted file mode 100755 (executable)
index 61f2735..0000000
--- a/softfloat_riscv/s_commonNaNToF32UI.c
+++ /dev/null
@@ -1,17 +0,0 @@
-\r
-#include <stdint.h>\r
-#include "platform.h"\r
-#include "specialize.h"\r
-\r
-/*----------------------------------------------------------------------------\r
-| Returns the result of converting the canonical NaN `a' to the single-\r
-| precision floating-point format.\r
-*----------------------------------------------------------------------------*/\r
-\r
-uint_fast32_t softfloat_commonNaNToF32UI( struct commonNaN a )\r
-{\r
-\r
-    return (uint_fast32_t) a.sign<<31 | 0x7FFFFFFF;\r
-\r
-}\r
-\r

diff --git a/softfloat_riscv/s_commonNaNToF64UI.c b/softfloat_riscv/s_commonNaNToF64UI.c
deleted file mode 100755 (executable)
index da36c04..0000000
--- a/softfloat_riscv/s_commonNaNToF64UI.c
+++ /dev/null
@@ -1,18 +0,0 @@
-
-#include <stdint.h>
-#include "platform.h"
-#include "specialize.h"
-
-/*----------------------------------------------------------------------------
-| Returns the result of converting the canonical NaN `a' to the double-
-| precision floating-point format.
-*----------------------------------------------------------------------------*/
-
-uint_fast64_t softfloat_commonNaNToF64UI( struct commonNaN a )
-{
-
-    return
-        (uint_fast64_t) a.sign<<63 | UINT64_C( 0x7FFFFFFFFFFFFFFF );
-
-}
-

diff --git a/softfloat_riscv/s_f32UIToCommonNaN.c b/softfloat_riscv/s_f32UIToCommonNaN.c
deleted file mode 100755 (executable)
index 9ee0db9..0000000
--- a/softfloat_riscv/s_f32UIToCommonNaN.c
+++ /dev/null
@@ -1,25 +0,0 @@
-\r
-#include <stdint.h>\r
-#include "platform.h"\r
-#include "specialize.h"\r
-#include "softfloat.h"\r
-\r
-/*----------------------------------------------------------------------------\r
-| Returns the result of converting the single-precision floating-point NaN\r
-| `a' to the canonical NaN format.  If `a' is a signaling NaN, the invalid\r
-| exception is raised.\r
-*----------------------------------------------------------------------------*/\r
-struct commonNaN softfloat_f32UIToCommonNaN( uint_fast32_t uiA )\r
-{\r
-    struct commonNaN z;\r
-\r
-    if ( softfloat_isSigNaNF32UI( uiA ) ) {\r
-        softfloat_raiseFlags( softfloat_flag_invalid );\r
-    }\r
-    z.sign = uiA>>31;\r
-    z.v64 = (uint_fast64_t) 0x7FFFF <<41;\r
-    z.v0 = 0;\r
-    return z;\r
-\r
-}\r
-\r

diff --git a/softfloat_riscv/s_f64UIToCommonNaN.c b/softfloat_riscv/s_f64UIToCommonNaN.c
deleted file mode 100755 (executable)
index 84d8ca0..0000000
--- a/softfloat_riscv/s_f64UIToCommonNaN.c
+++ /dev/null
@@ -1,25 +0,0 @@
-\r
-#include <stdint.h>\r
-#include "platform.h"\r
-#include "specialize.h"\r
-#include "softfloat.h"\r
-\r
-/*----------------------------------------------------------------------------\r
-| Returns the result of converting the double-precision floating-point NaN\r
-| `a' to the canonical NaN format.  If `a' is a signaling NaN, the invalid\r
-| exception is raised.\r
-*----------------------------------------------------------------------------*/\r
-struct commonNaN softfloat_f64UIToCommonNaN( uint_fast64_t uiA )\r
-{\r
-    struct commonNaN z;\r
-\r
-    if ( softfloat_isSigNaNF64UI( uiA ) ) {\r
-        softfloat_raiseFlags( softfloat_flag_invalid );\r
-    }\r
-    z.sign = uiA>>63;\r
-    z.v64 = (uint_fast64_t) 0xFFFFFFFFFFFFF <<12;\r
-    z.v0 = 0;\r
-    return z;\r
-\r
-}\r
-\r

diff --git a/softfloat_riscv/s_isSigNaNF32UI.c b/softfloat_riscv/s_isSigNaNF32UI.c
deleted file mode 100755 (executable)
index 0a9c33f..0000000
--- a/softfloat_riscv/s_isSigNaNF32UI.c
+++ /dev/null
@@ -1,13 +0,0 @@
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "specialize.h"
-
-bool softfloat_isSigNaNF32UI( uint_fast32_t ui )
-{
-
-    return ( ( ui>>22 & 0x1FF ) == 0x1FE ) && ( ui & 0x003FFFFF );
-
-}
-

diff --git a/softfloat_riscv/s_isSigNaNF64UI.c b/softfloat_riscv/s_isSigNaNF64UI.c
deleted file mode 100755 (executable)
index d255213..0000000
--- a/softfloat_riscv/s_isSigNaNF64UI.c
+++ /dev/null
@@ -1,15 +0,0 @@
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "specialize.h"
-
-bool softfloat_isSigNaNF64UI( uint_fast64_t ui )
-{
-
-    return
-        ( ( ui>>51 & 0xFFF ) == 0xFFE )
-            && ( ui & UINT64_C( 0x0007FFFFFFFFFFFF ) );
-
-}
-

diff --git a/softfloat_riscv/s_propagateNaNF32UI.c b/softfloat_riscv/s_propagateNaNF32UI.c
deleted file mode 100755 (executable)
index d8738d1..0000000
--- a/softfloat_riscv/s_propagateNaNF32UI.c
+++ /dev/null
@@ -1,25 +0,0 @@
-\r
-/*** UPDATE COMMENTS. ***/\r
-\r
-#include <stdbool.h>\r
-#include <stdint.h>\r
-#include "platform.h"\r
-#include "internals.h"\r
-#include "specialize.h"\r
-#include "softfloat.h"\r
-\r
-/*----------------------------------------------------------------------------\r
-| Takes two single-precision floating-point values `a' and `b', one of which\r
-| is a NaN, and returns the appropriate NaN result.  If either `a' or `b' is a\r
-| signaling NaN, the invalid exception is raised.\r
-*----------------------------------------------------------------------------*/\r
-\r
-uint_fast32_t\r
- softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB )\r
-{\r
-    if ( softfloat_isSigNaNF32UI( uiA ) | softfloat_isSigNaNF32UI( uiB ) ) {\r
-        softfloat_raiseFlags( softfloat_flag_invalid );\r
-    }\r
-    return defaultNaNF32UI;\r
-}\r
-\r

diff --git a/softfloat_riscv/s_propagateNaNF64UI.c b/softfloat_riscv/s_propagateNaNF64UI.c
deleted file mode 100755 (executable)
index 871989d..0000000
--- a/softfloat_riscv/s_propagateNaNF64UI.c
+++ /dev/null
@@ -1,25 +0,0 @@
-
-/*** UPDATE COMMENTS. ***/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| 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.
-*----------------------------------------------------------------------------*/
-
-uint_fast64_t
- softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB )
-{
-    if ( softfloat_isSigNaNF64UI( uiA ) | softfloat_isSigNaNF64UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-    }
-    return defaultNaNF64UI;
-}
-

diff --git a/softfloat_riscv/softfloat_raiseFlags.c b/softfloat_riscv/softfloat_raiseFlags.c
deleted file mode 100755 (executable)
index c0c0dc8..0000000
--- a/softfloat_riscv/softfloat_raiseFlags.c
+++ /dev/null
@@ -1,51 +0,0 @@
-
-/*============================================================================
-
-*** FIX.
-
-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.
-
-=============================================================================*/
-
-#include "platform.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Raises the exceptions specified by `flags'.  Floating-point traps can be
-| defined here if desired.  It is currently not possible for such a trap
-| to substitute a result value.  If traps are not implemented, this routine
-| should be simply `float_exception_flags |= flags;'.
-*----------------------------------------------------------------------------*/
-
-void softfloat_raiseFlags( int_fast8_t flags )
-{
-
-    softfloat_exceptionFlags |= flags;
-
-}
-

diff --git a/softfloat_riscv/softfloat_riscv.ac b/softfloat_riscv/softfloat_riscv.ac
deleted file mode 100644 (file)
index e69de29..0000000

diff --git a/softfloat_riscv/softfloat_riscv.mk.in b/softfloat_riscv/softfloat_riscv.mk.in
deleted file mode 100644 (file)
index 0b898ed..0000000
--- a/softfloat_riscv/softfloat_riscv.mk.in
+++ /dev/null
@@ -1,21 +0,0 @@
-softfloat_riscv_subproject_deps = \
-
-softfloat_riscv_hdrs = \
-       softfloat_types.h \
-       platform.h        \
-       specialize.h      \
-
-softfloat_riscv_c_srcs = \
-       softfloat_raiseFlags.c \
-       s_commonNaNToF32UI.c   \
-       s_commonNaNToF64UI.c   \
-       s_f32UIToCommonNaN.c   \
-       s_f64UIToCommonNaN.c   \
-       s_isSigNaNF32UI.c      \
-       s_isSigNaNF64UI.c      \
-       s_propagateNaNF32UI.c  \
-       s_propagateNaNF64UI.c  \
-
-softfloat_riscv_test_srcs =
-
-softfloat_riscv_install_prog_srcs =

diff --git a/softfloat_riscv/softfloat_types.h b/softfloat_riscv/softfloat_types.h
deleted file mode 100755 (executable)
index 9fada89..0000000
--- a/softfloat_riscv/softfloat_types.h
+++ /dev/null
@@ -1,16 +0,0 @@
-
-#ifndef softfloat_types_h
-#define softfloat_types_h
-
-/*** COMMENTS. ***/
-
-#include <stdbool.h>
-#include <stdint.h>
-
-typedef uint32_t float32_t;
-typedef uint64_t float64_t;
-typedef struct { uint64_t v; uint16_t x; } floatx80_t;
-typedef struct { uint64_t v[ 2 ]; } float128_t;
-
-#endif
-

diff --git a/softfloat_riscv/specialize.h b/softfloat_riscv/specialize.h
deleted file mode 100755 (executable)
index 1793c46..0000000
--- a/softfloat_riscv/specialize.h
+++ /dev/null
@@ -1,113 +0,0 @@
-\r
-/*============================================================================\r
-\r
-*** FIX.\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 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 <stdbool.h>\r
-#include <stdint.h>\r
-\r
-/*----------------------------------------------------------------------------\r
-*----------------------------------------------------------------------------*/\r
-#define init_detectTininess softfloat_tininess_beforeRounding;\r
-\r
-/*----------------------------------------------------------------------------\r
-| Structure used to transfer NaN representations from one format to another.\r
-*----------------------------------------------------------------------------*/\r
-struct commonNaN {\r
-    bool sign;\r
-    uint64_t v64, v0;\r
-};\r
-\r
-/*----------------------------------------------------------------------------\r
-| The pattern for a default generated single-precision NaN.\r
-*----------------------------------------------------------------------------*/\r
-#define defaultNaNF32UI 0xFFFFFFFF\r
-\r
-/*----------------------------------------------------------------------------\r
-| Returns 1 if the single-precision floating-point value `a' is a signaling\r
-| NaN; otherwise, returns 0.\r
-*----------------------------------------------------------------------------*/\r
-#if defined INLINE_LEVEL && ( 1 <= INLINE_LEVEL )\r
-INLINE bool softfloat_isSigNaNF32UI( uint_fast32_t ui )\r
-    { return ( ( ui>>22 & 0x1FF ) == 0x1FE ) && ( ui & 0x003FFFFF ); }\r
-#else\r
-bool softfloat_isSigNaNF32UI( uint_fast32_t );\r
-#endif\r
-\r
-/*----------------------------------------------------------------------------\r
-*----------------------------------------------------------------------------*/\r
-struct commonNaN softfloat_f32UIToCommonNaN( uint_fast32_t );\r
-#if defined INLINE_LEVEL && ( 1 <= INLINE_LEVEL )\r
-INLINE uint_fast32_t softfloat_commonNaNToF32UI( struct commonNaN a )\r
-    { return (uint_fast32_t) a.sign<<31 | 0x7FFFFFFF; }\r
-#else\r
-uint_fast32_t softfloat_commonNaNToF32UI( struct commonNaN );\r
-#endif\r
-\r
-/*----------------------------------------------------------------------------\r
-| Takes two single-precision floating-point values `a' and `b', one of which\r
-| is a NaN, and returns the appropriate NaN result.  If either `a' or `b' is a\r
-| signaling NaN, the invalid exception is raised.\r
-*----------------------------------------------------------------------------*/\r
-uint_fast32_t softfloat_propagateNaNF32UI( uint_fast32_t, uint_fast32_t );\r
-\r
-/*----------------------------------------------------------------------------\r
-| The pattern for a default generated double-precision NaN.\r
-*----------------------------------------------------------------------------*/\r
-#define defaultNaNF64UI UINT64_C(0xFFFFFFFFFFFFFFFF)\r
-\r
-/*----------------------------------------------------------------------------\r
-*----------------------------------------------------------------------------*/\r
-#if defined INLINE_LEVEL && ( 1 <= INLINE_LEVEL )\r
-INLINE bool softfloat_isSigNaNF64UI( uint_fast64_t ui )\r
-{\r
-    return\r
-        ( ( ui>>51 & 0xFFF ) == 0xFFE )\r
-            && ( ui & UINT64_C( 0x0007FFFFFFFFFFFF ) );\r
-}\r
-#else\r
-bool softfloat_isSigNaNF64UI( uint_fast64_t );\r
-#endif\r
-\r
-/*----------------------------------------------------------------------------\r
-*----------------------------------------------------------------------------*/\r
-/*** MIGHT BE INLINE'D. ***/\r
-struct commonNaN softfloat_f64UIToCommonNaN( uint_fast64_t );\r
-uint_fast64_t softfloat_commonNaNToF64UI( struct commonNaN );\r
-\r
-/*----------------------------------------------------------------------------\r
-| Takes two double-precision floating-point values `a' and `b', one of which\r
-| is a NaN, and returns the appropriate NaN result.  If either `a' or `b' is a\r
-| signaling NaN, the invalid exception is raised.\r
-*----------------------------------------------------------------------------*/\r
-uint_fast64_t softfloat_propagateNaNF64UI( uint_fast64_t, uint_fast64_t );\r
-\r