Changes in directory llvm/lib/VMCore:
ConstantFolding.cpp updated: 1.133 -> 1.134 ConstantFolding.h updated: 1.52 -> 1.53 Constants.cpp updated: 1.205 -> 1.206 Instructions.cpp updated: 1.66 -> 1.67 --- Log message: Revise APIs for creating constantexpr GEPs to not require the use of vectors. This allows us to eliminate many temporary vectors, and theirassociated malloc/free pairs. --- Diffs of the changes: (+47 -46) ConstantFolding.cpp | 37 +++++++++++++++++++++---------------- ConstantFolding.h | 4 +--- Constants.cpp | 41 +++++++++++++++++++---------------------- Instructions.cpp | 11 ++++++----- 4 files changed, 47 insertions(+), 46 deletions(-) Index: llvm/lib/VMCore/ConstantFolding.cpp diff -u llvm/lib/VMCore/ConstantFolding.cpp:1.133 llvm/lib/VMCore/ConstantFolding.cpp:1.134 --- llvm/lib/VMCore/ConstantFolding.cpp:1.133 Fri Jan 19 15:13:56 2007 +++ llvm/lib/VMCore/ConstantFolding.cpp Tue Jan 30 22:40:28 2007 @@ -23,6 +23,7 @@ #include "llvm/Instructions.h" #include "llvm/DerivedTypes.h" #include "llvm/Function.h" +#include "llvm/ADT/SmallVector.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/GetElementPtrTypeIterator.h" #include "llvm/Support/ManagedStatic.h" @@ -216,7 +217,7 @@ // the first element. If so, return the appropriate GEP instruction. if (const PointerType *PTy = dyn_cast<PointerType>(V->getType())) if (const PointerType *DPTy = dyn_cast<PointerType>(DestTy)) { - std::vector<Value*> IdxList; + SmallVector<Value*, 8> IdxList; IdxList.push_back(Constant::getNullValue(Type::Int32Ty)); const Type *ElTy = PTy->getElementType(); while (ElTy != DPTy->getElementType()) { @@ -236,7 +237,7 @@ if (ElTy == DPTy->getElementType()) return ConstantExpr::getGetElementPtr( - const_cast<Constant*>(V),IdxList); + const_cast<Constant*>(V), &IdxList[0], IdxList.size()); } // Handle casts from one packed constant to another. We know that the src @@ -1290,28 +1291,31 @@ } Constant *llvm::ConstantFoldGetElementPtr(const Constant *C, - const std::vector<Value*> &IdxList) { - if (IdxList.size() == 0 || - (IdxList.size() == 1 && cast<Constant>(IdxList[0])->isNullValue())) + Constant* const *Idxs, + unsigned NumIdx) { + if (NumIdx == 0 || + (NumIdx == 1 && Idxs[0]->isNullValue())) return const_cast<Constant*>(C); if (isa<UndefValue>(C)) { - const Type *Ty = GetElementPtrInst::getIndexedType(C->getType(), IdxList, + const Type *Ty = GetElementPtrInst::getIndexedType(C->getType(), + (Value**)Idxs, NumIdx, true); assert(Ty != 0 && "Invalid indices for GEP!"); return UndefValue::get(PointerType::get(Ty)); } - Constant *Idx0 = cast<Constant>(IdxList[0]); + Constant *Idx0 = Idxs[0]; if (C->isNullValue()) { bool isNull = true; - for (unsigned i = 0, e = IdxList.size(); i != e; ++i) - if (!cast<Constant>(IdxList[i])->isNullValue()) { + for (unsigned i = 0, e = NumIdx; i != e; ++i) + if (!Idxs[i]->isNullValue()) { isNull = false; break; } if (isNull) { - const Type *Ty = GetElementPtrInst::getIndexedType(C->getType(), IdxList, + const Type *Ty = GetElementPtrInst::getIndexedType(C->getType(), + (Value**)Idxs, NumIdx, true); assert(Ty != 0 && "Invalid indices for GEP!"); return ConstantPointerNull::get(PointerType::get(Ty)); @@ -1330,8 +1334,8 @@ LastTy = *I; if ((LastTy && isa<ArrayType>(LastTy)) || Idx0->isNullValue()) { - std::vector<Value*> NewIndices; - NewIndices.reserve(IdxList.size() + CE->getNumOperands()); + SmallVector<Value*, 16> NewIndices; + NewIndices.reserve(NumIdx + CE->getNumOperands()); for (unsigned i = 1, e = CE->getNumOperands()-1; i != e; ++i) NewIndices.push_back(CE->getOperand(i)); @@ -1353,8 +1357,9 @@ } NewIndices.push_back(Combined); - NewIndices.insert(NewIndices.end(), IdxList.begin()+1, IdxList.end()); - return ConstantExpr::getGetElementPtr(CE->getOperand(0), NewIndices); + NewIndices.insert(NewIndices.end(), Idxs+1, Idxs+NumIdx); + return ConstantExpr::getGetElementPtr(CE->getOperand(0), &NewIndices[0], + NewIndices.size()); } } @@ -1363,7 +1368,7 @@ // long 0, long 0) // To: int* getelementptr ([3 x int]* %X, long 0, long 0) // - if (CE->isCast() && IdxList.size() > 1 && Idx0->isNullValue()) + if (CE->isCast() && NumIdx > 1 && Idx0->isNullValue()) if (const PointerType *SPT = dyn_cast<PointerType>(CE->getOperand(0)->getType())) if (const ArrayType *SAT = dyn_cast<ArrayType>(SPT->getElementType())) @@ -1371,7 +1376,7 @@ dyn_cast<ArrayType>(cast<PointerType>(C->getType())->getElementType())) if (CAT->getElementType() == SAT->getElementType()) return ConstantExpr::getGetElementPtr( - (Constant*)CE->getOperand(0), IdxList); + (Constant*)CE->getOperand(0), Idxs, NumIdx); } return 0; } Index: llvm/lib/VMCore/ConstantFolding.h diff -u llvm/lib/VMCore/ConstantFolding.h:1.52 llvm/lib/VMCore/ConstantFolding.h:1.53 --- llvm/lib/VMCore/ConstantFolding.h:1.52 Sun Dec 24 12:52:08 2006 +++ llvm/lib/VMCore/ConstantFolding.h Tue Jan 30 22:40:28 2007 @@ -19,8 +19,6 @@ #ifndef CONSTANTFOLDING_H #define CONSTANTFOLDING_H -#include <vector> - namespace llvm { class Value; class Constant; @@ -49,7 +47,7 @@ const Constant *C1, const Constant *C2); Constant *ConstantFoldGetElementPtr(const Constant *C, - const std::vector<Value*> &IdxList); + Constant* const *Idxs, unsigned NumIdx); } // End llvm namespace #endif Index: llvm/lib/VMCore/Constants.cpp diff -u llvm/lib/VMCore/Constants.cpp:1.205 llvm/lib/VMCore/Constants.cpp:1.206 --- llvm/lib/VMCore/Constants.cpp:1.205 Fri Jan 26 01:37:34 2007 +++ llvm/lib/VMCore/Constants.cpp Tue Jan 30 22:40:28 2007 @@ -1377,7 +1377,8 @@ case Instruction::GetElementPtr: // Make everyone now use a constant of the new type... std::vector<Value*> Idx(OldC->op_begin()+1, OldC->op_end()); - New = ConstantExpr::getGetElementPtrTy(NewTy, OldC->getOperand(0), Idx); + New = ConstantExpr::getGetElementPtrTy(NewTy, OldC->getOperand(0), + &Idx[0], Idx.size()); break; } @@ -1744,45 +1745,41 @@ } Constant *ConstantExpr::getGetElementPtrTy(const Type *ReqTy, Constant *C, - const std::vector<Value*> &IdxList) { - assert(GetElementPtrInst::getIndexedType(C->getType(), IdxList, true) && + Value* const *Idxs, + unsigned NumIdx) { + assert(GetElementPtrInst::getIndexedType(C->getType(), Idxs, NumIdx, true) && "GEP indices invalid!"); - if (Constant *FC = ConstantFoldGetElementPtr(C, IdxList)) + if (Constant *FC = ConstantFoldGetElementPtr(C, (Constant**)Idxs, NumIdx)) return FC; // Fold a few common cases... assert(isa<PointerType>(C->getType()) && "Non-pointer type for constant GetElementPtr expression"); // Look up the constant in the table first to ensure uniqueness std::vector<Constant*> ArgVec; - ArgVec.reserve(IdxList.size()+1); + ArgVec.reserve(NumIdx+1); ArgVec.push_back(C); - for (unsigned i = 0, e = IdxList.size(); i != e; ++i) - ArgVec.push_back(cast<Constant>(IdxList[i])); - const ExprMapKeyType Key(Instruction::GetElementPtr,ArgVec); + for (unsigned i = 0; i != NumIdx; ++i) + ArgVec.push_back(cast<Constant>(Idxs[i])); + const ExprMapKeyType Key(Instruction::GetElementPtr, ArgVec); return ExprConstants->getOrCreate(ReqTy, Key); } -Constant *ConstantExpr::getGetElementPtr(Constant *C, - const std::vector<Constant*> &IdxList){ +Constant *ConstantExpr::getGetElementPtr(Constant *C, Value* const *Idxs, + unsigned NumIdx) { // Get the result type of the getelementptr! - std::vector<Value*> VIdxList(IdxList.begin(), IdxList.end()); - - const Type *Ty = GetElementPtrInst::getIndexedType(C->getType(), VIdxList, - true); + const Type *Ty = + GetElementPtrInst::getIndexedType(C->getType(), Idxs, NumIdx, true); assert(Ty && "GEP indices invalid!"); - return getGetElementPtrTy(PointerType::get(Ty), C, VIdxList); + return getGetElementPtrTy(PointerType::get(Ty), C, Idxs, NumIdx); } -Constant *ConstantExpr::getGetElementPtr(Constant *C, - const std::vector<Value*> &IdxList) { - // Get the result type of the getelementptr! - const Type *Ty = GetElementPtrInst::getIndexedType(C->getType(), IdxList, - true); - assert(Ty && "GEP indices invalid!"); - return getGetElementPtrTy(PointerType::get(Ty), C, IdxList); +Constant *ConstantExpr::getGetElementPtr(Constant *C, Constant* const *Idxs, + unsigned NumIdx) { + return getGetElementPtr(C, (Value* const *)Idxs, NumIdx); } + Constant * ConstantExpr::getICmp(unsigned short pred, Constant* LHS, Constant* RHS) { assert(LHS->getType() == RHS->getType()); Index: llvm/lib/VMCore/Instructions.cpp diff -u llvm/lib/VMCore/Instructions.cpp:1.66 llvm/lib/VMCore/Instructions.cpp:1.67 --- llvm/lib/VMCore/Instructions.cpp:1.66 Fri Jan 26 00:30:34 2007 +++ llvm/lib/VMCore/Instructions.cpp Tue Jan 30 22:40:28 2007 @@ -765,12 +765,13 @@ // pointer type. // const Type* GetElementPtrInst::getIndexedType(const Type *Ptr, - const std::vector<Value*> &Idx, + Value* const *Idxs, + unsigned NumIdx, bool AllowCompositeLeaf) { if (!isa<PointerType>(Ptr)) return 0; // Type isn't a pointer type! // Handle the special case of the empty set index set... - if (Idx.empty()) + if (NumIdx == 0) if (AllowCompositeLeaf || cast<PointerType>(Ptr)->getElementType()->isFirstClassType()) return cast<PointerType>(Ptr)->getElementType(); @@ -779,12 +780,12 @@ unsigned CurIdx = 0; while (const CompositeType *CT = dyn_cast<CompositeType>(Ptr)) { - if (Idx.size() == CurIdx) { + if (NumIdx == CurIdx) { if (AllowCompositeLeaf || CT->isFirstClassType()) return Ptr; return 0; // Can't load a whole structure or array!?!? } - Value *Index = Idx[CurIdx++]; + Value *Index = Idxs[CurIdx++]; if (isa<PointerType>(CT) && CurIdx != 1) return 0; // Can only index into pointer types at the first index! if (!CT->indexValid(Index)) return 0; @@ -798,7 +799,7 @@ Ptr = Ty; } } - return CurIdx == Idx.size() ? Ptr : 0; + return CurIdx == NumIdx ? Ptr : 0; } const Type* GetElementPtrInst::getIndexedType(const Type *Ptr, _______________________________________________ llvm-commits mailing list llvm-commits@cs.uiuc.edu http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits