From 2b1122eaec0d0b335feeac4adfaab2e3e04b7bd9 Mon Sep 17 00:00:00 2001 From: Jeremy Morse Date: Thu, 8 Aug 2024 15:18:34 +0100 Subject: [PATCH] [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. --- llvm/include/llvm/FuzzMutate/OpDescriptor.h | 2 +- llvm/lib/FuzzMutate/IRMutator.cpp | 10 +-- llvm/lib/FuzzMutate/Operations.cpp | 54 +++++++++------- llvm/lib/FuzzMutate/RandomIRBuilder.cpp | 17 ++--- .../deltas/ReduceOperandBundles.cpp | 3 +- llvm/tools/llvm-stress/llvm-stress.cpp | 64 ++++++++++--------- .../Analysis/CGSCCPassManagerTest.cpp | 37 +++++------ llvm/unittests/Analysis/LazyCallGraphTest.cpp | 34 +++++----- .../Analysis/ScalarEvolutionTest.cpp | 21 +++--- llvm/unittests/FuzzMutate/OperationsTest.cpp | 12 ++-- llvm/unittests/IR/BasicBlockTest.cpp | 11 ++-- .../Utils/ScalarEvolutionExpanderTest.cpp | 24 +++---- 12 files changed, 155 insertions(+), 134 deletions(-) diff --git a/llvm/include/llvm/FuzzMutate/OpDescriptor.h b/llvm/include/llvm/FuzzMutate/OpDescriptor.h index 00a8ea0e5bab..78114074dbbf 100644 --- a/llvm/include/llvm/FuzzMutate/OpDescriptor.h +++ b/llvm/include/llvm/FuzzMutate/OpDescriptor.h @@ -89,7 +89,7 @@ public: struct OpDescriptor { unsigned Weight; SmallVector SourcePreds; - std::function, Instruction *)> BuilderFunc; + std::function, BasicBlock::iterator)> BuilderFunc; }; static inline SourcePred onlyType(Type *Only) { diff --git a/llvm/lib/FuzzMutate/IRMutator.cpp b/llvm/lib/FuzzMutate/IRMutator.cpp index 3f27daad55e3..72e0de593760 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 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 IncomingValues; diff --git a/llvm/lib/FuzzMutate/Operations.cpp b/llvm/lib/FuzzMutate/Operations.cpp index 408f35879acd..389ff8130771 100644 --- a/llvm/lib/FuzzMutate/Operations.cpp +++ b/llvm/lib/FuzzMutate/Operations.cpp @@ -98,8 +98,8 @@ void llvm::describeFuzzerVectorOps(std::vector &Ops) { } OpDescriptor llvm::fuzzerop::selectDescriptor(unsigned Weight) { - auto buildOp = [](ArrayRef Srcs, Instruction *Inst) { - return SelectInst::Create(Srcs[0], Srcs[1], Srcs[2], "S", Inst); + auto buildOp = [](ArrayRef 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 Srcs, Instruction *Inst) { - return UnaryOperator::Create(Instruction::FNeg, Srcs[0], "F", Inst); + auto buildOp = [](ArrayRef 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 Srcs, Instruction *Inst) { - return BinaryOperator::Create(Op, Srcs[0], Srcs[1], "B", Inst); + auto buildOp = [Op](ArrayRef 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 Srcs, Instruction *Inst) { - return CmpInst::Create(CmpOp, Pred, Srcs[0], Srcs[1], "C", Inst); + auto buildOp = [CmpOp, Pred](ArrayRef 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 Srcs, Instruction *Inst) { - BasicBlock *Block = Inst->getParent(); - BasicBlock *Next = Block->splitBasicBlock(Inst, "BB"); + auto buildSplitBlock = [](ArrayRef 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 Srcs, Instruction *Inst) { + auto buildGEP = [](ArrayRef 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 Srcs, Instruction *Inst) { + auto buildExtract = [](ArrayRef Srcs, + BasicBlock::iterator InsertPt) { // TODO: It's pretty inefficient to shuffle this all through constants. unsigned Idx = cast(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 Srcs, Instruction *Inst) { + auto buildInsert = [](ArrayRef Srcs, BasicBlock::iterator InsertPt) { // TODO: It's pretty inefficient to shuffle this all through constants. unsigned Idx = cast(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 Srcs, Instruction *Inst) { - return ExtractElementInst::Create(Srcs[0], Srcs[1], "E", Inst); + auto buildExtract = [](ArrayRef 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 Srcs, Instruction *Inst) { - return InsertElementInst::Create(Srcs[0], Srcs[1], Srcs[2], "I", Inst); + auto buildInsert = [](ArrayRef 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 Srcs, Instruction *Inst) { - return new ShuffleVectorInst(Srcs[0], Srcs[1], Srcs[2], "S", Inst); + auto buildShuffle = [](ArrayRef 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 5569888e5b28..fe4ad10a02d5 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 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 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(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 a211b6ac8d6c..d2274877f126 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 80fb21038d30..e44b6023fff2 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 9fd782d1b761..5c71bc8063d6 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({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 64b6ccddc53b..6cfc01ed8110 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 64a7503d30ee..6fc24f679631 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 be4c75423a89..bc972ad21d04 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 3756f227143a..eea2746a352a 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 c4560cb9ce9b..32870d9fb373 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);