//
// 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 "llvm/ADT/APFloat.h"
+#include "llvm/ADT/FoldingSet.h"
#include <cassert>
#include <cstring>
-#include "llvm/ADT/APFloat.h"
#include "llvm/Support/MathExtras.h"
using namespace llvm;
/* 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;
}
/* Returns 0U-9U. Return values >= 10U are not digits. */
- inline unsigned int
+ static inline unsigned int
decDigitValue(unsigned int c)
{
return c - '0';
}
- unsigned int
+ static unsigned int
hexDigitValue(unsigned int c)
{
unsigned int r;
return -1U;
}
- inline void
+ static inline void
assertArithmeticOK(const llvm::fltSemantics &semantics) {
assert(semantics.arithmeticOK
&& "Compile-time arithmetic does not support these semantics");
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++;
return exponent;
}
- const char *
+ static const char *
skipLeadingZeroesAndAnyDot(const char *p, const char **dot)
{
*dot = 0;
is taken to have the decimal point after a single leading
non-zero digit.
- If the value is zero, V->firstSigDigit points to a zero, and the
- return exponent is zero.
+ If the value is zero, V->firstSigDigit points to a non-digit, and
+ the return exponent is zero.
*/
struct decimalInfo {
const char *firstSigDigit;
int normalizedExponent;
};
- void
+ static void
interpretDecimal(const char *p, decimalInfo *D)
{
const char *dot;
while (*p == '.');
/* Adjust the exponents for any decimal point. */
- D->exponent += (dot - p) - (dot > p);
- D->normalizedExponent = (D->exponent + (p - D->firstSigDigit)
- - (dot > D->firstSigDigit && dot < p));
+ 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 };
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 {
freeSignificand();
}
+// Profile - This method 'profiles' an APFloat for use with FoldingSet.
+void APFloat::Profile(FoldingSetNodeID& ID) const {
+ ID.Add(convertToAPInt());
+}
+
unsigned int
APFloat::partCount() const
{
opStatus fs;
assertArithmeticOK(*semantics);
+ assertArithmeticOK(toSemantics);
lostFraction = lfExactlyZero;
newPartCount = partCountForBits(toSemantics.precision + 1);
oldPartCount = partCount();
fs = normalize(rounding_mode, lostFraction);
} else if (category == fcNaN) {
int shift = toSemantics.precision - semantics->precision;
+ // Do this now so significandParts gets the right answer
+ semantics = &toSemantics;
// No normalization here, just truncate
if (shift>0)
APInt::tcShiftLeft(significandParts(), newPartCount, shift);
// 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;
const integerPart *src;
unsigned int dstPartsCount, truncatedBits;
+ assertArithmeticOK(*semantics);
+
/* Handle the three special cases first. */
if(category == fcInfinity || category == fcNaN)
return opInvalidOp;
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. */
/* 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;
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
42039/12655 < L < 28738/8651 [ numerator <= 65536 ]
*/
- if (*D.firstSigDigit == '0') {
+ if (decDigitValue(*D.firstSigDigit) >= 10U) {
category = fcZero;
fs = opOK;
} else if ((D.normalizedExponent + 1) * 28738
N-digit decimal integer is N * 196 / 59. Allocate enough space
to hold the full significand, and an extra part required by
tcMultiplyPart. */
- partCount = (D.lastSigDigit - D.firstSigDigit) + 1;
+ partCount = static_cast<unsigned int>(D.lastSigDigit - D.firstSigDigit) + 1;
partCount = partCountForBits(1 + 196 * partCount / 59);
decSignificand = new integerPart[partCount + 1];
partCount = 0;
partCount++;
} while (p <= D.lastSigDigit);
+ category = fcNormal;
fs = roundSignificandWithExponent(decSignificand, partCount,
D.exponent, rounding_mode);
*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) |
APInt
APFloat::convertToAPInt() 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);
+ assert(semantics == (const llvm::fltSemantics*)&IEEEsingle);
APInt api = convertToAPInt();
return api.bitsToFloat();
}
double
APFloat::convertToDouble() const
{
- assert(semantics == (const llvm::fltSemantics* const)&IEEEdouble);
+ assert(semantics == (const llvm::fltSemantics*)&IEEEdouble);
APInt api = convertToAPInt();
return api.bitsToDouble();
}
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;
projects / oota-llvm.git / blobdiff