int 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(); }
static void testFunctionVariety( uint8 functionCode, int8 roundingPrecision, int8 roundingMode ) { uint8 roundingCode; functionName = functions[ functionCode ].name; #ifdef FLOATX80 if ( roundingPrecision == 32 ) { roundingPrecisionName = "32"; } else if ( roundingPrecision == 64 ) { roundingPrecisionName = "64"; } else if ( roundingPrecision == 80 ) { roundingPrecisionName = "80"; } else { roundingPrecision = 80; roundingPrecisionName = 0; } floatx80_rounding_precision = roundingPrecision; syst_float_set_rounding_precision( roundingPrecision ); #endif switch ( roundingMode ) { case ROUND_NEAREST_EVEN: roundingModeName = "nearest_even"; roundingCode = float_round_nearest_even; break; case ROUND_TO_ZERO: roundingModeName = "to_zero"; roundingCode = float_round_to_zero; break; case ROUND_DOWN: roundingModeName = "down"; roundingCode = float_round_down; break; case ROUND_UP: roundingModeName = "up"; roundingCode = float_round_up; break; default: roundingModeName = 0; roundingCode = float_round_nearest_even; break; } float_rounding_mode = roundingCode; syst_float_set_rounding_mode( roundingCode ); printf( "Testing "/*, stderr*/ ); writeFunctionName( /*stderr*/ ); printf( ".\n" /*, stderr*/ ); switch ( functionCode ) { #ifdef SYST_INT32_TO_FLOAT32 case INT32_TO_FLOAT32: test_a_int32_z_float32( int32_to_float32, syst_int32_to_float32 ); break; #endif #ifdef SYST_INT32_TO_FLOAT64 case INT32_TO_FLOAT64: test_a_int32_z_float64( int32_to_float64, syst_int32_to_float64 ); break; #endif #ifdef SYST_INT32_TO_FLOATX80 case INT32_TO_FLOATX80: test_a_int32_z_floatx80( int32_to_floatx80, syst_int32_to_floatx80 ); break; #endif #ifdef SYST_INT32_TO_FLOAT128 case INT32_TO_FLOAT128: test_a_int32_z_float128( int32_to_float128, syst_int32_to_float128 ); break; #endif #ifdef SYST_INT64_TO_FLOAT32 case INT64_TO_FLOAT32: test_a_int64_z_float32( int64_to_float32, syst_int64_to_float32 ); break; #endif #ifdef SYST_INT64_TO_FLOAT64 case INT64_TO_FLOAT64: test_a_int64_z_float64( int64_to_float64, syst_int64_to_float64 ); break; #endif #ifdef SYST_INT64_TO_FLOATX80 case INT64_TO_FLOATX80: test_a_int64_z_floatx80( int64_to_floatx80, syst_int64_to_floatx80 ); break; #endif #ifdef SYST_INT64_TO_FLOAT128 case INT64_TO_FLOAT128: test_a_int64_z_float128( int64_to_float128, syst_int64_to_float128 ); break; #endif #ifdef SYST_FLOAT32_TO_INT32 case FLOAT32_TO_INT32: test_a_float32_z_int32( float32_to_int32, syst_float32_to_int32 ); break; #endif #ifdef SYST_FLOAT32_TO_INT32_ROUND_TO_ZERO case FLOAT32_TO_INT32_ROUND_TO_ZERO: syst_float_set_rounding_mode(float_round_to_zero); test_a_float32_z_int32( float32_to_int32_round_to_zero, syst_float32_to_int32_round_to_zero ); break; #endif #ifdef SYST_FLOAT32_TO_INT64 case FLOAT32_TO_INT64: test_a_float32_z_int64( float32_to_int64, syst_float32_to_int64 ); break; #endif #ifdef SYST_FLOAT32_TO_INT64_ROUND_TO_ZERO case FLOAT32_TO_INT64_ROUND_TO_ZERO: test_a_float32_z_int64( float32_to_int64_round_to_zero, syst_float32_to_int64_round_to_zero ); break; #endif #ifdef SYST_FLOAT32_TO_FLOAT64 case FLOAT32_TO_FLOAT64: test_a_float32_z_float64( float32_to_float64, syst_float32_to_float64 ); break; #endif #ifdef SYST_FLOAT32_TO_FLOATX80 case FLOAT32_TO_FLOATX80: test_a_float32_z_floatx80( float32_to_floatx80, syst_float32_to_floatx80 ); break; #endif #ifdef SYST_FLOAT32_TO_FLOAT128 case FLOAT32_TO_FLOAT128: test_a_float32_z_float128( float32_to_float128, syst_float32_to_float128 ); break; #endif #ifdef SYST_FLOAT32_ROUND_TO_INT case FLOAT32_ROUND_TO_INT: test_az_float32( float32_round_to_int, syst_float32_round_to_int ); break; #endif #ifdef SYST_FLOAT32_ADD case FLOAT32_ADD: test_abz_float32( float32_add, syst_float32_add ); break; #endif #ifdef SYST_FLOAT32_SUB case FLOAT32_SUB: test_abz_float32( float32_sub, syst_float32_sub ); break; #endif #ifdef SYST_FLOAT32_MUL case FLOAT32_MUL: test_abz_float32( float32_mul, syst_float32_mul ); break; #endif #ifdef SYST_FLOAT32_DIV case FLOAT32_DIV: test_abz_float32( float32_div, syst_float32_div ); break; #endif #ifdef SYST_FLOAT32_REM case FLOAT32_REM: test_abz_float32( float32_rem, syst_float32_rem ); break; #endif #ifdef SYST_FLOAT32_SQRT case FLOAT32_SQRT: test_az_float32( float32_sqrt, syst_float32_sqrt ); break; #endif #ifdef SYST_FLOAT32_EQ case FLOAT32_EQ: test_ab_float32_z_flag( float32_eq, syst_float32_eq ); break; #endif #ifdef SYST_FLOAT32_LE case FLOAT32_LE: test_ab_float32_z_flag( float32_le, syst_float32_le ); break; #endif #ifdef SYST_FLOAT32_LT case FLOAT32_LT: test_ab_float32_z_flag( float32_lt, syst_float32_lt ); break; #endif #ifdef SYST_FLOAT32_EQ_SIGNALING case FLOAT32_EQ_SIGNALING: test_ab_float32_z_flag( float32_eq_signaling, syst_float32_eq_signaling ); break; #endif #ifdef SYST_FLOAT32_LE_QUIET case FLOAT32_LE_QUIET: test_ab_float32_z_flag( float32_le_quiet, syst_float32_le_quiet ); break; #endif #ifdef SYST_FLOAT32_LT_QUIET case FLOAT32_LT_QUIET: test_ab_float32_z_flag( float32_lt_quiet, syst_float32_lt_quiet ); break; #endif #ifdef SYST_FLOAT64_TO_INT32 case FLOAT64_TO_INT32: test_a_float64_z_int32( float64_to_int32, syst_float64_to_int32 ); break; #endif #ifdef SYST_FLOAT64_TO_INT32_ROUND_TO_ZERO case FLOAT64_TO_INT32_ROUND_TO_ZERO: test_a_float64_z_int32( float64_to_int32_round_to_zero, syst_float64_to_int32_round_to_zero ); break; #endif #ifdef SYST_FLOAT64_TO_INT64 case FLOAT64_TO_INT64: test_a_float64_z_int64( float64_to_int64, syst_float64_to_int64 ); break; #endif #ifdef SYST_FLOAT64_TO_INT64_ROUND_TO_ZERO case FLOAT64_TO_INT64_ROUND_TO_ZERO: test_a_float64_z_int64( float64_to_int64_round_to_zero, syst_float64_to_int64_round_to_zero ); break; #endif #ifdef SYST_FLOAT64_TO_FLOAT32 case FLOAT64_TO_FLOAT32: test_a_float64_z_float32( float64_to_float32, syst_float64_to_float32 ); break; #endif #ifdef SYST_FLOAT64_TO_FLOATX80 case FLOAT64_TO_FLOATX80: test_a_float64_z_floatx80( float64_to_floatx80, syst_float64_to_floatx80 ); break; #endif #ifdef SYST_FLOAT64_TO_FLOAT128 case FLOAT64_TO_FLOAT128: test_a_float64_z_float128( float64_to_float128, syst_float64_to_float128 ); break; #endif #ifdef SYST_FLOAT64_ROUND_TO_INT case FLOAT64_ROUND_TO_INT: test_az_float64( float64_round_to_int, syst_float64_round_to_int ); break; #endif #ifdef SYST_FLOAT64_ADD case FLOAT64_ADD: test_abz_float64( float64_add, syst_float64_add ); break; #endif #ifdef SYST_FLOAT64_SUB case FLOAT64_SUB: test_abz_float64( float64_sub, syst_float64_sub ); break; #endif #ifdef SYST_FLOAT64_MUL case FLOAT64_MUL: test_abz_float64( float64_mul, syst_float64_mul ); break; #endif #ifdef SYST_FLOAT64_DIV case FLOAT64_DIV: test_abz_float64( float64_div, syst_float64_div ); break; #endif #ifdef SYST_FLOAT64_REM case FLOAT64_REM: test_abz_float64( float64_rem, syst_float64_rem ); break; #endif #ifdef SYST_FLOAT64_SQRT case FLOAT64_SQRT: test_az_float64( float64_sqrt, syst_float64_sqrt ); break; #endif #ifdef SYST_FLOAT64_EQ case FLOAT64_EQ: test_ab_float64_z_flag( float64_eq, syst_float64_eq ); break; #endif #ifdef SYST_FLOAT64_LE case FLOAT64_LE: test_ab_float64_z_flag( float64_le, syst_float64_le ); break; #endif #ifdef SYST_FLOAT64_LT case FLOAT64_LT: test_ab_float64_z_flag( float64_lt, syst_float64_lt ); break; #endif #ifdef SYST_FLOAT64_EQ_SIGNALING case FLOAT64_EQ_SIGNALING: test_ab_float64_z_flag( float64_eq_signaling, syst_float64_eq_signaling ); break; #endif #ifdef SYST_FLOAT64_LE_QUIET case FLOAT64_LE_QUIET: test_ab_float64_z_flag( float64_le_quiet, syst_float64_le_quiet ); break; #endif #ifdef SYST_FLOAT64_LT_QUIET case FLOAT64_LT_QUIET: test_ab_float64_z_flag( float64_lt_quiet, syst_float64_lt_quiet ); break; #endif #ifdef SYST_FLOATX80_TO_INT32 case FLOATX80_TO_INT32: test_a_floatx80_z_int32( floatx80_to_int32, syst_floatx80_to_int32 ); break; #endif #ifdef SYST_FLOATX80_TO_INT32_ROUND_TO_ZERO case FLOATX80_TO_INT32_ROUND_TO_ZERO: test_a_floatx80_z_int32( floatx80_to_int32_round_to_zero, syst_floatx80_to_int32_round_to_zero ); break; #endif #ifdef SYST_FLOATX80_TO_INT64 case FLOATX80_TO_INT64: test_a_floatx80_z_int64( floatx80_to_int64, syst_floatx80_to_int64 ); break; #endif #ifdef SYST_FLOATX80_TO_INT64_ROUND_TO_ZERO case FLOATX80_TO_INT64_ROUND_TO_ZERO: test_a_floatx80_z_int64( floatx80_to_int64_round_to_zero, syst_floatx80_to_int64_round_to_zero ); break; #endif #ifdef SYST_FLOATX80_TO_FLOAT32 case FLOATX80_TO_FLOAT32: test_a_floatx80_z_float32( floatx80_to_float32, syst_floatx80_to_float32 ); break; #endif #ifdef SYST_FLOATX80_TO_FLOAT64 case FLOATX80_TO_FLOAT64: test_a_floatx80_z_float64( floatx80_to_float64, syst_floatx80_to_float64 ); break; #endif #ifdef SYST_FLOATX80_TO_FLOAT128 case FLOATX80_TO_FLOAT128: test_a_floatx80_z_float128( floatx80_to_float128, syst_floatx80_to_float128 ); break; #endif #ifdef SYST_FLOATX80_ROUND_TO_INT case FLOATX80_ROUND_TO_INT: test_az_floatx80( floatx80_round_to_int, syst_floatx80_round_to_int ); break; #endif #ifdef SYST_FLOATX80_ADD case FLOATX80_ADD: test_abz_floatx80( floatx80_add, syst_floatx80_add ); break; #endif #ifdef SYST_FLOATX80_SUB case FLOATX80_SUB: test_abz_floatx80( floatx80_sub, syst_floatx80_sub ); break; #endif #ifdef SYST_FLOATX80_MUL case FLOATX80_MUL: test_abz_floatx80( floatx80_mul, syst_floatx80_mul ); break; #endif #ifdef SYST_FLOATX80_DIV case FLOATX80_DIV: test_abz_floatx80( floatx80_div, syst_floatx80_div ); break; #endif #ifdef SYST_FLOATX80_REM case FLOATX80_REM: test_abz_floatx80( floatx80_rem, syst_floatx80_rem ); break; #endif #ifdef SYST_FLOATX80_SQRT case FLOATX80_SQRT: test_az_floatx80( floatx80_sqrt, syst_floatx80_sqrt ); break; #endif #ifdef SYST_FLOATX80_EQ case FLOATX80_EQ: test_ab_floatx80_z_flag( floatx80_eq, syst_floatx80_eq ); break; #endif #ifdef SYST_FLOATX80_LE case FLOATX80_LE: test_ab_floatx80_z_flag( floatx80_le, syst_floatx80_le ); break; #endif #ifdef SYST_FLOATX80_LT case FLOATX80_LT: test_ab_floatx80_z_flag( floatx80_lt, syst_floatx80_lt ); break; #endif #ifdef SYST_FLOATX80_EQ_SIGNALING case FLOATX80_EQ_SIGNALING: test_ab_floatx80_z_flag( floatx80_eq_signaling, syst_floatx80_eq_signaling ); break; #endif #ifdef SYST_FLOATX80_LE_QUIET case FLOATX80_LE_QUIET: test_ab_floatx80_z_flag( floatx80_le_quiet, syst_floatx80_le_quiet ); break; #endif #ifdef SYST_FLOATX80_LT_QUIET case FLOATX80_LT_QUIET: test_ab_floatx80_z_flag( floatx80_lt_quiet, syst_floatx80_lt_quiet ); break; #endif #ifdef SYST_FLOAT128_TO_INT32 case FLOAT128_TO_INT32: test_a_float128_z_int32( float128_to_int32, syst_float128_to_int32 ); break; #endif #ifdef SYST_FLOAT128_TO_INT32_ROUND_TO_ZERO case FLOAT128_TO_INT32_ROUND_TO_ZERO: test_a_float128_z_int32( float128_to_int32_round_to_zero, syst_float128_to_int32_round_to_zero ); break; #endif #ifdef SYST_FLOAT128_TO_INT64 case FLOAT128_TO_INT64: test_a_float128_z_int64( float128_to_int64, syst_float128_to_int64 ); break; #endif #ifdef SYST_FLOAT128_TO_INT64_ROUND_TO_ZERO case FLOAT128_TO_INT64_ROUND_TO_ZERO: test_a_float128_z_int64( float128_to_int64_round_to_zero, syst_float128_to_int64_round_to_zero ); break; #endif #ifdef SYST_FLOAT128_TO_FLOAT32 case FLOAT128_TO_FLOAT32: test_a_float128_z_float32( float128_to_float32, syst_float128_to_float32 ); break; #endif #ifdef SYST_FLOAT128_TO_FLOAT64 case FLOAT128_TO_FLOAT64: test_a_float128_z_float64( float128_to_float64, syst_float128_to_float64 ); break; #endif #ifdef SYST_FLOAT128_TO_FLOATX80 case FLOAT128_TO_FLOATX80: test_a_float128_z_floatx80( float128_to_floatx80, syst_float128_to_floatx80 ); break; #endif #ifdef SYST_FLOAT128_ROUND_TO_INT case FLOAT128_ROUND_TO_INT: test_az_float128( float128_round_to_int, syst_float128_round_to_int ); break; #endif #ifdef SYST_FLOAT128_ADD case FLOAT128_ADD: test_abz_float128( float128_add, syst_float128_add ); break; #endif #ifdef SYST_FLOAT128_SUB case FLOAT128_SUB: test_abz_float128( float128_sub, syst_float128_sub ); break; #endif #ifdef SYST_FLOAT128_MUL case FLOAT128_MUL: test_abz_float128( float128_mul, syst_float128_mul ); break; #endif #ifdef SYST_FLOAT128_DIV case FLOAT128_DIV: test_abz_float128( float128_div, syst_float128_div ); break; #endif #ifdef SYST_FLOAT128_REM case FLOAT128_REM: test_abz_float128( float128_rem, syst_float128_rem ); break; #endif #ifdef SYST_FLOAT128_SQRT case FLOAT128_SQRT: test_az_float128( float128_sqrt, syst_float128_sqrt ); break; #endif #ifdef SYST_FLOAT128_EQ case FLOAT128_EQ: test_ab_float128_z_flag( float128_eq, syst_float128_eq ); break; #endif #ifdef SYST_FLOAT128_LE case FLOAT128_LE: test_ab_float128_z_flag( float128_le, syst_float128_le ); break; #endif #ifdef SYST_FLOAT128_LT case FLOAT128_LT: test_ab_float128_z_flag( float128_lt, syst_float128_lt ); break; #endif #ifdef SYST_FLOAT128_EQ_SIGNALING case FLOAT128_EQ_SIGNALING: test_ab_float128_z_flag( float128_eq_signaling, syst_float128_eq_signaling ); break; #endif #ifdef SYST_FLOAT128_LE_QUIET case FLOAT128_LE_QUIET: test_ab_float128_z_flag( float128_le_quiet, syst_float128_le_quiet ); break; #endif #ifdef SYST_FLOAT128_LT_QUIET case FLOAT128_LT_QUIET: test_ab_float128_z_flag( float128_lt_quiet, syst_float128_lt_quiet ); break; #endif } if ( ( errorStop && anyErrors ) || stop ) exitWithStatus(); }
static void testFunctionVariety( uint8 functionCode, int8 roundingPrecision, int8 roundingMode, int8 tininessMode ) { uint8 roundingCode; int8 tininessCode; functionName = functions[ functionCode ].name; if ( roundingPrecision == 32 ) { roundingPrecisionName = "32"; } else if ( roundingPrecision == 64 ) { roundingPrecisionName = "64"; } else if ( roundingPrecision == 80 ) { roundingPrecisionName = "80"; } else { roundingPrecisionName = 0; } #ifdef FLOATX80 floatx80_rounding_precision = roundingPrecision; slow_floatx80_rounding_precision = roundingPrecision; #endif switch ( roundingMode ) { case 0: roundingModeName = 0; roundingCode = float_round_nearest_even; break; case ROUND_NEAREST_EVEN: roundingModeName = "nearest_even"; roundingCode = float_round_nearest_even; break; case ROUND_TO_ZERO: roundingModeName = "to_zero"; roundingCode = float_round_to_zero; break; case ROUND_DOWN: roundingModeName = "down"; roundingCode = float_round_down; break; case ROUND_UP: roundingModeName = "up"; roundingCode = float_round_up; break; } float_rounding_mode = roundingCode; slow_float_rounding_mode = roundingCode; switch ( tininessMode ) { case 0: tininessModeName = 0; tininessCode = float_tininess_after_rounding; break; case TININESS_BEFORE_ROUNDING: tininessModeName = "before"; tininessCode = float_tininess_before_rounding; break; case TININESS_AFTER_ROUNDING: tininessModeName = "after"; tininessCode = float_tininess_after_rounding; break; } float_detect_tininess = tininessCode; slow_float_detect_tininess = tininessCode; fputs( "Testing ", stderr ); writeFunctionName( stderr ); fputs( ".\n", stderr ); switch ( functionCode ) { case INT32_TO_FLOAT32: test_a_int32_z_float32( slow_int32_to_float32, int32_to_float32 ); break; case INT32_TO_FLOAT64: test_a_int32_z_float64( slow_int32_to_float64, int32_to_float64 ); break; #ifdef FLOATX80 case INT32_TO_FLOATX80: test_a_int32_z_floatx80( slow_int32_to_floatx80, int32_to_floatx80 ); break; #endif #ifdef FLOAT128 case INT32_TO_FLOAT128: test_a_int32_z_float128( slow_int32_to_float128, int32_to_float128 ); break; #endif #ifdef BITS64 case INT64_TO_FLOAT32: test_a_int64_z_float32( slow_int64_to_float32, int64_to_float32 ); break; case INT64_TO_FLOAT64: test_a_int64_z_float64( slow_int64_to_float64, int64_to_float64 ); break; #ifdef FLOATX80 case INT64_TO_FLOATX80: test_a_int64_z_floatx80( slow_int64_to_floatx80, int64_to_floatx80 ); break; #endif #ifdef FLOAT128 case INT64_TO_FLOAT128: test_a_int64_z_float128( slow_int64_to_float128, int64_to_float128 ); break; #endif #endif case FLOAT32_TO_INT32: test_a_float32_z_int32( slow_float32_to_int32, float32_to_int32 ); break; case FLOAT32_TO_INT32_ROUND_TO_ZERO: test_a_float32_z_int32( slow_float32_to_int32_round_to_zero, float32_to_int32_round_to_zero ); break; #ifdef BITS64 case FLOAT32_TO_INT64: test_a_float32_z_int64( slow_float32_to_int64, float32_to_int64 ); break; case FLOAT32_TO_INT64_ROUND_TO_ZERO: test_a_float32_z_int64( slow_float32_to_int64_round_to_zero, float32_to_int64_round_to_zero ); break; #endif case FLOAT32_TO_FLOAT64: test_a_float32_z_float64( slow_float32_to_float64, float32_to_float64 ); break; #ifdef FLOATX80 case FLOAT32_TO_FLOATX80: test_a_float32_z_floatx80( slow_float32_to_floatx80, float32_to_floatx80 ); break; #endif #ifdef FLOAT128 case FLOAT32_TO_FLOAT128: test_a_float32_z_float128( slow_float32_to_float128, float32_to_float128 ); break; #endif case FLOAT32_ROUND_TO_INT: test_az_float32( slow_float32_round_to_int, float32_round_to_int ); break; case FLOAT32_ADD: test_abz_float32( slow_float32_add, float32_add ); break; case FLOAT32_SUB: test_abz_float32( slow_float32_sub, float32_sub ); break; case FLOAT32_MUL: test_abz_float32( slow_float32_mul, float32_mul ); break; case FLOAT32_DIV: test_abz_float32( slow_float32_div, float32_div ); break; case FLOAT32_REM: test_abz_float32( slow_float32_rem, float32_rem ); break; case FLOAT32_SQRT: test_az_float32( slow_float32_sqrt, float32_sqrt ); break; case FLOAT32_EQ: test_ab_float32_z_flag( slow_float32_eq, float32_eq ); break; case FLOAT32_LE: test_ab_float32_z_flag( slow_float32_le, float32_le ); break; case FLOAT32_LT: test_ab_float32_z_flag( slow_float32_lt, float32_lt ); break; case FLOAT32_EQ_SIGNALING: test_ab_float32_z_flag( slow_float32_eq_signaling, float32_eq_signaling ); break; case FLOAT32_LE_QUIET: test_ab_float32_z_flag( slow_float32_le_quiet, float32_le_quiet ); break; case FLOAT32_LT_QUIET: test_ab_float32_z_flag( slow_float32_lt_quiet, float32_lt_quiet ); break; case FLOAT64_TO_INT32: test_a_float64_z_int32( slow_float64_to_int32, float64_to_int32 ); break; case FLOAT64_TO_INT32_ROUND_TO_ZERO: test_a_float64_z_int32( slow_float64_to_int32_round_to_zero, float64_to_int32_round_to_zero ); break; #ifdef BITS64 case FLOAT64_TO_INT64: test_a_float64_z_int64( slow_float64_to_int64, float64_to_int64 ); break; case FLOAT64_TO_INT64_ROUND_TO_ZERO: test_a_float64_z_int64( slow_float64_to_int64_round_to_zero, float64_to_int64_round_to_zero ); break; #endif case FLOAT64_TO_FLOAT32: test_a_float64_z_float32( slow_float64_to_float32, float64_to_float32 ); break; #ifdef FLOATX80 case FLOAT64_TO_FLOATX80: test_a_float64_z_floatx80( slow_float64_to_floatx80, float64_to_floatx80 ); break; #endif #ifdef FLOAT128 case FLOAT64_TO_FLOAT128: test_a_float64_z_float128( slow_float64_to_float128, float64_to_float128 ); break; #endif case FLOAT64_ROUND_TO_INT: test_az_float64( slow_float64_round_to_int, float64_round_to_int ); break; case FLOAT64_ADD: test_abz_float64( slow_float64_add, float64_add ); break; case FLOAT64_SUB: test_abz_float64( slow_float64_sub, float64_sub ); break; case FLOAT64_MUL: test_abz_float64( slow_float64_mul, float64_mul ); break; case FLOAT64_DIV: test_abz_float64( slow_float64_div, float64_div ); break; case FLOAT64_REM: test_abz_float64( slow_float64_rem, float64_rem ); break; case FLOAT64_SQRT: test_az_float64( slow_float64_sqrt, float64_sqrt ); break; case FLOAT64_EQ: test_ab_float64_z_flag( slow_float64_eq, float64_eq ); break; case FLOAT64_LE: test_ab_float64_z_flag( slow_float64_le, float64_le ); break; case FLOAT64_LT: test_ab_float64_z_flag( slow_float64_lt, float64_lt ); break; case FLOAT64_EQ_SIGNALING: test_ab_float64_z_flag( slow_float64_eq_signaling, float64_eq_signaling ); break; case FLOAT64_LE_QUIET: test_ab_float64_z_flag( slow_float64_le_quiet, float64_le_quiet ); break; case FLOAT64_LT_QUIET: test_ab_float64_z_flag( slow_float64_lt_quiet, float64_lt_quiet ); break; #ifdef FLOATX80 case FLOATX80_TO_INT32: test_a_floatx80_z_int32( slow_floatx80_to_int32, floatx80_to_int32 ); break; case FLOATX80_TO_INT32_ROUND_TO_ZERO: test_a_floatx80_z_int32( slow_floatx80_to_int32_round_to_zero, floatx80_to_int32_round_to_zero ); break; #ifdef BITS64 case FLOATX80_TO_INT64: test_a_floatx80_z_int64( slow_floatx80_to_int64, floatx80_to_int64 ); break; case FLOATX80_TO_INT64_ROUND_TO_ZERO: test_a_floatx80_z_int64( slow_floatx80_to_int64_round_to_zero, floatx80_to_int64_round_to_zero ); break; #endif case FLOATX80_TO_FLOAT32: test_a_floatx80_z_float32( slow_floatx80_to_float32, floatx80_to_float32 ); break; case FLOATX80_TO_FLOAT64: test_a_floatx80_z_float64( slow_floatx80_to_float64, floatx80_to_float64 ); break; #ifdef FLOAT128 case FLOATX80_TO_FLOAT128: test_a_floatx80_z_float128( slow_floatx80_to_float128, floatx80_to_float128 ); break; #endif case FLOATX80_ROUND_TO_INT: test_az_floatx80( slow_floatx80_round_to_int, floatx80_round_to_int ); break; case FLOATX80_ADD: test_abz_floatx80( slow_floatx80_add, floatx80_add ); break; case FLOATX80_SUB: test_abz_floatx80( slow_floatx80_sub, floatx80_sub ); break; case FLOATX80_MUL: test_abz_floatx80( slow_floatx80_mul, floatx80_mul ); break; case FLOATX80_DIV: test_abz_floatx80( slow_floatx80_div, floatx80_div ); break; case FLOATX80_REM: test_abz_floatx80( slow_floatx80_rem, floatx80_rem ); break; case FLOATX80_SQRT: test_az_floatx80( slow_floatx80_sqrt, floatx80_sqrt ); break; case FLOATX80_EQ: test_ab_floatx80_z_flag( slow_floatx80_eq, floatx80_eq ); break; case FLOATX80_LE: test_ab_floatx80_z_flag( slow_floatx80_le, floatx80_le ); break; case FLOATX80_LT: test_ab_floatx80_z_flag( slow_floatx80_lt, floatx80_lt ); break; case FLOATX80_EQ_SIGNALING: test_ab_floatx80_z_flag( slow_floatx80_eq_signaling, floatx80_eq_signaling ); break; case FLOATX80_LE_QUIET: test_ab_floatx80_z_flag( slow_floatx80_le_quiet, floatx80_le_quiet ); break; case FLOATX80_LT_QUIET: test_ab_floatx80_z_flag( slow_floatx80_lt_quiet, floatx80_lt_quiet ); break; #endif #ifdef FLOAT128 case FLOAT128_TO_INT32: test_a_float128_z_int32( slow_float128_to_int32, float128_to_int32 ); break; case FLOAT128_TO_INT32_ROUND_TO_ZERO: test_a_float128_z_int32( slow_float128_to_int32_round_to_zero, float128_to_int32_round_to_zero ); break; #ifdef BITS64 case FLOAT128_TO_INT64: test_a_float128_z_int64( slow_float128_to_int64, float128_to_int64 ); break; case FLOAT128_TO_INT64_ROUND_TO_ZERO: test_a_float128_z_int64( slow_float128_to_int64_round_to_zero, float128_to_int64_round_to_zero ); break; #endif case FLOAT128_TO_FLOAT32: test_a_float128_z_float32( slow_float128_to_float32, float128_to_float32 ); break; case FLOAT128_TO_FLOAT64: test_a_float128_z_float64( slow_float128_to_float64, float128_to_float64 ); break; #ifdef FLOATX80 case FLOAT128_TO_FLOATX80: test_a_float128_z_floatx80( slow_float128_to_floatx80, float128_to_floatx80 ); break; #endif case FLOAT128_ROUND_TO_INT: test_az_float128( slow_float128_round_to_int, float128_round_to_int ); break; case FLOAT128_ADD: test_abz_float128( slow_float128_add, float128_add ); break; case FLOAT128_SUB: test_abz_float128( slow_float128_sub, float128_sub ); break; case FLOAT128_MUL: test_abz_float128( slow_float128_mul, float128_mul ); break; case FLOAT128_DIV: test_abz_float128( slow_float128_div, float128_div ); break; case FLOAT128_REM: test_abz_float128( slow_float128_rem, float128_rem ); break; case FLOAT128_SQRT: test_az_float128( slow_float128_sqrt, float128_sqrt ); break; case FLOAT128_EQ: test_ab_float128_z_flag( slow_float128_eq, float128_eq ); break; case FLOAT128_LE: test_ab_float128_z_flag( slow_float128_le, float128_le ); break; case FLOAT128_LT: test_ab_float128_z_flag( slow_float128_lt, float128_lt ); break; case FLOAT128_EQ_SIGNALING: test_ab_float128_z_flag( slow_float128_eq_signaling, float128_eq_signaling ); break; case FLOAT128_LE_QUIET: test_ab_float128_z_flag( slow_float128_le_quiet, float128_le_quiet ); break; case FLOAT128_LT_QUIET: test_ab_float128_z_flag( slow_float128_lt_quiet, float128_lt_quiet ); break; #endif } if ( ( errorStop && anyErrors ) || stop ) exitWithStatus(); }