shylie/llvm-project
1
0
Fork 0
Code Issues Pull Requests Actions 6 Packages Projects Releases Wiki Activity

[DebugInfo][RemoveDIs] Suppress getNextNonDebugInfoInstruction (#144383)

Browse Source 
There are no longer debug-info instructions, thus we don't need this
skipping. Horray!
This commit is contained in:
Jeremy Morse 2025-07-15 15:34:10 +01:00 committed by GitHub
parent 8db92a7d99
commit 57a5f9c47e
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
28 changed files with 66 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
clang/lib/CodeGen/CGBlocks.cpp
View File

@ -1549,8 +1549,8 @@ llvm::Function *CodeGenFunction::GenerateBlockFunction(
llvm::BasicBlock *resume = Builder.GetInsertBlock();
// Go back to the entry.
if (entry_ptr->getNextNonDebugInstruction())
entry_ptr = entry_ptr->getNextNonDebugInstruction()->getIterator();
if (entry_ptr->getNextNode())
entry_ptr = entry_ptr->getNextNode()->getIterator();
else
entry_ptr = entry->end();
Builder.SetInsertPoint(entry, entry_ptr);

11
llvm/include/llvm/IR/Instruction.h
View File

@ -898,17 +898,6 @@ public:
/// Return true if the instruction is a DbgInfoIntrinsic or PseudoProbeInst.
LLVM_ABI bool isDebugOrPseudoInst() const LLVM_READONLY;
/// Return a pointer to the next non-debug instruction in the same basic
/// block as 'this', or nullptr if no such instruction exists. Skip any pseudo
/// operations if \c SkipPseudoOp is true.
LLVM_ABI const Instruction *
getNextNonDebugInstruction(bool SkipPseudoOp = false) const;
Instruction *getNextNonDebugInstruction(bool SkipPseudoOp = false) {
return const_cast<Instruction *>(
static_cast<const Instruction *>(this)->getNextNonDebugInstruction(
SkipPseudoOp));
}
/// Return a pointer to the previous non-debug instruction in the same basic
/// block as 'this', or nullptr if no such instruction exists. Skip any pseudo
/// operations if \c SkipPseudoOp is true.

2
llvm/include/llvm/Transforms/Utils/LockstepReverseIterator.h
View File

@ -133,7 +133,7 @@ public:
return *this;
SmallVector<Instruction *, 4> NewInsts;
for (Instruction *Inst : Insts) {
Instruction *Next = Inst->getNextNonDebugInstruction();
Instruction *Next = Inst->getNextNode();
// Already at end of block.
if (!Next) {
Fail = true;

2
llvm/lib/Analysis/MemoryDependenceAnalysis.cpp
View File

@ -353,7 +353,7 @@ static bool canSkipClobberingStore(const StoreInst *SI,
if (BatchAA.alias(MemoryLocation::get(LI), MemLoc) != AliasResult::MustAlias)
return false;
unsigned NumVisitedInsts = 0;
for (const Instruction *I = LI; I != SI; I = I->getNextNonDebugInstruction())
for (const Instruction *I = LI; I != SI; I = I->getNextNode())
if (++NumVisitedInsts > ScanLimit ||
isModSet(BatchAA.getModRefInfo(I, MemLoc)))
return false;

2
llvm/lib/CodeGen/CodeGenPrepare.cpp
View File

@ -7328,7 +7328,7 @@ bool CodeGenPrepare::optimizeLoadExt(LoadInst *Load) {
!TLI->isLoadExtLegal(ISD::ZEXTLOAD, LoadResultVT, TruncVT))
return false;
IRBuilder<> Builder(Load->getNextNonDebugInstruction());
IRBuilder<> Builder(Load->getNextNode());
auto *NewAnd = cast<Instruction>(
Builder.CreateAnd(Load, ConstantInt::get(Ctx, DemandBits)));
// Mark this instruction as "inserted by CGP", so that other

11
llvm/lib/IR/Instruction.cpp
View File

@ -1235,14 +1235,6 @@ bool Instruction::isDebugOrPseudoInst() const {
return isa<DbgInfoIntrinsic>(this) || isa<PseudoProbeInst>(this);
}
const Instruction *
Instruction::getNextNonDebugInstruction(bool SkipPseudoOp) const {
for (const Instruction *I = getNextNode(); I; I = I->getNextNode())
if (!isa<DbgInfoIntrinsic>(I) && !(SkipPseudoOp && isa<PseudoProbeInst>(I)))
return I;
return nullptr;
}
const Instruction *
Instruction::getPrevNonDebugInstruction(bool SkipPseudoOp) const {
for (const Instruction *I = getPrevNode(); I; I = I->getPrevNode())
@ -1252,9 +1244,6 @@ Instruction::getPrevNonDebugInstruction(bool SkipPseudoOp) const {
}
const DebugLoc &Instruction::getStableDebugLoc() const {
if (isa<DbgInfoIntrinsic>(this))
if (const Instruction *Next = getNextNonDebugInstruction())
return Next->getDebugLoc();
return getDebugLoc();
}

2
llvm/lib/IR/Verifier.cpp
View File

@ -6541,7 +6541,7 @@ void Verifier::visitIntrinsicCall(Intrinsic::ID ID, CallBase &Call) {
Check(!Call.paramHasAttr(3, Attribute::InReg),
"VGPR arguments must not have the `inreg` attribute", &Call);
auto *Next = Call.getNextNonDebugInstruction();
auto *Next = Call.getNextNode();
bool IsAMDUnreachable = Next && isa<IntrinsicInst>(Next) &&
cast<IntrinsicInst>(Next)->getIntrinsicID() ==
Intrinsic::amdgcn_unreachable;

4
llvm/lib/Target/AArch64/AArch64TargetTransformInfo.cpp
View File

@ -2674,14 +2674,14 @@ static std::optional<Instruction *> instCombineSVEInsr(InstCombiner &IC,
static std::optional<Instruction *> instCombineDMB(InstCombiner &IC,
IntrinsicInst &II) {
// If this barrier is post-dominated by identical one we can remove it
auto *NI = II.getNextNonDebugInstruction();
auto *NI = II.getNextNode();
unsigned LookaheadThreshold = DMBLookaheadThreshold;
auto CanSkipOver = [](Instruction *I) {
return !I->mayReadOrWriteMemory() && !I->mayHaveSideEffects();
};
while (LookaheadThreshold-- && CanSkipOver(NI)) {
auto *NIBB = NI->getParent();
NI = NI->getNextNonDebugInstruction();
NI = NI->getNextNode();
if (!NI) {
if (auto *SuccBB = NIBB->getUniqueSuccessor())
NI = &*SuccBB->getFirstNonPHIOrDbgOrLifetime();

4
llvm/lib/Target/X86/X86WinEHState.cpp
View File

@ -811,7 +811,7 @@ void WinEHStatePass::updateEspForInAllocas(Function &F) {
if (auto *Alloca = dyn_cast<AllocaInst>(&I)) {
if (Alloca->isStaticAlloca())
continue;
IRBuilder<> Builder(Alloca->getNextNonDebugInstruction());
IRBuilder<> Builder(Alloca->getNextNode());
// SavedESP = llvm.stacksave()
Value *SP = Builder.CreateStackSave();
Builder.CreateStore(SP, Builder.CreateStructGEP(RegNodeTy, RegNode, 0));
@ -820,7 +820,7 @@ void WinEHStatePass::updateEspForInAllocas(Function &F) {
if (auto *II = dyn_cast<IntrinsicInst>(&I)) {
if (II->getIntrinsicID() != Intrinsic::stackrestore)
continue;
IRBuilder<> Builder(II->getNextNonDebugInstruction());
IRBuilder<> Builder(II->getNextNode());
// SavedESP = llvm.stacksave()
Value *SP = Builder.CreateStackSave();
Builder.CreateStore(SP, Builder.CreateStructGEP(RegNodeTy, RegNode, 0));

5
llvm/lib/Transforms/Coroutines/CoroSplit.cpp
View File

@ -808,15 +808,14 @@ static void updateScopeLine(Instruction *ActiveSuspend,
return;
// No subsequent instruction -> fallback to the location of ActiveSuspend.
if (!ActiveSuspend->getNextNonDebugInstruction()) {
if (!ActiveSuspend->getNextNode()) {
if (auto DL = ActiveSuspend->getDebugLoc())
if (SPToUpdate.getFile() == DL->getFile())
SPToUpdate.setScopeLine(DL->getLine());
return;
}
BasicBlock::iterator Successor =
ActiveSuspend->getNextNonDebugInstruction()->getIterator();
BasicBlock::iterator Successor = ActiveSuspend->getNextNode()->getIterator();
// Corosplit splits the BB around ActiveSuspend, so the meaningful
// instructions are not in the same BB.
if (auto *Branch = dyn_cast_or_null<BranchInst>(Successor);

2
llvm/lib/Transforms/IPO/Attributor.cpp
View File

@ -793,7 +793,7 @@ isPotentiallyReachable(Attributor &A, const Instruction &FromI,
if (isa<InvokeInst>(CB))
return false;
Instruction *Inst = CB->getNextNonDebugInstruction();
Instruction *Inst = CB->getNextNode();
Worklist.push_back(Inst);
return true;
};

7
llvm/lib/Transforms/IPO/AttributorAttributes.cpp
View File

@ -1776,7 +1776,7 @@ ChangeStatus AAPointerInfoFloating::updateImpl(Attributor &A) {
do {
if (FromI->mayWriteToMemory() && !IsAssumption(*FromI))
return true;
FromI = FromI->getNextNonDebugInstruction();
FromI = FromI->getNextNode();
} while (FromI && FromI != ToI);
return false;
};
@ -1787,7 +1787,7 @@ ChangeStatus AAPointerInfoFloating::updateImpl(Attributor &A) {
return false;
BasicBlock *IntrBB = IntrI.getParent();
if (IntrI.getParent() == BB) {
if (IsImpactedInRange(LoadI->getNextNonDebugInstruction(), &IntrI))
if (IsImpactedInRange(LoadI->getNextNode(), &IntrI))
return false;
} else {
auto PredIt = pred_begin(IntrBB);
@ -1804,8 +1804,7 @@ ChangeStatus AAPointerInfoFloating::updateImpl(Attributor &A) {
continue;
return false;
}
if (IsImpactedInRange(LoadI->getNextNonDebugInstruction(),
BB->getTerminator()))
if (IsImpactedInRange(LoadI->getNextNode(), BB->getTerminator()))
return false;
if (IsImpactedInRange(&IntrBB->front(), &IntrI))
return false;

4
llvm/lib/Transforms/IPO/GlobalOpt.cpp
View File

@ -1878,7 +1878,7 @@ static void RemovePreallocated(Function *F) {
Builder.SetInsertPoint(PreallocatedSetup);
auto *StackSave = Builder.CreateStackSave();
Builder.SetInsertPoint(NewCB->getNextNonDebugInstruction());
Builder.SetInsertPoint(NewCB->getNextNode());
Builder.CreateStackRestore(StackSave);
// Replace @llvm.call.preallocated.arg() with alloca.
@ -1902,7 +1902,7 @@ static void RemovePreallocated(Function *F) {
auto AddressSpace = UseCall->getType()->getPointerAddressSpace();
auto *ArgType =
UseCall->getFnAttr(Attribute::Preallocated).getValueAsType();
auto *InsertBefore = PreallocatedSetup->getNextNonDebugInstruction();
auto *InsertBefore = PreallocatedSetup->getNextNode();
Builder.SetInsertPoint(InsertBefore);
auto *Alloca =
Builder.CreateAlloca(ArgType, AddressSpace, nullptr, "paarg");

7
llvm/lib/Transforms/IPO/IROutliner.cpp
View File

@ -267,8 +267,7 @@ void OutlinableRegion::splitCandidate() {
// region is the same as the recorded instruction following the last
// instruction. If they do not match, there could be problems in rewriting
// the program after outlining, so we ignore it.
if (!BackInst->isTerminator() &&
EndInst != BackInst->getNextNonDebugInstruction())
if (!BackInst->isTerminator() && EndInst != BackInst->getNextNode())
return;
Instruction *StartInst = (*Candidate->begin()).Inst;
@ -2326,7 +2325,7 @@ static bool nextIRInstructionDataMatchesNextInst(IRInstructionData &ID) {
Instruction *NextIDLInst = NextIDIt->Inst;
Instruction *NextModuleInst = nullptr;
if (!ID.Inst->isTerminator())
NextModuleInst = ID.Inst->getNextNonDebugInstruction();
NextModuleInst = ID.Inst->getNextNode();
else if (NextIDLInst != nullptr)
NextModuleInst =
&*NextIDIt->Inst->getParent()->instructionsWithoutDebug().begin();
@ -2353,7 +2352,7 @@ bool IROutliner::isCompatibleWithAlreadyOutlinedCode(
// if it does not, we fix it in the InstructionDataList.
if (!Region.Candidate->backInstruction()->isTerminator()) {
Instruction *NewEndInst =
Region.Candidate->backInstruction()->getNextNonDebugInstruction();
Region.Candidate->backInstruction()->getNextNode();
assert(NewEndInst && "Next instruction is a nullptr?");
if (Region.Candidate->end()->Inst != NewEndInst) {
IRInstructionDataList *IDL = Region.Candidate->front()->IDL;

2
llvm/lib/Transforms/IPO/OpenMPOpt.cpp
View File

@ -2856,7 +2856,7 @@ struct AAExecutionDomainFunction : public AAExecutionDomain {
if (!It->getSecond().IsReachingAlignedBarrierOnly)
ForwardIsOk = false;
break;
} while ((CurI = CurI->getNextNonDebugInstruction()));
} while ((CurI = CurI->getNextNode()));
if (!CurI && !BEDMap.lookup(I.getParent()).IsReachingAlignedBarrierOnly)
ForwardIsOk = false;

12
llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp
View File

@ -3298,7 +3298,7 @@ Instruction *InstCombinerImpl::visitCallInst(CallInst &CI) {
// Remove an assume if it is followed by an identical assume.
// TODO: Do we need this? Unless there are conflicting assumptions, the
// computeKnownBits(IIOperand) below here eliminates redundant assumes.
Instruction *Next = II->getNextNonDebugInstruction();
Instruction *Next = II->getNextNode();
if (match(Next, m_Intrinsic<Intrinsic::assume>(m_Specific(IIOperand))))
return RemoveConditionFromAssume(Next);
@ -3471,12 +3471,12 @@ Instruction *InstCombinerImpl::visitCallInst(CallInst &CI) {
// Is this guard followed by another guard? We scan forward over a small
// fixed window of instructions to handle common cases with conditions
// computed between guards.
Instruction *NextInst = II->getNextNonDebugInstruction();
Instruction *NextInst = II->getNextNode();
for (unsigned i = 0; i < GuardWideningWindow; i++) {
// Note: Using context-free form to avoid compile time blow up
if (!isSafeToSpeculativelyExecute(NextInst))
break;
NextInst = NextInst->getNextNonDebugInstruction();
NextInst = NextInst->getNextNode();
}
Value *NextCond = nullptr;
if (match(NextInst,
@ -3486,10 +3486,10 @@ Instruction *InstCombinerImpl::visitCallInst(CallInst &CI) {
// Remove a guard that it is immediately preceded by an identical guard.
// Otherwise canonicalize guard(a); guard(b) -> guard(a & b).
if (CurrCond != NextCond) {
Instruction *MoveI = II->getNextNonDebugInstruction();
Instruction *MoveI = II->getNextNode();
while (MoveI != NextInst) {
auto *Temp = MoveI;
MoveI = MoveI->getNextNonDebugInstruction();
MoveI = MoveI->getNextNode();
Temp->moveBefore(II->getIterator());
}
replaceOperand(*II, 0, Builder.CreateAnd(CurrCond, NextCond));
@ -3913,7 +3913,7 @@ Instruction *InstCombinerImpl::visitCallInst(CallInst &CI) {
// Fence instruction simplification
Instruction *InstCombinerImpl::visitFenceInst(FenceInst &FI) {
auto *NFI = dyn_cast<FenceInst>(FI.getNextNonDebugInstruction());
auto *NFI = dyn_cast<FenceInst>(FI.getNextNode());
// This check is solely here to handle arbitrary target-dependent syncscopes.
// TODO: Can remove if does not matter in practice.
if (NFI && FI.isIdenticalTo(NFI))

4
llvm/lib/Transforms/Instrumentation/AddressSanitizer.cpp
View File

@ -3396,8 +3396,8 @@ void FunctionStackPoisoner::processDynamicAllocas() {
static void findStoresToUninstrumentedArgAllocas(
AddressSanitizer &ASan, Instruction &InsBefore,
SmallVectorImpl<Instruction *> &InitInsts) {
Instruction *Start = InsBefore.getNextNonDebugInstruction();
for (Instruction *It = Start; It; It = It->getNextNonDebugInstruction()) {
Instruction *Start = InsBefore.getNextNode();
for (Instruction *It = Start; It; It = It->getNextNode()) {
// Argument initialization looks like:
// 1) store <Argument>, <Alloca> OR
// 2) <CastArgument> = cast <Argument> to ...

4
llvm/lib/Transforms/Instrumentation/HWAddressSanitizer.cpp
View File

@ -1421,7 +1421,7 @@ void HWAddressSanitizer::emitPrologue(IRBuilder<> &IRB, bool WithFrameRecord) {
bool HWAddressSanitizer::instrumentLandingPads(
SmallVectorImpl<Instruction *> &LandingPadVec) {
for (auto *LP : LandingPadVec) {
IRBuilder<> IRB(LP->getNextNonDebugInstruction());
IRBuilder<> IRB(LP->getNextNode());
IRB.CreateCall(
HwasanHandleVfork,
{memtag::readRegister(
@ -1446,7 +1446,7 @@ bool HWAddressSanitizer::instrumentStack(memtag::StackInfo &SInfo,
auto N = I++;
auto *AI = KV.first;
memtag::AllocaInfo &Info = KV.second;
IRBuilder<> IRB(AI->getNextNonDebugInstruction());
IRBuilder<> IRB(AI->getNextNode());
// Replace uses of the alloca with tagged address.
Value *Tag = getAllocaTag(IRB, StackTag, N);

4
llvm/lib/Transforms/Instrumentation/ValueProfilePlugins.inc
View File

@ -102,12 +102,12 @@ public:
void run(std::vector<CandidateInfo> &Candidates) {
std::vector<Instruction *> Result = findVTableAddrs(F);
for (Instruction *I : Result) {
Instruction *InsertPt = I->getNextNonDebugInstruction();
Instruction *InsertPt = I->getNextNode();
// When finding an insertion point, keep PHI and EH pad instructions
// before vp intrinsics. This is similar to
// `BasicBlock::getFirstInsertionPt`.
while (InsertPt && (dyn_cast<PHINode>(InsertPt) || InsertPt->isEHPad()))
InsertPt = InsertPt->getNextNonDebugInstruction();
InsertPt = InsertPt->getNextNode();
// Skip instrumentating the value if InsertPt is the last instruction.
// FIXME: Set InsertPt to the end of basic block to instrument the value
// if InsertPt is the last instruction.

2
llvm/lib/Transforms/Scalar/LoopStrengthReduce.cpp
View File

@ -2705,7 +2705,7 @@ LSRInstance::OptimizeLoopTermCond() {
// It's possible for the setcc instruction to be anywhere in the loop, and
// possible for it to have multiple users. If it is not immediately before
// the exiting block branch, move it.
if (Cond->getNextNonDebugInstruction() != TermBr) {
if (Cond->getNextNode() != TermBr) {
if (Cond->hasOneUse()) {
Cond->moveBefore(TermBr->getIterator());
} else {

4
llvm/lib/Transforms/Scalar/MemCpyOptimizer.cpp
View File

@ -730,7 +730,7 @@ bool MemCpyOptPass::processStoreOfLoad(StoreInst *SI, LoadInst *LI,
if (performStackMoveOptzn(LI, SI, DestAlloca, SrcAlloca,
DL.getTypeStoreSize(T), BAA)) {
// Avoid invalidating the iterator.
BBI = SI->getNextNonDebugInstruction()->getIterator();
BBI = SI->getNextNode()->getIterator();
eraseInstruction(SI);
eraseInstruction(LI);
++NumMemCpyInstr;
@ -1863,7 +1863,7 @@ bool MemCpyOptPass::processMemCpy(MemCpyInst *M, BasicBlock::iterator &BBI) {
if (performStackMoveOptzn(M, M, DestAlloca, SrcAlloca,
TypeSize::getFixed(Len->getZExtValue()), BAA)) {
// Avoid invalidating the iterator.
BBI = M->getNextNonDebugInstruction()->getIterator();
BBI = M->getNextNode()->getIterator();
eraseInstruction(M);
++NumMemCpyInstr;
return true;

10
llvm/lib/Transforms/Utils/Local.cpp
View File

@ -2660,12 +2660,12 @@ static bool rewriteDebugUsers(
SmallPtrSet<DbgVariableIntrinsic *, 1> UndefOrSalvage;
SmallPtrSet<DbgVariableRecord *, 1> UndefOrSalvageDVR;
if (isa<Instruction>(&To)) {
bool DomPointAfterFrom = From.getNextNonDebugInstruction() == &DomPoint;
bool DomPointAfterFrom = From.getNextNode() == &DomPoint;
for (auto *DII : Users) {
// It's common to see a debug user between From and DomPoint. Move it
// after DomPoint to preserve the variable update without any reordering.
if (DomPointAfterFrom && DII->getNextNonDebugInstruction() == &DomPoint) {
if (DomPointAfterFrom && DII->getNextNode() == &DomPoint) {
LLVM_DEBUG(dbgs() << "MOVE: " << *DII << '\n');
DII->moveAfter(&DomPoint);
Changed = true;
@ -2683,7 +2683,7 @@ static bool rewriteDebugUsers(
Instruction *NextNonDebug = MarkedInstr;
// The next instruction might still be a dbg.declare, skip over it.
if (isa<DbgVariableIntrinsic>(NextNonDebug))
NextNonDebug = NextNonDebug->getNextNonDebugInstruction();
NextNonDebug = NextNonDebug->getNextNode();
if (DomPointAfterFrom && NextNonDebug == &DomPoint) {
LLVM_DEBUG(dbgs() << "MOVE: " << *DVR << '\n');
@ -3070,9 +3070,9 @@ static bool markAliveBlocks(Function &F,
// If we found a call to a no-return function, insert an unreachable
// instruction after it. Make sure there isn't *already* one there
// though.
if (!isa<UnreachableInst>(CI->getNextNonDebugInstruction())) {
if (!isa<UnreachableInst>(CI->getNextNode())) {
// Don't insert a call to llvm.trap right before the unreachable.
changeToUnreachable(CI->getNextNonDebugInstruction(), false, DTU);
changeToUnreachable(CI->getNextNode(), false, DTU);
Changed = true;
}
break;

2
llvm/lib/Transforms/Utils/ScalarEvolutionExpander.cpp
View File

@ -1682,7 +1682,7 @@ void SCEVExpander::replaceCongruentIVInc(
if (PHINode *PN = dyn_cast<PHINode>(OrigInc))
IP = PN->getParent()->getFirstInsertionPt();
else
IP = OrigInc->getNextNonDebugInstruction()->getIterator();
IP = OrigInc->getNextNode()->getIterator();
IRBuilder<> Builder(IP->getParent(), IP);
Builder.SetCurrentDebugLocation(IsomorphicInc->getDebugLoc());

8
llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp
View File

@ -16223,7 +16223,7 @@ void BoUpSLP::setInsertPointAfterBundle(const TreeEntry *E) {
// debug location to Front.
Builder.SetInsertPoint(
LastInst->getParent(),
LastInst->getNextNonDebugInstruction()->getIterator());
LastInst->getNextNode()->getIterator());
}
Builder.SetCurrentDebugLocation(Front->getDebugLoc());
}
@ -18975,7 +18975,7 @@ Value *BoUpSLP::vectorizeTree(
Builder.SetInsertPoint(
IVec->getParent()->getFirstNonPHIOrDbgOrLifetime());
} else if (auto *IVec = dyn_cast<Instruction>(Vec)) {
Builder.SetInsertPoint(IVec->getNextNonDebugInstruction());
Builder.SetInsertPoint(IVec->getNextNode());
}
Vec = Builder.CreateIntCast(
Vec,
@ -19953,7 +19953,7 @@ void BoUpSLP::scheduleBlock(BlockScheduling *BS) {
Instruction *PickedInst = BundleMember->getInst();
if (!Scheduled.insert(PickedInst).second)
continue;
if (PickedInst->getNextNonDebugInstruction() != LastScheduledInst)
if (PickedInst->getNextNode() != LastScheduledInst)
PickedInst->moveAfter(LastScheduledInst->getPrevNode());
LastScheduledInst = PickedInst;
}
@ -19962,7 +19962,7 @@ void BoUpSLP::scheduleBlock(BlockScheduling *BS) {
} else {
auto *SD = cast<ScheduleData>(Picked);
Instruction *PickedInst = SD->getInst();
if (PickedInst->getNextNonDebugInstruction() != LastScheduledInst)
if (PickedInst->getNextNode() != LastScheduledInst)
PickedInst->moveAfter(LastScheduledInst->getPrevNode());
LastScheduledInst = PickedInst;
}

18
llvm/unittests/Frontend/OpenMPIRBuilderTest.cpp
View File

@ -4655,7 +4655,7 @@ TEST_F(OpenMPIRBuilderTest, CreateTeamsWithThreadLimit) {
// Verifying that the next instruction to execute is kmpc_fork_teams
BranchInst *BrInst =
dyn_cast<BranchInst>(PushNumTeamsCallInst->getNextNonDebugInstruction());
dyn_cast<BranchInst>(PushNumTeamsCallInst->getNextNode());
ASSERT_NE(BrInst, nullptr);
ASSERT_EQ(BrInst->getNumSuccessors(), 1U);
BasicBlock::iterator NextInstruction =
@ -4712,7 +4712,7 @@ TEST_F(OpenMPIRBuilderTest, CreateTeamsWithNumTeamsUpper) {
// Verifying that the next instruction to execute is kmpc_fork_teams
BranchInst *BrInst =
dyn_cast<BranchInst>(PushNumTeamsCallInst->getNextNonDebugInstruction());
dyn_cast<BranchInst>(PushNumTeamsCallInst->getNextNode());
ASSERT_NE(BrInst, nullptr);
ASSERT_EQ(BrInst->getNumSuccessors(), 1U);
BasicBlock::iterator NextInstruction =
@ -4772,7 +4772,7 @@ TEST_F(OpenMPIRBuilderTest, CreateTeamsWithNumTeamsBoth) {
// Verifying that the next instruction to execute is kmpc_fork_teams
BranchInst *BrInst =
dyn_cast<BranchInst>(PushNumTeamsCallInst->getNextNonDebugInstruction());
dyn_cast<BranchInst>(PushNumTeamsCallInst->getNextNode());
ASSERT_NE(BrInst, nullptr);
ASSERT_EQ(BrInst->getNumSuccessors(), 1U);
BasicBlock::iterator NextInstruction =
@ -4838,7 +4838,7 @@ TEST_F(OpenMPIRBuilderTest, CreateTeamsWithNumTeamsAndThreadLimit) {
// Verifying that the next instruction to execute is kmpc_fork_teams
BranchInst *BrInst =
dyn_cast<BranchInst>(PushNumTeamsCallInst->getNextNonDebugInstruction());
dyn_cast<BranchInst>(PushNumTeamsCallInst->getNextNode());
ASSERT_NE(BrInst, nullptr);
ASSERT_EQ(BrInst->getNumSuccessors(), 1U);
BasicBlock::iterator NextInstruction =
@ -7349,8 +7349,8 @@ TEST_F(OpenMPIRBuilderTest, CreateTaskIfCondition) {
EXPECT_EQ(TaskBeginIfCall->getParent(),
IfConditionBranchInst->getSuccessor(1));
EXPECT_EQ(TaskBeginIfCall->getNextNonDebugInstruction(), OulinedFnCall);
EXPECT_EQ(OulinedFnCall->getNextNonDebugInstruction(), TaskCompleteCall);
EXPECT_EQ(TaskBeginIfCall->getNextNode(), OulinedFnCall);
EXPECT_EQ(OulinedFnCall->getNextNode(), TaskCompleteCall);
}
TEST_F(OpenMPIRBuilderTest, CreateTaskgroup) {
@ -7434,12 +7434,12 @@ TEST_F(OpenMPIRBuilderTest, CreateTaskgroup) {
OMPRTL___kmpc_global_thread_num));
// Checking the general structure of the IR generated is same as expected.
Instruction *GeneratedStoreInst = TaskgroupCall->getNextNonDebugInstruction();
Instruction *GeneratedStoreInst = TaskgroupCall->getNextNode();
EXPECT_EQ(GeneratedStoreInst, InternalStoreInst);
Instruction *GeneratedLoad32 =
GeneratedStoreInst->getNextNonDebugInstruction();
GeneratedStoreInst->getNextNode();
EXPECT_EQ(GeneratedLoad32, InternalLoad32);
Instruction *GeneratedLoad128 = GeneratedLoad32->getNextNonDebugInstruction();
Instruction *GeneratedLoad128 = GeneratedLoad32->getNextNode();
EXPECT_EQ(GeneratedLoad128, InternalLoad128);
// Checking the ordering because of the if statements and that

2
llvm/unittests/FuzzMutate/RandomIRBuilderTest.cpp
View File

@ -520,7 +520,7 @@ TEST(RandomIRBuilderTest, sinkToIntrinsic) {
ASSERT_TRUE(Modified);
Modified = false;
I = I->getNextNonDebugInstruction();
I = I->getNextNode();
for (int i = 0; i < 20; i++) {
Value *OldOperand = I->getOperand(0);
Value *Src = F.getArg(5);

4
llvm/unittests/IR/InstructionsTest.cpp
View File

@ -1482,11 +1482,11 @@ TEST(InstructionsTest, SkipDebug) {
// The first non-debug instruction is the terminator.
auto *Term = BB.getTerminator();
EXPECT_EQ(Term, BB.begin()->getNextNonDebugInstruction());
EXPECT_EQ(Term, BB.begin()->getNextNode());
EXPECT_EQ(Term->getIterator(), skipDebugIntrinsics(BB.begin()));
// After the terminator, there are no non-debug instructions.
EXPECT_EQ(nullptr, Term->getNextNonDebugInstruction());
EXPECT_EQ(nullptr, Term->getNextNode());
}
TEST(InstructionsTest, PhiMightNotBeFPMathOperator) {

14
llvm/unittests/Transforms/Utils/LocalTest.cpp
View File

@ -823,13 +823,13 @@ TEST(Local, ReplaceAllDbgUsesWith) {
BasicBlock &BB = F.front();
Instruction &A = BB.front();
Instruction &B = *A.getNextNonDebugInstruction();
Instruction &C = *B.getNextNonDebugInstruction();
Instruction &D = *C.getNextNonDebugInstruction();
Instruction &E = *D.getNextNonDebugInstruction();
Instruction &F_ = *E.getNextNonDebugInstruction();
Instruction &Barrier = *F_.getNextNonDebugInstruction();
Instruction &G = *Barrier.getNextNonDebugInstruction();
Instruction &B = *A.getNextNode();
Instruction &C = *B.getNextNode();
Instruction &D = *C.getNextNode();
Instruction &E = *D.getNextNode();
Instruction &F_ = *E.getNextNode();
Instruction &Barrier = *F_.getNextNode();
Instruction &G = *Barrier.getNextNode();
// Simulate i32 <-> i64* conversion. Expect no updates: the datalayout says
// pointers are 64 bits, so the conversion would be lossy.