diff options
| author | Owen Anderson <resistor@mac.com> | 2009-07-13 04:09:18 +0000 |
|---|---|---|
| committer | Owen Anderson <resistor@mac.com> | 2009-07-13 04:09:18 +0000 |
| commit | 0a5372ed3e8cda10d724feda3c1a1c998db05ca0 (patch) | |
| tree | 89dc39f73d938c223b4e192bc6fd918490a60218 | |
| parent | f1db120d0494ec55d9265cea7dab22e80dcae10c (diff) | |
| download | llvm-0a5372ed3e8cda10d724feda3c1a1c998db05ca0.tar.gz llvm-0a5372ed3e8cda10d724feda3c1a1c998db05ca0.tar.bz2 llvm-0a5372ed3e8cda10d724feda3c1a1c998db05ca0.tar.xz | |
Begin the painful process of tearing apart the rat'ss nest that is Constants.cpp and ConstantFold.cpp.
This involves temporarily hard wiring some parts to use the global context. This isn't ideal, but it's
the only way I could figure out to make this process vaguely incremental.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@75445 91177308-0d34-0410-b5e6-96231b3b80d8
43 files changed, 547 insertions, 480 deletions
diff --git a/docs/tutorial/LangImpl5.html b/docs/tutorial/LangImpl5.html index bb4b4075b8..f3630d06ac 100644 --- a/docs/tutorial/LangImpl5.html +++ b/docs/tutorial/LangImpl5.html @@ -856,7 +856,7 @@ the loop again and exiting the loop. Any future code is emitted in the NamedValues.erase(VarName); // for expr always returns 0.0. - return Constant::getNullValue(Type::DoubleTy); + return TheFunction->getContext()->getNullValue(Type::DoubleTy); } </pre> </div> diff --git a/docs/tutorial/LangImpl6.html b/docs/tutorial/LangImpl6.html index c6d9ce1847..c0c396b8a3 100644 --- a/docs/tutorial/LangImpl6.html +++ b/docs/tutorial/LangImpl6.html @@ -1570,7 +1570,7 @@ Value *ForExprAST::Codegen() { // for expr always returns 0.0. - return Constant::getNullValue(Type::DoubleTy); + return TheFunction->getContext()->getNullValue(Type::DoubleTy); } Function *PrototypeAST::Codegen() { diff --git a/docs/tutorial/LangImpl7.html b/docs/tutorial/LangImpl7.html index 71bb397b49..157b7dda45 100644 --- a/docs/tutorial/LangImpl7.html +++ b/docs/tutorial/LangImpl7.html @@ -1858,7 +1858,7 @@ Value *ForExprAST::Codegen() { // for expr always returns 0.0. - return Constant::getNullValue(Type::DoubleTy); + return TheFunction->getContext()->getNullValue(Type::DoubleTy); } Value *VarExprAST::Codegen() { diff --git a/examples/BrainF/BrainF.cpp b/examples/BrainF/BrainF.cpp index cd9e850728..38914688ec 100644 --- a/examples/BrainF/BrainF.cpp +++ b/examples/BrainF/BrainF.cpp @@ -145,7 +145,7 @@ void BrainF::header(LLVMContext& C) { //call i32 @puts(i8 *getelementptr([%d x i8] *@aberrormsg, i32 0, i32 0)) { - Constant *zero_32 = Constant::getNullValue(IntegerType::Int32Ty); + Constant *zero_32 = C.getNullValue(IntegerType::Int32Ty); Constant *gep_params[] = { zero_32, diff --git a/examples/Kaleidoscope/toy.cpp b/examples/Kaleidoscope/toy.cpp index 3893aeac59..134742516d 100644 --- a/examples/Kaleidoscope/toy.cpp +++ b/examples/Kaleidoscope/toy.cpp @@ -854,7 +854,7 @@ Value *ForExprAST::Codegen() { // for expr always returns 0.0. - return Constant::getNullValue(Type::DoubleTy); + return TheFunction->getContext()->getNullValue(Type::DoubleTy); } Value *VarExprAST::Codegen() { diff --git a/include/llvm/CodeGen/FastISel.h b/include/llvm/CodeGen/FastISel.h index c7b1a42d06..857267c011 100644 --- a/include/llvm/CodeGen/FastISel.h +++ b/include/llvm/CodeGen/FastISel.h @@ -60,6 +60,7 @@ protected: const TargetData &TD; const TargetInstrInfo &TII; const TargetLowering &TLI; + LLVMContext *Context; public: /// startNewBlock - Set the current block to which generated machine diff --git a/include/llvm/Constant.h b/include/llvm/Constant.h index d4949d1a0f..05a6623200 100644 --- a/include/llvm/Constant.h +++ b/include/llvm/Constant.h @@ -18,6 +18,7 @@ namespace llvm { template<typename T> class SmallVectorImpl; + class LLVMContext; /// If object contains references to other objects, then relocations are /// usually required for emission of such object (especially in PIC mode). One @@ -59,10 +60,6 @@ protected: void destroyConstantImpl(); public: - /// Static constructor to get a '0' constant of arbitrary type... - /// - static Constant *getNullValue(const Type *Ty); - /// Static constructor to get a '-1' constant. This supports integers and /// vectors. /// @@ -98,7 +95,8 @@ public: /// type, returns the elements of the vector in the specified smallvector. /// This handles breaking down a vector undef into undef elements, etc. For /// constant exprs and other cases we can't handle, we return an empty vector. - void getVectorElements(SmallVectorImpl<Constant*> &Elts) const; + void getVectorElements(LLVMContext &Context, + SmallVectorImpl<Constant*> &Elts) const; /// destroyConstant - Called if some element of this constant is no longer /// valid. At this point only other constants may be on the use_list for this diff --git a/include/llvm/Constants.h b/include/llvm/Constants.h index 09750668a1..77124d8974 100644 --- a/include/llvm/Constants.h +++ b/include/llvm/Constants.h @@ -276,9 +276,6 @@ public: /// considers -0.0 to be null as well as 0.0. :( virtual bool isNullValue() const; - // Get a negative zero. - static ConstantFP *getNegativeZero(const Type* Ty); - /// isExactlyValue - We don't rely on operator== working on double values, as /// it returns true for things that are clearly not equal, like -0.0 and 0.0. /// As such, this method can be used to do an exact bit-for-bit comparison of @@ -383,7 +380,7 @@ public: /// isString) and it ends in a null byte \0 and does not contains any other /// @endverbatim /// null bytes except its terminator. - bool isCString() const; + bool isCString(LLVMContext &Context) const; /// getAsString - If this array is isString(), then this method converts the /// array to an std::string and returns it. Otherwise, it asserts out. @@ -694,17 +691,6 @@ public: return getSelectTy(V1->getType(), C, V1, V2); } - /// getAlignOf constant expr - computes the alignment of a type in a target - /// independent way (Note: the return type is an i32; Note: assumes that i8 - /// is byte aligned). - /// - static Constant *getAlignOf(const Type *Ty); - - /// getSizeOf constant expr - computes the size of a type in a target - /// independent way (Note: the return type is an i64). - /// - static Constant *getSizeOf(const Type *Ty); - /// ConstantExpr::get - Return a binary or shift operator constant expression, /// folding if possible. /// @@ -716,8 +702,6 @@ public: /// ConstantExpr::get* - Return some common constants without having to /// specify the full Instruction::OPCODE identifier. /// - static Constant *getNeg(Constant *C); - static Constant *getFNeg(Constant *C); static Constant *getNot(Constant *C); static Constant *getAdd(Constant *C1, Constant *C2); static Constant *getFAdd(Constant *C1, Constant *C2); @@ -756,11 +740,6 @@ public: static Constant *getInsertValue(Constant *Agg, Constant *Val, const unsigned *IdxList, unsigned NumIdx); - /// 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 *getZeroValueForNegationExpr(const Type *Ty); - /// isNullValue - Return true if this is the value that would be returned by /// getNullValue. virtual bool isNullValue() const { return false; } diff --git a/include/llvm/InstrTypes.h b/include/llvm/InstrTypes.h index 76827191f1..9c1f8fc804 100644 --- a/include/llvm/InstrTypes.h +++ b/include/llvm/InstrTypes.h @@ -202,13 +202,17 @@ public: /// CreateNeg, CreateNot - Create the NEG and NOT /// instructions out of SUB and XOR instructions. /// - static BinaryOperator *CreateNeg(Value *Op, const std::string &Name = "", + static BinaryOperator *CreateNeg(LLVMContext &Context, + Value *Op, const std::string &Name = "", Instruction *InsertBefore = 0); - static BinaryOperator *CreateNeg(Value *Op, const std::string &Name, + static BinaryOperator *CreateNeg(LLVMContext &Context, + Value *Op, const std::string &Name, BasicBlock *InsertAtEnd); - static BinaryOperator *CreateFNeg(Value *Op, const std::string &Name = "", + static BinaryOperator *CreateFNeg(LLVMContext &Context, + Value *Op, const std::string &Name = "", Instruction *InsertBefore = 0); - static BinaryOperator *CreateFNeg(Value *Op, const std::string &Name, + static BinaryOperator *CreateFNeg(LLVMContext &Context, + Value *Op, const std::string &Name, BasicBlock *InsertAtEnd); static BinaryOperator *CreateNot(Value *Op, const std::string &Name = "", Instruction *InsertBefore = 0); @@ -218,8 +222,8 @@ public: /// isNeg, isFNeg, isNot - Check if the given Value is a /// NEG, FNeg, or NOT instruction. /// - static bool isNeg(const Value *V); - static bool isFNeg(const Value *V); + static bool isNeg(LLVMContext &Context, const Value *V); + static bool isFNeg(LLVMContext &Context, const Value *V); static bool isNot(const Value *V); /// getNegArgument, getNotArgument - Helper functions to extract the diff --git a/include/llvm/LLVMContext.h b/include/llvm/LLVMContext.h index 75b7e59ceb..e441d189c2 100644 --- a/include/llvm/LLVMContext.h +++ b/include/llvm/LLVMContext.h @@ -120,6 +120,11 @@ public: bool isSigned); Constant* getConstantExprFPCast(Constant* C, const Type* Ty); Constant* getConstantExprSelect(Constant* C, Constant* V1, Constant* V2); + + /// getAlignOf constant expr - computes the alignment of a type in a target + /// independent way (Note: the return type is an i32; Note: assumes that i8 + /// is byte aligned). + /// Constant* getConstantExprAlignOf(const Type* Ty); Constant* getConstantExprCompare(unsigned short pred, Constant* C1, Constant* C2); @@ -162,7 +167,15 @@ public: Constant* getConstantExprInsertValue(Constant* Agg, Constant* Val, const unsigned* IdxList, unsigned NumIdx); + + /// getSizeOf constant expr - computes the size of a type in a target + /// independent way (Note: the return type is an i64). + /// 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 @@ -200,6 +213,7 @@ public: StructType* getStructType(bool isPacked=false); StructType* getStructType(const std::vector<const Type*>& Params, bool isPacked = false); + StructType* getStructType(const Type* type, ...); // ArrayType accessors ArrayType* getArrayType(const Type* ElementType, uint64_t NumElements); diff --git a/include/llvm/Support/IRBuilder.h b/include/llvm/Support/IRBuilder.h index 9fc29ef44e..5de33eb2cb 100644 --- a/include/llvm/Support/IRBuilder.h +++ b/include/llvm/Support/IRBuilder.h @@ -311,12 +311,12 @@ public: Value *CreateNeg(Value *V, const char *Name = "") { if (Constant *VC = dyn_cast<Constant>(V)) return Folder.CreateNeg(VC); - return Insert(BinaryOperator::CreateNeg(V), Name); + return Insert(BinaryOperator::CreateNeg(getGlobalContext(), V), Name); } Value *CreateFNeg(Value *V, const char *Name = "") { if (Constant *VC = dyn_cast<Constant>(V)) return Folder.CreateFNeg(VC); - return Insert(BinaryOperator::CreateFNeg(V), Name); + return Insert(BinaryOperator::CreateFNeg(getGlobalContext(), V), Name); } Value *CreateNot(Value *V, const char *Name = "") { if (Constant *VC = dyn_cast<Constant>(V)) diff --git a/lib/Analysis/DebugInfo.cpp b/lib/Analysis/DebugInfo.cpp index 491cc3f202..437ff03b32 100644 --- a/lib/Analysis/DebugInfo.cpp +++ b/lib/Analysis/DebugInfo.cpp @@ -463,7 +463,7 @@ DIFactory::DIFactory(Module &m) /// getCastToEmpty - Return this descriptor as a Constant* with type '{}*'. /// This is only valid when the descriptor is non-null. Constant *DIFactory::getCastToEmpty(DIDescriptor D) { - if (D.isNull()) return Constant::getNullValue(EmptyStructPtr); + if (D.isNull()) return VMContext.getNullValue(EmptyStructPtr); return VMContext.getConstantExprBitCast(D.getGV(), EmptyStructPtr); } diff --git a/lib/Analysis/IPA/Andersens.cpp b/lib/Analysis/IPA/Andersens.cpp index 3f1dcb75b1..91aaf0670a 100644 --- a/lib/Analysis/IPA/Andersens.cpp +++ b/lib/Analysis/IPA/Andersens.cpp @@ -693,7 +693,7 @@ void Andersens::getMustAliases(Value *P, std::vector<Value*> &RetVals) { // If the object in the points-to set is the null object, then the null // pointer is a must alias. if (Pointee == &GraphNodes[NullObject]) - RetVals.push_back(Constant::getNullValue(P->getType())); + RetVals.push_back(Context->getNullValue(P->getType())); } } AliasAnalysis::getMustAliases(P, RetVals); diff --git a/lib/Analysis/ScalarEvolution.cpp b/lib/Analysis/ScalarEvolution.cpp index a167792024..fc7d286aaf 100644 --- a/lib/Analysis/ScalarEvolution.cpp +++ b/lib/Analysis/ScalarEvolution.cpp @@ -2084,7 +2084,8 @@ const SCEV *ScalarEvolution::getIntegerSCEV(int Val, const Type *Ty) { /// const SCEV *ScalarEvolution::getNegativeSCEV(const SCEV *V) { if (const SCEVConstant *VC = dyn_cast<SCEVConstant>(V)) - return getConstant(cast<ConstantInt>(ConstantExpr::getNeg(VC->getValue()))); + return getConstant( + cast<ConstantInt>(Context->getConstantExprNeg(VC->getValue()))); const Type *Ty = V->getType(); Ty = getEffectiveSCEVType(Ty); @@ -3284,7 +3285,7 @@ EvaluateConstantChrecAtConstant(const SCEVAddRecExpr *AddRec, ConstantInt *C, /// the addressed element of the initializer or null if the index expression is /// invalid. static Constant * -GetAddressedElementFromGlobal(GlobalVariable *GV, +GetAddressedElementFromGlobal(LLVMContext *Context, GlobalVariable *GV, const std::vector<ConstantInt*> &Indices) { Constant *Init = GV->getInitializer(); for (unsigned i = 0, e = Indices.size(); i != e; ++i) { @@ -3298,10 +3299,10 @@ GetAddressedElementFromGlobal(GlobalVariable *GV, } else if (isa<ConstantAggregateZero>(Init)) { if (const StructType *STy = dyn_cast<StructType>(Init->getType())) { assert(Idx < STy->getNumElements() && "Bad struct index!"); - Init = Constant::getNullValue(STy->getElementType(Idx)); + Init = Context->getNullValue(STy->getElementType(Idx)); } else if (const ArrayType *ATy = dyn_cast<ArrayType>(Init->getType())) { if (Idx >= ATy->getNumElements()) return 0; // Bogus program - Init = Constant::getNullValue(ATy->getElementType()); + Init = Context->getNullValue(ATy->getElementType()); } else { LLVM_UNREACHABLE("Unknown constant aggregate type!"); } @@ -3372,7 +3373,7 @@ ScalarEvolution::ComputeLoadConstantCompareBackedgeTakenCount( // Form the GEP offset. Indexes[VarIdxNum] = Val; - Constant *Result = GetAddressedElementFromGlobal(GV, Indexes); + Constant *Result = GetAddressedElementFromGlobal(Context, GV, Indexes); if (Result == 0) break; // Cannot compute! // Evaluate the condition for this iteration. diff --git a/lib/CodeGen/IntrinsicLowering.cpp b/lib/CodeGen/IntrinsicLowering.cpp index 914d703e85..9e6bcd83f3 100644 --- a/lib/CodeGen/IntrinsicLowering.cpp +++ b/lib/CodeGen/IntrinsicLowering.cpp @@ -315,6 +315,7 @@ static void ReplaceFPIntrinsicWithCall(CallInst *CI, const char *Fname, void IntrinsicLowering::LowerIntrinsicCall(CallInst *CI) { IRBuilder<> Builder(CI->getParent(), CI); + LLVMContext *Context = CI->getParent()->getContext(); Function *Callee = CI->getCalledFunction(); assert(Callee && "Cannot lower an indirect call!"); @@ -340,7 +341,7 @@ void IntrinsicLowering::LowerIntrinsicCall(CallInst *CI) { } case Intrinsic::sigsetjmp: if (CI->getType() != Type::VoidTy) - CI->replaceAllUsesWith(Constant::getNullValue(CI->getType())); + CI->replaceAllUsesWith(Context->getNullValue(CI->getType())); break; case Intrinsic::longjmp: { @@ -387,7 +388,7 @@ void IntrinsicLowering::LowerIntrinsicCall(CallInst *CI) { "save" : "restore") << " intrinsic.\n"; Warned = true; if (Callee->getIntrinsicID() == Intrinsic::stacksave) - CI->replaceAllUsesWith(Constant::getNullValue(CI->getType())); + CI->replaceAllUsesWith(Context->getNullValue(CI->getType())); break; } @@ -422,7 +423,7 @@ void IntrinsicLowering::LowerIntrinsicCall(CallInst *CI) { case Intrinsic::eh_exception: case Intrinsic::eh_selector_i32: case Intrinsic::eh_selector_i64: - CI->replaceAllUsesWith(Constant::getNullValue(CI->getType())); + CI->replaceAllUsesWith(Context->getNullValue(CI->getType())); break; case Intrinsic::eh_typeid_for_i32: diff --git a/lib/CodeGen/MachOWriter.cpp b/lib/CodeGen/MachOWriter.cpp index 7542d9ed10..35f71075cc 100644 --- a/lib/CodeGen/MachOWriter.cpp +++ b/lib/CodeGen/MachOWriter.cpp @@ -123,7 +123,7 @@ bool MachOWriter::doFinalization(Module &M) { // getConstSection - Get constant section for Constant 'C' MachOSection *MachOWriter::getConstSection(Constant *C) { const ConstantArray *CVA = dyn_cast<ConstantArray>(C); - if (CVA && CVA->isCString()) + if (CVA && CVA->isCString(*Context)) return getSection("__TEXT", "__cstring", MachOSection::S_CSTRING_LITERALS); diff --git a/lib/CodeGen/SelectionDAG/FastISel.cpp b/lib/CodeGen/SelectionDAG/FastISel.cpp index cd2d5ac8ec..adb4d729e6 100644 --- a/lib/CodeGen/SelectionDAG/FastISel.cpp +++ b/lib/CodeGen/SelectionDAG/FastISel.cpp @@ -92,7 +92,7 @@ unsigned FastISel::getRegForValue(Value *V) { } else if (isa<ConstantPointerNull>(V)) { // Translate this as an integer zero so that it can be // local-CSE'd with actual integer zeros. - Reg = getRegForValue(Constant::getNullValue(TD.getIntPtrType())); + Reg = getRegForValue(Context->getNullValue(TD.getIntPtrType())); } else if (ConstantFP *CF = dyn_cast<ConstantFP>(V)) { Reg = FastEmit_f(VT, VT, ISD::ConstantFP, CF); @@ -480,7 +480,7 @@ bool FastISel::SelectCall(User *I) { UpdateValueMap(I, ResultReg); } else { unsigned ResultReg = - getRegForValue(Constant::getNullValue(I->getType())); + getRegForValue(Context->getNullValue(I->getType())); UpdateValueMap(I, ResultReg); } return true; @@ -753,7 +753,8 @@ FastISel::FastISel(MachineFunction &mf, TM(MF.getTarget()), TD(*TM.getTargetData()), TII(*TM.getInstrInfo()), - TLI(*TM.getTargetLowering()) { + TLI(*TM.getTargetLowering()), + Context(mf.getFunction()->getContext()) { } FastISel::~FastISel() {} diff --git a/lib/CodeGen/SelectionDAG/SelectionDAGBuild.cpp b/lib/CodeGen/SelectionDAG/SelectionDAGBuild.cpp index 63aa7cfe7c..ef71a62f14 100644 --- a/lib/CodeGen/SelectionDAG/SelectionDAGBuild.cpp +++ b/lib/CodeGen/SelectionDAG/SelectionDAGBuild.cpp @@ -2139,7 +2139,7 @@ void SelectionDAGLowering::visitFSub(User &I) { const VectorType *DestTy = cast<VectorType>(I.getType()); const Type *ElTy = DestTy->getElementType(); unsigned VL = DestTy->getNumElements(); - std::vector<Constant*> NZ(VL, ConstantFP::getNegativeZero(ElTy)); + std::vector<Constant*> NZ(VL, Context->getConstantFPNegativeZero(ElTy)); Constant *CNZ = ConstantVector::get(&NZ[0], NZ.size()); if (CV == CNZ) { SDValue Op2 = getValue(I.getOperand(1)); @@ -2150,7 +2150,8 @@ void SelectionDAGLowering::visitFSub(User &I) { } } if (ConstantFP *CFP = dyn_cast<ConstantFP>(I.getOperand(0))) - if (CFP->isExactlyValue(ConstantFP::getNegativeZero(Ty)->getValueAPF())) { + if (CFP->isExactlyValue( + Context->getConstantFPNegativeZero(Ty)->getValueAPF())) { SDValue Op2 = getValue(I.getOperand(1)); setValue(&I, DAG.getNode(ISD::FNEG, getCurDebugLoc(), Op2.getValueType(), Op2)); @@ -2398,7 +2399,7 @@ void SelectionDAGLowering::visitShuffleVector(User &I) { // Convert the ConstantVector mask operand into an array of ints, with -1 // representing undef values. SmallVector<Constant*, 8> MaskElts; - cast<Constant>(I.getOperand(2))->getVectorElements(MaskElts); + cast<Constant>(I.getOperand(2))->getVectorElements(*Context, MaskElts); unsigned MaskNumElts = MaskElts.size(); for (unsigned i = 0; i != MaskNumElts; ++i) { if (isa<UndefValue>(MaskElts[i])) diff --git a/lib/CodeGen/SelectionDAG/SelectionDAGBuild.h b/lib/CodeGen/SelectionDAG/SelectionDAGBuild.h index 6039ef56f2..deb8855690 100644 --- a/lib/CodeGen/SelectionDAG/SelectionDAGBuild.h +++ b/lib/CodeGen/SelectionDAG/SelectionDAGBuild.h @@ -15,6 +15,7 @@ #define SELECTIONDAGBUILD_H #include "llvm/Constants.h" +#include "llvm/CodeGen/SelectionDAG.h" #include "llvm/ADT/APInt.h" #include "llvm/ADT/DenseMap.h" #ifndef NDEBUG @@ -362,11 +363,14 @@ public: /// GFI - Garbage collection metadata for the function. GCFunctionInfo *GFI; + LLVMContext *Context; + SelectionDAGLowering(SelectionDAG &dag, TargetLowering &tli, FunctionLoweringInfo &funcinfo, CodeGenOpt::Level ol) : CurDebugLoc(DebugLoc::getUnknownLoc()), - TLI(tli), DAG(dag), FuncInfo(funcinfo), OptLevel(ol) { + TLI(tli), DAG(dag), FuncInfo(funcinfo), OptLevel(ol), + Context(dag.getContext()) { } void init(GCFunctionInfo *gfi, AliasAnalysis &aa); diff --git a/lib/CodeGen/ShadowStackGC.cpp b/lib/CodeGen/ShadowStackGC.cpp index 6ba1243ce1..13fa758c24 100644 --- a/lib/CodeGen/ShadowStackGC.cpp +++ b/lib/CodeGen/ShadowStackGC.cpp @@ -293,10 +293,10 @@ bool ShadowStackGC::initializeCustomLowering(Module &M) { // linkage! Head = new GlobalVariable(M, StackEntryPtrTy, false, GlobalValue::LinkOnceAnyLinkage, - Constant::getNullValue(StackEntryPtrTy), + M.getContext().getNullValue(StackEntryPtrTy), "llvm_gc_root_chain"); } else if (Head->hasExternalLinkage() && Head->isDeclaration()) { - Head->setInitializer(Constant::getNullValue(StackEntryPtrTy)); + Head->setInitializer(M.getContext().getNullValue(StackEntryPtrTy)); Head->setLinkage(GlobalValue::LinkOnceAnyLinkage); } diff --git a/lib/CodeGen/UnreachableBlockElim.cpp b/lib/CodeGen/UnreachableBlockElim.cpp index c3b213cebe..003470d954 100644 --- a/lib/CodeGen/UnreachableBlockElim.cpp +++ b/lib/CodeGen/UnreachableBlockElim.cpp @@ -68,7 +68,7 @@ bool UnreachableBlockElim::runOnFunction(Function &F) { BasicBlock *BB = I; DeadBlocks.push_back(BB); while (PHINode *PN = dyn_cast<PHINode>(BB->begin())) { - PN->replaceAllUsesWith(Constant::getNullValue(PN->getType())); + PN->replaceAllUsesWith(Context->getNullValue(PN->getType())); BB->getInstList().pop_front(); } for (succ_iterator SI = succ_begin(BB), E = succ_end(BB); SI != E; ++SI) diff --git a/lib/Target/CBackend/CBackend.cpp b/lib/Target/CBackend/CBackend.cpp index f922146cd0..a403f2e9f1 100644 --- a/lib/Target/CBackend/CBackend.cpp +++ b/lib/Target/CBackend/CBackend.cpp @@ -1239,7 +1239,7 @@ void CWriter::printConstant(Constant *CPV, bool Static) { Out << '{'; if (AT->getNumElements()) { Out << ' '; - Constant *CZ = Constant::getNullValue(AT->getElementType()); + Constant *CZ = Context->getNullValue(AT->getElementType()); printConstant(CZ, Static); for (unsigned i = 1, e = AT->getNumElements(); i != e; ++i) { Out << ", "; @@ -1264,7 +1264,7 @@ void CWriter::printConstant(Constant *CPV, bool Static) { assert(isa<ConstantAggregateZero>(CPV) || isa<UndefValue>(CPV)); const VectorType *VT = cast<VectorType>(CPV->getType()); Out << "{ "; - Constant *CZ = Constant::getNullValue(VT->getElementType()); + Constant *CZ = Context->getNullValue(VT->getElementType()); printConstant(CZ, Static); for (unsigned i = 1, e = VT->getNumElements(); i != e; ++i) { Out << ", "; @@ -1286,10 +1286,10 @@ void CWriter::printConstant(Constant *CPV, bool Static) { Out << '{'; if (ST->getNumElements()) { Out << ' '; - printConstant(Constant::getNullValue(ST->getElementType(0)), Static); + printConstant(Context->getNullValue(ST->getElementType(0)), Static); for (unsigned i = 1, e = ST->getNumElements(); i != e; ++i) { Out << ", "; - printConstant(Constant::getNullValue(ST->getElementType(i)), Static); + printConstant(Context->getNullValue(ST->getElementType(i)), Static); } } Out << " }"; @@ -2621,11 +2621,11 @@ void CWriter::visitBinaryOperator(Instruction &I) { // If this is a negation operation, print it out as such. For FP, we don't // want to print "-0.0 - X". - if (BinaryOperator::isNeg(&I)) { + if (BinaryOperator::isNeg(*Context, &I)) { Out << "-("; writeOperand(BinaryOperator::getNegArgument(cast<BinaryOperator>(&I))); Out << ")"; - } else if (BinaryOperator::isFNeg(&I)) { + } else if (BinaryOperator::isFNeg(*Context, &I)) { Out << "-("; writeOperand(BinaryOperator::getFNegArgument(cast<BinaryOperator>(&I))); Out << ")"; diff --git a/lib/Target/Mips/AsmPrinter/MipsAsmPrinter.cpp b/lib/Target/Mips/AsmPrinter/MipsAsmPrinter.cpp index 17c7640e36..89e9426f24 100644 --- a/lib/Target/Mips/AsmPrinter/MipsAsmPrinter.cpp +++ b/lib/Target/Mips/AsmPrinter/MipsAsmPrinter.cpp @@ -541,7 +541,7 @@ printModuleLevelGV(const GlobalVariable* GVar) { // Fall Through case GlobalValue::PrivateLinkage: case GlobalValue::InternalLinkage: - if (CVA && CVA->isCString()) + if (CVA && CVA->isCString(GVar->getParent()->getContext())) printSizeAndType = false; break; case GlobalValue::GhostLinkage: diff --git a/lib/Target/Mips/MipsISelLowering.cpp b/lib/Target/Mips/MipsISelLowering.cpp index f3fa17938b..3727918eac 100644 --- a/lib/Target/Mips/MipsISelLowering.cpp +++ b/lib/Target/Mips/MipsISelLowering.cpp @@ -227,7 +227,7 @@ bool MipsTargetLowering::IsGlobalInSmallSection(GlobalValue *GV) if (GVA->hasInitializer() && GV->hasLocalLinkage()) { Constant *C = GVA->getInitializer(); const ConstantArray *CVA = dyn_cast<ConstantArray>(C); - if (CVA && CVA->isCString()) + if (CVA && CVA->isCString(GV->getParent()->getContext())) return false; } diff --git a/lib/Target/TargetAsmInfo.cpp b/lib/Target/TargetAsmInfo.cpp index 782e7b4d87..4fbe1ae55e 100644 --- a/lib/Target/TargetAsmInfo.cpp +++ b/lib/Target/TargetAsmInfo.cpp @@ -170,11 +170,11 @@ static bool isSuitableForBSS(const GlobalVariable *GV) { return (C->isNullValue() && !GV->isConstant() && !NoZerosInBSS); } -static bool isConstantString(const Constant *C) { +static bool isConstantString(LLVMContext &Context, const Constant *C) { // First check: is we have constant array of i8 terminated with zero const ConstantArray *CVA = dyn_cast<ConstantArray>(C); // Check, if initializer is a null-terminated string - if (CVA && CVA->isCString()) + if (CVA && CVA->isCString(Context)) return true; // Another possibility: [1 x i8] zeroinitializer @@ -229,7 +229,7 @@ TargetAsmInfo::SectionKindForGlobal(const GlobalValue *GV) const { } } else { // Check, if initializer is a null-terminated string - if (isConstantString(C)) + if (isConstantString(GV->getParent()->getContext(), C)) return SectionKind::RODataMergeStr; else return SectionKind::RODataMergeConst; diff --git a/lib/Target/X86/X86FastISel.cpp b/lib/Target/X86/X86FastISel.cpp index feb3d4c72e..2b3304d19c 100644 --- a/lib/Target/X86/X86FastISel.cpp +++ b/lib/Target/X86/X86FastISel.cpp @@ -272,7 +272,7 @@ bool X86FastISel::X86FastEmitStore(MVT VT, Value *Val, const X86AddressMode &AM) { // Handle 'null' like i32/i64 0. if (isa<ConstantPointerNull>(Val)) - Val = Constant::getNullValue(TD.getIntPtrType()); + Val = Context->getNullValue(TD.getIntPtrType()); // If this is a store of a simple constant, fold the constant into the store. if (ConstantInt *CI = dyn_cast<ConstantInt>(Val)) { @@ -672,7 +672,7 @@ bool X86FastISel::X86FastEmitCompare(Value *Op0, Value *Op1, MVT VT) { // Handle 'null' like i32/i64 0. if (isa<ConstantPointerNull>(Op1)) - Op1 = Constant::getNullValue(TD.getIntPtrType()); + Op1 = Context->getNullValue(TD.getIntPtrType()); // We have two options: compare with register or immediate. If the RHS of // the compare is an immediate that we can fold into this compare, use diff --git a/lib/Target/X86/X86InstrInfo.cpp b/lib/Target/X86/X86InstrInfo.cpp index 572b71dbc0..cb98c057c4 100644 --- a/lib/Target/X86/X86InstrInfo.cpp +++ b/lib/Target/X86/X86InstrInfo.cpp @@ -20,6 +20,7 @@ #include "X86TargetMachine.h" #include "llvm/GlobalVariable.h" #include "llvm/DerivedTypes.h" +#include "llvm/LLVMContext.h" #include "llvm/ADT/STLExtras.h" #include "llvm/CodeGen/MachineConstantPool.h" #include "llvm/CodeGen/MachineFrameInfo.h" @@ -2312,7 +2313,7 @@ MachineInstr* X86InstrInfo::foldMemoryOperandImpl(MachineFunction &MF, MachineConstantPool &MCP = *MF.getConstantPool(); const VectorType *Ty = VectorType::get(Type::Int32Ty, 4); Constant *C = LoadMI->getOpcode() == X86::V_SET0 ? - ConstantVector::getNullValue(Ty) : + MF.getFunction()->getContext()->getNullValue(Ty) : ConstantVector::getAllOnesValue(Ty); unsigned CPI = MCP.getConstantPoolIndex(C, 16); diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp index 2cf3fd7f2a..39ad04f53e 100644 --- a/lib/Transforms/Scalar/InstructionCombining.cpp +++ b/lib/Transforms/Scalar/InstructionCombining.cpp @@ -408,9 +408,10 @@ X("instcombine", "Combine redundant instructions"); // getComplexity: Assign a complexity or rank value to LLVM Values... // 0 -> undef, 1 -> Const, 2 -> Other, 3 -> Arg, 3 -> Unary, 4 -> OtherInst -static unsigned getComplexity(Value *V) { +static unsigned getComplexity(LLVMContext *Context, Value *V) { if (isa<Instruction>(V)) { - if (BinaryOperator::isNeg(V) || BinaryOperator::isFNeg(V) || + if (BinaryOperator::isNeg(*Context, V) || + BinaryOperator::isFNeg(*Context, V) || BinaryOperator::isNot(V)) return 3; return 4; @@ -521,7 +522,8 @@ static bool ValueRequiresCast(Instruction::CastOps opcode, const Value *V, // bool InstCombiner::SimplifyCommutative(BinaryOperator &I) { bool Changed = false; - if (getComplexity(I.getOperand(0)) < getComplexity(I.getOperand(1))) + if (getComplexity(Context, I.getOperand(0)) < + getComplexity(Context, I.getOperand(1))) Changed = !I.swapOperands(); if (!I.isAssociative()) return Changed; @@ -559,7 +561,8 @@ bool InstCombiner::SimplifyCommutative(BinaryOperator &I) { /// so that theyare listed from right (least complex) to left (most complex). /// This puts constants before unary operators before binary operators. bool InstCombiner::SimplifyCompare(CmpInst &I) { - if (getComplexity(I.getOperand(0)) >= getComplexity(I.getOperand(1))) + if (getComplexity(Context, I.getOperand(0)) >= + getComplexity(Context, I.getOperand(1))) return false; I.swapOperands(); // Compare instructions are not associative so there's nothing else we can do. @@ -570,7 +573,7 @@ bool InstCombiner::SimplifyCompare(CmpInst &I) { // if the LHS is a constant zero (which is the 'negate' form). // static inline Value *dyn_castNegVal(Value *V, LLVMContext *Context) { - if (BinaryOperator::isNeg(V)) + if (BinaryOperator::isNeg(*Context, V)) return BinaryOperator::getNegArgument(V); // Constants can be considered to be negated values if they can be folded. @@ -589,7 +592,7 @@ static inline Value *dyn_castNegVal(Value *V, LLVMContext *Context) { // form). // static inline Value *dyn_castFNegVal(Value *V, LLVMContext *Context) { - if (BinaryOperator::isFNeg(V)) + if (BinaryOperator::isFNeg(*Context, V)) return BinaryOperator::getFNegArgument(V); // Constants can be considered to be negated values if they can be folded. @@ -2185,7 +2188,7 @@ Instruction *InstCombiner::visitAdd(BinaryOperator &I) { if (Value *RHSV = dyn_castNegVal(RHS, Context)) { Instruction *NewAdd = BinaryOperator::CreateAdd(LHSV, RHSV, "sum"); InsertNewInstBefore(NewAdd, I); - return BinaryOperator::CreateNeg(NewAdd); + return BinaryOperator::CreateNeg(*Context, NewAdd); } } @@ -2530,9 +2533,11 @@ Instruction *InstCombiner::visitSub(BinaryOperator &I) { if (BinaryOperator *Op1I = dyn_cast<BinaryOperator>(Op1)) { if (Op1I->getOpcode() == Instruction::Add) { if (Op1I->getOperand(0) == Op0) // X-(X+Y) == -Y - return BinaryOperator::CreateNeg(Op1I->getOperand(1), I.getName()); + return BinaryOperator::CreateNeg(*Context, Op1I->getOperand(1), + I.getName()); else if (Op1I->getOperand(1) == Op0) // X-(Y+X) == -Y - return BinaryOperator::CreateNeg(Op1I->getOperand(0), I.getName()); + return BinaryOperator::CreateNeg(*Context, Op1I->getOperand(0), + I.getName()); else if (ConstantInt *CI1 = dyn_cast<ConstantInt>(I.getOperand(0))) { if (ConstantInt *CI2 = dyn_cast<ConstantInt>(Op1I->getOperand(1))) // C1-(X+C2) --> (C1-C2)-X @@ -2593,7 +2598,8 @@ Instruction *InstCombiner::visitSub(BinaryOperator &I) { return ReplaceInstUsesWith(I, Op0I->getOperand(0)); } else if (Op0I->getOpcode() == Instruction::Sub) { if (Op0I->getOperand(0) == Op1) // (X-Y)-X == -Y - return BinaryOperator::CreateNeg(Op0I->getOperand(1), I.getName()); + return BinaryOperator::CreateNeg(*Context, Op0I->getOperand(1), + I.getName()); } } @@ -2619,9 +2625,11 @@ Instruction *InstCombiner::visitFSub(BinaryOperator &I) { if (BinaryOperator *Op1I = dyn_cast<BinaryOperator>(Op1)) { if (Op1I->getOpcode() == Instruction::FAdd) { if (Op1I->getOperand(0) == Op0) // X-(X+Y) == -Y - return BinaryOperator::CreateFNeg(Op1I->getOperand(1), I.getName()); + return BinaryOperator::CreateFNeg(*Context, Op1I->getOperand(1), + I.getName()); else if (Op1I->getOperand(1) == Op0) // X-(Y+X) == -Y - return BinaryOperator::CreateFNeg(Op1I->getOperand(0), I.getName()); + return BinaryOperator::CreateFNeg(*Context, Op1I->getOperand(0), + I.getName()); } } @@ -2683,7 +2691,7 @@ Instruction *InstCombiner::visitMul(BinaryOperator &I) { if (CI->equalsInt(1)) // X * 1 == X return ReplaceInstUsesWith(I, Op0); if (CI->isAllOnesValue()) // X * -1 == 0 - X - return BinaryOperator::CreateNeg(Op0, I.getName()); + return BinaryOperator::CreateNeg(*Context, Op0, I.getName()); const APInt& Val = cast<ConstantInt>(CI)->getValue(); if (Val.isPowerOf2()) { // Replace X*(2^C) with X << C @@ -2695,7 +2703,7 @@ Instruction *InstCombiner::visitMul(BinaryOperator &I) { if (ConstantVector *Op1V = dyn_cast<ConstantVector>(Op1)) { if (Op1V->isAllOnesValue()) // X * -1 == 0 - X - return BinaryOperator::CreateNeg(Op0, I.getName()); + return BinaryOperator::CreateNeg(*Context, Op0, I.getName()); // As above, vector X*splat(1.0) -> X in all defined cases. if (Constant *Splat = Op1V->getSplatValue()) { @@ -3108,7 +3116,7 @@ Instruction *InstCombiner::visitSDiv(BinaryOperator &I) { if (ConstantInt *RHS = dyn_cast<ConstantInt>(Op1)) { // sdiv X, -1 == -X if (RHS->isAllOnesValue()) - return BinaryOperator::CreateNeg(Op0); + return BinaryOperator::CreateNeg(*Context, Op0); } // If the sign bits of both operands are zero (i.e. we can prove they are @@ -4042,7 +4050,7 @@ Instruction *InstCombiner::visitAnd(BinaryOperator &I) { ConstantInt *A = dyn_cast<ConstantInt>(Op0LHS); if (!(A && A->isZero()) && // avoid infinite recursion. MaskedValueIsZero(Op0LHS, Mask)) { - Instruction *NewNeg = BinaryOperator::CreateNeg(Op0RHS); + Instruction *NewNeg = BinaryOperator::CreateNeg(*Context, Op0RHS); InsertNewInstBefore(NewNeg, I); return BinaryOperator::CreateAnd(NewNeg, AndRHS); } @@ -7094,7 +7102,7 @@ Instruction *InstCombiner::visitICmpInstWithInstAndIntCst(ICmpInst &ICI, else if (Value *NegVal = dyn_castNegVal(BOp0, Context)) return new ICmpInst(*Context, ICI.getPredicate(), NegVal, BOp1); else if (BO->hasOneUse()) { - Instruction *Neg = BinaryOperator::CreateNeg(BOp1); + Instruction *Neg = BinaryOperator::CreateNeg(*Context, BOp1); InsertNewInstBefore(Neg, ICI); Neg->takeName(BO); return new ICmpInst(*Context, ICI.getPredicate(), BOp0, Neg); @@ -9587,7 +9595,8 @@ Instruction *InstCombiner::visitSelectInst(SelectInst &SI) { NegVal = Context->getConstantExprNeg(C); } else { NegVal = InsertNewInstBefore( - BinaryOperator::CreateNeg(SubOp->getOperand(1), "tmp"), SI); + BinaryOperator::CreateNeg(*Context, SubOp->getOperand(1), + "tmp"), SI); } Value *NewTrueOp = OtherAddOp; diff --git a/lib/Transforms/Scalar/PredicateSimplifier.cpp b/lib/Transforms/Scalar/PredicateSimplifier.cpp index c82c4ff3bf..24ac7bf30b 100644 --- a/lib/Transforms/Scalar/PredicateSimplifier.cpp +++ b/lib/Transforms/Scalar/PredicateSimplifier.cpp @@ -1341,6 +1341,7 @@ namespace { BasicBlock *TopBB; Instruction *TopInst; bool &modified; + LLVMContext *Context; typedef InequalityGraph::Node Node; @@ -1660,7 +1661,8 @@ namespace { Top(DTDFS->getNodeForBlock(TopBB)), TopBB(TopBB), TopInst(NULL), - modified(modified) + modified(modified), + Context(TopBB->getContext()) { assert(Top && "VRPSolver created for unreachable basic block."); } @@ -1760,7 +1762,7 @@ namespace { } break; case Instruction::Or: { // "or i32 %a, %b" EQ 0 then %a EQ 0 and %b EQ 0 - Constant *Zero = Constant::getNullValue(Ty); + Constant *Zero = Context->getNullValue(Ty); if (Canonical == Zero) { add(Zero, Op0, ICmpInst::ICMP_EQ, NewContext); add(Zero, Op1, ICmpInst::ICMP_EQ, NewContext); @@ -1783,10 +1785,10 @@ namespace { } if (Canonical == LHS) { if (isa<ConstantInt>(Canonical)) - add(RHS, Constant::getNullValue(Ty), ICmpInst::ICMP_EQ, + add(RHS, Context->getNullValue(Ty), ICmpInst::ICMP_EQ, NewContext); } else if (isRelatedBy(LHS, Canonical, ICmpInst::ICMP_NE)) { - add(RHS, Constant::getNullValue(Ty), ICmpInst::ICMP_NE, + add(RHS, Context->getNullValue(Ty), ICmpInst::ICMP_NE, NewContext); } } break; @@ -1831,10 +1833,10 @@ namespace { } // TODO: The GEPI indices are all zero. Copy from definition to operand, // jumping the type plane as needed. - if (isRelatedBy(GEPI, Constant::getNullValue(GEPI->getType()), + if (isRelatedBy(GEPI, Context->getNullValue(GEPI->getType()), ICmpInst::ICMP_NE)) { Value *Ptr = GEPI->getPointerOperand(); - add(Ptr, Constant::getNullValue(Ptr->getType()), ICmpInst::ICMP_NE, + add(Ptr, Context->getNullValue(Ptr->getType()), ICmpInst::ICMP_NE, NewContext); } } else if (CastInst *CI = dyn_cast<CastInst>(I)) { @@ -1888,7 +1890,7 @@ namespace { const Type *Ty = BO->getType(); assert(!Ty->isFPOrFPVector() && "Float in work queue!"); - Constant *Zero = Constant::getNullValue(Ty); + Constant *Zero = Context->getNullValue(Ty); Constant *One = ConstantInt::get(Ty, 1); ConstantInt *AllOnes = ConstantInt::getAllOnesValue(Ty); @@ -2110,9 +2112,9 @@ namespace { // TODO: The GEPI indices are all zero. Copy from operand to definition, // jumping the type plane as needed. Value *Ptr = GEPI->getPointerOperand(); - if (isRelatedBy(Ptr, Constant::getNullValue(Ptr->getType()), + if (isRelatedBy(Ptr, Context->getNullValue(Ptr->getType()), ICmpInst::ICMP_NE)) { - add(GEPI, Constant::getNullValue(GEPI->getType()), ICmpInst::ICMP_NE, + add(GEPI, Context->getNullValue(GEPI->getType()), ICmpInst::ICMP_NE, NewContext); } } @@ -2496,7 +2498,8 @@ namespace { void PredicateSimplifier::Forwards::visitAllocaInst(AllocaInst &AI) { VRPSolver VRP(VN, IG, UB, VR, PS->DTDFS, PS->modified, &AI); - VRP.add(Constant::getNullValue(AI.getType()), &AI, ICmpInst::ICMP_NE); + VRP.add(AI.getParent()->getContext()->getNullValue(AI.getType()), + &AI, ICmpInst::ICMP_NE); VRP.solve(); } @@ -2506,7 +2509,8 @@ namespace { if (isa<Constant>(Ptr)) return; VRPSolver VRP(VN, IG, UB, VR, PS->DTDFS, PS->modified, &LI); - VRP.add(Constant::getNullValue(Ptr->getType()), Ptr, ICmpInst::ICMP_NE); + VRP.add(LI.getParent()->getContext()->getNullValue(Ptr->getType()), + Ptr, ICmpInst::ICMP_NE); VRP.solve(); } @@ -2515,7 +2519,8 @@ namespace { if (isa<Constant>(Ptr)) return; VRPSolver VRP(VN, IG, UB, VR, PS->DTDFS, PS->modified, &SI); - VRP.add(Constant::getNullValue(Ptr->getType()), Ptr, ICmpInst::ICMP_NE); + VRP.add(SI.getParent()->getContext()->getNullValue(Ptr->getType()), + Ptr, ICmpInst::ICMP_NE); VRP.solve(); } @@ -2550,8 +2555,8 @@ namespace { case Instruction::SDiv: { Value *Divisor = BO.getOperand(1); VRPSolver VRP(VN, IG, UB, VR, PS->DTDFS, PS->modified, &BO); - VRP.add(Constant::getNullValue(Divisor->getType()), Divisor, - ICmpInst::ICMP_NE); + VRP.add(BO.getParent()->getContext()->getNullValue(Divisor->getType()), + Divisor, ICmpInst::ICMP_NE); VRP.solve(); break; } diff --git a/lib/Transforms/Scalar/Reassociate.cpp b/lib/Transforms/Scalar/Reassociate.cpp index 845c312c22..054e09d3c5 100644 --- a/lib/Transforms/Scalar/Reassociate.cpp +++ b/lib/Transforms/Scalar/Reassociate.cpp @@ -178,7 +178,7 @@ unsigned Reassociate::getRank(Value *V) { // If this is a not or neg instruction, do not count it for rank. This // assures us that X and ~X will have the same rank. if (!I->getType()->isInteger() || - (!BinaryOperator::isNot(I) && !BinaryOperator::isNeg(I))) + (!BinaryOperator::isNot(I) && !BinaryOperator::isNeg(*Context, I))) ++Rank; //DOUT << "Calculated Rank[" << V->getName() << "] = " @@ -264,12 +264,12 @@ void Reassociate::LinearizeExprTree(BinaryOperator *I, // If this is a multiply expression tree and it contains internal negations, // transform them into multiplies by -1 so they can be reassociated. if (I->getOpcode() == Instruction::Mul) { - if (!LHSBO && LHS->hasOneUse() && BinaryOperator::isNeg(LHS)) { + if (!LHSBO && LHS->hasOneUse() && BinaryOperator::isNeg(*Context, LHS)) { LHS = LowerNegateToMultiply(cast<Instruction>(LHS), ValueRankMap, Context); LHSBO = isReassociableOp(LHS, Opcode); } - if (!RHSBO && RHS->hasOneUse() && BinaryOperator::isNeg(RHS)) { + if (!RHSBO && RHS->hasOneUse() && BinaryOperator::isNeg(*Context, RHS)) { RHS = LowerNegateToMultiply(cast<Instruction>(RHS), ValueRankMap, Context); RHSBO = isReassociableOp(RHS, Opcode); @@ -373,7 +373,7 @@ void Reassociate::RewriteExprTree(BinaryOperator *I, // version of the value is returned, and BI is left pointing at the instruction // that should be processed next by the reassociation pass. // -static Value *NegateValue(Value *V, Instruction *BI) { +static Value *NegateValue(LLVMContext *Context, Value *V, Instruction *BI) { // We are trying to expose opportunity for reassociation. One of the things // that we want to do to achieve this is to push a negation as deep into an // expression chain as possible, to expose the add instructions. In practice, @@ -386,8 +386,8 @@ static Value *NegateValue(Value *V, Instruction *BI) { if (Instruction *I = dyn_cast<Instruction>(V)) if (I->getOpcode() == Instruction::Add && I->hasOneUse()) { // Push the negates through the add. - I->setOperand(0, NegateValue(I->getOperand(0), BI)); - I->setOperand(1, NegateValue(I->getOperand(1), BI)); + I->setOperand(0, NegateValue(Context, I->getOperand(0), BI)); + I->setOperand(1, NegateValue(Context, I->getOperand(1), BI)); // We must move the add instruction here, because the neg instructions do // not dominate the old add instruction in general. By moving it, we are @@ -402,14 +402,14 @@ static Value *NegateValue(Value *V, Instruction *BI) { // Insert a 'neg' instruction that subtracts the value from zero to get the // negation. // - return BinaryOperator::CreateNeg(V, V->getName() + ".neg", BI); + return BinaryOperator::CreateNeg(*Context, V, V->getName() + ".neg", BI); } /// ShouldBreakUpSubtract - Return true if we should break up this subtract of /// X-Y into (X + -Y). -static bool ShouldBreakUpSubtract(Instruction *Sub) { +static bool ShouldBreakUpSubtract(LLVMContext *Context, Instruction *Sub) { // If this is a negation, we can't split it up! - if (BinaryOperator::isNeg(Sub)) + if (BinaryOperator::isNeg(*Context, Sub)) return false; // Don't bother to break this up unless either the LHS is an associable add or @@ -431,7 +431,7 @@ static bool ShouldBreakUpSubtract(Instruction *Sub) { /// BreakUpSubtract - If we have (X-Y), and if either X is an add, or if this is /// only used by an add, transform this into (X+(0-Y)) to promote better /// reassociation. -static Instruction *BreakUpSubtract(Instruction *Sub, +static Instruction *BreakUpSubtract(LLVMContext *Context, Instruction *Sub, std::map<AssertingVH<>, unsigned> &ValueRankMap) { // Convert a subtract into an add and a neg instruction... so that sub // instructions can be commuted with other add instructions... @@ -439,7 +439,7 @@ static Instruction *BreakUpSubtract(Instruction *Sub, // Calculate the negative value of Operand 1 of the sub instruction... // and set it as the RHS of the add instruction we just made... // - Value *NegVal = NegateValue(Sub->getOperand(1), Sub); + Value *NegVal = NegateValue(Context, Sub->getOperand(1), Sub); Instruction *New = BinaryOperator::CreateAdd(Sub->getOperand(0), NegVal, "", Sub); New->takeName(Sub); @@ -663,7 +663,7 @@ Value *Reassociate::OptimizeExpression(BinaryOperator *I, for (unsigned i = 0, e = Ops.size(); i != e; ++i) { assert(i < Ops.size()); // Check for X and -X in the operand list. - if (BinaryOperator::isNeg(Ops[i].Op)) { + if (BinaryOperator::isNeg(*Context, Ops[i].Op)) { Value *X = BinaryOperator::getNegArgument(Ops[i].Op); unsigned FoundX = FindInOperandList(Ops, i, X); if (FoundX != i) { @@ -798,10 +798,10 @@ void Reassociate::ReassociateBB(BasicBlock *BB) { // If this is a subtract instruction which is not already in negate form, // see if we can convert it to X+-Y. if (BI->getOpcode() == Instruction::Sub) { - if (ShouldBreakUpSubtract(BI)) { - BI = BreakUpSubtract(BI, ValueRankMap); + if (ShouldBreakUpSubtract(Context, BI)) { + BI = BreakUpSubtract(Context, BI, ValueRankMap); MadeChange = true; - } else if (BinaryOperator::isNeg(BI)) { + } else if (BinaryOperator::isNeg(*Context, BI)) { // Otherwise, this is a negation. See if the operand is a multiply tree // and if this is not an inner node of a multiply tree. if (isReassociableOp(BI->getOperand(1), Instruction::Mul) && diff --git a/lib/Transforms/Utils/LowerInvoke.cpp b/lib/Transforms/Utils/LowerInvoke.cpp index b8e0fd88f0..2e13ed3bd8 100644 --- a/lib/Transforms/Utils/LowerInvoke.cpp +++ b/lib/Transforms/Utils/LowerInvoke.cpp @@ -251,7 +251,7 @@ bool LowerInvoke::insertCheapEHSupport(Function &F) { // Insert a return instruction. This really should be a "barrier", as it // is unreachable. ReturnInst::Create(F.getReturnType() == Type::VoidTy ? 0 : - Constant::getNullValue(F.getReturnType()), UI); + Context->getNullValue(F.getReturnType()), UI); // Remove the unwind instruction now. BB->getInstList().erase(UI); @@ -285,7 +285,7 @@ void LowerInvoke::rewriteExpensiveInvoke(InvokeInst *II, unsigned InvokeNo, BasicBlock::iterator NI = II->getNormalDest()->getFirstNonPHI(); // nonvolatile. - new StoreInst(Constant::getNullValue(Type::Int32Ty), InvokeNum, false, NI); + new StoreInst(Context->getNullValue(Type::Int32Ty), InvokeNum, false, NI); // Add a switch case to our unwind block. CatchSwitch->addCase(InvokeNoC, II->getUnwindDest()); @@ -473,7 +473,7 @@ bool LowerInvoke::insertExpensiveEHSupport(Function &F) { new AllocaInst(JBLinkTy, 0, Align, "jblink", F.begin()->begin()); std::vector<Value*> Idx; - Idx.push_back(Constant::getNullValue(Type::Int32Ty)); + Idx.push_back(Context->getNullValue(Type::Int32Ty)); Idx.push_back(ConstantInt::get(Type::Int32Ty, 1)); OldJmpBufPtr = GetElementPtrInst::Create(JmpBuf, Idx.begin(), Idx.end(), "OldBuf", EntryBB->getTerminator()); @@ -525,7 +525,7 @@ bool LowerInvoke::insertExpensiveEHSupport(Function &F) { // Compare the return value to zero. Value *IsNormal = new ICmpInst(EntryBB->getTerminator(), ICmpInst::ICMP_EQ, SJRet, - Constant::getNullValue(SJRet->getType()), + Context->getNullValue(SJRet->getType()), "notunwind"); // Nuke the uncond branch. EntryBB->getTerminator()->eraseFromParent(); @@ -559,14 +559,14 @@ bool LowerInvoke::insertExpensiveEHSupport(Function &F) { // Load the JBList, if it's null, then there was no catch! Value *NotNull = new ICmpInst(*UnwindHandler, ICmpInst::ICMP_NE, BufPtr, - Constant::getNullValue(BufPtr->getType()), + Context->getNullValue(BufPtr->getType()), "notnull"); BranchInst::Create(UnwindBlock, TermBlock, NotNull, UnwindHandler); // Create the block to do the longjmp. // Get a pointer to the jmpbuf and longjmp. std::vector<Value*> Idx; - Idx.push_back(Constant::getNullValue(Type::Int32Ty)); + Idx.push_back(Context->getNullValue(Type::Int32Ty)); Idx.push_back(ConstantInt::get(Type::Int32Ty, 0)); Idx[0] = GetElementPtrInst::Create(BufPtr, Idx.begin(), Idx.end(), "JmpBuf", UnwindBlock); diff --git a/lib/VMCore/ConstantFold.cpp b/lib/VMCore/ConstantFold.cpp index 3919643c00..1f622310df 100644 --- a/lib/VMCore/ConstantFold.cpp +++ b/lib/VMCore/ConstantFold.cpp @@ -24,6 +24,7 @@ #include "llvm/DerivedTypes.h" #include "llvm/Function.h" #include "llvm/GlobalAlias.h" +#include "llvm/LLVMContext.h" #include "llvm/ADT/SmallVector.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/ErrorHandling.h" @@ -40,7 +41,7 @@ using namespace llvm; /// BitCastConstantVector - Convert the specified ConstantVector node to the /// specified vector type. At this point, we know that the elements of the /// input vector constant are all simple integer or FP values. -static Constant *BitCastConstantVector(ConstantVector *CV, +static Constant *BitCastConstantVector(LLVMContext &Context, ConstantVector *CV, const VectorType *DstTy) { // If this cast changes element count then we can't handle it here: // doing so requires endianness information. This should be handled by @@ -60,8 +61,9 @@ static Constant *BitCastConstantVector(ConstantVector *CV, std::vector<Constant*> Result; const Type *DstEltTy = DstTy->getElementType(); for (unsigned i = 0; i != NumElts; ++i) - Result.push_back(ConstantExpr::getBitCast(CV->getOperand(i), DstEltTy)); - return ConstantVector::get(Result); + Result.push_back(Context.getConstantExprBitCast(CV->getOperand(i), + DstEltTy)); + return Context.getConstantVector(Result); } /// This function determines which opcode to use to fold two constant cast @@ -89,7 +91,8 @@ foldConstantCastPair( Type::Int64Ty); } -static Constant *FoldBitCast(Constant *V, const Type *DestTy) { +static Constant *FoldBitCast(LLVMContext &Context, + Constant *V, const Type *DestTy) { const Type *SrcTy = V->getType(); if (SrcTy == DestTy) return V; // no-op cast @@ -100,13 +103,13 @@ static Constant *FoldBitCast(Constant *V, const Type *DestTy) { if (const PointerType *DPTy = dyn_cast<PointerType>(DestTy)) if (PTy->getAddressSpace() == DPTy->getAddressSpace()) { SmallVector<Value*, 8> IdxList; - IdxList.push_back(Constant::getNullValue(Type::Int32Ty)); + IdxList.push_back(Context.getNullValue(Type::Int32Ty)); const Type *ElTy = PTy->getElementType(); while (ElTy != DPTy->getElementType()) { if (const StructType *STy = dyn_cast<StructType>(ElTy)) { if (STy->getNumElements() == 0) break; ElTy = STy->getElementType(0); - IdxList.push_back(Constant::getNullValue(Type::Int32Ty)); + IdxList.push_back(Context.getNullValue(Type::Int32Ty)); } else if (const SequentialType *STy = dyn_cast<SequentialType>(ElTy)) { if (isa<PointerType>(ElTy)) break; // Can't index into pointers! @@ -118,7 +121,8 @@ static Constant *FoldBitCast(Constant *V, const Type *DestTy) { } if (ElTy == DPTy->getElementType()) - return ConstantExpr::getGetElementPtr(V, &IdxList[0], IdxList.size()); + return Context.getConstantExprGetElementPtr(V, &IdxList[0], + IdxList.size()); } // Handle casts from one vector constant to another. We know that the src @@ -130,23 +134,24 @@ static Constant *FoldBitCast(Constant *V, const Type *DestTy) { SrcTy = NULL; // First, check for null. Undef is already handled. if (isa<ConstantAggregateZero>(V)) - return Constant::getNullValue(DestTy); + return Context.getNullValue(DestTy); if (ConstantVector *CV = dyn_cast<ConstantVector>(V)) - return BitCastConstantVector(CV, DestPTy); + return BitCastConstantVector(Context, CV, DestPTy); } // Canonicalize scalar-to-vector bitcasts into vector-to-vector bitcasts // This allows for other simplifications (although some of them // can only be handled by Analysis/ConstantFolding.cpp). if (isa<ConstantInt>(V) || isa<ConstantFP>(V)) - return ConstantExpr::getBitCast(ConstantVector::get(&V, 1), DestPTy); + return Context.getConstantExprBitCast( + Context.getConstantVector(&V, 1), DestPTy); } // Finally, implement bitcast folding now. The code below doesn't handle // bitcast right. if (isa<ConstantPointerNull>(V)) // ptr->ptr cast. - return ConstantPointerNull::get(cast<PointerType>(DestTy)); + return Context.getConstantPointerNull(cast<PointerType>(DestTy)); // Handle integral constant input. if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) { @@ -156,7 +161,7 @@ static Constant *FoldBitCast(Constant *V, const Type *DestTy) { return V; if (DestTy->isFloatingPoint()) - return ConstantFP::get(APFloat(CI->getValue(), + return Context.getConstantFP(APFloat(CI->getValue(), DestTy != Type::PPC_FP128Ty)); // Otherwise, can't fold this (vector?) @@ -166,13 +171,14 @@ static Constant *FoldBitCast(Constant *V, const Type *DestTy) { // Handle ConstantFP input. if (const ConstantFP *FP = dyn_cast<ConstantFP>(V)) // FP -> Integral. - return ConstantInt::get(FP->getValueAPF().bitcastToAPInt()); + return Context.getConstantInt(FP->getValueAPF().bitcastToAPInt()); return 0; } -Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V, +Constant *llvm::ConstantFoldCastInstruction(LLVMContext &Context, + unsigned opc, const Constant *V, const Type *DestTy) { if (isa<UndefValue>(V)) { // zext(undef) = 0, because the top bits will be zero. @@ -180,8 +186,8 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V, // [us]itofp(undef) = 0, because the result value is bounded. if (opc == Instruction::ZExt || opc == Instruction::SExt || opc == Instruction::UIToFP || opc == Instruction::SIToFP) - return Constant::getNullValue(DestTy); - return UndefValue::get(DestTy); + return Context.getNullValue(DestTy); + return Context.getUndef(DestTy); } // No compile-time operations on this type yet. if (V->getType() == Type::PPC_FP128Ty || DestTy == Type::PPC_FP128Ty) @@ -193,7 +199,7 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V, if (CE->isCast()) { // Try hard to fold cast of cast because they are often eliminable. if (unsigned newOpc = foldConstantCastPair(opc, CE, DestTy)) - return ConstantExpr::getCast(newOpc, CE->getOperand(0), DestTy); + return Context.getConstantExprCast(newOpc, CE->getOperand(0), DestTy); } else if (CE->getOpcode() == Instruction::GetElementPtr) { // If all of the indexes in the GEP are null values, there is no pointer // adjustment going on. We might as well cast the source pointer. @@ -205,7 +211,7 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V, } if (isAllNull) // This is casting one pointer type to another, always BitCast - return ConstantExpr::getPointerCast(CE->getOperand(0), DestTy); + return Context.getConstantExprPointerCast(CE->getOperand(0), DestTy); } } @@ -220,9 +226,9 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V, const VectorType *DestVecTy = cast<VectorType>(DestTy); const Type *DstEltTy = DestVecTy->getElementType(); for (unsigned i = 0, e = CV->getType()->getNumElements(); i != e; ++i) - res.push_back(ConstantExpr::getCast(opc, + res.push_back(Context.getConstantExprCast(opc, CV->getOperand(i), DstEltTy)); - return ConstantVector::get(DestVecTy, res); + return Context.getConstantVector(DestVecTy, res); } // We actually have to do a cast now. Perform the cast according to the @@ -239,7 +245,7 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V, DestTy == Type::FP128Ty ? APFloat::IEEEquad : APFloat::Bogus, APFloat::rmNearestTiesToEven, &ignored); - return ConstantFP::get(Val); + return Context.getConstantFP(Val); } return 0; // Can't fold. case Instruction::FPToUI: @@ -252,16 +258,16 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V, (void) V.convertToInteger(x, DestBitWidth, opc==Instruction::FPToSI, APFloat::rmTowardZero, &ignored); APInt Val(DestBitWidth, 2, x); - return ConstantInt::get(Val); + return Context.getConstantInt(Val); } return 0; // Can't fold. case Instruction::IntToPtr: //always treated as unsigned if (V->isNullValue()) // Is it an integral null value? - return ConstantPointerNull::get(cast<PointerType>(DestTy)); + return Context.getConstantPointerNull(cast<PointerType>(DestTy)); return 0; // Other pointer types cannot be casted case Instruction::PtrToInt: // always treated as unsigned if (V->isNullValue()) // is it a null pointer value? - return ConstantInt::get(DestTy, 0); + return Context.getConstantInt(DestTy, 0); return 0; // Other pointer types cannot be casted case Instruction::UIToFP: case Instruction::SIToFP: @@ -273,7 +279,7 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V, (void)apf.convertFromAPInt(api, opc==Instruction::SIToFP, APFloat::rmNearestTiesToEven); - return ConstantFP::get(apf); + return Context.getConstantFP(apf); } return 0; case Instruction::ZExt: @@ -281,7 +287,7 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V, uint32_t BitWidth = cast<IntegerType>(DestTy)->getBitWidth(); APInt Result(CI->getValue()); Result.zext(BitWidth); - return ConstantInt::get(Result); + return Context.getConstantInt(Result); } return 0; case Instruction::SExt: @@ -289,7 +295,7 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V, uint32_t BitWidth = cast<IntegerType>(DestTy)->getBitWidth(); APInt Result(CI->getValue()); Result.sext(BitWidth); - return ConstantInt::get(Result); + return Context.getConstantInt(Result); } return 0; case Instruction::Trunc: @@ -297,11 +303,11 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V, uint32_t BitWidth = cast<IntegerType>(DestTy)->getBitWidth(); APInt Result(CI->getValue()); Result.trunc(BitWidth); - return ConstantInt::get(Result); + return Context.getConstantInt(Result); } return 0; case Instruction::BitCast: - return FoldBitCast(const_cast<Constant*>(V), DestTy); + return FoldBitCast(Context, const_cast<Constant*>(V), DestTy); default: assert(!"Invalid CE CastInst opcode"); break; @@ -311,7 +317,8 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V, return 0; } -Constant *llvm::ConstantFoldSelectInstruction(const Constant *Cond, +Constant *llvm::ConstantFoldSelectInstruction(LLVMContext&, + const Constant *Cond, const Constant *V1, const Constant *V2) { if (const ConstantInt *CB = dyn_cast<ConstantInt>(Cond)) @@ -324,12 +331,13 @@ Constant *llvm::ConstantFoldSelectInstruction(const Constant *Cond, return 0; } -Constant *llvm::ConstantFoldExtractElementInstruction(const Constant *Val, +Constant *llvm::ConstantFoldExtractElementInstruction(LLVMContext &Context, + const Constant *Val, const Constant *Idx) { if (isa<UndefValue>(Val)) // ee(undef, x) -> undef - return UndefValue::get(cast<VectorType>(Val->getType())->getElementType()); + return Context.getUndef(cast<VectorType>(Val->getType())->getElementType()); if (Val->isNullValue()) // ee(zero, x) -> zero - return Constant::getNullValue( + return Context.getNullValue( cast<VectorType>(Val->getType())->getElementType()); if (const ConstantVector *CVal = dyn_cast<ConstantVector>(Val)) { @@ -343,7 +351,8 @@ Constant *llvm::ConstantFoldExtractElementInstruction(const Constant *Val, return 0; } -Constant *llvm::ConstantFoldInsertElementInstruction(const Constant *Val, +Constant *llvm::ConstantFoldInsertElementInstruction(LLVMContext &Context, + const Constant *Val, const Constant *Elt, const Constant *Idx) { const ConstantInt *CIdx = dyn_cast<ConstantInt>(Idx); @@ -362,10 +371,10 @@ Constant *llvm::ConstantFoldInsertElementInstruction(const Constant *Val, Ops.reserve(numOps); for (unsigned i = 0; i < numOps; ++i) { const Constant *Op = - (idxVal == i) ? Elt : UndefValue::get(Elt->getType()); + (idxVal == i) ? Elt : Context.getUndef(Elt->getType()); Ops.push_back(const_cast<Constant*>(Op)); } - return ConstantVector::get(Ops); + return Context.getConstantVector(Ops); } if (isa<ConstantAggregateZero>(Val)) { // Insertion of scalar constant into vector aggregate zero @@ -380,10 +389,10 @@ Constant *llvm::ConstantFoldInsertElementInstruction(const Constant *Val, Ops.reserve(numOps); for (unsigned i = 0; i < numOps; ++i) { const Constant *Op = - (idxVal == i) ? Elt : Constant::getNullValue(Elt->getType()); + (idxVal == i) ? Elt : Context.getNullValue(Elt->getType()); Ops.push_back(const_cast<Constant*>(Op)); } - return ConstantVector::get(Ops); + return Context.getConstantVector(Ops); } if (const ConstantVector *CVal = dyn_cast<ConstantVector>(Val)) { // Insertion of scalar constant into vector constant @@ -394,7 +403,7 @@ Constant *llvm::ConstantFoldInsertElementInstruction(const Constant *Val, (idxVal == i) ? Elt : cast<Constant>(CVal->getOperand(i)); Ops.push_back(const_cast<Constant*>(Op)); } - return ConstantVector::get(Ops); + return Context.getConstantVector(Ops); } return 0; @@ -402,23 +411,25 @@ Constant *llvm::ConstantFoldInsertElementInstruction(const Constant *Val, /// GetVectorElement - If C is a ConstantVector, ConstantAggregateZero or Undef /// return the specified element value. Otherwise return null. -static Constant *GetVectorElement(const Constant *C, unsigned EltNo) { +static Constant *GetVectorElement(LLVMContext &Context, const Constant *C, + unsigned EltNo) { if (const ConstantVector *CV = dyn_cast<ConstantVector>(C)) return CV->getOperand(EltNo); const Type *EltTy = cast<VectorType>(C->getType())->getElementType(); if (isa<ConstantAggregateZero>(C)) - return Constant::getNullValue(EltTy); + return Context.getNullValue(EltTy); if (isa<UndefValue>(C)) - return UndefValue::get(EltTy); + return Context.getUndef(EltTy); return 0; } -Constant *llvm::ConstantFoldShuffleVectorInstruction(const Constant *V1, +Constant *llvm::ConstantFoldShuffleVectorInstruction(LLVMContext &Context, + const Constant *V1, const Constant *V2, const Constant *Mask) { // Undefined shuffle mask -> undefined value. - if (isa<UndefValue>(Mask)) return UndefValue::get(V1->getType()); + if (isa<UndefValue>(Mask)) return Context.getUndef(V1->getType()); unsigned MaskNumElts = cast<VectorType>(Mask->getType())->getNumElements(); unsigned SrcNumElts = cast<VectorType>(V1->getType())->getNumElements(); @@ -427,19 +438,19 @@ Constant *llvm::ConstantFoldShuffleVectorInstruction(const Constant *V1, // Loop over the shuffle mask, evaluating each element. SmallVector<Constant*, 32> Result; for (unsigned i = 0; i != MaskNumElts; ++i) { - Constant *InElt = GetVectorElement(Mask, i); + Constant *InElt = GetVectorElement(Context, Mask, i); if (InElt == 0) return 0; if (isa<UndefValue>(InElt)) - InElt = UndefValue::get(EltTy); + InElt = Context.getUndef(EltTy); else if (ConstantInt *CI = dyn_cast<ConstantInt>(InElt)) { unsigned Elt = CI->getZExtValue(); if (Elt >= SrcNumElts*2) - InElt = UndefValue::get(EltTy); + InElt = Context.getUndef(EltTy); else if (Elt >= SrcNumElts) - InElt = GetVectorElement(V2, Elt - SrcNumElts); + InElt = GetVectorElement(Context, V2, Elt - SrcNumElts); else - InElt = GetVectorElement(V1, Elt); + InElt = GetVectorElement(Context, V1, Elt); if (InElt == 0) return 0; } else { // Unknown value. @@ -448,10 +459,11 @@ Constant *llvm::ConstantFoldShuffleVectorInstruction(const Constant *V1, Result.push_back(InElt); } - return ConstantVector::get(&Result[0], Result.size()); + return Context.getConstantVector(&Result[0], Result.size()); } -Constant *llvm::ConstantFoldExtractValueInstruction(const Constant *Agg, +Constant *llvm::ConstantFoldExtractValueInstruction(LLVMContext &Context, + const Constant *Agg, const unsigned *Idxs, unsigned NumIdx) { // Base case: no indices, so return the entire value. @@ -459,22 +471,23 @@ Constant *llvm::ConstantFoldExtractValueInstruction(const Constant *Agg, return const_cast<Constant *>(Agg); if (isa<UndefValue>(Agg)) // ev(undef, x) -> undef - return UndefValue::get(ExtractValueInst::getIndexedType(Agg->getType(), + return Context.getUndef(ExtractValueInst::getIndexedType(Agg->getType(), Idxs, Idxs + NumIdx)); if (isa<ConstantAggregateZero>(Agg)) // ev(0, x) -> 0 return - Constant::getNullValue(ExtractValueInst::getIndexedType(Agg->getType(), + Context.getNullValue(ExtractValueInst::getIndexedType(Agg->getType(), Idxs, Idxs + NumIdx)); // Otherwise recurse. - return ConstantFoldExtractValueInstruction(Agg->getOperand(*Idxs), + return ConstantFoldExtractValueInstruction(Context, Agg->getOperand(*Idxs), Idxs+1, NumIdx-1); } -Constant *llvm::ConstantFoldInsertValueInstruction(const Constant *Agg, +Constant *llvm::ConstantFoldInsertValueInstruction(LLVMContext &Context, + const Constant *Agg, const Constant *Val, const unsigned *Idxs, unsigned NumIdx) { @@ -500,15 +513,15 @@ Constant *llvm::ConstantFoldInsertValueInstruction(const Constant *Agg, const Type *MemberTy = AggTy->getTypeAtIndex(i); const Constant *Op = (*Idxs == i) ? - ConstantFoldInsertValueInstruction(UndefValue::get(MemberTy), + ConstantFoldInsertValueInstruction(Context, Context.getUndef(MemberTy), Val, Idxs+1, NumIdx-1) : - UndefValue::get(MemberTy); + Context.getUndef(MemberTy); Ops[i] = const_cast<Constant*>(Op); } if (isa<StructType>(AggTy)) - return ConstantStruct::get(Ops); + return Context.getConstantStruct(Ops); else - return ConstantArray::get(cast<ArrayType>(AggTy), Ops); + return Context.getConstantArray(cast<ArrayType>(AggTy), Ops); } if (isa<ConstantAggregateZero>(Agg)) { // Insertion of constant into aggregate zero @@ -528,15 +541,16 @@ Constant *llvm::ConstantFoldInsertValueInstruction(const Constant *Agg, const Type *MemberTy = AggTy->getTypeAtIndex(i); const Constant *Op = (*Idxs == i) ? - ConstantFoldInsertValueInstruction(Constant::getNullValue(MemberTy), + ConstantFoldInsertValueInstruction(Context, + Context.getNullValue(MemberTy), Val, Idxs+1, NumIdx-1) : - Constant::getNullValue(MemberTy); + Context.getNullValue(MemberTy); Ops[i] = const_cast<Constant*>(Op); } if (isa<StructType>(AggTy)) - return ConstantStruct::get(Ops); + return Context.getConstantStruct(Ops); else - return ConstantArray::get(cast<ArrayType>(AggTy), Ops); + return Context.getConstantArray(cast<ArrayType>(AggTy), Ops); } if (isa<ConstantStruct>(Agg) || isa<ConstantArray>(Agg)) { // Insertion of constant into aggregate constant @@ -544,16 +558,16 @@ Constant *llvm::ConstantFoldInsertValueInstruction(const Constant *Agg, for (unsigned i = 0; i < Agg->getNumOperands(); ++i) { const Constant *Op = (*Idxs == i) ? - ConstantFoldInsertValueInstruction(Agg->getOperand(i), + ConstantFoldInsertValueInstruction(Context, Agg->getOperand(i), Val, Idxs+1, NumIdx-1) : Agg->getOperand(i); Ops[i] = const_cast<Constant*>(Op); } Constant *C; if (isa<StructType>(Agg->getType())) - C = ConstantStruct::get(Ops); + C = Context.getConstantStruct(Ops); else - C = ConstantArray::get(cast<ArrayType>(Agg->getType()), Ops); + C = Context.getConstantArray(cast<ArrayType>(Agg->getType()), Ops); return C; } @@ -564,22 +578,23 @@ Constant *llvm::ConstantFoldInsertValueInstruction(const Constant *Agg, /// function pointer to each element pair, producing a new ConstantVector /// constant. Either or both of V1 and V2 may be NULL, meaning a /// ConstantAggregateZero operand. -static Constant *EvalVectorOp(const ConstantVector *V1, +static Constant *EvalVectorOp(LLVMContext &Context, const ConstantVector *V1, const ConstantVector *V2, const VectorType *VTy, Constant *(*FP)(Constant*, Constant*)) { std::vector<Constant*> Res; const Type *EltTy = VTy->getElementType(); for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) { - const Constant *C1 = V1 ? V1->getOperand(i) : Constant::getNullValue(EltTy); - const Constant *C2 = V2 ? V2->getOperand(i) : Constant::getNullValue(EltTy); + const Constant *C1 = V1 ? V1->getOperand(i) : Context.getNullValue(EltTy); + const Constant *C2 = V2 ? V2->getOperand(i) : Context.getNullValue(EltTy); Res.push_back(FP(const_cast<Constant*>(C1), const_cast<Constant*>(C2))); } - return ConstantVector::get(Res); + return Context.getConstantVector(Res); } -Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode, +Constant *llvm::ConstantFoldBinaryInstruction(LLVMContext &Context, + unsigned Opcode, const Constant *C1, const Constant *C2) { // No compile-time operations on this type yet. @@ -593,29 +608,29 @@ Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode, if (isa<UndefValue>(C1) && isa<UndefValue>(C2)) // Handle undef ^ undef -> 0 special case. This is a common // idiom (misuse). - return Constant::getNullValue(C1->getType()); + return Context.getNullValue(C1->getType()); // Fallthrough case Instruction::Add: case Instruction::Sub: - return UndefValue::get(C1->getType()); + return Context.getUndef(C1->getType()); case Instruction::Mul: case Instruction::And: - return Constant::getNullValue(C1->getType()); + return Context.getNullValue(C1->getType()); case Instruction::UDiv: case Instruction::SDiv: case Instruction::URem: case Instruction::SRem: if (!isa<UndefValue>(C2)) // undef / X -> 0 - return Constant::getNullValue(C1->getType()); + return Context.getNullValue(C1->getType()); return const_cast<Constant*>(C2); // X / undef -> undef case Instruction::Or: // X | undef -> -1 if (const VectorType *PTy = dyn_cast<VectorType>(C1->getType())) - return ConstantVector::getAllOnesValue(PTy); - return ConstantInt::getAllOnesValue(C1->getType()); + return Context.getAllOnesValue(PTy); + return Context.getAllOnesValue(C1->getType()); case Instruction::LShr: if (isa<UndefValue>(C2) && isa<UndefValue>(C1)) return const_cast<Constant*>(C1); // undef lshr undef -> undef - return Constant::getNullValue(C1->getType()); // X lshr undef -> 0 + return Context.getNullValue(C1->getType()); // X lshr undef -> 0 // undef lshr X -> 0 case Instruction::AShr: if (!isa<UndefValue>(C2)) @@ -626,7 +641,7 @@ Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode, return const_cast<Constant*>(C1); // X ashr undef --> X case Instruction::Shl: // undef << X -> 0 or X << undef -> 0 - return Constant::getNullValue(C1->getType()); + return Context.getNullValue(C1->getType()); } } @@ -649,14 +664,14 @@ Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode, if (CI2->equalsInt(1)) return const_cast<Constant*>(C1); // X / 1 == X if (CI2->equalsInt(0)) - return UndefValue::get(CI2->getType()); // X / 0 == undef + return Context.getUndef(CI2->getType()); // X / 0 == undef break; case Instruction::URem: case Instruction::SRem: if (CI2->equalsInt(1)) - return Constant::getNullValue(CI2->getType()); // X % 1 == 0 + return Context.getNullValue(CI2->getType()); // X % 1 == 0 if (CI2->equalsInt(0)) - return UndefValue::get(CI2->getType()); // X % 0 == undef + return Context.getUndef(CI2->getType()); // X % 0 == undef break; case Instruction::And: if (CI2->isZero()) return const_cast<Constant*>(C2); // X & 0 == 0 @@ -691,7 +706,7 @@ Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode, // If checking bits we know are clear, return zero. if ((CI2->getValue() & BitsNotSet) == CI2->getValue()) - return Constant::getNullValue(CI2->getType()); + return Context.getNullValue(CI2->getType()); } } } @@ -708,8 +723,8 @@ Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode, // ashr (zext C to Ty), C2 -> lshr (zext C, CSA), C2 if (const ConstantExpr *CE1 = dyn_cast<ConstantExpr>(C1)) if (CE1->getOpcode() == Instruction::ZExt) // Top bits known zero. - return ConstantExpr::getLShr(const_cast<Constant*>(C1), - const_cast<Constant*>(C2)); + return Context.getConstantExprLShr(const_cast<Constant*>(C1), + const_cast<Constant*>(C2)); break; } } @@ -724,53 +739,53 @@ Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode, default: break; case Instruction::Add: - return ConstantInt::get(C1V + C2V); + return Context.getConstantInt(C1V + C2V); case Instruction::Sub: - return ConstantInt::get(C1V - C2V); + return Context.getConstantInt(C1V - C2V); case Instruction::Mul: - return ConstantInt::get(C1V * C2V); + return Context.getConstantInt(C1V * C2V); case Instruction::UDiv: assert(!CI2->isNullValue() && "Div by zero handled above"); - return ConstantInt::get(C1V.udiv(C2V)); + return Context.getConstantInt(C1V.udiv(C2V)); case Instruction::SDiv: assert(!CI2->isNullValue() && "Div by zero handled above"); if (C2V.isAllOnesValue() && C1V.isMinSignedValue()) - return UndefValue::get(CI1->getType()); // MIN_INT / -1 -> undef - return ConstantInt::get(C1V.sdiv(C2V)); + return Context.getUndef(CI1->getType()); // MIN_INT / -1 -> undef + return Context.getConstantInt(C1V.sdiv(C2V)); case Instruction::URem: assert(!CI2->isNullValue() && "Div by zero handled above"); - return ConstantInt::get(C1V.urem(C2V)); + return Context.getConstantInt(C1V.urem(C2V)); case Instruction::SRem: assert(!CI2->isNullValue() && "Div by zero handled above"); if (C2V.isAllOnesValue() && C1V.isMinSignedValue()) - return UndefValue::get(CI1->getType()); // MIN_INT % -1 -> undef - return ConstantInt::get(C1V.srem(C2V)); + return Context.getUndef(CI1->getType()); // MIN_INT % -1 -> undef + return Context.getConstantInt(C1V.srem(C2V)); case Instruction::And: - return ConstantInt::get(C1V & C2V); + return Context.getConstantInt(C1V & C2V); case Instruction::Or: - return ConstantInt::get(C1V | C2V); + return Context.getConstantInt(C1V | C2V); case Instruction::Xor: - return ConstantInt::get(C1V ^ C2V); + return Context.getConstantInt(C1V ^ C2V); case Instruction::Shl: { uint32_t shiftAmt = C2V.getZExtValue(); if (shiftAmt < C1V.getBitWidth()) - return ConstantInt::get(C1V.shl(shiftAmt)); + return Context.getConstantInt(C1V.shl(shiftAmt)); else - return UndefValue::get(C1->getType()); // too big shift is undef + return Context.getUndef(C1->getType()); // too big shift is undef } case Instruction::LShr: { uint32_t shiftAmt = C2V.getZExtValue(); if (shiftAmt < C1V.getBitWidth()) - return ConstantInt::get(C1V.lshr(shiftAmt)); + return Context.getConstantInt(C1V.lshr(shiftAmt)); else - return UndefValue::get(C1->getType()); // too big shift is undef + return Context.getUndef(C1->getType()); // too big shift is undef } case Instruction::AShr: { uint32_t shiftAmt = C2V.getZExtValue(); if (shiftAmt < C1V.getBitWidth()) - return ConstantInt::get(C1V.ashr(shiftAmt)); + return Context.getConstantInt(C1V.ashr(shiftAmt)); else - return UndefValue::get(C1->getType()); // too big shift is undef + return Context.getUndef(C1->getType()); // too big shift is undef } } } @@ -798,19 +813,19 @@ Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode, break; case Instruction::FAdd: (void)C3V.add(C2V, APFloat::rmNearestTiesToEven); - return ConstantFP::get(C3V); + return Context.getConstantFP(C3V); case Instruction::FSub: (void)C3V.subtract(C2V, APFloat::rmNearestTiesToEven); - return ConstantFP::get(C3V); + return Context.getConstantFP(C3V); case Instruction::FMul: (void)C3V.multiply(C2V, APFloat::rmNearestTiesToEven); - return ConstantFP::get(C3V); + return Context.getConstantFP(C3V); case Instruction::FDiv: (void)C3V.divide(C2V, APFloat::rmNearestTiesToEven); - return ConstantFP::get(C3V); + return Context.getConstantFP(C3V); case Instruction::FRem: (void)C3V.mod(C2V, APFloat::rmNearestTiesToEven); - return ConstantFP::get(C3V); + return Context.getConstantFP(C3V); } } } else if (const VectorType *VTy = dyn_cast<VectorType>(C1->getType())) { @@ -822,41 +837,41 @@ Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode, default: break; case Instruction::Add: - return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getAdd); + return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getAdd); case Instruction::FAdd: - return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getFAdd); + return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getFAdd); case Instruction::Sub: - return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getSub); + return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getSub); case Instruction::FSub: - return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getFSub); + return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getFSub); case Instruction::Mul: - return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getMul); + return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getMul); case Instruction::FMul: - return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getFMul); + return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getFMul); case Instruction::UDiv: - return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getUDiv); + return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getUDiv); case Instruction::SDiv: - return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getSDiv); + return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getSDiv); case Instruction::FDiv: - return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getFDiv); + return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getFDiv); case Instruction::URem: - return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getURem); + return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getURem); case Instruction::SRem: - return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getSRem); + return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getSRem); case Instruction::FRem: - return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getFRem); + return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getFRem); case Instruction::And: - return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getAnd); + return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getAnd); case Instruction::Or: - return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getOr); + return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getOr); case Instruction::Xor: - return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getXor); + return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getXor); case Instruction::LShr: - return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getLShr); + return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getLShr); case Instruction::AShr: - return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getAShr); + return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getAShr); case Instruction::Shl: - return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getShl); + return EvalVectorOp(Context, CP1, CP2, VTy, ConstantExpr::getShl); } } } @@ -877,7 +892,7 @@ Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode, case Instruction::Or: case Instruction::Xor: // No change of opcode required. - return ConstantFoldBinaryInstruction(Opcode, C2, C1); + return ConstantFoldBinaryInstruction(Context, Opcode, C2, C1); case Instruction::Shl: case Instruction::LShr: @@ -923,7 +938,8 @@ static bool isMaybeZeroSizedType(const Type *Ty) { /// first is less than the second, return -1, if the second is less than the /// first, return 1. If the constants are not integral, return -2. /// -static int IdxCompare(Constant *C1, Constant *C2, const Type *ElTy) { +static int IdxCompare(LLVMContext &Context, Constant *C1, Constant *C2, + const Type *ElTy) { if (C1 == C2) return 0; // Ok, we found a different index. If they are not ConstantInt, we can't do @@ -934,10 +950,10 @@ static int IdxCompare(Constant *C1, Constant *C2, const Type *ElTy) { // Ok, we have two differing integer indices. Sign extend them to be the same // type. Long is always big enough, so we use it. if (C1->getType() != Type::Int64Ty) - C1 = ConstantExpr::getSExt(C1, Type::Int64Ty); + C1 = Context.getConstantExprSExt(C1, Type::Int64Ty); if (C2->getType() != Type::Int64Ty) - C2 = ConstantExpr::getSExt(C2, Type::Int64Ty); + C2 = Context.getConstantExprSExt(C2, Type::Int64Ty); if (C1 == C2) return 0; // They are equal @@ -966,7 +982,8 @@ static int IdxCompare(Constant *C1, Constant *C2, const Type *ElTy) { /// To simplify this code we canonicalize the relation so that the first /// operand is always the most "complex" of the two. We consider ConstantFP /// to be the simplest, and ConstantExprs to be the most complex. -static FCmpInst::Predicate evaluateFCmpRelation(const Constant *V1, +static FCmpInst::Predicate evaluateFCmpRelation(LLVMContext &Context, + const Constant *V1, const Constant *V2) { assert(V1->getType() == V2->getType() && "Cannot compare values of different types!"); @@ -985,15 +1002,15 @@ static FCmpInst::Predicate evaluateFCmpRelation(const Constant *V1, Constant *C1 = const_cast<Constant*>(V1); Constant *C2 = const_cast<Constant*>(V2); R = dyn_cast<ConstantInt>( - ConstantExpr::getFCmp(FCmpInst::FCMP_OEQ, C1, C2)); + Context.getConstantExprFCmp(FCmpInst::FCMP_OEQ, C1, C2)); if (R && !R->isZero()) return FCmpInst::FCMP_OEQ; R = dyn_cast<ConstantInt>( - ConstantExpr::getFCmp(FCmpInst::FCMP_OLT, C1, C2)); + Context.getConstantExprFCmp(FCmpInst::FCMP_OLT, C1, C2)); if (R && !R->isZero()) return FCmpInst::FCMP_OLT; R = dyn_cast<ConstantInt>( - ConstantExpr::getFCmp(FCmpInst::FCMP_OGT, C1, C2)); + Context.getConstantExprFCmp(FCmpInst::FCMP_OGT, C1, C2)); if (R && !R->isZero()) return FCmpInst::FCMP_OGT; @@ -1002,7 +1019,7 @@ static FCmpInst::Predicate evaluateFCmpRelation(const Constant *V1, } // If the first operand is simple and second is ConstantExpr, swap operands. - FCmpInst::Predicate SwappedRelation = evaluateFCmpRelation(V2, V1); + FCmpInst::Predicate SwappedRelation = evaluateFCmpRelation(Context, V2, V1); if (SwappedRelation != FCmpInst::BAD_FCMP_PREDICATE) return FCmpInst::getSwappedPredicate(SwappedRelation); } else { @@ -1037,7 +1054,8 @@ static FCmpInst::Predicate evaluateFCmpRelation(const Constant *V1, /// constants (like ConstantInt) to be the simplest, followed by /// GlobalValues, followed by ConstantExpr's (the most complex). /// -static ICmpInst::Predicate evaluateICmpRelation(const Constant *V1, +static ICmpInst::Predicate evaluateICmpRelation(LLVMContext &Context, + const Constant *V1, const Constant *V2, bool isSigned) { assert(V1->getType() == V2->getType() && @@ -1052,15 +1070,15 @@ static ICmpInst::Predicate evaluateICmpRelation(const Constant *V1, Constant *C1 = const_cast<Constant*>(V1); Constant *C2 = const_cast<Constant*>(V2); ICmpInst::Predicate pred = ICmpInst::ICMP_EQ; - R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, C1, C2)); + R = dyn_cast<ConstantInt>(Context.getConstantExprICmp(pred, C1, C2)); if (R && !R->isZero()) return pred; pred = isSigned ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT; - R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, C1, C2)); + R = dyn_cast<ConstantInt>(Context.getConstantExprICmp(pred, C1, C2)); if (R && !R->isZero()) return pred; pred = isSigned ? ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT; - R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, C1, C2)); + R = dyn_cast<ConstantInt>(Context.getConstantExprICmp(pred, C1, C2)); if (R && !R->isZero()) return pred; @@ -1070,14 +1088,14 @@ static ICmpInst::Predicate evaluateICmpRelation(const Constant *V1, // If the first operand is simple, swap operands. ICmpInst::Predicate SwappedRelation = - evaluateICmpRelation(V2, V1, isSigned); + evaluateICmpRelation(Context, V2, V1, isSigned); if (SwappedRelation != ICmpInst::BAD_ICMP_PREDICATE) return ICmpInst::getSwappedPredicate(SwappedRelation); } else if (const GlobalValue *CPR1 = dyn_cast<GlobalValue>(V1)) { if (isa<ConstantExpr>(V2)) { // Swap as necessary. ICmpInst::Predicate SwappedRelation = - evaluateICmpRelation(V2, V1, isSigned); + evaluateICmpRelation(Context, V2, V1, isSigned); if (SwappedRelation != ICmpInst::BAD_ICMP_PREDICATE) return ICmpInst::getSwappedPredicate(SwappedRelation); else @@ -1123,8 +1141,8 @@ static ICmpInst::Predicate evaluateICmpRelation(const Constant *V1, bool sgnd = isSigned; if (CE1->getOpcode() == Instruction::ZExt) isSigned = false; if (CE1->getOpcode() == Instruction::SExt) isSigned = true; - return evaluateICmpRelation(CE1Op0, - Constant::getNullValue(CE1Op0->getType()), + return evaluateICmpRelation(Context, CE1Op0, + Context.getNullValue(CE1Op0->getType()), sgnd); } @@ -1139,8 +1157,8 @@ static ICmpInst::Predicate evaluateICmpRelation(const Constant *V1, bool sgnd = isSigned; if (CE1->getOpcode() == Instruction::ZExt) isSigned = false; if (CE1->getOpcode() == Instruction::SExt) isSigned = true; - return evaluateICmpRelation(CE1->getOperand(0), CE2->getOperand(0), - sgnd); + return evaluateICmpRelation(Context, CE1->getOperand(0), + CE2->getOperand(0), sgnd); } break; @@ -1219,8 +1237,8 @@ static ICmpInst::Predicate evaluateICmpRelation(const Constant *V1, gep_type_iterator GTI = gep_type_begin(CE1); for (;i != CE1->getNumOperands() && i != CE2->getNumOperands(); ++i, ++GTI) - switch (IdxCompare(CE1->getOperand(i), CE2->getOperand(i), - GTI.getIndexedType())) { + switch (IdxCompare(Context, CE1->getOperand(i), + CE2->getOperand(i), GTI.getIndexedType())) { case -1: return isSigned ? ICmpInst::ICMP_SLT:ICmpInst::ICMP_ULT; case 1: return isSigned ? ICmpInst::ICMP_SGT:ICmpInst::ICMP_UGT; case -2: return ICmpInst::BAD_ICMP_PREDICATE; @@ -1255,25 +1273,26 @@ static ICmpInst::Predicate evaluateICmpRelation(const Constant *V1, return ICmpInst::BAD_ICMP_PREDICATE; } -Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred, +Constant *llvm::ConstantFoldCompareInstruction(LLVMContext &Context, + unsigned short pred, const Constant *C1, const Constant *C2) { const Type *ResultTy; if (const VectorType *VT = dyn_cast<VectorType>(C1->getType())) - ResultTy = VectorType::get(Type::Int1Ty, VT->getNumElements()); + ResultTy = Context.getVectorType(Type::Int1Ty, VT->getNumElements()); else ResultTy = Type::Int1Ty; // Fold FCMP_FALSE/FCMP_TRUE unconditionally. if (pred == FCmpInst::FCMP_FALSE) - return Constant::getNullValue(ResultTy); + return Context.getNullValue(ResultTy); if (pred == FCmpInst::FCMP_TRUE) - return Constant::getAllOnesValue(ResultTy); + return Context.getAllOnesValue(ResultTy); // Handle some degenerate cases first if (isa<UndefValue>(C1) || isa<UndefValue>(C2)) - return UndefValue::get(ResultTy); + return Context.getUndef(ResultTy); // No compile-time operations on this type yet. if (C1->getType() == Type::PPC_FP128Ty) @@ -1285,9 +1304,9 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred, // Don't try to evaluate aliases. External weak GV can be null. if (!isa<GlobalAlias>(GV) && !GV->hasExternalWeakLinkage()) { if (pred == ICmpInst::ICMP_EQ) - return ConstantInt::getFalse(); + return Context.getConstantIntFalse(); else if (pred == ICmpInst::ICMP_NE) - return ConstantInt::getTrue(); + return Context.getConstantIntTrue(); } // icmp eq/ne(GV,null) -> false/true } else if (C2->isNullValue()) { @@ -1295,9 +1314,9 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred, // Don't try to evaluate aliases. External weak GV can be null. if (!isa<GlobalAlias>(GV) && !GV->hasExternalWeakLinkage()) { if (pred == ICmpInst::ICMP_EQ) - return ConstantInt::getFalse(); + return Context.getConstantIntFalse(); else if (pred == ICmpInst::ICMP_NE) - return ConstantInt::getTrue(); + return Context.getConstantIntTrue(); } } @@ -1306,16 +1325,26 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred, APInt V2 = cast<ConstantInt>(C2)->getValue(); switch (pred) { default: LLVM_UNREACHABLE("Invalid ICmp Predicate"); return 0; - case ICmpInst::ICMP_EQ: return ConstantInt::get(Type::Int1Ty, V1 == V2); - case ICmpInst::ICMP_NE: return ConstantInt::get(Type::Int1Ty, V1 != V2); - case ICmpInst::ICMP_SLT:return ConstantInt::get(Type::Int1Ty, V1.slt(V2)); - case ICmpInst::ICMP_SGT:return ConstantInt::get(Type::Int1Ty, V1.sgt(V2)); - case ICmpInst::ICMP_SLE:return ConstantInt::get(Type::Int1Ty, V1.sle(V2)); - case ICmpInst::ICMP_SGE:return ConstantInt::get(Type::Int1Ty, V1.sge(V2)); - case ICmpInst::ICMP_ULT:return ConstantInt::get(Type::Int1Ty, V1.ult(V2)); - case ICmpInst::ICMP_UGT:return ConstantInt::get(Type::Int1Ty, V1.ugt(V2)); - case ICmpInst::ICMP_ULE:return ConstantInt::get(Type::Int1Ty, V1.ule(V2)); - case ICmpInst::ICMP_UGE:return ConstantInt::get(Type::Int1Ty, V1.uge(V2)); + case ICmpInst::ICMP_EQ: + return Context.getConstantInt(Type::Int1Ty, V1 == V2); + case ICmpInst::ICMP_NE: + return Context.getConstantInt(Type::Int1Ty, V1 != V2); + case ICmpInst::ICMP_SLT: + return Context.getConstantInt(Type::Int1Ty, V1.slt(V2)); + case ICmpInst::ICMP_SGT: + return Context.getConstantInt(Type::Int1Ty, V1.sgt(V2)); + case ICmpInst::ICMP_SLE: + return Context.getConstantInt(Type::Int1Ty, V1.sle(V2)); + case ICmpInst::ICMP_SGE: + return Context.getConstantInt(Type::Int1Ty, V1.sge(V2)); + case ICmpInst::ICMP_ULT: + return Context.getConstantInt(Type::Int1Ty, V1.ult(V2)); + case ICmpInst::ICMP_UGT: + return Context.getConstantInt(Type::Int1Ty, V1.ugt(V2)); + case ICmpInst::ICMP_ULE: + return Context.getConstantInt(Type::Int1Ty, V1.ule(V2)); + case ICmpInst::ICMP_UGE: + return Context.getConstantInt(Type::Int1Ty, V1.uge(V2)); } } else if (isa<ConstantFP>(C1) && isa<ConstantFP>(C2)) { APFloat C1V = cast<ConstantFP>(C1)->getValueAPF(); @@ -1323,61 +1352,62 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred, APFloat::cmpResult R = C1V.compare(C2V); switch (pred) { default: LLVM_UNREACHABLE("Invalid FCmp Predicate"); return 0; - case FCmpInst::FCMP_FALSE: return ConstantInt::getFalse(); - case FCmpInst::FCMP_TRUE: return ConstantInt::getTrue(); + case FCmpInst::FCMP_FALSE: return Context.getConstantIntFalse(); + case FCmpInst::FCMP_TRUE: return Context.getConstantIntTrue(); case FCmpInst::FCMP_UNO: - return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpUnordered); + return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpUnordered); case FCmpInst::FCMP_ORD: - return ConstantInt::get(Type::Int1Ty, R!=APFloat::cmpUnordered); + return Context.getConstantInt(Type::Int1Ty, R!=APFloat::cmpUnordered); case FCmpInst::FCMP_UEQ: - return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpUnordered || + return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpUnordered || R==APFloat::cmpEqual); case FCmpInst::FCMP_OEQ: - return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpEqual); + return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpEqual); case FCmpInst::FCMP_UNE: - return ConstantInt::get(Type::Int1Ty, R!=APFloat::cmpEqual); + return Context.getConstantInt(Type::Int1Ty, R!=APFloat::cmpEqual); case FCmpInst::FCMP_ONE: - return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpLessThan || + return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpLessThan || R==APFloat::cmpGreaterThan); case FCmpInst::FCMP_ULT: - return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpUnordered || + return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpUnordered || R==APFloat::cmpLessThan); case FCmpInst::FCMP_OLT: - return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpLessThan); + return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpLessThan); case FCmpInst::FCMP_UGT: - return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpUnordered || + return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpUnordered || R==APFloat::cmpGreaterThan); case FCmpInst::FCMP_OGT: - return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpGreaterThan); + return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpGreaterThan); case FCmpInst::FCMP_ULE: - return ConstantInt::get(Type::Int1Ty, R!=APFloat::cmpGreaterThan); + return Context.getConstantInt(Type::Int1Ty, R!=APFloat::cmpGreaterThan); case FCmpInst::FCMP_OLE: - return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpLessThan || + return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpLessThan || R==APFloat::cmpEqual); case FCmpInst::FCMP_UGE: - return ConstantInt::get(Type::Int1Ty, R!=APFloat::cmpLessThan); + return Context.getConstantInt(Type::Int1Ty, R!=APFloat::cmpLessThan); case FCmpInst::FCMP_OGE: - return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpGreaterThan || + return Context.getConstantInt(Type::Int1Ty, R==APFloat::cmpGreaterThan || R==APFloat::cmpEqual); } } else if (isa<VectorType>(C1->getType())) { SmallVector<Constant*, 16> C1Elts, C2Elts; - C1->getVectorElements(C1Elts); - C2->getVectorElements(C2Elts); + C1->getVectorElements(Context, C1Elts); + C2->getVectorElements(Context, C2Elts); // If we can constant fold the comparison of each element, constant fold // the whole vector comparison. SmallVector<Constant*, 4> ResElts; for (unsigned i = 0, e = C1Elts.size(); i != e; ++i) { // Compare the elements, producing an i1 result or constant expr. - ResElts.push_back(ConstantExpr::getCompare(pred, C1Elts[i], C2Elts[i])); + ResElts.push_back( + Context.getConstantExprCompare(pred, C1Elts[i], C2Elts[i])); } - return ConstantVector::get(&ResElts[0], ResElts.size()); + return Context.getConstantVector(&ResElts[0], ResElts.size()); } if (C1->getType()->isFloatingPoint()) { int Result = -1; // -1 = unknown, 0 = known false, 1 = known true. - switch (evaluateFCmpRelation(C1, C2)) { + switch (evaluateFCmpRelation(Context, C1, C2)) { default: LLVM_UNREACHABLE("Unknown relation!"); case FCmpInst::FCMP_UNO: case FCmpInst::FCMP_ORD: @@ -1431,12 +1461,12 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred, // If we evaluated the result, return it now. if (Result != -1) - return ConstantInt::get(Type::Int1Ty, Result); + return Context.getConstantInt(Type::Int1Ty, Result); } else { // Evaluate the relation between the two constants, per the predicate. int Result = -1; // -1 = unknown, 0 = known false, 1 = known true. - switch (evaluateICmpRelation(C1, C2, CmpInst::isSigned(pred))) { + switch (evaluateICmpRelation(Context, C1, C2, CmpInst::isSigned(pred))) { default: LLVM_UNREACHABLE("Unknown relational!"); case ICmpInst::BAD_ICMP_PREDICATE: break; // Couldn't determine anything about these constants. @@ -1508,7 +1538,7 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred, // If we evaluated the result, return it now. if (Result != -1) - return ConstantInt::get(Type::Int1Ty, Result); + return Context.getConstantInt(Type::Int1Ty, Result); if (!isa<ConstantExpr>(C1) && isa<ConstantExpr>(C2)) { // If C2 is a constant expr and C1 isn't, flip them around and fold the @@ -1517,7 +1547,7 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred, case ICmpInst::ICMP_EQ: case ICmpInst::ICMP_NE: // No change of predicate required. - return ConstantFoldCompareInstruction(pred, C2, C1); + return ConstantFoldCompareInstruction(Context, pred, C2, C1); case ICmpInst::ICMP_ULT: case ICmpInst::ICMP_SLT: @@ -1529,7 +1559,7 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred, case ICmpInst::ICMP_SGE: // Change the predicate as necessary to swap the operands. pred = ICmpInst::getSwappedPredicate((ICmpInst::Predicate)pred); - return ConstantFoldCompareInstruction(pred, C2, C1); + return ConstantFoldCompareInstruction(Context, pred, C2, C1); default: // These predicates cannot be flopped around. break; @@ -1539,7 +1569,8 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred, return 0; } -Constant *llvm::ConstantFoldGetElementPtr(const Constant *C, +Constant *llvm::ConstantFoldGetElementPtr(LLVMContext &Context, + const Constant *C, Constant* const *Idxs, unsigned NumIdx) { if (NumIdx == 0 || @@ -1552,7 +1583,7 @@ Constant *llvm::ConstantFoldGetElementPtr(const Constant *C, (Value **)Idxs, (Value **)Idxs+NumIdx); assert(Ty != 0 && "Invalid indices for GEP!"); - return UndefValue::get(PointerType::get(Ty, Ptr->getAddressSpace())); + return Context.getUndef(Context.getPointerType(Ty, Ptr->getAddressSpace())); } Constant *Idx0 = Idxs[0]; @@ -1569,8 +1600,8 @@ Constant *llvm::ConstantFoldGetElementPtr(const Constant *C, (Value**)Idxs, (Value**)Idxs+NumIdx); assert(Ty != 0 && "Invalid indices for GEP!"); - return - ConstantPointerNull::get(PointerType::get(Ty,Ptr->getAddressSpace())); + return Context.getConstantPointerNull( + Context.getPointerType(Ty,Ptr->getAddressSpace())); } } @@ -1598,19 +1629,21 @@ Constant *llvm::ConstantFoldGetElementPtr(const Constant *C, if (!Idx0->isNullValue()) { const Type *IdxTy = Combined->getType(); if (IdxTy != Idx0->getType()) { - Constant *C1 = ConstantExpr::getSExtOrBitCast(Idx0, Type::Int64Ty); - Constant *C2 = ConstantExpr::getSExtOrBitCast(Combined, + Constant *C1 = + Context.getConstantExprSExtOrBitCast(Idx0, Type::Int64Ty); + Constant *C2 = Context.getConstantExprSExtOrBitCast(Combined, Type::Int64Ty); - Combined = ConstantExpr::get(Instruction::Add, C1, C2); + Combined = Context.getConstantExpr(Instruction::Add, C1, C2); } else { Combined = - ConstantExpr::get(Instruction::Add, Idx0, Combined); + Context.getConstantExpr(Instruction::Add, Idx0, Combined); } } NewIndices.push_back(Combined); NewIndices.insert(NewIndices.end(), Idxs+1, Idxs+NumIdx); - return ConstantExpr::getGetElementPtr(CE->getOperand(0), &NewIndices[0], + return Context.getConstantExprGetElementPtr(CE->getOperand(0), + &NewIndices[0], NewIndices.size()); } } @@ -1627,7 +1660,7 @@ Constant *llvm::ConstantFoldGetElementPtr(const Constant *C, if (const ArrayType *CAT = dyn_cast<ArrayType>(cast<PointerType>(C->getType())->getElementType())) if (CAT->getElementType() == SAT->getElementType()) - return ConstantExpr::getGetElementPtr( + return Context.getConstantExprGetElementPtr( (Constant*)CE->getOperand(0), Idxs, NumIdx); } @@ -1643,13 +1676,13 @@ Constant *llvm::ConstantFoldGetElementPtr(const Constant *C, // Convert the smaller integer to the larger type. if (Offset->getType()->getPrimitiveSizeInBits() < Base->getType()->getPrimitiveSizeInBits()) - Offset = ConstantExpr::getSExt(Offset, Base->getType()); + Offset = Context.getConstantExprSExt(Offset, Base->getType()); else if (Base->getType()->getPrimitiveSizeInBits() < Offset->getType()->getPrimitiveSizeInBits()) - Base = ConstantExpr::getZExt(Base, Offset->getType()); + Base = Context.getConstantExprZExt(Base, Offset->getType()); - Base = ConstantExpr::getAdd(Base, Offset); - return ConstantExpr::getIntToPtr(Base, CE->getType()); + Base = Context.getConstantExprAdd(Base, Offset); + return Context.getConstantExprIntToPtr(Base, CE->getType()); } } return 0; diff --git a/lib/VMCore/ConstantFold.h b/lib/VMCore/ConstantFold.h index 49aea11870..afa9978767 100644 --- a/lib/VMCore/ConstantFold.h +++ b/lib/VMCore/ConstantFold.h @@ -23,37 +23,47 @@ namespace llvm { class Value; class Constant; class Type; + class LLVMContext; // Constant fold various types of instruction... Constant *ConstantFoldCastInstruction( + LLVMContext &Context, unsigned opcode, ///< The opcode of the cast const Constant *V, ///< The source constant const Type *DestTy ///< The destination type ); - Constant *ConstantFoldSelectInstruction(const Constant *Cond, + Constant *ConstantFoldSelectInstruction(LLVMContext &Context, + const Constant *Cond, const Constant *V1, const Constant *V2); - Constant *ConstantFoldExtractElementInstruction(const Constant *Val, + Constant *ConstantFoldExtractElementInstruction(LLVMContext &Context, + const Constant *Val, const Constant *Idx); - Constant *ConstantFoldInsertElementInstruction(const Constant *Val, + Constant *ConstantFoldInsertElementInstruction(LLVMContext &Context, + const Constant *Val, const Constant *Elt, const Constant *Idx); - Constant *ConstantFoldShuffleVectorInstruction(const Constant *V1, + Constant *ConstantFoldShuffleVectorInstruction(LLVMContext &Context, + const Constant *V1, const Constant *V2, const Constant *Mask); - Constant *ConstantFoldExtractValueInstruction(const Constant *Agg, + Constant *ConstantFoldExtractValueInstruction(LLVMContext &Context, + const Constant *Agg, const unsigned *Idxs, unsigned NumIdx); - Constant *ConstantFoldInsertValueInstruction(const Constant *Agg, + Constant *ConstantFoldInsertValueInstruction(LLVMContext &Context, + const Constant *Agg, const Constant *Val, const unsigned* Idxs, unsigned NumIdx); - Constant *ConstantFoldBinaryInstruction(unsigned Opcode, const Constant *V1, + Constant *ConstantFoldBinaryInstruction(LLVMContext &Context, + unsigned Opcode, const Constant *V1, const Constant *V2); - Constant *ConstantFoldCompareInstruction(unsigned short predicate, + Constant *ConstantFoldCompareInstruction(LLVMContext &Context, + unsigned short predicate, const Constant *C1, const Constant *C2); - Constant *ConstantFoldGetElementPtr(const Constant *C, + Constant *ConstantFoldGetElementPtr(LLVMContext &Context, const Constant *C, Constant* const *Idxs, unsigned NumIdx); } // End llvm namespace diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp index 38b30c281e..f8ae2bd79f 100644 --- a/lib/VMCore/Constants.cpp +++ b/lib/VMCore/Constants.cpp @@ -128,35 +128,6 @@ bool Constant::ContainsRelocations(unsigned Kind) const { return false; } -// Static constructor to create a '0' constant of arbitrary type... -static const uint64_t zero[2] = {0, 0}; -Constant *Constant::getNullValue(const Type *Ty) { - switch (Ty->getTypeID()) { - case Type::IntegerTyID: - return ConstantInt::get(Ty, 0); - case Type::FloatTyID: - return ConstantFP::get(APFloat(APInt(32, 0))); - case Type::DoubleTyID: - return ConstantFP::get(APFloat(APInt(64, 0))); - case Type::X86_FP80TyID: - return ConstantFP::get(APFloat(APInt(80, 2, zero))); - case Type::FP128TyID: - return ConstantFP::get(APFloat(APInt(128, 2, zero), true)); - case Type::PPC_FP128TyID: - return ConstantFP::get(APFloat(APInt(128, 2, zero))); - case Type::PointerTyID: - return ConstantPointerNull::get(cast<PointerType>(Ty)); - case Type::StructTyID: - case Type::ArrayTyID: - case Type::VectorTyID: - return ConstantAggregateZero::get(Ty); - default: - // Function, Label, or Opaque type? - assert(!"Cannot create a null constant of that type!"); - return 0; - } -} - Constant *Constant::getAllOnesValue(const Type *Ty) { if (const IntegerType* ITy = dyn_cast<IntegerType>(Ty)) return ConstantInt::get(APInt::getAllOnesValue(ITy->getBitWidth())); @@ -186,7 +157,8 @@ ConstantVector *ConstantVector::getAllOnesValue(const VectorType *Ty) { /// type, returns the elements of the vector in the specified smallvector. /// This handles breaking down a vector undef into undef elements, etc. For /// constant exprs and other cases we can't handle, we return an empty vector. -void Constant::getVectorElements(SmallVectorImpl<Constant*> &Elts) const { +void Constant::getVectorElements(LLVMContext &Context, + SmallVectorImpl<Constant*> &Elts) const { assert(isa<VectorType>(getType()) && "Not a vector constant!"); if (const ConstantVector *CV = dyn_cast<ConstantVector>(this)) { @@ -198,12 +170,12 @@ void Constant::getVectorElements(SmallVectorImpl<Constant*> &Elts) const { const VectorType *VT = cast<VectorType>(getType()); if (isa<ConstantAggregateZero>(this)) { Elts.assign(VT->getNumElements(), - Constant::getNullValue(VT->getElementType())); + Context.getNullValue(VT->getElementType())); return; } if (isa<UndefValue>(this)) { - Elts.assign(VT->getNumElements(), UndefValue::get(VT->getElementType())); + Elts.assign(VT->getNumElements(), Context.getUndef(VT->getElementType())); return; } @@ -361,12 +333,6 @@ bool ConstantFP::isNullValue() const { return Val.isZero() && !Val.isNegative(); } -ConstantFP *ConstantFP::getNegativeZero(const Type *Ty) { - APFloat apf = cast <ConstantFP>(Constant::getNullValue(Ty))->getValueAPF(); - apf.changeSign(); - return ConstantFP::get(apf); -} - bool ConstantFP::isExactlyValue(const APFloat& V) const { return Val.bitwiseIsEqual(V); } @@ -831,26 +797,6 @@ const SmallVector<unsigned, 4> &ConstantExpr::getIndices() const { return cast<InsertValueConstantExpr>(this)->Indices; } -/// ConstantExpr::get* - Return some common constants without having to -/// specify the full Instruction::OPCODE identifier. -/// -Constant *ConstantExpr::getNeg(Constant *C) { - // API compatibility: Adjust integer opcodes to floating-point opcodes. - if (C->getType()->isFPOrFPVector()) - return getFNeg(C); - assert(C->getType()->isIntOrIntVector() && - "Cannot NEG a nonintegral value!"); - return get(Instruction::Sub, - ConstantExpr::getZeroValueForNegationExpr(C->getType()), - C); -} -Constant *ConstantExpr::getFNeg(Constant *C) { - assert(C->getType()->isFPOrFPVector() && - "Cannot FNEG a non-floating-point value!"); - return get(Instruction::FSub, - ConstantExpr::getZeroValueForNegationExpr(C->getType()), - C); -} Constant *ConstantExpr::getNot(Constant *C) { assert(C->getType()->isIntOrIntVector() && "Cannot NOT a nonintegral value!"); @@ -1501,11 +1447,11 @@ bool ConstantArray::isString() const { /// isCString - This method returns true if the array is a string (see /// isString) and it ends in a null byte \\0 and does not contains any other /// null bytes except its terminator. -bool ConstantArray::isCString() const { +bool ConstantArray::isCString(LLVMContext &Context) const { // Check the element type for i8... if (getType()->getElementType() != Type::Int8Ty) return false; - Constant *Zero = Constant::getNullValue(getOperand(0)->getType()); + Constant *Zero = Context.getNullValue(getOperand(0)->getType()); // Last element must be a null. if (getOperand(getNumOperands()-1) != Zero) return false; @@ -2011,7 +1957,8 @@ static inline Constant *getFoldedCast( Instruction::CastOps opc, Constant *C, const Type *Ty) { assert(Ty->isFirstClassType() && "Cannot cast to an aggregate type!"); // Fold a few common cases - if (Constant *FC = ConstantFoldCastInstruction(opc, C, Ty)) + if (Constant *FC = + ConstantFoldCastInstruction(getGlobalContext(), opc, C, Ty)) return FC; // Look up the constant in the table first to ensure uniqueness @@ -2245,25 +2192,6 @@ Constant *ConstantExpr::getBitCast(Constant *C, const Type *DstTy) { return getFoldedCast(Instruction::BitCast, C, DstTy); } -Constant *ConstantExpr::getAlignOf(const Type *Ty) { - // alignof is implemented as: (i64) gep ({i8,Ty}*)null, 0, 1 - const Type *AligningTy = StructType::get(Type::Int8Ty, Ty, NULL); - Constant *NullPtr = getNullValue(AligningTy->getPointerTo()); - Constant *Zero = ConstantInt::get(Type::Int32Ty, 0); - Constant *One = ConstantInt::get(Type::Int32Ty, 1); - Constant *Indices[2] = { Zero, One }; - Constant *GEP = getGetElementPtr(NullPtr, Indices, 2); - return getCast(Instruction::PtrToInt, GEP, Type::Int32Ty); -} - -Constant *ConstantExpr::getSizeOf(const Type *Ty) { - // sizeof is implemented as: (i64) gep (Ty*)null, 1 - Constant *GEPIdx = ConstantInt::get(Type::Int32Ty, 1); - Constant *GEP = - getGetElementPtr(getNullValue(PointerType::getUnqual(Ty)), &GEPIdx, 1); - return getCast(Instruction::PtrToInt, GEP, Type::Int64Ty); -} - Constant *ConstantExpr::getTy(const Type *ReqTy, unsigned Opcode, Constant *C1, Constant *C2) { // Check the operands for consistency first @@ -2274,7 +2202,8 @@ Constant *ConstantExpr::getTy(const Type *ReqTy, unsigned Opcode, "Operand types in binary constant expression should match"); if (ReqTy == C1->getType() || ReqTy == Type::Int1Ty) - if (Constant *FC = ConstantFoldBinaryInstruction(Opcode, C1, C2)) + if (Constant *FC = ConstantFoldBinaryInstruction( + getGlobalContext(), Opcode, C1, C2)) return FC; // Fold a few common cases... std::vector<Constant*> argVec(1, C1); argVec.push_back(C2); @@ -2383,7 +2312,8 @@ Constant *ConstantExpr::getSelectTy(const Type *ReqTy, Constant *C, assert(!SelectInst::areInvalidOperands(C, V1, V2)&&"Invalid select operands"); if (ReqTy == V1->getType()) - if (Constant *SC = ConstantFoldSelectInstruction(C, V1, V2)) + if (Constant *SC = ConstantFoldSelectInstruction( + getGlobalContext(), C, V1, V2)) return SC; // Fold common cases std::vector<Constant*> argVec(3, C); @@ -2403,7 +2333,8 @@ Constant *ConstantExpr::getGetElementPtrTy(const Type *ReqTy, Constant *C, cast<PointerType>(ReqTy)->getElementType() && "GEP indices invalid!"); - if (Constant *FC = ConstantFoldGetElementPtr(C, (Constant**)Idxs, NumIdx)) + if (Constant *FC = ConstantFoldGetElementPtr( + getGlobalContext(), C, (Constant**)Idxs, NumIdx)) return FC; // Fold a few common cases... assert(isa<PointerType>(C->getType()) && @@ -2442,7 +2373,8 @@ ConstantExpr::getICmp(unsigned short pred, Constant* LHS, Constant* RHS) { assert(pred >= ICmpInst::FIRST_ICMP_PREDICATE && pred <= ICmpInst::LAST_ICMP_PREDICATE && "Invalid ICmp Predicate"); - if (Constant *FC = ConstantFoldCompareInstruction(pred, LHS, RHS)) + if (Constant *FC = ConstantFoldCompareInstruction( + getGlobalContext(),pred, LHS, RHS)) return FC; // Fold a few common cases... // Look up the constant in the table first to ensure uniqueness @@ -2461,7 +2393,8 @@ ConstantExpr::getFCmp(unsigned short pred, Constant* LHS, Constant* RHS) { assert(LHS->getType() == RHS->getType()); assert(pred <= FCmpInst::LAST_FCMP_PREDICATE && "Invalid FCmp Predicate"); - if (Constant *FC = ConstantFoldCompareInstruction(pred, LHS, RHS)) + if (Constant *FC = ConstantFoldCompareInstruction( + getGlobalContext(), pred, LHS, RHS)) return FC; // Fold a few common cases... // Look up the constant in the table first to ensure uniqueness @@ -2477,7 +2410,8 @@ ConstantExpr::getFCmp(unsigned short pred, Constant* LHS, Constant* RHS) { Constant *ConstantExpr::getExtractElementTy(const Type *ReqTy, Constant *Val, Constant *Idx) { - if (Constant *FC = ConstantFoldExtractElementInstruction(Val, Idx)) + if (Constant *FC = ConstantFoldExtractElementInstruction( + getGlobalContext(), Val, Idx)) return FC; // Fold a few common cases... // Look up the constant in the table first to ensure uniqueness std::vector<Constant*> ArgVec(1, Val); @@ -2499,7 +2433,8 @@ Constant *ConstantExpr::getExtractElement(Constant *Val, Constant *Idx) { Constant *ConstantExpr::getInsertElementTy(const Type *ReqTy, Constant *Val, Constant *Elt, Constant *Idx) { - if (Constant *FC = ConstantFoldInsertElementInstruction(Val, Elt, Idx)) + if (Constant *FC = ConstantFoldInsertElementInstruction( + getGlobalContext(), Val, Elt, Idx)) return FC; // Fold a few common cases... // Look up the constant in the table first to ensure uniqueness std::vector<Constant*> ArgVec(1, Val); @@ -2524,7 +2459,8 @@ Constant *ConstantExpr::getInsertElement(Constant *Val, Constant *Elt, Constant *ConstantExpr::getShuffleVectorTy(const Type *ReqTy, Constant *V1, Constant *V2, Constant *Mask) { - if (Constant *FC = ConstantFoldShuffleVectorInstruction(V1, V2, Mask)) + if (Constant *FC = ConstantFoldShuffleVectorInstruction( + getGlobalContext(), V1, V2, Mask)) return FC; // Fold a few common cases... // Look up the constant in the table first to ensure uniqueness std::vector<Constant*> ArgVec(1, V1); @@ -2557,7 +2493,8 @@ Constant *ConstantExpr::getInsertValueTy(const Type *ReqTy, Constant *Agg, "insertvalue type invalid!"); assert(Agg->getType()->isFirstClassType() && "Non-first-class type for constant InsertValue expression"); - Constant *FC = ConstantFoldInsertValueInstruction(Agg, Val, Idxs, NumIdx); + Constant *FC = ConstantFoldInsertValueInstruction( + getGlobalContext(), Agg, Val, Idxs, NumIdx); assert(FC && "InsertValue constant expr couldn't be folded!"); return FC; } @@ -2583,7 +2520,8 @@ Constant *ConstantExpr::getExtractValueTy(const Type *ReqTy, Constant *Agg, "extractvalue indices invalid!"); assert(Agg->getType()->isFirstClassType() && "Non-first-class type for constant extractvalue expression"); - Constant *FC = ConstantFoldExtractValueInstruction(Agg, Idxs, NumIdx); + Constant *FC = ConstantFoldExtractValueInstruction( + getGlobalContext(), Agg, Idxs, NumIdx); assert(FC && "ExtractValue constant expr couldn't be folded!"); return FC; } @@ -2599,20 +2537,6 @@ Constant *ConstantExpr::getExtractValue(Constant *Agg, return getExtractValueTy(ReqTy, Agg, IdxList, NumIdx); } -Constant *ConstantExpr::getZeroValueForNegationExpr(const Type *Ty) { - if (const VectorType *PTy = dyn_cast<VectorType>(Ty)) - if (PTy->getElementType()->isFloatingPoint()) { - std::vector<Constant*> zeros(PTy->getNumElements(), - ConstantFP::getNegativeZero(PTy->getElementType())); - return ConstantVector::get(PTy, zeros); - } - - if (Ty->isFloatingPoint()) - return ConstantFP::getNegativeZero(Ty); - - return Constant::getNullValue(Ty); -} - // destroyConstant - Remove the constant from the constant table... // void ConstantExpr::destroyConstant() { diff --git a/lib/VMCore/Instructions.cpp b/lib/VMCore/Instructions.cpp index 475d8cdd56..74bcc10041 100644 --- a/lib/VMCore/Instructions.cpp +++ b/lib/VMCore/Instructions.cpp @@ -1633,33 +1633,37 @@ BinaryOperator *BinaryOperator::Create(BinaryOps Op, Value *S1, Value *S2, return Res; } -BinaryOperator *BinaryOperator::CreateNeg(Value *Op, const std::string &Name, +BinaryOperator *BinaryOperator::CreateNeg(LLVMContext &Context, + Value *Op, const std::string &Name, Instruction *InsertBefore) { - Value *zero = ConstantExpr::getZeroValueForNegationExpr(Op->getType()); + Value *zero = Context.getZeroValueForNegation(Op->getType()); return new BinaryOperator(Instruction::Sub, zero, Op, Op->getType(), Name, InsertBefore); } -BinaryOperator *BinaryOperator::CreateNeg(Value *Op, const std::string &Name, +BinaryOperator *BinaryOperator::CreateNeg(LLVMContext &Context, + Value *Op, const std::string &Name, BasicBlock *InsertAtEnd) { - Value *zero = ConstantExpr::getZeroValueForNegationExpr(Op->getType()); + Value *zero = Context.getZeroValueForNegation(Op->getType()); return new BinaryOperator(Instruction::Sub, zero, Op, Op->getType(), Name, InsertAtEnd); } -BinaryOperator *BinaryOperator::CreateFNeg(Value *Op, const std::string &Name, +BinaryOperator *BinaryOperator::CreateFNeg(LLVMContext &Context, + Value *Op, const std::string &Name, Instruction *InsertBefore) { - Value *zero = ConstantExpr::getZeroValueForNegationExpr(Op->getType()); + Value *zero = Context.getZeroValueForNegation(Op->getType()); return new BinaryOperator(Instruction::FSub, zero, Op, Op->getType(), Name, InsertBefore); } -BinaryOperator *BinaryOperator::CreateFNeg(Value *Op, const std::string &Name, +BinaryOperator *BinaryOperator::CreateFNeg(LLVMContext &Context, + Value *Op, const std::string &Name, BasicBlock *InsertAtEnd) { - Value *zero = ConstantExpr::getZeroValueForNegationExpr(Op->getType()); + Value *zero = Context.getZeroValueForNegation(Op->getType()); return new BinaryOperator(Instruction::FSub, zero, Op, Op->getType(), Name, InsertAtEnd); @@ -1705,19 +1709,19 @@ static inline bool isConstantAllOnes(const Value *V) { return false; } -bool BinaryOperator::isNeg(const Value *V) { +bool BinaryOperator::isNeg(LLVMContext &Context, const Value *V) { if (const BinaryOperator *Bop = dyn_cast<BinaryOperator>(V)) if (Bop->getOpcode() == Instruction::Sub) return Bop->getOperand(0) == - ConstantExpr::getZeroValueForNegationExpr(Bop->getType()); + Context.getZeroValueForNegation(Bop->getType()); return false; } -bool BinaryOperator::isFNeg(const Value *V) { +bool BinaryOperator::isFNeg(LLVMContext &Context, const Value *V) { if (const BinaryOperator *Bop = dyn_cast<BinaryOperator>(V)) if (Bop->getOpcode() == Instruction::FSub) return Bop->getOperand(0) == - ConstantExpr::getZeroValueForNegationExpr(Bop->getType()); + Context.getZeroValueForNegation(Bop->getType()); return false; } @@ -1730,7 +1734,6 @@ bool BinaryOperator::isNot(const Value *V) { } Value *BinaryOperator::getNegArgument(Value *BinOp) { - assert(isNeg(BinOp) && "getNegArgument from non-'neg' instruction!"); return cast<BinaryOperator>(BinOp)->getOperand(1); } @@ -1739,7 +1742,6 @@ const Value *BinaryOperator::getNegArgument(const Value *BinOp) { } Value *BinaryOperator::getFNegArgument(Value *BinOp) { - assert(isFNeg(BinOp) && "getFNegArgument from non-'fneg' instruction!"); return cast<BinaryOperator>(BinOp)->getOperand(1); } diff --git a/lib/VMCore/LLVMContext.cpp b/lib/VMCore/LLVMContext.cpp index 4a9953a4f1..e091f2899b 100644 --- a/lib/VMCore/LLVMContext.cpp +++ b/lib/VMCore/LLVMContext.cpp @@ -15,6 +15,7 @@ #include "llvm/LLVMContext.h" #include "llvm/Constants.h" #include "llvm/DerivedTypes.h" +#include "llvm/Instruction.h" #include "llvm/MDNode.h" #include "llvm/Support/ManagedStatic.h" #include "LLVMContextImpl.h" @@ -31,8 +32,34 @@ LLVMContext::LLVMContext() : pImpl(new LLVMContextImpl()) { } LLVMContext::~LLVMContext() { delete pImpl; } // Constant accessors + +// Constructor to create a '0' constant of arbitrary type... +static const uint64_t zero[2] = {0, 0}; Constant* LLVMContext::getNullValue(const Type* Ty) { - return Constant::getNullValue(Ty); + switch (Ty->getTypeID()) { + case Type::IntegerTyID: + return getConstantInt(Ty, 0); + case Type::FloatTyID: + return getConstantFP(APFloat(APInt(32, 0))); + case Type::DoubleTyID: + return getConstantFP(APFloat(APInt(64, 0))); + case Type::X86_FP80TyID: + return getConstantFP(APFloat(APInt(80, 2, zero))); + case Type::FP128TyID: + return getConstantFP(APFloat(APInt(128, 2, zero), true)); + case Type::PPC_FP128TyID: + return getConstantFP(APFloat(APInt(128, 2, zero))); + case Type::PointerTyID: + return getConstantPointerNull(cast<PointerType>(Ty)); + case Type::StructTyID: + case Type::ArrayTyID: + case Type::VectorTyID: + return getConstantAggregateZero(Ty); + default: + // Function, Label, or Opaque type? + assert(!"Cannot create a null constant of that type!"); + return 0; + } } Constant* LLVMContext::getAllOnesValue(const Type* Ty) { @@ -222,7 +249,14 @@ Constant* LLVMContext::getConstantExprSelect(Constant* C, Constant* V1, } Constant* LLVMContext::getConstantExprAlignOf(const Type* Ty) { - return ConstantExpr::getAlignOf(Ty); + // alignof is implemented as: (i64) gep ({i8,Ty}*)null, 0, 1 + const Type *AligningTy = getStructType(Type::Int8Ty, Ty, NULL); + Constant *NullPtr = getNullValue(AligningTy->getPointerTo()); + Constant *Zero = getConstantInt(Type::Int32Ty, 0); + Constant *One = getConstantInt(Type::Int32Ty, 1); + Constant *Indices[2] = { Zero, One }; + Constant *GEP = getConstantExprGetElementPtr(NullPtr, Indices, 2); + return getConstantExprCast(Instruction::PtrToInt, GEP, Type::Int32Ty); } Constant* LLVMContext::getConstantExprCompare(unsigned short pred, @@ -231,11 +265,22 @@ Constant* LLVMContext::getConstantExprCompare(unsigned short pred, } Constant* LLVMContext::getConstantExprNeg(Constant* C) { - return ConstantExpr::getNeg(C); + // API compatibility: Adjust integer opcodes to floating-point opcodes. + if (C->getType()->isFPOrFPVector()) + return getConstantExprFNeg(C); + assert(C->getType()->isIntOrIntVector() && + "Cannot NEG a nonintegral value!"); + return getConstantExpr(Instruction::Sub, + getZeroValueForNegation(C->getType()), + C); } Constant* LLVMContext::getConstantExprFNeg(Constant* C) { - return ConstantExpr::getFNeg(C); + assert(C->getType()->isFPOrFPVector() && + "Cannot FNEG a non-floating-point value!"); + return getConstantExpr(Instruction::FSub, + getZeroValueForNegation(C->getType()), + C); } Constant* LLVMContext::getConstantExprNot(Constant* C) { @@ -365,11 +410,25 @@ Constant* LLVMContext::getConstantExprInsertValue(Constant* Agg, Constant* Val, } Constant* LLVMContext::getConstantExprSizeOf(const Type* Ty) { - return ConstantExpr::getSizeOf(Ty); + // sizeof is implemented as: (i64) gep (Ty*)null, 1 + Constant *GEPIdx = getConstantInt(Type::Int32Ty, 1); + Constant *GEP = getConstantExprGetElementPtr( + getNullValue(getPointerTypeUnqual(Ty)), &GEPIdx, 1); + return getConstantExprCast(Instruction::PtrToInt, GEP, Type::Int64Ty); } Constant* LLVMContext::getZeroValueForNegation(const Type* Ty) { - return ConstantExpr::getZeroValueForNegationExpr(Ty); + if (const VectorType *PTy = dyn_cast<VectorType>(Ty)) + if (PTy->getElementType()->isFloatingPoint()) { + std::vector<Constant*> zeros(PTy->getNumElements(), + getConstantFPNegativeZero(PTy->getElementType())); + return getConstantVector(PTy, zeros); + } + + if (Ty->isFloatingPoint()) + return getConstantFPNegativeZero(Ty); + + return getNullValue(Ty); } @@ -383,7 +442,9 @@ Constant* LLVMContext::getConstantFP(const Type* Ty, double V) { } ConstantFP* LLVMContext::getConstantFPNegativeZero(const Type* Ty) { - return ConstantFP::getNegativeZero(Ty); + APFloat apf = cast <ConstantFP>(getNullValue(Ty))->getValueAPF(); + apf.changeSign(); + return getConstantFP(apf); } @@ -452,6 +513,17 @@ StructType* LLVMContext::getStructType(const std::vector<const Type*>& Params, return StructType::get(Params, isPacked); } +StructType *LLVMContext::getStructType(const Type *type, ...) { + va_list ap; + std::vector<const llvm::Type*> StructFields; + va_start(ap, type); + while (type) { + StructFields.push_back(type); + type = va_arg(ap, llvm::Type*); + } + return StructType::get(StructFields); +} + // ArrayType accessors ArrayType* LLVMContext::getArrayType(const Type* ElementType, uint64_t NumElements) { diff --git a/tools/bugpoint/CrashDebugger.cpp b/tools/bugpoint/CrashDebugger.cpp index 9697b341f3..3084857f1a 100644 --- a/tools/bugpoint/CrashDebugger.cpp +++ b/tools/bugpoint/CrashDebugger.cpp @@ -299,7 +299,8 @@ bool ReduceCrashingBlocks::TestBlocks(std::vector<const BasicBlock*> &BBs) { if (isa<StructType>(BBTerm->getType())) BBTerm->replaceAllUsesWith(UndefValue::get(BBTerm->getType())); else if (BB->getTerminator()->getType() != Type::VoidTy) - BBTerm->replaceAllUsesWith(Constant::getNullValue(BBTerm->getType())); + BBTerm->replaceAllUsesWith( + BD.getContext().getNullValue(BBTerm->getType())); // Replace the old terminator instruction. BB->getInstList().pop_back(); diff --git a/tools/bugpoint/ExtractFunction.cpp b/tools/bugpoint/ExtractFunction.cpp index 6cd2d19b4f..4498f98fe2 100644 --- a/tools/bugpoint/ExtractFunction.cpp +++ b/tools/bugpoint/ExtractFunction.cpp @@ -74,7 +74,7 @@ Module *BugDriver::deleteInstructionFromProgram(const Instruction *I, if (isa<StructType>(TheInst->getType())) TheInst->replaceAllUsesWith(UndefValue::get(TheInst->getType())); else if (TheInst->getType() != Type::VoidTy) - TheInst->replaceAllUsesWith(Constant::getNullValue(TheInst->getType())); + TheInst->replaceAllUsesWith(Context.getNullValue(TheInst->getType())); // Remove the instruction from the program. TheInst->getParent()->getInstList().erase(TheInst); diff --git a/tools/bugpoint/Miscompilation.cpp b/tools/bugpoint/Miscompilation.cpp index 785abb9240..5fffcc19db 100644 --- a/tools/bugpoint/Miscompilation.cpp +++ b/tools/bugpoint/Miscompilation.cpp @@ -711,7 +711,8 @@ static void CleanupAndPrepareModules(BugDriver &BD, Module *&Test, // sbyte* so it matches the signature of the resolver function. // GetElementPtr *funcName, ulong 0, ulong 0 - std::vector<Constant*> GEPargs(2,Constant::getNullValue(Type::Int32Ty)); + std::vector<Constant*> GEPargs(2, + BD.getContext().getNullValue(Type::Int32Ty)); Value *GEP = ConstantExpr::getGetElementPtr(funcName, &GEPargs[0], 2); std::vector<Value*> ResolverArgs; ResolverArgs.push_back(GEP); diff --git a/tools/bugpoint/TestPasses.cpp b/tools/bugpoint/TestPasses.cpp index 900bf632a8..2c5b3b25ed 100644 --- a/tools/bugpoint/TestPasses.cpp +++ b/tools/bugpoint/TestPasses.cpp @@ -60,7 +60,7 @@ namespace { for (BasicBlock::iterator I = BB.begin(), E = BB.end(); I != E; ++I) if (CallInst *CI = dyn_cast<CallInst>(I)) { if (!CI->use_empty()) - CI->replaceAllUsesWith(Constant::getNullValue(CI->getType())); + CI->replaceAllUsesWith(Context->getNullValue(CI->getType())); CI->getParent()->getInstList().erase(CI); break; } diff --git a/tools/lto/LTOModule.cpp b/tools/lto/LTOModule.cpp index c4980d6bf7..591547fb22 100644 --- a/tools/lto/LTOModule.cpp +++ b/tools/lto/LTOModule.cpp @@ -189,7 +189,7 @@ bool LTOModule::objcClassNameFromExpression(Constant* c, std::string& name) if (GlobalVariable* gvn = dyn_cast<GlobalVariable>(op)) { Constant* cn = gvn->getInitializer(); if (ConstantArray* ca = dyn_cast<ConstantArray>(cn)) { - if ( ca->isCString() ) { + if ( ca->isCString(getGlobalContext()) ) { name = ".objc_class_name_" + ca->getAsString(); return true; } diff --git a/unittests/ExecutionEngine/JIT/JITTest.cpp b/unittests/ExecutionEngine/JIT/JITTest.cpp index 87f3498fac..fce756b042 100644 --- a/unittests/ExecutionEngine/JIT/JITTest.cpp +++ b/unittests/ExecutionEngine/JIT/JITTest.cpp @@ -73,7 +73,7 @@ TEST(JIT, GlobalInFunction) { GTy, false, // Not constant. GlobalValue::InternalLinkage, - Constant::getNullValue(GTy), + context.getNullValue(GTy), "myglobal"); // Make a function that points to a global. diff --git a/unittests/Support/ValueHandleTest.cpp b/unittests/Support/ValueHandleTest.cpp index 336e7d90dc..7a709427c9 100644 --- a/unittests/Support/ValueHandleTest.cpp +++ b/unittests/Support/ValueHandleTest.cpp @@ -284,14 +284,17 @@ TEST_F(ValueHandle, CallbackVH_DeletionCanRAUW) { public: int DeletedCalls; Value *AURWArgument; + LLVMContext *Context; - RecoveringVH() : DeletedCalls(0), AURWArgument(NULL) {} + RecoveringVH() : DeletedCalls(0), AURWArgument(NULL), + Context(&getGlobalContext()) {} RecoveringVH(Value *V) - : CallbackVH(V), DeletedCalls(0), AURWArgument(NULL) {} + : CallbackVH(V), DeletedCalls(0), AURWArgument(NULL), + Context(&getGlobalContext()) {} private: virtual void deleted() { - getValPtr()->replaceAllUsesWith(Constant::getNullValue(Type::Int32Ty)); + getValPtr()->replaceAllUsesWith(Context->getNullValue(Type::Int32Ty)); setValPtr(NULL); } virtual void allUsesReplacedWith(Value *new_value) { @@ -307,11 +310,13 @@ TEST_F(ValueHandle, CallbackVH_DeletionCanRAUW) { RecoveringVH RVH; RVH = BitcastV.get(); std::auto_ptr<BinaryOperator> BitcastUser( - BinaryOperator::CreateAdd(RVH, Constant::getNullValue(Type::Int32Ty))); + BinaryOperator::CreateAdd(RVH, + getGlobalContext().getNullValue(Type::Int32Ty))); EXPECT_EQ(BitcastV.get(), BitcastUser->getOperand(0)); BitcastV.reset(); // Would crash without the ValueHandler. - EXPECT_EQ(Constant::getNullValue(Type::Int32Ty), RVH.AURWArgument); - EXPECT_EQ(Constant::getNullValue(Type::Int32Ty), BitcastUser->getOperand(0)); + EXPECT_EQ(getGlobalContext().getNullValue(Type::Int32Ty), RVH.AURWArgument); + EXPECT_EQ(getGlobalContext().getNullValue(Type::Int32Ty), + BitcastUser->getOperand(0)); } } |