CodeGenDAGPatterns.h revision b49985a8499e18675db7e9baf920d6ef4e2b65cf
1//===- CodeGenDAGPatterns.h - Read DAG patterns from .td file ---*- C++ -*-===// 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// This file declares the CodeGenDAGPatterns class, which is used to read and 11// represent the patterns present in a .td file for instructions. 12// 13//===----------------------------------------------------------------------===// 14 15#ifndef CODEGEN_DAGPATTERNS_H 16#define CODEGEN_DAGPATTERNS_H 17 18#include <set> 19#include <algorithm> 20#include <vector> 21 22#include "CodeGenTarget.h" 23#include "CodeGenIntrinsics.h" 24 25namespace llvm { 26 class Record; 27 struct Init; 28 class ListInit; 29 class DagInit; 30 class SDNodeInfo; 31 class TreePattern; 32 class TreePatternNode; 33 class CodeGenDAGPatterns; 34 class ComplexPattern; 35 36/// EEVT::DAGISelGenValueType - These are some extended forms of 37/// MVT::SimpleValueType that we use as lattice values during type inference. 38/// The existing MVT iAny, fAny and vAny types suffice to represent 39/// arbitrary integer, floating-point, and vector types, so only an unknown 40/// value is needed. 41namespace EEVT { 42 enum DAGISelGenValueType { 43 isUnknown = MVT::LAST_VALUETYPE 44 }; 45 46 /// isExtIntegerInVTs - Return true if the specified extended value type 47 /// vector contains iAny or an integer value type. 48 bool isExtIntegerInVTs(const std::vector<unsigned char> &EVTs); 49 50 /// isExtFloatingPointInVTs - Return true if the specified extended value 51 /// type vector contains fAny or a FP value type. 52 bool isExtFloatingPointInVTs(const std::vector<unsigned char> &EVTs); 53 54 /// isExtVectorinVTs - Return true if the specified extended value type 55 /// vector contains vAny or a vector value type. 56 bool isExtVectorInVTs(const std::vector<unsigned char> &EVTs); 57} 58 59/// Set type used to track multiply used variables in patterns 60typedef std::set<std::string> MultipleUseVarSet; 61 62/// SDTypeConstraint - This is a discriminated union of constraints, 63/// corresponding to the SDTypeConstraint tablegen class in Target.td. 64struct SDTypeConstraint { 65 SDTypeConstraint(Record *R); 66 67 unsigned OperandNo; // The operand # this constraint applies to. 68 enum { 69 SDTCisVT, SDTCisPtrTy, SDTCisInt, SDTCisFP, SDTCisVec, SDTCisSameAs, 70 SDTCisVTSmallerThanOp, SDTCisOpSmallerThanOp, SDTCisEltOfVec 71 } ConstraintType; 72 73 union { // The discriminated union. 74 struct { 75 unsigned char VT; 76 } SDTCisVT_Info; 77 struct { 78 unsigned OtherOperandNum; 79 } SDTCisSameAs_Info; 80 struct { 81 unsigned OtherOperandNum; 82 } SDTCisVTSmallerThanOp_Info; 83 struct { 84 unsigned BigOperandNum; 85 } SDTCisOpSmallerThanOp_Info; 86 struct { 87 unsigned OtherOperandNum; 88 } SDTCisEltOfVec_Info; 89 } x; 90 91 /// ApplyTypeConstraint - Given a node in a pattern, apply this type 92 /// constraint to the nodes operands. This returns true if it makes a 93 /// change, false otherwise. If a type contradiction is found, throw an 94 /// exception. 95 bool ApplyTypeConstraint(TreePatternNode *N, const SDNodeInfo &NodeInfo, 96 TreePattern &TP) const; 97 98 /// getOperandNum - Return the node corresponding to operand #OpNo in tree 99 /// N, which has NumResults results. 100 TreePatternNode *getOperandNum(unsigned OpNo, TreePatternNode *N, 101 unsigned NumResults) const; 102}; 103 104/// SDNodeInfo - One of these records is created for each SDNode instance in 105/// the target .td file. This represents the various dag nodes we will be 106/// processing. 107class SDNodeInfo { 108 Record *Def; 109 std::string EnumName; 110 std::string SDClassName; 111 unsigned Properties; 112 unsigned NumResults; 113 int NumOperands; 114 std::vector<SDTypeConstraint> TypeConstraints; 115public: 116 SDNodeInfo(Record *R); // Parse the specified record. 117 118 unsigned getNumResults() const { return NumResults; } 119 int getNumOperands() const { return NumOperands; } 120 Record *getRecord() const { return Def; } 121 const std::string &getEnumName() const { return EnumName; } 122 const std::string &getSDClassName() const { return SDClassName; } 123 124 const std::vector<SDTypeConstraint> &getTypeConstraints() const { 125 return TypeConstraints; 126 } 127 128 /// hasProperty - Return true if this node has the specified property. 129 /// 130 bool hasProperty(enum SDNP Prop) const { return Properties & (1 << Prop); } 131 132 /// ApplyTypeConstraints - Given a node in a pattern, apply the type 133 /// constraints for this node to the operands of the node. This returns 134 /// true if it makes a change, false otherwise. If a type contradiction is 135 /// found, throw an exception. 136 bool ApplyTypeConstraints(TreePatternNode *N, TreePattern &TP) const { 137 bool MadeChange = false; 138 for (unsigned i = 0, e = TypeConstraints.size(); i != e; ++i) 139 MadeChange |= TypeConstraints[i].ApplyTypeConstraint(N, *this, TP); 140 return MadeChange; 141 } 142}; 143 144/// FIXME: TreePatternNode's can be shared in some cases (due to dag-shaped 145/// patterns), and as such should be ref counted. We currently just leak all 146/// TreePatternNode objects! 147class TreePatternNode { 148 /// The inferred type for this node, or EEVT::isUnknown if it hasn't 149 /// been determined yet. This is a std::vector because during inference 150 /// there may be multiple possible types. 151 std::vector<unsigned char> Types; 152 153 /// Operator - The Record for the operator if this is an interior node (not 154 /// a leaf). 155 Record *Operator; 156 157 /// Val - The init value (e.g. the "GPRC" record, or "7") for a leaf. 158 /// 159 Init *Val; 160 161 /// Name - The name given to this node with the :$foo notation. 162 /// 163 std::string Name; 164 165 /// PredicateFns - The predicate functions to execute on this node to check 166 /// for a match. If this list is empty, no predicate is involved. 167 std::vector<std::string> PredicateFns; 168 169 /// TransformFn - The transformation function to execute on this node before 170 /// it can be substituted into the resulting instruction on a pattern match. 171 Record *TransformFn; 172 173 std::vector<TreePatternNode*> Children; 174public: 175 TreePatternNode(Record *Op, const std::vector<TreePatternNode*> &Ch) 176 : Types(), Operator(Op), Val(0), TransformFn(0), 177 Children(Ch) { Types.push_back(EEVT::isUnknown); } 178 TreePatternNode(Init *val) // leaf ctor 179 : Types(), Operator(0), Val(val), TransformFn(0) { 180 Types.push_back(EEVT::isUnknown); 181 } 182 ~TreePatternNode(); 183 184 const std::string &getName() const { return Name; } 185 void setName(const std::string &N) { Name = N; } 186 187 bool isLeaf() const { return Val != 0; } 188 bool hasTypeSet() const { 189 return (Types[0] < MVT::LAST_VALUETYPE) || (Types[0] == MVT::iPTR) || 190 (Types[0] == MVT::iPTRAny); 191 } 192 bool isTypeCompletelyUnknown() const { 193 return Types[0] == EEVT::isUnknown; 194 } 195 bool isTypeDynamicallyResolved() const { 196 return (Types[0] == MVT::iPTR) || (Types[0] == MVT::iPTRAny); 197 } 198 MVT::SimpleValueType getTypeNum(unsigned Num) const { 199 assert(hasTypeSet() && "Doesn't have a type yet!"); 200 assert(Types.size() > Num && "Type num out of range!"); 201 return (MVT::SimpleValueType)Types[Num]; 202 } 203 unsigned char getExtTypeNum(unsigned Num) const { 204 assert(Types.size() > Num && "Extended type num out of range!"); 205 return Types[Num]; 206 } 207 const std::vector<unsigned char> &getExtTypes() const { return Types; } 208 void setTypes(const std::vector<unsigned char> &T) { Types = T; } 209 void removeTypes() { Types = std::vector<unsigned char>(1, EEVT::isUnknown); } 210 211 Init *getLeafValue() const { assert(isLeaf()); return Val; } 212 Record *getOperator() const { assert(!isLeaf()); return Operator; } 213 214 unsigned getNumChildren() const { return Children.size(); } 215 TreePatternNode *getChild(unsigned N) const { return Children[N]; } 216 void setChild(unsigned i, TreePatternNode *N) { 217 Children[i] = N; 218 } 219 220 /// hasChild - Return true if N is any of our children. 221 bool hasChild(const TreePatternNode *N) const { 222 for (unsigned i = 0, e = Children.size(); i != e; ++i) 223 if (Children[i] == N) return true; 224 return false; 225 } 226 227 const std::vector<std::string> &getPredicateFns() const {return PredicateFns;} 228 void clearPredicateFns() { PredicateFns.clear(); } 229 void setPredicateFns(const std::vector<std::string> &Fns) { 230 assert(PredicateFns.empty() && "Overwriting non-empty predicate list!"); 231 PredicateFns = Fns; 232 } 233 void addPredicateFn(const std::string &Fn) { 234 assert(!Fn.empty() && "Empty predicate string!"); 235 if (std::find(PredicateFns.begin(), PredicateFns.end(), Fn) == 236 PredicateFns.end()) 237 PredicateFns.push_back(Fn); 238 } 239 240 Record *getTransformFn() const { return TransformFn; } 241 void setTransformFn(Record *Fn) { TransformFn = Fn; } 242 243 /// getIntrinsicInfo - If this node corresponds to an intrinsic, return the 244 /// CodeGenIntrinsic information for it, otherwise return a null pointer. 245 const CodeGenIntrinsic *getIntrinsicInfo(const CodeGenDAGPatterns &CDP) const; 246 247 /// getComplexPatternInfo - If this node corresponds to a ComplexPattern, 248 /// return the ComplexPattern information, otherwise return null. 249 const ComplexPattern * 250 getComplexPatternInfo(const CodeGenDAGPatterns &CGP) const; 251 252 /// NodeHasProperty - Return true if this node has the specified property. 253 bool NodeHasProperty(SDNP Property, const CodeGenDAGPatterns &CGP) const; 254 255 /// TreeHasProperty - Return true if any node in this tree has the specified 256 /// property. 257 bool TreeHasProperty(SDNP Property, const CodeGenDAGPatterns &CGP) const; 258 259 /// isCommutativeIntrinsic - Return true if the node is an intrinsic which is 260 /// marked isCommutative. 261 bool isCommutativeIntrinsic(const CodeGenDAGPatterns &CDP) const; 262 263 void print(raw_ostream &OS) const; 264 void dump() const; 265 266public: // Higher level manipulation routines. 267 268 /// clone - Return a new copy of this tree. 269 /// 270 TreePatternNode *clone() const; 271 272 /// RemoveAllTypes - Recursively strip all the types of this tree. 273 void RemoveAllTypes(); 274 275 /// isIsomorphicTo - Return true if this node is recursively isomorphic to 276 /// the specified node. For this comparison, all of the state of the node 277 /// is considered, except for the assigned name. Nodes with differing names 278 /// that are otherwise identical are considered isomorphic. 279 bool isIsomorphicTo(const TreePatternNode *N, 280 const MultipleUseVarSet &DepVars) const; 281 282 /// SubstituteFormalArguments - Replace the formal arguments in this tree 283 /// with actual values specified by ArgMap. 284 void SubstituteFormalArguments(std::map<std::string, 285 TreePatternNode*> &ArgMap); 286 287 /// InlinePatternFragments - If this pattern refers to any pattern 288 /// fragments, inline them into place, giving us a pattern without any 289 /// PatFrag references. 290 TreePatternNode *InlinePatternFragments(TreePattern &TP); 291 292 /// ApplyTypeConstraints - Apply all of the type constraints relevant to 293 /// this node and its children in the tree. This returns true if it makes a 294 /// change, false otherwise. If a type contradiction is found, throw an 295 /// exception. 296 bool ApplyTypeConstraints(TreePattern &TP, bool NotRegisters); 297 298 /// UpdateNodeType - Set the node type of N to VT if VT contains 299 /// information. If N already contains a conflicting type, then throw an 300 /// exception. This returns true if any information was updated. 301 /// 302 bool UpdateNodeType(const std::vector<unsigned char> &ExtVTs, 303 TreePattern &TP); 304 bool UpdateNodeType(unsigned char ExtVT, TreePattern &TP) { 305 std::vector<unsigned char> ExtVTs(1, ExtVT); 306 return UpdateNodeType(ExtVTs, TP); 307 } 308 309 /// ContainsUnresolvedType - Return true if this tree contains any 310 /// unresolved types. 311 bool ContainsUnresolvedType() const { 312 if (!hasTypeSet() && !isTypeDynamicallyResolved()) return true; 313 for (unsigned i = 0, e = getNumChildren(); i != e; ++i) 314 if (getChild(i)->ContainsUnresolvedType()) return true; 315 return false; 316 } 317 318 /// canPatternMatch - If it is impossible for this pattern to match on this 319 /// target, fill in Reason and return false. Otherwise, return true. 320 bool canPatternMatch(std::string &Reason, const CodeGenDAGPatterns &CDP); 321}; 322 323inline raw_ostream &operator<<(raw_ostream &OS, const TreePatternNode &TPN) { 324 TPN.print(OS); 325 return OS; 326} 327 328 329/// TreePattern - Represent a pattern, used for instructions, pattern 330/// fragments, etc. 331/// 332class TreePattern { 333 /// Trees - The list of pattern trees which corresponds to this pattern. 334 /// Note that PatFrag's only have a single tree. 335 /// 336 std::vector<TreePatternNode*> Trees; 337 338 /// TheRecord - The actual TableGen record corresponding to this pattern. 339 /// 340 Record *TheRecord; 341 342 /// Args - This is a list of all of the arguments to this pattern (for 343 /// PatFrag patterns), which are the 'node' markers in this pattern. 344 std::vector<std::string> Args; 345 346 /// CDP - the top-level object coordinating this madness. 347 /// 348 CodeGenDAGPatterns &CDP; 349 350 /// isInputPattern - True if this is an input pattern, something to match. 351 /// False if this is an output pattern, something to emit. 352 bool isInputPattern; 353public: 354 355 /// TreePattern constructor - Parse the specified DagInits into the 356 /// current record. 357 TreePattern(Record *TheRec, ListInit *RawPat, bool isInput, 358 CodeGenDAGPatterns &ise); 359 TreePattern(Record *TheRec, DagInit *Pat, bool isInput, 360 CodeGenDAGPatterns &ise); 361 TreePattern(Record *TheRec, TreePatternNode *Pat, bool isInput, 362 CodeGenDAGPatterns &ise); 363 364 /// getTrees - Return the tree patterns which corresponds to this pattern. 365 /// 366 const std::vector<TreePatternNode*> &getTrees() const { return Trees; } 367 unsigned getNumTrees() const { return Trees.size(); } 368 TreePatternNode *getTree(unsigned i) const { return Trees[i]; } 369 TreePatternNode *getOnlyTree() const { 370 assert(Trees.size() == 1 && "Doesn't have exactly one pattern!"); 371 return Trees[0]; 372 } 373 374 /// getRecord - Return the actual TableGen record corresponding to this 375 /// pattern. 376 /// 377 Record *getRecord() const { return TheRecord; } 378 379 unsigned getNumArgs() const { return Args.size(); } 380 const std::string &getArgName(unsigned i) const { 381 assert(i < Args.size() && "Argument reference out of range!"); 382 return Args[i]; 383 } 384 std::vector<std::string> &getArgList() { return Args; } 385 386 CodeGenDAGPatterns &getDAGPatterns() const { return CDP; } 387 388 /// InlinePatternFragments - If this pattern refers to any pattern 389 /// fragments, inline them into place, giving us a pattern without any 390 /// PatFrag references. 391 void InlinePatternFragments() { 392 for (unsigned i = 0, e = Trees.size(); i != e; ++i) 393 Trees[i] = Trees[i]->InlinePatternFragments(*this); 394 } 395 396 /// InferAllTypes - Infer/propagate as many types throughout the expression 397 /// patterns as possible. Return true if all types are inferred, false 398 /// otherwise. Throw an exception if a type contradiction is found. 399 bool InferAllTypes(); 400 401 /// error - Throw an exception, prefixing it with information about this 402 /// pattern. 403 void error(const std::string &Msg) const; 404 405 void print(raw_ostream &OS) const; 406 void dump() const; 407 408private: 409 TreePatternNode *ParseTreePattern(DagInit *DI); 410}; 411 412/// DAGDefaultOperand - One of these is created for each PredicateOperand 413/// or OptionalDefOperand that has a set ExecuteAlways / DefaultOps field. 414struct DAGDefaultOperand { 415 std::vector<TreePatternNode*> DefaultOps; 416}; 417 418class DAGInstruction { 419 TreePattern *Pattern; 420 std::vector<Record*> Results; 421 std::vector<Record*> Operands; 422 std::vector<Record*> ImpResults; 423 std::vector<Record*> ImpOperands; 424 TreePatternNode *ResultPattern; 425public: 426 DAGInstruction(TreePattern *TP, 427 const std::vector<Record*> &results, 428 const std::vector<Record*> &operands, 429 const std::vector<Record*> &impresults, 430 const std::vector<Record*> &impoperands) 431 : Pattern(TP), Results(results), Operands(operands), 432 ImpResults(impresults), ImpOperands(impoperands), 433 ResultPattern(0) {} 434 435 const TreePattern *getPattern() const { return Pattern; } 436 unsigned getNumResults() const { return Results.size(); } 437 unsigned getNumOperands() const { return Operands.size(); } 438 unsigned getNumImpResults() const { return ImpResults.size(); } 439 unsigned getNumImpOperands() const { return ImpOperands.size(); } 440 const std::vector<Record*>& getImpResults() const { return ImpResults; } 441 442 void setResultPattern(TreePatternNode *R) { ResultPattern = R; } 443 444 Record *getResult(unsigned RN) const { 445 assert(RN < Results.size()); 446 return Results[RN]; 447 } 448 449 Record *getOperand(unsigned ON) const { 450 assert(ON < Operands.size()); 451 return Operands[ON]; 452 } 453 454 Record *getImpResult(unsigned RN) const { 455 assert(RN < ImpResults.size()); 456 return ImpResults[RN]; 457 } 458 459 Record *getImpOperand(unsigned ON) const { 460 assert(ON < ImpOperands.size()); 461 return ImpOperands[ON]; 462 } 463 464 TreePatternNode *getResultPattern() const { return ResultPattern; } 465}; 466 467/// PatternToMatch - Used by CodeGenDAGPatterns to keep tab of patterns 468/// processed to produce isel. 469class PatternToMatch { 470public: 471 PatternToMatch(ListInit *preds, 472 TreePatternNode *src, TreePatternNode *dst, 473 const std::vector<Record*> &dstregs, 474 unsigned complexity): 475 Predicates(preds), SrcPattern(src), DstPattern(dst), Dstregs(dstregs), 476 AddedComplexity(complexity) {} 477 478 ListInit *Predicates; // Top level predicate conditions to match. 479 TreePatternNode *SrcPattern; // Source pattern to match. 480 TreePatternNode *DstPattern; // Resulting pattern. 481 std::vector<Record*> Dstregs; // Physical register defs being matched. 482 unsigned AddedComplexity; // Add to matching pattern complexity. 483 484 ListInit *getPredicates() const { return Predicates; } 485 TreePatternNode *getSrcPattern() const { return SrcPattern; } 486 TreePatternNode *getDstPattern() const { return DstPattern; } 487 const std::vector<Record*> &getDstRegs() const { return Dstregs; } 488 unsigned getAddedComplexity() const { return AddedComplexity; } 489 490 std::string getPredicateCheck() const; 491}; 492 493// Deterministic comparison of Record*. 494struct RecordPtrCmp { 495 bool operator()(const Record *LHS, const Record *RHS) const; 496}; 497 498class CodeGenDAGPatterns { 499 RecordKeeper &Records; 500 CodeGenTarget Target; 501 std::vector<CodeGenIntrinsic> Intrinsics; 502 std::vector<CodeGenIntrinsic> TgtIntrinsics; 503 504 std::map<Record*, SDNodeInfo, RecordPtrCmp> SDNodes; 505 std::map<Record*, std::pair<Record*, std::string>, RecordPtrCmp> SDNodeXForms; 506 std::map<Record*, ComplexPattern, RecordPtrCmp> ComplexPatterns; 507 std::map<Record*, TreePattern*, RecordPtrCmp> PatternFragments; 508 std::map<Record*, DAGDefaultOperand, RecordPtrCmp> DefaultOperands; 509 std::map<Record*, DAGInstruction, RecordPtrCmp> Instructions; 510 511 // Specific SDNode definitions: 512 Record *intrinsic_void_sdnode; 513 Record *intrinsic_w_chain_sdnode, *intrinsic_wo_chain_sdnode; 514 515 /// PatternsToMatch - All of the things we are matching on the DAG. The first 516 /// value is the pattern to match, the second pattern is the result to 517 /// emit. 518 std::vector<PatternToMatch> PatternsToMatch; 519public: 520 CodeGenDAGPatterns(RecordKeeper &R); 521 ~CodeGenDAGPatterns(); 522 523 CodeGenTarget &getTargetInfo() { return Target; } 524 const CodeGenTarget &getTargetInfo() const { return Target; } 525 526 Record *getSDNodeNamed(const std::string &Name) const; 527 528 const SDNodeInfo &getSDNodeInfo(Record *R) const { 529 assert(SDNodes.count(R) && "Unknown node!"); 530 return SDNodes.find(R)->second; 531 } 532 533 // Node transformation lookups. 534 typedef std::pair<Record*, std::string> NodeXForm; 535 const NodeXForm &getSDNodeTransform(Record *R) const { 536 assert(SDNodeXForms.count(R) && "Invalid transform!"); 537 return SDNodeXForms.find(R)->second; 538 } 539 540 typedef std::map<Record*, NodeXForm, RecordPtrCmp>::const_iterator 541 nx_iterator; 542 nx_iterator nx_begin() const { return SDNodeXForms.begin(); } 543 nx_iterator nx_end() const { return SDNodeXForms.end(); } 544 545 546 const ComplexPattern &getComplexPattern(Record *R) const { 547 assert(ComplexPatterns.count(R) && "Unknown addressing mode!"); 548 return ComplexPatterns.find(R)->second; 549 } 550 551 const CodeGenIntrinsic &getIntrinsic(Record *R) const { 552 for (unsigned i = 0, e = Intrinsics.size(); i != e; ++i) 553 if (Intrinsics[i].TheDef == R) return Intrinsics[i]; 554 for (unsigned i = 0, e = TgtIntrinsics.size(); i != e; ++i) 555 if (TgtIntrinsics[i].TheDef == R) return TgtIntrinsics[i]; 556 assert(0 && "Unknown intrinsic!"); 557 abort(); 558 } 559 560 const CodeGenIntrinsic &getIntrinsicInfo(unsigned IID) const { 561 if (IID-1 < Intrinsics.size()) 562 return Intrinsics[IID-1]; 563 if (IID-Intrinsics.size()-1 < TgtIntrinsics.size()) 564 return TgtIntrinsics[IID-Intrinsics.size()-1]; 565 assert(0 && "Bad intrinsic ID!"); 566 abort(); 567 } 568 569 unsigned getIntrinsicID(Record *R) const { 570 for (unsigned i = 0, e = Intrinsics.size(); i != e; ++i) 571 if (Intrinsics[i].TheDef == R) return i; 572 for (unsigned i = 0, e = TgtIntrinsics.size(); i != e; ++i) 573 if (TgtIntrinsics[i].TheDef == R) return i + Intrinsics.size(); 574 assert(0 && "Unknown intrinsic!"); 575 abort(); 576 } 577 578 const DAGDefaultOperand &getDefaultOperand(Record *R) const { 579 assert(DefaultOperands.count(R) &&"Isn't an analyzed default operand!"); 580 return DefaultOperands.find(R)->second; 581 } 582 583 // Pattern Fragment information. 584 TreePattern *getPatternFragment(Record *R) const { 585 assert(PatternFragments.count(R) && "Invalid pattern fragment request!"); 586 return PatternFragments.find(R)->second; 587 } 588 typedef std::map<Record*, TreePattern*, RecordPtrCmp>::const_iterator 589 pf_iterator; 590 pf_iterator pf_begin() const { return PatternFragments.begin(); } 591 pf_iterator pf_end() const { return PatternFragments.end(); } 592 593 // Patterns to match information. 594 typedef std::vector<PatternToMatch>::const_iterator ptm_iterator; 595 ptm_iterator ptm_begin() const { return PatternsToMatch.begin(); } 596 ptm_iterator ptm_end() const { return PatternsToMatch.end(); } 597 598 599 600 const DAGInstruction &getInstruction(Record *R) const { 601 assert(Instructions.count(R) && "Unknown instruction!"); 602 return Instructions.find(R)->second; 603 } 604 605 Record *get_intrinsic_void_sdnode() const { 606 return intrinsic_void_sdnode; 607 } 608 Record *get_intrinsic_w_chain_sdnode() const { 609 return intrinsic_w_chain_sdnode; 610 } 611 Record *get_intrinsic_wo_chain_sdnode() const { 612 return intrinsic_wo_chain_sdnode; 613 } 614 615 bool hasTargetIntrinsics() { return !TgtIntrinsics.empty(); } 616 617private: 618 void ParseNodeInfo(); 619 void ParseNodeTransforms(); 620 void ParseComplexPatterns(); 621 void ParsePatternFragments(); 622 void ParseDefaultOperands(); 623 void ParseInstructions(); 624 void ParsePatterns(); 625 void InferInstructionFlags(); 626 void GenerateVariants(); 627 628 void FindPatternInputsAndOutputs(TreePattern *I, TreePatternNode *Pat, 629 std::map<std::string, 630 TreePatternNode*> &InstInputs, 631 std::map<std::string, 632 TreePatternNode*> &InstResults, 633 std::vector<Record*> &InstImpInputs, 634 std::vector<Record*> &InstImpResults); 635}; 636} // end namespace llvm 637 638#endif 639