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/FoldingSet.h"
19 #include "llvm/Support/MathExtras.h"
23 #define convolve(lhs, rhs) ((lhs) * 4 + (rhs))
25 /* Assumed in hexadecimal significand parsing, and conversion to
26 hexadecimal strings. */
27 #define COMPILE_TIME_ASSERT(cond) extern int CTAssert[(cond) ? 1 : -1]
28 COMPILE_TIME_ASSERT(integerPartWidth % 4 == 0);
32 /* Represents floating point arithmetic semantics. */
34 /* The largest E such that 2^E is representable; this matches the
35 definition of IEEE 754. */
36 exponent_t maxExponent;
38 /* The smallest E such that 2^E is a normalized number; this
39 matches the definition of IEEE 754. */
40 exponent_t minExponent;
42 /* Number of bits in the significand. This includes the integer
44 unsigned int precision;
46 /* True if arithmetic is supported. */
47 unsigned int arithmeticOK;
50 const fltSemantics APFloat::IEEEsingle = { 127, -126, 24, true };
51 const fltSemantics APFloat::IEEEdouble = { 1023, -1022, 53, true };
52 const fltSemantics APFloat::IEEEquad = { 16383, -16382, 113, true };
53 const fltSemantics APFloat::x87DoubleExtended = { 16383, -16382, 64, true };
54 const fltSemantics APFloat::Bogus = { 0, 0, 0, true };
56 // The PowerPC format consists of two doubles. It does not map cleanly
57 // onto the usual format above. For now only storage of constants of
58 // this type is supported, no arithmetic.
59 const fltSemantics APFloat::PPCDoubleDouble = { 1023, -1022, 106, false };
61 /* A tight upper bound on number of parts required to hold the value
64 power * 815 / (351 * integerPartWidth) + 1
66 However, whilst the result may require only this many parts,
67 because we are multiplying two values to get it, the
68 multiplication may require an extra part with the excess part
69 being zero (consider the trivial case of 1 * 1, tcFullMultiply
70 requires two parts to hold the single-part result). So we add an
71 extra one to guarantee enough space whilst multiplying. */
72 const unsigned int maxExponent = 16383;
73 const unsigned int maxPrecision = 113;
74 const unsigned int maxPowerOfFiveExponent = maxExponent + maxPrecision - 1;
75 const unsigned int maxPowerOfFiveParts = 2 + ((maxPowerOfFiveExponent * 815)
76 / (351 * integerPartWidth));
79 /* Put a bunch of private, handy routines in an anonymous namespace. */
82 static inline unsigned int
83 partCountForBits(unsigned int bits)
85 return ((bits) + integerPartWidth - 1) / integerPartWidth;
88 /* Returns 0U-9U. Return values >= 10U are not digits. */
89 static inline unsigned int
90 decDigitValue(unsigned int c)
96 hexDigitValue(unsigned int c)
116 assertArithmeticOK(const llvm::fltSemantics &semantics) {
117 assert(semantics.arithmeticOK
118 && "Compile-time arithmetic does not support these semantics");
121 /* Return the value of a decimal exponent of the form
124 If the exponent overflows, returns a large exponent with the
127 readExponent(const char *p)
130 unsigned int absExponent;
131 const unsigned int overlargeExponent = 24000; /* FIXME. */
133 isNegative = (*p == '-');
134 if (*p == '-' || *p == '+')
137 absExponent = decDigitValue(*p++);
138 assert (absExponent < 10U);
143 value = decDigitValue(*p);
148 value += absExponent * 10;
149 if (absExponent >= overlargeExponent) {
150 absExponent = overlargeExponent;
157 return -(int) absExponent;
159 return (int) absExponent;
162 /* This is ugly and needs cleaning up, but I don't immediately see
163 how whilst remaining safe. */
165 totalExponent(const char *p, int exponentAdjustment)
167 int unsignedExponent;
168 bool negative, overflow;
171 /* Move past the exponent letter and sign to the digits. */
173 negative = *p == '-';
174 if(*p == '-' || *p == '+')
177 unsignedExponent = 0;
182 value = decDigitValue(*p);
187 unsignedExponent = unsignedExponent * 10 + value;
188 if(unsignedExponent > 65535)
192 if(exponentAdjustment > 65535 || exponentAdjustment < -65536)
196 exponent = unsignedExponent;
198 exponent = -exponent;
199 exponent += exponentAdjustment;
200 if(exponent > 65535 || exponent < -65536)
205 exponent = negative ? -65536: 65535;
211 skipLeadingZeroesAndAnyDot(const char *p, const char **dot)
226 /* Given a normal decimal floating point number of the form
230 where the decimal point and exponent are optional, fill out the
231 structure D. Exponent is appropriate if the significand is
232 treated as an integer, and normalizedExponent if the significand
233 is taken to have the decimal point after a single leading
236 If the value is zero, V->firstSigDigit points to a non-digit, and
237 the return exponent is zero.
240 const char *firstSigDigit;
241 const char *lastSigDigit;
243 int normalizedExponent;
247 interpretDecimal(const char *p, decimalInfo *D)
251 p = skipLeadingZeroesAndAnyDot (p, &dot);
253 D->firstSigDigit = p;
255 D->normalizedExponent = 0;
262 if (decDigitValue(*p) >= 10U)
267 /* If number is all zerooes accept any exponent. */
268 if (p != D->firstSigDigit) {
269 if (*p == 'e' || *p == 'E')
270 D->exponent = readExponent(p + 1);
272 /* Implied decimal point? */
276 /* Drop insignificant trailing zeroes. */
283 /* Adjust the exponents for any decimal point. */
284 D->exponent += static_cast<exponent_t>((dot - p) - (dot > p));
285 D->normalizedExponent = (D->exponent +
286 static_cast<exponent_t>((p - D->firstSigDigit)
287 - (dot > D->firstSigDigit && dot < p)));
293 /* Return the trailing fraction of a hexadecimal number.
294 DIGITVALUE is the first hex digit of the fraction, P points to
297 trailingHexadecimalFraction(const char *p, unsigned int digitValue)
299 unsigned int hexDigit;
301 /* If the first trailing digit isn't 0 or 8 we can work out the
302 fraction immediately. */
304 return lfMoreThanHalf;
305 else if(digitValue < 8 && digitValue > 0)
306 return lfLessThanHalf;
308 /* Otherwise we need to find the first non-zero digit. */
312 hexDigit = hexDigitValue(*p);
314 /* If we ran off the end it is exactly zero or one-half, otherwise
317 return digitValue == 0 ? lfExactlyZero: lfExactlyHalf;
319 return digitValue == 0 ? lfLessThanHalf: lfMoreThanHalf;
322 /* Return the fraction lost were a bignum truncated losing the least
323 significant BITS bits. */
325 lostFractionThroughTruncation(const integerPart *parts,
326 unsigned int partCount,
331 lsb = APInt::tcLSB(parts, partCount);
333 /* Note this is guaranteed true if bits == 0, or LSB == -1U. */
335 return lfExactlyZero;
337 return lfExactlyHalf;
338 if(bits <= partCount * integerPartWidth
339 && APInt::tcExtractBit(parts, bits - 1))
340 return lfMoreThanHalf;
342 return lfLessThanHalf;
345 /* Shift DST right BITS bits noting lost fraction. */
347 shiftRight(integerPart *dst, unsigned int parts, unsigned int bits)
349 lostFraction lost_fraction;
351 lost_fraction = lostFractionThroughTruncation(dst, parts, bits);
353 APInt::tcShiftRight(dst, parts, bits);
355 return lost_fraction;
358 /* Combine the effect of two lost fractions. */
360 combineLostFractions(lostFraction moreSignificant,
361 lostFraction lessSignificant)
363 if(lessSignificant != lfExactlyZero) {
364 if(moreSignificant == lfExactlyZero)
365 moreSignificant = lfLessThanHalf;
366 else if(moreSignificant == lfExactlyHalf)
367 moreSignificant = lfMoreThanHalf;
370 return moreSignificant;
373 /* The error from the true value, in half-ulps, on multiplying two
374 floating point numbers, which differ from the value they
375 approximate by at most HUE1 and HUE2 half-ulps, is strictly less
376 than the returned value.
378 See "How to Read Floating Point Numbers Accurately" by William D
381 HUerrBound(bool inexactMultiply, unsigned int HUerr1, unsigned int HUerr2)
383 assert(HUerr1 < 2 || HUerr2 < 2 || (HUerr1 + HUerr2 < 8));
385 if (HUerr1 + HUerr2 == 0)
386 return inexactMultiply * 2; /* <= inexactMultiply half-ulps. */
388 return inexactMultiply + 2 * (HUerr1 + HUerr2);
391 /* The number of ulps from the boundary (zero, or half if ISNEAREST)
392 when the least significant BITS are truncated. BITS cannot be
395 ulpsFromBoundary(const integerPart *parts, unsigned int bits, bool isNearest)
397 unsigned int count, partBits;
398 integerPart part, boundary;
403 count = bits / integerPartWidth;
404 partBits = bits % integerPartWidth + 1;
406 part = parts[count] & (~(integerPart) 0 >> (integerPartWidth - partBits));
409 boundary = (integerPart) 1 << (partBits - 1);
414 if (part - boundary <= boundary - part)
415 return part - boundary;
417 return boundary - part;
420 if (part == boundary) {
423 return ~(integerPart) 0; /* A lot. */
426 } else if (part == boundary - 1) {
429 return ~(integerPart) 0; /* A lot. */
434 return ~(integerPart) 0; /* A lot. */
437 /* Place pow(5, power) in DST, and return the number of parts used.
438 DST must be at least one part larger than size of the answer. */
440 powerOf5(integerPart *dst, unsigned int power)
442 static const integerPart firstEightPowers[] = { 1, 5, 25, 125, 625, 3125,
444 static integerPart pow5s[maxPowerOfFiveParts * 2 + 5] = { 78125 * 5 };
445 static unsigned int partsCount[16] = { 1 };
447 integerPart scratch[maxPowerOfFiveParts], *p1, *p2, *pow5;
450 assert(power <= maxExponent);
455 *p1 = firstEightPowers[power & 7];
461 for (unsigned int n = 0; power; power >>= 1, n++) {
466 /* Calculate pow(5,pow(2,n+3)) if we haven't yet. */
468 pc = partsCount[n - 1];
469 APInt::tcFullMultiply(pow5, pow5 - pc, pow5 - pc, pc, pc);
471 if (pow5[pc - 1] == 0)
479 APInt::tcFullMultiply(p2, p1, pow5, result, pc);
481 if (p2[result - 1] == 0)
484 /* Now result is in p1 with partsCount parts and p2 is scratch
486 tmp = p1, p1 = p2, p2 = tmp;
493 APInt::tcAssign(dst, p1, result);
498 /* Zero at the end to avoid modular arithmetic when adding one; used
499 when rounding up during hexadecimal output. */
500 static const char hexDigitsLower[] = "0123456789abcdef0";
501 static const char hexDigitsUpper[] = "0123456789ABCDEF0";
502 static const char infinityL[] = "infinity";
503 static const char infinityU[] = "INFINITY";
504 static const char NaNL[] = "nan";
505 static const char NaNU[] = "NAN";
507 /* Write out an integerPart in hexadecimal, starting with the most
508 significant nibble. Write out exactly COUNT hexdigits, return
511 partAsHex (char *dst, integerPart part, unsigned int count,
512 const char *hexDigitChars)
514 unsigned int result = count;
516 assert (count != 0 && count <= integerPartWidth / 4);
518 part >>= (integerPartWidth - 4 * count);
520 dst[count] = hexDigitChars[part & 0xf];
527 /* Write out an unsigned decimal integer. */
529 writeUnsignedDecimal (char *dst, unsigned int n)
545 /* Write out a signed decimal integer. */
547 writeSignedDecimal (char *dst, int value)
551 dst = writeUnsignedDecimal(dst, -(unsigned) value);
553 dst = writeUnsignedDecimal(dst, value);
561 APFloat::initialize(const fltSemantics *ourSemantics)
565 semantics = ourSemantics;
568 significand.parts = new integerPart[count];
572 APFloat::freeSignificand()
575 delete [] significand.parts;
579 APFloat::assign(const APFloat &rhs)
581 assert(semantics == rhs.semantics);
584 category = rhs.category;
585 exponent = rhs.exponent;
587 exponent2 = rhs.exponent2;
588 if(category == fcNormal || category == fcNaN)
589 copySignificand(rhs);
593 APFloat::copySignificand(const APFloat &rhs)
595 assert(category == fcNormal || category == fcNaN);
596 assert(rhs.partCount() >= partCount());
598 APInt::tcAssign(significandParts(), rhs.significandParts(),
602 /* Make this number a NaN, with an arbitrary but deterministic value
603 for the significand. */
605 APFloat::makeNaN(void)
608 APInt::tcSet(significandParts(), ~0U, partCount());
612 APFloat::operator=(const APFloat &rhs)
615 if(semantics != rhs.semantics) {
617 initialize(rhs.semantics);
626 APFloat::bitwiseIsEqual(const APFloat &rhs) const {
629 if (semantics != rhs.semantics ||
630 category != rhs.category ||
633 if (semantics==(const llvm::fltSemantics*)&PPCDoubleDouble &&
636 if (category==fcZero || category==fcInfinity)
638 else if (category==fcNormal && exponent!=rhs.exponent)
640 else if (semantics==(const llvm::fltSemantics*)&PPCDoubleDouble &&
641 exponent2!=rhs.exponent2)
645 const integerPart* p=significandParts();
646 const integerPart* q=rhs.significandParts();
647 for (; i>0; i--, p++, q++) {
655 APFloat::APFloat(const fltSemantics &ourSemantics, integerPart value)
657 assertArithmeticOK(ourSemantics);
658 initialize(&ourSemantics);
661 exponent = ourSemantics.precision - 1;
662 significandParts()[0] = value;
663 normalize(rmNearestTiesToEven, lfExactlyZero);
666 APFloat::APFloat(const fltSemantics &ourSemantics,
667 fltCategory ourCategory, bool negative)
669 assertArithmeticOK(ourSemantics);
670 initialize(&ourSemantics);
671 category = ourCategory;
673 if(category == fcNormal)
675 else if (ourCategory == fcNaN)
679 APFloat::APFloat(const fltSemantics &ourSemantics, const char *text)
681 assertArithmeticOK(ourSemantics);
682 initialize(&ourSemantics);
683 convertFromString(text, rmNearestTiesToEven);
686 APFloat::APFloat(const APFloat &rhs)
688 initialize(rhs.semantics);
697 // Profile - This method 'profiles' an APFloat for use with FoldingSet.
698 void APFloat::Profile(FoldingSetNodeID& ID) const {
699 ID.Add(convertToAPInt());
703 APFloat::partCount() const
705 return partCountForBits(semantics->precision + 1);
709 APFloat::semanticsPrecision(const fltSemantics &semantics)
711 return semantics.precision;
715 APFloat::significandParts() const
717 return const_cast<APFloat *>(this)->significandParts();
721 APFloat::significandParts()
723 assert(category == fcNormal || category == fcNaN);
726 return significand.parts;
728 return &significand.part;
732 APFloat::zeroSignificand()
735 APInt::tcSet(significandParts(), 0, partCount());
738 /* Increment an fcNormal floating point number's significand. */
740 APFloat::incrementSignificand()
744 carry = APInt::tcIncrement(significandParts(), partCount());
746 /* Our callers should never cause us to overflow. */
750 /* Add the significand of the RHS. Returns the carry flag. */
752 APFloat::addSignificand(const APFloat &rhs)
756 parts = significandParts();
758 assert(semantics == rhs.semantics);
759 assert(exponent == rhs.exponent);
761 return APInt::tcAdd(parts, rhs.significandParts(), 0, partCount());
764 /* Subtract the significand of the RHS with a borrow flag. Returns
767 APFloat::subtractSignificand(const APFloat &rhs, integerPart borrow)
771 parts = significandParts();
773 assert(semantics == rhs.semantics);
774 assert(exponent == rhs.exponent);
776 return APInt::tcSubtract(parts, rhs.significandParts(), borrow,
780 /* Multiply the significand of the RHS. If ADDEND is non-NULL, add it
781 on to the full-precision result of the multiplication. Returns the
784 APFloat::multiplySignificand(const APFloat &rhs, const APFloat *addend)
786 unsigned int omsb; // One, not zero, based MSB.
787 unsigned int partsCount, newPartsCount, precision;
788 integerPart *lhsSignificand;
789 integerPart scratch[4];
790 integerPart *fullSignificand;
791 lostFraction lost_fraction;
793 assert(semantics == rhs.semantics);
795 precision = semantics->precision;
796 newPartsCount = partCountForBits(precision * 2);
798 if(newPartsCount > 4)
799 fullSignificand = new integerPart[newPartsCount];
801 fullSignificand = scratch;
803 lhsSignificand = significandParts();
804 partsCount = partCount();
806 APInt::tcFullMultiply(fullSignificand, lhsSignificand,
807 rhs.significandParts(), partsCount, partsCount);
809 lost_fraction = lfExactlyZero;
810 omsb = APInt::tcMSB(fullSignificand, newPartsCount) + 1;
811 exponent += rhs.exponent;
814 Significand savedSignificand = significand;
815 const fltSemantics *savedSemantics = semantics;
816 fltSemantics extendedSemantics;
818 unsigned int extendedPrecision;
820 /* Normalize our MSB. */
821 extendedPrecision = precision + precision - 1;
822 if(omsb != extendedPrecision)
824 APInt::tcShiftLeft(fullSignificand, newPartsCount,
825 extendedPrecision - omsb);
826 exponent -= extendedPrecision - omsb;
829 /* Create new semantics. */
830 extendedSemantics = *semantics;
831 extendedSemantics.precision = extendedPrecision;
833 if(newPartsCount == 1)
834 significand.part = fullSignificand[0];
836 significand.parts = fullSignificand;
837 semantics = &extendedSemantics;
839 APFloat extendedAddend(*addend);
840 status = extendedAddend.convert(extendedSemantics, rmTowardZero);
841 assert(status == opOK);
842 lost_fraction = addOrSubtractSignificand(extendedAddend, false);
844 /* Restore our state. */
845 if(newPartsCount == 1)
846 fullSignificand[0] = significand.part;
847 significand = savedSignificand;
848 semantics = savedSemantics;
850 omsb = APInt::tcMSB(fullSignificand, newPartsCount) + 1;
853 exponent -= (precision - 1);
855 if(omsb > precision) {
856 unsigned int bits, significantParts;
859 bits = omsb - precision;
860 significantParts = partCountForBits(omsb);
861 lf = shiftRight(fullSignificand, significantParts, bits);
862 lost_fraction = combineLostFractions(lf, lost_fraction);
866 APInt::tcAssign(lhsSignificand, fullSignificand, partsCount);
868 if(newPartsCount > 4)
869 delete [] fullSignificand;
871 return lost_fraction;
874 /* Multiply the significands of LHS and RHS to DST. */
876 APFloat::divideSignificand(const APFloat &rhs)
878 unsigned int bit, i, partsCount;
879 const integerPart *rhsSignificand;
880 integerPart *lhsSignificand, *dividend, *divisor;
881 integerPart scratch[4];
882 lostFraction lost_fraction;
884 assert(semantics == rhs.semantics);
886 lhsSignificand = significandParts();
887 rhsSignificand = rhs.significandParts();
888 partsCount = partCount();
891 dividend = new integerPart[partsCount * 2];
895 divisor = dividend + partsCount;
897 /* Copy the dividend and divisor as they will be modified in-place. */
898 for(i = 0; i < partsCount; i++) {
899 dividend[i] = lhsSignificand[i];
900 divisor[i] = rhsSignificand[i];
901 lhsSignificand[i] = 0;
904 exponent -= rhs.exponent;
906 unsigned int precision = semantics->precision;
908 /* Normalize the divisor. */
909 bit = precision - APInt::tcMSB(divisor, partsCount) - 1;
912 APInt::tcShiftLeft(divisor, partsCount, bit);
915 /* Normalize the dividend. */
916 bit = precision - APInt::tcMSB(dividend, partsCount) - 1;
919 APInt::tcShiftLeft(dividend, partsCount, bit);
922 /* Ensure the dividend >= divisor initially for the loop below.
923 Incidentally, this means that the division loop below is
924 guaranteed to set the integer bit to one. */
925 if(APInt::tcCompare(dividend, divisor, partsCount) < 0) {
927 APInt::tcShiftLeft(dividend, partsCount, 1);
928 assert(APInt::tcCompare(dividend, divisor, partsCount) >= 0);
932 for(bit = precision; bit; bit -= 1) {
933 if(APInt::tcCompare(dividend, divisor, partsCount) >= 0) {
934 APInt::tcSubtract(dividend, divisor, 0, partsCount);
935 APInt::tcSetBit(lhsSignificand, bit - 1);
938 APInt::tcShiftLeft(dividend, partsCount, 1);
941 /* Figure out the lost fraction. */
942 int cmp = APInt::tcCompare(dividend, divisor, partsCount);
945 lost_fraction = lfMoreThanHalf;
947 lost_fraction = lfExactlyHalf;
948 else if(APInt::tcIsZero(dividend, partsCount))
949 lost_fraction = lfExactlyZero;
951 lost_fraction = lfLessThanHalf;
956 return lost_fraction;
960 APFloat::significandMSB() const
962 return APInt::tcMSB(significandParts(), partCount());
966 APFloat::significandLSB() const
968 return APInt::tcLSB(significandParts(), partCount());
971 /* Note that a zero result is NOT normalized to fcZero. */
973 APFloat::shiftSignificandRight(unsigned int bits)
975 /* Our exponent should not overflow. */
976 assert((exponent_t) (exponent + bits) >= exponent);
980 return shiftRight(significandParts(), partCount(), bits);
983 /* Shift the significand left BITS bits, subtract BITS from its exponent. */
985 APFloat::shiftSignificandLeft(unsigned int bits)
987 assert(bits < semantics->precision);
990 unsigned int partsCount = partCount();
992 APInt::tcShiftLeft(significandParts(), partsCount, bits);
995 assert(!APInt::tcIsZero(significandParts(), partsCount));
1000 APFloat::compareAbsoluteValue(const APFloat &rhs) const
1004 assert(semantics == rhs.semantics);
1005 assert(category == fcNormal);
1006 assert(rhs.category == fcNormal);
1008 compare = exponent - rhs.exponent;
1010 /* If exponents are equal, do an unsigned bignum comparison of the
1013 compare = APInt::tcCompare(significandParts(), rhs.significandParts(),
1017 return cmpGreaterThan;
1018 else if(compare < 0)
1024 /* Handle overflow. Sign is preserved. We either become infinity or
1025 the largest finite number. */
1027 APFloat::handleOverflow(roundingMode rounding_mode)
1030 if(rounding_mode == rmNearestTiesToEven
1031 || rounding_mode == rmNearestTiesToAway
1032 || (rounding_mode == rmTowardPositive && !sign)
1033 || (rounding_mode == rmTowardNegative && sign))
1035 category = fcInfinity;
1036 return (opStatus) (opOverflow | opInexact);
1039 /* Otherwise we become the largest finite number. */
1040 category = fcNormal;
1041 exponent = semantics->maxExponent;
1042 APInt::tcSetLeastSignificantBits(significandParts(), partCount(),
1043 semantics->precision);
1048 /* Returns TRUE if, when truncating the current number, with BIT the
1049 new LSB, with the given lost fraction and rounding mode, the result
1050 would need to be rounded away from zero (i.e., by increasing the
1051 signficand). This routine must work for fcZero of both signs, and
1052 fcNormal numbers. */
1054 APFloat::roundAwayFromZero(roundingMode rounding_mode,
1055 lostFraction lost_fraction,
1056 unsigned int bit) const
1058 /* NaNs and infinities should not have lost fractions. */
1059 assert(category == fcNormal || category == fcZero);
1061 /* Current callers never pass this so we don't handle it. */
1062 assert(lost_fraction != lfExactlyZero);
1064 switch(rounding_mode) {
1068 case rmNearestTiesToAway:
1069 return lost_fraction == lfExactlyHalf || lost_fraction == lfMoreThanHalf;
1071 case rmNearestTiesToEven:
1072 if(lost_fraction == lfMoreThanHalf)
1075 /* Our zeroes don't have a significand to test. */
1076 if(lost_fraction == lfExactlyHalf && category != fcZero)
1077 return APInt::tcExtractBit(significandParts(), bit);
1084 case rmTowardPositive:
1085 return sign == false;
1087 case rmTowardNegative:
1088 return sign == true;
1093 APFloat::normalize(roundingMode rounding_mode,
1094 lostFraction lost_fraction)
1096 unsigned int omsb; /* One, not zero, based MSB. */
1099 if(category != fcNormal)
1102 /* Before rounding normalize the exponent of fcNormal numbers. */
1103 omsb = significandMSB() + 1;
1106 /* OMSB is numbered from 1. We want to place it in the integer
1107 bit numbered PRECISON if possible, with a compensating change in
1109 exponentChange = omsb - semantics->precision;
1111 /* If the resulting exponent is too high, overflow according to
1112 the rounding mode. */
1113 if(exponent + exponentChange > semantics->maxExponent)
1114 return handleOverflow(rounding_mode);
1116 /* Subnormal numbers have exponent minExponent, and their MSB
1117 is forced based on that. */
1118 if(exponent + exponentChange < semantics->minExponent)
1119 exponentChange = semantics->minExponent - exponent;
1121 /* Shifting left is easy as we don't lose precision. */
1122 if(exponentChange < 0) {
1123 assert(lost_fraction == lfExactlyZero);
1125 shiftSignificandLeft(-exponentChange);
1130 if(exponentChange > 0) {
1133 /* Shift right and capture any new lost fraction. */
1134 lf = shiftSignificandRight(exponentChange);
1136 lost_fraction = combineLostFractions(lf, lost_fraction);
1138 /* Keep OMSB up-to-date. */
1139 if(omsb > (unsigned) exponentChange)
1140 omsb -= exponentChange;
1146 /* Now round the number according to rounding_mode given the lost
1149 /* As specified in IEEE 754, since we do not trap we do not report
1150 underflow for exact results. */
1151 if(lost_fraction == lfExactlyZero) {
1152 /* Canonicalize zeroes. */
1159 /* Increment the significand if we're rounding away from zero. */
1160 if(roundAwayFromZero(rounding_mode, lost_fraction, 0)) {
1162 exponent = semantics->minExponent;
1164 incrementSignificand();
1165 omsb = significandMSB() + 1;
1167 /* Did the significand increment overflow? */
1168 if(omsb == (unsigned) semantics->precision + 1) {
1169 /* Renormalize by incrementing the exponent and shifting our
1170 significand right one. However if we already have the
1171 maximum exponent we overflow to infinity. */
1172 if(exponent == semantics->maxExponent) {
1173 category = fcInfinity;
1175 return (opStatus) (opOverflow | opInexact);
1178 shiftSignificandRight(1);
1184 /* The normal case - we were and are not denormal, and any
1185 significand increment above didn't overflow. */
1186 if(omsb == semantics->precision)
1189 /* We have a non-zero denormal. */
1190 assert(omsb < semantics->precision);
1192 /* Canonicalize zeroes. */
1196 /* The fcZero case is a denormal that underflowed to zero. */
1197 return (opStatus) (opUnderflow | opInexact);
1201 APFloat::addOrSubtractSpecials(const APFloat &rhs, bool subtract)
1203 switch(convolve(category, rhs.category)) {
1207 case convolve(fcNaN, fcZero):
1208 case convolve(fcNaN, fcNormal):
1209 case convolve(fcNaN, fcInfinity):
1210 case convolve(fcNaN, fcNaN):
1211 case convolve(fcNormal, fcZero):
1212 case convolve(fcInfinity, fcNormal):
1213 case convolve(fcInfinity, fcZero):
1216 case convolve(fcZero, fcNaN):
1217 case convolve(fcNormal, fcNaN):
1218 case convolve(fcInfinity, fcNaN):
1220 copySignificand(rhs);
1223 case convolve(fcNormal, fcInfinity):
1224 case convolve(fcZero, fcInfinity):
1225 category = fcInfinity;
1226 sign = rhs.sign ^ subtract;
1229 case convolve(fcZero, fcNormal):
1231 sign = rhs.sign ^ subtract;
1234 case convolve(fcZero, fcZero):
1235 /* Sign depends on rounding mode; handled by caller. */
1238 case convolve(fcInfinity, fcInfinity):
1239 /* Differently signed infinities can only be validly
1241 if((sign ^ rhs.sign) != subtract) {
1248 case convolve(fcNormal, fcNormal):
1253 /* Add or subtract two normal numbers. */
1255 APFloat::addOrSubtractSignificand(const APFloat &rhs, bool subtract)
1258 lostFraction lost_fraction;
1261 /* Determine if the operation on the absolute values is effectively
1262 an addition or subtraction. */
1263 subtract ^= (sign ^ rhs.sign) ? true : false;
1265 /* Are we bigger exponent-wise than the RHS? */
1266 bits = exponent - rhs.exponent;
1268 /* Subtraction is more subtle than one might naively expect. */
1270 APFloat temp_rhs(rhs);
1274 reverse = compareAbsoluteValue(temp_rhs) == cmpLessThan;
1275 lost_fraction = lfExactlyZero;
1276 } else if (bits > 0) {
1277 lost_fraction = temp_rhs.shiftSignificandRight(bits - 1);
1278 shiftSignificandLeft(1);
1281 lost_fraction = shiftSignificandRight(-bits - 1);
1282 temp_rhs.shiftSignificandLeft(1);
1287 carry = temp_rhs.subtractSignificand
1288 (*this, lost_fraction != lfExactlyZero);
1289 copySignificand(temp_rhs);
1292 carry = subtractSignificand
1293 (temp_rhs, lost_fraction != lfExactlyZero);
1296 /* Invert the lost fraction - it was on the RHS and
1298 if(lost_fraction == lfLessThanHalf)
1299 lost_fraction = lfMoreThanHalf;
1300 else if(lost_fraction == lfMoreThanHalf)
1301 lost_fraction = lfLessThanHalf;
1303 /* The code above is intended to ensure that no borrow is
1308 APFloat temp_rhs(rhs);
1310 lost_fraction = temp_rhs.shiftSignificandRight(bits);
1311 carry = addSignificand(temp_rhs);
1313 lost_fraction = shiftSignificandRight(-bits);
1314 carry = addSignificand(rhs);
1317 /* We have a guard bit; generating a carry cannot happen. */
1321 return lost_fraction;
1325 APFloat::multiplySpecials(const APFloat &rhs)
1327 switch(convolve(category, rhs.category)) {
1331 case convolve(fcNaN, fcZero):
1332 case convolve(fcNaN, fcNormal):
1333 case convolve(fcNaN, fcInfinity):
1334 case convolve(fcNaN, fcNaN):
1337 case convolve(fcZero, fcNaN):
1338 case convolve(fcNormal, fcNaN):
1339 case convolve(fcInfinity, fcNaN):
1341 copySignificand(rhs);
1344 case convolve(fcNormal, fcInfinity):
1345 case convolve(fcInfinity, fcNormal):
1346 case convolve(fcInfinity, fcInfinity):
1347 category = fcInfinity;
1350 case convolve(fcZero, fcNormal):
1351 case convolve(fcNormal, fcZero):
1352 case convolve(fcZero, fcZero):
1356 case convolve(fcZero, fcInfinity):
1357 case convolve(fcInfinity, fcZero):
1361 case convolve(fcNormal, fcNormal):
1367 APFloat::divideSpecials(const APFloat &rhs)
1369 switch(convolve(category, rhs.category)) {
1373 case convolve(fcNaN, fcZero):
1374 case convolve(fcNaN, fcNormal):
1375 case convolve(fcNaN, fcInfinity):
1376 case convolve(fcNaN, fcNaN):
1377 case convolve(fcInfinity, fcZero):
1378 case convolve(fcInfinity, fcNormal):
1379 case convolve(fcZero, fcInfinity):
1380 case convolve(fcZero, fcNormal):
1383 case convolve(fcZero, fcNaN):
1384 case convolve(fcNormal, fcNaN):
1385 case convolve(fcInfinity, fcNaN):
1387 copySignificand(rhs);
1390 case convolve(fcNormal, fcInfinity):
1394 case convolve(fcNormal, fcZero):
1395 category = fcInfinity;
1398 case convolve(fcInfinity, fcInfinity):
1399 case convolve(fcZero, fcZero):
1403 case convolve(fcNormal, fcNormal):
1410 APFloat::changeSign()
1412 /* Look mummy, this one's easy. */
1417 APFloat::clearSign()
1419 /* So is this one. */
1424 APFloat::copySign(const APFloat &rhs)
1430 /* Normalized addition or subtraction. */
1432 APFloat::addOrSubtract(const APFloat &rhs, roundingMode rounding_mode,
1437 assertArithmeticOK(*semantics);
1439 fs = addOrSubtractSpecials(rhs, subtract);
1441 /* This return code means it was not a simple case. */
1442 if(fs == opDivByZero) {
1443 lostFraction lost_fraction;
1445 lost_fraction = addOrSubtractSignificand(rhs, subtract);
1446 fs = normalize(rounding_mode, lost_fraction);
1448 /* Can only be zero if we lost no fraction. */
1449 assert(category != fcZero || lost_fraction == lfExactlyZero);
1452 /* If two numbers add (exactly) to zero, IEEE 754 decrees it is a
1453 positive zero unless rounding to minus infinity, except that
1454 adding two like-signed zeroes gives that zero. */
1455 if(category == fcZero) {
1456 if(rhs.category != fcZero || (sign == rhs.sign) == subtract)
1457 sign = (rounding_mode == rmTowardNegative);
1463 /* Normalized addition. */
1465 APFloat::add(const APFloat &rhs, roundingMode rounding_mode)
1467 return addOrSubtract(rhs, rounding_mode, false);
1470 /* Normalized subtraction. */
1472 APFloat::subtract(const APFloat &rhs, roundingMode rounding_mode)
1474 return addOrSubtract(rhs, rounding_mode, true);
1477 /* Normalized multiply. */
1479 APFloat::multiply(const APFloat &rhs, roundingMode rounding_mode)
1483 assertArithmeticOK(*semantics);
1485 fs = multiplySpecials(rhs);
1487 if(category == fcNormal) {
1488 lostFraction lost_fraction = multiplySignificand(rhs, 0);
1489 fs = normalize(rounding_mode, lost_fraction);
1490 if(lost_fraction != lfExactlyZero)
1491 fs = (opStatus) (fs | opInexact);
1497 /* Normalized divide. */
1499 APFloat::divide(const APFloat &rhs, roundingMode rounding_mode)
1503 assertArithmeticOK(*semantics);
1505 fs = divideSpecials(rhs);
1507 if(category == fcNormal) {
1508 lostFraction lost_fraction = divideSignificand(rhs);
1509 fs = normalize(rounding_mode, lost_fraction);
1510 if(lost_fraction != lfExactlyZero)
1511 fs = (opStatus) (fs | opInexact);
1517 /* Normalized remainder. This is not currently doing TRT. */
1519 APFloat::mod(const APFloat &rhs, roundingMode rounding_mode)
1523 unsigned int origSign = sign;
1525 assertArithmeticOK(*semantics);
1526 fs = V.divide(rhs, rmNearestTiesToEven);
1527 if (fs == opDivByZero)
1530 int parts = partCount();
1531 integerPart *x = new integerPart[parts];
1532 fs = V.convertToInteger(x, parts * integerPartWidth, true,
1533 rmNearestTiesToEven);
1534 if (fs==opInvalidOp)
1537 fs = V.convertFromZeroExtendedInteger(x, parts * integerPartWidth, true,
1538 rmNearestTiesToEven);
1539 assert(fs==opOK); // should always work
1541 fs = V.multiply(rhs, rounding_mode);
1542 assert(fs==opOK || fs==opInexact); // should not overflow or underflow
1544 fs = subtract(V, rounding_mode);
1545 assert(fs==opOK || fs==opInexact); // likewise
1548 sign = origSign; // IEEE754 requires this
1553 /* Normalized fused-multiply-add. */
1555 APFloat::fusedMultiplyAdd(const APFloat &multiplicand,
1556 const APFloat &addend,
1557 roundingMode rounding_mode)
1561 assertArithmeticOK(*semantics);
1563 /* Post-multiplication sign, before addition. */
1564 sign ^= multiplicand.sign;
1566 /* If and only if all arguments are normal do we need to do an
1567 extended-precision calculation. */
1568 if(category == fcNormal
1569 && multiplicand.category == fcNormal
1570 && addend.category == fcNormal) {
1571 lostFraction lost_fraction;
1573 lost_fraction = multiplySignificand(multiplicand, &addend);
1574 fs = normalize(rounding_mode, lost_fraction);
1575 if(lost_fraction != lfExactlyZero)
1576 fs = (opStatus) (fs | opInexact);
1578 /* If two numbers add (exactly) to zero, IEEE 754 decrees it is a
1579 positive zero unless rounding to minus infinity, except that
1580 adding two like-signed zeroes gives that zero. */
1581 if(category == fcZero && sign != addend.sign)
1582 sign = (rounding_mode == rmTowardNegative);
1584 fs = multiplySpecials(multiplicand);
1586 /* FS can only be opOK or opInvalidOp. There is no more work
1587 to do in the latter case. The IEEE-754R standard says it is
1588 implementation-defined in this case whether, if ADDEND is a
1589 quiet NaN, we raise invalid op; this implementation does so.
1591 If we need to do the addition we can do so with normal
1594 fs = addOrSubtract(addend, rounding_mode, false);
1600 /* Comparison requires normalized numbers. */
1602 APFloat::compare(const APFloat &rhs) const
1606 assertArithmeticOK(*semantics);
1607 assert(semantics == rhs.semantics);
1609 switch(convolve(category, rhs.category)) {
1613 case convolve(fcNaN, fcZero):
1614 case convolve(fcNaN, fcNormal):
1615 case convolve(fcNaN, fcInfinity):
1616 case convolve(fcNaN, fcNaN):
1617 case convolve(fcZero, fcNaN):
1618 case convolve(fcNormal, fcNaN):
1619 case convolve(fcInfinity, fcNaN):
1620 return cmpUnordered;
1622 case convolve(fcInfinity, fcNormal):
1623 case convolve(fcInfinity, fcZero):
1624 case convolve(fcNormal, fcZero):
1628 return cmpGreaterThan;
1630 case convolve(fcNormal, fcInfinity):
1631 case convolve(fcZero, fcInfinity):
1632 case convolve(fcZero, fcNormal):
1634 return cmpGreaterThan;
1638 case convolve(fcInfinity, fcInfinity):
1639 if(sign == rhs.sign)
1644 return cmpGreaterThan;
1646 case convolve(fcZero, fcZero):
1649 case convolve(fcNormal, fcNormal):
1653 /* Two normal numbers. Do they have the same sign? */
1654 if(sign != rhs.sign) {
1656 result = cmpLessThan;
1658 result = cmpGreaterThan;
1660 /* Compare absolute values; invert result if negative. */
1661 result = compareAbsoluteValue(rhs);
1664 if(result == cmpLessThan)
1665 result = cmpGreaterThan;
1666 else if(result == cmpGreaterThan)
1667 result = cmpLessThan;
1675 APFloat::convert(const fltSemantics &toSemantics,
1676 roundingMode rounding_mode)
1678 lostFraction lostFraction;
1679 unsigned int newPartCount, oldPartCount;
1682 assertArithmeticOK(*semantics);
1683 assertArithmeticOK(toSemantics);
1684 lostFraction = lfExactlyZero;
1685 newPartCount = partCountForBits(toSemantics.precision + 1);
1686 oldPartCount = partCount();
1688 /* Handle storage complications. If our new form is wider,
1689 re-allocate our bit pattern into wider storage. If it is
1690 narrower, we ignore the excess parts, but if narrowing to a
1691 single part we need to free the old storage.
1692 Be careful not to reference significandParts for zeroes
1693 and infinities, since it aborts. */
1694 if (newPartCount > oldPartCount) {
1695 integerPart *newParts;
1696 newParts = new integerPart[newPartCount];
1697 APInt::tcSet(newParts, 0, newPartCount);
1698 if (category==fcNormal || category==fcNaN)
1699 APInt::tcAssign(newParts, significandParts(), oldPartCount);
1701 significand.parts = newParts;
1702 } else if (newPartCount < oldPartCount) {
1703 /* Capture any lost fraction through truncation of parts so we get
1704 correct rounding whilst normalizing. */
1705 if (category==fcNormal)
1706 lostFraction = lostFractionThroughTruncation
1707 (significandParts(), oldPartCount, toSemantics.precision);
1708 if (newPartCount == 1) {
1709 integerPart newPart = 0;
1710 if (category==fcNormal || category==fcNaN)
1711 newPart = significandParts()[0];
1713 significand.part = newPart;
1717 if(category == fcNormal) {
1718 /* Re-interpret our bit-pattern. */
1719 exponent += toSemantics.precision - semantics->precision;
1720 semantics = &toSemantics;
1721 fs = normalize(rounding_mode, lostFraction);
1722 } else if (category == fcNaN) {
1723 int shift = toSemantics.precision - semantics->precision;
1724 // Do this now so significandParts gets the right answer
1725 semantics = &toSemantics;
1726 // No normalization here, just truncate
1728 APInt::tcShiftLeft(significandParts(), newPartCount, shift);
1730 APInt::tcShiftRight(significandParts(), newPartCount, -shift);
1731 // gcc forces the Quiet bit on, which means (float)(double)(float_sNan)
1732 // does not give you back the same bits. This is dubious, and we
1733 // don't currently do it. You're really supposed to get
1734 // an invalid operation signal at runtime, but nobody does that.
1737 semantics = &toSemantics;
1744 /* Convert a floating point number to an integer according to the
1745 rounding mode. If the rounded integer value is out of range this
1746 returns an invalid operation exception and the contents of the
1747 destination parts are unspecified. If the rounded value is in
1748 range but the floating point number is not the exact integer, the C
1749 standard doesn't require an inexact exception to be raised. IEEE
1750 854 does require it so we do that.
1752 Note that for conversions to integer type the C standard requires
1753 round-to-zero to always be used. */
1755 APFloat::convertToSignExtendedInteger(integerPart *parts, unsigned int width,
1757 roundingMode rounding_mode) const
1759 lostFraction lost_fraction;
1760 const integerPart *src;
1761 unsigned int dstPartsCount, truncatedBits;
1763 assertArithmeticOK(*semantics);
1765 /* Handle the three special cases first. */
1766 if(category == fcInfinity || category == fcNaN)
1769 dstPartsCount = partCountForBits(width);
1771 if(category == fcZero) {
1772 APInt::tcSet(parts, 0, dstPartsCount);
1776 src = significandParts();
1778 /* Step 1: place our absolute value, with any fraction truncated, in
1781 /* Our absolute value is less than one; truncate everything. */
1782 APInt::tcSet(parts, 0, dstPartsCount);
1783 truncatedBits = semantics->precision;
1785 /* We want the most significant (exponent + 1) bits; the rest are
1787 unsigned int bits = exponent + 1U;
1789 /* Hopelessly large in magnitude? */
1793 if (bits < semantics->precision) {
1794 /* We truncate (semantics->precision - bits) bits. */
1795 truncatedBits = semantics->precision - bits;
1796 APInt::tcExtract(parts, dstPartsCount, src, bits, truncatedBits);
1798 /* We want at least as many bits as are available. */
1799 APInt::tcExtract(parts, dstPartsCount, src, semantics->precision, 0);
1800 APInt::tcShiftLeft(parts, dstPartsCount, bits - semantics->precision);
1805 /* Step 2: work out any lost fraction, and increment the absolute
1806 value if we would round away from zero. */
1807 if (truncatedBits) {
1808 lost_fraction = lostFractionThroughTruncation(src, partCount(),
1810 if (lost_fraction != lfExactlyZero
1811 && roundAwayFromZero(rounding_mode, lost_fraction, truncatedBits)) {
1812 if (APInt::tcIncrement(parts, dstPartsCount))
1813 return opInvalidOp; /* Overflow. */
1816 lost_fraction = lfExactlyZero;
1819 /* Step 3: check if we fit in the destination. */
1820 unsigned int omsb = APInt::tcMSB(parts, dstPartsCount) + 1;
1824 /* Negative numbers cannot be represented as unsigned. */
1828 /* It takes omsb bits to represent the unsigned integer value.
1829 We lose a bit for the sign, but care is needed as the
1830 maximally negative integer is a special case. */
1831 if (omsb == width && APInt::tcLSB(parts, dstPartsCount) + 1 != omsb)
1834 /* This case can happen because of rounding. */
1839 APInt::tcNegate (parts, dstPartsCount);
1841 if (omsb >= width + !isSigned)
1845 if (lost_fraction == lfExactlyZero)
1851 /* Same as convertToSignExtendedInteger, except we provide
1852 deterministic values in case of an invalid operation exception,
1853 namely zero for NaNs and the minimal or maximal value respectively
1854 for underflow or overflow. */
1856 APFloat::convertToInteger(integerPart *parts, unsigned int width,
1858 roundingMode rounding_mode) const
1862 fs = convertToSignExtendedInteger(parts, width, isSigned, rounding_mode);
1864 if (fs == opInvalidOp) {
1865 unsigned int bits, dstPartsCount;
1867 dstPartsCount = partCountForBits(width);
1869 if (category == fcNaN)
1874 bits = width - isSigned;
1876 APInt::tcSetLeastSignificantBits(parts, dstPartsCount, bits);
1877 if (sign && isSigned)
1878 APInt::tcShiftLeft(parts, dstPartsCount, width - 1);
1884 /* Convert an unsigned integer SRC to a floating point number,
1885 rounding according to ROUNDING_MODE. The sign of the floating
1886 point number is not modified. */
1888 APFloat::convertFromUnsignedParts(const integerPart *src,
1889 unsigned int srcCount,
1890 roundingMode rounding_mode)
1892 unsigned int omsb, precision, dstCount;
1894 lostFraction lost_fraction;
1896 assertArithmeticOK(*semantics);
1897 category = fcNormal;
1898 omsb = APInt::tcMSB(src, srcCount) + 1;
1899 dst = significandParts();
1900 dstCount = partCount();
1901 precision = semantics->precision;
1903 /* We want the most significant PRECISON bits of SRC. There may not
1904 be that many; extract what we can. */
1905 if (precision <= omsb) {
1906 exponent = omsb - 1;
1907 lost_fraction = lostFractionThroughTruncation(src, srcCount,
1909 APInt::tcExtract(dst, dstCount, src, precision, omsb - precision);
1911 exponent = precision - 1;
1912 lost_fraction = lfExactlyZero;
1913 APInt::tcExtract(dst, dstCount, src, omsb, 0);
1916 return normalize(rounding_mode, lost_fraction);
1920 APFloat::convertFromAPInt(const APInt &Val,
1922 roundingMode rounding_mode)
1924 unsigned int partCount = Val.getNumWords();
1928 if (isSigned && api.isNegative()) {
1933 return convertFromUnsignedParts(api.getRawData(), partCount, rounding_mode);
1936 /* Convert a two's complement integer SRC to a floating point number,
1937 rounding according to ROUNDING_MODE. ISSIGNED is true if the
1938 integer is signed, in which case it must be sign-extended. */
1940 APFloat::convertFromSignExtendedInteger(const integerPart *src,
1941 unsigned int srcCount,
1943 roundingMode rounding_mode)
1947 assertArithmeticOK(*semantics);
1949 && APInt::tcExtractBit(src, srcCount * integerPartWidth - 1)) {
1952 /* If we're signed and negative negate a copy. */
1954 copy = new integerPart[srcCount];
1955 APInt::tcAssign(copy, src, srcCount);
1956 APInt::tcNegate(copy, srcCount);
1957 status = convertFromUnsignedParts(copy, srcCount, rounding_mode);
1961 status = convertFromUnsignedParts(src, srcCount, rounding_mode);
1967 /* FIXME: should this just take a const APInt reference? */
1969 APFloat::convertFromZeroExtendedInteger(const integerPart *parts,
1970 unsigned int width, bool isSigned,
1971 roundingMode rounding_mode)
1973 unsigned int partCount = partCountForBits(width);
1974 APInt api = APInt(width, partCount, parts);
1977 if(isSigned && APInt::tcExtractBit(parts, width - 1)) {
1982 return convertFromUnsignedParts(api.getRawData(), partCount, rounding_mode);
1986 APFloat::convertFromHexadecimalString(const char *p,
1987 roundingMode rounding_mode)
1989 lostFraction lost_fraction;
1990 integerPart *significand;
1991 unsigned int bitPos, partsCount;
1992 const char *dot, *firstSignificantDigit;
1996 category = fcNormal;
1998 significand = significandParts();
1999 partsCount = partCount();
2000 bitPos = partsCount * integerPartWidth;
2002 /* Skip leading zeroes and any (hexa)decimal point. */
2003 p = skipLeadingZeroesAndAnyDot(p, &dot);
2004 firstSignificantDigit = p;
2007 integerPart hex_value;
2014 hex_value = hexDigitValue(*p);
2015 if(hex_value == -1U) {
2016 lost_fraction = lfExactlyZero;
2022 /* Store the number whilst 4-bit nibbles remain. */
2025 hex_value <<= bitPos % integerPartWidth;
2026 significand[bitPos / integerPartWidth] |= hex_value;
2028 lost_fraction = trailingHexadecimalFraction(p, hex_value);
2029 while(hexDigitValue(*p) != -1U)
2035 /* Hex floats require an exponent but not a hexadecimal point. */
2036 assert(*p == 'p' || *p == 'P');
2038 /* Ignore the exponent if we are zero. */
2039 if(p != firstSignificantDigit) {
2042 /* Implicit hexadecimal point? */
2046 /* Calculate the exponent adjustment implicit in the number of
2047 significant digits. */
2048 expAdjustment = static_cast<int>(dot - firstSignificantDigit);
2049 if(expAdjustment < 0)
2051 expAdjustment = expAdjustment * 4 - 1;
2053 /* Adjust for writing the significand starting at the most
2054 significant nibble. */
2055 expAdjustment += semantics->precision;
2056 expAdjustment -= partsCount * integerPartWidth;
2058 /* Adjust for the given exponent. */
2059 exponent = totalExponent(p, expAdjustment);
2062 return normalize(rounding_mode, lost_fraction);
2066 APFloat::roundSignificandWithExponent(const integerPart *decSigParts,
2067 unsigned sigPartCount, int exp,
2068 roundingMode rounding_mode)
2070 unsigned int parts, pow5PartCount;
2071 fltSemantics calcSemantics = { 32767, -32767, 0, true };
2072 integerPart pow5Parts[maxPowerOfFiveParts];
2075 isNearest = (rounding_mode == rmNearestTiesToEven
2076 || rounding_mode == rmNearestTiesToAway);
2078 parts = partCountForBits(semantics->precision + 11);
2080 /* Calculate pow(5, abs(exp)). */
2081 pow5PartCount = powerOf5(pow5Parts, exp >= 0 ? exp: -exp);
2083 for (;; parts *= 2) {
2084 opStatus sigStatus, powStatus;
2085 unsigned int excessPrecision, truncatedBits;
2087 calcSemantics.precision = parts * integerPartWidth - 1;
2088 excessPrecision = calcSemantics.precision - semantics->precision;
2089 truncatedBits = excessPrecision;
2091 APFloat decSig(calcSemantics, fcZero, sign);
2092 APFloat pow5(calcSemantics, fcZero, false);
2094 sigStatus = decSig.convertFromUnsignedParts(decSigParts, sigPartCount,
2095 rmNearestTiesToEven);
2096 powStatus = pow5.convertFromUnsignedParts(pow5Parts, pow5PartCount,
2097 rmNearestTiesToEven);
2098 /* Add exp, as 10^n = 5^n * 2^n. */
2099 decSig.exponent += exp;
2101 lostFraction calcLostFraction;
2102 integerPart HUerr, HUdistance;
2103 unsigned int powHUerr;
2106 /* multiplySignificand leaves the precision-th bit set to 1. */
2107 calcLostFraction = decSig.multiplySignificand(pow5, NULL);
2108 powHUerr = powStatus != opOK;
2110 calcLostFraction = decSig.divideSignificand(pow5);
2111 /* Denormal numbers have less precision. */
2112 if (decSig.exponent < semantics->minExponent) {
2113 excessPrecision += (semantics->minExponent - decSig.exponent);
2114 truncatedBits = excessPrecision;
2115 if (excessPrecision > calcSemantics.precision)
2116 excessPrecision = calcSemantics.precision;
2118 /* Extra half-ulp lost in reciprocal of exponent. */
2119 powHUerr = (powStatus == opOK && calcLostFraction == lfExactlyZero) ? 0:2;
2122 /* Both multiplySignificand and divideSignificand return the
2123 result with the integer bit set. */
2124 assert (APInt::tcExtractBit
2125 (decSig.significandParts(), calcSemantics.precision - 1) == 1);
2127 HUerr = HUerrBound(calcLostFraction != lfExactlyZero, sigStatus != opOK,
2129 HUdistance = 2 * ulpsFromBoundary(decSig.significandParts(),
2130 excessPrecision, isNearest);
2132 /* Are we guaranteed to round correctly if we truncate? */
2133 if (HUdistance >= HUerr) {
2134 APInt::tcExtract(significandParts(), partCount(), decSig.significandParts(),
2135 calcSemantics.precision - excessPrecision,
2137 /* Take the exponent of decSig. If we tcExtract-ed less bits
2138 above we must adjust our exponent to compensate for the
2139 implicit right shift. */
2140 exponent = (decSig.exponent + semantics->precision
2141 - (calcSemantics.precision - excessPrecision));
2142 calcLostFraction = lostFractionThroughTruncation(decSig.significandParts(),
2145 return normalize(rounding_mode, calcLostFraction);
2151 APFloat::convertFromDecimalString(const char *p, roundingMode rounding_mode)
2156 /* Scan the text. */
2157 interpretDecimal(p, &D);
2159 /* Handle the quick cases. First the case of no significant digits,
2160 i.e. zero, and then exponents that are obviously too large or too
2161 small. Writing L for log 10 / log 2, a number d.ddddd*10^exp
2162 definitely overflows if
2164 (exp - 1) * L >= maxExponent
2166 and definitely underflows to zero where
2168 (exp + 1) * L <= minExponent - precision
2170 With integer arithmetic the tightest bounds for L are
2172 93/28 < L < 196/59 [ numerator <= 256 ]
2173 42039/12655 < L < 28738/8651 [ numerator <= 65536 ]
2176 if (decDigitValue(*D.firstSigDigit) >= 10U) {
2179 } else if ((D.normalizedExponent + 1) * 28738
2180 <= 8651 * (semantics->minExponent - (int) semantics->precision)) {
2181 /* Underflow to zero and round. */
2183 fs = normalize(rounding_mode, lfLessThanHalf);
2184 } else if ((D.normalizedExponent - 1) * 42039
2185 >= 12655 * semantics->maxExponent) {
2186 /* Overflow and round. */
2187 fs = handleOverflow(rounding_mode);
2189 integerPart *decSignificand;
2190 unsigned int partCount;
2192 /* A tight upper bound on number of bits required to hold an
2193 N-digit decimal integer is N * 196 / 59. Allocate enough space
2194 to hold the full significand, and an extra part required by
2196 partCount = static_cast<unsigned int>(D.lastSigDigit - D.firstSigDigit) + 1;
2197 partCount = partCountForBits(1 + 196 * partCount / 59);
2198 decSignificand = new integerPart[partCount + 1];
2201 /* Convert to binary efficiently - we do almost all multiplication
2202 in an integerPart. When this would overflow do we do a single
2203 bignum multiplication, and then revert again to multiplication
2204 in an integerPart. */
2206 integerPart decValue, val, multiplier;
2215 decValue = decDigitValue(*p++);
2217 val = val * 10 + decValue;
2218 /* The maximum number that can be multiplied by ten with any
2219 digit added without overflowing an integerPart. */
2220 } while (p <= D.lastSigDigit && multiplier <= (~ (integerPart) 0 - 9) / 10);
2222 /* Multiply out the current part. */
2223 APInt::tcMultiplyPart(decSignificand, decSignificand, multiplier, val,
2224 partCount, partCount + 1, false);
2226 /* If we used another part (likely but not guaranteed), increase
2228 if (decSignificand[partCount])
2230 } while (p <= D.lastSigDigit);
2232 category = fcNormal;
2233 fs = roundSignificandWithExponent(decSignificand, partCount,
2234 D.exponent, rounding_mode);
2236 delete [] decSignificand;
2243 APFloat::convertFromString(const char *p, roundingMode rounding_mode)
2245 assertArithmeticOK(*semantics);
2247 /* Handle a leading minus sign. */
2253 if(p[0] == '0' && (p[1] == 'x' || p[1] == 'X'))
2254 return convertFromHexadecimalString(p + 2, rounding_mode);
2256 return convertFromDecimalString(p, rounding_mode);
2259 /* Write out a hexadecimal representation of the floating point value
2260 to DST, which must be of sufficient size, in the C99 form
2261 [-]0xh.hhhhp[+-]d. Return the number of characters written,
2262 excluding the terminating NUL.
2264 If UPPERCASE, the output is in upper case, otherwise in lower case.
2266 HEXDIGITS digits appear altogether, rounding the value if
2267 necessary. If HEXDIGITS is 0, the minimal precision to display the
2268 number precisely is used instead. If nothing would appear after
2269 the decimal point it is suppressed.
2271 The decimal exponent is always printed and has at least one digit.
2272 Zero values display an exponent of zero. Infinities and NaNs
2273 appear as "infinity" or "nan" respectively.
2275 The above rules are as specified by C99. There is ambiguity about
2276 what the leading hexadecimal digit should be. This implementation
2277 uses whatever is necessary so that the exponent is displayed as
2278 stored. This implies the exponent will fall within the IEEE format
2279 range, and the leading hexadecimal digit will be 0 (for denormals),
2280 1 (normal numbers) or 2 (normal numbers rounded-away-from-zero with
2281 any other digits zero).
2284 APFloat::convertToHexString(char *dst, unsigned int hexDigits,
2285 bool upperCase, roundingMode rounding_mode) const
2289 assertArithmeticOK(*semantics);
2297 memcpy (dst, upperCase ? infinityU: infinityL, sizeof infinityU - 1);
2298 dst += sizeof infinityL - 1;
2302 memcpy (dst, upperCase ? NaNU: NaNL, sizeof NaNU - 1);
2303 dst += sizeof NaNU - 1;
2308 *dst++ = upperCase ? 'X': 'x';
2310 if (hexDigits > 1) {
2312 memset (dst, '0', hexDigits - 1);
2313 dst += hexDigits - 1;
2315 *dst++ = upperCase ? 'P': 'p';
2320 dst = convertNormalToHexString (dst, hexDigits, upperCase, rounding_mode);
2326 return static_cast<unsigned int>(dst - p);
2329 /* Does the hard work of outputting the correctly rounded hexadecimal
2330 form of a normal floating point number with the specified number of
2331 hexadecimal digits. If HEXDIGITS is zero the minimum number of
2332 digits necessary to print the value precisely is output. */
2334 APFloat::convertNormalToHexString(char *dst, unsigned int hexDigits,
2336 roundingMode rounding_mode) const
2338 unsigned int count, valueBits, shift, partsCount, outputDigits;
2339 const char *hexDigitChars;
2340 const integerPart *significand;
2345 *dst++ = upperCase ? 'X': 'x';
2348 hexDigitChars = upperCase ? hexDigitsUpper: hexDigitsLower;
2350 significand = significandParts();
2351 partsCount = partCount();
2353 /* +3 because the first digit only uses the single integer bit, so
2354 we have 3 virtual zero most-significant-bits. */
2355 valueBits = semantics->precision + 3;
2356 shift = integerPartWidth - valueBits % integerPartWidth;
2358 /* The natural number of digits required ignoring trailing
2359 insignificant zeroes. */
2360 outputDigits = (valueBits - significandLSB () + 3) / 4;
2362 /* hexDigits of zero means use the required number for the
2363 precision. Otherwise, see if we are truncating. If we are,
2364 find out if we need to round away from zero. */
2366 if (hexDigits < outputDigits) {
2367 /* We are dropping non-zero bits, so need to check how to round.
2368 "bits" is the number of dropped bits. */
2370 lostFraction fraction;
2372 bits = valueBits - hexDigits * 4;
2373 fraction = lostFractionThroughTruncation (significand, partsCount, bits);
2374 roundUp = roundAwayFromZero(rounding_mode, fraction, bits);
2376 outputDigits = hexDigits;
2379 /* Write the digits consecutively, and start writing in the location
2380 of the hexadecimal point. We move the most significant digit
2381 left and add the hexadecimal point later. */
2384 count = (valueBits + integerPartWidth - 1) / integerPartWidth;
2386 while (outputDigits && count) {
2389 /* Put the most significant integerPartWidth bits in "part". */
2390 if (--count == partsCount)
2391 part = 0; /* An imaginary higher zero part. */
2393 part = significand[count] << shift;
2396 part |= significand[count - 1] >> (integerPartWidth - shift);
2398 /* Convert as much of "part" to hexdigits as we can. */
2399 unsigned int curDigits = integerPartWidth / 4;
2401 if (curDigits > outputDigits)
2402 curDigits = outputDigits;
2403 dst += partAsHex (dst, part, curDigits, hexDigitChars);
2404 outputDigits -= curDigits;
2410 /* Note that hexDigitChars has a trailing '0'. */
2413 *q = hexDigitChars[hexDigitValue (*q) + 1];
2414 } while (*q == '0');
2417 /* Add trailing zeroes. */
2418 memset (dst, '0', outputDigits);
2419 dst += outputDigits;
2422 /* Move the most significant digit to before the point, and if there
2423 is something after the decimal point add it. This must come
2424 after rounding above. */
2431 /* Finally output the exponent. */
2432 *dst++ = upperCase ? 'P': 'p';
2434 return writeSignedDecimal (dst, exponent);
2437 // For good performance it is desirable for different APFloats
2438 // to produce different integers.
2440 APFloat::getHashValue() const
2442 if (category==fcZero) return sign<<8 | semantics->precision ;
2443 else if (category==fcInfinity) return sign<<9 | semantics->precision;
2444 else if (category==fcNaN) return 1<<10 | semantics->precision;
2446 uint32_t hash = sign<<11 | semantics->precision | exponent<<12;
2447 const integerPart* p = significandParts();
2448 for (int i=partCount(); i>0; i--, p++)
2449 hash ^= ((uint32_t)*p) ^ (uint32_t)((*p)>>32);
2454 // Conversion from APFloat to/from host float/double. It may eventually be
2455 // possible to eliminate these and have everybody deal with APFloats, but that
2456 // will take a while. This approach will not easily extend to long double.
2457 // Current implementation requires integerPartWidth==64, which is correct at
2458 // the moment but could be made more general.
2460 // Denormals have exponent minExponent in APFloat, but minExponent-1 in
2461 // the actual IEEE respresentations. We compensate for that here.
2464 APFloat::convertF80LongDoubleAPFloatToAPInt() const
2466 assert(semantics == (const llvm::fltSemantics*)&x87DoubleExtended);
2467 assert (partCount()==2);
2469 uint64_t myexponent, mysignificand;
2471 if (category==fcNormal) {
2472 myexponent = exponent+16383; //bias
2473 mysignificand = significandParts()[0];
2474 if (myexponent==1 && !(mysignificand & 0x8000000000000000ULL))
2475 myexponent = 0; // denormal
2476 } else if (category==fcZero) {
2479 } else if (category==fcInfinity) {
2480 myexponent = 0x7fff;
2481 mysignificand = 0x8000000000000000ULL;
2483 assert(category == fcNaN && "Unknown category");
2484 myexponent = 0x7fff;
2485 mysignificand = significandParts()[0];
2489 words[0] = ((uint64_t)(sign & 1) << 63) |
2490 ((myexponent & 0x7fffLL) << 48) |
2491 ((mysignificand >>16) & 0xffffffffffffLL);
2492 words[1] = mysignificand & 0xffff;
2493 return APInt(80, 2, words);
2497 APFloat::convertPPCDoubleDoubleAPFloatToAPInt() const
2499 assert(semantics == (const llvm::fltSemantics*)&PPCDoubleDouble);
2500 assert (partCount()==2);
2502 uint64_t myexponent, mysignificand, myexponent2, mysignificand2;
2504 if (category==fcNormal) {
2505 myexponent = exponent + 1023; //bias
2506 myexponent2 = exponent2 + 1023;
2507 mysignificand = significandParts()[0];
2508 mysignificand2 = significandParts()[1];
2509 if (myexponent==1 && !(mysignificand & 0x10000000000000LL))
2510 myexponent = 0; // denormal
2511 if (myexponent2==1 && !(mysignificand2 & 0x10000000000000LL))
2512 myexponent2 = 0; // denormal
2513 } else if (category==fcZero) {
2518 } else if (category==fcInfinity) {
2524 assert(category == fcNaN && "Unknown category");
2526 mysignificand = significandParts()[0];
2527 myexponent2 = exponent2;
2528 mysignificand2 = significandParts()[1];
2532 words[0] = ((uint64_t)(sign & 1) << 63) |
2533 ((myexponent & 0x7ff) << 52) |
2534 (mysignificand & 0xfffffffffffffLL);
2535 words[1] = ((uint64_t)(sign2 & 1) << 63) |
2536 ((myexponent2 & 0x7ff) << 52) |
2537 (mysignificand2 & 0xfffffffffffffLL);
2538 return APInt(128, 2, words);
2542 APFloat::convertDoubleAPFloatToAPInt() const
2544 assert(semantics == (const llvm::fltSemantics*)&IEEEdouble);
2545 assert (partCount()==1);
2547 uint64_t myexponent, mysignificand;
2549 if (category==fcNormal) {
2550 myexponent = exponent+1023; //bias
2551 mysignificand = *significandParts();
2552 if (myexponent==1 && !(mysignificand & 0x10000000000000LL))
2553 myexponent = 0; // denormal
2554 } else if (category==fcZero) {
2557 } else if (category==fcInfinity) {
2561 assert(category == fcNaN && "Unknown category!");
2563 mysignificand = *significandParts();
2566 return APInt(64, ((((uint64_t)(sign & 1) << 63) |
2567 ((myexponent & 0x7ff) << 52) |
2568 (mysignificand & 0xfffffffffffffLL))));
2572 APFloat::convertFloatAPFloatToAPInt() const
2574 assert(semantics == (const llvm::fltSemantics*)&IEEEsingle);
2575 assert (partCount()==1);
2577 uint32_t myexponent, mysignificand;
2579 if (category==fcNormal) {
2580 myexponent = exponent+127; //bias
2581 mysignificand = (uint32_t)*significandParts();
2582 if (myexponent == 1 && !(mysignificand & 0x800000))
2583 myexponent = 0; // denormal
2584 } else if (category==fcZero) {
2587 } else if (category==fcInfinity) {
2591 assert(category == fcNaN && "Unknown category!");
2593 mysignificand = (uint32_t)*significandParts();
2596 return APInt(32, (((sign&1) << 31) | ((myexponent&0xff) << 23) |
2597 (mysignificand & 0x7fffff)));
2600 // This function creates an APInt that is just a bit map of the floating
2601 // point constant as it would appear in memory. It is not a conversion,
2602 // and treating the result as a normal integer is unlikely to be useful.
2605 APFloat::convertToAPInt() const
2607 if (semantics == (const llvm::fltSemantics*)&IEEEsingle)
2608 return convertFloatAPFloatToAPInt();
2610 if (semantics == (const llvm::fltSemantics*)&IEEEdouble)
2611 return convertDoubleAPFloatToAPInt();
2613 if (semantics == (const llvm::fltSemantics*)&PPCDoubleDouble)
2614 return convertPPCDoubleDoubleAPFloatToAPInt();
2616 assert(semantics == (const llvm::fltSemantics*)&x87DoubleExtended &&
2618 return convertF80LongDoubleAPFloatToAPInt();
2622 APFloat::convertToFloat() const
2624 assert(semantics == (const llvm::fltSemantics*)&IEEEsingle);
2625 APInt api = convertToAPInt();
2626 return api.bitsToFloat();
2630 APFloat::convertToDouble() const
2632 assert(semantics == (const llvm::fltSemantics*)&IEEEdouble);
2633 APInt api = convertToAPInt();
2634 return api.bitsToDouble();
2637 /// Integer bit is explicit in this format. Current Intel book does not
2638 /// define meaning of:
2639 /// exponent = all 1's, integer bit not set.
2640 /// exponent = 0, integer bit set. (formerly "psuedodenormals")
2641 /// exponent!=0 nor all 1's, integer bit not set. (formerly "unnormals")
2643 APFloat::initFromF80LongDoubleAPInt(const APInt &api)
2645 assert(api.getBitWidth()==80);
2646 uint64_t i1 = api.getRawData()[0];
2647 uint64_t i2 = api.getRawData()[1];
2648 uint64_t myexponent = (i1 >> 48) & 0x7fff;
2649 uint64_t mysignificand = ((i1 << 16) & 0xffffffffffff0000ULL) |
2652 initialize(&APFloat::x87DoubleExtended);
2653 assert(partCount()==2);
2655 sign = static_cast<unsigned int>(i1>>63);
2656 if (myexponent==0 && mysignificand==0) {
2657 // exponent, significand meaningless
2659 } else if (myexponent==0x7fff && mysignificand==0x8000000000000000ULL) {
2660 // exponent, significand meaningless
2661 category = fcInfinity;
2662 } else if (myexponent==0x7fff && mysignificand!=0x8000000000000000ULL) {
2663 // exponent meaningless
2665 significandParts()[0] = mysignificand;
2666 significandParts()[1] = 0;
2668 category = fcNormal;
2669 exponent = myexponent - 16383;
2670 significandParts()[0] = mysignificand;
2671 significandParts()[1] = 0;
2672 if (myexponent==0) // denormal
2678 APFloat::initFromPPCDoubleDoubleAPInt(const APInt &api)
2680 assert(api.getBitWidth()==128);
2681 uint64_t i1 = api.getRawData()[0];
2682 uint64_t i2 = api.getRawData()[1];
2683 uint64_t myexponent = (i1 >> 52) & 0x7ff;
2684 uint64_t mysignificand = i1 & 0xfffffffffffffLL;
2685 uint64_t myexponent2 = (i2 >> 52) & 0x7ff;
2686 uint64_t mysignificand2 = i2 & 0xfffffffffffffLL;
2688 initialize(&APFloat::PPCDoubleDouble);
2689 assert(partCount()==2);
2691 sign = static_cast<unsigned int>(i1>>63);
2692 sign2 = static_cast<unsigned int>(i2>>63);
2693 if (myexponent==0 && mysignificand==0) {
2694 // exponent, significand meaningless
2695 // exponent2 and significand2 are required to be 0; we don't check
2697 } else if (myexponent==0x7ff && mysignificand==0) {
2698 // exponent, significand meaningless
2699 // exponent2 and significand2 are required to be 0; we don't check
2700 category = fcInfinity;
2701 } else if (myexponent==0x7ff && mysignificand!=0) {
2702 // exponent meaningless. So is the whole second word, but keep it
2705 exponent2 = myexponent2;
2706 significandParts()[0] = mysignificand;
2707 significandParts()[1] = mysignificand2;
2709 category = fcNormal;
2710 // Note there is no category2; the second word is treated as if it is
2711 // fcNormal, although it might be something else considered by itself.
2712 exponent = myexponent - 1023;
2713 exponent2 = myexponent2 - 1023;
2714 significandParts()[0] = mysignificand;
2715 significandParts()[1] = mysignificand2;
2716 if (myexponent==0) // denormal
2719 significandParts()[0] |= 0x10000000000000LL; // integer bit
2723 significandParts()[1] |= 0x10000000000000LL; // integer bit
2728 APFloat::initFromDoubleAPInt(const APInt &api)
2730 assert(api.getBitWidth()==64);
2731 uint64_t i = *api.getRawData();
2732 uint64_t myexponent = (i >> 52) & 0x7ff;
2733 uint64_t mysignificand = i & 0xfffffffffffffLL;
2735 initialize(&APFloat::IEEEdouble);
2736 assert(partCount()==1);
2738 sign = static_cast<unsigned int>(i>>63);
2739 if (myexponent==0 && mysignificand==0) {
2740 // exponent, significand meaningless
2742 } else if (myexponent==0x7ff && mysignificand==0) {
2743 // exponent, significand meaningless
2744 category = fcInfinity;
2745 } else if (myexponent==0x7ff && mysignificand!=0) {
2746 // exponent meaningless
2748 *significandParts() = mysignificand;
2750 category = fcNormal;
2751 exponent = myexponent - 1023;
2752 *significandParts() = mysignificand;
2753 if (myexponent==0) // denormal
2756 *significandParts() |= 0x10000000000000LL; // integer bit
2761 APFloat::initFromFloatAPInt(const APInt & api)
2763 assert(api.getBitWidth()==32);
2764 uint32_t i = (uint32_t)*api.getRawData();
2765 uint32_t myexponent = (i >> 23) & 0xff;
2766 uint32_t mysignificand = i & 0x7fffff;
2768 initialize(&APFloat::IEEEsingle);
2769 assert(partCount()==1);
2772 if (myexponent==0 && mysignificand==0) {
2773 // exponent, significand meaningless
2775 } else if (myexponent==0xff && mysignificand==0) {
2776 // exponent, significand meaningless
2777 category = fcInfinity;
2778 } else if (myexponent==0xff && mysignificand!=0) {
2779 // sign, exponent, significand meaningless
2781 *significandParts() = mysignificand;
2783 category = fcNormal;
2784 exponent = myexponent - 127; //bias
2785 *significandParts() = mysignificand;
2786 if (myexponent==0) // denormal
2789 *significandParts() |= 0x800000; // integer bit
2793 /// Treat api as containing the bits of a floating point number. Currently
2794 /// we infer the floating point type from the size of the APInt. The
2795 /// isIEEE argument distinguishes between PPC128 and IEEE128 (not meaningful
2796 /// when the size is anything else).
2798 APFloat::initFromAPInt(const APInt& api, bool isIEEE)
2800 if (api.getBitWidth() == 32)
2801 return initFromFloatAPInt(api);
2802 else if (api.getBitWidth()==64)
2803 return initFromDoubleAPInt(api);
2804 else if (api.getBitWidth()==80)
2805 return initFromF80LongDoubleAPInt(api);
2806 else if (api.getBitWidth()==128 && !isIEEE)
2807 return initFromPPCDoubleDoubleAPInt(api);
2812 APFloat::APFloat(const APInt& api, bool isIEEE)
2814 initFromAPInt(api, isIEEE);
2817 APFloat::APFloat(float f)
2819 APInt api = APInt(32, 0);
2820 initFromAPInt(api.floatToBits(f));
2823 APFloat::APFloat(double d)
2825 APInt api = APInt(64, 0);
2826 initFromAPInt(api.doubleToBits(d));