From 917be6814e0a4e529d290be5d806a054bbbc4a27 Mon Sep 17 00:00:00 2001 From: Evan Cheng Date: Tue, 4 Mar 2008 00:41:45 +0000 Subject: [PATCH] Rename isOperand() to isOperandOf() (and other similar methods). It always confuses me. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@47872 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/CodeGen/SelectionDAGNodes.h | 20 ++++++++++---------- lib/CodeGen/SelectionDAG/DAGCombiner.cpp | 18 +++++++++--------- lib/CodeGen/SelectionDAG/ScheduleDAG.cpp | 2 +- lib/CodeGen/SelectionDAG/ScheduleDAGRRList.cpp | 2 +- lib/CodeGen/SelectionDAG/SelectionDAG.cpp | 12 ++++++------ 5 files changed, 27 insertions(+), 27 deletions(-) diff --git a/include/llvm/CodeGen/SelectionDAGNodes.h b/include/llvm/CodeGen/SelectionDAGNodes.h index 3fbe905ccde..afd1e78d204 100644 --- a/include/llvm/CodeGen/SelectionDAGNodes.h +++ b/include/llvm/CodeGen/SelectionDAGNodes.h @@ -825,8 +825,8 @@ public: return SDOperand(Val, R); } - // isOperand - Return true if this node is an operand of N. - bool isOperand(SDNode *N) const; + // isOperandOf - Return true if this node is an operand of N. + bool isOperandOf(SDNode *N) const; /// getValueType - Return the ValueType of the referenced return value. /// @@ -969,19 +969,19 @@ public: /// value. This method ignores uses of other values defined by this operation. bool hasAnyUseOfValue(unsigned Value) const; - /// isOnlyUse - Return true if this node is the only use of N. + /// isOnlyUseOf - Return true if this node is the only use of N. /// - bool isOnlyUse(SDNode *N) const; + bool isOnlyUseOf(SDNode *N) const; - /// isOperand - Return true if this node is an operand of N. + /// isOperandOf - Return true if this node is an operand of N. /// - bool isOperand(SDNode *N) const; + bool isOperandOf(SDNode *N) const; - /// isPredecessor - Return true if this node is a predecessor of N. This node - /// is either an operand of N or it can be reached by recursively traversing - /// up the operands. + /// isPredecessorOf - Return true if this node is a predecessor of N. This + /// node is either an operand of N or it can be reached by recursively + /// traversing up the operands. /// NOTE: this is an expensive method. Use it carefully. - bool isPredecessor(SDNode *N) const; + bool isPredecessorOf(SDNode *N) const; /// getNumOperands - Return the number of values used by this operation. /// diff --git a/lib/CodeGen/SelectionDAG/DAGCombiner.cpp b/lib/CodeGen/SelectionDAG/DAGCombiner.cpp index 6069c932104..963a1feba8a 100644 --- a/lib/CodeGen/SelectionDAG/DAGCombiner.cpp +++ b/lib/CodeGen/SelectionDAG/DAGCombiner.cpp @@ -4030,7 +4030,7 @@ bool DAGCombiner::CombineToPreIndexedLoadStore(SDNode *N) { // Check #2. if (!isLoad) { SDOperand Val = cast(N)->getValue(); - if (Val == BasePtr || BasePtr.Val->isPredecessor(Val.Val)) + if (Val == BasePtr || BasePtr.Val->isPredecessorOf(Val.Val)) return false; } @@ -4041,7 +4041,7 @@ bool DAGCombiner::CombineToPreIndexedLoadStore(SDNode *N) { SDNode *Use = *I; if (Use == N) continue; - if (Use->isPredecessor(N)) + if (Use->isPredecessorOf(N)) return false; if (!((Use->getOpcode() == ISD::LOAD && @@ -4179,7 +4179,7 @@ bool DAGCombiner::CombineToPostIndexedLoadStore(SDNode *N) { continue; // Check for #2 - if (!Op->isPredecessor(N) && !N->isPredecessor(Op)) { + if (!Op->isPredecessorOf(N) && !N->isPredecessorOf(Op)) { SDOperand Result = isLoad ? DAG.getIndexedLoad(SDOperand(N,0), BasePtr, Offset, AM) : DAG.getIndexedStore(SDOperand(N,0), BasePtr, Offset, AM); @@ -5008,8 +5008,8 @@ bool DAGCombiner::SimplifySelectOps(SDNode *TheSelect, SDOperand LHS, if (TheSelect->getOpcode() == ISD::SELECT) { // Check that the condition doesn't reach either load. If so, folding // this will induce a cycle into the DAG. - if (!LLD->isPredecessor(TheSelect->getOperand(0).Val) && - !RLD->isPredecessor(TheSelect->getOperand(0).Val)) { + if (!LLD->isPredecessorOf(TheSelect->getOperand(0).Val) && + !RLD->isPredecessorOf(TheSelect->getOperand(0).Val)) { Addr = DAG.getNode(ISD::SELECT, LLD->getBasePtr().getValueType(), TheSelect->getOperand(0), LLD->getBasePtr(), RLD->getBasePtr()); @@ -5017,10 +5017,10 @@ bool DAGCombiner::SimplifySelectOps(SDNode *TheSelect, SDOperand LHS, } else { // Check that the condition doesn't reach either load. If so, folding // this will induce a cycle into the DAG. - if (!LLD->isPredecessor(TheSelect->getOperand(0).Val) && - !RLD->isPredecessor(TheSelect->getOperand(0).Val) && - !LLD->isPredecessor(TheSelect->getOperand(1).Val) && - !RLD->isPredecessor(TheSelect->getOperand(1).Val)) { + if (!LLD->isPredecessorOf(TheSelect->getOperand(0).Val) && + !RLD->isPredecessorOf(TheSelect->getOperand(0).Val) && + !LLD->isPredecessorOf(TheSelect->getOperand(1).Val) && + !RLD->isPredecessorOf(TheSelect->getOperand(1).Val)) { Addr = DAG.getNode(ISD::SELECT_CC, LLD->getBasePtr().getValueType(), TheSelect->getOperand(0), TheSelect->getOperand(1), diff --git a/lib/CodeGen/SelectionDAG/ScheduleDAG.cpp b/lib/CodeGen/SelectionDAG/ScheduleDAG.cpp index c87fb60593f..3be59952d1e 100644 --- a/lib/CodeGen/SelectionDAG/ScheduleDAG.cpp +++ b/lib/CodeGen/SelectionDAG/ScheduleDAG.cpp @@ -128,7 +128,7 @@ void ScheduleDAG::BuildSchedUnits() { bool HasFlagUse = false; for (SDNode::use_iterator UI = N->use_begin(), E = N->use_end(); UI != E; ++UI) - if (FlagVal.isOperand(*UI)) { + if (FlagVal.isOperandOf(*UI)) { HasFlagUse = true; NodeSUnit->FlaggedNodes.push_back(N); SUnitMap[N].push_back(NodeSUnit); diff --git a/lib/CodeGen/SelectionDAG/ScheduleDAGRRList.cpp b/lib/CodeGen/SelectionDAG/ScheduleDAGRRList.cpp index 9f604ed70eb..df57f746b3b 100644 --- a/lib/CodeGen/SelectionDAG/ScheduleDAGRRList.cpp +++ b/lib/CodeGen/SelectionDAG/ScheduleDAGRRList.cpp @@ -472,7 +472,7 @@ SUnit *ScheduleDAGRRList::CopyAndMoveSuccessors(SUnit *SU) { I != E; ++I) { if (I->isCtrl) ChainPred = I->Dep; - else if (I->Dep->Node && I->Dep->Node->isOperand(LoadNode)) + else if (I->Dep->Node && I->Dep->Node->isOperandOf(LoadNode)) LoadPreds.push_back(SDep(I->Dep, I->Reg, I->Cost, false, false)); else NodePreds.push_back(SDep(I->Dep, I->Reg, I->Cost, false, false)); diff --git a/lib/CodeGen/SelectionDAG/SelectionDAG.cpp b/lib/CodeGen/SelectionDAG/SelectionDAG.cpp index 6f8f4818d2f..89376222268 100644 --- a/lib/CodeGen/SelectionDAG/SelectionDAG.cpp +++ b/lib/CodeGen/SelectionDAG/SelectionDAG.cpp @@ -3674,9 +3674,9 @@ bool SDNode::hasAnyUseOfValue(unsigned Value) const { } -/// isOnlyUse - Return true if this node is the only use of N. +/// isOnlyUseOf - Return true if this node is the only use of N. /// -bool SDNode::isOnlyUse(SDNode *N) const { +bool SDNode::isOnlyUseOf(SDNode *N) const { bool Seen = false; for (SDNode::use_iterator I = N->use_begin(), E = N->use_end(); I != E; ++I) { SDNode *User = *I; @@ -3691,14 +3691,14 @@ bool SDNode::isOnlyUse(SDNode *N) const { /// isOperand - Return true if this node is an operand of N. /// -bool SDOperand::isOperand(SDNode *N) const { +bool SDOperand::isOperandOf(SDNode *N) const { for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) if (*this == N->getOperand(i)) return true; return false; } -bool SDNode::isOperand(SDNode *N) const { +bool SDNode::isOperandOf(SDNode *N) const { for (unsigned i = 0, e = N->NumOperands; i != e; ++i) if (this == N->OperandList[i].Val) return true; @@ -3751,11 +3751,11 @@ static void findPredecessor(SDNode *N, const SDNode *P, bool &found, } } -/// isPredecessor - Return true if this node is a predecessor of N. This node +/// isPredecessorOf - Return true if this node is a predecessor of N. This node /// is either an operand of N or it can be reached by recursively traversing /// up the operands. /// NOTE: this is an expensive method. Use it carefully. -bool SDNode::isPredecessor(SDNode *N) const { +bool SDNode::isPredecessorOf(SDNode *N) const { SmallPtrSet Visited; bool found = false; findPredecessor(N, this, found, Visited); -- 2.11.0