/* Bitwise comparison for equality (QNaNs compare equal, 0!=-0). */
bool operator==(const APFloat &) const;
+ /* Inversion of the preceding. */
+ inline bool operator!=(const APFloat &RHS) const {
+ return !((*this)==RHS);
+ }
+
/* Simple queries. */
fltCategory getCategory() const { return category; }
const fltSemantics &getSemantics() const { return *semantics; }
#include <cassert>
#include "llvm/ADT/APFloat.h"
+#include "llvm/Support/MathExtras.h"
using namespace llvm;
double
APFloat::convertToDouble() const {
- union {
- double d;
- uint64_t i;
- } u;
assert(semantics == (const llvm::fltSemantics* const)&IEEEdouble);
assert (partCount()==1);
} else
assert(0);
- u.i = ((mysign & 1) << 63) | ((myexponent & 0x7ff) << 52) |
- (mysignificand & 0xfffffffffffffLL);
- return u.d;
+ return BitsToDouble(((mysign & 1) << 63) | ((myexponent & 0x7ff) << 52) |
+ (mysignificand & 0xfffffffffffffLL));
}
float
APFloat::convertToFloat() const {
- union {
- float f;
- int32_t i;
- } u;
assert(semantics == (const llvm::fltSemantics* const)&IEEEsingle);
assert (partCount()==1);
} else
assert(0);
- u.i = ((mysign&1) << 31) | ((myexponent&0xff) << 23) |
- ((mysignificand & 0x7fffff));
- return u.f;
+ return BitsToFloat(((mysign&1) << 31) | ((myexponent&0xff) << 23) |
+ (mysignificand & 0x7fffff));
}
APFloat::APFloat(double d) {
+ uint64_t i = DoubleToBits(d);
+ uint64_t mysign = i >> 63;
+ uint64_t myexponent = (i >> 52) & 0x7ff;
+ uint64_t mysignificand = i & 0xfffffffffffffLL;
+
initialize(&APFloat::IEEEdouble);
- union {
- double d;
- uint64_t i;
- } u;
- u.d = d;
assert(partCount()==1);
- uint64_t mysign, myexponent, mysignificand;
-
- mysign = u.i >> 63;
- myexponent = (u.i >> 52) & 0x7ff;
- mysignificand = u.i & 0xfffffffffffffLL;
-
if (myexponent==0 && mysignificand==0) {
// exponent, significand meaningless
category = fcZero;
}
APFloat::APFloat(float f) {
+ uint32_t i = FloatToBits(f);
+ uint32_t mysign = i >> 31;
+ uint32_t myexponent = (i >> 23) & 0xff;
+ uint32_t mysignificand = i & 0x7fffff;
+
initialize(&APFloat::IEEEsingle);
- union {
- float f;
- uint32_t i;
- } u;
- u.f = f;
assert(partCount()==1);
- uint32_t mysign, myexponent, mysignificand;
-
- mysign = u.i >> 31;
- myexponent = (u.i >> 23) & 0xff;
- mysignificand = u.i & 0x7fffff;
-
if (myexponent==0 && mysignificand==0) {
// exponent, significand meaningless
category = fcZero;
namespace {
struct DenseMapAPFloatKeyInfo {
- struct KeyTy {
- APFloat val;
- KeyTy(const APFloat& V) : val(V){}
- KeyTy(const KeyTy& that) : val(that.val) {}
- bool operator==(const KeyTy& that) const {
- return this->val == that.val;
- }
- bool operator!=(const KeyTy& that) const {
- return !this->operator==(that);
- }
- };
- static inline KeyTy getEmptyKey() {
- return KeyTy(APFloat(APFloat::Bogus,1));
+ static inline APFloat getEmptyKey() {
+ return APFloat(APFloat::Bogus,1);
}
- static inline KeyTy getTombstoneKey() {
- return KeyTy(APFloat(APFloat::Bogus,2));
+ static inline APFloat getTombstoneKey() {
+ return APFloat(APFloat::Bogus,2);
}
- static unsigned getHashValue(const KeyTy &Key) {
- return Key.val.getHashValue();
+ static unsigned getHashValue(const APFloat &Key) {
+ return Key.getHashValue();
}
static bool isPod() { return false; }
};
//---- ConstantFP::get() implementation...
//
-typedef DenseMap<DenseMapAPFloatKeyInfo::KeyTy, ConstantFP*,
+typedef DenseMap<APFloat, ConstantFP*,
DenseMapAPFloatKeyInfo> FPMapTy;
static ManagedStatic<FPMapTy> FPConstants;
ConstantFP *ConstantFP::get(const Type *Ty, double V) {
if (Ty == Type::FloatTy) {
- DenseMapAPFloatKeyInfo::KeyTy Key(APFloat((float)V));
+ APFloat Key(APFloat((float)V));
ConstantFP *&Slot = (*FPConstants)[Key];
if (Slot) return Slot;
return Slot = new ConstantFP(Ty, (float)V);
} else if (Ty == Type::DoubleTy) {
// Without the redundant cast, the following is taken to be
// a function declaration. What a language.
- DenseMapAPFloatKeyInfo::KeyTy Key(APFloat((double)V));
+ APFloat Key(APFloat((double)V));
ConstantFP *&Slot = (*FPConstants)[Key];
if (Slot) return Slot;
return Slot = new ConstantFP(Ty, V);