From: Chris Lattner Date: Sun, 6 Jan 2008 01:10:31 +0000 (+0000) Subject: rename CodegenDAGPatterns -> CodeGenDAGPatterns X-Git-Url: http://plrg.eecs.uci.edu/git/?p=oota-llvm.git;a=commitdiff_plain;h=fe71893183f504feff290e343bf740bd32432129 rename CodegenDAGPatterns -> CodeGenDAGPatterns git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@45641 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/utils/TableGen/CodeGenDAGPatterns.cpp b/utils/TableGen/CodeGenDAGPatterns.cpp index 6907d8f06b9..670a138cb54 100644 --- a/utils/TableGen/CodeGenDAGPatterns.cpp +++ b/utils/TableGen/CodeGenDAGPatterns.cpp @@ -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 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(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::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 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 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 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 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 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 &InstInputs, std::map&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 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 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 > &ChildVariants, std::vector &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 &LHS, const std::vector &RHS, std::vector &OutVariants, - CodegenDAGPatterns &CDP) { + CodeGenDAGPatterns &CDP) { std::vector > 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 &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 diff --git a/utils/TableGen/CodeGenDAGPatterns.h b/utils/TableGen/CodeGenDAGPatterns.h index 08b40d190d5..4097079c4cf 100644 --- a/utils/TableGen/CodeGenDAGPatterns.h +++ b/utils/TableGen/CodeGenDAGPatterns.h @@ -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 &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 Intrinsics; @@ -451,8 +451,8 @@ class CodegenDAGPatterns { /// emit. std::vector PatternsToMatch; public: - CodegenDAGPatterns(RecordKeeper &R); - ~CodegenDAGPatterns(); + CodeGenDAGPatterns(RecordKeeper &R); + ~CodeGenDAGPatterns(); const CodeGenTarget &getTargetInfo() const { return Target; } diff --git a/utils/TableGen/DAGISelEmitter.cpp b/utils/TableGen/DAGISelEmitter.cpp index eacd13e8c04..b0eada86b5b 100644 --- a/utils/TableGen/DAGISelEmitter.cpp +++ b/utils/TableGen/DAGISelEmitter.cpp @@ -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(N->getLeafValue()) && static_cast(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 NXsByNameTy; + typedef std::map 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 > 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 > &gc, std::set &gd, @@ -1461,7 +1461,7 @@ void DAGISelEmitter::EmitPatterns(std::vector > PatternsByOpcode; // All unique target node emission functions. std::map 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()); diff --git a/utils/TableGen/DAGISelEmitter.h b/utils/TableGen/DAGISelEmitter.h index 0045a3ab98c..534326e9261 100644 --- a/utils/TableGen/DAGISelEmitter.h +++ b/utils/TableGen/DAGISelEmitter.h @@ -24,7 +24,7 @@ namespace llvm { /// class DAGISelEmitter : public TableGenBackend { RecordKeeper &Records; - CodegenDAGPatterns CGP; + CodeGenDAGPatterns CGP; public: DAGISelEmitter(RecordKeeper &R) : Records(R), CGP(R) {}