PR5207: change APInt::doubleToBits() and APInt::floatToBits() to be

static methods that return a new APInt.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@120261 91177308-0d34-0410-b5e6-96231b3b80d8

include/llvm/ADT/APInt.h

@@ -1293,37 +1293,27 @@ public:
   }
 
   /// The conversion does not do a translation from double to integer, it just
-  /// re-interprets the bits of the double. Note that it is valid to do this on
+  /// re-interprets the bits of the double.
-  /// any bit width but bits from V may get truncated.
   /// @brief Converts a double to APInt bits.
-  APInt& doubleToBits(double V) {
+  static APInt doubleToBits(double V) {
     union {
       uint64_t I;
       double D;
     } T;
     T.D = V;
-    if (isSingleWord())
+    return APInt(sizeof T * CHAR_BIT, T.I);
-      VAL = T.I;
-    else
-      pVal[0] = T.I;
-    return clearUnusedBits();
   }
 
   /// The conversion does not do a translation from float to integer, it just
-  /// re-interprets the bits of the float. Note that it is valid to do this on
+  /// re-interprets the bits of the float.
-  /// any bit width but bits from V may get truncated.
   /// @brief Converts a float to APInt bits.
-  APInt& floatToBits(float V) {
+  static APInt floatToBits(float V) {
     union {
       unsigned I;
       float F;
     } T;
     T.F = V;
-    if (isSingleWord())
+    return APInt(sizeof T * CHAR_BIT, T.I);
-      VAL = T.I;
-    else
-      pVal[0] = T.I;
-    return clearUnusedBits();
   }
 
   /// @}

lib/ExecutionEngine/ExecutionEngine.cpp

@@ -637,11 +637,11 @@ GenericValue ExecutionEngine::getConstantValue(const Constant *C) {
           break;
         case Type::FloatTyID:
           assert(DestTy->isIntegerTy(32) && "Invalid bitcast");
-          GV.IntVal.floatToBits(GV.FloatVal);
+          GV.IntVal = APInt::floatToBits(GV.FloatVal);
           break;
         case Type::DoubleTyID:
           assert(DestTy->isIntegerTy(64) && "Invalid bitcast");
-          GV.IntVal.doubleToBits(GV.DoubleVal);
+          GV.IntVal = APInt::doubleToBits(GV.DoubleVal);
           break;
         case Type::PointerTyID:
           assert(DestTy->isPointerTy() && "Invalid bitcast");

lib/ExecutionEngine/Interpreter/Execution.cpp

@@ -1060,11 +1060,9 @@ GenericValue Interpreter::executeBitCastInst(Value *SrcVal, const Type *DstTy,
     Dest.PointerVal = Src.PointerVal;
   } else if (DstTy->isIntegerTy()) {
     if (SrcTy->isFloatTy()) {
-      Dest.IntVal.zext(sizeof(Src.FloatVal) * CHAR_BIT);
+      Dest.IntVal = APInt::floatToBits(Src.FloatVal);
-      Dest.IntVal.floatToBits(Src.FloatVal);
     } else if (SrcTy->isDoubleTy()) {
-      Dest.IntVal.zext(sizeof(Src.DoubleVal) * CHAR_BIT);
+      Dest.IntVal = APInt::doubleToBits(Src.DoubleVal);
-      Dest.IntVal.doubleToBits(Src.DoubleVal);
     } else if (SrcTy->isIntegerTy()) {
       Dest.IntVal = Src.IntVal;
     } else 

lib/Support/APFloat.cpp

@@ -3258,14 +3258,12 @@ APFloat::APFloat(const APInt& api, bool isIEEE)
 
 APFloat::APFloat(float f)
 {
-  APInt api = APInt(32, 0);
+  initFromAPInt(APInt::floatToBits(f));
-  initFromAPInt(api.floatToBits(f));
 }
 
 APFloat::APFloat(double d)
 {
-  APInt api = APInt(64, 0);
+  initFromAPInt(APInt::doubleToBits(d));
-  initFromAPInt(api.doubleToBits(d));
 }
 
 namespace {