101 changes: 48 additions & 53 deletions libc/utils/FPUtil/LongDoubleBitsX86.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -28,7 +28,7 @@ template <> struct Padding<4> { static constexpr unsigned value = 16; };
// x86_64 padding.
template <> struct Padding<8> { static constexpr unsigned value = 48; };

template <> struct __attribute__((packed)) FPBits<long double> {
template <> union FPBits<long double> {
using UIntType = __uint128_t;

static constexpr int exponentBias = 0x3FFF;
Expand All @@ -43,102 +43,97 @@ template <> struct __attribute__((packed)) FPBits<long double> {
((UIntType(maxExponent) - 1) << (MantissaWidth<long double>::value + 1)) |
(UIntType(1) << MantissaWidth<long double>::value) | maxSubnormal;

UIntType mantissa : MantissaWidth<long double>::value;
uint8_t implicitBit : 1;
uint16_t exponent : ExponentWidth<long double>::value;
uint8_t sign : 1;
uint64_t padding : Padding<sizeof(uintptr_t)>::value;
struct __attribute__((packed)) {
UIntType mantissa : MantissaWidth<long double>::value;
uint8_t implicitBit : 1;
uint16_t exponent : ExponentWidth<long double>::value;
uint8_t sign : 1;
uint64_t padding : Padding<sizeof(uintptr_t)>::value;
} encoding;
UIntType integer;
long double val;

FPBits() : integer(0) {}

template <typename XType,
cpp::EnableIfType<cpp::IsSame<long double, XType>::Value, int> = 0>
explicit FPBits<long double>(XType x) {
*this = *reinterpret_cast<FPBits<long double> *>(&x);
}
explicit FPBits<long double>(XType x) : val(x) {}

template <typename XType,
cpp::EnableIfType<cpp::IsSame<XType, UIntType>::Value, int> = 0>
explicit FPBits(XType x) : integer(x) {}

operator long double() { return val; }

operator long double() { return *reinterpret_cast<long double *>(this); }
UIntType uintval() {
// We zero the padding bits as they can contain garbage.
static constexpr UIntType mask =
(UIntType(1) << (sizeof(long double) * 8 -
Padding<sizeof(uintptr_t)>::value)) -
1;
return integer & mask;
}

int getExponent() const {
if (exponent == 0)
if (encoding.exponent == 0)
return int(1) - exponentBias;
return int(exponent) - exponentBias;
return int(encoding.exponent) - exponentBias;
}

bool isZero() const {
return exponent == 0 && mantissa == 0 && implicitBit == 0;
return encoding.exponent == 0 && encoding.mantissa == 0 &&
encoding.implicitBit == 0;
}

bool isInf() const {
return exponent == maxExponent && mantissa == 0 && implicitBit == 1;
return encoding.exponent == maxExponent && encoding.mantissa == 0 &&
encoding.implicitBit == 1;
}

bool isNaN() const {
if (exponent == maxExponent) {
return (implicitBit == 0) || mantissa != 0;
} else if (exponent != 0) {
return implicitBit == 0;
if (encoding.exponent == maxExponent) {
return (encoding.implicitBit == 0) || encoding.mantissa != 0;
} else if (encoding.exponent != 0) {
return encoding.implicitBit == 0;
}
return false;
}

bool isInfOrNaN() const {
return (exponent == maxExponent) || (exponent != 0 && implicitBit == 0);
return (encoding.exponent == maxExponent) ||
(encoding.exponent != 0 && encoding.implicitBit == 0);
}

// Methods below this are used by tests.

template <typename XType,
cpp::EnableIfType<cpp::IsSame<UIntType, XType>::Value, int> = 0>
explicit FPBits<long double>(XType x) {
// The last 4 bytes of v are ignored in case of i386.
*this = *reinterpret_cast<FPBits<long double> *>(&x);
}

UIntType bitsAsUInt() const {
// We cannot just return the bits as is as it will lead to reading
// out of bounds in case of i386. So, we first copy the wider value
// before returning the value. This makes the last 4 bytes are always
// zero in case i386.
UIntType result = UIntType(0);
*reinterpret_cast<FPBits<long double> *>(&result) = *this;

// Even though we zero out |result| before copying the long double value,
// there can be garbage bits in the padding. So, we zero the padding bits
// in |result|.
static constexpr UIntType mask =
(UIntType(1) << (sizeof(long double) * 8 -
Padding<sizeof(uintptr_t)>::value)) -
1;
return result & mask;
}

static FPBits<long double> zero() { return FPBits<long double>(0.0l); }

static FPBits<long double> negZero() {
FPBits<long double> bits(0.0l);
bits.sign = 1;
bits.encoding.sign = 1;
return bits;
}

static FPBits<long double> inf() {
FPBits<long double> bits(0.0l);
bits.exponent = maxExponent;
bits.implicitBit = 1;
bits.encoding.exponent = maxExponent;
bits.encoding.implicitBit = 1;
return bits;
}

static FPBits<long double> negInf() {
FPBits<long double> bits(0.0l);
bits.exponent = maxExponent;
bits.implicitBit = 1;
bits.sign = 1;
bits.encoding.exponent = maxExponent;
bits.encoding.implicitBit = 1;
bits.encoding.sign = 1;
return bits;
}

static long double buildNaN(UIntType v) {
FPBits<long double> bits(0.0l);
bits.exponent = maxExponent;
bits.implicitBit = 1;
bits.mantissa = v;
bits.encoding.exponent = maxExponent;
bits.encoding.implicitBit = 1;
bits.encoding.mantissa = v;
return bits;
}
};
Expand Down
14 changes: 7 additions & 7 deletions libc/utils/FPUtil/ManipulationFunctions.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -47,13 +47,13 @@ static inline T modf(T x, T &iptr) {
return x;
} else if (bits.isInf()) {
iptr = x;
return bits.sign ? FPBits<T>::negZero() : FPBits<T>::zero();
return bits.encoding.sign ? FPBits<T>::negZero() : FPBits<T>::zero();
} else {
iptr = trunc(x);
if (x == iptr) {
// If x is already an integer value, then return zero with the right
// sign.
return bits.sign ? FPBits<T>::negZero() : FPBits<T>::zero();
return bits.encoding.sign ? FPBits<T>::negZero() : FPBits<T>::zero();
} else {
return x - iptr;
}
Expand All @@ -64,7 +64,7 @@ template <typename T,
cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
static inline T copysign(T x, T y) {
FPBits<T> xbits(x);
xbits.sign = FPBits<T>(y).sign;
xbits.encoding.sign = FPBits<T>(y).encoding.sign;
return xbits;
}

Expand Down Expand Up @@ -131,11 +131,11 @@ static inline T ldexp(T x, int exp) {
// calculating the limit.
int expLimit = FPBits<T>::maxExponent + MantissaWidth<T>::value + 1;
if (exp > expLimit)
return bits.sign ? FPBits<T>::negInf() : FPBits<T>::inf();
return bits.encoding.sign ? FPBits<T>::negInf() : FPBits<T>::inf();

// Similarly on the negative side we return zero early if |exp| is too small.
if (exp < -expLimit)
return bits.sign ? FPBits<T>::negZero() : FPBits<T>::zero();
return bits.encoding.sign ? FPBits<T>::negZero() : FPBits<T>::zero();

// For all other values, NormalFloat to T conversion handles it the right way.
NormalFloat<T> normal(bits);
Expand All @@ -158,7 +158,7 @@ static inline T nextafter(T from, T to) {
return to;

using UIntType = typename FPBits<T>::UIntType;
auto intVal = fromBits.bitsAsUInt();
UIntType intVal = fromBits.uintval();
UIntType signMask = (UIntType(1) << (sizeof(T) * 8 - 1));
if (from != T(0.0)) {
if ((from < to) == (from > T(0.0))) {
Expand All @@ -167,7 +167,7 @@ static inline T nextafter(T from, T to) {
--intVal;
}
} else {
intVal = (toBits.bitsAsUInt() & signMask) + UIntType(1);
intVal = (UIntType(toBits) & signMask) + UIntType(1);
}

return *reinterpret_cast<T *>(&intVal);
Expand Down
34 changes: 17 additions & 17 deletions libc/utils/FPUtil/NearestIntegerOperations.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -43,14 +43,14 @@ static inline T trunc(T x) {

// If the exponent is such that abs(x) is less than 1, then return 0.
if (exponent <= -1) {
if (bits.sign)
if (bits.encoding.sign)
return T(-0.0);
else
return T(0.0);
}

int trimSize = MantissaWidth<T>::value - exponent;
bits.mantissa = (bits.mantissa >> trimSize) << trimSize;
bits.encoding.mantissa = (bits.encoding.mantissa >> trimSize) << trimSize;
return bits;
}

Expand All @@ -63,7 +63,7 @@ static inline T ceil(T x) {
if (bits.isInfOrNaN() || bits.isZero())
return x;

bool isNeg = bits.sign;
bool isNeg = bits.encoding.sign;
int exponent = bits.getExponent();

// If the exponent is greater than the most negative mantissa
Expand All @@ -79,7 +79,7 @@ static inline T ceil(T x) {
}

uint32_t trimSize = MantissaWidth<T>::value - exponent;
bits.mantissa = (bits.mantissa >> trimSize) << trimSize;
bits.encoding.mantissa = (bits.encoding.mantissa >> trimSize) << trimSize;
T truncValue = T(bits);

// If x is already an integer, return it.
Expand All @@ -97,7 +97,7 @@ template <typename T,
cpp::EnableIfType<cpp::IsFloatingPointType<T>::Value, int> = 0>
static inline T floor(T x) {
FPBits<T> bits(x);
if (bits.sign) {
if (bits.encoding.sign) {
return -ceil(-x);
} else {
return trunc(x);
Expand All @@ -114,7 +114,7 @@ static inline T round(T x) {
if (bits.isInfOrNaN() || bits.isZero())
return x;

bool isNeg = bits.sign;
bool isNeg = bits.encoding.sign;
int exponent = bits.getExponent();

// If the exponent is greater than the most negative mantissa
Expand All @@ -139,8 +139,8 @@ static inline T round(T x) {
}

uint32_t trimSize = MantissaWidth<T>::value - exponent;
bool halfBitSet = bits.mantissa & (UIntType(1) << (trimSize - 1));
bits.mantissa = (bits.mantissa >> trimSize) << trimSize;
bool halfBitSet = bits.encoding.mantissa & (UIntType(1) << (trimSize - 1));
bits.encoding.mantissa = (bits.encoding.mantissa >> trimSize) << trimSize;
T truncValue = T(bits);

// If x is already an integer, return it.
Expand All @@ -166,7 +166,7 @@ static inline T roundUsingCurrentRoundingMode(T x) {
if (bits.isInfOrNaN() || bits.isZero())
return x;

bool isNeg = bits.sign;
bool isNeg = bits.encoding.sign;
int exponent = bits.getExponent();
int roundingMode = getRound();

Expand All @@ -184,7 +184,7 @@ static inline T roundUsingCurrentRoundingMode(T x) {
case FE_TOWARDZERO:
return isNeg ? T(-0.0) : T(0.0);
case FE_TONEAREST:
if (exponent <= -2 || bits.mantissa == 0)
if (exponent <= -2 || bits.encoding.mantissa == 0)
return isNeg ? T(-0.0) : T(0.0); // abs(x) <= 0.5
else
return isNeg ? T(-1.0) : T(1.0); // abs(x) > 0.5
Expand All @@ -195,19 +195,19 @@ static inline T roundUsingCurrentRoundingMode(T x) {

uint32_t trimSize = MantissaWidth<T>::value - exponent;
FPBits<T> newBits = bits;
newBits.mantissa = (bits.mantissa >> trimSize) << trimSize;
newBits.encoding.mantissa = (bits.encoding.mantissa >> trimSize) << trimSize;
T truncValue = T(newBits);

// If x is already an integer, return it.
if (truncValue == x)
return x;

UIntType trimValue = bits.mantissa & ((UIntType(1) << trimSize) - 1);
UIntType trimValue = bits.encoding.mantissa & ((UIntType(1) << trimSize) - 1);
UIntType halfValue = (UIntType(1) << (trimSize - 1));
// If exponent is 0, trimSize will be equal to the mantissa width, and
// truncIsOdd` will not be correct. So, we handle it as a special case
// below.
UIntType truncIsOdd = newBits.mantissa & (UIntType(1) << trimSize);
UIntType truncIsOdd = newBits.encoding.mantissa & (UIntType(1) << trimSize);

switch (roundingMode) {
case FE_DOWNWARD:
Expand Down Expand Up @@ -255,18 +255,18 @@ static inline I roundedFloatToSignedInteger(F x) {

if (bits.isInfOrNaN()) {
setDomainErrorAndRaiseInvalid();
return bits.sign ? IntegerMin : IntegerMax;
return bits.encoding.sign ? IntegerMin : IntegerMax;
}

int exponent = bits.getExponent();
constexpr int exponentLimit = sizeof(I) * 8 - 1;
if (exponent > exponentLimit) {
setDomainErrorAndRaiseInvalid();
return bits.sign ? IntegerMin : IntegerMax;
return bits.encoding.sign ? IntegerMin : IntegerMax;
} else if (exponent == exponentLimit) {
if (bits.sign == 0 || bits.mantissa != 0) {
if (bits.encoding.sign == 0 || bits.encoding.mantissa != 0) {
setDomainErrorAndRaiseInvalid();
return bits.sign ? IntegerMin : IntegerMax;
return bits.encoding.sign ? IntegerMin : IntegerMax;
}
// If the control reaches here, then it means that the rounded
// value is the most negative number for the signed integer type I.
Expand Down
22 changes: 11 additions & 11 deletions libc/utils/FPUtil/NextAfterLongDoubleX86.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -30,27 +30,27 @@ static inline long double nextafter(long double from, long double to) {
return to;

// Convert pseudo subnormal number to normal number.
if (fromBits.implicitBit == 1 && fromBits.exponent == 0) {
fromBits.exponent = 1;
if (fromBits.encoding.implicitBit == 1 && fromBits.encoding.exponent == 0) {
fromBits.encoding.exponent = 1;
}

using UIntType = FPBits::UIntType;
constexpr UIntType signVal = (UIntType(1) << 79);
constexpr UIntType mantissaMask =
(UIntType(1) << MantissaWidth<long double>::value) - 1;
auto intVal = fromBits.bitsAsUInt();
UIntType intVal = fromBits.uintval();
if (from < 0.0l) {
if (from > to) {
if (intVal == (signVal + FPBits::maxSubnormal)) {
// We deal with normal/subnormal boundary separately to avoid
// dealing with the implicit bit.
intVal = signVal + FPBits::minNormal;
} else if ((intVal & mantissaMask) == mantissaMask) {
fromBits.mantissa = 0;
fromBits.encoding.mantissa = 0;
// Incrementing exponent might overflow the value to infinity,
// which is what is expected. Since NaNs are handling separately,
// it will never overflow "beyond" infinity.
++fromBits.exponent;
++fromBits.encoding.exponent;
return fromBits;
} else {
++intVal;
Expand All @@ -61,10 +61,10 @@ static inline long double nextafter(long double from, long double to) {
// dealing with the implicit bit.
intVal = signVal + FPBits::maxSubnormal;
} else if ((intVal & mantissaMask) == 0) {
fromBits.mantissa = mantissaMask;
fromBits.encoding.mantissa = mantissaMask;
// from == 0 is handled separately so decrementing the exponent will not
// lead to underflow.
--fromBits.exponent;
--fromBits.encoding.exponent;
return fromBits;
} else {
--intVal;
Expand All @@ -80,10 +80,10 @@ static inline long double nextafter(long double from, long double to) {
if (intVal == FPBits::minNormal) {
intVal = FPBits::maxSubnormal;
} else if ((intVal & mantissaMask) == 0) {
fromBits.mantissa = mantissaMask;
fromBits.encoding.mantissa = mantissaMask;
// from == 0 is handled separately so decrementing the exponent will not
// lead to underflow.
--fromBits.exponent;
--fromBits.encoding.exponent;
return fromBits;
} else {
--intVal;
Expand All @@ -92,11 +92,11 @@ static inline long double nextafter(long double from, long double to) {
if (intVal == FPBits::maxSubnormal) {
intVal = FPBits::minNormal;
} else if ((intVal & mantissaMask) == mantissaMask) {
fromBits.mantissa = 0;
fromBits.encoding.mantissa = 0;
// Incrementing exponent might overflow the value to infinity,
// which is what is expected. Since NaNs are handling separately,
// it will never overflow "beyond" infinity.
++fromBits.exponent;
++fromBits.encoding.exponent;
return fromBits;
} else {
++intVal;
Expand Down
73 changes: 37 additions & 36 deletions libc/utils/FPUtil/NormalFloat.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -97,7 +97,7 @@ template <typename T> struct NormalFloat {
}

FPBits<T> result(T(0.0));
result.sign = sign;
result.encoding.sign = sign;

constexpr int subnormalExponent = -FPBits<T>::exponentBias + 1;
if (exponent < subnormalExponent) {
Expand All @@ -110,36 +110,36 @@ template <typename T> struct NormalFloat {
const UIntType shiftOutMask = (UIntType(1) << shift) - 1;
const UIntType shiftOutValue = mantissa & shiftOutMask;
const UIntType halfwayValue = UIntType(1) << (shift - 1);
result.exponent = 0;
result.mantissa = mantissa >> shift;
UIntType newMantissa = result.mantissa;
result.encoding.exponent = 0;
result.encoding.mantissa = mantissa >> shift;
UIntType newMantissa = result.encoding.mantissa;
if (shiftOutValue > halfwayValue) {
newMantissa += 1;
} else if (shiftOutValue == halfwayValue) {
// Round to even.
if (result.mantissa & 0x1)
if (result.encoding.mantissa & 0x1)
newMantissa += 1;
}
result.mantissa = newMantissa;
result.encoding.mantissa = newMantissa;
// Adding 1 to mantissa can lead to overflow. This can only happen if
// mantissa was all ones (0b111..11). For such a case, we will carry
// the overflow into the exponent.
if (newMantissa == one)
result.exponent = 1;
result.encoding.exponent = 1;
return result;
} else {
return result;
}
}

result.exponent = exponent + FPBits<T>::exponentBias;
result.mantissa = mantissa;
result.encoding.exponent = exponent + FPBits<T>::exponentBias;
result.encoding.mantissa = mantissa;
return result;
}

private:
void initFromBits(FPBits<T> bits) {
sign = bits.sign;
sign = bits.encoding.sign;

if (bits.isInfOrNaN() || bits.isZero()) {
// Ignore special bit patterns. Implementations deal with them separately
Expand All @@ -150,13 +150,13 @@ template <typename T> struct NormalFloat {
}

// Normalize subnormal numbers.
if (bits.exponent == 0) {
unsigned shift = evaluateNormalizationShift(bits.mantissa);
mantissa = UIntType(bits.mantissa) << shift;
if (bits.encoding.exponent == 0) {
unsigned shift = evaluateNormalizationShift(bits.encoding.mantissa);
mantissa = UIntType(bits.encoding.mantissa) << shift;
exponent = 1 - FPBits<T>::exponentBias - shift;
} else {
exponent = bits.exponent - FPBits<T>::exponentBias;
mantissa = one | bits.mantissa;
exponent = bits.encoding.exponent - FPBits<T>::exponentBias;
mantissa = one | bits.encoding.mantissa;
}
}

Expand All @@ -172,7 +172,7 @@ template <typename T> struct NormalFloat {
#if defined(__x86_64__) || defined(__i386__)
template <>
inline void NormalFloat<long double>::initFromBits(FPBits<long double> bits) {
sign = bits.sign;
sign = bits.encoding.sign;

if (bits.isInfOrNaN() || bits.isZero()) {
// Ignore special bit patterns. Implementations deal with them separately
Expand All @@ -182,24 +182,25 @@ inline void NormalFloat<long double>::initFromBits(FPBits<long double> bits) {
return;
}

if (bits.exponent == 0) {
if (bits.implicitBit == 0) {
if (bits.encoding.exponent == 0) {
if (bits.encoding.implicitBit == 0) {
// Since we ignore zero value, the mantissa in this case is non-zero.
int normalizationShift = evaluateNormalizationShift(bits.mantissa);
int normalizationShift =
evaluateNormalizationShift(bits.encoding.mantissa);
exponent = -16382 - normalizationShift;
mantissa = (bits.mantissa << normalizationShift);
mantissa = (bits.encoding.mantissa << normalizationShift);
} else {
exponent = -16382;
mantissa = one | bits.mantissa;
mantissa = one | bits.encoding.mantissa;
}
} else {
if (bits.implicitBit == 0) {
if (bits.encoding.implicitBit == 0) {
// Invalid number so just store 0 similar to a NaN.
exponent = 0;
mantissa = 0;
} else {
exponent = bits.exponent - 16383;
mantissa = one | bits.mantissa;
exponent = bits.encoding.exponent - 16383;
mantissa = one | bits.encoding.mantissa;
}
}
}
Expand All @@ -213,7 +214,7 @@ template <> inline NormalFloat<long double>::operator long double() const {
}

FPBits<long double> result(0.0l);
result.sign = sign;
result.encoding.sign = sign;

constexpr int subnormalExponent = -FPBits<long double>::exponentBias + 1;
if (exponent < subnormalExponent) {
Expand All @@ -224,35 +225,35 @@ template <> inline NormalFloat<long double>::operator long double() const {
const UIntType shiftOutMask = (UIntType(1) << shift) - 1;
const UIntType shiftOutValue = mantissa & shiftOutMask;
const UIntType halfwayValue = UIntType(1) << (shift - 1);
result.exponent = 0;
result.mantissa = mantissa >> shift;
UIntType newMantissa = result.mantissa;
result.encoding.exponent = 0;
result.encoding.mantissa = mantissa >> shift;
UIntType newMantissa = result.encoding.mantissa;
if (shiftOutValue > halfwayValue) {
newMantissa += 1;
} else if (shiftOutValue == halfwayValue) {
// Round to even.
if (result.mantissa & 0x1)
if (result.encoding.mantissa & 0x1)
newMantissa += 1;
}
result.mantissa = newMantissa;
result.encoding.mantissa = newMantissa;
// Adding 1 to mantissa can lead to overflow. This can only happen if
// mantissa was all ones (0b111..11). For such a case, we will carry
// the overflow into the exponent and set the implicit bit to 1.
if (newMantissa == one) {
result.exponent = 1;
result.implicitBit = 1;
result.encoding.exponent = 1;
result.encoding.implicitBit = 1;
} else {
result.implicitBit = 0;
result.encoding.implicitBit = 0;
}
return result;
} else {
return result;
}
}

result.exponent = biasedExponent;
result.mantissa = mantissa;
result.implicitBit = 1;
result.encoding.exponent = biasedExponent;
result.encoding.mantissa = mantissa;
result.encoding.implicitBit = 1;
return result;
}
#endif
Expand Down
8 changes: 4 additions & 4 deletions libc/utils/FPUtil/Sqrt.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -96,7 +96,7 @@ static inline T sqrt(T x) {
FPBits<T> bits(x);

if (bits.isInfOrNaN()) {
if (bits.sign && (bits.mantissa == 0)) {
if (bits.encoding.sign && (bits.encoding.mantissa == 0)) {
// sqrt(-Inf) = NaN
return FPBits<T>::buildNaN(One >> 1);
} else {
Expand All @@ -108,15 +108,15 @@ static inline T sqrt(T x) {
// sqrt(+0) = +0
// sqrt(-0) = -0
return x;
} else if (bits.sign) {
} else if (bits.encoding.sign) {
// sqrt( negative numbers ) = NaN
return FPBits<T>::buildNaN(One >> 1);
} else {
int xExp = bits.getExponent();
UIntType xMant = bits.mantissa;
UIntType xMant = bits.encoding.mantissa;

// Step 1a: Normalize denormal input and append hiddent bit to the mantissa
if (bits.exponent == 0) {
if (bits.encoding.exponent == 0) {
++xExp; // let xExp be the correct exponent of One bit.
internal::normalize<T>(xExp, xMant);
} else {
Expand Down
16 changes: 8 additions & 8 deletions libc/utils/FPUtil/SqrtLongDoubleX86.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -51,7 +51,7 @@ template <> inline long double sqrt<long double, 0>(long double x) {
FPBits<long double> bits(x);

if (bits.isInfOrNaN()) {
if (bits.sign && (bits.mantissa == 0)) {
if (bits.encoding.sign && (bits.encoding.mantissa == 0)) {
// sqrt(-Inf) = NaN
return FPBits<long double>::buildNaN(One >> 1);
} else {
Expand All @@ -63,17 +63,17 @@ template <> inline long double sqrt<long double, 0>(long double x) {
// sqrt(+0) = +0
// sqrt(-0) = -0
return x;
} else if (bits.sign) {
} else if (bits.encoding.sign) {
// sqrt( negative numbers ) = NaN
return FPBits<long double>::buildNaN(One >> 1);
} else {
int xExp = bits.getExponent();
UIntType xMant = bits.mantissa;
UIntType xMant = bits.encoding.mantissa;

// Step 1a: Normalize denormal input
if (bits.implicitBit) {
if (bits.encoding.implicitBit) {
xMant |= One;
} else if (bits.exponent == 0) {
} else if (bits.encoding.exponent == 0) {
internal::normalize<long double>(xExp, xMant);
}

Expand Down Expand Up @@ -129,9 +129,9 @@ template <> inline long double sqrt<long double, 0>(long double x) {

// Extract output
FPBits<long double> out(0.0L);
out.exponent = xExp;
out.implicitBit = 1;
out.mantissa = (y & (One - 1));
out.encoding.exponent = xExp;
out.encoding.implicitBit = 1;
out.encoding.mantissa = (y & (One - 1));

return out;
}
Expand Down
9 changes: 5 additions & 4 deletions libc/utils/FPUtil/TestHelpers.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -40,7 +40,7 @@ describeValue(const char *label, ValType value,
if (bits.isNaN()) {
stream << "(NaN)";
} else if (bits.isInf()) {
if (bits.sign)
if (bits.encoding.sign)
stream << "(-Infinity)";
else
stream << "(+Infinity)";
Expand All @@ -50,12 +50,13 @@ describeValue(const char *label, ValType value,
constexpr int mantissaWidthInHex =
(fputil::MantissaWidth<ValType>::value - 1) / 4 + 1;

stream << "Sign: " << (bits.sign ? '1' : '0') << ", "
stream << "Sign: " << (bits.encoding.sign ? '1' : '0') << ", "
<< "Exponent: 0x"
<< uintToHex<uint16_t>(bits.exponent, exponentWidthInHex) << ", "
<< uintToHex<uint16_t>(bits.encoding.exponent, exponentWidthInHex)
<< ", "
<< "Mantissa: 0x"
<< uintToHex<typename fputil::FPBits<ValType>::UIntType>(
bits.mantissa, mantissaWidthInHex);
bits.encoding.mantissa, mantissaWidthInHex);
}

stream << '\n';
Expand Down
4 changes: 2 additions & 2 deletions libc/utils/FPUtil/TestHelpers.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -41,13 +41,13 @@ class FPMatcher : public __llvm_libc::testing::Matcher<T> {
fputil::FPBits<T> actualBits(actual), expectedBits(expected);
if (Condition == __llvm_libc::testing::Cond_EQ)
return (actualBits.isNaN() && expectedBits.isNaN()) ||
(actualBits.bitsAsUInt() == expectedBits.bitsAsUInt());
(actualBits.uintval() == expectedBits.uintval());

// If condition == Cond_NE.
if (actualBits.isNaN())
return !expectedBits.isNaN();
return expectedBits.isNaN() ||
(actualBits.bitsAsUInt() != expectedBits.bitsAsUInt());
(actualBits.uintval() != expectedBits.uintval());
}

void explainError(testutils::StreamWrapper &stream) override {
Expand Down
16 changes: 8 additions & 8 deletions libc/utils/MPFRWrapper/MPFRUtils.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -264,12 +264,12 @@ class MPFRNumber {
mpfr_abs(mpfrInput.value, mpfrInput.value, MPFR_RNDN);

// get eps(input)
int epsExponent = bits.exponent - fputil::FPBits<T>::exponentBias -
int epsExponent = bits.encoding.exponent - fputil::FPBits<T>::exponentBias -
fputil::MantissaWidth<T>::value;
if (bits.exponent == 0) {
if (bits.encoding.exponent == 0) {
// correcting denormal exponent
++epsExponent;
} else if ((bits.mantissa == 0) && (bits.exponent > 1) &&
} else if ((bits.encoding.mantissa == 0) && (bits.encoding.exponent > 1) &&
mpfr_less_p(value, mpfrInput.value)) {
// when the input is exactly 2^n, distance (epsilon) between the input
// and the next floating point number is different from the distance to
Expand Down Expand Up @@ -567,7 +567,7 @@ bool compareUnaryOperationSingleOutput(Operation op, T input, T libcResult,
// is rounded to the nearest even.
MPFRNumber mpfrResult = unaryOperation(op, input);
double ulp = mpfrResult.ulp(libcResult);
bool bitsAreEven = ((FPBits<T>(libcResult).bitsAsUInt() & 1) == 0);
bool bitsAreEven = ((FPBits<T>(libcResult).uintval() & 1) == 0);
return (ulp < ulpError) ||
((ulp == ulpError) && ((ulp != 0.5) || bitsAreEven));
}
Expand All @@ -592,7 +592,7 @@ bool compareUnaryOperationTwoOutputs(Operation op, T input,
if (mpfrIntResult != libcResult.i)
return false;

bool bitsAreEven = ((FPBits<T>(libcResult.f).bitsAsUInt() & 1) == 0);
bool bitsAreEven = ((FPBits<T>(libcResult.f).uintval() & 1) == 0);
return (ulp < ulpError) ||
((ulp == ulpError) && ((ulp != 0.5) || bitsAreEven));
}
Expand Down Expand Up @@ -624,7 +624,7 @@ bool compareBinaryOperationTwoOutputs(Operation op, const BinaryInput<T> &input,
}
}

bool bitsAreEven = ((FPBits<T>(libcResult.f).bitsAsUInt() & 1) == 0);
bool bitsAreEven = ((FPBits<T>(libcResult.f).uintval() & 1) == 0);
return (ulp < ulpError) ||
((ulp == ulpError) && ((ulp != 0.5) || bitsAreEven));
}
Expand All @@ -645,7 +645,7 @@ bool compareBinaryOperationOneOutput(Operation op, const BinaryInput<T> &input,
MPFRNumber mpfrResult = binaryOperationOneOutput(op, input.x, input.y);
double ulp = mpfrResult.ulp(libcResult);

bool bitsAreEven = ((FPBits<T>(libcResult).bitsAsUInt() & 1) == 0);
bool bitsAreEven = ((FPBits<T>(libcResult).uintval() & 1) == 0);
return (ulp < ulpError) ||
((ulp == ulpError) && ((ulp != 0.5) || bitsAreEven));
}
Expand All @@ -667,7 +667,7 @@ bool compareTernaryOperationOneOutput(Operation op,
ternaryOperationOneOutput(op, input.x, input.y, input.z);
double ulp = mpfrResult.ulp(libcResult);

bool bitsAreEven = ((FPBits<T>(libcResult).bitsAsUInt() & 1) == 0);
bool bitsAreEven = ((FPBits<T>(libcResult).uintval() & 1) == 0);
return (ulp < ulpError) ||
((ulp == ulpError) && ((ulp != 0.5) || bitsAreEven));
}
Expand Down