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

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

diff --git a/include/llvm/ADT/APFloat.h b/include/llvm/ADT/APFloat.h
index 695c99a107958d44e169dd88aab4719980f66dfc..7b95392e7ff6ad04f9ec868210509458abccd71d 100644 (file)
--- a/include/llvm/ADT/APFloat.h
+++ b/include/llvm/ADT/APFloat.h
@@ -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; }

diff --git a/lib/CodeGen/SelectionDAG/SelectionDAG.cpp b/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
index 10ffdc42b1523ba841944c9d33f17d9e3503bcb4..6155ee160c25c5522aedabbed1595d6a5e241e8a 100644 (file)
--- a/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
+++ b/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
@@ -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));
 }
 
 //===----------------------------------------------------------------------===//

diff --git a/lib/Support/APFloat.cpp b/lib/Support/APFloat.cpp
index 8f1a566c30305b9432b9ba55294f79a068cf0186..d2e52adb17085b542a50d1f6997f5068f6841f34 100644 (file)
--- a/lib/Support/APFloat.cpp
+++ b/lib/Support/APFloat.cpp
@@ -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 ||

diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp
index 36ba7c0220c035d1a2bb05732a5e4cd965f74368..04689e4c98a2c53f196e7181ef8bd68a597e3ab8 100644 (file)
--- a/lib/VMCore/Constants.cpp
+++ b/lib/VMCore/Constants.cpp
@@ -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);