return *this;
}
- SDUse * getNext() { return Next; }
+ SDUse *getNext() { return Next; }
SDNode *getUser() { return User; }
const SDOperand& getSDOperand() const { return Operand; }
- SDNode* &getVal () { return Operand.Val; }
+ SDNode *&getVal() { return Operand.Val; }
bool operator==(const SDOperand &O) const {
return Operand == O;
use_iterator tmp = *this; ++*this; return tmp;
}
-
- /// getOperandNum - Retrive a number of a current operand.
- unsigned getOperandNum() const {
+ /// Retrieve a pointer to the current user node.
+ SDNode *operator*() const {
assert(Op && "Cannot dereference end iterator!");
- return (unsigned)(Op - Op->getUser()->OperandList);
+ return Op->getUser();
}
- /// Retrieve a reference to the current operand.
- SDUse &operator*() const {
- assert(Op && "Cannot dereference end iterator!");
- return *Op;
- }
+ SDNode *operator->() const { return operator*(); }
+
+ SDUse &getUse() const { return *Op; }
- /// Retrieve a pointer to the current operand.
- SDUse *operator->() const {
+ /// getOperandNo - Retrive the operand # of this use in its user.
+ ///
+ unsigned getOperandNo() const {
assert(Op && "Cannot dereference end iterator!");
- return Op;
+ return (unsigned)(Op - Op->getUser()->OperandList);
}
};
/// use_begin/use_end - Provide iteration support to walk over all uses
/// of an SDNode.
- use_iterator use_begin(SDNode *node) const {
- return use_iterator(node->Uses);
- }
-
use_iterator use_begin() const {
return use_iterator(Uses);
}
_Self tmp = *this; ++*this; return tmp;
}
- // Retrieve a reference to the current User
+ // Retrieve a pointer to the current User.
UserTy *operator*() const {
assert(U && "Cannot dereference end iterator!");
return U->getUser();
void AddUsersToWorkList(SDNode *N) {
for (SDNode::use_iterator UI = N->use_begin(), UE = N->use_end();
UI != UE; ++UI)
- AddToWorkList(UI->getUser());
+ AddToWorkList(*UI);
}
/// visit - call the node-specific routine that knows how to fold each
bool isTruncFree = TLI.isTruncateFree(N->getValueType(0), N0.getValueType());
for (SDNode::use_iterator UI = N0.Val->use_begin(), UE = N0.Val->use_end();
UI != UE; ++UI) {
- SDNode *User = UI->getUser();
+ SDNode *User = *UI;
if (User == N)
continue;
// FIXME: Only extend SETCC N, N and SETCC N, c for now.
bool BothLiveOut = false;
for (SDNode::use_iterator UI = N->use_begin(), UE = N->use_end();
UI != UE; ++UI) {
- SDNode *User = UI->getUser();
+ SDNode *User = *UI;
for (unsigned i = 0, e = User->getNumOperands(); i != e; ++i) {
SDOperand UseOp = User->getOperand(i);
if (UseOp.Val == N && UseOp.ResNo == 0) {
// If this is fp_round(fpextend), don't fold it, allow ourselves to be folded.
if (N->hasOneUse() &&
- N->use_begin()->getSDOperand().getOpcode() == ISD::FP_ROUND)
+ N->use_begin().getUse().getSDOperand().getOpcode() == ISD::FP_ROUND)
return SDOperand();
// fold (fp_extend c1fp) -> c1fp
bool RealUse = false;
for (SDNode::use_iterator I = Ptr.Val->use_begin(),
E = Ptr.Val->use_end(); I != E; ++I) {
- SDNode *Use = I->getUser();
+ SDNode *Use = *I;
if (Use == N)
continue;
if (Use->isPredecessorOf(N))
for (SDNode::use_iterator I = Ptr.Val->use_begin(),
E = Ptr.Val->use_end(); I != E; ++I) {
- SDNode *Op = I->getUser();
+ SDNode *Op = *I;
if (Op == N ||
(Op->getOpcode() != ISD::ADD && Op->getOpcode() != ISD::SUB))
continue;
bool TryNext = false;
for (SDNode::use_iterator II = BasePtr.Val->use_begin(),
EE = BasePtr.Val->use_end(); II != EE; ++II) {
- SDNode *Use = II->getUser();
+ SDNode *Use = *II;
if (Use == Ptr.Val)
continue;
bool RealUse = false;
for (SDNode::use_iterator III = Use->use_begin(),
EEE = Use->use_end(); III != EEE; ++III) {
- SDNode *UseUse = III->getUser();
+ SDNode *UseUse = *III;
if (!((UseUse->getOpcode() == ISD::LOAD &&
cast<LoadSDNode>(UseUse)->getBasePtr().Val == Use) ||
(UseUse->getOpcode() == ISD::STORE &&
// Now that we have N in, add anything that uses it if all of their operands
// are now done.
- for (SDNode::use_iterator UI = N->use_begin(), E = N->use_end();
- UI != E; ++UI)
- Worklist.push_back(UI->getUser());
+ Worklist.insert(Worklist.end(), N->use_begin(), N->use_end());
}
assert(Order.size() == Visited.size() &&
E = Node->use_end(); UI != E; ++UI) {
// Make sure to only follow users of our token chain.
- SDNode *User = UI->getUser();
+ SDNode *User = *UI;
for (unsigned i = 0, e = User->getNumOperands(); i != e; ++i)
if (User->getOperand(i) == TheChain)
if (SDNode *Result = FindCallEndFromCallStart(User))
for (SDNode::use_iterator UI = N->use_begin(), E = N->use_end();
UI != E; ++UI) {
- SDNode *User = UI->getUser();
+ SDNode *User = *UI;
int NodeID = User->getNodeId();
assert(NodeID != ReadyToProcess && NodeID != Processed &&
"Invalid node id for user of unprocessed node!");
/// CheckForPhysRegDependency - Check if the dependency between def and use of
/// a specified operand is a physical register dependency. If so, returns the
/// register and the cost of copying the register.
-static void CheckForPhysRegDependency(SDNode *Def, SDNode *Use, unsigned Op,
+static void CheckForPhysRegDependency(SDNode *Def, SDNode *User, unsigned Op,
const TargetRegisterInfo *TRI,
const TargetInstrInfo *TII,
unsigned &PhysReg, int &Cost) {
- if (Op != 2 || Use->getOpcode() != ISD::CopyToReg)
+ if (Op != 2 || User->getOpcode() != ISD::CopyToReg)
return;
- unsigned Reg = cast<RegisterSDNode>(Use->getOperand(1))->getReg();
+ unsigned Reg = cast<RegisterSDNode>(User->getOperand(1))->getReg();
if (TargetRegisterInfo::isVirtualRegister(Reg))
return;
- unsigned ResNo = Use->getOperand(2).ResNo;
+ unsigned ResNo = User->getOperand(2).ResNo;
if (Def->isMachineOpcode()) {
const TargetInstrDesc &II = TII->get(Def->getMachineOpcode());
if (ResNo >= II.getNumDefs() &&
bool HasFlagUse = false;
for (SDNode::use_iterator UI = N->use_begin(), E = N->use_end();
UI != E; ++UI)
- if (FlagVal.isOperandOf(UI->getUser())) {
+ if (FlagVal.isOperandOf(*UI)) {
HasFlagUse = true;
NodeSUnit->FlaggedNodes.push_back(N);
assert(N->getNodeId() == -1 && "Node already inserted!");
N->setNodeId(NodeSUnit->NodeNum);
- N = UI->getUser();
+ N = *UI;
break;
}
if (!HasFlagUse) break;
bool MatchReg = true;
for (SDNode::use_iterator UI = Node->use_begin(), E = Node->use_end();
UI != E; ++UI) {
- SDNode *Use = UI->getUser();
+ SDNode *User = *UI;
bool Match = true;
- if (Use->getOpcode() == ISD::CopyToReg &&
- Use->getOperand(2).Val == Node &&
- Use->getOperand(2).ResNo == ResNo) {
- unsigned DestReg = cast<RegisterSDNode>(Use->getOperand(1))->getReg();
+ if (User->getOpcode() == ISD::CopyToReg &&
+ User->getOperand(2).Val == Node &&
+ User->getOperand(2).ResNo == ResNo) {
+ unsigned DestReg = cast<RegisterSDNode>(User->getOperand(1))->getReg();
if (TargetRegisterInfo::isVirtualRegister(DestReg)) {
VRBase = DestReg;
Match = false;
} else if (DestReg != SrcReg)
Match = false;
} else {
- for (unsigned i = 0, e = Use->getNumOperands(); i != e; ++i) {
- SDOperand Op = Use->getOperand(i);
+ for (unsigned i = 0, e = User->getNumOperands(); i != e; ++i) {
+ SDOperand Op = User->getOperand(i);
if (Op.Val != Node || Op.ResNo != ResNo)
continue;
MVT VT = Node->getValueType(Op.ResNo);
if (!Node->hasOneUse())
return 0;
- SDNode *Use = Node->use_begin()->getUser();
- if (Use->getOpcode() == ISD::CopyToReg &&
- Use->getOperand(2).Val == Node &&
- Use->getOperand(2).ResNo == ResNo) {
- unsigned Reg = cast<RegisterSDNode>(Use->getOperand(1))->getReg();
+ SDNode *User = *Node->use_begin();
+ if (User->getOpcode() == ISD::CopyToReg &&
+ User->getOperand(2).Val == Node &&
+ User->getOperand(2).ResNo == ResNo) {
+ unsigned Reg = cast<RegisterSDNode>(User->getOperand(1))->getReg();
if (TargetRegisterInfo::isVirtualRegister(Reg))
return Reg;
}
unsigned VRBase = 0;
for (SDNode::use_iterator UI = Node->use_begin(), E = Node->use_end();
UI != E; ++UI) {
- SDNode *Use = UI->getUser();
- if (Use->getOpcode() == ISD::CopyToReg &&
- Use->getOperand(2).Val == Node &&
- Use->getOperand(2).ResNo == i) {
- unsigned Reg = cast<RegisterSDNode>(Use->getOperand(1))->getReg();
+ SDNode *User = *UI;
+ if (User->getOpcode() == ISD::CopyToReg &&
+ User->getOperand(2).Val == Node &&
+ User->getOperand(2).ResNo == i) {
+ unsigned Reg = cast<RegisterSDNode>(User->getOperand(1))->getReg();
if (TargetRegisterInfo::isVirtualRegister(Reg)) {
VRBase = Reg;
MI->addOperand(MachineOperand::CreateReg(Reg, true));
// the CopyToReg'd destination register instead of creating a new vreg.
for (SDNode::use_iterator UI = Node->use_begin(), E = Node->use_end();
UI != E; ++UI) {
- SDNode *Use = UI->getUser();
- if (Use->getOpcode() == ISD::CopyToReg &&
- Use->getOperand(2).Val == Node) {
- unsigned DestReg = cast<RegisterSDNode>(Use->getOperand(1))->getReg();
+ SDNode *User = *UI;
+ if (User->getOpcode() == ISD::CopyToReg &&
+ User->getOperand(2).Val == Node) {
+ unsigned DestReg = cast<RegisterSDNode>(User->getOperand(1))->getReg();
if (TargetRegisterInfo::isVirtualRegister(DestReg)) {
VRBase = DestReg;
break;
while (!From->use_empty()) {
SDNode::use_iterator UI = From->use_begin();
- SDNode *U = UI->getUser();
+ SDNode *U = *UI;
// This node is about to morph, remove its old self from the CSE maps.
RemoveNodeFromCSEMaps(U);
while (!From->use_empty()) {
SDNode::use_iterator UI = From->use_begin();
- SDNode *U = UI->getUser();
+ SDNode *U = *UI;
// This node is about to morph, remove its old self from the CSE maps.
RemoveNodeFromCSEMaps(U);
while (!From->use_empty()) {
SDNode::use_iterator UI = From->use_begin();
- SDNode *U = UI->getUser();
+ SDNode *U = *UI;
// This node is about to morph, remove its old self from the CSE maps.
RemoveNodeFromCSEMaps(U);
return;
}
- if (From.use_empty()) return;
-
// Get all of the users of From.Val. We want these in a nice,
// deterministically ordered and uniqued set, so we use a SmallSetVector.
- SmallSetVector<SDNode*, 16> Users;
- for (SDNode::use_iterator UI = From.Val->use_begin(),
- E = From.Val->use_end(); UI != E; ++UI) {
- SDNode *User = UI->getUser();
- Users.insert(User);
- }
+ SmallSetVector<SDNode*, 16> Users(From.Val->use_begin(), From.Val->use_end());
while (!Users.empty()) {
// We know that this user uses some value of From. If it is the right
for (unsigned i = 0; i != Num; ++i)
for (SDNode::use_iterator UI = From[i].Val->use_begin(),
E = From[i].Val->use_end(); UI != E; ++UI)
- Users.push_back(std::make_pair(UI->getUser(), i));
+ Users.push_back(std::make_pair(*UI, i));
while (!Users.empty()) {
// We know that this user uses some value of From. If it is the right
// TODO: Only iterate over uses of a given value of the node
for (SDNode::use_iterator UI = use_begin(), E = use_end(); UI != E; ++UI) {
- if (UI->getSDOperand().ResNo == Value) {
+ if (UI.getUse().getSDOperand().ResNo == Value) {
if (NUses == 0)
return false;
--NUses;
assert(Value < getNumValues() && "Bad value!");
for (SDNode::use_iterator UI = use_begin(), E = use_end(); UI != E; ++UI)
- if (UI->getSDOperand().ResNo == Value)
+ if (UI.getUse().getSDOperand().ResNo == Value)
return true;
return false;
bool SDNode::isOnlyUserOf(SDNode *N) const {
bool Seen = false;
for (SDNode::use_iterator I = N->use_begin(), E = N->use_end(); I != E; ++I) {
- SDNode *User = I->getUser();
+ SDNode *User = *I;
if (User == this)
Seen = true;
else
SDNode *LHSN = N->getOperand(0).Val;
for (SDNode::use_iterator UI = LHSN->use_begin(), E = LHSN->use_end();
UI != E; ++UI)
- if ((*UI).getUser()->getOpcode() == PPCISD::VCMPo &&
- (*UI).getUser()->getOperand(1) == N->getOperand(1) &&
- (*UI).getUser()->getOperand(2) == N->getOperand(2) &&
- (*UI).getUser()->getOperand(0) == N->getOperand(0)) {
- VCMPoNode = UI->getUser();
+ if (UI->getOpcode() == PPCISD::VCMPo &&
+ UI->getOperand(1) == N->getOperand(1) &&
+ UI->getOperand(2) == N->getOperand(2) &&
+ UI->getOperand(0) == N->getOperand(0)) {
+ VCMPoNode = *UI;
break;
}
for (SDNode::use_iterator UI = VCMPoNode->use_begin();
FlagUser == 0; ++UI) {
assert(UI != VCMPoNode->use_end() && "Didn't find user!");
- SDNode *User = UI->getUser();
+ SDNode *User = *UI;
for (unsigned i = 0, e = User->getNumOperands(); i != e; ++i) {
if (User->getOperand(i) == SDOperand(VCMPoNode, 1)) {
FlagUser = User;
static SDNode *findFlagUse(SDNode *N) {
unsigned FlagResNo = N->getNumValues()-1;
for (SDNode::use_iterator I = N->use_begin(), E = N->use_end(); I != E; ++I) {
- SDNode *User = I->getUser();
+ SDNode *User = *I;
for (unsigned i = 0, e = User->getNumOperands(); i != e; ++i) {
SDOperand Op = User->getOperand(i);
if (Op.Val == N && Op.ResNo == FlagResNo)
// result has a single use which is a store or a bitcast to i32.
if (!Op.hasOneUse())
return SDOperand();
- SDNode *User = Op.Val->use_begin()->getUser();
+ SDNode *User = *Op.Val->use_begin();
if (User->getOpcode() != ISD::STORE &&
(User->getOpcode() != ISD::BIT_CONVERT ||
User->getValueType(0) != MVT::i32))