RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-23 19:23:23 +01:00
Code Issues Projects Releases Wiki Activity

Rename some function arguments in MachineBasicBlock.cpp/h by turning the first letter into upper case. NFC.

Browse Source 
llvm-svn: 248821
This commit is contained in:
Cong Hou 2015-09-29 19:46:09 +00:00
parent a883fbf7ee
commit 9504de2aa1
2 changed files with 88 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
include/llvm/CodeGen/MachineBasicBlock.h
View File

@ -57,8 +57,8 @@ public:
void addNodeToList(MachineInstr* N); void addNodeToList(MachineInstr* N);
void removeNodeFromList(MachineInstr* N); void removeNodeFromList(MachineInstr* N);
void transferNodesFromList(ilist_traits &SrcTraits, void transferNodesFromList(ilist_traits &SrcTraits,
ilist_iterator<MachineInstr> first, ilist_iterator<MachineInstr> First,
ilist_iterator<MachineInstr> last); ilist_iterator<MachineInstr> Last);
void deleteNode(MachineInstr *N); void deleteNode(MachineInstr *N);
private: private:
void createNode(const MachineInstr &); void createNode(const MachineInstr &);
@ -121,7 +121,7 @@ protected:
// Intrusive list support // Intrusive list support
MachineBasicBlock() {} MachineBasicBlock() {}
explicit MachineBasicBlock(MachineFunction &mf, const BasicBlock *bb); explicit MachineBasicBlock(MachineFunction &MF, const BasicBlock *BB);
~MachineBasicBlock(); ~MachineBasicBlock();
@ -159,14 +159,14 @@ public:
IterTy MII; IterTy MII;
public: public:
bundle_iterator(IterTy mii) : MII(mii) {} bundle_iterator(IterTy MI) : MII(MI) {}
bundle_iterator(Ty &mi) : MII(mi) { bundle_iterator(Ty &MI) : MII(MI) {
assert(!mi.isBundledWithPred() && assert(!MI.isBundledWithPred() &&
"It's not legal to initialize bundle_iterator with a bundled MI"); "It's not legal to initialize bundle_iterator with a bundled MI");
} }
bundle_iterator(Ty *mi) : MII(mi) { bundle_iterator(Ty *MI) : MII(MI) {
assert((!mi || !mi->isBundledWithPred()) && assert((!MI || !MI->isBundledWithPred()) &&
"It's not legal to initialize bundle_iterator with a bundled MI"); "It's not legal to initialize bundle_iterator with a bundled MI");
} }
// Template allows conversion from const to nonconst. // Template allows conversion from const to nonconst.
@ -180,11 +180,11 @@ public:
operator Ty*() const { return MII; } operator Ty*() const { return MII; }
bool operator==(const bundle_iterator &x) const { bool operator==(const bundle_iterator &X) const {
return MII == x.MII; return MII == X.MII;
} }
bool operator!=(const bundle_iterator &x) const { bool operator!=(const bundle_iterator &X) const {
return !operator==(x); return !operator==(X);
} }
// Increment and decrement operators... // Increment and decrement operators...
@ -408,23 +408,23 @@ public:
// Machine-CFG mutators // Machine-CFG mutators
/// Add succ as a successor of this MachineBasicBlock. The Predecessors list /// Add Succ as a successor of this MachineBasicBlock. The Predecessors list
/// of succ is automatically updated. WEIGHT parameter is stored in Weights /// of Succ is automatically updated. WEIGHT parameter is stored in Weights
/// list and it may be used by MachineBranchProbabilityInfo analysis to /// list and it may be used by MachineBranchProbabilityInfo analysis to
/// calculate branch probability. /// calculate branch probability.
/// ///
/// Note that duplicate Machine CFG edges are not allowed. /// Note that duplicate Machine CFG edges are not allowed.
void addSuccessor(MachineBasicBlock *succ, uint32_t weight = 0); void addSuccessor(MachineBasicBlock *Succ, uint32_t Weight = 0);
/// Set successor weight of a given iterator. /// Set successor weight of a given iterator.
void setSuccWeight(succ_iterator I, uint32_t weight); void setSuccWeight(succ_iterator I, uint32_t Weight);
/// Remove successor from the successors list of this MachineBasicBlock. The /// Remove successor from the successors list of this MachineBasicBlock. The
/// Predecessors list of succ is automatically updated. /// Predecessors list of Succ is automatically updated.
void removeSuccessor(MachineBasicBlock *succ); void removeSuccessor(MachineBasicBlock *Succ);
/// Remove specified successor from the successors list of this /// Remove specified successor from the successors list of this
/// MachineBasicBlock. The Predecessors list of succ is automatically updated. /// MachineBasicBlock. The Predecessors list of Succ is automatically updated.
/// Return the iterator to the element after the one removed. /// Return the iterator to the element after the one removed.
succ_iterator removeSuccessor(succ_iterator I); succ_iterator removeSuccessor(succ_iterator I);
@ -432,13 +432,13 @@ public:
void replaceSuccessor(MachineBasicBlock *Old, MachineBasicBlock *New); void replaceSuccessor(MachineBasicBlock *Old, MachineBasicBlock *New);
/// Transfers all the successors from MBB to this machine basic block (i.e., /// Transfers all the successors from MBB to this machine basic block (i.e.,
/// copies all the successors fromMBB and remove all the successors from /// copies all the successors FromMBB and remove all the successors from
/// fromMBB). /// FromMBB).
void transferSuccessors(MachineBasicBlock *fromMBB); void transferSuccessors(MachineBasicBlock *FromMBB);
/// Transfers all the successors, as in transferSuccessors, and update PHI /// Transfers all the successors, as in transferSuccessors, and update PHI
/// operands in the successor blocks which refer to fromMBB to refer to this. /// operands in the successor blocks which refer to FromMBB to refer to this.
void transferSuccessorsAndUpdatePHIs(MachineBasicBlock *fromMBB); void transferSuccessorsAndUpdatePHIs(MachineBasicBlock *FromMBB);
/// Return true if any of the successors have weights attached to them. /// Return true if any of the successors have weights attached to them.
bool hasSuccessorWeights() const { return !Weights.empty(); } bool hasSuccessorWeights() const { return !Weights.empty(); }
@ -645,7 +645,7 @@ public:
/// possible that DestA and/or DestB are LandingPads. /// possible that DestA and/or DestB are LandingPads.
bool CorrectExtraCFGEdges(MachineBasicBlock *DestA, bool CorrectExtraCFGEdges(MachineBasicBlock *DestA,
MachineBasicBlock *DestB, MachineBasicBlock *DestB,
bool isCond); bool IsCond);
/// Find the next valid DebugLoc starting at MBBI, skipping any DBG_VALUE /// Find the next valid DebugLoc starting at MBBI, skipping any DBG_VALUE
/// instructions. Return UnknownLoc if there is none. /// instructions. Return UnknownLoc if there is none.
@ -714,15 +714,15 @@ private:
// Machine-CFG mutators // Machine-CFG mutators
/// Remove pred as a predecessor of this MachineBasicBlock. Don't do this /// Remove Pred as a predecessor of this MachineBasicBlock. Don't do this
/// unless you know what you're doing, because it doesn't update pred's /// unless you know what you're doing, because it doesn't update Pred's
/// successors list. Use pred->addSuccessor instead. /// successors list. Use Pred->addSuccessor instead.
void addPredecessor(MachineBasicBlock *pred); void addPredecessor(MachineBasicBlock *Pred);
/// Remove pred as a predecessor of this MachineBasicBlock. Don't do this /// Remove Pred as a predecessor of this MachineBasicBlock. Don't do this
/// unless you know what you're doing, because it doesn't update pred's /// unless you know what you're doing, because it doesn't update Pred's
/// successors list. Use pred->removeSuccessor instead. /// successors list. Use Pred->removeSuccessor instead.
void removePredecessor(MachineBasicBlock *pred); void removePredecessor(MachineBasicBlock *Pred);
}; };
raw_ostream& operator<<(raw_ostream &OS, const MachineBasicBlock &MBB); raw_ostream& operator<<(raw_ostream &OS, const MachineBasicBlock &MBB);

110
lib/CodeGen/MachineBasicBlock.cpp
View File

@ -38,8 +38,8 @@ using namespace llvm;
#define DEBUG_TYPE "codegen" #define DEBUG_TYPE "codegen"
MachineBasicBlock::MachineBasicBlock(MachineFunction &mf, const BasicBlock *bb) MachineBasicBlock::MachineBasicBlock(MachineFunction &MF, const BasicBlock *B)
: BB(bb), Number(-1), xParent(&mf) { : BB(B), Number(-1), xParent(&MF) {
Insts.Parent = this; Insts.Parent = this;
} }
@ -116,19 +116,19 @@ void ilist_traits<MachineInstr>::removeNodeFromList(MachineInstr *N) {
/// When moving a range of instructions from one MBB list to another, we need to /// When moving a range of instructions from one MBB list to another, we need to
/// update the parent pointers and the use/def lists. /// update the parent pointers and the use/def lists.
void ilist_traits<MachineInstr>:: void ilist_traits<MachineInstr>::
transferNodesFromList(ilist_traits<MachineInstr> &fromList, transferNodesFromList(ilist_traits<MachineInstr> &FromList,
ilist_iterator<MachineInstr> first, ilist_iterator<MachineInstr> First,
ilist_iterator<MachineInstr> last) { ilist_iterator<MachineInstr> Last) {
assert(Parent->getParent() == fromList.Parent->getParent() && assert(Parent->getParent() == FromList.Parent->getParent() &&
"MachineInstr parent mismatch!"); "MachineInstr parent mismatch!");
// Splice within the same MBB -> no change. // Splice within the same MBB -> no change.
if (Parent == fromList.Parent) return; if (Parent == FromList.Parent) return;
// If splicing between two blocks within the same function, just update the // If splicing between two blocks within the same function, just update the
// parent pointers. // parent pointers.
for (; first != last; ++first) for (; First != Last; ++First)
first->setParent(Parent); First->setParent(Parent);
} }
void ilist_traits<MachineInstr>::deleteNode(MachineInstr* MI) { void ilist_traits<MachineInstr>::deleteNode(MachineInstr* MI) {
@ -417,7 +417,7 @@ void MachineBasicBlock::updateTerminator() {
MachineBasicBlock *TBB = nullptr, *FBB = nullptr; MachineBasicBlock *TBB = nullptr, *FBB = nullptr;
SmallVector<MachineOperand, 4> Cond; SmallVector<MachineOperand, 4> Cond;
DebugLoc dl; // FIXME: this is nowhere DebugLoc DL; // FIXME: this is nowhere
bool B = TII->AnalyzeBranch(*this, TBB, FBB, Cond); bool B = TII->AnalyzeBranch(*this, TBB, FBB, Cond);
(void) B; (void) B;
assert(!B && "UpdateTerminators requires analyzable predecessors!"); assert(!B && "UpdateTerminators requires analyzable predecessors!");
@ -446,7 +446,7 @@ void MachineBasicBlock::updateTerminator() {
// Finally update the unconditional successor to be reached via a branch // Finally update the unconditional successor to be reached via a branch
// if it would not be reached by fallthrough. // if it would not be reached by fallthrough.
if (!isLayoutSuccessor(TBB)) if (!isLayoutSuccessor(TBB))
TII->InsertBranch(*this, TBB, nullptr, Cond, dl); TII->InsertBranch(*this, TBB, nullptr, Cond, DL);
} }
} else { } else {
if (FBB) { if (FBB) {
@ -457,10 +457,10 @@ void MachineBasicBlock::updateTerminator() {
if (TII->ReverseBranchCondition(Cond)) if (TII->ReverseBranchCondition(Cond))
return; return;
TII->RemoveBranch(*this); TII->RemoveBranch(*this);
TII->InsertBranch(*this, FBB, nullptr, Cond, dl); TII->InsertBranch(*this, FBB, nullptr, Cond, DL);
} else if (isLayoutSuccessor(FBB)) { } else if (isLayoutSuccessor(FBB)) {
TII->RemoveBranch(*this); TII->RemoveBranch(*this);
TII->InsertBranch(*this, TBB, nullptr, Cond, dl); TII->InsertBranch(*this, TBB, nullptr, Cond, DL);
} }
} else { } else {
// Walk through the successors and find the successor which is not // Walk through the successors and find the successor which is not
@ -484,7 +484,7 @@ void MachineBasicBlock::updateTerminator() {
// Finally update the unconditional successor to be reached via a branch // Finally update the unconditional successor to be reached via a branch
// if it would not be reached by fallthrough. // if it would not be reached by fallthrough.
if (!isLayoutSuccessor(TBB)) if (!isLayoutSuccessor(TBB))
TII->InsertBranch(*this, TBB, nullptr, Cond, dl); TII->InsertBranch(*this, TBB, nullptr, Cond, DL);
return; return;
} }
@ -493,36 +493,36 @@ void MachineBasicBlock::updateTerminator() {
if (TII->ReverseBranchCondition(Cond)) { if (TII->ReverseBranchCondition(Cond)) {
// We can't reverse the condition, add an unconditional branch. // We can't reverse the condition, add an unconditional branch.
Cond.clear(); Cond.clear();
TII->InsertBranch(*this, FallthroughBB, nullptr, Cond, dl); TII->InsertBranch(*this, FallthroughBB, nullptr, Cond, DL);
return; return;
} }
TII->RemoveBranch(*this); TII->RemoveBranch(*this);
TII->InsertBranch(*this, FallthroughBB, nullptr, Cond, dl); TII->InsertBranch(*this, FallthroughBB, nullptr, Cond, DL);
} else if (!isLayoutSuccessor(FallthroughBB)) { } else if (!isLayoutSuccessor(FallthroughBB)) {
TII->RemoveBranch(*this); TII->RemoveBranch(*this);
TII->InsertBranch(*this, TBB, FallthroughBB, Cond, dl); TII->InsertBranch(*this, TBB, FallthroughBB, Cond, DL);
} }
} }
} }
} }
void MachineBasicBlock::addSuccessor(MachineBasicBlock *succ, uint32_t weight) { void MachineBasicBlock::addSuccessor(MachineBasicBlock *Succ, uint32_t Weight) {
// If we see non-zero value for the first time it means we actually use Weight // If we see non-zero value for the first time it means we actually use Weight
// list, so we fill all Weights with 0's. // list, so we fill all Weights with 0's.
if (weight != 0 && Weights.empty()) if (Weight != 0 && Weights.empty())
Weights.resize(Successors.size()); Weights.resize(Successors.size());
if (weight != 0 || !Weights.empty()) if (Weight != 0 || !Weights.empty())
Weights.push_back(weight); Weights.push_back(Weight);
Successors.push_back(succ); Successors.push_back(Succ);
succ->addPredecessor(this); Succ->addPredecessor(this);
} }
void MachineBasicBlock::removeSuccessor(MachineBasicBlock *succ) { void MachineBasicBlock::removeSuccessor(MachineBasicBlock *Succ) {
succ->removePredecessor(this); Succ->removePredecessor(this);
succ_iterator I = std::find(Successors.begin(), Successors.end(), succ); succ_iterator I = std::find(Successors.begin(), Successors.end(), Succ);
assert(I != Successors.end() && "Not a current successor!"); assert(I != Successors.end() && "Not a current successor!");
// If Weight list is empty it means we don't use it (disabled optimization). // If Weight list is empty it means we don't use it (disabled optimization).
@ -588,52 +588,52 @@ void MachineBasicBlock::replaceSuccessor(MachineBasicBlock *Old,
Successors.erase(OldI); Successors.erase(OldI);
} }
void MachineBasicBlock::addPredecessor(MachineBasicBlock *pred) { void MachineBasicBlock::addPredecessor(MachineBasicBlock *Pred) {
Predecessors.push_back(pred); Predecessors.push_back(Pred);
} }
void MachineBasicBlock::removePredecessor(MachineBasicBlock *pred) { void MachineBasicBlock::removePredecessor(MachineBasicBlock *Pred) {
pred_iterator I = std::find(Predecessors.begin(), Predecessors.end(), pred); pred_iterator I = std::find(Predecessors.begin(), Predecessors.end(), Pred);
assert(I != Predecessors.end() && "Pred is not a predecessor of this block!"); assert(I != Predecessors.end() && "Pred is not a predecessor of this block!");
Predecessors.erase(I); Predecessors.erase(I);
} }
void MachineBasicBlock::transferSuccessors(MachineBasicBlock *fromMBB) { void MachineBasicBlock::transferSuccessors(MachineBasicBlock *FromMBB) {
if (this == fromMBB) if (this == FromMBB)
return; return;
while (!fromMBB->succ_empty()) { while (!FromMBB->succ_empty()) {
MachineBasicBlock *Succ = *fromMBB->succ_begin(); MachineBasicBlock *Succ = *FromMBB->succ_begin();
uint32_t Weight = 0; uint32_t Weight = 0;
// If Weight list is empty it means we don't use it (disabled optimization). // If Weight list is empty it means we don't use it (disabled optimization).
if (!fromMBB->Weights.empty()) if (!FromMBB->Weights.empty())
Weight = *fromMBB->Weights.begin(); Weight = *FromMBB->Weights.begin();
addSuccessor(Succ, Weight); addSuccessor(Succ, Weight);
fromMBB->removeSuccessor(Succ); FromMBB->removeSuccessor(Succ);
} }
} }
void void
MachineBasicBlock::transferSuccessorsAndUpdatePHIs(MachineBasicBlock *fromMBB) { MachineBasicBlock::transferSuccessorsAndUpdatePHIs(MachineBasicBlock *FromMBB) {
if (this == fromMBB) if (this == FromMBB)
return; return;
while (!fromMBB->succ_empty()) { while (!FromMBB->succ_empty()) {
MachineBasicBlock *Succ = *fromMBB->succ_begin(); MachineBasicBlock *Succ = *FromMBB->succ_begin();
uint32_t Weight = 0; uint32_t Weight = 0;
if (!fromMBB->Weights.empty()) if (!FromMBB->Weights.empty())
Weight = *fromMBB->Weights.begin(); Weight = *FromMBB->Weights.begin();
addSuccessor(Succ, Weight); addSuccessor(Succ, Weight);
fromMBB->removeSuccessor(Succ); FromMBB->removeSuccessor(Succ);
// Fix up any PHI nodes in the successor. // Fix up any PHI nodes in the successor.
for (MachineBasicBlock::instr_iterator MI = Succ->instr_begin(), for (MachineBasicBlock::instr_iterator MI = Succ->instr_begin(),
ME = Succ->instr_end(); MI != ME && MI->isPHI(); ++MI) ME = Succ->instr_end(); MI != ME && MI->isPHI(); ++MI)
for (unsigned i = 2, e = MI->getNumOperands()+1; i != e; i += 2) { for (unsigned i = 2, e = MI->getNumOperands()+1; i != e; i += 2) {
MachineOperand &MO = MI->getOperand(i); MachineOperand &MO = MI->getOperand(i);
if (MO.getMBB() == fromMBB) if (MO.getMBB() == FromMBB)
MO.setMBB(this); MO.setMBB(this);
} }
} }
@ -702,7 +702,7 @@ MachineBasicBlock::SplitCriticalEdge(MachineBasicBlock *Succ, Pass *P) {
return nullptr; return nullptr;
MachineFunction *MF = getParent(); MachineFunction *MF = getParent();
DebugLoc dl; // FIXME: this is nowhere DebugLoc DL; // FIXME: this is nowhere
// Performance might be harmed on HW that implements branching using exec mask // Performance might be harmed on HW that implements branching using exec mask
// where both sides of the branches are always executed. // where both sides of the branches are always executed.
@ -816,7 +816,7 @@ MachineBasicBlock::SplitCriticalEdge(MachineBasicBlock *Succ, Pass *P) {
NMBB->addSuccessor(Succ); NMBB->addSuccessor(Succ);
if (!NMBB->isLayoutSuccessor(Succ)) { if (!NMBB->isLayoutSuccessor(Succ)) {
Cond.clear(); Cond.clear();
TII->InsertBranch(*NMBB, Succ, nullptr, Cond, dl); TII->InsertBranch(*NMBB, Succ, nullptr, Cond, DL);
if (Indexes) { if (Indexes) {
for (instr_iterator I = NMBB->instr_begin(), E = NMBB->instr_end(); for (instr_iterator I = NMBB->instr_begin(), E = NMBB->instr_end();
@ -1041,18 +1041,18 @@ void MachineBasicBlock::ReplaceUsesOfBlockWith(MachineBasicBlock *Old,
/// Note it is possible that DestA and/or DestB are LandingPads. /// Note it is possible that DestA and/or DestB are LandingPads.
bool MachineBasicBlock::CorrectExtraCFGEdges(MachineBasicBlock *DestA, bool MachineBasicBlock::CorrectExtraCFGEdges(MachineBasicBlock *DestA,
MachineBasicBlock *DestB, MachineBasicBlock *DestB,
bool isCond) { bool IsCond) {
// The values of DestA and DestB frequently come from a call to the // The values of DestA and DestB frequently come from a call to the
// 'TargetInstrInfo::AnalyzeBranch' method. We take our meaning of the initial // 'TargetInstrInfo::AnalyzeBranch' method. We take our meaning of the initial
// values from there. // values from there.
// //
// 1. If both DestA and DestB are null, then the block ends with no branches // 1. If both DestA and DestB are null, then the block ends with no branches
// (it falls through to its successor). // (it falls through to its successor).
// 2. If DestA is set, DestB is null, and isCond is false, then the block ends // 2. If DestA is set, DestB is null, and IsCond is false, then the block ends
// with only an unconditional branch. // with only an unconditional branch.
// 3. If DestA is set, DestB is null, and isCond is true, then the block ends // 3. If DestA is set, DestB is null, and IsCond is true, then the block ends
// with a conditional branch that falls through to a successor (DestB). // with a conditional branch that falls through to a successor (DestB).
// 4. If DestA and DestB is set and isCond is true, then the block ends with a // 4. If DestA and DestB is set and IsCond is true, then the block ends with a
// conditional branch followed by an unconditional branch. DestA is the // conditional branch followed by an unconditional branch. DestA is the
// 'true' destination and DestB is the 'false' destination. // 'true' destination and DestB is the 'false' destination.
@ -1066,11 +1066,11 @@ bool MachineBasicBlock::CorrectExtraCFGEdges(MachineBasicBlock *DestA,
DestA = FallThru; DestA = FallThru;
DestB = FallThru; DestB = FallThru;
} else if (DestA && !DestB) { } else if (DestA && !DestB) {
if (isCond) if (IsCond)
// Block ends in conditional jump that falls through to successor. // Block ends in conditional jump that falls through to successor.
DestB = FallThru; DestB = FallThru;
} else { } else {
assert(DestA && DestB && isCond && assert(DestA && DestB && IsCond &&
"CFG in a bad state. Cannot correct CFG edges"); "CFG in a bad state. Cannot correct CFG edges");
} }
@ -1119,10 +1119,10 @@ uint32_t MachineBasicBlock::getSuccWeight(const_succ_iterator Succ) const {
} }
/// Set successor weight of a given iterator. /// Set successor weight of a given iterator.
void MachineBasicBlock::setSuccWeight(succ_iterator I, uint32_t weight) { void MachineBasicBlock::setSuccWeight(succ_iterator I, uint32_t Weight) {
if (Weights.empty()) if (Weights.empty())
return; return;
*getWeightIterator(I) = weight; *getWeightIterator(I) = Weight;
} }
/// Return wight iterator corresonding to the I successor iterator. /// Return wight iterator corresonding to the I successor iterator.