Move a bit more functionality to LLVMContext, which apparently wasn't being used...

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

diff --git a/include/llvm/Constants.h b/include/llvm/Constants.h
index 143f3ad7578ba614abb89fd682ddf4d0c8949603..4590528f61a0183a5278243adc40dbffe3635a8c 100644 (file)
--- a/include/llvm/Constants.h
+++ b/include/llvm/Constants.h
@@ -256,12 +256,6 @@ public:
   /// get() - Static factory methods - Return objects of the specified value
   static ConstantFP *get(const APFloat &V);
 
-  /// get() - This returns a ConstantFP, or a vector containing a splat of a
-  /// ConstantFP, for the specified value in the specified type.  This should
-  /// only be used for simple constant values like 2.0/1.0 etc, that are
-  /// known-valid both as host double and as the target format.
-  static Constant *get(const Type *Ty, double V);
-
   /// isValueValidForType - return true if Ty is big enough to represent V.
   static bool isValueValidForType(const Type *Ty, const APFloat& V);
   inline const APFloat& getValueAPF() const { return Val; }

diff --git a/include/llvm/LLVMContext.h b/include/llvm/LLVMContext.h
index 55eead4621c27f6e3c1c1b193b5a8e4cec9d9783..e71183855a65aa3830b22b9776deb6252cc75ab9 100644 (file)
--- a/include/llvm/LLVMContext.h
+++ b/include/llvm/LLVMContext.h
@@ -183,6 +183,11 @@ public:
   
   // ConstantFP accessors
   ConstantFP* getConstantFP(const APFloat& V);
+  
+  /// get() - This returns a ConstantFP, or a vector containing a splat of a
+  /// ConstantFP, for the specified value in the specified type.  This should
+  /// only be used for simple constant values like 2.0/1.0 etc, that are
+  /// known-valid both as host double and as the target format.
   Constant* getConstantFP(const Type* Ty, double V);
   ConstantFP* getConstantFPNegativeZero(const Type* Ty);
   

diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp
index 184ae9d21ed55612684275cf017e1ca8ea4bdec4..8b71956e206331d0cd7b01e7474c876f1fd38188 100644 (file)
--- a/lib/VMCore/Constants.cpp
+++ b/lib/VMCore/Constants.cpp
@@ -382,24 +382,6 @@ ConstantFP *ConstantFP::get(const APFloat &V) {
   return Slot;
 }
 
-/// get() - This returns a constant fp for the specified value in the
-/// specified type.  This should only be used for simple constant values like
-/// 2.0/1.0 etc, that are known-valid both as double and as the target format.
-Constant *ConstantFP::get(const Type *Ty, double V) {
-  APFloat FV(V);
-  bool ignored;
-  FV.convert(*TypeToFloatSemantics(Ty->getScalarType()),
-             APFloat::rmNearestTiesToEven, &ignored);
-  Constant *C = get(FV);
-
-  // For vectors, broadcast the value.
-  if (const VectorType *VTy = dyn_cast<VectorType>(Ty))
-    return
-      ConstantVector::get(std::vector<Constant *>(VTy->getNumElements(), C));
-
-  return C;
-}
-
 //===----------------------------------------------------------------------===//
 //                            ConstantXXX Classes
 //===----------------------------------------------------------------------===//

diff --git a/lib/VMCore/LLVMContext.cpp b/lib/VMCore/LLVMContext.cpp
index a7df2affe3123632300e4bc1674fb710ac7ec9cb..8d57d2c6fa06cb30ed28e6975bfc280c4bf34a51 100644 (file)
--- a/lib/VMCore/LLVMContext.cpp
+++ b/lib/VMCore/LLVMContext.cpp
@@ -442,8 +442,36 @@ ConstantFP* LLVMContext::getConstantFP(const APFloat& V) {
   return ConstantFP::get(V);
 }
 
+static const fltSemantics *TypeToFloatSemantics(const Type *Ty) {
+  if (Ty == Type::FloatTy)
+    return &APFloat::IEEEsingle;
+  if (Ty == Type::DoubleTy)
+    return &APFloat::IEEEdouble;
+  if (Ty == Type::X86_FP80Ty)
+    return &APFloat::x87DoubleExtended;
+  else if (Ty == Type::FP128Ty)
+    return &APFloat::IEEEquad;
+  
+  assert(Ty == Type::PPC_FP128Ty && "Unknown FP format");
+  return &APFloat::PPCDoubleDouble;
+}
+
+/// get() - This returns a constant fp for the specified value in the
+/// specified type.  This should only be used for simple constant values like
+/// 2.0/1.0 etc, that are known-valid both as double and as the target format.
 Constant* LLVMContext::getConstantFP(const Type* Ty, double V) {
-  return ConstantFP::get(Ty, V);
+  APFloat FV(V);
+  bool ignored;
+  FV.convert(*TypeToFloatSemantics(Ty->getScalarType()),
+             APFloat::rmNearestTiesToEven, &ignored);
+  Constant *C = getConstantFP(FV);
+
+  // For vectors, broadcast the value.
+  if (const VectorType *VTy = dyn_cast<VectorType>(Ty))
+    return
+      getConstantVector(std::vector<Constant *>(VTy->getNumElements(), C));
+
+  return C;
 }
 
 ConstantFP* LLVMContext::getConstantFPNegativeZero(const Type* Ty) {