DAGISelMatcher.h revision c96087b3433582f1c2bdb4f0ad3dad7f0b350339
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/Support/Casting.h" 17 18namespace llvm { 19 class CodeGenDAGPatterns; 20 class MatcherNode; 21 class PatternToMatch; 22 class raw_ostream; 23 class ComplexPattern; 24 25MatcherNode *ConvertPatternToMatcher(const PatternToMatch &Pattern, 26 const CodeGenDAGPatterns &CGP); 27 28void EmitMatcherTable(const MatcherNode *Matcher, raw_ostream &OS); 29 30 31/// MatcherNode - Base class for all the the DAG ISel Matcher representation 32/// nodes. 33class MatcherNode { 34public: 35 enum KindTy { 36 EmitNode, 37 Push, // [Push, Dest0, Dest1, Dest2, Dest3] 38 Record, // [Record] 39 MoveChild, // [MoveChild, Child#] 40 MoveParent, // [MoveParent] 41 42 CheckSame, // [CheckSame, N] Fail if not same as prev match. 43 CheckPatternPredicate, 44 CheckPredicate, // [CheckPredicate, P] Fail if predicate fails. 45 CheckOpcode, // [CheckOpcode, Opcode] Fail if not opcode. 46 CheckType, // [CheckType, MVT] Fail if not correct type. 47 CheckInteger, // [CheckInteger, int0,int1,int2,...int7] Fail if wrong val. 48 CheckCondCode, // [CheckCondCode, CondCode] Fail if not condcode. 49 CheckValueType, 50 CheckComplexPat, 51 CheckAndImm, 52 CheckOrImm, 53 CheckFoldableChainNode 54 }; 55 const KindTy Kind; 56 57protected: 58 MatcherNode(KindTy K) : Kind(K) {} 59public: 60 virtual ~MatcherNode() {} 61 62 KindTy getKind() const { return Kind; } 63 64 65 static inline bool classof(const MatcherNode *) { return true; } 66 67 virtual void print(raw_ostream &OS, unsigned indent = 0) const = 0; 68 void dump() const; 69}; 70 71/// EmitNodeMatcherNode - This signals a successful match and generates a node. 72class EmitNodeMatcherNode : public MatcherNode { 73 const PatternToMatch &Pattern; 74public: 75 EmitNodeMatcherNode(const PatternToMatch &pattern) 76 : MatcherNode(EmitNode), Pattern(pattern) {} 77 78 const PatternToMatch &getPattern() const { return Pattern; } 79 80 static inline bool classof(const MatcherNode *N) { 81 return N->getKind() == EmitNode; 82 } 83 84 virtual void print(raw_ostream &OS, unsigned indent = 0) const; 85}; 86 87/// MatcherNodeWithChild - Every node accept the final accept state has a child 88/// that is executed after the node runs. This class captures this commonality. 89class MatcherNodeWithChild : public MatcherNode { 90 OwningPtr<MatcherNode> Child; 91public: 92 MatcherNodeWithChild(KindTy K) : MatcherNode(K) {} 93 94 MatcherNode *getChild() { return Child.get(); } 95 const MatcherNode *getChild() const { return Child.get(); } 96 void setChild(MatcherNode *C) { Child.reset(C); } 97 98 static inline bool classof(const MatcherNode *N) { 99 return N->getKind() != EmitNode; 100 } 101 102protected: 103 void printChild(raw_ostream &OS, unsigned indent) const; 104}; 105 106/// PushMatcherNode - This pushes a failure scope on the stack and evaluates 107/// 'child'. If 'child' fails to match, it pops its scope and attempts to 108/// match 'Failure'. 109class PushMatcherNode : public MatcherNodeWithChild { 110 OwningPtr<MatcherNode> Failure; 111public: 112 PushMatcherNode(MatcherNode *child = 0, MatcherNode *failure = 0) 113 : MatcherNodeWithChild(Push), Failure(failure) { 114 setChild(child); 115 } 116 117 MatcherNode *getFailure() { return Failure.get(); } 118 const MatcherNode *getFailure() const { return Failure.get(); } 119 void setFailure(MatcherNode *N) { Failure.reset(N); } 120 121 static inline bool classof(const MatcherNode *N) { 122 return N->getKind() == Push; 123 } 124 125 virtual void print(raw_ostream &OS, unsigned indent = 0) const; 126}; 127 128/// RecordMatcherNode - Save the current node in the operand list. 129class RecordMatcherNode : public MatcherNodeWithChild { 130 /// WhatFor - This is a string indicating why we're recording this. This 131 /// should only be used for comment generation not anything semantic. 132 std::string WhatFor; 133public: 134 RecordMatcherNode(StringRef whatfor) 135 : MatcherNodeWithChild(Record), WhatFor(whatfor) {} 136 137 StringRef getWhatFor() const { return WhatFor; } 138 139 static inline bool classof(const MatcherNode *N) { 140 return N->getKind() == Record; 141 } 142 143 virtual void print(raw_ostream &OS, unsigned indent = 0) const; 144}; 145 146/// MoveChildMatcherNode - This tells the interpreter to move into the 147/// specified child node. 148class MoveChildMatcherNode : public MatcherNodeWithChild { 149 unsigned ChildNo; 150public: 151 MoveChildMatcherNode(unsigned childNo) 152 : MatcherNodeWithChild(MoveChild), ChildNo(childNo) {} 153 154 unsigned getChildNo() const { return ChildNo; } 155 156 static inline bool classof(const MatcherNode *N) { 157 return N->getKind() == MoveChild; 158 } 159 160 virtual void print(raw_ostream &OS, unsigned indent = 0) const; 161}; 162 163/// MoveParentMatcherNode - This tells the interpreter to move to the parent 164/// of the current node. 165class MoveParentMatcherNode : public MatcherNodeWithChild { 166public: 167 MoveParentMatcherNode() 168 : MatcherNodeWithChild(MoveParent) {} 169 170 static inline bool classof(const MatcherNode *N) { 171 return N->getKind() == MoveParent; 172 } 173 174 virtual void print(raw_ostream &OS, unsigned indent = 0) const; 175}; 176 177/// CheckSameMatcherNode - This checks to see if this node is exactly the same 178/// node as the specified match that was recorded with 'Record'. This is used 179/// when patterns have the same name in them, like '(mul GPR:$in, GPR:$in)'. 180class CheckSameMatcherNode : public MatcherNodeWithChild { 181 unsigned MatchNumber; 182public: 183 CheckSameMatcherNode(unsigned matchnumber) 184 : MatcherNodeWithChild(CheckSame), MatchNumber(matchnumber) {} 185 186 unsigned getMatchNumber() const { return MatchNumber; } 187 188 static inline bool classof(const MatcherNode *N) { 189 return N->getKind() == CheckSame; 190 } 191 192 virtual void print(raw_ostream &OS, unsigned indent = 0) const; 193}; 194 195/// CheckPatternPredicateMatcherNode - This checks the target-specific predicate 196/// to see if the entire pattern is capable of matching. This predicate does 197/// not take a node as input. This is used for subtarget feature checks etc. 198class CheckPatternPredicateMatcherNode : public MatcherNodeWithChild { 199 std::string Predicate; 200public: 201 CheckPatternPredicateMatcherNode(StringRef predicate) 202 : MatcherNodeWithChild(CheckPatternPredicate), Predicate(predicate) {} 203 204 StringRef getPredicate() const { return Predicate; } 205 206 static inline bool classof(const MatcherNode *N) { 207 return N->getKind() == CheckPatternPredicate; 208 } 209 210 virtual void print(raw_ostream &OS, unsigned indent = 0) const; 211}; 212 213/// CheckPredicateMatcherNode - This checks the target-specific predicate to 214/// see if the node is acceptable. 215class CheckPredicateMatcherNode : public MatcherNodeWithChild { 216 StringRef PredName; 217public: 218 CheckPredicateMatcherNode(StringRef predname) 219 : MatcherNodeWithChild(CheckPredicate), PredName(predname) {} 220 221 StringRef getPredicateName() const { return PredName; } 222 223 static inline bool classof(const MatcherNode *N) { 224 return N->getKind() == CheckPredicate; 225 } 226 227 virtual void print(raw_ostream &OS, unsigned indent = 0) const; 228}; 229 230 231/// CheckOpcodeMatcherNode - This checks to see if the current node has the 232/// specified opcode, if not it fails to match. 233class CheckOpcodeMatcherNode : public MatcherNodeWithChild { 234 StringRef OpcodeName; 235public: 236 CheckOpcodeMatcherNode(StringRef opcodename) 237 : MatcherNodeWithChild(CheckOpcode), OpcodeName(opcodename) {} 238 239 StringRef getOpcodeName() const { return OpcodeName; } 240 241 static inline bool classof(const MatcherNode *N) { 242 return N->getKind() == CheckOpcode; 243 } 244 245 virtual void print(raw_ostream &OS, unsigned indent = 0) const; 246}; 247 248/// CheckTypeMatcherNode - This checks to see if the current node has the 249/// specified type, if not it fails to match. 250class CheckTypeMatcherNode : public MatcherNodeWithChild { 251 MVT::SimpleValueType Type; 252public: 253 CheckTypeMatcherNode(MVT::SimpleValueType type) 254 : MatcherNodeWithChild(CheckType), Type(type) {} 255 256 MVT::SimpleValueType getType() const { return Type; } 257 258 static inline bool classof(const MatcherNode *N) { 259 return N->getKind() == CheckType; 260 } 261 262 virtual void print(raw_ostream &OS, unsigned indent = 0) const; 263}; 264 265/// CheckIntegerMatcherNode - This checks to see if the current node is a 266/// ConstantSDNode with the specified integer value, if not it fails to match. 267class CheckIntegerMatcherNode : public MatcherNodeWithChild { 268 int64_t Value; 269public: 270 CheckIntegerMatcherNode(int64_t value) 271 : MatcherNodeWithChild(CheckInteger), Value(value) {} 272 273 int64_t getValue() const { return Value; } 274 275 static inline bool classof(const MatcherNode *N) { 276 return N->getKind() == CheckInteger; 277 } 278 279 virtual void print(raw_ostream &OS, unsigned indent = 0) const; 280}; 281 282/// CheckCondCodeMatcherNode - This checks to see if the current node is a 283/// CondCodeSDNode with the specified condition, if not it fails to match. 284class CheckCondCodeMatcherNode : public MatcherNodeWithChild { 285 StringRef CondCodeName; 286public: 287 CheckCondCodeMatcherNode(StringRef condcodename) 288 : MatcherNodeWithChild(CheckCondCode), CondCodeName(condcodename) {} 289 290 StringRef getCondCodeName() const { return CondCodeName; } 291 292 static inline bool classof(const MatcherNode *N) { 293 return N->getKind() == CheckCondCode; 294 } 295 296 virtual void print(raw_ostream &OS, unsigned indent = 0) const; 297}; 298 299/// CheckValueTypeMatcherNode - This checks to see if the current node is a 300/// VTSDNode with the specified type, if not it fails to match. 301class CheckValueTypeMatcherNode : public MatcherNodeWithChild { 302 StringRef TypeName; 303public: 304 CheckValueTypeMatcherNode(StringRef type_name) 305 : MatcherNodeWithChild(CheckValueType), TypeName(type_name) {} 306 307 StringRef getTypeName() const { return TypeName; } 308 309 static inline bool classof(const MatcherNode *N) { 310 return N->getKind() == CheckValueType; 311 } 312 313 virtual void print(raw_ostream &OS, unsigned indent = 0) const; 314}; 315 316 317 318/// CheckComplexPatMatcherNode - This node runs the specified ComplexPattern on 319/// the current node. 320class CheckComplexPatMatcherNode : public MatcherNodeWithChild { 321 const ComplexPattern &Pattern; 322public: 323 CheckComplexPatMatcherNode(const ComplexPattern &pattern) 324 : MatcherNodeWithChild(CheckComplexPat), Pattern(pattern) {} 325 326 const ComplexPattern &getPattern() const { return Pattern; } 327 328 static inline bool classof(const MatcherNode *N) { 329 return N->getKind() == CheckComplexPat; 330 } 331 332 virtual void print(raw_ostream &OS, unsigned indent = 0) const; 333}; 334 335/// CheckAndImmMatcherNode - This checks to see if the current node is an 'and' 336/// with something equivalent to the specified immediate. 337class CheckAndImmMatcherNode : public MatcherNodeWithChild { 338 int64_t Value; 339public: 340 CheckAndImmMatcherNode(int64_t value) 341 : MatcherNodeWithChild(CheckAndImm), Value(value) {} 342 343 int64_t getValue() const { return Value; } 344 345 static inline bool classof(const MatcherNode *N) { 346 return N->getKind() == CheckAndImm; 347 } 348 349 virtual void print(raw_ostream &OS, unsigned indent = 0) const; 350}; 351 352/// CheckOrImmMatcherNode - This checks to see if the current node is an 'and' 353/// with something equivalent to the specified immediate. 354class CheckOrImmMatcherNode : public MatcherNodeWithChild { 355 int64_t Value; 356public: 357 CheckOrImmMatcherNode(int64_t value) 358 : MatcherNodeWithChild(CheckOrImm), Value(value) {} 359 360 int64_t getValue() const { return Value; } 361 362 static inline bool classof(const MatcherNode *N) { 363 return N->getKind() == CheckOrImm; 364 } 365 366 virtual void print(raw_ostream &OS, unsigned indent = 0) const; 367}; 368 369/// CheckFoldableChainNodeMatcherNode - This checks to see if the current node 370/// (which defines a chain operand) is safe to fold into a larger pattern. 371class CheckFoldableChainNodeMatcherNode : public MatcherNodeWithChild { 372public: 373 CheckFoldableChainNodeMatcherNode() 374 : MatcherNodeWithChild(CheckFoldableChainNode) {} 375 376 static inline bool classof(const MatcherNode *N) { 377 return N->getKind() == CheckFoldableChainNode; 378 } 379 380 virtual void print(raw_ostream &OS, unsigned indent = 0) const; 381}; 382 383} // end namespace llvm 384 385#endif 386