[DebugInfo][RemoveDIs] Use iterator-insertion in unittests and fuzzer #102015
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
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/pr-subscribers-llvm-ir @llvm/pr-subscribers-llvm-analysis Author: Jeremy Morse (jmorse) ChangesThese 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:
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]
|
|
Thanks for ploughing through those! |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
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.