6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-14 11:32:34 +00:00
Code Issues Projects Releases Wiki Activity

Poison APFloat::operator==. Replace existing uses with bitwiseIsEqual.

Browse Source 
This means backing out the preceding change to Constants.cpp, alas.



git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41378 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Dale Johannesen 2007-08-24 22:09:56 +00:00
parent 8bb369b807
commit 12595d7b16
4 changed files with 29 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
include/llvm/ADT/APFloat.h
View File

@ -187,17 +187,17 @@ namespace llvm {
double convertToDouble() const;
float convertToFloat() const;
/* The definition of equality is not straightforward for floating point,
so we won't use operator==. Use one of the following, or write
whatever it is you really mean. */
bool operator==(const APFloat &) const; // DO NOT IMPLEMENT
/* IEEE comparison with another floating point number (QNaNs
compare unordered, 0==-0). */
cmpResult compare(const APFloat &) const;
/* 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);
}
bool bitwiseIsEqual(const APFloat &) const;
/* Simple queries. */
fltCategory getCategory() const { return category; }

2
lib/CodeGen/SelectionDAG/SelectionDAG.cpp
View File

@ -49,7 +49,7 @@ static SDVTList makeVTList(const MVT::ValueType *VTs, unsigned NumVTs) {
/// As such, this method can be used to do an exact bit-for-bit comparison of
/// two floating point values.
bool ConstantFPSDNode::isExactlyValue(double V) const {
return Value == APFloat(V);
return Value.bitwiseIsEqual(APFloat(V));
}
//===----------------------------------------------------------------------===//

2
lib/Support/APFloat.cpp
View File

@ -276,7 +276,7 @@ APFloat::operator=(const APFloat &rhs)
}
bool
APFloat::operator==(const APFloat &rhs) const {
APFloat::bitwiseIsEqual(const APFloat &rhs) const {
if (this == &rhs)
return true;
if (semantics != rhs.semantics ||

31
lib/VMCore/Constants.cpp
View File

@ -248,19 +248,30 @@ bool ConstantFP::isNullValue() const {
}
bool ConstantFP::isExactlyValue(double V) const {
return Val == APFloat(V);
return Val.bitwiseIsEqual(APFloat(V));
}
namespace {
struct DenseMapAPFloatKeyInfo {
static inline APFloat getEmptyKey() {
return APFloat(APFloat::Bogus,1);
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.bitwiseIsEqual(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 getTombstoneKey() {
return APFloat(APFloat::Bogus,2);
static inline KeyTy getTombstoneKey() {
return KeyTy(APFloat(APFloat::Bogus,2));
}
static unsigned getHashValue(const APFloat &Key) {
return Key.getHashValue();
static unsigned getHashValue(const KeyTy &Key) {
return Key.val.getHashValue();
}
static bool isPod() { return false; }
};
@ -268,21 +279,21 @@ namespace {
//---- ConstantFP::get() implementation...
//
typedef DenseMap<APFloat, ConstantFP*,
typedef DenseMap<DenseMapAPFloatKeyInfo::KeyTy, ConstantFP*,
DenseMapAPFloatKeyInfo> FPMapTy;
static ManagedStatic<FPMapTy> FPConstants;
ConstantFP *ConstantFP::get(const Type *Ty, double V) {
if (Ty == Type::FloatTy) {
APFloat Key(APFloat((float)V));
DenseMapAPFloatKeyInfo::KeyTy 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.
APFloat Key(APFloat((double)V));
DenseMapAPFloatKeyInfo::KeyTy Key(APFloat((double)V));
ConstantFP *&Slot = (*FPConstants)[Key];
if (Slot) return Slot;
return Slot = new ConstantFP(Ty, V);