uint_fast64_t
extF80_to_ui64( extFloat80_t a, uint_fast8_t roundingMode, bool exact )
{
union { struct extFloat80M s; extFloat80_t f; } uA;
uint_fast16_t uiA64;
int_fast32_t exp, shiftCount;
bool sign;
uint_fast64_t sig, sigExtra;
struct uint64_extra sig64Extra;
uA.f = a;
uiA64 = uA.s.signExp;
exp = expExtF80UI64( uiA64 );
shiftCount = 0x403E - exp;
if ( shiftCount < 0 ) {
softfloat_raiseFlags( softfloat_flag_invalid );
return UINT64_C( 0xFFFFFFFFFFFFFFFF );
}
sign = signExtF80UI64( uiA64 );
sig = uA.s.signif;
sigExtra = 0;
if ( shiftCount ) {
sig64Extra = softfloat_shiftRightJam64Extra( sig, 0, shiftCount );
sig = sig64Extra.v;
sigExtra = sig64Extra.extra;
}
return
softfloat_roundPackToUI64( sign, sig, sigExtra, roundingMode, exact );
}
int_fast64_t f64_to_i64( float64_t a, uint_fast8_t roundingMode, bool exact )
{
union ui64_f64 uA;
uint_fast64_t uiA;
bool sign;
int_fast16_t exp;
uint_fast64_t sig;
int_fast16_t shiftCount;
#ifdef SOFTFLOAT_FAST_INT64
struct uint64_extra sigExtra;
#else
uint32_t extSig[3];
#endif
uA.f = a;
uiA = uA.ui;
sign = signF64UI( uiA );
exp = expF64UI( uiA );
sig = fracF64UI( uiA );
if ( exp ) sig |= UINT64_C( 0x0010000000000000 );
shiftCount = 0x433 - exp;
#ifdef SOFTFLOAT_FAST_INT64
if ( shiftCount <= 0 ) {
if ( shiftCount < -11 ) {
softfloat_raiseFlags( softfloat_flag_invalid );
return
! sign
|| ((exp == 0x7FF)
&& (sig != UINT64_C( 0x0010000000000000 )))
? INT64_C( 0x7FFFFFFFFFFFFFFF )
: -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1;
}
sigExtra.v = sig<<-shiftCount;
sigExtra.extra = 0;
} else {
sigExtra = softfloat_shiftRightJam64Extra( sig, 0, shiftCount );
}
return
softfloat_roundPackToI64(
sign, sigExtra.v, sigExtra.extra, roundingMode, exact );
#else
extSig[indexWord( 3, 0 )] = 0;
if ( shiftCount <= 0 ) {
if ( shiftCount < -11 ) {
softfloat_raiseFlags( softfloat_flag_invalid );
return
! sign
|| ((exp == 0x7FF)
&& (sig != UINT64_C( 0x0010000000000000 )))
? INT64_C( 0x7FFFFFFFFFFFFFFF )
: -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1;
}
sig <<= -shiftCount;
extSig[indexWord( 3, 2 )] = sig>>32;
extSig[indexWord( 3, 1 )] = sig;
} else {
uint_fast64_t
f128_to_ui64( float128_t a, uint_fast8_t roundingMode, bool exact )
{
union ui128_f128 uA;
uint_fast64_t uiA64, uiA0;
bool sign;
int_fast32_t exp;
uint_fast64_t sig64, sig0;
int_fast32_t shiftDist;
struct uint128 sig128;
struct uint64_extra sigExtra;
/*------------------------------------------------------------------------
*------------------------------------------------------------------------*/
uA.f = a;
uiA64 = uA.ui.v64;
uiA0 = uA.ui.v0;
sign = signF128UI64( uiA64 );
exp = expF128UI64( uiA64 );
sig64 = fracF128UI64( uiA64 );
sig0 = uiA0;
/*------------------------------------------------------------------------
*------------------------------------------------------------------------*/
shiftDist = 0x402F - exp;
if ( shiftDist <= 0 ) {
/*--------------------------------------------------------------------
*--------------------------------------------------------------------*/
if ( shiftDist < -15 ) {
softfloat_raiseFlags( softfloat_flag_invalid );
return
(exp == 0x7FFF) && (sig64 | sig0) ? ui64_fromNaN
: sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
}
/*--------------------------------------------------------------------
*--------------------------------------------------------------------*/
sig64 |= UINT64_C( 0x0001000000000000 );
if ( shiftDist ) {
sig128 = softfloat_shortShiftLeft128( sig64, sig0, -shiftDist );
sig64 = sig128.v64;
sig0 = sig128.v0;
}
} else {
/*--------------------------------------------------------------------
*--------------------------------------------------------------------*/
if ( exp ) sig64 |= UINT64_C( 0x0001000000000000 );
sigExtra = softfloat_shiftRightJam64Extra( sig64, sig0, shiftDist );
sig64 = sigExtra.v;
sig0 = sigExtra.extra;
}
return softfloat_roundToUI64( sign, sig64, sig0, roundingMode, exact );
}
int_fast64_t f32_to_i64( float32_t a, uint_fast8_t roundingMode, bool exact )
{
union ui32_f32 uA;
uint_fast32_t uiA;
bool sign;
int_fast16_t exp;
uint_fast32_t sig;
int_fast16_t shiftDist;
#ifdef SOFTFLOAT_FAST_INT64
uint_fast64_t sig64, extra;
struct uint64_extra sig64Extra;
#else
uint32_t extSig[3];
#endif
/*------------------------------------------------------------------------
*------------------------------------------------------------------------*/
uA.f = a;
uiA = uA.ui;
sign = signF32UI( uiA );
exp = expF32UI( uiA );
sig = fracF32UI( uiA );
/*------------------------------------------------------------------------
*------------------------------------------------------------------------*/
shiftDist = 0xBE - exp;
if ( shiftDist < 0 ) {
softfloat_raiseFlags( softfloat_flag_invalid );
return
(exp == 0xFF) && sig ? i64_fromNaN
: sign ? i64_fromNegOverflow : i64_fromPosOverflow;
}
/*------------------------------------------------------------------------
*------------------------------------------------------------------------*/
if ( exp ) sig |= 0x00800000;
#ifdef SOFTFLOAT_FAST_INT64
sig64 = (uint_fast64_t) sig<<40;
extra = 0;
if ( shiftDist ) {
sig64Extra = softfloat_shiftRightJam64Extra( sig64, 0, shiftDist );
sig64 = sig64Extra.v;
extra = sig64Extra.extra;
}
return softfloat_roundToI64( sign, sig64, extra, roundingMode, exact );
#else
extSig[indexWord( 3, 2 )] = sig<<8;
extSig[indexWord( 3, 1 )] = 0;
extSig[indexWord( 3, 0 )] = 0;
if ( shiftDist ) softfloat_shiftRightJam96M( extSig, shiftDist, extSig );
return softfloat_roundMToI64( sign, extSig, roundingMode, exact );
#endif
}
int_fast64_t
extF80_to_i64( extFloat80_t a, uint_fast8_t roundingMode, bool exact )
{
union { struct extFloat80M s; extFloat80_t f; } uA;
uint_fast16_t uiA64;
bool sign;
int_fast32_t exp;
uint_fast64_t sig;
int_fast32_t shiftDist;
uint_fast64_t sigExtra;
struct uint64_extra sig64Extra;
/*------------------------------------------------------------------------
*------------------------------------------------------------------------*/
uA.f = a;
uiA64 = uA.s.signExp;
sign = signExtF80UI64( uiA64 );
exp = expExtF80UI64( uiA64 );
sig = uA.s.signif;
/*------------------------------------------------------------------------
*------------------------------------------------------------------------*/
shiftDist = 0x403E - exp;
if ( shiftDist <= 0 ) {
/*--------------------------------------------------------------------
*--------------------------------------------------------------------*/
if ( shiftDist ) {
softfloat_raiseFlags( softfloat_flag_invalid );
return
(exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
? i64_fromNaN
: sign ? i64_fromNegOverflow : i64_fromPosOverflow;
}
/*--------------------------------------------------------------------
*--------------------------------------------------------------------*/
sigExtra = 0;
} else {
/*--------------------------------------------------------------------
*--------------------------------------------------------------------*/
sig64Extra = softfloat_shiftRightJam64Extra( sig, 0, shiftDist );
sig = sig64Extra.v;
sigExtra = sig64Extra.extra;
}
return
softfloat_roundPackToI64( sign, sig, sigExtra, roundingMode, exact );
}
uint_fast64_t f64_to_ui64( float64_t a, uint_fast8_t roundingMode, bool exact )
{
union ui64_f64 uA;
uint_fast64_t uiA;
bool sign;
int_fast16_t exp;
uint_fast64_t sig;
int_fast16_t shiftDist;
#ifdef SOFTFLOAT_FAST_INT64
struct uint64_extra sigExtra;
#else
uint32_t extSig[3];
#endif
/*------------------------------------------------------------------------
*------------------------------------------------------------------------*/
uA.f = a;
uiA = uA.ui;
sign = signF64UI( uiA );
exp = expF64UI( uiA );
sig = fracF64UI( uiA );
/*------------------------------------------------------------------------
*------------------------------------------------------------------------*/
if ( exp ) sig |= UINT64_C( 0x0010000000000000 );
shiftDist = 0x433 - exp;
#ifdef SOFTFLOAT_FAST_INT64
if ( shiftDist <= 0 ) {
if ( shiftDist < -11 ) goto invalid;
sigExtra.v = sig<<-shiftDist;
sigExtra.extra = 0;
} else {
sigExtra = softfloat_shiftRightJam64Extra( sig, 0, shiftDist );
}
return
softfloat_roundToUI64(
sign, sigExtra.v, sigExtra.extra, roundingMode, exact );
#else
extSig[indexWord( 3, 0 )] = 0;
if ( shiftDist <= 0 ) {
if ( shiftDist < -11 ) goto invalid;
sig <<= -shiftDist;
extSig[indexWord( 3, 2 )] = sig>>32;
extSig[indexWord( 3, 1 )] = sig;
} else {
int_fast64_t f128_to_i64( float128_t a, uint_fast8_t roundingMode, bool exact )
{
union ui128_f128 uA;
uint_fast64_t uiA64, uiA0;
bool sign;
int_fast32_t exp;
uint_fast64_t sig64, sig0;
int_fast32_t shiftCount;
struct uint128 sig128;
struct uint64_extra sigExtra;
uA.f = a;
uiA64 = uA.ui.v64;
uiA0 = uA.ui.v0;
sign = signF128UI64( uiA64 );
exp = expF128UI64( uiA64 );
sig64 = fracF128UI64( uiA64 );
sig0 = uiA0;
shiftCount = 0x402F - exp;
if ( shiftCount <= 0 ) {
if ( shiftCount < -15 ) {
softfloat_raiseFlags( softfloat_flag_invalid );
return
! sign || ((exp == 0x7FFF) && (sig64 | sig0))
? INT64_C( 0x7FFFFFFFFFFFFFFF )
: -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1;
}
sig64 |= UINT64_C( 0x0001000000000000 );
if ( shiftCount ) {
sig128 = softfloat_shortShiftLeft128( sig64, sig0, -shiftCount );
sig64 = sig128.v64;
sig0 = sig128.v0;
}
} else {
if ( exp ) sig64 |= UINT64_C( 0x0001000000000000 );
sigExtra = softfloat_shiftRightJam64Extra( sig64, sig0, shiftCount );
sig64 = sigExtra.v;
sig0 = sigExtra.extra;
}
return softfloat_roundPackToI64( sign, sig64, sig0, roundingMode, exact );
}
int_fast64_t
extF80_to_i64( extFloat80_t a, uint_fast8_t roundingMode, bool exact )
{
union {
struct extFloat80M s;
extFloat80_t f;
} uA;
uint_fast16_t uiA64;
bool sign;
int_fast32_t exp;
uint_fast64_t sig;
int_fast32_t shiftCount;
uint_fast64_t sigExtra;
struct uint64_extra sig64Extra;
uA.f = a;
uiA64 = uA.s.signExp;
sign = signExtF80UI64( uiA64 );
exp = expExtF80UI64( uiA64 );
sig = uA.s.signif;
shiftCount = 0x403E - exp;
if ( shiftCount <= 0 ) {
if ( shiftCount ) {
softfloat_raiseFlags( softfloat_flag_invalid );
return
! sign
|| ((exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF )))
? INT64_C( 0x7FFFFFFFFFFFFFFF )
: -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1;
}
sigExtra = 0;
} else {
sig64Extra = softfloat_shiftRightJam64Extra( sig, 0, shiftCount );
sig = sig64Extra.v;
sigExtra = sig64Extra.extra;
}
return
softfloat_roundPackToI64( sign, sig, sigExtra, roundingMode, exact );
}
extFloat80_t
softfloat_roundPackToExtF80(
bool sign,
int_fast32_t exp,
uint_fast64_t sig,
uint_fast64_t sigExtra,
uint_fast8_t roundingPrecision
)
{
uint_fast8_t roundingMode;
bool roundNearEven;
uint_fast64_t roundIncrement, roundMask, roundBits;
bool isTiny, doIncrement;
struct uint64_extra sig64Extra;
union { struct extFloat80M s; extFloat80_t f; } uZ;
roundingMode = softfloat_roundingMode;
roundNearEven = (roundingMode == softfloat_round_near_even);
if ( roundingPrecision == 80 ) goto precision80;
if ( roundingPrecision == 64 ) {
roundIncrement = UINT64_C( 0x0000000000000400 );
roundMask = UINT64_C( 0x00000000000007FF );
} else if ( roundingPrecision == 32 ) {
roundIncrement = UINT64_C( 0x0000008000000000 );
roundMask = UINT64_C( 0x000000FFFFFFFFFF );
} else {
goto precision80;
}
sig |= (sigExtra != 0);
if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) {
roundIncrement =
(roundingMode
== (sign ? softfloat_round_min : softfloat_round_max))
? roundMask
: 0;
}
roundBits = sig & roundMask;
if ( 0x7FFD <= (uint32_t) (exp - 1) ) {
if ( exp <= 0 ) {
isTiny =
(softfloat_detectTininess
== softfloat_tininess_beforeRounding)
|| (exp < 0)
|| (sig <= (uint64_t) (sig + roundIncrement));
sig = softfloat_shiftRightJam64( sig, 1 - exp );
roundBits = sig & roundMask;
if ( isTiny && roundBits ) {
softfloat_raiseFlags( softfloat_flag_underflow );
}
if ( roundBits ) {
softfloat_exceptionFlags |= softfloat_flag_inexact;
}
sig += roundIncrement;
exp = ((sig & UINT64_C( 0x8000000000000000 )) != 0);
roundIncrement = roundMask + 1;
if ( roundNearEven && (roundBits<<1 == roundIncrement) ) {
roundMask |= roundIncrement;
}
sig &= ~roundMask;
goto packReturn;
}
if (
(0x7FFE < exp)
|| ((exp == 0x7FFE) && ((uint64_t) (sig + roundIncrement) < sig))
) {
goto overflow;
}
}
if ( roundBits ) softfloat_exceptionFlags |= softfloat_flag_inexact;
sig = (uint64_t) (sig + roundIncrement);
if ( sig < roundIncrement ) {
++exp;
sig = UINT64_C( 0x8000000000000000 );
}
roundIncrement = roundMask + 1;
if ( roundNearEven && (roundBits<<1 == roundIncrement) ) {
roundMask |= roundIncrement;
}
sig &= ~roundMask;
if ( ! sig ) exp = 0;
goto packReturn;
precision80:
doIncrement = (UINT64_C( 0x8000000000000000 ) <= sigExtra);
if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) {
doIncrement =
(roundingMode
== (sign ? softfloat_round_min : softfloat_round_max))
&& sigExtra;
}
if ( 0x7FFD <= (uint32_t) (exp - 1) ) {
if ( exp <= 0 ) {
isTiny =
(softfloat_detectTininess
== softfloat_tininess_beforeRounding)
|| (exp < 0)
|| ! doIncrement
|| (sig < UINT64_C( 0xFFFFFFFFFFFFFFFF ));
sig64Extra =
softfloat_shiftRightJam64Extra( sig, sigExtra, 1 - exp );
sig = sig64Extra.v;
sigExtra = sig64Extra.extra;
if ( isTiny && sigExtra ) {
softfloat_raiseFlags( softfloat_flag_underflow );
}
if ( sigExtra ) softfloat_exceptionFlags |= softfloat_flag_inexact;
doIncrement = (UINT64_C( 0x8000000000000000 ) <= sigExtra);
if (
! roundNearEven
&& (roundingMode != softfloat_round_near_maxMag)
) {
doIncrement =
(roundingMode
== (sign ? softfloat_round_min : softfloat_round_max))
&& sigExtra;
}
exp = 0;
if ( doIncrement ) {
++sig;
sig &=
~(uint_fast64_t)
(! (sigExtra & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
& roundNearEven);
exp = ((sig & UINT64_C( 0x8000000000000000 )) != 0);
}
goto packReturn;
}
if (
(0x7FFE < exp)
|| ((exp == 0x7FFE) && (sig == UINT64_C( 0xFFFFFFFFFFFFFFFF ))
&& doIncrement)
) {
roundMask = 0;
overflow:
softfloat_raiseFlags(
softfloat_flag_overflow | softfloat_flag_inexact );
if (
roundNearEven
|| (roundingMode == softfloat_round_near_maxMag)
|| (roundingMode
== (sign ? softfloat_round_min : softfloat_round_max))
) {
exp = 0x7FFF;
sig = UINT64_C( 0x8000000000000000 );
} else {
exp = 0x7FFE;
sig = ~roundMask;
}
goto packReturn;
}
}
if ( sigExtra ) softfloat_exceptionFlags |= softfloat_flag_inexact;
if ( doIncrement ) {
++sig;
if ( ! sig ) {
++exp;
sig = UINT64_C( 0x8000000000000000 );
} else {
sig &=
~(uint_fast64_t)
(! (sigExtra & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
& roundNearEven);
}
} else {
if ( ! sig ) exp = 0;
}
packReturn:
uZ.s.signExp = packToExtF80UI64( sign, exp );
uZ.s.signif = sig;
return uZ.f;
}
extFloat80_t
softfloat_addMagsExtF80(
uint_fast16_t uiA64,
uint_fast64_t uiA0,
uint_fast16_t uiB64,
uint_fast64_t uiB0,
bool signZ
)
{
int_fast32_t expA;
uint_fast64_t sigA;
int_fast32_t expB;
uint_fast64_t sigB;
int_fast32_t expDiff;
uint_fast16_t uiZ64;
uint_fast64_t uiZ0, sigZ, sigZExtra;
struct exp32_sig64 normExpSig;
int_fast32_t expZ;
struct uint64_extra sig64Extra;
struct uint128 uiZ;
union { struct extFloat80M s; extFloat80_t f; } uZ;
/*------------------------------------------------------------------------
*------------------------------------------------------------------------*/
expA = expExtF80UI64( uiA64 );
sigA = uiA0;
expB = expExtF80UI64( uiB64 );
sigB = uiB0;
/*------------------------------------------------------------------------
*------------------------------------------------------------------------*/
expDiff = expA - expB;
if ( ! expDiff ) {
if ( expA == 0x7FFF ) {
if ( (sigA | sigB) & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
goto propagateNaN;
}
uiZ64 = uiA64;
uiZ0 = uiA0;
goto uiZ;
}
sigZ = sigA + sigB;
sigZExtra = 0;
if ( ! expA ) {
normExpSig = softfloat_normSubnormalExtF80Sig( sigZ );
expZ = normExpSig.exp + 1;
sigZ = normExpSig.sig;
goto roundAndPack;
}
expZ = expA;
goto shiftRight1;
}
/*------------------------------------------------------------------------
*------------------------------------------------------------------------*/
if ( expDiff < 0 ) {
if ( expB == 0x7FFF ) {
if ( sigB & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) goto propagateNaN;
uiZ64 = packToExtF80UI64( signZ, 0x7FFF );
uiZ0 = uiB0;
goto uiZ;
}
expZ = expB;
if ( ! expA ) {
++expDiff;
sigZExtra = 0;
if ( ! expDiff ) goto newlyAligned;
}
sig64Extra = softfloat_shiftRightJam64Extra( sigA, 0, -expDiff );
sigA = sig64Extra.v;
sigZExtra = sig64Extra.extra;
} else {
if ( expA == 0x7FFF ) {
if ( sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) goto propagateNaN;
uiZ64 = uiA64;
uiZ0 = uiA0;
goto uiZ;
}
expZ = expA;
if ( ! expB ) {
--expDiff;
sigZExtra = 0;
if ( ! expDiff ) goto newlyAligned;
}
sig64Extra = softfloat_shiftRightJam64Extra( sigB, 0, expDiff );
sigB = sig64Extra.v;
sigZExtra = sig64Extra.extra;
}
newlyAligned:
sigZ = sigA + sigB;
if ( sigZ & UINT64_C( 0x8000000000000000 ) ) goto roundAndPack;
/*------------------------------------------------------------------------
*------------------------------------------------------------------------*/
shiftRight1:
sig64Extra = softfloat_shortShiftRightJam64Extra( sigZ, sigZExtra, 1 );
sigZ = sig64Extra.v | UINT64_C( 0x8000000000000000 );
sigZExtra = sig64Extra.extra;
++expZ;
roundAndPack:
return
softfloat_roundPackToExtF80(
signZ, expZ, sigZ, sigZExtra, extF80_roundingPrecision );
/*------------------------------------------------------------------------
*------------------------------------------------------------------------*/
propagateNaN:
uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 );
uiZ64 = uiZ.v64;
uiZ0 = uiZ.v0;
uiZ:
uZ.s.signExp = uiZ64;
uZ.s.signif = uiZ0;
return uZ.f;
}