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 6907d8f06b90e757d9214a997d868680b9aa1c60..670a138cb542b3a1c6fbf41cfc98a8672bfdc8f4 100644 (file)
--- 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
 //
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 // 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) {
 /// 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.
   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, 
 /// 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)
   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,
 //
 
 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,
    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,
   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);
 }
   isInputPattern = isInput;
   Trees.push_back(Pat);
 }


@@ -1106,11 +1106,11 @@ void TreePattern::print(std::ostream &OS) const {
 void TreePattern::dump() const { print(*cerr.stream()); }
 
 //===----------------------------------------------------------------------===//
 void TreePattern::dump() const { print(*cerr.stream()); }
 
 //===----------------------------------------------------------------------===//

-// CodegenDAGPatterns implementation
+// CodeGenDAGPatterns implementation

 //
 
 // FIXME: REMOVE OSTREAM ARGUMENT
 //
 
 // FIXME: REMOVE OSTREAM ARGUMENT

-CodegenDAGPatterns::CodegenDAGPatterns(RecordKeeper &R) : Records(R) {
+CodeGenDAGPatterns::CodeGenDAGPatterns(RecordKeeper &R) : Records(R) {

   Intrinsics = LoadIntrinsics(Records);
   ParseNodeInfo();
   ParseNodeTransforms();
   Intrinsics = LoadIntrinsics(Records);
   ParseNodeInfo();
   ParseNodeTransforms();


@@ -1125,14 +1125,14 @@ CodegenDAGPatterns::CodegenDAGPatterns(RecordKeeper &R) : Records(R) {
   GenerateVariants();
 }
 
   GenerateVariants();
 }
 

-CodegenDAGPatterns::~CodegenDAGPatterns() {
+CodeGenDAGPatterns::~CodeGenDAGPatterns() {

   for (std::map<Record*, TreePattern*>::iterator I = PatternFragments.begin(),
        E = PatternFragments.end(); I != E; ++I)
     delete I->second;
 }
 
 
   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";
   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.
 }
 
 // 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()));
   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.
 
 /// 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();
   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()));
   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.
 ///
 /// 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.
   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");
   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.
 /// 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,
 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.
 /// 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) {
   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) {
   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,
 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())
   // 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,
                                  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);
   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,
 ///
 static void GenerateVariantsOf(TreePatternNode *N,
                                std::vector<TreePatternNode*> &OutVariants,

-                               CodegenDAGPatterns &CDP) {
+                               CodeGenDAGPatterns &CDP) {

   // We cannot permute leaves.
   if (N->isLeaf()) {
     OutVariants.push_back(N);
   // 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.
 
 // 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
   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 08b40d190d51eebf972cd850b94b2a892f3c5651..4097079c4cf9c734cb9bcd04ac76cf87db629d17 100644 (file)
--- 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
 //
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 // represent the patterns present in a .td file for instructions.
 //
 //===----------------------------------------------------------------------===//


@@ -27,7 +27,7 @@ namespace llvm {
   class SDNodeInfo;
   class TreePattern;
   class TreePatternNode;
   class SDNodeInfo;
   class TreePattern;
   class TreePatternNode;

-  class CodegenDAGPatterns;
+  class CodeGenDAGPatterns;

   class ComplexPattern;
 
 /// MVT::DAGISelGenValueType - These are some extended forms of MVT::ValueType
   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.
   
   /// 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.
   ///
   
   /// 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.
 
   /// 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,
   /// 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,
   TreePattern(Record *TheRec, DagInit *Pat, bool isInput,

-              CodegenDAGPatterns &ise);
+              CodeGenDAGPatterns &ise);

   TreePattern(Record *TheRec, TreePatternNode *Pat, bool isInput,
   TreePattern(Record *TheRec, TreePatternNode *Pat, bool isInput,

-              CodegenDAGPatterns &ise);
+              CodeGenDAGPatterns &ise);

       
   /// getTrees - Return the tree patterns which corresponds to this pattern.
   ///
       
   /// getTrees - Return the tree patterns which corresponds to this pattern.
   ///


@@ -325,7 +325,7 @@ public:
   }
   std::vector<std::string> &getArgList() { return Args; }
   
   }
   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
 
   /// 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; }
 };
   
   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,
 /// 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;
   RecordKeeper &Records;
   CodeGenTarget Target;
   std::vector<CodeGenIntrinsic> Intrinsics;


@@ -451,8 +451,8 @@ class CodegenDAGPatterns {
   /// emit.
   std::vector<PatternToMatch> PatternsToMatch;
 public:
   /// emit.
   std::vector<PatternToMatch> PatternsToMatch;
 public:

-  CodegenDAGPatterns(RecordKeeper &R); 
-  ~CodegenDAGPatterns();
+  CodeGenDAGPatterns(RecordKeeper &R); 
+  ~CodeGenDAGPatterns();

   
   const CodeGenTarget &getTargetInfo() const { return Target; }
   
   
   const CodeGenTarget &getTargetInfo() const { return Target; }
   

diff --git a/utils/TableGen/DAGISelEmitter.cpp b/utils/TableGen/DAGISelEmitter.cpp
index eacd13e8c04a2aad3893e339c7f0948380a6f480..b0eada86b5b26b6a3f8f2ac6e2710856ce628fb8 100644 (file)
--- 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,
 /// 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()->
   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.
 /// 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 ||
   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,
 /// 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;
   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, 
 /// 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;
   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 {
 // 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) {
 
   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,
 /// 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)
   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,
 }
 
 static bool PatternHasProperty(TreePatternNode *N, SDNP Property,

-                               CodegenDAGPatterns &CGP) {
+                               CodeGenDAGPatterns &CGP) {

   if (NodeHasProperty(N, Property, CGP))
     return true;
 
   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.
 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;
 
   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));
   
        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;
 
   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));
 
        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:
 //
 class PatternCodeEmitter {
 private:

-  CodegenDAGPatterns &CGP;
+  CodeGenDAGPatterns &CGP;

 
   // Predicates.
   ListInit *Predicates;
 
   // Predicates.
   ListInit *Predicates;


@@ -354,7 +354,7 @@ private:
     VTNo++;
   }
 public:
     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,
                      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";
 }
 
     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();
 }
 
   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;
   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;
 
        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";
   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());
        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 0045a3ab98c1fa09cb16e6a4cdc854459c4e5b36..534326e926173aa76aeb243ca8f0b43f07344280 100644 (file)
--- a/utils/TableGen/DAGISelEmitter.h
+++ b/utils/TableGen/DAGISelEmitter.h
@@ -24,7 +24,7 @@ namespace llvm {
 ///
 class DAGISelEmitter : public TableGenBackend {
   RecordKeeper &Records;
 ///
 class DAGISelEmitter : public TableGenBackend {
   RecordKeeper &Records;

-  CodegenDAGPatterns CGP;
+  CodeGenDAGPatterns CGP;

 public:
   DAGISelEmitter(RecordKeeper &R) : Records(R), CGP(R) {}
 
 public:
   DAGISelEmitter(RecordKeeper &R) : Records(R), CGP(R) {}