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))
287 return A.maxExponent <=
B.maxExponent &&
A.minExponent >=
B.minExponent &&
288 A.precision <=
B.precision;
359 if (Src.maxExponent >= Dst.maxExponent || Src.minExponent <= Dst.minExponent)
367 return Dst.precision >= Src.precision;
407static inline unsigned int
421 unsigned int absExponent;
422 const unsigned int overlargeExponent = 24000;
426 if (p == end || ((*p ==
'-' || *p ==
'+') && (p + 1) == end)) {
430 isNegative = (*p ==
'-');
431 if (*p ==
'-' || *p ==
'+') {
438 if (absExponent >= 10U)
439 return createError(
"Invalid character in exponent");
441 for (; p != end; ++p) {
446 return createError(
"Invalid character in exponent");
448 absExponent = absExponent * 10U +
value;
449 if (absExponent >= overlargeExponent) {
450 absExponent = overlargeExponent;
456 return -(int) absExponent;
458 return (
int) absExponent;
465 int exponentAdjustment) {
466 int unsignedExponent;
467 bool negative, overflow;
473 negative = *p ==
'-';
474 if (*p ==
'-' || *p ==
'+') {
480 unsignedExponent = 0;
482 for (; p != end; ++p) {
487 return createError(
"Invalid character in exponent");
489 unsignedExponent = unsignedExponent * 10 +
value;
490 if (unsignedExponent > 32767) {
496 if (exponentAdjustment > 32767 || exponentAdjustment < -32768)
500 exponent = unsignedExponent;
502 exponent = -exponent;
503 exponent += exponentAdjustment;
504 if (exponent > 32767 || exponent < -32768)
509 exponent = negative ? -32768: 32767;
519 while (p != end && *p ==
'0')
522 if (p != end && *p ==
'.') {
525 if (end - begin == 1)
528 while (p != end && *p ==
'0')
561 return PtrOrErr.takeError();
564 D->firstSigDigit = p;
566 D->normalizedExponent = 0;
568 for (; p != end; ++p) {
571 return createError(
"String contains multiple dots");
581 if (*p !=
'e' && *p !=
'E')
582 return createError(
"Invalid character in significand");
585 if (dot != end && p - begin == 1)
591 return ExpOrErr.takeError();
592 D->exponent = *ExpOrErr;
600 if (p !=
D->firstSigDigit) {
606 while (p != begin && *p ==
'0');
607 while (p != begin && *p ==
'.');
612 D->normalizedExponent = (
D->exponent +
614 - (dot >
D->firstSigDigit && dot < p)));
626 unsigned int digitValue) {
627 unsigned int hexDigit;
633 else if (digitValue < 8 && digitValue > 0)
637 while (p != end && (*p ==
'0' || *p ==
'.'))
641 return createError(
"Invalid trailing hexadecimal fraction!");
643 hexDigit = hexDigitValue(*p);
647 if (hexDigit == UINT_MAX)
657 unsigned int partCount,
686 return lost_fraction;
701 return moreSignificant;
712HUerrBound(
bool inexactMultiply,
unsigned int HUerr1,
unsigned int HUerr2)
714 assert(HUerr1 < 2 || HUerr2 < 2 || (HUerr1 + HUerr2 < 8));
716 if (HUerr1 + HUerr2 == 0)
717 return inexactMultiply * 2;
719 return inexactMultiply + 2 * (HUerr1 + HUerr2);
728 unsigned int count, partBits;
745 if (part - boundary <= boundary - part)
746 return part - boundary;
748 return boundary - part;
751 if (part == boundary) {
757 }
else if (part == boundary - 1) {
774 pow5s[0] = 78125 * 5;
776 unsigned int partsCount = 1;
784 *p1 = firstEightPowers[power & 7];
790 for (
unsigned int n = 0; power; power >>= 1, n++) {
794 partsCount, partsCount);
796 if (pow5[partsCount - 1] == 0)
804 result += partsCount;
805 if (p2[result - 1] == 0)
830static const char NaNL[] =
"nan";
831static const char NaNU[] =
"NAN";
838 const char *hexDigitChars)
840 unsigned int result =
count;
846 dst[
count] = hexDigitChars[part & 0xf];
886void IEEEFloat::initialize(
const fltSemantics *ourSemantics) {
889 semantics = ourSemantics;
895void IEEEFloat::freeSignificand() {
897 delete [] significand.parts;
900void IEEEFloat::assign(
const IEEEFloat &rhs) {
901 assert(semantics == rhs.semantics);
904 category = rhs.category;
905 exponent = rhs.exponent;
907 copySignificand(rhs);
910void IEEEFloat::copySignificand(
const IEEEFloat &rhs) {
912 assert(rhs.partCount() >= partCount());
927 "This floating point format does not support signed values");
931 exponent = exponentNaN();
934 unsigned numParts = partCount();
947 fill = &fill_storage;
958 unsigned bitsToPreserve = semantics->
precision - 1;
959 unsigned part = bitsToPreserve / 64;
960 bitsToPreserve %= 64;
961 significand[part] &= ((1ULL << bitsToPreserve) - 1);
962 for (part++; part != numParts; ++part)
963 significand[part] = 0;
995 if (semantics != rhs.semantics) {
997 initialize(rhs.semantics);
1008 semantics = rhs.semantics;
1009 significand = rhs.significand;
1010 exponent = rhs.exponent;
1011 category = rhs.category;
1029 significandMSB() == 0;
1034 isSignificandAllZerosExceptMSB();
1037unsigned int IEEEFloat::getNumHighBits()
const {
1044 const unsigned int NumHighBits = (semantics->
precision > 1)
1050bool IEEEFloat::isSignificandAllOnes()
const {
1055 for (
unsigned i = 0; i < PartCount - 1; i++)
1060 const unsigned NumHighBits = getNumHighBits();
1061 assert(NumHighBits <= integerPartWidth && NumHighBits > 0 &&
1062 "Can not have more high bits to fill than integerPartWidth");
1065 if ((semantics->
precision <= 1) || (~(Parts[PartCount - 1] | HighBitFill)))
1071bool IEEEFloat::isSignificandAllOnesExceptLSB()
const {
1080 for (
unsigned i = 0; i < PartCount - 1; i++) {
1081 if (~Parts[i] & ~
unsigned{!i})
1086 const unsigned NumHighBits = getNumHighBits();
1087 assert(NumHighBits <= integerPartWidth && NumHighBits > 0 &&
1088 "Can not have more high bits to fill than integerPartWidth");
1091 if (~(Parts[PartCount - 1] | HighBitFill | 0x1))
1097bool IEEEFloat::isSignificandAllZeros()
const {
1103 for (
unsigned i = 0; i < PartCount - 1; i++)
1108 const unsigned NumHighBits = getNumHighBits();
1110 "clear than integerPartWidth");
1111 const integerPart HighBitMask = ~integerPart(0) >> NumHighBits;
1113 if ((semantics->
precision > 1) && (Parts[PartCount - 1] & HighBitMask))
1119bool IEEEFloat::isSignificandAllZerosExceptMSB()
const {
1123 for (
unsigned i = 0; i < PartCount - 1; i++) {
1128 const unsigned NumHighBits = getNumHighBits();
1131 return ((semantics->
precision <= 1) || (Parts[PartCount - 1] == MSBMask));
1142 ? isSignificandAllOnesExceptLSB()
1147 return IsMaxExp && isSignificandAllOnes();
1162 if (semantics != rhs.semantics ||
1163 category != rhs.category ||
1172 return std::equal(significandParts(), significandParts() + partCount(),
1173 rhs.significandParts());
1177 initialize(&ourSemantics);
1182 significandParts()[0] =
value;
1187 initialize(&ourSemantics);
1203 initialize(rhs.semantics);
1208 *
this = std::move(rhs);
1213unsigned int IEEEFloat::partCount()
const {
1218 return const_cast<IEEEFloat *
>(
this)->significandParts();
1222 if (partCount() > 1)
1223 return significand.parts;
1225 return &significand.part;
1228void IEEEFloat::zeroSignificand() {
1233void IEEEFloat::incrementSignificand() {
1247 parts = significandParts();
1249 assert(semantics == rhs.semantics);
1250 assert(exponent == rhs.exponent);
1252 return APInt::tcAdd(parts, rhs.significandParts(), 0, partCount());
1261 parts = significandParts();
1263 assert(semantics == rhs.semantics);
1264 assert(exponent == rhs.exponent);
1273lostFraction IEEEFloat::multiplySignificand(
const IEEEFloat &rhs,
1275 bool ignoreAddend) {
1277 unsigned int partsCount, newPartsCount, precision;
1284 assert(semantics == rhs.semantics);
1292 if (newPartsCount > 4)
1295 fullSignificand = scratch;
1297 lhsSignificand = significandParts();
1298 partsCount = partCount();
1301 rhs.significandParts(), partsCount, partsCount);
1304 omsb =
APInt::tcMSB(fullSignificand, newPartsCount) + 1;
1305 exponent += rhs.exponent;
1319 if (!ignoreAddend && addend.isNonZero()) {
1323 Significand savedSignificand = significand;
1327 unsigned int extendedPrecision;
1330 extendedPrecision = 2 * precision + 1;
1331 if (omsb != extendedPrecision - 1) {
1332 assert(extendedPrecision > omsb);
1334 (extendedPrecision - 1) - omsb);
1335 exponent -= (extendedPrecision - 1) - omsb;
1339 extendedSemantics = *semantics;
1340 extendedSemantics.
precision = extendedPrecision;
1342 if (newPartsCount == 1)
1343 significand.part = fullSignificand[0];
1345 significand.parts = fullSignificand;
1346 semantics = &extendedSemantics;
1360 lost_fraction = extendedAddend.shiftSignificandRight(1);
1362 "Lost precision while shifting addend for fused-multiply-add.");
1364 lost_fraction = addOrSubtractSignificand(extendedAddend,
false);
1367 if (newPartsCount == 1)
1368 fullSignificand[0] = significand.part;
1369 significand = savedSignificand;
1370 semantics = savedSemantics;
1372 omsb =
APInt::tcMSB(fullSignificand, newPartsCount) + 1;
1379 exponent -= precision + 1;
1388 if (omsb > precision) {
1389 unsigned int bits, significantParts;
1392 bits = omsb - precision;
1394 lf =
shiftRight(fullSignificand, significantParts, bits);
1401 if (newPartsCount > 4)
1402 delete [] fullSignificand;
1404 return lost_fraction;
1407lostFraction IEEEFloat::multiplySignificand(
const IEEEFloat &rhs) {
1413 return multiplySignificand(rhs,
IEEEFloat(*semantics), !semantics->
hasZero);
1417lostFraction IEEEFloat::divideSignificand(
const IEEEFloat &rhs) {
1418 unsigned int bit, i, partsCount;
1424 assert(semantics == rhs.semantics);
1426 lhsSignificand = significandParts();
1427 rhsSignificand = rhs.significandParts();
1428 partsCount = partCount();
1435 divisor = dividend + partsCount;
1438 for (i = 0; i < partsCount; i++) {
1439 dividend[i] = lhsSignificand[i];
1440 divisor[i] = rhsSignificand[i];
1441 lhsSignificand[i] = 0;
1444 exponent -= rhs.exponent;
1446 unsigned int precision = semantics->
precision;
1449 bit = precision -
APInt::tcMSB(divisor, partsCount) - 1;
1456 bit = precision -
APInt::tcMSB(dividend, partsCount) - 1;
1472 for (bit = precision; bit; bit -= 1) {
1496 return lost_fraction;
1499unsigned int IEEEFloat::significandMSB()
const {
1503unsigned int IEEEFloat::significandLSB()
const {
1508lostFraction IEEEFloat::shiftSignificandRight(
unsigned int bits) {
1514 return shiftRight(significandParts(), partCount(), bits);
1518void IEEEFloat::shiftSignificandLeft(
unsigned int bits) {
1519 assert(bits < semantics->precision ||
1520 (semantics->
precision == 1 && bits <= 1));
1523 unsigned int partsCount = partCount();
1535 assert(semantics == rhs.semantics);
1539 compare = exponent - rhs.exponent;
1606bool IEEEFloat::roundAwayFromZero(
roundingMode rounding_mode,
1608 unsigned int bit)
const {
1615 switch (rounding_mode) {
1653 omsb = significandMSB() + 1;
1659 exponentChange = omsb - semantics->
precision;
1663 if (exponent + exponentChange > semantics->
maxExponent)
1664 return handleOverflow(rounding_mode);
1668 if (exponent + exponentChange < semantics->minExponent)
1669 exponentChange = semantics->
minExponent - exponent;
1672 if (exponentChange < 0) {
1675 shiftSignificandLeft(-exponentChange);
1680 if (exponentChange > 0) {
1684 lf = shiftSignificandRight(exponentChange);
1689 if (omsb > (
unsigned) exponentChange)
1690 omsb -= exponentChange;
1700 exponent == semantics->
maxExponent && isSignificandAllOnes())
1701 return handleOverflow(rounding_mode);
1722 if (roundAwayFromZero(rounding_mode, lost_fraction, 0)) {
1726 incrementSignificand();
1727 omsb = significandMSB() + 1;
1730 if (omsb == (
unsigned) semantics->
precision + 1) {
1741 shiftSignificandRight(1);
1750 exponent == semantics->
maxExponent && isSignificandAllOnes())
1751 return handleOverflow(rounding_mode);
1760 assert(omsb < semantics->precision);
1835lostFraction IEEEFloat::addOrSubtractSignificand(
const IEEEFloat &rhs,
1843 subtract ^=
static_cast<bool>(sign ^ rhs.sign);
1846 bits = exponent - rhs.exponent;
1852 "This floating point format does not support signed values");
1858 else if (bits > 0) {
1859 lost_fraction = temp_rhs.shiftSignificandRight(bits - 1);
1860 shiftSignificandLeft(1);
1862 lost_fraction = shiftSignificandRight(-bits - 1);
1863 temp_rhs.shiftSignificandLeft(1);
1868 carry = temp_rhs.subtractSignificand
1870 copySignificand(temp_rhs);
1873 carry = subtractSignificand
1892 lost_fraction = temp_rhs.shiftSignificandRight(bits);
1893 carry = addSignificand(temp_rhs);
1895 lost_fraction = shiftSignificandRight(-bits);
1896 carry = addSignificand(rhs);
1904 return lost_fraction;
2093 fs = addOrSubtractSpecials(rhs,
subtract);
2099 lost_fraction = addOrSubtractSignificand(rhs,
subtract);
2100 fs = normalize(rounding_mode, lost_fraction);
2109 if (category ==
fcZero) {
2123 return addOrSubtract(rhs, rounding_mode,
false);
2129 return addOrSubtract(rhs, rounding_mode,
true);
2138 fs = multiplySpecials(rhs);
2144 fs = normalize(rounding_mode, lost_fraction);
2158 fs = divideSpecials(rhs);
2164 fs = normalize(rounding_mode, lost_fraction);
2175 unsigned int origSign = sign;
2178 fs = remainderSpecials(rhs);
2285 fs = modSpecials(rhs);
2286 unsigned int origSign = sign;
2307 if (!semantics->
hasZero && this->isSmallest())
2327 sign ^= multiplicand.sign;
2336 lost_fraction = multiplySignificand(multiplicand, addend);
2337 fs = normalize(rounding_mode, lost_fraction);
2350 fs = multiplySpecials(multiplicand);
2360 fs = addOrSubtract(addend, rounding_mode,
false);
2434 MagicConstant.sign = sign;
2440 fs =
add(MagicConstant, rounding_mode);
2444 subtract(MagicConstant, rounding_mode);
2457 assert(semantics == rhs.semantics);
2489 if (sign == rhs.sign)
2504 if (sign != rhs.sign) {
2535 unsigned int newPartCount, oldPartCount;
2543 oldPartCount = partCount();
2546 bool X86SpecialNan =
false;
2549 (!(*significandParts() & 0x8000000000000000ULL) ||
2550 !(*significandParts() & 0x4000000000000000ULL))) {
2553 X86SpecialNan =
true;
2564 int omsb = significandMSB() + 1;
2565 int exponentChange = omsb - fromSemantics.
precision;
2566 if (exponent + exponentChange < toSemantics.
minExponent)
2567 exponentChange = toSemantics.
minExponent - exponent;
2568 if (exponentChange < shift)
2569 exponentChange = shift;
2570 if (exponentChange < 0) {
2571 shift -= exponentChange;
2572 exponent += exponentChange;
2573 }
else if (omsb <= -shift) {
2574 exponentChange = omsb + shift - 1;
2575 shift -= exponentChange;
2576 exponent += exponentChange;
2587 if (newPartCount > oldPartCount) {
2595 significand.parts = newParts;
2596 }
else if (newPartCount == 1 && oldPartCount != 1) {
2600 newPart = significandParts()[0];
2602 significand.part = newPart;
2606 semantics = &toSemantics;
2615 *losesInfo = (fs !=
opOK);
2616 }
else if (category ==
fcNaN) {
2651 }
else if (category ==
fcZero &&
2684 unsigned int dstPartsCount, truncatedBits;
2693 assert(dstPartsCount <= parts.
size() &&
"Integer too big");
2695 if (category ==
fcZero) {
2702 src = significandParts();
2711 truncatedBits = semantics->
precision -1U - exponent;
2715 unsigned int bits = exponent + 1U;
2721 if (bits < semantics->precision) {
2723 truncatedBits = semantics->
precision - bits;
2737 if (truncatedBits) {
2741 roundAwayFromZero(rounding_mode, lost_fraction, truncatedBits)) {
2761 if (omsb == width &&
2798 fs = convertToSignExtendedInteger(parts, width,
isSigned, rounding_mode,
2802 unsigned int bits, dstPartsCount;
2805 assert(dstPartsCount <= parts.
size() &&
"Integer too big");
2807 if (category ==
fcNaN)
2827 unsigned int omsb, precision, dstCount;
2833 dst = significandParts();
2834 dstCount = partCount();
2839 if (precision <= omsb) {
2840 exponent = omsb - 1;
2845 exponent = precision - 1;
2850 return normalize(rounding_mode, lost_fraction);
2864 return convertFromUnsignedParts(api.
getRawData(), partCount, rounding_mode);
2872 unsigned int srcCount,
bool isSigned,
2885 status = convertFromUnsignedParts(
copy, srcCount, rounding_mode);
2889 status = convertFromUnsignedParts(src, srcCount, rounding_mode);
2909 return convertFromUnsignedParts(api.
getRawData(), partCount, rounding_mode);
2913IEEEFloat::convertFromHexadecimalString(
StringRef s,
2922 unsigned partsCount = partCount();
2924 bool computedTrailingFraction =
false;
2932 return PtrOrErr.takeError();
2941 return createError(
"String contains multiple dots");
2946 hex_value = hexDigitValue(*p);
2947 if (hex_value == UINT_MAX)
2957 }
else if (!computedTrailingFraction) {
2960 return FractOrErr.takeError();
2961 lost_fraction = *FractOrErr;
2962 computedTrailingFraction =
true;
2968 return createError(
"Hex strings require an exponent");
2969 if (*p !=
'p' && *p !=
'P')
2970 return createError(
"Invalid character in significand");
2973 if (dot != end && p - begin == 1)
2977 if (p != firstSignificantDigit) {
2986 expAdjustment =
static_cast<int>(
dot - firstSignificantDigit);
2987 if (expAdjustment < 0)
2989 expAdjustment = expAdjustment * 4 - 1;
2999 return ExpOrErr.takeError();
3000 exponent = *ExpOrErr;
3003 return normalize(rounding_mode, lost_fraction);
3007IEEEFloat::roundSignificandWithExponent(
const integerPart *decSigParts,
3008 unsigned sigPartCount,
int exp,
3010 unsigned int parts, pow5PartCount;
3021 pow5PartCount =
powerOf5(pow5Parts, exp >= 0 ? exp: -exp);
3023 for (;; parts *= 2) {
3025 unsigned int excessPrecision, truncatedBits;
3029 truncatedBits = excessPrecision;
3032 decSig.makeZero(sign);
3035 sigStatus = decSig.convertFromUnsignedParts(decSigParts, sigPartCount,
3037 powStatus = pow5.convertFromUnsignedParts(pow5Parts, pow5PartCount,
3040 decSig.exponent += exp;
3044 unsigned int powHUerr;
3048 calcLostFraction = decSig.multiplySignificand(pow5);
3049 powHUerr = powStatus !=
opOK;
3051 calcLostFraction = decSig.divideSignificand(pow5);
3054 excessPrecision += (semantics->
minExponent - decSig.exponent);
3055 truncatedBits = excessPrecision;
3056 if (excessPrecision > calcSemantics.
precision)
3057 excessPrecision = calcSemantics.
precision;
3066 (decSig.significandParts(), calcSemantics.
precision - 1) == 1);
3071 excessPrecision, isNearest);
3074 if (HUdistance >= HUerr) {
3075 APInt::tcExtract(significandParts(), partCount(), decSig.significandParts(),
3076 calcSemantics.
precision - excessPrecision,
3081 exponent = (decSig.exponent + semantics->
precision
3082 - (calcSemantics.
precision - excessPrecision));
3086 return normalize(rounding_mode, calcLostFraction);
3099 return std::move(Err);
3135 }
else if (
D.normalizedExponent - 1 > INT_MAX / 42039) {
3136 fs = handleOverflow(rounding_mode);
3142 }
else if (
D.normalizedExponent - 1 < INT_MIN / 42039 ||
3143 (
D.normalizedExponent + 1) * 28738 <=
3151 }
else if ((
D.normalizedExponent - 1) * 42039
3154 fs = handleOverflow(rounding_mode);
3157 unsigned int partCount;
3163 partCount =
static_cast<unsigned int>(
D.lastSigDigit -
D.firstSigDigit) + 1;
3181 if (p == str.
end()) {
3186 if (decValue >= 10U) {
3187 delete[] decSignificand;
3188 return createError(
"Invalid character in significand");
3191 val = val * 10 + decValue;
3194 }
while (p <=
D.lastSigDigit && multiplier <= (~ (
integerPart) 0 - 9) / 10);
3198 partCount, partCount + 1,
false);
3202 if (decSignificand[partCount])
3204 }
while (p <=
D.lastSigDigit);
3207 fs = roundSignificandWithExponent(decSignificand, partCount,
3208 D.exponent, rounding_mode);
3210 delete [] decSignificand;
3216bool IEEEFloat::convertFromStringSpecials(
StringRef str) {
3217 const size_t MIN_NAME_SIZE = 3;
3219 if (str.
size() < MIN_NAME_SIZE)
3222 if (str ==
"inf" || str ==
"INFINITY" || str ==
"+Inf") {
3227 bool IsNegative = str.
front() ==
'-';
3230 if (str.
size() < MIN_NAME_SIZE)
3233 if (str ==
"inf" || str ==
"INFINITY" || str ==
"Inf") {
3240 bool IsSignaling = str.
front() ==
's' || str.
front() ==
'S';
3243 if (str.
size() < MIN_NAME_SIZE)
3252 makeNaN(IsSignaling, IsNegative);
3257 if (str.
front() ==
'(') {
3259 if (str.
size() <= 2 || str.
back() !=
')')
3266 unsigned Radix = 10;
3267 if (str[0] ==
'0') {
3268 if (str.
size() > 1 && tolower(str[1]) ==
'x') {
3278 makeNaN(IsSignaling, IsNegative, &Payload);
3292 if (convertFromStringSpecials(str))
3297 size_t slen = str.
size();
3298 sign = *p ==
'-' ? 1 : 0;
3301 "This floating point format does not support signed values");
3303 if (*p ==
'-' || *p ==
'+') {
3310 if (slen >= 2 && p[0] ==
'0' && (p[1] ==
'x' || p[1] ==
'X')) {
3313 return convertFromHexadecimalString(
StringRef(p + 2, slen - 2),
3317 return convertFromDecimalString(
StringRef(p, slen), rounding_mode);
3361 dst +=
sizeof NaNU - 1;
3366 *dst++ = upperCase ?
'X':
'x';
3368 if (hexDigits > 1) {
3370 memset (dst,
'0', hexDigits - 1);
3371 dst += hexDigits - 1;
3373 *dst++ = upperCase ?
'P':
'p';
3378 dst = convertNormalToHexString (dst, hexDigits, upperCase, rounding_mode);
3384 return static_cast<unsigned int>(dst - p);
3391char *IEEEFloat::convertNormalToHexString(
char *dst,
unsigned int hexDigits,
3394 unsigned int count, valueBits, shift, partsCount, outputDigits;
3395 const char *hexDigitChars;
3401 *dst++ = upperCase ?
'X':
'x';
3406 significand = significandParts();
3407 partsCount = partCount();
3416 outputDigits = (valueBits - significandLSB () + 3) / 4;
3422 if (hexDigits < outputDigits) {
3428 bits = valueBits - hexDigits * 4;
3430 roundUp = roundAwayFromZero(rounding_mode, fraction, bits);
3432 outputDigits = hexDigits;
3442 while (outputDigits &&
count) {
3446 if (--
count == partsCount)
3449 part = significand[
count] << shift;
3457 if (curDigits > outputDigits)
3458 curDigits = outputDigits;
3459 dst +=
partAsHex (dst, part, curDigits, hexDigitChars);
3460 outputDigits -= curDigits;
3469 *
q = hexDigitChars[hexDigitValue (*q) + 1];
3470 }
while (*q ==
'0');
3474 memset (dst,
'0', outputDigits);
3475 dst += outputDigits;
3488 *dst++ = upperCase ?
'P':
'p';
3504 Arg.significandParts(),
3505 Arg.significandParts() + Arg.partCount()));
3517APInt IEEEFloat::convertF80LongDoubleAPFloatToAPInt()
const {
3521 uint64_t myexponent, mysignificand;
3524 myexponent = exponent+16383;
3525 mysignificand = significandParts()[0];
3526 if (myexponent==1 && !(mysignificand & 0x8000000000000000ULL))
3528 }
else if (category==
fcZero) {
3532 myexponent = 0x7fff;
3533 mysignificand = 0x8000000000000000ULL;
3536 myexponent = 0x7fff;
3537 mysignificand = significandParts()[0];
3541 words[0] = mysignificand;
3542 words[1] = ((
uint64_t)(sign & 1) << 15) |
3543 (myexponent & 0x7fffLL);
3544 return APInt(80, words);
3547APInt IEEEFloat::convertPPCDoubleDoubleLegacyAPFloatToAPInt()
const {
3572 words[0] = *
u.convertDoubleAPFloatToAPInt().getRawData();
3578 if (
u.isFiniteNonZero() && losesInfo) {
3588 words[1] = *
v.convertDoubleAPFloatToAPInt().getRawData();
3593 return APInt(128, words);
3596template <const fltSemantics &S>
3597APInt IEEEFloat::convertIEEEFloatToAPInt()
const {
3601 constexpr unsigned int trailing_significand_bits = S.precision - 1;
3602 constexpr int integer_bit_part = trailing_significand_bits /
integerPartWidth;
3605 constexpr uint64_t significand_mask = integer_bit - 1;
3606 constexpr unsigned int exponent_bits =
3607 trailing_significand_bits ? (S.sizeInBits - 1 - trailing_significand_bits)
3609 static_assert(exponent_bits < 64);
3617 myexponent = exponent + bias;
3618 std::copy_n(significandParts(), mysignificand.size(),
3619 mysignificand.begin());
3620 if (myexponent == 1 &&
3621 !(significandParts()[integer_bit_part] & integer_bit))
3623 }
else if (category ==
fcZero) {
3626 myexponent = ::exponentZero(S) + bias;
3627 mysignificand.fill(0);
3632 myexponent = ::exponentInf(S) + bias;
3633 mysignificand.fill(0);
3638 myexponent = ::exponentNaN(S) + bias;
3639 std::copy_n(significandParts(), mysignificand.size(),
3640 mysignificand.begin());
3642 std::array<
uint64_t, (S.sizeInBits + 63) / 64> words;
3644 std::copy_n(mysignificand.begin(), mysignificand.size(), words.begin());
3645 if constexpr (significand_mask != 0 || trailing_significand_bits == 0) {
3647 words[mysignificand.size() - 1] &= significand_mask;
3649 std::fill(words_iter, words.end(),
uint64_t{0});
3650 constexpr size_t last_word = words.size() - 1;
3652 << ((S.sizeInBits - 1) % 64);
3653 words[last_word] |= shifted_sign;
3654 uint64_t shifted_exponent = (myexponent & exponent_mask)
3655 << (trailing_significand_bits % 64);
3656 words[last_word] |= shifted_exponent;
3657 if constexpr (last_word == 0) {
3658 return APInt(S.sizeInBits, words[0]);
3660 return APInt(S.sizeInBits, words);
3663APInt IEEEFloat::convertQuadrupleAPFloatToAPInt()
const {
3664 assert(partCount() == 2);
3665 return convertIEEEFloatToAPInt<semIEEEquad>();
3668APInt IEEEFloat::convertDoubleAPFloatToAPInt()
const {
3670 return convertIEEEFloatToAPInt<semIEEEdouble>();
3673APInt IEEEFloat::convertFloatAPFloatToAPInt()
const {
3675 return convertIEEEFloatToAPInt<semIEEEsingle>();
3678APInt IEEEFloat::convertBFloatAPFloatToAPInt()
const {
3679 assert(partCount() == 1);
3680 return convertIEEEFloatToAPInt<semBFloat>();
3683APInt IEEEFloat::convertHalfAPFloatToAPInt()
const {
3685 return convertIEEEFloatToAPInt<semIEEEhalf>();
3688APInt IEEEFloat::convertFloat8E5M2APFloatToAPInt()
const {
3689 assert(partCount() == 1);
3690 return convertIEEEFloatToAPInt<semFloat8E5M2>();
3693APInt IEEEFloat::convertFloat8E5M2FNUZAPFloatToAPInt()
const {
3694 assert(partCount() == 1);
3695 return convertIEEEFloatToAPInt<semFloat8E5M2FNUZ>();
3698APInt IEEEFloat::convertFloat8E4M3APFloatToAPInt()
const {
3699 assert(partCount() == 1);
3700 return convertIEEEFloatToAPInt<semFloat8E4M3>();
3703APInt IEEEFloat::convertFloat8E4M3FNAPFloatToAPInt()
const {
3704 assert(partCount() == 1);
3705 return convertIEEEFloatToAPInt<semFloat8E4M3FN>();
3708APInt IEEEFloat::convertFloat8E4M3FNUZAPFloatToAPInt()
const {
3709 assert(partCount() == 1);
3710 return convertIEEEFloatToAPInt<semFloat8E4M3FNUZ>();
3713APInt IEEEFloat::convertFloat8E4M3B11FNUZAPFloatToAPInt()
const {
3714 assert(partCount() == 1);
3715 return convertIEEEFloatToAPInt<semFloat8E4M3B11FNUZ>();
3718APInt IEEEFloat::convertFloat8E3M4APFloatToAPInt()
const {
3719 assert(partCount() == 1);
3720 return convertIEEEFloatToAPInt<semFloat8E3M4>();
3723APInt IEEEFloat::convertFloatTF32APFloatToAPInt()
const {
3724 assert(partCount() == 1);
3725 return convertIEEEFloatToAPInt<semFloatTF32>();
3728APInt IEEEFloat::convertFloat8E8M0FNUAPFloatToAPInt()
const {
3729 assert(partCount() == 1);
3730 return convertIEEEFloatToAPInt<semFloat8E8M0FNU>();
3733APInt IEEEFloat::convertFloat6E3M2FNAPFloatToAPInt()
const {
3734 assert(partCount() == 1);
3735 return convertIEEEFloatToAPInt<semFloat6E3M2FN>();
3738APInt IEEEFloat::convertFloat6E2M3FNAPFloatToAPInt()
const {
3739 assert(partCount() == 1);
3740 return convertIEEEFloatToAPInt<semFloat6E2M3FN>();
3743APInt IEEEFloat::convertFloat4E2M1FNAPFloatToAPInt()
const {
3744 assert(partCount() == 1);
3745 return convertIEEEFloatToAPInt<semFloat4E2M1FN>();
3754 return convertHalfAPFloatToAPInt();
3757 return convertBFloatAPFloatToAPInt();
3760 return convertFloatAPFloatToAPInt();
3763 return convertDoubleAPFloatToAPInt();
3766 return convertQuadrupleAPFloatToAPInt();
3769 return convertPPCDoubleDoubleLegacyAPFloatToAPInt();
3772 return convertFloat8E5M2APFloatToAPInt();
3775 return convertFloat8E5M2FNUZAPFloatToAPInt();
3778 return convertFloat8E4M3APFloatToAPInt();
3781 return convertFloat8E4M3FNAPFloatToAPInt();
3784 return convertFloat8E4M3FNUZAPFloatToAPInt();
3787 return convertFloat8E4M3B11FNUZAPFloatToAPInt();
3790 return convertFloat8E3M4APFloatToAPInt();
3793 return convertFloatTF32APFloatToAPInt();
3796 return convertFloat8E8M0FNUAPFloatToAPInt();
3799 return convertFloat6E3M2FNAPFloatToAPInt();
3802 return convertFloat6E2M3FNAPFloatToAPInt();
3805 return convertFloat4E2M1FNAPFloatToAPInt();
3809 return convertF80LongDoubleAPFloatToAPInt();
3814 "Float semantics are not IEEEsingle");
3821 "Float semantics are not IEEEdouble");
3826#ifdef HAS_IEE754_FLOAT128
3827float128 IEEEFloat::convertToQuad()
const {
3829 "Float semantics are not IEEEquads");
3831 return api.bitsToQuad();
3842void IEEEFloat::initFromF80LongDoubleAPInt(
const APInt &api) {
3845 uint64_t myexponent = (i2 & 0x7fff);
3847 uint8_t myintegerbit = mysignificand >> 63;
3852 sign =
static_cast<unsigned int>(i2>>15);
3853 if (myexponent == 0 && mysignificand == 0) {
3855 }
else if (myexponent==0x7fff && mysignificand==0x8000000000000000ULL) {
3857 }
else if ((myexponent == 0x7fff && mysignificand != 0x8000000000000000ULL) ||
3858 (myexponent != 0x7fff && myexponent != 0 && myintegerbit == 0)) {
3860 exponent = exponentNaN();
3861 significandParts()[0] = mysignificand;
3862 significandParts()[1] = 0;
3865 exponent = myexponent - 16383;
3866 significandParts()[0] = mysignificand;
3867 significandParts()[1] = 0;
3873void IEEEFloat::initFromPPCDoubleDoubleLegacyAPInt(
const APInt &api) {
3880 initFromDoubleAPInt(
APInt(64, i1));
3901void IEEEFloat::initFromFloat8E8M0FNUAPInt(
const APInt &api) {
3902 const uint64_t exponent_mask = 0xff;
3904 uint64_t myexponent = (val & exponent_mask);
3907 assert(partCount() == 1);
3916 significandParts()[0] = mysignificand;
3920 if (val == exponent_mask) {
3922 exponent = exponentNaN();
3927 exponent = myexponent - 127;
3929template <const fltSemantics &S>
3930void IEEEFloat::initFromIEEEAPInt(
const APInt &api) {
3934 constexpr uint64_t significand_mask = integer_bit - 1;
3935 constexpr unsigned int trailing_significand_bits = S.precision - 1;
3936 constexpr unsigned int stored_significand_parts =
3938 constexpr unsigned int exponent_bits =
3939 S.sizeInBits - 1 - trailing_significand_bits;
3940 static_assert(exponent_bits < 64);
3942 constexpr int bias = -(S.minExponent - 1);
3946 std::array<integerPart, stored_significand_parts> mysignificand;
3947 std::copy_n(api.
getRawData(), mysignificand.size(), mysignificand.begin());
3948 if constexpr (significand_mask != 0) {
3949 mysignificand[mysignificand.size() - 1] &= significand_mask;
3956 (last_word >> (trailing_significand_bits % 64)) & exponent_mask;
3959 assert(partCount() == mysignificand.size());
3961 sign =
static_cast<unsigned int>(last_word >> ((S.sizeInBits - 1) % 64));
3963 bool all_zero_significand =
3966 bool is_zero = myexponent == 0 && all_zero_significand;
3969 if (myexponent - bias == ::exponentInf(S) && all_zero_significand) {
3978 is_nan = myexponent - bias == ::exponentNaN(S) && !all_zero_significand;
3980 bool all_ones_significand =
3981 std::all_of(mysignificand.begin(), mysignificand.end() - 1,
3982 [](
integerPart bits) { return bits == ~integerPart{0}; }) &&
3983 (!significand_mask ||
3984 mysignificand[mysignificand.size() - 1] == significand_mask);
3985 is_nan = myexponent - bias == ::exponentNaN(S) && all_ones_significand;
3993 std::copy_n(mysignificand.begin(), mysignificand.size(),
3994 significandParts());
4004 exponent = myexponent - bias;
4005 std::copy_n(mysignificand.begin(), mysignificand.size(), significandParts());
4006 if (myexponent == 0)
4007 exponent = S.minExponent;
4009 significandParts()[mysignificand.size()-1] |= integer_bit;
4012void IEEEFloat::initFromQuadrupleAPInt(
const APInt &api) {
4013 initFromIEEEAPInt<semIEEEquad>(api);
4016void IEEEFloat::initFromDoubleAPInt(
const APInt &api) {
4017 initFromIEEEAPInt<semIEEEdouble>(api);
4020void IEEEFloat::initFromFloatAPInt(
const APInt &api) {
4021 initFromIEEEAPInt<semIEEEsingle>(api);
4024void IEEEFloat::initFromBFloatAPInt(
const APInt &api) {
4025 initFromIEEEAPInt<semBFloat>(api);
4028void IEEEFloat::initFromHalfAPInt(
const APInt &api) {
4029 initFromIEEEAPInt<semIEEEhalf>(api);
4032void IEEEFloat::initFromFloat8E5M2APInt(
const APInt &api) {
4033 initFromIEEEAPInt<semFloat8E5M2>(api);
4036void IEEEFloat::initFromFloat8E5M2FNUZAPInt(
const APInt &api) {
4037 initFromIEEEAPInt<semFloat8E5M2FNUZ>(api);
4040void IEEEFloat::initFromFloat8E4M3APInt(
const APInt &api) {
4041 initFromIEEEAPInt<semFloat8E4M3>(api);
4044void IEEEFloat::initFromFloat8E4M3FNAPInt(
const APInt &api) {
4045 initFromIEEEAPInt<semFloat8E4M3FN>(api);
4048void IEEEFloat::initFromFloat8E4M3FNUZAPInt(
const APInt &api) {
4049 initFromIEEEAPInt<semFloat8E4M3FNUZ>(api);
4052void IEEEFloat::initFromFloat8E4M3B11FNUZAPInt(
const APInt &api) {
4053 initFromIEEEAPInt<semFloat8E4M3B11FNUZ>(api);
4056void IEEEFloat::initFromFloat8E3M4APInt(
const APInt &api) {
4057 initFromIEEEAPInt<semFloat8E3M4>(api);
4060void IEEEFloat::initFromFloatTF32APInt(
const APInt &api) {
4061 initFromIEEEAPInt<semFloatTF32>(api);
4064void IEEEFloat::initFromFloat6E3M2FNAPInt(
const APInt &api) {
4065 initFromIEEEAPInt<semFloat6E3M2FN>(api);
4068void IEEEFloat::initFromFloat6E2M3FNAPInt(
const APInt &api) {
4069 initFromIEEEAPInt<semFloat6E2M3FN>(api);
4072void IEEEFloat::initFromFloat4E2M1FNAPInt(
const APInt &api) {
4073 initFromIEEEAPInt<semFloat4E2M1FN>(api);
4080 return initFromHalfAPInt(api);
4082 return initFromBFloatAPInt(api);
4084 return initFromFloatAPInt(api);
4086 return initFromDoubleAPInt(api);
4088 return initFromF80LongDoubleAPInt(api);
4090 return initFromQuadrupleAPInt(api);
4092 return initFromPPCDoubleDoubleLegacyAPInt(api);
4094 return initFromFloat8E5M2APInt(api);
4096 return initFromFloat8E5M2FNUZAPInt(api);
4098 return initFromFloat8E4M3APInt(api);
4100 return initFromFloat8E4M3FNAPInt(api);
4102 return initFromFloat8E4M3FNUZAPInt(api);
4104 return initFromFloat8E4M3B11FNUZAPInt(api);
4106 return initFromFloat8E3M4APInt(api);
4108 return initFromFloatTF32APInt(api);
4110 return initFromFloat8E8M0FNUAPInt(api);
4112 return initFromFloat6E3M2FNAPInt(api);
4114 return initFromFloat6E2M3FNAPInt(api);
4116 return initFromFloat4E2M1FNAPInt(api);
4123void IEEEFloat::makeLargest(
bool Negative) {
4124 if (Negative && !semantics->hasSignedRepr)
4126 "This floating point format does not support signed values");
4133 exponent = semantics->maxExponent;
4137 unsigned PartCount = partCount();
4138 memset(significand, 0xFF,
sizeof(
integerPart)*(PartCount - 1));
4142 const unsigned NumUnusedHighBits =
4143 PartCount*integerPartWidth - semantics->precision;
4144 significand[PartCount - 1] = (NumUnusedHighBits < integerPartWidth)
4149 (semantics->precision > 1))
4155void IEEEFloat::makeSmallest(
bool Negative) {
4156 if (Negative && !semantics->hasSignedRepr)
4158 "This floating point format does not support signed values");
4165 exponent = semantics->minExponent;
4169void IEEEFloat::makeSmallestNormalized(
bool Negative) {
4170 if (Negative && !semantics->hasSignedRepr)
4172 "This floating point format does not support signed values");
4181 exponent = semantics->minExponent;
4186 initFromAPInt(&Sem, API);
4189IEEEFloat::IEEEFloat(
float f) {
4193IEEEFloat::IEEEFloat(
double d) {
4199 Buffer.
append(Str.begin(), Str.end());
4204 void AdjustToPrecision(
APInt &significand,
4205 int &exp,
unsigned FormatPrecision) {
4209 unsigned bitsRequired = (FormatPrecision * 196 + 58) / 59;
4211 if (bits <= bitsRequired)
return;
4213 unsigned tensRemovable = (bits - bitsRequired) * 59 / 196;
4214 if (!tensRemovable)
return;
4216 exp += tensRemovable;
4221 if (tensRemovable & 1)
4223 tensRemovable >>= 1;
4224 if (!tensRemovable)
break;
4228 significand = significand.
udiv(divisor);
4236 int &exp,
unsigned FormatPrecision) {
4237 unsigned N = buffer.
size();
4238 if (
N <= FormatPrecision)
return;
4241 unsigned FirstSignificant =
N - FormatPrecision;
4248 if (buffer[FirstSignificant - 1] <
'5') {
4249 while (FirstSignificant <
N && buffer[FirstSignificant] ==
'0')
4252 exp += FirstSignificant;
4253 buffer.
erase(&buffer[0], &buffer[FirstSignificant]);
4259 for (
unsigned I = FirstSignificant;
I !=
N; ++
I) {
4260 if (buffer[
I] ==
'9') {
4269 if (FirstSignificant ==
N) {
4270 exp += FirstSignificant;
4276 exp += FirstSignificant;
4277 buffer.
erase(&buffer[0], &buffer[FirstSignificant]);
4281 APInt significand,
unsigned FormatPrecision,
4282 unsigned FormatMaxPadding,
bool TruncateZero) {
4283 const int semanticsPrecision = significand.
getBitWidth();
4290 if (!FormatPrecision) {
4298 FormatPrecision = 2 + semanticsPrecision * 59 / 196;
4303 exp += trailingZeros;
4309 }
else if (exp > 0) {
4311 significand = significand.
zext(semanticsPrecision + exp);
4312 significand <<= exp;
4326 unsigned precision = semanticsPrecision + (137 * texp + 136) / 59;
4330 significand = significand.
zext(precision);
4331 APInt five_to_the_i(precision, 5);
4334 significand *= five_to_the_i;
4339 five_to_the_i *= five_to_the_i;
4343 AdjustToPrecision(significand, exp, FormatPrecision);
4348 unsigned precision = significand.getBitWidth();
4349 if (precision < 4) {
4352 significand = significand.zext(precision);
4354 APInt ten(precision, 10);
4355 APInt digit(precision, 0);
4357 bool inTrail =
true;
4358 while (significand != 0) {
4363 unsigned d = digit.getZExtValue();
4374 assert(!buffer.
empty() &&
"no characters in buffer!");
4378 AdjustToPrecision(buffer, exp, FormatPrecision);
4380 unsigned NDigits = buffer.
size();
4383 bool FormatScientific;
4384 if (!FormatMaxPadding)
4385 FormatScientific =
true;
4391 FormatScientific = ((
unsigned) exp > FormatMaxPadding ||
4392 NDigits + (
unsigned) exp > FormatPrecision);
4395 int MSD = exp + (int) (NDigits - 1);
4398 FormatScientific =
false;
4402 FormatScientific = ((
unsigned) -MSD) > FormatMaxPadding;
4408 if (FormatScientific) {
4409 exp += (NDigits - 1);
4411 Str.push_back(buffer[NDigits-1]);
4413 if (NDigits == 1 && TruncateZero)
4416 for (
unsigned I = 1;
I != NDigits; ++
I)
4417 Str.push_back(buffer[NDigits-1-
I]);
4419 if (!TruncateZero && FormatPrecision > NDigits - 1)
4420 Str.append(FormatPrecision - NDigits + 1,
'0');
4422 Str.push_back(TruncateZero ?
'E' :
'e');
4424 Str.push_back(exp >= 0 ?
'+' :
'-');
4429 expbuf.
push_back((
char) (
'0' + (exp % 10)));
4433 if (!TruncateZero && expbuf.
size() < 2)
4435 for (
unsigned I = 0, E = expbuf.
size();
I != E; ++
I)
4436 Str.push_back(expbuf[E-1-
I]);
4442 for (
unsigned I = 0;
I != NDigits; ++
I)
4443 Str.push_back(buffer[NDigits-1-
I]);
4452 int NWholeDigits = exp + (int) NDigits;
4455 if (NWholeDigits > 0) {
4457 Str.push_back(buffer[NDigits-
I-1]);
4460 unsigned NZeros = 1 + (
unsigned) -NWholeDigits;
4464 for (
unsigned Z = 1;
Z != NZeros; ++
Z)
4468 for (;
I != NDigits; ++
I)
4469 Str.push_back(buffer[NDigits-
I-1]);
4475 unsigned FormatMaxPadding,
bool TruncateZero)
const {
4479 return append(Str,
"-Inf");
4481 return append(Str,
"+Inf");
4483 case fcNaN:
return append(Str,
"NaN");
4489 if (!FormatMaxPadding) {
4491 append(Str,
"0.0E+0");
4494 if (FormatPrecision > 1)
4495 Str.append(FormatPrecision - 1,
'0');
4496 append(Str,
"e+00");
4507 int exp = exponent - ((int) semantics->precision - 1);
4509 semantics->precision,
4512 toStringImpl(Str, isNegative(), exp, significand, FormatPrecision,
4513 FormatMaxPadding, TruncateZero);
4517bool IEEEFloat::getExactInverse(
APFloat *inv)
const {
4519 if (!isFiniteNonZero())
4524 if (significandLSB() != semantics->precision - 1)
4529 if (reciprocal.
divide(*
this, rmNearestTiesToEven) != opOK)
4538 reciprocal.significandLSB() == reciprocal.semantics->
precision - 1);
4541 *inv =
APFloat(reciprocal, *semantics);
4546int IEEEFloat::getExactLog2Abs()
const {
4554 for (
int i = 0; i < PartCount; ++i) {
4560 if (exponent != semantics->minExponent)
4563 int CountrParts = 0;
4564 for (
int i = 0; i < PartCount;
4566 if (Parts[i] != 0) {
4567 return exponent - semantics->precision + CountrParts +
4575bool IEEEFloat::isSignaling()
const {
4612 if (isSignaling()) {
4613 result = opInvalidOp;
4615 makeNaN(
false, isNegative(),
nullptr);
4620 makeSmallest(
false);
4624 if (isSmallest() && isNegative()) {
4630 if (!semantics->hasZero)
4631 makeSmallestNormalized(
false);
4635 if (isLargest() && !isNegative()) {
4640 }
else if (semantics->nonFiniteBehavior ==
4647 category = fcInfinity;
4648 exponent = semantics->maxExponent + 1;
4662 bool WillCrossBinadeBoundary =
4663 exponent != semantics->minExponent && isSignificandAllZeros();
4681 if (WillCrossBinadeBoundary) {
4700 (!isDenormal() && isSignificandAllOnes());
4702 if (WillCrossBinadeBoundary) {
4706 assert(exponent != semantics->maxExponent &&
4707 "We can not increment an exponent beyond the maxExponent allowed"
4708 " by the given floating point semantics.");
4711 incrementSignificand();
4725 return ::exponentNaN(*semantics);
4729 return ::exponentInf(*semantics);
4733 return ::exponentZero(*semantics);
4736void IEEEFloat::makeInf(
bool Negative) {
4742 makeNaN(
false, Negative);
4745 category = fcInfinity;
4751void IEEEFloat::makeZero(
bool Negative) {
4752 if (!semantics->hasZero)
4765void IEEEFloat::makeQuiet() {
4779 return Arg.exponent;
4784 Normalized.exponent += SignificandBits;
4786 return Normalized.exponent - SignificandBits;
4790 auto MaxExp =
X.getSemantics().maxExponent;
4791 auto MinExp =
X.getSemantics().minExponent;
4799 int SignificandBits =
X.getSemantics().precision - 1;
4800 int MaxIncrement = MaxExp - (MinExp - SignificandBits) + 1;
4803 X.exponent += std::clamp(Exp, -MaxIncrement - 1, MaxIncrement);
4826 return scalbn(Val, -Exp, RM);
4859 Floats(new
APFloat[2]{std::move(
First), std::move(Second)}) {
4866 : Semantics(
RHS.Semantics),
4880 if (Semantics ==
RHS.Semantics &&
RHS.Floats) {
4881 Floats[0] =
RHS.Floats[0];
4882 Floats[1] =
RHS.Floats[1];
4883 }
else if (
this != &
RHS) {
4901 Floats[0] = std::move(z);
4902 Floats[1].makeZero(
false);
4906 auto AComparedToC = a.compareAbsoluteValue(c);
4919 Floats[0] = std::move(z);
4920 Floats[1].makeZero(
false);
4929 Status |= Floats[1].subtract(z, RM);
4930 Status |= Floats[1].add(c, RM);
4931 Status |= Floats[1].add(zz, RM);
4935 Status |= Floats[1].subtract(z, RM);
4936 Status |= Floats[1].add(a, RM);
4937 Status |= Floats[1].add(zz, RM);
4955 Floats[0] = std::move(z);
4956 Floats[1].makeZero(
false);
4960 Status |= Floats[0].add(zz, RM);
4962 Floats[1].makeZero(
false);
4965 Floats[1] = std::move(z);
4966 Status |= Floats[1].subtract(Floats[0], RM);
4967 Status |= Floats[1].add(zz, RM);
4973 const DoubleAPFloat &RHS,
4993 LHS.isNegative() !=
RHS.isNegative()) {
4994 Out.makeNaN(
false, Out.isNegative(),
nullptr);
5015 return Out.addImpl(
A, AA,
C,
CC, RM);
5020 return addWithSpecial(*
this,
RHS, *
this, RM);
5033 const auto &
LHS = *
this;
5060 Out.makeNaN(
false,
false,
nullptr);
5072 "Special cases not handled exhaustively");
5079 if (!
T.isFiniteNonZero()) {
5081 Floats[1].makeZero(
false);
5103 Status |= U.add(Tau, RM);
5106 if (!U.isFinite()) {
5107 Floats[1].makeZero(
false);
5166 Floats[0].changeSign();
5167 Floats[1].changeSign();
5172 auto Result = Floats[0].compareAbsoluteValue(
RHS.Floats[0]);
5175 Result = Floats[1].compareAbsoluteValue(
RHS.Floats[1]);
5177 auto Against = Floats[0].isNegative() ^ Floats[1].isNegative();
5178 auto RHSAgainst =
RHS.Floats[0].isNegative() ^
RHS.Floats[1].isNegative();
5179 if (Against && !RHSAgainst)
5181 if (!Against && RHSAgainst)
5183 if (!Against && !RHSAgainst)
5185 if (Against && RHSAgainst)
5192 return Floats[0].getCategory();
5198 Floats[0].makeInf(Neg);
5199 Floats[1].makeZero(
false);
5203 Floats[0].makeZero(Neg);
5204 Floats[1].makeZero(
false);
5217 Floats[0].makeSmallest(Neg);
5218 Floats[1].makeZero(
false);
5225 Floats[0].changeSign();
5226 Floats[1].makeZero(
false);
5230 Floats[0].makeNaN(SNaN, Neg, fill);
5231 Floats[1].makeZero(
false);
5235 auto Result = Floats[0].compare(
RHS.Floats[0]);
5238 return Floats[1].compare(
RHS.Floats[1]);
5243 return Floats[0].bitwiseIsEqual(
RHS.Floats[0]) &&
5244 Floats[1].bitwiseIsEqual(
RHS.Floats[1]);
5256 Floats[0].bitcastToAPInt().getRawData()[0],
5257 Floats[1].bitcastToAPInt().getRawData()[0],
5274 auto Ret = Tmp.
next(nextDown);
5281 unsigned int Width,
bool IsSigned,
5300 unsigned int InputSize,
5311 unsigned int InputSize,
5321 unsigned int HexDigits,
5331 (Floats[0].isDenormal() || Floats[1].isDenormal() ||
5333 Floats[0] != Floats[0] + Floats[1]);
5363 return Floats[0].isInteger() && Floats[1].isInteger();
5367 unsigned FormatPrecision,
5368 unsigned FormatMaxPadding,
5369 bool TruncateZero)
const {
5372 .
toString(Str, FormatPrecision, FormatMaxPadding, TruncateZero);
5400 scalbn(Arg.Floats[1], Exp, RM));
5407 APFloat Second = Arg.Floats[1];
5409 Second =
scalbn(Second, -Exp, RM);
5415APFloat::Storage::Storage(IEEEFloat
F,
const fltSemantics &Semantics) {
5416 if (usesLayout<IEEEFloat>(Semantics)) {
5417 new (&
IEEE) IEEEFloat(std::move(
F));
5420 if (usesLayout<DoubleAPFloat>(Semantics)) {
5423 DoubleAPFloat(Semantics,
APFloat(std::move(
F), S),
5436 if (APFloat::usesLayout<detail::IEEEFloat>(Arg.
getSemantics()))
5438 if (APFloat::usesLayout<detail::DoubleAPFloat>(Arg.
getSemantics()))
5446 assert(StatusOrErr &&
"Invalid floating point representation");
5470 usesLayout<IEEEFloat>(ToSemantics))
5471 return U.IEEE.convert(ToSemantics, RM, losesInfo);
5473 usesLayout<DoubleAPFloat>(ToSemantics)) {
5476 *
this =
APFloat(ToSemantics, U.IEEE.bitcastToAPInt());
5480 usesLayout<IEEEFloat>(ToSemantics)) {
5481 auto Ret = getIEEE().
convert(ToSemantics, RM, losesInfo);
5482 *
this =
APFloat(std::move(getIEEE()), ToSemantics);
5498#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
5515 bool *isExact)
const {
5519 rounding_mode, isExact);
5521 result =
APInt(bitWidth, parts);
5529 "Float semantics is not representable by IEEEdouble");
5538#ifdef HAS_IEE754_FLOAT128
5539float128 APFloat::convertToQuad()
const {
5541 return getIEEE().convertToQuad();
5543 "Float semantics is not representable by IEEEquad");
5549 return Temp.getIEEE().convertToQuad();
5557 "Float semantics is not representable by IEEEsingle");
5568#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.
static bool isNeg(Value *V)
Returns true if the operation is a negation of V, and it works for both integers and floats.
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)
static bool hasSignificand(const fltSemantics &Sem)
Returns true if the given semantics has actual significand.
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.
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.
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 constexpr unsigned APINT_BITS_PER_WORD
Bits in a word.
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...
cmpResult compareAbsoluteValue(const IEEEFloat &) const
opStatus mod(const IEEEFloat &)
C fmod, or llvm frem.
fltCategory getCategory() const
opStatus convertFromAPInt(const APInt &, bool, roundingMode)
bool isFiniteNonZero() const
bool needsCleanup() const
Returns whether this instance allocated memory.
APInt bitcastToAPInt() const
cmpResult compare(const IEEEFloat &) const
IEEE comparison with another floating point number (NaNs compare unordered, 0==-0).
bool isNegative() const
IEEE-754R isSignMinus: Returns true if and only if the current value is negative.
opStatus divide(const IEEEFloat &, roundingMode)
bool isNaN() const
Returns true if and only if the float is a quiet or signaling NaN.
opStatus remainder(const IEEEFloat &)
IEEE remainder.
double convertToDouble() const
opStatus convertFromSignExtendedInteger(const integerPart *, unsigned int, bool, roundingMode)
float convertToFloat() const
opStatus subtract(const IEEEFloat &, roundingMode)
void makeInf(bool Neg=false)
opStatus convertFromZeroExtendedInteger(const integerPart *, unsigned int, bool, 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...
opStatus add(const IEEEFloat &, roundingMode)
bool isFinite() const
Returns true if and only if the current value is zero, subnormal, or normal.
Expected< opStatus > convertFromString(StringRef, roundingMode)
void makeNaN(bool SNaN=false, bool Neg=false, const APInt *fill=nullptr)
friend int ilogb(const IEEEFloat &Arg)
Returns the exponent of the internal representation of the APFloat.
opStatus multiply(const IEEEFloat &, roundingMode)
opStatus roundToIntegral(roundingMode)
IEEEFloat & operator=(const IEEEFloat &)
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).
void makeSmallestNormalized(bool Negative=false)
Returns the smallest (by magnitude) normalized finite number in the given semantics.
bool isInteger() const
Returns true if and only if the number is an exact integer.
IEEEFloat(const fltSemantics &)
opStatus fusedMultiplyAdd(const IEEEFloat &, 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.
void makeZero(bool Neg=false)
opStatus convert(const fltSemantics &, roundingMode, bool *)
IEEEFloat::convert - convert a value of one floating point type to another.
bool isDenormal() const
IEEE-754R isSubnormal(): Returns true if and only if the float is a denormal.
opStatus convertToInteger(MutableArrayRef< integerPart >, unsigned int, bool, roundingMode, bool *) const
bool isSmallest() const
Returns true if and only if the number has the smallest possible non-zero magnitude in the current se...
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.
static constexpr opStatus opInexact
APFloatBase::roundingMode roundingMode
static constexpr fltCategory fcNaN
static constexpr opStatus opDivByZero
static constexpr opStatus opOverflow
static constexpr cmpResult cmpLessThan
static void tcSetLeastSignificantBits(APInt::WordType *dst, unsigned parts, unsigned bits)
APFloatBase::opStatus opStatus
static constexpr roundingMode rmTowardPositive
static constexpr uninitializedTag uninitialized
static constexpr fltCategory fcZero
static constexpr opStatus opOK
static constexpr cmpResult cmpGreaterThan
static constexpr unsigned integerPartWidth
APFloatBase::ExponentType ExponentType
hash_code hash_value(const IEEEFloat &Arg)
static constexpr fltCategory fcNormal
static constexpr opStatus opInvalidOp
IEEEFloat scalbn(IEEEFloat X, int Exp, roundingMode)
IEEEFloat frexp(const IEEEFloat &Val, int &Exp, roundingMode RM)
APFloatBase::integerPart integerPart
static constexpr cmpResult cmpUnordered
static constexpr roundingMode rmTowardNegative
static constexpr fltCategory fcInfinity
static constexpr roundingMode rmNearestTiesToAway
static constexpr roundingMode rmTowardZero
static constexpr opStatus opUnderflow
static constexpr roundingMode rmNearestTiesToEven
int ilogb(const IEEEFloat &Arg)
static constexpr cmpResult cmpEqual
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 constexpr fltSemantics semFloat8E8M0FNU
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 constexpr fltSemantics semFloat8E3M4
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.
static constexpr fltSemantics semFloat8E4M3
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 bool semanticsHasInf(const fltSemantics &)
static const fltSemantics & Float6E3M2FN() LLVM_READNONE
static constexpr roundingMode rmNearestTiesToAway
cmpResult
IEEE-754R 5.11: Floating Point Comparison Relations.
static const fltSemantics & PPCDoubleDoubleLegacy() LLVM_READNONE
static constexpr roundingMode rmTowardNegative
static ExponentType semanticsMinExponent(const fltSemantics &)
static constexpr roundingMode rmNearestTiesToEven
static unsigned int semanticsSizeInBits(const fltSemantics &)
static bool semanticsHasSignedRepr(const fltSemantics &)
static const fltSemantics & Float8E4M3() LLVM_READNONE
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 & Float8E8M0FNU() 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 bool semanticsHasNaN(const fltSemantics &)
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 semanticsHasZero(const fltSemantics &)
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 bool isRepresentableBy(const fltSemantics &A, const fltSemantics &B)
static const fltSemantics & Float8E5M2FNUZ() LLVM_READNONE
static const fltSemantics & Float6E2M3FN() LLVM_READNONE
fltCategory
Category of internally-represented number.
@ S_PPCDoubleDoubleLegacy
static const fltSemantics & Float8E3M4() LLVM_READNONE
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
APFloatBase::ExponentType maxExponent
fltNonfiniteBehavior nonFiniteBehavior
APFloatBase::ExponentType minExponent
fltNanEncoding nanEncoding