//
// The LLVM Compiler Infrastructure
//
-// This file was developed by Neil Booth and is distributed under the
-// University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
//
//===----------------------------------------------------------------------===//
-#include <cassert>
-#include <cstring>
#include "llvm/ADT/APFloat.h"
+#include "llvm/ADT/FoldingSet.h"
#include "llvm/Support/MathExtras.h"
+#include <cstring>
using namespace llvm;
/* Assumed in hexadecimal significand parsing, and conversion to
hexadecimal strings. */
+#define COMPILE_TIME_ASSERT(cond) extern int CTAssert[(cond) ? 1 : -1]
COMPILE_TIME_ASSERT(integerPartWidth % 4 == 0);
namespace llvm {
/* Number of bits in the significand. This includes the integer
bit. */
unsigned int precision;
+
+ /* True if arithmetic is supported. */
+ unsigned int arithmeticOK;
};
- const fltSemantics APFloat::IEEEsingle = { 127, -126, 24 };
- const fltSemantics APFloat::IEEEdouble = { 1023, -1022, 53 };
- const fltSemantics APFloat::IEEEquad = { 16383, -16382, 113 };
- const fltSemantics APFloat::x87DoubleExtended = { 16383, -16382, 64 };
- const fltSemantics APFloat::Bogus = { 0, 0, 0 };
+ const fltSemantics APFloat::IEEEsingle = { 127, -126, 24, true };
+ const fltSemantics APFloat::IEEEdouble = { 1023, -1022, 53, true };
+ const fltSemantics APFloat::IEEEquad = { 16383, -16382, 113, true };
+ const fltSemantics APFloat::x87DoubleExtended = { 16383, -16382, 64, true };
+ const fltSemantics APFloat::Bogus = { 0, 0, 0, true };
// The PowerPC format consists of two doubles. It does not map cleanly
// onto the usual format above. For now only storage of constants of
// this type is supported, no arithmetic.
- const fltSemantics APFloat::PPCDoubleDouble = { 1023, -1022, 106 };
+ const fltSemantics APFloat::PPCDoubleDouble = { 1023, -1022, 106, false };
/* A tight upper bound on number of parts required to hold the value
pow(5, power) is
- power * 1024 / (441 * integerPartWidth) + 1
+ power * 815 / (351 * integerPartWidth) + 1
However, whilst the result may require only this many parts,
because we are multiplying two values to get it, the
const unsigned int maxExponent = 16383;
const unsigned int maxPrecision = 113;
const unsigned int maxPowerOfFiveExponent = maxExponent + maxPrecision - 1;
- const unsigned int maxPowerOfFiveParts = 2 + ((maxPowerOfFiveExponent * 1024)
- / (441 * integerPartWidth));
+ const unsigned int maxPowerOfFiveParts = 2 + ((maxPowerOfFiveExponent * 815)
+ / (351 * integerPartWidth));
}
/* Put a bunch of private, handy routines in an anonymous namespace. */
namespace {
- inline unsigned int
+ static inline unsigned int
partCountForBits(unsigned int bits)
{
return ((bits) + integerPartWidth - 1) / integerPartWidth;
}
- unsigned int
- digitValue(unsigned int c)
+ /* Returns 0U-9U. Return values >= 10U are not digits. */
+ static inline unsigned int
+ decDigitValue(unsigned int c)
{
- unsigned int r;
-
- r = c - '0';
- if(r <= 9)
- return r;
-
- return -1U;
+ return c - '0';
}
- unsigned int
+ static unsigned int
hexDigitValue(unsigned int c)
{
unsigned int r;
return -1U;
}
+ static inline void
+ assertArithmeticOK(const llvm::fltSemantics &semantics) {
+ assert(semantics.arithmeticOK
+ && "Compile-time arithmetic does not support these semantics");
+ }
+
+ /* Return the value of a decimal exponent of the form
+ [+-]ddddddd.
+
+ If the exponent overflows, returns a large exponent with the
+ appropriate sign. */
+ static int
+ readExponent(const char *p)
+ {
+ bool isNegative;
+ unsigned int absExponent;
+ const unsigned int overlargeExponent = 24000; /* FIXME. */
+
+ isNegative = (*p == '-');
+ if (*p == '-' || *p == '+')
+ p++;
+
+ absExponent = decDigitValue(*p++);
+ assert (absExponent < 10U);
+
+ for (;;) {
+ unsigned int value;
+
+ value = decDigitValue(*p);
+ if (value >= 10U)
+ break;
+
+ p++;
+ value += absExponent * 10;
+ if (absExponent >= overlargeExponent) {
+ absExponent = overlargeExponent;
+ break;
+ }
+ absExponent = value;
+ }
+
+ if (isNegative)
+ return -(int) absExponent;
+ else
+ return (int) absExponent;
+ }
+
/* This is ugly and needs cleaning up, but I don't immediately see
how whilst remaining safe. */
static int
totalExponent(const char *p, int exponentAdjustment)
{
- integerPart unsignedExponent;
+ int unsignedExponent;
bool negative, overflow;
- long exponent;
+ int exponent;
/* Move past the exponent letter and sign to the digits. */
p++;
for(;;) {
unsigned int value;
- value = digitValue(*p);
- if(value == -1U)
+ value = decDigitValue(*p);
+ if(value >= 10U)
break;
p++;
return exponent;
}
- const char *
+ static const char *
skipLeadingZeroesAndAnyDot(const char *p, const char **dot)
{
*dot = 0;
return p;
}
+ /* Given a normal decimal floating point number of the form
+
+ dddd.dddd[eE][+-]ddd
+
+ where the decimal point and exponent are optional, fill out the
+ structure D. Exponent is appropriate if the significand is
+ treated as an integer, and normalizedExponent if the significand
+ is taken to have the decimal point after a single leading
+ non-zero digit.
+
+ If the value is zero, V->firstSigDigit points to a non-digit, and
+ the return exponent is zero.
+ */
+ struct decimalInfo {
+ const char *firstSigDigit;
+ const char *lastSigDigit;
+ int exponent;
+ int normalizedExponent;
+ };
+
+ static void
+ interpretDecimal(const char *p, decimalInfo *D)
+ {
+ const char *dot;
+
+ p = skipLeadingZeroesAndAnyDot (p, &dot);
+
+ D->firstSigDigit = p;
+ D->exponent = 0;
+ D->normalizedExponent = 0;
+
+ for (;;) {
+ if (*p == '.') {
+ assert(dot == 0);
+ dot = p++;
+ }
+ if (decDigitValue(*p) >= 10U)
+ break;
+ p++;
+ }
+
+ /* If number is all zerooes accept any exponent. */
+ if (p != D->firstSigDigit) {
+ if (*p == 'e' || *p == 'E')
+ D->exponent = readExponent(p + 1);
+
+ /* Implied decimal point? */
+ if (!dot)
+ dot = p;
+
+ /* Drop insignificant trailing zeroes. */
+ do
+ do
+ p--;
+ while (*p == '0');
+ while (*p == '.');
+
+ /* Adjust the exponents for any decimal point. */
+ D->exponent += static_cast<exponent_t>((dot - p) - (dot > p));
+ D->normalizedExponent = (D->exponent +
+ static_cast<exponent_t>((p - D->firstSigDigit)
+ - (dot > D->firstSigDigit && dot < p)));
+ }
+
+ D->lastSigDigit = p;
+ }
+
/* Return the trailing fraction of a hexadecimal number.
DIGITVALUE is the first hex digit of the fraction, P points to
the next digit. */
- lostFraction
+ static lostFraction
trailingHexadecimalFraction(const char *p, unsigned int digitValue)
{
unsigned int hexDigit;
/* Return the fraction lost were a bignum truncated losing the least
significant BITS bits. */
- lostFraction
+ static lostFraction
lostFractionThroughTruncation(const integerPart *parts,
unsigned int partCount,
unsigned int bits)
}
/* Shift DST right BITS bits noting lost fraction. */
- lostFraction
+ static lostFraction
shiftRight(integerPart *dst, unsigned int parts, unsigned int bits)
{
lostFraction lost_fraction;
}
/* Combine the effect of two lost fractions. */
- lostFraction
+ static lostFraction
combineLostFractions(lostFraction moreSignificant,
lostFraction lessSignificant)
{
See "How to Read Floating Point Numbers Accurately" by William D
Clinger. */
- unsigned int
+ static unsigned int
HUerrBound(bool inexactMultiply, unsigned int HUerr1, unsigned int HUerr2)
{
assert(HUerr1 < 2 || HUerr2 < 2 || (HUerr1 + HUerr2 < 8));
/* The number of ulps from the boundary (zero, or half if ISNEAREST)
when the least significant BITS are truncated. BITS cannot be
zero. */
- integerPart
+ static integerPart
ulpsFromBoundary(const integerPart *parts, unsigned int bits, bool isNearest)
{
unsigned int count, partBits;
static unsigned int
powerOf5(integerPart *dst, unsigned int power)
{
- static integerPart firstEightPowers[] = { 1, 5, 25, 125, 625, 3125,
- 15625, 78125 };
+ static const integerPart firstEightPowers[] = { 1, 5, 25, 125, 625, 3125,
+ 15625, 78125 };
static integerPart pow5s[maxPowerOfFiveParts * 2 + 5] = { 78125 * 5 };
static unsigned int partsCount[16] = { 1 };
partCount());
}
+/* Make this number a NaN, with an arbitrary but deterministic value
+ for the significand. */
+void
+APFloat::makeNaN(void)
+{
+ category = fcNaN;
+ APInt::tcSet(significandParts(), ~0U, partCount());
+}
+
APFloat &
APFloat::operator=(const APFloat &rhs)
{
category != rhs.category ||
sign != rhs.sign)
return false;
- if (semantics==(const llvm::fltSemantics* const)&PPCDoubleDouble &&
+ if (semantics==(const llvm::fltSemantics*)&PPCDoubleDouble &&
sign2 != rhs.sign2)
return false;
if (category==fcZero || category==fcInfinity)
return true;
else if (category==fcNormal && exponent!=rhs.exponent)
return false;
- else if (semantics==(const llvm::fltSemantics* const)&PPCDoubleDouble &&
+ else if (semantics==(const llvm::fltSemantics*)&PPCDoubleDouble &&
exponent2!=rhs.exponent2)
return false;
else {
APFloat::APFloat(const fltSemantics &ourSemantics, integerPart value)
{
- assert(semantics != (const llvm::fltSemantics* const)&PPCDoubleDouble &&
- "Compile-time arithmetic on PPC long double not supported yet");
+ assertArithmeticOK(ourSemantics);
initialize(&ourSemantics);
sign = 0;
zeroSignificand();
APFloat::APFloat(const fltSemantics &ourSemantics,
fltCategory ourCategory, bool negative)
{
- assert(semantics != (const llvm::fltSemantics* const)&PPCDoubleDouble &&
- "Compile-time arithmetic on PPC long double not supported yet");
+ assertArithmeticOK(ourSemantics);
initialize(&ourSemantics);
category = ourCategory;
sign = negative;
if(category == fcNormal)
category = fcZero;
+ else if (ourCategory == fcNaN)
+ makeNaN();
}
APFloat::APFloat(const fltSemantics &ourSemantics, const char *text)
{
- assert(semantics != (const llvm::fltSemantics* const)&PPCDoubleDouble &&
- "Compile-time arithmetic on PPC long double not supported yet");
+ assertArithmeticOK(ourSemantics);
initialize(&ourSemantics);
convertFromString(text, rmNearestTiesToEven);
}
freeSignificand();
}
+// Profile - This method 'profiles' an APFloat for use with FoldingSet.
+void APFloat::Profile(FoldingSetNodeID& ID) const {
+ ID.Add(bitcastToAPInt());
+}
+
unsigned int
APFloat::partCount() const
{
integerPart scratch[4];
integerPart *fullSignificand;
lostFraction lost_fraction;
+ bool ignored;
assert(semantics == rhs.semantics);
semantics = &extendedSemantics;
APFloat extendedAddend(*addend);
- status = extendedAddend.convert(extendedSemantics, rmTowardZero);
+ status = extendedAddend.convert(extendedSemantics, rmTowardZero, &ignored);
assert(status == opOK);
lost_fraction = addOrSubtractSignificand(extendedAddend, false);
case convolve(fcInfinity, fcInfinity):
/* Differently signed infinities can only be validly
subtracted. */
- if(sign ^ rhs.sign != subtract) {
- category = fcNaN;
- // Arbitrary but deterministic value for significand
- APInt::tcSet(significandParts(), ~0U, partCount());
+ if((sign ^ rhs.sign) != subtract) {
+ makeNaN();
return opInvalidOp;
}
/* Determine if the operation on the absolute values is effectively
an addition or subtraction. */
- subtract ^= (sign ^ rhs.sign);
+ subtract ^= (sign ^ rhs.sign) ? true : false;
/* Are we bigger exponent-wise than the RHS? */
bits = exponent - rhs.exponent;
case convolve(fcZero, fcInfinity):
case convolve(fcInfinity, fcZero):
- category = fcNaN;
- // Arbitrary but deterministic value for significand
- APInt::tcSet(significandParts(), ~0U, partCount());
+ makeNaN();
return opInvalidOp;
case convolve(fcNormal, fcNormal):
case convolve(fcInfinity, fcInfinity):
case convolve(fcZero, fcZero):
+ makeNaN();
+ return opInvalidOp;
+
+ case convolve(fcNormal, fcNormal):
+ return opOK;
+ }
+}
+
+APFloat::opStatus
+APFloat::modSpecials(const APFloat &rhs)
+{
+ switch(convolve(category, rhs.category)) {
+ default:
+ assert(0);
+
+ case convolve(fcNaN, fcZero):
+ case convolve(fcNaN, fcNormal):
+ case convolve(fcNaN, fcInfinity):
+ case convolve(fcNaN, fcNaN):
+ case convolve(fcZero, fcInfinity):
+ case convolve(fcZero, fcNormal):
+ case convolve(fcNormal, fcInfinity):
+ return opOK;
+
+ case convolve(fcZero, fcNaN):
+ case convolve(fcNormal, fcNaN):
+ case convolve(fcInfinity, fcNaN):
category = fcNaN;
- // Arbitrary but deterministic value for significand
- APInt::tcSet(significandParts(), ~0U, partCount());
+ copySignificand(rhs);
+ return opOK;
+
+ case convolve(fcNormal, fcZero):
+ case convolve(fcInfinity, fcZero):
+ case convolve(fcInfinity, fcNormal):
+ case convolve(fcInfinity, fcInfinity):
+ case convolve(fcZero, fcZero):
+ makeNaN();
return opInvalidOp;
case convolve(fcNormal, fcNormal):
{
opStatus fs;
+ assertArithmeticOK(*semantics);
+
fs = addOrSubtractSpecials(rhs, subtract);
/* This return code means it was not a simple case. */
APFloat::opStatus
APFloat::add(const APFloat &rhs, roundingMode rounding_mode)
{
- assert(semantics != (const llvm::fltSemantics* const)&PPCDoubleDouble &&
- "Compile-time arithmetic on PPC long double not supported yet");
return addOrSubtract(rhs, rounding_mode, false);
}
APFloat::opStatus
APFloat::subtract(const APFloat &rhs, roundingMode rounding_mode)
{
- assert(semantics != (const llvm::fltSemantics* const)&PPCDoubleDouble &&
- "Compile-time arithmetic on PPC long double not supported yet");
return addOrSubtract(rhs, rounding_mode, true);
}
APFloat::opStatus
APFloat::multiply(const APFloat &rhs, roundingMode rounding_mode)
{
- assert(semantics != (const llvm::fltSemantics* const)&PPCDoubleDouble &&
- "Compile-time arithmetic on PPC long double not supported yet");
opStatus fs;
+ assertArithmeticOK(*semantics);
sign ^= rhs.sign;
fs = multiplySpecials(rhs);
APFloat::opStatus
APFloat::divide(const APFloat &rhs, roundingMode rounding_mode)
{
- assert(semantics != (const llvm::fltSemantics* const)&PPCDoubleDouble &&
- "Compile-time arithmetic on PPC long double not supported yet");
opStatus fs;
+ assertArithmeticOK(*semantics);
sign ^= rhs.sign;
fs = divideSpecials(rhs);
return fs;
}
-/* Normalized remainder. This is not currently doing TRT. */
+/* Normalized remainder. This is not currently correct in all cases. */
APFloat::opStatus
-APFloat::mod(const APFloat &rhs, roundingMode rounding_mode)
+APFloat::remainder(const APFloat &rhs)
{
- assert(semantics != (const llvm::fltSemantics* const)&PPCDoubleDouble &&
- "Compile-time arithmetic on PPC long double not supported yet");
opStatus fs;
APFloat V = *this;
unsigned int origSign = sign;
+
+ assertArithmeticOK(*semantics);
fs = V.divide(rhs, rmNearestTiesToEven);
if (fs == opDivByZero)
return fs;
int parts = partCount();
integerPart *x = new integerPart[parts];
+ bool ignored;
fs = V.convertToInteger(x, parts * integerPartWidth, true,
- rmNearestTiesToEven);
+ rmNearestTiesToEven, &ignored);
if (fs==opInvalidOp)
return fs;
rmNearestTiesToEven);
assert(fs==opOK); // should always work
- fs = V.multiply(rhs, rounding_mode);
+ fs = V.multiply(rhs, rmNearestTiesToEven);
assert(fs==opOK || fs==opInexact); // should not overflow or underflow
- fs = subtract(V, rounding_mode);
+ fs = subtract(V, rmNearestTiesToEven);
assert(fs==opOK || fs==opInexact); // likewise
if (isZero())
return fs;
}
+/* Normalized llvm frem (C fmod).
+ This is not currently correct in all cases. */
+APFloat::opStatus
+APFloat::mod(const APFloat &rhs, roundingMode rounding_mode)
+{
+ opStatus fs;
+ assertArithmeticOK(*semantics);
+ fs = modSpecials(rhs);
+
+ if (category == fcNormal && rhs.category == fcNormal) {
+ APFloat V = *this;
+ unsigned int origSign = sign;
+
+ fs = V.divide(rhs, rmNearestTiesToEven);
+ if (fs == opDivByZero)
+ return fs;
+
+ int parts = partCount();
+ integerPart *x = new integerPart[parts];
+ bool ignored;
+ fs = V.convertToInteger(x, parts * integerPartWidth, true,
+ rmTowardZero, &ignored);
+ if (fs==opInvalidOp)
+ return fs;
+
+ fs = V.convertFromZeroExtendedInteger(x, parts * integerPartWidth, true,
+ rmNearestTiesToEven);
+ assert(fs==opOK); // should always work
+
+ fs = V.multiply(rhs, rounding_mode);
+ assert(fs==opOK || fs==opInexact); // should not overflow or underflow
+
+ fs = subtract(V, rounding_mode);
+ assert(fs==opOK || fs==opInexact); // likewise
+
+ if (isZero())
+ sign = origSign; // IEEE754 requires this
+ delete[] x;
+ }
+ return fs;
+}
+
/* Normalized fused-multiply-add. */
APFloat::opStatus
APFloat::fusedMultiplyAdd(const APFloat &multiplicand,
const APFloat &addend,
roundingMode rounding_mode)
{
- assert(semantics != (const llvm::fltSemantics* const)&PPCDoubleDouble &&
- "Compile-time arithmetic on PPC long double not supported yet");
opStatus fs;
+ assertArithmeticOK(*semantics);
+
/* Post-multiplication sign, before addition. */
sign ^= multiplicand.sign;
APFloat::cmpResult
APFloat::compare(const APFloat &rhs) const
{
- assert(semantics != (const llvm::fltSemantics* const)&PPCDoubleDouble &&
- "Compile-time arithmetic on PPC long double not supported yet");
cmpResult result;
+ assertArithmeticOK(*semantics);
assert(semantics == rhs.semantics);
switch(convolve(category, rhs.category)) {
return result;
}
+/// APFloat::convert - convert a value of one floating point type to another.
+/// The return value corresponds to the IEEE754 exceptions. *losesInfo
+/// records whether the transformation lost information, i.e. whether
+/// converting the result back to the original type will produce the
+/// original value (this is almost the same as return value==fsOK, but there
+/// are edge cases where this is not so).
+
APFloat::opStatus
APFloat::convert(const fltSemantics &toSemantics,
- roundingMode rounding_mode)
+ roundingMode rounding_mode, bool *losesInfo)
{
- assert(semantics != (const llvm::fltSemantics* const)&PPCDoubleDouble &&
- "Compile-time arithmetic on PPC long double not supported yet");
lostFraction lostFraction;
unsigned int newPartCount, oldPartCount;
opStatus fs;
+ assertArithmeticOK(*semantics);
+ assertArithmeticOK(toSemantics);
lostFraction = lfExactlyZero;
newPartCount = partCountForBits(toSemantics.precision + 1);
oldPartCount = partCount();
exponent += toSemantics.precision - semantics->precision;
semantics = &toSemantics;
fs = normalize(rounding_mode, lostFraction);
+ *losesInfo = (fs != opOK);
} else if (category == fcNaN) {
int shift = toSemantics.precision - semantics->precision;
+ // Do this now so significandParts gets the right answer
+ const fltSemantics *oldSemantics = semantics;
+ semantics = &toSemantics;
+ *losesInfo = false;
// No normalization here, just truncate
if (shift>0)
APInt::tcShiftLeft(significandParts(), newPartCount, shift);
- else if (shift < 0)
- APInt::tcShiftRight(significandParts(), newPartCount, -shift);
+ else if (shift < 0) {
+ unsigned ushift = -shift;
+ // Figure out if we are losing information. This happens
+ // if are shifting out something other than 0s, or if the x87 long
+ // double input did not have its integer bit set (pseudo-NaN), or if the
+ // x87 long double input did not have its QNan bit set (because the x87
+ // hardware sets this bit when converting a lower-precision NaN to
+ // x87 long double).
+ if (APInt::tcLSB(significandParts(), newPartCount) < ushift)
+ *losesInfo = true;
+ if (oldSemantics == &APFloat::x87DoubleExtended &&
+ (!(*significandParts() & 0x8000000000000000ULL) ||
+ !(*significandParts() & 0x4000000000000000ULL)))
+ *losesInfo = true;
+ APInt::tcShiftRight(significandParts(), newPartCount, ushift);
+ }
// gcc forces the Quiet bit on, which means (float)(double)(float_sNan)
// does not give you back the same bits. This is dubious, and we
// don't currently do it. You're really supposed to get
// an invalid operation signal at runtime, but nobody does that.
- semantics = &toSemantics;
fs = opOK;
} else {
semantics = &toSemantics;
fs = opOK;
+ *losesInfo = false;
}
return fs;
/* Convert a floating point number to an integer according to the
rounding mode. If the rounded integer value is out of range this
- returns an invalid operation exception. If the rounded value is in
+ returns an invalid operation exception and the contents of the
+ destination parts are unspecified. If the rounded value is in
range but the floating point number is not the exact integer, the C
standard doesn't require an inexact exception to be raised. IEEE
854 does require it so we do that.
Note that for conversions to integer type the C standard requires
round-to-zero to always be used. */
APFloat::opStatus
-APFloat::convertToInteger(integerPart *parts, unsigned int width,
- bool isSigned,
- roundingMode rounding_mode) const
+APFloat::convertToSignExtendedInteger(integerPart *parts, unsigned int width,
+ bool isSigned,
+ roundingMode rounding_mode,
+ bool *isExact) const
{
- assert(semantics != (const llvm::fltSemantics* const)&PPCDoubleDouble &&
- "Compile-time arithmetic on PPC long double not supported yet");
lostFraction lost_fraction;
- unsigned int msb, partsCount;
- int bits;
+ const integerPart *src;
+ unsigned int dstPartsCount, truncatedBits;
- partsCount = partCountForBits(width);
+ assertArithmeticOK(*semantics);
- /* Handle the three special cases first. We produce
- a deterministic result even for the Invalid cases. */
- if (category == fcNaN) {
- // Neither sign nor isSigned affects this.
- APInt::tcSet(parts, 0, partsCount);
- return opInvalidOp;
- }
- if (category == fcInfinity) {
- if (!sign && isSigned)
- APInt::tcSetLeastSignificantBits(parts, partsCount, width-1);
- else if (!sign && !isSigned)
- APInt::tcSetLeastSignificantBits(parts, partsCount, width);
- else if (sign && isSigned) {
- APInt::tcSetLeastSignificantBits(parts, partsCount, 1);
- APInt::tcShiftLeft(parts, partsCount, width-1);
- } else // sign && !isSigned
- APInt::tcSet(parts, 0, partsCount);
+ *isExact = false;
+
+ /* Handle the three special cases first. */
+ if(category == fcInfinity || category == fcNaN)
return opInvalidOp;
- }
- if (category == fcZero) {
- APInt::tcSet(parts, 0, partsCount);
+
+ dstPartsCount = partCountForBits(width);
+
+ if(category == fcZero) {
+ APInt::tcSet(parts, 0, dstPartsCount);
+ // Negative zero can't be represented as an int.
+ *isExact = !sign;
return opOK;
}
- /* Shift the bit pattern so the fraction is lost. */
- APFloat tmp(*this);
-
- bits = (int) semantics->precision - 1 - exponent;
+ src = significandParts();
- if(bits > 0) {
- lost_fraction = tmp.shiftSignificandRight(bits);
+ /* Step 1: place our absolute value, with any fraction truncated, in
+ the destination. */
+ if (exponent < 0) {
+ /* Our absolute value is less than one; truncate everything. */
+ APInt::tcSet(parts, 0, dstPartsCount);
+ /* For exponent -1 the integer bit represents .5, look at that.
+ For smaller exponents leftmost truncated bit is 0. */
+ truncatedBits = semantics->precision -1U - exponent;
} else {
- if (-bits >= semantics->precision) {
- // Unrepresentably large.
- if (!sign && isSigned)
- APInt::tcSetLeastSignificantBits(parts, partsCount, width-1);
- else if (!sign && !isSigned)
- APInt::tcSetLeastSignificantBits(parts, partsCount, width);
- else if (sign && isSigned) {
- APInt::tcSetLeastSignificantBits(parts, partsCount, 1);
- APInt::tcShiftLeft(parts, partsCount, width-1);
- } else // sign && !isSigned
- APInt::tcSet(parts, 0, partsCount);
- return (opStatus)(opOverflow | opInexact);
+ /* We want the most significant (exponent + 1) bits; the rest are
+ truncated. */
+ unsigned int bits = exponent + 1U;
+
+ /* Hopelessly large in magnitude? */
+ if (bits > width)
+ return opInvalidOp;
+
+ if (bits < semantics->precision) {
+ /* We truncate (semantics->precision - bits) bits. */
+ truncatedBits = semantics->precision - bits;
+ APInt::tcExtract(parts, dstPartsCount, src, bits, truncatedBits);
+ } else {
+ /* We want at least as many bits as are available. */
+ APInt::tcExtract(parts, dstPartsCount, src, semantics->precision, 0);
+ APInt::tcShiftLeft(parts, dstPartsCount, bits - semantics->precision);
+ truncatedBits = 0;
+ }
+ }
+
+ /* Step 2: work out any lost fraction, and increment the absolute
+ value if we would round away from zero. */
+ if (truncatedBits) {
+ lost_fraction = lostFractionThroughTruncation(src, partCount(),
+ truncatedBits);
+ if (lost_fraction != lfExactlyZero
+ && roundAwayFromZero(rounding_mode, lost_fraction, truncatedBits)) {
+ if (APInt::tcIncrement(parts, dstPartsCount))
+ return opInvalidOp; /* Overflow. */
}
- tmp.shiftSignificandLeft(-bits);
+ } else {
lost_fraction = lfExactlyZero;
}
- if(lost_fraction != lfExactlyZero
- && tmp.roundAwayFromZero(rounding_mode, lost_fraction, 0))
- tmp.incrementSignificand();
+ /* Step 3: check if we fit in the destination. */
+ unsigned int omsb = APInt::tcMSB(parts, dstPartsCount) + 1;
- msb = tmp.significandMSB();
+ if (sign) {
+ if (!isSigned) {
+ /* Negative numbers cannot be represented as unsigned. */
+ if (omsb != 0)
+ return opInvalidOp;
+ } else {
+ /* It takes omsb bits to represent the unsigned integer value.
+ We lose a bit for the sign, but care is needed as the
+ maximally negative integer is a special case. */
+ if (omsb == width && APInt::tcLSB(parts, dstPartsCount) + 1 != omsb)
+ return opInvalidOp;
+
+ /* This case can happen because of rounding. */
+ if (omsb > width)
+ return opInvalidOp;
+ }
- /* Negative numbers cannot be represented as unsigned. */
- if(!isSigned && tmp.sign && msb != -1U)
- return opInvalidOp;
+ APInt::tcNegate (parts, dstPartsCount);
+ } else {
+ if (omsb >= width + !isSigned)
+ return opInvalidOp;
+ }
- /* It takes exponent + 1 bits to represent the truncated floating
- point number without its sign. We lose a bit for the sign, but
- the maximally negative integer is a special case. */
- if(msb + 1 > width) /* !! Not same as msb >= width !! */
- return opInvalidOp;
+ if (lost_fraction == lfExactlyZero) {
+ *isExact = true;
+ return opOK;
+ } else
+ return opInexact;
+}
- if(isSigned && msb + 1 == width
- && (!tmp.sign || tmp.significandLSB() != msb))
- return opInvalidOp;
+/* Same as convertToSignExtendedInteger, except we provide
+ deterministic values in case of an invalid operation exception,
+ namely zero for NaNs and the minimal or maximal value respectively
+ for underflow or overflow.
+ The *isExact output tells whether the result is exact, in the sense
+ that converting it back to the original floating point type produces
+ the original value. This is almost equivalent to result==opOK,
+ except for negative zeroes.
+*/
+APFloat::opStatus
+APFloat::convertToInteger(integerPart *parts, unsigned int width,
+ bool isSigned,
+ roundingMode rounding_mode, bool *isExact) const
+{
+ opStatus fs;
- APInt::tcAssign(parts, tmp.significandParts(), partsCount);
+ fs = convertToSignExtendedInteger(parts, width, isSigned, rounding_mode,
+ isExact);
- if(tmp.sign)
- APInt::tcNegate(parts, partsCount);
+ if (fs == opInvalidOp) {
+ unsigned int bits, dstPartsCount;
- if(lost_fraction == lfExactlyZero)
- return opOK;
- else
- return opInexact;
+ dstPartsCount = partCountForBits(width);
+
+ if (category == fcNaN)
+ bits = 0;
+ else if (sign)
+ bits = isSigned;
+ else
+ bits = width - isSigned;
+
+ APInt::tcSetLeastSignificantBits(parts, dstPartsCount, bits);
+ if (sign && isSigned)
+ APInt::tcShiftLeft(parts, dstPartsCount, width - 1);
+ }
+
+ return fs;
}
/* Convert an unsigned integer SRC to a floating point number,
integerPart *dst;
lostFraction lost_fraction;
+ assertArithmeticOK(*semantics);
category = fcNormal;
omsb = APInt::tcMSB(src, srcCount) + 1;
dst = significandParts();
return normalize(rounding_mode, lost_fraction);
}
+APFloat::opStatus
+APFloat::convertFromAPInt(const APInt &Val,
+ bool isSigned,
+ roundingMode rounding_mode)
+{
+ unsigned int partCount = Val.getNumWords();
+ APInt api = Val;
+
+ sign = false;
+ if (isSigned && api.isNegative()) {
+ sign = true;
+ api = -api;
+ }
+
+ return convertFromUnsignedParts(api.getRawData(), partCount, rounding_mode);
+}
+
/* Convert a two's complement integer SRC to a floating point number,
rounding according to ROUNDING_MODE. ISSIGNED is true if the
integer is signed, in which case it must be sign-extended. */
bool isSigned,
roundingMode rounding_mode)
{
- assert(semantics != (const llvm::fltSemantics* const)&PPCDoubleDouble &&
- "Compile-time arithmetic on PPC long double not supported yet");
opStatus status;
+ assertArithmeticOK(*semantics);
if (isSigned
&& APInt::tcExtractBit(src, srcCount * integerPartWidth - 1)) {
integerPart *copy;
unsigned int width, bool isSigned,
roundingMode rounding_mode)
{
- assert(semantics != (const llvm::fltSemantics* const)&PPCDoubleDouble &&
- "Compile-time arithmetic on PPC long double not supported yet");
unsigned int partCount = partCountForBits(width);
APInt api = APInt(width, partCount, parts);
APFloat::convertFromHexadecimalString(const char *p,
roundingMode rounding_mode)
{
- assert(semantics != (const llvm::fltSemantics* const)&PPCDoubleDouble &&
- "Compile-time arithmetic on PPC long double not supported yet");
lostFraction lost_fraction;
integerPart *significand;
unsigned int bitPos, partsCount;
/* Calculate the exponent adjustment implicit in the number of
significant digits. */
- expAdjustment = dot - firstSignificantDigit;
+ expAdjustment = static_cast<int>(dot - firstSignificantDigit);
if(expAdjustment < 0)
expAdjustment++;
expAdjustment = expAdjustment * 4 - 1;
roundingMode rounding_mode)
{
unsigned int parts, pow5PartCount;
- fltSemantics calcSemantics = { 32767, -32767, 0 };
+ fltSemantics calcSemantics = { 32767, -32767, 0, true };
integerPart pow5Parts[maxPowerOfFiveParts];
bool isNearest;
decSig.exponent += exp;
lostFraction calcLostFraction;
- integerPart HUerr, HUdistance, powHUerr;
+ integerPart HUerr, HUdistance;
+ unsigned int powHUerr;
if (exp >= 0) {
/* multiplySignificand leaves the precision-th bit set to 1. */
excessPrecision = calcSemantics.precision;
}
/* Extra half-ulp lost in reciprocal of exponent. */
- powHUerr = (powStatus == opOK && calcLostFraction == lfExactlyZero) ? 0: 2;
+ powHUerr = (powStatus == opOK && calcLostFraction == lfExactlyZero) ? 0:2;
}
/* Both multiplySignificand and divideSignificand return the
APFloat::opStatus
APFloat::convertFromDecimalString(const char *p, roundingMode rounding_mode)
{
- const char *dot, *firstSignificantDigit;
- integerPart val, maxVal, decValue;
+ decimalInfo D;
opStatus fs;
- /* Skip leading zeroes and any decimal point. */
- p = skipLeadingZeroesAndAnyDot(p, &dot);
- firstSignificantDigit = p;
+ /* Scan the text. */
+ interpretDecimal(p, &D);
- /* The maximum number that can be multiplied by ten with any digit
- added without overflowing an integerPart. */
- maxVal = (~ (integerPart) 0 - 9) / 10;
+ /* Handle the quick cases. First the case of no significant digits,
+ i.e. zero, and then exponents that are obviously too large or too
+ small. Writing L for log 10 / log 2, a number d.ddddd*10^exp
+ definitely overflows if
- val = 0;
- while (val <= maxVal) {
- if (*p == '.') {
- assert(dot == 0);
- dot = p++;
- }
+ (exp - 1) * L >= maxExponent
- decValue = digitValue(*p);
- if (decValue == -1U)
- break;
- p++;
- val = val * 10 + decValue;
- }
-
- integerPart *decSignificand;
- unsigned int partCount, maxPartCount;
+ and definitely underflows to zero where
- partCount = 0;
- maxPartCount = 4;
- decSignificand = new integerPart[maxPartCount];
- decSignificand[partCount++] = val;
+ (exp + 1) * L <= minExponent - precision
- /* Now continue to do single-part arithmetic for as long as we can.
- Then do a part multiplication, and repeat. */
- while (decValue != -1U) {
- integerPart multiplier;
+ With integer arithmetic the tightest bounds for L are
- val = 0;
- multiplier = 1;
+ 93/28 < L < 196/59 [ numerator <= 256 ]
+ 42039/12655 < L < 28738/8651 [ numerator <= 65536 ]
+ */
- while (multiplier <= maxVal) {
- if (*p == '.') {
- assert(dot == 0);
- dot = p++;
- }
-
- decValue = digitValue(*p);
- if (decValue == -1U)
- break;
- p++;
- multiplier *= 10;
- val = val * 10 + decValue;
- }
-
- if (partCount == maxPartCount) {
- integerPart *newDecSignificand;
- newDecSignificand = new integerPart[maxPartCount = partCount * 2];
- APInt::tcAssign(newDecSignificand, decSignificand, partCount);
- delete [] decSignificand;
- decSignificand = newDecSignificand;
- }
-
- APInt::tcMultiplyPart(decSignificand, decSignificand, multiplier, val,
- partCount, partCount + 1, false);
-
- /* If we used another part (likely), increase the count. */
- if (decSignificand[partCount] != 0)
- partCount++;
- }
-
- /* Now decSignificand contains the supplied significand ignoring the
- decimal point. Figure out our effective exponent, which is the
- specified exponent adjusted for any decimal point. */
-
- if (p == firstSignificantDigit) {
- /* Ignore the exponent if we are zero - we cannot overflow. */
+ if (decDigitValue(*D.firstSigDigit) >= 10U) {
category = fcZero;
fs = opOK;
+ } else if ((D.normalizedExponent + 1) * 28738
+ <= 8651 * (semantics->minExponent - (int) semantics->precision)) {
+ /* Underflow to zero and round. */
+ zeroSignificand();
+ fs = normalize(rounding_mode, lfLessThanHalf);
+ } else if ((D.normalizedExponent - 1) * 42039
+ >= 12655 * semantics->maxExponent) {
+ /* Overflow and round. */
+ fs = handleOverflow(rounding_mode);
} else {
- int decimalExponent;
+ integerPart *decSignificand;
+ unsigned int partCount;
+
+ /* A tight upper bound on number of bits required to hold an
+ N-digit decimal integer is N * 196 / 59. Allocate enough space
+ to hold the full significand, and an extra part required by
+ tcMultiplyPart. */
+ partCount = static_cast<unsigned int>(D.lastSigDigit - D.firstSigDigit) + 1;
+ partCount = partCountForBits(1 + 196 * partCount / 59);
+ decSignificand = new integerPart[partCount + 1];
+ partCount = 0;
+
+ /* Convert to binary efficiently - we do almost all multiplication
+ in an integerPart. When this would overflow do we do a single
+ bignum multiplication, and then revert again to multiplication
+ in an integerPart. */
+ do {
+ integerPart decValue, val, multiplier;
- if (dot)
- decimalExponent = dot + 1 - p;
- else
- decimalExponent = 0;
+ val = 0;
+ multiplier = 1;
- /* Add the given exponent. */
- if (*p == 'e' || *p == 'E')
- decimalExponent = totalExponent(p, decimalExponent);
+ do {
+ if (*p == '.')
+ p++;
+
+ decValue = decDigitValue(*p++);
+ multiplier *= 10;
+ val = val * 10 + decValue;
+ /* The maximum number that can be multiplied by ten with any
+ digit added without overflowing an integerPart. */
+ } while (p <= D.lastSigDigit && multiplier <= (~ (integerPart) 0 - 9) / 10);
+
+ /* Multiply out the current part. */
+ APInt::tcMultiplyPart(decSignificand, decSignificand, multiplier, val,
+ partCount, partCount + 1, false);
+
+ /* If we used another part (likely but not guaranteed), increase
+ the count. */
+ if (decSignificand[partCount])
+ partCount++;
+ } while (p <= D.lastSigDigit);
category = fcNormal;
fs = roundSignificandWithExponent(decSignificand, partCount,
- decimalExponent, rounding_mode);
- }
+ D.exponent, rounding_mode);
- delete [] decSignificand;
+ delete [] decSignificand;
+ }
return fs;
}
APFloat::opStatus
APFloat::convertFromString(const char *p, roundingMode rounding_mode)
{
- assert(semantics != (const llvm::fltSemantics* const)&PPCDoubleDouble &&
- "Compile-time arithmetic on PPC long double not supported yet");
+ assertArithmeticOK(*semantics);
+
/* Handle a leading minus sign. */
if(*p == '-')
sign = 1, p++;
if(p[0] == '0' && (p[1] == 'x' || p[1] == 'X'))
return convertFromHexadecimalString(p + 2, rounding_mode);
- else
- return convertFromDecimalString(p, rounding_mode);
+
+ return convertFromDecimalString(p, rounding_mode);
}
/* Write out a hexadecimal representation of the floating point value
APFloat::convertToHexString(char *dst, unsigned int hexDigits,
bool upperCase, roundingMode rounding_mode) const
{
- assert(semantics != (const llvm::fltSemantics* const)&PPCDoubleDouble &&
- "Compile-time arithmetic on PPC long double not supported yet");
char *p;
+ assertArithmeticOK(*semantics);
+
p = dst;
if (sign)
*dst++ = '-';
*dst = 0;
- return dst - p;
+ return static_cast<unsigned int>(dst - p);
}
/* Does the hard work of outputting the correctly rounded hexadecimal
uint32_t hash = sign<<11 | semantics->precision | exponent<<12;
const integerPart* p = significandParts();
for (int i=partCount(); i>0; i--, p++)
- hash ^= ((uint32_t)*p) ^ (*p)>>32;
+ hash ^= ((uint32_t)*p) ^ (uint32_t)((*p)>>32);
return hash;
}
}
APInt
APFloat::convertF80LongDoubleAPFloatToAPInt() const
{
- assert(semantics == (const llvm::fltSemantics* const)&x87DoubleExtended);
+ assert(semantics == (const llvm::fltSemantics*)&x87DoubleExtended);
assert (partCount()==2);
uint64_t myexponent, mysignificand;
}
uint64_t words[2];
- words[0] = (((uint64_t)sign & 1) << 63) |
- ((myexponent & 0x7fff) << 48) |
+ words[0] = ((uint64_t)(sign & 1) << 63) |
+ ((myexponent & 0x7fffLL) << 48) |
((mysignificand >>16) & 0xffffffffffffLL);
words[1] = mysignificand & 0xffff;
return APInt(80, 2, words);
APInt
APFloat::convertPPCDoubleDoubleAPFloatToAPInt() const
{
- assert(semantics == (const llvm::fltSemantics* const)&PPCDoubleDouble);
+ assert(semantics == (const llvm::fltSemantics*)&PPCDoubleDouble);
assert (partCount()==2);
uint64_t myexponent, mysignificand, myexponent2, mysignificand2;
}
uint64_t words[2];
- words[0] = (((uint64_t)sign & 1) << 63) |
+ words[0] = ((uint64_t)(sign & 1) << 63) |
((myexponent & 0x7ff) << 52) |
(mysignificand & 0xfffffffffffffLL);
- words[1] = (((uint64_t)sign2 & 1) << 63) |
+ words[1] = ((uint64_t)(sign2 & 1) << 63) |
((myexponent2 & 0x7ff) << 52) |
(mysignificand2 & 0xfffffffffffffLL);
return APInt(128, 2, words);
mysignificand = *significandParts();
}
- return APInt(64, (((((uint64_t)sign & 1) << 63) |
+ return APInt(64, ((((uint64_t)(sign & 1) << 63) |
((myexponent & 0x7ff) << 52) |
(mysignificand & 0xfffffffffffffLL))));
}
if (category==fcNormal) {
myexponent = exponent+127; //bias
- mysignificand = *significandParts();
- if (myexponent == 1 && !(mysignificand & 0x400000))
+ mysignificand = (uint32_t)*significandParts();
+ if (myexponent == 1 && !(mysignificand & 0x800000))
myexponent = 0; // denormal
} else if (category==fcZero) {
myexponent = 0;
} else {
assert(category == fcNaN && "Unknown category!");
myexponent = 0xff;
- mysignificand = *significandParts();
+ mysignificand = (uint32_t)*significandParts();
}
return APInt(32, (((sign&1) << 31) | ((myexponent&0xff) << 23) |
// and treating the result as a normal integer is unlikely to be useful.
APInt
-APFloat::convertToAPInt() const
+APFloat::bitcastToAPInt() const
{
- if (semantics == (const llvm::fltSemantics* const)&IEEEsingle)
+ if (semantics == (const llvm::fltSemantics*)&IEEEsingle)
return convertFloatAPFloatToAPInt();
- if (semantics == (const llvm::fltSemantics* const)&IEEEdouble)
+ if (semantics == (const llvm::fltSemantics*)&IEEEdouble)
return convertDoubleAPFloatToAPInt();
- if (semantics == (const llvm::fltSemantics* const)&PPCDoubleDouble)
+ if (semantics == (const llvm::fltSemantics*)&PPCDoubleDouble)
return convertPPCDoubleDoubleAPFloatToAPInt();
- assert(semantics == (const llvm::fltSemantics* const)&x87DoubleExtended &&
+ assert(semantics == (const llvm::fltSemantics*)&x87DoubleExtended &&
"unknown format!");
return convertF80LongDoubleAPFloatToAPInt();
}
float
APFloat::convertToFloat() const
{
- assert(semantics == (const llvm::fltSemantics* const)&IEEEsingle);
- APInt api = convertToAPInt();
+ assert(semantics == (const llvm::fltSemantics*)&IEEEsingle);
+ APInt api = bitcastToAPInt();
return api.bitsToFloat();
}
double
APFloat::convertToDouble() const
{
- assert(semantics == (const llvm::fltSemantics* const)&IEEEdouble);
- APInt api = convertToAPInt();
+ assert(semantics == (const llvm::fltSemantics*)&IEEEdouble);
+ APInt api = bitcastToAPInt();
return api.bitsToDouble();
}
-/// Integer bit is explicit in this format. Current Intel book does not
-/// define meaning of:
-/// exponent = all 1's, integer bit not set.
-/// exponent = 0, integer bit set. (formerly "psuedodenormals")
-/// exponent!=0 nor all 1's, integer bit not set. (formerly "unnormals")
+/// Integer bit is explicit in this format. Intel hardware (387 and later)
+/// does not support these bit patterns:
+/// exponent = all 1's, integer bit 0, significand 0 ("pseudoinfinity")
+/// exponent = all 1's, integer bit 0, significand nonzero ("pseudoNaN")
+/// exponent = 0, integer bit 1 ("pseudodenormal")
+/// exponent!=0 nor all 1's, integer bit 0 ("unnormal")
+/// At the moment, the first two are treated as NaNs, the second two as Normal.
void
APFloat::initFromF80LongDoubleAPInt(const APInt &api)
{
initialize(&APFloat::x87DoubleExtended);
assert(partCount()==2);
- sign = i1>>63;
+ sign = static_cast<unsigned int>(i1>>63);
if (myexponent==0 && mysignificand==0) {
// exponent, significand meaningless
category = fcZero;
initialize(&APFloat::PPCDoubleDouble);
assert(partCount()==2);
- sign = i1>>63;
- sign2 = i2>>63;
+ sign = static_cast<unsigned int>(i1>>63);
+ sign2 = static_cast<unsigned int>(i2>>63);
if (myexponent==0 && mysignificand==0) {
// exponent, significand meaningless
// exponent2 and significand2 are required to be 0; we don't check
initialize(&APFloat::IEEEdouble);
assert(partCount()==1);
- sign = i>>63;
+ sign = static_cast<unsigned int>(i>>63);
if (myexponent==0 && mysignificand==0) {
// exponent, significand meaningless
category = fcZero;