[llvm] r278895 - IfConversion: Use references instead of pointers where possible; NFC
Matthias Braun via llvm-commits
llvm-commits at lists.llvm.org
Tue Aug 16 19:52:01 PDT 2016
Author: matze
Date: Tue Aug 16 21:52:01 2016
New Revision: 278895
URL: http://llvm.org/viewvc/llvm-project?rev=278895&view=rev
Log:
IfConversion: Use references instead of pointers where possible; NFC
Also put some commonly used subexpressions into variables.
Modified:
llvm/trunk/lib/CodeGen/IfConversion.cpp
Modified: llvm/trunk/lib/CodeGen/IfConversion.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/IfConversion.cpp?rev=278895&r1=278894&r2=278895&view=diff
==============================================================================
--- llvm/trunk/lib/CodeGen/IfConversion.cpp (original)
+++ llvm/trunk/lib/CodeGen/IfConversion.cpp Tue Aug 16 21:52:01 2016
@@ -207,13 +207,13 @@ namespace {
void ScanInstructions(BBInfo &BBI,
MachineBasicBlock::iterator &Begin,
MachineBasicBlock::iterator &End) const;
- void AnalyzeBlock(MachineBasicBlock *MBB,
+ void AnalyzeBlock(MachineBasicBlock &MBB,
std::vector<std::unique_ptr<IfcvtToken>> &Tokens);
bool FeasibilityAnalysis(BBInfo &BBI, SmallVectorImpl<MachineOperand> &Cond,
bool isTriangle = false, bool RevBranch = false);
void AnalyzeBlocks(MachineFunction &MF,
std::vector<std::unique_ptr<IfcvtToken>> &Tokens);
- void InvalidatePreds(MachineBasicBlock *BB);
+ void InvalidatePreds(MachineBasicBlock &MBB);
void RemoveExtraEdges(BBInfo &BBI);
bool IfConvertSimple(BBInfo &BBI, IfcvtKind Kind);
bool IfConvertTriangle(BBInfo &BBI, IfcvtKind Kind);
@@ -463,9 +463,9 @@ bool IfConverter::ReverseBranchCondition
/// Returns the next block in the function blocks ordering. If it is the end,
/// returns NULL.
-static inline MachineBasicBlock *getNextBlock(MachineBasicBlock *BB) {
- MachineFunction::iterator I = BB->getIterator();
- MachineFunction::iterator E = BB->getParent()->end();
+static inline MachineBasicBlock *getNextBlock(MachineBasicBlock &MBB) {
+ MachineFunction::iterator I = MBB.getIterator();
+ MachineFunction::iterator E = MBB.getParent()->end();
if (++I == E)
return nullptr;
return &*I;
@@ -656,9 +656,9 @@ bool IfConverter::ValidDiamond(BBInfo &T
MachineBasicBlock *FT = FalseBBI.TrueBB;
if (!TT && blockAlwaysFallThrough(TrueBBI))
- TT = getNextBlock(TrueBBI.BB);
+ TT = getNextBlock(*TrueBBI.BB);
if (!FT && blockAlwaysFallThrough(FalseBBI))
- FT = getNextBlock(FalseBBI.BB);
+ FT = getNextBlock(*FalseBBI.BB);
if (TT != FT)
return false;
if (!TT && (TrueBBI.IsBrAnalyzable || FalseBBI.IsBrAnalyzable))
@@ -847,9 +847,9 @@ bool IfConverter::FeasibilityAnalysis(BB
/// Analyze the structure of the sub-CFG starting from the specified block.
/// Record its successors and whether it looks like an if-conversion candidate.
void IfConverter::AnalyzeBlock(
- MachineBasicBlock *MBB, std::vector<std::unique_ptr<IfcvtToken>> &Tokens) {
+ MachineBasicBlock &MBB, std::vector<std::unique_ptr<IfcvtToken>> &Tokens) {
struct BBState {
- BBState(MachineBasicBlock *BB) : MBB(BB), SuccsAnalyzed(false) {}
+ BBState(MachineBasicBlock &MBB) : MBB(&MBB), SuccsAnalyzed(false) {}
MachineBasicBlock *MBB;
/// This flag is true if MBB's successors have been analyzed.
@@ -905,8 +905,8 @@ void IfConverter::AnalyzeBlock(
// Push the False and True blocks to the stack.
State.SuccsAnalyzed = true;
- BBStack.push_back(BBI.FalseBB);
- BBStack.push_back(BBI.TrueBB);
+ BBStack.push_back(*BBI.FalseBB);
+ BBStack.push_back(*BBI.TrueBB);
continue;
}
@@ -1040,7 +1040,7 @@ void IfConverter::AnalyzeBlock(
void IfConverter::AnalyzeBlocks(
MachineFunction &MF, std::vector<std::unique_ptr<IfcvtToken>> &Tokens) {
for (MachineBasicBlock &MBB : MF)
- AnalyzeBlock(&MBB, Tokens);
+ AnalyzeBlock(MBB, Tokens);
// Sort to favor more complex ifcvt scheme.
std::stable_sort(Tokens.begin(), Tokens.end(), IfcvtTokenCmp);
@@ -1048,11 +1048,11 @@ void IfConverter::AnalyzeBlocks(
/// Returns true either if ToMBB is the next block after MBB or that all the
/// intervening blocks are empty (given MBB can fall through to its next block).
-static bool canFallThroughTo(MachineBasicBlock *BB, MachineBasicBlock *ToBB) {
- MachineFunction::iterator PI = BB->getIterator();
+static bool canFallThroughTo(MachineBasicBlock &MBB, MachineBasicBlock &ToMBB) {
+ MachineFunction::iterator PI = MBB.getIterator();
MachineFunction::iterator I = std::next(PI);
- MachineFunction::iterator TI = ToBB->getIterator();
- MachineFunction::iterator E = BB->getParent()->end();
+ MachineFunction::iterator TI = ToMBB.getIterator();
+ MachineFunction::iterator E = MBB.getParent()->end();
while (I != TI) {
// Check isSuccessor to avoid case where the next block is empty, but
// it's not a successor.
@@ -1065,10 +1065,10 @@ static bool canFallThroughTo(MachineBasi
/// Invalidate predecessor BB info so it would be re-analyzed to determine if it
/// can be if-converted. If predecessor is already enqueued, dequeue it!
-void IfConverter::InvalidatePreds(MachineBasicBlock *BB) {
- for (const MachineBasicBlock *Predecessor : BB->predecessors()) {
+void IfConverter::InvalidatePreds(MachineBasicBlock &MBB) {
+ for (const MachineBasicBlock *Predecessor : MBB.predecessors()) {
BBInfo &PBBI = BBAnalysis[Predecessor->getNumber()];
- if (PBBI.IsDone || PBBI.BB == BB)
+ if (PBBI.IsDone || PBBI.BB == &MBB)
continue;
PBBI.IsAnalyzed = false;
PBBI.IsEnqueued = false;
@@ -1076,11 +1076,11 @@ void IfConverter::InvalidatePreds(Machin
}
/// Inserts an unconditional branch from \p MBB to \p ToMBB.
-static void InsertUncondBranch(MachineBasicBlock *BB, MachineBasicBlock *ToBB,
+static void InsertUncondBranch(MachineBasicBlock &MBB, MachineBasicBlock &ToMBB,
const TargetInstrInfo *TII) {
DebugLoc dl; // FIXME: this is nowhere
SmallVector<MachineOperand, 0> NoCond;
- TII->InsertBranch(*BB, ToBB, nullptr, NoCond, dl);
+ TII->InsertBranch(MBB, &ToMBB, nullptr, NoCond, dl);
}
/// Remove true / false edges if either / both are no longer successors.
@@ -1109,24 +1109,25 @@ static void UpdatePredRedefs(MachineInst
Redefs.stepForward(MI, Clobbers);
// Now add the implicit uses for each of the clobbered values.
- for (auto Reg : Clobbers) {
+ for (auto Clobber : Clobbers) {
// FIXME: Const cast here is nasty, but better than making StepForward
// take a mutable instruction instead of const.
- MachineOperand &Op = const_cast<MachineOperand&>(*Reg.second);
+ unsigned Reg = Clobber.first;
+ MachineOperand &Op = const_cast<MachineOperand&>(*Clobber.second);
MachineInstr *OpMI = Op.getParent();
MachineInstrBuilder MIB(*OpMI->getParent()->getParent(), OpMI);
if (Op.isRegMask()) {
// First handle regmasks. They clobber any entries in the mask which
// means that we need a def for those registers.
- if (LiveBeforeMI.count(Reg.first))
- MIB.addReg(Reg.first, RegState::Implicit);
+ if (LiveBeforeMI.count(Reg))
+ MIB.addReg(Reg, RegState::Implicit);
// We also need to add an implicit def of this register for the later
// use to read from.
// For the register allocator to have allocated a register clobbered
// by the call which is used later, it must be the case that
// the call doesn't return.
- MIB.addReg(Reg.first, RegState::Implicit | RegState::Define);
+ MIB.addReg(Reg, RegState::Implicit | RegState::Define);
continue;
}
assert(Op.isReg() && "Register operand required");
@@ -1136,8 +1137,8 @@ static void UpdatePredRedefs(MachineInst
if (Redefs.contains(Op.getReg()))
Op.setIsDead(false);
}
- if (LiveBeforeMI.count(Reg.first))
- MIB.addReg(Reg.first, RegState::Implicit);
+ if (LiveBeforeMI.count(Reg))
+ MIB.addReg(Reg, RegState::Implicit);
}
}
@@ -1172,15 +1173,17 @@ bool IfConverter::IfConvertSimple(BBInfo
if (Kind == ICSimpleFalse)
std::swap(CvtBBI, NextBBI);
+ MachineBasicBlock &CvtMBB = *CvtBBI->BB;
+ MachineBasicBlock &NextMBB = *NextBBI->BB;
if (CvtBBI->IsDone ||
- (CvtBBI->CannotBeCopied && CvtBBI->BB->pred_size() > 1)) {
+ (CvtBBI->CannotBeCopied && CvtMBB.pred_size() > 1)) {
// Something has changed. It's no longer safe to predicate this block.
BBI.IsAnalyzed = false;
CvtBBI->IsAnalyzed = false;
return false;
}
- if (CvtBBI->BB->hasAddressTaken())
+ if (CvtMBB.hasAddressTaken())
// Conservatively abort if-conversion if BB's address is taken.
return false;
@@ -1191,15 +1194,15 @@ bool IfConverter::IfConvertSimple(BBInfo
// Initialize liveins to the first BB. These are potentiall redefined by
// predicated instructions.
Redefs.init(TRI);
- Redefs.addLiveIns(*CvtBBI->BB);
- Redefs.addLiveIns(*NextBBI->BB);
+ Redefs.addLiveIns(CvtMBB);
+ Redefs.addLiveIns(NextMBB);
// Compute a set of registers which must not be killed by instructions in
// BB1: This is everything live-in to BB2.
DontKill.init(TRI);
- DontKill.addLiveIns(*NextBBI->BB);
+ DontKill.addLiveIns(NextMBB);
- if (CvtBBI->BB->pred_size() > 1) {
+ if (CvtMBB.pred_size() > 1) {
BBI.NonPredSize -= TII->RemoveBranch(*BBI.BB);
// Copy instructions in the true block, predicate them, and add them to
// the entry block.
@@ -1207,10 +1210,10 @@ bool IfConverter::IfConvertSimple(BBInfo
// RemoveExtraEdges won't work if the block has an unanalyzable branch, so
// explicitly remove CvtBBI as a successor.
- BBI.BB->removeSuccessor(CvtBBI->BB, true);
+ BBI.BB->removeSuccessor(&CvtMBB, true);
} else {
- RemoveKills(CvtBBI->BB->begin(), CvtBBI->BB->end(), DontKill, *TRI);
- PredicateBlock(*CvtBBI, CvtBBI->BB->end(), Cond);
+ RemoveKills(CvtMBB.begin(), CvtMBB.end(), DontKill, *TRI);
+ PredicateBlock(*CvtBBI, CvtMBB.end(), Cond);
// Merge converted block into entry block.
BBI.NonPredSize -= TII->RemoveBranch(*BBI.BB);
@@ -1218,8 +1221,8 @@ bool IfConverter::IfConvertSimple(BBInfo
}
bool IterIfcvt = true;
- if (!canFallThroughTo(BBI.BB, NextBBI->BB)) {
- InsertUncondBranch(BBI.BB, NextBBI->BB, TII);
+ if (!canFallThroughTo(*BBI.BB, NextMBB)) {
+ InsertUncondBranch(*BBI.BB, NextMBB, TII);
BBI.HasFallThrough = false;
// Now ifcvt'd block will look like this:
// BB:
@@ -1239,7 +1242,7 @@ bool IfConverter::IfConvertSimple(BBInfo
// Update block info. BB can be iteratively if-converted.
if (!IterIfcvt)
BBI.IsDone = true;
- InvalidatePreds(BBI.BB);
+ InvalidatePreds(*BBI.BB);
CvtBBI->IsDone = true;
// FIXME: Must maintain LiveIns.
@@ -1258,15 +1261,17 @@ bool IfConverter::IfConvertTriangle(BBIn
if (Kind == ICTriangleFalse || Kind == ICTriangleFRev)
std::swap(CvtBBI, NextBBI);
+ MachineBasicBlock &CvtMBB = *CvtBBI->BB;
+ MachineBasicBlock &NextMBB = *NextBBI->BB;
if (CvtBBI->IsDone ||
- (CvtBBI->CannotBeCopied && CvtBBI->BB->pred_size() > 1)) {
+ (CvtBBI->CannotBeCopied && CvtMBB.pred_size() > 1)) {
// Something has changed. It's no longer safe to predicate this block.
BBI.IsAnalyzed = false;
CvtBBI->IsAnalyzed = false;
return false;
}
- if (CvtBBI->BB->hasAddressTaken())
+ if (CvtMBB.hasAddressTaken())
// Conservatively abort if-conversion if BB's address is taken.
return false;
@@ -1278,7 +1283,7 @@ bool IfConverter::IfConvertTriangle(BBIn
if (ReverseBranchCondition(*CvtBBI)) {
// BB has been changed, modify its predecessors (except for this
// one) so they don't get ifcvt'ed based on bad intel.
- for (MachineBasicBlock *PBB : CvtBBI->BB->predecessors()) {
+ for (MachineBasicBlock *PBB : CvtMBB.predecessors()) {
if (PBB == BBI.BB)
continue;
BBInfo &PBBI = BBAnalysis[PBB->getNumber()];
@@ -1293,8 +1298,8 @@ bool IfConverter::IfConvertTriangle(BBIn
// Initialize liveins to the first BB. These are potentially redefined by
// predicated instructions.
Redefs.init(TRI);
- Redefs.addLiveIns(*CvtBBI->BB);
- Redefs.addLiveIns(*NextBBI->BB);
+ Redefs.addLiveIns(CvtMBB);
+ Redefs.addLiveIns(NextMBB);
DontKill.clear();
@@ -1302,14 +1307,14 @@ bool IfConverter::IfConvertTriangle(BBIn
BranchProbability CvtNext, CvtFalse, BBNext, BBCvt;
if (HasEarlyExit) {
- // Get probabilities before modifying CvtBBI->BB and BBI.BB.
- CvtNext = MBPI->getEdgeProbability(CvtBBI->BB, NextBBI->BB);
- CvtFalse = MBPI->getEdgeProbability(CvtBBI->BB, CvtBBI->FalseBB);
- BBNext = MBPI->getEdgeProbability(BBI.BB, NextBBI->BB);
- BBCvt = MBPI->getEdgeProbability(BBI.BB, CvtBBI->BB);
+ // Get probabilities before modifying CvtMBB and BBI.BB.
+ CvtNext = MBPI->getEdgeProbability(&CvtMBB, &NextMBB);
+ CvtFalse = MBPI->getEdgeProbability(&CvtMBB, CvtBBI->FalseBB);
+ BBNext = MBPI->getEdgeProbability(BBI.BB, &NextMBB);
+ BBCvt = MBPI->getEdgeProbability(BBI.BB, &CvtMBB);
}
- if (CvtBBI->BB->pred_size() > 1) {
+ if (CvtMBB.pred_size() > 1) {
BBI.NonPredSize -= TII->RemoveBranch(*BBI.BB);
// Copy instructions in the true block, predicate them, and add them to
// the entry block.
@@ -1317,11 +1322,11 @@ bool IfConverter::IfConvertTriangle(BBIn
// RemoveExtraEdges won't work if the block has an unanalyzable branch, so
// explicitly remove CvtBBI as a successor.
- BBI.BB->removeSuccessor(CvtBBI->BB, true);
+ BBI.BB->removeSuccessor(&CvtMBB, true);
} else {
// Predicate the 'true' block after removing its branch.
- CvtBBI->NonPredSize -= TII->RemoveBranch(*CvtBBI->BB);
- PredicateBlock(*CvtBBI, CvtBBI->BB->end(), Cond);
+ CvtBBI->NonPredSize -= TII->RemoveBranch(CvtMBB);
+ PredicateBlock(*CvtBBI, CvtMBB.end(), Cond);
// Now merge the entry of the triangle with the true block.
BBI.NonPredSize -= TII->RemoveBranch(*BBI.BB);
@@ -1336,12 +1341,12 @@ bool IfConverter::IfConvertTriangle(BBIn
llvm_unreachable("Unable to reverse branch condition!");
// Update the edge probability for both CvtBBI->FalseBB and NextBBI.
- // NewNext = New_Prob(BBI.BB, NextBBI->BB) =
- // Prob(BBI.BB, NextBBI->BB) +
- // Prob(BBI.BB, CvtBBI->BB) * Prob(CvtBBI->BB, NextBBI->BB)
+ // NewNext = New_Prob(BBI.BB, NextMBB) =
+ // Prob(BBI.BB, NextMBB) +
+ // Prob(BBI.BB, CvtMBB) * Prob(CvtMBB, NextMBB)
// NewFalse = New_Prob(BBI.BB, CvtBBI->FalseBB) =
- // Prob(BBI.BB, CvtBBI->BB) * Prob(CvtBBI->BB, CvtBBI->FalseBB)
- auto NewTrueBB = getNextBlock(BBI.BB);
+ // Prob(BBI.BB, CvtMBB) * Prob(CvtMBB, CvtBBI->FalseBB)
+ auto NewTrueBB = getNextBlock(*BBI.BB);
auto NewNext = BBNext + BBCvt * CvtNext;
auto NewTrueBBIter = find(BBI.BB->successors(), NewTrueBB);
if (NewTrueBBIter != BBI.BB->succ_end())
@@ -1356,18 +1361,18 @@ bool IfConverter::IfConvertTriangle(BBIn
// predecessors. Otherwise, add an unconditional branch to 'false'.
bool FalseBBDead = false;
bool IterIfcvt = true;
- bool isFallThrough = canFallThroughTo(BBI.BB, NextBBI->BB);
+ bool isFallThrough = canFallThroughTo(*BBI.BB, NextMBB);
if (!isFallThrough) {
// Only merge them if the true block does not fallthrough to the false
// block. By not merging them, we make it possible to iteratively
// ifcvt the blocks.
if (!HasEarlyExit &&
- NextBBI->BB->pred_size() == 1 && !NextBBI->HasFallThrough &&
- !NextBBI->BB->hasAddressTaken()) {
+ NextMBB.pred_size() == 1 && !NextBBI->HasFallThrough &&
+ !NextMBB.hasAddressTaken()) {
MergeBlocks(BBI, *NextBBI);
FalseBBDead = true;
} else {
- InsertUncondBranch(BBI.BB, NextBBI->BB, TII);
+ InsertUncondBranch(*BBI.BB, NextMBB, TII);
BBI.HasFallThrough = false;
}
// Mixed predicated and unpredicated code. This cannot be iteratively
@@ -1380,7 +1385,7 @@ bool IfConverter::IfConvertTriangle(BBIn
// Update block info. BB can be iteratively if-converted.
if (!IterIfcvt)
BBI.IsDone = true;
- InvalidatePreds(BBI.BB);
+ InvalidatePreds(*BBI.BB);
CvtBBI->IsDone = true;
if (FalseBBDead)
NextBBI->IsDone = true;
@@ -1443,6 +1448,9 @@ bool IfConverter::IfConvertDiamond(BBInf
// Remove the conditional branch from entry to the blocks.
BBI.NonPredSize -= TII->RemoveBranch(*BBI.BB);
+ MachineBasicBlock &MBB1 = *BBI1->BB;
+ MachineBasicBlock &MBB2 = *BBI2->BB;
+
// Initialize the Redefs:
// - BB2 live-in regs need implicit uses before being redefined by BB1
// instructions.
@@ -1450,13 +1458,13 @@ bool IfConverter::IfConvertDiamond(BBInf
// instructions. We start with BB1 live-ins so we have the live-out regs
// after tracking the BB1 instructions.
Redefs.init(TRI);
- Redefs.addLiveIns(*BBI1->BB);
- Redefs.addLiveIns(*BBI2->BB);
+ Redefs.addLiveIns(MBB1);
+ Redefs.addLiveIns(MBB2);
// Remove the duplicated instructions at the beginnings of both paths.
// Skip dbg_value instructions
- MachineBasicBlock::iterator DI1 = BBI1->BB->getFirstNonDebugInstr();
- MachineBasicBlock::iterator DI2 = BBI2->BB->getFirstNonDebugInstr();
+ MachineBasicBlock::iterator DI1 = MBB1.getFirstNonDebugInstr();
+ MachineBasicBlock::iterator DI2 = MBB2.getFirstNonDebugInstr();
BBI1->NonPredSize -= NumDups1;
BBI2->NonPredSize -= NumDups1;
@@ -1476,49 +1484,49 @@ bool IfConverter::IfConvertDiamond(BBInf
// This is everything used+live in BB2 after the duplicated instructions. We
// can compute this set by simulating liveness backwards from the end of BB2.
DontKill.init(TRI);
- for (const MachineInstr &MI : make_range(BBI2->BB->rbegin(),
- MachineBasicBlock::reverse_iterator(DI2)))
+ for (const MachineInstr &MI :
+ make_range(MBB2.rbegin(), MachineBasicBlock::reverse_iterator(DI2)))
DontKill.stepBackward(MI);
- for (const MachineInstr &MI : make_range(BBI1->BB->begin(), DI1)) {
+ for (const MachineInstr &MI : make_range(MBB1.begin(), DI1)) {
SmallVector<std::pair<unsigned, const MachineOperand*>, 4> IgnoredClobbers;
Redefs.stepForward(MI, IgnoredClobbers);
}
- BBI.BB->splice(BBI.BB->end(), BBI1->BB, BBI1->BB->begin(), DI1);
- BBI2->BB->erase(BBI2->BB->begin(), DI2);
+ BBI.BB->splice(BBI.BB->end(), &MBB1, MBB1.begin(), DI1);
+ MBB2.erase(MBB2.begin(), DI2);
// Remove branch from the 'true' block, unless it was not analyzable.
// Non-analyzable branches need to be preserved, since in such cases,
// the CFG structure is not an actual diamond (the join block may not
// be present).
if (BBI1->IsBrAnalyzable)
- BBI1->NonPredSize -= TII->RemoveBranch(*BBI1->BB);
+ BBI1->NonPredSize -= TII->RemoveBranch(MBB1);
// Remove duplicated instructions.
- DI1 = BBI1->BB->end();
+ DI1 = MBB1.end();
for (unsigned i = 0; i != NumDups2; ) {
// NumDups2 only counted non-dbg_value instructions, so this won't
// run off the head of the list.
- assert (DI1 != BBI1->BB->begin());
+ assert(DI1 != MBB1.begin());
--DI1;
// skip dbg_value instructions
if (!DI1->isDebugValue())
++i;
}
- BBI1->BB->erase(DI1, BBI1->BB->end());
+ MBB1.erase(DI1, MBB1.end());
// Kill flags in the true block for registers living into the false block
// must be removed.
- RemoveKills(BBI1->BB->begin(), BBI1->BB->end(), DontKill, *TRI);
+ RemoveKills(MBB1.begin(), MBB1.end(), DontKill, *TRI);
// Remove 'false' block branch (unless it was not analyzable), and find
// the last instruction to predicate.
if (BBI2->IsBrAnalyzable)
- BBI2->NonPredSize -= TII->RemoveBranch(*BBI2->BB);
- DI2 = BBI2->BB->end();
+ BBI2->NonPredSize -= TII->RemoveBranch(MBB2);
+ DI2 = MBB2.end();
while (NumDups2 != 0) {
// NumDups2 only counted non-dbg_value instructions, so this won't
// run off the head of the list.
- assert (DI2 != BBI2->BB->begin());
+ assert(DI2 != MBB2.begin());
--DI2;
// skip dbg_value instructions
if (!DI2->isDebugValue())
@@ -1535,8 +1543,8 @@ bool IfConverter::IfConvertDiamond(BBInf
// addne r0, r1, #1
SmallSet<unsigned, 4> RedefsByFalse;
SmallSet<unsigned, 4> ExtUses;
- if (TII->isProfitableToUnpredicate(*BBI1->BB, *BBI2->BB)) {
- for (const MachineInstr &FI : make_range(BBI2->BB->begin(), DI2)) {
+ if (TII->isProfitableToUnpredicate(MBB1, MBB2)) {
+ for (const MachineInstr &FI : make_range(MBB2.begin(), DI2)) {
if (FI.isDebugValue())
continue;
SmallVector<unsigned, 4> Defs;
@@ -1568,17 +1576,17 @@ bool IfConverter::IfConvertDiamond(BBInf
}
// Predicate the 'true' block.
- PredicateBlock(*BBI1, BBI1->BB->end(), *Cond1, &RedefsByFalse);
+ PredicateBlock(*BBI1, MBB1.end(), *Cond1, &RedefsByFalse);
// After predicating BBI1, if there is a predicated terminator in BBI1 and
// a non-predicated in BBI2, then we don't want to predicate the one from
// BBI2. The reason is that if we merged these blocks, we would end up with
// two predicated terminators in the same block.
- if (!BBI2->BB->empty() && (DI2 == BBI2->BB->end())) {
- MachineBasicBlock::iterator BBI1T = BBI1->BB->getFirstTerminator();
- MachineBasicBlock::iterator BBI2T = BBI2->BB->getFirstTerminator();
- if (BBI1T != BBI1->BB->end() && TII->isPredicated(*BBI1T) &&
- BBI2T != BBI2->BB->end() && !TII->isPredicated(*BBI2T))
+ if (!MBB2.empty() && (DI2 == MBB2.end())) {
+ MachineBasicBlock::iterator BBI1T = MBB1.getFirstTerminator();
+ MachineBasicBlock::iterator BBI2T = MBB2.getFirstTerminator();
+ if (BBI1T != MBB1.end() && TII->isPredicated(*BBI1T) &&
+ BBI2T != MBB2.end() && !TII->isPredicated(*BBI2T))
--DI2;
}
@@ -1610,7 +1618,7 @@ bool IfConverter::IfConvertDiamond(BBInf
CanMergeTail = false;
else if (NumPreds == 1 && CanMergeTail) {
MachineBasicBlock::pred_iterator PI = TailBB->pred_begin();
- if (*PI != BBI1->BB && *PI != BBI2->BB)
+ if (*PI != &MBB1 && *PI != &MBB2)
CanMergeTail = false;
}
if (CanMergeTail) {
@@ -1618,7 +1626,7 @@ bool IfConverter::IfConvertDiamond(BBInf
TailBBI.IsDone = true;
} else {
BBI.BB->addSuccessor(TailBB, BranchProbability::getOne());
- InsertUncondBranch(BBI.BB, TailBB, TII);
+ InsertUncondBranch(*BBI.BB, *TailBB, TII);
BBI.HasFallThrough = false;
}
}
@@ -1626,13 +1634,13 @@ bool IfConverter::IfConvertDiamond(BBInf
// RemoveExtraEdges won't work if the block has an unanalyzable branch,
// which can happen here if TailBB is unanalyzable and is merged, so
// explicitly remove BBI1 and BBI2 as successors.
- BBI.BB->removeSuccessor(BBI1->BB);
- BBI.BB->removeSuccessor(BBI2->BB, true);
+ BBI.BB->removeSuccessor(&MBB1);
+ BBI.BB->removeSuccessor(&MBB2, true);
RemoveExtraEdges(BBI);
// Update block info.
BBI.IsDone = TrueBBI.IsDone = FalseBBI.IsDone = true;
- InvalidatePreds(BBI.BB);
+ InvalidatePreds(*BBI.BB);
// FIXME: Must maintain LiveIns.
return true;
@@ -1707,7 +1715,8 @@ void IfConverter::CopyAndPredicateBlock(
bool IgnoreBr) {
MachineFunction &MF = *ToBBI.BB->getParent();
- for (MachineInstr &I : *FromBBI.BB) {
+ MachineBasicBlock &FromMBB = *FromBBI.BB;
+ for (MachineInstr &I : FromMBB) {
// Do not copy the end of the block branches.
if (IgnoreBr && I.isBranch())
break;
@@ -1740,9 +1749,9 @@ void IfConverter::CopyAndPredicateBlock(
}
if (!IgnoreBr) {
- std::vector<MachineBasicBlock *> Succs(FromBBI.BB->succ_begin(),
- FromBBI.BB->succ_end());
- MachineBasicBlock *NBB = getNextBlock(FromBBI.BB);
+ std::vector<MachineBasicBlock *> Succs(FromMBB.succ_begin(),
+ FromMBB.succ_end());
+ MachineBasicBlock *NBB = getNextBlock(FromMBB);
MachineBasicBlock *FallThrough = FromBBI.HasFallThrough ? NBB : nullptr;
for (MachineBasicBlock *Succ : Succs) {
@@ -1767,19 +1776,20 @@ void IfConverter::CopyAndPredicateBlock(
/// the fall-through edge. If AddEdges is true, i.e., when FromBBI's branch is
/// being moved, add those successor edges to ToBBI.
void IfConverter::MergeBlocks(BBInfo &ToBBI, BBInfo &FromBBI, bool AddEdges) {
- assert(!FromBBI.BB->hasAddressTaken() &&
+ MachineBasicBlock &FromMBB = *FromBBI.BB;
+ assert(!FromMBB.hasAddressTaken() &&
"Removing a BB whose address is taken!");
- // In case FromBBI.BB contains terminators (e.g. return instruction),
+ // In case FromMBB contains terminators (e.g. return instruction),
// first move the non-terminator instructions, then the terminators.
- MachineBasicBlock::iterator FromTI = FromBBI.BB->getFirstTerminator();
+ MachineBasicBlock::iterator FromTI = FromMBB.getFirstTerminator();
MachineBasicBlock::iterator ToTI = ToBBI.BB->getFirstTerminator();
- ToBBI.BB->splice(ToTI, FromBBI.BB, FromBBI.BB->begin(), FromTI);
+ ToBBI.BB->splice(ToTI, &FromMBB, FromMBB.begin(), FromTI);
// If FromBB has non-predicated terminator we should copy it at the end.
- if (FromTI != FromBBI.BB->end() && !TII->isPredicated(*FromTI))
+ if (FromTI != FromMBB.end() && !TII->isPredicated(*FromTI))
ToTI = ToBBI.BB->end();
- ToBBI.BB->splice(ToTI, FromBBI.BB, FromTI, FromBBI.BB->end());
+ ToBBI.BB->splice(ToTI, &FromMBB, FromTI, FromMBB.end());
// Force normalizing the successors' probabilities of ToBBI.BB to convert all
// unknown probabilities into known ones.
@@ -1787,19 +1797,19 @@ void IfConverter::MergeBlocks(BBInfo &To
// eliminate all unknown probabilities in MBB.
ToBBI.BB->normalizeSuccProbs();
- SmallVector<MachineBasicBlock *, 4> FromSuccs(FromBBI.BB->succ_begin(),
- FromBBI.BB->succ_end());
- MachineBasicBlock *NBB = getNextBlock(FromBBI.BB);
+ SmallVector<MachineBasicBlock *, 4> FromSuccs(FromMBB.succ_begin(),
+ FromMBB.succ_end());
+ MachineBasicBlock *NBB = getNextBlock(FromMBB);
MachineBasicBlock *FallThrough = FromBBI.HasFallThrough ? NBB : nullptr;
- // The edge probability from ToBBI.BB to FromBBI.BB, which is only needed when
- // AddEdges is true and FromBBI.BB is a successor of ToBBI.BB.
+ // The edge probability from ToBBI.BB to FromMBB, which is only needed when
+ // AddEdges is true and FromMBB is a successor of ToBBI.BB.
auto To2FromProb = BranchProbability::getZero();
- if (AddEdges && ToBBI.BB->isSuccessor(FromBBI.BB)) {
- To2FromProb = MBPI->getEdgeProbability(ToBBI.BB, FromBBI.BB);
- // Set the edge probability from ToBBI.BB to FromBBI.BB to zero to avoid the
+ if (AddEdges && ToBBI.BB->isSuccessor(&FromMBB)) {
+ To2FromProb = MBPI->getEdgeProbability(ToBBI.BB, &FromMBB);
+ // Set the edge probability from ToBBI.BB to FromMBB to zero to avoid the
// edge probability being merged to other edges when this edge is removed
// later.
- ToBBI.BB->setSuccProbability(find(ToBBI.BB->successors(), FromBBI.BB),
+ ToBBI.BB->setSuccProbability(find(ToBBI.BB->successors(), &FromMBB),
BranchProbability::getZero());
}
@@ -1811,26 +1821,26 @@ void IfConverter::MergeBlocks(BBInfo &To
auto NewProb = BranchProbability::getZero();
if (AddEdges) {
// Calculate the edge probability for the edge from ToBBI.BB to Succ,
- // which is a portion of the edge probability from FromBBI.BB to Succ. The
- // portion ratio is the edge probability from ToBBI.BB to FromBBI.BB (if
+ // which is a portion of the edge probability from FromMBB to Succ. The
+ // portion ratio is the edge probability from ToBBI.BB to FromMBB (if
// FromBBI is a successor of ToBBI.BB. See comment below for excepion).
- NewProb = MBPI->getEdgeProbability(FromBBI.BB, Succ);
+ NewProb = MBPI->getEdgeProbability(&FromMBB, Succ);
- // To2FromProb is 0 when FromBBI.BB is not a successor of ToBBI.BB. This
- // only happens when if-converting a diamond CFG and FromBBI.BB is the
- // tail BB. In this case FromBBI.BB post-dominates ToBBI.BB and hence we
- // could just use the probabilities on FromBBI.BB's out-edges when adding
+ // To2FromProb is 0 when FromMBB is not a successor of ToBBI.BB. This
+ // only happens when if-converting a diamond CFG and FromMBB is the
+ // tail BB. In this case FromMBB post-dominates ToBBI.BB and hence we
+ // could just use the probabilities on FromMBB's out-edges when adding
// new successors.
if (!To2FromProb.isZero())
NewProb *= To2FromProb;
}
- FromBBI.BB->removeSuccessor(Succ);
+ FromMBB.removeSuccessor(Succ);
if (AddEdges) {
// If the edge from ToBBI.BB to Succ already exists, update the
// probability of this edge by adding NewProb to it. An example is shown
- // below, in which A is ToBBI.BB and B is FromBBI.BB. In this case we
+ // below, in which A is ToBBI.BB and B is FromMBB. In this case we
// don't have to set C as A's successor as it already is. We only need to
// update the edge probability on A->C. Note that B will not be
// immediately removed from A's successors. It is possible that B->D is
@@ -1860,8 +1870,8 @@ void IfConverter::MergeBlocks(BBInfo &To
}
// Now FromBBI always falls through to the next block!
- if (NBB && !FromBBI.BB->isSuccessor(NBB))
- FromBBI.BB->addSuccessor(NBB);
+ if (NBB && !FromMBB.isSuccessor(NBB))
+ FromMBB.addSuccessor(NBB);
// Normalize the probabilities of ToBBI.BB's successors with all adjustment
// we've done above.
More information about the llvm-commits
mailing list