float32_t f32_sub( float32_t a, float32_t b ) { union ui32_f32 uA; uint_fast32_t uiA; union ui32_f32 uB; uint_fast32_t uiB; #if ! defined INLINE_LEVEL || (INLINE_LEVEL < 1) float32_t (*magsFuncPtr)( uint_fast32_t, uint_fast32_t ); #endif uA.f = a; uiA = uA.ui; uB.f = b; uiB = uB.ui; #if defined INLINE_LEVEL && (1 <= INLINE_LEVEL) if ( signF32UI( uiA ^ uiB ) ) { return softfloat_addMagsF32( uiA, uiB ); } else { return softfloat_subMagsF32( uiA, uiB ); } #else magsFuncPtr = signF32UI( uiA ^ uiB ) ? softfloat_addMagsF32 : softfloat_subMagsF32; return (*magsFuncPtr)( uiA, uiB ); #endif }
void qcms_transform_data_rgba_out_lut_neon(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length) { size_t i; unsigned char alpha; float32_t (*mat)[4] = transform->matrix; const float32_t *igtbl_r = (float32_t*)transform->input_gamma_table_r; const float32_t *igtbl_g = (float32_t*)transform->input_gamma_table_g; const float32_t *igtbl_b = (float32_t*)transform->input_gamma_table_b; const uint8_t *otdata_r = &transform->output_table_r->data[0]; const uint8_t *otdata_g = &transform->output_table_g->data[0]; const uint8_t *otdata_b = &transform->output_table_b->data[0]; const float32x4_t mat0 = vld1q_f32(mat[0]); const float32x4_t mat1 = vld1q_f32(mat[1]); const float32x4_t mat2 = vld1q_f32(mat[2]); const float32x4_t max = vld1q_dup_f32(&clampMaxValue); const float32x4_t min = vld1q_dup_f32(&zero); const float32x4_t scale = vld1q_dup_f32(&floatScale); float32x4_t vec_r, vec_g, vec_b; int32x4_t result; /* CYA */ if (!length) return; for (i = 0; i < length; i++) { /* setup for transforming the pixel */ vec_r = vld1q_dup_f32(&igtbl_r[*src++]); vec_g = vld1q_dup_f32(&igtbl_g[*src++]); vec_b = vld1q_dup_f32(&igtbl_b[*src++]); alpha = *src++; /* gamma * matrix */ vec_r = vmulq_f32(vec_r, mat0); vec_g = vmulq_f32(vec_g, mat1); vec_b = vmulq_f32(vec_b, mat2); /* crunch, crunch, crunch */ vec_r = vaddq_f32(vec_r, vaddq_f32(vec_g, vec_b)); vec_r = vmaxq_f32(min, vec_r); vec_r = vminq_f32(max, vec_r); result = vcvtq_s32_f32(vmulq_f32(vec_r, scale)); /* use calc'd indices to output RGB values */ *dest++ = otdata_r[vgetq_lane_s32(result, 0)]; *dest++ = otdata_g[vgetq_lane_s32(result, 1)]; *dest++ = otdata_b[vgetq_lane_s32(result, 2)]; *dest++ = alpha; } }
State::Shared MoveDirection::update(Player::Shared& player, Environment::Shared env, std::time_t dt) { auto fdt = Time::toSeconds(dt); auto translation = direction_ * fdt * PLAYER_SPEED; auto a = -player->transform()->z(); auto b = glm::normalize(translation); auto angle = Math::signedAngle(a, b, glm::vec3(0, 1, 0)); auto nval = std::min(angle, angle * float32_t(fdt) * PLAYER_SPEED); player->transform()->rotateGlobal(nval, glm::vec3(0, 1, 0)); player->moveAlong(translation, env); return nullptr; }
int main( int argc, char *argv[] ) { const char *prefixTextPtr; uint_fast8_t roundingMode; bool exact; int functionCode; const char *argPtr; long i; int functionAttribs; float32_t (*trueFunction_abz_f32)( float32_t, float32_t ); bool (*trueFunction_ab_f32_z_bool)( float32_t, float32_t ); float64_t (*trueFunction_abz_f64)( float64_t, float64_t ); bool (*trueFunction_ab_f64_z_bool)( float64_t, float64_t ); #ifdef EXTFLOAT80 void (*trueFunction_abz_extF80)( const extFloat80_t *, const extFloat80_t *, extFloat80_t * ); bool (*trueFunction_ab_extF80_z_bool)( const extFloat80_t *, const extFloat80_t * ); #endif #ifdef FLOAT128 void (*trueFunction_abz_f128)( const float128_t *, const float128_t *, float128_t * ); bool (*trueFunction_ab_f128_z_bool)( const float128_t *, const float128_t * ); #endif /*------------------------------------------------------------------------ *------------------------------------------------------------------------*/ fail_programName = "testfloat_gen"; if ( argc <= 1 ) goto writeHelpMessage; prefixTextPtr = 0; softfloat_detectTininess = softfloat_tininess_beforeRounding; #ifdef EXTFLOAT80 extF80_roundingPrecision = 80; #endif roundingMode = softfloat_round_near_even; exact = false; genCases_setLevel( 1 ); genLoops_trueFlagsPtr = &softfloat_exceptionFlags; genLoops_forever = false; genLoops_givenCount = false; functionCode = 0; for (;;) { --argc; if ( ! argc ) break; argPtr = *++argv; if ( ! argPtr ) break; if ( argPtr[0] == '-' ) ++argPtr; if ( ! strcmp( argPtr, "help" ) || ! strcmp( argPtr, "-help" ) || ! strcmp( argPtr, "h" ) ) { writeHelpMessage: fputs( "testfloat_gen [<option>...] <type>|<function>\n" " <option>: (* is default)\n" " -help --Write this message and exit.\n" " -prefix <text> --Write <text> as a line of output before any test cases.\n" " -level <num> --Testing level <num> (1 or 2).\n" " * -level 1\n" " -n <num> --Generate <num> test cases.\n" " -forever --Generate test cases indefinitely (implies `-level 2').\n" #ifdef EXTFLOAT80 " -precision32 --For extF80, rounding precision is 32 bits.\n" " -precision64 --For extF80, rounding precision is 64 bits.\n" " * -precision80 --For extF80, rounding precision is 80 bits.\n" #endif " * -rnear_even --Round to nearest/even.\n" " -rminMag --Round to minimum magnitude (toward zero).\n" " -rmin --Round to minimum (down).\n" " -rmax --Round to maximum (up).\n" " -rnear_maxMag --Round to nearest/maximum magnitude (nearest/away).\n" " * -tininessbefore --Detect underflow tininess before rounding.\n" " -tininessafter --Detect underflow tininess after rounding.\n" " * -notexact --Rounding to integer is not exact (no inexact\n" " exceptions).\n" " -exact --Rounding to integer is exact (raising inexact\n" " exceptions).\n" " <type>:\n" " <int> --Generate test cases with one integer operand.\n" " <float> --Generate test cases with one floating-point operand.\n" " <float> <num> --Generate test cases with <num> (1, 2, or 3)\n" " floating-point operands.\n" " <function>:\n" " <int>_to_<float> <float>_add <float>_eq\n" " <float>_to_<int> <float>_sub <float>_le\n" " <float>_to_<float> <float>_mul <float>_lt\n" " <float>_roundToInt <float>_mulAdd <float>_eq_signaling\n" " <float>_div <float>_le_quiet\n" " <float>_rem <float>_lt_quiet\n" " <float>_sqrt\n" " <int>:\n" " ui32 --Unsigned 32-bit integer.\n" " ui64 --Unsigned 64-bit integer.\n" " i32 --Signed 32-bit integer.\n" " i64 --Signed 64-bit integer.\n" " <float>:\n" " f32 --Binary 32-bit floating-point (single-precision).\n" " f64 --Binary 64-bit floating-point (double-precision).\n" #ifdef EXTFLOAT80 " extF80 --Binary 80-bit extended floating-point.\n" #endif #ifdef FLOAT128 " f128 --Binary 128-bit floating-point (quadruple-precision).\n" #endif , stdout ); return EXIT_SUCCESS; } else if ( ! strcmp( argPtr, "prefix" ) ) { if ( argc < 2 ) goto optionError; prefixTextPtr = argv[1]; --argc; ++argv; } else if ( ! strcmp( argPtr, "level" ) ) { if ( argc < 2 ) goto optionError; i = strtol( argv[1], (char **) &argPtr, 10 ); if ( *argPtr ) goto optionError; genCases_setLevel( i ); --argc; ++argv; } else if ( ! strcmp( argPtr, "level1" ) ) { genCases_setLevel( 1 ); } else if ( ! strcmp( argPtr, "level2" ) ) { genCases_setLevel( 2 ); } else if ( ! strcmp( argPtr, "n" ) ) { if ( argc < 2 ) goto optionError; genLoops_forever = true; genLoops_givenCount = true; i = strtol( argv[1], (char **) &argPtr, 10 ); if ( *argPtr ) goto optionError; genLoops_count = i; --argc; ++argv; } else if ( ! strcmp( argPtr, "forever" ) ) { genCases_setLevel( 2 ); genLoops_forever = true; genLoops_givenCount = false; #ifdef EXTFLOAT80 } else if ( ! strcmp( argPtr, "precision32" ) ) { extF80_roundingPrecision = 32; } else if ( ! strcmp( argPtr, "precision64" ) ) { extF80_roundingPrecision = 64; } else if ( ! strcmp( argPtr, "precision80" ) ) { extF80_roundingPrecision = 80; #endif } else if ( ! strcmp( argPtr, "rnear_even" ) || ! strcmp( argPtr, "rneareven" ) || ! strcmp( argPtr, "rnearest_even" ) ) { roundingMode = softfloat_round_near_even; } else if ( ! strcmp( argPtr, "rminmag" ) || ! strcmp( argPtr, "rminMag" ) ) { roundingMode = softfloat_round_minMag; } else if ( ! strcmp( argPtr, "rmin" ) ) { roundingMode = softfloat_round_min; } else if ( ! strcmp( argPtr, "rmax" ) ) { roundingMode = softfloat_round_max; } else if ( ! strcmp( argPtr, "rnear_maxmag" ) || ! strcmp( argPtr, "rnear_maxMag" ) || ! strcmp( argPtr, "rnearmaxmag" ) || ! strcmp( argPtr, "rnearest_maxmag" ) || ! strcmp( argPtr, "rnearest_maxMag" ) ) { roundingMode = softfloat_round_near_maxMag; } else if ( ! strcmp( argPtr, "tininessbefore" ) ) { softfloat_detectTininess = softfloat_tininess_beforeRounding; } else if ( ! strcmp( argPtr, "tininessafter" ) ) { softfloat_detectTininess = softfloat_tininess_afterRounding; } else if ( ! strcmp( argPtr, "notexact" ) ) { exact = false; } else if ( ! strcmp( argPtr, "exact" ) ) { exact = true; } else if ( ! strcmp( argPtr, "ui32" ) || ! strcmp( argPtr, "uint32" ) ) { functionCode = TYPE_UI32; if ( 2 <= argc ) goto absorbArg1; } else if ( ! strcmp( argPtr, "ui64" ) || ! strcmp( argPtr, "uint64" ) ) { functionCode = TYPE_UI64; if ( 2 <= argc ) goto absorbArg1; } else if ( ! strcmp( argPtr, "i32" ) || ! strcmp( argPtr, "int32" ) ) { functionCode = TYPE_I32; if ( 2 <= argc ) goto absorbArg1; } else if ( ! strcmp( argPtr, "i64" ) || ! strcmp( argPtr, "int64" ) ) { functionCode = TYPE_I64; if ( 2 <= argc ) goto absorbArg1; } else if ( ! strcmp( argPtr, "f32" ) || ! strcmp( argPtr, "float32" ) ) { functionCode = TYPE_F32; goto absorbArg; } else if ( ! strcmp( argPtr, "f64" ) || ! strcmp( argPtr, "float64" ) ) { functionCode = TYPE_F64; #ifdef EXTFLOAT80 goto absorbArg; } else if ( ! strcmp( argPtr, "extF80" ) || ! strcmp( argPtr, "extFloat80" ) ) { functionCode = TYPE_EXTF80; #endif #ifdef FLOAT128 goto absorbArg; } else if ( ! strcmp( argPtr, "f128" ) || ! strcmp( argPtr, "float128" ) ) { functionCode = TYPE_F128; #endif absorbArg: if ( 2 <= argc ) { if ( ! strcmp( argv[1], "2" ) ) { --argc; ++argv; ++functionCode; } else if ( ! strcmp( argv[1], "3" ) ) { --argc; ++argv; functionCode += 2; } else { absorbArg1: if ( ! strcmp( argv[1], "1" ) ) { --argc; ++argv; } } } } else { functionCode = 1; while ( strcmp( argPtr, functionInfos[functionCode].namePtr ) ) { ++functionCode; if ( functionCode == NUM_FUNCTIONS ) goto invalidArg; } functionAttribs = functionInfos[functionCode].attribs; if ( (functionAttribs & FUNC_ARG_EXACT) && ! (functionAttribs & FUNC_ARG_ROUNDINGMODE) ) { goto invalidArg; } } } if ( ! functionCode ) fail( "Type or function argument required" ); /*------------------------------------------------------------------------ *------------------------------------------------------------------------*/ if ( prefixTextPtr ) { fputs( prefixTextPtr, stdout ); fputc( '\n', stdout ); } softfloat_roundingMode = roundingMode; signal( SIGINT, catchSIGINT ); signal( SIGTERM, catchSIGINT ); switch ( functionCode ) { /*-------------------------------------------------------------------- *--------------------------------------------------------------------*/ case TYPE_UI32: gen_a_ui32(); break; case TYPE_UI64: gen_a_ui64(); break; case TYPE_I32: gen_a_i32(); break; case TYPE_I64: gen_a_i64(); break; case TYPE_F32: gen_a_f32(); break; case TYPE_F32_2: gen_ab_f32(); break; case TYPE_F32_3: gen_abc_f32(); break; case TYPE_F64: gen_a_f64(); break; case TYPE_F64_2: gen_ab_f64(); break; case TYPE_F64_3: gen_abc_f64(); break; #ifdef EXTFLOAT80 case TYPE_EXTF80: gen_a_extF80(); break; case TYPE_EXTF80_2: gen_ab_extF80(); break; case TYPE_EXTF80_3: gen_abc_extF80(); break; #endif #ifdef FLOAT128 case TYPE_F128: gen_a_f128(); break; case TYPE_F128_2: gen_ab_f128(); break; case TYPE_F128_3: gen_abc_f128(); break; #endif /*-------------------------------------------------------------------- *--------------------------------------------------------------------*/ case UI32_TO_F32: gen_a_ui32_z_f32( ui32_to_f32 ); break; case UI32_TO_F64: gen_a_ui32_z_f64( ui32_to_f64 ); break; #ifdef EXTFLOAT80 case UI32_TO_EXTF80: gen_a_ui32_z_extF80( ui32_to_extF80M ); break; #endif #ifdef FLOAT128 case UI32_TO_F128: gen_a_ui32_z_f128( ui32_to_f128M ); break; #endif case UI64_TO_F32: gen_a_ui64_z_f32( ui64_to_f32 ); break; case UI64_TO_F64: gen_a_ui64_z_f64( ui64_to_f64 ); break; #ifdef EXTFLOAT80 case UI64_TO_EXTF80: gen_a_ui64_z_extF80( ui64_to_extF80M ); break; #endif #ifdef FLOAT128 case UI64_TO_F128: gen_a_ui64_z_f128( ui64_to_f128M ); break; #endif case I32_TO_F32: gen_a_i32_z_f32( i32_to_f32 ); break; case I32_TO_F64: gen_a_i32_z_f64( i32_to_f64 ); break; #ifdef EXTFLOAT80 case I32_TO_EXTF80: gen_a_i32_z_extF80( i32_to_extF80M ); break; #endif #ifdef FLOAT128 case I32_TO_F128: gen_a_i32_z_f128( i32_to_f128M ); break; #endif case I64_TO_F32: gen_a_i64_z_f32( i64_to_f32 ); break; case I64_TO_F64: gen_a_i64_z_f64( i64_to_f64 ); break; #ifdef EXTFLOAT80 case I64_TO_EXTF80: gen_a_i64_z_extF80( i64_to_extF80M ); break; #endif #ifdef FLOAT128 case I64_TO_F128: gen_a_i64_z_f128( i64_to_f128M ); break; #endif /*-------------------------------------------------------------------- *--------------------------------------------------------------------*/ case F32_TO_UI32: gen_a_f32_z_ui32_rx( f32_to_ui32, roundingMode, exact ); break; case F32_TO_UI64: gen_a_f32_z_ui64_rx( f32_to_ui64, roundingMode, exact ); break; case F32_TO_I32: gen_a_f32_z_i32_rx( f32_to_i32, roundingMode, exact ); break; case F32_TO_I64: gen_a_f32_z_i64_rx( f32_to_i64, roundingMode, exact ); break; case F32_TO_F64: gen_a_f32_z_f64( f32_to_f64 ); break; #ifdef EXTFLOAT80 case F32_TO_EXTF80: gen_a_f32_z_extF80( f32_to_extF80M ); break; #endif #ifdef FLOAT128 case F32_TO_F128: gen_a_f32_z_f128( f32_to_f128M ); break; #endif case F32_ROUNDTOINT: gen_az_f32_rx( f32_roundToInt, roundingMode, exact ); break; case F32_ADD: trueFunction_abz_f32 = f32_add; goto gen_abz_f32; case F32_SUB: trueFunction_abz_f32 = f32_sub; goto gen_abz_f32; case F32_MUL: trueFunction_abz_f32 = f32_mul; goto gen_abz_f32; case F32_DIV: trueFunction_abz_f32 = f32_div; goto gen_abz_f32; case F32_REM: trueFunction_abz_f32 = f32_rem; gen_abz_f32: gen_abz_f32( trueFunction_abz_f32 ); break; case F32_MULADD: gen_abcz_f32( f32_mulAdd ); break; case F32_SQRT: gen_az_f32( f32_sqrt ); break; case F32_EQ: trueFunction_ab_f32_z_bool = f32_eq; goto gen_ab_f32_z_bool; case F32_LE: trueFunction_ab_f32_z_bool = f32_le; goto gen_ab_f32_z_bool; case F32_LT: trueFunction_ab_f32_z_bool = f32_lt; goto gen_ab_f32_z_bool; case F32_EQ_SIGNALING: trueFunction_ab_f32_z_bool = f32_eq_signaling; goto gen_ab_f32_z_bool; case F32_LE_QUIET: trueFunction_ab_f32_z_bool = f32_le_quiet; goto gen_ab_f32_z_bool; case F32_LT_QUIET: trueFunction_ab_f32_z_bool = f32_lt_quiet; gen_ab_f32_z_bool: gen_ab_f32_z_bool( trueFunction_ab_f32_z_bool ); break; /*-------------------------------------------------------------------- *--------------------------------------------------------------------*/ case F64_TO_UI32: gen_a_f64_z_ui32_rx( f64_to_ui32, roundingMode, exact ); break; case F64_TO_UI64: gen_a_f64_z_ui64_rx( f64_to_ui64, roundingMode, exact ); break; case F64_TO_I32: gen_a_f64_z_i32_rx( f64_to_i32, roundingMode, exact ); break; case F64_TO_I64: gen_a_f64_z_i64_rx( f64_to_i64, roundingMode, exact ); break; case F64_TO_F32: gen_a_f64_z_f32( f64_to_f32 ); break; #ifdef EXTFLOAT80 case F64_TO_EXTF80: gen_a_f64_z_extF80( f64_to_extF80M ); break; #endif #ifdef FLOAT128 case F64_TO_F128: gen_a_f64_z_f128( f64_to_f128M ); break; #endif case F64_ROUNDTOINT: gen_az_f64_rx( f64_roundToInt, roundingMode, exact ); break; case F64_ADD: trueFunction_abz_f64 = f64_add; goto gen_abz_f64; case F64_SUB: trueFunction_abz_f64 = f64_sub; goto gen_abz_f64; case F64_MUL: trueFunction_abz_f64 = f64_mul; goto gen_abz_f64; case F64_DIV: trueFunction_abz_f64 = f64_div; goto gen_abz_f64; case F64_REM: trueFunction_abz_f64 = f64_rem; gen_abz_f64: gen_abz_f64( trueFunction_abz_f64 ); break; case F64_MULADD: gen_abcz_f64( f64_mulAdd ); break; case F64_SQRT: gen_az_f64( f64_sqrt ); break; case F64_EQ: trueFunction_ab_f64_z_bool = f64_eq; goto gen_ab_f64_z_bool; case F64_LE: trueFunction_ab_f64_z_bool = f64_le; goto gen_ab_f64_z_bool; case F64_LT: trueFunction_ab_f64_z_bool = f64_lt; goto gen_ab_f64_z_bool; case F64_EQ_SIGNALING: trueFunction_ab_f64_z_bool = f64_eq_signaling; goto gen_ab_f64_z_bool; case F64_LE_QUIET: trueFunction_ab_f64_z_bool = f64_le_quiet; goto gen_ab_f64_z_bool; case F64_LT_QUIET: trueFunction_ab_f64_z_bool = f64_lt_quiet; gen_ab_f64_z_bool: gen_ab_f64_z_bool( trueFunction_ab_f64_z_bool ); break; /*-------------------------------------------------------------------- *--------------------------------------------------------------------*/ #ifdef EXTFLOAT80 case EXTF80_TO_UI32: gen_a_extF80_z_ui32_rx( extF80M_to_ui32, roundingMode, exact ); break; case EXTF80_TO_UI64: gen_a_extF80_z_ui64_rx( extF80M_to_ui64, roundingMode, exact ); break; case EXTF80_TO_I32: gen_a_extF80_z_i32_rx( extF80M_to_i32, roundingMode, exact ); break; case EXTF80_TO_I64: gen_a_extF80_z_i64_rx( extF80M_to_i64, roundingMode, exact ); break; case EXTF80_TO_F32: gen_a_extF80_z_f32( extF80M_to_f32 ); break; case EXTF80_TO_F64: gen_a_extF80_z_f64( extF80M_to_f64 ); break; #ifdef FLOAT128 case EXTF80_TO_F128: gen_a_extF80_z_f128( extF80M_to_f128M ); break; #endif case EXTF80_ROUNDTOINT: gen_az_extF80_rx( extF80M_roundToInt, roundingMode, exact ); break; case EXTF80_ADD: trueFunction_abz_extF80 = extF80M_add; goto gen_abz_extF80; case EXTF80_SUB: trueFunction_abz_extF80 = extF80M_sub; goto gen_abz_extF80; case EXTF80_MUL: trueFunction_abz_extF80 = extF80M_mul; goto gen_abz_extF80; case EXTF80_DIV: trueFunction_abz_extF80 = extF80M_div; goto gen_abz_extF80; case EXTF80_REM: trueFunction_abz_extF80 = extF80M_rem; gen_abz_extF80: gen_abz_extF80( trueFunction_abz_extF80 ); break; case EXTF80_SQRT: gen_az_extF80( extF80M_sqrt ); break; case EXTF80_EQ: trueFunction_ab_extF80_z_bool = extF80M_eq; goto gen_ab_extF80_z_bool; case EXTF80_LE: trueFunction_ab_extF80_z_bool = extF80M_le; goto gen_ab_extF80_z_bool; case EXTF80_LT: trueFunction_ab_extF80_z_bool = extF80M_lt; goto gen_ab_extF80_z_bool; case EXTF80_EQ_SIGNALING: trueFunction_ab_extF80_z_bool = extF80M_eq_signaling; goto gen_ab_extF80_z_bool; case EXTF80_LE_QUIET: trueFunction_ab_extF80_z_bool = extF80M_le_quiet; goto gen_ab_extF80_z_bool; case EXTF80_LT_QUIET: trueFunction_ab_extF80_z_bool = extF80M_lt_quiet; gen_ab_extF80_z_bool: gen_ab_extF80_z_bool( trueFunction_ab_extF80_z_bool ); break; #endif /*-------------------------------------------------------------------- *--------------------------------------------------------------------*/ #ifdef FLOAT128 case F128_TO_UI32: gen_a_f128_z_ui32_rx( f128M_to_ui32, roundingMode, exact ); break; case F128_TO_UI64: gen_a_f128_z_ui64_rx( f128M_to_ui64, roundingMode, exact ); break; case F128_TO_I32: gen_a_f128_z_i32_rx( f128M_to_i32, roundingMode, exact ); break; case F128_TO_I64: gen_a_f128_z_i64_rx( f128M_to_i64, roundingMode, exact ); break; case F128_TO_F32: gen_a_f128_z_f32( f128M_to_f32 ); break; case F128_TO_F64: gen_a_f128_z_f64( f128M_to_f64 ); break; #ifdef EXTFLOAT80 case F128_TO_EXTF80: gen_a_f128_z_extF80( f128M_to_extF80M ); break; #endif case F128_ROUNDTOINT: gen_az_f128_rx( f128M_roundToInt, roundingMode, exact ); break; case F128_ADD: trueFunction_abz_f128 = f128M_add; goto gen_abz_f128; case F128_SUB: trueFunction_abz_f128 = f128M_sub; goto gen_abz_f128; case F128_MUL: trueFunction_abz_f128 = f128M_mul; goto gen_abz_f128; case F128_DIV: trueFunction_abz_f128 = f128M_div; goto gen_abz_f128; case F128_REM: trueFunction_abz_f128 = f128M_rem; gen_abz_f128: gen_abz_f128( trueFunction_abz_f128 ); break; case F128_MULADD: gen_abcz_f128( f128M_mulAdd ); break; case F128_SQRT: gen_az_f128( f128M_sqrt ); break; case F128_EQ: trueFunction_ab_f128_z_bool = f128M_eq; goto gen_ab_f128_z_bool; case F128_LE: trueFunction_ab_f128_z_bool = f128M_le; goto gen_ab_f128_z_bool; case F128_LT: trueFunction_ab_f128_z_bool = f128M_lt; goto gen_ab_f128_z_bool; case F128_EQ_SIGNALING: trueFunction_ab_f128_z_bool = f128M_eq_signaling; goto gen_ab_f128_z_bool; case F128_LE_QUIET: trueFunction_ab_f128_z_bool = f128M_le_quiet; goto gen_ab_f128_z_bool; case F128_LT_QUIET: trueFunction_ab_f128_z_bool = f128M_lt_quiet; gen_ab_f128_z_bool: gen_ab_f128_z_bool( trueFunction_ab_f128_z_bool ); break; #endif } return EXIT_SUCCESS; /*------------------------------------------------------------------------ *------------------------------------------------------------------------*/ optionError: fail( "`%s' option requires numeric argument", *argv ); /*------------------------------------------------------------------------ *------------------------------------------------------------------------*/ invalidArg: fail( "Invalid argument `%s'", *argv ); }
static void testFunctionInstance( int functionCode, uint_fast8_t roundingMode, bool exact ) { #ifdef FLOAT16 float16_t (*trueFunction_abz_f16)( float16_t, float16_t ); float16_t (*subjFunction_abz_f16)( float16_t, float16_t ); bool (*trueFunction_ab_f16_z_bool)( float16_t, float16_t ); bool (*subjFunction_ab_f16_z_bool)( float16_t, float16_t ); #endif float32_t (*trueFunction_abz_f32)( float32_t, float32_t ); float32_t (*subjFunction_abz_f32)( float32_t, float32_t ); bool (*trueFunction_ab_f32_z_bool)( float32_t, float32_t ); bool (*subjFunction_ab_f32_z_bool)( float32_t, float32_t ); float64_t (*trueFunction_abz_f64)( float64_t, float64_t ); float64_t (*subjFunction_abz_f64)( float64_t, float64_t ); bool (*trueFunction_ab_f64_z_bool)( float64_t, float64_t ); bool (*subjFunction_ab_f64_z_bool)( float64_t, float64_t ); #ifdef EXTFLOAT80 void (*trueFunction_abz_extF80M)( const extFloat80_t *, const extFloat80_t *, extFloat80_t * ); void (*subjFunction_abz_extF80M)( const extFloat80_t *, const extFloat80_t *, extFloat80_t * ); bool (*trueFunction_ab_extF80M_z_bool)( const extFloat80_t *, const extFloat80_t * ); bool (*subjFunction_ab_extF80M_z_bool)( const extFloat80_t *, const extFloat80_t * ); #endif #ifdef FLOAT128 void (*trueFunction_abz_f128M)( const float128_t *, const float128_t *, float128_t * ); void (*subjFunction_abz_f128M)( const float128_t *, const float128_t *, float128_t * ); bool (*trueFunction_ab_f128M_z_bool)( const float128_t *, const float128_t * ); bool (*subjFunction_ab_f128M_z_bool)( const float128_t *, const float128_t * ); #endif fputs( "Testing ", stderr ); verCases_writeFunctionName( stderr ); fputs( ".\n", stderr ); switch ( functionCode ) { /*-------------------------------------------------------------------- *--------------------------------------------------------------------*/ #ifdef FLOAT16 case UI32_TO_F16: test_a_ui32_z_f16( slow_ui32_to_f16, ui32_to_f16 ); break; #endif case UI32_TO_F32: test_a_ui32_z_f32( slow_ui32_to_f32, ui32_to_f32 ); break; case UI32_TO_F64: test_a_ui32_z_f64( slow_ui32_to_f64, ui32_to_f64 ); break; #ifdef EXTFLOAT80 case UI32_TO_EXTF80: test_a_ui32_z_extF80( slow_ui32_to_extF80M, ui32_to_extF80M ); break; #endif #ifdef FLOAT128 case UI32_TO_F128: test_a_ui32_z_f128( slow_ui32_to_f128M, ui32_to_f128M ); break; #endif #ifdef FLOAT16 case UI64_TO_F16: test_a_ui64_z_f16( slow_ui64_to_f16, ui64_to_f16 ); break; #endif case UI64_TO_F32: test_a_ui64_z_f32( slow_ui64_to_f32, ui64_to_f32 ); break; case UI64_TO_F64: test_a_ui64_z_f64( slow_ui64_to_f64, ui64_to_f64 ); break; #ifdef EXTFLOAT80 case UI64_TO_EXTF80: test_a_ui64_z_extF80( slow_ui64_to_extF80M, ui64_to_extF80M ); break; #endif #ifdef FLOAT128 case UI64_TO_F128: test_a_ui64_z_f128( slow_ui64_to_f128M, ui64_to_f128M ); break; #endif #ifdef FLOAT16 case I32_TO_F16: test_a_i32_z_f16( slow_i32_to_f16, i32_to_f16 ); break; #endif case I32_TO_F32: test_a_i32_z_f32( slow_i32_to_f32, i32_to_f32 ); break; case I32_TO_F64: test_a_i32_z_f64( slow_i32_to_f64, i32_to_f64 ); break; #ifdef EXTFLOAT80 case I32_TO_EXTF80: test_a_i32_z_extF80( slow_i32_to_extF80M, i32_to_extF80M ); break; #endif #ifdef FLOAT128 case I32_TO_F128: test_a_i32_z_f128( slow_i32_to_f128M, i32_to_f128M ); break; #endif #ifdef FLOAT16 case I64_TO_F16: test_a_i64_z_f16( slow_i64_to_f16, i64_to_f16 ); break; #endif case I64_TO_F32: test_a_i64_z_f32( slow_i64_to_f32, i64_to_f32 ); break; case I64_TO_F64: test_a_i64_z_f64( slow_i64_to_f64, i64_to_f64 ); break; #ifdef EXTFLOAT80 case I64_TO_EXTF80: test_a_i64_z_extF80( slow_i64_to_extF80M, i64_to_extF80M ); break; #endif #ifdef FLOAT128 case I64_TO_F128: test_a_i64_z_f128( slow_i64_to_f128M, i64_to_f128M ); break; #endif /*-------------------------------------------------------------------- *--------------------------------------------------------------------*/ #ifdef FLOAT16 case F16_TO_UI32: test_a_f16_z_ui32_rx( slow_f16_to_ui32, f16_to_ui32, roundingMode, exact ); break; case F16_TO_UI64: test_a_f16_z_ui64_rx( slow_f16_to_ui64, f16_to_ui64, roundingMode, exact ); break; case F16_TO_I32: test_a_f16_z_i32_rx( slow_f16_to_i32, f16_to_i32, roundingMode, exact ); break; case F16_TO_I64: test_a_f16_z_i64_rx( slow_f16_to_i64, f16_to_i64, roundingMode, exact ); break; case F16_TO_UI32_R_MINMAG: test_a_f16_z_ui32_x( slow_f16_to_ui32_r_minMag, f16_to_ui32_r_minMag, exact ); break; case F16_TO_UI64_R_MINMAG: test_a_f16_z_ui64_x( slow_f16_to_ui64_r_minMag, f16_to_ui64_r_minMag, exact ); break; case F16_TO_I32_R_MINMAG: test_a_f16_z_i32_x( slow_f16_to_i32_r_minMag, f16_to_i32_r_minMag, exact ); break; case F16_TO_I64_R_MINMAG: test_a_f16_z_i64_x( slow_f16_to_i64_r_minMag, f16_to_i64_r_minMag, exact ); break; case F16_TO_F32: test_a_f16_z_f32( slow_f16_to_f32, f16_to_f32 ); break; case F16_TO_F64: test_a_f16_z_f64( slow_f16_to_f64, f16_to_f64 ); break; #ifdef EXTFLOAT80 case F16_TO_EXTF80: test_a_f16_z_extF80( slow_f16_to_extF80M, f16_to_extF80M ); break; #endif #ifdef FLOAT128 case F16_TO_F128: test_a_f16_z_f128( slow_f16_to_f128M, f16_to_f128M ); break; #endif case F16_ROUNDTOINT: test_az_f16_rx( slow_f16_roundToInt, f16_roundToInt, roundingMode, exact ); break; case F16_ADD: trueFunction_abz_f16 = slow_f16_add; subjFunction_abz_f16 = f16_add; goto test_abz_f16; case F16_SUB: trueFunction_abz_f16 = slow_f16_sub; subjFunction_abz_f16 = f16_sub; goto test_abz_f16; case F16_MUL: trueFunction_abz_f16 = slow_f16_mul; subjFunction_abz_f16 = f16_mul; goto test_abz_f16; case F16_DIV: trueFunction_abz_f16 = slow_f16_div; subjFunction_abz_f16 = f16_div; goto test_abz_f16; case F16_REM: trueFunction_abz_f16 = slow_f16_rem; subjFunction_abz_f16 = f16_rem; test_abz_f16: test_abz_f16( trueFunction_abz_f16, subjFunction_abz_f16 ); break; case F16_MULADD: test_abcz_f16( slow_f16_mulAdd, f16_mulAdd ); break; case F16_SQRT: test_az_f16( slow_f16_sqrt, f16_sqrt ); break; case F16_EQ: trueFunction_ab_f16_z_bool = slow_f16_eq; subjFunction_ab_f16_z_bool = f16_eq; goto test_ab_f16_z_bool; case F16_LE: trueFunction_ab_f16_z_bool = slow_f16_le; subjFunction_ab_f16_z_bool = f16_le; goto test_ab_f16_z_bool; case F16_LT: trueFunction_ab_f16_z_bool = slow_f16_lt; subjFunction_ab_f16_z_bool = f16_lt; goto test_ab_f16_z_bool; case F16_EQ_SIGNALING: trueFunction_ab_f16_z_bool = slow_f16_eq_signaling; subjFunction_ab_f16_z_bool = f16_eq_signaling; goto test_ab_f16_z_bool; case F16_LE_QUIET: trueFunction_ab_f16_z_bool = slow_f16_le_quiet; subjFunction_ab_f16_z_bool = f16_le_quiet; goto test_ab_f16_z_bool; case F16_LT_QUIET: trueFunction_ab_f16_z_bool = slow_f16_lt_quiet; subjFunction_ab_f16_z_bool = f16_lt_quiet; test_ab_f16_z_bool: test_ab_f16_z_bool( trueFunction_ab_f16_z_bool, subjFunction_ab_f16_z_bool ); break; #endif /*-------------------------------------------------------------------- *--------------------------------------------------------------------*/ case F32_TO_UI32: test_a_f32_z_ui32_rx( slow_f32_to_ui32, f32_to_ui32, roundingMode, exact ); break; case F32_TO_UI64: test_a_f32_z_ui64_rx( slow_f32_to_ui64, f32_to_ui64, roundingMode, exact ); break; case F32_TO_I32: test_a_f32_z_i32_rx( slow_f32_to_i32, f32_to_i32, roundingMode, exact ); break; case F32_TO_I64: test_a_f32_z_i64_rx( slow_f32_to_i64, f32_to_i64, roundingMode, exact ); break; case F32_TO_UI32_R_MINMAG: test_a_f32_z_ui32_x( slow_f32_to_ui32_r_minMag, f32_to_ui32_r_minMag, exact ); break; case F32_TO_UI64_R_MINMAG: test_a_f32_z_ui64_x( slow_f32_to_ui64_r_minMag, f32_to_ui64_r_minMag, exact ); break; case F32_TO_I32_R_MINMAG: test_a_f32_z_i32_x( slow_f32_to_i32_r_minMag, f32_to_i32_r_minMag, exact ); break; case F32_TO_I64_R_MINMAG: test_a_f32_z_i64_x( slow_f32_to_i64_r_minMag, f32_to_i64_r_minMag, exact ); break; #ifdef FLOAT16 case F32_TO_F16: test_a_f32_z_f16( slow_f32_to_f16, f32_to_f16 ); break; #endif case F32_TO_F64: test_a_f32_z_f64( slow_f32_to_f64, f32_to_f64 ); break; #ifdef EXTFLOAT80 case F32_TO_EXTF80: test_a_f32_z_extF80( slow_f32_to_extF80M, f32_to_extF80M ); break; #endif #ifdef FLOAT128 case F32_TO_F128: test_a_f32_z_f128( slow_f32_to_f128M, f32_to_f128M ); break; #endif case F32_ROUNDTOINT: test_az_f32_rx( slow_f32_roundToInt, f32_roundToInt, roundingMode, exact ); break; case F32_ADD: trueFunction_abz_f32 = slow_f32_add; subjFunction_abz_f32 = f32_add; goto test_abz_f32; case F32_SUB: trueFunction_abz_f32 = slow_f32_sub; subjFunction_abz_f32 = f32_sub; goto test_abz_f32; case F32_MUL: trueFunction_abz_f32 = slow_f32_mul; subjFunction_abz_f32 = f32_mul; goto test_abz_f32; case F32_DIV: trueFunction_abz_f32 = slow_f32_div; subjFunction_abz_f32 = f32_div; goto test_abz_f32; case F32_REM: trueFunction_abz_f32 = slow_f32_rem; subjFunction_abz_f32 = f32_rem; test_abz_f32: test_abz_f32( trueFunction_abz_f32, subjFunction_abz_f32 ); break; case F32_MULADD: test_abcz_f32( slow_f32_mulAdd, f32_mulAdd ); break; case F32_SQRT: test_az_f32( slow_f32_sqrt, f32_sqrt ); break; case F32_EQ: trueFunction_ab_f32_z_bool = slow_f32_eq; subjFunction_ab_f32_z_bool = f32_eq; goto test_ab_f32_z_bool; case F32_LE: trueFunction_ab_f32_z_bool = slow_f32_le; subjFunction_ab_f32_z_bool = f32_le; goto test_ab_f32_z_bool; case F32_LT: trueFunction_ab_f32_z_bool = slow_f32_lt; subjFunction_ab_f32_z_bool = f32_lt; goto test_ab_f32_z_bool; case F32_EQ_SIGNALING: trueFunction_ab_f32_z_bool = slow_f32_eq_signaling; subjFunction_ab_f32_z_bool = f32_eq_signaling; goto test_ab_f32_z_bool; case F32_LE_QUIET: trueFunction_ab_f32_z_bool = slow_f32_le_quiet; subjFunction_ab_f32_z_bool = f32_le_quiet; goto test_ab_f32_z_bool; case F32_LT_QUIET: trueFunction_ab_f32_z_bool = slow_f32_lt_quiet; subjFunction_ab_f32_z_bool = f32_lt_quiet; test_ab_f32_z_bool: test_ab_f32_z_bool( trueFunction_ab_f32_z_bool, subjFunction_ab_f32_z_bool ); break; /*-------------------------------------------------------------------- *--------------------------------------------------------------------*/ case F64_TO_UI32: test_a_f64_z_ui32_rx( slow_f64_to_ui32, f64_to_ui32, roundingMode, exact ); break; case F64_TO_UI64: test_a_f64_z_ui64_rx( slow_f64_to_ui64, f64_to_ui64, roundingMode, exact ); break; case F64_TO_I32: test_a_f64_z_i32_rx( slow_f64_to_i32, f64_to_i32, roundingMode, exact ); break; case F64_TO_I64: test_a_f64_z_i64_rx( slow_f64_to_i64, f64_to_i64, roundingMode, exact ); break; case F64_TO_UI32_R_MINMAG: test_a_f64_z_ui32_x( slow_f64_to_ui32_r_minMag, f64_to_ui32_r_minMag, exact ); break; case F64_TO_UI64_R_MINMAG: test_a_f64_z_ui64_x( slow_f64_to_ui64_r_minMag, f64_to_ui64_r_minMag, exact ); break; case F64_TO_I32_R_MINMAG: test_a_f64_z_i32_x( slow_f64_to_i32_r_minMag, f64_to_i32_r_minMag, exact ); break; case F64_TO_I64_R_MINMAG: test_a_f64_z_i64_x( slow_f64_to_i64_r_minMag, f64_to_i64_r_minMag, exact ); break; #ifdef FLOAT16 case F64_TO_F16: test_a_f64_z_f16( slow_f64_to_f16, f64_to_f16 ); break; #endif case F64_TO_F32: test_a_f64_z_f32( slow_f64_to_f32, f64_to_f32 ); break; #ifdef EXTFLOAT80 case F64_TO_EXTF80: test_a_f64_z_extF80( slow_f64_to_extF80M, f64_to_extF80M ); break; #endif #ifdef FLOAT128 case F64_TO_F128: test_a_f64_z_f128( slow_f64_to_f128M, f64_to_f128M ); break; #endif case F64_ROUNDTOINT: test_az_f64_rx( slow_f64_roundToInt, f64_roundToInt, roundingMode, exact ); break; case F64_ADD: trueFunction_abz_f64 = slow_f64_add; subjFunction_abz_f64 = f64_add; goto test_abz_f64; case F64_SUB: trueFunction_abz_f64 = slow_f64_sub; subjFunction_abz_f64 = f64_sub; goto test_abz_f64; case F64_MUL: trueFunction_abz_f64 = slow_f64_mul; subjFunction_abz_f64 = f64_mul; goto test_abz_f64; case F64_DIV: trueFunction_abz_f64 = slow_f64_div; subjFunction_abz_f64 = f64_div; goto test_abz_f64; case F64_REM: trueFunction_abz_f64 = slow_f64_rem; subjFunction_abz_f64 = f64_rem; test_abz_f64: test_abz_f64( trueFunction_abz_f64, subjFunction_abz_f64 ); break; case F64_MULADD: test_abcz_f64( slow_f64_mulAdd, f64_mulAdd ); break; case F64_SQRT: test_az_f64( slow_f64_sqrt, f64_sqrt ); break; case F64_EQ: trueFunction_ab_f64_z_bool = slow_f64_eq; subjFunction_ab_f64_z_bool = f64_eq; goto test_ab_f64_z_bool; case F64_LE: trueFunction_ab_f64_z_bool = slow_f64_le; subjFunction_ab_f64_z_bool = f64_le; goto test_ab_f64_z_bool; case F64_LT: trueFunction_ab_f64_z_bool = slow_f64_lt; subjFunction_ab_f64_z_bool = f64_lt; goto test_ab_f64_z_bool; case F64_EQ_SIGNALING: trueFunction_ab_f64_z_bool = slow_f64_eq_signaling; subjFunction_ab_f64_z_bool = f64_eq_signaling; goto test_ab_f64_z_bool; case F64_LE_QUIET: trueFunction_ab_f64_z_bool = slow_f64_le_quiet; subjFunction_ab_f64_z_bool = f64_le_quiet; goto test_ab_f64_z_bool; case F64_LT_QUIET: trueFunction_ab_f64_z_bool = slow_f64_lt_quiet; subjFunction_ab_f64_z_bool = f64_lt_quiet; test_ab_f64_z_bool: test_ab_f64_z_bool( trueFunction_ab_f64_z_bool, subjFunction_ab_f64_z_bool ); break; /*-------------------------------------------------------------------- *--------------------------------------------------------------------*/ #ifdef EXTFLOAT80 case EXTF80_TO_UI32: test_a_extF80_z_ui32_rx( slow_extF80M_to_ui32, extF80M_to_ui32, roundingMode, exact ); break; case EXTF80_TO_UI64: test_a_extF80_z_ui64_rx( slow_extF80M_to_ui64, extF80M_to_ui64, roundingMode, exact ); break; case EXTF80_TO_I32: test_a_extF80_z_i32_rx( slow_extF80M_to_i32, extF80M_to_i32, roundingMode, exact ); break; case EXTF80_TO_I64: test_a_extF80_z_i64_rx( slow_extF80M_to_i64, extF80M_to_i64, roundingMode, exact ); break; case EXTF80_TO_UI32_R_MINMAG: test_a_extF80_z_ui32_x( slow_extF80M_to_ui32_r_minMag, extF80M_to_ui32_r_minMag, exact ); break; case EXTF80_TO_UI64_R_MINMAG: test_a_extF80_z_ui64_x( slow_extF80M_to_ui64_r_minMag, extF80M_to_ui64_r_minMag, exact ); break; case EXTF80_TO_I32_R_MINMAG: test_a_extF80_z_i32_x( slow_extF80M_to_i32_r_minMag, extF80M_to_i32_r_minMag, exact ); break; case EXTF80_TO_I64_R_MINMAG: test_a_extF80_z_i64_x( slow_extF80M_to_i64_r_minMag, extF80M_to_i64_r_minMag, exact ); break; #ifdef FLOAT16 case EXTF80_TO_F16: test_a_extF80_z_f16( slow_extF80M_to_f16, extF80M_to_f16 ); break; #endif case EXTF80_TO_F32: test_a_extF80_z_f32( slow_extF80M_to_f32, extF80M_to_f32 ); break; case EXTF80_TO_F64: test_a_extF80_z_f64( slow_extF80M_to_f64, extF80M_to_f64 ); break; #ifdef FLOAT128 case EXTF80_TO_F128: test_a_extF80_z_f128( slow_extF80M_to_f128M, extF80M_to_f128M ); break; #endif case EXTF80_ROUNDTOINT: test_az_extF80_rx( slow_extF80M_roundToInt, extF80M_roundToInt, roundingMode, exact ); break; case EXTF80_ADD: trueFunction_abz_extF80M = slow_extF80M_add; subjFunction_abz_extF80M = extF80M_add; goto test_abz_extF80; case EXTF80_SUB: trueFunction_abz_extF80M = slow_extF80M_sub; subjFunction_abz_extF80M = extF80M_sub; goto test_abz_extF80; case EXTF80_MUL: trueFunction_abz_extF80M = slow_extF80M_mul; subjFunction_abz_extF80M = extF80M_mul; goto test_abz_extF80; case EXTF80_DIV: trueFunction_abz_extF80M = slow_extF80M_div; subjFunction_abz_extF80M = extF80M_div; goto test_abz_extF80; case EXTF80_REM: trueFunction_abz_extF80M = slow_extF80M_rem; subjFunction_abz_extF80M = extF80M_rem; test_abz_extF80: test_abz_extF80( trueFunction_abz_extF80M, subjFunction_abz_extF80M ); break; case EXTF80_SQRT: test_az_extF80( slow_extF80M_sqrt, extF80M_sqrt ); break; case EXTF80_EQ: trueFunction_ab_extF80M_z_bool = slow_extF80M_eq; subjFunction_ab_extF80M_z_bool = extF80M_eq; goto test_ab_extF80_z_bool; case EXTF80_LE: trueFunction_ab_extF80M_z_bool = slow_extF80M_le; subjFunction_ab_extF80M_z_bool = extF80M_le; goto test_ab_extF80_z_bool; case EXTF80_LT: trueFunction_ab_extF80M_z_bool = slow_extF80M_lt; subjFunction_ab_extF80M_z_bool = extF80M_lt; goto test_ab_extF80_z_bool; case EXTF80_EQ_SIGNALING: trueFunction_ab_extF80M_z_bool = slow_extF80M_eq_signaling; subjFunction_ab_extF80M_z_bool = extF80M_eq_signaling; goto test_ab_extF80_z_bool; case EXTF80_LE_QUIET: trueFunction_ab_extF80M_z_bool = slow_extF80M_le_quiet; subjFunction_ab_extF80M_z_bool = extF80M_le_quiet; goto test_ab_extF80_z_bool; case EXTF80_LT_QUIET: trueFunction_ab_extF80M_z_bool = slow_extF80M_lt_quiet; subjFunction_ab_extF80M_z_bool = extF80M_lt_quiet; test_ab_extF80_z_bool: test_ab_extF80_z_bool( trueFunction_ab_extF80M_z_bool, subjFunction_ab_extF80M_z_bool ); break; #endif /*-------------------------------------------------------------------- *--------------------------------------------------------------------*/ #ifdef FLOAT128 case F128_TO_UI32: test_a_f128_z_ui32_rx( slow_f128M_to_ui32, f128M_to_ui32, roundingMode, exact ); break; case F128_TO_UI64: test_a_f128_z_ui64_rx( slow_f128M_to_ui64, f128M_to_ui64, roundingMode, exact ); break; case F128_TO_I32: test_a_f128_z_i32_rx( slow_f128M_to_i32, f128M_to_i32, roundingMode, exact ); break; case F128_TO_I64: test_a_f128_z_i64_rx( slow_f128M_to_i64, f128M_to_i64, roundingMode, exact ); break; case F128_TO_UI32_R_MINMAG: test_a_f128_z_ui32_x( slow_f128M_to_ui32_r_minMag, f128M_to_ui32_r_minMag, exact ); break; case F128_TO_UI64_R_MINMAG: test_a_f128_z_ui64_x( slow_f128M_to_ui64_r_minMag, f128M_to_ui64_r_minMag, exact ); break; case F128_TO_I32_R_MINMAG: test_a_f128_z_i32_x( slow_f128M_to_i32_r_minMag, f128M_to_i32_r_minMag, exact ); break; case F128_TO_I64_R_MINMAG: test_a_f128_z_i64_x( slow_f128M_to_i64_r_minMag, f128M_to_i64_r_minMag, exact ); break; #ifdef FLOAT16 case F128_TO_F16: test_a_f128_z_f16( slow_f128M_to_f16, f128M_to_f16 ); break; #endif case F128_TO_F32: test_a_f128_z_f32( slow_f128M_to_f32, f128M_to_f32 ); break; case F128_TO_F64: test_a_f128_z_f64( slow_f128M_to_f64, f128M_to_f64 ); break; #ifdef EXTFLOAT80 case F128_TO_EXTF80: test_a_f128_z_extF80( slow_f128M_to_extF80M, f128M_to_extF80M ); break; #endif case F128_ROUNDTOINT: test_az_f128_rx( slow_f128M_roundToInt, f128M_roundToInt, roundingMode, exact ); break; case F128_ADD: trueFunction_abz_f128M = slow_f128M_add; subjFunction_abz_f128M = f128M_add; goto test_abz_f128; case F128_SUB: trueFunction_abz_f128M = slow_f128M_sub; subjFunction_abz_f128M = f128M_sub; goto test_abz_f128; case F128_MUL: trueFunction_abz_f128M = slow_f128M_mul; subjFunction_abz_f128M = f128M_mul; goto test_abz_f128; case F128_DIV: trueFunction_abz_f128M = slow_f128M_div; subjFunction_abz_f128M = f128M_div; goto test_abz_f128; case F128_REM: trueFunction_abz_f128M = slow_f128M_rem; subjFunction_abz_f128M = f128M_rem; test_abz_f128: test_abz_f128( trueFunction_abz_f128M, subjFunction_abz_f128M ); break; case F128_MULADD: test_abcz_f128( slow_f128M_mulAdd, f128M_mulAdd ); break; case F128_SQRT: test_az_f128( slow_f128M_sqrt, f128M_sqrt ); break; case F128_EQ: trueFunction_ab_f128M_z_bool = slow_f128M_eq; subjFunction_ab_f128M_z_bool = f128M_eq; goto test_ab_f128_z_bool; case F128_LE: trueFunction_ab_f128M_z_bool = slow_f128M_le; subjFunction_ab_f128M_z_bool = f128M_le; goto test_ab_f128_z_bool; case F128_LT: trueFunction_ab_f128M_z_bool = slow_f128M_lt; subjFunction_ab_f128M_z_bool = f128M_lt; goto test_ab_f128_z_bool; case F128_EQ_SIGNALING: trueFunction_ab_f128M_z_bool = slow_f128M_eq_signaling; subjFunction_ab_f128M_z_bool = f128M_eq_signaling; goto test_ab_f128_z_bool; case F128_LE_QUIET: trueFunction_ab_f128M_z_bool = slow_f128M_le_quiet; subjFunction_ab_f128M_z_bool = f128M_le_quiet; goto test_ab_f128_z_bool; case F128_LT_QUIET: trueFunction_ab_f128M_z_bool = slow_f128M_lt_quiet; subjFunction_ab_f128M_z_bool = f128M_lt_quiet; test_ab_f128_z_bool: test_ab_f128_z_bool( trueFunction_ab_f128M_z_bool, subjFunction_ab_f128M_z_bool ); break; #endif } if ( (verCases_errorStop && verCases_anyErrors) || verCases_stop ) { verCases_exitWithStatus(); } }