Patch 10 for long double. Doing constants right needs expanding ConstantFP

to handle values bigger than double.  If we assume host==target and host
long double works correctly, this is not too bad, but we don't want to
have that limitation longterm.  I could implement accepting double
constants as long double or something like that, which would lead to
incorrect codegen with no errors; the more I think about that the worse
it seems.  Rather than do such a hack that would be backed out later,
I'm settling for giving reasonable error messages, for now.

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

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 07a4279e13cab8b85af48fa88ff736ada471e425..eb18e31531015b6c762f89ad84b172b2727a3e8d 100644 (file)
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -629,6 +629,10 @@ bool BitcodeReader::ParseConstants() {
         V = ConstantFP::get(CurTy, BitsToFloat(Record[0]));
       else if (CurTy == Type::DoubleTy)
         V = ConstantFP::get(CurTy, BitsToDouble(Record[0]));
+      // FIXME: Make long double constants work.
+      else if (CurTy == Type::X86_FP80Ty ||
+               CurTy == Type::FP128Ty || CurTy == Type::PPC_FP128Ty)
+        assert(0 && "Long double constants not handled yet.");
       else
         V = UndefValue::get(CurTy);
       break;

diff --git a/lib/Bitcode/Writer/BitcodeWriter.cpp b/lib/Bitcode/Writer/BitcodeWriter.cpp
index c5be80fc508eb58d65153456c4f344a8e490fc52..17c14f0a0d1e7243ac39bf47c57137a041639cf8 100644 (file)
--- a/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -525,11 +525,17 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal,
       }
     } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(C)) {
       Code = bitc::CST_CODE_FLOAT;
-      if (CFP->getType() == Type::FloatTy) {
+      const Type *Ty = CFP->getType();
+      if (Ty == Type::FloatTy) {
         Record.push_back(FloatToBits((float)CFP->getValue()));
-      } else {
-        assert (CFP->getType() == Type::DoubleTy && "Unknown FP type!");
+      } else if (Ty == Type::DoubleTy) {
         Record.push_back(DoubleToBits((double)CFP->getValue()));
+      // FIXME: make long double constants work.
+      } else if (Ty == Type::X86_FP80Ty ||
+                 Ty == Type::FP128Ty || Ty == Type::PPC_FP128Ty) {
+        assert (0 && "Long double constants not handled yet.");
+      } else {
+        assert (0 && "Unknown FP type!");
       }
     } else if (isa<ConstantArray>(C) && cast<ConstantArray>(C)->isString()) {
       // Emit constant strings specially.

diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp
index e171011159c972a15727196c5f14d83efae4c25e..eadfe39afa6a4c59d6c30a710ec18ccafe2e6822 100644 (file)
--- a/lib/VMCore/Constants.cpp
+++ b/lib/VMCore/Constants.cpp
@@ -108,6 +108,9 @@ Constant *Constant::getNullValue(const Type *Ty) {
     return ConstantInt::get(Ty, 0);
   case Type::FloatTyID:
   case Type::DoubleTyID:
+  case Type::X86_FP80TyID:
+  case Type::PPC_FP128TyID:
+  case Type::FP128TyID:
     return ConstantFP::get(Ty, 0.0);
   case Type::PointerTyID:
     return ConstantPointerNull::get(cast<PointerType>(Ty));
@@ -288,12 +291,17 @@ ConstantFP *ConstantFP::get(const Type *Ty, double V) {
     ConstantFP *&Slot = (*FloatConstants)[std::make_pair(IntVal, Ty)];
     if (Slot) return Slot;
     return Slot = new ConstantFP(Ty, (float)V);
-  } else {
-    assert(Ty == Type::DoubleTy);
+  } else if (Ty == Type::DoubleTy) { 
     uint64_t IntVal = DoubleToBits(V);
     ConstantFP *&Slot = (*DoubleConstants)[std::make_pair(IntVal, Ty)];
     if (Slot) return Slot;
     return Slot = new ConstantFP(Ty, V);
+  // FIXME:  Make long double constants work.
+  } else if (Ty == Type::X86_FP80Ty ||
+             Ty == Type::PPC_FP128Ty || Ty == Type::FP128Ty) {
+    assert(0 && "Long double constants not handled yet.");
+  } else {
+    assert(0 && "Unknown FP Type!");
   }
 }
 
@@ -696,10 +704,13 @@ bool ConstantFP::isValueValidForType(const Type *Ty, double Val) {
   default:
     return false;         // These can't be represented as floating point!
 
-    // TODO: Figure out how to test if a double can be cast to a float!
+    // TODO: Figure out how to test if we can use a shorter type instead!
   case Type::FloatTyID:
   case Type::DoubleTyID:
-    return true;          // This is the largest type...
+  case Type::X86_FP80TyID:
+  case Type::PPC_FP128TyID:
+  case Type::FP128TyID:
+    return true;
   }
 }