//
// 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;
If the exponent overflows, returns a large exponent with the
appropriate sign. */
- static int
+ int
readExponent(const char *p)
{
bool isNegative;
/* This is ugly and needs cleaning up, but I don't immediately see
how whilst remaining safe. */
- static int
+ int
totalExponent(const char *p, int exponentAdjustment)
{
integerPart unsignedExponent;
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;
/* Place pow(5, power) in DST, and return the number of parts used.
DST must be at least one part larger than size of the answer. */
- static unsigned int
+ unsigned int
powerOf5(integerPart *dst, unsigned int power)
{
static integerPart firstEightPowers[] = { 1, 5, 25, 125, 625, 3125,
/* Write out an integerPart in hexadecimal, starting with the most
significant nibble. Write out exactly COUNT hexdigits, return
COUNT. */
- static unsigned int
+ unsigned int
partAsHex (char *dst, integerPart part, unsigned int count,
const char *hexDigitChars)
{
}
/* Write out an unsigned decimal integer. */
- static char *
+ char *
writeUnsignedDecimal (char *dst, unsigned int n)
{
char buff[40], *p;
}
/* Write out a signed decimal integer. */
- static char *
+ char *
writeSignedDecimal (char *dst, int value)
{
if (value < 0) {
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
{
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;
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
APInt
APFloat::convertF80LongDoubleAPFloatToAPInt() const
{
- assert(semantics == (const llvm::fltSemantics* const)&x87DoubleExtended);
+ assert(semantics == (const llvm::fltSemantics*)&x87DoubleExtended);
assert (partCount()==2);
uint64_t myexponent, mysignificand;
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;
if (category==fcNormal) {
myexponent = exponent+127; //bias
mysignificand = *significandParts();
- if (myexponent == 1 && !(mysignificand & 0x400000))
+ if (myexponent == 1 && !(mysignificand & 0x800000))
myexponent = 0; // denormal
} else if (category==fcZero) {
myexponent = 0;
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();
}