[llvm] 2b1122e - [DebugInfo][RemoveDIs] Use iterator-insertion in unittests and fuzzer (#102015)
via llvm-commits
llvm-commits at lists.llvm.org
Thu Aug 8 07:18:39 PDT 2024
Author: Jeremy Morse
Date: 2024-08-08T15:18:34+01:00
New Revision: 2b1122eaec0d0b335feeac4adfaab2e3e04b7bd9
URL: https://github.com/llvm/llvm-project/commit/2b1122eaec0d0b335feeac4adfaab2e3e04b7bd9
DIFF: https://github.com/llvm/llvm-project/commit/2b1122eaec0d0b335feeac4adfaab2e3e04b7bd9.diff
LOG: [DebugInfo][RemoveDIs] Use iterator-insertion in unittests and fuzzer (#102015)
These are the final few places in LLVM that use instruction pointers to
insert instructions -- use iterators instead, which is needed for
debug-info correctness in the future. Most of this is a gentle
scattering of getIterator calls or not deref-then-addrofing iterators.
libfuzzer does require a storage change to keep built instruction
positions in a container though. The unit-test changes are very
straightforwards.
This leaves us in a position where libfuzzer can't fuzz on either of
debug-info records, however I don't believe that fuzzing of debug-info
is in scope for the library.
Added:
Modified:
llvm/include/llvm/FuzzMutate/OpDescriptor.h
llvm/lib/FuzzMutate/IRMutator.cpp
llvm/lib/FuzzMutate/Operations.cpp
llvm/lib/FuzzMutate/RandomIRBuilder.cpp
llvm/tools/llvm-reduce/deltas/ReduceOperandBundles.cpp
llvm/tools/llvm-stress/llvm-stress.cpp
llvm/unittests/Analysis/CGSCCPassManagerTest.cpp
llvm/unittests/Analysis/LazyCallGraphTest.cpp
llvm/unittests/Analysis/ScalarEvolutionTest.cpp
llvm/unittests/FuzzMutate/OperationsTest.cpp
llvm/unittests/IR/BasicBlockTest.cpp
llvm/unittests/Transforms/Utils/ScalarEvolutionExpanderTest.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/FuzzMutate/OpDescriptor.h b/llvm/include/llvm/FuzzMutate/OpDescriptor.h
index 00a8ea0e5babc6..78114074dbbfce 100644
--- a/llvm/include/llvm/FuzzMutate/OpDescriptor.h
+++ b/llvm/include/llvm/FuzzMutate/OpDescriptor.h
@@ -89,7 +89,7 @@ class SourcePred {
struct OpDescriptor {
unsigned Weight;
SmallVector<SourcePred, 2> SourcePreds;
- std::function<Value *(ArrayRef<Value *>, Instruction *)> BuilderFunc;
+ std::function<Value *(ArrayRef<Value *>, BasicBlock::iterator)> BuilderFunc;
};
static inline SourcePred onlyType(Type *Only) {
diff --git a/llvm/lib/FuzzMutate/IRMutator.cpp b/llvm/lib/FuzzMutate/IRMutator.cpp
index 3f27daad55e39b..72e0de59376076 100644
--- a/llvm/lib/FuzzMutate/IRMutator.cpp
+++ b/llvm/lib/FuzzMutate/IRMutator.cpp
@@ -148,7 +148,7 @@ void InjectorIRStrategy::mutate(BasicBlock &BB, RandomIRBuilder &IB) {
for (const auto &Pred : ArrayRef(OpDesc->SourcePreds).slice(1))
Srcs.push_back(IB.findOrCreateSource(BB, InstsBefore, Srcs, Pred));
- if (Value *Op = OpDesc->BuilderFunc(Srcs, Insts[IP])) {
+ if (Value *Op = OpDesc->BuilderFunc(Srcs, Insts[IP]->getIterator())) {
// Find a sink and wire up the results of the operation.
IB.connectToSink(BB, InstsAfter, Op);
}
@@ -388,9 +388,9 @@ void InsertFunctionStrategy::mutate(BasicBlock &BB, RandomIRBuilder &IB) {
}
bool isRetVoid = (F->getReturnType() == Type::getVoidTy(M->getContext()));
auto BuilderFunc = [FTy, F, isRetVoid](ArrayRef<Value *> Srcs,
- Instruction *Inst) {
+ BasicBlock::iterator InsertPt) {
StringRef Name = isRetVoid ? nullptr : "C";
- CallInst *Call = CallInst::Create(FTy, F, Srcs, Name, Inst);
+ CallInst *Call = CallInst::Create(FTy, F, Srcs, Name, InsertPt);
// Don't return this call inst if it return void as it can't be sinked.
return isRetVoid ? nullptr : Call;
};
@@ -414,7 +414,7 @@ void InsertFunctionStrategy::mutate(BasicBlock &BB, RandomIRBuilder &IB) {
Srcs.push_back(IB.findOrCreateSource(BB, InstsBefore, Srcs, Pred));
}
- if (Value *Op = BuilderFunc(Srcs, Insts[IP])) {
+ if (Value *Op = BuilderFunc(Srcs, Insts[IP]->getIterator())) {
// Find a sink and wire up the results of the operation.
IB.connectToSink(BB, InstsAfter, Op);
}
@@ -543,7 +543,7 @@ void InsertPHIStrategy::mutate(BasicBlock &BB, RandomIRBuilder &IB) {
if (&BB == &BB.getParent()->getEntryBlock())
return;
Type *Ty = IB.randomType();
- PHINode *PHI = PHINode::Create(Ty, llvm::pred_size(&BB), "", &BB.front());
+ PHINode *PHI = PHINode::Create(Ty, llvm::pred_size(&BB), "", BB.begin());
// Use a map to make sure the same incoming basic block has the same value.
DenseMap<BasicBlock *, Value *> IncomingValues;
diff --git a/llvm/lib/FuzzMutate/Operations.cpp b/llvm/lib/FuzzMutate/Operations.cpp
index 408f35879acd3b..389ff8130771c8 100644
--- a/llvm/lib/FuzzMutate/Operations.cpp
+++ b/llvm/lib/FuzzMutate/Operations.cpp
@@ -98,8 +98,8 @@ void llvm::describeFuzzerVectorOps(std::vector<fuzzerop::OpDescriptor> &Ops) {
}
OpDescriptor llvm::fuzzerop::selectDescriptor(unsigned Weight) {
- auto buildOp = [](ArrayRef<Value *> Srcs, Instruction *Inst) {
- return SelectInst::Create(Srcs[0], Srcs[1], Srcs[2], "S", Inst);
+ auto buildOp = [](ArrayRef<Value *> Srcs, BasicBlock::iterator InsertPt) {
+ return SelectInst::Create(Srcs[0], Srcs[1], Srcs[2], "S", InsertPt);
};
return {Weight,
{boolOrVecBoolType(), matchFirstLengthWAnyType(), matchSecondType()},
@@ -107,16 +107,16 @@ OpDescriptor llvm::fuzzerop::selectDescriptor(unsigned Weight) {
}
OpDescriptor llvm::fuzzerop::fnegDescriptor(unsigned Weight) {
- auto buildOp = [](ArrayRef<Value *> Srcs, Instruction *Inst) {
- return UnaryOperator::Create(Instruction::FNeg, Srcs[0], "F", Inst);
+ auto buildOp = [](ArrayRef<Value *> Srcs, BasicBlock::iterator InsertPt) {
+ return UnaryOperator::Create(Instruction::FNeg, Srcs[0], "F", InsertPt);
};
return {Weight, {anyFloatOrVecFloatType()}, buildOp};
}
OpDescriptor llvm::fuzzerop::binOpDescriptor(unsigned Weight,
Instruction::BinaryOps Op) {
- auto buildOp = [Op](ArrayRef<Value *> Srcs, Instruction *Inst) {
- return BinaryOperator::Create(Op, Srcs[0], Srcs[1], "B", Inst);
+ auto buildOp = [Op](ArrayRef<Value *> Srcs, BasicBlock::iterator InsertPt) {
+ return BinaryOperator::Create(Op, Srcs[0], Srcs[1], "B", InsertPt);
};
switch (Op) {
case Instruction::Add:
@@ -148,8 +148,9 @@ OpDescriptor llvm::fuzzerop::binOpDescriptor(unsigned Weight,
OpDescriptor llvm::fuzzerop::cmpOpDescriptor(unsigned Weight,
Instruction::OtherOps CmpOp,
CmpInst::Predicate Pred) {
- auto buildOp = [CmpOp, Pred](ArrayRef<Value *> Srcs, Instruction *Inst) {
- return CmpInst::Create(CmpOp, Pred, Srcs[0], Srcs[1], "C", Inst);
+ auto buildOp = [CmpOp, Pred](ArrayRef<Value *> Srcs,
+ BasicBlock::iterator InsertPt) {
+ return CmpInst::Create(CmpOp, Pred, Srcs[0], Srcs[1], "C", InsertPt);
};
switch (CmpOp) {
@@ -163,9 +164,10 @@ OpDescriptor llvm::fuzzerop::cmpOpDescriptor(unsigned Weight,
}
OpDescriptor llvm::fuzzerop::splitBlockDescriptor(unsigned Weight) {
- auto buildSplitBlock = [](ArrayRef<Value *> Srcs, Instruction *Inst) {
- BasicBlock *Block = Inst->getParent();
- BasicBlock *Next = Block->splitBasicBlock(Inst, "BB");
+ auto buildSplitBlock = [](ArrayRef<Value *> Srcs,
+ BasicBlock::iterator InsertPt) {
+ BasicBlock *Block = InsertPt->getParent();
+ BasicBlock *Next = Block->splitBasicBlock(InsertPt, "BB");
// If it was an exception handling block, we are done.
if (Block->isEHPad())
@@ -174,7 +176,8 @@ OpDescriptor llvm::fuzzerop::splitBlockDescriptor(unsigned Weight) {
// Loop back on this block by replacing the unconditional forward branch
// with a conditional with a backedge.
if (Block != &Block->getParent()->getEntryBlock()) {
- BranchInst::Create(Block, Next, Srcs[0], Block->getTerminator());
+ BranchInst::Create(Block, Next, Srcs[0],
+ Block->getTerminator()->getIterator());
Block->getTerminator()->eraseFromParent();
// We need values for each phi in the block. Since there isn't a good way
@@ -193,12 +196,12 @@ OpDescriptor llvm::fuzzerop::splitBlockDescriptor(unsigned Weight) {
}
OpDescriptor llvm::fuzzerop::gepDescriptor(unsigned Weight) {
- auto buildGEP = [](ArrayRef<Value *> Srcs, Instruction *Inst) {
+ auto buildGEP = [](ArrayRef<Value *> Srcs, BasicBlock::iterator InsertPt) {
// TODO: It would be better to generate a random type here, rather than
// generating a random value and picking its type.
Type *Ty = Srcs[1]->getType();
auto Indices = ArrayRef(Srcs).drop_front(2);
- return GetElementPtrInst::Create(Ty, Srcs[0], Indices, "G", Inst);
+ return GetElementPtrInst::Create(Ty, Srcs[0], Indices, "G", InsertPt);
};
// TODO: Handle aggregates and vectors
// TODO: Support multiple indices.
@@ -239,10 +242,11 @@ static SourcePred validExtractValueIndex() {
}
OpDescriptor llvm::fuzzerop::extractValueDescriptor(unsigned Weight) {
- auto buildExtract = [](ArrayRef<Value *> Srcs, Instruction *Inst) {
+ auto buildExtract = [](ArrayRef<Value *> Srcs,
+ BasicBlock::iterator InsertPt) {
// TODO: It's pretty inefficient to shuffle this all through constants.
unsigned Idx = cast<ConstantInt>(Srcs[1])->getZExtValue();
- return ExtractValueInst::Create(Srcs[0], {Idx}, "E", Inst);
+ return ExtractValueInst::Create(Srcs[0], {Idx}, "E", InsertPt);
};
// TODO: Should we handle multiple indices?
return {Weight, {anyAggregateType(), validExtractValueIndex()}, buildExtract};
@@ -298,10 +302,10 @@ static SourcePred validInsertValueIndex() {
}
OpDescriptor llvm::fuzzerop::insertValueDescriptor(unsigned Weight) {
- auto buildInsert = [](ArrayRef<Value *> Srcs, Instruction *Inst) {
+ auto buildInsert = [](ArrayRef<Value *> Srcs, BasicBlock::iterator InsertPt) {
// TODO: It's pretty inefficient to shuffle this all through constants.
unsigned Idx = cast<ConstantInt>(Srcs[2])->getZExtValue();
- return InsertValueInst::Create(Srcs[0], Srcs[1], {Idx}, "I", Inst);
+ return InsertValueInst::Create(Srcs[0], Srcs[1], {Idx}, "I", InsertPt);
};
return {
Weight,
@@ -310,16 +314,17 @@ OpDescriptor llvm::fuzzerop::insertValueDescriptor(unsigned Weight) {
}
OpDescriptor llvm::fuzzerop::extractElementDescriptor(unsigned Weight) {
- auto buildExtract = [](ArrayRef<Value *> Srcs, Instruction *Inst) {
- return ExtractElementInst::Create(Srcs[0], Srcs[1], "E", Inst);
+ auto buildExtract = [](ArrayRef<Value *> Srcs,
+ BasicBlock::iterator InsertPt) {
+ return ExtractElementInst::Create(Srcs[0], Srcs[1], "E", InsertPt);
};
// TODO: Try to avoid undefined accesses.
return {Weight, {anyVectorType(), anyIntType()}, buildExtract};
}
OpDescriptor llvm::fuzzerop::insertElementDescriptor(unsigned Weight) {
- auto buildInsert = [](ArrayRef<Value *> Srcs, Instruction *Inst) {
- return InsertElementInst::Create(Srcs[0], Srcs[1], Srcs[2], "I", Inst);
+ auto buildInsert = [](ArrayRef<Value *> Srcs, BasicBlock::iterator InsertPt) {
+ return InsertElementInst::Create(Srcs[0], Srcs[1], Srcs[2], "I", InsertPt);
};
// TODO: Try to avoid undefined accesses.
return {Weight,
@@ -343,8 +348,9 @@ static SourcePred validShuffleVectorIndex() {
}
OpDescriptor llvm::fuzzerop::shuffleVectorDescriptor(unsigned Weight) {
- auto buildShuffle = [](ArrayRef<Value *> Srcs, Instruction *Inst) {
- return new ShuffleVectorInst(Srcs[0], Srcs[1], Srcs[2], "S", Inst);
+ auto buildShuffle = [](ArrayRef<Value *> Srcs,
+ BasicBlock::iterator InsertPt) {
+ return new ShuffleVectorInst(Srcs[0], Srcs[1], Srcs[2], "S", InsertPt);
};
return {Weight,
{anyVectorType(), matchFirstType(), validShuffleVectorIndex()},
diff --git a/llvm/lib/FuzzMutate/RandomIRBuilder.cpp b/llvm/lib/FuzzMutate/RandomIRBuilder.cpp
index 5569888e5b28e8..fe4ad10a02d57d 100644
--- a/llvm/lib/FuzzMutate/RandomIRBuilder.cpp
+++ b/llvm/lib/FuzzMutate/RandomIRBuilder.cpp
@@ -69,9 +69,9 @@ AllocaInst *RandomIRBuilder::createStackMemory(Function *F, Type *Ty,
BasicBlock *EntryBB = &F->getEntryBlock();
DataLayout DL(F->getParent());
AllocaInst *Alloca = new AllocaInst(Ty, DL.getAllocaAddrSpace(), "A",
- &*EntryBB->getFirstInsertionPt());
+ EntryBB->getFirstInsertionPt());
if (Init)
- new StoreInst(Init, Alloca, Alloca->getNextNode());
+ new StoreInst(Init, Alloca, std::next(Alloca->getIterator()));
return Alloca;
}
@@ -165,7 +165,7 @@ Value *RandomIRBuilder::findOrCreateSource(BasicBlock &BB,
Type *Ty = GV->getValueType();
LoadInst *LoadGV = nullptr;
if (BB.getTerminator()) {
- LoadGV = new LoadInst(Ty, GV, "LGV", &*BB.getFirstInsertionPt());
+ LoadGV = new LoadInst(Ty, GV, "LGV", BB.getFirstInsertionPt());
} else {
LoadGV = new LoadInst(Ty, GV, "LGV", &BB);
}
@@ -213,7 +213,7 @@ Value *RandomIRBuilder::newSource(BasicBlock &BB, ArrayRef<Instruction *> Insts,
}
// Pick the type independently.
Type *AccessTy = RS.getSelection()->getType();
- auto *NewLoad = new LoadInst(AccessTy, Ptr, "L", &*IP);
+ auto *NewLoad = new LoadInst(AccessTy, Ptr, "L", IP);
// Only sample this load if it really matches the descriptor
if (Pred.matches(Srcs, NewLoad))
@@ -231,7 +231,8 @@ Value *RandomIRBuilder::newSource(BasicBlock &BB, ArrayRef<Instruction *> Insts,
Function *F = BB.getParent();
AllocaInst *Alloca = createStackMemory(F, Ty, newSrc);
if (BB.getTerminator()) {
- newSrc = new LoadInst(Ty, Alloca, /*ArrLen,*/ "L", BB.getTerminator());
+ newSrc = new LoadInst(Ty, Alloca, /*ArrLen,*/ "L",
+ BB.getTerminator()->getIterator());
} else {
newSrc = new LoadInst(Ty, Alloca, /*ArrLen,*/ "L", &BB);
}
@@ -325,7 +326,7 @@ Instruction *RandomIRBuilder::connectToSink(BasicBlock &BB,
for (BasicBlock *Dom : Dominators) {
for (Instruction &I : *Dom) {
if (isa<PointerType>(I.getType()))
- return new StoreInst(V, &I, Insts.back());
+ return new StoreInst(V, &I, Insts.back()->getIterator());
}
}
break;
@@ -351,7 +352,7 @@ Instruction *RandomIRBuilder::connectToSink(BasicBlock &BB,
Module *M = BB.getParent()->getParent();
auto [GV, DidCreate] =
findOrCreateGlobalVariable(M, {}, fuzzerop::onlyType(V->getType()));
- return new StoreInst(V, GV, Insts.back());
+ return new StoreInst(V, GV, Insts.back()->getIterator());
}
case EndOfValueSink:
default:
@@ -373,7 +374,7 @@ Instruction *RandomIRBuilder::newSink(BasicBlock &BB,
}
}
- return new StoreInst(V, Ptr, Insts.back());
+ return new StoreInst(V, Ptr, Insts.back()->getIterator());
}
Value *RandomIRBuilder::findPointer(BasicBlock &BB,
diff --git a/llvm/tools/llvm-reduce/deltas/ReduceOperandBundles.cpp b/llvm/tools/llvm-reduce/deltas/ReduceOperandBundles.cpp
index a211b6ac8d6cfc..d2274877f126b2 100644
--- a/llvm/tools/llvm-reduce/deltas/ReduceOperandBundles.cpp
+++ b/llvm/tools/llvm-reduce/deltas/ReduceOperandBundles.cpp
@@ -88,7 +88,8 @@ static void maybeRewriteCallWithDifferentBundles(
});
// Finally actually replace the bundles on the call.
- CallBase *NewCall = CallBase::Create(OrigCall, NewBundles, OrigCall);
+ CallBase *NewCall =
+ CallBase::Create(OrigCall, NewBundles, OrigCall->getIterator());
OrigCall->replaceAllUsesWith(NewCall);
OrigCall->eraseFromParent();
}
diff --git a/llvm/tools/llvm-stress/llvm-stress.cpp b/llvm/tools/llvm-stress/llvm-stress.cpp
index 80fb21038d304f..e44b6023fff231 100644
--- a/llvm/tools/llvm-stress/llvm-stress.cpp
+++ b/llvm/tools/llvm-stress/llvm-stress.cpp
@@ -336,7 +336,7 @@ struct LoadModifier: public Modifier {
// Try to use predefined pointers. If non-exist, use undef pointer value;
Value *Ptr = getRandomPointerValue();
Type *Ty = pickType();
- Value *V = new LoadInst(Ty, Ptr, "L", BB->getTerminator());
+ Value *V = new LoadInst(Ty, Ptr, "L", BB->getTerminator()->getIterator());
PT->push_back(V);
}
};
@@ -356,7 +356,7 @@ struct StoreModifier: public Modifier {
return;
Value *Val = getRandomValue(ValTy);
- new StoreInst(Val, Ptr, BB->getTerminator());
+ new StoreInst(Val, Ptr, BB->getTerminator()->getIterator());
}
};
@@ -399,7 +399,8 @@ struct BinModifier: public Modifier {
case 12:{Op = Instruction::Xor; break; }
}
- PT->push_back(BinaryOperator::Create(Op, Val0, Val1, "B", Term));
+ PT->push_back(
+ BinaryOperator::Create(Op, Val0, Val1, "B", Term->getIterator()));
}
};
@@ -462,8 +463,8 @@ struct AllocaModifier: public Modifier {
void Act() override {
Type *Tp = pickType();
const DataLayout &DL = BB->getDataLayout();
- PT->push_back(new AllocaInst(Tp, DL.getAllocaAddrSpace(),
- "A", BB->getFirstNonPHI()));
+ PT->push_back(new AllocaInst(Tp, DL.getAllocaAddrSpace(), "A",
+ BB->getFirstNonPHIIt()));
}
};
@@ -474,9 +475,8 @@ struct ExtractElementModifier: public Modifier {
void Act() override {
Value *Val0 = getRandomVectorValue();
Value *V = ExtractElementInst::Create(
- Val0,
- getRandomValue(Type::getInt32Ty(BB->getContext())),
- "E", BB->getTerminator());
+ Val0, getRandomValue(Type::getInt32Ty(BB->getContext())), "E",
+ BB->getTerminator()->getIterator());
return PT->push_back(V);
}
};
@@ -508,7 +508,7 @@ struct ShuffModifier: public Modifier {
Constant *Mask = ConstantVector::get(Idxs);
Value *V = new ShuffleVectorInst(Val0, Val1, Mask, "Shuff",
- BB->getTerminator());
+ BB->getTerminator()->getIterator());
PT->push_back(V);
}
};
@@ -522,9 +522,8 @@ struct InsertElementModifier: public Modifier {
Value *Val1 = getRandomValue(Val0->getType()->getScalarType());
Value *V = InsertElementInst::Create(
- Val0, Val1,
- getRandomValue(Type::getInt32Ty(BB->getContext())),
- "I", BB->getTerminator());
+ Val0, Val1, getRandomValue(Type::getInt32Ty(BB->getContext())), "I",
+ BB->getTerminator()->getIterator());
return PT->push_back(V);
}
};
@@ -550,7 +549,7 @@ struct CastModifier: public Modifier {
if (!DestTy->isPointerTy())
DestTy = PointerType::get(DestTy, 0);
return PT->push_back(
- new BitCastInst(V, DestTy, "PC", BB->getTerminator()));
+ new BitCastInst(V, DestTy, "PC", BB->getTerminator()->getIterator()));
}
unsigned VSize = VTy->getScalarType()->getPrimitiveSizeInBits();
@@ -559,47 +558,50 @@ struct CastModifier: public Modifier {
// Generate lots of bitcasts.
if ((getRandom() & 1) && VSize == DestSize) {
return PT->push_back(
- new BitCastInst(V, DestTy, "BC", BB->getTerminator()));
+ new BitCastInst(V, DestTy, "BC", BB->getTerminator()->getIterator()));
}
// Both types are integers:
if (VTy->isIntOrIntVectorTy() && DestTy->isIntOrIntVectorTy()) {
if (VSize > DestSize) {
return PT->push_back(
- new TruncInst(V, DestTy, "Tr", BB->getTerminator()));
+ new TruncInst(V, DestTy, "Tr", BB->getTerminator()->getIterator()));
} else {
assert(VSize < DestSize && "Different int types with the same size?");
if (getRandom() & 1)
- return PT->push_back(
- new ZExtInst(V, DestTy, "ZE", BB->getTerminator()));
- return PT->push_back(new SExtInst(V, DestTy, "Se", BB->getTerminator()));
+ return PT->push_back(new ZExtInst(
+ V, DestTy, "ZE", BB->getTerminator()->getIterator()));
+ return PT->push_back(
+ new SExtInst(V, DestTy, "Se", BB->getTerminator()->getIterator()));
}
}
// Fp to int.
if (VTy->isFPOrFPVectorTy() && DestTy->isIntOrIntVectorTy()) {
if (getRandom() & 1)
- return PT->push_back(
- new FPToSIInst(V, DestTy, "FC", BB->getTerminator()));
- return PT->push_back(new FPToUIInst(V, DestTy, "FC", BB->getTerminator()));
+ return PT->push_back(new FPToSIInst(
+ V, DestTy, "FC", BB->getTerminator()->getIterator()));
+ return PT->push_back(
+ new FPToUIInst(V, DestTy, "FC", BB->getTerminator()->getIterator()));
}
// Int to fp.
if (VTy->isIntOrIntVectorTy() && DestTy->isFPOrFPVectorTy()) {
if (getRandom() & 1)
- return PT->push_back(
- new SIToFPInst(V, DestTy, "FC", BB->getTerminator()));
- return PT->push_back(new UIToFPInst(V, DestTy, "FC", BB->getTerminator()));
+ return PT->push_back(new SIToFPInst(
+ V, DestTy, "FC", BB->getTerminator()->getIterator()));
+ return PT->push_back(
+ new UIToFPInst(V, DestTy, "FC", BB->getTerminator()->getIterator()));
}
// Both floats.
if (VTy->isFPOrFPVectorTy() && DestTy->isFPOrFPVectorTy()) {
if (VSize > DestSize) {
- return PT->push_back(
- new FPTruncInst(V, DestTy, "Tr", BB->getTerminator()));
+ return PT->push_back(new FPTruncInst(
+ V, DestTy, "Tr", BB->getTerminator()->getIterator()));
} else if (VSize < DestSize) {
return PT->push_back(
- new FPExtInst(V, DestTy, "ZE", BB->getTerminator()));
+ new FPExtInst(V, DestTy, "ZE", BB->getTerminator()->getIterator()));
}
// If VSize == DestSize, then the two types must be fp128 and ppc_fp128,
// for which there is no defined conversion. So do nothing.
@@ -625,7 +627,8 @@ struct SelectModifier: public Modifier {
CondTy = VectorType::get(CondTy, VTy->getElementCount());
Value *Cond = getRandomValue(CondTy);
- Value *V = SelectInst::Create(Cond, Val0, Val1, "Sl", BB->getTerminator());
+ Value *V = SelectInst::Create(Cond, Val0, Val1, "Sl",
+ BB->getTerminator()->getIterator());
return PT->push_back(V);
}
};
@@ -654,7 +657,7 @@ struct CmpModifier: public Modifier {
Value *V = CmpInst::Create(fp ? Instruction::FCmp : Instruction::ICmp,
(CmpInst::Predicate)op, Val0, Val1, "Cmp",
- BB->getTerminator());
+ BB->getTerminator()->getIterator());
return PT->push_back(V);
}
};
@@ -712,7 +715,8 @@ static void IntroduceControlFlow(Function *F, Random &R) {
BasicBlock *Next = Curr->splitBasicBlock(Loc, "CF");
Instr->moveBefore(Curr->getTerminator());
if (Curr != &F->getEntryBlock()) {
- BranchInst::Create(Curr, Next, Instr, Curr->getTerminator());
+ BranchInst::Create(Curr, Next, Instr,
+ Curr->getTerminator()->getIterator());
Curr->getTerminator()->eraseFromParent();
}
}
diff --git a/llvm/unittests/Analysis/CGSCCPassManagerTest.cpp b/llvm/unittests/Analysis/CGSCCPassManagerTest.cpp
index 9fd782d1b7614b..5c71bc8063d6c9 100644
--- a/llvm/unittests/Analysis/CGSCCPassManagerTest.cpp
+++ b/llvm/unittests/Analysis/CGSCCPassManagerTest.cpp
@@ -1205,7 +1205,7 @@ TEST_F(CGSCCPassManagerTest, TestAnalysisInvalidationCGSCCUpdate) {
// Insert a bitcast of `h3` so that we retain a ref edge to it.
(void)CastInst::CreatePointerCast(
&H3F, PointerType::getUnqual(H2F.getContext()), "dummy",
- &*H2F.begin()->begin());
+ H2F.begin()->begin());
// Now update the call graph.
auto &NewC =
@@ -1251,7 +1251,7 @@ TEST_F(CGSCCPassManagerTest, TestAnalysisInvalidationCGSCCUpdate) {
assert(H3F.getName() == "h3" && "Wrong called function!");
H2F.begin()->begin()->eraseFromParent();
// And insert a call to `h3`.
- (void)CallInst::Create(&H3F, {}, "", &*H2F.begin()->begin());
+ (void)CallInst::Create(&H3F, {}, "", H2F.begin()->begin());
// Now update the call graph.
auto &NewC =
@@ -1359,7 +1359,7 @@ TEST_F(CGSCCPassManagerTest, TestUpdateCGAndAnalysisManagerForPasses0) {
ASSERT_NE(FnH3, nullptr);
// And insert a call to `h1`, `h2`, and `h3`.
- Instruction *IP = &FnH2->getEntryBlock().front();
+ BasicBlock::iterator IP = FnH2->getEntryBlock().begin();
(void)CallInst::Create(FnH1, {}, "", IP);
(void)CallInst::Create(FnH2, {}, "", IP);
(void)CallInst::Create(FnH3, {}, "", IP);
@@ -1396,7 +1396,7 @@ TEST_F(CGSCCPassManagerTest, TestUpdateCGAndAnalysisManagerForPasses1) {
ASSERT_NE(FnH3, nullptr);
// And insert a call to `h1`, `h2`, and `h3`.
- Instruction *IP = &FnH2->getEntryBlock().front();
+ BasicBlock::iterator IP = FnH2->getEntryBlock().begin();
(void)CallInst::Create(FnH1, {}, "", IP);
(void)CallInst::Create(FnH2, {}, "", IP);
(void)CallInst::Create(FnH3, {}, "", IP);
@@ -1429,7 +1429,7 @@ TEST_F(CGSCCPassManagerTest, TestUpdateCGAndAnalysisManagerForPasses2) {
ASSERT_NE(FnH2, nullptr);
// And insert a call to `h2`
- Instruction *IP = &FnF->getEntryBlock().front();
+ BasicBlock::iterator IP = FnF->getEntryBlock().begin();
(void)CallInst::Create(FnH2, {}, "", IP);
auto &FN = *llvm::find_if(
@@ -1460,7 +1460,7 @@ TEST_F(CGSCCPassManagerTest, TestUpdateCGAndAnalysisManagerForPasses3) {
ASSERT_NE(FnH2, nullptr);
// And insert a call to `h2`
- Instruction *IP = &FnF->getEntryBlock().front();
+ BasicBlock::iterator IP = FnF->getEntryBlock().begin();
(void)CallInst::Create(FnH2, {}, "", IP);
auto &FN = *llvm::find_if(
@@ -1492,7 +1492,7 @@ TEST_F(CGSCCPassManagerTest, TestUpdateCGAndAnalysisManagerForPasses4) {
ReturnInst::Create(FnewF->getContext(), BB);
// And insert a call to `newF`
- Instruction *IP = &FnF->getEntryBlock().front();
+ BasicBlock::iterator IP = FnF->getEntryBlock().begin();
(void)CallInst::Create(FnewF, {}, "", IP);
// Use the CallGraphUpdater to update the call graph for the new
@@ -1536,7 +1536,7 @@ TEST_F(CGSCCPassManagerTest, TestUpdateCGAndAnalysisManagerForPasses5) {
CGU.initialize(CG, C, AM, UR);
// And insert a call to `newF`
- Instruction *IP = &FnF->getEntryBlock().front();
+ BasicBlock::iterator IP = FnF->getEntryBlock().begin();
(void)CallInst::Create(FnewF, {}, "", IP);
auto &FN = *llvm::find_if(
@@ -1569,7 +1569,7 @@ TEST_F(CGSCCPassManagerTest, TestUpdateCGAndAnalysisManagerForPasses6) {
ASSERT_NE(FnH3, nullptr);
// And insert a call to `h1`, `h2`, and `h3`.
- Instruction *IP = &FnH2->getEntryBlock().front();
+ BasicBlock::iterator IP = FnH2->getEntryBlock().begin();
(void)CallInst::Create(FnH1, {}, "", IP);
(void)CallInst::Create(FnH2, {}, "", IP);
(void)CallInst::Create(FnH3, {}, "", IP);
@@ -1600,7 +1600,7 @@ TEST_F(CGSCCPassManagerTest, TestUpdateCGAndAnalysisManagerForPasses7) {
ASSERT_NE(FnH2, nullptr);
// And insert a call to `h2`
- Instruction *IP = &FnF->getEntryBlock().front();
+ BasicBlock::iterator IP = FnF->getEntryBlock().begin();
(void)CallInst::Create(FnH2, {}, "", IP);
// Use the CallGraphUpdater to update the call graph for the new
@@ -1690,7 +1690,7 @@ TEST_F(CGSCCPassManagerTest, TestUpdateCGAndAnalysisManagerForPasses10) {
ASSERT_NE(FnH3, nullptr);
// And insert a call to `h1`, and `h3`.
- Instruction *IP = &FnH1->getEntryBlock().front();
+ BasicBlock::iterator IP = FnH1->getEntryBlock().begin();
(void)CallInst::Create(FnH1, {}, "", IP);
(void)CallInst::Create(FnH3, {}, "", IP);
@@ -1763,11 +1763,11 @@ TEST_F(CGSCCPassManagerTest, TestInsertionOfNewFunctions1) {
// 2. Insert a ref edge from 'f' to 'f'.
(void)CastInst::CreatePointerCast(
&F, PointerType::getUnqual(F.getContext()), "f.ref",
- &F.getEntryBlock().front());
+ F.getEntryBlock().begin());
// 3. Insert a ref edge from 'f' to 'g'.
(void)CastInst::CreatePointerCast(
G, PointerType::getUnqual(F.getContext()), "g.ref",
- &F.getEntryBlock().front());
+ F.getEntryBlock().begin());
CG.addSplitFunction(F, *G);
@@ -1827,9 +1827,9 @@ TEST_F(CGSCCPassManagerTest, TestInsertionOfNewFunctions2) {
(void)ReturnInst::Create(G2->getContext(), G2BB);
// Add 'f -> g1' call edge.
- (void)CallInst::Create(G1, {}, "", &F.getEntryBlock().front());
+ (void)CallInst::Create(G1, {}, "", F.getEntryBlock().begin());
// Add 'f -> g2' call edge.
- (void)CallInst::Create(G2, {}, "", &F.getEntryBlock().front());
+ (void)CallInst::Create(G2, {}, "", F.getEntryBlock().begin());
CG.addSplitFunction(F, *G1);
CG.addSplitFunction(F, *G2);
@@ -1853,11 +1853,11 @@ TEST_F(CGSCCPassManagerTest, TestInsertionOfNewFunctions2) {
// Add 'f -> h1' ref edge.
(void)CastInst::CreatePointerCast(H1,
PointerType::getUnqual(F.getContext()),
- "h1.ref", &F.getEntryBlock().front());
+ "h1.ref", F.getEntryBlock().begin());
// Add 'f -> h2' ref edge.
(void)CastInst::CreatePointerCast(H2,
PointerType::getUnqual(F.getContext()),
- "h2.ref", &F.getEntryBlock().front());
+ "h2.ref", F.getEntryBlock().begin());
CG.addSplitRefRecursiveFunctions(F, SmallVector<Function *, 2>({H1, H2}));
@@ -1980,7 +1980,8 @@ TEST_F(CGSCCPassManagerTest, TestInsertionOfNewNonTrivialCallEdge) {
ASSERT_TRUE(F3 != nullptr);
// Create call from f1 to f3.
- (void)CallInst::Create(F3, {}, "", F.getEntryBlock().getTerminator());
+ (void)CallInst::Create(F3, {}, "",
+ F.getEntryBlock().getTerminator()->getIterator());
ASSERT_NO_FATAL_FAILURE(
updateCGAndAnalysisManagerForCGSCCPass(CG, C, *N, AM, UR, FAM))
diff --git a/llvm/unittests/Analysis/LazyCallGraphTest.cpp b/llvm/unittests/Analysis/LazyCallGraphTest.cpp
index 64b6ccddc53b0c..6cfc01ed81102f 100644
--- a/llvm/unittests/Analysis/LazyCallGraphTest.cpp
+++ b/llvm/unittests/Analysis/LazyCallGraphTest.cpp
@@ -2357,7 +2357,7 @@ TEST(LazyCallGraphTest, AddSplitFunction1) {
(void)ReturnInst::Create(Context, GBB);
// Create f -call-> g.
- (void)CallInst::Create(G, {}, "", &*F.getEntryBlock().begin());
+ (void)CallInst::Create(G, {}, "", F.getEntryBlock().begin());
EXPECT_FALSE(verifyModule(*M, &errs()));
@@ -2398,7 +2398,7 @@ TEST(LazyCallGraphTest, AddSplitFunction2) {
// Create f -ref-> g.
(void)CastInst::CreatePointerCast(G, PointerType::getUnqual(Context), "",
- &*F.getEntryBlock().begin());
+ F.getEntryBlock().begin());
EXPECT_FALSE(verifyModule(*M, &errs()));
@@ -2441,7 +2441,7 @@ TEST(LazyCallGraphTest, AddSplitFunction3) {
(void)ReturnInst::Create(Context, GBB);
// Create f -call-> g.
- (void)CallInst::Create(G, {}, "", &*F.getEntryBlock().begin());
+ (void)CallInst::Create(G, {}, "", F.getEntryBlock().begin());
EXPECT_FALSE(verifyModule(*M, &errs()));
@@ -2487,7 +2487,7 @@ TEST(LazyCallGraphTest, AddSplitFunction4) {
// Create f -ref-> g.
(void)CastInst::CreatePointerCast(G, PointerType::getUnqual(Context), "",
- &*F.getEntryBlock().begin());
+ F.getEntryBlock().begin());
EXPECT_FALSE(verifyModule(*M, &errs()));
@@ -2533,7 +2533,7 @@ TEST(LazyCallGraphTest, AddSplitFunction5) {
// Create f -ref-> g.
(void)CastInst::CreatePointerCast(G, PointerType::getUnqual(Context), "",
- &*F.getEntryBlock().begin());
+ F.getEntryBlock().begin());
EXPECT_FALSE(verifyModule(*M, &errs()));
@@ -2577,7 +2577,7 @@ TEST(LazyCallGraphTest, AddSplitFunction6) {
(void)ReturnInst::Create(Context, GBB);
// Create f -call-> g.
- (void)CallInst::Create(G, {}, "", &*F.getEntryBlock().begin());
+ (void)CallInst::Create(G, {}, "", F.getEntryBlock().begin());
EXPECT_FALSE(verifyModule(*M, &errs()));
@@ -2628,7 +2628,7 @@ TEST(LazyCallGraphTest, AddSplitFunction7) {
(void)ReturnInst::Create(Context, GBB);
// Create f -call-> g.
- (void)CallInst::Create(G, {}, "", &*F.getEntryBlock().begin());
+ (void)CallInst::Create(G, {}, "", F.getEntryBlock().begin());
EXPECT_FALSE(verifyModule(*M, &errs()));
@@ -2681,7 +2681,7 @@ TEST(LazyCallGraphTest, AddSplitFunction8) {
// Create f -ref-> g.
(void)CastInst::CreatePointerCast(G, PointerType::getUnqual(Context), "",
- &*F.getEntryBlock().begin());
+ F.getEntryBlock().begin());
EXPECT_FALSE(verifyModule(*M, &errs()));
@@ -2734,7 +2734,7 @@ TEST(LazyCallGraphTest, AddSplitFunction9) {
(void)ReturnInst::Create(Context, GBB);
// Create f -call-> g.
- (void)CallInst::Create(G, {}, "", &*F.getEntryBlock().begin());
+ (void)CallInst::Create(G, {}, "", F.getEntryBlock().begin());
EXPECT_FALSE(verifyModule(*M, &errs()));
@@ -2778,7 +2778,7 @@ TEST(LazyCallGraphTest, AddSplitFunctions1) {
// Create f -ref-> g.
(void)CastInst::CreatePointerCast(G, PointerType::getUnqual(Context), "",
- &*F.getEntryBlock().begin());
+ F.getEntryBlock().begin());
EXPECT_FALSE(verifyModule(*M, &errs()));
@@ -2822,7 +2822,7 @@ TEST(LazyCallGraphTest, AddSplitFunctions2) {
// Create f -ref-> g.
(void)CastInst::CreatePointerCast(G, PointerType::getUnqual(Context), "",
- &*F.getEntryBlock().begin());
+ F.getEntryBlock().begin());
EXPECT_FALSE(verifyModule(*M, &errs()));
@@ -2875,9 +2875,9 @@ TEST(LazyCallGraphTest, AddSplitFunctions3) {
// Create f -ref-> g1 and f -ref-> g2.
(void)CastInst::CreatePointerCast(G1, PointerType::getUnqual(Context), "",
- &*F.getEntryBlock().begin());
+ F.getEntryBlock().begin());
(void)CastInst::CreatePointerCast(G2, PointerType::getUnqual(Context), "",
- &*F.getEntryBlock().begin());
+ F.getEntryBlock().begin());
EXPECT_FALSE(verifyModule(*M, &errs()));
@@ -2934,9 +2934,9 @@ TEST(LazyCallGraphTest, AddSplitFunctions4) {
// Create f -ref-> g1 and f -ref-> g2.
(void)CastInst::CreatePointerCast(G1, PointerType::getUnqual(Context), "",
- &*F.getEntryBlock().begin());
+ F.getEntryBlock().begin());
(void)CastInst::CreatePointerCast(G2, PointerType::getUnqual(Context), "",
- &*F.getEntryBlock().begin());
+ F.getEntryBlock().begin());
EXPECT_FALSE(verifyModule(*M, &errs()));
@@ -3004,9 +3004,9 @@ TEST(LazyCallGraphTest, AddSplitFunctions5) {
// Create f -ref-> g1 and f -ref-> g2.
(void)CastInst::CreatePointerCast(G1, PointerType::getUnqual(Context), "",
- &*F.getEntryBlock().begin());
+ F.getEntryBlock().begin());
(void)CastInst::CreatePointerCast(G2, PointerType::getUnqual(Context), "",
- &*F.getEntryBlock().begin());
+ F.getEntryBlock().begin());
EXPECT_FALSE(verifyModule(*M, &errs()));
diff --git a/llvm/unittests/Analysis/ScalarEvolutionTest.cpp b/llvm/unittests/Analysis/ScalarEvolutionTest.cpp
index 64a7503d30eedd..6fc24f6796310d 100644
--- a/llvm/unittests/Analysis/ScalarEvolutionTest.cpp
+++ b/llvm/unittests/Analysis/ScalarEvolutionTest.cpp
@@ -137,7 +137,7 @@ TEST_F(ScalarEvolutionsTest, SimplifiedPHI) {
LoopBB);
ReturnInst::Create(Context, nullptr, ExitBB);
auto *Ty = Type::getInt32Ty(Context);
- auto *PN = PHINode::Create(Ty, 2, "", &*LoopBB->begin());
+ auto *PN = PHINode::Create(Ty, 2, "", LoopBB->begin());
PN->addIncoming(Constant::getNullValue(Ty), EntryBB);
PN->addIncoming(UndefValue::get(Ty), LoopBB);
ScalarEvolution SE = buildSE(*F);
@@ -930,10 +930,12 @@ TEST_F(ScalarEvolutionsTest, SCEVAddRecFromPHIwithLargeConstants) {
auto *Int64_32 = ConstantInt::get(Context, APInt(64, 32));
auto *Br = BranchInst::Create(
LoopBB, ExitBB, UndefValue::get(Type::getInt1Ty(Context)), LoopBB);
- auto *Phi = PHINode::Create(Type::getInt64Ty(Context), 2, "", Br);
- auto *Shl = BinaryOperator::CreateShl(Phi, Int64_32, "", Br);
- auto *AShr = BinaryOperator::CreateExactAShr(Shl, Int64_32, "", Br);
- auto *Add = BinaryOperator::CreateAdd(AShr, MinInt64, "", Br);
+ auto *Phi =
+ PHINode::Create(Type::getInt64Ty(Context), 2, "", Br->getIterator());
+ auto *Shl = BinaryOperator::CreateShl(Phi, Int64_32, "", Br->getIterator());
+ auto *AShr =
+ BinaryOperator::CreateExactAShr(Shl, Int64_32, "", Br->getIterator());
+ auto *Add = BinaryOperator::CreateAdd(AShr, MinInt64, "", Br->getIterator());
Phi->addIncoming(MinInt64, EntryBB);
Phi->addIncoming(Add, LoopBB);
// exit:
@@ -986,10 +988,11 @@ TEST_F(ScalarEvolutionsTest, SCEVAddRecFromPHIwithLargeConstantAccum) {
auto *Int32_16 = ConstantInt::get(Context, APInt(32, 16));
auto *Br = BranchInst::Create(
LoopBB, ExitBB, UndefValue::get(Type::getInt1Ty(Context)), LoopBB);
- auto *Phi = PHINode::Create(Int32Ty, 2, "", Br);
- auto *Shl = BinaryOperator::CreateShl(Phi, Int32_16, "", Br);
- auto *AShr = BinaryOperator::CreateExactAShr(Shl, Int32_16, "", Br);
- auto *Add = BinaryOperator::CreateAdd(AShr, MinInt32, "", Br);
+ auto *Phi = PHINode::Create(Int32Ty, 2, "", Br->getIterator());
+ auto *Shl = BinaryOperator::CreateShl(Phi, Int32_16, "", Br->getIterator());
+ auto *AShr =
+ BinaryOperator::CreateExactAShr(Shl, Int32_16, "", Br->getIterator());
+ auto *Add = BinaryOperator::CreateAdd(AShr, MinInt32, "", Br->getIterator());
auto *Arg = &*(F->arg_begin());
Phi->addIncoming(Arg, EntryBB);
Phi->addIncoming(Add, LoopBB);
diff --git a/llvm/unittests/FuzzMutate/OperationsTest.cpp b/llvm/unittests/FuzzMutate/OperationsTest.cpp
index be4c75423a89a5..bc972ad21d049f 100644
--- a/llvm/unittests/FuzzMutate/OperationsTest.cpp
+++ b/llvm/unittests/FuzzMutate/OperationsTest.cpp
@@ -261,7 +261,7 @@ TEST(OperationsTest, SplitBlock) {
// Create a block with only a return and split it on the return.
auto *BB = BasicBlock::Create(Ctx, "BB", F);
auto *RI = ReturnInst::Create(Ctx, BB);
- SBOp.BuilderFunc({UndefValue::get(Type::getInt1Ty(Ctx))}, RI);
+ SBOp.BuilderFunc({UndefValue::get(Type::getInt1Ty(Ctx))}, RI->getIterator());
// We should end up with an unconditional branch from BB to BB1, and the
// return ends up in BB1.
@@ -271,9 +271,9 @@ TEST(OperationsTest, SplitBlock) {
ASSERT_THAT(RI->getParent(), Eq(BB1));
// Now add an instruction to BB1 and split on that.
- auto *AI = new AllocaInst(Type::getInt8Ty(Ctx), 0, "a", RI);
+ auto *AI = new AllocaInst(Type::getInt8Ty(Ctx), 0, "a", RI->getIterator());
Value *Cond = ConstantInt::getFalse(Ctx);
- SBOp.BuilderFunc({Cond}, AI);
+ SBOp.BuilderFunc({Cond}, AI->getIterator());
// We should end up with a loop back on BB1 and the instruction we split on
// moves to BB2.
@@ -313,7 +313,7 @@ TEST(OperationsTest, SplitEHBlock) {
fuzzerop::OpDescriptor Descr = fuzzerop::splitBlockDescriptor(1);
- Descr.BuilderFunc({ConstantInt::getTrue(Ctx)}, &*BB.getFirstInsertionPt());
+ Descr.BuilderFunc({ConstantInt::getTrue(Ctx)}, BB.getFirstInsertionPt());
ASSERT_TRUE(!verifyModule(*M, &errs()));
}
@@ -346,7 +346,7 @@ TEST(OperationsTest, SplitBlockWithPhis) {
// Now we split the block with PHI nodes, making sure they're all updated.
Value *Cond = ConstantInt::getFalse(Ctx);
- SBOp.BuilderFunc({Cond}, RI);
+ SBOp.BuilderFunc({Cond}, RI->getIterator());
// Make sure the PHIs are updated with a value for the third incoming edge.
EXPECT_THAT(PHI1->getNumIncomingValues(), Eq(3u));
@@ -373,7 +373,7 @@ TEST(OperationsTest, GEP) {
ConstantInt::get(Int32Ty, 0)));
GEPOp.BuilderFunc({UndefValue::get(Int8PtrTy), ConstantInt::get(Int32Ty, 0)},
- RI);
+ RI->getIterator());
EXPECT_FALSE(verifyModule(M, &errs()));
}
diff --git a/llvm/unittests/IR/BasicBlockTest.cpp b/llvm/unittests/IR/BasicBlockTest.cpp
index 3756f227143a50..eea2746a352aa6 100644
--- a/llvm/unittests/IR/BasicBlockTest.cpp
+++ b/llvm/unittests/IR/BasicBlockTest.cpp
@@ -49,12 +49,15 @@ TEST(BasicBlockTest, PhiRange) {
// Now insert some PHI nodes.
auto *Int32Ty = Type::getInt32Ty(Context);
- auto *P1 = PHINode::Create(Int32Ty, /*NumReservedValues*/ 3, "phi.1", BI);
- auto *P2 = PHINode::Create(Int32Ty, /*NumReservedValues*/ 3, "phi.2", BI);
- auto *P3 = PHINode::Create(Int32Ty, /*NumReservedValues*/ 3, "phi.3", BI);
+ auto *P1 = PHINode::Create(Int32Ty, /*NumReservedValues*/ 3, "phi.1",
+ BI->getIterator());
+ auto *P2 = PHINode::Create(Int32Ty, /*NumReservedValues*/ 3, "phi.2",
+ BI->getIterator());
+ auto *P3 = PHINode::Create(Int32Ty, /*NumReservedValues*/ 3, "phi.3",
+ BI->getIterator());
// Some non-PHI nodes.
- auto *Sum = BinaryOperator::CreateAdd(P1, P2, "sum", BI);
+ auto *Sum = BinaryOperator::CreateAdd(P1, P2, "sum", BI->getIterator());
// Now wire up the incoming values that are interesting.
P1->addIncoming(P2, BB.get());
diff --git a/llvm/unittests/Transforms/Utils/ScalarEvolutionExpanderTest.cpp b/llvm/unittests/Transforms/Utils/ScalarEvolutionExpanderTest.cpp
index c4560cb9ce9b22..32870d9fb37378 100644
--- a/llvm/unittests/Transforms/Utils/ScalarEvolutionExpanderTest.cpp
+++ b/llvm/unittests/Transforms/Utils/ScalarEvolutionExpanderTest.cpp
@@ -99,22 +99,24 @@ TEST_F(ScalarEvolutionExpanderTest, ExpandPtrTypeSCEV) {
const DataLayout &DL = F->getDataLayout();
BranchInst *Br = BranchInst::Create(
LoopBB, ExitBB, UndefValue::get(Type::getInt1Ty(Context)), LoopBB);
- AllocaInst *Alloca =
- new AllocaInst(I32Ty, DL.getAllocaAddrSpace(), "alloca", Br);
+ AllocaInst *Alloca = new AllocaInst(I32Ty, DL.getAllocaAddrSpace(), "alloca",
+ Br->getIterator());
ConstantInt *Ci32 = ConstantInt::get(Context, APInt(32, 1));
GetElementPtrInst *Gep0 =
- GetElementPtrInst::Create(I32Ty, Alloca, Ci32, "gep0", Br);
- CastInst *CastA =
- CastInst::CreateBitOrPointerCast(Gep0, I8PtrTy, "bitcast1", Br);
+ GetElementPtrInst::Create(I32Ty, Alloca, Ci32, "gep0", Br->getIterator());
+ CastInst *CastA = CastInst::CreateBitOrPointerCast(Gep0, I8PtrTy, "bitcast1",
+ Br->getIterator());
GetElementPtrInst *Gep1 =
- GetElementPtrInst::Create(I8Ty, CastA, Ci32, "gep1", Br);
+ GetElementPtrInst::Create(I8Ty, CastA, Ci32, "gep1", Br->getIterator());
GetElementPtrInst *Gep2 = GetElementPtrInst::Create(
- I8Ty, UndefValue::get(I8PtrTy), Ci32, "gep2", Br);
+ I8Ty, UndefValue::get(I8PtrTy), Ci32, "gep2", Br->getIterator());
CmpInst *Cmp = CmpInst::Create(Instruction::ICmp, CmpInst::ICMP_ULT,
- UndefValue::get(I8PtrTy), CastA, "cmp", Br);
- SelectInst *Sel = SelectInst::Create(Cmp, Gep1, Gep2, "select", Br);
- CastInst *CastB =
- CastInst::CreateBitOrPointerCast(Sel, I32PtrTy, "bitcast2", Br);
+ UndefValue::get(I8PtrTy), CastA, "cmp",
+ Br->getIterator());
+ SelectInst *Sel =
+ SelectInst::Create(Cmp, Gep1, Gep2, "select", Br->getIterator());
+ CastInst *CastB = CastInst::CreateBitOrPointerCast(Sel, I32PtrTy, "bitcast2",
+ Br->getIterator());
ScalarEvolution SE = buildSE(*F);
const SCEV *S = SE.getSCEV(CastB);
More information about the llvm-commits
mailing list