[clang] [llvm] Remove remaining uses of Instruction-constructors that insert before another Instruction (PR #85981)
Stephen Tozer via cfe-commits
cfe-commits at lists.llvm.org
Fri Apr 5 08:45:49 PDT 2024
https://github.com/SLTozer updated https://github.com/llvm/llvm-project/pull/85981
>From b2f6d93d87082dd0ccc91a9a8094a4c3552b81a2 Mon Sep 17 00:00:00 2001
From: Stephen Tozer <stephen.tozer at sony.com>
Date: Wed, 20 Mar 2024 17:43:10 +0000
Subject: [PATCH 1/2] Assorted fixes since rebase and outside core llvm
---
clang/lib/CodeGen/CGCUDANV.cpp | 6 +-
clang/lib/CodeGen/CGCall.cpp | 4 +-
clang/lib/CodeGen/CGCleanup.cpp | 8 ++-
clang/lib/CodeGen/CGCoroutine.cpp | 5 +-
clang/lib/CodeGen/CGExpr.cpp | 2 +-
clang/lib/CodeGen/CGObjC.cpp | 3 +-
clang/lib/CodeGen/CodeGenFunction.h | 4 +-
clang/lib/CodeGen/CodeGenModule.cpp | 10 +--
llvm/examples/IRTransforms/SimplifyCFG.cpp | 7 +-
llvm/include/llvm/IR/InstrTypes.h | 9 ---
llvm/lib/FuzzMutate/IRMutator.cpp | 5 +-
llvm/lib/FuzzMutate/Operations.cpp | 32 ++++++----
llvm/lib/FuzzMutate/RandomIRBuilder.cpp | 17 ++---
.../Instrumentation/AddressSanitizer.cpp | 4 +-
.../deltas/ReduceOperandBundles.cpp | 3 +-
llvm/tools/llvm-stress/llvm-stress.cpp | 64 ++++++++++---------
16 files changed, 98 insertions(+), 85 deletions(-)
diff --git a/clang/lib/CodeGen/CGCUDANV.cpp b/clang/lib/CodeGen/CGCUDANV.cpp
index 0cb5b06a519c00..13660fcd69b465 100644
--- a/clang/lib/CodeGen/CGCUDANV.cpp
+++ b/clang/lib/CodeGen/CGCUDANV.cpp
@@ -484,9 +484,9 @@ static void replaceManagedVar(llvm::GlobalVariable *Var,
}
if (auto *I = dyn_cast<llvm::Instruction>(U)) {
llvm::Value *OldV = Var;
- llvm::Instruction *NewV =
- new llvm::LoadInst(Var->getType(), ManagedVar, "ld.managed", false,
- llvm::Align(Var->getAlignment()), I);
+ llvm::Instruction *NewV = new llvm::LoadInst(
+ Var->getType(), ManagedVar, "ld.managed", false,
+ llvm::Align(Var->getAlignment()), I->getIterator());
WorkItem.pop_back();
// Replace constant expressions directly or indirectly using the managed
// variable with instructions.
diff --git a/clang/lib/CodeGen/CGCall.cpp b/clang/lib/CodeGen/CGCall.cpp
index f12765b826935b..3c8c3fe9f5e6e8 100644
--- a/clang/lib/CodeGen/CGCall.cpp
+++ b/clang/lib/CodeGen/CGCall.cpp
@@ -5062,8 +5062,8 @@ RValue CodeGenFunction::EmitCall(const CGFunctionInfo &CallInfo,
llvm::AllocaInst *AI;
if (IP) {
IP = IP->getNextNode();
- AI = new llvm::AllocaInst(ArgStruct, DL.getAllocaAddrSpace(),
- "argmem", IP);
+ AI = new llvm::AllocaInst(ArgStruct, DL.getAllocaAddrSpace(), "argmem",
+ IP->getIterator());
} else {
AI = CreateTempAlloca(ArgStruct, "argmem");
}
diff --git a/clang/lib/CodeGen/CGCleanup.cpp b/clang/lib/CodeGen/CGCleanup.cpp
index e6f8e6873004f2..3cd540c65d3b34 100644
--- a/clang/lib/CodeGen/CGCleanup.cpp
+++ b/clang/lib/CodeGen/CGCleanup.cpp
@@ -295,7 +295,8 @@ void EHScopeStack::Cleanup::anchor() {}
static void createStoreInstBefore(llvm::Value *value, Address addr,
llvm::Instruction *beforeInst,
CodeGenFunction &CGF) {
- auto store = new llvm::StoreInst(value, addr.emitRawPointer(CGF), beforeInst);
+ auto store = new llvm::StoreInst(value, addr.emitRawPointer(CGF),
+ beforeInst->getIterator());
store->setAlignment(addr.getAlignment().getAsAlign());
}
@@ -304,7 +305,7 @@ static llvm::LoadInst *createLoadInstBefore(Address addr, const Twine &name,
CodeGenFunction &CGF) {
return new llvm::LoadInst(addr.getElementType(), addr.emitRawPointer(CGF),
name, false, addr.getAlignment().getAsAlign(),
- beforeInst);
+ beforeInst->getIterator());
}
/// All the branch fixups on the EH stack have propagated out past the
@@ -612,7 +613,8 @@ static void destroyOptimisticNormalEntry(CodeGenFunction &CGF,
llvm::SwitchInst *si = cast<llvm::SwitchInst>(use.getUser());
if (si->getNumCases() == 1 && si->getDefaultDest() == unreachableBB) {
// Replace the switch with a branch.
- llvm::BranchInst::Create(si->case_begin()->getCaseSuccessor(), si);
+ llvm::BranchInst::Create(si->case_begin()->getCaseSuccessor(),
+ si->getIterator());
// The switch operand is a load from the cleanup-dest alloca.
llvm::LoadInst *condition = cast<llvm::LoadInst>(si->getCondition());
diff --git a/clang/lib/CodeGen/CGCoroutine.cpp b/clang/lib/CodeGen/CGCoroutine.cpp
index 93ca711f716fce..fcad59bb05c728 100644
--- a/clang/lib/CodeGen/CGCoroutine.cpp
+++ b/clang/lib/CodeGen/CGCoroutine.cpp
@@ -867,8 +867,9 @@ void CodeGenFunction::EmitCoroutineBody(const CoroutineBodyStmt &S) {
EmitStmt(S.getPromiseDeclStmt());
Address PromiseAddr = GetAddrOfLocalVar(S.getPromiseDecl());
- auto *PromiseAddrVoidPtr = new llvm::BitCastInst(
- PromiseAddr.emitRawPointer(*this), VoidPtrTy, "", CoroId);
+ auto *PromiseAddrVoidPtr =
+ new llvm::BitCastInst(PromiseAddr.emitRawPointer(*this), VoidPtrTy, "",
+ CoroId->getIterator());
// Update CoroId to refer to the promise. We could not do it earlier because
// promise local variable was not emitted yet.
CoroId->setArgOperand(1, PromiseAddrVoidPtr);
diff --git a/clang/lib/CodeGen/CGExpr.cpp b/clang/lib/CodeGen/CGExpr.cpp
index 54432353e7420d..4abb715b59ea1b 100644
--- a/clang/lib/CodeGen/CGExpr.cpp
+++ b/clang/lib/CodeGen/CGExpr.cpp
@@ -112,7 +112,7 @@ llvm::AllocaInst *CodeGenFunction::CreateTempAlloca(llvm::Type *Ty,
if (ArraySize)
return Builder.CreateAlloca(Ty, ArraySize, Name);
return new llvm::AllocaInst(Ty, CGM.getDataLayout().getAllocaAddrSpace(),
- ArraySize, Name, AllocaInsertPt);
+ ArraySize, Name, AllocaInsertPt->getIterator());
}
/// CreateDefaultAlignTempAlloca - This creates an alloca with the
diff --git a/clang/lib/CodeGen/CGObjC.cpp b/clang/lib/CodeGen/CGObjC.cpp
index c7f497a7c8451b..45246542851ad5 100644
--- a/clang/lib/CodeGen/CGObjC.cpp
+++ b/clang/lib/CodeGen/CGObjC.cpp
@@ -2394,7 +2394,8 @@ static llvm::Value *emitOptimizedARCReturnCall(llvm::Value *value,
llvm::OperandBundleDef OB("clang.arc.attachedcall", bundleArgs);
auto *oldCall = cast<llvm::CallBase>(value);
llvm::CallBase *newCall = llvm::CallBase::addOperandBundle(
- oldCall, llvm::LLVMContext::OB_clang_arc_attachedcall, OB, oldCall);
+ oldCall, llvm::LLVMContext::OB_clang_arc_attachedcall, OB,
+ oldCall->getIterator());
newCall->copyMetadata(*oldCall);
oldCall->replaceAllUsesWith(newCall);
oldCall->eraseFromParent();
diff --git a/clang/lib/CodeGen/CodeGenFunction.h b/clang/lib/CodeGen/CodeGenFunction.h
index e2a7e28c8211ea..88ca56174f128d 100644
--- a/clang/lib/CodeGen/CodeGenFunction.h
+++ b/clang/lib/CodeGen/CodeGenFunction.h
@@ -1269,8 +1269,8 @@ class CodeGenFunction : public CodeGenTypeCache {
CodeGenFunction &CGF) {
assert(isInConditionalBranch());
llvm::BasicBlock *block = OutermostConditional->getStartingBlock();
- auto store =
- new llvm::StoreInst(value, addr.emitRawPointer(CGF), &block->back());
+ auto store = new llvm::StoreInst(value, addr.emitRawPointer(CGF),
+ &block->back().getIterator());
store->setAlignment(addr.getAlignment().getAsAlign());
}
diff --git a/clang/lib/CodeGen/CodeGenModule.cpp b/clang/lib/CodeGen/CodeGenModule.cpp
index 00b3bfcaa0bc25..e336f62a6e3213 100644
--- a/clang/lib/CodeGen/CodeGenModule.cpp
+++ b/clang/lib/CodeGen/CodeGenModule.cpp
@@ -5747,13 +5747,13 @@ static void replaceUsesOfNonProtoConstant(llvm::Constant *old,
llvm::CallBase *newCall;
if (isa<llvm::CallInst>(callSite)) {
- newCall =
- llvm::CallInst::Create(newFn, newArgs, newBundles, "", callSite);
+ newCall = llvm::CallInst::Create(newFn, newArgs, newBundles, "",
+ callSite->getIterator());
} else {
auto *oldInvoke = cast<llvm::InvokeInst>(callSite);
- newCall = llvm::InvokeInst::Create(newFn, oldInvoke->getNormalDest(),
- oldInvoke->getUnwindDest(), newArgs,
- newBundles, "", callSite);
+ newCall = llvm::InvokeInst::Create(
+ newFn, oldInvoke->getNormalDest(), oldInvoke->getUnwindDest(),
+ newArgs, newBundles, "", callSite->getIterator());
}
newArgs.clear(); // for the next iteration
diff --git a/llvm/examples/IRTransforms/SimplifyCFG.cpp b/llvm/examples/IRTransforms/SimplifyCFG.cpp
index d6364385eb1ec9..a37060cedb4a77 100644
--- a/llvm/examples/IRTransforms/SimplifyCFG.cpp
+++ b/llvm/examples/IRTransforms/SimplifyCFG.cpp
@@ -158,7 +158,7 @@ static bool eliminateCondBranches_v1(Function &F) {
// Replace the conditional branch with an unconditional one, by creating
// a new unconditional branch to the selected successor and removing the
// conditional one.
- BranchInst::Create(BI->getSuccessor(CI->isZero()), BI);
+ BranchInst::Create(BI->getSuccessor(CI->isZero()), BI->getIterator());
BI->eraseFromParent();
Changed = true;
}
@@ -195,7 +195,7 @@ static bool eliminateCondBranches_v2(Function &F, DominatorTree &DT) {
// a new unconditional branch to the selected successor and removing the
// conditional one.
BranchInst *NewBranch =
- BranchInst::Create(BI->getSuccessor(CI->isZero()), BI);
+ BranchInst::Create(BI->getSuccessor(CI->isZero()), BI->getIterator());
BI->eraseFromParent();
// Delete the edge between BB and RemovedSucc in the DominatorTree, iff
@@ -242,7 +242,8 @@ static bool eliminateCondBranches_v3(Function &F, DominatorTree &DT) {
// a new unconditional branch to the selected successor and removing the
// conditional one.
- BranchInst *NewBranch = BranchInst::Create(TakenSucc, BB.getTerminator());
+ BranchInst *NewBranch =
+ BranchInst::Create(TakenSucc, BB.getTerminator()->getIterator());
BB.getTerminator()->eraseFromParent();
// Delete the edge between BB and RemovedSucc in the DominatorTree, iff
diff --git a/llvm/include/llvm/IR/InstrTypes.h b/llvm/include/llvm/IR/InstrTypes.h
index e4e5fa15c399eb..a4d5562646f294 100644
--- a/llvm/include/llvm/IR/InstrTypes.h
+++ b/llvm/include/llvm/IR/InstrTypes.h
@@ -1542,19 +1542,10 @@ class CallBase : public Instruction {
OperandBundleDef OB,
Instruction *InsertPt = nullptr);
- /// Create a clone of \p CB with operand bundle \p OB added.
- static CallBase *addOperandBundle(CallBase *CB, uint32_t ID,
- OperandBundleDef OB,
- BasicBlock::iterator InsertPt);
-
/// Create a clone of \p CB with operand bundle \p ID removed.
static CallBase *removeOperandBundle(CallBase *CB, uint32_t ID,
Instruction *InsertPt = nullptr);
- /// Create a clone of \p CB with operand bundle \p ID removed.
- static CallBase *removeOperandBundle(CallBase *CB, uint32_t ID,
- BasicBlock::iterator InsertPt);
-
static bool classof(const Instruction *I) {
return I->getOpcode() == Instruction::Call ||
I->getOpcode() == Instruction::Invoke ||
diff --git a/llvm/lib/FuzzMutate/IRMutator.cpp b/llvm/lib/FuzzMutate/IRMutator.cpp
index ea630c4602ba45..10e73d21f5c5c6 100644
--- a/llvm/lib/FuzzMutate/IRMutator.cpp
+++ b/llvm/lib/FuzzMutate/IRMutator.cpp
@@ -389,7 +389,7 @@ void InsertFunctionStrategy::mutate(BasicBlock &BB, RandomIRBuilder &IB) {
auto BuilderFunc = [FTy, F, isRetVoid](ArrayRef<Value *> Srcs,
Instruction *Inst) {
StringRef Name = isRetVoid ? nullptr : "C";
- CallInst *Call = CallInst::Create(FTy, F, Srcs, Name, Inst);
+ CallInst *Call = CallInst::Create(FTy, F, Srcs, Name, Inst->getIterator());
// Don't return this call inst if it return void as it can't be sinked.
return isRetVoid ? nullptr : Call;
};
@@ -542,7 +542,8 @@ 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.getFirstInsertionPt());
// 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..c00db45cfe4313 100644
--- a/llvm/lib/FuzzMutate/Operations.cpp
+++ b/llvm/lib/FuzzMutate/Operations.cpp
@@ -99,7 +99,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);
+ return SelectInst::Create(Srcs[0], Srcs[1], Srcs[2], "S",
+ Inst->getIterator());
};
return {Weight,
{boolOrVecBoolType(), matchFirstLengthWAnyType(), matchSecondType()},
@@ -108,7 +109,8 @@ 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);
+ return UnaryOperator::Create(Instruction::FNeg, Srcs[0], "F",
+ Inst->getIterator());
};
return {Weight, {anyFloatOrVecFloatType()}, buildOp};
}
@@ -116,7 +118,8 @@ OpDescriptor llvm::fuzzerop::fnegDescriptor(unsigned Weight) {
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);
+ return BinaryOperator::Create(Op, Srcs[0], Srcs[1], "B",
+ Inst->getIterator());
};
switch (Op) {
case Instruction::Add:
@@ -149,7 +152,8 @@ 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);
+ return CmpInst::Create(CmpOp, Pred, Srcs[0], Srcs[1], "C",
+ Inst->getIterator());
};
switch (CmpOp) {
@@ -174,7 +178,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
@@ -198,7 +203,8 @@ OpDescriptor llvm::fuzzerop::gepDescriptor(unsigned Weight) {
// 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",
+ Inst->getIterator());
};
// TODO: Handle aggregates and vectors
// TODO: Support multiple indices.
@@ -242,7 +248,7 @@ OpDescriptor llvm::fuzzerop::extractValueDescriptor(unsigned Weight) {
auto buildExtract = [](ArrayRef<Value *> Srcs, Instruction *Inst) {
// 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", Inst->getIterator());
};
// TODO: Should we handle multiple indices?
return {Weight, {anyAggregateType(), validExtractValueIndex()}, buildExtract};
@@ -301,7 +307,8 @@ OpDescriptor llvm::fuzzerop::insertValueDescriptor(unsigned Weight) {
auto buildInsert = [](ArrayRef<Value *> Srcs, Instruction *Inst) {
// 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",
+ Inst->getIterator());
};
return {
Weight,
@@ -311,7 +318,8 @@ 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);
+ return ExtractElementInst::Create(Srcs[0], Srcs[1], "E",
+ Inst->getIterator());
};
// TODO: Try to avoid undefined accesses.
return {Weight, {anyVectorType(), anyIntType()}, buildExtract};
@@ -319,7 +327,8 @@ OpDescriptor llvm::fuzzerop::extractElementDescriptor(unsigned Weight) {
OpDescriptor llvm::fuzzerop::insertElementDescriptor(unsigned Weight) {
auto buildInsert = [](ArrayRef<Value *> Srcs, Instruction *Inst) {
- return InsertElementInst::Create(Srcs[0], Srcs[1], Srcs[2], "I", Inst);
+ return InsertElementInst::Create(Srcs[0], Srcs[1], Srcs[2], "I",
+ Inst->getIterator());
};
// TODO: Try to avoid undefined accesses.
return {Weight,
@@ -344,7 +353,8 @@ 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);
+ return new ShuffleVectorInst(Srcs[0], Srcs[1], Srcs[2], "S",
+ Inst->getIterator());
};
return {Weight,
{anyVectorType(), matchFirstType(), validShuffleVectorIndex()},
diff --git a/llvm/lib/FuzzMutate/RandomIRBuilder.cpp b/llvm/lib/FuzzMutate/RandomIRBuilder.cpp
index 5569888e5b28e8..90a18c0ab76310 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, Alloca->getNextNode()->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/lib/Transforms/Instrumentation/AddressSanitizer.cpp b/llvm/lib/Transforms/Instrumentation/AddressSanitizer.cpp
index 26fedbfd65dd41..023525d8fe5b1a 100644
--- a/llvm/lib/Transforms/Instrumentation/AddressSanitizer.cpp
+++ b/llvm/lib/Transforms/Instrumentation/AddressSanitizer.cpp
@@ -690,8 +690,8 @@ class RuntimeCallInserter {
if (EHPad && EHPad->isEHPad()) {
// Replace CI with a clone with an added funclet OperandBundle
OperandBundleDef OB("funclet", EHPad);
- auto *NewCall =
- CallBase::addOperandBundle(CI, LLVMContext::OB_funclet, OB, CI);
+ auto *NewCall = CallBase::addOperandBundle(CI, LLVMContext::OB_funclet,
+ OB, CI->getIterator());
NewCall->copyMetadata(*CI);
CI->replaceAllUsesWith(NewCall);
CI->eraseFromParent();
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 8cb7fce5c366b3..c596ffe00511bd 100644
--- a/llvm/tools/llvm-stress/llvm-stress.cpp
+++ b/llvm/tools/llvm-stress/llvm-stress.cpp
@@ -342,7 +342,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);
}
};
@@ -362,7 +362,7 @@ struct StoreModifier: public Modifier {
return;
Value *Val = getRandomValue(ValTy);
- new StoreInst(Val, Ptr, BB->getTerminator());
+ new StoreInst(Val, Ptr, BB->getTerminator()->getIterator());
}
};
@@ -405,7 +405,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()));
}
};
@@ -468,8 +469,8 @@ struct AllocaModifier: public Modifier {
void Act() override {
Type *Tp = pickType();
const DataLayout &DL = BB->getModule()->getDataLayout();
- PT->push_back(new AllocaInst(Tp, DL.getAllocaAddrSpace(),
- "A", BB->getFirstNonPHI()));
+ PT->push_back(new AllocaInst(Tp, DL.getAllocaAddrSpace(), "A",
+ BB->getFirstNonPHIIt()));
}
};
@@ -480,9 +481,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);
}
};
@@ -514,7 +514,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);
}
};
@@ -528,9 +528,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);
}
};
@@ -556,7 +555,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();
@@ -565,47 +564,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.
@@ -631,7 +633,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);
}
};
@@ -660,7 +663,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);
}
};
@@ -718,7 +721,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();
}
}
>From 28c4f6871c04c0e159c246550131628185e91363 Mon Sep 17 00:00:00 2001
From: Stephen Tozer <stephen.tozer at sony.com>
Date: Fri, 5 Apr 2024 16:45:26 +0100
Subject: [PATCH 2/2] Restore accidentally-removed functions
---
llvm/include/llvm/IR/InstrTypes.h | 9 +++++++++
1 file changed, 9 insertions(+)
diff --git a/llvm/include/llvm/IR/InstrTypes.h b/llvm/include/llvm/IR/InstrTypes.h
index a4d5562646f294..e4e5fa15c399eb 100644
--- a/llvm/include/llvm/IR/InstrTypes.h
+++ b/llvm/include/llvm/IR/InstrTypes.h
@@ -1542,10 +1542,19 @@ class CallBase : public Instruction {
OperandBundleDef OB,
Instruction *InsertPt = nullptr);
+ /// Create a clone of \p CB with operand bundle \p OB added.
+ static CallBase *addOperandBundle(CallBase *CB, uint32_t ID,
+ OperandBundleDef OB,
+ BasicBlock::iterator InsertPt);
+
/// Create a clone of \p CB with operand bundle \p ID removed.
static CallBase *removeOperandBundle(CallBase *CB, uint32_t ID,
Instruction *InsertPt = nullptr);
+ /// Create a clone of \p CB with operand bundle \p ID removed.
+ static CallBase *removeOperandBundle(CallBase *CB, uint32_t ID,
+ BasicBlock::iterator InsertPt);
+
static bool classof(const Instruction *I) {
return I->getOpcode() == Instruction::Call ||
I->getOpcode() == Instruction::Invoke ||
More information about the cfe-commits
mailing list