6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-01-14 16:33:28 +00:00
Code Issues Projects Releases Wiki Activity

Factor the ReachesChainWithoutSideEffects out of dag combiner into

Browse Source 
a public SDOperand::reachesChainWithoutSideEffects method.  No 
functionality change.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@46050 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2008-01-16 05:49:24 +00:00
parent 8c231e5dda
commit 572dee71af
3 changed files with 40 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
include/llvm/CodeGen/SelectionDAGNodes.h
View File

@ -780,6 +780,14 @@ public:
inline bool isTargetOpcode() const;
inline unsigned getTargetOpcode() const;
/// reachesChainWithoutSideEffects - Return true if this operand (which must
/// be a chain) reaches the specified operand without crossing any
/// side-effecting instructions. In practice, this looks through token
/// factors and non-volatile loads. In order to remain efficient, this only
/// looks a couple of nodes in, it does not do an exhaustive search.
bool reachesChainWithoutSideEffects(SDOperand Dest, unsigned Depth = 2) const;
/// hasOneUse - Return true if there is exactly one operation using this
/// result value of the defining operator.
inline bool hasOneUse() const;

29
lib/CodeGen/SelectionDAG/DAGCombiner.cpp
View File

@ -4122,33 +4122,6 @@ SDOperand DAGCombiner::visitLOAD(SDNode *N) {
return SDOperand();
}
/// ReachesChainWithoutSideEffects - Do a little local search to see if Src can
/// reach Dest without any side effects like a store, or call. Non-volatile
/// loads are ok though.
static bool ReachesChainWithoutSideEffects(SDOperand Src, SDOperand Dest,
unsigned Depth = 0) {
if (Src == Dest) return true;
// Don't search too deeply, we just want to be able to see through
// TokenFactor's etc.
if (Depth == 2) return false;
// If this is a token factor, all inputs to the TF happen in parallel. If any
// of the operands of the TF reach dest, then we can do the xform.
if (Src.getOpcode() == ISD::TokenFactor) {
for (unsigned i = 0, e = Src.getNumOperands(); i != e; ++i)
if (ReachesChainWithoutSideEffects(Src.getOperand(i), Dest, Depth+1))
return true;
return false;
}
// Loads don't have side effects, look through them.
if (LoadSDNode *Ld = dyn_cast<LoadSDNode>(Src)) {
if (!Ld->isVolatile())
return ReachesChainWithoutSideEffects(Ld->getChain(), Dest, Depth+1);
}
return false;
}
SDOperand DAGCombiner::visitSTORE(SDNode *N) {
StoreSDNode *ST = cast<StoreSDNode>(N);
@ -4283,7 +4256,7 @@ SDOperand DAGCombiner::visitSTORE(SDNode *N) {
!ST->isVolatile() &&
// There can't be any side effects between the load and store, such as
// a call or store.
ReachesChainWithoutSideEffects(Chain, SDOperand(Ld, 1))) {
Chain.reachesChainWithoutSideEffects(SDOperand(Ld, 1))) {
// The store is dead, remove it.
return Chain;
}

31
lib/CodeGen/SelectionDAG/SelectionDAG.cpp
View File

@ -3562,6 +3562,37 @@ bool SDNode::isOperand(SDNode *N) const {
return false;
}
/// reachesChainWithoutSideEffects - Return true if this operand (which must
/// be a chain) reaches the specified operand without crossing any
/// side-effecting instructions. In practice, this looks through token
/// factors and non-volatile loads. In order to remain efficient, this only
/// looks a couple of nodes in, it does not do an exhaustive search.
bool SDOperand::reachesChainWithoutSideEffects(SDOperand Dest,
unsigned Depth) const {
if (*this == Dest) return true;
// Don't search too deeply, we just want to be able to see through
// TokenFactor's etc.
if (Depth == 0) return false;
// If this is a token factor, all inputs to the TF happen in parallel. If any
// of the operands of the TF reach dest, then we can do the xform.
if (getOpcode() == ISD::TokenFactor) {
for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
if (getOperand(i).reachesChainWithoutSideEffects(Dest, Depth-1))
return true;
return false;
}
// Loads don't have side effects, look through them.
if (LoadSDNode *Ld = dyn_cast<LoadSDNode>(*this)) {
if (!Ld->isVolatile())
return Ld->getChain().reachesChainWithoutSideEffects(Dest, Depth-1);
}
return false;
}
static void findPredecessor(SDNode *N, const SDNode *P, bool &found,
SmallPtrSet<SDNode *, 32> &Visited) {
if (found || !Visited.insert(N))