Check in the first big step of rewriting DAGISelEmitter to

produce a table based matcher instead of gobs of C++ Code.

Though it's not done yet, the shrinkage seems promising,
the table for the X86 ISel is 75K and still has a lot of 
optimization to come (compare to the ~1.5M of .o generated
the old way, much of which will go away).

The code is currently disabled by default (the #if 0 in
DAGISelEmitter.cpp).  When enabled it generates a dead
SelectCode2 function in the DAGISel Header which will
eventually replace SelectCode.

There is still a lot of stuff left to do, which are
documented with a trail of FIXMEs.



git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@96215 91177308-0d34-0410-b5e6-96231b3b80d8

1 files changed, 362 insertions, 0 deletions

diff --git a/utils/TableGen/DAGISelMatcher.h b/utils/TableGen/DAGISelMatcher.h
new file mode 100644
index 0000000000..72bdb7bf27
--- /dev/null
+++ b/utils/TableGen/DAGISelMatcher.h
@@ -0,0 +1,362 @@
+//===- DAGISelMatcher.h - Representation of DAG pattern matcher -----------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef TBLGEN_DAGISELMATCHER_H
+#define TBLGEN_DAGISELMATCHER_H
+
+#include "llvm/ADT/OwningPtr.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/CodeGen/ValueTypes.h"
+
+namespace llvm {
+  class CodeGenDAGPatterns;
+  class MatcherNode;
+  class PatternToMatch;
+  class raw_ostream;
+  class ComplexPattern;
+
+MatcherNode *ConvertPatternToMatcher(const PatternToMatch &Pattern,
+                                     const CodeGenDAGPatterns &CGP);
+
+void EmitMatcherTable(const MatcherNode *Matcher, raw_ostream &OS);
+
+  
+/// MatcherNode - Base class for all the the DAG ISel Matcher representation
+/// nodes.
+class MatcherNode {
+public:
+  enum KindTy {
+    EmitNode,
+    Push,           // [Push, Dest0, Dest1, Dest2, Dest3]
+    Record,         // [Record]
+    MoveChild,      // [MoveChild, Child#]
+    MoveParent,     // [MoveParent]
+    
+    CheckSame,      // [CheckSame, N]         Fail if not same as prev match.
+    CheckPatternPredicate,
+    CheckPredicate, // [CheckPredicate, P]    Fail if predicate fails.
+    CheckOpcode,    // [CheckOpcode, Opcode]  Fail if not opcode.
+    CheckType,      // [CheckType, MVT]       Fail if not correct type.
+    CheckInteger,   // [CheckInteger, int0,int1,int2,...int7] Fail if wrong val.
+    CheckCondCode,  // [CheckCondCode, CondCode] Fail if not condcode.
+    CheckValueType,
+    CheckComplexPat,
+    CheckAndImm,
+    CheckOrImm
+  };
+  const KindTy Kind;
+  
+protected:
+  MatcherNode(KindTy K) : Kind(K) {}
+public:
+  virtual ~MatcherNode() {}
+  
+  KindTy getKind() const { return Kind; }
+  
+  
+  static inline bool classof(const MatcherNode *) { return true; }
+  
+  virtual void print(raw_ostream &OS, unsigned indent = 0) const = 0;
+  void dump() const;
+};
+  
+/// EmitNodeMatcherNode - This signals a successful match and generates a node.
+class EmitNodeMatcherNode : public MatcherNode {
+  const PatternToMatch &Pattern;
+public:
+  EmitNodeMatcherNode(const PatternToMatch &pattern)
+    : MatcherNode(EmitNode), Pattern(pattern) {}
+
+  const PatternToMatch &getPattern() const { return Pattern; }
+
+  static inline bool classof(const MatcherNode *N) {
+    return N->getKind() == EmitNode;
+  }
+
+  virtual void print(raw_ostream &OS, unsigned indent = 0) const;
+};
+
+/// MatcherNodeWithChild - Every node accept the final accept state has a child
+/// that is executed after the node runs.  This class captures this commonality.
+class MatcherNodeWithChild : public MatcherNode {
+  OwningPtr<MatcherNode> Child;
+public:
+  MatcherNodeWithChild(KindTy K) : MatcherNode(K) {}
+  
+  MatcherNode *getChild() { return Child.get(); }
+  const MatcherNode *getChild() const { return Child.get(); }
+  void setChild(MatcherNode *C) { Child.reset(C); }
+  
+  static inline bool classof(const MatcherNode *N) {
+    return N->getKind() != EmitNode;
+  }
+  
+protected:
+  void printChild(raw_ostream &OS, unsigned indent) const;
+};
+
+/// PushMatcherNode - This pushes a failure scope on the stack and evaluates
+/// 'child'.  If 'child' fails to match, it pops its scope and attempts to
+/// match 'Failure'.
+class PushMatcherNode : public MatcherNodeWithChild {
+  OwningPtr<MatcherNode> Failure;
+public:
+  PushMatcherNode(MatcherNode *child = 0, MatcherNode *failure = 0)
+    : MatcherNodeWithChild(Push), Failure(failure) {
+    setChild(child);
+  }
+  
+  MatcherNode *getFailure() { return Failure.get(); }
+  const MatcherNode *getFailure() const { return Failure.get(); }
+  void setFailure(MatcherNode *N) { Failure.reset(N); }
+
+  static inline bool classof(const MatcherNode *N) {
+    return N->getKind() == Push;
+  }
+  
+  virtual void print(raw_ostream &OS, unsigned indent = 0) const;
+};
+
+/// RecordMatcherNode - Save the current node in the operand list.
+class RecordMatcherNode : public MatcherNodeWithChild {
+public:
+  RecordMatcherNode() : MatcherNodeWithChild(Record) {}
+  
+  static inline bool classof(const MatcherNode *N) {
+    return N->getKind() == Record;
+  }
+  
+  virtual void print(raw_ostream &OS, unsigned indent = 0) const;
+};
+  
+/// MoveChildMatcherNode - This tells the interpreter to move into the
+/// specified child node.
+class MoveChildMatcherNode : public MatcherNodeWithChild {
+  unsigned ChildNo;
+public:
+  MoveChildMatcherNode(unsigned childNo)
+  : MatcherNodeWithChild(MoveChild), ChildNo(childNo) {}
+  
+  unsigned getChildNo() const { return ChildNo; }
+  
+  static inline bool classof(const MatcherNode *N) {
+    return N->getKind() == MoveChild;
+  }
+  
+  virtual void print(raw_ostream &OS, unsigned indent = 0) const;
+};
+  
+/// MoveParentMatcherNode - This tells the interpreter to move to the parent
+/// of the current node.
+class MoveParentMatcherNode : public MatcherNodeWithChild {
+public:
+  MoveParentMatcherNode()
+  : MatcherNodeWithChild(MoveParent) {}
+  
+  static inline bool classof(const MatcherNode *N) {
+    return N->getKind() == MoveParent;
+  }
+  
+  virtual void print(raw_ostream &OS, unsigned indent = 0) const;
+};
+
+/// CheckSameMatcherNode - This checks to see if this node is exactly the same
+/// node as the specified match that was recorded with 'Record'.  This is used
+/// when patterns have the same name in them, like '(mul GPR:$in, GPR:$in)'.
+class CheckSameMatcherNode : public MatcherNodeWithChild {
+  unsigned MatchNumber;
+public:
+  CheckSameMatcherNode(unsigned matchnumber)
+  : MatcherNodeWithChild(CheckSame), MatchNumber(matchnumber) {}
+  
+  unsigned getMatchNumber() const { return MatchNumber; }
+  
+  static inline bool classof(const MatcherNode *N) {
+    return N->getKind() == CheckSame;
+  }
+  
+  virtual void print(raw_ostream &OS, unsigned indent = 0) const;
+};
+  
+/// CheckPatternPredicateMatcherNode - This checks the target-specific predicate
+/// to see if the entire pattern is capable of matching.  This predicate does
+/// not take a node as input.  This is used for subtarget feature checks etc.
+class CheckPatternPredicateMatcherNode : public MatcherNodeWithChild {
+  std::string Predicate;
+public:
+  CheckPatternPredicateMatcherNode(StringRef predicate)
+  : MatcherNodeWithChild(CheckPatternPredicate), Predicate(predicate) {}
+  
+  StringRef getPredicate() const { return Predicate; }
+  
+  static inline bool classof(const MatcherNode *N) {
+    return N->getKind() == CheckPatternPredicate;
+  }
+  
+  virtual void print(raw_ostream &OS, unsigned indent = 0) const;
+};
+  
+/// CheckPredicateMatcherNode - This checks the target-specific predicate to
+/// see if the node is acceptable.
+class CheckPredicateMatcherNode : public MatcherNodeWithChild {
+  StringRef PredName;
+public:
+  CheckPredicateMatcherNode(StringRef predname)
+    : MatcherNodeWithChild(CheckPredicate), PredName(predname) {}
+  
+  StringRef getPredicateName() const { return PredName; }
+
+  static inline bool classof(const MatcherNode *N) {
+    return N->getKind() == CheckPredicate;
+  }
+  
+  virtual void print(raw_ostream &OS, unsigned indent = 0) const;
+};
+  
+  
+/// CheckOpcodeMatcherNode - This checks to see if the current node has the
+/// specified opcode, if not it fails to match.
+class CheckOpcodeMatcherNode : public MatcherNodeWithChild {
+  StringRef OpcodeName;
+public:
+  CheckOpcodeMatcherNode(StringRef opcodename)
+    : MatcherNodeWithChild(CheckOpcode), OpcodeName(opcodename) {}
+  
+  StringRef getOpcodeName() const { return OpcodeName; }
+  
+  static inline bool classof(const MatcherNode *N) {
+    return N->getKind() == CheckOpcode;
+  }
+  
+  virtual void print(raw_ostream &OS, unsigned indent = 0) const;
+};
+  
+/// CheckTypeMatcherNode - This checks to see if the current node has the
+/// specified type, if not it fails to match.
+class CheckTypeMatcherNode : public MatcherNodeWithChild {
+  MVT::SimpleValueType Type;
+public:
+  CheckTypeMatcherNode(MVT::SimpleValueType type)
+    : MatcherNodeWithChild(CheckType), Type(type) {}
+  
+  MVT::SimpleValueType getType() const { return Type; }
+  
+  static inline bool classof(const MatcherNode *N) {
+    return N->getKind() == CheckType;
+  }
+  
+  virtual void print(raw_ostream &OS, unsigned indent = 0) const;
+};
+
+/// CheckIntegerMatcherNode - This checks to see if the current node is a
+/// ConstantSDNode with the specified integer value, if not it fails to match.
+class CheckIntegerMatcherNode : public MatcherNodeWithChild {
+  int64_t Value;
+public:
+  CheckIntegerMatcherNode(int64_t value)
+    : MatcherNodeWithChild(CheckInteger), Value(value) {}
+  
+  int64_t getValue() const { return Value; }
+  
+  static inline bool classof(const MatcherNode *N) {
+    return N->getKind() == CheckInteger;
+  }
+  
+  virtual void print(raw_ostream &OS, unsigned indent = 0) const;
+};
+  
+/// CheckCondCodeMatcherNode - This checks to see if the current node is a
+/// CondCodeSDNode with the specified condition, if not it fails to match.
+class CheckCondCodeMatcherNode : public MatcherNodeWithChild {
+  StringRef CondCodeName;
+public:
+  CheckCondCodeMatcherNode(StringRef condcodename)
+  : MatcherNodeWithChild(CheckCondCode), CondCodeName(condcodename) {}
+  
+  StringRef getCondCodeName() const { return CondCodeName; }
+  
+  static inline bool classof(const MatcherNode *N) {
+    return N->getKind() == CheckCondCode;
+  }
+  
+  virtual void print(raw_ostream &OS, unsigned indent = 0) const;
+};
+  
+/// CheckValueTypeMatcherNode - This checks to see if the current node is a
+/// VTSDNode with the specified type, if not it fails to match.
+class CheckValueTypeMatcherNode : public MatcherNodeWithChild {
+  StringRef TypeName;
+public:
+  CheckValueTypeMatcherNode(StringRef type_name)
+  : MatcherNodeWithChild(CheckValueType), TypeName(type_name) {}
+  
+  StringRef getTypeName() const { return TypeName; }
+
+  static inline bool classof(const MatcherNode *N) {
+    return N->getKind() == CheckValueType;
+  }
+  
+  virtual void print(raw_ostream &OS, unsigned indent = 0) const;
+};
+  
+  
+  
+/// CheckComplexPatMatcherNode - This node runs the specified ComplexPattern on
+/// the current node.
+class CheckComplexPatMatcherNode : public MatcherNodeWithChild {
+  const ComplexPattern &Pattern;
+public:
+  CheckComplexPatMatcherNode(const ComplexPattern &pattern)
+  : MatcherNodeWithChild(CheckComplexPat), Pattern(pattern) {}
+  
+  static inline bool classof(const MatcherNode *N) {
+    return N->getKind() == CheckComplexPat;
+  }
+  
+  virtual void print(raw_ostream &OS, unsigned indent = 0) const;
+};
+  
+/// CheckAndImmMatcherNode - This checks to see if the current node is an 'and'
+/// with something equivalent to the specified immediate.
+class CheckAndImmMatcherNode : public MatcherNodeWithChild {
+  int64_t Value;
+public:
+  CheckAndImmMatcherNode(int64_t value)
+  : MatcherNodeWithChild(CheckAndImm), Value(value) {}
+  
+  int64_t getValue() const { return Value; }
+  
+  static inline bool classof(const MatcherNode *N) {
+    return N->getKind() == CheckAndImm;
+  }
+  
+  virtual void print(raw_ostream &OS, unsigned indent = 0) const;
+};
+
+/// CheckOrImmMatcherNode - This checks to see if the current node is an 'and'
+/// with something equivalent to the specified immediate.
+class CheckOrImmMatcherNode : public MatcherNodeWithChild {
+  int64_t Value;
+public:
+  CheckOrImmMatcherNode(int64_t value)
+    : MatcherNodeWithChild(CheckOrImm), Value(value) {}
+  
+  int64_t getValue() const { return Value; }
+
+  static inline bool classof(const MatcherNode *N) {
+    return N->getKind() == CheckOrImm;
+  }
+  
+  virtual void print(raw_ostream &OS, unsigned indent = 0) const;
+};
+  
+  
+} // end namespace llvm
+
+#endif