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

Revert of r213521. This change introduced a non-hermetic test (depending on a

Browse Source 
file not in the test/ area). Backing out now so that this test isn't part of
the 3.5 branch.

Original commit message: "TableGen: Allow AddedComplexity values to be negative
[...]"

llvm-svn: 213596
This commit is contained in:
Richard Smith 2014-07-22 02:32:12 +00:00
parent 2ae2a57274
commit f8a40b80fc
4 changed files with 7 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
test/TableGen/NegativeAddedComplexity.ll
View File

@ -1,41 +0,0 @@
// RUN: llvm-tblgen -I../../include -gen-dag-isel %s | FileCheck %s
// XFAIL: vg_leak
include "llvm/Target/Target.td"
// Make sure the higher complexity pattern comes first
// CHECK: TARGET_VAL(::ADD0)
// CHECK: Complexity = {{[^-]}}
// Make sure the ADD1 pattern has a negative complexity
// CHECK: TARGET_VAL(::ADD1)
// CHECK: Complexity = -{{[0-9]+}}
def TestRC : RegisterClass<"TEST", [i32], 32, (add)>;
def TestInstrInfo : InstrInfo;
def Test : Target {
let InstructionSet = TestInstrInfo;
}
def ADD0 : Instruction {
let OutOperandList = (outs TestRC:$dst);
let InOperandList = (ins TestRC:$src0, TestRC:$src1);
}
def ADD1 : Instruction {
let OutOperandList = (outs TestRC:$dst);
let InOperandList = (ins TestRC:$src0, TestRC:$src1);
}
def : Pat <
(add i32:$src0, i32:$src1),
(ADD1 $src0, $src1)
> {
let AddedComplexity = -1000;
}
def : Pat <
(add i32:$src0, i32:$src1),
(ADD0 $src0, $src1)
>;

2
utils/TableGen/CodeGenDAGPatterns.cpp
View File

@ -771,7 +771,7 @@ static unsigned getPatternSize(const TreePatternNode *P,
/// Compute the complexity metric for the input pattern. This roughly
/// corresponds to the number of nodes that are covered.
int PatternToMatch::
unsigned PatternToMatch::
getPatternComplexity(const CodeGenDAGPatterns &CGP) const {
return getPatternSize(getSrcPattern(), CGP) + getAddedComplexity();
}

8
utils/TableGen/CodeGenDAGPatterns.h
View File

@ -667,7 +667,7 @@ public:
PatternToMatch(Record *srcrecord, ListInit *preds,
TreePatternNode *src, TreePatternNode *dst,
const std::vector<Record*> &dstregs,
int complexity, unsigned uid)
unsigned complexity, unsigned uid)
: SrcRecord(srcrecord), Predicates(preds), SrcPattern(src), DstPattern(dst),
Dstregs(dstregs), AddedComplexity(complexity), ID(uid) {}
@ -676,7 +676,7 @@ public:
TreePatternNode *SrcPattern; // Source pattern to match.
TreePatternNode *DstPattern; // Resulting pattern.
std::vector<Record*> Dstregs; // Physical register defs being matched.
int AddedComplexity; // Add to matching pattern complexity.
unsigned AddedComplexity; // Add to matching pattern complexity.
unsigned ID; // Unique ID for the record.
Record *getSrcRecord() const { return SrcRecord; }
@ -684,13 +684,13 @@ public:
TreePatternNode *getSrcPattern() const { return SrcPattern; }
TreePatternNode *getDstPattern() const { return DstPattern; }
const std::vector<Record*> &getDstRegs() const { return Dstregs; }
int getAddedComplexity() const { return AddedComplexity; }
unsigned getAddedComplexity() const { return AddedComplexity; }
std::string getPredicateCheck() const;
/// Compute the complexity metric for the input pattern. This roughly
/// corresponds to the number of nodes that are covered.
int getPatternComplexity(const CodeGenDAGPatterns &CGP) const;
unsigned getPatternComplexity(const CodeGenDAGPatterns &CGP) const;
};
class CodeGenDAGPatterns {

4
utils/TableGen/DAGISelEmitter.cpp
View File

@ -94,8 +94,8 @@ struct PatternSortingPredicate {
// Otherwise, if the patterns might both match, sort based on complexity,
// which means that we prefer to match patterns that cover more nodes in the
// input over nodes that cover fewer.
int LHSSize = LHS->getPatternComplexity(CGP);
int RHSSize = RHS->getPatternComplexity(CGP);
unsigned LHSSize = LHS->getPatternComplexity(CGP);
unsigned RHSSize = RHS->getPatternComplexity(CGP);
if (LHSSize > RHSSize) return true; // LHS -> bigger -> less cost
if (LHSSize < RHSSize) return false;