diff options
Diffstat (limited to 'testfloat/testfloat.c')
| -rw-r--r-- | testfloat/testfloat.c | 295 |
1 files changed, 295 insertions, 0 deletions
diff --git a/testfloat/testfloat.c b/testfloat/testfloat.c new file mode 100644 index 000000000000..ea9e8f4c09d6 --- /dev/null +++ b/testfloat/testfloat.c @@ -0,0 +1,295 @@ + +/* +=============================================================================== + +This C source 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 <stdlib.h> +#include <signal.h> +#include <string.h> +#include "milieu.h" +#include "fail.h" +#include "softfloat.h" +#include "testCases.h" +#include "testLoops.h" +#include "systflags.h" +#include "testFunction.h" + +static void catchSIGINT( int signalCode ) +{ + + if ( stop ) exit( EXIT_FAILURE ); + stop = TRUE; + +} + +main( int argc, char **argv ) +{ + char *argPtr; + flag functionArgument; + uint8 functionCode; + int8 operands, roundingPrecision, roundingMode; + + fail_programName = "testfloat"; + if ( argc <= 1 ) goto writeHelpMessage; + testCases_setLevel( 1 ); + trueName = "soft"; + testName = "syst"; + errorStop = FALSE; + forever = FALSE; + maxErrorCount = 20; + trueFlagsPtr = &float_exception_flags; + testFlagsFunctionPtr = syst_float_flags_clear; + tininessModeName = 0; + functionArgument = FALSE; + functionCode = 0; + operands = 0; + roundingPrecision = 0; + roundingMode = 0; + --argc; + ++argv; + while ( argc && ( argPtr = argv[ 0 ] ) ) { + if ( argPtr[ 0 ] == '-' ) ++argPtr; + if ( strcmp( argPtr, "help" ) == 0 ) { + writeHelpMessage: + fputs( +"testfloat [<option>...] <function>\n" +" <option>: (* is default)\n" +" -help --Write this message and exit.\n" +" -list --List all testable functions and exit.\n" +" -level <num> --Testing level <num> (1 or 2).\n" +" * -level 1\n" +" -errors <num> --Stop each function test after <num> errors.\n" +" * -errors 20\n" +" -errorstop --Exit after first function with any error.\n" +" -forever --Test one function repeatedly (implies `-level 2').\n" +" -checkNaNs --Check for bitwise correctness of NaN results.\n" +#ifdef FLOATX80 +" -precision32 --Only test rounding precision equivalent to float32.\n" +" -precision64 --Only test rounding precision equivalent to float64.\n" +" -precision80 --Only test maximum rounding precision.\n" +#endif +" -nearesteven --Only test rounding to nearest/even.\n" +" -tozero --Only test rounding to zero.\n" +" -down --Only test rounding down.\n" +" -up --Only test rounding up.\n" +" -tininessbefore --Underflow tininess detected before rounding.\n" +" -tininessafter --Underflow tininess detected after rounding.\n" +" <function>:\n" +" int32_to_<float> <float>_add <float>_eq\n" +" <float>_to_int32 <float>_sub <float>_le\n" +" <float>_to_int32_round_to_zero <float>_mul <float>_lt\n" +#ifdef BITS64 +" int64_to_<float> <float>_div <float>_eq_signaling\n" +" <float>_to_int64 <float>_rem <float>_le_quiet\n" +" <float>_to_int64_round_to_zero <float>_lt_quiet\n" +" <float>_to_<float>\n" +" <float>_round_to_int\n" +" <float>_sqrt\n" +#else +" <float>_to_<float> <float>_div <float>_eq_signaling\n" +" <float>_round_to_int <float>_rem <float>_le_quiet\n" +" <float>_sqrt <float>_lt_quiet\n" +#endif +" -all1 --All 1-operand functions.\n" +" -all2 --All 2-operand functions.\n" +" -all --All functions.\n" +" <float>:\n" +" float32 --Single precision.\n" +" float64 --Double precision.\n" +#ifdef FLOATX80 +" floatx80 --Extended double precision.\n" +#endif +#ifdef FLOAT128 +" float128 --Quadruple precision.\n" +#endif + , + stdout + ); + return EXIT_SUCCESS; + } + else if ( strcmp( argPtr, "list" ) == 0 ) { + for ( functionCode = 1; + functionCode < NUM_FUNCTIONS; + ++functionCode + ) { + if ( functionExists[ functionCode ] ) { + puts( functions[ functionCode ].name ); + } + } + return EXIT_SUCCESS; + } + else if ( strcmp( argPtr, "level" ) == 0 ) { + if ( argc < 2 ) goto optionError; + testCases_setLevel( atoi( argv[ 1 ] ) ); + --argc; + ++argv; + } + else if ( strcmp( argPtr, "level1" ) == 0 ) { + testCases_setLevel( 1 ); + } + else if ( strcmp( argPtr, "level2" ) == 0 ) { + testCases_setLevel( 2 ); + } + else if ( strcmp( argPtr, "errors" ) == 0 ) { + if ( argc < 2 ) { + optionError: + fail( "`%s' option requires numeric argument", argv[ 0 ] ); + } + maxErrorCount = atoi( argv[ 1 ] ); + --argc; + ++argv; + } + else if ( strcmp( argPtr, "errorstop" ) == 0 ) { + errorStop = TRUE; + } + else if ( strcmp( argPtr, "forever" ) == 0 ) { + testCases_setLevel( 2 ); + forever = TRUE; + } + else if ( ( strcmp( argPtr, "checkNaNs" ) == 0 ) + || ( strcmp( argPtr, "checknans" ) == 0 ) ) { + checkNaNs = TRUE; + } +#ifdef FLOATX80 + else if ( strcmp( argPtr, "precision32" ) == 0 ) { + roundingPrecision = 32; + } + else if ( strcmp( argPtr, "precision64" ) == 0 ) { + roundingPrecision = 64; + } + else if ( strcmp( argPtr, "precision80" ) == 0 ) { + roundingPrecision = 80; + } +#endif + else if ( ( strcmp( argPtr, "nearesteven" ) == 0 ) + || ( strcmp( argPtr, "nearest_even" ) == 0 ) ) { + roundingMode = ROUND_NEAREST_EVEN; + } + else if ( ( strcmp( argPtr, "tozero" ) == 0 ) + || ( strcmp( argPtr, "to_zero" ) == 0 ) ) { + roundingMode = ROUND_TO_ZERO; + } + else if ( strcmp( argPtr, "down" ) == 0 ) { + roundingMode = ROUND_DOWN; + } + else if ( strcmp( argPtr, "up" ) == 0 ) { + roundingMode = ROUND_UP; + } + else if ( strcmp( argPtr, "tininessbefore" ) == 0 ) { + float_detect_tininess = float_tininess_before_rounding; + } + else if ( strcmp( argPtr, "tininessafter" ) == 0 ) { + float_detect_tininess = float_tininess_after_rounding; + } + else if ( strcmp( argPtr, "all1" ) == 0 ) { + functionArgument = TRUE; + functionCode = 0; + operands = 1; + } + else if ( strcmp( argPtr, "all2" ) == 0 ) { + functionArgument = TRUE; + functionCode = 0; + operands = 2; + } + else if ( strcmp( argPtr, "all" ) == 0 ) { + functionArgument = TRUE; + functionCode = 0; + operands = 0; + } + else { + for ( functionCode = 1; + functionCode < NUM_FUNCTIONS; + ++functionCode + ) { + if ( strcmp( argPtr, functions[ functionCode ].name ) == 0 ) { + break; + } + } + if ( functionCode == NUM_FUNCTIONS ) { + fail( "Invalid option or function `%s'", argv[ 0 ] ); + } + if ( ! functionExists[ functionCode ] ) { + fail( + "Function `%s' is not supported or cannot be tested", + argPtr + ); + } + functionArgument = TRUE; + } + --argc; + ++argv; + } + if ( ! functionArgument ) fail( "Function argument required" ); + (void) signal( SIGINT, catchSIGINT ); + (void) signal( SIGTERM, catchSIGINT ); + if ( functionCode ) { + if ( forever ) { + if ( ! roundingPrecision ) roundingPrecision = 80; + if ( ! roundingMode ) roundingMode = ROUND_NEAREST_EVEN; + } + testFunction( functionCode, roundingPrecision, roundingMode ); + } + else { + if ( forever ) { + fail( "Can only test one function with `-forever' option" ); + } + if ( operands == 1 ) { + for ( functionCode = 1; + functionCode < NUM_FUNCTIONS; + ++functionCode + ) { + if ( functionExists[ functionCode ] + && ( functions[ functionCode ].numInputs == 1 ) ) { + testFunction( + functionCode, roundingPrecision, roundingMode ); + } + } + } + else if ( operands == 2 ) { + for ( functionCode = 1; + functionCode < NUM_FUNCTIONS; + ++functionCode + ) { + if ( functionExists[ functionCode ] + && ( functions[ functionCode ].numInputs == 2 ) ) { + testFunction( + functionCode, roundingPrecision, roundingMode ); + } + } + } + else { + for ( functionCode = 1; + functionCode < NUM_FUNCTIONS; + ++functionCode + ) { + if ( functionExists[ functionCode ] ) { + testFunction( + functionCode, roundingPrecision, roundingMode ); + } + } + } + } + exitWithStatus(); + +} + |