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. */
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::isDenormal() const {
688 return isFiniteNonZero() && (exponent == semantics->minExponent) &&
689 (APInt::tcExtractBit(significandParts(),
690 semantics->precision - 1) == 0);
694 APFloat::isSmallest() const {
695 // The smallest number by magnitude in our format will be the smallest
696 // denormal, i.e. the floating point number with exponent being minimum
697 // exponent and significand bitwise equal to 1 (i.e. with MSB equal to 0).
698 return isFiniteNonZero() && exponent == semantics->minExponent &&
699 significandMSB() == 0;
702 bool APFloat::isSignificandAllOnes() const {
703 // Test if the significand excluding the integral bit is all ones. This allows
704 // us to test for binade boundaries.
705 const integerPart *Parts = significandParts();
706 const unsigned PartCount = partCount();
707 for (unsigned i = 0; i < PartCount - 1; i++)
711 // Set the unused high bits to all ones when we compare.
712 const unsigned NumHighBits =
713 PartCount*integerPartWidth - semantics->precision + 1;
714 assert(NumHighBits <= integerPartWidth && "Can not have more high bits to "
715 "fill than integerPartWidth");
716 const integerPart HighBitFill =
717 ~integerPart(0) << (integerPartWidth - NumHighBits);
718 if (~(Parts[PartCount - 1] | HighBitFill))
724 bool APFloat::isSignificandAllZeros() const {
725 // Test if the significand excluding the integral bit is all zeros. This
726 // allows us to test for binade boundaries.
727 const integerPart *Parts = significandParts();
728 const unsigned PartCount = partCount();
730 for (unsigned i = 0; i < PartCount - 1; i++)
734 const unsigned NumHighBits =
735 PartCount*integerPartWidth - semantics->precision + 1;
736 assert(NumHighBits <= integerPartWidth && "Can not have more high bits to "
737 "clear than integerPartWidth");
738 const integerPart HighBitMask = ~integerPart(0) >> NumHighBits;
740 if (Parts[PartCount - 1] & HighBitMask)
747 APFloat::isLargest() const {
748 // The largest number by magnitude in our format will be the floating point
749 // number with maximum exponent and with significand that is all ones.
750 return isFiniteNonZero() && exponent == semantics->maxExponent
751 && isSignificandAllOnes();
755 APFloat::bitwiseIsEqual(const APFloat &rhs) const {
758 if (semantics != rhs.semantics ||
759 category != rhs.category ||
762 if (category==fcZero || category==fcInfinity)
764 else if (isFiniteNonZero() && exponent!=rhs.exponent)
768 const integerPart* p=significandParts();
769 const integerPart* q=rhs.significandParts();
770 for (; i>0; i--, p++, q++) {
778 APFloat::APFloat(const fltSemantics &ourSemantics, integerPart value) {
779 initialize(&ourSemantics);
782 exponent = ourSemantics.precision - 1;
783 significandParts()[0] = value;
784 normalize(rmNearestTiesToEven, lfExactlyZero);
787 APFloat::APFloat(const fltSemantics &ourSemantics) {
788 initialize(&ourSemantics);
793 APFloat::APFloat(const fltSemantics &ourSemantics, uninitializedTag tag) {
794 // Allocates storage if necessary but does not initialize it.
795 initialize(&ourSemantics);
798 APFloat::APFloat(const fltSemantics &ourSemantics, StringRef text) {
799 initialize(&ourSemantics);
800 convertFromString(text, rmNearestTiesToEven);
803 APFloat::APFloat(const APFloat &rhs) {
804 initialize(rhs.semantics);
813 // Profile - This method 'profiles' an APFloat for use with FoldingSet.
814 void APFloat::Profile(FoldingSetNodeID& ID) const {
815 ID.Add(bitcastToAPInt());
819 APFloat::partCount() const
821 return partCountForBits(semantics->precision + 1);
825 APFloat::semanticsPrecision(const fltSemantics &semantics)
827 return semantics.precision;
831 APFloat::significandParts() const
833 return const_cast<APFloat *>(this)->significandParts();
837 APFloat::significandParts()
840 return significand.parts;
842 return &significand.part;
846 APFloat::zeroSignificand()
849 APInt::tcSet(significandParts(), 0, partCount());
852 /* Increment an fcNormal floating point number's significand. */
854 APFloat::incrementSignificand()
858 carry = APInt::tcIncrement(significandParts(), partCount());
860 /* Our callers should never cause us to overflow. */
865 /* Add the significand of the RHS. Returns the carry flag. */
867 APFloat::addSignificand(const APFloat &rhs)
871 parts = significandParts();
873 assert(semantics == rhs.semantics);
874 assert(exponent == rhs.exponent);
876 return APInt::tcAdd(parts, rhs.significandParts(), 0, partCount());
879 /* Subtract the significand of the RHS with a borrow flag. Returns
882 APFloat::subtractSignificand(const APFloat &rhs, integerPart borrow)
886 parts = significandParts();
888 assert(semantics == rhs.semantics);
889 assert(exponent == rhs.exponent);
891 return APInt::tcSubtract(parts, rhs.significandParts(), borrow,
895 /* Multiply the significand of the RHS. If ADDEND is non-NULL, add it
896 on to the full-precision result of the multiplication. Returns the
899 APFloat::multiplySignificand(const APFloat &rhs, const APFloat *addend)
901 unsigned int omsb; // One, not zero, based MSB.
902 unsigned int partsCount, newPartsCount, precision;
903 integerPart *lhsSignificand;
904 integerPart scratch[4];
905 integerPart *fullSignificand;
906 lostFraction lost_fraction;
909 assert(semantics == rhs.semantics);
911 precision = semantics->precision;
912 newPartsCount = partCountForBits(precision * 2);
914 if (newPartsCount > 4)
915 fullSignificand = new integerPart[newPartsCount];
917 fullSignificand = scratch;
919 lhsSignificand = significandParts();
920 partsCount = partCount();
922 APInt::tcFullMultiply(fullSignificand, lhsSignificand,
923 rhs.significandParts(), partsCount, partsCount);
925 lost_fraction = lfExactlyZero;
926 omsb = APInt::tcMSB(fullSignificand, newPartsCount) + 1;
927 exponent += rhs.exponent;
929 // Assume the operands involved in the multiplication are single-precision
930 // FP, and the two multiplicants are:
931 // *this = a23 . a22 ... a0 * 2^e1
932 // rhs = b23 . b22 ... b0 * 2^e2
933 // the result of multiplication is:
934 // *this = c47 c46 . c45 ... c0 * 2^(e1+e2)
935 // Note that there are two significant bits at the left-hand side of the
936 // radix point. Move the radix point toward left by one bit, and adjust
937 // exponent accordingly.
941 // The intermediate result of the multiplication has "2 * precision"
942 // signicant bit; adjust the addend to be consistent with mul result.
944 Significand savedSignificand = significand;
945 const fltSemantics *savedSemantics = semantics;
946 fltSemantics extendedSemantics;
948 unsigned int extendedPrecision;
950 /* Normalize our MSB. */
951 extendedPrecision = 2 * precision;
952 if (omsb != extendedPrecision) {
953 assert(extendedPrecision > omsb);
954 APInt::tcShiftLeft(fullSignificand, newPartsCount,
955 extendedPrecision - omsb);
956 exponent -= extendedPrecision - omsb;
959 /* Create new semantics. */
960 extendedSemantics = *semantics;
961 extendedSemantics.precision = extendedPrecision;
963 if (newPartsCount == 1)
964 significand.part = fullSignificand[0];
966 significand.parts = fullSignificand;
967 semantics = &extendedSemantics;
969 APFloat extendedAddend(*addend);
970 status = extendedAddend.convert(extendedSemantics, rmTowardZero, &ignored);
971 assert(status == opOK);
973 lost_fraction = addOrSubtractSignificand(extendedAddend, false);
975 /* Restore our state. */
976 if (newPartsCount == 1)
977 fullSignificand[0] = significand.part;
978 significand = savedSignificand;
979 semantics = savedSemantics;
981 omsb = APInt::tcMSB(fullSignificand, newPartsCount) + 1;
984 // Convert the result having "2 * precision" significant-bits back to the one
985 // having "precision" significant-bits. First, move the radix point from
986 // poision "2*precision - 1" to "precision - 1". The exponent need to be
987 // adjusted by "2*precision - 1" - "precision - 1" = "precision".
988 exponent -= precision;
990 // In case MSB resides at the left-hand side of radix point, shift the
991 // mantissa right by some amount to make sure the MSB reside right before
992 // the radix point (i.e. "MSB . rest-significant-bits").
994 // Note that the result is not normalized when "omsb < precision". So, the
995 // caller needs to call APFloat::normalize() if normalized value is expected.
996 if (omsb > precision) {
997 unsigned int bits, significantParts;
1000 bits = omsb - precision;
1001 significantParts = partCountForBits(omsb);
1002 lf = shiftRight(fullSignificand, significantParts, bits);
1003 lost_fraction = combineLostFractions(lf, lost_fraction);
1007 APInt::tcAssign(lhsSignificand, fullSignificand, partsCount);
1009 if (newPartsCount > 4)
1010 delete [] fullSignificand;
1012 return lost_fraction;
1015 /* Multiply the significands of LHS and RHS to DST. */
1017 APFloat::divideSignificand(const APFloat &rhs)
1019 unsigned int bit, i, partsCount;
1020 const integerPart *rhsSignificand;
1021 integerPart *lhsSignificand, *dividend, *divisor;
1022 integerPart scratch[4];
1023 lostFraction lost_fraction;
1025 assert(semantics == rhs.semantics);
1027 lhsSignificand = significandParts();
1028 rhsSignificand = rhs.significandParts();
1029 partsCount = partCount();
1032 dividend = new integerPart[partsCount * 2];
1036 divisor = dividend + partsCount;
1038 /* Copy the dividend and divisor as they will be modified in-place. */
1039 for (i = 0; i < partsCount; i++) {
1040 dividend[i] = lhsSignificand[i];
1041 divisor[i] = rhsSignificand[i];
1042 lhsSignificand[i] = 0;
1045 exponent -= rhs.exponent;
1047 unsigned int precision = semantics->precision;
1049 /* Normalize the divisor. */
1050 bit = precision - APInt::tcMSB(divisor, partsCount) - 1;
1053 APInt::tcShiftLeft(divisor, partsCount, bit);
1056 /* Normalize the dividend. */
1057 bit = precision - APInt::tcMSB(dividend, partsCount) - 1;
1060 APInt::tcShiftLeft(dividend, partsCount, bit);
1063 /* Ensure the dividend >= divisor initially for the loop below.
1064 Incidentally, this means that the division loop below is
1065 guaranteed to set the integer bit to one. */
1066 if (APInt::tcCompare(dividend, divisor, partsCount) < 0) {
1068 APInt::tcShiftLeft(dividend, partsCount, 1);
1069 assert(APInt::tcCompare(dividend, divisor, partsCount) >= 0);
1072 /* Long division. */
1073 for (bit = precision; bit; bit -= 1) {
1074 if (APInt::tcCompare(dividend, divisor, partsCount) >= 0) {
1075 APInt::tcSubtract(dividend, divisor, 0, partsCount);
1076 APInt::tcSetBit(lhsSignificand, bit - 1);
1079 APInt::tcShiftLeft(dividend, partsCount, 1);
1082 /* Figure out the lost fraction. */
1083 int cmp = APInt::tcCompare(dividend, divisor, partsCount);
1086 lost_fraction = lfMoreThanHalf;
1088 lost_fraction = lfExactlyHalf;
1089 else if (APInt::tcIsZero(dividend, partsCount))
1090 lost_fraction = lfExactlyZero;
1092 lost_fraction = lfLessThanHalf;
1097 return lost_fraction;
1101 APFloat::significandMSB() const
1103 return APInt::tcMSB(significandParts(), partCount());
1107 APFloat::significandLSB() const
1109 return APInt::tcLSB(significandParts(), partCount());
1112 /* Note that a zero result is NOT normalized to fcZero. */
1114 APFloat::shiftSignificandRight(unsigned int bits)
1116 /* Our exponent should not overflow. */
1117 assert((ExponentType) (exponent + bits) >= exponent);
1121 return shiftRight(significandParts(), partCount(), bits);
1124 /* Shift the significand left BITS bits, subtract BITS from its exponent. */
1126 APFloat::shiftSignificandLeft(unsigned int bits)
1128 assert(bits < semantics->precision);
1131 unsigned int partsCount = partCount();
1133 APInt::tcShiftLeft(significandParts(), partsCount, bits);
1136 assert(!APInt::tcIsZero(significandParts(), partsCount));
1141 APFloat::compareAbsoluteValue(const APFloat &rhs) const
1145 assert(semantics == rhs.semantics);
1146 assert(isFiniteNonZero());
1147 assert(rhs.isFiniteNonZero());
1149 compare = exponent - rhs.exponent;
1151 /* If exponents are equal, do an unsigned bignum comparison of the
1154 compare = APInt::tcCompare(significandParts(), rhs.significandParts(),
1158 return cmpGreaterThan;
1159 else if (compare < 0)
1165 /* Handle overflow. Sign is preserved. We either become infinity or
1166 the largest finite number. */
1168 APFloat::handleOverflow(roundingMode rounding_mode)
1171 if (rounding_mode == rmNearestTiesToEven ||
1172 rounding_mode == rmNearestTiesToAway ||
1173 (rounding_mode == rmTowardPositive && !sign) ||
1174 (rounding_mode == rmTowardNegative && sign)) {
1175 category = fcInfinity;
1176 return (opStatus) (opOverflow | opInexact);
1179 /* Otherwise we become the largest finite number. */
1180 category = fcNormal;
1181 exponent = semantics->maxExponent;
1182 APInt::tcSetLeastSignificantBits(significandParts(), partCount(),
1183 semantics->precision);
1188 /* Returns TRUE if, when truncating the current number, with BIT the
1189 new LSB, with the given lost fraction and rounding mode, the result
1190 would need to be rounded away from zero (i.e., by increasing the
1191 signficand). This routine must work for fcZero of both signs, and
1192 fcNormal numbers. */
1194 APFloat::roundAwayFromZero(roundingMode rounding_mode,
1195 lostFraction lost_fraction,
1196 unsigned int bit) const
1198 /* NaNs and infinities should not have lost fractions. */
1199 assert(isFiniteNonZero() || category == fcZero);
1201 /* Current callers never pass this so we don't handle it. */
1202 assert(lost_fraction != lfExactlyZero);
1204 switch (rounding_mode) {
1205 case rmNearestTiesToAway:
1206 return lost_fraction == lfExactlyHalf || lost_fraction == lfMoreThanHalf;
1208 case rmNearestTiesToEven:
1209 if (lost_fraction == lfMoreThanHalf)
1212 /* Our zeroes don't have a significand to test. */
1213 if (lost_fraction == lfExactlyHalf && category != fcZero)
1214 return APInt::tcExtractBit(significandParts(), bit);
1221 case rmTowardPositive:
1222 return sign == false;
1224 case rmTowardNegative:
1225 return sign == true;
1227 llvm_unreachable("Invalid rounding mode found");
1231 APFloat::normalize(roundingMode rounding_mode,
1232 lostFraction lost_fraction)
1234 unsigned int omsb; /* One, not zero, based MSB. */
1237 if (!isFiniteNonZero())
1240 /* Before rounding normalize the exponent of fcNormal numbers. */
1241 omsb = significandMSB() + 1;
1244 /* OMSB is numbered from 1. We want to place it in the integer
1245 bit numbered PRECISION if possible, with a compensating change in
1247 exponentChange = omsb - semantics->precision;
1249 /* If the resulting exponent is too high, overflow according to
1250 the rounding mode. */
1251 if (exponent + exponentChange > semantics->maxExponent)
1252 return handleOverflow(rounding_mode);
1254 /* Subnormal numbers have exponent minExponent, and their MSB
1255 is forced based on that. */
1256 if (exponent + exponentChange < semantics->minExponent)
1257 exponentChange = semantics->minExponent - exponent;
1259 /* Shifting left is easy as we don't lose precision. */
1260 if (exponentChange < 0) {
1261 assert(lost_fraction == lfExactlyZero);
1263 shiftSignificandLeft(-exponentChange);
1268 if (exponentChange > 0) {
1271 /* Shift right and capture any new lost fraction. */
1272 lf = shiftSignificandRight(exponentChange);
1274 lost_fraction = combineLostFractions(lf, lost_fraction);
1276 /* Keep OMSB up-to-date. */
1277 if (omsb > (unsigned) exponentChange)
1278 omsb -= exponentChange;
1284 /* Now round the number according to rounding_mode given the lost
1287 /* As specified in IEEE 754, since we do not trap we do not report
1288 underflow for exact results. */
1289 if (lost_fraction == lfExactlyZero) {
1290 /* Canonicalize zeroes. */
1297 /* Increment the significand if we're rounding away from zero. */
1298 if (roundAwayFromZero(rounding_mode, lost_fraction, 0)) {
1300 exponent = semantics->minExponent;
1302 incrementSignificand();
1303 omsb = significandMSB() + 1;
1305 /* Did the significand increment overflow? */
1306 if (omsb == (unsigned) semantics->precision + 1) {
1307 /* Renormalize by incrementing the exponent and shifting our
1308 significand right one. However if we already have the
1309 maximum exponent we overflow to infinity. */
1310 if (exponent == semantics->maxExponent) {
1311 category = fcInfinity;
1313 return (opStatus) (opOverflow | opInexact);
1316 shiftSignificandRight(1);
1322 /* The normal case - we were and are not denormal, and any
1323 significand increment above didn't overflow. */
1324 if (omsb == semantics->precision)
1327 /* We have a non-zero denormal. */
1328 assert(omsb < semantics->precision);
1330 /* Canonicalize zeroes. */
1334 /* The fcZero case is a denormal that underflowed to zero. */
1335 return (opStatus) (opUnderflow | opInexact);
1339 APFloat::addOrSubtractSpecials(const APFloat &rhs, bool subtract)
1341 switch (PackCategoriesIntoKey(category, rhs.category)) {
1343 llvm_unreachable(0);
1345 case PackCategoriesIntoKey(fcNaN, fcZero):
1346 case PackCategoriesIntoKey(fcNaN, fcNormal):
1347 case PackCategoriesIntoKey(fcNaN, fcInfinity):
1348 case PackCategoriesIntoKey(fcNaN, fcNaN):
1349 case PackCategoriesIntoKey(fcNormal, fcZero):
1350 case PackCategoriesIntoKey(fcInfinity, fcNormal):
1351 case PackCategoriesIntoKey(fcInfinity, fcZero):
1354 case PackCategoriesIntoKey(fcZero, fcNaN):
1355 case PackCategoriesIntoKey(fcNormal, fcNaN):
1356 case PackCategoriesIntoKey(fcInfinity, fcNaN):
1358 copySignificand(rhs);
1361 case PackCategoriesIntoKey(fcNormal, fcInfinity):
1362 case PackCategoriesIntoKey(fcZero, fcInfinity):
1363 category = fcInfinity;
1364 sign = rhs.sign ^ subtract;
1367 case PackCategoriesIntoKey(fcZero, fcNormal):
1369 sign = rhs.sign ^ subtract;
1372 case PackCategoriesIntoKey(fcZero, fcZero):
1373 /* Sign depends on rounding mode; handled by caller. */
1376 case PackCategoriesIntoKey(fcInfinity, fcInfinity):
1377 /* Differently signed infinities can only be validly
1379 if (((sign ^ rhs.sign)!=0) != subtract) {
1386 case PackCategoriesIntoKey(fcNormal, fcNormal):
1391 /* Add or subtract two normal numbers. */
1393 APFloat::addOrSubtractSignificand(const APFloat &rhs, bool subtract)
1396 lostFraction lost_fraction;
1399 /* Determine if the operation on the absolute values is effectively
1400 an addition or subtraction. */
1401 subtract ^= (sign ^ rhs.sign) ? true : false;
1403 /* Are we bigger exponent-wise than the RHS? */
1404 bits = exponent - rhs.exponent;
1406 /* Subtraction is more subtle than one might naively expect. */
1408 APFloat temp_rhs(rhs);
1412 reverse = compareAbsoluteValue(temp_rhs) == cmpLessThan;
1413 lost_fraction = lfExactlyZero;
1414 } else if (bits > 0) {
1415 lost_fraction = temp_rhs.shiftSignificandRight(bits - 1);
1416 shiftSignificandLeft(1);
1419 lost_fraction = shiftSignificandRight(-bits - 1);
1420 temp_rhs.shiftSignificandLeft(1);
1425 carry = temp_rhs.subtractSignificand
1426 (*this, lost_fraction != lfExactlyZero);
1427 copySignificand(temp_rhs);
1430 carry = subtractSignificand
1431 (temp_rhs, lost_fraction != lfExactlyZero);
1434 /* Invert the lost fraction - it was on the RHS and
1436 if (lost_fraction == lfLessThanHalf)
1437 lost_fraction = lfMoreThanHalf;
1438 else if (lost_fraction == lfMoreThanHalf)
1439 lost_fraction = lfLessThanHalf;
1441 /* The code above is intended to ensure that no borrow is
1447 APFloat temp_rhs(rhs);
1449 lost_fraction = temp_rhs.shiftSignificandRight(bits);
1450 carry = addSignificand(temp_rhs);
1452 lost_fraction = shiftSignificandRight(-bits);
1453 carry = addSignificand(rhs);
1456 /* We have a guard bit; generating a carry cannot happen. */
1461 return lost_fraction;
1465 APFloat::multiplySpecials(const APFloat &rhs)
1467 switch (PackCategoriesIntoKey(category, rhs.category)) {
1469 llvm_unreachable(0);
1471 case PackCategoriesIntoKey(fcNaN, fcZero):
1472 case PackCategoriesIntoKey(fcNaN, fcNormal):
1473 case PackCategoriesIntoKey(fcNaN, fcInfinity):
1474 case PackCategoriesIntoKey(fcNaN, fcNaN):
1477 case PackCategoriesIntoKey(fcZero, fcNaN):
1478 case PackCategoriesIntoKey(fcNormal, fcNaN):
1479 case PackCategoriesIntoKey(fcInfinity, fcNaN):
1481 copySignificand(rhs);
1484 case PackCategoriesIntoKey(fcNormal, fcInfinity):
1485 case PackCategoriesIntoKey(fcInfinity, fcNormal):
1486 case PackCategoriesIntoKey(fcInfinity, fcInfinity):
1487 category = fcInfinity;
1490 case PackCategoriesIntoKey(fcZero, fcNormal):
1491 case PackCategoriesIntoKey(fcNormal, fcZero):
1492 case PackCategoriesIntoKey(fcZero, fcZero):
1496 case PackCategoriesIntoKey(fcZero, fcInfinity):
1497 case PackCategoriesIntoKey(fcInfinity, fcZero):
1501 case PackCategoriesIntoKey(fcNormal, fcNormal):
1507 APFloat::divideSpecials(const APFloat &rhs)
1509 switch (PackCategoriesIntoKey(category, rhs.category)) {
1511 llvm_unreachable(0);
1513 case PackCategoriesIntoKey(fcNaN, fcZero):
1514 case PackCategoriesIntoKey(fcNaN, fcNormal):
1515 case PackCategoriesIntoKey(fcNaN, fcInfinity):
1516 case PackCategoriesIntoKey(fcNaN, fcNaN):
1517 case PackCategoriesIntoKey(fcInfinity, fcZero):
1518 case PackCategoriesIntoKey(fcInfinity, fcNormal):
1519 case PackCategoriesIntoKey(fcZero, fcInfinity):
1520 case PackCategoriesIntoKey(fcZero, fcNormal):
1523 case PackCategoriesIntoKey(fcZero, fcNaN):
1524 case PackCategoriesIntoKey(fcNormal, fcNaN):
1525 case PackCategoriesIntoKey(fcInfinity, fcNaN):
1527 copySignificand(rhs);
1530 case PackCategoriesIntoKey(fcNormal, fcInfinity):
1534 case PackCategoriesIntoKey(fcNormal, fcZero):
1535 category = fcInfinity;
1538 case PackCategoriesIntoKey(fcInfinity, fcInfinity):
1539 case PackCategoriesIntoKey(fcZero, fcZero):
1543 case PackCategoriesIntoKey(fcNormal, fcNormal):
1549 APFloat::modSpecials(const APFloat &rhs)
1551 switch (PackCategoriesIntoKey(category, rhs.category)) {
1553 llvm_unreachable(0);
1555 case PackCategoriesIntoKey(fcNaN, fcZero):
1556 case PackCategoriesIntoKey(fcNaN, fcNormal):
1557 case PackCategoriesIntoKey(fcNaN, fcInfinity):
1558 case PackCategoriesIntoKey(fcNaN, fcNaN):
1559 case PackCategoriesIntoKey(fcZero, fcInfinity):
1560 case PackCategoriesIntoKey(fcZero, fcNormal):
1561 case PackCategoriesIntoKey(fcNormal, fcInfinity):
1564 case PackCategoriesIntoKey(fcZero, fcNaN):
1565 case PackCategoriesIntoKey(fcNormal, fcNaN):
1566 case PackCategoriesIntoKey(fcInfinity, fcNaN):
1568 copySignificand(rhs);
1571 case PackCategoriesIntoKey(fcNormal, fcZero):
1572 case PackCategoriesIntoKey(fcInfinity, fcZero):
1573 case PackCategoriesIntoKey(fcInfinity, fcNormal):
1574 case PackCategoriesIntoKey(fcInfinity, fcInfinity):
1575 case PackCategoriesIntoKey(fcZero, fcZero):
1579 case PackCategoriesIntoKey(fcNormal, fcNormal):
1586 APFloat::changeSign()
1588 /* Look mummy, this one's easy. */
1593 APFloat::clearSign()
1595 /* So is this one. */
1600 APFloat::copySign(const APFloat &rhs)
1606 /* Normalized addition or subtraction. */
1608 APFloat::addOrSubtract(const APFloat &rhs, roundingMode rounding_mode,
1613 fs = addOrSubtractSpecials(rhs, subtract);
1615 /* This return code means it was not a simple case. */
1616 if (fs == opDivByZero) {
1617 lostFraction lost_fraction;
1619 lost_fraction = addOrSubtractSignificand(rhs, subtract);
1620 fs = normalize(rounding_mode, lost_fraction);
1622 /* Can only be zero if we lost no fraction. */
1623 assert(category != fcZero || lost_fraction == lfExactlyZero);
1626 /* If two numbers add (exactly) to zero, IEEE 754 decrees it is a
1627 positive zero unless rounding to minus infinity, except that
1628 adding two like-signed zeroes gives that zero. */
1629 if (category == fcZero) {
1630 if (rhs.category != fcZero || (sign == rhs.sign) == subtract)
1631 sign = (rounding_mode == rmTowardNegative);
1637 /* Normalized addition. */
1639 APFloat::add(const APFloat &rhs, roundingMode rounding_mode)
1641 return addOrSubtract(rhs, rounding_mode, false);
1644 /* Normalized subtraction. */
1646 APFloat::subtract(const APFloat &rhs, roundingMode rounding_mode)
1648 return addOrSubtract(rhs, rounding_mode, true);
1651 /* Normalized multiply. */
1653 APFloat::multiply(const APFloat &rhs, roundingMode rounding_mode)
1658 fs = multiplySpecials(rhs);
1660 if (isFiniteNonZero()) {
1661 lostFraction lost_fraction = multiplySignificand(rhs, 0);
1662 fs = normalize(rounding_mode, lost_fraction);
1663 if (lost_fraction != lfExactlyZero)
1664 fs = (opStatus) (fs | opInexact);
1670 /* Normalized divide. */
1672 APFloat::divide(const APFloat &rhs, roundingMode rounding_mode)
1677 fs = divideSpecials(rhs);
1679 if (isFiniteNonZero()) {
1680 lostFraction lost_fraction = divideSignificand(rhs);
1681 fs = normalize(rounding_mode, lost_fraction);
1682 if (lost_fraction != lfExactlyZero)
1683 fs = (opStatus) (fs | opInexact);
1689 /* Normalized remainder. This is not currently correct in all cases. */
1691 APFloat::remainder(const APFloat &rhs)
1695 unsigned int origSign = sign;
1697 fs = V.divide(rhs, rmNearestTiesToEven);
1698 if (fs == opDivByZero)
1701 int parts = partCount();
1702 integerPart *x = new integerPart[parts];
1704 fs = V.convertToInteger(x, parts * integerPartWidth, true,
1705 rmNearestTiesToEven, &ignored);
1706 if (fs==opInvalidOp)
1709 fs = V.convertFromZeroExtendedInteger(x, parts * integerPartWidth, true,
1710 rmNearestTiesToEven);
1711 assert(fs==opOK); // should always work
1713 fs = V.multiply(rhs, rmNearestTiesToEven);
1714 assert(fs==opOK || fs==opInexact); // should not overflow or underflow
1716 fs = subtract(V, rmNearestTiesToEven);
1717 assert(fs==opOK || fs==opInexact); // likewise
1720 sign = origSign; // IEEE754 requires this
1725 /* Normalized llvm frem (C fmod).
1726 This is not currently correct in all cases. */
1728 APFloat::mod(const APFloat &rhs, roundingMode rounding_mode)
1731 fs = modSpecials(rhs);
1733 if (isFiniteNonZero() && rhs.isFiniteNonZero()) {
1735 unsigned int origSign = sign;
1737 fs = V.divide(rhs, rmNearestTiesToEven);
1738 if (fs == opDivByZero)
1741 int parts = partCount();
1742 integerPart *x = new integerPart[parts];
1744 fs = V.convertToInteger(x, parts * integerPartWidth, true,
1745 rmTowardZero, &ignored);
1746 if (fs==opInvalidOp)
1749 fs = V.convertFromZeroExtendedInteger(x, parts * integerPartWidth, true,
1750 rmNearestTiesToEven);
1751 assert(fs==opOK); // should always work
1753 fs = V.multiply(rhs, rounding_mode);
1754 assert(fs==opOK || fs==opInexact); // should not overflow or underflow
1756 fs = subtract(V, rounding_mode);
1757 assert(fs==opOK || fs==opInexact); // likewise
1760 sign = origSign; // IEEE754 requires this
1766 /* Normalized fused-multiply-add. */
1768 APFloat::fusedMultiplyAdd(const APFloat &multiplicand,
1769 const APFloat &addend,
1770 roundingMode rounding_mode)
1774 /* Post-multiplication sign, before addition. */
1775 sign ^= multiplicand.sign;
1777 /* If and only if all arguments are normal do we need to do an
1778 extended-precision calculation. */
1779 if (isFiniteNonZero() &&
1780 multiplicand.isFiniteNonZero() &&
1781 addend.isFiniteNonZero()) {
1782 lostFraction lost_fraction;
1784 lost_fraction = multiplySignificand(multiplicand, &addend);
1785 fs = normalize(rounding_mode, lost_fraction);
1786 if (lost_fraction != lfExactlyZero)
1787 fs = (opStatus) (fs | opInexact);
1789 /* If two numbers add (exactly) to zero, IEEE 754 decrees it is a
1790 positive zero unless rounding to minus infinity, except that
1791 adding two like-signed zeroes gives that zero. */
1792 if (category == fcZero && sign != addend.sign)
1793 sign = (rounding_mode == rmTowardNegative);
1795 fs = multiplySpecials(multiplicand);
1797 /* FS can only be opOK or opInvalidOp. There is no more work
1798 to do in the latter case. The IEEE-754R standard says it is
1799 implementation-defined in this case whether, if ADDEND is a
1800 quiet NaN, we raise invalid op; this implementation does so.
1802 If we need to do the addition we can do so with normal
1805 fs = addOrSubtract(addend, rounding_mode, false);
1811 /* Rounding-mode corrrect round to integral value. */
1812 APFloat::opStatus APFloat::roundToIntegral(roundingMode rounding_mode) {
1815 // If the exponent is large enough, we know that this value is already
1816 // integral, and the arithmetic below would potentially cause it to saturate
1817 // to +/-Inf. Bail out early instead.
1818 if (isFiniteNonZero() && exponent+1 >= (int)semanticsPrecision(*semantics))
1821 // The algorithm here is quite simple: we add 2^(p-1), where p is the
1822 // precision of our format, and then subtract it back off again. The choice
1823 // of rounding modes for the addition/subtraction determines the rounding mode
1824 // for our integral rounding as well.
1825 // NOTE: When the input value is negative, we do subtraction followed by
1826 // addition instead.
1827 APInt IntegerConstant(NextPowerOf2(semanticsPrecision(*semantics)), 1);
1828 IntegerConstant <<= semanticsPrecision(*semantics)-1;
1829 APFloat MagicConstant(*semantics);
1830 fs = MagicConstant.convertFromAPInt(IntegerConstant, false,
1831 rmNearestTiesToEven);
1832 MagicConstant.copySign(*this);
1837 // Preserve the input sign so that we can handle 0.0/-0.0 cases correctly.
1838 bool inputSign = isNegative();
1840 fs = add(MagicConstant, rounding_mode);
1841 if (fs != opOK && fs != opInexact)
1844 fs = subtract(MagicConstant, rounding_mode);
1846 // Restore the input sign.
1847 if (inputSign != isNegative())
1854 /* Comparison requires normalized numbers. */
1856 APFloat::compare(const APFloat &rhs) const
1860 assert(semantics == rhs.semantics);
1862 switch (PackCategoriesIntoKey(category, rhs.category)) {
1864 llvm_unreachable(0);
1866 case PackCategoriesIntoKey(fcNaN, fcZero):
1867 case PackCategoriesIntoKey(fcNaN, fcNormal):
1868 case PackCategoriesIntoKey(fcNaN, fcInfinity):
1869 case PackCategoriesIntoKey(fcNaN, fcNaN):
1870 case PackCategoriesIntoKey(fcZero, fcNaN):
1871 case PackCategoriesIntoKey(fcNormal, fcNaN):
1872 case PackCategoriesIntoKey(fcInfinity, fcNaN):
1873 return cmpUnordered;
1875 case PackCategoriesIntoKey(fcInfinity, fcNormal):
1876 case PackCategoriesIntoKey(fcInfinity, fcZero):
1877 case PackCategoriesIntoKey(fcNormal, fcZero):
1881 return cmpGreaterThan;
1883 case PackCategoriesIntoKey(fcNormal, fcInfinity):
1884 case PackCategoriesIntoKey(fcZero, fcInfinity):
1885 case PackCategoriesIntoKey(fcZero, fcNormal):
1887 return cmpGreaterThan;
1891 case PackCategoriesIntoKey(fcInfinity, fcInfinity):
1892 if (sign == rhs.sign)
1897 return cmpGreaterThan;
1899 case PackCategoriesIntoKey(fcZero, fcZero):
1902 case PackCategoriesIntoKey(fcNormal, fcNormal):
1906 /* Two normal numbers. Do they have the same sign? */
1907 if (sign != rhs.sign) {
1909 result = cmpLessThan;
1911 result = cmpGreaterThan;
1913 /* Compare absolute values; invert result if negative. */
1914 result = compareAbsoluteValue(rhs);
1917 if (result == cmpLessThan)
1918 result = cmpGreaterThan;
1919 else if (result == cmpGreaterThan)
1920 result = cmpLessThan;
1927 /// APFloat::convert - convert a value of one floating point type to another.
1928 /// The return value corresponds to the IEEE754 exceptions. *losesInfo
1929 /// records whether the transformation lost information, i.e. whether
1930 /// converting the result back to the original type will produce the
1931 /// original value (this is almost the same as return value==fsOK, but there
1932 /// are edge cases where this is not so).
1935 APFloat::convert(const fltSemantics &toSemantics,
1936 roundingMode rounding_mode, bool *losesInfo)
1938 lostFraction lostFraction;
1939 unsigned int newPartCount, oldPartCount;
1942 const fltSemantics &fromSemantics = *semantics;
1944 lostFraction = lfExactlyZero;
1945 newPartCount = partCountForBits(toSemantics.precision + 1);
1946 oldPartCount = partCount();
1947 shift = toSemantics.precision - fromSemantics.precision;
1949 bool X86SpecialNan = false;
1950 if (&fromSemantics == &APFloat::x87DoubleExtended &&
1951 &toSemantics != &APFloat::x87DoubleExtended && category == fcNaN &&
1952 (!(*significandParts() & 0x8000000000000000ULL) ||
1953 !(*significandParts() & 0x4000000000000000ULL))) {
1954 // x86 has some unusual NaNs which cannot be represented in any other
1955 // format; note them here.
1956 X86SpecialNan = true;
1959 // If this is a truncation of a denormal number, and the target semantics
1960 // has larger exponent range than the source semantics (this can happen
1961 // when truncating from PowerPC double-double to double format), the
1962 // right shift could lose result mantissa bits. Adjust exponent instead
1963 // of performing excessive shift.
1964 if (shift < 0 && isFiniteNonZero()) {
1965 int exponentChange = significandMSB() + 1 - fromSemantics.precision;
1966 if (exponent + exponentChange < toSemantics.minExponent)
1967 exponentChange = toSemantics.minExponent - exponent;
1968 if (exponentChange < shift)
1969 exponentChange = shift;
1970 if (exponentChange < 0) {
1971 shift -= exponentChange;
1972 exponent += exponentChange;
1976 // If this is a truncation, perform the shift before we narrow the storage.
1977 if (shift < 0 && (isFiniteNonZero() || category==fcNaN))
1978 lostFraction = shiftRight(significandParts(), oldPartCount, -shift);
1980 // Fix the storage so it can hold to new value.
1981 if (newPartCount > oldPartCount) {
1982 // The new type requires more storage; make it available.
1983 integerPart *newParts;
1984 newParts = new integerPart[newPartCount];
1985 APInt::tcSet(newParts, 0, newPartCount);
1986 if (isFiniteNonZero() || category==fcNaN)
1987 APInt::tcAssign(newParts, significandParts(), oldPartCount);
1989 significand.parts = newParts;
1990 } else if (newPartCount == 1 && oldPartCount != 1) {
1991 // Switch to built-in storage for a single part.
1992 integerPart newPart = 0;
1993 if (isFiniteNonZero() || category==fcNaN)
1994 newPart = significandParts()[0];
1996 significand.part = newPart;
1999 // Now that we have the right storage, switch the semantics.
2000 semantics = &toSemantics;
2002 // If this is an extension, perform the shift now that the storage is
2004 if (shift > 0 && (isFiniteNonZero() || category==fcNaN))
2005 APInt::tcShiftLeft(significandParts(), newPartCount, shift);
2007 if (isFiniteNonZero()) {
2008 fs = normalize(rounding_mode, lostFraction);
2009 *losesInfo = (fs != opOK);
2010 } else if (category == fcNaN) {
2011 *losesInfo = lostFraction != lfExactlyZero || X86SpecialNan;
2013 // For x87 extended precision, we want to make a NaN, not a special NaN if
2014 // the input wasn't special either.
2015 if (!X86SpecialNan && semantics == &APFloat::x87DoubleExtended)
2016 APInt::tcSetBit(significandParts(), semantics->precision - 1);
2018 // gcc forces the Quiet bit on, which means (float)(double)(float_sNan)
2019 // does not give you back the same bits. This is dubious, and we
2020 // don't currently do it. You're really supposed to get
2021 // an invalid operation signal at runtime, but nobody does that.
2031 /* Convert a floating point number to an integer according to the
2032 rounding mode. If the rounded integer value is out of range this
2033 returns an invalid operation exception and the contents of the
2034 destination parts are unspecified. If the rounded value is in
2035 range but the floating point number is not the exact integer, the C
2036 standard doesn't require an inexact exception to be raised. IEEE
2037 854 does require it so we do that.
2039 Note that for conversions to integer type the C standard requires
2040 round-to-zero to always be used. */
2042 APFloat::convertToSignExtendedInteger(integerPart *parts, unsigned int width,
2044 roundingMode rounding_mode,
2045 bool *isExact) const
2047 lostFraction lost_fraction;
2048 const integerPart *src;
2049 unsigned int dstPartsCount, truncatedBits;
2053 /* Handle the three special cases first. */
2054 if (category == fcInfinity || category == fcNaN)
2057 dstPartsCount = partCountForBits(width);
2059 if (category == fcZero) {
2060 APInt::tcSet(parts, 0, dstPartsCount);
2061 // Negative zero can't be represented as an int.
2066 src = significandParts();
2068 /* Step 1: place our absolute value, with any fraction truncated, in
2071 /* Our absolute value is less than one; truncate everything. */
2072 APInt::tcSet(parts, 0, dstPartsCount);
2073 /* For exponent -1 the integer bit represents .5, look at that.
2074 For smaller exponents leftmost truncated bit is 0. */
2075 truncatedBits = semantics->precision -1U - exponent;
2077 /* We want the most significant (exponent + 1) bits; the rest are
2079 unsigned int bits = exponent + 1U;
2081 /* Hopelessly large in magnitude? */
2085 if (bits < semantics->precision) {
2086 /* We truncate (semantics->precision - bits) bits. */
2087 truncatedBits = semantics->precision - bits;
2088 APInt::tcExtract(parts, dstPartsCount, src, bits, truncatedBits);
2090 /* We want at least as many bits as are available. */
2091 APInt::tcExtract(parts, dstPartsCount, src, semantics->precision, 0);
2092 APInt::tcShiftLeft(parts, dstPartsCount, bits - semantics->precision);
2097 /* Step 2: work out any lost fraction, and increment the absolute
2098 value if we would round away from zero. */
2099 if (truncatedBits) {
2100 lost_fraction = lostFractionThroughTruncation(src, partCount(),
2102 if (lost_fraction != lfExactlyZero &&
2103 roundAwayFromZero(rounding_mode, lost_fraction, truncatedBits)) {
2104 if (APInt::tcIncrement(parts, dstPartsCount))
2105 return opInvalidOp; /* Overflow. */
2108 lost_fraction = lfExactlyZero;
2111 /* Step 3: check if we fit in the destination. */
2112 unsigned int omsb = APInt::tcMSB(parts, dstPartsCount) + 1;
2116 /* Negative numbers cannot be represented as unsigned. */
2120 /* It takes omsb bits to represent the unsigned integer value.
2121 We lose a bit for the sign, but care is needed as the
2122 maximally negative integer is a special case. */
2123 if (omsb == width && APInt::tcLSB(parts, dstPartsCount) + 1 != omsb)
2126 /* This case can happen because of rounding. */
2131 APInt::tcNegate (parts, dstPartsCount);
2133 if (omsb >= width + !isSigned)
2137 if (lost_fraction == lfExactlyZero) {
2144 /* Same as convertToSignExtendedInteger, except we provide
2145 deterministic values in case of an invalid operation exception,
2146 namely zero for NaNs and the minimal or maximal value respectively
2147 for underflow or overflow.
2148 The *isExact output tells whether the result is exact, in the sense
2149 that converting it back to the original floating point type produces
2150 the original value. This is almost equivalent to result==opOK,
2151 except for negative zeroes.
2154 APFloat::convertToInteger(integerPart *parts, unsigned int width,
2156 roundingMode rounding_mode, bool *isExact) const
2160 fs = convertToSignExtendedInteger(parts, width, isSigned, rounding_mode,
2163 if (fs == opInvalidOp) {
2164 unsigned int bits, dstPartsCount;
2166 dstPartsCount = partCountForBits(width);
2168 if (category == fcNaN)
2173 bits = width - isSigned;
2175 APInt::tcSetLeastSignificantBits(parts, dstPartsCount, bits);
2176 if (sign && isSigned)
2177 APInt::tcShiftLeft(parts, dstPartsCount, width - 1);
2183 /* Same as convertToInteger(integerPart*, ...), except the result is returned in
2184 an APSInt, whose initial bit-width and signed-ness are used to determine the
2185 precision of the conversion.
2188 APFloat::convertToInteger(APSInt &result,
2189 roundingMode rounding_mode, bool *isExact) const
2191 unsigned bitWidth = result.getBitWidth();
2192 SmallVector<uint64_t, 4> parts(result.getNumWords());
2193 opStatus status = convertToInteger(
2194 parts.data(), bitWidth, result.isSigned(), rounding_mode, isExact);
2195 // Keeps the original signed-ness.
2196 result = APInt(bitWidth, parts);
2200 /* Convert an unsigned integer SRC to a floating point number,
2201 rounding according to ROUNDING_MODE. The sign of the floating
2202 point number is not modified. */
2204 APFloat::convertFromUnsignedParts(const integerPart *src,
2205 unsigned int srcCount,
2206 roundingMode rounding_mode)
2208 unsigned int omsb, precision, dstCount;
2210 lostFraction lost_fraction;
2212 category = fcNormal;
2213 omsb = APInt::tcMSB(src, srcCount) + 1;
2214 dst = significandParts();
2215 dstCount = partCount();
2216 precision = semantics->precision;
2218 /* We want the most significant PRECISION bits of SRC. There may not
2219 be that many; extract what we can. */
2220 if (precision <= omsb) {
2221 exponent = omsb - 1;
2222 lost_fraction = lostFractionThroughTruncation(src, srcCount,
2224 APInt::tcExtract(dst, dstCount, src, precision, omsb - precision);
2226 exponent = precision - 1;
2227 lost_fraction = lfExactlyZero;
2228 APInt::tcExtract(dst, dstCount, src, omsb, 0);
2231 return normalize(rounding_mode, lost_fraction);
2235 APFloat::convertFromAPInt(const APInt &Val,
2237 roundingMode rounding_mode)
2239 unsigned int partCount = Val.getNumWords();
2243 if (isSigned && api.isNegative()) {
2248 return convertFromUnsignedParts(api.getRawData(), partCount, rounding_mode);
2251 /* Convert a two's complement integer SRC to a floating point number,
2252 rounding according to ROUNDING_MODE. ISSIGNED is true if the
2253 integer is signed, in which case it must be sign-extended. */
2255 APFloat::convertFromSignExtendedInteger(const integerPart *src,
2256 unsigned int srcCount,
2258 roundingMode rounding_mode)
2263 APInt::tcExtractBit(src, srcCount * integerPartWidth - 1)) {
2266 /* If we're signed and negative negate a copy. */
2268 copy = new integerPart[srcCount];
2269 APInt::tcAssign(copy, src, srcCount);
2270 APInt::tcNegate(copy, srcCount);
2271 status = convertFromUnsignedParts(copy, srcCount, rounding_mode);
2275 status = convertFromUnsignedParts(src, srcCount, rounding_mode);
2281 /* FIXME: should this just take a const APInt reference? */
2283 APFloat::convertFromZeroExtendedInteger(const integerPart *parts,
2284 unsigned int width, bool isSigned,
2285 roundingMode rounding_mode)
2287 unsigned int partCount = partCountForBits(width);
2288 APInt api = APInt(width, makeArrayRef(parts, partCount));
2291 if (isSigned && APInt::tcExtractBit(parts, width - 1)) {
2296 return convertFromUnsignedParts(api.getRawData(), partCount, rounding_mode);
2300 APFloat::convertFromHexadecimalString(StringRef s, roundingMode rounding_mode)
2302 lostFraction lost_fraction = lfExactlyZero;
2303 integerPart *significand;
2304 unsigned int bitPos, partsCount;
2305 StringRef::iterator dot, firstSignificantDigit;
2309 category = fcNormal;
2311 significand = significandParts();
2312 partsCount = partCount();
2313 bitPos = partsCount * integerPartWidth;
2315 /* Skip leading zeroes and any (hexa)decimal point. */
2316 StringRef::iterator begin = s.begin();
2317 StringRef::iterator end = s.end();
2318 StringRef::iterator p = skipLeadingZeroesAndAnyDot(begin, end, &dot);
2319 firstSignificantDigit = p;
2322 integerPart hex_value;
2325 assert(dot == end && "String contains multiple dots");
2332 hex_value = hexDigitValue(*p);
2333 if (hex_value == -1U) {
2342 /* Store the number whilst 4-bit nibbles remain. */
2345 hex_value <<= bitPos % integerPartWidth;
2346 significand[bitPos / integerPartWidth] |= hex_value;
2348 lost_fraction = trailingHexadecimalFraction(p, end, hex_value);
2349 while (p != end && hexDigitValue(*p) != -1U)
2356 /* Hex floats require an exponent but not a hexadecimal point. */
2357 assert(p != end && "Hex strings require an exponent");
2358 assert((*p == 'p' || *p == 'P') && "Invalid character in significand");
2359 assert(p != begin && "Significand has no digits");
2360 assert((dot == end || p - begin != 1) && "Significand has no digits");
2362 /* Ignore the exponent if we are zero. */
2363 if (p != firstSignificantDigit) {
2366 /* Implicit hexadecimal point? */
2370 /* Calculate the exponent adjustment implicit in the number of
2371 significant digits. */
2372 expAdjustment = static_cast<int>(dot - firstSignificantDigit);
2373 if (expAdjustment < 0)
2375 expAdjustment = expAdjustment * 4 - 1;
2377 /* Adjust for writing the significand starting at the most
2378 significant nibble. */
2379 expAdjustment += semantics->precision;
2380 expAdjustment -= partsCount * integerPartWidth;
2382 /* Adjust for the given exponent. */
2383 exponent = totalExponent(p + 1, end, expAdjustment);
2386 return normalize(rounding_mode, lost_fraction);
2390 APFloat::roundSignificandWithExponent(const integerPart *decSigParts,
2391 unsigned sigPartCount, int exp,
2392 roundingMode rounding_mode)
2394 unsigned int parts, pow5PartCount;
2395 fltSemantics calcSemantics = { 32767, -32767, 0 };
2396 integerPart pow5Parts[maxPowerOfFiveParts];
2399 isNearest = (rounding_mode == rmNearestTiesToEven ||
2400 rounding_mode == rmNearestTiesToAway);
2402 parts = partCountForBits(semantics->precision + 11);
2404 /* Calculate pow(5, abs(exp)). */
2405 pow5PartCount = powerOf5(pow5Parts, exp >= 0 ? exp: -exp);
2407 for (;; parts *= 2) {
2408 opStatus sigStatus, powStatus;
2409 unsigned int excessPrecision, truncatedBits;
2411 calcSemantics.precision = parts * integerPartWidth - 1;
2412 excessPrecision = calcSemantics.precision - semantics->precision;
2413 truncatedBits = excessPrecision;
2415 APFloat decSig = APFloat::getZero(calcSemantics, sign);
2416 APFloat pow5(calcSemantics);
2418 sigStatus = decSig.convertFromUnsignedParts(decSigParts, sigPartCount,
2419 rmNearestTiesToEven);
2420 powStatus = pow5.convertFromUnsignedParts(pow5Parts, pow5PartCount,
2421 rmNearestTiesToEven);
2422 /* Add exp, as 10^n = 5^n * 2^n. */
2423 decSig.exponent += exp;
2425 lostFraction calcLostFraction;
2426 integerPart HUerr, HUdistance;
2427 unsigned int powHUerr;
2430 /* multiplySignificand leaves the precision-th bit set to 1. */
2431 calcLostFraction = decSig.multiplySignificand(pow5, NULL);
2432 powHUerr = powStatus != opOK;
2434 calcLostFraction = decSig.divideSignificand(pow5);
2435 /* Denormal numbers have less precision. */
2436 if (decSig.exponent < semantics->minExponent) {
2437 excessPrecision += (semantics->minExponent - decSig.exponent);
2438 truncatedBits = excessPrecision;
2439 if (excessPrecision > calcSemantics.precision)
2440 excessPrecision = calcSemantics.precision;
2442 /* Extra half-ulp lost in reciprocal of exponent. */
2443 powHUerr = (powStatus == opOK && calcLostFraction == lfExactlyZero) ? 0:2;
2446 /* Both multiplySignificand and divideSignificand return the
2447 result with the integer bit set. */
2448 assert(APInt::tcExtractBit
2449 (decSig.significandParts(), calcSemantics.precision - 1) == 1);
2451 HUerr = HUerrBound(calcLostFraction != lfExactlyZero, sigStatus != opOK,
2453 HUdistance = 2 * ulpsFromBoundary(decSig.significandParts(),
2454 excessPrecision, isNearest);
2456 /* Are we guaranteed to round correctly if we truncate? */
2457 if (HUdistance >= HUerr) {
2458 APInt::tcExtract(significandParts(), partCount(), decSig.significandParts(),
2459 calcSemantics.precision - excessPrecision,
2461 /* Take the exponent of decSig. If we tcExtract-ed less bits
2462 above we must adjust our exponent to compensate for the
2463 implicit right shift. */
2464 exponent = (decSig.exponent + semantics->precision
2465 - (calcSemantics.precision - excessPrecision));
2466 calcLostFraction = lostFractionThroughTruncation(decSig.significandParts(),
2469 return normalize(rounding_mode, calcLostFraction);
2475 APFloat::convertFromDecimalString(StringRef str, roundingMode rounding_mode)
2480 /* Scan the text. */
2481 StringRef::iterator p = str.begin();
2482 interpretDecimal(p, str.end(), &D);
2484 /* Handle the quick cases. First the case of no significant digits,
2485 i.e. zero, and then exponents that are obviously too large or too
2486 small. Writing L for log 10 / log 2, a number d.ddddd*10^exp
2487 definitely overflows if
2489 (exp - 1) * L >= maxExponent
2491 and definitely underflows to zero where
2493 (exp + 1) * L <= minExponent - precision
2495 With integer arithmetic the tightest bounds for L are
2497 93/28 < L < 196/59 [ numerator <= 256 ]
2498 42039/12655 < L < 28738/8651 [ numerator <= 65536 ]
2501 // Test if we have a zero number allowing for strings with no null terminators
2502 // and zero decimals with non-zero exponents.
2504 // We computed firstSigDigit by ignoring all zeros and dots. Thus if
2505 // D->firstSigDigit equals str.end(), every digit must be a zero and there can
2506 // be at most one dot. On the other hand, if we have a zero with a non-zero
2507 // exponent, then we know that D.firstSigDigit will be non-numeric.
2508 if (D.firstSigDigit == str.end() || decDigitValue(*D.firstSigDigit) >= 10U) {
2512 /* Check whether the normalized exponent is high enough to overflow
2513 max during the log-rebasing in the max-exponent check below. */
2514 } else if (D.normalizedExponent - 1 > INT_MAX / 42039) {
2515 fs = handleOverflow(rounding_mode);
2517 /* If it wasn't, then it also wasn't high enough to overflow max
2518 during the log-rebasing in the min-exponent check. Check that it
2519 won't overflow min in either check, then perform the min-exponent
2521 } else if (D.normalizedExponent - 1 < INT_MIN / 42039 ||
2522 (D.normalizedExponent + 1) * 28738 <=
2523 8651 * (semantics->minExponent - (int) semantics->precision)) {
2524 /* Underflow to zero and round. */
2526 fs = normalize(rounding_mode, lfLessThanHalf);
2528 /* We can finally safely perform the max-exponent check. */
2529 } else if ((D.normalizedExponent - 1) * 42039
2530 >= 12655 * semantics->maxExponent) {
2531 /* Overflow and round. */
2532 fs = handleOverflow(rounding_mode);
2534 integerPart *decSignificand;
2535 unsigned int partCount;
2537 /* A tight upper bound on number of bits required to hold an
2538 N-digit decimal integer is N * 196 / 59. Allocate enough space
2539 to hold the full significand, and an extra part required by
2541 partCount = static_cast<unsigned int>(D.lastSigDigit - D.firstSigDigit) + 1;
2542 partCount = partCountForBits(1 + 196 * partCount / 59);
2543 decSignificand = new integerPart[partCount + 1];
2546 /* Convert to binary efficiently - we do almost all multiplication
2547 in an integerPart. When this would overflow do we do a single
2548 bignum multiplication, and then revert again to multiplication
2549 in an integerPart. */
2551 integerPart decValue, val, multiplier;
2559 if (p == str.end()) {
2563 decValue = decDigitValue(*p++);
2564 assert(decValue < 10U && "Invalid character in significand");
2566 val = val * 10 + decValue;
2567 /* The maximum number that can be multiplied by ten with any
2568 digit added without overflowing an integerPart. */
2569 } while (p <= D.lastSigDigit && multiplier <= (~ (integerPart) 0 - 9) / 10);
2571 /* Multiply out the current part. */
2572 APInt::tcMultiplyPart(decSignificand, decSignificand, multiplier, val,
2573 partCount, partCount + 1, false);
2575 /* If we used another part (likely but not guaranteed), increase
2577 if (decSignificand[partCount])
2579 } while (p <= D.lastSigDigit);
2581 category = fcNormal;
2582 fs = roundSignificandWithExponent(decSignificand, partCount,
2583 D.exponent, rounding_mode);
2585 delete [] decSignificand;
2592 APFloat::convertFromStringSpecials(StringRef str) {
2593 if (str.equals("inf") || str.equals("INFINITY")) {
2598 if (str.equals("-inf") || str.equals("-INFINITY")) {
2603 if (str.equals("nan") || str.equals("NaN")) {
2604 makeNaN(false, false);
2608 if (str.equals("-nan") || str.equals("-NaN")) {
2609 makeNaN(false, true);
2617 APFloat::convertFromString(StringRef str, roundingMode rounding_mode)
2619 assert(!str.empty() && "Invalid string length");
2621 // Handle special cases.
2622 if (convertFromStringSpecials(str))
2625 /* Handle a leading minus sign. */
2626 StringRef::iterator p = str.begin();
2627 size_t slen = str.size();
2628 sign = *p == '-' ? 1 : 0;
2629 if (*p == '-' || *p == '+') {
2632 assert(slen && "String has no digits");
2635 if (slen >= 2 && p[0] == '0' && (p[1] == 'x' || p[1] == 'X')) {
2636 assert(slen - 2 && "Invalid string");
2637 return convertFromHexadecimalString(StringRef(p + 2, slen - 2),
2641 return convertFromDecimalString(StringRef(p, slen), rounding_mode);
2644 /* Write out a hexadecimal representation of the floating point value
2645 to DST, which must be of sufficient size, in the C99 form
2646 [-]0xh.hhhhp[+-]d. Return the number of characters written,
2647 excluding the terminating NUL.
2649 If UPPERCASE, the output is in upper case, otherwise in lower case.
2651 HEXDIGITS digits appear altogether, rounding the value if
2652 necessary. If HEXDIGITS is 0, the minimal precision to display the
2653 number precisely is used instead. If nothing would appear after
2654 the decimal point it is suppressed.
2656 The decimal exponent is always printed and has at least one digit.
2657 Zero values display an exponent of zero. Infinities and NaNs
2658 appear as "infinity" or "nan" respectively.
2660 The above rules are as specified by C99. There is ambiguity about
2661 what the leading hexadecimal digit should be. This implementation
2662 uses whatever is necessary so that the exponent is displayed as
2663 stored. This implies the exponent will fall within the IEEE format
2664 range, and the leading hexadecimal digit will be 0 (for denormals),
2665 1 (normal numbers) or 2 (normal numbers rounded-away-from-zero with
2666 any other digits zero).
2669 APFloat::convertToHexString(char *dst, unsigned int hexDigits,
2670 bool upperCase, roundingMode rounding_mode) const
2680 memcpy (dst, upperCase ? infinityU: infinityL, sizeof infinityU - 1);
2681 dst += sizeof infinityL - 1;
2685 memcpy (dst, upperCase ? NaNU: NaNL, sizeof NaNU - 1);
2686 dst += sizeof NaNU - 1;
2691 *dst++ = upperCase ? 'X': 'x';
2693 if (hexDigits > 1) {
2695 memset (dst, '0', hexDigits - 1);
2696 dst += hexDigits - 1;
2698 *dst++ = upperCase ? 'P': 'p';
2703 dst = convertNormalToHexString (dst, hexDigits, upperCase, rounding_mode);
2709 return static_cast<unsigned int>(dst - p);
2712 /* Does the hard work of outputting the correctly rounded hexadecimal
2713 form of a normal floating point number with the specified number of
2714 hexadecimal digits. If HEXDIGITS is zero the minimum number of
2715 digits necessary to print the value precisely is output. */
2717 APFloat::convertNormalToHexString(char *dst, unsigned int hexDigits,
2719 roundingMode rounding_mode) const
2721 unsigned int count, valueBits, shift, partsCount, outputDigits;
2722 const char *hexDigitChars;
2723 const integerPart *significand;
2728 *dst++ = upperCase ? 'X': 'x';
2731 hexDigitChars = upperCase ? hexDigitsUpper: hexDigitsLower;
2733 significand = significandParts();
2734 partsCount = partCount();
2736 /* +3 because the first digit only uses the single integer bit, so
2737 we have 3 virtual zero most-significant-bits. */
2738 valueBits = semantics->precision + 3;
2739 shift = integerPartWidth - valueBits % integerPartWidth;
2741 /* The natural number of digits required ignoring trailing
2742 insignificant zeroes. */
2743 outputDigits = (valueBits - significandLSB () + 3) / 4;
2745 /* hexDigits of zero means use the required number for the
2746 precision. Otherwise, see if we are truncating. If we are,
2747 find out if we need to round away from zero. */
2749 if (hexDigits < outputDigits) {
2750 /* We are dropping non-zero bits, so need to check how to round.
2751 "bits" is the number of dropped bits. */
2753 lostFraction fraction;
2755 bits = valueBits - hexDigits * 4;
2756 fraction = lostFractionThroughTruncation (significand, partsCount, bits);
2757 roundUp = roundAwayFromZero(rounding_mode, fraction, bits);
2759 outputDigits = hexDigits;
2762 /* Write the digits consecutively, and start writing in the location
2763 of the hexadecimal point. We move the most significant digit
2764 left and add the hexadecimal point later. */
2767 count = (valueBits + integerPartWidth - 1) / integerPartWidth;
2769 while (outputDigits && count) {
2772 /* Put the most significant integerPartWidth bits in "part". */
2773 if (--count == partsCount)
2774 part = 0; /* An imaginary higher zero part. */
2776 part = significand[count] << shift;
2779 part |= significand[count - 1] >> (integerPartWidth - shift);
2781 /* Convert as much of "part" to hexdigits as we can. */
2782 unsigned int curDigits = integerPartWidth / 4;
2784 if (curDigits > outputDigits)
2785 curDigits = outputDigits;
2786 dst += partAsHex (dst, part, curDigits, hexDigitChars);
2787 outputDigits -= curDigits;
2793 /* Note that hexDigitChars has a trailing '0'. */
2796 *q = hexDigitChars[hexDigitValue (*q) + 1];
2797 } while (*q == '0');
2800 /* Add trailing zeroes. */
2801 memset (dst, '0', outputDigits);
2802 dst += outputDigits;
2805 /* Move the most significant digit to before the point, and if there
2806 is something after the decimal point add it. This must come
2807 after rounding above. */
2814 /* Finally output the exponent. */
2815 *dst++ = upperCase ? 'P': 'p';
2817 return writeSignedDecimal (dst, exponent);
2820 hash_code llvm::hash_value(const APFloat &Arg) {
2821 if (!Arg.isFiniteNonZero())
2822 return hash_combine((uint8_t)Arg.category,
2823 // NaN has no sign, fix it at zero.
2824 Arg.isNaN() ? (uint8_t)0 : (uint8_t)Arg.sign,
2825 Arg.semantics->precision);
2827 // Normal floats need their exponent and significand hashed.
2828 return hash_combine((uint8_t)Arg.category, (uint8_t)Arg.sign,
2829 Arg.semantics->precision, Arg.exponent,
2831 Arg.significandParts(),
2832 Arg.significandParts() + Arg.partCount()));
2835 // Conversion from APFloat to/from host float/double. It may eventually be
2836 // possible to eliminate these and have everybody deal with APFloats, but that
2837 // will take a while. This approach will not easily extend to long double.
2838 // Current implementation requires integerPartWidth==64, which is correct at
2839 // the moment but could be made more general.
2841 // Denormals have exponent minExponent in APFloat, but minExponent-1 in
2842 // the actual IEEE respresentations. We compensate for that here.
2845 APFloat::convertF80LongDoubleAPFloatToAPInt() const
2847 assert(semantics == (const llvm::fltSemantics*)&x87DoubleExtended);
2848 assert(partCount()==2);
2850 uint64_t myexponent, mysignificand;
2852 if (isFiniteNonZero()) {
2853 myexponent = exponent+16383; //bias
2854 mysignificand = significandParts()[0];
2855 if (myexponent==1 && !(mysignificand & 0x8000000000000000ULL))
2856 myexponent = 0; // denormal
2857 } else if (category==fcZero) {
2860 } else if (category==fcInfinity) {
2861 myexponent = 0x7fff;
2862 mysignificand = 0x8000000000000000ULL;
2864 assert(category == fcNaN && "Unknown category");
2865 myexponent = 0x7fff;
2866 mysignificand = significandParts()[0];
2870 words[0] = mysignificand;
2871 words[1] = ((uint64_t)(sign & 1) << 15) |
2872 (myexponent & 0x7fffLL);
2873 return APInt(80, words);
2877 APFloat::convertPPCDoubleDoubleAPFloatToAPInt() const
2879 assert(semantics == (const llvm::fltSemantics*)&PPCDoubleDouble);
2880 assert(partCount()==2);
2886 // Convert number to double. To avoid spurious underflows, we re-
2887 // normalize against the "double" minExponent first, and only *then*
2888 // truncate the mantissa. The result of that second conversion
2889 // may be inexact, but should never underflow.
2890 // Declare fltSemantics before APFloat that uses it (and
2891 // saves pointer to it) to ensure correct destruction order.
2892 fltSemantics extendedSemantics = *semantics;
2893 extendedSemantics.minExponent = IEEEdouble.minExponent;
2894 APFloat extended(*this);
2895 fs = extended.convert(extendedSemantics, rmNearestTiesToEven, &losesInfo);
2896 assert(fs == opOK && !losesInfo);
2899 APFloat u(extended);
2900 fs = u.convert(IEEEdouble, rmNearestTiesToEven, &losesInfo);
2901 assert(fs == opOK || fs == opInexact);
2903 words[0] = *u.convertDoubleAPFloatToAPInt().getRawData();
2905 // If conversion was exact or resulted in a special case, we're done;
2906 // just set the second double to zero. Otherwise, re-convert back to
2907 // the extended format and compute the difference. This now should
2908 // convert exactly to double.
2909 if (u.isFiniteNonZero() && losesInfo) {
2910 fs = u.convert(extendedSemantics, rmNearestTiesToEven, &losesInfo);
2911 assert(fs == opOK && !losesInfo);
2914 APFloat v(extended);
2915 v.subtract(u, rmNearestTiesToEven);
2916 fs = v.convert(IEEEdouble, rmNearestTiesToEven, &losesInfo);
2917 assert(fs == opOK && !losesInfo);
2919 words[1] = *v.convertDoubleAPFloatToAPInt().getRawData();
2924 return APInt(128, words);
2928 APFloat::convertQuadrupleAPFloatToAPInt() const
2930 assert(semantics == (const llvm::fltSemantics*)&IEEEquad);
2931 assert(partCount()==2);
2933 uint64_t myexponent, mysignificand, mysignificand2;
2935 if (isFiniteNonZero()) {
2936 myexponent = exponent+16383; //bias
2937 mysignificand = significandParts()[0];
2938 mysignificand2 = significandParts()[1];
2939 if (myexponent==1 && !(mysignificand2 & 0x1000000000000LL))
2940 myexponent = 0; // denormal
2941 } else if (category==fcZero) {
2943 mysignificand = mysignificand2 = 0;
2944 } else if (category==fcInfinity) {
2945 myexponent = 0x7fff;
2946 mysignificand = mysignificand2 = 0;
2948 assert(category == fcNaN && "Unknown category!");
2949 myexponent = 0x7fff;
2950 mysignificand = significandParts()[0];
2951 mysignificand2 = significandParts()[1];
2955 words[0] = mysignificand;
2956 words[1] = ((uint64_t)(sign & 1) << 63) |
2957 ((myexponent & 0x7fff) << 48) |
2958 (mysignificand2 & 0xffffffffffffLL);
2960 return APInt(128, words);
2964 APFloat::convertDoubleAPFloatToAPInt() const
2966 assert(semantics == (const llvm::fltSemantics*)&IEEEdouble);
2967 assert(partCount()==1);
2969 uint64_t myexponent, mysignificand;
2971 if (isFiniteNonZero()) {
2972 myexponent = exponent+1023; //bias
2973 mysignificand = *significandParts();
2974 if (myexponent==1 && !(mysignificand & 0x10000000000000LL))
2975 myexponent = 0; // denormal
2976 } else if (category==fcZero) {
2979 } else if (category==fcInfinity) {
2983 assert(category == fcNaN && "Unknown category!");
2985 mysignificand = *significandParts();
2988 return APInt(64, ((((uint64_t)(sign & 1) << 63) |
2989 ((myexponent & 0x7ff) << 52) |
2990 (mysignificand & 0xfffffffffffffLL))));
2994 APFloat::convertFloatAPFloatToAPInt() const
2996 assert(semantics == (const llvm::fltSemantics*)&IEEEsingle);
2997 assert(partCount()==1);
2999 uint32_t myexponent, mysignificand;
3001 if (isFiniteNonZero()) {
3002 myexponent = exponent+127; //bias
3003 mysignificand = (uint32_t)*significandParts();
3004 if (myexponent == 1 && !(mysignificand & 0x800000))
3005 myexponent = 0; // denormal
3006 } else if (category==fcZero) {
3009 } else if (category==fcInfinity) {
3013 assert(category == fcNaN && "Unknown category!");
3015 mysignificand = (uint32_t)*significandParts();
3018 return APInt(32, (((sign&1) << 31) | ((myexponent&0xff) << 23) |
3019 (mysignificand & 0x7fffff)));
3023 APFloat::convertHalfAPFloatToAPInt() const
3025 assert(semantics == (const llvm::fltSemantics*)&IEEEhalf);
3026 assert(partCount()==1);
3028 uint32_t myexponent, mysignificand;
3030 if (isFiniteNonZero()) {
3031 myexponent = exponent+15; //bias
3032 mysignificand = (uint32_t)*significandParts();
3033 if (myexponent == 1 && !(mysignificand & 0x400))
3034 myexponent = 0; // denormal
3035 } else if (category==fcZero) {
3038 } else if (category==fcInfinity) {
3042 assert(category == fcNaN && "Unknown category!");
3044 mysignificand = (uint32_t)*significandParts();
3047 return APInt(16, (((sign&1) << 15) | ((myexponent&0x1f) << 10) |
3048 (mysignificand & 0x3ff)));
3051 // This function creates an APInt that is just a bit map of the floating
3052 // point constant as it would appear in memory. It is not a conversion,
3053 // and treating the result as a normal integer is unlikely to be useful.
3056 APFloat::bitcastToAPInt() const
3058 if (semantics == (const llvm::fltSemantics*)&IEEEhalf)
3059 return convertHalfAPFloatToAPInt();
3061 if (semantics == (const llvm::fltSemantics*)&IEEEsingle)
3062 return convertFloatAPFloatToAPInt();
3064 if (semantics == (const llvm::fltSemantics*)&IEEEdouble)
3065 return convertDoubleAPFloatToAPInt();
3067 if (semantics == (const llvm::fltSemantics*)&IEEEquad)
3068 return convertQuadrupleAPFloatToAPInt();
3070 if (semantics == (const llvm::fltSemantics*)&PPCDoubleDouble)
3071 return convertPPCDoubleDoubleAPFloatToAPInt();
3073 assert(semantics == (const llvm::fltSemantics*)&x87DoubleExtended &&
3075 return convertF80LongDoubleAPFloatToAPInt();
3079 APFloat::convertToFloat() const
3081 assert(semantics == (const llvm::fltSemantics*)&IEEEsingle &&
3082 "Float semantics are not IEEEsingle");
3083 APInt api = bitcastToAPInt();
3084 return api.bitsToFloat();
3088 APFloat::convertToDouble() const
3090 assert(semantics == (const llvm::fltSemantics*)&IEEEdouble &&
3091 "Float semantics are not IEEEdouble");
3092 APInt api = bitcastToAPInt();
3093 return api.bitsToDouble();
3096 /// Integer bit is explicit in this format. Intel hardware (387 and later)
3097 /// does not support these bit patterns:
3098 /// exponent = all 1's, integer bit 0, significand 0 ("pseudoinfinity")
3099 /// exponent = all 1's, integer bit 0, significand nonzero ("pseudoNaN")
3100 /// exponent = 0, integer bit 1 ("pseudodenormal")
3101 /// exponent!=0 nor all 1's, integer bit 0 ("unnormal")
3102 /// At the moment, the first two are treated as NaNs, the second two as Normal.
3104 APFloat::initFromF80LongDoubleAPInt(const APInt &api)
3106 assert(api.getBitWidth()==80);
3107 uint64_t i1 = api.getRawData()[0];
3108 uint64_t i2 = api.getRawData()[1];
3109 uint64_t myexponent = (i2 & 0x7fff);
3110 uint64_t mysignificand = i1;
3112 initialize(&APFloat::x87DoubleExtended);
3113 assert(partCount()==2);
3115 sign = static_cast<unsigned int>(i2>>15);
3116 if (myexponent==0 && mysignificand==0) {
3117 // exponent, significand meaningless
3119 } else if (myexponent==0x7fff && mysignificand==0x8000000000000000ULL) {
3120 // exponent, significand meaningless
3121 category = fcInfinity;
3122 } else if (myexponent==0x7fff && mysignificand!=0x8000000000000000ULL) {
3123 // exponent meaningless
3125 significandParts()[0] = mysignificand;
3126 significandParts()[1] = 0;
3128 category = fcNormal;
3129 exponent = myexponent - 16383;
3130 significandParts()[0] = mysignificand;
3131 significandParts()[1] = 0;
3132 if (myexponent==0) // denormal
3138 APFloat::initFromPPCDoubleDoubleAPInt(const APInt &api)
3140 assert(api.getBitWidth()==128);
3141 uint64_t i1 = api.getRawData()[0];
3142 uint64_t i2 = api.getRawData()[1];
3146 // Get the first double and convert to our format.
3147 initFromDoubleAPInt(APInt(64, i1));
3148 fs = convert(PPCDoubleDouble, rmNearestTiesToEven, &losesInfo);
3149 assert(fs == opOK && !losesInfo);
3152 // Unless we have a special case, add in second double.
3153 if (isFiniteNonZero()) {
3154 APFloat v(IEEEdouble, APInt(64, i2));
3155 fs = v.convert(PPCDoubleDouble, rmNearestTiesToEven, &losesInfo);
3156 assert(fs == opOK && !losesInfo);
3159 add(v, rmNearestTiesToEven);
3164 APFloat::initFromQuadrupleAPInt(const APInt &api)
3166 assert(api.getBitWidth()==128);
3167 uint64_t i1 = api.getRawData()[0];
3168 uint64_t i2 = api.getRawData()[1];
3169 uint64_t myexponent = (i2 >> 48) & 0x7fff;
3170 uint64_t mysignificand = i1;
3171 uint64_t mysignificand2 = i2 & 0xffffffffffffLL;
3173 initialize(&APFloat::IEEEquad);
3174 assert(partCount()==2);
3176 sign = static_cast<unsigned int>(i2>>63);
3177 if (myexponent==0 &&
3178 (mysignificand==0 && mysignificand2==0)) {
3179 // exponent, significand meaningless
3181 } else if (myexponent==0x7fff &&
3182 (mysignificand==0 && mysignificand2==0)) {
3183 // exponent, significand meaningless
3184 category = fcInfinity;
3185 } else if (myexponent==0x7fff &&
3186 (mysignificand!=0 || mysignificand2 !=0)) {
3187 // exponent meaningless
3189 significandParts()[0] = mysignificand;
3190 significandParts()[1] = mysignificand2;
3192 category = fcNormal;
3193 exponent = myexponent - 16383;
3194 significandParts()[0] = mysignificand;
3195 significandParts()[1] = mysignificand2;
3196 if (myexponent==0) // denormal
3199 significandParts()[1] |= 0x1000000000000LL; // integer bit
3204 APFloat::initFromDoubleAPInt(const APInt &api)
3206 assert(api.getBitWidth()==64);
3207 uint64_t i = *api.getRawData();
3208 uint64_t myexponent = (i >> 52) & 0x7ff;
3209 uint64_t mysignificand = i & 0xfffffffffffffLL;
3211 initialize(&APFloat::IEEEdouble);
3212 assert(partCount()==1);
3214 sign = static_cast<unsigned int>(i>>63);
3215 if (myexponent==0 && mysignificand==0) {
3216 // exponent, significand meaningless
3218 } else if (myexponent==0x7ff && mysignificand==0) {
3219 // exponent, significand meaningless
3220 category = fcInfinity;
3221 } else if (myexponent==0x7ff && mysignificand!=0) {
3222 // exponent meaningless
3224 *significandParts() = mysignificand;
3226 category = fcNormal;
3227 exponent = myexponent - 1023;
3228 *significandParts() = mysignificand;
3229 if (myexponent==0) // denormal
3232 *significandParts() |= 0x10000000000000LL; // integer bit
3237 APFloat::initFromFloatAPInt(const APInt & api)
3239 assert(api.getBitWidth()==32);
3240 uint32_t i = (uint32_t)*api.getRawData();
3241 uint32_t myexponent = (i >> 23) & 0xff;
3242 uint32_t mysignificand = i & 0x7fffff;
3244 initialize(&APFloat::IEEEsingle);
3245 assert(partCount()==1);
3248 if (myexponent==0 && mysignificand==0) {
3249 // exponent, significand meaningless
3251 } else if (myexponent==0xff && mysignificand==0) {
3252 // exponent, significand meaningless
3253 category = fcInfinity;
3254 } else if (myexponent==0xff && mysignificand!=0) {
3255 // sign, exponent, significand meaningless
3257 *significandParts() = mysignificand;
3259 category = fcNormal;
3260 exponent = myexponent - 127; //bias
3261 *significandParts() = mysignificand;
3262 if (myexponent==0) // denormal
3265 *significandParts() |= 0x800000; // integer bit
3270 APFloat::initFromHalfAPInt(const APInt & api)
3272 assert(api.getBitWidth()==16);
3273 uint32_t i = (uint32_t)*api.getRawData();
3274 uint32_t myexponent = (i >> 10) & 0x1f;
3275 uint32_t mysignificand = i & 0x3ff;
3277 initialize(&APFloat::IEEEhalf);
3278 assert(partCount()==1);
3281 if (myexponent==0 && mysignificand==0) {
3282 // exponent, significand meaningless
3284 } else if (myexponent==0x1f && mysignificand==0) {
3285 // exponent, significand meaningless
3286 category = fcInfinity;
3287 } else if (myexponent==0x1f && mysignificand!=0) {
3288 // sign, exponent, significand meaningless
3290 *significandParts() = mysignificand;
3292 category = fcNormal;
3293 exponent = myexponent - 15; //bias
3294 *significandParts() = mysignificand;
3295 if (myexponent==0) // denormal
3298 *significandParts() |= 0x400; // integer bit
3302 /// Treat api as containing the bits of a floating point number. Currently
3303 /// we infer the floating point type from the size of the APInt. The
3304 /// isIEEE argument distinguishes between PPC128 and IEEE128 (not meaningful
3305 /// when the size is anything else).
3307 APFloat::initFromAPInt(const fltSemantics* Sem, const APInt& api)
3309 if (Sem == &IEEEhalf)
3310 return initFromHalfAPInt(api);
3311 if (Sem == &IEEEsingle)
3312 return initFromFloatAPInt(api);
3313 if (Sem == &IEEEdouble)
3314 return initFromDoubleAPInt(api);
3315 if (Sem == &x87DoubleExtended)
3316 return initFromF80LongDoubleAPInt(api);
3317 if (Sem == &IEEEquad)
3318 return initFromQuadrupleAPInt(api);
3319 if (Sem == &PPCDoubleDouble)
3320 return initFromPPCDoubleDoubleAPInt(api);
3322 llvm_unreachable(0);
3326 APFloat::getAllOnesValue(unsigned BitWidth, bool isIEEE)
3330 return APFloat(IEEEhalf, APInt::getAllOnesValue(BitWidth));
3332 return APFloat(IEEEsingle, APInt::getAllOnesValue(BitWidth));
3334 return APFloat(IEEEdouble, APInt::getAllOnesValue(BitWidth));
3336 return APFloat(x87DoubleExtended, APInt::getAllOnesValue(BitWidth));
3339 return APFloat(IEEEquad, APInt::getAllOnesValue(BitWidth));
3340 return APFloat(PPCDoubleDouble, APInt::getAllOnesValue(BitWidth));
3342 llvm_unreachable("Unknown floating bit width");
3346 /// Make this number the largest magnitude normal number in the given
3348 void APFloat::makeLargest(bool Negative) {
3349 // We want (in interchange format):
3350 // sign = {Negative}
3352 // significand = 1..1
3353 category = fcNormal;
3355 exponent = semantics->maxExponent;
3357 // Use memset to set all but the highest integerPart to all ones.
3358 integerPart *significand = significandParts();
3359 unsigned PartCount = partCount();
3360 memset(significand, 0xFF, sizeof(integerPart)*(PartCount - 1));
3362 // Set the high integerPart especially setting all unused top bits for
3363 // internal consistency.
3364 const unsigned NumUnusedHighBits =
3365 PartCount*integerPartWidth - semantics->precision;
3366 significand[PartCount - 1] = ~integerPart(0) >> NumUnusedHighBits;
3369 /// Make this number the smallest magnitude denormal number in the given
3371 void APFloat::makeSmallest(bool Negative) {
3372 // We want (in interchange format):
3373 // sign = {Negative}
3375 // significand = 0..01
3376 category = fcNormal;
3378 exponent = semantics->minExponent;
3379 APInt::tcSet(significandParts(), 1, partCount());
3383 APFloat APFloat::getLargest(const fltSemantics &Sem, bool Negative) {
3384 // We want (in interchange format):
3385 // sign = {Negative}
3387 // significand = 1..1
3388 APFloat Val(Sem, uninitialized);
3389 Val.makeLargest(Negative);
3393 APFloat APFloat::getSmallest(const fltSemantics &Sem, bool Negative) {
3394 // We want (in interchange format):
3395 // sign = {Negative}
3397 // significand = 0..01
3398 APFloat Val(Sem, uninitialized);
3399 Val.makeSmallest(Negative);
3403 APFloat APFloat::getSmallestNormalized(const fltSemantics &Sem, bool Negative) {
3404 APFloat Val(Sem, uninitialized);
3406 // We want (in interchange format):
3407 // sign = {Negative}
3409 // significand = 10..0
3411 Val.zeroSignificand();
3412 Val.sign = Negative;
3413 Val.exponent = Sem.minExponent;
3414 Val.significandParts()[partCountForBits(Sem.precision)-1] |=
3415 (((integerPart) 1) << ((Sem.precision - 1) % integerPartWidth));
3420 APFloat::APFloat(const fltSemantics &Sem, const APInt &API) {
3421 initFromAPInt(&Sem, API);
3424 APFloat::APFloat(float f) {
3425 initFromAPInt(&IEEEsingle, APInt::floatToBits(f));
3428 APFloat::APFloat(double d) {
3429 initFromAPInt(&IEEEdouble, APInt::doubleToBits(d));
3433 void append(SmallVectorImpl<char> &Buffer, StringRef Str) {
3434 Buffer.append(Str.begin(), Str.end());
3437 /// Removes data from the given significand until it is no more
3438 /// precise than is required for the desired precision.
3439 void AdjustToPrecision(APInt &significand,
3440 int &exp, unsigned FormatPrecision) {
3441 unsigned bits = significand.getActiveBits();
3443 // 196/59 is a very slight overestimate of lg_2(10).
3444 unsigned bitsRequired = (FormatPrecision * 196 + 58) / 59;
3446 if (bits <= bitsRequired) return;
3448 unsigned tensRemovable = (bits - bitsRequired) * 59 / 196;
3449 if (!tensRemovable) return;
3451 exp += tensRemovable;
3453 APInt divisor(significand.getBitWidth(), 1);
3454 APInt powten(significand.getBitWidth(), 10);
3456 if (tensRemovable & 1)
3458 tensRemovable >>= 1;
3459 if (!tensRemovable) break;
3463 significand = significand.udiv(divisor);
3465 // Truncate the significand down to its active bit count.
3466 significand = significand.trunc(significand.getActiveBits());
3470 void AdjustToPrecision(SmallVectorImpl<char> &buffer,
3471 int &exp, unsigned FormatPrecision) {
3472 unsigned N = buffer.size();
3473 if (N <= FormatPrecision) return;
3475 // The most significant figures are the last ones in the buffer.
3476 unsigned FirstSignificant = N - FormatPrecision;
3479 // FIXME: this probably shouldn't use 'round half up'.
3481 // Rounding down is just a truncation, except we also want to drop
3482 // trailing zeros from the new result.
3483 if (buffer[FirstSignificant - 1] < '5') {
3484 while (FirstSignificant < N && buffer[FirstSignificant] == '0')
3487 exp += FirstSignificant;
3488 buffer.erase(&buffer[0], &buffer[FirstSignificant]);
3492 // Rounding up requires a decimal add-with-carry. If we continue
3493 // the carry, the newly-introduced zeros will just be truncated.
3494 for (unsigned I = FirstSignificant; I != N; ++I) {
3495 if (buffer[I] == '9') {
3503 // If we carried through, we have exactly one digit of precision.
3504 if (FirstSignificant == N) {
3505 exp += FirstSignificant;
3507 buffer.push_back('1');
3511 exp += FirstSignificant;
3512 buffer.erase(&buffer[0], &buffer[FirstSignificant]);
3516 void APFloat::toString(SmallVectorImpl<char> &Str,
3517 unsigned FormatPrecision,
3518 unsigned FormatMaxPadding) const {
3522 return append(Str, "-Inf");
3524 return append(Str, "+Inf");
3526 case fcNaN: return append(Str, "NaN");
3532 if (!FormatMaxPadding)
3533 append(Str, "0.0E+0");
3545 // Decompose the number into an APInt and an exponent.
3546 int exp = exponent - ((int) semantics->precision - 1);
3547 APInt significand(semantics->precision,
3548 makeArrayRef(significandParts(),
3549 partCountForBits(semantics->precision)));
3551 // Set FormatPrecision if zero. We want to do this before we
3552 // truncate trailing zeros, as those are part of the precision.
3553 if (!FormatPrecision) {
3554 // It's an interesting question whether to use the nominal
3555 // precision or the active precision here for denormals.
3557 // FormatPrecision = ceil(significandBits / lg_2(10))
3558 FormatPrecision = (semantics->precision * 59 + 195) / 196;
3561 // Ignore trailing binary zeros.
3562 int trailingZeros = significand.countTrailingZeros();
3563 exp += trailingZeros;
3564 significand = significand.lshr(trailingZeros);
3566 // Change the exponent from 2^e to 10^e.
3569 } else if (exp > 0) {
3571 significand = significand.zext(semantics->precision + exp);
3572 significand <<= exp;
3574 } else { /* exp < 0 */
3577 // We transform this using the identity:
3578 // (N)(2^-e) == (N)(5^e)(10^-e)
3579 // This means we have to multiply N (the significand) by 5^e.
3580 // To avoid overflow, we have to operate on numbers large
3581 // enough to store N * 5^e:
3582 // log2(N * 5^e) == log2(N) + e * log2(5)
3583 // <= semantics->precision + e * 137 / 59
3584 // (log_2(5) ~ 2.321928 < 2.322034 ~ 137/59)
3586 unsigned precision = semantics->precision + (137 * texp + 136) / 59;
3588 // Multiply significand by 5^e.
3589 // N * 5^0101 == N * 5^(1*1) * 5^(0*2) * 5^(1*4) * 5^(0*8)
3590 significand = significand.zext(precision);
3591 APInt five_to_the_i(precision, 5);
3593 if (texp & 1) significand *= five_to_the_i;
3597 five_to_the_i *= five_to_the_i;
3601 AdjustToPrecision(significand, exp, FormatPrecision);
3603 SmallVector<char, 256> buffer;
3606 unsigned precision = significand.getBitWidth();
3607 APInt ten(precision, 10);
3608 APInt digit(precision, 0);
3610 bool inTrail = true;
3611 while (significand != 0) {
3612 // digit <- significand % 10
3613 // significand <- significand / 10
3614 APInt::udivrem(significand, ten, significand, digit);
3616 unsigned d = digit.getZExtValue();
3618 // Drop trailing zeros.
3619 if (inTrail && !d) exp++;
3621 buffer.push_back((char) ('0' + d));
3626 assert(!buffer.empty() && "no characters in buffer!");
3628 // Drop down to FormatPrecision.
3629 // TODO: don't do more precise calculations above than are required.
3630 AdjustToPrecision(buffer, exp, FormatPrecision);
3632 unsigned NDigits = buffer.size();
3634 // Check whether we should use scientific notation.
3635 bool FormatScientific;
3636 if (!FormatMaxPadding)
3637 FormatScientific = true;
3642 // But we shouldn't make the number look more precise than it is.
3643 FormatScientific = ((unsigned) exp > FormatMaxPadding ||
3644 NDigits + (unsigned) exp > FormatPrecision);
3646 // Power of the most significant digit.
3647 int MSD = exp + (int) (NDigits - 1);
3650 FormatScientific = false;
3652 // 765e-5 == 0.00765
3654 FormatScientific = ((unsigned) -MSD) > FormatMaxPadding;
3659 // Scientific formatting is pretty straightforward.
3660 if (FormatScientific) {
3661 exp += (NDigits - 1);
3663 Str.push_back(buffer[NDigits-1]);
3668 for (unsigned I = 1; I != NDigits; ++I)
3669 Str.push_back(buffer[NDigits-1-I]);
3672 Str.push_back(exp >= 0 ? '+' : '-');
3673 if (exp < 0) exp = -exp;
3674 SmallVector<char, 6> expbuf;
3676 expbuf.push_back((char) ('0' + (exp % 10)));
3679 for (unsigned I = 0, E = expbuf.size(); I != E; ++I)
3680 Str.push_back(expbuf[E-1-I]);
3684 // Non-scientific, positive exponents.
3686 for (unsigned I = 0; I != NDigits; ++I)
3687 Str.push_back(buffer[NDigits-1-I]);
3688 for (unsigned I = 0; I != (unsigned) exp; ++I)
3693 // Non-scientific, negative exponents.
3695 // The number of digits to the left of the decimal point.
3696 int NWholeDigits = exp + (int) NDigits;
3699 if (NWholeDigits > 0) {
3700 for (; I != (unsigned) NWholeDigits; ++I)
3701 Str.push_back(buffer[NDigits-I-1]);
3704 unsigned NZeros = 1 + (unsigned) -NWholeDigits;
3708 for (unsigned Z = 1; Z != NZeros; ++Z)
3712 for (; I != NDigits; ++I)
3713 Str.push_back(buffer[NDigits-I-1]);
3716 bool APFloat::getExactInverse(APFloat *inv) const {
3717 // Special floats and denormals have no exact inverse.
3718 if (!isFiniteNonZero())
3721 // Check that the number is a power of two by making sure that only the
3722 // integer bit is set in the significand.
3723 if (significandLSB() != semantics->precision - 1)
3727 APFloat reciprocal(*semantics, 1ULL);
3728 if (reciprocal.divide(*this, rmNearestTiesToEven) != opOK)
3731 // Avoid multiplication with a denormal, it is not safe on all platforms and
3732 // may be slower than a normal division.
3733 if (reciprocal.isDenormal())
3736 assert(reciprocal.isFiniteNonZero() &&
3737 reciprocal.significandLSB() == reciprocal.semantics->precision - 1);
3745 bool APFloat::isSignaling() const {
3749 // IEEE-754R 2008 6.2.1: A signaling NaN bit string should be encoded with the
3750 // first bit of the trailing significand being 0.
3751 return !APInt::tcExtractBit(significandParts(), semantics->precision - 2);
3754 /// IEEE-754R 2008 5.3.1: nextUp/nextDown.
3756 /// *NOTE* since nextDown(x) = -nextUp(-x), we only implement nextUp with
3757 /// appropriate sign switching before/after the computation.
3758 APFloat::opStatus APFloat::next(bool nextDown) {
3759 // If we are performing nextDown, swap sign so we have -x.
3763 // Compute nextUp(x)
3764 opStatus result = opOK;
3766 // Handle each float category separately.
3769 // nextUp(+inf) = +inf
3772 // nextUp(-inf) = -getLargest()
3776 // IEEE-754R 2008 6.2 Par 2: nextUp(sNaN) = qNaN. Set Invalid flag.
3777 // IEEE-754R 2008 6.2: nextUp(qNaN) = qNaN. Must be identity so we do not
3778 // change the payload.
3779 if (isSignaling()) {
3780 result = opInvalidOp;
3781 // For consistency, propogate the sign of the sNaN to the qNaN.
3782 makeNaN(false, isNegative(), 0);
3786 // nextUp(pm 0) = +getSmallest()
3787 makeSmallest(false);
3790 // nextUp(-getSmallest()) = -0
3791 if (isSmallest() && isNegative()) {
3792 APInt::tcSet(significandParts(), 0, partCount());
3798 // nextUp(getLargest()) == INFINITY
3799 if (isLargest() && !isNegative()) {
3800 APInt::tcSet(significandParts(), 0, partCount());
3801 category = fcInfinity;
3802 exponent = semantics->maxExponent + 1;
3806 // nextUp(normal) == normal + inc.
3808 // If we are negative, we need to decrement the significand.
3810 // We only cross a binade boundary that requires adjusting the exponent
3812 // 1. exponent != semantics->minExponent. This implies we are not in the
3813 // smallest binade or are dealing with denormals.
3814 // 2. Our significand excluding the integral bit is all zeros.
3815 bool WillCrossBinadeBoundary =
3816 exponent != semantics->minExponent && isSignificandAllZeros();
3818 // Decrement the significand.
3820 // We always do this since:
3821 // 1. If we are dealing with a non binade decrement, by definition we
3822 // just decrement the significand.
3823 // 2. If we are dealing with a normal -> normal binade decrement, since
3824 // we have an explicit integral bit the fact that all bits but the
3825 // integral bit are zero implies that subtracting one will yield a
3826 // significand with 0 integral bit and 1 in all other spots. Thus we
3827 // must just adjust the exponent and set the integral bit to 1.
3828 // 3. If we are dealing with a normal -> denormal binade decrement,
3829 // since we set the integral bit to 0 when we represent denormals, we
3830 // just decrement the significand.
3831 integerPart *Parts = significandParts();
3832 APInt::tcDecrement(Parts, partCount());
3834 if (WillCrossBinadeBoundary) {
3835 // Our result is a normal number. Do the following:
3836 // 1. Set the integral bit to 1.
3837 // 2. Decrement the exponent.
3838 APInt::tcSetBit(Parts, semantics->precision - 1);
3842 // If we are positive, we need to increment the significand.
3844 // We only cross a binade boundary that requires adjusting the exponent if
3845 // the input is not a denormal and all of said input's significand bits
3846 // are set. If all of said conditions are true: clear the significand, set
3847 // the integral bit to 1, and increment the exponent. If we have a
3848 // denormal always increment since moving denormals and the numbers in the
3849 // smallest normal binade have the same exponent in our representation.
3850 bool WillCrossBinadeBoundary = !isDenormal() && isSignificandAllOnes();
3852 if (WillCrossBinadeBoundary) {
3853 integerPart *Parts = significandParts();
3854 APInt::tcSet(Parts, 0, partCount());
3855 APInt::tcSetBit(Parts, semantics->precision - 1);
3856 assert(exponent != semantics->maxExponent &&
3857 "We can not increment an exponent beyond the maxExponent allowed"
3858 " by the given floating point semantics.");
3861 incrementSignificand();
3867 // If we are performing nextDown, swap sign so we have -nextUp(-x)
3875 APFloat::makeInf(bool Negative) {
3876 category = fcInfinity;
3878 exponent = semantics->maxExponent + 1;
3879 APInt::tcSet(significandParts(), 0, partCount());
3883 APFloat::makeZero(bool Negative) {
3886 exponent = semantics->minExponent-1;
3887 APInt::tcSet(significandParts(), 0, partCount());