[llvm] d61b4cb - [CodeGen] Use range-based for loops (NFC)
Kazu Hirata via llvm-commits
llvm-commits at lists.llvm.org
Thu Feb 11 23:32:10 PST 2021
Author: Kazu Hirata
Date: 2021-02-11T23:31:31-08:00
New Revision: d61b4cb9d8de946fd564707c2e4c32ce1d152eaf
URL: https://github.com/llvm/llvm-project/commit/d61b4cb9d8de946fd564707c2e4c32ce1d152eaf
DIFF: https://github.com/llvm/llvm-project/commit/d61b4cb9d8de946fd564707c2e4c32ce1d152eaf.diff
LOG: [CodeGen] Use range-based for loops (NFC)
Added:
Modified:
llvm/lib/CodeGen/AggressiveAntiDepBreaker.cpp
llvm/lib/CodeGen/BranchFolding.cpp
llvm/lib/CodeGen/CodeGenPrepare.cpp
Removed:
################################################################################
diff --git a/llvm/lib/CodeGen/AggressiveAntiDepBreaker.cpp b/llvm/lib/CodeGen/AggressiveAntiDepBreaker.cpp
index acf8553f7205..0146d038f670 100644
--- a/llvm/lib/CodeGen/AggressiveAntiDepBreaker.cpp
+++ b/llvm/lib/CodeGen/AggressiveAntiDepBreaker.cpp
@@ -153,9 +153,8 @@ void AggressiveAntiDepBreaker::StartBlock(MachineBasicBlock *BB) {
std::vector<unsigned> &DefIndices = State->GetDefIndices();
// Examine the live-in regs of all successors.
- for (MachineBasicBlock::succ_iterator SI = BB->succ_begin(),
- SE = BB->succ_end(); SI != SE; ++SI)
- for (const auto &LI : (*SI)->liveins()) {
+ for (MachineBasicBlock *Succ : BB->successors())
+ for (const auto &LI : Succ->liveins()) {
for (MCRegAliasIterator AI(LI.PhysReg, TRI, true); AI.isValid(); ++AI) {
unsigned Reg = *AI;
State->UnionGroups(Reg, 0);
@@ -259,11 +258,10 @@ void AggressiveAntiDepBreaker::GetPassthruRegs(
/// in SU that we want to consider for breaking.
static void AntiDepEdges(const SUnit *SU, std::vector<const SDep *> &Edges) {
SmallSet<unsigned, 4> RegSet;
- for (SUnit::const_pred_iterator P = SU->Preds.begin(), PE = SU->Preds.end();
- P != PE; ++P) {
- if ((P->getKind() == SDep::Anti) || (P->getKind() == SDep::Output)) {
- if (RegSet.insert(P->getReg()).second)
- Edges.push_back(&*P);
+ for (const SDep &Pred : SU->Preds) {
+ if ((Pred.getKind() == SDep::Anti) || (Pred.getKind() == SDep::Output)) {
+ if (RegSet.insert(Pred.getReg()).second)
+ Edges.push_back(&Pred);
}
}
}
@@ -275,17 +273,16 @@ static const SUnit *CriticalPathStep(const SUnit *SU) {
unsigned NextDepth = 0;
// Find the predecessor edge with the greatest depth.
if (SU) {
- for (SUnit::const_pred_iterator P = SU->Preds.begin(), PE = SU->Preds.end();
- P != PE; ++P) {
- const SUnit *PredSU = P->getSUnit();
- unsigned PredLatency = P->getLatency();
+ for (const SDep &Pred : SU->Preds) {
+ const SUnit *PredSU = Pred.getSUnit();
+ unsigned PredLatency = Pred.getLatency();
unsigned PredTotalLatency = PredSU->getDepth() + PredLatency;
// In the case of a latency tie, prefer an anti-dependency edge over
// other types of edges.
if (NextDepth < PredTotalLatency ||
- (NextDepth == PredTotalLatency && P->getKind() == SDep::Anti)) {
+ (NextDepth == PredTotalLatency && Pred.getKind() == SDep::Anti)) {
NextDepth = PredTotalLatency;
- Next = &*P;
+ Next = &Pred;
}
}
}
@@ -886,25 +883,24 @@ unsigned AggressiveAntiDepBreaker::BreakAntiDependencies(
// Also, if there are dependencies on other SUnits with the
// same register as the anti-dependency, don't attempt to
// break it.
- for (SUnit::const_pred_iterator P = PathSU->Preds.begin(),
- PE = PathSU->Preds.end(); P != PE; ++P) {
- if (P->getSUnit() == NextSU ?
- (P->getKind() != SDep::Anti || P->getReg() != AntiDepReg) :
- (P->getKind() == SDep::Data && P->getReg() == AntiDepReg)) {
+ for (const SDep &Pred : PathSU->Preds) {
+ if (Pred.getSUnit() == NextSU ? (Pred.getKind() != SDep::Anti ||
+ Pred.getReg() != AntiDepReg)
+ : (Pred.getKind() == SDep::Data &&
+ Pred.getReg() == AntiDepReg)) {
AntiDepReg = 0;
break;
}
}
- for (SUnit::const_pred_iterator P = PathSU->Preds.begin(),
- PE = PathSU->Preds.end(); P != PE; ++P) {
- if ((P->getSUnit() == NextSU) && (P->getKind() != SDep::Anti) &&
- (P->getKind() != SDep::Output)) {
+ for (const SDep &Pred : PathSU->Preds) {
+ if ((Pred.getSUnit() == NextSU) && (Pred.getKind() != SDep::Anti) &&
+ (Pred.getKind() != SDep::Output)) {
LLVM_DEBUG(dbgs() << " (real dependency)\n");
AntiDepReg = 0;
break;
- } else if ((P->getSUnit() != NextSU) &&
- (P->getKind() == SDep::Data) &&
- (P->getReg() == AntiDepReg)) {
+ } else if ((Pred.getSUnit() != NextSU) &&
+ (Pred.getKind() == SDep::Data) &&
+ (Pred.getReg() == AntiDepReg)) {
LLVM_DEBUG(dbgs() << " (other dependency)\n");
AntiDepReg = 0;
break;
diff --git a/llvm/lib/CodeGen/BranchFolding.cpp b/llvm/lib/CodeGen/BranchFolding.cpp
index fd3f465fb390..c5a806aea8ed 100644
--- a/llvm/lib/CodeGen/BranchFolding.cpp
+++ b/llvm/lib/CodeGen/BranchFolding.cpp
@@ -164,10 +164,10 @@ void BranchFolder::RemoveDeadBlock(MachineBasicBlock *MBB) {
TriedMerging.erase(MBB);
// Update call site info.
- std::for_each(MBB->begin(), MBB->end(), [MF](const MachineInstr &MI) {
+ for (const MachineInstr &MI : *MBB)
if (MI.shouldUpdateCallSiteInfo())
MF->eraseCallSiteInfo(&MI);
- });
+
// Remove the block.
MF->erase(MBB);
EHScopeMembership.erase(MBB);
diff --git a/llvm/lib/CodeGen/CodeGenPrepare.cpp b/llvm/lib/CodeGen/CodeGenPrepare.cpp
index 492d3d07cd06..6f9475da8c0a 100644
--- a/llvm/lib/CodeGen/CodeGenPrepare.cpp
+++ b/llvm/lib/CodeGen/CodeGenPrepare.cpp
@@ -566,10 +566,9 @@ bool CodeGenPrepare::runOnFunction(Function &F) {
MadeChange |= ConstantFoldTerminator(&BB, true);
if (!MadeChange) continue;
- for (SmallVectorImpl<BasicBlock*>::iterator
- II = Successors.begin(), IE = Successors.end(); II != IE; ++II)
- if (pred_empty(*II))
- WorkList.insert(*II);
+ for (BasicBlock *Succ : Successors)
+ if (pred_empty(Succ))
+ WorkList.insert(Succ);
}
// Delete the dead blocks and any of their dead successors.
@@ -580,10 +579,9 @@ bool CodeGenPrepare::runOnFunction(Function &F) {
DeleteDeadBlock(BB);
- for (SmallVectorImpl<BasicBlock*>::iterator
- II = Successors.begin(), IE = Successors.end(); II != IE; ++II)
- if (pred_empty(*II))
- WorkList.insert(*II);
+ for (BasicBlock *Succ : Successors)
+ if (pred_empty(Succ))
+ WorkList.insert(Succ);
}
// Merge pairs of basic blocks with unconditional branches, connected by
@@ -780,8 +778,8 @@ bool CodeGenPrepare::isMergingEmptyBlockProfitable(BasicBlock *BB,
// Skip merging if the block's successor is also a successor to any callbr
// that leads to this block.
// FIXME: Is this really needed? Is this a correctness issue?
- for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) {
- if (auto *CBI = dyn_cast<CallBrInst>((*PI)->getTerminator()))
+ for (BasicBlock *Pred : predecessors(BB)) {
+ if (auto *CBI = dyn_cast<CallBrInst>((Pred)->getTerminator()))
for (unsigned i = 0, e = CBI->getNumSuccessors(); i != e; ++i)
if (DestBB == CBI->getSuccessor(i))
return false;
@@ -822,9 +820,7 @@ bool CodeGenPrepare::isMergingEmptyBlockProfitable(BasicBlock *BB,
// Find all other incoming blocks from which incoming values of all PHIs in
// DestBB are the same as the ones from BB.
- for (pred_iterator PI = pred_begin(DestBB), E = pred_end(DestBB); PI != E;
- ++PI) {
- BasicBlock *DestBBPred = *PI;
+ for (BasicBlock *DestBBPred : predecessors(DestBB)) {
if (DestBBPred == BB)
continue;
@@ -964,8 +960,8 @@ void CodeGenPrepare::eliminateMostlyEmptyBlock(BasicBlock *BB) {
for (unsigned i = 0, e = BBPN->getNumIncomingValues(); i != e; ++i)
PN.addIncoming(InVal, BBPN->getIncomingBlock(i));
} else {
- for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI)
- PN.addIncoming(InVal, *PI);
+ for (BasicBlock *Pred : predecessors(BB))
+ PN.addIncoming(InVal, Pred);
}
}
}
@@ -2315,14 +2311,14 @@ bool CodeGenPrepare::dupRetToEnableTailCallOpts(BasicBlock *BB, bool &ModifiedDT
}
} else {
SmallPtrSet<BasicBlock*, 4> VisitedBBs;
- for (pred_iterator PI = pred_begin(BB), PE = pred_end(BB); PI != PE; ++PI) {
- if (!VisitedBBs.insert(*PI).second)
+ for (BasicBlock *Pred : predecessors(BB)) {
+ if (!VisitedBBs.insert(Pred).second)
continue;
- if (Instruction *I = (*PI)->rbegin()->getPrevNonDebugInstruction(true)) {
+ if (Instruction *I = Pred->rbegin()->getPrevNonDebugInstruction(true)) {
CallInst *CI = dyn_cast<CallInst>(I);
if (CI && CI->use_empty() && TLI->mayBeEmittedAsTailCall(CI) &&
attributesPermitTailCall(F, CI, RetI, *TLI))
- TailCallBBs.push_back(*PI);
+ TailCallBBs.push_back(Pred);
}
}
}
@@ -2837,11 +2833,8 @@ class TypePromotionTransaction {
/// Reassign the original uses of Inst to Inst.
void undo() override {
LLVM_DEBUG(dbgs() << "Undo: UsersReplacer: " << *Inst << "\n");
- for (use_iterator UseIt = OriginalUses.begin(),
- EndIt = OriginalUses.end();
- UseIt != EndIt; ++UseIt) {
- UseIt->Inst->setOperand(UseIt->Idx, Inst);
- }
+ for (InstructionAndIdx &Use : OriginalUses)
+ Use.Inst->setOperand(Use.Idx, Inst);
// RAUW has replaced all original uses with references to the new value,
// including the debug uses. Since we are undoing the replacements,
// the original debug uses must also be reinstated to maintain the
@@ -3020,9 +3013,8 @@ TypePromotionTransaction::getRestorationPoint() const {
}
bool TypePromotionTransaction::commit() {
- for (CommitPt It = Actions.begin(), EndIt = Actions.end(); It != EndIt;
- ++It)
- (*It)->commit();
+ for (std::unique_ptr<TypePromotionAction> &Action : Actions)
+ Action->commit();
bool Modified = !Actions.empty();
Actions.clear();
return Modified;
More information about the llvm-commits
mailing list