Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Browse files

Original post-\r-rip include files for TestFloat-2a

  • Loading branch information...
commit 4ae71d86de8974cb2e7bf2e3665a3a9d13e8fdee 1 parent 477a19d
ross authored
View
29 regress/lib/libc/ieeefp/testfloat/include/fail.h
@@ -0,0 +1,29 @@
+
+/*
+===============================================================================
+
+This C header file is part of TestFloat, Release 2a, a package of programs
+for testing the correctness of floating-point arithmetic complying to the
+IEC/IEEE Standard for Floating-Point.
+
+Written by John R. Hauser. More information is available through the Web
+page `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.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 ANY
+AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
+
+Derivative works are acceptable, even for commercial purposes, so long as
+(1) they include prominent notice that the work is derivative, and (2) they
+include prominent notice akin to these four paragraphs for those parts of
+this code that are retained.
+
+===============================================================================
+*/
+
+extern char *fail_programName;
+
+void fail( const char *, ... );
+
View
32 regress/lib/libc/ieeefp/testfloat/include/random.h
@@ -0,0 +1,32 @@
+
+/*
+===============================================================================
+
+This C header file is part of TestFloat, Release 2a, a package of programs
+for testing the correctness of floating-point arithmetic complying to the
+IEC/IEEE Standard for Floating-Point.
+
+Written by John R. Hauser. More information is available through the Web
+page `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.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 ANY
+AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
+
+Derivative works are acceptable, even for commercial purposes, so long as
+(1) they include prominent notice that the work is derivative, and (2) they
+include prominent notice akin to these four paragraphs for those parts of
+this code that are retained.
+
+===============================================================================
+*/
+
+uint8 randomUint8( void );
+uint16 randomUint16( void );
+uint32 randomUint32( void );
+#ifdef BITS64
+uint64 randomUint64( void );
+#endif
+
View
33 regress/lib/libc/ieeefp/testfloat/include/systflags.h
@@ -0,0 +1,33 @@
+
+/*
+===============================================================================
+
+This C header file is part of TestFloat, Release 2a, a package of programs
+for testing the correctness of floating-point arithmetic complying to the
+IEC/IEEE Standard for Floating-Point.
+
+Written by John R. Hauser. More information is available through the Web
+page `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.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 ANY
+AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
+
+Derivative works are acceptable, even for commercial purposes, so long as
+(1) they include prominent notice that the work is derivative, and (2) they
+include prominent notice akin to these four paragraphs for those parts of
+this code that are retained.
+
+===============================================================================
+*/
+
+/*
+-------------------------------------------------------------------------------
+Target-specific function for clearing the system's IEC/IEEE floating-point
+exception flags. The previous value of the flags is returned.
+-------------------------------------------------------------------------------
+*/
+int8 syst_float_flags_clear( void );
+
View
233 regress/lib/libc/ieeefp/testfloat/include/systfloat.h
@@ -0,0 +1,233 @@
+
+/*
+===============================================================================
+
+This C header file is part of TestFloat, Release 2a, a package of programs
+for testing the correctness of floating-point arithmetic complying to the
+IEC/IEEE Standard for Floating-Point.
+
+Written by John R. Hauser. More information is available through the Web
+page `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.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 ANY
+AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
+
+Derivative works are acceptable, even for commercial purposes, so long as
+(1) they include prominent notice that the work is derivative, and (2) they
+include prominent notice akin to these four paragraphs for those parts of
+this code that are retained.
+
+===============================================================================
+*/
+
+/*
+-------------------------------------------------------------------------------
+The following macros are defined to indicate that the corresponding
+functions exist.
+-------------------------------------------------------------------------------
+*/
+#define SYST_INT32_TO_FLOAT32
+#define SYST_INT32_TO_FLOAT64
+#ifdef BITS64
+#define SYST_INT64_TO_FLOAT32
+#define SYST_INT64_TO_FLOAT64
+#endif
+#define SYST_FLOAT32_TO_INT32_ROUND_TO_ZERO
+#ifdef BITS64
+#define SYST_FLOAT32_TO_INT64_ROUND_TO_ZERO
+#endif
+#define SYST_FLOAT32_TO_FLOAT64
+#define SYST_FLOAT32_ADD
+#define SYST_FLOAT32_SUB
+#define SYST_FLOAT32_MUL
+#define SYST_FLOAT32_DIV
+#define SYST_FLOAT32_EQ
+#define SYST_FLOAT32_LE
+#define SYST_FLOAT32_LT
+#define SYST_FLOAT64_TO_INT32_ROUND_TO_ZERO
+#ifdef BITS64
+#define SYST_FLOAT64_TO_INT64_ROUND_TO_ZERO
+#endif
+#define SYST_FLOAT64_TO_FLOAT32
+#define SYST_FLOAT64_ADD
+#define SYST_FLOAT64_SUB
+#define SYST_FLOAT64_MUL
+#define SYST_FLOAT64_DIV
+#define SYST_FLOAT64_SQRT
+#define SYST_FLOAT64_EQ
+#define SYST_FLOAT64_LE
+#define SYST_FLOAT64_LT
+#if defined( FLOATX80 ) && defined( LONG_DOUBLE_IS_FLOATX80 )
+#define SYST_INT32_TO_FLOATX80
+#ifdef BITS64
+#define SYST_INT64_TO_FLOATX80
+#endif
+#define SYST_FLOAT32_TO_FLOATX80
+#define SYST_FLOAT64_TO_FLOATX80
+#define SYST_FLOATX80_TO_INT32_ROUND_TO_ZERO
+#ifdef BITS64
+#define SYST_FLOATX80_TO_INT64_ROUND_TO_ZERO
+#endif
+#define SYST_FLOATX80_TO_FLOAT32
+#define SYST_FLOATX80_TO_FLOAT64
+#define SYST_FLOATX80_ADD
+#define SYST_FLOATX80_SUB
+#define SYST_FLOATX80_MUL
+#define SYST_FLOATX80_DIV
+#define SYST_FLOATX80_EQ
+#define SYST_FLOATX80_LE
+#define SYST_FLOATX80_LT
+#endif
+#if defined( FLOAT128 ) && defined( LONG_DOUBLE_IS_FLOAT128 )
+#define SYST_INT32_TO_FLOAT128
+#ifdef BITS64
+#define SYST_INT64_TO_FLOAT128
+#endif
+#define SYST_FLOAT32_TO_FLOAT128
+#define SYST_FLOAT64_TO_FLOAT128
+#define SYST_FLOAT128_TO_INT32_ROUND_TO_ZERO
+#ifdef BITS64
+#define SYST_FLOAT128_TO_INT64_ROUND_TO_ZERO
+#endif
+#define SYST_FLOAT128_TO_FLOAT32
+#define SYST_FLOAT128_TO_FLOAT64
+#define SYST_FLOAT128_ADD
+#define SYST_FLOAT128_SUB
+#define SYST_FLOAT128_MUL
+#define SYST_FLOAT128_DIV
+#define SYST_FLOAT128_EQ
+#define SYST_FLOAT128_LE
+#define SYST_FLOAT128_LT
+#endif
+
+/*
+-------------------------------------------------------------------------------
+System function declarations. (Some of these functions may not exist.)
+-------------------------------------------------------------------------------
+*/
+float32 syst_int32_to_float32( int32 );
+float64 syst_int32_to_float64( int32 );
+#ifdef FLOATX80
+floatx80 syst_int32_to_floatx80( int32 );
+#endif
+#ifdef FLOAT128
+float128 syst_int32_to_float128( int32 );
+#endif
+#ifdef BITS64
+float32 syst_int64_to_float32( int64 );
+float64 syst_int64_to_float64( int64 );
+#ifdef FLOATX80
+floatx80 syst_int64_to_floatx80( int64 );
+#endif
+#ifdef FLOAT128
+float128 syst_int64_to_float128( int64 );
+#endif
+#endif
+int32 syst_float32_to_int32( float32 );
+int32 syst_float32_to_int32_round_to_zero( float32 );
+#ifdef BITS64
+int64 syst_float32_to_int64( float32 );
+int64 syst_float32_to_int64_round_to_zero( float32 );
+#endif
+float64 syst_float32_to_float64( float32 );
+#ifdef FLOATX80
+floatx80 syst_float32_to_floatx80( float32 );
+#endif
+#ifdef FLOAT128
+float128 syst_float32_to_float128( float32 );
+#endif
+float32 syst_float32_round_to_int( float32 );
+float32 syst_float32_add( float32, float32 );
+float32 syst_float32_sub( float32, float32 );
+float32 syst_float32_mul( float32, float32 );
+float32 syst_float32_div( float32, float32 );
+float32 syst_float32_rem( float32, float32 );
+float32 syst_float32_sqrt( float32 );
+flag syst_float32_eq( float32, float32 );
+flag syst_float32_le( float32, float32 );
+flag syst_float32_lt( float32, float32 );
+flag syst_float32_eq_signaling( float32, float32 );
+flag syst_float32_le_quiet( float32, float32 );
+flag syst_float32_lt_quiet( float32, float32 );
+int32 syst_float64_to_int32( float64 );
+int32 syst_float64_to_int32_round_to_zero( float64 );
+#ifdef BITS64
+int64 syst_float64_to_int64( float64 );
+int64 syst_float64_to_int64_round_to_zero( float64 );
+#endif
+float32 syst_float64_to_float32( float64 );
+#ifdef FLOATX80
+floatx80 syst_float64_to_floatx80( float64 );
+#endif
+#ifdef FLOAT128
+float128 syst_float64_to_float128( float64 );
+#endif
+float64 syst_float64_round_to_int( float64 );
+float64 syst_float64_add( float64, float64 );
+float64 syst_float64_sub( float64, float64 );
+float64 syst_float64_mul( float64, float64 );
+float64 syst_float64_div( float64, float64 );
+float64 syst_float64_rem( float64, float64 );
+float64 syst_float64_sqrt( float64 );
+flag syst_float64_eq( float64, float64 );
+flag syst_float64_le( float64, float64 );
+flag syst_float64_lt( float64, float64 );
+flag syst_float64_eq_signaling( float64, float64 );
+flag syst_float64_le_quiet( float64, float64 );
+flag syst_float64_lt_quiet( float64, float64 );
+#ifdef FLOATX80
+int32 syst_floatx80_to_int32( floatx80 );
+int32 syst_floatx80_to_int32_round_to_zero( floatx80 );
+#ifdef BITS64
+int64 syst_floatx80_to_int64( floatx80 );
+int64 syst_floatx80_to_int64_round_to_zero( floatx80 );
+#endif
+float32 syst_floatx80_to_float32( floatx80 );
+float64 syst_floatx80_to_float64( floatx80 );
+#ifdef FLOAT128
+float128 syst_floatx80_to_float128( floatx80 );
+#endif
+floatx80 syst_floatx80_round_to_int( floatx80 );
+floatx80 syst_floatx80_add( floatx80, floatx80 );
+floatx80 syst_floatx80_sub( floatx80, floatx80 );
+floatx80 syst_floatx80_mul( floatx80, floatx80 );
+floatx80 syst_floatx80_div( floatx80, floatx80 );
+floatx80 syst_floatx80_rem( floatx80, floatx80 );
+floatx80 syst_floatx80_sqrt( floatx80 );
+flag syst_floatx80_eq( floatx80, floatx80 );
+flag syst_floatx80_le( floatx80, floatx80 );
+flag syst_floatx80_lt( floatx80, floatx80 );
+flag syst_floatx80_eq_signaling( floatx80, floatx80 );
+flag syst_floatx80_le_quiet( floatx80, floatx80 );
+flag syst_floatx80_lt_quiet( floatx80, floatx80 );
+#endif
+#ifdef FLOAT128
+int32 syst_float128_to_int32( float128 );
+int32 syst_float128_to_int32_round_to_zero( float128 );
+#ifdef BITS64
+int64 syst_float128_to_int64( float128 );
+int64 syst_float128_to_int64_round_to_zero( float128 );
+#endif
+float32 syst_float128_to_float32( float128 );
+float64 syst_float128_to_float64( float128 );
+#ifdef FLOATX80
+floatx80 syst_float128_to_floatx80( float128 );
+#endif
+float128 syst_float128_round_to_int( float128 );
+float128 syst_float128_add( float128, float128 );
+float128 syst_float128_sub( float128, float128 );
+float128 syst_float128_mul( float128, float128 );
+float128 syst_float128_div( float128, float128 );
+float128 syst_float128_rem( float128, float128 );
+float128 syst_float128_sqrt( float128 );
+flag syst_float128_eq( float128, float128 );
+flag syst_float128_le( float128, float128 );
+flag syst_float128_lt( float128, float128 );
+flag syst_float128_eq_signaling( float128, float128 );
+flag syst_float128_le_quiet( float128, float128 );
+flag syst_float128_lt_quiet( float128, float128 );
+#endif
+
View
42 regress/lib/libc/ieeefp/testfloat/include/systmodes.h
@@ -0,0 +1,42 @@
+
+/*
+===============================================================================
+
+This C header file is part of TestFloat, Release 2a, a package of programs
+for testing the correctness of floating-point arithmetic complying to the
+IEC/IEEE Standard for Floating-Point.
+
+Written by John R. Hauser. More information is available through the Web
+page `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.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 ANY
+AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
+
+Derivative works are acceptable, even for commercial purposes, so long as
+(1) they include prominent notice that the work is derivative, and (2) they
+include prominent notice akin to these four paragraphs for those parts of
+this code that are retained.
+
+===============================================================================
+*/
+
+/*
+-------------------------------------------------------------------------------
+Target-specific function for setting the system's IEC/IEEE floating-point
+rounding mode. Other system modes are also initialized as necessary (for
+example, exception trapping may be disabled).
+-------------------------------------------------------------------------------
+*/
+void syst_float_set_rounding_mode( int8 );
+
+/*
+-------------------------------------------------------------------------------
+Target-specific function for setting the IEC/IEEE rounding precision of
+subsequent extended double-precision operations performed by the system.
+-------------------------------------------------------------------------------
+*/
+void syst_float_set_rounding_precision( int8 );
+
View
69 regress/lib/libc/ieeefp/testfloat/include/testCases.h
@@ -0,0 +1,69 @@
+
+/*
+===============================================================================
+
+This C header file is part of TestFloat, Release 2a, a package of programs
+for testing the correctness of floating-point arithmetic complying to the
+IEC/IEEE Standard for Floating-Point.
+
+Written by John R. Hauser. More information is available through the Web
+page `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.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 ANY
+AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
+
+Derivative works are acceptable, even for commercial purposes, so long as
+(1) they include prominent notice that the work is derivative, and (2) they
+include prominent notice akin to these four paragraphs for those parts of
+this code that are retained.
+
+===============================================================================
+*/
+
+void testCases_setLevel( int8 );
+
+void testCases_initSequence( int8 );
+enum {
+ testCases_sequence_a_int32,
+#ifdef BITS64
+ testCases_sequence_a_int64,
+#endif
+ testCases_sequence_a_float32,
+ testCases_sequence_ab_float32,
+ testCases_sequence_a_float64,
+ testCases_sequence_ab_float64,
+#ifdef FLOATX80
+ testCases_sequence_a_floatx80,
+ testCases_sequence_ab_floatx80,
+#endif
+#ifdef FLOAT128
+ testCases_sequence_a_float128,
+ testCases_sequence_ab_float128,
+#endif
+};
+
+extern uint32 testCases_total;
+extern flag testCases_done;
+
+void testCases_next( void );
+
+extern int32 testCases_a_int32;
+#ifdef BITS64
+extern int64 testCases_a_int64;
+#endif
+extern float32 testCases_a_float32;
+extern float32 testCases_b_float32;
+extern float64 testCases_a_float64;
+extern float64 testCases_b_float64;
+#ifdef FLOATX80
+extern floatx80 testCases_a_floatx80;
+extern floatx80 testCases_b_floatx80;
+#endif
+#ifdef FLOAT128
+extern float128 testCases_a_float128;
+extern float128 testCases_b_float128;
+#endif
+
View
135 regress/lib/libc/ieeefp/testfloat/include/testFunction.h
@@ -0,0 +1,135 @@
+
+/*
+===============================================================================
+
+This C header file is part of TestFloat, Release 2a, a package of programs
+for testing the correctness of floating-point arithmetic complying to the
+IEC/IEEE Standard for Floating-Point.
+
+Written by John R. Hauser. More information is available through the Web
+page `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.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 ANY
+AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
+
+Derivative works are acceptable, even for commercial purposes, so long as
+(1) they include prominent notice that the work is derivative, and (2) they
+include prominent notice akin to these four paragraphs for those parts of
+this code that are retained.
+
+===============================================================================
+*/
+
+enum {
+ INT32_TO_FLOAT32 = 1,
+ INT32_TO_FLOAT64,
+ INT32_TO_FLOATX80,
+ INT32_TO_FLOAT128,
+ INT64_TO_FLOAT32,
+ INT64_TO_FLOAT64,
+ INT64_TO_FLOATX80,
+ INT64_TO_FLOAT128,
+ FLOAT32_TO_INT32,
+ FLOAT32_TO_INT32_ROUND_TO_ZERO,
+ FLOAT32_TO_INT64,
+ FLOAT32_TO_INT64_ROUND_TO_ZERO,
+ FLOAT32_TO_FLOAT64,
+ FLOAT32_TO_FLOATX80,
+ FLOAT32_TO_FLOAT128,
+ FLOAT32_ROUND_TO_INT,
+ FLOAT32_ADD,
+ FLOAT32_SUB,
+ FLOAT32_MUL,
+ FLOAT32_DIV,
+ FLOAT32_REM,
+ FLOAT32_SQRT,
+ FLOAT32_EQ,
+ FLOAT32_LE,
+ FLOAT32_LT,
+ FLOAT32_EQ_SIGNALING,
+ FLOAT32_LE_QUIET,
+ FLOAT32_LT_QUIET,
+ FLOAT64_TO_INT32,
+ FLOAT64_TO_INT32_ROUND_TO_ZERO,
+ FLOAT64_TO_INT64,
+ FLOAT64_TO_INT64_ROUND_TO_ZERO,
+ FLOAT64_TO_FLOAT32,
+ FLOAT64_TO_FLOATX80,
+ FLOAT64_TO_FLOAT128,
+ FLOAT64_ROUND_TO_INT,
+ FLOAT64_ADD,
+ FLOAT64_SUB,
+ FLOAT64_MUL,
+ FLOAT64_DIV,
+ FLOAT64_REM,
+ FLOAT64_SQRT,
+ FLOAT64_EQ,
+ FLOAT64_LE,
+ FLOAT64_LT,
+ FLOAT64_EQ_SIGNALING,
+ FLOAT64_LE_QUIET,
+ FLOAT64_LT_QUIET,
+ FLOATX80_TO_INT32,
+ FLOATX80_TO_INT32_ROUND_TO_ZERO,
+ FLOATX80_TO_INT64,
+ FLOATX80_TO_INT64_ROUND_TO_ZERO,
+ FLOATX80_TO_FLOAT32,
+ FLOATX80_TO_FLOAT64,
+ FLOATX80_TO_FLOAT128,
+ FLOATX80_ROUND_TO_INT,
+ FLOATX80_ADD,
+ FLOATX80_SUB,
+ FLOATX80_MUL,
+ FLOATX80_DIV,
+ FLOATX80_REM,
+ FLOATX80_SQRT,
+ FLOATX80_EQ,
+ FLOATX80_LE,
+ FLOATX80_LT,
+ FLOATX80_EQ_SIGNALING,
+ FLOATX80_LE_QUIET,
+ FLOATX80_LT_QUIET,
+ FLOAT128_TO_INT32,
+ FLOAT128_TO_INT32_ROUND_TO_ZERO,
+ FLOAT128_TO_INT64,
+ FLOAT128_TO_INT64_ROUND_TO_ZERO,
+ FLOAT128_TO_FLOAT32,
+ FLOAT128_TO_FLOAT64,
+ FLOAT128_TO_FLOATX80,
+ FLOAT128_ROUND_TO_INT,
+ FLOAT128_ADD,
+ FLOAT128_SUB,
+ FLOAT128_MUL,
+ FLOAT128_DIV,
+ FLOAT128_REM,
+ FLOAT128_SQRT,
+ FLOAT128_EQ,
+ FLOAT128_LE,
+ FLOAT128_LT,
+ FLOAT128_EQ_SIGNALING,
+ FLOAT128_LE_QUIET,
+ FLOAT128_LT_QUIET,
+ NUM_FUNCTIONS
+};
+
+typedef struct {
+ char *name;
+ int8 numInputs;
+ flag roundingPrecision, roundingMode;
+} functionT;
+extern const functionT functions[ NUM_FUNCTIONS ];
+extern const flag functionExists[ NUM_FUNCTIONS ];
+
+enum {
+ ROUND_NEAREST_EVEN = 1,
+ ROUND_TO_ZERO,
+ ROUND_DOWN,
+ ROUND_UP,
+ NUM_ROUNDINGMODES
+};
+
+void testFunction( uint8, int8, int8 );
+
View
143 regress/lib/libc/ieeefp/testfloat/include/testLoops.h
@@ -0,0 +1,143 @@
+
+/*
+===============================================================================
+
+This C header file is part of TestFloat, Release 2a, a package of programs
+for testing the correctness of floating-point arithmetic complying to the
+IEC/IEEE Standard for Floating-Point.
+
+Written by John R. Hauser. More information is available through the Web
+page `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.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 ANY
+AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
+
+Derivative works are acceptable, even for commercial purposes, so long as
+(1) they include prominent notice that the work is derivative, and (2) they
+include prominent notice akin to these four paragraphs for those parts of
+this code that are retained.
+
+===============================================================================
+*/
+
+#include <stdio.h>
+
+extern volatile flag stop;
+
+extern char *trueName, *testName;
+extern flag forever, errorStop;
+extern uint32 maxErrorCount;
+extern flag checkNaNs;
+extern int8 *trueFlagsPtr;
+extern int8 ( *testFlagsFunctionPtr )( void );
+extern char *functionName;
+extern char *roundingPrecisionName, *roundingModeName, *tininessModeName;
+extern flag anyErrors;
+
+void writeFunctionName( FILE * );
+void exitWithStatus( void );
+
+void test_a_int32_z_float32( float32 ( int32 ), float32 ( int32 ) );
+void test_a_int32_z_float64( float64 ( int32 ), float64 ( int32 ) );
+#ifdef FLOATX80
+void test_a_int32_z_floatx80( floatx80 ( int32 ), floatx80 ( int32 ) );
+#endif
+#ifdef FLOAT128
+void test_a_int32_z_float128( float128 ( int32 ), float128 ( int32 ) );
+#endif
+#ifdef BITS64
+void test_a_int64_z_float32( float32 ( int64 ), float32 ( int64 ) );
+void test_a_int64_z_float64( float64 ( int64 ), float64 ( int64 ) );
+#ifdef FLOATX80
+void test_a_int64_z_floatx80( floatx80 ( int64 ), floatx80 ( int64 ) );
+#endif
+#ifdef FLOAT128
+void test_a_int64_z_float128( float128 ( int64 ), float128 ( int64 ) );
+#endif
+#endif
+
+void test_a_float32_z_int32( int32 ( float32 ), int32 ( float32 ) );
+#ifdef BITS64
+void test_a_float32_z_int64( int64 ( float32 ), int64 ( float32 ) );
+#endif
+void test_a_float32_z_float64( float64 ( float32 ), float64 ( float32 ) );
+#ifdef FLOATX80
+void test_a_float32_z_floatx80( floatx80 ( float32 ), floatx80 ( float32 ) );
+#endif
+#ifdef FLOAT128
+void test_a_float32_z_float128( float128 ( float32 ), float128 ( float32 ) );
+#endif
+void test_az_float32( float32 ( float32 ), float32 ( float32 ) );
+void
+ test_ab_float32_z_flag(
+ flag ( float32, float32 ), flag ( float32, float32 ) );
+void
+ test_abz_float32(
+ float32 ( float32, float32 ), float32 ( float32, float32 ) );
+
+void test_a_float64_z_int32( int32 ( float64 ), int32 ( float64 ) );
+#ifdef BITS64
+void test_a_float64_z_int64( int64 ( float64 ), int64 ( float64 ) );
+#endif
+void test_a_float64_z_float32( float32 ( float64 ), float32 ( float64 ) );
+#ifdef FLOATX80
+void test_a_float64_z_floatx80( floatx80 ( float64 ), floatx80 ( float64 ) );
+#endif
+#ifdef FLOAT128
+void test_a_float64_z_float128( float128 ( float64 ), float128 ( float64 ) );
+#endif
+void test_az_float64( float64 ( float64 ), float64 ( float64 ) );
+void
+ test_ab_float64_z_flag(
+ flag ( float64, float64 ), flag ( float64, float64 ) );
+void
+ test_abz_float64(
+ float64 ( float64, float64 ), float64 ( float64, float64 ) );
+
+#ifdef FLOATX80
+
+void test_a_floatx80_z_int32( int32 ( floatx80 ), int32 ( floatx80 ) );
+#ifdef BITS64
+void test_a_floatx80_z_int64( int64 ( floatx80 ), int64 ( floatx80 ) );
+#endif
+void test_a_floatx80_z_float32( float32 ( floatx80 ), float32 ( floatx80 ) );
+void test_a_floatx80_z_float64( float64 ( floatx80 ), float64 ( floatx80 ) );
+#ifdef FLOAT128
+void
+ test_a_floatx80_z_float128( float128 ( floatx80 ), float128 ( floatx80 ) );
+#endif
+void test_az_floatx80( floatx80 ( floatx80 ), floatx80 ( floatx80 ) );
+void
+ test_ab_floatx80_z_flag(
+ flag ( floatx80, floatx80 ), flag ( floatx80, floatx80 ) );
+void
+ test_abz_floatx80(
+ floatx80 ( floatx80, floatx80 ), floatx80 ( floatx80, floatx80 ) );
+
+#endif
+
+#ifdef FLOAT128
+
+void test_a_float128_z_int32( int32 ( float128 ), int32 ( float128 ) );
+#ifdef BITS64
+void test_a_float128_z_int64( int64 ( float128 ), int64 ( float128 ) );
+#endif
+void test_a_float128_z_float32( float32 ( float128 ), float32 ( float128 ) );
+void test_a_float128_z_float64( float64 ( float128 ), float64 ( float128 ) );
+#ifdef FLOATX80
+void
+ test_a_float128_z_floatx80( floatx80 ( float128 ), floatx80 ( float128 ) );
+#endif
+void test_az_float128( float128 ( float128 ), float128 ( float128 ) );
+void
+ test_ab_float128_z_flag(
+ flag ( float128, float128 ), flag ( float128, float128 ) );
+void
+ test_abz_float128(
+ float128 ( float128, float128 ), float128 ( float128, float128 ) );
+
+#endif
+
View
42 regress/lib/libc/ieeefp/testfloat/include/writeHex.h
@@ -0,0 +1,42 @@
+
+/*
+===============================================================================
+
+This C header file is part of TestFloat, Release 2a, a package of programs
+for testing the correctness of floating-point arithmetic complying to the
+IEC/IEEE Standard for Floating-Point.
+
+Written by John R. Hauser. More information is available through the Web
+page `http://HTTP.CS.Berkeley.EDU/~jhauser/arithmetic/TestFloat.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 ANY
+AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
+
+Derivative works are acceptable, even for commercial purposes, so long as
+(1) they include prominent notice that the work is derivative, and (2) they
+include prominent notice akin to these four paragraphs for those parts of
+this code that are retained.
+
+===============================================================================
+*/
+
+#include <stdio.h>
+
+void writeHex_flag( flag, FILE * );
+void writeHex_bits32( bits32, FILE * );
+#ifdef BITS64
+void writeHex_bits64( bits64, FILE * );
+#endif
+void writeHex_float32( float32, FILE * );
+void writeHex_float64( float64, FILE * );
+#ifdef FLOATX80
+void writeHex_floatx80( floatx80, FILE * );
+#endif
+#ifdef FLOAT128
+void writeHex_float128( float128, FILE * );
+#endif
+void writeHex_float_flags( uint8, FILE * );
+
Please sign in to comment.
Something went wrong with that request. Please try again.