6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-04-09 16:45:03 +00:00
Code Issues Projects Releases Wiki Activity

rename CodegenDAGPatterns -> CodeGenDAGPatterns

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@45641 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2008-01-06 01:10:31 +00:00
parent 7b11712ef2
commit fe71893183
4 changed files with 53 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
utils/TableGen/CodeGenDAGPatterns.cpp
View File

@ -1,4 +1,4 @@
//===- CodegenDAGPatterns.cpp - Read DAG patterns from .td file -----------===//
//===- CodeGenDAGPatterns.cpp - Read DAG patterns from .td file -----------===//
//
// The LLVM Compiler Infrastructure
//
@ -7,7 +7,7 @@
//
//===----------------------------------------------------------------------===//
//
// This file implements the CodegenDAGPatterns class, which is used to read and
// This file implements the CodeGenDAGPatterns class, which is used to read and
// represent the patterns present in a .td file for instructions.
//
//===----------------------------------------------------------------------===//
@ -638,7 +638,7 @@ static std::vector<unsigned char> getImplicitType(Record *R, bool NotRegisters,
/// change, false otherwise. If a type contradiction is found, throw an
/// exception.
bool TreePatternNode::ApplyTypeConstraints(TreePattern &TP, bool NotRegisters) {
CodegenDAGPatterns &CDP = TP.getDAGPatterns();
CodeGenDAGPatterns &CDP = TP.getDAGPatterns();
if (isLeaf()) {
if (DefInit *DI = dynamic_cast<DefInit*>(getLeafValue())) {
// If it's a regclass or something else known, include the type.
@ -862,7 +862,7 @@ static bool OnlyOnRHSOfCommutative(TreePatternNode *N) {
/// that can never possibly work), and to prevent the pattern permuter from
/// generating stuff that is useless.
bool TreePatternNode::canPatternMatch(std::string &Reason,
CodegenDAGPatterns &CDP){
CodeGenDAGPatterns &CDP){
if (isLeaf()) return true;
for (unsigned i = 0, e = getNumChildren(); i != e; ++i)
@ -899,20 +899,20 @@ bool TreePatternNode::canPatternMatch(std::string &Reason,
//
TreePattern::TreePattern(Record *TheRec, ListInit *RawPat, bool isInput,
CodegenDAGPatterns &cdp) : TheRecord(TheRec), CDP(cdp){
CodeGenDAGPatterns &cdp) : TheRecord(TheRec), CDP(cdp){
isInputPattern = isInput;
for (unsigned i = 0, e = RawPat->getSize(); i != e; ++i)
Trees.push_back(ParseTreePattern((DagInit*)RawPat->getElement(i)));
}
TreePattern::TreePattern(Record *TheRec, DagInit *Pat, bool isInput,
CodegenDAGPatterns &cdp) : TheRecord(TheRec), CDP(cdp){
CodeGenDAGPatterns &cdp) : TheRecord(TheRec), CDP(cdp){
isInputPattern = isInput;
Trees.push_back(ParseTreePattern(Pat));
}
TreePattern::TreePattern(Record *TheRec, TreePatternNode *Pat, bool isInput,
CodegenDAGPatterns &cdp) : TheRecord(TheRec), CDP(cdp){
CodeGenDAGPatterns &cdp) : TheRecord(TheRec), CDP(cdp){
isInputPattern = isInput;
Trees.push_back(Pat);
}
@ -1106,11 +1106,11 @@ void TreePattern::print(std::ostream &OS) const {
void TreePattern::dump() const { print(*cerr.stream()); }
//===----------------------------------------------------------------------===//
// CodegenDAGPatterns implementation
// CodeGenDAGPatterns implementation
//
// FIXME: REMOVE OSTREAM ARGUMENT
CodegenDAGPatterns::CodegenDAGPatterns(RecordKeeper &R) : Records(R) {
CodeGenDAGPatterns::CodeGenDAGPatterns(RecordKeeper &R) : Records(R) {
Intrinsics = LoadIntrinsics(Records);
ParseNodeInfo();
ParseNodeTransforms();
@ -1125,14 +1125,14 @@ CodegenDAGPatterns::CodegenDAGPatterns(RecordKeeper &R) : Records(R) {
GenerateVariants();
}
CodegenDAGPatterns::~CodegenDAGPatterns() {
CodeGenDAGPatterns::~CodeGenDAGPatterns() {
for (std::map<Record*, TreePattern*>::iterator I = PatternFragments.begin(),
E = PatternFragments.end(); I != E; ++I)
delete I->second;
}
Record *CodegenDAGPatterns::getSDNodeNamed(const std::string &Name) const {
Record *CodeGenDAGPatterns::getSDNodeNamed(const std::string &Name) const {
Record *N = Records.getDef(Name);
if (!N || !N->isSubClassOf("SDNode")) {
cerr << "Error getting SDNode '" << Name << "'!\n";
@ -1142,7 +1142,7 @@ Record *CodegenDAGPatterns::getSDNodeNamed(const std::string &Name) const {
}
// Parse all of the SDNode definitions for the target, populating SDNodes.
void CodegenDAGPatterns::ParseNodeInfo() {
void CodeGenDAGPatterns::ParseNodeInfo() {
std::vector<Record*> Nodes = Records.getAllDerivedDefinitions("SDNode");
while (!Nodes.empty()) {
SDNodes.insert(std::make_pair(Nodes.back(), Nodes.back()));
@ -1157,7 +1157,7 @@ void CodegenDAGPatterns::ParseNodeInfo() {
/// ParseNodeTransforms - Parse all SDNodeXForm instances into the SDNodeXForms
/// map, and emit them to the file as functions.
void CodegenDAGPatterns::ParseNodeTransforms() {
void CodeGenDAGPatterns::ParseNodeTransforms() {
std::vector<Record*> Xforms = Records.getAllDerivedDefinitions("SDNodeXForm");
while (!Xforms.empty()) {
Record *XFormNode = Xforms.back();
@ -1169,7 +1169,7 @@ void CodegenDAGPatterns::ParseNodeTransforms() {
}
}
void CodegenDAGPatterns::ParseComplexPatterns() {
void CodeGenDAGPatterns::ParseComplexPatterns() {
std::vector<Record*> AMs = Records.getAllDerivedDefinitions("ComplexPattern");
while (!AMs.empty()) {
ComplexPatterns.insert(std::make_pair(AMs.back(), AMs.back()));
@ -1183,7 +1183,7 @@ void CodegenDAGPatterns::ParseComplexPatterns() {
/// inline fragments together as necessary, so that there are no references left
/// inside a pattern fragment to a pattern fragment.
///
void CodegenDAGPatterns::ParsePatternFragments() {
void CodeGenDAGPatterns::ParsePatternFragments() {
std::vector<Record*> Fragments = Records.getAllDerivedDefinitions("PatFrag");
// First step, parse all of the fragments.
@ -1266,7 +1266,7 @@ void CodegenDAGPatterns::ParsePatternFragments() {
}
}
void CodegenDAGPatterns::ParseDefaultOperands() {
void CodeGenDAGPatterns::ParseDefaultOperands() {
std::vector<Record*> DefaultOps[2];
DefaultOps[0] = Records.getAllDerivedDefinitions("PredicateOperand");
DefaultOps[1] = Records.getAllDerivedDefinitions("OptionalDefOperand");
@ -1373,7 +1373,7 @@ static bool HandleUse(TreePattern *I, TreePatternNode *Pat,
/// FindPatternInputsAndOutputs - Scan the specified TreePatternNode (which is
/// part of "I", the instruction), computing the set of inputs and outputs of
/// the pattern. Report errors if we see anything naughty.
void CodegenDAGPatterns::
void CodeGenDAGPatterns::
FindPatternInputsAndOutputs(TreePattern *I, TreePatternNode *Pat,
std::map<std::string, TreePatternNode*> &InstInputs,
std::map<std::string, TreePatternNode*>&InstResults,
@ -1458,7 +1458,7 @@ FindPatternInputsAndOutputs(TreePattern *I, TreePatternNode *Pat,
/// ParseInstructions - Parse all of the instructions, inlining and resolving
/// any fragments involved. This populates the Instructions list with fully
/// resolved instructions.
void CodegenDAGPatterns::ParseInstructions() {
void CodeGenDAGPatterns::ParseInstructions() {
std::vector<Record*> Instrs = Records.getAllDerivedDefinitions("Instruction");
for (unsigned i = 0, e = Instrs.size(); i != e; ++i) {
@ -1688,7 +1688,7 @@ void CodegenDAGPatterns::ParseInstructions() {
}
}
void CodegenDAGPatterns::ParsePatterns() {
void CodeGenDAGPatterns::ParsePatterns() {
std::vector<Record*> Patterns = Records.getAllDerivedDefinitions("Pattern");
for (unsigned i = 0, e = Patterns.size(); i != e; ++i) {
@ -1798,7 +1798,7 @@ void CodegenDAGPatterns::ParsePatterns() {
static void CombineChildVariants(TreePatternNode *Orig,
const std::vector<std::vector<TreePatternNode*> > &ChildVariants,
std::vector<TreePatternNode*> &OutVariants,
CodegenDAGPatterns &CDP) {
CodeGenDAGPatterns &CDP) {
// Make sure that each operand has at least one variant to choose from.
for (unsigned i = 0, e = ChildVariants.size(); i != e; ++i)
if (ChildVariants[i].empty())
@ -1863,7 +1863,7 @@ static void CombineChildVariants(TreePatternNode *Orig,
const std::vector<TreePatternNode*> &LHS,
const std::vector<TreePatternNode*> &RHS,
std::vector<TreePatternNode*> &OutVariants,
CodegenDAGPatterns &CDP) {
CodeGenDAGPatterns &CDP) {
std::vector<std::vector<TreePatternNode*> > ChildVariants;
ChildVariants.push_back(LHS);
ChildVariants.push_back(RHS);
@ -1899,7 +1899,7 @@ static void GatherChildrenOfAssociativeOpcode(TreePatternNode *N,
///
static void GenerateVariantsOf(TreePatternNode *N,
std::vector<TreePatternNode*> &OutVariants,
CodegenDAGPatterns &CDP) {
CodeGenDAGPatterns &CDP) {
// We cannot permute leaves.
if (N->isLeaf()) {
OutVariants.push_back(N);
@ -1995,7 +1995,7 @@ static void GenerateVariantsOf(TreePatternNode *N,
// GenerateVariants - Generate variants. For example, commutative patterns can
// match multiple ways. Add them to PatternsToMatch as well.
void CodegenDAGPatterns::GenerateVariants() {
void CodeGenDAGPatterns::GenerateVariants() {
DOUT << "Generating instruction variants.\n";
// Loop over all of the patterns we've collected, checking to see if we can

26
utils/TableGen/CodeGenDAGPatterns.h
View File

@ -1,4 +1,4 @@
//===- CodegenDAGPatterns.h - Read DAG patterns from .td file ---*- C++ -*-===//
//===- CodeGenDAGPatterns.h - Read DAG patterns from .td file ---*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
@ -7,7 +7,7 @@
//
//===----------------------------------------------------------------------===//
//
// This file declares the CodegenDAGPatterns class, which is used to read and
// This file declares the CodeGenDAGPatterns class, which is used to read and
// represent the patterns present in a .td file for instructions.
//
//===----------------------------------------------------------------------===//
@ -27,7 +27,7 @@ namespace llvm {
class SDNodeInfo;
class TreePattern;
class TreePatternNode;
class CodegenDAGPatterns;
class CodeGenDAGPatterns;
class ComplexPattern;
/// MVT::DAGISelGenValueType - These are some extended forms of MVT::ValueType
@ -264,7 +264,7 @@ public: // Higher level manipulation routines.
/// canPatternMatch - If it is impossible for this pattern to match on this
/// target, fill in Reason and return false. Otherwise, return true.
bool canPatternMatch(std::string &Reason, CodegenDAGPatterns &CDP);
bool canPatternMatch(std::string &Reason, CodeGenDAGPatterns &CDP);
};
@ -287,7 +287,7 @@ class TreePattern {
/// CDP - the top-level object coordinating this madness.
///
CodegenDAGPatterns &CDP;
CodeGenDAGPatterns &CDP;
/// isInputPattern - True if this is an input pattern, something to match.
/// False if this is an output pattern, something to emit.
@ -297,11 +297,11 @@ public:
/// TreePattern constructor - Parse the specified DagInits into the
/// current record.
TreePattern(Record *TheRec, ListInit *RawPat, bool isInput,
CodegenDAGPatterns &ise);
CodeGenDAGPatterns &ise);
TreePattern(Record *TheRec, DagInit *Pat, bool isInput,
CodegenDAGPatterns &ise);
CodeGenDAGPatterns &ise);
TreePattern(Record *TheRec, TreePatternNode *Pat, bool isInput,
CodegenDAGPatterns &ise);
CodeGenDAGPatterns &ise);
/// getTrees - Return the tree patterns which corresponds to this pattern.
///
@ -325,7 +325,7 @@ public:
}
std::vector<std::string> &getArgList() { return Args; }
CodegenDAGPatterns &getDAGPatterns() const { return CDP; }
CodeGenDAGPatterns &getDAGPatterns() const { return CDP; }
/// InlinePatternFragments - If this pattern refers to any pattern
/// fragments, inline them into place, giving us a pattern without any
@ -406,7 +406,7 @@ public:
TreePatternNode *getResultPattern() const { return ResultPattern; }
};
/// PatternToMatch - Used by CodegenDAGPatterns to keep tab of patterns
/// PatternToMatch - Used by CodeGenDAGPatterns to keep tab of patterns
/// processed to produce isel.
struct PatternToMatch {
PatternToMatch(ListInit *preds,
@ -430,7 +430,7 @@ struct PatternToMatch {
};
class CodegenDAGPatterns {
class CodeGenDAGPatterns {
RecordKeeper &Records;
CodeGenTarget Target;
std::vector<CodeGenIntrinsic> Intrinsics;
@ -451,8 +451,8 @@ class CodegenDAGPatterns {
/// emit.
std::vector<PatternToMatch> PatternsToMatch;
public:
CodegenDAGPatterns(RecordKeeper &R);
~CodegenDAGPatterns();
CodeGenDAGPatterns(RecordKeeper &R);
~CodeGenDAGPatterns();
const CodeGenTarget &getTargetInfo() const { return Target; }

32
utils/TableGen/DAGISelEmitter.cpp
View File

@ -36,7 +36,7 @@ static bool NodeIsComplexPattern(TreePatternNode *N) {
/// NodeGetComplexPattern - return the pointer to the ComplexPattern if N
/// is a leaf node and a subclass of ComplexPattern, else it returns NULL.
static const ComplexPattern *NodeGetComplexPattern(TreePatternNode *N,
CodegenDAGPatterns &CGP) {
CodeGenDAGPatterns &CGP) {
if (N->isLeaf() &&
dynamic_cast<DefInit*>(N->getLeafValue()) &&
static_cast<DefInit*>(N->getLeafValue())->getDef()->
@ -50,7 +50,7 @@ static const ComplexPattern *NodeGetComplexPattern(TreePatternNode *N,
/// getPatternSize - Return the 'size' of this pattern. We want to match large
/// patterns before small ones. This is used to determine the size of a
/// pattern.
static unsigned getPatternSize(TreePatternNode *P, CodegenDAGPatterns &CGP) {
static unsigned getPatternSize(TreePatternNode *P, CodeGenDAGPatterns &CGP) {
assert((MVT::isExtIntegerInVTs(P->getExtTypes()) ||
MVT::isExtFloatingPointInVTs(P->getExtTypes()) ||
P->getExtTypeNum(0) == MVT::isVoid ||
@ -99,7 +99,7 @@ static unsigned getPatternSize(TreePatternNode *P, CodegenDAGPatterns &CGP) {
/// This is a temporary hack. We should really include the instruction
/// latencies in this calculation.
static unsigned getResultPatternCost(TreePatternNode *P,
CodegenDAGPatterns &CGP) {
CodeGenDAGPatterns &CGP) {
if (P->isLeaf()) return 0;
unsigned Cost = 0;
@ -118,7 +118,7 @@ static unsigned getResultPatternCost(TreePatternNode *P,
/// getResultPatternCodeSize - Compute the code size of instructions for this
/// pattern.
static unsigned getResultPatternSize(TreePatternNode *P,
CodegenDAGPatterns &CGP) {
CodeGenDAGPatterns &CGP) {
if (P->isLeaf()) return 0;
unsigned Cost = 0;
@ -135,8 +135,8 @@ static unsigned getResultPatternSize(TreePatternNode *P,
// In particular, we want to match maximal patterns first and lowest cost within
// a particular complexity first.
struct PatternSortingPredicate {
PatternSortingPredicate(CodegenDAGPatterns &cgp) : CGP(cgp) {}
CodegenDAGPatterns &CGP;
PatternSortingPredicate(CodeGenDAGPatterns &cgp) : CGP(cgp) {}
CodeGenDAGPatterns &CGP;
bool operator()(const PatternToMatch *LHS,
const PatternToMatch *RHS) {
@ -179,7 +179,7 @@ static void RemoveAllTypes(TreePatternNode *N) {
/// NodeHasProperty - return true if TreePatternNode has the specified
/// property.
static bool NodeHasProperty(TreePatternNode *N, SDNP Property,
CodegenDAGPatterns &CGP) {
CodeGenDAGPatterns &CGP) {
if (N->isLeaf()) {
const ComplexPattern *CP = NodeGetComplexPattern(N, CGP);
if (CP)
@ -193,7 +193,7 @@ static bool NodeHasProperty(TreePatternNode *N, SDNP Property,
}
static bool PatternHasProperty(TreePatternNode *N, SDNP Property,
CodegenDAGPatterns &CGP) {
CodeGenDAGPatterns &CGP) {
if (NodeHasProperty(N, Property, CGP))
return true;
@ -212,10 +212,10 @@ static bool PatternHasProperty(TreePatternNode *N, SDNP Property,
void DAGISelEmitter::EmitNodeTransforms(std::ostream &OS) {
// Walk the pattern fragments, adding them to a map, which sorts them by
// name.
typedef std::map<std::string, CodegenDAGPatterns::NodeXForm> NXsByNameTy;
typedef std::map<std::string, CodeGenDAGPatterns::NodeXForm> NXsByNameTy;
NXsByNameTy NXsByName;
for (CodegenDAGPatterns::nx_iterator I = CGP.nx_begin(), E = CGP.nx_end();
for (CodeGenDAGPatterns::nx_iterator I = CGP.nx_begin(), E = CGP.nx_end();
I != E; ++I)
NXsByName.insert(std::make_pair(I->first->getName(), I->second));
@ -251,7 +251,7 @@ void DAGISelEmitter::EmitPredicateFunctions(std::ostream &OS) {
typedef std::map<std::string, std::pair<Record*, TreePattern*> > PFsByNameTy;
PFsByNameTy PFsByName;
for (CodegenDAGPatterns::pf_iterator I = CGP.pf_begin(), E = CGP.pf_end();
for (CodeGenDAGPatterns::pf_iterator I = CGP.pf_begin(), E = CGP.pf_end();
I != E; ++I)
PFsByName.insert(std::make_pair(I->first->getName(), *I));
@ -290,7 +290,7 @@ void DAGISelEmitter::EmitPredicateFunctions(std::ostream &OS) {
//
class PatternCodeEmitter {
private:
CodegenDAGPatterns &CGP;
CodeGenDAGPatterns &CGP;
// Predicates.
ListInit *Predicates;
@ -354,7 +354,7 @@ private:
VTNo++;
}
public:
PatternCodeEmitter(CodegenDAGPatterns &cgp, ListInit *preds,
PatternCodeEmitter(CodeGenDAGPatterns &cgp, ListInit *preds,
TreePatternNode *pattern, TreePatternNode *instr,
std::vector<std::pair<unsigned, std::string> > &gc,
std::set<std::string> &gd,
@ -1461,7 +1461,7 @@ void DAGISelEmitter::EmitPatterns(std::vector<std::pair<const PatternToMatch*,
OS << std::string(Indent-2, ' ') << "}\n";
}
static std::string getOpcodeName(Record *Op, CodegenDAGPatterns &CGP) {
static std::string getOpcodeName(Record *Op, CodeGenDAGPatterns &CGP) {
return CGP.getSDNodeInfo(Op).getEnumName();
}
@ -1492,7 +1492,7 @@ void DAGISelEmitter::EmitInstructionSelector(std::ostream &OS) {
std::map<std::string, std::vector<const PatternToMatch*> > PatternsByOpcode;
// All unique target node emission functions.
std::map<std::string, unsigned> EmitFunctions;
for (CodegenDAGPatterns::ptm_iterator I = CGP.ptm_begin(),
for (CodeGenDAGPatterns::ptm_iterator I = CGP.ptm_begin(),
E = CGP.ptm_end(); I != E; ++I) {
const PatternToMatch &Pattern = *I;
@ -2046,7 +2046,7 @@ OS << " unsigned NumKilled = ISelKilled.size();\n";
EmitPredicateFunctions(OS);
DOUT << "\n\nALL PATTERNS TO MATCH:\n\n";
for (CodegenDAGPatterns::ptm_iterator I = CGP.ptm_begin(), E = CGP.ptm_end();
for (CodeGenDAGPatterns::ptm_iterator I = CGP.ptm_begin(), E = CGP.ptm_end();
I != E; ++I) {
DOUT << "PATTERN: "; DEBUG(I->getSrcPattern()->dump());
DOUT << "\nRESULT: "; DEBUG(I->getDstPattern()->dump());

2
utils/TableGen/DAGISelEmitter.h
View File

@ -24,7 +24,7 @@ namespace llvm {
///
class DAGISelEmitter : public TableGenBackend {
RecordKeeper &Records;
CodegenDAGPatterns CGP;
CodeGenDAGPatterns CGP;
public:
DAGISelEmitter(RecordKeeper &R) : Records(R), CGP(R) {}