mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-21 18:29:46 +00:00
Convert IRBuilder::CreateGEP and IRBuilder::CreateInBoundsGEP to use
ArrayRef. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@135761 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
parent
48ac8e9be7
commit
0a2a60ace9
@ -644,6 +644,8 @@ from the previous release.</p>
|
||||
<li><code>InvokeInst::Create</code></li>
|
||||
<li><code>IRBuilder::CreateCall</code></li>
|
||||
<li><code>IRBuilder::CreateExtractValue</code></li>
|
||||
<li><code>IRBuilder::CreateGEP</code></li>
|
||||
<li><code>IRBuilder::CreateInBoundsGEP</code></li>
|
||||
<li><code>IRBuilder::CreateInsertValue</code></li>
|
||||
<li><code>IRBuilder::CreateInvoke</code></li>
|
||||
<li><code>MDNode::get</code></li>
|
||||
|
@ -762,41 +762,34 @@ public:
|
||||
StoreInst *CreateStore(Value *Val, Value *Ptr, bool isVolatile = false) {
|
||||
return Insert(new StoreInst(Val, Ptr, isVolatile));
|
||||
}
|
||||
template<typename RandomAccessIterator>
|
||||
Value *CreateGEP(Value *Ptr,
|
||||
RandomAccessIterator IdxBegin,
|
||||
RandomAccessIterator IdxEnd,
|
||||
Value *CreateGEP(Value *Ptr, ArrayRef<Value *> IdxList,
|
||||
const Twine &Name = "") {
|
||||
if (Constant *PC = dyn_cast<Constant>(Ptr)) {
|
||||
// Every index must be constant.
|
||||
RandomAccessIterator i;
|
||||
for (i = IdxBegin; i < IdxEnd; ++i)
|
||||
if (!isa<Constant>(*i))
|
||||
size_t i, e;
|
||||
for (i = 0, e = IdxList.size(); i != e; ++i)
|
||||
if (!isa<Constant>(IdxList[i]))
|
||||
break;
|
||||
if (i == IdxEnd)
|
||||
return Insert(Folder.CreateGetElementPtr(PC, makeArrayRef(IdxBegin,
|
||||
IdxEnd)),
|
||||
Name);
|
||||
if (i == e)
|
||||
return Insert(Folder.CreateGetElementPtr(PC, IdxList), Name);
|
||||
}
|
||||
return Insert(GetElementPtrInst::Create(Ptr, IdxBegin, IdxEnd), Name);
|
||||
return Insert(GetElementPtrInst::Create(Ptr, IdxList.begin(),
|
||||
IdxList.end()),
|
||||
Name);
|
||||
}
|
||||
template<typename RandomAccessIterator>
|
||||
Value *CreateInBoundsGEP(Value *Ptr, RandomAccessIterator IdxBegin,
|
||||
RandomAccessIterator IdxEnd,
|
||||
Value *CreateInBoundsGEP(Value *Ptr, ArrayRef<Value *> IdxList,
|
||||
const Twine &Name = "") {
|
||||
if (Constant *PC = dyn_cast<Constant>(Ptr)) {
|
||||
// Every index must be constant.
|
||||
RandomAccessIterator i;
|
||||
for (i = IdxBegin; i < IdxEnd; ++i)
|
||||
if (!isa<Constant>(*i))
|
||||
size_t i, e;
|
||||
for (i = 0, e = IdxList.size(); i != e; ++i)
|
||||
if (!isa<Constant>(IdxList[i]))
|
||||
break;
|
||||
if (i == IdxEnd)
|
||||
return Insert(Folder.CreateInBoundsGetElementPtr(PC,
|
||||
makeArrayRef(IdxBegin,
|
||||
IdxEnd)),
|
||||
Name);
|
||||
if (i == e)
|
||||
return Insert(Folder.CreateInBoundsGetElementPtr(PC, IdxList), Name);
|
||||
}
|
||||
return Insert(GetElementPtrInst::CreateInBounds(Ptr, IdxBegin, IdxEnd),
|
||||
return Insert(GetElementPtrInst::CreateInBounds(Ptr, IdxList.begin(),
|
||||
IdxList.end()),
|
||||
Name);
|
||||
}
|
||||
Value *CreateGEP(Value *Ptr, Value *Idx, const Twine &Name = "") {
|
||||
@ -817,7 +810,7 @@ public:
|
||||
if (Constant *PC = dyn_cast<Constant>(Ptr))
|
||||
return Insert(Folder.CreateGetElementPtr(PC, Idx), Name);
|
||||
|
||||
return Insert(GetElementPtrInst::Create(Ptr, &Idx, &Idx+1), Name);
|
||||
return Insert(GetElementPtrInst::Create(Ptr, Idx), Name);
|
||||
}
|
||||
Value *CreateConstInBoundsGEP1_32(Value *Ptr, unsigned Idx0,
|
||||
const Twine &Name = "") {
|
||||
@ -826,7 +819,7 @@ public:
|
||||
if (Constant *PC = dyn_cast<Constant>(Ptr))
|
||||
return Insert(Folder.CreateInBoundsGetElementPtr(PC, Idx), Name);
|
||||
|
||||
return Insert(GetElementPtrInst::CreateInBounds(Ptr, &Idx, &Idx+1), Name);
|
||||
return Insert(GetElementPtrInst::CreateInBounds(Ptr, Idx), Name);
|
||||
}
|
||||
Value *CreateConstGEP2_32(Value *Ptr, unsigned Idx0, unsigned Idx1,
|
||||
const Twine &Name = "") {
|
||||
@ -858,7 +851,7 @@ public:
|
||||
if (Constant *PC = dyn_cast<Constant>(Ptr))
|
||||
return Insert(Folder.CreateGetElementPtr(PC, Idx), Name);
|
||||
|
||||
return Insert(GetElementPtrInst::Create(Ptr, &Idx, &Idx+1), Name);
|
||||
return Insert(GetElementPtrInst::Create(Ptr, Idx), Name);
|
||||
}
|
||||
Value *CreateConstInBoundsGEP1_64(Value *Ptr, uint64_t Idx0,
|
||||
const Twine &Name = "") {
|
||||
@ -867,7 +860,7 @@ public:
|
||||
if (Constant *PC = dyn_cast<Constant>(Ptr))
|
||||
return Insert(Folder.CreateInBoundsGetElementPtr(PC, Idx), Name);
|
||||
|
||||
return Insert(GetElementPtrInst::CreateInBounds(Ptr, &Idx, &Idx+1), Name);
|
||||
return Insert(GetElementPtrInst::CreateInBounds(Ptr, Idx), Name);
|
||||
}
|
||||
Value *CreateConstGEP2_64(Value *Ptr, uint64_t Idx0, uint64_t Idx1,
|
||||
const Twine &Name = "") {
|
||||
@ -903,7 +896,7 @@ public:
|
||||
Value *gv = CreateGlobalString(Str, Name);
|
||||
Value *zero = ConstantInt::get(Type::getInt32Ty(Context), 0);
|
||||
Value *Args[] = { zero, zero };
|
||||
return CreateInBoundsGEP(gv, Args, Args+2, Name);
|
||||
return CreateInBoundsGEP(gv, Args, Name);
|
||||
}
|
||||
|
||||
//===--------------------------------------------------------------------===//
|
||||
|
@ -572,8 +572,7 @@ Value *SCEVExpander::expandAddToGEP(const SCEV *const *op_begin,
|
||||
if (V->getType() != PTy)
|
||||
Casted = InsertNoopCastOfTo(Casted, PTy);
|
||||
Value *GEP = Builder.CreateGEP(Casted,
|
||||
GepIndices.begin(),
|
||||
GepIndices.end(),
|
||||
GepIndices,
|
||||
"scevgep");
|
||||
Ops.push_back(SE.getUnknown(GEP));
|
||||
rememberInstruction(GEP);
|
||||
|
@ -340,7 +340,7 @@ ShadowStackGC::CreateGEP(LLVMContext &Context, IRBuilder<> &B, Value *BasePtr,
|
||||
Value *Indices[] = { ConstantInt::get(Type::getInt32Ty(Context), 0),
|
||||
ConstantInt::get(Type::getInt32Ty(Context), Idx),
|
||||
ConstantInt::get(Type::getInt32Ty(Context), Idx2) };
|
||||
Value* Val = B.CreateGEP(BasePtr, Indices, Indices + 3, Name);
|
||||
Value* Val = B.CreateGEP(BasePtr, Indices, Name);
|
||||
|
||||
assert(isa<GetElementPtrInst>(Val) && "Unexpected folded constant");
|
||||
|
||||
@ -352,7 +352,7 @@ ShadowStackGC::CreateGEP(LLVMContext &Context, IRBuilder<> &B, Value *BasePtr,
|
||||
int Idx, const char *Name) {
|
||||
Value *Indices[] = { ConstantInt::get(Type::getInt32Ty(Context), 0),
|
||||
ConstantInt::get(Type::getInt32Ty(Context), Idx) };
|
||||
Value *Val = B.CreateGEP(BasePtr, Indices, Indices + 2, Name);
|
||||
Value *Val = B.CreateGEP(BasePtr, Indices, Name);
|
||||
|
||||
assert(isa<GetElementPtrInst>(Val) && "Unexpected folded constant");
|
||||
|
||||
|
@ -1360,9 +1360,8 @@ Instruction *InstCombiner::commonPointerCastTransforms(CastInst &CI) {
|
||||
// and bitcast the result. This eliminates one bitcast, potentially
|
||||
// two.
|
||||
Value *NGEP = cast<GEPOperator>(GEP)->isInBounds() ?
|
||||
Builder->CreateInBoundsGEP(OrigBase,
|
||||
NewIndices.begin(), NewIndices.end()) :
|
||||
Builder->CreateGEP(OrigBase, NewIndices.begin(), NewIndices.end());
|
||||
Builder->CreateInBoundsGEP(OrigBase, NewIndices) :
|
||||
Builder->CreateGEP(OrigBase, NewIndices);
|
||||
NGEP->takeName(GEP);
|
||||
|
||||
if (isa<BitCastInst>(CI))
|
||||
|
@ -327,8 +327,7 @@ static Instruction *InstCombineStoreToCast(InstCombiner &IC, StoreInst &SI) {
|
||||
// SIOp0 is a pointer to aggregate and this is a store to the first field,
|
||||
// emit a GEP to index into its first field.
|
||||
if (!NewGEPIndices.empty())
|
||||
CastOp = IC.Builder->CreateInBoundsGEP(CastOp, NewGEPIndices.begin(),
|
||||
NewGEPIndices.end());
|
||||
CastOp = IC.Builder->CreateInBoundsGEP(CastOp, NewGEPIndices);
|
||||
|
||||
NewCast = IC.Builder->CreateCast(opcode, SIOp0, CastDstTy,
|
||||
SIOp0->getName()+".c");
|
||||
|
@ -916,8 +916,8 @@ Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) {
|
||||
Idx[0] = Constant::getNullValue(Type::getInt32Ty(GEP.getContext()));
|
||||
Idx[1] = GEP.getOperand(1);
|
||||
Value *NewGEP = GEP.isInBounds() ?
|
||||
Builder->CreateInBoundsGEP(StrippedPtr, Idx, Idx + 2, GEP.getName()) :
|
||||
Builder->CreateGEP(StrippedPtr, Idx, Idx + 2, GEP.getName());
|
||||
Builder->CreateInBoundsGEP(StrippedPtr, Idx, GEP.getName()) :
|
||||
Builder->CreateGEP(StrippedPtr, Idx, GEP.getName());
|
||||
// V and GEP are both pointer types --> BitCast
|
||||
return new BitCastInst(NewGEP, GEP.getType());
|
||||
}
|
||||
@ -975,8 +975,8 @@ Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) {
|
||||
Idx[0] = Constant::getNullValue(Type::getInt32Ty(GEP.getContext()));
|
||||
Idx[1] = NewIdx;
|
||||
Value *NewGEP = GEP.isInBounds() ?
|
||||
Builder->CreateInBoundsGEP(StrippedPtr, Idx, Idx + 2,GEP.getName()):
|
||||
Builder->CreateGEP(StrippedPtr, Idx, Idx + 2, GEP.getName());
|
||||
Builder->CreateInBoundsGEP(StrippedPtr, Idx, GEP.getName()):
|
||||
Builder->CreateGEP(StrippedPtr, Idx, GEP.getName());
|
||||
// The NewGEP must be pointer typed, so must the old one -> BitCast
|
||||
return new BitCastInst(NewGEP, GEP.getType());
|
||||
}
|
||||
@ -1027,10 +1027,8 @@ Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) {
|
||||
cast<PointerType>(BCI->getOperand(0)->getType())->getElementType();
|
||||
if (FindElementAtOffset(InTy, Offset, NewIndices)) {
|
||||
Value *NGEP = GEP.isInBounds() ?
|
||||
Builder->CreateInBoundsGEP(BCI->getOperand(0), NewIndices.begin(),
|
||||
NewIndices.end()) :
|
||||
Builder->CreateGEP(BCI->getOperand(0), NewIndices.begin(),
|
||||
NewIndices.end());
|
||||
Builder->CreateInBoundsGEP(BCI->getOperand(0), NewIndices) :
|
||||
Builder->CreateGEP(BCI->getOperand(0), NewIndices);
|
||||
|
||||
if (NGEP->getType() == GEP.getType())
|
||||
return ReplaceInstUsesWith(GEP, NGEP);
|
||||
@ -1322,8 +1320,7 @@ Instruction *InstCombiner::visitExtractValueInst(ExtractValueInst &EV) {
|
||||
// We need to insert these at the location of the old load, not at that of
|
||||
// the extractvalue.
|
||||
Builder->SetInsertPoint(L->getParent(), L);
|
||||
Value *GEP = Builder->CreateInBoundsGEP(L->getPointerOperand(),
|
||||
Indices.begin(), Indices.end());
|
||||
Value *GEP = Builder->CreateInBoundsGEP(L->getPointerOperand(), Indices);
|
||||
// Returning the load directly will cause the main loop to insert it in
|
||||
// the wrong spot, so use ReplaceInstUsesWith().
|
||||
return ReplaceInstUsesWith(EV, Builder->CreateLoad(GEP));
|
||||
|
@ -478,8 +478,7 @@ bool GCOVProfiler::emitProfileArcs(DebugInfoFinder &DIF) {
|
||||
SmallVector<Value *, 2> Idx;
|
||||
Idx.push_back(Constant::getNullValue(Type::getInt64Ty(*Ctx)));
|
||||
Idx.push_back(Sel);
|
||||
Value *Counter = Builder.CreateInBoundsGEP(Counters,
|
||||
Idx.begin(), Idx.end());
|
||||
Value *Counter = Builder.CreateInBoundsGEP(Counters, Idx);
|
||||
Value *Count = Builder.CreateLoad(Counter);
|
||||
Count = Builder.CreateAdd(Count,
|
||||
ConstantInt::get(Type::getInt64Ty(*Ctx),1));
|
||||
|
@ -1909,15 +1909,15 @@ LLVMValueRef LLVMBuildStore(LLVMBuilderRef B, LLVMValueRef Val,
|
||||
LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
|
||||
LLVMValueRef *Indices, unsigned NumIndices,
|
||||
const char *Name) {
|
||||
return wrap(unwrap(B)->CreateGEP(unwrap(Pointer), unwrap(Indices),
|
||||
unwrap(Indices) + NumIndices, Name));
|
||||
ArrayRef<Value *> IdxList(unwrap(Indices), NumIndices);
|
||||
return wrap(unwrap(B)->CreateGEP(unwrap(Pointer), IdxList, Name));
|
||||
}
|
||||
|
||||
LLVMValueRef LLVMBuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
|
||||
LLVMValueRef *Indices, unsigned NumIndices,
|
||||
const char *Name) {
|
||||
return wrap(unwrap(B)->CreateInBoundsGEP(unwrap(Pointer), unwrap(Indices),
|
||||
unwrap(Indices) + NumIndices, Name));
|
||||
ArrayRef<Value *> IdxList(unwrap(Indices), NumIndices);
|
||||
return wrap(unwrap(B)->CreateInBoundsGEP(unwrap(Pointer), IdxList, Name));
|
||||
}
|
||||
|
||||
LLVMValueRef LLVMBuildStructGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
|
||||
|
Loading…
Reference in New Issue
Block a user