caio/clang-p2996
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[DebugInfo][RemoveDIs] Use iterator-insertion in unittests and fuzzer (#102015)

Browse Source 
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.
This commit is contained in:
Jeremy Morse
2024-08-08 15:18:34 +01:00
committed by GitHub
parent 29817a9626
commit 2b1122eaec
12 changed files with 155 additions and 134 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
llvm/include/llvm/FuzzMutate/OpDescriptor.h
View File

@@ -89,7 +89,7 @@ public:
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) {

10
llvm/lib/FuzzMutate/IRMutator.cpp
View File

@@ -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;

54
llvm/lib/FuzzMutate/Operations.cpp
View File

@@ -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()},

17
llvm/lib/FuzzMutate/RandomIRBuilder.cpp
View File

@@ -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,

3
llvm/tools/llvm-reduce/deltas/ReduceOperandBundles.cpp
View File

@@ -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();
}

64
llvm/tools/llvm-stress/llvm-stress.cpp
View File

@@ -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();
}
}

37
llvm/unittests/Analysis/CGSCCPassManagerTest.cpp
View File

@@ -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))

34
llvm/unittests/Analysis/LazyCallGraphTest.cpp
View File

@@ -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()));

21
llvm/unittests/Analysis/ScalarEvolutionTest.cpp
View File

@@ -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);

12
llvm/unittests/FuzzMutate/OperationsTest.cpp
View File

@@ -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()));
}

11
llvm/unittests/IR/BasicBlockTest.cpp
View File

@@ -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());

24
llvm/unittests/Transforms/Utils/ScalarEvolutionExpanderTest.cpp
View File

@@ -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);