utils/TableGen/DAGISelMatcher.h

   1 //===- DAGISelMatcher.h - Representation of DAG pattern matcher -----------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef TBLGEN_DAGISELMATCHER_H
  11 #define TBLGEN_DAGISELMATCHER_H
  12
  13 #include "llvm/CodeGen/ValueTypes.h"
  14 #include "llvm/ADT/OwningPtr.h"
  15 #include "llvm/ADT/StringRef.h"
  16 #include "llvm/ADT/SmallVector.h"
  17 #include "llvm/Support/Casting.h"
  18
  19 namespace llvm {
  20   class CodeGenDAGPatterns;
  21   class Matcher;
  22   class PatternToMatch;
  23   class raw_ostream;
  24   class ComplexPattern;
  25   class Record;
  26
  27 Matcher *ConvertPatternToMatcher(const PatternToMatch &Pattern,
  28                                  const CodeGenDAGPatterns &CGP);
  29 Matcher *OptimizeMatcher(Matcher *Matcher);
  30 void EmitMatcherTable(const Matcher *Matcher, raw_ostream &OS);
  31
  32
  33 /// Matcher - Base class for all the the DAG ISel Matcher representation
  34 /// nodes.
  35 class Matcher {
  36   // The next matcher node that is executed after this one.  Null if this is the
  37   // last stage of a match.
  38   OwningPtr<Matcher> Next;
  39 public:
  40   enum KindTy {
  41     // Matcher state manipulation.
  42     Scope,                // Push a checking scope.
  43     RecordNode,           // Record the current node.
  44     RecordChild,          // Record a child of the current node.
  45     RecordMemRef,         // Record the memref in the current node.
  46     CaptureFlagInput,     // If the current node has an input flag, save it.
  47     MoveChild,            // Move current node to specified child.
  48     MoveParent,           // Move current node to parent.
  49
  50     // Predicate checking.
  51     CheckSame,            // Fail if not same as prev match.
  52     CheckPatternPredicate,
  53     CheckPredicate,       // Fail if node predicate fails.
  54     CheckOpcode,          // Fail if not opcode.
  55     CheckMultiOpcode,     // Fail if not in opcode list.
  56     CheckType,            // Fail if not correct type.
  57     CheckChildType,       // Fail if child has wrong type.
  58     CheckInteger,         // Fail if wrong val.
  59     CheckCondCode,        // Fail if not condcode.
  60     CheckValueType,
  61     CheckComplexPat,
  62     CheckAndImm,
  63     CheckOrImm,
  64     CheckFoldableChainNode,
  65     CheckChainCompatible,
  66
  67     // Node creation/emisssion.
  68     EmitInteger,          // Create a TargetConstant
  69     EmitStringInteger,    // Create a TargetConstant from a string.
  70     EmitRegister,         // Create a register.
  71     EmitConvertToTarget,  // Convert a imm/fpimm to target imm/fpimm
  72     EmitMergeInputChains, // Merge together a chains for an input.
  73     EmitCopyToReg,        // Emit a copytoreg into a physreg.
  74     EmitNode,             // Create a DAG node
  75     EmitNodeXForm,        // Run a SDNodeXForm
  76     MarkFlagResults,      // Indicate which interior nodes have flag results.
  77     CompleteMatch         // Finish a match and update the results.
  78   };
  79   const KindTy Kind;
  80
  81 protected:
  82   Matcher(KindTy K) : Kind(K) {}
  83 public:
  84   virtual ~Matcher() {}
  85
  86   KindTy getKind() const { return Kind; }
  87
  88   Matcher *getNext() { return Next.get(); }
  89   const Matcher *getNext() const { return Next.get(); }
  90   void setNext(Matcher *C) { Next.reset(C); }
  91   Matcher *takeNext() { return Next.take(); }
  92
  93   OwningPtr<Matcher> &getNextPtr() { return Next; }
  94
  95   static inline bool classof(const Matcher *) { return true; }
  96
  97   bool isEqual(const Matcher *M) const {
  98     if (getKind() != M->getKind()) return false;
  99     return isEqualImpl(M);
 100   }
 101
 102   unsigned getHash() const {
 103     // Clear the high bit so we don't conflict with tombstones etc.
 104     return ((getHashImpl() << 4) ^ getKind()) & (~0U>>1);
 105   }
 106
 107   void print(raw_ostream &OS, unsigned indent = 0) const;
 108   void dump() const;
 109 protected:
 110   virtual void printImpl(raw_ostream &OS, unsigned indent) const = 0;
 111   virtual bool isEqualImpl(const Matcher *M) const = 0;
 112   virtual unsigned getHashImpl() const = 0;
 113 };
 114
 115 /// ScopeMatcher - This attempts to match each of its children to find the first
 116 /// one that successfully matches.  If one child fails, it tries the next child.
 117 /// If none of the children match then this check fails.  It never has a 'next'.
 118 class ScopeMatcher : public Matcher {
 119   SmallVector<Matcher*, 4> Children;
 120 public:
 121   ScopeMatcher(Matcher *const *children, unsigned numchildren)
 122     : Matcher(Scope), Children(children, children+numchildren) {
 123   }
 124   virtual ~ScopeMatcher();
 125
 126   unsigned getNumChildren() const { return Children.size(); }
 127
 128   Matcher *getChild(unsigned i) { return Children[i]; }
 129   const Matcher *getChild(unsigned i) const { return Children[i]; }
 130
 131   void resetChild(unsigned i, Matcher *N) {
 132     delete Children[i];
 133     Children[i] = N;
 134   }
 135
 136   Matcher *takeChild(unsigned i) {
 137     Matcher *Res = Children[i];
 138     Children[i] = 0;
 139     return Res;
 140   }
 141
 142   void setNumChildren(unsigned NC) {
 143     if (NC < Children.size()) {
 144       // delete any children we're about to lose pointers to.
 145       for (unsigned i = NC, e = Children.size(); i != e; ++i)
 146         delete Children[i];
 147     }
 148     Children.resize(NC);
 149   }
 150
 151   static inline bool classof(const Matcher *N) {
 152     return N->getKind() == Scope;
 153   }
 154
 155 private:
 156   virtual void printImpl(raw_ostream &OS, unsigned indent) const;
 157   virtual bool isEqualImpl(const Matcher *M) const { return false; }
 158   virtual unsigned getHashImpl() const { return 12312; }
 159 };
 160
 161 /// RecordMatcher - Save the current node in the operand list.
 162 class RecordMatcher : public Matcher {
 163   /// WhatFor - This is a string indicating why we're recording this.  This
 164   /// should only be used for comment generation not anything semantic.
 165   std::string WhatFor;
 166 public:
 167   RecordMatcher(const std::string &whatfor)
 168     : Matcher(RecordNode), WhatFor(whatfor) {}
 169
 170   const std::string &getWhatFor() const { return WhatFor; }
 171
 172   static inline bool classof(const Matcher *N) {
 173     return N->getKind() == RecordNode;
 174   }
 175
 176 private:
 177   virtual void printImpl(raw_ostream &OS, unsigned indent) const;
 178   virtual bool isEqualImpl(const Matcher *M) const { return true; }
 179   virtual unsigned getHashImpl() const { return 0; }
 180 };
 181
 182 /// RecordChildMatcher - Save a numbered child of the current node, or fail
 183 /// the match if it doesn't exist.  This is logically equivalent to:
 184 ///    MoveChild N + RecordNode + MoveParent.
 185 class RecordChildMatcher : public Matcher {
 186   unsigned ChildNo;
 187
 188   /// WhatFor - This is a string indicating why we're recording this.  This
 189   /// should only be used for comment generation not anything semantic.
 190   std::string WhatFor;
 191 public:
 192   RecordChildMatcher(unsigned childno, const std::string &whatfor)
 193   : Matcher(RecordChild), ChildNo(childno), WhatFor(whatfor) {}
 194
 195   unsigned getChildNo() const { return ChildNo; }
 196   const std::string &getWhatFor() const { return WhatFor; }
 197
 198   static inline bool classof(const Matcher *N) {
 199     return N->getKind() == RecordChild;
 200   }
 201
 202 private:
 203   virtual void printImpl(raw_ostream &OS, unsigned indent) const;
 204   virtual bool isEqualImpl(const Matcher *M) const {
 205     return cast<RecordChildMatcher>(M)->getChildNo() == getChildNo();
 206   }
 207   virtual unsigned getHashImpl() const { return getChildNo(); }
 208 };
 209
 210 /// RecordMemRefMatcher - Save the current node's memref.
 211 class RecordMemRefMatcher : public Matcher {
 212 public:
 213   RecordMemRefMatcher() : Matcher(RecordMemRef) {}
 214
 215   static inline bool classof(const Matcher *N) {
 216     return N->getKind() == RecordMemRef;
 217   }
 218
 219 private:
 220   virtual void printImpl(raw_ostream &OS, unsigned indent) const;
 221   virtual bool isEqualImpl(const Matcher *M) const { return true; }
 222   virtual unsigned getHashImpl() const { return 0; }
 223 };
 224
 225
 226 /// CaptureFlagInputMatcher - If the current record has a flag input, record
 227 /// it so that it is used as an input to the generated code.
 228 class CaptureFlagInputMatcher : public Matcher {
 229 public:
 230   CaptureFlagInputMatcher() : Matcher(CaptureFlagInput) {}
 231
 232   static inline bool classof(const Matcher *N) {
 233     return N->getKind() == CaptureFlagInput;
 234   }
 235
 236 private:
 237   virtual void printImpl(raw_ostream &OS, unsigned indent) const;
 238   virtual bool isEqualImpl(const Matcher *M) const { return true; }
 239   virtual unsigned getHashImpl() const { return 0; }
 240 };
 241
 242 /// MoveChildMatcher - This tells the interpreter to move into the
 243 /// specified child node.
 244 class MoveChildMatcher : public Matcher {
 245   unsigned ChildNo;
 246 public:
 247   MoveChildMatcher(unsigned childNo) : Matcher(MoveChild), ChildNo(childNo) {}
 248
 249   unsigned getChildNo() const { return ChildNo; }
 250
 251   static inline bool classof(const Matcher *N) {
 252     return N->getKind() == MoveChild;
 253   }
 254
 255 private:
 256   virtual void printImpl(raw_ostream &OS, unsigned indent) const;
 257   virtual bool isEqualImpl(const Matcher *M) const {
 258     return cast<MoveChildMatcher>(M)->getChildNo() == getChildNo();
 259   }
 260   virtual unsigned getHashImpl() const { return getChildNo(); }
 261 };
 262
 263 /// MoveParentMatcher - This tells the interpreter to move to the parent
 264 /// of the current node.
 265 class MoveParentMatcher : public Matcher {
 266 public:
 267   MoveParentMatcher() : Matcher(MoveParent) {}
 268
 269   static inline bool classof(const Matcher *N) {
 270     return N->getKind() == MoveParent;
 271   }
 272
 273 private:
 274   virtual void printImpl(raw_ostream &OS, unsigned indent) const;
 275   virtual bool isEqualImpl(const Matcher *M) const { return true; }
 276   virtual unsigned getHashImpl() const { return 0; }
 277 };
 278
 279 /// CheckSameMatcher - This checks to see if this node is exactly the same
 280 /// node as the specified match that was recorded with 'Record'.  This is used
 281 /// when patterns have the same name in them, like '(mul GPR:$in, GPR:$in)'.
 282 class CheckSameMatcher : public Matcher {
 283   unsigned MatchNumber;
 284 public:
 285   CheckSameMatcher(unsigned matchnumber)
 286     : Matcher(CheckSame), MatchNumber(matchnumber) {}
 287
 288   unsigned getMatchNumber() const { return MatchNumber; }
 289
 290   static inline bool classof(const Matcher *N) {
 291     return N->getKind() == CheckSame;
 292   }
 293
 294 private:
 295   virtual void printImpl(raw_ostream &OS, unsigned indent) const;
 296   virtual bool isEqualImpl(const Matcher *M) const {
 297     return cast<CheckSameMatcher>(M)->getMatchNumber() == getMatchNumber();
 298   }
 299   virtual unsigned getHashImpl() const { return getMatchNumber(); }
 300 };
 301
 302 /// CheckPatternPredicateMatcher - This checks the target-specific predicate
 303 /// to see if the entire pattern is capable of matching.  This predicate does
 304 /// not take a node as input.  This is used for subtarget feature checks etc.
 305 class CheckPatternPredicateMatcher : public Matcher {
 306   std::string Predicate;
 307 public:
 308   CheckPatternPredicateMatcher(StringRef predicate)
 309     : Matcher(CheckPatternPredicate), Predicate(predicate) {}
 310
 311   StringRef getPredicate() const { return Predicate; }
 312
 313   static inline bool classof(const Matcher *N) {
 314     return N->getKind() == CheckPatternPredicate;
 315   }
 316
 317 private:
 318   virtual void printImpl(raw_ostream &OS, unsigned indent) const;
 319   virtual bool isEqualImpl(const Matcher *M) const {
 320     return cast<CheckPatternPredicateMatcher>(M)->getPredicate() == Predicate;
 321   }
 322   virtual unsigned getHashImpl() const;
 323 };
 324
 325 /// CheckPredicateMatcher - This checks the target-specific predicate to
 326 /// see if the node is acceptable.
 327 class CheckPredicateMatcher : public Matcher {
 328   StringRef PredName;
 329 public:
 330   CheckPredicateMatcher(StringRef predname)
 331     : Matcher(CheckPredicate), PredName(predname) {}
 332
 333   StringRef getPredicateName() const { return PredName; }
 334
 335   static inline bool classof(const Matcher *N) {
 336     return N->getKind() == CheckPredicate;
 337   }
 338
 339 private:
 340   virtual void printImpl(raw_ostream &OS, unsigned indent) const;
 341   virtual bool isEqualImpl(const Matcher *M) const {
 342     return cast<CheckPredicateMatcher>(M)->PredName == PredName;
 343   }
 344   virtual unsigned getHashImpl() const;
 345 };
 346
 347
 348 /// CheckOpcodeMatcher - This checks to see if the current node has the
 349 /// specified opcode, if not it fails to match.
 350 class CheckOpcodeMatcher : public Matcher {
 351   StringRef OpcodeName;
 352 public:
 353   CheckOpcodeMatcher(StringRef opcodename)
 354     : Matcher(CheckOpcode), OpcodeName(opcodename) {}
 355
 356   StringRef getOpcodeName() const { return OpcodeName; }
 357
 358   static inline bool classof(const Matcher *N) {
 359     return N->getKind() == CheckOpcode;
 360   }
 361
 362 private:
 363   virtual void printImpl(raw_ostream &OS, unsigned indent) const;
 364   virtual bool isEqualImpl(const Matcher *M) const {
 365     return cast<CheckOpcodeMatcher>(M)->OpcodeName == OpcodeName;
 366   }
 367   virtual unsigned getHashImpl() const;
 368 };
 369
 370 /// CheckMultiOpcodeMatcher - This checks to see if the current node has one
 371 /// of the specified opcode, if not it fails to match.
 372 class CheckMultiOpcodeMatcher : public Matcher {
 373   SmallVector<StringRef, 4> OpcodeNames;
 374 public:
 375   CheckMultiOpcodeMatcher(const StringRef *opcodes, unsigned numops)
 376     : Matcher(CheckMultiOpcode), OpcodeNames(opcodes, opcodes+numops) {}
 377
 378   unsigned getNumOpcodeNames() const { return OpcodeNames.size(); }
 379   StringRef getOpcodeName(unsigned i) const { return OpcodeNames[i]; }
 380
 381   static inline bool classof(const Matcher *N) {
 382     return N->getKind() == CheckMultiOpcode;
 383   }
 384
 385 private:
 386   virtual void printImpl(raw_ostream &OS, unsigned indent) const;
 387   virtual bool isEqualImpl(const Matcher *M) const {
 388     return cast<CheckMultiOpcodeMatcher>(M)->OpcodeNames == OpcodeNames;
 389   }
 390   virtual unsigned getHashImpl() const;
 391 };
 392
 393
 394
 395 /// CheckTypeMatcher - This checks to see if the current node has the
 396 /// specified type, if not it fails to match.
 397 class CheckTypeMatcher : public Matcher {
 398   MVT::SimpleValueType Type;
 399 public:
 400   CheckTypeMatcher(MVT::SimpleValueType type)
 401     : Matcher(CheckType), Type(type) {}
 402
 403   MVT::SimpleValueType getType() const { return Type; }
 404
 405   static inline bool classof(const Matcher *N) {
 406     return N->getKind() == CheckType;
 407   }
 408
 409 private:
 410   virtual void printImpl(raw_ostream &OS, unsigned indent) const;
 411   virtual bool isEqualImpl(const Matcher *M) const {
 412     return cast<CheckTypeMatcher>(this)->Type == Type;
 413   }
 414   virtual unsigned getHashImpl() const { return Type; }
 415 };
 416
 417 /// CheckChildTypeMatcher - This checks to see if a child node has the
 418 /// specified type, if not it fails to match.
 419 class CheckChildTypeMatcher : public Matcher {
 420   unsigned ChildNo;
 421   MVT::SimpleValueType Type;
 422 public:
 423   CheckChildTypeMatcher(unsigned childno, MVT::SimpleValueType type)
 424     : Matcher(CheckChildType), ChildNo(childno), Type(type) {}
 425
 426   unsigned getChildNo() const { return ChildNo; }
 427   MVT::SimpleValueType getType() const { return Type; }
 428
 429   static inline bool classof(const Matcher *N) {
 430     return N->getKind() == CheckChildType;
 431   }
 432
 433 private:
 434   virtual void printImpl(raw_ostream &OS, unsigned indent) const;
 435   virtual bool isEqualImpl(const Matcher *M) const {
 436     return cast<CheckChildTypeMatcher>(M)->ChildNo == ChildNo &&
 437            cast<CheckChildTypeMatcher>(M)->Type == Type;
 438   }
 439   virtual unsigned getHashImpl() const { return (Type << 3) | ChildNo; }
 440 };
 441
 442
 443 /// CheckIntegerMatcher - This checks to see if the current node is a
 444 /// ConstantSDNode with the specified integer value, if not it fails to match.
 445 class CheckIntegerMatcher : public Matcher {
 446   int64_t Value;
 447 public:
 448   CheckIntegerMatcher(int64_t value)
 449     : Matcher(CheckInteger), Value(value) {}
 450
 451   int64_t getValue() const { return Value; }
 452
 453   static inline bool classof(const Matcher *N) {
 454     return N->getKind() == CheckInteger;
 455   }
 456
 457 private:
 458   virtual void printImpl(raw_ostream &OS, unsigned indent) const;
 459   virtual bool isEqualImpl(const Matcher *M) const {
 460     return cast<CheckIntegerMatcher>(M)->Value == Value;
 461   }
 462   virtual unsigned getHashImpl() const { return Value; }
 463 };
 464
 465 /// CheckCondCodeMatcher - This checks to see if the current node is a
 466 /// CondCodeSDNode with the specified condition, if not it fails to match.
 467 class CheckCondCodeMatcher : public Matcher {
 468   StringRef CondCodeName;
 469 public:
 470   CheckCondCodeMatcher(StringRef condcodename)
 471     : Matcher(CheckCondCode), CondCodeName(condcodename) {}
 472
 473   StringRef getCondCodeName() const { return CondCodeName; }
 474
 475   static inline bool classof(const Matcher *N) {
 476     return N->getKind() == CheckCondCode;
 477   }
 478
 479 private:
 480   virtual void printImpl(raw_ostream &OS, unsigned indent) const;
 481   virtual bool isEqualImpl(const Matcher *M) const {
 482     return cast<CheckCondCodeMatcher>(M)->CondCodeName == CondCodeName;
 483   }
 484   virtual unsigned getHashImpl() const;
 485 };
 486
 487 /// CheckValueTypeMatcher - This checks to see if the current node is a
 488 /// VTSDNode with the specified type, if not it fails to match.
 489 class CheckValueTypeMatcher : public Matcher {
 490   StringRef TypeName;
 491 public:
 492   CheckValueTypeMatcher(StringRef type_name)
 493     : Matcher(CheckValueType), TypeName(type_name) {}
 494
 495   StringRef getTypeName() const { return TypeName; }
 496
 497   static inline bool classof(const Matcher *N) {
 498     return N->getKind() == CheckValueType;
 499   }
 500
 501 private:
 502   virtual void printImpl(raw_ostream &OS, unsigned indent) const;
 503   virtual bool isEqualImpl(const Matcher *M) const {
 504     return cast<CheckValueTypeMatcher>(M)->TypeName == TypeName;
 505   }
 506   virtual unsigned getHashImpl() const;
 507 };
 508
 509
 510
 511 /// CheckComplexPatMatcher - This node runs the specified ComplexPattern on
 512 /// the current node.
 513 class CheckComplexPatMatcher : public Matcher {
 514   const ComplexPattern &Pattern;
 515 public:
 516   CheckComplexPatMatcher(const ComplexPattern &pattern)
 517     : Matcher(CheckComplexPat), Pattern(pattern) {}
 518
 519   const ComplexPattern &getPattern() const { return Pattern; }
 520
 521   static inline bool classof(const Matcher *N) {
 522     return N->getKind() == CheckComplexPat;
 523   }
 524
 525 private:
 526   virtual void printImpl(raw_ostream &OS, unsigned indent) const;
 527   virtual bool isEqualImpl(const Matcher *M) const {
 528     return &cast<CheckComplexPatMatcher>(M)->Pattern == &Pattern;
 529   }
 530   virtual unsigned getHashImpl() const {
 531     return (unsigned)(intptr_t)&Pattern;
 532   }
 533 };
 534
 535 /// CheckAndImmMatcher - This checks to see if the current node is an 'and'
 536 /// with something equivalent to the specified immediate.
 537 class CheckAndImmMatcher : public Matcher {
 538   int64_t Value;
 539 public:
 540   CheckAndImmMatcher(int64_t value)
 541     : Matcher(CheckAndImm), Value(value) {}
 542
 543   int64_t getValue() const { return Value; }
 544
 545   static inline bool classof(const Matcher *N) {
 546     return N->getKind() == CheckAndImm;
 547   }
 548
 549 private:
 550   virtual void printImpl(raw_ostream &OS, unsigned indent) const;
 551   virtual bool isEqualImpl(const Matcher *M) const {
 552     return cast<CheckAndImmMatcher>(M)->Value == Value;
 553   }
 554   virtual unsigned getHashImpl() const { return Value; }
 555 };
 556
 557 /// CheckOrImmMatcher - This checks to see if the current node is an 'and'
 558 /// with something equivalent to the specified immediate.
 559 class CheckOrImmMatcher : public Matcher {
 560   int64_t Value;
 561 public:
 562   CheckOrImmMatcher(int64_t value)
 563     : Matcher(CheckOrImm), Value(value) {}
 564
 565   int64_t getValue() const { return Value; }
 566
 567   static inline bool classof(const Matcher *N) {
 568     return N->getKind() == CheckOrImm;
 569   }
 570
 571 private:
 572   virtual void printImpl(raw_ostream &OS, unsigned indent) const;
 573   virtual bool isEqualImpl(const Matcher *M) const {
 574     return cast<CheckOrImmMatcher>(M)->Value == Value;
 575   }
 576   virtual unsigned getHashImpl() const { return Value; }
 577 };
 578
 579 /// CheckFoldableChainNodeMatcher - This checks to see if the current node
 580 /// (which defines a chain operand) is safe to fold into a larger pattern.
 581 class CheckFoldableChainNodeMatcher : public Matcher {
 582 public:
 583   CheckFoldableChainNodeMatcher()
 584     : Matcher(CheckFoldableChainNode) {}
 585
 586   static inline bool classof(const Matcher *N) {
 587     return N->getKind() == CheckFoldableChainNode;
 588   }
 589
 590 private:
 591   virtual void printImpl(raw_ostream &OS, unsigned indent) const;
 592   virtual bool isEqualImpl(const Matcher *M) const { return true; }
 593   virtual unsigned getHashImpl() const { return 0; }
 594 };
 595
 596 /// CheckChainCompatibleMatcher - Verify that the current node's chain
 597 /// operand is 'compatible' with the specified recorded node's.
 598 class CheckChainCompatibleMatcher : public Matcher {
 599   unsigned PreviousOp;
 600 public:
 601   CheckChainCompatibleMatcher(unsigned previousop)
 602     : Matcher(CheckChainCompatible), PreviousOp(previousop) {}
 603
 604   unsigned getPreviousOp() const { return PreviousOp; }
 605
 606   static inline bool classof(const Matcher *N) {
 607     return N->getKind() == CheckChainCompatible;
 608   }
 609
 610 private:
 611   virtual void printImpl(raw_ostream &OS, unsigned indent) const;
 612   virtual bool isEqualImpl(const Matcher *M) const {
 613     return cast<CheckChainCompatibleMatcher>(this)->PreviousOp == PreviousOp;
 614   }
 615   virtual unsigned getHashImpl() const { return PreviousOp; }
 616 };
 617
 618 /// EmitIntegerMatcher - This creates a new TargetConstant.
 619 class EmitIntegerMatcher : public Matcher {
 620   int64_t Val;
 621   MVT::SimpleValueType VT;
 622 public:
 623   EmitIntegerMatcher(int64_t val, MVT::SimpleValueType vt)
 624     : Matcher(EmitInteger), Val(val), VT(vt) {}
 625
 626   int64_t getValue() const { return Val; }
 627   MVT::SimpleValueType getVT() const { return VT; }
 628
 629   static inline bool classof(const Matcher *N) {
 630     return N->getKind() == EmitInteger;
 631   }
 632
 633 private:
 634   virtual void printImpl(raw_ostream &OS, unsigned indent) const;
 635   virtual bool isEqualImpl(const Matcher *M) const {
 636     return cast<EmitIntegerMatcher>(M)->Val == Val &&
 637            cast<EmitIntegerMatcher>(M)->VT == VT;
 638   }
 639   virtual unsigned getHashImpl() const { return (Val << 4) | VT; }
 640 };
 641
 642 /// EmitStringIntegerMatcher - A target constant whose value is represented
 643 /// by a string.
 644 class EmitStringIntegerMatcher : public Matcher {
 645   std::string Val;
 646   MVT::SimpleValueType VT;
 647 public:
 648   EmitStringIntegerMatcher(const std::string &val, MVT::SimpleValueType vt)
 649     : Matcher(EmitStringInteger), Val(val), VT(vt) {}
 650
 651   const std::string &getValue() const { return Val; }
 652   MVT::SimpleValueType getVT() const { return VT; }
 653
 654   static inline bool classof(const Matcher *N) {
 655     return N->getKind() == EmitStringInteger;
 656   }
 657
 658 private:
 659   virtual void printImpl(raw_ostream &OS, unsigned indent) const;
 660   virtual bool isEqualImpl(const Matcher *M) const {
 661     return cast<EmitStringIntegerMatcher>(M)->Val == Val &&
 662            cast<EmitStringIntegerMatcher>(M)->VT == VT;
 663   }
 664   virtual unsigned getHashImpl() const;
 665 };
 666
 667 /// EmitRegisterMatcher - This creates a new TargetConstant.
 668 class EmitRegisterMatcher : public Matcher {
 669   /// Reg - The def for the register that we're emitting.  If this is null, then
 670   /// this is a reference to zero_reg.
 671   Record *Reg;
 672   MVT::SimpleValueType VT;
 673 public:
 674   EmitRegisterMatcher(Record *reg, MVT::SimpleValueType vt)
 675     : Matcher(EmitRegister), Reg(reg), VT(vt) {}
 676
 677   Record *getReg() const { return Reg; }
 678   MVT::SimpleValueType getVT() const { return VT; }
 679
 680   static inline bool classof(const Matcher *N) {
 681     return N->getKind() == EmitRegister;
 682   }
 683
 684 private:
 685   virtual void printImpl(raw_ostream &OS, unsigned indent) const;
 686   virtual bool isEqualImpl(const Matcher *M) const {
 687     return cast<EmitRegisterMatcher>(M)->Reg == Reg &&
 688            cast<EmitRegisterMatcher>(M)->VT == VT;
 689   }
 690   virtual unsigned getHashImpl() const {
 691     return ((unsigned)(intptr_t)Reg) << 4 | VT;
 692   }
 693 };
 694
 695 /// EmitConvertToTargetMatcher - Emit an operation that reads a specified
 696 /// recorded node and converts it from being a ISD::Constant to
 697 /// ISD::TargetConstant, likewise for ConstantFP.
 698 class EmitConvertToTargetMatcher : public Matcher {
 699   unsigned Slot;
 700 public:
 701   EmitConvertToTargetMatcher(unsigned slot)
 702     : Matcher(EmitConvertToTarget), Slot(slot) {}
 703
 704   unsigned getSlot() const { return Slot; }
 705
 706   static inline bool classof(const Matcher *N) {
 707     return N->getKind() == EmitConvertToTarget;
 708   }
 709
 710 private:
 711   virtual void printImpl(raw_ostream &OS, unsigned indent) const;
 712   virtual bool isEqualImpl(const Matcher *M) const {
 713     return cast<EmitConvertToTargetMatcher>(M)->Slot == Slot;
 714   }
 715   virtual unsigned getHashImpl() const { return Slot; }
 716 };
 717
 718 /// EmitMergeInputChainsMatcher - Emit a node that merges a list of input
 719 /// chains together with a token factor.  The list of nodes are the nodes in the
 720 /// matched pattern that have chain input/outputs.  This node adds all input
 721 /// chains of these nodes if they are not themselves a node in the pattern.
 722 class EmitMergeInputChainsMatcher : public Matcher {
 723   SmallVector<unsigned, 3> ChainNodes;
 724 public:
 725   EmitMergeInputChainsMatcher(const unsigned *nodes, unsigned NumNodes)
 726     : Matcher(EmitMergeInputChains), ChainNodes(nodes, nodes+NumNodes) {}
 727
 728   unsigned getNumNodes() const { return ChainNodes.size(); }
 729
 730   unsigned getNode(unsigned i) const {
 731     assert(i < ChainNodes.size());
 732     return ChainNodes[i];
 733   }
 734
 735   static inline bool classof(const Matcher *N) {
 736     return N->getKind() == EmitMergeInputChains;
 737   }
 738
 739 private:
 740   virtual void printImpl(raw_ostream &OS, unsigned indent) const;
 741   virtual bool isEqualImpl(const Matcher *M) const {
 742     return cast<EmitMergeInputChainsMatcher>(M)->ChainNodes == ChainNodes;
 743   }
 744   virtual unsigned getHashImpl() const;
 745 };
 746
 747 /// EmitCopyToRegMatcher - Emit a CopyToReg node from a value to a physreg,
 748 /// pushing the chain and flag results.
 749 ///
 750 class EmitCopyToRegMatcher : public Matcher {
 751   unsigned SrcSlot; // Value to copy into the physreg.
 752   Record *DestPhysReg;
 753 public:
 754   EmitCopyToRegMatcher(unsigned srcSlot, Record *destPhysReg)
 755     : Matcher(EmitCopyToReg), SrcSlot(srcSlot), DestPhysReg(destPhysReg) {}
 756
 757   unsigned getSrcSlot() const { return SrcSlot; }
 758   Record *getDestPhysReg() const { return DestPhysReg; }
 759
 760   static inline bool classof(const Matcher *N) {
 761     return N->getKind() == EmitCopyToReg;
 762   }
 763
 764 private:
 765   virtual void printImpl(raw_ostream &OS, unsigned indent) const;
 766   virtual bool isEqualImpl(const Matcher *M) const {
 767     return cast<EmitCopyToRegMatcher>(M)->SrcSlot == SrcSlot &&
 768            cast<EmitCopyToRegMatcher>(M)->DestPhysReg == DestPhysReg;
 769   }
 770   virtual unsigned getHashImpl() const {
 771     return SrcSlot ^ ((unsigned)(intptr_t)DestPhysReg << 4);
 772   }
 773 };
 774
 775
 776
 777 /// EmitNodeXFormMatcher - Emit an operation that runs an SDNodeXForm on a
 778 /// recorded node and records the result.
 779 class EmitNodeXFormMatcher : public Matcher {
 780   unsigned Slot;
 781   Record *NodeXForm;
 782 public:
 783   EmitNodeXFormMatcher(unsigned slot, Record *nodeXForm)
 784     : Matcher(EmitNodeXForm), Slot(slot), NodeXForm(nodeXForm) {}
 785
 786   unsigned getSlot() const { return Slot; }
 787   Record *getNodeXForm() const { return NodeXForm; }
 788
 789   static inline bool classof(const Matcher *N) {
 790     return N->getKind() == EmitNodeXForm;
 791   }
 792
 793 private:
 794   virtual void printImpl(raw_ostream &OS, unsigned indent) const;
 795   virtual bool isEqualImpl(const Matcher *M) const {
 796     return cast<EmitNodeXFormMatcher>(M)->Slot == Slot &&
 797            cast<EmitNodeXFormMatcher>(M)->NodeXForm == NodeXForm;
 798   }
 799   virtual unsigned getHashImpl() const {
 800     return Slot ^ ((unsigned)(intptr_t)NodeXForm << 4);
 801   }
 802 };
 803
 804 /// EmitNodeMatcher - This signals a successful match and generates a node.
 805 class EmitNodeMatcher : public Matcher {
 806   std::string OpcodeName;
 807   const SmallVector<MVT::SimpleValueType, 3> VTs;
 808   const SmallVector<unsigned, 6> Operands;
 809   bool HasChain, HasFlag, HasMemRefs;
 810
 811   /// NumFixedArityOperands - If this is a fixed arity node, this is set to -1.
 812   /// If this is a varidic node, this is set to the number of fixed arity
 813   /// operands in the root of the pattern.  The rest are appended to this node.
 814   int NumFixedArityOperands;
 815 public:
 816   EmitNodeMatcher(const std::string &opcodeName,
 817                   const MVT::SimpleValueType *vts, unsigned numvts,
 818                   const unsigned *operands, unsigned numops,
 819                   bool hasChain, bool hasFlag, bool hasmemrefs,
 820                   int numfixedarityoperands)
 821     : Matcher(EmitNode), OpcodeName(opcodeName),
 822       VTs(vts, vts+numvts), Operands(operands, operands+numops),
 823       HasChain(hasChain), HasFlag(hasFlag), HasMemRefs(hasmemrefs),
 824       NumFixedArityOperands(numfixedarityoperands) {}
 825
 826   const std::string &getOpcodeName() const { return OpcodeName; }
 827
 828   unsigned getNumVTs() const { return VTs.size(); }
 829   MVT::SimpleValueType getVT(unsigned i) const {
 830     assert(i < VTs.size());
 831     return VTs[i];
 832   }
 833
 834   unsigned getNumOperands() const { return Operands.size(); }
 835   unsigned getOperand(unsigned i) const {
 836     assert(i < Operands.size());
 837     return Operands[i];
 838   }
 839
 840   bool hasChain() const { return HasChain; }
 841   bool hasFlag() const { return HasFlag; }
 842   bool hasMemRefs() const { return HasMemRefs; }
 843   int getNumFixedArityOperands() const { return NumFixedArityOperands; }
 844
 845   static inline bool classof(const Matcher *N) {
 846     return N->getKind() == EmitNode;
 847   }
 848
 849 private:
 850   virtual void printImpl(raw_ostream &OS, unsigned indent) const;
 851   virtual bool isEqualImpl(const Matcher *M) const;
 852   virtual unsigned getHashImpl() const;
 853 };
 854
 855 /// MarkFlagResultsMatcher - This node indicates which non-root nodes in the
 856 /// pattern produce flags.  This allows CompleteMatchMatcher to update them
 857 /// with the output flag of the resultant code.
 858 class MarkFlagResultsMatcher : public Matcher {
 859   SmallVector<unsigned, 3> FlagResultNodes;
 860 public:
 861   MarkFlagResultsMatcher(const unsigned *nodes, unsigned NumNodes)
 862     : Matcher(MarkFlagResults), FlagResultNodes(nodes, nodes+NumNodes) {}
 863
 864   unsigned getNumNodes() const { return FlagResultNodes.size(); }
 865
 866   unsigned getNode(unsigned i) const {
 867     assert(i < FlagResultNodes.size());
 868     return FlagResultNodes[i];
 869   }
 870
 871   static inline bool classof(const Matcher *N) {
 872     return N->getKind() == MarkFlagResults;
 873   }
 874
 875 private:
 876   virtual void printImpl(raw_ostream &OS, unsigned indent) const;
 877   virtual bool isEqualImpl(const Matcher *M) const {
 878     return cast<MarkFlagResultsMatcher>(M)->FlagResultNodes == FlagResultNodes;
 879   }
 880   virtual unsigned getHashImpl() const;
 881 };
 882
 883 /// CompleteMatchMatcher - Complete a match by replacing the results of the
 884 /// pattern with the newly generated nodes.  This also prints a comment
 885 /// indicating the source and dest patterns.
 886 class CompleteMatchMatcher : public Matcher {
 887   SmallVector<unsigned, 2> Results;
 888   const PatternToMatch &Pattern;
 889 public:
 890   CompleteMatchMatcher(const unsigned *results, unsigned numresults,
 891                            const PatternToMatch &pattern)
 892   : Matcher(CompleteMatch), Results(results, results+numresults),
 893     Pattern(pattern) {}
 894
 895   unsigned getNumResults() const { return Results.size(); }
 896   unsigned getResult(unsigned R) const { return Results[R]; }
 897   const PatternToMatch &getPattern() const { return Pattern; }
 898
 899   static inline bool classof(const Matcher *N) {
 900     return N->getKind() == CompleteMatch;
 901   }
 902
 903 private:
 904   virtual void printImpl(raw_ostream &OS, unsigned indent) const;
 905   virtual bool isEqualImpl(const Matcher *M) const {
 906     return cast<CompleteMatchMatcher>(M)->Results == Results &&
 907           &cast<CompleteMatchMatcher>(M)->Pattern == &Pattern;
 908   }
 909   virtual unsigned getHashImpl() const;
 910 };
 911
 912 } // end namespace llvm
 913
 914 #endif