[llvm] [DebugInfo][RemoveDIs] Use iterator-insertion in unittests and fuzzer (PR #102015)
via llvm-commits
llvm-commits at lists.llvm.org
Mon Aug 5 09:41:35 PDT 2024
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-llvm-ir
@llvm/pr-subscribers-llvm-analysis
Author: Jeremy Morse (jmorse)
<details>
<summary>Changes</summary>
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.
---
Patch is 42.11 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/102015.diff
12 Files Affected:
- (modified) llvm/include/llvm/FuzzMutate/OpDescriptor.h (+1-1)
- (modified) llvm/lib/FuzzMutate/IRMutator.cpp (+5-5)
- (modified) llvm/lib/FuzzMutate/Operations.cpp (+30-24)
- (modified) llvm/lib/FuzzMutate/RandomIRBuilder.cpp (+9-8)
- (modified) llvm/tools/llvm-reduce/deltas/ReduceOperandBundles.cpp (+2-1)
- (modified) llvm/tools/llvm-stress/llvm-stress.cpp (+34-30)
- (modified) llvm/unittests/Analysis/CGSCCPassManagerTest.cpp (+19-18)
- (modified) llvm/unittests/Analysis/LazyCallGraphTest.cpp (+17-17)
- (modified) llvm/unittests/Analysis/ScalarEvolutionTest.cpp (+12-9)
- (modified) llvm/unittests/FuzzMutate/OperationsTest.cpp (+6-6)
- (modified) llvm/unittests/IR/BasicBlockTest.cpp (+7-4)
- (modified) llvm/unittests/Transforms/Utils/ScalarEvolutionExpanderTest.cpp (+13-11)
``````````diff
diff --git a/llvm/include/llvm/FuzzMutate/OpDescriptor.h b/llvm/include/llvm/FuzzMutate/OpDescriptor.h
index 00a8ea0e5babc..78114074dbbfc 100644
--- a/llvm/include/llvm/FuzzMutate/OpDescriptor.h
+++ b/llvm/include/llvm/FuzzMutate/OpDescriptor.h
@@ -89,7 +89,7 @@ class SourcePred {
struct OpDescriptor {
unsigned Weight;
SmallVector<SourcePred, 2> SourcePreds;
- std::function<Value *(ArrayRef<Value *>, Instruction *)> BuilderFunc;
+ std::function<Value *(ArrayRef<Value *>, BasicBlock::iterator)> BuilderFunc;
};
static inline SourcePred onlyType(Type *Only) {
diff --git a/llvm/lib/FuzzMutate/IRMutator.cpp b/llvm/lib/FuzzMutate/IRMutator.cpp
index 3f27daad55e39..72e0de5937607 100644
--- a/llvm/lib/FuzzMutate/IRMutator.cpp
+++ b/llvm/lib/FuzzMutate/IRMutator.cpp
@@ -148,7 +148,7 @@ void InjectorIRStrategy::mutate(BasicBlock &BB, RandomIRBuilder &IB) {
for (const auto &Pred : ArrayRef(OpDesc->SourcePreds).slice(1))
Srcs.push_back(IB.findOrCreateSource(BB, InstsBefore, Srcs, Pred));
- if (Value *Op = OpDesc->BuilderFunc(Srcs, Insts[IP])) {
+ if (Value *Op = OpDesc->BuilderFunc(Srcs, Insts[IP]->getIterator())) {
// Find a sink and wire up the results of the operation.
IB.connectToSink(BB, InstsAfter, Op);
}
@@ -388,9 +388,9 @@ void InsertFunctionStrategy::mutate(BasicBlock &BB, RandomIRBuilder &IB) {
}
bool isRetVoid = (F->getReturnType() == Type::getVoidTy(M->getContext()));
auto BuilderFunc = [FTy, F, isRetVoid](ArrayRef<Value *> Srcs,
- Instruction *Inst) {
+ BasicBlock::iterator InsertPt) {
StringRef Name = isRetVoid ? nullptr : "C";
- CallInst *Call = CallInst::Create(FTy, F, Srcs, Name, Inst);
+ CallInst *Call = CallInst::Create(FTy, F, Srcs, Name, InsertPt);
// Don't return this call inst if it return void as it can't be sinked.
return isRetVoid ? nullptr : Call;
};
@@ -414,7 +414,7 @@ void InsertFunctionStrategy::mutate(BasicBlock &BB, RandomIRBuilder &IB) {
Srcs.push_back(IB.findOrCreateSource(BB, InstsBefore, Srcs, Pred));
}
- if (Value *Op = BuilderFunc(Srcs, Insts[IP])) {
+ if (Value *Op = BuilderFunc(Srcs, Insts[IP]->getIterator())) {
// Find a sink and wire up the results of the operation.
IB.connectToSink(BB, InstsAfter, Op);
}
@@ -543,7 +543,7 @@ void InsertPHIStrategy::mutate(BasicBlock &BB, RandomIRBuilder &IB) {
if (&BB == &BB.getParent()->getEntryBlock())
return;
Type *Ty = IB.randomType();
- PHINode *PHI = PHINode::Create(Ty, llvm::pred_size(&BB), "", &BB.front());
+ PHINode *PHI = PHINode::Create(Ty, llvm::pred_size(&BB), "", BB.begin());
// Use a map to make sure the same incoming basic block has the same value.
DenseMap<BasicBlock *, Value *> IncomingValues;
diff --git a/llvm/lib/FuzzMutate/Operations.cpp b/llvm/lib/FuzzMutate/Operations.cpp
index 408f35879acd3..389ff8130771c 100644
--- a/llvm/lib/FuzzMutate/Operations.cpp
+++ b/llvm/lib/FuzzMutate/Operations.cpp
@@ -98,8 +98,8 @@ void llvm::describeFuzzerVectorOps(std::vector<fuzzerop::OpDescriptor> &Ops) {
}
OpDescriptor llvm::fuzzerop::selectDescriptor(unsigned Weight) {
- auto buildOp = [](ArrayRef<Value *> Srcs, Instruction *Inst) {
- return SelectInst::Create(Srcs[0], Srcs[1], Srcs[2], "S", Inst);
+ auto buildOp = [](ArrayRef<Value *> Srcs, BasicBlock::iterator InsertPt) {
+ return SelectInst::Create(Srcs[0], Srcs[1], Srcs[2], "S", InsertPt);
};
return {Weight,
{boolOrVecBoolType(), matchFirstLengthWAnyType(), matchSecondType()},
@@ -107,16 +107,16 @@ OpDescriptor llvm::fuzzerop::selectDescriptor(unsigned Weight) {
}
OpDescriptor llvm::fuzzerop::fnegDescriptor(unsigned Weight) {
- auto buildOp = [](ArrayRef<Value *> Srcs, Instruction *Inst) {
- return UnaryOperator::Create(Instruction::FNeg, Srcs[0], "F", Inst);
+ auto buildOp = [](ArrayRef<Value *> Srcs, BasicBlock::iterator InsertPt) {
+ return UnaryOperator::Create(Instruction::FNeg, Srcs[0], "F", InsertPt);
};
return {Weight, {anyFloatOrVecFloatType()}, buildOp};
}
OpDescriptor llvm::fuzzerop::binOpDescriptor(unsigned Weight,
Instruction::BinaryOps Op) {
- auto buildOp = [Op](ArrayRef<Value *> Srcs, Instruction *Inst) {
- return BinaryOperator::Create(Op, Srcs[0], Srcs[1], "B", Inst);
+ auto buildOp = [Op](ArrayRef<Value *> Srcs, BasicBlock::iterator InsertPt) {
+ return BinaryOperator::Create(Op, Srcs[0], Srcs[1], "B", InsertPt);
};
switch (Op) {
case Instruction::Add:
@@ -148,8 +148,9 @@ OpDescriptor llvm::fuzzerop::binOpDescriptor(unsigned Weight,
OpDescriptor llvm::fuzzerop::cmpOpDescriptor(unsigned Weight,
Instruction::OtherOps CmpOp,
CmpInst::Predicate Pred) {
- auto buildOp = [CmpOp, Pred](ArrayRef<Value *> Srcs, Instruction *Inst) {
- return CmpInst::Create(CmpOp, Pred, Srcs[0], Srcs[1], "C", Inst);
+ auto buildOp = [CmpOp, Pred](ArrayRef<Value *> Srcs,
+ BasicBlock::iterator InsertPt) {
+ return CmpInst::Create(CmpOp, Pred, Srcs[0], Srcs[1], "C", InsertPt);
};
switch (CmpOp) {
@@ -163,9 +164,10 @@ OpDescriptor llvm::fuzzerop::cmpOpDescriptor(unsigned Weight,
}
OpDescriptor llvm::fuzzerop::splitBlockDescriptor(unsigned Weight) {
- auto buildSplitBlock = [](ArrayRef<Value *> Srcs, Instruction *Inst) {
- BasicBlock *Block = Inst->getParent();
- BasicBlock *Next = Block->splitBasicBlock(Inst, "BB");
+ auto buildSplitBlock = [](ArrayRef<Value *> Srcs,
+ BasicBlock::iterator InsertPt) {
+ BasicBlock *Block = InsertPt->getParent();
+ BasicBlock *Next = Block->splitBasicBlock(InsertPt, "BB");
// If it was an exception handling block, we are done.
if (Block->isEHPad())
@@ -174,7 +176,8 @@ OpDescriptor llvm::fuzzerop::splitBlockDescriptor(unsigned Weight) {
// Loop back on this block by replacing the unconditional forward branch
// with a conditional with a backedge.
if (Block != &Block->getParent()->getEntryBlock()) {
- BranchInst::Create(Block, Next, Srcs[0], Block->getTerminator());
+ BranchInst::Create(Block, Next, Srcs[0],
+ Block->getTerminator()->getIterator());
Block->getTerminator()->eraseFromParent();
// We need values for each phi in the block. Since there isn't a good way
@@ -193,12 +196,12 @@ OpDescriptor llvm::fuzzerop::splitBlockDescriptor(unsigned Weight) {
}
OpDescriptor llvm::fuzzerop::gepDescriptor(unsigned Weight) {
- auto buildGEP = [](ArrayRef<Value *> Srcs, Instruction *Inst) {
+ auto buildGEP = [](ArrayRef<Value *> Srcs, BasicBlock::iterator InsertPt) {
// TODO: It would be better to generate a random type here, rather than
// generating a random value and picking its type.
Type *Ty = Srcs[1]->getType();
auto Indices = ArrayRef(Srcs).drop_front(2);
- return GetElementPtrInst::Create(Ty, Srcs[0], Indices, "G", Inst);
+ return GetElementPtrInst::Create(Ty, Srcs[0], Indices, "G", InsertPt);
};
// TODO: Handle aggregates and vectors
// TODO: Support multiple indices.
@@ -239,10 +242,11 @@ static SourcePred validExtractValueIndex() {
}
OpDescriptor llvm::fuzzerop::extractValueDescriptor(unsigned Weight) {
- auto buildExtract = [](ArrayRef<Value *> Srcs, Instruction *Inst) {
+ auto buildExtract = [](ArrayRef<Value *> Srcs,
+ BasicBlock::iterator InsertPt) {
// TODO: It's pretty inefficient to shuffle this all through constants.
unsigned Idx = cast<ConstantInt>(Srcs[1])->getZExtValue();
- return ExtractValueInst::Create(Srcs[0], {Idx}, "E", Inst);
+ return ExtractValueInst::Create(Srcs[0], {Idx}, "E", InsertPt);
};
// TODO: Should we handle multiple indices?
return {Weight, {anyAggregateType(), validExtractValueIndex()}, buildExtract};
@@ -298,10 +302,10 @@ static SourcePred validInsertValueIndex() {
}
OpDescriptor llvm::fuzzerop::insertValueDescriptor(unsigned Weight) {
- auto buildInsert = [](ArrayRef<Value *> Srcs, Instruction *Inst) {
+ auto buildInsert = [](ArrayRef<Value *> Srcs, BasicBlock::iterator InsertPt) {
// TODO: It's pretty inefficient to shuffle this all through constants.
unsigned Idx = cast<ConstantInt>(Srcs[2])->getZExtValue();
- return InsertValueInst::Create(Srcs[0], Srcs[1], {Idx}, "I", Inst);
+ return InsertValueInst::Create(Srcs[0], Srcs[1], {Idx}, "I", InsertPt);
};
return {
Weight,
@@ -310,16 +314,17 @@ OpDescriptor llvm::fuzzerop::insertValueDescriptor(unsigned Weight) {
}
OpDescriptor llvm::fuzzerop::extractElementDescriptor(unsigned Weight) {
- auto buildExtract = [](ArrayRef<Value *> Srcs, Instruction *Inst) {
- return ExtractElementInst::Create(Srcs[0], Srcs[1], "E", Inst);
+ auto buildExtract = [](ArrayRef<Value *> Srcs,
+ BasicBlock::iterator InsertPt) {
+ return ExtractElementInst::Create(Srcs[0], Srcs[1], "E", InsertPt);
};
// TODO: Try to avoid undefined accesses.
return {Weight, {anyVectorType(), anyIntType()}, buildExtract};
}
OpDescriptor llvm::fuzzerop::insertElementDescriptor(unsigned Weight) {
- auto buildInsert = [](ArrayRef<Value *> Srcs, Instruction *Inst) {
- return InsertElementInst::Create(Srcs[0], Srcs[1], Srcs[2], "I", Inst);
+ auto buildInsert = [](ArrayRef<Value *> Srcs, BasicBlock::iterator InsertPt) {
+ return InsertElementInst::Create(Srcs[0], Srcs[1], Srcs[2], "I", InsertPt);
};
// TODO: Try to avoid undefined accesses.
return {Weight,
@@ -343,8 +348,9 @@ static SourcePred validShuffleVectorIndex() {
}
OpDescriptor llvm::fuzzerop::shuffleVectorDescriptor(unsigned Weight) {
- auto buildShuffle = [](ArrayRef<Value *> Srcs, Instruction *Inst) {
- return new ShuffleVectorInst(Srcs[0], Srcs[1], Srcs[2], "S", Inst);
+ auto buildShuffle = [](ArrayRef<Value *> Srcs,
+ BasicBlock::iterator InsertPt) {
+ return new ShuffleVectorInst(Srcs[0], Srcs[1], Srcs[2], "S", InsertPt);
};
return {Weight,
{anyVectorType(), matchFirstType(), validShuffleVectorIndex()},
diff --git a/llvm/lib/FuzzMutate/RandomIRBuilder.cpp b/llvm/lib/FuzzMutate/RandomIRBuilder.cpp
index 5569888e5b28e..fe4ad10a02d57 100644
--- a/llvm/lib/FuzzMutate/RandomIRBuilder.cpp
+++ b/llvm/lib/FuzzMutate/RandomIRBuilder.cpp
@@ -69,9 +69,9 @@ AllocaInst *RandomIRBuilder::createStackMemory(Function *F, Type *Ty,
BasicBlock *EntryBB = &F->getEntryBlock();
DataLayout DL(F->getParent());
AllocaInst *Alloca = new AllocaInst(Ty, DL.getAllocaAddrSpace(), "A",
- &*EntryBB->getFirstInsertionPt());
+ EntryBB->getFirstInsertionPt());
if (Init)
- new StoreInst(Init, Alloca, Alloca->getNextNode());
+ new StoreInst(Init, Alloca, std::next(Alloca->getIterator()));
return Alloca;
}
@@ -165,7 +165,7 @@ Value *RandomIRBuilder::findOrCreateSource(BasicBlock &BB,
Type *Ty = GV->getValueType();
LoadInst *LoadGV = nullptr;
if (BB.getTerminator()) {
- LoadGV = new LoadInst(Ty, GV, "LGV", &*BB.getFirstInsertionPt());
+ LoadGV = new LoadInst(Ty, GV, "LGV", BB.getFirstInsertionPt());
} else {
LoadGV = new LoadInst(Ty, GV, "LGV", &BB);
}
@@ -213,7 +213,7 @@ Value *RandomIRBuilder::newSource(BasicBlock &BB, ArrayRef<Instruction *> Insts,
}
// Pick the type independently.
Type *AccessTy = RS.getSelection()->getType();
- auto *NewLoad = new LoadInst(AccessTy, Ptr, "L", &*IP);
+ auto *NewLoad = new LoadInst(AccessTy, Ptr, "L", IP);
// Only sample this load if it really matches the descriptor
if (Pred.matches(Srcs, NewLoad))
@@ -231,7 +231,8 @@ Value *RandomIRBuilder::newSource(BasicBlock &BB, ArrayRef<Instruction *> Insts,
Function *F = BB.getParent();
AllocaInst *Alloca = createStackMemory(F, Ty, newSrc);
if (BB.getTerminator()) {
- newSrc = new LoadInst(Ty, Alloca, /*ArrLen,*/ "L", BB.getTerminator());
+ newSrc = new LoadInst(Ty, Alloca, /*ArrLen,*/ "L",
+ BB.getTerminator()->getIterator());
} else {
newSrc = new LoadInst(Ty, Alloca, /*ArrLen,*/ "L", &BB);
}
@@ -325,7 +326,7 @@ Instruction *RandomIRBuilder::connectToSink(BasicBlock &BB,
for (BasicBlock *Dom : Dominators) {
for (Instruction &I : *Dom) {
if (isa<PointerType>(I.getType()))
- return new StoreInst(V, &I, Insts.back());
+ return new StoreInst(V, &I, Insts.back()->getIterator());
}
}
break;
@@ -351,7 +352,7 @@ Instruction *RandomIRBuilder::connectToSink(BasicBlock &BB,
Module *M = BB.getParent()->getParent();
auto [GV, DidCreate] =
findOrCreateGlobalVariable(M, {}, fuzzerop::onlyType(V->getType()));
- return new StoreInst(V, GV, Insts.back());
+ return new StoreInst(V, GV, Insts.back()->getIterator());
}
case EndOfValueSink:
default:
@@ -373,7 +374,7 @@ Instruction *RandomIRBuilder::newSink(BasicBlock &BB,
}
}
- return new StoreInst(V, Ptr, Insts.back());
+ return new StoreInst(V, Ptr, Insts.back()->getIterator());
}
Value *RandomIRBuilder::findPointer(BasicBlock &BB,
diff --git a/llvm/tools/llvm-reduce/deltas/ReduceOperandBundles.cpp b/llvm/tools/llvm-reduce/deltas/ReduceOperandBundles.cpp
index a211b6ac8d6cf..d2274877f126b 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 80fb21038d304..e44b6023fff23 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, Val...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/102015
More information about the llvm-commits
mailing list