RPCS3/llvm
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm.git synced 2025-01-22 18:35:45 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

simplify this code. In the new world order there is no

Browse Source 
need to scan the entire subtree of the pattern anymore.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96369 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2010-02-16 19:19:58 +00:00
parent 21390d7984
commit 6bc1b51377
1 changed files with 24 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
utils/TableGen/DAGISelMatcherGen.cpp
View File

@ -186,36 +186,33 @@ void MatcherGen::EmitOperatorMatchCode(const TreePatternNode *N,
// If this node has a chain, then the chain is operand #0 is the SDNode, and
// the child numbers of the node are all offset by one.
unsigned OpNo = 0;
if (N->NodeHasProperty(SDNPHasChain, CGP))
if (N->NodeHasProperty(SDNPHasChain, CGP)) {
OpNo = 1;
// If this node is not the root and the subtree underneath it produces a
// chain, then the result of matching the node is also produce a chain.
// Beyond that, this means that we're also folding (at least) the root node
// into the node that produce the chain (for example, matching
// "(add reg, (load ptr))" as a add_with_memory on X86). This is problematic,
// if the 'reg' node also uses the load (say, its chain). Graphically:
//
// [LD]
// ^ ^
// | \ DAG's like cheese.
// / |
// / [YY]
// | ^
// [XX]--/
//
// It would be invalid to fold XX and LD. In this case, folding the two
// nodes together would induce a cycle in the DAG, making it a cyclic DAG (!).
// To prevent this, we emit a dynamic check for legality before allowing this
// to be folded.
//
const TreePatternNode *Root = Pattern.getSrcPattern();
if (N != Root && // Not the root of the pattern.
N->TreeHasProperty(SDNPHasChain, CGP)) { // Has a chain somewhere in tree.
// If this node is not the root and the subtree underneath it produces a
// chain, then the result of matching the node is also produce a chain.
// Beyond that, this means that we're also folding (at least) the root node
// into the node that produce the chain (for example, matching
// "(add reg, (load ptr))" as a add_with_memory on X86). This is
// problematic, if the 'reg' node also uses the load (say, its chain).
// Graphically:
//
// [LD]
// ^ ^
// | \ DAG's like cheese.
// / |
// / [YY]
// | ^
// [XX]--/
//
// It would be invalid to fold XX and LD. In this case, folding the two
// nodes together would induce a cycle in the DAG, making it a 'cyclic DAG'
// To prevent this, we emit a dynamic check for legality before allowing
// this to be folded.
//
const TreePatternNode *Root = Pattern.getSrcPattern();
if (N != Root) { // Not the root of the pattern.
// If this non-root node produces a chain, we may need to emit a validity
// check.
if (OpNo != 0) {
// If there is a node between the root and this node, then we definitely
// need to emit the check.
bool NeedCheck = !Root->hasChild(N);