From b8f74793b9d161bc666fe27fc92fe112b6ec169b Mon Sep 17 00:00:00 2001 From: David Greene Date: Tue, 4 Sep 2007 15:46:09 +0000 Subject: [PATCH] Update GEP constructors to use an iterator interface to fix GLIBCXX_DEBUG issues. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@41697 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Instructions.h | 107 +++++++++++++++--- include/llvm/Support/LLVMBuilder.h | 13 +-- lib/AsmParser/llvmAsmParser.y | 6 +- lib/Bitcode/Reader/BitcodeReader.cpp | 2 +- lib/Transforms/IPO/ArgumentPromotion.cpp | 6 +- lib/Transforms/IPO/GlobalOpt.cpp | 6 +- lib/Transforms/Scalar/GVNPRE.cpp | 4 +- lib/Transforms/Scalar/IndVarSimplify.cpp | 5 +- .../Scalar/InstructionCombining.cpp | 28 +++-- lib/Transforms/Scalar/LowerGC.cpp | 15 ++- lib/Transforms/Scalar/LowerPacked.cpp | 4 +- .../Scalar/ScalarReplAggregates.cpp | 16 ++- lib/Transforms/Utils/CodeExtractor.cpp | 28 +++-- lib/Transforms/Utils/LowerInvoke.cpp | 9 +- lib/VMCore/ConstantFold.cpp | 8 +- lib/VMCore/ConstantFold.h | 3 + lib/VMCore/Constants.cpp | 4 +- lib/VMCore/Instructions.cpp | 73 ------------ lib/VMCore/Verifier.cpp | 2 +- tools/llvm-upgrade/UpgradeParser.y | 9 +- tools/llvm2cpp/CppWriter.cpp | 7 +- 21 files changed, 195 insertions(+), 160 deletions(-) diff --git a/include/llvm/Instructions.h b/include/llvm/Instructions.h index 328932acac1..5aeccec8f46 100644 --- a/include/llvm/Instructions.h +++ b/include/llvm/Instructions.h @@ -367,6 +367,14 @@ public: // GetElementPtrInst Class //===----------------------------------------------------------------------===// +// checkType - Simple wrapper function to give a better assertion failure +// message on bad indexes for a gep instruction. +// +static inline const Type *checkType(const Type *Ty) { + assert(Ty && "Invalid GetElementPtrInst indices for type!"); + return Ty; +} + /// GetElementPtrInst - an instruction for type-safe pointer arithmetic to /// access elements of arrays and structs /// @@ -380,28 +388,94 @@ class GetElementPtrInst : public Instruction { OL[i].init(GEPIOL[i], this); } void init(Value *Ptr, Value* const *Idx, unsigned NumIdx); - void init(Value *Ptr, Value *Idx0, Value *Idx1); void init(Value *Ptr, Value *Idx); + + template + void init(Value *Ptr, InputIterator IdxBegin, InputIterator IdxEnd, + const std::string &Name, + // This argument ensures that we have an iterator we can + // do arithmetic on in constant time + std::random_access_iterator_tag) { + typename std::iterator_traits::difference_type NumIdx = + std::distance(IdxBegin, IdxEnd); + + if (NumIdx > 0) { + // This requires that the itoerator points to contiguous memory. + init(Ptr, &*IdxBegin, NumIdx); + } + else { + init(Ptr, 0, NumIdx); + } + + setName(Name); + } + + /// getIndexedType - Returns the type of the element that would be loaded with + /// a load instruction with the specified parameters. + /// + /// A null type is returned if the indices are invalid for the specified + /// pointer type. + /// + static const Type *getIndexedType(const Type *Ptr, + Value* const *Idx, unsigned NumIdx, + bool AllowStructLeaf = false); + + template + static const Type *getIndexedType(const Type *Ptr, + InputIterator IdxBegin, + InputIterator IdxEnd, + bool AllowStructLeaf, + // This argument ensures that we + // have an iterator we can do + // arithmetic on in constant time + std::random_access_iterator_tag) { + typename std::iterator_traits::difference_type NumIdx = + std::distance(IdxBegin, IdxEnd); + + if (NumIdx > 0) { + // This requires that the iterator points to contiguous memory. + return(getIndexedType(Ptr, (Value *const *)&*IdxBegin, NumIdx, + AllowStructLeaf)); + } + else { + return(getIndexedType(Ptr, (Value *const*)0, NumIdx, AllowStructLeaf)); + } + } + public: /// Constructors - Create a getelementptr instruction with a base pointer an /// list of indices. The first ctor can optionally insert before an existing /// instruction, the second appends the new instruction to the specified /// BasicBlock. - GetElementPtrInst(Value *Ptr, Value* const *Idx, unsigned NumIdx, - const std::string &Name = "", Instruction *InsertBefore =0); - GetElementPtrInst(Value *Ptr, Value* const *Idx, unsigned NumIdx, - const std::string &Name, BasicBlock *InsertAtEnd); - + template + GetElementPtrInst(Value *Ptr, InputIterator IdxBegin, + InputIterator IdxEnd, + const std::string &Name = "", + Instruction *InsertBefore =0) + : Instruction(PointerType::get( + checkType(getIndexedType(Ptr->getType(), + IdxBegin, IdxEnd, true))), + GetElementPtr, 0, 0, InsertBefore) { + init(Ptr, IdxBegin, IdxEnd, Name, + typename std::iterator_traits::iterator_category()); + } + template + GetElementPtrInst(Value *Ptr, InputIterator IdxBegin, InputIterator IdxEnd, + const std::string &Name, BasicBlock *InsertAtEnd) + : Instruction(PointerType::get( + checkType(getIndexedType(Ptr->getType(), + IdxBegin, IdxEnd, true))), + GetElementPtr, 0, 0, InsertAtEnd) { + init(Ptr, IdxBegin, IdxEnd, Name, + typename std::iterator_traits::iterator_category()); + } + /// Constructors - These two constructors are convenience methods because one /// and two index getelementptr instructions are so common. GetElementPtrInst(Value *Ptr, Value *Idx, const std::string &Name = "", Instruction *InsertBefore =0); GetElementPtrInst(Value *Ptr, Value *Idx, const std::string &Name, BasicBlock *InsertAtEnd); - GetElementPtrInst(Value *Ptr, Value *Idx0, Value *Idx1, - const std::string &Name = "", Instruction *InsertBefore =0); - GetElementPtrInst(Value *Ptr, Value *Idx0, Value *Idx1, - const std::string &Name, BasicBlock *InsertAtEnd); ~GetElementPtrInst(); virtual GetElementPtrInst *clone() const; @@ -417,12 +491,15 @@ public: /// A null type is returned if the indices are invalid for the specified /// pointer type. /// + template static const Type *getIndexedType(const Type *Ptr, - Value* const *Idx, unsigned NumIdx, - bool AllowStructLeaf = false); - - static const Type *getIndexedType(const Type *Ptr, Value *Idx0, Value *Idx1, - bool AllowStructLeaf = false); + InputIterator IdxBegin, + InputIterator IdxEnd, + bool AllowStructLeaf = false) { + return(getIndexedType(Ptr, IdxBegin, IdxEnd, AllowStructLeaf, + typename std::iterator_traits:: + iterator_category())); + } static const Type *getIndexedType(const Type *Ptr, Value *Idx); inline op_iterator idx_begin() { return op_begin()+1; } diff --git a/include/llvm/Support/LLVMBuilder.h b/include/llvm/Support/LLVMBuilder.h index ce403f17525..cdfd9618c59 100644 --- a/include/llvm/Support/LLVMBuilder.h +++ b/include/llvm/Support/LLVMBuilder.h @@ -217,16 +217,13 @@ public: StoreInst *CreateStore(Value *Val, Value *Ptr, bool isVolatile = false) { return Insert(new StoreInst(Val, Ptr, isVolatile)); } - GetElementPtrInst *CreateGEP(Value *Ptr, Value* const *Idx, unsigned NumIdx, - const char *Name = "") { - return Insert(new GetElementPtrInst(Ptr, Idx, NumIdx, Name)); + template + GetElementPtrInst *CreateGEP(Value *Ptr, InputIterator IdxBegin, + InputIterator IdxEnd, const char *Name = "") { + return(Insert(new GetElementPtrInst(Ptr, IdxBegin, IdxEnd, Name))); } GetElementPtrInst *CreateGEP(Value *Ptr, Value *Idx, const char *Name = "") { - return Insert(new GetElementPtrInst(Ptr, &Idx, 1, Name)); - } - GetElementPtrInst *CreateGEP(Value *Ptr, Value *Idx0, Value *Idx1, - const char *Name = "") { - return Insert(new GetElementPtrInst(Ptr, Idx0, Idx1, Name)); + return Insert(new GetElementPtrInst(Ptr, Idx, Name)); } //===--------------------------------------------------------------------===// diff --git a/lib/AsmParser/llvmAsmParser.y b/lib/AsmParser/llvmAsmParser.y index 5570692864a..93f7a085bc6 100644 --- a/lib/AsmParser/llvmAsmParser.y +++ b/lib/AsmParser/llvmAsmParser.y @@ -1886,7 +1886,7 @@ ConstExpr: CastOps '(' ConstVal TO Types ')' { GEN_ERROR("GetElementPtr requires a pointer operand"); const Type *IdxTy = - GetElementPtrInst::getIndexedType($3->getType(), &(*$4)[0], $4->size(), + GetElementPtrInst::getIndexedType($3->getType(), $4->begin(), $4->end(), true); if (!IdxTy) GEN_ERROR("Index list invalid for constant getelementptr"); @@ -3064,12 +3064,12 @@ MemoryInst : MALLOC Types OptCAlign { if (!isa($2->get())) GEN_ERROR("getelementptr insn requires pointer operand"); - if (!GetElementPtrInst::getIndexedType(*$2, &(*$4)[0], $4->size(), true)) + if (!GetElementPtrInst::getIndexedType(*$2, $4->begin(), $4->end(), true)) GEN_ERROR("Invalid getelementptr indices for type '" + (*$2)->getDescription()+ "'"); Value* tmpVal = getVal(*$2, $3); CHECK_FOR_ERROR - $$ = new GetElementPtrInst(tmpVal, &(*$4)[0], $4->size()); + $$ = new GetElementPtrInst(tmpVal, $4->begin(), $4->end()); delete $2; delete $4; }; diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp index e1cd668a83e..6ad1fd595b7 100644 --- a/lib/Bitcode/Reader/BitcodeReader.cpp +++ b/lib/Bitcode/Reader/BitcodeReader.cpp @@ -1234,7 +1234,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) { GEPIdx.push_back(Op); } - I = new GetElementPtrInst(BasePtr, &GEPIdx[0], GEPIdx.size()); + I = new GetElementPtrInst(BasePtr, GEPIdx.begin(), GEPIdx.end()); break; } diff --git a/lib/Transforms/IPO/ArgumentPromotion.cpp b/lib/Transforms/IPO/ArgumentPromotion.cpp index 9853afe8752..93a7af68a0d 100644 --- a/lib/Transforms/IPO/ArgumentPromotion.cpp +++ b/lib/Transforms/IPO/ArgumentPromotion.cpp @@ -376,8 +376,8 @@ Function *ArgPromotion::DoPromotion(Function *F, for (ScalarizeTable::iterator SI = ArgIndices.begin(), E = ArgIndices.end(); SI != E; ++SI) Params.push_back(GetElementPtrInst::getIndexedType(I->getType(), - &(*SI)[0], - SI->size())); + SI->begin(), + SI->end())); if (ArgIndices.size() == 1 && ArgIndices.begin()->empty()) ++NumArgumentsPromoted; @@ -428,7 +428,7 @@ Function *ArgPromotion::DoPromotion(Function *F, Value *V = *AI; LoadInst *OrigLoad = OriginalLoads[*SI]; if (!SI->empty()) { - V = new GetElementPtrInst(V, &(*SI)[0], SI->size(), + V = new GetElementPtrInst(V, SI->begin(), SI->end(), V->getName()+".idx", Call); AA.copyValue(OrigLoad->getOperand(0), V); } diff --git a/lib/Transforms/IPO/GlobalOpt.cpp b/lib/Transforms/IPO/GlobalOpt.cpp index 520af8750e1..58a705d496a 100644 --- a/lib/Transforms/IPO/GlobalOpt.cpp +++ b/lib/Transforms/IPO/GlobalOpt.cpp @@ -464,7 +464,7 @@ static GlobalVariable *SRAGlobal(GlobalVariable *GV) { Idxs.push_back(NullInt); for (unsigned i = 3, e = GEPI->getNumOperands(); i != e; ++i) Idxs.push_back(GEPI->getOperand(i)); - NewPtr = new GetElementPtrInst(NewPtr, &Idxs[0], Idxs.size(), + NewPtr = new GetElementPtrInst(NewPtr, Idxs.begin(), Idxs.end(), GEPI->getName()+"."+utostr(Val), GEPI); } GEP->replaceAllUsesWith(NewPtr); @@ -698,7 +698,7 @@ static GlobalVariable *OptimizeGlobalAddressOfMalloc(GlobalVariable *GV, MI->getAlignment(), MI->getName(), MI); Value* Indices[2]; Indices[0] = Indices[1] = Constant::getNullValue(Type::Int32Ty); - Value *NewGEP = new GetElementPtrInst(NewMI, Indices, 2, + Value *NewGEP = new GetElementPtrInst(NewMI, Indices, Indices + 2, NewMI->getName()+".el0", MI); MI->replaceAllUsesWith(NewGEP); MI->eraseFromParent(); @@ -926,7 +926,7 @@ static void RewriteUsesOfLoadForHeapSRoA(LoadInst *Ptr, GEPIdx.push_back(GEPI->getOperand(1)); GEPIdx.append(GEPI->op_begin()+3, GEPI->op_end()); - Value *NGEPI = new GetElementPtrInst(NewPtr, &GEPIdx[0], GEPIdx.size(), + Value *NGEPI = new GetElementPtrInst(NewPtr, GEPIdx.begin(), GEPIdx.end(), GEPI->getName(), GEPI); GEPI->replaceAllUsesWith(NGEPI); GEPI->eraseFromParent(); diff --git a/lib/Transforms/Scalar/GVNPRE.cpp b/lib/Transforms/Scalar/GVNPRE.cpp index e56be31ba69..d362f54b493 100644 --- a/lib/Transforms/Scalar/GVNPRE.cpp +++ b/lib/Transforms/Scalar/GVNPRE.cpp @@ -945,7 +945,7 @@ Value* GVNPRE::phi_translate(Value* V, BasicBlock* pred, BasicBlock* succ) { if (newOp1 != U->getPointerOperand() || changed_idx) { Instruction* newVal = new GetElementPtrInst(newOp1, - &newIdx[0], newIdx.size(), + newIdx.begin(), newIdx.end(), U->getName()+".expr"); uint32_t v = VN.lookup_or_add(newVal); @@ -1675,7 +1675,7 @@ void GVNPRE::insertion_pre(Value* e, BasicBlock* BB, C->getName()+".gvnpre", (*PI)->getTerminator()); else if (GetElementPtrInst* G = dyn_cast(U)) - newVal = new GetElementPtrInst(s1, &sVarargs[0], sVarargs.size(), + newVal = new GetElementPtrInst(s1, sVarargs.begin(), sVarargs.end(), G->getName()+".gvnpre", (*PI)->getTerminator()); diff --git a/lib/Transforms/Scalar/IndVarSimplify.cpp b/lib/Transforms/Scalar/IndVarSimplify.cpp index 7f0e65e7f27..5e82ad0f7b5 100644 --- a/lib/Transforms/Scalar/IndVarSimplify.cpp +++ b/lib/Transforms/Scalar/IndVarSimplify.cpp @@ -178,8 +178,11 @@ void IndVarSimplify::EliminatePointerRecurrence(PHINode *PN, Constant *NCE = ConstantExpr::getGetElementPtr(CE->getOperand(0), &CEIdxs[0], CEIdxs.size()); + Value *Idx[2]; + Idx[0] = Constant::getNullValue(Type::Int32Ty); + Idx[1] = NewAdd; GetElementPtrInst *NGEPI = new GetElementPtrInst( - NCE, Constant::getNullValue(Type::Int32Ty), NewAdd, + NCE, Idx, Idx + 2, GEPI->getName(), GEPI); SE->deleteValueFromRecords(GEPI); GEPI->replaceAllUsesWith(NGEPI); diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp index 218da9773d1..34f9806428d 100644 --- a/lib/Transforms/Scalar/InstructionCombining.cpp +++ b/lib/Transforms/Scalar/InstructionCombining.cpp @@ -6564,8 +6564,9 @@ Instruction *InstCombiner::commonPointerCastTransforms(CastInst &CI) { // If we were able to index down into an element, create the GEP // and bitcast the result. This eliminates one bitcast, potentially // two. - Instruction *NGEP = new GetElementPtrInst(OrigBase, &NewIndices[0], - NewIndices.size(), ""); + Instruction *NGEP = new GetElementPtrInst(OrigBase, + NewIndices.begin(), + NewIndices.end(), ""); InsertNewInstBefore(NGEP, CI); NGEP->takeName(GEP); @@ -7057,7 +7058,7 @@ Instruction *InstCombiner::visitBitCast(BitCastInst &CI) { // If we found a path from the src to dest, create the getelementptr now. if (SrcElTy == DstElTy) { SmallVector Idxs(NumZeros+1, ZeroUInt); - return new GetElementPtrInst(Src, &Idxs[0], Idxs.size()); + return new GetElementPtrInst(Src, Idxs.begin(), Idxs.end()); } } @@ -8502,8 +8503,8 @@ Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) { } if (!Indices.empty()) - return new GetElementPtrInst(SrcGEPOperands[0], &Indices[0], - Indices.size(), GEP.getName()); + return new GetElementPtrInst(SrcGEPOperands[0], Indices.begin(), + Indices.end(), GEP.getName()); } else if (GlobalValue *GV = dyn_cast(PtrOp)) { // GEP of global variable. If all of the indices for this GEP are @@ -8554,9 +8555,11 @@ Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) { if (isa(SrcElTy) && TD->getTypeSize(cast(SrcElTy)->getElementType()) == TD->getTypeSize(ResElTy)) { + Value *Idx[2]; + Idx[0] = Constant::getNullValue(Type::Int32Ty); + Idx[1] = GEP.getOperand(1); Value *V = InsertNewInstBefore( - new GetElementPtrInst(X, Constant::getNullValue(Type::Int32Ty), - GEP.getOperand(1), GEP.getName()), GEP); + new GetElementPtrInst(X, Idx, Idx + 2, GEP.getName()), GEP); // V and GEP are both pointer types --> BitCast return new BitCastInst(V, GEP.getType()); } @@ -8609,9 +8612,11 @@ Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) { } // Insert the new GEP instruction. + Value *Idx[2]; + Idx[0] = Constant::getNullValue(Type::Int32Ty); + Idx[1] = NewIdx; Instruction *NewGEP = - new GetElementPtrInst(X, Constant::getNullValue(Type::Int32Ty), - NewIdx, GEP.getName()); + new GetElementPtrInst(X, Idx, Idx + 2, GEP.getName()); NewGEP = InsertNewInstBefore(NewGEP, GEP); // The NewGEP must be pointer typed, so must the old one -> BitCast return new BitCastInst(NewGEP, GEP.getType()); @@ -8651,7 +8656,10 @@ Instruction *InstCombiner::visitAllocationInst(AllocationInst &AI) { // insert our getelementptr instruction... // Value *NullIdx = Constant::getNullValue(Type::Int32Ty); - Value *V = new GetElementPtrInst(New, NullIdx, NullIdx, + Value *Idx[2]; + Idx[0] = NullIdx; + Idx[1] = NullIdx; + Value *V = new GetElementPtrInst(New, Idx, Idx + 2, New->getName()+".sub", It); // Now make everything use the getelementptr instead of the original diff --git a/lib/Transforms/Scalar/LowerGC.cpp b/lib/Transforms/Scalar/LowerGC.cpp index 0da1d9199ba..98070995afc 100644 --- a/lib/Transforms/Scalar/LowerGC.cpp +++ b/lib/Transforms/Scalar/LowerGC.cpp @@ -242,8 +242,11 @@ bool LowerGC::runOnFunction(Function &F) { Constant *Zero = ConstantInt::get(Type::Int32Ty, 0); Constant *One = ConstantInt::get(Type::Int32Ty, 1); + Value *Idx[2] = { Zero, Zero }; + // Get a pointer to the prev pointer. - Value *PrevPtrPtr = new GetElementPtrInst(AI, Zero, Zero, "prevptrptr", IP); + Value *PrevPtrPtr = new GetElementPtrInst(AI, Idx, Idx + 2, + "prevptrptr", IP); // Load the previous pointer. Value *PrevPtr = new LoadInst(RootChain, "prevptr", IP); @@ -251,7 +254,9 @@ bool LowerGC::runOnFunction(Function &F) { new StoreInst(PrevPtr, PrevPtrPtr, IP); // Set the number of elements in this record. - Value *NumEltsPtr = new GetElementPtrInst(AI, Zero, One, "numeltsptr", IP); + Idx[1] = One; + Value *NumEltsPtr = new GetElementPtrInst(AI, Idx, Idx + 2, + "numeltsptr", IP); new StoreInst(ConstantInt::get(Type::Int32Ty, GCRoots.size()), NumEltsPtr,IP); Value* Par[4]; @@ -267,13 +272,15 @@ bool LowerGC::runOnFunction(Function &F) { // Initialize the meta-data pointer. Par[2] = ConstantInt::get(Type::Int32Ty, i); Par[3] = One; - Value *MetaDataPtr = new GetElementPtrInst(AI, Par, 4, "MetaDataPtr", IP); + Value *MetaDataPtr = new GetElementPtrInst(AI, Par, Par + 4, + "MetaDataPtr", IP); assert(isa(GCRoots[i]->getOperand(2)) && "Must be a constant"); new StoreInst(GCRoots[i]->getOperand(2), MetaDataPtr, IP); // Initialize the root pointer to null on entry to the function. Par[3] = Zero; - Value *RootPtrPtr = new GetElementPtrInst(AI, Par, 4, "RootEntPtr", IP); + Value *RootPtrPtr = new GetElementPtrInst(AI, Par, Par + 4, + "RootEntPtr", IP); new StoreInst(Null, RootPtrPtr, IP); // Each occurrance of the llvm.gcroot intrinsic now turns into an diff --git a/lib/Transforms/Scalar/LowerPacked.cpp b/lib/Transforms/Scalar/LowerPacked.cpp index a701c75feb3..24a9cc20ee9 100644 --- a/lib/Transforms/Scalar/LowerPacked.cpp +++ b/lib/Transforms/Scalar/LowerPacked.cpp @@ -235,7 +235,7 @@ void LowerPacked::visitLoadInst(LoadInst& LI) // Get the pointer Value* val = new GetElementPtrInst(array, - &Idx[0], Idx.size(), + Idx.begin(), Idx.end(), LI.getName() + ".ge." + utostr(i), &LI); @@ -333,7 +333,7 @@ void LowerPacked::visitStoreInst(StoreInst& SI) // Generate the indices for getelementptr Idx[1] = ConstantInt::get(Type::Int32Ty,i); Value* val = new GetElementPtrInst(array, - &Idx[0], Idx.size(), + Idx.begin(), Idx.end(), "store.ge." + utostr(i) + ".", &SI); diff --git a/lib/Transforms/Scalar/ScalarReplAggregates.cpp b/lib/Transforms/Scalar/ScalarReplAggregates.cpp index 52edcb67af1..1092b889277 100644 --- a/lib/Transforms/Scalar/ScalarReplAggregates.cpp +++ b/lib/Transforms/Scalar/ScalarReplAggregates.cpp @@ -319,8 +319,8 @@ void SROA::DoScalarReplacement(AllocationInst *AI, SmallVector NewArgs; NewArgs.push_back(Constant::getNullValue(Type::Int32Ty)); NewArgs.append(GEPI->op_begin()+3, GEPI->op_end()); - RepValue = new GetElementPtrInst(AllocaToUse, &NewArgs[0], - NewArgs.size(), "", GEPI); + RepValue = new GetElementPtrInst(AllocaToUse, NewArgs.begin(), + NewArgs.end(), "", GEPI); RepValue->takeName(GEPI); } @@ -626,8 +626,10 @@ void SROA::RewriteBitCastUserOfAlloca(Instruction *BCInst, AllocationInst *AI, // If this is a memcpy/memmove, emit a GEP of the other element address. Value *OtherElt = 0; if (OtherPtr) { - OtherElt = new GetElementPtrInst(OtherPtr, Zero, - ConstantInt::get(Type::Int32Ty, i), + Value *Idx[2]; + Idx[0] = Zero; + Idx[1] = ConstantInt::get(Type::Int32Ty, i); + OtherElt = new GetElementPtrInst(OtherPtr, Idx, Idx + 2, OtherPtr->getNameStr()+"."+utostr(i), MI); } @@ -829,11 +831,13 @@ void SROA::CanonicalizeAllocaUsers(AllocationInst *AI) { SmallVector Indices(GEPI->op_begin()+1, GEPI->op_end()); Indices[1] = Constant::getNullValue(Type::Int32Ty); Value *ZeroIdx = new GetElementPtrInst(GEPI->getOperand(0), - &Indices[0], Indices.size(), + Indices.begin(), + Indices.end(), GEPI->getName()+".0", GEPI); Indices[1] = ConstantInt::get(Type::Int32Ty, 1); Value *OneIdx = new GetElementPtrInst(GEPI->getOperand(0), - &Indices[0], Indices.size(), + Indices.begin(), + Indices.end(), GEPI->getName()+".1", GEPI); // Replace all loads of the variable index GEP with loads from both // indexes and a select. diff --git a/lib/Transforms/Utils/CodeExtractor.cpp b/lib/Transforms/Utils/CodeExtractor.cpp index 90642f1b45e..c42d5e177d3 100644 --- a/lib/Transforms/Utils/CodeExtractor.cpp +++ b/lib/Transforms/Utils/CodeExtractor.cpp @@ -294,11 +294,12 @@ Function *CodeExtractor::constructFunction(const Values &inputs, for (unsigned i = 0, e = inputs.size(); i != e; ++i) { Value *RewriteVal; if (AggregateArgs) { - Value *Idx0 = Constant::getNullValue(Type::Int32Ty); - Value *Idx1 = ConstantInt::get(Type::Int32Ty, i); + Value *Idx[2]; + Idx[0] = Constant::getNullValue(Type::Int32Ty); + Idx[1] = ConstantInt::get(Type::Int32Ty, i); std::string GEPname = "gep_" + inputs[i]->getName(); TerminatorInst *TI = newFunction->begin()->getTerminator(); - GetElementPtrInst *GEP = new GetElementPtrInst(AI, Idx0, Idx1, + GetElementPtrInst *GEP = new GetElementPtrInst(AI, Idx, Idx+2, GEPname, TI); RewriteVal = new LoadInst(GEP, "load" + GEPname, TI); } else @@ -381,10 +382,11 @@ emitCallAndSwitchStatement(Function *newFunction, BasicBlock *codeReplacer, params.push_back(Struct); for (unsigned i = 0, e = inputs.size(); i != e; ++i) { - Value *Idx0 = Constant::getNullValue(Type::Int32Ty); - Value *Idx1 = ConstantInt::get(Type::Int32Ty, i); + Value *Idx[2]; + Idx[0] = Constant::getNullValue(Type::Int32Ty); + Idx[1] = ConstantInt::get(Type::Int32Ty, i); GetElementPtrInst *GEP = - new GetElementPtrInst(Struct, Idx0, Idx1, + new GetElementPtrInst(Struct, Idx, Idx + 2, "gep_" + StructValues[i]->getName()); codeReplacer->getInstList().push_back(GEP); StoreInst *SI = new StoreInst(StructValues[i], GEP); @@ -406,10 +408,11 @@ emitCallAndSwitchStatement(Function *newFunction, BasicBlock *codeReplacer, for (unsigned i = 0, e = outputs.size(); i != e; ++i) { Value *Output = 0; if (AggregateArgs) { - Value *Idx0 = Constant::getNullValue(Type::Int32Ty); - Value *Idx1 = ConstantInt::get(Type::Int32Ty, FirstOut + i); + Value *Idx[2]; + Idx[0] = Constant::getNullValue(Type::Int32Ty); + Idx[1] = ConstantInt::get(Type::Int32Ty, FirstOut + i); GetElementPtrInst *GEP - = new GetElementPtrInst(Struct, Idx0, Idx1, + = new GetElementPtrInst(Struct, Idx, Idx + 2, "gep_reload_" + outputs[i]->getName()); codeReplacer->getInstList().push_back(GEP); Output = GEP; @@ -506,10 +509,11 @@ emitCallAndSwitchStatement(Function *newFunction, BasicBlock *codeReplacer, if (DominatesDef) { if (AggregateArgs) { - Value *Idx0 = Constant::getNullValue(Type::Int32Ty); - Value *Idx1 = ConstantInt::get(Type::Int32Ty,FirstOut+out); + Value *Idx[2]; + Idx[0] = Constant::getNullValue(Type::Int32Ty); + Idx[1] = ConstantInt::get(Type::Int32Ty,FirstOut+out); GetElementPtrInst *GEP = - new GetElementPtrInst(OAI, Idx0, Idx1, + new GetElementPtrInst(OAI, Idx, Idx + 2, "gep_" + outputs[out]->getName(), NTRet); new StoreInst(outputs[out], GEP, NTRet); diff --git a/lib/Transforms/Utils/LowerInvoke.cpp b/lib/Transforms/Utils/LowerInvoke.cpp index ba0363594b0..acb2b529c27 100644 --- a/lib/Transforms/Utils/LowerInvoke.cpp +++ b/lib/Transforms/Utils/LowerInvoke.cpp @@ -450,8 +450,8 @@ bool LowerInvoke::insertExpensiveEHSupport(Function &F) { std::vector Idx; Idx.push_back(Constant::getNullValue(Type::Int32Ty)); Idx.push_back(ConstantInt::get(Type::Int32Ty, 1)); - OldJmpBufPtr = new GetElementPtrInst(JmpBuf, &Idx[0], 2, "OldBuf", - EntryBB->getTerminator()); + OldJmpBufPtr = new GetElementPtrInst(JmpBuf, Idx.begin(), Idx.end(), + "OldBuf", EntryBB->getTerminator()); // Copy the JBListHead to the alloca. Value *OldBuf = new LoadInst(JBListHead, "oldjmpbufptr", true, @@ -489,7 +489,7 @@ bool LowerInvoke::insertExpensiveEHSupport(Function &F) { "setjmp.cont"); Idx[1] = ConstantInt::get(Type::Int32Ty, 0); - Value *JmpBufPtr = new GetElementPtrInst(JmpBuf, &Idx[0], Idx.size(), + Value *JmpBufPtr = new GetElementPtrInst(JmpBuf, Idx.begin(), Idx.end(), "TheJmpBuf", EntryBB->getTerminator()); Value *SJRet = new CallInst(SetJmpFn, JmpBufPtr, "sjret", @@ -540,7 +540,8 @@ bool LowerInvoke::insertExpensiveEHSupport(Function &F) { std::vector Idx; Idx.push_back(Constant::getNullValue(Type::Int32Ty)); Idx.push_back(ConstantInt::get(Type::Int32Ty, 0)); - Idx[0] = new GetElementPtrInst(BufPtr, &Idx[0], 2, "JmpBuf", UnwindBlock); + Idx[0] = new GetElementPtrInst(BufPtr, Idx.begin(), Idx.end(), "JmpBuf", + UnwindBlock); Idx[1] = ConstantInt::get(Type::Int32Ty, 1); new CallInst(LongJmpFn, Idx.begin(), Idx.end(), "", UnwindBlock); new UnreachableInst(UnwindBlock); diff --git a/lib/VMCore/ConstantFold.cpp b/lib/VMCore/ConstantFold.cpp index c950e8d07ff..fb2e65f6ba6 100644 --- a/lib/VMCore/ConstantFold.cpp +++ b/lib/VMCore/ConstantFold.cpp @@ -1350,7 +1350,7 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred, } Constant *llvm::ConstantFoldGetElementPtr(const Constant *C, - Constant* const *Idxs, + Constant* const *Idxs, unsigned NumIdx) { if (NumIdx == 0 || (NumIdx == 1 && Idxs[0]->isNullValue())) @@ -1358,7 +1358,8 @@ Constant *llvm::ConstantFoldGetElementPtr(const Constant *C, if (isa(C)) { const Type *Ty = GetElementPtrInst::getIndexedType(C->getType(), - (Value**)Idxs, NumIdx, + (Value **)Idxs, + (Value **)Idxs+NumIdx, true); assert(Ty != 0 && "Invalid indices for GEP!"); return UndefValue::get(PointerType::get(Ty)); @@ -1374,7 +1375,8 @@ Constant *llvm::ConstantFoldGetElementPtr(const Constant *C, } if (isNull) { const Type *Ty = GetElementPtrInst::getIndexedType(C->getType(), - (Value**)Idxs, NumIdx, + (Value**)Idxs, + (Value**)Idxs+NumIdx, true); assert(Ty != 0 && "Invalid indices for GEP!"); return ConstantPointerNull::get(PointerType::get(Ty)); diff --git a/lib/VMCore/ConstantFold.h b/lib/VMCore/ConstantFold.h index e01fa770840..ffb7b1057e5 100644 --- a/lib/VMCore/ConstantFold.h +++ b/lib/VMCore/ConstantFold.h @@ -19,6 +19,8 @@ #ifndef CONSTANTFOLDING_H #define CONSTANTFOLDING_H +#include + namespace llvm { class Value; class Constant; @@ -46,6 +48,7 @@ namespace llvm { Constant *ConstantFoldCompareInstruction(unsigned short predicate, const Constant *C1, const Constant *C2); + Constant *ConstantFoldGetElementPtr(const Constant *C, Constant* const *Idxs, unsigned NumIdx); } // End llvm namespace diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp index 8e3d946ec47..f7cbe82e72a 100644 --- a/lib/VMCore/Constants.cpp +++ b/lib/VMCore/Constants.cpp @@ -1799,7 +1799,7 @@ Constant *ConstantExpr::getSelectTy(const Type *ReqTy, Constant *C, Constant *ConstantExpr::getGetElementPtrTy(const Type *ReqTy, Constant *C, Value* const *Idxs, unsigned NumIdx) { - assert(GetElementPtrInst::getIndexedType(C->getType(), Idxs, NumIdx, true) && + assert(GetElementPtrInst::getIndexedType(C->getType(), Idxs, Idxs+NumIdx, true) && "GEP indices invalid!"); if (Constant *FC = ConstantFoldGetElementPtr(C, (Constant**)Idxs, NumIdx)) @@ -1821,7 +1821,7 @@ Constant *ConstantExpr::getGetElementPtr(Constant *C, Value* const *Idxs, unsigned NumIdx) { // Get the result type of the getelementptr! const Type *Ty = - GetElementPtrInst::getIndexedType(C->getType(), Idxs, NumIdx, true); + GetElementPtrInst::getIndexedType(C->getType(), Idxs, Idxs+NumIdx, true); assert(Ty && "GEP indices invalid!"); return getGetElementPtrTy(PointerType::get(Ty), C, Idxs, NumIdx); } diff --git a/lib/VMCore/Instructions.cpp b/lib/VMCore/Instructions.cpp index bb11a4b87bc..369e98afe37 100644 --- a/lib/VMCore/Instructions.cpp +++ b/lib/VMCore/Instructions.cpp @@ -864,14 +864,6 @@ void StoreInst::setAlignment(unsigned Align) { // GetElementPtrInst Implementation //===----------------------------------------------------------------------===// -// checkType - Simple wrapper function to give a better assertion failure -// message on bad indexes for a gep instruction. -// -static inline const Type *checkType(const Type *Ty) { - assert(Ty && "Invalid GetElementPtrInst indices for type!"); - return Ty; -} - void GetElementPtrInst::init(Value *Ptr, Value* const *Idx, unsigned NumIdx) { NumOperands = 1+NumIdx; Use *OL = OperandList = new Use[NumOperands]; @@ -881,14 +873,6 @@ void GetElementPtrInst::init(Value *Ptr, Value* const *Idx, unsigned NumIdx) { OL[i+1].init(Idx[i], this); } -void GetElementPtrInst::init(Value *Ptr, Value *Idx0, Value *Idx1) { - NumOperands = 3; - Use *OL = OperandList = new Use[3]; - OL[0].init(Ptr, this); - OL[1].init(Idx0, this); - OL[2].init(Idx1, this); -} - void GetElementPtrInst::init(Value *Ptr, Value *Idx) { NumOperands = 2; Use *OL = OperandList = new Use[2]; @@ -896,27 +880,6 @@ void GetElementPtrInst::init(Value *Ptr, Value *Idx) { OL[1].init(Idx, this); } - -GetElementPtrInst::GetElementPtrInst(Value *Ptr, Value* const *Idx, - unsigned NumIdx, - const std::string &Name, Instruction *InBe) -: Instruction(PointerType::get(checkType(getIndexedType(Ptr->getType(), - Idx, NumIdx, true))), - GetElementPtr, 0, 0, InBe) { - init(Ptr, Idx, NumIdx); - setName(Name); -} - -GetElementPtrInst::GetElementPtrInst(Value *Ptr, Value* const *Idx, - unsigned NumIdx, - const std::string &Name, BasicBlock *IAE) -: Instruction(PointerType::get(checkType(getIndexedType(Ptr->getType(), - Idx, NumIdx, true))), - GetElementPtr, 0, 0, IAE) { - init(Ptr, Idx, NumIdx); - setName(Name); -} - GetElementPtrInst::GetElementPtrInst(Value *Ptr, Value *Idx, const std::string &Name, Instruction *InBe) : Instruction(PointerType::get(checkType(getIndexedType(Ptr->getType(),Idx))), @@ -933,24 +896,6 @@ GetElementPtrInst::GetElementPtrInst(Value *Ptr, Value *Idx, setName(Name); } -GetElementPtrInst::GetElementPtrInst(Value *Ptr, Value *Idx0, Value *Idx1, - const std::string &Name, Instruction *InBe) - : Instruction(PointerType::get(checkType(getIndexedType(Ptr->getType(), - Idx0, Idx1, true))), - GetElementPtr, 0, 0, InBe) { - init(Ptr, Idx0, Idx1); - setName(Name); -} - -GetElementPtrInst::GetElementPtrInst(Value *Ptr, Value *Idx0, Value *Idx1, - const std::string &Name, BasicBlock *IAE) - : Instruction(PointerType::get(checkType(getIndexedType(Ptr->getType(), - Idx0, Idx1, true))), - GetElementPtr, 0, 0, IAE) { - init(Ptr, Idx0, Idx1); - setName(Name); -} - GetElementPtrInst::~GetElementPtrInst() { delete[] OperandList; } @@ -999,24 +944,6 @@ const Type* GetElementPtrInst::getIndexedType(const Type *Ptr, return CurIdx == NumIdx ? Ptr : 0; } -const Type* GetElementPtrInst::getIndexedType(const Type *Ptr, - Value *Idx0, Value *Idx1, - bool AllowCompositeLeaf) { - const PointerType *PTy = dyn_cast(Ptr); - if (!PTy) return 0; // Type isn't a pointer type! - - // Check the pointer index. - if (!PTy->indexValid(Idx0)) return 0; - - const CompositeType *CT = dyn_cast(PTy->getElementType()); - if (!CT || !CT->indexValid(Idx1)) return 0; - - const Type *ElTy = CT->getTypeAtIndex(Idx1); - if (AllowCompositeLeaf || ElTy->isFirstClassType()) - return ElTy; - return 0; -} - const Type* GetElementPtrInst::getIndexedType(const Type *Ptr, Value *Idx) { const PointerType *PTy = dyn_cast(Ptr); if (!PTy) return 0; // Type isn't a pointer type! diff --git a/lib/VMCore/Verifier.cpp b/lib/VMCore/Verifier.cpp index 49f6abd0807..58bf485512a 100644 --- a/lib/VMCore/Verifier.cpp +++ b/lib/VMCore/Verifier.cpp @@ -913,7 +913,7 @@ void Verifier::visitGetElementPtrInst(GetElementPtrInst &GEP) { SmallVector Idxs(GEP.idx_begin(), GEP.idx_end()); const Type *ElTy = GetElementPtrInst::getIndexedType(GEP.getOperand(0)->getType(), - &Idxs[0], Idxs.size(), true); + Idxs.begin(), Idxs.end(), true); Assert1(ElTy, "Invalid indices for GEP pointer type!", &GEP); Assert2(isa(GEP.getType()) && cast(GEP.getType())->getElementType() == ElTy, diff --git a/tools/llvm-upgrade/UpgradeParser.y b/tools/llvm-upgrade/UpgradeParser.y index 5893fcd5ccc..9cc1af2ed9f 100644 --- a/tools/llvm-upgrade/UpgradeParser.y +++ b/tools/llvm-upgrade/UpgradeParser.y @@ -1533,8 +1533,8 @@ const Type* upgradeGEPCEIndices(const Type* PTy, } } Result.push_back(Index); - Ty = GetElementPtrInst::getIndexedType(PTy, (Value**)&Result[0], - Result.size(),true); + Ty = GetElementPtrInst::getIndexedType(PTy, Result.begin(), + Result.end(),true); if (!Ty) error("Index list invalid for constant getelementptr"); } @@ -1579,7 +1579,8 @@ const Type* upgradeGEPInstIndices(const Type* PTy, } } Result.push_back(Index); - Ty = GetElementPtrInst::getIndexedType(PTy, &Result[0], Result.size(),true); + Ty = GetElementPtrInst::getIndexedType(PTy, Result.begin(), + Result.end(),true); if (!Ty) error("Index list invalid for constant getelementptr"); } @@ -3890,7 +3891,7 @@ MemoryInst upgradeGEPInstIndices(Ty, $4, VIndices); Value* tmpVal = getVal(Ty, $3); - $$.I = new GetElementPtrInst(tmpVal, &VIndices[0], VIndices.size()); + $$.I = new GetElementPtrInst(tmpVal, VIndices.begin(), VIndices.end()); ValueInfo VI; VI.V = tmpVal; VI.S.copy($2.S); $$.S.copy(getElementSign(VI, VIndices)); delete $2.PAT; diff --git a/tools/llvm2cpp/CppWriter.cpp b/tools/llvm2cpp/CppWriter.cpp index 99d79def019..a481372cc3a 100644 --- a/tools/llvm2cpp/CppWriter.cpp +++ b/tools/llvm2cpp/CppWriter.cpp @@ -787,7 +787,8 @@ void CppWriter::printConstant(const Constant *CV) { Out << "Constant* " << constName << " = ConstantExpr::getGetElementPtr(" << getCppName(CE->getOperand(0)) << ", " - << "&" << constName << "_indices[0], " << CE->getNumOperands() - 1 + << constName << "_indices.begin(), " + << constName << "_indices.end(), " << " );"; } else if (CE->isCast()) { printConstant(CE->getOperand(0)); @@ -1253,8 +1254,8 @@ CppWriter::printInstruction(const Instruction *I, const std::string& bbname) { nl(Out); } Out << "Instruction* " << iName << " = new GetElementPtrInst(" - << opNames[0] << ", &" << iName << "_indices[0], " - << gep->getNumOperands() - 1; + << opNames[0] << ", " << iName << "_indices.begin(), " + << iName << "_indices.end()"; } Out << ", \""; printEscapedString(gep->getName()); -- 2.34.1