float16_t i32_to_f16( int32_t a ) { bool sign; uint_fast32_t absA; int_fast8_t shiftDist; union ui16_f16 u; uint_fast16_t sig; sign = (a < 0); absA = sign ? -(uint_fast32_t) a : (uint_fast32_t) a; shiftDist = softfloat_countLeadingZeros32( absA ) - 21; if ( 0 <= shiftDist ) { u.ui = a ? packToF16UI( sign, 0x18 - shiftDist, (uint_fast16_t) absA<<shiftDist ) : 0; return u.f; } else { shiftDist += 4; sig = (shiftDist < 0) ? absA>>(-shiftDist) | ((uint32_t) (absA<<(shiftDist & 31)) != 0) : (uint_fast16_t) absA<<shiftDist; return softfloat_roundPackToF16( sign, 0x1C - shiftDist, sig ); } }
void i32_to_f128M( int32_t a, float128_t *zPtr ) { uint32_t *zWPtr; uint32_t uiZ96, uiZ64; bool sign; uint32_t absA; int_fast8_t shiftDist; uint64_t normAbsA; zWPtr = (uint32_t *) zPtr; uiZ96 = 0; uiZ64 = 0; if ( a ) { sign = (a < 0); absA = sign ? -(uint32_t) a : (uint32_t) a; shiftDist = softfloat_countLeadingZeros32( absA ) + 17; normAbsA = (uint64_t) absA<<shiftDist; uiZ96 = packToF128UI96( sign, 0x402E - shiftDist, normAbsA>>32 ); uiZ64 = normAbsA; } zWPtr[indexWord( 4, 3 )] = uiZ96; zWPtr[indexWord( 4, 2 )] = uiZ64; zWPtr[indexWord( 4, 1 )] = 0; zWPtr[indexWord( 4, 0 )] = 0; }
struct exp16_sig32 softfloat_normSubnormalF32Sig( uint_fast32_t sig ) { int_fast8_t shiftCount; struct exp16_sig32 z; shiftCount = softfloat_countLeadingZeros32( sig ) - 8; z.exp = 1 - shiftCount; z.sig = sig<<shiftCount; return z; }
float32_t softfloat_normRoundPackToF32( bool sign, int_fast16_t exp, uint_fast32_t sig ) { int_fast8_t shiftDist; union ui32_f32 uZ; shiftDist = softfloat_countLeadingZeros32( sig ) - 1; exp -= shiftDist; if ( (7 <= shiftDist) && ((unsigned int) exp < 0xFD) ) { uZ.ui = packToF32UI( sign, sig ? exp : 0, sig<<(shiftDist - 7) ); return uZ.f; } else { return softfloat_roundPackToF32( sign, exp, sig<<shiftDist ); } }
extFloat80_t ui32_to_extF80( uint32_t a ) { uint_fast16_t uiZ64; int_fast8_t shiftCount; union { struct extFloat80M s; extFloat80_t f; } uZ; uiZ64 = 0; if ( a ) { shiftCount = softfloat_countLeadingZeros32( a ); uiZ64 = 0x401E - shiftCount; a <<= shiftCount; } uZ.s.signExp = uiZ64; uZ.s.signif = (uint_fast64_t) a<<32; return uZ.f; }
float64_t ui32_to_f64( uint32_t a ) { uint_fast64_t uiZ; int_fast8_t shiftDist; union ui64_f64 uZ; if ( ! a ) { uiZ = 0; } else { shiftDist = softfloat_countLeadingZeros32( a ) + 21; uiZ = packToF64UI( 0, 0x432 - shiftDist, (uint_fast64_t) a<<shiftDist ); } uZ.ui = uiZ; return uZ.f; }
float128_t ui32_to_f128( uint32_t a ) { uint_fast64_t uiZ64; int_fast8_t shiftCount; union ui128_f128 uZ; uiZ64 = 0; if ( a ) { shiftCount = softfloat_countLeadingZeros32( a ) + 17; uiZ64 = packToF128UI64( 0, 0x402E - shiftCount, (uint_fast64_t) a<<shiftCount ); } uZ.ui.v64 = uiZ64; uZ.ui.v0 = 0; return uZ.f; }
void ui32_to_extF80M( uint32_t a, extFloat80_t *zPtr ) { struct extFloat80M *zSPtr; uint_fast16_t uiZ64; uint64_t sigZ; int_fast8_t shiftDist; zSPtr = (struct extFloat80M *) zPtr; uiZ64 = 0; sigZ = 0; if ( a ) { shiftDist = softfloat_countLeadingZeros32( a ); uiZ64 = packToExtF80UI64( 0, 0x401E - shiftDist ); sigZ = (uint64_t) (a<<shiftDist)<<32; } zSPtr->signExp = uiZ64; zSPtr->signif = sigZ; }
int softfloat_normSubnormalF128SigM( uint32_t *sigPtr ) { const uint32_t *ptr; int_fast16_t shiftCount; uint32_t wordSig; ptr = sigPtr + indexWordHi( 4 ); shiftCount = 0; for (;;) { wordSig = *ptr; if ( wordSig ) break; shiftCount += 32; if ( 128 <= shiftCount ) return 1; ptr -= wordIncr; } shiftCount += softfloat_countLeadingZeros32( wordSig ) - 15; if ( shiftCount ) softfloat_shiftLeft128M( sigPtr, shiftCount, sigPtr ); return 1 - shiftCount; }
void ui32_to_f128M( uint32_t a, float128_t *zPtr ) { uint32_t *zWPtr, uiZ96, uiZ64; int_fast8_t shiftCount; uint64_t normA; zWPtr = (uint32_t *) zPtr; uiZ96 = 0; uiZ64 = 0; if ( a ) { shiftCount = softfloat_countLeadingZeros32( a ) + 17; normA = (uint64_t) a<<shiftCount; uiZ96 = packToF128UI96( 0, 0x402E - shiftCount, normA>>32 ); uiZ64 = normA; } zWPtr[indexWord( 4, 3 )] = uiZ96; zWPtr[indexWord( 4, 2 )] = uiZ64; zWPtr[indexWord( 4, 1 )] = 0; zWPtr[indexWord( 4, 0 )] = 0; }
float64_t i32_to_f64( int32_t a ) { uint_fast64_t uiZ; bool sign; uint_fast32_t absA; int_fast8_t shiftDist; union ui64_f64 uZ; if ( ! a ) { uiZ = 0; } else { sign = (a < 0); absA = sign ? -(uint_fast32_t) a : (uint_fast32_t) a; shiftDist = softfloat_countLeadingZeros32( absA ) + 21; uiZ = packToF64UI( sign, 0x432 - shiftDist, (uint_fast64_t) absA<<shiftDist ); } uZ.ui = uiZ; return uZ.f; }
float128_t i32_to_f128( int32_t a ) { uint_fast64_t uiZ64; bool sign; uint_fast32_t absA; int_fast8_t shiftDist; union ui128_f128 uZ; uiZ64 = 0; if ( a ) { sign = (a < 0); absA = sign ? -(uint_fast32_t) a : (uint_fast32_t) a; shiftDist = softfloat_countLeadingZeros32( absA ) + 17; uiZ64 = packToF128UI64( sign, 0x402E - shiftDist, (uint_fast64_t) absA<<shiftDist ); } uZ.ui.v64 = uiZ64; uZ.ui.v0 = 0; return uZ.f; }
void i32_to_extF80M( int32_t a, extFloat80_t *zPtr ) { struct extFloat80M *zSPtr; uint_fast16_t uiZ64; uint64_t sigZ; bool sign; uint32_t absA; int_fast8_t shiftDist; zSPtr = (struct extFloat80M *) zPtr; uiZ64 = 0; sigZ = 0; if ( a ) { sign = (a < 0); absA = sign ? -(uint32_t) a : (uint32_t) a; shiftDist = softfloat_countLeadingZeros32( absA ); uiZ64 = packToExtF80UI64( sign, 0x401E - shiftDist ); sigZ = (uint64_t) (absA<<shiftDist)<<32; } zSPtr->signExp = uiZ64; zSPtr->signif = sigZ; }
void softfloat_normRoundPackMToExtF80M( bool sign, int32_t exp, uint32_t *extSigPtr, uint_fast8_t roundingPrecision, struct extFloat80M *zSPtr ) { int_fast16_t shiftCount; uint32_t wordSig; shiftCount = 0; wordSig = extSigPtr[indexWord( 3, 2 )]; if ( ! wordSig ) { shiftCount = 32; wordSig = extSigPtr[indexWord( 3, 1 )]; if ( ! wordSig ) { shiftCount = 64; wordSig = extSigPtr[indexWord( 3, 0 )]; if ( ! wordSig ) { zSPtr->signExp = packToExtF80UI64( sign, 0 ); zSPtr->signif = 0; return; } } } shiftCount += softfloat_countLeadingZeros32( wordSig ); if ( shiftCount ) { exp -= shiftCount; softfloat_shiftLeft96M( extSigPtr, shiftCount, extSigPtr ); } softfloat_roundPackMToExtF80M( sign, exp, extSigPtr, roundingPrecision, zSPtr ); }
float32_t softfloat_subMagsF32( uint_fast32_t uiA, uint_fast32_t uiB ) { int_fast16_t expA; uint_fast32_t sigA; int_fast16_t expB; uint_fast32_t sigB; int_fast16_t expDiff; uint_fast32_t uiZ; int_fast32_t sigDiff; bool signZ; int_fast8_t shiftDist; int_fast16_t expZ; uint_fast32_t sigX, sigY; union ui32_f32 uZ; /*------------------------------------------------------------------------ *------------------------------------------------------------------------*/ expA = expF32UI( uiA ); sigA = fracF32UI( uiA ); expB = expF32UI( uiB ); sigB = fracF32UI( uiB ); /*------------------------------------------------------------------------ *------------------------------------------------------------------------*/ expDiff = expA - expB; if ( ! expDiff ) { /*-------------------------------------------------------------------- *--------------------------------------------------------------------*/ if ( expA == 0xFF ) { if ( sigA | sigB ) goto propagateNaN; softfloat_raiseFlags( softfloat_flag_invalid ); uiZ = defaultNaNF32UI; goto uiZ; } sigDiff = sigA - sigB; if ( ! sigDiff ) { uiZ = packToF32UI( (softfloat_roundingMode == softfloat_round_min), 0, 0 ); goto uiZ; } if ( expA ) --expA; signZ = signF32UI( uiA ); if ( sigDiff < 0 ) { signZ = ! signZ; sigDiff = -sigDiff; } shiftDist = softfloat_countLeadingZeros32( sigDiff ) - 8; expZ = expA - shiftDist; if ( expZ < 0 ) { shiftDist = expA; expZ = 0; } uiZ = packToF32UI( signZ, expZ, sigDiff<<shiftDist ); goto uiZ; } else { /*-------------------------------------------------------------------- *--------------------------------------------------------------------*/ signZ = signF32UI( uiA ); sigA <<= 7; sigB <<= 7; if ( expDiff < 0 ) { /*---------------------------------------------------------------- *----------------------------------------------------------------*/ signZ = ! signZ; if ( expB == 0xFF ) { if ( sigB ) goto propagateNaN; uiZ = packToF32UI( signZ, 0xFF, 0 ); goto uiZ; } expZ = expB - 1; sigX = sigB | 0x40000000; sigY = sigA + (expA ? 0x40000000 : sigA); expDiff = -expDiff; } else { /*---------------------------------------------------------------- *----------------------------------------------------------------*/ if ( expA == 0xFF ) { if ( sigA ) goto propagateNaN; uiZ = uiA; goto uiZ; } expZ = expA - 1; sigX = sigA | 0x40000000; sigY = sigB + (expB ? 0x40000000 : sigB); } return softfloat_normRoundPackToF32( signZ, expZ, sigX - softfloat_shiftRightJam32( sigY, expDiff ) ); } /*------------------------------------------------------------------------ *------------------------------------------------------------------------*/ propagateNaN: uiZ = softfloat_propagateNaNF32UI( uiA, uiB ); uiZ: uZ.ui = uiZ; return uZ.f; }