// 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
///
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<typename InputIterator>
+ 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<InputIterator>::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<typename InputIterator>
+ 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<InputIterator>::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<typename InputIterator>
+ 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<InputIterator>::iterator_category());
+ }
+ template<typename InputIterator>
+ 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<InputIterator>::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;
/// A null type is returned if the indices are invalid for the specified
/// pointer type.
///
+ template<typename InputIterator>
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<InputIterator>::
+ iterator_category()));
+ }
static const Type *getIndexedType(const Type *Ptr, Value *Idx);
inline op_iterator idx_begin() { return op_begin()+1; }
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<typename InputIterator>
+ 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));
}
//===--------------------------------------------------------------------===//
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");
if (!isa<PointerType>($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;
};
GEPIdx.push_back(Op);
}
- I = new GetElementPtrInst(BasePtr, &GEPIdx[0], GEPIdx.size());
+ I = new GetElementPtrInst(BasePtr, GEPIdx.begin(), GEPIdx.end());
break;
}
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;
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);
}
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);
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();
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();
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);
C->getName()+".gvnpre",
(*PI)->getTerminator());
else if (GetElementPtrInst* G = dyn_cast<GetElementPtrInst>(U))
- newVal = new GetElementPtrInst(s1, &sVarargs[0], sVarargs.size(),
+ newVal = new GetElementPtrInst(s1, sVarargs.begin(), sVarargs.end(),
G->getName()+".gvnpre",
(*PI)->getTerminator());
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);
// 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);
// If we found a path from the src to dest, create the getelementptr now.
if (SrcElTy == DstElTy) {
SmallVector<Value*, 8> Idxs(NumZeros+1, ZeroUInt);
- return new GetElementPtrInst(Src, &Idxs[0], Idxs.size());
+ return new GetElementPtrInst(Src, Idxs.begin(), Idxs.end());
}
}
}
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<GlobalValue>(PtrOp)) {
// GEP of global variable. If all of the indices for this GEP are
if (isa<ArrayType>(SrcElTy) &&
TD->getTypeSize(cast<ArrayType>(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());
}
}
// 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());
// 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
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);
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];
// 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<Constant>(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
// Get the pointer
Value* val = new GetElementPtrInst(array,
- &Idx[0], Idx.size(),
+ Idx.begin(), Idx.end(),
LI.getName() +
".ge." + utostr(i),
&LI);
// 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);
SmallVector<Value*, 8> 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);
}
// 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);
}
SmallVector<Value*, 8> 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.
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
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);
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;
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);
std::vector<Value*> 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,
"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",
std::vector<Value*> 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);
}
Constant *llvm::ConstantFoldGetElementPtr(const Constant *C,
- Constant* const *Idxs,
+ Constant* const *Idxs,
unsigned NumIdx) {
if (NumIdx == 0 ||
(NumIdx == 1 && Idxs[0]->isNullValue()))
if (isa<UndefValue>(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));
}
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));
#ifndef CONSTANTFOLDING_H
#define CONSTANTFOLDING_H
+#include <iterator>
+
namespace llvm {
class Value;
class Constant;
Constant *ConstantFoldCompareInstruction(unsigned short predicate,
const Constant *C1,
const Constant *C2);
+
Constant *ConstantFoldGetElementPtr(const Constant *C,
Constant* const *Idxs, unsigned NumIdx);
} // End llvm namespace
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))
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);
}
// 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];
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];
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))),
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;
}
return CurIdx == NumIdx ? Ptr : 0;
}
-const Type* GetElementPtrInst::getIndexedType(const Type *Ptr,
- Value *Idx0, Value *Idx1,
- bool AllowCompositeLeaf) {
- const PointerType *PTy = dyn_cast<PointerType>(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<CompositeType>(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<PointerType>(Ptr);
if (!PTy) return 0; // Type isn't a pointer type!
SmallVector<Value*, 16> 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<PointerType>(GEP.getType()) &&
cast<PointerType>(GEP.getType())->getElementType() == ElTy,
}
}
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");
}
}
}
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");
}
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;
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));
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());