1 //===-- APFloat.cpp - Implement APFloat class -----------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements a class to represent arbitrary precision floating
11 // point values and provide a variety of arithmetic operations on them.
13 //===----------------------------------------------------------------------===//
15 #include "llvm/ADT/APFloat.h"
16 #include "llvm/ADT/APSInt.h"
17 #include "llvm/ADT/FoldingSet.h"
18 #include "llvm/ADT/Hashing.h"
19 #include "llvm/ADT/StringExtras.h"
20 #include "llvm/ADT/StringRef.h"
21 #include "llvm/Support/ErrorHandling.h"
22 #include "llvm/Support/MathExtras.h"
28 /// A macro used to combine two fcCategory enums into one key which can be used
29 /// in a switch statement to classify how the interaction of two APFloat's
30 /// categories affects an operation.
32 /// TODO: If clang source code is ever allowed to use constexpr in its own
33 /// codebase, change this into a static inline function.
34 #define PackCategoriesIntoKey(_lhs, _rhs) ((_lhs) * 4 + (_rhs))
36 /* Assumed in hexadecimal significand parsing, and conversion to
37 hexadecimal strings. */
38 #define COMPILE_TIME_ASSERT(cond) extern int CTAssert[(cond) ? 1 : -1]
39 COMPILE_TIME_ASSERT(integerPartWidth % 4 == 0);
43 /* Represents floating point arithmetic semantics. */
45 /* The largest E such that 2^E is representable; this matches the
46 definition of IEEE 754. */
47 APFloat::ExponentType maxExponent;
49 /* The smallest E such that 2^E is a normalized number; this
50 matches the definition of IEEE 754. */
51 APFloat::ExponentType minExponent;
53 /* Number of bits in the significand. This includes the integer
55 unsigned int precision;
58 const fltSemantics APFloat::IEEEhalf = { 15, -14, 11 };
59 const fltSemantics APFloat::IEEEsingle = { 127, -126, 24 };
60 const fltSemantics APFloat::IEEEdouble = { 1023, -1022, 53 };
61 const fltSemantics APFloat::IEEEquad = { 16383, -16382, 113 };
62 const fltSemantics APFloat::x87DoubleExtended = { 16383, -16382, 64 };
63 const fltSemantics APFloat::Bogus = { 0, 0, 0 };
65 /* The PowerPC format consists of two doubles. It does not map cleanly
66 onto the usual format above. It is approximated using twice the
67 mantissa bits. Note that for exponents near the double minimum,
68 we no longer can represent the full 106 mantissa bits, so those
69 will be treated as denormal numbers.
71 FIXME: While this approximation is equivalent to what GCC uses for
72 compile-time arithmetic on PPC double-double numbers, it is not able
73 to represent all possible values held by a PPC double-double number,
74 for example: (long double) 1.0 + (long double) 0x1p-106
75 Should this be replaced by a full emulation of PPC double-double? */
76 const fltSemantics APFloat::PPCDoubleDouble = { 1023, -1022 + 53, 53 + 53 };
78 /* A tight upper bound on number of parts required to hold the value
81 power * 815 / (351 * integerPartWidth) + 1
83 However, whilst the result may require only this many parts,
84 because we are multiplying two values to get it, the
85 multiplication may require an extra part with the excess part
86 being zero (consider the trivial case of 1 * 1, tcFullMultiply
87 requires two parts to hold the single-part result). So we add an
88 extra one to guarantee enough space whilst multiplying. */
89 const unsigned int maxExponent = 16383;
90 const unsigned int maxPrecision = 113;
91 const unsigned int maxPowerOfFiveExponent = maxExponent + maxPrecision - 1;
92 const unsigned int maxPowerOfFiveParts = 2 + ((maxPowerOfFiveExponent * 815)
93 / (351 * integerPartWidth));
96 /* A bunch of private, handy routines. */
98 static inline unsigned int
99 partCountForBits(unsigned int bits)
101 return ((bits) + integerPartWidth - 1) / integerPartWidth;
104 /* Returns 0U-9U. Return values >= 10U are not digits. */
105 static inline unsigned int
106 decDigitValue(unsigned int c)
111 /* Return the value of a decimal exponent of the form
114 If the exponent overflows, returns a large exponent with the
117 readExponent(StringRef::iterator begin, StringRef::iterator end)
120 unsigned int absExponent;
121 const unsigned int overlargeExponent = 24000; /* FIXME. */
122 StringRef::iterator p = begin;
124 assert(p != end && "Exponent has no digits");
126 isNegative = (*p == '-');
127 if (*p == '-' || *p == '+') {
129 assert(p != end && "Exponent has no digits");
132 absExponent = decDigitValue(*p++);
133 assert(absExponent < 10U && "Invalid character in exponent");
135 for (; p != end; ++p) {
138 value = decDigitValue(*p);
139 assert(value < 10U && "Invalid character in exponent");
141 value += absExponent * 10;
142 if (absExponent >= overlargeExponent) {
143 absExponent = overlargeExponent;
144 p = end; /* outwit assert below */
150 assert(p == end && "Invalid exponent in exponent");
153 return -(int) absExponent;
155 return (int) absExponent;
158 /* This is ugly and needs cleaning up, but I don't immediately see
159 how whilst remaining safe. */
161 totalExponent(StringRef::iterator p, StringRef::iterator end,
162 int exponentAdjustment)
164 int unsignedExponent;
165 bool negative, overflow;
168 assert(p != end && "Exponent has no digits");
170 negative = *p == '-';
171 if (*p == '-' || *p == '+') {
173 assert(p != end && "Exponent has no digits");
176 unsignedExponent = 0;
178 for (; p != end; ++p) {
181 value = decDigitValue(*p);
182 assert(value < 10U && "Invalid character in exponent");
184 unsignedExponent = unsignedExponent * 10 + value;
185 if (unsignedExponent > 32767) {
191 if (exponentAdjustment > 32767 || exponentAdjustment < -32768)
195 exponent = unsignedExponent;
197 exponent = -exponent;
198 exponent += exponentAdjustment;
199 if (exponent > 32767 || exponent < -32768)
204 exponent = negative ? -32768: 32767;
209 static StringRef::iterator
210 skipLeadingZeroesAndAnyDot(StringRef::iterator begin, StringRef::iterator end,
211 StringRef::iterator *dot)
213 StringRef::iterator p = begin;
215 while (*p == '0' && p != end)
221 assert(end - begin != 1 && "Significand has no digits");
223 while (*p == '0' && p != end)
230 /* Given a normal decimal floating point number of the form
234 where the decimal point and exponent are optional, fill out the
235 structure D. Exponent is appropriate if the significand is
236 treated as an integer, and normalizedExponent if the significand
237 is taken to have the decimal point after a single leading
240 If the value is zero, V->firstSigDigit points to a non-digit, and
241 the return exponent is zero.
244 const char *firstSigDigit;
245 const char *lastSigDigit;
247 int normalizedExponent;
251 interpretDecimal(StringRef::iterator begin, StringRef::iterator end,
254 StringRef::iterator dot = end;
255 StringRef::iterator p = skipLeadingZeroesAndAnyDot (begin, end, &dot);
257 D->firstSigDigit = p;
259 D->normalizedExponent = 0;
261 for (; p != end; ++p) {
263 assert(dot == end && "String contains multiple dots");
268 if (decDigitValue(*p) >= 10U)
273 assert((*p == 'e' || *p == 'E') && "Invalid character in significand");
274 assert(p != begin && "Significand has no digits");
275 assert((dot == end || p - begin != 1) && "Significand has no digits");
277 /* p points to the first non-digit in the string */
278 D->exponent = readExponent(p + 1, end);
280 /* Implied decimal point? */
285 /* If number is all zeroes accept any exponent. */
286 if (p != D->firstSigDigit) {
287 /* Drop insignificant trailing zeroes. */
292 while (p != begin && *p == '0');
293 while (p != begin && *p == '.');
296 /* Adjust the exponents for any decimal point. */
297 D->exponent += static_cast<APFloat::ExponentType>((dot - p) - (dot > p));
298 D->normalizedExponent = (D->exponent +
299 static_cast<APFloat::ExponentType>((p - D->firstSigDigit)
300 - (dot > D->firstSigDigit && dot < p)));
306 /* Return the trailing fraction of a hexadecimal number.
307 DIGITVALUE is the first hex digit of the fraction, P points to
310 trailingHexadecimalFraction(StringRef::iterator p, StringRef::iterator end,
311 unsigned int digitValue)
313 unsigned int hexDigit;
315 /* If the first trailing digit isn't 0 or 8 we can work out the
316 fraction immediately. */
318 return lfMoreThanHalf;
319 else if (digitValue < 8 && digitValue > 0)
320 return lfLessThanHalf;
322 // Otherwise we need to find the first non-zero digit.
323 while (p != end && (*p == '0' || *p == '.'))
326 assert(p != end && "Invalid trailing hexadecimal fraction!");
328 hexDigit = hexDigitValue(*p);
330 /* If we ran off the end it is exactly zero or one-half, otherwise
333 return digitValue == 0 ? lfExactlyZero: lfExactlyHalf;
335 return digitValue == 0 ? lfLessThanHalf: lfMoreThanHalf;
338 /* Return the fraction lost were a bignum truncated losing the least
339 significant BITS bits. */
341 lostFractionThroughTruncation(const integerPart *parts,
342 unsigned int partCount,
347 lsb = APInt::tcLSB(parts, partCount);
349 /* Note this is guaranteed true if bits == 0, or LSB == -1U. */
351 return lfExactlyZero;
353 return lfExactlyHalf;
354 if (bits <= partCount * integerPartWidth &&
355 APInt::tcExtractBit(parts, bits - 1))
356 return lfMoreThanHalf;
358 return lfLessThanHalf;
361 /* Shift DST right BITS bits noting lost fraction. */
363 shiftRight(integerPart *dst, unsigned int parts, unsigned int bits)
365 lostFraction lost_fraction;
367 lost_fraction = lostFractionThroughTruncation(dst, parts, bits);
369 APInt::tcShiftRight(dst, parts, bits);
371 return lost_fraction;
374 /* Combine the effect of two lost fractions. */
376 combineLostFractions(lostFraction moreSignificant,
377 lostFraction lessSignificant)
379 if (lessSignificant != lfExactlyZero) {
380 if (moreSignificant == lfExactlyZero)
381 moreSignificant = lfLessThanHalf;
382 else if (moreSignificant == lfExactlyHalf)
383 moreSignificant = lfMoreThanHalf;
386 return moreSignificant;
389 /* The error from the true value, in half-ulps, on multiplying two
390 floating point numbers, which differ from the value they
391 approximate by at most HUE1 and HUE2 half-ulps, is strictly less
392 than the returned value.
394 See "How to Read Floating Point Numbers Accurately" by William D
397 HUerrBound(bool inexactMultiply, unsigned int HUerr1, unsigned int HUerr2)
399 assert(HUerr1 < 2 || HUerr2 < 2 || (HUerr1 + HUerr2 < 8));
401 if (HUerr1 + HUerr2 == 0)
402 return inexactMultiply * 2; /* <= inexactMultiply half-ulps. */
404 return inexactMultiply + 2 * (HUerr1 + HUerr2);
407 /* The number of ulps from the boundary (zero, or half if ISNEAREST)
408 when the least significant BITS are truncated. BITS cannot be
411 ulpsFromBoundary(const integerPart *parts, unsigned int bits, bool isNearest)
413 unsigned int count, partBits;
414 integerPart part, boundary;
419 count = bits / integerPartWidth;
420 partBits = bits % integerPartWidth + 1;
422 part = parts[count] & (~(integerPart) 0 >> (integerPartWidth - partBits));
425 boundary = (integerPart) 1 << (partBits - 1);
430 if (part - boundary <= boundary - part)
431 return part - boundary;
433 return boundary - part;
436 if (part == boundary) {
439 return ~(integerPart) 0; /* A lot. */
442 } else if (part == boundary - 1) {
445 return ~(integerPart) 0; /* A lot. */
450 return ~(integerPart) 0; /* A lot. */
453 /* Place pow(5, power) in DST, and return the number of parts used.
454 DST must be at least one part larger than size of the answer. */
456 powerOf5(integerPart *dst, unsigned int power)
458 static const integerPart firstEightPowers[] = { 1, 5, 25, 125, 625, 3125,
460 integerPart pow5s[maxPowerOfFiveParts * 2 + 5];
461 pow5s[0] = 78125 * 5;
463 unsigned int partsCount[16] = { 1 };
464 integerPart scratch[maxPowerOfFiveParts], *p1, *p2, *pow5;
466 assert(power <= maxExponent);
471 *p1 = firstEightPowers[power & 7];
477 for (unsigned int n = 0; power; power >>= 1, n++) {
482 /* Calculate pow(5,pow(2,n+3)) if we haven't yet. */
484 pc = partsCount[n - 1];
485 APInt::tcFullMultiply(pow5, pow5 - pc, pow5 - pc, pc, pc);
487 if (pow5[pc - 1] == 0)
495 APInt::tcFullMultiply(p2, p1, pow5, result, pc);
497 if (p2[result - 1] == 0)
500 /* Now result is in p1 with partsCount parts and p2 is scratch
502 tmp = p1, p1 = p2, p2 = tmp;
509 APInt::tcAssign(dst, p1, result);
514 /* Zero at the end to avoid modular arithmetic when adding one; used
515 when rounding up during hexadecimal output. */
516 static const char hexDigitsLower[] = "0123456789abcdef0";
517 static const char hexDigitsUpper[] = "0123456789ABCDEF0";
518 static const char infinityL[] = "infinity";
519 static const char infinityU[] = "INFINITY";
520 static const char NaNL[] = "nan";
521 static const char NaNU[] = "NAN";
523 /* Write out an integerPart in hexadecimal, starting with the most
524 significant nibble. Write out exactly COUNT hexdigits, return
527 partAsHex (char *dst, integerPart part, unsigned int count,
528 const char *hexDigitChars)
530 unsigned int result = count;
532 assert(count != 0 && count <= integerPartWidth / 4);
534 part >>= (integerPartWidth - 4 * count);
536 dst[count] = hexDigitChars[part & 0xf];
543 /* Write out an unsigned decimal integer. */
545 writeUnsignedDecimal (char *dst, unsigned int n)
561 /* Write out a signed decimal integer. */
563 writeSignedDecimal (char *dst, int value)
567 dst = writeUnsignedDecimal(dst, -(unsigned) value);
569 dst = writeUnsignedDecimal(dst, value);
576 APFloat::initialize(const fltSemantics *ourSemantics)
580 semantics = ourSemantics;
583 significand.parts = new integerPart[count];
587 APFloat::freeSignificand()
590 delete [] significand.parts;
594 APFloat::assign(const APFloat &rhs)
596 assert(semantics == rhs.semantics);
599 category = rhs.category;
600 exponent = rhs.exponent;
601 if (isFiniteNonZero() || category == fcNaN)
602 copySignificand(rhs);
606 APFloat::copySignificand(const APFloat &rhs)
608 assert(isFiniteNonZero() || category == fcNaN);
609 assert(rhs.partCount() >= partCount());
611 APInt::tcAssign(significandParts(), rhs.significandParts(),
615 /* Make this number a NaN, with an arbitrary but deterministic value
616 for the significand. If double or longer, this is a signalling NaN,
617 which may not be ideal. If float, this is QNaN(0). */
618 void APFloat::makeNaN(bool SNaN, bool Negative, const APInt *fill)
623 integerPart *significand = significandParts();
624 unsigned numParts = partCount();
626 // Set the significand bits to the fill.
627 if (!fill || fill->getNumWords() < numParts)
628 APInt::tcSet(significand, 0, numParts);
630 APInt::tcAssign(significand, fill->getRawData(),
631 std::min(fill->getNumWords(), numParts));
633 // Zero out the excess bits of the significand.
634 unsigned bitsToPreserve = semantics->precision - 1;
635 unsigned part = bitsToPreserve / 64;
636 bitsToPreserve %= 64;
637 significand[part] &= ((1ULL << bitsToPreserve) - 1);
638 for (part++; part != numParts; ++part)
639 significand[part] = 0;
642 unsigned QNaNBit = semantics->precision - 2;
645 // We always have to clear the QNaN bit to make it an SNaN.
646 APInt::tcClearBit(significand, QNaNBit);
648 // If there are no bits set in the payload, we have to set
649 // *something* to make it a NaN instead of an infinity;
650 // conventionally, this is the next bit down from the QNaN bit.
651 if (APInt::tcIsZero(significand, numParts))
652 APInt::tcSetBit(significand, QNaNBit - 1);
654 // We always have to set the QNaN bit to make it a QNaN.
655 APInt::tcSetBit(significand, QNaNBit);
658 // For x87 extended precision, we want to make a NaN, not a
659 // pseudo-NaN. Maybe we should expose the ability to make
661 if (semantics == &APFloat::x87DoubleExtended)
662 APInt::tcSetBit(significand, QNaNBit + 1);
665 APFloat APFloat::makeNaN(const fltSemantics &Sem, bool SNaN, bool Negative,
667 APFloat value(Sem, uninitialized);
668 value.makeNaN(SNaN, Negative, fill);
673 APFloat::operator=(const APFloat &rhs)
676 if (semantics != rhs.semantics) {
678 initialize(rhs.semantics);
687 APFloat::operator=(APFloat &&rhs) {
690 semantics = rhs.semantics;
691 significand = rhs.significand;
692 exponent = rhs.exponent;
693 category = rhs.category;
696 rhs.semantics = &Bogus;
701 APFloat::isDenormal() const {
702 return isFiniteNonZero() && (exponent == semantics->minExponent) &&
703 (APInt::tcExtractBit(significandParts(),
704 semantics->precision - 1) == 0);
708 APFloat::isSmallest() const {
709 // The smallest number by magnitude in our format will be the smallest
710 // denormal, i.e. the floating point number with exponent being minimum
711 // exponent and significand bitwise equal to 1 (i.e. with MSB equal to 0).
712 return isFiniteNonZero() && exponent == semantics->minExponent &&
713 significandMSB() == 0;
716 bool APFloat::isSignificandAllOnes() const {
717 // Test if the significand excluding the integral bit is all ones. This allows
718 // us to test for binade boundaries.
719 const integerPart *Parts = significandParts();
720 const unsigned PartCount = partCount();
721 for (unsigned i = 0; i < PartCount - 1; i++)
725 // Set the unused high bits to all ones when we compare.
726 const unsigned NumHighBits =
727 PartCount*integerPartWidth - semantics->precision + 1;
728 assert(NumHighBits <= integerPartWidth && "Can not have more high bits to "
729 "fill than integerPartWidth");
730 const integerPart HighBitFill =
731 ~integerPart(0) << (integerPartWidth - NumHighBits);
732 if (~(Parts[PartCount - 1] | HighBitFill))
738 bool APFloat::isSignificandAllZeros() const {
739 // Test if the significand excluding the integral bit is all zeros. This
740 // allows us to test for binade boundaries.
741 const integerPart *Parts = significandParts();
742 const unsigned PartCount = partCount();
744 for (unsigned i = 0; i < PartCount - 1; i++)
748 const unsigned NumHighBits =
749 PartCount*integerPartWidth - semantics->precision + 1;
750 assert(NumHighBits <= integerPartWidth && "Can not have more high bits to "
751 "clear than integerPartWidth");
752 const integerPart HighBitMask = ~integerPart(0) >> NumHighBits;
754 if (Parts[PartCount - 1] & HighBitMask)
761 APFloat::isLargest() const {
762 // The largest number by magnitude in our format will be the floating point
763 // number with maximum exponent and with significand that is all ones.
764 return isFiniteNonZero() && exponent == semantics->maxExponent
765 && isSignificandAllOnes();
769 APFloat::bitwiseIsEqual(const APFloat &rhs) const {
772 if (semantics != rhs.semantics ||
773 category != rhs.category ||
776 if (category==fcZero || category==fcInfinity)
778 else if (isFiniteNonZero() && exponent!=rhs.exponent)
782 const integerPart* p=significandParts();
783 const integerPart* q=rhs.significandParts();
784 for (; i>0; i--, p++, q++) {
792 APFloat::APFloat(const fltSemantics &ourSemantics, integerPart value) {
793 initialize(&ourSemantics);
797 exponent = ourSemantics.precision - 1;
798 significandParts()[0] = value;
799 normalize(rmNearestTiesToEven, lfExactlyZero);
802 APFloat::APFloat(const fltSemantics &ourSemantics) {
803 initialize(&ourSemantics);
808 APFloat::APFloat(const fltSemantics &ourSemantics, uninitializedTag tag) {
809 // Allocates storage if necessary but does not initialize it.
810 initialize(&ourSemantics);
813 APFloat::APFloat(const fltSemantics &ourSemantics, StringRef text) {
814 initialize(&ourSemantics);
815 convertFromString(text, rmNearestTiesToEven);
818 APFloat::APFloat(const APFloat &rhs) {
819 initialize(rhs.semantics);
823 APFloat::APFloat(APFloat &&rhs) : semantics(&Bogus) {
824 *this = std::move(rhs);
832 // Profile - This method 'profiles' an APFloat for use with FoldingSet.
833 void APFloat::Profile(FoldingSetNodeID& ID) const {
834 ID.Add(bitcastToAPInt());
838 APFloat::partCount() const
840 return partCountForBits(semantics->precision + 1);
844 APFloat::semanticsPrecision(const fltSemantics &semantics)
846 return semantics.precision;
850 APFloat::significandParts() const
852 return const_cast<APFloat *>(this)->significandParts();
856 APFloat::significandParts()
859 return significand.parts;
861 return &significand.part;
865 APFloat::zeroSignificand()
867 APInt::tcSet(significandParts(), 0, partCount());
870 /* Increment an fcNormal floating point number's significand. */
872 APFloat::incrementSignificand()
876 carry = APInt::tcIncrement(significandParts(), partCount());
878 /* Our callers should never cause us to overflow. */
883 /* Add the significand of the RHS. Returns the carry flag. */
885 APFloat::addSignificand(const APFloat &rhs)
889 parts = significandParts();
891 assert(semantics == rhs.semantics);
892 assert(exponent == rhs.exponent);
894 return APInt::tcAdd(parts, rhs.significandParts(), 0, partCount());
897 /* Subtract the significand of the RHS with a borrow flag. Returns
900 APFloat::subtractSignificand(const APFloat &rhs, integerPart borrow)
904 parts = significandParts();
906 assert(semantics == rhs.semantics);
907 assert(exponent == rhs.exponent);
909 return APInt::tcSubtract(parts, rhs.significandParts(), borrow,
913 /* Multiply the significand of the RHS. If ADDEND is non-NULL, add it
914 on to the full-precision result of the multiplication. Returns the
917 APFloat::multiplySignificand(const APFloat &rhs, const APFloat *addend)
919 unsigned int omsb; // One, not zero, based MSB.
920 unsigned int partsCount, newPartsCount, precision;
921 integerPart *lhsSignificand;
922 integerPart scratch[4];
923 integerPart *fullSignificand;
924 lostFraction lost_fraction;
927 assert(semantics == rhs.semantics);
929 precision = semantics->precision;
930 newPartsCount = partCountForBits(precision * 2);
932 if (newPartsCount > 4)
933 fullSignificand = new integerPart[newPartsCount];
935 fullSignificand = scratch;
937 lhsSignificand = significandParts();
938 partsCount = partCount();
940 APInt::tcFullMultiply(fullSignificand, lhsSignificand,
941 rhs.significandParts(), partsCount, partsCount);
943 lost_fraction = lfExactlyZero;
944 omsb = APInt::tcMSB(fullSignificand, newPartsCount) + 1;
945 exponent += rhs.exponent;
947 // Assume the operands involved in the multiplication are single-precision
948 // FP, and the two multiplicants are:
949 // *this = a23 . a22 ... a0 * 2^e1
950 // rhs = b23 . b22 ... b0 * 2^e2
951 // the result of multiplication is:
952 // *this = c47 c46 . c45 ... c0 * 2^(e1+e2)
953 // Note that there are two significant bits at the left-hand side of the
954 // radix point. Move the radix point toward left by one bit, and adjust
955 // exponent accordingly.
959 // The intermediate result of the multiplication has "2 * precision"
960 // signicant bit; adjust the addend to be consistent with mul result.
962 Significand savedSignificand = significand;
963 const fltSemantics *savedSemantics = semantics;
964 fltSemantics extendedSemantics;
966 unsigned int extendedPrecision;
968 /* Normalize our MSB. */
969 extendedPrecision = 2 * precision;
970 if (omsb != extendedPrecision) {
971 assert(extendedPrecision > omsb);
972 APInt::tcShiftLeft(fullSignificand, newPartsCount,
973 extendedPrecision - omsb);
974 exponent -= extendedPrecision - omsb;
977 /* Create new semantics. */
978 extendedSemantics = *semantics;
979 extendedSemantics.precision = extendedPrecision;
981 if (newPartsCount == 1)
982 significand.part = fullSignificand[0];
984 significand.parts = fullSignificand;
985 semantics = &extendedSemantics;
987 APFloat extendedAddend(*addend);
988 status = extendedAddend.convert(extendedSemantics, rmTowardZero, &ignored);
989 assert(status == opOK);
991 lost_fraction = addOrSubtractSignificand(extendedAddend, false);
993 /* Restore our state. */
994 if (newPartsCount == 1)
995 fullSignificand[0] = significand.part;
996 significand = savedSignificand;
997 semantics = savedSemantics;
999 omsb = APInt::tcMSB(fullSignificand, newPartsCount) + 1;
1002 // Convert the result having "2 * precision" significant-bits back to the one
1003 // having "precision" significant-bits. First, move the radix point from
1004 // poision "2*precision - 1" to "precision - 1". The exponent need to be
1005 // adjusted by "2*precision - 1" - "precision - 1" = "precision".
1006 exponent -= precision;
1008 // In case MSB resides at the left-hand side of radix point, shift the
1009 // mantissa right by some amount to make sure the MSB reside right before
1010 // the radix point (i.e. "MSB . rest-significant-bits").
1012 // Note that the result is not normalized when "omsb < precision". So, the
1013 // caller needs to call APFloat::normalize() if normalized value is expected.
1014 if (omsb > precision) {
1015 unsigned int bits, significantParts;
1018 bits = omsb - precision;
1019 significantParts = partCountForBits(omsb);
1020 lf = shiftRight(fullSignificand, significantParts, bits);
1021 lost_fraction = combineLostFractions(lf, lost_fraction);
1025 APInt::tcAssign(lhsSignificand, fullSignificand, partsCount);
1027 if (newPartsCount > 4)
1028 delete [] fullSignificand;
1030 return lost_fraction;
1033 /* Multiply the significands of LHS and RHS to DST. */
1035 APFloat::divideSignificand(const APFloat &rhs)
1037 unsigned int bit, i, partsCount;
1038 const integerPart *rhsSignificand;
1039 integerPart *lhsSignificand, *dividend, *divisor;
1040 integerPart scratch[4];
1041 lostFraction lost_fraction;
1043 assert(semantics == rhs.semantics);
1045 lhsSignificand = significandParts();
1046 rhsSignificand = rhs.significandParts();
1047 partsCount = partCount();
1050 dividend = new integerPart[partsCount * 2];
1054 divisor = dividend + partsCount;
1056 /* Copy the dividend and divisor as they will be modified in-place. */
1057 for (i = 0; i < partsCount; i++) {
1058 dividend[i] = lhsSignificand[i];
1059 divisor[i] = rhsSignificand[i];
1060 lhsSignificand[i] = 0;
1063 exponent -= rhs.exponent;
1065 unsigned int precision = semantics->precision;
1067 /* Normalize the divisor. */
1068 bit = precision - APInt::tcMSB(divisor, partsCount) - 1;
1071 APInt::tcShiftLeft(divisor, partsCount, bit);
1074 /* Normalize the dividend. */
1075 bit = precision - APInt::tcMSB(dividend, partsCount) - 1;
1078 APInt::tcShiftLeft(dividend, partsCount, bit);
1081 /* Ensure the dividend >= divisor initially for the loop below.
1082 Incidentally, this means that the division loop below is
1083 guaranteed to set the integer bit to one. */
1084 if (APInt::tcCompare(dividend, divisor, partsCount) < 0) {
1086 APInt::tcShiftLeft(dividend, partsCount, 1);
1087 assert(APInt::tcCompare(dividend, divisor, partsCount) >= 0);
1090 /* Long division. */
1091 for (bit = precision; bit; bit -= 1) {
1092 if (APInt::tcCompare(dividend, divisor, partsCount) >= 0) {
1093 APInt::tcSubtract(dividend, divisor, 0, partsCount);
1094 APInt::tcSetBit(lhsSignificand, bit - 1);
1097 APInt::tcShiftLeft(dividend, partsCount, 1);
1100 /* Figure out the lost fraction. */
1101 int cmp = APInt::tcCompare(dividend, divisor, partsCount);
1104 lost_fraction = lfMoreThanHalf;
1106 lost_fraction = lfExactlyHalf;
1107 else if (APInt::tcIsZero(dividend, partsCount))
1108 lost_fraction = lfExactlyZero;
1110 lost_fraction = lfLessThanHalf;
1115 return lost_fraction;
1119 APFloat::significandMSB() const
1121 return APInt::tcMSB(significandParts(), partCount());
1125 APFloat::significandLSB() const
1127 return APInt::tcLSB(significandParts(), partCount());
1130 /* Note that a zero result is NOT normalized to fcZero. */
1132 APFloat::shiftSignificandRight(unsigned int bits)
1134 /* Our exponent should not overflow. */
1135 assert((ExponentType) (exponent + bits) >= exponent);
1139 return shiftRight(significandParts(), partCount(), bits);
1142 /* Shift the significand left BITS bits, subtract BITS from its exponent. */
1144 APFloat::shiftSignificandLeft(unsigned int bits)
1146 assert(bits < semantics->precision);
1149 unsigned int partsCount = partCount();
1151 APInt::tcShiftLeft(significandParts(), partsCount, bits);
1154 assert(!APInt::tcIsZero(significandParts(), partsCount));
1159 APFloat::compareAbsoluteValue(const APFloat &rhs) const
1163 assert(semantics == rhs.semantics);
1164 assert(isFiniteNonZero());
1165 assert(rhs.isFiniteNonZero());
1167 compare = exponent - rhs.exponent;
1169 /* If exponents are equal, do an unsigned bignum comparison of the
1172 compare = APInt::tcCompare(significandParts(), rhs.significandParts(),
1176 return cmpGreaterThan;
1177 else if (compare < 0)
1183 /* Handle overflow. Sign is preserved. We either become infinity or
1184 the largest finite number. */
1186 APFloat::handleOverflow(roundingMode rounding_mode)
1189 if (rounding_mode == rmNearestTiesToEven ||
1190 rounding_mode == rmNearestTiesToAway ||
1191 (rounding_mode == rmTowardPositive && !sign) ||
1192 (rounding_mode == rmTowardNegative && sign)) {
1193 category = fcInfinity;
1194 return (opStatus) (opOverflow | opInexact);
1197 /* Otherwise we become the largest finite number. */
1198 category = fcNormal;
1199 exponent = semantics->maxExponent;
1200 APInt::tcSetLeastSignificantBits(significandParts(), partCount(),
1201 semantics->precision);
1206 /* Returns TRUE if, when truncating the current number, with BIT the
1207 new LSB, with the given lost fraction and rounding mode, the result
1208 would need to be rounded away from zero (i.e., by increasing the
1209 signficand). This routine must work for fcZero of both signs, and
1210 fcNormal numbers. */
1212 APFloat::roundAwayFromZero(roundingMode rounding_mode,
1213 lostFraction lost_fraction,
1214 unsigned int bit) const
1216 /* NaNs and infinities should not have lost fractions. */
1217 assert(isFiniteNonZero() || category == fcZero);
1219 /* Current callers never pass this so we don't handle it. */
1220 assert(lost_fraction != lfExactlyZero);
1222 switch (rounding_mode) {
1223 case rmNearestTiesToAway:
1224 return lost_fraction == lfExactlyHalf || lost_fraction == lfMoreThanHalf;
1226 case rmNearestTiesToEven:
1227 if (lost_fraction == lfMoreThanHalf)
1230 /* Our zeroes don't have a significand to test. */
1231 if (lost_fraction == lfExactlyHalf && category != fcZero)
1232 return APInt::tcExtractBit(significandParts(), bit);
1239 case rmTowardPositive:
1240 return sign == false;
1242 case rmTowardNegative:
1243 return sign == true;
1245 llvm_unreachable("Invalid rounding mode found");
1249 APFloat::normalize(roundingMode rounding_mode,
1250 lostFraction lost_fraction)
1252 unsigned int omsb; /* One, not zero, based MSB. */
1255 if (!isFiniteNonZero())
1258 /* Before rounding normalize the exponent of fcNormal numbers. */
1259 omsb = significandMSB() + 1;
1262 /* OMSB is numbered from 1. We want to place it in the integer
1263 bit numbered PRECISION if possible, with a compensating change in
1265 exponentChange = omsb - semantics->precision;
1267 /* If the resulting exponent is too high, overflow according to
1268 the rounding mode. */
1269 if (exponent + exponentChange > semantics->maxExponent)
1270 return handleOverflow(rounding_mode);
1272 /* Subnormal numbers have exponent minExponent, and their MSB
1273 is forced based on that. */
1274 if (exponent + exponentChange < semantics->minExponent)
1275 exponentChange = semantics->minExponent - exponent;
1277 /* Shifting left is easy as we don't lose precision. */
1278 if (exponentChange < 0) {
1279 assert(lost_fraction == lfExactlyZero);
1281 shiftSignificandLeft(-exponentChange);
1286 if (exponentChange > 0) {
1289 /* Shift right and capture any new lost fraction. */
1290 lf = shiftSignificandRight(exponentChange);
1292 lost_fraction = combineLostFractions(lf, lost_fraction);
1294 /* Keep OMSB up-to-date. */
1295 if (omsb > (unsigned) exponentChange)
1296 omsb -= exponentChange;
1302 /* Now round the number according to rounding_mode given the lost
1305 /* As specified in IEEE 754, since we do not trap we do not report
1306 underflow for exact results. */
1307 if (lost_fraction == lfExactlyZero) {
1308 /* Canonicalize zeroes. */
1315 /* Increment the significand if we're rounding away from zero. */
1316 if (roundAwayFromZero(rounding_mode, lost_fraction, 0)) {
1318 exponent = semantics->minExponent;
1320 incrementSignificand();
1321 omsb = significandMSB() + 1;
1323 /* Did the significand increment overflow? */
1324 if (omsb == (unsigned) semantics->precision + 1) {
1325 /* Renormalize by incrementing the exponent and shifting our
1326 significand right one. However if we already have the
1327 maximum exponent we overflow to infinity. */
1328 if (exponent == semantics->maxExponent) {
1329 category = fcInfinity;
1331 return (opStatus) (opOverflow | opInexact);
1334 shiftSignificandRight(1);
1340 /* The normal case - we were and are not denormal, and any
1341 significand increment above didn't overflow. */
1342 if (omsb == semantics->precision)
1345 /* We have a non-zero denormal. */
1346 assert(omsb < semantics->precision);
1348 /* Canonicalize zeroes. */
1352 /* The fcZero case is a denormal that underflowed to zero. */
1353 return (opStatus) (opUnderflow | opInexact);
1357 APFloat::addOrSubtractSpecials(const APFloat &rhs, bool subtract)
1359 switch (PackCategoriesIntoKey(category, rhs.category)) {
1361 llvm_unreachable(nullptr);
1363 case PackCategoriesIntoKey(fcNaN, fcZero):
1364 case PackCategoriesIntoKey(fcNaN, fcNormal):
1365 case PackCategoriesIntoKey(fcNaN, fcInfinity):
1366 case PackCategoriesIntoKey(fcNaN, fcNaN):
1367 case PackCategoriesIntoKey(fcNormal, fcZero):
1368 case PackCategoriesIntoKey(fcInfinity, fcNormal):
1369 case PackCategoriesIntoKey(fcInfinity, fcZero):
1372 case PackCategoriesIntoKey(fcZero, fcNaN):
1373 case PackCategoriesIntoKey(fcNormal, fcNaN):
1374 case PackCategoriesIntoKey(fcInfinity, fcNaN):
1375 // We need to be sure to flip the sign here for subtraction because we
1376 // don't have a separate negate operation so -NaN becomes 0 - NaN here.
1377 sign = rhs.sign ^ subtract;
1379 copySignificand(rhs);
1382 case PackCategoriesIntoKey(fcNormal, fcInfinity):
1383 case PackCategoriesIntoKey(fcZero, fcInfinity):
1384 category = fcInfinity;
1385 sign = rhs.sign ^ subtract;
1388 case PackCategoriesIntoKey(fcZero, fcNormal):
1390 sign = rhs.sign ^ subtract;
1393 case PackCategoriesIntoKey(fcZero, fcZero):
1394 /* Sign depends on rounding mode; handled by caller. */
1397 case PackCategoriesIntoKey(fcInfinity, fcInfinity):
1398 /* Differently signed infinities can only be validly
1400 if (((sign ^ rhs.sign)!=0) != subtract) {
1407 case PackCategoriesIntoKey(fcNormal, fcNormal):
1412 /* Add or subtract two normal numbers. */
1414 APFloat::addOrSubtractSignificand(const APFloat &rhs, bool subtract)
1417 lostFraction lost_fraction;
1420 /* Determine if the operation on the absolute values is effectively
1421 an addition or subtraction. */
1422 subtract ^= (sign ^ rhs.sign) ? true : false;
1424 /* Are we bigger exponent-wise than the RHS? */
1425 bits = exponent - rhs.exponent;
1427 /* Subtraction is more subtle than one might naively expect. */
1429 APFloat temp_rhs(rhs);
1433 reverse = compareAbsoluteValue(temp_rhs) == cmpLessThan;
1434 lost_fraction = lfExactlyZero;
1435 } else if (bits > 0) {
1436 lost_fraction = temp_rhs.shiftSignificandRight(bits - 1);
1437 shiftSignificandLeft(1);
1440 lost_fraction = shiftSignificandRight(-bits - 1);
1441 temp_rhs.shiftSignificandLeft(1);
1446 carry = temp_rhs.subtractSignificand
1447 (*this, lost_fraction != lfExactlyZero);
1448 copySignificand(temp_rhs);
1451 carry = subtractSignificand
1452 (temp_rhs, lost_fraction != lfExactlyZero);
1455 /* Invert the lost fraction - it was on the RHS and
1457 if (lost_fraction == lfLessThanHalf)
1458 lost_fraction = lfMoreThanHalf;
1459 else if (lost_fraction == lfMoreThanHalf)
1460 lost_fraction = lfLessThanHalf;
1462 /* The code above is intended to ensure that no borrow is
1468 APFloat temp_rhs(rhs);
1470 lost_fraction = temp_rhs.shiftSignificandRight(bits);
1471 carry = addSignificand(temp_rhs);
1473 lost_fraction = shiftSignificandRight(-bits);
1474 carry = addSignificand(rhs);
1477 /* We have a guard bit; generating a carry cannot happen. */
1482 return lost_fraction;
1486 APFloat::multiplySpecials(const APFloat &rhs)
1488 switch (PackCategoriesIntoKey(category, rhs.category)) {
1490 llvm_unreachable(nullptr);
1492 case PackCategoriesIntoKey(fcNaN, fcZero):
1493 case PackCategoriesIntoKey(fcNaN, fcNormal):
1494 case PackCategoriesIntoKey(fcNaN, fcInfinity):
1495 case PackCategoriesIntoKey(fcNaN, fcNaN):
1499 case PackCategoriesIntoKey(fcZero, fcNaN):
1500 case PackCategoriesIntoKey(fcNormal, fcNaN):
1501 case PackCategoriesIntoKey(fcInfinity, fcNaN):
1504 copySignificand(rhs);
1507 case PackCategoriesIntoKey(fcNormal, fcInfinity):
1508 case PackCategoriesIntoKey(fcInfinity, fcNormal):
1509 case PackCategoriesIntoKey(fcInfinity, fcInfinity):
1510 category = fcInfinity;
1513 case PackCategoriesIntoKey(fcZero, fcNormal):
1514 case PackCategoriesIntoKey(fcNormal, fcZero):
1515 case PackCategoriesIntoKey(fcZero, fcZero):
1519 case PackCategoriesIntoKey(fcZero, fcInfinity):
1520 case PackCategoriesIntoKey(fcInfinity, fcZero):
1524 case PackCategoriesIntoKey(fcNormal, fcNormal):
1530 APFloat::divideSpecials(const APFloat &rhs)
1532 switch (PackCategoriesIntoKey(category, rhs.category)) {
1534 llvm_unreachable(nullptr);
1536 case PackCategoriesIntoKey(fcZero, fcNaN):
1537 case PackCategoriesIntoKey(fcNormal, fcNaN):
1538 case PackCategoriesIntoKey(fcInfinity, fcNaN):
1540 copySignificand(rhs);
1541 case PackCategoriesIntoKey(fcNaN, fcZero):
1542 case PackCategoriesIntoKey(fcNaN, fcNormal):
1543 case PackCategoriesIntoKey(fcNaN, fcInfinity):
1544 case PackCategoriesIntoKey(fcNaN, fcNaN):
1546 case PackCategoriesIntoKey(fcInfinity, fcZero):
1547 case PackCategoriesIntoKey(fcInfinity, fcNormal):
1548 case PackCategoriesIntoKey(fcZero, fcInfinity):
1549 case PackCategoriesIntoKey(fcZero, fcNormal):
1552 case PackCategoriesIntoKey(fcNormal, fcInfinity):
1556 case PackCategoriesIntoKey(fcNormal, fcZero):
1557 category = fcInfinity;
1560 case PackCategoriesIntoKey(fcInfinity, fcInfinity):
1561 case PackCategoriesIntoKey(fcZero, fcZero):
1565 case PackCategoriesIntoKey(fcNormal, fcNormal):
1571 APFloat::modSpecials(const APFloat &rhs)
1573 switch (PackCategoriesIntoKey(category, rhs.category)) {
1575 llvm_unreachable(nullptr);
1577 case PackCategoriesIntoKey(fcNaN, fcZero):
1578 case PackCategoriesIntoKey(fcNaN, fcNormal):
1579 case PackCategoriesIntoKey(fcNaN, fcInfinity):
1580 case PackCategoriesIntoKey(fcNaN, fcNaN):
1581 case PackCategoriesIntoKey(fcZero, fcInfinity):
1582 case PackCategoriesIntoKey(fcZero, fcNormal):
1583 case PackCategoriesIntoKey(fcNormal, fcInfinity):
1586 case PackCategoriesIntoKey(fcZero, fcNaN):
1587 case PackCategoriesIntoKey(fcNormal, fcNaN):
1588 case PackCategoriesIntoKey(fcInfinity, fcNaN):
1591 copySignificand(rhs);
1594 case PackCategoriesIntoKey(fcNormal, fcZero):
1595 case PackCategoriesIntoKey(fcInfinity, fcZero):
1596 case PackCategoriesIntoKey(fcInfinity, fcNormal):
1597 case PackCategoriesIntoKey(fcInfinity, fcInfinity):
1598 case PackCategoriesIntoKey(fcZero, fcZero):
1602 case PackCategoriesIntoKey(fcNormal, fcNormal):
1609 APFloat::changeSign()
1611 /* Look mummy, this one's easy. */
1616 APFloat::clearSign()
1618 /* So is this one. */
1623 APFloat::copySign(const APFloat &rhs)
1629 /* Normalized addition or subtraction. */
1631 APFloat::addOrSubtract(const APFloat &rhs, roundingMode rounding_mode,
1636 fs = addOrSubtractSpecials(rhs, subtract);
1638 /* This return code means it was not a simple case. */
1639 if (fs == opDivByZero) {
1640 lostFraction lost_fraction;
1642 lost_fraction = addOrSubtractSignificand(rhs, subtract);
1643 fs = normalize(rounding_mode, lost_fraction);
1645 /* Can only be zero if we lost no fraction. */
1646 assert(category != fcZero || lost_fraction == lfExactlyZero);
1649 /* If two numbers add (exactly) to zero, IEEE 754 decrees it is a
1650 positive zero unless rounding to minus infinity, except that
1651 adding two like-signed zeroes gives that zero. */
1652 if (category == fcZero) {
1653 if (rhs.category != fcZero || (sign == rhs.sign) == subtract)
1654 sign = (rounding_mode == rmTowardNegative);
1660 /* Normalized addition. */
1662 APFloat::add(const APFloat &rhs, roundingMode rounding_mode)
1664 return addOrSubtract(rhs, rounding_mode, false);
1667 /* Normalized subtraction. */
1669 APFloat::subtract(const APFloat &rhs, roundingMode rounding_mode)
1671 return addOrSubtract(rhs, rounding_mode, true);
1674 /* Normalized multiply. */
1676 APFloat::multiply(const APFloat &rhs, roundingMode rounding_mode)
1681 fs = multiplySpecials(rhs);
1683 if (isFiniteNonZero()) {
1684 lostFraction lost_fraction = multiplySignificand(rhs, nullptr);
1685 fs = normalize(rounding_mode, lost_fraction);
1686 if (lost_fraction != lfExactlyZero)
1687 fs = (opStatus) (fs | opInexact);
1693 /* Normalized divide. */
1695 APFloat::divide(const APFloat &rhs, roundingMode rounding_mode)
1700 fs = divideSpecials(rhs);
1702 if (isFiniteNonZero()) {
1703 lostFraction lost_fraction = divideSignificand(rhs);
1704 fs = normalize(rounding_mode, lost_fraction);
1705 if (lost_fraction != lfExactlyZero)
1706 fs = (opStatus) (fs | opInexact);
1712 /* Normalized remainder. This is not currently correct in all cases. */
1714 APFloat::remainder(const APFloat &rhs)
1718 unsigned int origSign = sign;
1720 fs = V.divide(rhs, rmNearestTiesToEven);
1721 if (fs == opDivByZero)
1724 int parts = partCount();
1725 auto XOwner = make_unique<integerPart[]>(parts);
1726 auto x = XOwner.get();
1728 fs = V.convertToInteger(x, parts * integerPartWidth, true,
1729 rmNearestTiesToEven, &ignored);
1730 if (fs==opInvalidOp)
1733 fs = V.convertFromZeroExtendedInteger(x, parts * integerPartWidth, true,
1734 rmNearestTiesToEven);
1735 assert(fs==opOK); // should always work
1737 fs = V.multiply(rhs, rmNearestTiesToEven);
1738 assert(fs==opOK || fs==opInexact); // should not overflow or underflow
1740 fs = subtract(V, rmNearestTiesToEven);
1741 assert(fs==opOK || fs==opInexact); // likewise
1744 sign = origSign; // IEEE754 requires this
1748 /* Normalized llvm frem (C fmod).
1749 This is not currently correct in all cases. */
1751 APFloat::mod(const APFloat &rhs, roundingMode rounding_mode)
1754 fs = modSpecials(rhs);
1756 if (isFiniteNonZero() && rhs.isFiniteNonZero()) {
1758 unsigned int origSign = sign;
1760 fs = V.divide(rhs, rmNearestTiesToEven);
1761 if (fs == opDivByZero)
1764 int parts = partCount();
1765 auto XOwner = make_unique<integerPart[]>(parts);
1766 auto x = XOwner.get();
1768 fs = V.convertToInteger(x, parts * integerPartWidth, true,
1769 rmTowardZero, &ignored);
1770 if (fs==opInvalidOp)
1773 fs = V.convertFromZeroExtendedInteger(x, parts * integerPartWidth, true,
1774 rmNearestTiesToEven);
1775 assert(fs==opOK); // should always work
1777 fs = V.multiply(rhs, rounding_mode);
1778 assert(fs==opOK || fs==opInexact); // should not overflow or underflow
1780 fs = subtract(V, rounding_mode);
1781 assert(fs==opOK || fs==opInexact); // likewise
1784 sign = origSign; // IEEE754 requires this
1789 /* Normalized fused-multiply-add. */
1791 APFloat::fusedMultiplyAdd(const APFloat &multiplicand,
1792 const APFloat &addend,
1793 roundingMode rounding_mode)
1797 /* Post-multiplication sign, before addition. */
1798 sign ^= multiplicand.sign;
1800 /* If and only if all arguments are normal do we need to do an
1801 extended-precision calculation. */
1802 if (isFiniteNonZero() &&
1803 multiplicand.isFiniteNonZero() &&
1804 addend.isFiniteNonZero()) {
1805 lostFraction lost_fraction;
1807 lost_fraction = multiplySignificand(multiplicand, &addend);
1808 fs = normalize(rounding_mode, lost_fraction);
1809 if (lost_fraction != lfExactlyZero)
1810 fs = (opStatus) (fs | opInexact);
1812 /* If two numbers add (exactly) to zero, IEEE 754 decrees it is a
1813 positive zero unless rounding to minus infinity, except that
1814 adding two like-signed zeroes gives that zero. */
1815 if (category == fcZero && sign != addend.sign)
1816 sign = (rounding_mode == rmTowardNegative);
1818 fs = multiplySpecials(multiplicand);
1820 /* FS can only be opOK or opInvalidOp. There is no more work
1821 to do in the latter case. The IEEE-754R standard says it is
1822 implementation-defined in this case whether, if ADDEND is a
1823 quiet NaN, we raise invalid op; this implementation does so.
1825 If we need to do the addition we can do so with normal
1828 fs = addOrSubtract(addend, rounding_mode, false);
1834 /* Rounding-mode corrrect round to integral value. */
1835 APFloat::opStatus APFloat::roundToIntegral(roundingMode rounding_mode) {
1838 // If the exponent is large enough, we know that this value is already
1839 // integral, and the arithmetic below would potentially cause it to saturate
1840 // to +/-Inf. Bail out early instead.
1841 if (isFiniteNonZero() && exponent+1 >= (int)semanticsPrecision(*semantics))
1844 // The algorithm here is quite simple: we add 2^(p-1), where p is the
1845 // precision of our format, and then subtract it back off again. The choice
1846 // of rounding modes for the addition/subtraction determines the rounding mode
1847 // for our integral rounding as well.
1848 // NOTE: When the input value is negative, we do subtraction followed by
1849 // addition instead.
1850 APInt IntegerConstant(NextPowerOf2(semanticsPrecision(*semantics)), 1);
1851 IntegerConstant <<= semanticsPrecision(*semantics)-1;
1852 APFloat MagicConstant(*semantics);
1853 fs = MagicConstant.convertFromAPInt(IntegerConstant, false,
1854 rmNearestTiesToEven);
1855 MagicConstant.copySign(*this);
1860 // Preserve the input sign so that we can handle 0.0/-0.0 cases correctly.
1861 bool inputSign = isNegative();
1863 fs = add(MagicConstant, rounding_mode);
1864 if (fs != opOK && fs != opInexact)
1867 fs = subtract(MagicConstant, rounding_mode);
1869 // Restore the input sign.
1870 if (inputSign != isNegative())
1877 /* Comparison requires normalized numbers. */
1879 APFloat::compare(const APFloat &rhs) const
1883 assert(semantics == rhs.semantics);
1885 switch (PackCategoriesIntoKey(category, rhs.category)) {
1887 llvm_unreachable(nullptr);
1889 case PackCategoriesIntoKey(fcNaN, fcZero):
1890 case PackCategoriesIntoKey(fcNaN, fcNormal):
1891 case PackCategoriesIntoKey(fcNaN, fcInfinity):
1892 case PackCategoriesIntoKey(fcNaN, fcNaN):
1893 case PackCategoriesIntoKey(fcZero, fcNaN):
1894 case PackCategoriesIntoKey(fcNormal, fcNaN):
1895 case PackCategoriesIntoKey(fcInfinity, fcNaN):
1896 return cmpUnordered;
1898 case PackCategoriesIntoKey(fcInfinity, fcNormal):
1899 case PackCategoriesIntoKey(fcInfinity, fcZero):
1900 case PackCategoriesIntoKey(fcNormal, fcZero):
1904 return cmpGreaterThan;
1906 case PackCategoriesIntoKey(fcNormal, fcInfinity):
1907 case PackCategoriesIntoKey(fcZero, fcInfinity):
1908 case PackCategoriesIntoKey(fcZero, fcNormal):
1910 return cmpGreaterThan;
1914 case PackCategoriesIntoKey(fcInfinity, fcInfinity):
1915 if (sign == rhs.sign)
1920 return cmpGreaterThan;
1922 case PackCategoriesIntoKey(fcZero, fcZero):
1925 case PackCategoriesIntoKey(fcNormal, fcNormal):
1929 /* Two normal numbers. Do they have the same sign? */
1930 if (sign != rhs.sign) {
1932 result = cmpLessThan;
1934 result = cmpGreaterThan;
1936 /* Compare absolute values; invert result if negative. */
1937 result = compareAbsoluteValue(rhs);
1940 if (result == cmpLessThan)
1941 result = cmpGreaterThan;
1942 else if (result == cmpGreaterThan)
1943 result = cmpLessThan;
1950 /// APFloat::convert - convert a value of one floating point type to another.
1951 /// The return value corresponds to the IEEE754 exceptions. *losesInfo
1952 /// records whether the transformation lost information, i.e. whether
1953 /// converting the result back to the original type will produce the
1954 /// original value (this is almost the same as return value==fsOK, but there
1955 /// are edge cases where this is not so).
1958 APFloat::convert(const fltSemantics &toSemantics,
1959 roundingMode rounding_mode, bool *losesInfo)
1961 lostFraction lostFraction;
1962 unsigned int newPartCount, oldPartCount;
1965 const fltSemantics &fromSemantics = *semantics;
1967 lostFraction = lfExactlyZero;
1968 newPartCount = partCountForBits(toSemantics.precision + 1);
1969 oldPartCount = partCount();
1970 shift = toSemantics.precision - fromSemantics.precision;
1972 bool X86SpecialNan = false;
1973 if (&fromSemantics == &APFloat::x87DoubleExtended &&
1974 &toSemantics != &APFloat::x87DoubleExtended && category == fcNaN &&
1975 (!(*significandParts() & 0x8000000000000000ULL) ||
1976 !(*significandParts() & 0x4000000000000000ULL))) {
1977 // x86 has some unusual NaNs which cannot be represented in any other
1978 // format; note them here.
1979 X86SpecialNan = true;
1982 // If this is a truncation of a denormal number, and the target semantics
1983 // has larger exponent range than the source semantics (this can happen
1984 // when truncating from PowerPC double-double to double format), the
1985 // right shift could lose result mantissa bits. Adjust exponent instead
1986 // of performing excessive shift.
1987 if (shift < 0 && isFiniteNonZero()) {
1988 int exponentChange = significandMSB() + 1 - fromSemantics.precision;
1989 if (exponent + exponentChange < toSemantics.minExponent)
1990 exponentChange = toSemantics.minExponent - exponent;
1991 if (exponentChange < shift)
1992 exponentChange = shift;
1993 if (exponentChange < 0) {
1994 shift -= exponentChange;
1995 exponent += exponentChange;
1999 // If this is a truncation, perform the shift before we narrow the storage.
2000 if (shift < 0 && (isFiniteNonZero() || category==fcNaN))
2001 lostFraction = shiftRight(significandParts(), oldPartCount, -shift);
2003 // Fix the storage so it can hold to new value.
2004 if (newPartCount > oldPartCount) {
2005 // The new type requires more storage; make it available.
2006 integerPart *newParts;
2007 newParts = new integerPart[newPartCount];
2008 APInt::tcSet(newParts, 0, newPartCount);
2009 if (isFiniteNonZero() || category==fcNaN)
2010 APInt::tcAssign(newParts, significandParts(), oldPartCount);
2012 significand.parts = newParts;
2013 } else if (newPartCount == 1 && oldPartCount != 1) {
2014 // Switch to built-in storage for a single part.
2015 integerPart newPart = 0;
2016 if (isFiniteNonZero() || category==fcNaN)
2017 newPart = significandParts()[0];
2019 significand.part = newPart;
2022 // Now that we have the right storage, switch the semantics.
2023 semantics = &toSemantics;
2025 // If this is an extension, perform the shift now that the storage is
2027 if (shift > 0 && (isFiniteNonZero() || category==fcNaN))
2028 APInt::tcShiftLeft(significandParts(), newPartCount, shift);
2030 if (isFiniteNonZero()) {
2031 fs = normalize(rounding_mode, lostFraction);
2032 *losesInfo = (fs != opOK);
2033 } else if (category == fcNaN) {
2034 *losesInfo = lostFraction != lfExactlyZero || X86SpecialNan;
2036 // For x87 extended precision, we want to make a NaN, not a special NaN if
2037 // the input wasn't special either.
2038 if (!X86SpecialNan && semantics == &APFloat::x87DoubleExtended)
2039 APInt::tcSetBit(significandParts(), semantics->precision - 1);
2041 // gcc forces the Quiet bit on, which means (float)(double)(float_sNan)
2042 // does not give you back the same bits. This is dubious, and we
2043 // don't currently do it. You're really supposed to get
2044 // an invalid operation signal at runtime, but nobody does that.
2054 /* Convert a floating point number to an integer according to the
2055 rounding mode. If the rounded integer value is out of range this
2056 returns an invalid operation exception and the contents of the
2057 destination parts are unspecified. If the rounded value is in
2058 range but the floating point number is not the exact integer, the C
2059 standard doesn't require an inexact exception to be raised. IEEE
2060 854 does require it so we do that.
2062 Note that for conversions to integer type the C standard requires
2063 round-to-zero to always be used. */
2065 APFloat::convertToSignExtendedInteger(integerPart *parts, unsigned int width,
2067 roundingMode rounding_mode,
2068 bool *isExact) const
2070 lostFraction lost_fraction;
2071 const integerPart *src;
2072 unsigned int dstPartsCount, truncatedBits;
2076 /* Handle the three special cases first. */
2077 if (category == fcInfinity || category == fcNaN)
2080 dstPartsCount = partCountForBits(width);
2082 if (category == fcZero) {
2083 APInt::tcSet(parts, 0, dstPartsCount);
2084 // Negative zero can't be represented as an int.
2089 src = significandParts();
2091 /* Step 1: place our absolute value, with any fraction truncated, in
2094 /* Our absolute value is less than one; truncate everything. */
2095 APInt::tcSet(parts, 0, dstPartsCount);
2096 /* For exponent -1 the integer bit represents .5, look at that.
2097 For smaller exponents leftmost truncated bit is 0. */
2098 truncatedBits = semantics->precision -1U - exponent;
2100 /* We want the most significant (exponent + 1) bits; the rest are
2102 unsigned int bits = exponent + 1U;
2104 /* Hopelessly large in magnitude? */
2108 if (bits < semantics->precision) {
2109 /* We truncate (semantics->precision - bits) bits. */
2110 truncatedBits = semantics->precision - bits;
2111 APInt::tcExtract(parts, dstPartsCount, src, bits, truncatedBits);
2113 /* We want at least as many bits as are available. */
2114 APInt::tcExtract(parts, dstPartsCount, src, semantics->precision, 0);
2115 APInt::tcShiftLeft(parts, dstPartsCount, bits - semantics->precision);
2120 /* Step 2: work out any lost fraction, and increment the absolute
2121 value if we would round away from zero. */
2122 if (truncatedBits) {
2123 lost_fraction = lostFractionThroughTruncation(src, partCount(),
2125 if (lost_fraction != lfExactlyZero &&
2126 roundAwayFromZero(rounding_mode, lost_fraction, truncatedBits)) {
2127 if (APInt::tcIncrement(parts, dstPartsCount))
2128 return opInvalidOp; /* Overflow. */
2131 lost_fraction = lfExactlyZero;
2134 /* Step 3: check if we fit in the destination. */
2135 unsigned int omsb = APInt::tcMSB(parts, dstPartsCount) + 1;
2139 /* Negative numbers cannot be represented as unsigned. */
2143 /* It takes omsb bits to represent the unsigned integer value.
2144 We lose a bit for the sign, but care is needed as the
2145 maximally negative integer is a special case. */
2146 if (omsb == width && APInt::tcLSB(parts, dstPartsCount) + 1 != omsb)
2149 /* This case can happen because of rounding. */
2154 APInt::tcNegate (parts, dstPartsCount);
2156 if (omsb >= width + !isSigned)
2160 if (lost_fraction == lfExactlyZero) {
2167 /* Same as convertToSignExtendedInteger, except we provide
2168 deterministic values in case of an invalid operation exception,
2169 namely zero for NaNs and the minimal or maximal value respectively
2170 for underflow or overflow.
2171 The *isExact output tells whether the result is exact, in the sense
2172 that converting it back to the original floating point type produces
2173 the original value. This is almost equivalent to result==opOK,
2174 except for negative zeroes.
2177 APFloat::convertToInteger(integerPart *parts, unsigned int width,
2179 roundingMode rounding_mode, bool *isExact) const
2183 fs = convertToSignExtendedInteger(parts, width, isSigned, rounding_mode,
2186 if (fs == opInvalidOp) {
2187 unsigned int bits, dstPartsCount;
2189 dstPartsCount = partCountForBits(width);
2191 if (category == fcNaN)
2196 bits = width - isSigned;
2198 APInt::tcSetLeastSignificantBits(parts, dstPartsCount, bits);
2199 if (sign && isSigned)
2200 APInt::tcShiftLeft(parts, dstPartsCount, width - 1);
2206 /* Same as convertToInteger(integerPart*, ...), except the result is returned in
2207 an APSInt, whose initial bit-width and signed-ness are used to determine the
2208 precision of the conversion.
2211 APFloat::convertToInteger(APSInt &result,
2212 roundingMode rounding_mode, bool *isExact) const
2214 unsigned bitWidth = result.getBitWidth();
2215 SmallVector<uint64_t, 4> parts(result.getNumWords());
2216 opStatus status = convertToInteger(
2217 parts.data(), bitWidth, result.isSigned(), rounding_mode, isExact);
2218 // Keeps the original signed-ness.
2219 result = APInt(bitWidth, parts);
2223 /* Convert an unsigned integer SRC to a floating point number,
2224 rounding according to ROUNDING_MODE. The sign of the floating
2225 point number is not modified. */
2227 APFloat::convertFromUnsignedParts(const integerPart *src,
2228 unsigned int srcCount,
2229 roundingMode rounding_mode)
2231 unsigned int omsb, precision, dstCount;
2233 lostFraction lost_fraction;
2235 category = fcNormal;
2236 omsb = APInt::tcMSB(src, srcCount) + 1;
2237 dst = significandParts();
2238 dstCount = partCount();
2239 precision = semantics->precision;
2241 /* We want the most significant PRECISION bits of SRC. There may not
2242 be that many; extract what we can. */
2243 if (precision <= omsb) {
2244 exponent = omsb - 1;
2245 lost_fraction = lostFractionThroughTruncation(src, srcCount,
2247 APInt::tcExtract(dst, dstCount, src, precision, omsb - precision);
2249 exponent = precision - 1;
2250 lost_fraction = lfExactlyZero;
2251 APInt::tcExtract(dst, dstCount, src, omsb, 0);
2254 return normalize(rounding_mode, lost_fraction);
2258 APFloat::convertFromAPInt(const APInt &Val,
2260 roundingMode rounding_mode)
2262 unsigned int partCount = Val.getNumWords();
2266 if (isSigned && api.isNegative()) {
2271 return convertFromUnsignedParts(api.getRawData(), partCount, rounding_mode);
2274 /* Convert a two's complement integer SRC to a floating point number,
2275 rounding according to ROUNDING_MODE. ISSIGNED is true if the
2276 integer is signed, in which case it must be sign-extended. */
2278 APFloat::convertFromSignExtendedInteger(const integerPart *src,
2279 unsigned int srcCount,
2281 roundingMode rounding_mode)
2286 APInt::tcExtractBit(src, srcCount * integerPartWidth - 1)) {
2287 auto C = make_unique<integerPart[]>(srcCount);
2288 auto copy = C.get();
2290 /* If we're signed and negative negate a copy. */
2292 APInt::tcAssign(copy, src, srcCount);
2293 APInt::tcNegate(copy, srcCount);
2294 status = convertFromUnsignedParts(copy, srcCount, rounding_mode);
2297 status = convertFromUnsignedParts(src, srcCount, rounding_mode);
2303 /* FIXME: should this just take a const APInt reference? */
2305 APFloat::convertFromZeroExtendedInteger(const integerPart *parts,
2306 unsigned int width, bool isSigned,
2307 roundingMode rounding_mode)
2309 unsigned int partCount = partCountForBits(width);
2310 APInt api = APInt(width, makeArrayRef(parts, partCount));
2313 if (isSigned && APInt::tcExtractBit(parts, width - 1)) {
2318 return convertFromUnsignedParts(api.getRawData(), partCount, rounding_mode);
2322 APFloat::convertFromHexadecimalString(StringRef s, roundingMode rounding_mode)
2324 lostFraction lost_fraction = lfExactlyZero;
2326 category = fcNormal;
2330 integerPart *significand = significandParts();
2331 unsigned partsCount = partCount();
2332 unsigned bitPos = partsCount * integerPartWidth;
2333 bool computedTrailingFraction = false;
2335 // Skip leading zeroes and any (hexa)decimal point.
2336 StringRef::iterator begin = s.begin();
2337 StringRef::iterator end = s.end();
2338 StringRef::iterator dot;
2339 StringRef::iterator p = skipLeadingZeroesAndAnyDot(begin, end, &dot);
2340 StringRef::iterator firstSignificantDigit = p;
2343 integerPart hex_value;
2346 assert(dot == end && "String contains multiple dots");
2351 hex_value = hexDigitValue(*p);
2352 if (hex_value == -1U)
2357 // Store the number while we have space.
2360 hex_value <<= bitPos % integerPartWidth;
2361 significand[bitPos / integerPartWidth] |= hex_value;
2362 } else if (!computedTrailingFraction) {
2363 lost_fraction = trailingHexadecimalFraction(p, end, hex_value);
2364 computedTrailingFraction = true;
2368 /* Hex floats require an exponent but not a hexadecimal point. */
2369 assert(p != end && "Hex strings require an exponent");
2370 assert((*p == 'p' || *p == 'P') && "Invalid character in significand");
2371 assert(p != begin && "Significand has no digits");
2372 assert((dot == end || p - begin != 1) && "Significand has no digits");
2374 /* Ignore the exponent if we are zero. */
2375 if (p != firstSignificantDigit) {
2378 /* Implicit hexadecimal point? */
2382 /* Calculate the exponent adjustment implicit in the number of
2383 significant digits. */
2384 expAdjustment = static_cast<int>(dot - firstSignificantDigit);
2385 if (expAdjustment < 0)
2387 expAdjustment = expAdjustment * 4 - 1;
2389 /* Adjust for writing the significand starting at the most
2390 significant nibble. */
2391 expAdjustment += semantics->precision;
2392 expAdjustment -= partsCount * integerPartWidth;
2394 /* Adjust for the given exponent. */
2395 exponent = totalExponent(p + 1, end, expAdjustment);
2398 return normalize(rounding_mode, lost_fraction);
2402 APFloat::roundSignificandWithExponent(const integerPart *decSigParts,
2403 unsigned sigPartCount, int exp,
2404 roundingMode rounding_mode)
2406 unsigned int parts, pow5PartCount;
2407 fltSemantics calcSemantics = { 32767, -32767, 0 };
2408 integerPart pow5Parts[maxPowerOfFiveParts];
2411 isNearest = (rounding_mode == rmNearestTiesToEven ||
2412 rounding_mode == rmNearestTiesToAway);
2414 parts = partCountForBits(semantics->precision + 11);
2416 /* Calculate pow(5, abs(exp)). */
2417 pow5PartCount = powerOf5(pow5Parts, exp >= 0 ? exp: -exp);
2419 for (;; parts *= 2) {
2420 opStatus sigStatus, powStatus;
2421 unsigned int excessPrecision, truncatedBits;
2423 calcSemantics.precision = parts * integerPartWidth - 1;
2424 excessPrecision = calcSemantics.precision - semantics->precision;
2425 truncatedBits = excessPrecision;
2427 APFloat decSig = APFloat::getZero(calcSemantics, sign);
2428 APFloat pow5(calcSemantics);
2430 sigStatus = decSig.convertFromUnsignedParts(decSigParts, sigPartCount,
2431 rmNearestTiesToEven);
2432 powStatus = pow5.convertFromUnsignedParts(pow5Parts, pow5PartCount,
2433 rmNearestTiesToEven);
2434 /* Add exp, as 10^n = 5^n * 2^n. */
2435 decSig.exponent += exp;
2437 lostFraction calcLostFraction;
2438 integerPart HUerr, HUdistance;
2439 unsigned int powHUerr;
2442 /* multiplySignificand leaves the precision-th bit set to 1. */
2443 calcLostFraction = decSig.multiplySignificand(pow5, nullptr);
2444 powHUerr = powStatus != opOK;
2446 calcLostFraction = decSig.divideSignificand(pow5);
2447 /* Denormal numbers have less precision. */
2448 if (decSig.exponent < semantics->minExponent) {
2449 excessPrecision += (semantics->minExponent - decSig.exponent);
2450 truncatedBits = excessPrecision;
2451 if (excessPrecision > calcSemantics.precision)
2452 excessPrecision = calcSemantics.precision;
2454 /* Extra half-ulp lost in reciprocal of exponent. */
2455 powHUerr = (powStatus == opOK && calcLostFraction == lfExactlyZero) ? 0:2;
2458 /* Both multiplySignificand and divideSignificand return the
2459 result with the integer bit set. */
2460 assert(APInt::tcExtractBit
2461 (decSig.significandParts(), calcSemantics.precision - 1) == 1);
2463 HUerr = HUerrBound(calcLostFraction != lfExactlyZero, sigStatus != opOK,
2465 HUdistance = 2 * ulpsFromBoundary(decSig.significandParts(),
2466 excessPrecision, isNearest);
2468 /* Are we guaranteed to round correctly if we truncate? */
2469 if (HUdistance >= HUerr) {
2470 APInt::tcExtract(significandParts(), partCount(), decSig.significandParts(),
2471 calcSemantics.precision - excessPrecision,
2473 /* Take the exponent of decSig. If we tcExtract-ed less bits
2474 above we must adjust our exponent to compensate for the
2475 implicit right shift. */
2476 exponent = (decSig.exponent + semantics->precision
2477 - (calcSemantics.precision - excessPrecision));
2478 calcLostFraction = lostFractionThroughTruncation(decSig.significandParts(),
2481 return normalize(rounding_mode, calcLostFraction);
2487 APFloat::convertFromDecimalString(StringRef str, roundingMode rounding_mode)
2492 /* Scan the text. */
2493 StringRef::iterator p = str.begin();
2494 interpretDecimal(p, str.end(), &D);
2496 /* Handle the quick cases. First the case of no significant digits,
2497 i.e. zero, and then exponents that are obviously too large or too
2498 small. Writing L for log 10 / log 2, a number d.ddddd*10^exp
2499 definitely overflows if
2501 (exp - 1) * L >= maxExponent
2503 and definitely underflows to zero where
2505 (exp + 1) * L <= minExponent - precision
2507 With integer arithmetic the tightest bounds for L are
2509 93/28 < L < 196/59 [ numerator <= 256 ]
2510 42039/12655 < L < 28738/8651 [ numerator <= 65536 ]
2513 // Test if we have a zero number allowing for strings with no null terminators
2514 // and zero decimals with non-zero exponents.
2516 // We computed firstSigDigit by ignoring all zeros and dots. Thus if
2517 // D->firstSigDigit equals str.end(), every digit must be a zero and there can
2518 // be at most one dot. On the other hand, if we have a zero with a non-zero
2519 // exponent, then we know that D.firstSigDigit will be non-numeric.
2520 if (D.firstSigDigit == str.end() || decDigitValue(*D.firstSigDigit) >= 10U) {
2524 /* Check whether the normalized exponent is high enough to overflow
2525 max during the log-rebasing in the max-exponent check below. */
2526 } else if (D.normalizedExponent - 1 > INT_MAX / 42039) {
2527 fs = handleOverflow(rounding_mode);
2529 /* If it wasn't, then it also wasn't high enough to overflow max
2530 during the log-rebasing in the min-exponent check. Check that it
2531 won't overflow min in either check, then perform the min-exponent
2533 } else if (D.normalizedExponent - 1 < INT_MIN / 42039 ||
2534 (D.normalizedExponent + 1) * 28738 <=
2535 8651 * (semantics->minExponent - (int) semantics->precision)) {
2536 /* Underflow to zero and round. */
2537 category = fcNormal;
2539 fs = normalize(rounding_mode, lfLessThanHalf);
2541 /* We can finally safely perform the max-exponent check. */
2542 } else if ((D.normalizedExponent - 1) * 42039
2543 >= 12655 * semantics->maxExponent) {
2544 /* Overflow and round. */
2545 fs = handleOverflow(rounding_mode);
2547 unsigned int partCount;
2549 /* A tight upper bound on number of bits required to hold an
2550 N-digit decimal integer is N * 196 / 59. Allocate enough space
2551 to hold the full significand, and an extra part required by
2553 partCount = static_cast<unsigned int>(D.lastSigDigit - D.firstSigDigit) + 1;
2554 partCount = partCountForBits(1 + 196 * partCount / 59);
2555 auto DecSignificandOwner = make_unique<integerPart[]>(partCount + 1);
2556 auto decSignificand = DecSignificandOwner.get();
2559 /* Convert to binary efficiently - we do almost all multiplication
2560 in an integerPart. When this would overflow do we do a single
2561 bignum multiplication, and then revert again to multiplication
2562 in an integerPart. */
2564 integerPart decValue, val, multiplier;
2572 if (p == str.end()) {
2576 decValue = decDigitValue(*p++);
2577 assert(decValue < 10U && "Invalid character in significand");
2579 val = val * 10 + decValue;
2580 /* The maximum number that can be multiplied by ten with any
2581 digit added without overflowing an integerPart. */
2582 } while (p <= D.lastSigDigit && multiplier <= (~ (integerPart) 0 - 9) / 10);
2584 /* Multiply out the current part. */
2585 APInt::tcMultiplyPart(decSignificand, decSignificand, multiplier, val,
2586 partCount, partCount + 1, false);
2588 /* If we used another part (likely but not guaranteed), increase
2590 if (decSignificand[partCount])
2592 } while (p <= D.lastSigDigit);
2594 category = fcNormal;
2595 fs = roundSignificandWithExponent(decSignificand, partCount,
2596 D.exponent, rounding_mode);
2603 APFloat::convertFromStringSpecials(StringRef str) {
2604 if (str.equals("inf") || str.equals("INFINITY")) {
2609 if (str.equals("-inf") || str.equals("-INFINITY")) {
2614 if (str.equals("nan") || str.equals("NaN")) {
2615 makeNaN(false, false);
2619 if (str.equals("-nan") || str.equals("-NaN")) {
2620 makeNaN(false, true);
2628 APFloat::convertFromString(StringRef str, roundingMode rounding_mode)
2630 assert(!str.empty() && "Invalid string length");
2632 // Handle special cases.
2633 if (convertFromStringSpecials(str))
2636 /* Handle a leading minus sign. */
2637 StringRef::iterator p = str.begin();
2638 size_t slen = str.size();
2639 sign = *p == '-' ? 1 : 0;
2640 if (*p == '-' || *p == '+') {
2643 assert(slen && "String has no digits");
2646 if (slen >= 2 && p[0] == '0' && (p[1] == 'x' || p[1] == 'X')) {
2647 assert(slen - 2 && "Invalid string");
2648 return convertFromHexadecimalString(StringRef(p + 2, slen - 2),
2652 return convertFromDecimalString(StringRef(p, slen), rounding_mode);
2655 /* Write out a hexadecimal representation of the floating point value
2656 to DST, which must be of sufficient size, in the C99 form
2657 [-]0xh.hhhhp[+-]d. Return the number of characters written,
2658 excluding the terminating NUL.
2660 If UPPERCASE, the output is in upper case, otherwise in lower case.
2662 HEXDIGITS digits appear altogether, rounding the value if
2663 necessary. If HEXDIGITS is 0, the minimal precision to display the
2664 number precisely is used instead. If nothing would appear after
2665 the decimal point it is suppressed.
2667 The decimal exponent is always printed and has at least one digit.
2668 Zero values display an exponent of zero. Infinities and NaNs
2669 appear as "infinity" or "nan" respectively.
2671 The above rules are as specified by C99. There is ambiguity about
2672 what the leading hexadecimal digit should be. This implementation
2673 uses whatever is necessary so that the exponent is displayed as
2674 stored. This implies the exponent will fall within the IEEE format
2675 range, and the leading hexadecimal digit will be 0 (for denormals),
2676 1 (normal numbers) or 2 (normal numbers rounded-away-from-zero with
2677 any other digits zero).
2680 APFloat::convertToHexString(char *dst, unsigned int hexDigits,
2681 bool upperCase, roundingMode rounding_mode) const
2691 memcpy (dst, upperCase ? infinityU: infinityL, sizeof infinityU - 1);
2692 dst += sizeof infinityL - 1;
2696 memcpy (dst, upperCase ? NaNU: NaNL, sizeof NaNU - 1);
2697 dst += sizeof NaNU - 1;
2702 *dst++ = upperCase ? 'X': 'x';
2704 if (hexDigits > 1) {
2706 memset (dst, '0', hexDigits - 1);
2707 dst += hexDigits - 1;
2709 *dst++ = upperCase ? 'P': 'p';
2714 dst = convertNormalToHexString (dst, hexDigits, upperCase, rounding_mode);
2720 return static_cast<unsigned int>(dst - p);
2723 /* Does the hard work of outputting the correctly rounded hexadecimal
2724 form of a normal floating point number with the specified number of
2725 hexadecimal digits. If HEXDIGITS is zero the minimum number of
2726 digits necessary to print the value precisely is output. */
2728 APFloat::convertNormalToHexString(char *dst, unsigned int hexDigits,
2730 roundingMode rounding_mode) const
2732 unsigned int count, valueBits, shift, partsCount, outputDigits;
2733 const char *hexDigitChars;
2734 const integerPart *significand;
2739 *dst++ = upperCase ? 'X': 'x';
2742 hexDigitChars = upperCase ? hexDigitsUpper: hexDigitsLower;
2744 significand = significandParts();
2745 partsCount = partCount();
2747 /* +3 because the first digit only uses the single integer bit, so
2748 we have 3 virtual zero most-significant-bits. */
2749 valueBits = semantics->precision + 3;
2750 shift = integerPartWidth - valueBits % integerPartWidth;
2752 /* The natural number of digits required ignoring trailing
2753 insignificant zeroes. */
2754 outputDigits = (valueBits - significandLSB () + 3) / 4;
2756 /* hexDigits of zero means use the required number for the
2757 precision. Otherwise, see if we are truncating. If we are,
2758 find out if we need to round away from zero. */
2760 if (hexDigits < outputDigits) {
2761 /* We are dropping non-zero bits, so need to check how to round.
2762 "bits" is the number of dropped bits. */
2764 lostFraction fraction;
2766 bits = valueBits - hexDigits * 4;
2767 fraction = lostFractionThroughTruncation (significand, partsCount, bits);
2768 roundUp = roundAwayFromZero(rounding_mode, fraction, bits);
2770 outputDigits = hexDigits;
2773 /* Write the digits consecutively, and start writing in the location
2774 of the hexadecimal point. We move the most significant digit
2775 left and add the hexadecimal point later. */
2778 count = (valueBits + integerPartWidth - 1) / integerPartWidth;
2780 while (outputDigits && count) {
2783 /* Put the most significant integerPartWidth bits in "part". */
2784 if (--count == partsCount)
2785 part = 0; /* An imaginary higher zero part. */
2787 part = significand[count] << shift;
2790 part |= significand[count - 1] >> (integerPartWidth - shift);
2792 /* Convert as much of "part" to hexdigits as we can. */
2793 unsigned int curDigits = integerPartWidth / 4;
2795 if (curDigits > outputDigits)
2796 curDigits = outputDigits;
2797 dst += partAsHex (dst, part, curDigits, hexDigitChars);
2798 outputDigits -= curDigits;
2804 /* Note that hexDigitChars has a trailing '0'. */
2807 *q = hexDigitChars[hexDigitValue (*q) + 1];
2808 } while (*q == '0');
2811 /* Add trailing zeroes. */
2812 memset (dst, '0', outputDigits);
2813 dst += outputDigits;
2816 /* Move the most significant digit to before the point, and if there
2817 is something after the decimal point add it. This must come
2818 after rounding above. */
2825 /* Finally output the exponent. */
2826 *dst++ = upperCase ? 'P': 'p';
2828 return writeSignedDecimal (dst, exponent);
2831 hash_code llvm::hash_value(const APFloat &Arg) {
2832 if (!Arg.isFiniteNonZero())
2833 return hash_combine((uint8_t)Arg.category,
2834 // NaN has no sign, fix it at zero.
2835 Arg.isNaN() ? (uint8_t)0 : (uint8_t)Arg.sign,
2836 Arg.semantics->precision);
2838 // Normal floats need their exponent and significand hashed.
2839 return hash_combine((uint8_t)Arg.category, (uint8_t)Arg.sign,
2840 Arg.semantics->precision, Arg.exponent,
2842 Arg.significandParts(),
2843 Arg.significandParts() + Arg.partCount()));
2846 // Conversion from APFloat to/from host float/double. It may eventually be
2847 // possible to eliminate these and have everybody deal with APFloats, but that
2848 // will take a while. This approach will not easily extend to long double.
2849 // Current implementation requires integerPartWidth==64, which is correct at
2850 // the moment but could be made more general.
2852 // Denormals have exponent minExponent in APFloat, but minExponent-1 in
2853 // the actual IEEE respresentations. We compensate for that here.
2856 APFloat::convertF80LongDoubleAPFloatToAPInt() const
2858 assert(semantics == (const llvm::fltSemantics*)&x87DoubleExtended);
2859 assert(partCount()==2);
2861 uint64_t myexponent, mysignificand;
2863 if (isFiniteNonZero()) {
2864 myexponent = exponent+16383; //bias
2865 mysignificand = significandParts()[0];
2866 if (myexponent==1 && !(mysignificand & 0x8000000000000000ULL))
2867 myexponent = 0; // denormal
2868 } else if (category==fcZero) {
2871 } else if (category==fcInfinity) {
2872 myexponent = 0x7fff;
2873 mysignificand = 0x8000000000000000ULL;
2875 assert(category == fcNaN && "Unknown category");
2876 myexponent = 0x7fff;
2877 mysignificand = significandParts()[0];
2881 words[0] = mysignificand;
2882 words[1] = ((uint64_t)(sign & 1) << 15) |
2883 (myexponent & 0x7fffLL);
2884 return APInt(80, words);
2888 APFloat::convertPPCDoubleDoubleAPFloatToAPInt() const
2890 assert(semantics == (const llvm::fltSemantics*)&PPCDoubleDouble);
2891 assert(partCount()==2);
2897 // Convert number to double. To avoid spurious underflows, we re-
2898 // normalize against the "double" minExponent first, and only *then*
2899 // truncate the mantissa. The result of that second conversion
2900 // may be inexact, but should never underflow.
2901 // Declare fltSemantics before APFloat that uses it (and
2902 // saves pointer to it) to ensure correct destruction order.
2903 fltSemantics extendedSemantics = *semantics;
2904 extendedSemantics.minExponent = IEEEdouble.minExponent;
2905 APFloat extended(*this);
2906 fs = extended.convert(extendedSemantics, rmNearestTiesToEven, &losesInfo);
2907 assert(fs == opOK && !losesInfo);
2910 APFloat u(extended);
2911 fs = u.convert(IEEEdouble, rmNearestTiesToEven, &losesInfo);
2912 assert(fs == opOK || fs == opInexact);
2914 words[0] = *u.convertDoubleAPFloatToAPInt().getRawData();
2916 // If conversion was exact or resulted in a special case, we're done;
2917 // just set the second double to zero. Otherwise, re-convert back to
2918 // the extended format and compute the difference. This now should
2919 // convert exactly to double.
2920 if (u.isFiniteNonZero() && losesInfo) {
2921 fs = u.convert(extendedSemantics, rmNearestTiesToEven, &losesInfo);
2922 assert(fs == opOK && !losesInfo);
2925 APFloat v(extended);
2926 v.subtract(u, rmNearestTiesToEven);
2927 fs = v.convert(IEEEdouble, rmNearestTiesToEven, &losesInfo);
2928 assert(fs == opOK && !losesInfo);
2930 words[1] = *v.convertDoubleAPFloatToAPInt().getRawData();
2935 return APInt(128, words);
2939 APFloat::convertQuadrupleAPFloatToAPInt() const
2941 assert(semantics == (const llvm::fltSemantics*)&IEEEquad);
2942 assert(partCount()==2);
2944 uint64_t myexponent, mysignificand, mysignificand2;
2946 if (isFiniteNonZero()) {
2947 myexponent = exponent+16383; //bias
2948 mysignificand = significandParts()[0];
2949 mysignificand2 = significandParts()[1];
2950 if (myexponent==1 && !(mysignificand2 & 0x1000000000000LL))
2951 myexponent = 0; // denormal
2952 } else if (category==fcZero) {
2954 mysignificand = mysignificand2 = 0;
2955 } else if (category==fcInfinity) {
2956 myexponent = 0x7fff;
2957 mysignificand = mysignificand2 = 0;
2959 assert(category == fcNaN && "Unknown category!");
2960 myexponent = 0x7fff;
2961 mysignificand = significandParts()[0];
2962 mysignificand2 = significandParts()[1];
2966 words[0] = mysignificand;
2967 words[1] = ((uint64_t)(sign & 1) << 63) |
2968 ((myexponent & 0x7fff) << 48) |
2969 (mysignificand2 & 0xffffffffffffLL);
2971 return APInt(128, words);
2975 APFloat::convertDoubleAPFloatToAPInt() const
2977 assert(semantics == (const llvm::fltSemantics*)&IEEEdouble);
2978 assert(partCount()==1);
2980 uint64_t myexponent, mysignificand;
2982 if (isFiniteNonZero()) {
2983 myexponent = exponent+1023; //bias
2984 mysignificand = *significandParts();
2985 if (myexponent==1 && !(mysignificand & 0x10000000000000LL))
2986 myexponent = 0; // denormal
2987 } else if (category==fcZero) {
2990 } else if (category==fcInfinity) {
2994 assert(category == fcNaN && "Unknown category!");
2996 mysignificand = *significandParts();
2999 return APInt(64, ((((uint64_t)(sign & 1) << 63) |
3000 ((myexponent & 0x7ff) << 52) |
3001 (mysignificand & 0xfffffffffffffLL))));
3005 APFloat::convertFloatAPFloatToAPInt() const
3007 assert(semantics == (const llvm::fltSemantics*)&IEEEsingle);
3008 assert(partCount()==1);
3010 uint32_t myexponent, mysignificand;
3012 if (isFiniteNonZero()) {
3013 myexponent = exponent+127; //bias
3014 mysignificand = (uint32_t)*significandParts();
3015 if (myexponent == 1 && !(mysignificand & 0x800000))
3016 myexponent = 0; // denormal
3017 } else if (category==fcZero) {
3020 } else if (category==fcInfinity) {
3024 assert(category == fcNaN && "Unknown category!");
3026 mysignificand = (uint32_t)*significandParts();
3029 return APInt(32, (((sign&1) << 31) | ((myexponent&0xff) << 23) |
3030 (mysignificand & 0x7fffff)));
3034 APFloat::convertHalfAPFloatToAPInt() const
3036 assert(semantics == (const llvm::fltSemantics*)&IEEEhalf);
3037 assert(partCount()==1);
3039 uint32_t myexponent, mysignificand;
3041 if (isFiniteNonZero()) {
3042 myexponent = exponent+15; //bias
3043 mysignificand = (uint32_t)*significandParts();
3044 if (myexponent == 1 && !(mysignificand & 0x400))
3045 myexponent = 0; // denormal
3046 } else if (category==fcZero) {
3049 } else if (category==fcInfinity) {
3053 assert(category == fcNaN && "Unknown category!");
3055 mysignificand = (uint32_t)*significandParts();
3058 return APInt(16, (((sign&1) << 15) | ((myexponent&0x1f) << 10) |
3059 (mysignificand & 0x3ff)));
3062 // This function creates an APInt that is just a bit map of the floating
3063 // point constant as it would appear in memory. It is not a conversion,
3064 // and treating the result as a normal integer is unlikely to be useful.
3067 APFloat::bitcastToAPInt() const
3069 if (semantics == (const llvm::fltSemantics*)&IEEEhalf)
3070 return convertHalfAPFloatToAPInt();
3072 if (semantics == (const llvm::fltSemantics*)&IEEEsingle)
3073 return convertFloatAPFloatToAPInt();
3075 if (semantics == (const llvm::fltSemantics*)&IEEEdouble)
3076 return convertDoubleAPFloatToAPInt();
3078 if (semantics == (const llvm::fltSemantics*)&IEEEquad)
3079 return convertQuadrupleAPFloatToAPInt();
3081 if (semantics == (const llvm::fltSemantics*)&PPCDoubleDouble)
3082 return convertPPCDoubleDoubleAPFloatToAPInt();
3084 assert(semantics == (const llvm::fltSemantics*)&x87DoubleExtended &&
3086 return convertF80LongDoubleAPFloatToAPInt();
3090 APFloat::convertToFloat() const
3092 assert(semantics == (const llvm::fltSemantics*)&IEEEsingle &&
3093 "Float semantics are not IEEEsingle");
3094 APInt api = bitcastToAPInt();
3095 return api.bitsToFloat();
3099 APFloat::convertToDouble() const
3101 assert(semantics == (const llvm::fltSemantics*)&IEEEdouble &&
3102 "Float semantics are not IEEEdouble");
3103 APInt api = bitcastToAPInt();
3104 return api.bitsToDouble();
3107 /// Integer bit is explicit in this format. Intel hardware (387 and later)
3108 /// does not support these bit patterns:
3109 /// exponent = all 1's, integer bit 0, significand 0 ("pseudoinfinity")
3110 /// exponent = all 1's, integer bit 0, significand nonzero ("pseudoNaN")
3111 /// exponent = 0, integer bit 1 ("pseudodenormal")
3112 /// exponent!=0 nor all 1's, integer bit 0 ("unnormal")
3113 /// At the moment, the first two are treated as NaNs, the second two as Normal.
3115 APFloat::initFromF80LongDoubleAPInt(const APInt &api)
3117 assert(api.getBitWidth()==80);
3118 uint64_t i1 = api.getRawData()[0];
3119 uint64_t i2 = api.getRawData()[1];
3120 uint64_t myexponent = (i2 & 0x7fff);
3121 uint64_t mysignificand = i1;
3123 initialize(&APFloat::x87DoubleExtended);
3124 assert(partCount()==2);
3126 sign = static_cast<unsigned int>(i2>>15);
3127 if (myexponent==0 && mysignificand==0) {
3128 // exponent, significand meaningless
3130 } else if (myexponent==0x7fff && mysignificand==0x8000000000000000ULL) {
3131 // exponent, significand meaningless
3132 category = fcInfinity;
3133 } else if (myexponent==0x7fff && mysignificand!=0x8000000000000000ULL) {
3134 // exponent meaningless
3136 significandParts()[0] = mysignificand;
3137 significandParts()[1] = 0;
3139 category = fcNormal;
3140 exponent = myexponent - 16383;
3141 significandParts()[0] = mysignificand;
3142 significandParts()[1] = 0;
3143 if (myexponent==0) // denormal
3149 APFloat::initFromPPCDoubleDoubleAPInt(const APInt &api)
3151 assert(api.getBitWidth()==128);
3152 uint64_t i1 = api.getRawData()[0];
3153 uint64_t i2 = api.getRawData()[1];
3157 // Get the first double and convert to our format.
3158 initFromDoubleAPInt(APInt(64, i1));
3159 fs = convert(PPCDoubleDouble, rmNearestTiesToEven, &losesInfo);
3160 assert(fs == opOK && !losesInfo);
3163 // Unless we have a special case, add in second double.
3164 if (isFiniteNonZero()) {
3165 APFloat v(IEEEdouble, APInt(64, i2));
3166 fs = v.convert(PPCDoubleDouble, rmNearestTiesToEven, &losesInfo);
3167 assert(fs == opOK && !losesInfo);
3170 add(v, rmNearestTiesToEven);
3175 APFloat::initFromQuadrupleAPInt(const APInt &api)
3177 assert(api.getBitWidth()==128);
3178 uint64_t i1 = api.getRawData()[0];
3179 uint64_t i2 = api.getRawData()[1];
3180 uint64_t myexponent = (i2 >> 48) & 0x7fff;
3181 uint64_t mysignificand = i1;
3182 uint64_t mysignificand2 = i2 & 0xffffffffffffLL;
3184 initialize(&APFloat::IEEEquad);
3185 assert(partCount()==2);
3187 sign = static_cast<unsigned int>(i2>>63);
3188 if (myexponent==0 &&
3189 (mysignificand==0 && mysignificand2==0)) {
3190 // exponent, significand meaningless
3192 } else if (myexponent==0x7fff &&
3193 (mysignificand==0 && mysignificand2==0)) {
3194 // exponent, significand meaningless
3195 category = fcInfinity;
3196 } else if (myexponent==0x7fff &&
3197 (mysignificand!=0 || mysignificand2 !=0)) {
3198 // exponent meaningless
3200 significandParts()[0] = mysignificand;
3201 significandParts()[1] = mysignificand2;
3203 category = fcNormal;
3204 exponent = myexponent - 16383;
3205 significandParts()[0] = mysignificand;
3206 significandParts()[1] = mysignificand2;
3207 if (myexponent==0) // denormal
3210 significandParts()[1] |= 0x1000000000000LL; // integer bit
3215 APFloat::initFromDoubleAPInt(const APInt &api)
3217 assert(api.getBitWidth()==64);
3218 uint64_t i = *api.getRawData();
3219 uint64_t myexponent = (i >> 52) & 0x7ff;
3220 uint64_t mysignificand = i & 0xfffffffffffffLL;
3222 initialize(&APFloat::IEEEdouble);
3223 assert(partCount()==1);
3225 sign = static_cast<unsigned int>(i>>63);
3226 if (myexponent==0 && mysignificand==0) {
3227 // exponent, significand meaningless
3229 } else if (myexponent==0x7ff && mysignificand==0) {
3230 // exponent, significand meaningless
3231 category = fcInfinity;
3232 } else if (myexponent==0x7ff && mysignificand!=0) {
3233 // exponent meaningless
3235 *significandParts() = mysignificand;
3237 category = fcNormal;
3238 exponent = myexponent - 1023;
3239 *significandParts() = mysignificand;
3240 if (myexponent==0) // denormal
3243 *significandParts() |= 0x10000000000000LL; // integer bit
3248 APFloat::initFromFloatAPInt(const APInt & api)
3250 assert(api.getBitWidth()==32);
3251 uint32_t i = (uint32_t)*api.getRawData();
3252 uint32_t myexponent = (i >> 23) & 0xff;
3253 uint32_t mysignificand = i & 0x7fffff;
3255 initialize(&APFloat::IEEEsingle);
3256 assert(partCount()==1);
3259 if (myexponent==0 && mysignificand==0) {
3260 // exponent, significand meaningless
3262 } else if (myexponent==0xff && mysignificand==0) {
3263 // exponent, significand meaningless
3264 category = fcInfinity;
3265 } else if (myexponent==0xff && mysignificand!=0) {
3266 // sign, exponent, significand meaningless
3268 *significandParts() = mysignificand;
3270 category = fcNormal;
3271 exponent = myexponent - 127; //bias
3272 *significandParts() = mysignificand;
3273 if (myexponent==0) // denormal
3276 *significandParts() |= 0x800000; // integer bit
3281 APFloat::initFromHalfAPInt(const APInt & api)
3283 assert(api.getBitWidth()==16);
3284 uint32_t i = (uint32_t)*api.getRawData();
3285 uint32_t myexponent = (i >> 10) & 0x1f;
3286 uint32_t mysignificand = i & 0x3ff;
3288 initialize(&APFloat::IEEEhalf);
3289 assert(partCount()==1);
3292 if (myexponent==0 && mysignificand==0) {
3293 // exponent, significand meaningless
3295 } else if (myexponent==0x1f && mysignificand==0) {
3296 // exponent, significand meaningless
3297 category = fcInfinity;
3298 } else if (myexponent==0x1f && mysignificand!=0) {
3299 // sign, exponent, significand meaningless
3301 *significandParts() = mysignificand;
3303 category = fcNormal;
3304 exponent = myexponent - 15; //bias
3305 *significandParts() = mysignificand;
3306 if (myexponent==0) // denormal
3309 *significandParts() |= 0x400; // integer bit
3313 /// Treat api as containing the bits of a floating point number. Currently
3314 /// we infer the floating point type from the size of the APInt. The
3315 /// isIEEE argument distinguishes between PPC128 and IEEE128 (not meaningful
3316 /// when the size is anything else).
3318 APFloat::initFromAPInt(const fltSemantics* Sem, const APInt& api)
3320 if (Sem == &IEEEhalf)
3321 return initFromHalfAPInt(api);
3322 if (Sem == &IEEEsingle)
3323 return initFromFloatAPInt(api);
3324 if (Sem == &IEEEdouble)
3325 return initFromDoubleAPInt(api);
3326 if (Sem == &x87DoubleExtended)
3327 return initFromF80LongDoubleAPInt(api);
3328 if (Sem == &IEEEquad)
3329 return initFromQuadrupleAPInt(api);
3330 if (Sem == &PPCDoubleDouble)
3331 return initFromPPCDoubleDoubleAPInt(api);
3333 llvm_unreachable(nullptr);
3337 APFloat::getAllOnesValue(unsigned BitWidth, bool isIEEE)
3341 return APFloat(IEEEhalf, APInt::getAllOnesValue(BitWidth));
3343 return APFloat(IEEEsingle, APInt::getAllOnesValue(BitWidth));
3345 return APFloat(IEEEdouble, APInt::getAllOnesValue(BitWidth));
3347 return APFloat(x87DoubleExtended, APInt::getAllOnesValue(BitWidth));
3350 return APFloat(IEEEquad, APInt::getAllOnesValue(BitWidth));
3351 return APFloat(PPCDoubleDouble, APInt::getAllOnesValue(BitWidth));
3353 llvm_unreachable("Unknown floating bit width");
3357 /// Make this number the largest magnitude normal number in the given
3359 void APFloat::makeLargest(bool Negative) {
3360 // We want (in interchange format):
3361 // sign = {Negative}
3363 // significand = 1..1
3364 category = fcNormal;
3366 exponent = semantics->maxExponent;
3368 // Use memset to set all but the highest integerPart to all ones.
3369 integerPart *significand = significandParts();
3370 unsigned PartCount = partCount();
3371 memset(significand, 0xFF, sizeof(integerPart)*(PartCount - 1));
3373 // Set the high integerPart especially setting all unused top bits for
3374 // internal consistency.
3375 const unsigned NumUnusedHighBits =
3376 PartCount*integerPartWidth - semantics->precision;
3377 significand[PartCount - 1] = ~integerPart(0) >> NumUnusedHighBits;
3380 /// Make this number the smallest magnitude denormal number in the given
3382 void APFloat::makeSmallest(bool Negative) {
3383 // We want (in interchange format):
3384 // sign = {Negative}
3386 // significand = 0..01
3387 category = fcNormal;
3389 exponent = semantics->minExponent;
3390 APInt::tcSet(significandParts(), 1, partCount());
3394 APFloat APFloat::getLargest(const fltSemantics &Sem, bool Negative) {
3395 // We want (in interchange format):
3396 // sign = {Negative}
3398 // significand = 1..1
3399 APFloat Val(Sem, uninitialized);
3400 Val.makeLargest(Negative);
3404 APFloat APFloat::getSmallest(const fltSemantics &Sem, bool Negative) {
3405 // We want (in interchange format):
3406 // sign = {Negative}
3408 // significand = 0..01
3409 APFloat Val(Sem, uninitialized);
3410 Val.makeSmallest(Negative);
3414 APFloat APFloat::getSmallestNormalized(const fltSemantics &Sem, bool Negative) {
3415 APFloat Val(Sem, uninitialized);
3417 // We want (in interchange format):
3418 // sign = {Negative}
3420 // significand = 10..0
3422 Val.category = fcNormal;
3423 Val.zeroSignificand();
3424 Val.sign = Negative;
3425 Val.exponent = Sem.minExponent;
3426 Val.significandParts()[partCountForBits(Sem.precision)-1] |=
3427 (((integerPart) 1) << ((Sem.precision - 1) % integerPartWidth));
3432 APFloat::APFloat(const fltSemantics &Sem, const APInt &API) {
3433 initFromAPInt(&Sem, API);
3436 APFloat::APFloat(float f) {
3437 initFromAPInt(&IEEEsingle, APInt::floatToBits(f));
3440 APFloat::APFloat(double d) {
3441 initFromAPInt(&IEEEdouble, APInt::doubleToBits(d));
3445 void append(SmallVectorImpl<char> &Buffer, StringRef Str) {
3446 Buffer.append(Str.begin(), Str.end());
3449 /// Removes data from the given significand until it is no more
3450 /// precise than is required for the desired precision.
3451 void AdjustToPrecision(APInt &significand,
3452 int &exp, unsigned FormatPrecision) {
3453 unsigned bits = significand.getActiveBits();
3455 // 196/59 is a very slight overestimate of lg_2(10).
3456 unsigned bitsRequired = (FormatPrecision * 196 + 58) / 59;
3458 if (bits <= bitsRequired) return;
3460 unsigned tensRemovable = (bits - bitsRequired) * 59 / 196;
3461 if (!tensRemovable) return;
3463 exp += tensRemovable;
3465 APInt divisor(significand.getBitWidth(), 1);
3466 APInt powten(significand.getBitWidth(), 10);
3468 if (tensRemovable & 1)
3470 tensRemovable >>= 1;
3471 if (!tensRemovable) break;
3475 significand = significand.udiv(divisor);
3477 // Truncate the significand down to its active bit count.
3478 significand = significand.trunc(significand.getActiveBits());
3482 void AdjustToPrecision(SmallVectorImpl<char> &buffer,
3483 int &exp, unsigned FormatPrecision) {
3484 unsigned N = buffer.size();
3485 if (N <= FormatPrecision) return;
3487 // The most significant figures are the last ones in the buffer.
3488 unsigned FirstSignificant = N - FormatPrecision;
3491 // FIXME: this probably shouldn't use 'round half up'.
3493 // Rounding down is just a truncation, except we also want to drop
3494 // trailing zeros from the new result.
3495 if (buffer[FirstSignificant - 1] < '5') {
3496 while (FirstSignificant < N && buffer[FirstSignificant] == '0')
3499 exp += FirstSignificant;
3500 buffer.erase(&buffer[0], &buffer[FirstSignificant]);
3504 // Rounding up requires a decimal add-with-carry. If we continue
3505 // the carry, the newly-introduced zeros will just be truncated.
3506 for (unsigned I = FirstSignificant; I != N; ++I) {
3507 if (buffer[I] == '9') {
3515 // If we carried through, we have exactly one digit of precision.
3516 if (FirstSignificant == N) {
3517 exp += FirstSignificant;
3519 buffer.push_back('1');
3523 exp += FirstSignificant;
3524 buffer.erase(&buffer[0], &buffer[FirstSignificant]);
3528 void APFloat::toString(SmallVectorImpl<char> &Str,
3529 unsigned FormatPrecision,
3530 unsigned FormatMaxPadding) const {
3534 return append(Str, "-Inf");
3536 return append(Str, "+Inf");
3538 case fcNaN: return append(Str, "NaN");
3544 if (!FormatMaxPadding)
3545 append(Str, "0.0E+0");
3557 // Decompose the number into an APInt and an exponent.
3558 int exp = exponent - ((int) semantics->precision - 1);
3559 APInt significand(semantics->precision,
3560 makeArrayRef(significandParts(),
3561 partCountForBits(semantics->precision)));
3563 // Set FormatPrecision if zero. We want to do this before we
3564 // truncate trailing zeros, as those are part of the precision.
3565 if (!FormatPrecision) {
3566 // We use enough digits so the number can be round-tripped back to an
3567 // APFloat. The formula comes from "How to Print Floating-Point Numbers
3568 // Accurately" by Steele and White.
3569 // FIXME: Using a formula based purely on the precision is conservative;
3570 // we can print fewer digits depending on the actual value being printed.
3572 // FormatPrecision = 2 + floor(significandBits / lg_2(10))
3573 FormatPrecision = 2 + semantics->precision * 59 / 196;
3576 // Ignore trailing binary zeros.
3577 int trailingZeros = significand.countTrailingZeros();
3578 exp += trailingZeros;
3579 significand = significand.lshr(trailingZeros);
3581 // Change the exponent from 2^e to 10^e.
3584 } else if (exp > 0) {
3586 significand = significand.zext(semantics->precision + exp);
3587 significand <<= exp;
3589 } else { /* exp < 0 */
3592 // We transform this using the identity:
3593 // (N)(2^-e) == (N)(5^e)(10^-e)
3594 // This means we have to multiply N (the significand) by 5^e.
3595 // To avoid overflow, we have to operate on numbers large
3596 // enough to store N * 5^e:
3597 // log2(N * 5^e) == log2(N) + e * log2(5)
3598 // <= semantics->precision + e * 137 / 59
3599 // (log_2(5) ~ 2.321928 < 2.322034 ~ 137/59)
3601 unsigned precision = semantics->precision + (137 * texp + 136) / 59;
3603 // Multiply significand by 5^e.
3604 // N * 5^0101 == N * 5^(1*1) * 5^(0*2) * 5^(1*4) * 5^(0*8)
3605 significand = significand.zext(precision);
3606 APInt five_to_the_i(precision, 5);
3608 if (texp & 1) significand *= five_to_the_i;
3612 five_to_the_i *= five_to_the_i;
3616 AdjustToPrecision(significand, exp, FormatPrecision);
3618 SmallVector<char, 256> buffer;
3621 unsigned precision = significand.getBitWidth();
3622 APInt ten(precision, 10);
3623 APInt digit(precision, 0);
3625 bool inTrail = true;
3626 while (significand != 0) {
3627 // digit <- significand % 10
3628 // significand <- significand / 10
3629 APInt::udivrem(significand, ten, significand, digit);
3631 unsigned d = digit.getZExtValue();
3633 // Drop trailing zeros.
3634 if (inTrail && !d) exp++;
3636 buffer.push_back((char) ('0' + d));
3641 assert(!buffer.empty() && "no characters in buffer!");
3643 // Drop down to FormatPrecision.
3644 // TODO: don't do more precise calculations above than are required.
3645 AdjustToPrecision(buffer, exp, FormatPrecision);
3647 unsigned NDigits = buffer.size();
3649 // Check whether we should use scientific notation.
3650 bool FormatScientific;
3651 if (!FormatMaxPadding)
3652 FormatScientific = true;
3657 // But we shouldn't make the number look more precise than it is.
3658 FormatScientific = ((unsigned) exp > FormatMaxPadding ||
3659 NDigits + (unsigned) exp > FormatPrecision);
3661 // Power of the most significant digit.
3662 int MSD = exp + (int) (NDigits - 1);
3665 FormatScientific = false;
3667 // 765e-5 == 0.00765
3669 FormatScientific = ((unsigned) -MSD) > FormatMaxPadding;
3674 // Scientific formatting is pretty straightforward.
3675 if (FormatScientific) {
3676 exp += (NDigits - 1);
3678 Str.push_back(buffer[NDigits-1]);
3683 for (unsigned I = 1; I != NDigits; ++I)
3684 Str.push_back(buffer[NDigits-1-I]);
3687 Str.push_back(exp >= 0 ? '+' : '-');
3688 if (exp < 0) exp = -exp;
3689 SmallVector<char, 6> expbuf;
3691 expbuf.push_back((char) ('0' + (exp % 10)));
3694 for (unsigned I = 0, E = expbuf.size(); I != E; ++I)
3695 Str.push_back(expbuf[E-1-I]);
3699 // Non-scientific, positive exponents.
3701 for (unsigned I = 0; I != NDigits; ++I)
3702 Str.push_back(buffer[NDigits-1-I]);
3703 for (unsigned I = 0; I != (unsigned) exp; ++I)
3708 // Non-scientific, negative exponents.
3710 // The number of digits to the left of the decimal point.
3711 int NWholeDigits = exp + (int) NDigits;
3714 if (NWholeDigits > 0) {
3715 for (; I != (unsigned) NWholeDigits; ++I)
3716 Str.push_back(buffer[NDigits-I-1]);
3719 unsigned NZeros = 1 + (unsigned) -NWholeDigits;
3723 for (unsigned Z = 1; Z != NZeros; ++Z)
3727 for (; I != NDigits; ++I)
3728 Str.push_back(buffer[NDigits-I-1]);
3731 bool APFloat::getExactInverse(APFloat *inv) const {
3732 // Special floats and denormals have no exact inverse.
3733 if (!isFiniteNonZero())
3736 // Check that the number is a power of two by making sure that only the
3737 // integer bit is set in the significand.
3738 if (significandLSB() != semantics->precision - 1)
3742 APFloat reciprocal(*semantics, 1ULL);
3743 if (reciprocal.divide(*this, rmNearestTiesToEven) != opOK)
3746 // Avoid multiplication with a denormal, it is not safe on all platforms and
3747 // may be slower than a normal division.
3748 if (reciprocal.isDenormal())
3751 assert(reciprocal.isFiniteNonZero() &&
3752 reciprocal.significandLSB() == reciprocal.semantics->precision - 1);
3760 bool APFloat::isSignaling() const {
3764 // IEEE-754R 2008 6.2.1: A signaling NaN bit string should be encoded with the
3765 // first bit of the trailing significand being 0.
3766 return !APInt::tcExtractBit(significandParts(), semantics->precision - 2);
3769 /// IEEE-754R 2008 5.3.1: nextUp/nextDown.
3771 /// *NOTE* since nextDown(x) = -nextUp(-x), we only implement nextUp with
3772 /// appropriate sign switching before/after the computation.
3773 APFloat::opStatus APFloat::next(bool nextDown) {
3774 // If we are performing nextDown, swap sign so we have -x.
3778 // Compute nextUp(x)
3779 opStatus result = opOK;
3781 // Handle each float category separately.
3784 // nextUp(+inf) = +inf
3787 // nextUp(-inf) = -getLargest()
3791 // IEEE-754R 2008 6.2 Par 2: nextUp(sNaN) = qNaN. Set Invalid flag.
3792 // IEEE-754R 2008 6.2: nextUp(qNaN) = qNaN. Must be identity so we do not
3793 // change the payload.
3794 if (isSignaling()) {
3795 result = opInvalidOp;
3796 // For consistency, propagate the sign of the sNaN to the qNaN.
3797 makeNaN(false, isNegative(), nullptr);
3801 // nextUp(pm 0) = +getSmallest()
3802 makeSmallest(false);
3805 // nextUp(-getSmallest()) = -0
3806 if (isSmallest() && isNegative()) {
3807 APInt::tcSet(significandParts(), 0, partCount());
3813 // nextUp(getLargest()) == INFINITY
3814 if (isLargest() && !isNegative()) {
3815 APInt::tcSet(significandParts(), 0, partCount());
3816 category = fcInfinity;
3817 exponent = semantics->maxExponent + 1;
3821 // nextUp(normal) == normal + inc.
3823 // If we are negative, we need to decrement the significand.
3825 // We only cross a binade boundary that requires adjusting the exponent
3827 // 1. exponent != semantics->minExponent. This implies we are not in the
3828 // smallest binade or are dealing with denormals.
3829 // 2. Our significand excluding the integral bit is all zeros.
3830 bool WillCrossBinadeBoundary =
3831 exponent != semantics->minExponent && isSignificandAllZeros();
3833 // Decrement the significand.
3835 // We always do this since:
3836 // 1. If we are dealing with a non-binade decrement, by definition we
3837 // just decrement the significand.
3838 // 2. If we are dealing with a normal -> normal binade decrement, since
3839 // we have an explicit integral bit the fact that all bits but the
3840 // integral bit are zero implies that subtracting one will yield a
3841 // significand with 0 integral bit and 1 in all other spots. Thus we
3842 // must just adjust the exponent and set the integral bit to 1.
3843 // 3. If we are dealing with a normal -> denormal binade decrement,
3844 // since we set the integral bit to 0 when we represent denormals, we
3845 // just decrement the significand.
3846 integerPart *Parts = significandParts();
3847 APInt::tcDecrement(Parts, partCount());
3849 if (WillCrossBinadeBoundary) {
3850 // Our result is a normal number. Do the following:
3851 // 1. Set the integral bit to 1.
3852 // 2. Decrement the exponent.
3853 APInt::tcSetBit(Parts, semantics->precision - 1);
3857 // If we are positive, we need to increment the significand.
3859 // We only cross a binade boundary that requires adjusting the exponent if
3860 // the input is not a denormal and all of said input's significand bits
3861 // are set. If all of said conditions are true: clear the significand, set
3862 // the integral bit to 1, and increment the exponent. If we have a
3863 // denormal always increment since moving denormals and the numbers in the
3864 // smallest normal binade have the same exponent in our representation.
3865 bool WillCrossBinadeBoundary = !isDenormal() && isSignificandAllOnes();
3867 if (WillCrossBinadeBoundary) {
3868 integerPart *Parts = significandParts();
3869 APInt::tcSet(Parts, 0, partCount());
3870 APInt::tcSetBit(Parts, semantics->precision - 1);
3871 assert(exponent != semantics->maxExponent &&
3872 "We can not increment an exponent beyond the maxExponent allowed"
3873 " by the given floating point semantics.");
3876 incrementSignificand();
3882 // If we are performing nextDown, swap sign so we have -nextUp(-x)
3890 APFloat::makeInf(bool Negative) {
3891 category = fcInfinity;
3893 exponent = semantics->maxExponent + 1;
3894 APInt::tcSet(significandParts(), 0, partCount());
3898 APFloat::makeZero(bool Negative) {
3901 exponent = semantics->minExponent-1;
3902 APInt::tcSet(significandParts(), 0, partCount());