23#include "llvm/Config/llvm-config.h"
31#define APFLOAT_DISPATCH_ON_SEMANTICS(METHOD_CALL) \
33 if (usesLayout<IEEEFloat>(getSemantics())) \
34 return U.IEEE.METHOD_CALL; \
35 if (usesLayout<DoubleAPFloat>(getSemantics())) \
36 return U.Double.METHOD_CALL; \
37 llvm_unreachable("Unexpected semantics"); \
48#define PackCategoriesIntoKey(_lhs, _rhs) ((_lhs) * 4 + (_rhs))
345 if (Src.maxExponent >= Dst.maxExponent || Src.minExponent <= Dst.minExponent)
353 return Dst.precision >= Src.precision;
391static inline unsigned int
405 unsigned int absExponent;
406 const unsigned int overlargeExponent = 24000;
410 if (p == end || ((*p ==
'-' || *p ==
'+') && (p + 1) == end)) {
414 isNegative = (*p ==
'-');
415 if (*p ==
'-' || *p ==
'+') {
422 if (absExponent >= 10U)
423 return createError(
"Invalid character in exponent");
425 for (; p != end; ++p) {
430 return createError(
"Invalid character in exponent");
432 absExponent = absExponent * 10U +
value;
433 if (absExponent >= overlargeExponent) {
434 absExponent = overlargeExponent;
440 return -(int) absExponent;
442 return (
int) absExponent;
449 int exponentAdjustment) {
450 int unsignedExponent;
451 bool negative, overflow;
457 negative = *p ==
'-';
458 if (*p ==
'-' || *p ==
'+') {
464 unsignedExponent = 0;
466 for (; p != end; ++p) {
471 return createError(
"Invalid character in exponent");
473 unsignedExponent = unsignedExponent * 10 +
value;
474 if (unsignedExponent > 32767) {
480 if (exponentAdjustment > 32767 || exponentAdjustment < -32768)
484 exponent = unsignedExponent;
486 exponent = -exponent;
487 exponent += exponentAdjustment;
488 if (exponent > 32767 || exponent < -32768)
493 exponent = negative ? -32768: 32767;
503 while (p != end && *p ==
'0')
506 if (p != end && *p ==
'.') {
509 if (end - begin == 1)
512 while (p != end && *p ==
'0')
545 return PtrOrErr.takeError();
548 D->firstSigDigit = p;
550 D->normalizedExponent = 0;
552 for (; p != end; ++p) {
555 return createError(
"String contains multiple dots");
565 if (*p !=
'e' && *p !=
'E')
566 return createError(
"Invalid character in significand");
569 if (dot != end && p - begin == 1)
575 return ExpOrErr.takeError();
576 D->exponent = *ExpOrErr;
584 if (p !=
D->firstSigDigit) {
590 while (p != begin && *p ==
'0');
591 while (p != begin && *p ==
'.');
596 D->normalizedExponent = (
D->exponent +
598 - (dot >
D->firstSigDigit && dot < p)));
610 unsigned int digitValue) {
611 unsigned int hexDigit;
617 else if (digitValue < 8 && digitValue > 0)
621 while (p != end && (*p ==
'0' || *p ==
'.'))
625 return createError(
"Invalid trailing hexadecimal fraction!");
627 hexDigit = hexDigitValue(*p);
631 if (hexDigit == UINT_MAX)
641 unsigned int partCount,
670 return lost_fraction;
685 return moreSignificant;
696HUerrBound(
bool inexactMultiply,
unsigned int HUerr1,
unsigned int HUerr2)
698 assert(HUerr1 < 2 || HUerr2 < 2 || (HUerr1 + HUerr2 < 8));
700 if (HUerr1 + HUerr2 == 0)
701 return inexactMultiply * 2;
703 return inexactMultiply + 2 * (HUerr1 + HUerr2);
712 unsigned int count, partBits;
729 if (part - boundary <= boundary - part)
730 return part - boundary;
732 return boundary - part;
735 if (part == boundary) {
741 }
else if (part == boundary - 1) {
758 pow5s[0] = 78125 * 5;
760 unsigned int partsCount = 1;
768 *p1 = firstEightPowers[power & 7];
774 for (
unsigned int n = 0; power; power >>= 1, n++) {
778 partsCount, partsCount);
780 if (pow5[partsCount - 1] == 0)
788 result += partsCount;
789 if (p2[result - 1] == 0)
814static const char NaNL[] =
"nan";
815static const char NaNU[] =
"NAN";
822 const char *hexDigitChars)
824 unsigned int result =
count;
830 dst[
count] = hexDigitChars[part & 0xf];
870void IEEEFloat::initialize(
const fltSemantics *ourSemantics) {
873 semantics = ourSemantics;
879void IEEEFloat::freeSignificand() {
881 delete [] significand.parts;
884void IEEEFloat::assign(
const IEEEFloat &rhs) {
885 assert(semantics == rhs.semantics);
888 category = rhs.category;
889 exponent = rhs.exponent;
891 copySignificand(rhs);
894void IEEEFloat::copySignificand(
const IEEEFloat &rhs) {
896 assert(rhs.partCount() >= partCount());
911 exponent = exponentNaN();
914 unsigned numParts = partCount();
927 fill = &fill_storage;
938 unsigned bitsToPreserve = semantics->
precision - 1;
939 unsigned part = bitsToPreserve / 64;
940 bitsToPreserve %= 64;
941 significand[part] &= ((1ULL << bitsToPreserve) - 1);
942 for (part++; part != numParts; ++part)
943 significand[part] = 0;
946 unsigned QNaNBit = semantics->
precision - 2;
974 if (semantics != rhs.semantics) {
976 initialize(rhs.semantics);
987 semantics = rhs.semantics;
988 significand = rhs.significand;
989 exponent = rhs.exponent;
990 category = rhs.category;
1008 significandMSB() == 0;
1013 isSignificandAllZerosExceptMSB();
1016bool IEEEFloat::isSignificandAllOnes()
const {
1021 for (
unsigned i = 0; i < PartCount - 1; i++)
1026 const unsigned NumHighBits =
1028 assert(NumHighBits <= integerPartWidth && NumHighBits > 0 &&
1029 "Can not have more high bits to fill than integerPartWidth");
1032 if (~(Parts[PartCount - 1] | HighBitFill))
1038bool IEEEFloat::isSignificandAllOnesExceptLSB()
const {
1047 for (
unsigned i = 0; i < PartCount - 1; i++) {
1048 if (~Parts[i] & ~
unsigned{!i})
1053 const unsigned NumHighBits =
1055 assert(NumHighBits <= integerPartWidth && NumHighBits > 0 &&
1056 "Can not have more high bits to fill than integerPartWidth");
1059 if (~(Parts[PartCount - 1] | HighBitFill | 0x1))
1065bool IEEEFloat::isSignificandAllZeros()
const {
1071 for (
unsigned i = 0; i < PartCount - 1; i++)
1076 const unsigned NumHighBits =
1079 "clear than integerPartWidth");
1080 const integerPart HighBitMask = ~integerPart(0) >> NumHighBits;
1082 if (Parts[PartCount - 1] & HighBitMask)
1088bool IEEEFloat::isSignificandAllZerosExceptMSB()
const {
1092 for (
unsigned i = 0; i < PartCount - 1; i++) {
1097 const unsigned NumHighBits =
1110 isSignificandAllOnesExceptLSB();
1115 isSignificandAllOnes();
1130 if (semantics != rhs.semantics ||
1131 category != rhs.category ||
1140 return std::equal(significandParts(), significandParts() + partCount(),
1141 rhs.significandParts());
1145 initialize(&ourSemantics);
1150 significandParts()[0] =
value;
1155 initialize(&ourSemantics);
1165 initialize(rhs.semantics);
1170 *
this = std::move(rhs);
1175unsigned int IEEEFloat::partCount()
const {
1180 return const_cast<IEEEFloat *
>(
this)->significandParts();
1184 if (partCount() > 1)
1185 return significand.parts;
1187 return &significand.part;
1190void IEEEFloat::zeroSignificand() {
1195void IEEEFloat::incrementSignificand() {
1209 parts = significandParts();
1211 assert(semantics == rhs.semantics);
1212 assert(exponent == rhs.exponent);
1214 return APInt::tcAdd(parts, rhs.significandParts(), 0, partCount());
1220 integerPart borrow) {
1223 parts = significandParts();
1225 assert(semantics == rhs.semantics);
1226 assert(exponent == rhs.exponent);
1235lostFraction IEEEFloat::multiplySignificand(
const IEEEFloat &rhs,
1238 unsigned int partsCount, newPartsCount, precision;
1245 assert(semantics == rhs.semantics);
1253 if (newPartsCount > 4)
1256 fullSignificand = scratch;
1258 lhsSignificand = significandParts();
1259 partsCount = partCount();
1262 rhs.significandParts(), partsCount, partsCount);
1265 omsb =
APInt::tcMSB(fullSignificand, newPartsCount) + 1;
1266 exponent += rhs.exponent;
1280 if (addend.isNonZero()) {
1284 Significand savedSignificand = significand;
1288 unsigned int extendedPrecision;
1291 extendedPrecision = 2 * precision + 1;
1292 if (omsb != extendedPrecision - 1) {
1293 assert(extendedPrecision > omsb);
1295 (extendedPrecision - 1) - omsb);
1296 exponent -= (extendedPrecision - 1) - omsb;
1300 extendedSemantics = *semantics;
1301 extendedSemantics.
precision = extendedPrecision;
1303 if (newPartsCount == 1)
1304 significand.part = fullSignificand[0];
1306 significand.parts = fullSignificand;
1307 semantics = &extendedSemantics;
1320 lost_fraction = extendedAddend.shiftSignificandRight(1);
1322 "Lost precision while shifting addend for fused-multiply-add.");
1324 lost_fraction = addOrSubtractSignificand(extendedAddend,
false);
1327 if (newPartsCount == 1)
1328 fullSignificand[0] = significand.part;
1329 significand = savedSignificand;
1330 semantics = savedSemantics;
1332 omsb =
APInt::tcMSB(fullSignificand, newPartsCount) + 1;
1339 exponent -= precision + 1;
1348 if (omsb > precision) {
1349 unsigned int bits, significantParts;
1352 bits = omsb - precision;
1354 lf =
shiftRight(fullSignificand, significantParts, bits);
1361 if (newPartsCount > 4)
1362 delete [] fullSignificand;
1364 return lost_fraction;
1367lostFraction IEEEFloat::multiplySignificand(
const IEEEFloat &rhs) {
1368 return multiplySignificand(rhs,
IEEEFloat(*semantics));
1372lostFraction IEEEFloat::divideSignificand(
const IEEEFloat &rhs) {
1373 unsigned int bit, i, partsCount;
1379 assert(semantics == rhs.semantics);
1381 lhsSignificand = significandParts();
1382 rhsSignificand = rhs.significandParts();
1383 partsCount = partCount();
1390 divisor = dividend + partsCount;
1393 for (i = 0; i < partsCount; i++) {
1394 dividend[i] = lhsSignificand[i];
1395 divisor[i] = rhsSignificand[i];
1396 lhsSignificand[i] = 0;
1399 exponent -= rhs.exponent;
1401 unsigned int precision = semantics->
precision;
1404 bit = precision -
APInt::tcMSB(divisor, partsCount) - 1;
1411 bit = precision -
APInt::tcMSB(dividend, partsCount) - 1;
1427 for (bit = precision; bit; bit -= 1) {
1451 return lost_fraction;
1454unsigned int IEEEFloat::significandMSB()
const {
1458unsigned int IEEEFloat::significandLSB()
const {
1463lostFraction IEEEFloat::shiftSignificandRight(
unsigned int bits) {
1469 return shiftRight(significandParts(), partCount(), bits);
1473void IEEEFloat::shiftSignificandLeft(
unsigned int bits) {
1474 assert(bits < semantics->precision);
1477 unsigned int partsCount = partCount();
1490 assert(semantics == rhs.semantics);
1494 compare = exponent - rhs.exponent;
1561bool IEEEFloat::roundAwayFromZero(roundingMode rounding_mode,
1563 unsigned int bit)
const {
1570 switch (rounding_mode) {
1608 omsb = significandMSB() + 1;
1614 exponentChange = omsb - semantics->
precision;
1618 if (exponent + exponentChange > semantics->
maxExponent)
1619 return handleOverflow(rounding_mode);
1623 if (exponent + exponentChange < semantics->minExponent)
1624 exponentChange = semantics->
minExponent - exponent;
1627 if (exponentChange < 0) {
1630 shiftSignificandLeft(-exponentChange);
1635 if (exponentChange > 0) {
1639 lf = shiftSignificandRight(exponentChange);
1644 if (omsb > (
unsigned) exponentChange)
1645 omsb -= exponentChange;
1655 exponent == semantics->
maxExponent && isSignificandAllOnes())
1656 return handleOverflow(rounding_mode);
1675 if (roundAwayFromZero(rounding_mode, lost_fraction, 0)) {
1679 incrementSignificand();
1680 omsb = significandMSB() + 1;
1683 if (omsb == (
unsigned) semantics->
precision + 1) {
1694 shiftSignificandRight(1);
1703 exponent == semantics->
maxExponent && isSignificandAllOnes())
1704 return handleOverflow(rounding_mode);
1713 assert(omsb < semantics->precision);
1783lostFraction IEEEFloat::addOrSubtractSignificand(
const IEEEFloat &rhs,
1791 subtract ^=
static_cast<bool>(sign ^ rhs.sign);
1794 bits = exponent - rhs.exponent;
1802 else if (bits > 0) {
1803 lost_fraction = temp_rhs.shiftSignificandRight(bits - 1);
1804 shiftSignificandLeft(1);
1806 lost_fraction = shiftSignificandRight(-bits - 1);
1807 temp_rhs.shiftSignificandLeft(1);
1812 carry = temp_rhs.subtractSignificand
1814 copySignificand(temp_rhs);
1817 carry = subtractSignificand
1836 lost_fraction = temp_rhs.shiftSignificandRight(bits);
1837 carry = addSignificand(temp_rhs);
1839 lost_fraction = shiftSignificandRight(-bits);
1840 carry = addSignificand(rhs);
1848 return lost_fraction;
2033 roundingMode rounding_mode,
2037 fs = addOrSubtractSpecials(rhs,
subtract);
2043 lost_fraction = addOrSubtractSignificand(rhs,
subtract);
2044 fs = normalize(rounding_mode, lost_fraction);
2053 if (category ==
fcZero) {
2067 return addOrSubtract(rhs, rounding_mode,
false);
2073 return addOrSubtract(rhs, rounding_mode,
true);
2082 fs = multiplySpecials(rhs);
2088 fs = normalize(rounding_mode, lost_fraction);
2102 fs = divideSpecials(rhs);
2108 fs = normalize(rounding_mode, lost_fraction);
2119 unsigned int origSign = sign;
2122 fs = remainderSpecials(rhs);
2229 fs = modSpecials(rhs);
2230 unsigned int origSign = sign;
2260 sign ^= multiplicand.sign;
2269 lost_fraction = multiplySignificand(multiplicand, addend);
2270 fs = normalize(rounding_mode, lost_fraction);
2283 fs = multiplySpecials(multiplicand);
2293 fs = addOrSubtract(addend, rounding_mode,
false);
2366 MagicConstant.sign = sign;
2372 fs =
add(MagicConstant, rounding_mode);
2376 subtract(MagicConstant, rounding_mode);
2390 assert(semantics == rhs.semantics);
2422 if (sign == rhs.sign)
2437 if (sign != rhs.sign) {
2468 unsigned int newPartCount, oldPartCount;
2476 oldPartCount = partCount();
2479 bool X86SpecialNan =
false;
2482 (!(*significandParts() & 0x8000000000000000ULL) ||
2483 !(*significandParts() & 0x4000000000000000ULL))) {
2486 X86SpecialNan =
true;
2497 int omsb = significandMSB() + 1;
2498 int exponentChange = omsb - fromSemantics.
precision;
2499 if (exponent + exponentChange < toSemantics.
minExponent)
2500 exponentChange = toSemantics.
minExponent - exponent;
2501 if (exponentChange < shift)
2502 exponentChange = shift;
2503 if (exponentChange < 0) {
2504 shift -= exponentChange;
2505 exponent += exponentChange;
2506 }
else if (omsb <= -shift) {
2507 exponentChange = omsb + shift - 1;
2508 shift -= exponentChange;
2509 exponent += exponentChange;
2520 if (newPartCount > oldPartCount) {
2528 significand.parts = newParts;
2529 }
else if (newPartCount == 1 && oldPartCount != 1) {
2533 newPart = significandParts()[0];
2535 significand.part = newPart;
2539 semantics = &toSemantics;
2548 *losesInfo = (fs !=
opOK);
2549 }
else if (category ==
fcNaN) {
2584 }
else if (category ==
fcZero &&
2612 roundingMode rounding_mode,
bool *isExact)
const {
2615 unsigned int dstPartsCount, truncatedBits;
2624 assert(dstPartsCount <= parts.
size() &&
"Integer too big");
2626 if (category ==
fcZero) {
2633 src = significandParts();
2642 truncatedBits = semantics->
precision -1U - exponent;
2646 unsigned int bits = exponent + 1U;
2652 if (bits < semantics->precision) {
2654 truncatedBits = semantics->
precision - bits;
2668 if (truncatedBits) {
2672 roundAwayFromZero(rounding_mode, lost_fraction, truncatedBits)) {
2692 if (omsb == width &&
2729 fs = convertToSignExtendedInteger(parts, width,
isSigned, rounding_mode,
2733 unsigned int bits, dstPartsCount;
2736 assert(dstPartsCount <= parts.
size() &&
"Integer too big");
2738 if (category ==
fcNaN)
2757 const integerPart *src,
unsigned int srcCount, roundingMode rounding_mode) {
2758 unsigned int omsb, precision, dstCount;
2764 dst = significandParts();
2765 dstCount = partCount();
2770 if (precision <= omsb) {
2771 exponent = omsb - 1;
2776 exponent = precision - 1;
2781 return normalize(rounding_mode, lost_fraction);
2795 return convertFromUnsignedParts(api.
getRawData(), partCount, rounding_mode);
2803 unsigned int srcCount,
bool isSigned,
2816 status = convertFromUnsignedParts(
copy, srcCount, rounding_mode);
2820 status = convertFromUnsignedParts(src, srcCount, rounding_mode);
2840 return convertFromUnsignedParts(api.
getRawData(), partCount, rounding_mode);
2844IEEEFloat::convertFromHexadecimalString(
StringRef s,
2845 roundingMode rounding_mode) {
2853 unsigned partsCount = partCount();
2855 bool computedTrailingFraction =
false;
2863 return PtrOrErr.takeError();
2872 return createError(
"String contains multiple dots");
2877 hex_value = hexDigitValue(*p);
2878 if (hex_value == UINT_MAX)
2888 }
else if (!computedTrailingFraction) {
2891 return FractOrErr.takeError();
2892 lost_fraction = *FractOrErr;
2893 computedTrailingFraction =
true;
2899 return createError(
"Hex strings require an exponent");
2900 if (*p !=
'p' && *p !=
'P')
2901 return createError(
"Invalid character in significand");
2904 if (dot != end && p - begin == 1)
2908 if (p != firstSignificantDigit) {
2917 expAdjustment =
static_cast<int>(
dot - firstSignificantDigit);
2918 if (expAdjustment < 0)
2920 expAdjustment = expAdjustment * 4 - 1;
2930 return ExpOrErr.takeError();
2931 exponent = *ExpOrErr;
2934 return normalize(rounding_mode, lost_fraction);
2938IEEEFloat::roundSignificandWithExponent(
const integerPart *decSigParts,
2939 unsigned sigPartCount,
int exp,
2940 roundingMode rounding_mode) {
2941 unsigned int parts, pow5PartCount;
2952 pow5PartCount =
powerOf5(pow5Parts, exp >= 0 ? exp: -exp);
2954 for (;; parts *= 2) {
2956 unsigned int excessPrecision, truncatedBits;
2960 truncatedBits = excessPrecision;
2963 decSig.makeZero(sign);
2966 sigStatus = decSig.convertFromUnsignedParts(decSigParts, sigPartCount,
2968 powStatus = pow5.convertFromUnsignedParts(pow5Parts, pow5PartCount,
2971 decSig.exponent += exp;
2975 unsigned int powHUerr;
2979 calcLostFraction = decSig.multiplySignificand(pow5);
2980 powHUerr = powStatus !=
opOK;
2982 calcLostFraction = decSig.divideSignificand(pow5);
2985 excessPrecision += (semantics->
minExponent - decSig.exponent);
2986 truncatedBits = excessPrecision;
2987 if (excessPrecision > calcSemantics.
precision)
2988 excessPrecision = calcSemantics.
precision;
2997 (decSig.significandParts(), calcSemantics.
precision - 1) == 1);
3002 excessPrecision, isNearest);
3005 if (HUdistance >= HUerr) {
3006 APInt::tcExtract(significandParts(), partCount(), decSig.significandParts(),
3007 calcSemantics.
precision - excessPrecision,
3012 exponent = (decSig.exponent + semantics->
precision
3013 - (calcSemantics.
precision - excessPrecision));
3017 return normalize(rounding_mode, calcLostFraction);
3023IEEEFloat::convertFromDecimalString(
StringRef str, roundingMode rounding_mode) {
3030 return std::move(Err);
3064 }
else if (
D.normalizedExponent - 1 > INT_MAX / 42039) {
3065 fs = handleOverflow(rounding_mode);
3071 }
else if (
D.normalizedExponent - 1 < INT_MIN / 42039 ||
3072 (
D.normalizedExponent + 1) * 28738 <=
3080 }
else if ((
D.normalizedExponent - 1) * 42039
3083 fs = handleOverflow(rounding_mode);
3086 unsigned int partCount;
3092 partCount =
static_cast<unsigned int>(
D.lastSigDigit -
D.firstSigDigit) + 1;
3110 if (p == str.
end()) {
3115 if (decValue >= 10U) {
3116 delete[] decSignificand;
3117 return createError(
"Invalid character in significand");
3120 val = val * 10 + decValue;
3123 }
while (p <=
D.lastSigDigit && multiplier <= (~ (
integerPart) 0 - 9) / 10);
3127 partCount, partCount + 1,
false);
3131 if (decSignificand[partCount])
3133 }
while (p <=
D.lastSigDigit);
3136 fs = roundSignificandWithExponent(decSignificand, partCount,
3137 D.exponent, rounding_mode);
3139 delete [] decSignificand;
3145bool IEEEFloat::convertFromStringSpecials(
StringRef str) {
3146 const size_t MIN_NAME_SIZE = 3;
3148 if (str.
size() < MIN_NAME_SIZE)
3151 if (str ==
"inf" || str ==
"INFINITY" || str ==
"+Inf") {
3156 bool IsNegative = str.
front() ==
'-';
3159 if (str.
size() < MIN_NAME_SIZE)
3162 if (str ==
"inf" || str ==
"INFINITY" || str ==
"Inf") {
3169 bool IsSignaling = str.
front() ==
's' || str.
front() ==
'S';
3172 if (str.
size() < MIN_NAME_SIZE)
3181 makeNaN(IsSignaling, IsNegative);
3186 if (str.
front() ==
'(') {
3188 if (str.
size() <= 2 || str.
back() !=
')')
3195 unsigned Radix = 10;
3196 if (str[0] ==
'0') {
3197 if (str.
size() > 1 && tolower(str[1]) ==
'x') {
3207 makeNaN(IsSignaling, IsNegative, &Payload);
3221 if (convertFromStringSpecials(str))
3226 size_t slen = str.
size();
3227 sign = *p ==
'-' ? 1 : 0;
3228 if (*p ==
'-' || *p ==
'+') {
3235 if (slen >= 2 && p[0] ==
'0' && (p[1] ==
'x' || p[1] ==
'X')) {
3238 return convertFromHexadecimalString(
StringRef(p + 2, slen - 2),
3242 return convertFromDecimalString(
StringRef(p, slen), rounding_mode);
3286 dst +=
sizeof NaNU - 1;
3291 *dst++ = upperCase ?
'X':
'x';
3293 if (hexDigits > 1) {
3295 memset (dst,
'0', hexDigits - 1);
3296 dst += hexDigits - 1;
3298 *dst++ = upperCase ?
'P':
'p';
3303 dst = convertNormalToHexString (dst, hexDigits, upperCase, rounding_mode);
3309 return static_cast<unsigned int>(dst - p);
3316char *IEEEFloat::convertNormalToHexString(
char *dst,
unsigned int hexDigits,
3318 roundingMode rounding_mode)
const {
3319 unsigned int count, valueBits, shift, partsCount, outputDigits;
3320 const char *hexDigitChars;
3326 *dst++ = upperCase ?
'X':
'x';
3331 significand = significandParts();
3332 partsCount = partCount();
3341 outputDigits = (valueBits - significandLSB () + 3) / 4;
3347 if (hexDigits < outputDigits) {
3353 bits = valueBits - hexDigits * 4;
3355 roundUp = roundAwayFromZero(rounding_mode, fraction, bits);
3357 outputDigits = hexDigits;
3367 while (outputDigits &&
count) {
3371 if (--
count == partsCount)
3374 part = significand[
count] << shift;
3382 if (curDigits > outputDigits)
3383 curDigits = outputDigits;
3384 dst +=
partAsHex (dst, part, curDigits, hexDigitChars);
3385 outputDigits -= curDigits;
3394 *
q = hexDigitChars[hexDigitValue (*q) + 1];
3395 }
while (*q ==
'0');
3399 memset (dst,
'0', outputDigits);
3400 dst += outputDigits;
3413 *dst++ = upperCase ?
'P':
'p';
3422 Arg.
isNaN() ? (uint8_t)0 : (uint8_t)Arg.sign,
3426 return hash_combine((uint8_t)Arg.category, (uint8_t)Arg.sign,
3429 Arg.significandParts(),
3430 Arg.significandParts() + Arg.partCount()));
3442APInt IEEEFloat::convertF80LongDoubleAPFloatToAPInt()
const {
3446 uint64_t myexponent, mysignificand;
3449 myexponent = exponent+16383;
3450 mysignificand = significandParts()[0];
3451 if (myexponent==1 && !(mysignificand & 0x8000000000000000ULL))
3453 }
else if (category==
fcZero) {
3457 myexponent = 0x7fff;
3458 mysignificand = 0x8000000000000000ULL;
3461 myexponent = 0x7fff;
3462 mysignificand = significandParts()[0];
3466 words[0] = mysignificand;
3467 words[1] = ((
uint64_t)(sign & 1) << 15) |
3468 (myexponent & 0x7fffLL);
3469 return APInt(80, words);
3472APInt IEEEFloat::convertPPCDoubleDoubleAPFloatToAPInt()
const {
3497 words[0] = *
u.convertDoubleAPFloatToAPInt().getRawData();
3503 if (
u.isFiniteNonZero() && losesInfo) {
3513 words[1] = *
v.convertDoubleAPFloatToAPInt().getRawData();
3518 return APInt(128, words);
3521template <const fltSemantics &S>
3522APInt IEEEFloat::convertIEEEFloatToAPInt()
const {
3525 constexpr int bias = -(S.minExponent - 1);
3526 constexpr unsigned int trailing_significand_bits = S.precision - 1;
3527 constexpr int integer_bit_part = trailing_significand_bits /
integerPartWidth;
3530 constexpr uint64_t significand_mask = integer_bit - 1;
3531 constexpr unsigned int exponent_bits =
3532 S.sizeInBits - 1 - trailing_significand_bits;
3533 static_assert(exponent_bits < 64);
3541 myexponent = exponent + bias;
3542 std::copy_n(significandParts(), mysignificand.size(),
3543 mysignificand.begin());
3544 if (myexponent == 1 &&
3545 !(significandParts()[integer_bit_part] & integer_bit))
3547 }
else if (category ==
fcZero) {
3548 myexponent = ::exponentZero(S) + bias;
3549 mysignificand.fill(0);
3554 myexponent = ::exponentInf(S) + bias;
3555 mysignificand.fill(0);
3560 myexponent = ::exponentNaN(S) + bias;
3561 std::copy_n(significandParts(), mysignificand.size(),
3562 mysignificand.begin());
3564 std::array<
uint64_t, (S.sizeInBits + 63) / 64> words;
3566 std::copy_n(mysignificand.begin(), mysignificand.size(), words.begin());
3567 if constexpr (significand_mask != 0) {
3569 words[mysignificand.size() - 1] &= significand_mask;
3571 std::fill(words_iter, words.end(),
uint64_t{0});
3572 constexpr size_t last_word = words.size() - 1;
3574 << ((S.sizeInBits - 1) % 64);
3575 words[last_word] |= shifted_sign;
3576 uint64_t shifted_exponent = (myexponent & exponent_mask)
3577 << (trailing_significand_bits % 64);
3578 words[last_word] |= shifted_exponent;
3579 if constexpr (last_word == 0) {
3580 return APInt(S.sizeInBits, words[0]);
3582 return APInt(S.sizeInBits, words);
3585APInt IEEEFloat::convertQuadrupleAPFloatToAPInt()
const {
3586 assert(partCount() == 2);
3587 return convertIEEEFloatToAPInt<semIEEEquad>();
3590APInt IEEEFloat::convertDoubleAPFloatToAPInt()
const {
3592 return convertIEEEFloatToAPInt<semIEEEdouble>();
3595APInt IEEEFloat::convertFloatAPFloatToAPInt()
const {
3597 return convertIEEEFloatToAPInt<semIEEEsingle>();
3600APInt IEEEFloat::convertBFloatAPFloatToAPInt()
const {
3601 assert(partCount() == 1);
3602 return convertIEEEFloatToAPInt<semBFloat>();
3605APInt IEEEFloat::convertHalfAPFloatToAPInt()
const {
3607 return convertIEEEFloatToAPInt<semIEEEhalf>();
3610APInt IEEEFloat::convertFloat8E5M2APFloatToAPInt()
const {
3611 assert(partCount() == 1);
3612 return convertIEEEFloatToAPInt<semFloat8E5M2>();
3615APInt IEEEFloat::convertFloat8E5M2FNUZAPFloatToAPInt()
const {
3616 assert(partCount() == 1);
3617 return convertIEEEFloatToAPInt<semFloat8E5M2FNUZ>();
3620APInt IEEEFloat::convertFloat8E4M3FNAPFloatToAPInt()
const {
3621 assert(partCount() == 1);
3622 return convertIEEEFloatToAPInt<semFloat8E4M3FN>();
3625APInt IEEEFloat::convertFloat8E4M3FNUZAPFloatToAPInt()
const {
3626 assert(partCount() == 1);
3627 return convertIEEEFloatToAPInt<semFloat8E4M3FNUZ>();
3630APInt IEEEFloat::convertFloat8E4M3B11FNUZAPFloatToAPInt()
const {
3631 assert(partCount() == 1);
3632 return convertIEEEFloatToAPInt<semFloat8E4M3B11FNUZ>();
3635APInt IEEEFloat::convertFloatTF32APFloatToAPInt()
const {
3636 assert(partCount() == 1);
3637 return convertIEEEFloatToAPInt<semFloatTF32>();
3640APInt IEEEFloat::convertFloat6E3M2FNAPFloatToAPInt()
const {
3641 assert(partCount() == 1);
3642 return convertIEEEFloatToAPInt<semFloat6E3M2FN>();
3645APInt IEEEFloat::convertFloat6E2M3FNAPFloatToAPInt()
const {
3646 assert(partCount() == 1);
3647 return convertIEEEFloatToAPInt<semFloat6E2M3FN>();
3650APInt IEEEFloat::convertFloat4E2M1FNAPFloatToAPInt()
const {
3651 assert(partCount() == 1);
3652 return convertIEEEFloatToAPInt<semFloat4E2M1FN>();
3661 return convertHalfAPFloatToAPInt();
3664 return convertBFloatAPFloatToAPInt();
3667 return convertFloatAPFloatToAPInt();
3670 return convertDoubleAPFloatToAPInt();
3673 return convertQuadrupleAPFloatToAPInt();
3676 return convertPPCDoubleDoubleAPFloatToAPInt();
3679 return convertFloat8E5M2APFloatToAPInt();
3682 return convertFloat8E5M2FNUZAPFloatToAPInt();
3685 return convertFloat8E4M3FNAPFloatToAPInt();
3688 return convertFloat8E4M3FNUZAPFloatToAPInt();
3691 return convertFloat8E4M3B11FNUZAPFloatToAPInt();
3694 return convertFloatTF32APFloatToAPInt();
3697 return convertFloat6E3M2FNAPFloatToAPInt();
3700 return convertFloat6E2M3FNAPFloatToAPInt();
3703 return convertFloat4E2M1FNAPFloatToAPInt();
3707 return convertF80LongDoubleAPFloatToAPInt();
3712 "Float semantics are not IEEEsingle");
3719 "Float semantics are not IEEEdouble");
3724#ifdef HAS_IEE754_FLOAT128
3725float128 IEEEFloat::convertToQuad()
const {
3727 "Float semantics are not IEEEquads");
3729 return api.bitsToQuad();
3740void IEEEFloat::initFromF80LongDoubleAPInt(
const APInt &api) {
3743 uint64_t myexponent = (i2 & 0x7fff);
3745 uint8_t myintegerbit = mysignificand >> 63;
3750 sign =
static_cast<unsigned int>(i2>>15);
3751 if (myexponent == 0 && mysignificand == 0) {
3753 }
else if (myexponent==0x7fff && mysignificand==0x8000000000000000ULL) {
3755 }
else if ((myexponent == 0x7fff && mysignificand != 0x8000000000000000ULL) ||
3756 (myexponent != 0x7fff && myexponent != 0 && myintegerbit == 0)) {
3758 exponent = exponentNaN();
3759 significandParts()[0] = mysignificand;
3760 significandParts()[1] = 0;
3763 exponent = myexponent - 16383;
3764 significandParts()[0] = mysignificand;
3765 significandParts()[1] = 0;
3771void IEEEFloat::initFromPPCDoubleDoubleAPInt(
const APInt &api) {
3778 initFromDoubleAPInt(
APInt(64, i1));
3794template <const fltSemantics &S>
3795void IEEEFloat::initFromIEEEAPInt(
const APInt &api) {
3799 constexpr uint64_t significand_mask = integer_bit - 1;
3800 constexpr unsigned int trailing_significand_bits = S.precision - 1;
3801 constexpr unsigned int stored_significand_parts =
3803 constexpr unsigned int exponent_bits =
3804 S.sizeInBits - 1 - trailing_significand_bits;
3805 static_assert(exponent_bits < 64);
3807 constexpr int bias = -(S.minExponent - 1);
3811 std::array<integerPart, stored_significand_parts> mysignificand;
3812 std::copy_n(api.
getRawData(), mysignificand.size(), mysignificand.begin());
3813 if constexpr (significand_mask != 0) {
3814 mysignificand[mysignificand.size() - 1] &= significand_mask;
3821 (last_word >> (trailing_significand_bits % 64)) & exponent_mask;
3824 assert(partCount() == mysignificand.size());
3826 sign =
static_cast<unsigned int>(last_word >> ((S.sizeInBits - 1) % 64));
3828 bool all_zero_significand =
3831 bool is_zero = myexponent == 0 && all_zero_significand;
3834 if (myexponent - bias == ::exponentInf(S) && all_zero_significand) {
3843 is_nan = myexponent - bias == ::exponentNaN(S) && !all_zero_significand;
3845 bool all_ones_significand =
3846 std::all_of(mysignificand.begin(), mysignificand.end() - 1,
3847 [](
integerPart bits) { return bits == ~integerPart{0}; }) &&
3848 (!significand_mask ||
3849 mysignificand[mysignificand.size() - 1] == significand_mask);
3850 is_nan = myexponent - bias == ::exponentNaN(S) && all_ones_significand;
3858 std::copy_n(mysignificand.begin(), mysignificand.size(),
3859 significandParts());
3869 exponent = myexponent - bias;
3870 std::copy_n(mysignificand.begin(), mysignificand.size(), significandParts());
3871 if (myexponent == 0)
3872 exponent = S.minExponent;
3874 significandParts()[mysignificand.size()-1] |= integer_bit;
3877void IEEEFloat::initFromQuadrupleAPInt(
const APInt &api) {
3878 initFromIEEEAPInt<semIEEEquad>(api);
3881void IEEEFloat::initFromDoubleAPInt(
const APInt &api) {
3882 initFromIEEEAPInt<semIEEEdouble>(api);
3885void IEEEFloat::initFromFloatAPInt(
const APInt &api) {
3886 initFromIEEEAPInt<semIEEEsingle>(api);
3889void IEEEFloat::initFromBFloatAPInt(
const APInt &api) {
3890 initFromIEEEAPInt<semBFloat>(api);
3893void IEEEFloat::initFromHalfAPInt(
const APInt &api) {
3894 initFromIEEEAPInt<semIEEEhalf>(api);
3897void IEEEFloat::initFromFloat8E5M2APInt(
const APInt &api) {
3898 initFromIEEEAPInt<semFloat8E5M2>(api);
3901void IEEEFloat::initFromFloat8E5M2FNUZAPInt(
const APInt &api) {
3902 initFromIEEEAPInt<semFloat8E5M2FNUZ>(api);
3905void IEEEFloat::initFromFloat8E4M3FNAPInt(
const APInt &api) {
3906 initFromIEEEAPInt<semFloat8E4M3FN>(api);
3909void IEEEFloat::initFromFloat8E4M3FNUZAPInt(
const APInt &api) {
3910 initFromIEEEAPInt<semFloat8E4M3FNUZ>(api);
3913void IEEEFloat::initFromFloat8E4M3B11FNUZAPInt(
const APInt &api) {
3914 initFromIEEEAPInt<semFloat8E4M3B11FNUZ>(api);
3917void IEEEFloat::initFromFloatTF32APInt(
const APInt &api) {
3918 initFromIEEEAPInt<semFloatTF32>(api);
3921void IEEEFloat::initFromFloat6E3M2FNAPInt(
const APInt &api) {
3922 initFromIEEEAPInt<semFloat6E3M2FN>(api);
3925void IEEEFloat::initFromFloat6E2M3FNAPInt(
const APInt &api) {
3926 initFromIEEEAPInt<semFloat6E2M3FN>(api);
3929void IEEEFloat::initFromFloat4E2M1FNAPInt(
const APInt &api) {
3930 initFromIEEEAPInt<semFloat4E2M1FN>(api);
3937 return initFromHalfAPInt(api);
3939 return initFromBFloatAPInt(api);
3941 return initFromFloatAPInt(api);
3943 return initFromDoubleAPInt(api);
3945 return initFromF80LongDoubleAPInt(api);
3947 return initFromQuadrupleAPInt(api);
3949 return initFromPPCDoubleDoubleAPInt(api);
3951 return initFromFloat8E5M2APInt(api);
3953 return initFromFloat8E5M2FNUZAPInt(api);
3955 return initFromFloat8E4M3FNAPInt(api);
3957 return initFromFloat8E4M3FNUZAPInt(api);
3959 return initFromFloat8E4M3B11FNUZAPInt(api);
3961 return initFromFloatTF32APInt(api);
3963 return initFromFloat6E3M2FNAPInt(api);
3965 return initFromFloat6E2M3FNAPInt(api);
3967 return initFromFloat4E2M1FNAPInt(api);
3974void IEEEFloat::makeLargest(
bool Negative) {
3981 exponent = semantics->maxExponent;
3985 unsigned PartCount = partCount();
3986 memset(significand, 0xFF,
sizeof(
integerPart)*(PartCount - 1));
3990 const unsigned NumUnusedHighBits =
3991 PartCount*integerPartWidth - semantics->precision;
3992 significand[PartCount - 1] = (NumUnusedHighBits < integerPartWidth)
4003void IEEEFloat::makeSmallest(
bool Negative) {
4010 exponent = semantics->minExponent;
4014void IEEEFloat::makeSmallestNormalized(
bool Negative) {
4023 exponent = semantics->minExponent;
4028 initFromAPInt(&Sem, API);
4031IEEEFloat::IEEEFloat(
float f) {
4035IEEEFloat::IEEEFloat(
double d) {
4041 Buffer.
append(Str.begin(), Str.end());
4046 void AdjustToPrecision(
APInt &significand,
4047 int &exp,
unsigned FormatPrecision) {
4051 unsigned bitsRequired = (FormatPrecision * 196 + 58) / 59;
4053 if (bits <= bitsRequired)
return;
4055 unsigned tensRemovable = (bits - bitsRequired) * 59 / 196;
4056 if (!tensRemovable)
return;
4058 exp += tensRemovable;
4063 if (tensRemovable & 1)
4065 tensRemovable >>= 1;
4066 if (!tensRemovable)
break;
4070 significand = significand.
udiv(divisor);
4078 int &exp,
unsigned FormatPrecision) {
4079 unsigned N = buffer.
size();
4080 if (
N <= FormatPrecision)
return;
4083 unsigned FirstSignificant =
N - FormatPrecision;
4090 if (buffer[FirstSignificant - 1] <
'5') {
4091 while (FirstSignificant <
N && buffer[FirstSignificant] ==
'0')
4094 exp += FirstSignificant;
4095 buffer.
erase(&buffer[0], &buffer[FirstSignificant]);
4101 for (
unsigned I = FirstSignificant;
I !=
N; ++
I) {
4102 if (buffer[
I] ==
'9') {
4111 if (FirstSignificant ==
N) {
4112 exp += FirstSignificant;
4118 exp += FirstSignificant;
4119 buffer.
erase(&buffer[0], &buffer[FirstSignificant]);
4124 unsigned FormatMaxPadding,
bool TruncateZero)
const {
4128 return append(Str,
"-Inf");
4130 return append(Str,
"+Inf");
4132 case fcNaN:
return append(Str,
"NaN");
4138 if (!FormatMaxPadding) {
4140 append(Str,
"0.0E+0");
4143 if (FormatPrecision > 1)
4144 Str.append(FormatPrecision - 1,
'0');
4145 append(Str,
"e+00");
4159 int exp = exponent - ((int) semantics->precision - 1);
4161 semantics->precision,
4166 if (!FormatPrecision) {
4174 FormatPrecision = 2 + semantics->precision * 59 / 196;
4179 exp += trailingZeros;
4185 }
else if (exp > 0) {
4187 significand = significand.
zext(semantics->precision + exp);
4188 significand <<= exp;
4202 unsigned precision = semantics->precision + (137 * texp + 136) / 59;
4206 significand = significand.
zext(precision);
4207 APInt five_to_the_i(precision, 5);
4209 if (texp & 1) significand *= five_to_the_i;
4213 five_to_the_i *= five_to_the_i;
4217 AdjustToPrecision(significand, exp, FormatPrecision);
4223 if (precision < 4) {
4226 significand = significand.
zext(precision);
4228 APInt ten(precision, 10);
4229 APInt digit(precision, 0);
4231 bool inTrail =
true;
4232 while (significand != 0) {
4240 if (inTrail && !d) exp++;
4247 assert(!buffer.
empty() &&
"no characters in buffer!");
4251 AdjustToPrecision(buffer, exp, FormatPrecision);
4253 unsigned NDigits = buffer.
size();
4256 bool FormatScientific;
4257 if (!FormatMaxPadding)
4258 FormatScientific =
true;
4264 FormatScientific = ((
unsigned) exp > FormatMaxPadding ||
4265 NDigits + (
unsigned) exp > FormatPrecision);
4268 int MSD = exp + (int) (NDigits - 1);
4271 FormatScientific =
false;
4275 FormatScientific = ((
unsigned) -MSD) > FormatMaxPadding;
4281 if (FormatScientific) {
4282 exp += (NDigits - 1);
4284 Str.push_back(buffer[NDigits-1]);
4286 if (NDigits == 1 && TruncateZero)
4289 for (
unsigned I = 1;
I != NDigits; ++
I)
4290 Str.push_back(buffer[NDigits-1-
I]);
4292 if (!TruncateZero && FormatPrecision > NDigits - 1)
4293 Str.append(FormatPrecision - NDigits + 1,
'0');
4295 Str.push_back(TruncateZero ?
'E' :
'e');
4297 Str.push_back(exp >= 0 ?
'+' :
'-');
4298 if (exp < 0) exp = -exp;
4301 expbuf.
push_back((
char) (
'0' + (exp % 10)));
4305 if (!TruncateZero && expbuf.
size() < 2)
4307 for (
unsigned I = 0, E = expbuf.
size();
I != E; ++
I)
4308 Str.push_back(expbuf[E-1-
I]);
4314 for (
unsigned I = 0;
I != NDigits; ++
I)
4315 Str.push_back(buffer[NDigits-1-
I]);
4324 int NWholeDigits = exp + (int) NDigits;
4327 if (NWholeDigits > 0) {
4329 Str.push_back(buffer[NDigits-
I-1]);
4332 unsigned NZeros = 1 + (
unsigned) -NWholeDigits;
4336 for (
unsigned Z = 1; Z != NZeros; ++Z)
4340 for (;
I != NDigits; ++
I)
4341 Str.push_back(buffer[NDigits-
I-1]);
4344bool IEEEFloat::getExactInverse(
APFloat *inv)
const {
4346 if (!isFiniteNonZero())
4351 if (significandLSB() != semantics->precision - 1)
4356 if (reciprocal.
divide(*
this, rmNearestTiesToEven) != opOK)
4365 reciprocal.significandLSB() == reciprocal.semantics->
precision - 1);
4368 *inv =
APFloat(reciprocal, *semantics);
4373int IEEEFloat::getExactLog2Abs()
const {
4381 for (
int i = 0; i < PartCount; ++i) {
4387 if (exponent != semantics->minExponent)
4390 int CountrParts = 0;
4391 for (
int i = 0; i < PartCount;
4393 if (Parts[i] != 0) {
4394 return exponent - semantics->precision + CountrParts +
4402bool IEEEFloat::isSignaling()
const {
4439 if (isSignaling()) {
4440 result = opInvalidOp;
4442 makeNaN(
false, isNegative(),
nullptr);
4447 makeSmallest(
false);
4451 if (isSmallest() && isNegative()) {
4460 if (isLargest() && !isNegative()) {
4465 }
else if (semantics->nonFiniteBehavior ==
4472 category = fcInfinity;
4473 exponent = semantics->maxExponent + 1;
4487 bool WillCrossBinadeBoundary =
4488 exponent != semantics->minExponent && isSignificandAllZeros();
4506 if (WillCrossBinadeBoundary) {
4522 bool WillCrossBinadeBoundary = !isDenormal() && isSignificandAllOnes();
4524 if (WillCrossBinadeBoundary) {
4528 assert(exponent != semantics->maxExponent &&
4529 "We can not increment an exponent beyond the maxExponent allowed"
4530 " by the given floating point semantics.");
4533 incrementSignificand();
4547 return ::exponentNaN(*semantics);
4551 return ::exponentInf(*semantics);
4555 return ::exponentZero(*semantics);
4558void IEEEFloat::makeInf(
bool Negative) {
4564 makeNaN(
false, Negative);
4567 category = fcInfinity;
4573void IEEEFloat::makeZero(
bool Negative) {
4584void IEEEFloat::makeQuiet() {
4592 return IEEEFloat::IEK_NaN;
4594 return IEEEFloat::IEK_Zero;
4596 return IEEEFloat::IEK_Inf;
4598 return Arg.exponent;
4603 Normalized.exponent += SignificandBits;
4604 Normalized.normalize(IEEEFloat::rmNearestTiesToEven,
lfExactlyZero);
4605 return Normalized.exponent - SignificandBits;
4609 auto MaxExp =
X.getSemantics().maxExponent;
4610 auto MinExp =
X.getSemantics().minExponent;
4618 int SignificandBits =
X.getSemantics().precision - 1;
4619 int MaxIncrement = MaxExp - (MinExp - SignificandBits) + 1;
4622 X.exponent += std::clamp(Exp, -MaxIncrement - 1, MaxIncrement);
4633 if (Exp == IEEEFloat::IEK_NaN) {
4639 if (Exp == IEEEFloat::IEK_Inf)
4644 Exp = Exp == IEEEFloat::IEK_Zero ? 0 : Exp + 1;
4645 return scalbn(Val, -Exp, RM);
4678 Floats(new
APFloat[2]{std::move(
First), std::move(Second)}) {
4700 Floats[0] =
RHS.Floats[0];
4701 Floats[1] =
RHS.Floats[1];
4702 }
else if (
this != &
RHS) {
4720 Floats[0] = std::move(z);
4721 Floats[1].makeZero(
false);
4725 auto AComparedToC = a.compareAbsoluteValue(c);
4738 Floats[0] = std::move(z);
4739 Floats[1].makeZero(
false);
4748 Status |= Floats[1].subtract(z, RM);
4749 Status |= Floats[1].add(c, RM);
4750 Status |= Floats[1].add(zz, RM);
4754 Status |= Floats[1].subtract(z, RM);
4755 Status |= Floats[1].add(a, RM);
4756 Status |= Floats[1].add(zz, RM);
4774 Floats[0] = std::move(z);
4775 Floats[1].makeZero(
false);
4779 Status |= Floats[0].add(zz, RM);
4781 Floats[1].makeZero(
false);
4784 Floats[1] = std::move(z);
4785 Status |= Floats[1].subtract(Floats[0], RM);
4786 Status |= Floats[1].add(zz, RM);
4792 const DoubleAPFloat &RHS,
4812 LHS.isNegative() !=
RHS.isNegative()) {
4813 Out.makeNaN(
false, Out.isNegative(),
nullptr);
4834 return Out.addImpl(
A, AA,
C,
CC, RM);
4839 return addWithSpecial(*
this,
RHS, *
this, RM);
4852 const auto &
LHS = *
this;
4879 Out.makeNaN(
false,
false,
nullptr);
4891 "Special cases not handled exhaustively");
4898 if (!
T.isFiniteNonZero()) {
4900 Floats[1].makeZero(
false);
4922 Status |= U.add(Tau, RM);
4925 if (!U.isFinite()) {
4926 Floats[1].makeZero(
false);
4985 Floats[0].changeSign();
4986 Floats[1].changeSign();
4991 auto Result = Floats[0].compareAbsoluteValue(
RHS.Floats[0]);
4994 Result = Floats[1].compareAbsoluteValue(
RHS.Floats[1]);
4996 auto Against = Floats[0].isNegative() ^ Floats[1].isNegative();
4997 auto RHSAgainst =
RHS.Floats[0].isNegative() ^
RHS.Floats[1].isNegative();
4998 if (Against && !RHSAgainst)
5000 if (!Against && RHSAgainst)
5002 if (!Against && !RHSAgainst)
5004 if (Against && RHSAgainst)
5011 return Floats[0].getCategory();
5017 Floats[0].makeInf(Neg);
5018 Floats[1].makeZero(
false);
5022 Floats[0].makeZero(Neg);
5023 Floats[1].makeZero(
false);
5036 Floats[0].makeSmallest(Neg);
5037 Floats[1].makeZero(
false);
5044 Floats[0].changeSign();
5045 Floats[1].makeZero(
false);
5049 Floats[0].makeNaN(SNaN, Neg, fill);
5050 Floats[1].makeZero(
false);
5054 auto Result = Floats[0].compare(
RHS.Floats[0]);
5057 return Floats[1].compare(
RHS.Floats[1]);
5062 return Floats[0].bitwiseIsEqual(
RHS.Floats[0]) &&
5063 Floats[1].bitwiseIsEqual(
RHS.Floats[1]);
5075 Floats[0].bitcastToAPInt().getRawData()[0],
5076 Floats[1].bitcastToAPInt().getRawData()[0],
5093 auto Ret = Tmp.
next(nextDown);
5100 unsigned int Width,
bool IsSigned,
5119 unsigned int InputSize,
5130 unsigned int InputSize,
5140 unsigned int HexDigits,
5150 (Floats[0].isDenormal() || Floats[1].isDenormal() ||
5152 Floats[0] != Floats[0] + Floats[1]);
5182 return Floats[0].isInteger() && Floats[1].isInteger();
5186 unsigned FormatPrecision,
5187 unsigned FormatMaxPadding,
5188 bool TruncateZero)
const {
5191 .
toString(Str, FormatPrecision, FormatMaxPadding, TruncateZero);
5219 scalbn(Arg.Floats[1], Exp, RM));
5226 APFloat Second = Arg.Floats[1];
5228 Second =
scalbn(Second, -Exp, RM);
5234APFloat::Storage::Storage(IEEEFloat
F,
const fltSemantics &Semantics) {
5235 if (usesLayout<IEEEFloat>(Semantics)) {
5236 new (&
IEEE) IEEEFloat(std::move(
F));
5239 if (usesLayout<DoubleAPFloat>(Semantics)) {
5242 DoubleAPFloat(Semantics,
APFloat(std::move(
F), S),
5255 if (APFloat::usesLayout<detail::IEEEFloat>(Arg.
getSemantics()))
5257 if (APFloat::usesLayout<detail::DoubleAPFloat>(Arg.
getSemantics()))
5265 assert(StatusOrErr &&
"Invalid floating point representation");
5289 usesLayout<IEEEFloat>(ToSemantics))
5290 return U.IEEE.convert(ToSemantics, RM, losesInfo);
5292 usesLayout<DoubleAPFloat>(ToSemantics)) {
5295 *
this =
APFloat(ToSemantics, U.IEEE.bitcastToAPInt());
5299 usesLayout<IEEEFloat>(ToSemantics)) {
5300 auto Ret = getIEEE().
convert(ToSemantics, RM, losesInfo);
5301 *
this =
APFloat(std::move(getIEEE()), ToSemantics);
5314 OS << Buffer <<
"\n";
5317#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
5331 bool *isExact)
const {
5335 rounding_mode, isExact);
5337 result =
APInt(bitWidth, parts);
5345 "Float semantics is not representable by IEEEdouble");
5354#ifdef HAS_IEE754_FLOAT128
5355float128 APFloat::convertToQuad()
const {
5357 return getIEEE().convertToQuad();
5359 "Float semantics is not representable by IEEEquad");
5365 return Temp.getIEEE().convertToQuad();
5373 "Float semantics is not representable by IEEEsingle");
5384#undef APFLOAT_DISPATCH_ON_SEMANTICS
#define PackCategoriesIntoKey(_lhs, _rhs)
A macro used to combine two fcCategory enums into one key which can be used in a switch statement to ...
This file declares a class to represent arbitrary precision floating point values and provide a varie...
#define APFLOAT_DISPATCH_ON_SEMANTICS(METHOD_CALL)
This file implements the APSInt class, which is a simple class that represents an arbitrary sized int...
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
#define LLVM_DUMP_METHOD
Mark debug helper function definitions like dump() that should not be stripped from debug builds.
Looks at all the uses of the given value Returns the Liveness deduced from the uses of this value Adds all uses that cause the result to be MaybeLive to MaybeLiveRetUses If the result is MaybeLiveUses might be modified but its content should be ignored(since it might not be complete). DeadArgumentEliminationPass
Given that RA is a live value
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
static bool isSigned(unsigned int Opcode)
Utilities for dealing with flags related to floating point properties and mode controls.
This file defines a hash set that can be used to remove duplication of nodes in a graph.
static bool isZero(Value *V, const DataLayout &DL, DominatorTree *DT, AssumptionCache *AC)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
void Profile(FoldingSetNodeID &NID) const
Used to insert APFloat objects, or objects that contain APFloat objects, into FoldingSets.
opStatus divide(const APFloat &RHS, roundingMode RM)
bool getExactInverse(APFloat *inv) const
opStatus convert(const fltSemantics &ToSemantics, roundingMode RM, bool *losesInfo)
double convertToDouble() const
Converts this APFloat to host double value.
void toString(SmallVectorImpl< char > &Str, unsigned FormatPrecision=0, unsigned FormatMaxPadding=3, bool TruncateZero=true) const
opStatus add(const APFloat &RHS, roundingMode RM)
static APFloat getAllOnesValue(const fltSemantics &Semantics)
Returns a float which is bitcasted from an all one value int.
const fltSemantics & getSemantics() const
opStatus convertFromSignExtendedInteger(const integerPart *Input, unsigned int InputSize, bool IsSigned, roundingMode RM)
opStatus convertFromAPInt(const APInt &Input, bool IsSigned, roundingMode RM)
unsigned int convertToHexString(char *DST, unsigned int HexDigits, bool UpperCase, roundingMode RM) const
float convertToFloat() const
Converts this APFloat to host float value.
opStatus fusedMultiplyAdd(const APFloat &Multiplicand, const APFloat &Addend, roundingMode RM)
opStatus remainder(const APFloat &RHS)
APInt bitcastToAPInt() const
opStatus convertToInteger(MutableArrayRef< integerPart > Input, unsigned int Width, bool IsSigned, roundingMode RM, bool *IsExact) const
opStatus next(bool nextDown)
FPClassTest classify() const
Return the FPClassTest which will return true for the value.
opStatus mod(const APFloat &RHS)
Expected< opStatus > convertFromString(StringRef, roundingMode)
void print(raw_ostream &) const
opStatus roundToIntegral(roundingMode RM)
opStatus convertFromZeroExtendedInteger(const integerPart *Input, unsigned int InputSize, bool IsSigned, roundingMode RM)
Class for arbitrary precision integers.
APInt udiv(const APInt &RHS) const
Unsigned division operation.
static void tcSetBit(WordType *, unsigned bit)
Set the given bit of a bignum. Zero-based.
static APInt getAllOnes(unsigned numBits)
Return an APInt of a specified width with all bits set.
static void tcSet(WordType *, WordType, unsigned)
Sets the least significant part of a bignum to the input value, and zeroes out higher parts.
static void udivrem(const APInt &LHS, const APInt &RHS, APInt &Quotient, APInt &Remainder)
Dual division/remainder interface.
static int tcExtractBit(const WordType *, unsigned bit)
Extract the given bit of a bignum; returns 0 or 1. Zero-based.
APInt zext(unsigned width) const
Zero extend to a new width.
uint64_t getZExtValue() const
Get zero extended value.
static WordType tcAdd(WordType *, const WordType *, WordType carry, unsigned)
DST += RHS + CARRY where CARRY is zero or one. Returns the carry flag.
static void tcExtract(WordType *, unsigned dstCount, const WordType *, unsigned srcBits, unsigned srcLSB)
Copy the bit vector of width srcBITS from SRC, starting at bit srcLSB, to DST, of dstCOUNT parts,...
unsigned getActiveBits() const
Compute the number of active bits in the value.
APInt trunc(unsigned width) const
Truncate to new width.
static int tcCompare(const WordType *, const WordType *, unsigned)
Comparison (unsigned) of two bignums.
static APInt floatToBits(float V)
Converts a float to APInt bits.
static void tcAssign(WordType *, const WordType *, unsigned)
Assign one bignum to another.
unsigned getBitWidth() const
Return the number of bits in the APInt.
static void tcShiftRight(WordType *, unsigned Words, unsigned Count)
Shift a bignum right Count bits.
static void tcFullMultiply(WordType *, const WordType *, const WordType *, unsigned, unsigned)
DST = LHS * RHS, where DST has width the sum of the widths of the operands.
unsigned getNumWords() const
Get the number of words.
bool isNegative() const
Determine sign of this APInt.
@ APINT_BITS_PER_WORD
Bits in a word.
static void tcClearBit(WordType *, unsigned bit)
Clear the given bit of a bignum. Zero-based.
static WordType tcDecrement(WordType *dst, unsigned parts)
Decrement a bignum in-place. Return the borrow flag.
unsigned countr_zero() const
Count the number of trailing zero bits.
static unsigned tcLSB(const WordType *, unsigned n)
Returns the bit number of the least or most significant set bit of a number.
static void tcShiftLeft(WordType *, unsigned Words, unsigned Count)
Shift a bignum left Count bits.
static bool tcIsZero(const WordType *, unsigned)
Returns true if a bignum is zero, false otherwise.
static unsigned tcMSB(const WordType *parts, unsigned n)
Returns the bit number of the most significant set bit of a number.
float bitsToFloat() const
Converts APInt bits to a float.
static int tcMultiplyPart(WordType *dst, const WordType *src, WordType multiplier, WordType carry, unsigned srcParts, unsigned dstParts, bool add)
DST += SRC * MULTIPLIER + PART if add is true DST = SRC * MULTIPLIER + PART if add is false.
static WordType tcSubtract(WordType *, const WordType *, WordType carry, unsigned)
DST -= RHS + CARRY where CARRY is zero or one. Returns the carry flag.
static void tcNegate(WordType *, unsigned)
Negate a bignum in-place.
static APInt doubleToBits(double V)
Converts a double to APInt bits.
static WordType tcIncrement(WordType *dst, unsigned parts)
Increment a bignum in-place. Return the carry flag.
double bitsToDouble() const
Converts APInt bits to a double.
const uint64_t * getRawData() const
This function returns a pointer to the internal storage of the APInt.
static APInt getZero(unsigned numBits)
Get the '0' value for the specified bit-width.
void lshrInPlace(unsigned ShiftAmt)
Logical right-shift this APInt by ShiftAmt in place.
An arbitrary precision integer that knows its signedness.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
size_t size() const
size - Get the array size.
Lightweight error class with error context and mandatory checking.
static ErrorSuccess success()
Create a success value.
Tagged union holding either a T or a Error.
FoldingSetNodeID - This class is used to gather all the unique data bits of a node.
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
iterator erase(const_iterator CI)
void append(ItTy in_start, ItTy in_end)
Add the specified range to the end of the SmallVector.
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringRef - Represent a constant reference to a string, i.e.
bool getAsInteger(unsigned Radix, T &Result) const
Parse the current string as an integer of the specified radix.
bool starts_with(StringRef Prefix) const
Check if this string starts with the given Prefix.
constexpr bool empty() const
empty - Check if the string is empty.
StringRef drop_front(size_t N=1) const
Return a StringRef equal to 'this' but with the first N elements dropped.
char back() const
back - Get the last character in the string.
StringRef slice(size_t Start, size_t End) const
Return a reference to the substring from [Start, End).
constexpr size_t size() const
size - Get the string size.
char front() const
front - Get the first character in the string.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
void makeSmallestNormalized(bool Neg)
DoubleAPFloat & operator=(const DoubleAPFloat &RHS)
LLVM_READONLY int getExactLog2() const
opStatus remainder(const DoubleAPFloat &RHS)
opStatus multiply(const DoubleAPFloat &RHS, roundingMode RM)
fltCategory getCategory() const
bool bitwiseIsEqual(const DoubleAPFloat &RHS) const
LLVM_READONLY int getExactLog2Abs() const
opStatus convertFromAPInt(const APInt &Input, bool IsSigned, roundingMode RM)
opStatus convertFromZeroExtendedInteger(const integerPart *Input, unsigned int InputSize, bool IsSigned, roundingMode RM)
APInt bitcastToAPInt() const
bool getExactInverse(APFloat *inv) const
Expected< opStatus > convertFromString(StringRef, roundingMode)
opStatus subtract(const DoubleAPFloat &RHS, roundingMode RM)
cmpResult compareAbsoluteValue(const DoubleAPFloat &RHS) const
opStatus convertToInteger(MutableArrayRef< integerPart > Input, unsigned int Width, bool IsSigned, roundingMode RM, bool *IsExact) const
void makeSmallest(bool Neg)
opStatus next(bool nextDown)
opStatus divide(const DoubleAPFloat &RHS, roundingMode RM)
bool isSmallestNormalized() const
opStatus mod(const DoubleAPFloat &RHS)
DoubleAPFloat(const fltSemantics &S)
void toString(SmallVectorImpl< char > &Str, unsigned FormatPrecision, unsigned FormatMaxPadding, bool TruncateZero=true) const
void makeLargest(bool Neg)
cmpResult compare(const DoubleAPFloat &RHS) const
opStatus roundToIntegral(roundingMode RM)
opStatus convertFromSignExtendedInteger(const integerPart *Input, unsigned int InputSize, bool IsSigned, roundingMode RM)
opStatus fusedMultiplyAdd(const DoubleAPFloat &Multiplicand, const DoubleAPFloat &Addend, roundingMode RM)
unsigned int convertToHexString(char *DST, unsigned int HexDigits, bool UpperCase, roundingMode RM) const
opStatus add(const DoubleAPFloat &RHS, roundingMode RM)
void makeNaN(bool SNaN, bool Neg, const APInt *fill)
unsigned int convertToHexString(char *dst, unsigned int hexDigits, bool upperCase, roundingMode) const
Write out a hexadecimal representation of the floating point value to DST, which must be of sufficien...
fltCategory getCategory() const
bool isFiniteNonZero() const
opStatus add(const IEEEFloat &, roundingMode)
bool needsCleanup() const
Returns whether this instance allocated memory.
APInt bitcastToAPInt() const
bool isNegative() const
IEEE-754R isSignMinus: Returns true if and only if the current value is negative.
opStatus convertFromZeroExtendedInteger(const integerPart *, unsigned int, bool, roundingMode)
bool isNaN() const
Returns true if and only if the float is a quiet or signaling NaN.
opStatus convertFromAPInt(const APInt &, bool, roundingMode)
opStatus roundToIntegral(roundingMode)
double convertToDouble() const
float convertToFloat() const
cmpResult compareAbsoluteValue(const IEEEFloat &) const
opStatus fusedMultiplyAdd(const IEEEFloat &, const IEEEFloat &, roundingMode)
void makeInf(bool Neg=false)
Expected< opStatus > convertFromString(StringRef, roundingMode)
bool isSmallestNormalized() const
Returns true if this is the smallest (by magnitude) normalized finite number in the given semantics.
bool isLargest() const
Returns true if and only if the number has the largest possible finite magnitude in the current seman...
bool isFinite() const
Returns true if and only if the current value is zero, subnormal, or normal.
void makeNaN(bool SNaN=false, bool Neg=false, const APInt *fill=nullptr)
opStatus convertToInteger(MutableArrayRef< integerPart >, unsigned int, bool, roundingMode, bool *) const
friend int ilogb(const IEEEFloat &Arg)
Returns the exponent of the internal representation of the APFloat.
opStatus remainder(const IEEEFloat &)
IEEE remainder.
IEEEFloat & operator=(const IEEEFloat &)
opStatus divide(const IEEEFloat &, roundingMode)
friend IEEEFloat scalbn(IEEEFloat X, int Exp, roundingMode)
Returns: X * 2^Exp for integral exponents.
bool bitwiseIsEqual(const IEEEFloat &) const
Bitwise comparison for equality (QNaNs compare equal, 0!=-0).
bool isInteger() const
Returns true if and only if the number is an exact integer.
IEEEFloat(const fltSemantics &)
cmpResult compare(const IEEEFloat &) const
IEEE comparison with another floating point number (NaNs compare unordered, 0==-0).
opStatus subtract(const IEEEFloat &, roundingMode)
bool isInfinity() const
IEEE-754R isInfinite(): Returns true if and only if the float is infinity.
const fltSemantics & getSemantics() const
bool isZero() const
Returns true if and only if the float is plus or minus zero.
bool isSignaling() const
Returns true if and only if the float is a signaling NaN.
opStatus convertFromSignExtendedInteger(const integerPart *, unsigned int, bool, roundingMode)
opStatus convert(const fltSemantics &, roundingMode, bool *)
IEEEFloat::convert - convert a value of one floating point type to another.
void makeZero(bool Neg=false)
bool isDenormal() const
IEEE-754R isSubnormal(): Returns true if and only if the float is a denormal.
bool isSmallest() const
Returns true if and only if the number has the smallest possible non-zero magnitude in the current se...
opStatus mod(const IEEEFloat &)
C fmod, or llvm frem.
opStatus multiply(const IEEEFloat &, roundingMode)
An opaque object representing a hash code.
This class implements an extremely fast bulk output stream that can only output to a stream.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ C
The default llvm calling convention, compatible with C.
IEEEFloat scalbn(IEEEFloat X, int Exp, IEEEFloat::roundingMode)
static void tcSetLeastSignificantBits(APInt::WordType *dst, unsigned parts, unsigned bits)
hash_code hash_value(const IEEEFloat &Arg)
IEEEFloat frexp(const IEEEFloat &Val, int &Exp, IEEEFloat::roundingMode RM)
int ilogb(const IEEEFloat &Arg)
std::error_code status(const Twine &path, file_status &result, bool follow=true)
Get file status as if by POSIX stat().
This is an optimization pass for GlobalISel generic memory operations.
static unsigned int partAsHex(char *dst, APFloatBase::integerPart part, unsigned int count, const char *hexDigitChars)
static constexpr fltSemantics semBogus
static const char infinityL[]
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
hash_code hash_value(const FixedPointSemantics &Val)
int popcount(T Value) noexcept
Count the number of set bits in a value.
static constexpr unsigned int partCountForBits(unsigned int bits)
static unsigned int HUerrBound(bool inexactMultiply, unsigned int HUerr1, unsigned int HUerr2)
static unsigned int powerOf5(APFloatBase::integerPart *dst, unsigned int power)
static constexpr fltSemantics semFloat6E2M3FN
static constexpr APFloatBase::ExponentType exponentZero(const fltSemantics &semantics)
static Expected< int > totalExponent(StringRef::iterator p, StringRef::iterator end, int exponentAdjustment)
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
static constexpr fltSemantics semIEEEquad
const unsigned int maxPowerOfFiveExponent
static constexpr fltSemantics semFloat6E3M2FN
static char * writeUnsignedDecimal(char *dst, unsigned int n)
static constexpr fltSemantics semFloat8E4M3FNUZ
const unsigned int maxPrecision
static constexpr fltSemantics semIEEEdouble
APFloat frexp(const APFloat &X, int &Exp, APFloat::roundingMode RM)
Equivalent of C standard library function.
int countr_zero(T Val)
Count number of 0's from the least significant bit to the most stopping at the first 1.
static constexpr fltSemantics semFloat8E4M3FN
static const char infinityU[]
lostFraction
Enum that represents what fraction of the LSB truncated bits of an fp number represent.
static constexpr fltSemantics semPPCDoubleDouble
static Error interpretDecimal(StringRef::iterator begin, StringRef::iterator end, decimalInfo *D)
static constexpr fltSemantics semFloat8E5M2FNUZ
bool isFinite(const Loop *L)
Return true if this loop can be assumed to run for a finite number of iterations.
FPClassTest
Floating-point class tests, supported by 'is_fpclass' intrinsic.
const unsigned int maxPowerOfFiveParts
static constexpr fltSemantics semIEEEsingle
APFloat scalbn(APFloat X, int Exp, APFloat::roundingMode RM)
static constexpr fltSemantics semFloat4E2M1FN
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
static constexpr APFloatBase::ExponentType exponentNaN(const fltSemantics &semantics)
static Error createError(const Twine &Err)
static constexpr fltSemantics semIEEEhalf
static constexpr fltSemantics semPPCDoubleDoubleLegacy
static lostFraction shiftRight(APFloatBase::integerPart *dst, unsigned int parts, unsigned int bits)
static constexpr fltSemantics semFloat8E5M2
@ First
Helpers to iterate all locations in the MemoryEffectsBase class.
static const char hexDigitsUpper[]
const unsigned int maxExponent
static unsigned int decDigitValue(unsigned int c)
static constexpr fltSemantics semFloat8E4M3B11FNUZ
auto count(R &&Range, const E &Element)
Wrapper function around std::count to count the number of times an element Element occurs in the give...
static lostFraction combineLostFractions(lostFraction moreSignificant, lostFraction lessSignificant)
static Expected< StringRef::iterator > skipLeadingZeroesAndAnyDot(StringRef::iterator begin, StringRef::iterator end, StringRef::iterator *dot)
RoundingMode
Rounding mode.
OutputIt copy(R &&Range, OutputIt Out)
static constexpr fltSemantics semX87DoubleExtended
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
static constexpr fltSemantics semFloatTF32
static constexpr APFloatBase::ExponentType exponentInf(const fltSemantics &semantics)
static lostFraction lostFractionThroughTruncation(const APFloatBase::integerPart *parts, unsigned int partCount, unsigned int bits)
static APFloatBase::integerPart ulpsFromBoundary(const APFloatBase::integerPart *parts, unsigned int bits, bool isNearest)
static char * writeSignedDecimal(char *dst, int value)
hash_code hash_combine(const Ts &...args)
Combine values into a single hash_code.
static constexpr fltSemantics semBFloat
static Expected< lostFraction > trailingHexadecimalFraction(StringRef::iterator p, StringRef::iterator end, unsigned int digitValue)
void consumeError(Error Err)
Consume a Error without doing anything.
static Expected< int > readExponent(StringRef::iterator begin, StringRef::iterator end)
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last)
Compute a hash_code for a sequence of values.
constexpr uint64_t NextPowerOf2(uint64_t A)
Returns the next power of two (in 64-bits) that is strictly greater than A.
static const char hexDigitsLower[]
Implement std::hash so that hash_code can be used in STL containers.
static const llvm::fltSemantics & EnumToSemantics(Semantics S)
static const fltSemantics & IEEEsingle() LLVM_READNONE
static const fltSemantics & Float6E3M2FN() LLVM_READNONE
static constexpr roundingMode rmNearestTiesToAway
cmpResult
IEEE-754R 5.11: Floating Point Comparison Relations.
static constexpr roundingMode rmTowardNegative
static ExponentType semanticsMinExponent(const fltSemantics &)
static constexpr roundingMode rmNearestTiesToEven
static unsigned int semanticsSizeInBits(const fltSemantics &)
static unsigned getSizeInBits(const fltSemantics &Sem)
Returns the size of the floating point number (in bits) in the given semantics.
static const fltSemantics & Float8E4M3FN() LLVM_READNONE
static const fltSemantics & PPCDoubleDouble() LLVM_READNONE
static constexpr roundingMode rmTowardZero
static const fltSemantics & x87DoubleExtended() LLVM_READNONE
uninitializedTag
Convenience enum used to construct an uninitialized APFloat.
static const fltSemantics & IEEEquad() LLVM_READNONE
static const fltSemantics & Float4E2M1FN() LLVM_READNONE
static const fltSemantics & Float8E4M3B11FNUZ() LLVM_READNONE
static const fltSemantics & Bogus() LLVM_READNONE
A Pseudo fltsemantic used to construct APFloats that cannot conflict with anything real.
static ExponentType semanticsMaxExponent(const fltSemantics &)
static unsigned int semanticsPrecision(const fltSemantics &)
static const fltSemantics & IEEEdouble() LLVM_READNONE
static const fltSemantics & Float8E5M2() LLVM_READNONE
static Semantics SemanticsToEnum(const llvm::fltSemantics &Sem)
static constexpr unsigned integerPartWidth
static const fltSemantics & IEEEhalf() LLVM_READNONE
APInt::WordType integerPart
static constexpr roundingMode rmTowardPositive
static bool isRepresentableAsNormalIn(const fltSemantics &Src, const fltSemantics &Dst)
static const fltSemantics & Float8E4M3FNUZ() LLVM_READNONE
static const fltSemantics & BFloat() LLVM_READNONE
static const fltSemantics & FloatTF32() LLVM_READNONE
static const fltSemantics & Float8E5M2FNUZ() LLVM_READNONE
static const fltSemantics & Float6E2M3FN() LLVM_READNONE
fltCategory
Category of internally-represented number.
opStatus
IEEE-754R 7: Default exception handling.
int32_t ExponentType
A signed type to represent a floating point numbers unbiased exponent.
static unsigned int semanticsIntSizeInBits(const fltSemantics &, bool)
const char * lastSigDigit
const char * firstSigDigit
bool isRepresentableBy(const fltSemantics &S) const
APFloatBase::ExponentType maxExponent
fltNonfiniteBehavior nonFiniteBehavior
APFloatBase::ExponentType minExponent
fltNanEncoding nanEncoding