From 6f83c9c6ef0e7f79825a0a8f22941815e4b684c7 Mon Sep 17 00:00:00 2001 From: Owen Anderson Date: Mon, 27 Jul 2009 20:59:43 +0000 Subject: Move ConstantFP construction back to the 2.5-ish API. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@77247 91177308-0d34-0410-b5e6-96231b3b80d8 --- docs/tutorial/LangImpl3.html | 4 +- docs/tutorial/LangImpl4.html | 2 +- docs/tutorial/LangImpl5.html | 14 ++--- docs/tutorial/LangImpl6.html | 8 +-- docs/tutorial/LangImpl7.html | 12 ++-- examples/Kaleidoscope/toy.cpp | 10 ++-- include/llvm/Constants.h | 14 ++++- include/llvm/LLVMContext.h | 16 +---- include/llvm/Support/PatternMatch.h | 4 +- lib/Analysis/ConstantFolding.cpp | 12 ++-- lib/AsmParser/LLParser.cpp | 2 +- lib/Bitcode/Reader/BitcodeReader.cpp | 10 ++-- lib/CodeGen/SelectionDAG/SelectionDAG.cpp | 2 +- lib/CodeGen/SelectionDAG/SelectionDAGBuild.cpp | 6 +- lib/ExecutionEngine/JIT/JIT.cpp | 6 +- lib/Target/X86/X86ISelLowering.cpp | 36 ++++++------ lib/Transforms/Scalar/InstructionCombining.cpp | 4 +- lib/Transforms/Scalar/LoopStrengthReduce.cpp | 6 +- lib/Transforms/Scalar/SimplifyLibCalls.cpp | 6 +- lib/VMCore/ConstantFold.cpp | 16 ++--- lib/VMCore/Constants.cpp | 81 ++++++++++++++++++++++++++ lib/VMCore/Core.cpp | 4 +- lib/VMCore/Instructions.cpp | 8 +-- lib/VMCore/LLVMContext.cpp | 74 +++-------------------- lib/VMCore/LLVMContextImpl.cpp | 35 ----------- lib/VMCore/LLVMContextImpl.h | 3 +- 26 files changed, 188 insertions(+), 207 deletions(-) diff --git a/docs/tutorial/LangImpl3.html b/docs/tutorial/LangImpl3.html index 5031427a7b..c56b1edac6 100644 --- a/docs/tutorial/LangImpl3.html +++ b/docs/tutorial/LangImpl3.html @@ -159,7 +159,7 @@ we'll do numeric literals:

 Value *NumberExprAST::Codegen() {
-  return getGlobalContext().getConstantFP(APFloat(Val));
+  return ConstantFP::get(getGlobalContext(), APFloat(Val));
 }
@@ -1034,7 +1034,7 @@ static std::map<std::string, Value*> NamedValues; Value *ErrorV(const char *Str) { Error(Str); return 0; } Value *NumberExprAST::Codegen() { - return getGlobalContext().getConstantFP(APFloat(Val)); + return ConstantFP::get(getGlobalContext(), APFloat(Val)); } Value *VariableExprAST::Codegen() { diff --git a/docs/tutorial/LangImpl4.html b/docs/tutorial/LangImpl4.html index 41f3a2cd85..45002d29ea 100644 --- a/docs/tutorial/LangImpl4.html +++ b/docs/tutorial/LangImpl4.html @@ -869,7 +869,7 @@ static FunctionPassManager *TheFPM; Value *ErrorV(const char *Str) { Error(Str); return 0; } Value *NumberExprAST::Codegen() { - return getGlobalContext().getConstantFP(APFloat(Val)); + return ConstantFP::get(getGlobalContext(), APFloat(Val)); } Value *VariableExprAST::Codegen() { diff --git a/docs/tutorial/LangImpl5.html b/docs/tutorial/LangImpl5.html index a783c4abbd..62a0dd9739 100644 --- a/docs/tutorial/LangImpl5.html +++ b/docs/tutorial/LangImpl5.html @@ -364,7 +364,7 @@ Value *IfExprAST::Codegen() { // Convert condition to a bool by comparing equal to 0.0. CondV = Builder.CreateFCmpONE(CondV, - getGlobalContext().getConstantFP(APFloat(0.0)), + ConstantFP::get(getGlobalContext(), APFloat(0.0)), "ifcond"); @@ -796,7 +796,7 @@ references to it will naturally find it in the symbol table.

if (StepVal == 0) return 0; } else { // If not specified, use 1.0. - StepVal = getGlobalContext().getConstantFP(APFloat(1.0)); + StepVal = ConstantFP::get(getGlobalContext(), APFloat(1.0)); } Value *NextVar = Builder.CreateAdd(Variable, StepVal, "nextvar"); @@ -815,7 +815,7 @@ will be the value of the loop variable on the next iteration of the loop.

// Convert condition to a bool by comparing equal to 0.0. EndCond = Builder.CreateFCmpONE(EndCond, - getGlobalContext().getConstantFP(APFloat(0.0)), + ConstantFP::get(getGlobalContext(), APFloat(0.0)), "loopcond"); @@ -1360,7 +1360,7 @@ static FunctionPassManager *TheFPM; Value *ErrorV(const char *Str) { Error(Str); return 0; } Value *NumberExprAST::Codegen() { - return getGlobalContext().getConstantFP(APFloat(Val)); + return ConstantFP::get(getGlobalContext(), APFloat(Val)); } Value *VariableExprAST::Codegen() { @@ -1411,7 +1411,7 @@ Value *IfExprAST::Codegen() { // Convert condition to a bool by comparing equal to 0.0. CondV = Builder.CreateFCmpONE(CondV, - getGlobalContext().getConstantFP(APFloat(0.0)), + ConstantFP::get(getGlobalContext(), APFloat(0.0)), "ifcond"); Function *TheFunction = Builder.GetInsertBlock()->getParent(); @@ -1510,7 +1510,7 @@ Value *ForExprAST::Codegen() { if (StepVal == 0) return 0; } else { // If not specified, use 1.0. - StepVal = getGlobalContext().getConstantFP(APFloat(1.0)); + StepVal = ConstantFP::get(getGlobalContext(), APFloat(1.0)); } Value *NextVar = Builder.CreateAdd(Variable, StepVal, "nextvar"); @@ -1521,7 +1521,7 @@ Value *ForExprAST::Codegen() { // Convert condition to a bool by comparing equal to 0.0. EndCond = Builder.CreateFCmpONE(EndCond, - getGlobalContext().getConstantFP(APFloat(0.0)), + ConstantFP::get(getGlobalContext(), APFloat(0.0)), "loopcond"); // Create the "after loop" block and insert it. diff --git a/docs/tutorial/LangImpl6.html b/docs/tutorial/LangImpl6.html index 1933d71c06..5a553b7b8a 100644 --- a/docs/tutorial/LangImpl6.html +++ b/docs/tutorial/LangImpl6.html @@ -1365,7 +1365,7 @@ static FunctionPassManager *TheFPM; Value *ErrorV(const char *Str) { Error(Str); return 0; } Value *NumberExprAST::Codegen() { - return getGlobalContext().getConstantFP(APFloat(Val)); + return ConstantFP::get(getGlobalContext(), APFloat(Val)); } Value *VariableExprAST::Codegen() { @@ -1436,7 +1436,7 @@ Value *IfExprAST::Codegen() { // Convert condition to a bool by comparing equal to 0.0. CondV = Builder.CreateFCmpONE(CondV, - getGlobalContext().getConstantFP(APFloat(0.0)), + ConstantFP::get(getGlobalContext(), APFloat(0.0)), "ifcond"); Function *TheFunction = Builder.GetInsertBlock()->getParent(); @@ -1535,7 +1535,7 @@ Value *ForExprAST::Codegen() { if (StepVal == 0) return 0; } else { // If not specified, use 1.0. - StepVal = getGlobalContext().getConstantFP(APFloat(1.0)); + StepVal = ConstantFP::get(getGlobalContext(), APFloat(1.0)); } Value *NextVar = Builder.CreateAdd(Variable, StepVal, "nextvar"); @@ -1546,7 +1546,7 @@ Value *ForExprAST::Codegen() { // Convert condition to a bool by comparing equal to 0.0. EndCond = Builder.CreateFCmpONE(EndCond, - getGlobalContext().getConstantFP(APFloat(0.0)), + ConstantFP::get(getGlobalContext(), APFloat(0.0)), "loopcond"); // Create the "after loop" block and insert it. diff --git a/docs/tutorial/LangImpl7.html b/docs/tutorial/LangImpl7.html index 07c8da653c..d3ebd962c5 100644 --- a/docs/tutorial/LangImpl7.html +++ b/docs/tutorial/LangImpl7.html @@ -923,7 +923,7 @@ that we replace in OldBindings.

InitVal = Init->Codegen(); if (InitVal == 0) return 0; } else { // If not specified, use 0.0. - InitVal = getGlobalContext().getConstantFP(APFloat(0.0)); + InitVal = ConstantFP::get(getGlobalContext(), APFloat(0.0)); } AllocaInst *Alloca = CreateEntryBlockAlloca(TheFunction, VarName); @@ -1623,7 +1623,7 @@ static AllocaInst *CreateEntryBlockAlloca(Function *TheFunction, Value *NumberExprAST::Codegen() { - return getGlobalContext().getConstantFP(APFloat(Val)); + return ConstantFP::get(getGlobalContext(), APFloat(Val)); } Value *VariableExprAST::Codegen() { @@ -1716,7 +1716,7 @@ Value *IfExprAST::Codegen() { // Convert condition to a bool by comparing equal to 0.0. CondV = Builder.CreateFCmpONE(CondV, - getGlobalContext().getConstantFP(APFloat(0.0)), + ConstantFP::get(getGlobalContext(), APFloat(0.0)), "ifcond"); Function *TheFunction = Builder.GetInsertBlock()->getParent(); @@ -1822,7 +1822,7 @@ Value *ForExprAST::Codegen() { if (StepVal == 0) return 0; } else { // If not specified, use 1.0. - StepVal = getGlobalContext().getConstantFP(APFloat(1.0)); + StepVal = ConstantFP::get(getGlobalContext(), APFloat(1.0)); } // Compute the end condition. @@ -1837,7 +1837,7 @@ Value *ForExprAST::Codegen() { // Convert condition to a bool by comparing equal to 0.0. EndCond = Builder.CreateFCmpONE(EndCond, - getGlobalContext().getConstantFP(APFloat(0.0)), + ConstantFP::get(getGlobalContext(), APFloat(0.0)), "loopcond"); // Create the "after loop" block and insert it. @@ -1881,7 +1881,7 @@ Value *VarExprAST::Codegen() { InitVal = Init->Codegen(); if (InitVal == 0) return 0; } else { // If not specified, use 0.0. - InitVal = getGlobalContext().getConstantFP(APFloat(0.0)); + InitVal = ConstantFP::get(getGlobalContext(), APFloat(0.0)); } AllocaInst *Alloca = CreateEntryBlockAlloca(TheFunction, VarName); diff --git a/examples/Kaleidoscope/toy.cpp b/examples/Kaleidoscope/toy.cpp index 1aa9965fa4..6f7f0ee206 100644 --- a/examples/Kaleidoscope/toy.cpp +++ b/examples/Kaleidoscope/toy.cpp @@ -623,7 +623,7 @@ static AllocaInst *CreateEntryBlockAlloca(Function *TheFunction, Value *NumberExprAST::Codegen() { - return getGlobalContext().getConstantFP(APFloat(Val)); + return ConstantFP::get(getGlobalContext(), APFloat(Val)); } Value *VariableExprAST::Codegen() { @@ -716,7 +716,7 @@ Value *IfExprAST::Codegen() { // Convert condition to a bool by comparing equal to 0.0. CondV = Builder.CreateFCmpONE(CondV, - getGlobalContext().getConstantFP(APFloat(0.0)), + ConstantFP::get(getGlobalContext(), APFloat(0.0)), "ifcond"); Function *TheFunction = Builder.GetInsertBlock()->getParent(); @@ -821,7 +821,7 @@ Value *ForExprAST::Codegen() { if (StepVal == 0) return 0; } else { // If not specified, use 1.0. - StepVal = getGlobalContext().getConstantFP(APFloat(1.0)); + StepVal = ConstantFP::get(getGlobalContext(), APFloat(1.0)); } // Compute the end condition. @@ -836,7 +836,7 @@ Value *ForExprAST::Codegen() { // Convert condition to a bool by comparing equal to 0.0. EndCond = Builder.CreateFCmpONE(EndCond, - getGlobalContext().getConstantFP(APFloat(0.0)), + ConstantFP::get(getGlobalContext(), APFloat(0.0)), "loopcond"); // Create the "after loop" block and insert it. @@ -879,7 +879,7 @@ Value *VarExprAST::Codegen() { InitVal = Init->Codegen(); if (InitVal == 0) return 0; } else { // If not specified, use 0.0. - InitVal = getGlobalContext().getConstantFP(APFloat(0.0)); + InitVal = ConstantFP::get(getGlobalContext(), APFloat(0.0)); } AllocaInst *Alloca = CreateEntryBlockAlloca(TheFunction, VarName); diff --git a/include/llvm/Constants.h b/include/llvm/Constants.h index d59621a453..f7b785aff3 100644 --- a/include/llvm/Constants.h +++ b/include/llvm/Constants.h @@ -50,7 +50,6 @@ class ConstantInt : public Constant { ConstantInt(const ConstantInt &); // DO NOT IMPLEMENT ConstantInt(const IntegerType *Ty, const APInt& V); APInt Val; - friend class LLVMContextImpl; protected: // allocate space for exactly zero operands void *operator new(size_t s) { @@ -238,6 +237,19 @@ protected: return User::operator new(s, 0); } public: + /// Floating point negation must be implemented with f(x) = -0.0 - x. This + /// method returns the negative zero constant for floating point or vector + /// floating point types; for all other types, it returns the null value. + static Constant* getZeroValueForNegation(const Type* Ty); + + /// 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); + static ConstantFP* get(LLVMContext &Context, const APFloat& V); + static ConstantFP* getNegativeZero(const Type* Ty); + /// 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 ab81595722..37f0cd1a44 100644 --- a/include/llvm/LLVMContext.h +++ b/include/llvm/LLVMContext.h @@ -56,6 +56,7 @@ class LLVMContext { LLVMContextImpl* pImpl; friend class ConstantInt; + friend class ConstantFP; public: LLVMContext(); ~LLVMContext(); @@ -180,21 +181,6 @@ public: /// Constant* getConstantExprSizeOf(const Type* Ty); - /// Floating point negation must be implemented with f(x) = -0.0 - x. This - /// method returns the negative zero constant for floating point or vector - /// floating point types; for all other types, it returns the null value. - Constant* getZeroValueForNegation(const Type* Ty); - - // 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); - // ConstantVector accessors Constant* getConstantVector(const VectorType* T, const std::vector& V); diff --git a/include/llvm/Support/PatternMatch.h b/include/llvm/Support/PatternMatch.h index fb8e387d3d..7a93b7665f 100644 --- a/include/llvm/Support/PatternMatch.h +++ b/include/llvm/Support/PatternMatch.h @@ -506,7 +506,7 @@ struct neg_match { } private: bool matchIfNeg(Value *LHS, Value *RHS, LLVMContext &Context) { - return LHS == Context.getZeroValueForNegation(LHS->getType()) && + return LHS == ConstantFP::getZeroValueForNegation(LHS->getType()) && L.match(RHS, Context); } }; @@ -535,7 +535,7 @@ struct fneg_match { } private: bool matchIfFNeg(Value *LHS, Value *RHS, LLVMContext &Context) { - return LHS == Context.getZeroValueForNegation(LHS->getType()) && + return LHS == ConstantFP::getZeroValueForNegation(LHS->getType()) && L.match(RHS, Context); } }; diff --git a/lib/Analysis/ConstantFolding.cpp b/lib/Analysis/ConstantFolding.cpp index 173326e2bb..31d4f8230b 100644 --- a/lib/Analysis/ConstantFolding.cpp +++ b/lib/Analysis/ConstantFolding.cpp @@ -655,9 +655,9 @@ static Constant *ConstantFoldFP(double (*NativeFP)(double), double V, } if (Ty == Type::FloatTy) - return Context.getConstantFP(APFloat((float)V)); + return ConstantFP::get(Context, APFloat((float)V)); if (Ty == Type::DoubleTy) - return Context.getConstantFP(APFloat(V)); + return ConstantFP::get(Context, APFloat(V)); llvm_unreachable("Can only constant fold float/double"); return 0; // dummy return to suppress warning } @@ -674,9 +674,9 @@ static Constant *ConstantFoldBinaryFP(double (*NativeFP)(double, double), } if (Ty == Type::FloatTy) - return Context.getConstantFP(APFloat((float)V)); + return ConstantFP::get(Context, APFloat((float)V)); if (Ty == Type::DoubleTy) - return Context.getConstantFP(APFloat(V)); + return ConstantFP::get(Context, APFloat(V)); llvm_unreachable("Can only constant fold float/double"); return 0; // dummy return to suppress warning } @@ -796,10 +796,10 @@ llvm::ConstantFoldCall(Function *F, } } else if (ConstantInt *Op2C = dyn_cast(Operands[1])) { if (Name == "llvm.powi.f32") { - return Context.getConstantFP(APFloat((float)std::pow((float)Op1V, + return ConstantFP::get(Context, APFloat((float)std::pow((float)Op1V, (int)Op2C->getZExtValue()))); } else if (Name == "llvm.powi.f64") { - return Context.getConstantFP(APFloat((double)std::pow((double)Op1V, + return ConstantFP::get(Context, APFloat((double)std::pow((double)Op1V, (int)Op2C->getZExtValue()))); } } diff --git a/lib/AsmParser/LLParser.cpp b/lib/AsmParser/LLParser.cpp index c6f1b257bd..f9db40915a 100644 --- a/lib/AsmParser/LLParser.cpp +++ b/lib/AsmParser/LLParser.cpp @@ -2143,7 +2143,7 @@ bool LLParser::ConvertGlobalValIDToValue(const Type *Ty, ValID &ID, ID.APFloatVal.convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven, &Ignored); } - V = Context.getConstantFP(ID.APFloatVal); + V = ConstantFP::get(Context, ID.APFloatVal); if (V->getType() != Ty) return Error(ID.Loc, "floating point constant does not have type '" + diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp index 0c6162ccff..687cae9ecf 100644 --- a/lib/Bitcode/Reader/BitcodeReader.cpp +++ b/lib/Bitcode/Reader/BitcodeReader.cpp @@ -896,19 +896,19 @@ bool BitcodeReader::ParseConstants() { if (Record.empty()) return Error("Invalid FLOAT record"); if (CurTy == Type::FloatTy) - V = Context.getConstantFP(APFloat(APInt(32, (uint32_t)Record[0]))); + V = ConstantFP::get(Context, APFloat(APInt(32, (uint32_t)Record[0]))); else if (CurTy == Type::DoubleTy) - V = Context.getConstantFP(APFloat(APInt(64, Record[0]))); + V = ConstantFP::get(Context, APFloat(APInt(64, Record[0]))); else if (CurTy == Type::X86_FP80Ty) { // Bits are not stored the same way as a normal i80 APInt, compensate. uint64_t Rearrange[2]; Rearrange[0] = (Record[1] & 0xffffLL) | (Record[0] << 16); Rearrange[1] = Record[0] >> 48; - V = Context.getConstantFP(APFloat(APInt(80, 2, Rearrange))); + V = ConstantFP::get(Context, APFloat(APInt(80, 2, Rearrange))); } else if (CurTy == Type::FP128Ty) - V = Context.getConstantFP(APFloat(APInt(128, 2, &Record[0]), true)); + V = ConstantFP::get(Context, APFloat(APInt(128, 2, &Record[0]), true)); else if (CurTy == Type::PPC_FP128Ty) - V = Context.getConstantFP(APFloat(APInt(128, 2, &Record[0]))); + V = ConstantFP::get(Context, APFloat(APInt(128, 2, &Record[0]))); else V = Context.getUndef(CurTy); break; diff --git a/lib/CodeGen/SelectionDAG/SelectionDAG.cpp b/lib/CodeGen/SelectionDAG/SelectionDAG.cpp index 5a46288e58..a8398243c7 100644 --- a/lib/CodeGen/SelectionDAG/SelectionDAG.cpp +++ b/lib/CodeGen/SelectionDAG/SelectionDAG.cpp @@ -916,7 +916,7 @@ SDValue SelectionDAG::getIntPtrConstant(uint64_t Val, bool isTarget) { SDValue SelectionDAG::getConstantFP(const APFloat& V, MVT VT, bool isTarget) { - return getConstantFP(*Context->getConstantFP(V), VT, isTarget); + return getConstantFP(*ConstantFP::get(*getContext(), V), VT, isTarget); } SDValue SelectionDAG::getConstantFP(const ConstantFP& V, MVT VT, bool isTarget){ diff --git a/lib/CodeGen/SelectionDAG/SelectionDAGBuild.cpp b/lib/CodeGen/SelectionDAG/SelectionDAGBuild.cpp index 8685c85b58..3a8b782564 100644 --- a/lib/CodeGen/SelectionDAG/SelectionDAGBuild.cpp +++ b/lib/CodeGen/SelectionDAG/SelectionDAGBuild.cpp @@ -2148,8 +2148,7 @@ void SelectionDAGLowering::visitFSub(User &I) { const VectorType *DestTy = cast(I.getType()); const Type *ElTy = DestTy->getElementType(); unsigned VL = DestTy->getNumElements(); - std::vector NZ(VL, - DAG.getContext()->getConstantFPNegativeZero(ElTy)); + std::vector NZ(VL, ConstantFP::getNegativeZero(ElTy)); Constant *CNZ = DAG.getContext()->getConstantVector(&NZ[0], NZ.size()); if (CV == CNZ) { SDValue Op2 = getValue(I.getOperand(1)); @@ -2160,8 +2159,7 @@ void SelectionDAGLowering::visitFSub(User &I) { } } if (ConstantFP *CFP = dyn_cast(I.getOperand(0))) - if (CFP->isExactlyValue( - DAG.getContext()->getConstantFPNegativeZero(Ty)->getValueAPF())) { + if (CFP->isExactlyValue(ConstantFP::getNegativeZero(Ty)->getValueAPF())) { SDValue Op2 = getValue(I.getOperand(1)); setValue(&I, DAG.getNode(ISD::FNEG, getCurDebugLoc(), Op2.getValueType(), Op2)); diff --git a/lib/ExecutionEngine/JIT/JIT.cpp b/lib/ExecutionEngine/JIT/JIT.cpp index a9b062d85e..444ef3c3ce 100644 --- a/lib/ExecutionEngine/JIT/JIT.cpp +++ b/lib/ExecutionEngine/JIT/JIT.cpp @@ -490,15 +490,15 @@ GenericValue JIT::runFunction(Function *F, C = ConstantInt::get(F->getContext(), AV.IntVal); break; case Type::FloatTyID: - C = Context.getConstantFP(APFloat(AV.FloatVal)); + C = ConstantFP::get(F->getContext(), APFloat(AV.FloatVal)); break; case Type::DoubleTyID: - C = Context.getConstantFP(APFloat(AV.DoubleVal)); + C = ConstantFP::get(F->getContext(), APFloat(AV.DoubleVal)); break; case Type::PPC_FP128TyID: case Type::X86_FP80TyID: case Type::FP128TyID: - C = Context.getConstantFP(APFloat(AV.IntVal)); + C = ConstantFP::get(F->getContext(), APFloat(AV.IntVal)); break; case Type::PointerTyID: void *ArgPtr = GVTOP(AV); diff --git a/lib/Target/X86/X86ISelLowering.cpp b/lib/Target/X86/X86ISelLowering.cpp index 15c6dfead4..42bd7dc983 100644 --- a/lib/Target/X86/X86ISelLowering.cpp +++ b/lib/Target/X86/X86ISelLowering.cpp @@ -4898,9 +4898,9 @@ SDValue X86TargetLowering::LowerUINT_TO_FP_i64(SDValue Op, SelectionDAG &DAG) { std::vector CV1; CV1.push_back( - Context->getConstantFP(APFloat(APInt(64, 0x4530000000000000ULL)))); + ConstantFP::get(*Context, APFloat(APInt(64, 0x4530000000000000ULL)))); CV1.push_back( - Context->getConstantFP(APFloat(APInt(64, 0x4330000000000000ULL)))); + ConstantFP::get(*Context, APFloat(APInt(64, 0x4330000000000000ULL)))); Constant *C1 = Context->getConstantVector(CV1); SDValue CPIdx1 = DAG.getConstantPool(C1, getPointerTy(), 16); @@ -5113,11 +5113,11 @@ SDValue X86TargetLowering::LowerFABS(SDValue Op, SelectionDAG &DAG) { EltVT = VT.getVectorElementType(); std::vector CV; if (EltVT == MVT::f64) { - Constant *C = Context->getConstantFP(APFloat(APInt(64, ~(1ULL << 63)))); + Constant *C = ConstantFP::get(*Context, APFloat(APInt(64, ~(1ULL << 63)))); CV.push_back(C); CV.push_back(C); } else { - Constant *C = Context->getConstantFP(APFloat(APInt(32, ~(1U << 31)))); + Constant *C = ConstantFP::get(*Context, APFloat(APInt(32, ~(1U << 31)))); CV.push_back(C); CV.push_back(C); CV.push_back(C); @@ -5143,11 +5143,11 @@ SDValue X86TargetLowering::LowerFNEG(SDValue Op, SelectionDAG &DAG) { } std::vector CV; if (EltVT == MVT::f64) { - Constant *C = Context->getConstantFP(APFloat(APInt(64, 1ULL << 63))); + Constant *C = ConstantFP::get(*Context, APFloat(APInt(64, 1ULL << 63))); CV.push_back(C); CV.push_back(C); } else { - Constant *C = Context->getConstantFP(APFloat(APInt(32, 1U << 31))); + Constant *C = ConstantFP::get(*Context, APFloat(APInt(32, 1U << 31))); CV.push_back(C); CV.push_back(C); CV.push_back(C); @@ -5194,13 +5194,13 @@ SDValue X86TargetLowering::LowerFCOPYSIGN(SDValue Op, SelectionDAG &DAG) { // First get the sign bit of second operand. std::vector CV; if (SrcVT == MVT::f64) { - CV.push_back(Context->getConstantFP(APFloat(APInt(64, 1ULL << 63)))); - CV.push_back(Context->getConstantFP(APFloat(APInt(64, 0)))); + CV.push_back(ConstantFP::get(*Context, APFloat(APInt(64, 1ULL << 63)))); + CV.push_back(ConstantFP::get(*Context, APFloat(APInt(64, 0)))); } else { - CV.push_back(Context->getConstantFP(APFloat(APInt(32, 1U << 31)))); - CV.push_back(Context->getConstantFP(APFloat(APInt(32, 0)))); - CV.push_back(Context->getConstantFP(APFloat(APInt(32, 0)))); - CV.push_back(Context->getConstantFP(APFloat(APInt(32, 0)))); + CV.push_back(ConstantFP::get(*Context, APFloat(APInt(32, 1U << 31)))); + CV.push_back(ConstantFP::get(*Context, APFloat(APInt(32, 0)))); + CV.push_back(ConstantFP::get(*Context, APFloat(APInt(32, 0)))); + CV.push_back(ConstantFP::get(*Context, APFloat(APInt(32, 0)))); } Constant *C = Context->getConstantVector(CV); SDValue CPIdx = DAG.getConstantPool(C, getPointerTy(), 16); @@ -5223,13 +5223,13 @@ SDValue X86TargetLowering::LowerFCOPYSIGN(SDValue Op, SelectionDAG &DAG) { // Clear first operand sign bit. CV.clear(); if (VT == MVT::f64) { - CV.push_back(Context->getConstantFP(APFloat(APInt(64, ~(1ULL << 63))))); - CV.push_back(Context->getConstantFP(APFloat(APInt(64, 0)))); + CV.push_back(ConstantFP::get(*Context, APFloat(APInt(64, ~(1ULL << 63))))); + CV.push_back(ConstantFP::get(*Context, APFloat(APInt(64, 0)))); } else { - CV.push_back(Context->getConstantFP(APFloat(APInt(32, ~(1U << 31))))); - CV.push_back(Context->getConstantFP(APFloat(APInt(32, 0)))); - CV.push_back(Context->getConstantFP(APFloat(APInt(32, 0)))); - CV.push_back(Context->getConstantFP(APFloat(APInt(32, 0)))); + CV.push_back(ConstantFP::get(*Context, APFloat(APInt(32, ~(1U << 31))))); + CV.push_back(ConstantFP::get(*Context, APFloat(APInt(32, 0)))); + CV.push_back(ConstantFP::get(*Context, APFloat(APInt(32, 0)))); + CV.push_back(ConstantFP::get(*Context, APFloat(APInt(32, 0)))); } C = Context->getConstantVector(CV); CPIdx = DAG.getConstantPool(C, getPointerTy(), 16); diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp index 15daf3efb4..a6538dcaa2 100644 --- a/lib/Transforms/Scalar/InstructionCombining.cpp +++ b/lib/Transforms/Scalar/InstructionCombining.cpp @@ -2354,7 +2354,7 @@ Instruction *InstCombiner::visitFAdd(BinaryOperator &I) { if (Constant *RHSC = dyn_cast(RHS)) { // X + 0 --> X if (ConstantFP *CFP = dyn_cast(RHSC)) { - if (CFP->isExactlyValue(Context->getConstantFPNegativeZero + if (CFP->isExactlyValue(ConstantFP::getNegativeZero (I.getType())->getValueAPF())) return ReplaceInstUsesWith(I, LHS); } @@ -8779,7 +8779,7 @@ static Constant *FitsInFPType(ConstantFP *CFP, const fltSemantics &Sem, APFloat F = CFP->getValueAPF(); (void)F.convert(Sem, APFloat::rmNearestTiesToEven, &losesInfo); if (!losesInfo) - return Context->getConstantFP(F); + return ConstantFP::get(*Context, F); return 0; } diff --git a/lib/Transforms/Scalar/LoopStrengthReduce.cpp b/lib/Transforms/Scalar/LoopStrengthReduce.cpp index 82ca81acc4..9829c8d7df 100644 --- a/lib/Transforms/Scalar/LoopStrengthReduce.cpp +++ b/lib/Transforms/Scalar/LoopStrengthReduce.cpp @@ -2177,8 +2177,6 @@ void LoopStrengthReduce::OptimizeShadowIV(Loop *L) { if (isa(BackedgeTakenCount)) return; - LLVMContext &Context = L->getHeader()->getContext(); - for (unsigned Stride = 0, e = IU->StrideOrder.size(); Stride != e; ++Stride) { std::map::iterator SI = @@ -2240,7 +2238,7 @@ void LoopStrengthReduce::OptimizeShadowIV(Loop *L) { ConstantInt *Init = dyn_cast(PH->getIncomingValue(Entry)); if (!Init) continue; - Constant *NewInit = Context.getConstantFP(DestTy, Init->getZExtValue()); + Constant *NewInit = ConstantFP::get(DestTy, Init->getZExtValue()); BinaryOperator *Incr = dyn_cast(PH->getIncomingValue(Latch)); @@ -2264,7 +2262,7 @@ void LoopStrengthReduce::OptimizeShadowIV(Loop *L) { PHINode *NewPH = PHINode::Create(DestTy, "IV.S.", PH); /* create new increment. '++d' in above example. */ - Constant *CFP = Context.getConstantFP(DestTy, C->getZExtValue()); + Constant *CFP = ConstantFP::get(DestTy, C->getZExtValue()); BinaryOperator *NewIncr = BinaryOperator::Create(Incr->getOpcode() == Instruction::Add ? Instruction::FAdd : Instruction::FSub, diff --git a/lib/Transforms/Scalar/SimplifyLibCalls.cpp b/lib/Transforms/Scalar/SimplifyLibCalls.cpp index e48b14c2cd..0bf583a52a 100644 --- a/lib/Transforms/Scalar/SimplifyLibCalls.cpp +++ b/lib/Transforms/Scalar/SimplifyLibCalls.cpp @@ -1035,7 +1035,7 @@ struct VISIBILITY_HIDDEN PowOpt : public LibCallOptimization { if (Op2C == 0) return 0; if (Op2C->getValueAPF().isZero()) // pow(x, 0.0) -> 1.0 - return Context->getConstantFP(CI->getType(), 1.0); + return ConstantFP::get(CI->getType(), 1.0); if (Op2C->isExactlyValue(0.5)) { // FIXME: This is not safe for -0.0 and -inf. This can only be done when @@ -1055,7 +1055,7 @@ struct VISIBILITY_HIDDEN PowOpt : public LibCallOptimization { if (Op2C->isExactlyValue(2.0)) // pow(x, 2.0) -> x*x return B.CreateFMul(Op1, Op1, "pow2"); if (Op2C->isExactlyValue(-1.0)) // pow(x, -1.0) -> 1.0/x - return B.CreateFDiv(Context->getConstantFP(CI->getType(), 1.0), + return B.CreateFDiv(ConstantFP::get(CI->getType(), 1.0), Op1, "powrecip"); return 0; } @@ -1094,7 +1094,7 @@ struct VISIBILITY_HIDDEN Exp2Opt : public LibCallOptimization { else Name = "ldexpl"; - Constant *One = Context->getConstantFP(APFloat(1.0f)); + Constant *One = ConstantFP::get(*Context, APFloat(1.0f)); if (Op->getType() != Type::FloatTy) One = Context->getConstantExprFPExtend(One, Op->getType()); diff --git a/lib/VMCore/ConstantFold.cpp b/lib/VMCore/ConstantFold.cpp index a26bee8f95..6546dc70d8 100644 --- a/lib/VMCore/ConstantFold.cpp +++ b/lib/VMCore/ConstantFold.cpp @@ -161,7 +161,7 @@ static Constant *FoldBitCast(LLVMContext &Context, return V; if (DestTy->isFloatingPoint()) - return Context.getConstantFP(APFloat(CI->getValue(), + return ConstantFP::get(Context, APFloat(CI->getValue(), DestTy != Type::PPC_FP128Ty)); // Otherwise, can't fold this (vector?) @@ -245,7 +245,7 @@ Constant *llvm::ConstantFoldCastInstruction(LLVMContext &Context, DestTy == Type::FP128Ty ? APFloat::IEEEquad : APFloat::Bogus, APFloat::rmNearestTiesToEven, &ignored); - return Context.getConstantFP(Val); + return ConstantFP::get(Context, Val); } return 0; // Can't fold. case Instruction::FPToUI: @@ -279,7 +279,7 @@ Constant *llvm::ConstantFoldCastInstruction(LLVMContext &Context, (void)apf.convertFromAPInt(api, opc==Instruction::SIToFP, APFloat::rmNearestTiesToEven); - return Context.getConstantFP(apf); + return ConstantFP::get(Context, apf); } return 0; case Instruction::ZExt: @@ -795,19 +795,19 @@ Constant *llvm::ConstantFoldBinaryInstruction(LLVMContext &Context, break; case Instruction::FAdd: (void)C3V.add(C2V, APFloat::rmNearestTiesToEven); - return Context.getConstantFP(C3V); + return ConstantFP::get(Context, C3V); case Instruction::FSub: (void)C3V.subtract(C2V, APFloat::rmNearestTiesToEven); - return Context.getConstantFP(C3V); + return ConstantFP::get(Context, C3V); case Instruction::FMul: (void)C3V.multiply(C2V, APFloat::rmNearestTiesToEven); - return Context.getConstantFP(C3V); + return ConstantFP::get(Context, C3V); case Instruction::FDiv: (void)C3V.divide(C2V, APFloat::rmNearestTiesToEven); - return Context.getConstantFP(C3V); + return ConstantFP::get(Context, C3V); case Instruction::FRem: (void)C3V.mod(C2V, APFloat::rmNearestTiesToEven); - return Context.getConstantFP(C3V); + return ConstantFP::get(Context, C3V); } } } else if (const VectorType *VTy = dyn_cast(C1->getType())) { diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp index 96f729a7e6..873a0f1dc2 100644 --- a/lib/VMCore/Constants.cpp +++ b/lib/VMCore/Constants.cpp @@ -258,6 +258,87 @@ static const fltSemantics *TypeToFloatSemantics(const Type *Ty) { } #endif +/// 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) { + LLVMContext &Context = Ty->getContext(); + + APFloat FV(V); + bool ignored; + FV.convert(*TypeToFloatSemantics(Ty->getScalarType()), + APFloat::rmNearestTiesToEven, &ignored); + Constant *C = get(Context, FV); + + // For vectors, broadcast the value. + if (const VectorType *VTy = dyn_cast(Ty)) + return Context.getConstantVector( + std::vector(VTy->getNumElements(), C)); + + return C; +} + +ConstantFP* ConstantFP::getNegativeZero(const Type* Ty) { + LLVMContext &Context = Ty->getContext(); + APFloat apf = cast (Context.getNullValue(Ty))->getValueAPF(); + apf.changeSign(); + return get(Context, apf); +} + + +Constant* ConstantFP::getZeroValueForNegation(const Type* Ty) { + LLVMContext &Context = Ty->getContext(); + if (const VectorType *PTy = dyn_cast(Ty)) + if (PTy->getElementType()->isFloatingPoint()) { + std::vector zeros(PTy->getNumElements(), + getNegativeZero(PTy->getElementType())); + return Context.getConstantVector(PTy, zeros); + } + + if (Ty->isFloatingPoint()) + return getNegativeZero(Ty); + + return Context.getNullValue(Ty); +} + + +// ConstantFP accessors. +ConstantFP* ConstantFP::get(LLVMContext &Context, const APFloat& V) { + DenseMapAPFloatKeyInfo::KeyTy Key(V); + + LLVMContextImpl* pImpl = Context.pImpl; + + pImpl->ConstantsLock.reader_acquire(); + ConstantFP *&Slot = pImpl->FPConstants[Key]; + pImpl->ConstantsLock.reader_release(); + + if (!Slot) { + sys::SmartScopedWriter Writer(pImpl->ConstantsLock); + ConstantFP *&NewSlot = pImpl->FPConstants[Key]; + if (!NewSlot) { + const Type *Ty; + if (&V.getSemantics() == &APFloat::IEEEsingle) + Ty = Type::FloatTy; + else if (&V.getSemantics() == &APFloat::IEEEdouble) + Ty = Type::DoubleTy; + else if (&V.getSemantics() == &APFloat::x87DoubleExtended) + Ty = Type::X86_FP80Ty; + else if (&V.getSemantics() == &APFloat::IEEEquad) + Ty = Type::FP128Ty; + else { + assert(&V.getSemantics() == &APFloat::PPCDoubleDouble && + "Unknown FP format"); + Ty = Type::PPC_FP128Ty; + } + NewSlot = new ConstantFP(Ty, V); + } + + return NewSlot; + } + + return Slot; +} + ConstantFP::ConstantFP(const Type *Ty, const APFloat& V) : Constant(Ty, ConstantFPVal, 0, 0), Val(V) { assert(&V.getSemantics() == TypeToFloatSemantics(Ty) && diff --git a/lib/VMCore/Core.cpp b/lib/VMCore/Core.cpp index 15d9f7a525..90f08c8e48 100644 --- a/lib/VMCore/Core.cpp +++ b/lib/VMCore/Core.cpp @@ -388,11 +388,11 @@ LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N) { bool ignored; APN.convert(SemanticsForType(unwrap(RealTy)), APFloat::rmNearestTiesToEven, &ignored); - return wrap(getGlobalContext().getConstantFP(APN)); + return wrap(ConstantFP::get(getGlobalContext(), APN)); } LLVMValueRef LLVMConstRealOfString(LLVMTypeRef RealTy, const char *Text) { - return wrap(getGlobalContext().getConstantFP( + return wrap(ConstantFP::get(getGlobalContext(), APFloat(SemanticsForType(unwrap(RealTy)), Text))); } diff --git a/lib/VMCore/Instructions.cpp b/lib/VMCore/Instructions.cpp index 20de3fecf8..a90bb4afcb 100644 --- a/lib/VMCore/Instructions.cpp +++ b/lib/VMCore/Instructions.cpp @@ -1577,7 +1577,7 @@ BinaryOperator *BinaryOperator::Create(BinaryOps Op, Value *S1, Value *S2, BinaryOperator *BinaryOperator::CreateNeg(LLVMContext &Context, Value *Op, const Twine &Name, Instruction *InsertBefore) { - Value *zero = Context.getZeroValueForNegation(Op->getType()); + Value *zero = ConstantFP::getZeroValueForNegation(Op->getType()); return new BinaryOperator(Instruction::Sub, zero, Op, Op->getType(), Name, InsertBefore); @@ -1586,7 +1586,7 @@ BinaryOperator *BinaryOperator::CreateNeg(LLVMContext &Context, BinaryOperator *BinaryOperator::CreateNeg(LLVMContext &Context, Value *Op, const Twine &Name, BasicBlock *InsertAtEnd) { - Value *zero = Context.getZeroValueForNegation(Op->getType()); + Value *zero = ConstantFP::getZeroValueForNegation(Op->getType()); return new BinaryOperator(Instruction::Sub, zero, Op, Op->getType(), Name, InsertAtEnd); @@ -1595,7 +1595,7 @@ BinaryOperator *BinaryOperator::CreateNeg(LLVMContext &Context, BinaryOperator *BinaryOperator::CreateFNeg(LLVMContext &Context, Value *Op, const Twine &Name, Instruction *InsertBefore) { - Value *zero = Context.getZeroValueForNegation(Op->getType()); + Value *zero = ConstantFP::getZeroValueForNegation(Op->getType()); return new BinaryOperator(Instruction::FSub, zero, Op, Op->getType(), Name, InsertBefore); @@ -1604,7 +1604,7 @@ BinaryOperator *BinaryOperator::CreateFNeg(LLVMContext &Context, BinaryOperator *BinaryOperator::CreateFNeg(LLVMContext &Context, Value *Op, const Twine &Name, BasicBlock *InsertAtEnd) { - Value *zero = Context.getZeroValueForNegation(Op->getType()); + Value *zero = ConstantFP::getZeroValueForNegation(Op->getType()); return new BinaryOperator(Instruction::FSub, zero, Op, Op->getType(), Name, InsertAtEnd); diff --git a/lib/VMCore/LLVMContext.cpp b/lib/VMCore/LLVMContext.cpp index 3ee029d4c3..d7f4594e3a 100644 --- a/lib/VMCore/LLVMContext.cpp +++ b/lib/VMCore/LLVMContext.cpp @@ -41,15 +41,16 @@ Constant* LLVMContext::getNullValue(const Type* Ty) { case Type::IntegerTyID: return ConstantInt::get(Ty, 0); case Type::FloatTyID: - return getConstantFP(APFloat(APInt(32, 0))); + return ConstantFP::get(Ty->getContext(), APFloat(APInt(32, 0))); case Type::DoubleTyID: - return getConstantFP(APFloat(APInt(64, 0))); + return ConstantFP::get(Ty->getContext(), APFloat(APInt(64, 0))); case Type::X86_FP80TyID: - return getConstantFP(APFloat(APInt(80, 2, zero))); + return ConstantFP::get(Ty->getContext(), APFloat(APInt(80, 2, zero))); case Type::FP128TyID: - return getConstantFP(APFloat(APInt(128, 2, zero), true)); + return ConstantFP::get(Ty->getContext(), + APFloat(APInt(128, 2, zero), true)); case Type::PPC_FP128TyID: - return getConstantFP(APFloat(APInt(128, 2, zero))); + return ConstantFP::get(Ty->getContext(), APFloat(APInt(128, 2, zero))); case Type::PointerTyID: return getConstantPointerNull(cast(Ty)); case Type::StructTyID: @@ -276,7 +277,7 @@ Constant* LLVMContext::getConstantExprNeg(Constant* C) { assert(C->getType()->isIntOrIntVector() && "Cannot NEG a nonintegral value!"); return getConstantExpr(Instruction::Sub, - getZeroValueForNegation(C->getType()), + ConstantFP::getZeroValueForNegation(C->getType()), C); } @@ -284,7 +285,7 @@ Constant* LLVMContext::getConstantExprFNeg(Constant* C) { assert(C->getType()->isFPOrFPVector() && "Cannot FNEG a non-floating-point value!"); return getConstantExpr(Instruction::FSub, - getZeroValueForNegation(C->getType()), + ConstantFP::getZeroValueForNegation(C->getType()), C); } @@ -424,65 +425,6 @@ Constant* LLVMContext::getConstantExprSizeOf(const Type* Ty) { return getConstantExprCast(Instruction::PtrToInt, GEP, Type::Int64Ty); } -Constant* LLVMContext::getZeroValueForNegation(const Type* Ty) { - if (const VectorType *PTy = dyn_cast(Ty)) - if (PTy->getElementType()->isFloatingPoint()) { - std::vector zeros(PTy->getNumElements(), - getConstantFPNegativeZero(PTy->getElementType())); - return getConstantVector(PTy, zeros); - } - - if (Ty->isFloatingPoint()) - return getConstantFPNegativeZero(Ty); - - return getNullValue(Ty); -} - - -// ConstantFP accessors. -ConstantFP* LLVMContext::getConstantFP(const APFloat& V) { - return pImpl->getConstantFP(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) { - 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(Ty)) - return - getConstantVector(std::vector(VTy->getNumElements(), C)); - - return C; -} - -ConstantFP* LLVMContext::getConstantFPNegativeZero(const Type* Ty) { - APFloat apf = cast (getNullValue(Ty))->getValueAPF(); - apf.changeSign(); - return getConstantFP(apf); -} - - // ConstantVector accessors. Constant* LLVMContext::getConstantVector(const VectorType* T, const std::vector& V) { diff --git a/lib/VMCore/LLVMContextImpl.cpp b/lib/VMCore/LLVMContextImpl.cpp index edd76fc031..5315e23f8e 100644 --- a/lib/VMCore/LLVMContextImpl.cpp +++ b/lib/VMCore/LLVMContextImpl.cpp @@ -49,41 +49,6 @@ static std::vector getValType(ConstantVector *CP) { LLVMContextImpl::LLVMContextImpl(LLVMContext &C) : Context(C), TheTrueVal(0), TheFalseVal(0) { } - -ConstantFP *LLVMContextImpl::getConstantFP(const APFloat &V) { - DenseMapAPFloatKeyInfo::KeyTy Key(V); - - ConstantsLock.reader_acquire(); - ConstantFP *&Slot = FPConstants[Key]; - ConstantsLock.reader_release(); - - if (!Slot) { - sys::SmartScopedWriter Writer(ConstantsLock); - ConstantFP *&NewSlot = FPConstants[Key]; - if (!NewSlot) { - const Type *Ty; - if (&V.getSemantics() == &APFloat::IEEEsingle) - Ty = Type::FloatTy; - else if (&V.getSemantics() == &APFloat::IEEEdouble) - Ty = Type::DoubleTy; - else if (&V.getSemantics() == &APFloat::x87DoubleExtended) - Ty = Type::X86_FP80Ty; - else if (&V.getSemantics() == &APFloat::IEEEquad) - Ty = Type::FP128Ty; - else { - assert(&V.getSemantics() == &APFloat::PPCDoubleDouble && - "Unknown FP format"); - Ty = Type::PPC_FP128Ty; - } - NewSlot = new ConstantFP(Ty, V); - } - - return NewSlot; - } - - return Slot; -} - MDString *LLVMContextImpl::getMDString(const char *StrBegin, unsigned StrLength) { sys::SmartScopedWriter Writer(ConstantsLock); diff --git a/lib/VMCore/LLVMContextImpl.h b/lib/VMCore/LLVMContextImpl.h index 96ac0f80fc..a5ff8d5c54 100644 --- a/lib/VMCore/LLVMContextImpl.h +++ b/lib/VMCore/LLVMContextImpl.h @@ -457,11 +457,10 @@ class LLVMContextImpl { LLVMContextImpl(const LLVMContextImpl&); friend class ConstantInt; + friend class ConstantFP; public: LLVMContextImpl(LLVMContext &C); - ConstantFP *getConstantFP(const APFloat &V); - MDString *getMDString(const char *StrBegin, unsigned StrLength); MDNode *getMDNode(Value*const* Vals, unsigned NumVals); -- cgit v1.2.3