1 //===- llvm/TableGen/Record.h - Classes for Table Records -------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file defines the main TableGen data structures, including the TableGen 10 // types, values, and high-level data structures. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef LLVM_TABLEGEN_RECORD_H 15 #define LLVM_TABLEGEN_RECORD_H 16 17 #include "llvm/ADT/ArrayRef.h" 18 #include "llvm/ADT/DenseMap.h" 19 #include "llvm/ADT/DenseSet.h" 20 #include "llvm/ADT/FoldingSet.h" 21 #include "llvm/ADT/PointerIntPair.h" 22 #include "llvm/ADT/SmallVector.h" 23 #include "llvm/ADT/StringRef.h" 24 #include "llvm/Support/Casting.h" 25 #include "llvm/Support/ErrorHandling.h" 26 #include "llvm/Support/SMLoc.h" 27 #include "llvm/Support/TrailingObjects.h" 28 #include "llvm/Support/raw_ostream.h" 29 #include <algorithm> 30 #include <cassert> 31 #include <cstddef> 32 #include <cstdint> 33 #include <map> 34 #include <memory> 35 #include <string> 36 #include <utility> 37 #include <vector> 38 39 namespace llvm { 40 41 class ListRecTy; 42 struct MultiClass; 43 class Record; 44 class RecordKeeper; 45 class RecordVal; 46 class Resolver; 47 class StringInit; 48 class TypedInit; 49 50 //===----------------------------------------------------------------------===// 51 // Type Classes 52 //===----------------------------------------------------------------------===// 53 54 class RecTy { 55 public: 56 /// Subclass discriminator (for dyn_cast<> et al.) 57 enum RecTyKind { 58 BitRecTyKind, 59 BitsRecTyKind, 60 CodeRecTyKind, 61 IntRecTyKind, 62 StringRecTyKind, 63 ListRecTyKind, 64 DagRecTyKind, 65 RecordRecTyKind 66 }; 67 68 private: 69 RecTyKind Kind; 70 ListRecTy *ListTy = nullptr; 71 72 public: RecTy(RecTyKind K)73 RecTy(RecTyKind K) : Kind(K) {} 74 virtual ~RecTy() = default; 75 getRecTyKind()76 RecTyKind getRecTyKind() const { return Kind; } 77 78 virtual std::string getAsString() const = 0; print(raw_ostream & OS)79 void print(raw_ostream &OS) const { OS << getAsString(); } 80 void dump() const; 81 82 /// Return true if all values of 'this' type can be converted to the specified 83 /// type. 84 virtual bool typeIsConvertibleTo(const RecTy *RHS) const; 85 86 /// Return true if 'this' type is equal to or a subtype of RHS. For example, 87 /// a bit set is not an int, but they are convertible. 88 virtual bool typeIsA(const RecTy *RHS) const; 89 90 /// Returns the type representing list<this>. 91 ListRecTy *getListTy(); 92 }; 93 94 inline raw_ostream &operator<<(raw_ostream &OS, const RecTy &Ty) { 95 Ty.print(OS); 96 return OS; 97 } 98 99 /// 'bit' - Represent a single bit 100 class BitRecTy : public RecTy { 101 static BitRecTy Shared; 102 BitRecTy()103 BitRecTy() : RecTy(BitRecTyKind) {} 104 105 public: classof(const RecTy * RT)106 static bool classof(const RecTy *RT) { 107 return RT->getRecTyKind() == BitRecTyKind; 108 } 109 get()110 static BitRecTy *get() { return &Shared; } 111 getAsString()112 std::string getAsString() const override { return "bit"; } 113 114 bool typeIsConvertibleTo(const RecTy *RHS) const override; 115 }; 116 117 /// 'bits<n>' - Represent a fixed number of bits 118 class BitsRecTy : public RecTy { 119 unsigned Size; 120 BitsRecTy(unsigned Sz)121 explicit BitsRecTy(unsigned Sz) : RecTy(BitsRecTyKind), Size(Sz) {} 122 123 public: classof(const RecTy * RT)124 static bool classof(const RecTy *RT) { 125 return RT->getRecTyKind() == BitsRecTyKind; 126 } 127 128 static BitsRecTy *get(unsigned Sz); 129 getNumBits()130 unsigned getNumBits() const { return Size; } 131 132 std::string getAsString() const override; 133 134 bool typeIsConvertibleTo(const RecTy *RHS) const override; 135 136 bool typeIsA(const RecTy *RHS) const override; 137 }; 138 139 /// 'code' - Represent a code fragment 140 class CodeRecTy : public RecTy { 141 static CodeRecTy Shared; 142 CodeRecTy()143 CodeRecTy() : RecTy(CodeRecTyKind) {} 144 145 public: classof(const RecTy * RT)146 static bool classof(const RecTy *RT) { 147 return RT->getRecTyKind() == CodeRecTyKind; 148 } 149 get()150 static CodeRecTy *get() { return &Shared; } 151 getAsString()152 std::string getAsString() const override { return "code"; } 153 154 bool typeIsConvertibleTo(const RecTy *RHS) const override; 155 }; 156 157 /// 'int' - Represent an integer value of no particular size 158 class IntRecTy : public RecTy { 159 static IntRecTy Shared; 160 IntRecTy()161 IntRecTy() : RecTy(IntRecTyKind) {} 162 163 public: classof(const RecTy * RT)164 static bool classof(const RecTy *RT) { 165 return RT->getRecTyKind() == IntRecTyKind; 166 } 167 get()168 static IntRecTy *get() { return &Shared; } 169 getAsString()170 std::string getAsString() const override { return "int"; } 171 172 bool typeIsConvertibleTo(const RecTy *RHS) const override; 173 }; 174 175 /// 'string' - Represent an string value 176 class StringRecTy : public RecTy { 177 static StringRecTy Shared; 178 StringRecTy()179 StringRecTy() : RecTy(StringRecTyKind) {} 180 181 public: classof(const RecTy * RT)182 static bool classof(const RecTy *RT) { 183 return RT->getRecTyKind() == StringRecTyKind; 184 } 185 get()186 static StringRecTy *get() { return &Shared; } 187 188 std::string getAsString() const override; 189 190 bool typeIsConvertibleTo(const RecTy *RHS) const override; 191 }; 192 193 /// 'list<Ty>' - Represent a list of values, all of which must be of 194 /// the specified type. 195 class ListRecTy : public RecTy { 196 friend ListRecTy *RecTy::getListTy(); 197 198 RecTy *Ty; 199 ListRecTy(RecTy * T)200 explicit ListRecTy(RecTy *T) : RecTy(ListRecTyKind), Ty(T) {} 201 202 public: classof(const RecTy * RT)203 static bool classof(const RecTy *RT) { 204 return RT->getRecTyKind() == ListRecTyKind; 205 } 206 get(RecTy * T)207 static ListRecTy *get(RecTy *T) { return T->getListTy(); } getElementType()208 RecTy *getElementType() const { return Ty; } 209 210 std::string getAsString() const override; 211 212 bool typeIsConvertibleTo(const RecTy *RHS) const override; 213 214 bool typeIsA(const RecTy *RHS) const override; 215 }; 216 217 /// 'dag' - Represent a dag fragment 218 class DagRecTy : public RecTy { 219 static DagRecTy Shared; 220 DagRecTy()221 DagRecTy() : RecTy(DagRecTyKind) {} 222 223 public: classof(const RecTy * RT)224 static bool classof(const RecTy *RT) { 225 return RT->getRecTyKind() == DagRecTyKind; 226 } 227 get()228 static DagRecTy *get() { return &Shared; } 229 230 std::string getAsString() const override; 231 }; 232 233 /// '[classname]' - Type of record values that have zero or more superclasses. 234 /// 235 /// The list of superclasses is non-redundant, i.e. only contains classes that 236 /// are not the superclass of some other listed class. 237 class RecordRecTy final : public RecTy, public FoldingSetNode, 238 public TrailingObjects<RecordRecTy, Record *> { 239 friend class Record; 240 241 unsigned NumClasses; 242 RecordRecTy(unsigned Num)243 explicit RecordRecTy(unsigned Num) 244 : RecTy(RecordRecTyKind), NumClasses(Num) {} 245 246 public: 247 RecordRecTy(const RecordRecTy &) = delete; 248 RecordRecTy &operator=(const RecordRecTy &) = delete; 249 250 // Do not use sized deallocation due to trailing objects. delete(void * p)251 void operator delete(void *p) { ::operator delete(p); } 252 classof(const RecTy * RT)253 static bool classof(const RecTy *RT) { 254 return RT->getRecTyKind() == RecordRecTyKind; 255 } 256 257 /// Get the record type with the given non-redundant list of superclasses. 258 static RecordRecTy *get(ArrayRef<Record *> Classes); 259 260 void Profile(FoldingSetNodeID &ID) const; 261 getClasses()262 ArrayRef<Record *> getClasses() const { 263 return makeArrayRef(getTrailingObjects<Record *>(), NumClasses); 264 } 265 266 using const_record_iterator = Record * const *; 267 classes_begin()268 const_record_iterator classes_begin() const { return getClasses().begin(); } classes_end()269 const_record_iterator classes_end() const { return getClasses().end(); } 270 271 std::string getAsString() const override; 272 273 bool isSubClassOf(Record *Class) const; 274 bool typeIsConvertibleTo(const RecTy *RHS) const override; 275 276 bool typeIsA(const RecTy *RHS) const override; 277 }; 278 279 /// Find a common type that T1 and T2 convert to. 280 /// Return 0 if no such type exists. 281 RecTy *resolveTypes(RecTy *T1, RecTy *T2); 282 283 //===----------------------------------------------------------------------===// 284 // Initializer Classes 285 //===----------------------------------------------------------------------===// 286 287 class Init { 288 protected: 289 /// Discriminator enum (for isa<>, dyn_cast<>, et al.) 290 /// 291 /// This enum is laid out by a preorder traversal of the inheritance 292 /// hierarchy, and does not contain an entry for abstract classes, as per 293 /// the recommendation in docs/HowToSetUpLLVMStyleRTTI.rst. 294 /// 295 /// We also explicitly include "first" and "last" values for each 296 /// interior node of the inheritance tree, to make it easier to read the 297 /// corresponding classof(). 298 /// 299 /// We could pack these a bit tighter by not having the IK_FirstXXXInit 300 /// and IK_LastXXXInit be their own values, but that would degrade 301 /// readability for really no benefit. 302 enum InitKind : uint8_t { 303 IK_First, // unused; silence a spurious warning 304 IK_FirstTypedInit, 305 IK_BitInit, 306 IK_BitsInit, 307 IK_CodeInit, 308 IK_DagInit, 309 IK_DefInit, 310 IK_FieldInit, 311 IK_IntInit, 312 IK_ListInit, 313 IK_FirstOpInit, 314 IK_BinOpInit, 315 IK_TernOpInit, 316 IK_UnOpInit, 317 IK_LastOpInit, 318 IK_CondOpInit, 319 IK_FoldOpInit, 320 IK_IsAOpInit, 321 IK_StringInit, 322 IK_VarInit, 323 IK_VarListElementInit, 324 IK_VarBitInit, 325 IK_VarDefInit, 326 IK_LastTypedInit, 327 IK_UnsetInit 328 }; 329 330 private: 331 const InitKind Kind; 332 333 protected: 334 uint8_t Opc; // Used by UnOpInit, BinOpInit, and TernOpInit 335 336 private: 337 virtual void anchor(); 338 339 public: getKind()340 InitKind getKind() const { return Kind; } 341 342 protected: Kind(K)343 explicit Init(InitKind K, uint8_t Opc = 0) : Kind(K), Opc(Opc) {} 344 345 public: 346 Init(const Init &) = delete; 347 Init &operator=(const Init &) = delete; 348 virtual ~Init() = default; 349 350 /// This virtual method should be overridden by values that may 351 /// not be completely specified yet. isComplete()352 virtual bool isComplete() const { return true; } 353 354 /// Is this a concrete and fully resolved value without any references or 355 /// stuck operations? Unset values are concrete. isConcrete()356 virtual bool isConcrete() const { return false; } 357 358 /// Print out this value. print(raw_ostream & OS)359 void print(raw_ostream &OS) const { OS << getAsString(); } 360 361 /// Convert this value to a string form. 362 virtual std::string getAsString() const = 0; 363 /// Convert this value to a string form, 364 /// without adding quote markers. This primaruly affects 365 /// StringInits where we will not surround the string value with 366 /// quotes. getAsUnquotedString()367 virtual std::string getAsUnquotedString() const { return getAsString(); } 368 369 /// Debugging method that may be called through a debugger, just 370 /// invokes print on stderr. 371 void dump() const; 372 373 /// If this initializer is convertible to Ty, return an initializer whose 374 /// type is-a Ty, generating a !cast operation if required. Otherwise, return 375 /// nullptr. 376 virtual Init *getCastTo(RecTy *Ty) const = 0; 377 378 /// Convert to an initializer whose type is-a Ty, or return nullptr if this 379 /// is not possible (this can happen if the initializer's type is convertible 380 /// to Ty, but there are unresolved references). 381 virtual Init *convertInitializerTo(RecTy *Ty) const = 0; 382 383 /// This method is used to implement the bitrange 384 /// selection operator. Given an initializer, it selects the specified bits 385 /// out, returning them as a new init of bits type. If it is not legal to use 386 /// the bit subscript operator on this initializer, return null. convertInitializerBitRange(ArrayRef<unsigned> Bits)387 virtual Init *convertInitializerBitRange(ArrayRef<unsigned> Bits) const { 388 return nullptr; 389 } 390 391 /// This method is used to implement the list slice 392 /// selection operator. Given an initializer, it selects the specified list 393 /// elements, returning them as a new init of list type. If it is not legal 394 /// to take a slice of this, return null. convertInitListSlice(ArrayRef<unsigned> Elements)395 virtual Init *convertInitListSlice(ArrayRef<unsigned> Elements) const { 396 return nullptr; 397 } 398 399 /// This method is used to implement the FieldInit class. 400 /// Implementors of this method should return the type of the named field if 401 /// they are of record type. getFieldType(StringInit * FieldName)402 virtual RecTy *getFieldType(StringInit *FieldName) const { 403 return nullptr; 404 } 405 406 /// This method is used by classes that refer to other 407 /// variables which may not be defined at the time the expression is formed. 408 /// If a value is set for the variable later, this method will be called on 409 /// users of the value to allow the value to propagate out. resolveReferences(Resolver & R)410 virtual Init *resolveReferences(Resolver &R) const { 411 return const_cast<Init *>(this); 412 } 413 414 /// This method is used to return the initializer for the specified 415 /// bit. 416 virtual Init *getBit(unsigned Bit) const = 0; 417 }; 418 419 inline raw_ostream &operator<<(raw_ostream &OS, const Init &I) { 420 I.print(OS); return OS; 421 } 422 423 /// This is the common super-class of types that have a specific, 424 /// explicit, type. 425 class TypedInit : public Init { 426 RecTy *Ty; 427 428 protected: 429 explicit TypedInit(InitKind K, RecTy *T, uint8_t Opc = 0) Init(K,Opc)430 : Init(K, Opc), Ty(T) {} 431 432 public: 433 TypedInit(const TypedInit &) = delete; 434 TypedInit &operator=(const TypedInit &) = delete; 435 classof(const Init * I)436 static bool classof(const Init *I) { 437 return I->getKind() >= IK_FirstTypedInit && 438 I->getKind() <= IK_LastTypedInit; 439 } 440 getType()441 RecTy *getType() const { return Ty; } 442 443 Init *getCastTo(RecTy *Ty) const override; 444 Init *convertInitializerTo(RecTy *Ty) const override; 445 446 Init *convertInitializerBitRange(ArrayRef<unsigned> Bits) const override; 447 Init *convertInitListSlice(ArrayRef<unsigned> Elements) const override; 448 449 /// This method is used to implement the FieldInit class. 450 /// Implementors of this method should return the type of the named field if 451 /// they are of record type. 452 /// 453 RecTy *getFieldType(StringInit *FieldName) const override; 454 }; 455 456 /// '?' - Represents an uninitialized value 457 class UnsetInit : public Init { UnsetInit()458 UnsetInit() : Init(IK_UnsetInit) {} 459 460 public: 461 UnsetInit(const UnsetInit &) = delete; 462 UnsetInit &operator=(const UnsetInit &) = delete; 463 classof(const Init * I)464 static bool classof(const Init *I) { 465 return I->getKind() == IK_UnsetInit; 466 } 467 468 static UnsetInit *get(); 469 470 Init *getCastTo(RecTy *Ty) const override; 471 Init *convertInitializerTo(RecTy *Ty) const override; 472 getBit(unsigned Bit)473 Init *getBit(unsigned Bit) const override { 474 return const_cast<UnsetInit*>(this); 475 } 476 isComplete()477 bool isComplete() const override { return false; } isConcrete()478 bool isConcrete() const override { return true; } getAsString()479 std::string getAsString() const override { return "?"; } 480 }; 481 482 /// 'true'/'false' - Represent a concrete initializer for a bit. 483 class BitInit final : public TypedInit { 484 bool Value; 485 BitInit(bool V)486 explicit BitInit(bool V) : TypedInit(IK_BitInit, BitRecTy::get()), Value(V) {} 487 488 public: 489 BitInit(const BitInit &) = delete; 490 BitInit &operator=(BitInit &) = delete; 491 classof(const Init * I)492 static bool classof(const Init *I) { 493 return I->getKind() == IK_BitInit; 494 } 495 496 static BitInit *get(bool V); 497 getValue()498 bool getValue() const { return Value; } 499 500 Init *convertInitializerTo(RecTy *Ty) const override; 501 getBit(unsigned Bit)502 Init *getBit(unsigned Bit) const override { 503 assert(Bit < 1 && "Bit index out of range!"); 504 return const_cast<BitInit*>(this); 505 } 506 isConcrete()507 bool isConcrete() const override { return true; } getAsString()508 std::string getAsString() const override { return Value ? "1" : "0"; } 509 }; 510 511 /// '{ a, b, c }' - Represents an initializer for a BitsRecTy value. 512 /// It contains a vector of bits, whose size is determined by the type. 513 class BitsInit final : public TypedInit, public FoldingSetNode, 514 public TrailingObjects<BitsInit, Init *> { 515 unsigned NumBits; 516 BitsInit(unsigned N)517 BitsInit(unsigned N) 518 : TypedInit(IK_BitsInit, BitsRecTy::get(N)), NumBits(N) {} 519 520 public: 521 BitsInit(const BitsInit &) = delete; 522 BitsInit &operator=(const BitsInit &) = delete; 523 524 // Do not use sized deallocation due to trailing objects. delete(void * p)525 void operator delete(void *p) { ::operator delete(p); } 526 classof(const Init * I)527 static bool classof(const Init *I) { 528 return I->getKind() == IK_BitsInit; 529 } 530 531 static BitsInit *get(ArrayRef<Init *> Range); 532 533 void Profile(FoldingSetNodeID &ID) const; 534 getNumBits()535 unsigned getNumBits() const { return NumBits; } 536 537 Init *convertInitializerTo(RecTy *Ty) const override; 538 Init *convertInitializerBitRange(ArrayRef<unsigned> Bits) const override; 539 isComplete()540 bool isComplete() const override { 541 for (unsigned i = 0; i != getNumBits(); ++i) 542 if (!getBit(i)->isComplete()) return false; 543 return true; 544 } 545 allInComplete()546 bool allInComplete() const { 547 for (unsigned i = 0; i != getNumBits(); ++i) 548 if (getBit(i)->isComplete()) return false; 549 return true; 550 } 551 552 bool isConcrete() const override; 553 std::string getAsString() const override; 554 555 Init *resolveReferences(Resolver &R) const override; 556 getBit(unsigned Bit)557 Init *getBit(unsigned Bit) const override { 558 assert(Bit < NumBits && "Bit index out of range!"); 559 return getTrailingObjects<Init *>()[Bit]; 560 } 561 }; 562 563 /// '7' - Represent an initialization by a literal integer value. 564 class IntInit : public TypedInit { 565 int64_t Value; 566 IntInit(int64_t V)567 explicit IntInit(int64_t V) 568 : TypedInit(IK_IntInit, IntRecTy::get()), Value(V) {} 569 570 public: 571 IntInit(const IntInit &) = delete; 572 IntInit &operator=(const IntInit &) = delete; 573 classof(const Init * I)574 static bool classof(const Init *I) { 575 return I->getKind() == IK_IntInit; 576 } 577 578 static IntInit *get(int64_t V); 579 getValue()580 int64_t getValue() const { return Value; } 581 582 Init *convertInitializerTo(RecTy *Ty) const override; 583 Init *convertInitializerBitRange(ArrayRef<unsigned> Bits) const override; 584 isConcrete()585 bool isConcrete() const override { return true; } 586 std::string getAsString() const override; 587 getBit(unsigned Bit)588 Init *getBit(unsigned Bit) const override { 589 return BitInit::get((Value & (1ULL << Bit)) != 0); 590 } 591 }; 592 593 /// "foo" - Represent an initialization by a string value. 594 class StringInit : public TypedInit { 595 StringRef Value; 596 StringInit(StringRef V)597 explicit StringInit(StringRef V) 598 : TypedInit(IK_StringInit, StringRecTy::get()), Value(V) {} 599 600 public: 601 StringInit(const StringInit &) = delete; 602 StringInit &operator=(const StringInit &) = delete; 603 classof(const Init * I)604 static bool classof(const Init *I) { 605 return I->getKind() == IK_StringInit; 606 } 607 608 static StringInit *get(StringRef); 609 getValue()610 StringRef getValue() const { return Value; } 611 612 Init *convertInitializerTo(RecTy *Ty) const override; 613 isConcrete()614 bool isConcrete() const override { return true; } getAsString()615 std::string getAsString() const override { return "\"" + Value.str() + "\""; } 616 getAsUnquotedString()617 std::string getAsUnquotedString() const override { return Value; } 618 getBit(unsigned Bit)619 Init *getBit(unsigned Bit) const override { 620 llvm_unreachable("Illegal bit reference off string"); 621 } 622 }; 623 624 class CodeInit : public TypedInit { 625 StringRef Value; 626 SMLoc Loc; 627 CodeInit(StringRef V,const SMLoc & Loc)628 explicit CodeInit(StringRef V, const SMLoc &Loc) 629 : TypedInit(IK_CodeInit, static_cast<RecTy *>(CodeRecTy::get())), 630 Value(V), Loc(Loc) {} 631 632 public: 633 CodeInit(const StringInit &) = delete; 634 CodeInit &operator=(const StringInit &) = delete; 635 classof(const Init * I)636 static bool classof(const Init *I) { 637 return I->getKind() == IK_CodeInit; 638 } 639 640 static CodeInit *get(StringRef, const SMLoc &Loc); 641 getValue()642 StringRef getValue() const { return Value; } getLoc()643 const SMLoc &getLoc() const { return Loc; } 644 645 Init *convertInitializerTo(RecTy *Ty) const override; 646 isConcrete()647 bool isConcrete() const override { return true; } getAsString()648 std::string getAsString() const override { 649 return "[{" + Value.str() + "}]"; 650 } 651 getAsUnquotedString()652 std::string getAsUnquotedString() const override { return Value; } 653 getBit(unsigned Bit)654 Init *getBit(unsigned Bit) const override { 655 llvm_unreachable("Illegal bit reference off string"); 656 } 657 }; 658 659 /// [AL, AH, CL] - Represent a list of defs 660 /// 661 class ListInit final : public TypedInit, public FoldingSetNode, 662 public TrailingObjects<ListInit, Init *> { 663 unsigned NumValues; 664 665 public: 666 using const_iterator = Init *const *; 667 668 private: ListInit(unsigned N,RecTy * EltTy)669 explicit ListInit(unsigned N, RecTy *EltTy) 670 : TypedInit(IK_ListInit, ListRecTy::get(EltTy)), NumValues(N) {} 671 672 public: 673 ListInit(const ListInit &) = delete; 674 ListInit &operator=(const ListInit &) = delete; 675 676 // Do not use sized deallocation due to trailing objects. delete(void * p)677 void operator delete(void *p) { ::operator delete(p); } 678 classof(const Init * I)679 static bool classof(const Init *I) { 680 return I->getKind() == IK_ListInit; 681 } 682 static ListInit *get(ArrayRef<Init *> Range, RecTy *EltTy); 683 684 void Profile(FoldingSetNodeID &ID) const; 685 getElement(unsigned i)686 Init *getElement(unsigned i) const { 687 assert(i < NumValues && "List element index out of range!"); 688 return getTrailingObjects<Init *>()[i]; 689 } getElementType()690 RecTy *getElementType() const { 691 return cast<ListRecTy>(getType())->getElementType(); 692 } 693 694 Record *getElementAsRecord(unsigned i) const; 695 696 Init *convertInitListSlice(ArrayRef<unsigned> Elements) const override; 697 698 Init *convertInitializerTo(RecTy *Ty) const override; 699 700 /// This method is used by classes that refer to other 701 /// variables which may not be defined at the time they expression is formed. 702 /// If a value is set for the variable later, this method will be called on 703 /// users of the value to allow the value to propagate out. 704 /// 705 Init *resolveReferences(Resolver &R) const override; 706 707 bool isConcrete() const override; 708 std::string getAsString() const override; 709 getValues()710 ArrayRef<Init*> getValues() const { 711 return makeArrayRef(getTrailingObjects<Init *>(), NumValues); 712 } 713 begin()714 const_iterator begin() const { return getTrailingObjects<Init *>(); } end()715 const_iterator end () const { return begin() + NumValues; } 716 size()717 size_t size () const { return NumValues; } empty()718 bool empty() const { return NumValues == 0; } 719 getBit(unsigned Bit)720 Init *getBit(unsigned Bit) const override { 721 llvm_unreachable("Illegal bit reference off list"); 722 } 723 }; 724 725 /// Base class for operators 726 /// 727 class OpInit : public TypedInit { 728 protected: OpInit(InitKind K,RecTy * Type,uint8_t Opc)729 explicit OpInit(InitKind K, RecTy *Type, uint8_t Opc) 730 : TypedInit(K, Type, Opc) {} 731 732 public: 733 OpInit(const OpInit &) = delete; 734 OpInit &operator=(OpInit &) = delete; 735 classof(const Init * I)736 static bool classof(const Init *I) { 737 return I->getKind() >= IK_FirstOpInit && 738 I->getKind() <= IK_LastOpInit; 739 } 740 741 // Clone - Clone this operator, replacing arguments with the new list 742 virtual OpInit *clone(ArrayRef<Init *> Operands) const = 0; 743 744 virtual unsigned getNumOperands() const = 0; 745 virtual Init *getOperand(unsigned i) const = 0; 746 747 Init *getBit(unsigned Bit) const override; 748 }; 749 750 /// !op (X) - Transform an init. 751 /// 752 class UnOpInit : public OpInit, public FoldingSetNode { 753 public: 754 enum UnaryOp : uint8_t { CAST, HEAD, TAIL, SIZE, EMPTY }; 755 756 private: 757 Init *LHS; 758 UnOpInit(UnaryOp opc,Init * lhs,RecTy * Type)759 UnOpInit(UnaryOp opc, Init *lhs, RecTy *Type) 760 : OpInit(IK_UnOpInit, Type, opc), LHS(lhs) {} 761 762 public: 763 UnOpInit(const UnOpInit &) = delete; 764 UnOpInit &operator=(const UnOpInit &) = delete; 765 classof(const Init * I)766 static bool classof(const Init *I) { 767 return I->getKind() == IK_UnOpInit; 768 } 769 770 static UnOpInit *get(UnaryOp opc, Init *lhs, RecTy *Type); 771 772 void Profile(FoldingSetNodeID &ID) const; 773 774 // Clone - Clone this operator, replacing arguments with the new list clone(ArrayRef<Init * > Operands)775 OpInit *clone(ArrayRef<Init *> Operands) const override { 776 assert(Operands.size() == 1 && 777 "Wrong number of operands for unary operation"); 778 return UnOpInit::get(getOpcode(), *Operands.begin(), getType()); 779 } 780 getNumOperands()781 unsigned getNumOperands() const override { return 1; } 782 getOperand(unsigned i)783 Init *getOperand(unsigned i) const override { 784 assert(i == 0 && "Invalid operand id for unary operator"); 785 return getOperand(); 786 } 787 getOpcode()788 UnaryOp getOpcode() const { return (UnaryOp)Opc; } getOperand()789 Init *getOperand() const { return LHS; } 790 791 // Fold - If possible, fold this to a simpler init. Return this if not 792 // possible to fold. 793 Init *Fold(Record *CurRec, bool IsFinal = false) const; 794 795 Init *resolveReferences(Resolver &R) const override; 796 797 std::string getAsString() const override; 798 }; 799 800 /// !op (X, Y) - Combine two inits. 801 class BinOpInit : public OpInit, public FoldingSetNode { 802 public: 803 enum BinaryOp : uint8_t { ADD, MUL, AND, OR, SHL, SRA, SRL, LISTCONCAT, 804 LISTSPLAT, STRCONCAT, CONCAT, EQ, NE, LE, LT, GE, 805 GT }; 806 807 private: 808 Init *LHS, *RHS; 809 BinOpInit(BinaryOp opc,Init * lhs,Init * rhs,RecTy * Type)810 BinOpInit(BinaryOp opc, Init *lhs, Init *rhs, RecTy *Type) : 811 OpInit(IK_BinOpInit, Type, opc), LHS(lhs), RHS(rhs) {} 812 813 public: 814 BinOpInit(const BinOpInit &) = delete; 815 BinOpInit &operator=(const BinOpInit &) = delete; 816 classof(const Init * I)817 static bool classof(const Init *I) { 818 return I->getKind() == IK_BinOpInit; 819 } 820 821 static BinOpInit *get(BinaryOp opc, Init *lhs, Init *rhs, 822 RecTy *Type); 823 static Init *getStrConcat(Init *lhs, Init *rhs); 824 static Init *getListConcat(TypedInit *lhs, Init *rhs); 825 static Init *getListSplat(TypedInit *lhs, Init *rhs); 826 827 void Profile(FoldingSetNodeID &ID) const; 828 829 // Clone - Clone this operator, replacing arguments with the new list clone(ArrayRef<Init * > Operands)830 OpInit *clone(ArrayRef<Init *> Operands) const override { 831 assert(Operands.size() == 2 && 832 "Wrong number of operands for binary operation"); 833 return BinOpInit::get(getOpcode(), Operands[0], Operands[1], getType()); 834 } 835 getNumOperands()836 unsigned getNumOperands() const override { return 2; } getOperand(unsigned i)837 Init *getOperand(unsigned i) const override { 838 switch (i) { 839 default: llvm_unreachable("Invalid operand id for binary operator"); 840 case 0: return getLHS(); 841 case 1: return getRHS(); 842 } 843 } 844 getOpcode()845 BinaryOp getOpcode() const { return (BinaryOp)Opc; } getLHS()846 Init *getLHS() const { return LHS; } getRHS()847 Init *getRHS() const { return RHS; } 848 849 // Fold - If possible, fold this to a simpler init. Return this if not 850 // possible to fold. 851 Init *Fold(Record *CurRec) const; 852 853 Init *resolveReferences(Resolver &R) const override; 854 855 std::string getAsString() const override; 856 }; 857 858 /// !op (X, Y, Z) - Combine two inits. 859 class TernOpInit : public OpInit, public FoldingSetNode { 860 public: 861 enum TernaryOp : uint8_t { SUBST, FOREACH, IF, DAG }; 862 863 private: 864 Init *LHS, *MHS, *RHS; 865 TernOpInit(TernaryOp opc,Init * lhs,Init * mhs,Init * rhs,RecTy * Type)866 TernOpInit(TernaryOp opc, Init *lhs, Init *mhs, Init *rhs, 867 RecTy *Type) : 868 OpInit(IK_TernOpInit, Type, opc), LHS(lhs), MHS(mhs), RHS(rhs) {} 869 870 public: 871 TernOpInit(const TernOpInit &) = delete; 872 TernOpInit &operator=(const TernOpInit &) = delete; 873 classof(const Init * I)874 static bool classof(const Init *I) { 875 return I->getKind() == IK_TernOpInit; 876 } 877 878 static TernOpInit *get(TernaryOp opc, Init *lhs, 879 Init *mhs, Init *rhs, 880 RecTy *Type); 881 882 void Profile(FoldingSetNodeID &ID) const; 883 884 // Clone - Clone this operator, replacing arguments with the new list clone(ArrayRef<Init * > Operands)885 OpInit *clone(ArrayRef<Init *> Operands) const override { 886 assert(Operands.size() == 3 && 887 "Wrong number of operands for ternary operation"); 888 return TernOpInit::get(getOpcode(), Operands[0], Operands[1], Operands[2], 889 getType()); 890 } 891 getNumOperands()892 unsigned getNumOperands() const override { return 3; } getOperand(unsigned i)893 Init *getOperand(unsigned i) const override { 894 switch (i) { 895 default: llvm_unreachable("Invalid operand id for ternary operator"); 896 case 0: return getLHS(); 897 case 1: return getMHS(); 898 case 2: return getRHS(); 899 } 900 } 901 getOpcode()902 TernaryOp getOpcode() const { return (TernaryOp)Opc; } getLHS()903 Init *getLHS() const { return LHS; } getMHS()904 Init *getMHS() const { return MHS; } getRHS()905 Init *getRHS() const { return RHS; } 906 907 // Fold - If possible, fold this to a simpler init. Return this if not 908 // possible to fold. 909 Init *Fold(Record *CurRec) const; 910 isComplete()911 bool isComplete() const override { 912 return LHS->isComplete() && MHS->isComplete() && RHS->isComplete(); 913 } 914 915 Init *resolveReferences(Resolver &R) const override; 916 917 std::string getAsString() const override; 918 }; 919 920 /// !cond(condition_1: value1, ... , condition_n: value) 921 /// Selects the first value for which condition is true. 922 /// Otherwise reports an error. 923 class CondOpInit final : public TypedInit, public FoldingSetNode, 924 public TrailingObjects<CondOpInit, Init *> { 925 unsigned NumConds; 926 RecTy *ValType; 927 CondOpInit(unsigned NC,RecTy * Type)928 CondOpInit(unsigned NC, RecTy *Type) 929 : TypedInit(IK_CondOpInit, Type), 930 NumConds(NC), ValType(Type) {} 931 numTrailingObjects(OverloadToken<Init * >)932 size_t numTrailingObjects(OverloadToken<Init *>) const { 933 return 2*NumConds; 934 } 935 936 public: 937 CondOpInit(const CondOpInit &) = delete; 938 CondOpInit &operator=(const CondOpInit &) = delete; 939 classof(const Init * I)940 static bool classof(const Init *I) { 941 return I->getKind() == IK_CondOpInit; 942 } 943 944 static CondOpInit *get(ArrayRef<Init*> C, ArrayRef<Init*> V, 945 RecTy *Type); 946 947 void Profile(FoldingSetNodeID &ID) const; 948 getValType()949 RecTy *getValType() const { return ValType; } 950 getNumConds()951 unsigned getNumConds() const { return NumConds; } 952 getCond(unsigned Num)953 Init *getCond(unsigned Num) const { 954 assert(Num < NumConds && "Condition number out of range!"); 955 return getTrailingObjects<Init *>()[Num]; 956 } 957 getVal(unsigned Num)958 Init *getVal(unsigned Num) const { 959 assert(Num < NumConds && "Val number out of range!"); 960 return getTrailingObjects<Init *>()[Num+NumConds]; 961 } 962 getConds()963 ArrayRef<Init *> getConds() const { 964 return makeArrayRef(getTrailingObjects<Init *>(), NumConds); 965 } 966 getVals()967 ArrayRef<Init *> getVals() const { 968 return makeArrayRef(getTrailingObjects<Init *>()+NumConds, NumConds); 969 } 970 971 Init *Fold(Record *CurRec) const; 972 973 Init *resolveReferences(Resolver &R) const override; 974 975 bool isConcrete() const override; 976 bool isComplete() const override; 977 std::string getAsString() const override; 978 979 using const_case_iterator = SmallVectorImpl<Init*>::const_iterator; 980 using const_val_iterator = SmallVectorImpl<Init*>::const_iterator; 981 arg_begin()982 inline const_case_iterator arg_begin() const { return getConds().begin(); } arg_end()983 inline const_case_iterator arg_end () const { return getConds().end(); } 984 case_size()985 inline size_t case_size () const { return NumConds; } case_empty()986 inline bool case_empty() const { return NumConds == 0; } 987 name_begin()988 inline const_val_iterator name_begin() const { return getVals().begin();} name_end()989 inline const_val_iterator name_end () const { return getVals().end(); } 990 val_size()991 inline size_t val_size () const { return NumConds; } val_empty()992 inline bool val_empty() const { return NumConds == 0; } 993 994 Init *getBit(unsigned Bit) const override; 995 }; 996 997 /// !foldl (a, b, expr, start, lst) - Fold over a list. 998 class FoldOpInit : public TypedInit, public FoldingSetNode { 999 private: 1000 Init *Start; 1001 Init *List; 1002 Init *A; 1003 Init *B; 1004 Init *Expr; 1005 FoldOpInit(Init * Start,Init * List,Init * A,Init * B,Init * Expr,RecTy * Type)1006 FoldOpInit(Init *Start, Init *List, Init *A, Init *B, Init *Expr, RecTy *Type) 1007 : TypedInit(IK_FoldOpInit, Type), Start(Start), List(List), A(A), B(B), 1008 Expr(Expr) {} 1009 1010 public: 1011 FoldOpInit(const FoldOpInit &) = delete; 1012 FoldOpInit &operator=(const FoldOpInit &) = delete; 1013 classof(const Init * I)1014 static bool classof(const Init *I) { return I->getKind() == IK_FoldOpInit; } 1015 1016 static FoldOpInit *get(Init *Start, Init *List, Init *A, Init *B, Init *Expr, 1017 RecTy *Type); 1018 1019 void Profile(FoldingSetNodeID &ID) const; 1020 1021 // Fold - If possible, fold this to a simpler init. Return this if not 1022 // possible to fold. 1023 Init *Fold(Record *CurRec) const; 1024 isComplete()1025 bool isComplete() const override { return false; } 1026 1027 Init *resolveReferences(Resolver &R) const override; 1028 1029 Init *getBit(unsigned Bit) const override; 1030 1031 std::string getAsString() const override; 1032 }; 1033 1034 /// !isa<type>(expr) - Dynamically determine the type of an expression. 1035 class IsAOpInit : public TypedInit, public FoldingSetNode { 1036 private: 1037 RecTy *CheckType; 1038 Init *Expr; 1039 IsAOpInit(RecTy * CheckType,Init * Expr)1040 IsAOpInit(RecTy *CheckType, Init *Expr) 1041 : TypedInit(IK_IsAOpInit, IntRecTy::get()), CheckType(CheckType), 1042 Expr(Expr) {} 1043 1044 public: 1045 IsAOpInit(const IsAOpInit &) = delete; 1046 IsAOpInit &operator=(const IsAOpInit &) = delete; 1047 classof(const Init * I)1048 static bool classof(const Init *I) { return I->getKind() == IK_IsAOpInit; } 1049 1050 static IsAOpInit *get(RecTy *CheckType, Init *Expr); 1051 1052 void Profile(FoldingSetNodeID &ID) const; 1053 1054 // Fold - If possible, fold this to a simpler init. Return this if not 1055 // possible to fold. 1056 Init *Fold() const; 1057 isComplete()1058 bool isComplete() const override { return false; } 1059 1060 Init *resolveReferences(Resolver &R) const override; 1061 1062 Init *getBit(unsigned Bit) const override; 1063 1064 std::string getAsString() const override; 1065 }; 1066 1067 /// 'Opcode' - Represent a reference to an entire variable object. 1068 class VarInit : public TypedInit { 1069 Init *VarName; 1070 VarInit(Init * VN,RecTy * T)1071 explicit VarInit(Init *VN, RecTy *T) 1072 : TypedInit(IK_VarInit, T), VarName(VN) {} 1073 1074 public: 1075 VarInit(const VarInit &) = delete; 1076 VarInit &operator=(const VarInit &) = delete; 1077 classof(const Init * I)1078 static bool classof(const Init *I) { 1079 return I->getKind() == IK_VarInit; 1080 } 1081 1082 static VarInit *get(StringRef VN, RecTy *T); 1083 static VarInit *get(Init *VN, RecTy *T); 1084 1085 StringRef getName() const; getNameInit()1086 Init *getNameInit() const { return VarName; } 1087 getNameInitAsString()1088 std::string getNameInitAsString() const { 1089 return getNameInit()->getAsUnquotedString(); 1090 } 1091 1092 /// This method is used by classes that refer to other 1093 /// variables which may not be defined at the time they expression is formed. 1094 /// If a value is set for the variable later, this method will be called on 1095 /// users of the value to allow the value to propagate out. 1096 /// 1097 Init *resolveReferences(Resolver &R) const override; 1098 1099 Init *getBit(unsigned Bit) const override; 1100 getAsString()1101 std::string getAsString() const override { return getName(); } 1102 }; 1103 1104 /// Opcode{0} - Represent access to one bit of a variable or field. 1105 class VarBitInit final : public TypedInit { 1106 TypedInit *TI; 1107 unsigned Bit; 1108 VarBitInit(TypedInit * T,unsigned B)1109 VarBitInit(TypedInit *T, unsigned B) 1110 : TypedInit(IK_VarBitInit, BitRecTy::get()), TI(T), Bit(B) { 1111 assert(T->getType() && 1112 (isa<IntRecTy>(T->getType()) || 1113 (isa<BitsRecTy>(T->getType()) && 1114 cast<BitsRecTy>(T->getType())->getNumBits() > B)) && 1115 "Illegal VarBitInit expression!"); 1116 } 1117 1118 public: 1119 VarBitInit(const VarBitInit &) = delete; 1120 VarBitInit &operator=(const VarBitInit &) = delete; 1121 classof(const Init * I)1122 static bool classof(const Init *I) { 1123 return I->getKind() == IK_VarBitInit; 1124 } 1125 1126 static VarBitInit *get(TypedInit *T, unsigned B); 1127 getBitVar()1128 Init *getBitVar() const { return TI; } getBitNum()1129 unsigned getBitNum() const { return Bit; } 1130 1131 std::string getAsString() const override; 1132 Init *resolveReferences(Resolver &R) const override; 1133 getBit(unsigned B)1134 Init *getBit(unsigned B) const override { 1135 assert(B < 1 && "Bit index out of range!"); 1136 return const_cast<VarBitInit*>(this); 1137 } 1138 }; 1139 1140 /// List[4] - Represent access to one element of a var or 1141 /// field. 1142 class VarListElementInit : public TypedInit { 1143 TypedInit *TI; 1144 unsigned Element; 1145 VarListElementInit(TypedInit * T,unsigned E)1146 VarListElementInit(TypedInit *T, unsigned E) 1147 : TypedInit(IK_VarListElementInit, 1148 cast<ListRecTy>(T->getType())->getElementType()), 1149 TI(T), Element(E) { 1150 assert(T->getType() && isa<ListRecTy>(T->getType()) && 1151 "Illegal VarBitInit expression!"); 1152 } 1153 1154 public: 1155 VarListElementInit(const VarListElementInit &) = delete; 1156 VarListElementInit &operator=(const VarListElementInit &) = delete; 1157 classof(const Init * I)1158 static bool classof(const Init *I) { 1159 return I->getKind() == IK_VarListElementInit; 1160 } 1161 1162 static VarListElementInit *get(TypedInit *T, unsigned E); 1163 getVariable()1164 TypedInit *getVariable() const { return TI; } getElementNum()1165 unsigned getElementNum() const { return Element; } 1166 1167 std::string getAsString() const override; 1168 Init *resolveReferences(Resolver &R) const override; 1169 1170 Init *getBit(unsigned Bit) const override; 1171 }; 1172 1173 /// AL - Represent a reference to a 'def' in the description 1174 class DefInit : public TypedInit { 1175 friend class Record; 1176 1177 Record *Def; 1178 1179 explicit DefInit(Record *D); 1180 1181 public: 1182 DefInit(const DefInit &) = delete; 1183 DefInit &operator=(const DefInit &) = delete; 1184 classof(const Init * I)1185 static bool classof(const Init *I) { 1186 return I->getKind() == IK_DefInit; 1187 } 1188 1189 static DefInit *get(Record*); 1190 1191 Init *convertInitializerTo(RecTy *Ty) const override; 1192 getDef()1193 Record *getDef() const { return Def; } 1194 1195 //virtual Init *convertInitializerBitRange(ArrayRef<unsigned> Bits); 1196 1197 RecTy *getFieldType(StringInit *FieldName) const override; 1198 isConcrete()1199 bool isConcrete() const override { return true; } 1200 std::string getAsString() const override; 1201 getBit(unsigned Bit)1202 Init *getBit(unsigned Bit) const override { 1203 llvm_unreachable("Illegal bit reference off def"); 1204 } 1205 }; 1206 1207 /// classname<targs...> - Represent an uninstantiated anonymous class 1208 /// instantiation. 1209 class VarDefInit final : public TypedInit, public FoldingSetNode, 1210 public TrailingObjects<VarDefInit, Init *> { 1211 Record *Class; 1212 DefInit *Def = nullptr; // after instantiation 1213 unsigned NumArgs; 1214 VarDefInit(Record * Class,unsigned N)1215 explicit VarDefInit(Record *Class, unsigned N) 1216 : TypedInit(IK_VarDefInit, RecordRecTy::get(Class)), Class(Class), NumArgs(N) {} 1217 1218 DefInit *instantiate(); 1219 1220 public: 1221 VarDefInit(const VarDefInit &) = delete; 1222 VarDefInit &operator=(const VarDefInit &) = delete; 1223 1224 // Do not use sized deallocation due to trailing objects. delete(void * p)1225 void operator delete(void *p) { ::operator delete(p); } 1226 classof(const Init * I)1227 static bool classof(const Init *I) { 1228 return I->getKind() == IK_VarDefInit; 1229 } 1230 static VarDefInit *get(Record *Class, ArrayRef<Init *> Args); 1231 1232 void Profile(FoldingSetNodeID &ID) const; 1233 1234 Init *resolveReferences(Resolver &R) const override; 1235 Init *Fold() const; 1236 1237 std::string getAsString() const override; 1238 getArg(unsigned i)1239 Init *getArg(unsigned i) const { 1240 assert(i < NumArgs && "Argument index out of range!"); 1241 return getTrailingObjects<Init *>()[i]; 1242 } 1243 1244 using const_iterator = Init *const *; 1245 args_begin()1246 const_iterator args_begin() const { return getTrailingObjects<Init *>(); } args_end()1247 const_iterator args_end () const { return args_begin() + NumArgs; } 1248 args_size()1249 size_t args_size () const { return NumArgs; } args_empty()1250 bool args_empty() const { return NumArgs == 0; } 1251 args()1252 ArrayRef<Init *> args() const { return makeArrayRef(args_begin(), NumArgs); } 1253 getBit(unsigned Bit)1254 Init *getBit(unsigned Bit) const override { 1255 llvm_unreachable("Illegal bit reference off anonymous def"); 1256 } 1257 }; 1258 1259 /// X.Y - Represent a reference to a subfield of a variable 1260 class FieldInit : public TypedInit { 1261 Init *Rec; // Record we are referring to 1262 StringInit *FieldName; // Field we are accessing 1263 FieldInit(Init * R,StringInit * FN)1264 FieldInit(Init *R, StringInit *FN) 1265 : TypedInit(IK_FieldInit, R->getFieldType(FN)), Rec(R), FieldName(FN) { 1266 assert(getType() && "FieldInit with non-record type!"); 1267 } 1268 1269 public: 1270 FieldInit(const FieldInit &) = delete; 1271 FieldInit &operator=(const FieldInit &) = delete; 1272 classof(const Init * I)1273 static bool classof(const Init *I) { 1274 return I->getKind() == IK_FieldInit; 1275 } 1276 1277 static FieldInit *get(Init *R, StringInit *FN); 1278 getRecord()1279 Init *getRecord() const { return Rec; } getFieldName()1280 StringInit *getFieldName() const { return FieldName; } 1281 1282 Init *getBit(unsigned Bit) const override; 1283 1284 Init *resolveReferences(Resolver &R) const override; 1285 Init *Fold(Record *CurRec) const; 1286 getAsString()1287 std::string getAsString() const override { 1288 return Rec->getAsString() + "." + FieldName->getValue().str(); 1289 } 1290 }; 1291 1292 /// (v a, b) - Represent a DAG tree value. DAG inits are required 1293 /// to have at least one value then a (possibly empty) list of arguments. Each 1294 /// argument can have a name associated with it. 1295 class DagInit final : public TypedInit, public FoldingSetNode, 1296 public TrailingObjects<DagInit, Init *, StringInit *> { 1297 friend TrailingObjects; 1298 1299 Init *Val; 1300 StringInit *ValName; 1301 unsigned NumArgs; 1302 unsigned NumArgNames; 1303 DagInit(Init * V,StringInit * VN,unsigned NumArgs,unsigned NumArgNames)1304 DagInit(Init *V, StringInit *VN, unsigned NumArgs, unsigned NumArgNames) 1305 : TypedInit(IK_DagInit, DagRecTy::get()), Val(V), ValName(VN), 1306 NumArgs(NumArgs), NumArgNames(NumArgNames) {} 1307 numTrailingObjects(OverloadToken<Init * >)1308 size_t numTrailingObjects(OverloadToken<Init *>) const { return NumArgs; } 1309 1310 public: 1311 DagInit(const DagInit &) = delete; 1312 DagInit &operator=(const DagInit &) = delete; 1313 classof(const Init * I)1314 static bool classof(const Init *I) { 1315 return I->getKind() == IK_DagInit; 1316 } 1317 1318 static DagInit *get(Init *V, StringInit *VN, ArrayRef<Init *> ArgRange, 1319 ArrayRef<StringInit*> NameRange); 1320 static DagInit *get(Init *V, StringInit *VN, 1321 ArrayRef<std::pair<Init*, StringInit*>> Args); 1322 1323 void Profile(FoldingSetNodeID &ID) const; 1324 getOperator()1325 Init *getOperator() const { return Val; } 1326 getName()1327 StringInit *getName() const { return ValName; } 1328 getNameStr()1329 StringRef getNameStr() const { 1330 return ValName ? ValName->getValue() : StringRef(); 1331 } 1332 getNumArgs()1333 unsigned getNumArgs() const { return NumArgs; } 1334 getArg(unsigned Num)1335 Init *getArg(unsigned Num) const { 1336 assert(Num < NumArgs && "Arg number out of range!"); 1337 return getTrailingObjects<Init *>()[Num]; 1338 } 1339 getArgName(unsigned Num)1340 StringInit *getArgName(unsigned Num) const { 1341 assert(Num < NumArgNames && "Arg number out of range!"); 1342 return getTrailingObjects<StringInit *>()[Num]; 1343 } 1344 getArgNameStr(unsigned Num)1345 StringRef getArgNameStr(unsigned Num) const { 1346 StringInit *Init = getArgName(Num); 1347 return Init ? Init->getValue() : StringRef(); 1348 } 1349 getArgs()1350 ArrayRef<Init *> getArgs() const { 1351 return makeArrayRef(getTrailingObjects<Init *>(), NumArgs); 1352 } 1353 getArgNames()1354 ArrayRef<StringInit *> getArgNames() const { 1355 return makeArrayRef(getTrailingObjects<StringInit *>(), NumArgNames); 1356 } 1357 1358 Init *resolveReferences(Resolver &R) const override; 1359 1360 bool isConcrete() const override; 1361 std::string getAsString() const override; 1362 1363 using const_arg_iterator = SmallVectorImpl<Init*>::const_iterator; 1364 using const_name_iterator = SmallVectorImpl<StringInit*>::const_iterator; 1365 arg_begin()1366 inline const_arg_iterator arg_begin() const { return getArgs().begin(); } arg_end()1367 inline const_arg_iterator arg_end () const { return getArgs().end(); } 1368 arg_size()1369 inline size_t arg_size () const { return NumArgs; } arg_empty()1370 inline bool arg_empty() const { return NumArgs == 0; } 1371 name_begin()1372 inline const_name_iterator name_begin() const { return getArgNames().begin();} name_end()1373 inline const_name_iterator name_end () const { return getArgNames().end(); } 1374 name_size()1375 inline size_t name_size () const { return NumArgNames; } name_empty()1376 inline bool name_empty() const { return NumArgNames == 0; } 1377 getBit(unsigned Bit)1378 Init *getBit(unsigned Bit) const override { 1379 llvm_unreachable("Illegal bit reference off dag"); 1380 } 1381 }; 1382 1383 //===----------------------------------------------------------------------===// 1384 // High-Level Classes 1385 //===----------------------------------------------------------------------===// 1386 1387 class RecordVal { 1388 friend class Record; 1389 1390 Init *Name; 1391 PointerIntPair<RecTy *, 1, bool> TyAndPrefix; 1392 Init *Value; 1393 1394 public: 1395 RecordVal(Init *N, RecTy *T, bool P); 1396 1397 StringRef getName() const; getNameInit()1398 Init *getNameInit() const { return Name; } 1399 getNameInitAsString()1400 std::string getNameInitAsString() const { 1401 return getNameInit()->getAsUnquotedString(); 1402 } 1403 getPrefix()1404 bool getPrefix() const { return TyAndPrefix.getInt(); } getType()1405 RecTy *getType() const { return TyAndPrefix.getPointer(); } getValue()1406 Init *getValue() const { return Value; } 1407 1408 bool setValue(Init *V); 1409 1410 void dump() const; 1411 void print(raw_ostream &OS, bool PrintSem = true) const; 1412 }; 1413 1414 inline raw_ostream &operator<<(raw_ostream &OS, const RecordVal &RV) { 1415 RV.print(OS << " "); 1416 return OS; 1417 } 1418 1419 class Record { 1420 static unsigned LastID; 1421 1422 Init *Name; 1423 // Location where record was instantiated, followed by the location of 1424 // multiclass prototypes used. 1425 SmallVector<SMLoc, 4> Locs; 1426 SmallVector<Init *, 0> TemplateArgs; 1427 SmallVector<RecordVal, 0> Values; 1428 1429 // All superclasses in the inheritance forest in reverse preorder (yes, it 1430 // must be a forest; diamond-shaped inheritance is not allowed). 1431 SmallVector<std::pair<Record *, SMRange>, 0> SuperClasses; 1432 1433 // Tracks Record instances. Not owned by Record. 1434 RecordKeeper &TrackedRecords; 1435 1436 DefInit *TheInit = nullptr; 1437 1438 // Unique record ID. 1439 unsigned ID; 1440 1441 bool IsAnonymous; 1442 bool IsClass; 1443 1444 void checkName(); 1445 1446 public: 1447 // Constructs a record. 1448 explicit Record(Init *N, ArrayRef<SMLoc> locs, RecordKeeper &records, 1449 bool Anonymous = false, bool Class = false) Name(N)1450 : Name(N), Locs(locs.begin(), locs.end()), TrackedRecords(records), 1451 ID(LastID++), IsAnonymous(Anonymous), IsClass(Class) { 1452 checkName(); 1453 } 1454 1455 explicit Record(StringRef N, ArrayRef<SMLoc> locs, RecordKeeper &records, 1456 bool Class = false) Record(StringInit::get (N),locs,records,false,Class)1457 : Record(StringInit::get(N), locs, records, false, Class) {} 1458 1459 // When copy-constructing a Record, we must still guarantee a globally unique 1460 // ID number. Don't copy TheInit either since it's owned by the original 1461 // record. All other fields can be copied normally. Record(const Record & O)1462 Record(const Record &O) 1463 : Name(O.Name), Locs(O.Locs), TemplateArgs(O.TemplateArgs), 1464 Values(O.Values), SuperClasses(O.SuperClasses), 1465 TrackedRecords(O.TrackedRecords), ID(LastID++), 1466 IsAnonymous(O.IsAnonymous), IsClass(O.IsClass) { } 1467 getNewUID()1468 static unsigned getNewUID() { return LastID++; } 1469 getID()1470 unsigned getID() const { return ID; } 1471 getName()1472 StringRef getName() const { return cast<StringInit>(Name)->getValue(); } 1473 getNameInit()1474 Init *getNameInit() const { 1475 return Name; 1476 } 1477 getNameInitAsString()1478 const std::string getNameInitAsString() const { 1479 return getNameInit()->getAsUnquotedString(); 1480 } 1481 1482 void setName(Init *Name); // Also updates RecordKeeper. 1483 getLoc()1484 ArrayRef<SMLoc> getLoc() const { return Locs; } appendLoc(SMLoc Loc)1485 void appendLoc(SMLoc Loc) { Locs.push_back(Loc); } 1486 1487 // Make the type that this record should have based on its superclasses. 1488 RecordRecTy *getType(); 1489 1490 /// get the corresponding DefInit. 1491 DefInit *getDefInit(); 1492 isClass()1493 bool isClass() const { return IsClass; } 1494 getTemplateArgs()1495 ArrayRef<Init *> getTemplateArgs() const { 1496 return TemplateArgs; 1497 } 1498 getValues()1499 ArrayRef<RecordVal> getValues() const { return Values; } 1500 getSuperClasses()1501 ArrayRef<std::pair<Record *, SMRange>> getSuperClasses() const { 1502 return SuperClasses; 1503 } 1504 1505 /// Append the direct super classes of this record to Classes. 1506 void getDirectSuperClasses(SmallVectorImpl<Record *> &Classes) const; 1507 isTemplateArg(Init * Name)1508 bool isTemplateArg(Init *Name) const { 1509 for (Init *TA : TemplateArgs) 1510 if (TA == Name) return true; 1511 return false; 1512 } 1513 getValue(const Init * Name)1514 const RecordVal *getValue(const Init *Name) const { 1515 for (const RecordVal &Val : Values) 1516 if (Val.Name == Name) return &Val; 1517 return nullptr; 1518 } 1519 getValue(StringRef Name)1520 const RecordVal *getValue(StringRef Name) const { 1521 return getValue(StringInit::get(Name)); 1522 } 1523 getValue(const Init * Name)1524 RecordVal *getValue(const Init *Name) { 1525 return const_cast<RecordVal *>(static_cast<const Record *>(this)->getValue(Name)); 1526 } 1527 getValue(StringRef Name)1528 RecordVal *getValue(StringRef Name) { 1529 return const_cast<RecordVal *>(static_cast<const Record *>(this)->getValue(Name)); 1530 } 1531 addTemplateArg(Init * Name)1532 void addTemplateArg(Init *Name) { 1533 assert(!isTemplateArg(Name) && "Template arg already defined!"); 1534 TemplateArgs.push_back(Name); 1535 } 1536 addValue(const RecordVal & RV)1537 void addValue(const RecordVal &RV) { 1538 assert(getValue(RV.getNameInit()) == nullptr && "Value already added!"); 1539 Values.push_back(RV); 1540 } 1541 removeValue(Init * Name)1542 void removeValue(Init *Name) { 1543 for (unsigned i = 0, e = Values.size(); i != e; ++i) 1544 if (Values[i].getNameInit() == Name) { 1545 Values.erase(Values.begin()+i); 1546 return; 1547 } 1548 llvm_unreachable("Cannot remove an entry that does not exist!"); 1549 } 1550 removeValue(StringRef Name)1551 void removeValue(StringRef Name) { 1552 removeValue(StringInit::get(Name)); 1553 } 1554 isSubClassOf(const Record * R)1555 bool isSubClassOf(const Record *R) const { 1556 for (const auto &SCPair : SuperClasses) 1557 if (SCPair.first == R) 1558 return true; 1559 return false; 1560 } 1561 isSubClassOf(StringRef Name)1562 bool isSubClassOf(StringRef Name) const { 1563 for (const auto &SCPair : SuperClasses) { 1564 if (const auto *SI = dyn_cast<StringInit>(SCPair.first->getNameInit())) { 1565 if (SI->getValue() == Name) 1566 return true; 1567 } else if (SCPair.first->getNameInitAsString() == Name) { 1568 return true; 1569 } 1570 } 1571 return false; 1572 } 1573 addSuperClass(Record * R,SMRange Range)1574 void addSuperClass(Record *R, SMRange Range) { 1575 assert(!TheInit && "changing type of record after it has been referenced"); 1576 assert(!isSubClassOf(R) && "Already subclassing record!"); 1577 SuperClasses.push_back(std::make_pair(R, Range)); 1578 } 1579 1580 /// If there are any field references that refer to fields 1581 /// that have been filled in, we can propagate the values now. 1582 /// 1583 /// This is a final resolve: any error messages, e.g. due to undefined 1584 /// !cast references, are generated now. 1585 void resolveReferences(); 1586 1587 /// Apply the resolver to the name of the record as well as to the 1588 /// initializers of all fields of the record except SkipVal. 1589 /// 1590 /// The resolver should not resolve any of the fields itself, to avoid 1591 /// recursion / infinite loops. 1592 void resolveReferences(Resolver &R, const RecordVal *SkipVal = nullptr); 1593 1594 /// If anything in this record refers to RV, replace the 1595 /// reference to RV with the RHS of RV. If RV is null, we resolve all 1596 /// possible references. 1597 void resolveReferencesTo(const RecordVal *RV); 1598 getRecords()1599 RecordKeeper &getRecords() const { 1600 return TrackedRecords; 1601 } 1602 isAnonymous()1603 bool isAnonymous() const { 1604 return IsAnonymous; 1605 } 1606 1607 void print(raw_ostream &OS) const; 1608 void dump() const; 1609 1610 //===--------------------------------------------------------------------===// 1611 // High-level methods useful to tablegen back-ends 1612 // 1613 1614 /// Return the initializer for a value with the specified name, 1615 /// or throw an exception if the field does not exist. 1616 Init *getValueInit(StringRef FieldName) const; 1617 1618 /// Return true if the named field is unset. isValueUnset(StringRef FieldName)1619 bool isValueUnset(StringRef FieldName) const { 1620 return isa<UnsetInit>(getValueInit(FieldName)); 1621 } 1622 1623 /// This method looks up the specified field and returns 1624 /// its value as a string, throwing an exception if the field does not exist 1625 /// or if the value is not a string. 1626 StringRef getValueAsString(StringRef FieldName) const; 1627 1628 /// This method looks up the specified field and returns 1629 /// its value as a BitsInit, throwing an exception if the field does not exist 1630 /// or if the value is not the right type. 1631 BitsInit *getValueAsBitsInit(StringRef FieldName) const; 1632 1633 /// This method looks up the specified field and returns 1634 /// its value as a ListInit, throwing an exception if the field does not exist 1635 /// or if the value is not the right type. 1636 ListInit *getValueAsListInit(StringRef FieldName) const; 1637 1638 /// This method looks up the specified field and 1639 /// returns its value as a vector of records, throwing an exception if the 1640 /// field does not exist or if the value is not the right type. 1641 std::vector<Record*> getValueAsListOfDefs(StringRef FieldName) const; 1642 1643 /// This method looks up the specified field and 1644 /// returns its value as a vector of integers, throwing an exception if the 1645 /// field does not exist or if the value is not the right type. 1646 std::vector<int64_t> getValueAsListOfInts(StringRef FieldName) const; 1647 1648 /// This method looks up the specified field and 1649 /// returns its value as a vector of strings, throwing an exception if the 1650 /// field does not exist or if the value is not the right type. 1651 std::vector<StringRef> getValueAsListOfStrings(StringRef FieldName) const; 1652 1653 /// This method looks up the specified field and returns its 1654 /// value as a Record, throwing an exception if the field does not exist or if 1655 /// the value is not the right type. 1656 Record *getValueAsDef(StringRef FieldName) const; 1657 1658 /// This method looks up the specified field and returns its 1659 /// value as a bit, throwing an exception if the field does not exist or if 1660 /// the value is not the right type. 1661 bool getValueAsBit(StringRef FieldName) const; 1662 1663 /// This method looks up the specified field and 1664 /// returns its value as a bit. If the field is unset, sets Unset to true and 1665 /// returns false. 1666 bool getValueAsBitOrUnset(StringRef FieldName, bool &Unset) const; 1667 1668 /// This method looks up the specified field and returns its 1669 /// value as an int64_t, throwing an exception if the field does not exist or 1670 /// if the value is not the right type. 1671 int64_t getValueAsInt(StringRef FieldName) const; 1672 1673 /// This method looks up the specified field and returns its 1674 /// value as an Dag, throwing an exception if the field does not exist or if 1675 /// the value is not the right type. 1676 DagInit *getValueAsDag(StringRef FieldName) const; 1677 }; 1678 1679 raw_ostream &operator<<(raw_ostream &OS, const Record &R); 1680 1681 class RecordKeeper { 1682 friend class RecordRecTy; 1683 using RecordMap = std::map<std::string, std::unique_ptr<Record>>; 1684 RecordMap Classes, Defs; 1685 FoldingSet<RecordRecTy> RecordTypePool; 1686 std::map<std::string, Init *> ExtraGlobals; 1687 unsigned AnonCounter = 0; 1688 1689 public: getClasses()1690 const RecordMap &getClasses() const { return Classes; } getDefs()1691 const RecordMap &getDefs() const { return Defs; } 1692 getClass(StringRef Name)1693 Record *getClass(StringRef Name) const { 1694 auto I = Classes.find(Name); 1695 return I == Classes.end() ? nullptr : I->second.get(); 1696 } 1697 getDef(StringRef Name)1698 Record *getDef(StringRef Name) const { 1699 auto I = Defs.find(Name); 1700 return I == Defs.end() ? nullptr : I->second.get(); 1701 } 1702 getGlobal(StringRef Name)1703 Init *getGlobal(StringRef Name) const { 1704 if (Record *R = getDef(Name)) 1705 return R->getDefInit(); 1706 auto It = ExtraGlobals.find(Name); 1707 return It == ExtraGlobals.end() ? nullptr : It->second; 1708 } 1709 addClass(std::unique_ptr<Record> R)1710 void addClass(std::unique_ptr<Record> R) { 1711 bool Ins = Classes.insert(std::make_pair(R->getName(), 1712 std::move(R))).second; 1713 (void)Ins; 1714 assert(Ins && "Class already exists"); 1715 } 1716 addDef(std::unique_ptr<Record> R)1717 void addDef(std::unique_ptr<Record> R) { 1718 bool Ins = Defs.insert(std::make_pair(R->getName(), 1719 std::move(R))).second; 1720 (void)Ins; 1721 assert(Ins && "Record already exists"); 1722 } 1723 addExtraGlobal(StringRef Name,Init * I)1724 void addExtraGlobal(StringRef Name, Init *I) { 1725 bool Ins = ExtraGlobals.insert(std::make_pair(Name, I)).second; 1726 (void)Ins; 1727 assert(!getDef(Name)); 1728 assert(Ins && "Global already exists"); 1729 } 1730 1731 Init *getNewAnonymousName(); 1732 1733 //===--------------------------------------------------------------------===// 1734 // High-level helper methods, useful for tablegen backends... 1735 1736 /// This method returns all concrete definitions 1737 /// that derive from the specified class name. A class with the specified 1738 /// name must exist. 1739 std::vector<Record *> getAllDerivedDefinitions(StringRef ClassName) const; 1740 1741 void dump() const; 1742 }; 1743 1744 /// Sorting predicate to sort record pointers by name. 1745 struct LessRecord { operatorLessRecord1746 bool operator()(const Record *Rec1, const Record *Rec2) const { 1747 return StringRef(Rec1->getName()).compare_numeric(Rec2->getName()) < 0; 1748 } 1749 }; 1750 1751 /// Sorting predicate to sort record pointers by their 1752 /// unique ID. If you just need a deterministic order, use this, since it 1753 /// just compares two `unsigned`; the other sorting predicates require 1754 /// string manipulation. 1755 struct LessRecordByID { operatorLessRecordByID1756 bool operator()(const Record *LHS, const Record *RHS) const { 1757 return LHS->getID() < RHS->getID(); 1758 } 1759 }; 1760 1761 /// Sorting predicate to sort record pointers by their 1762 /// name field. 1763 struct LessRecordFieldName { operatorLessRecordFieldName1764 bool operator()(const Record *Rec1, const Record *Rec2) const { 1765 return Rec1->getValueAsString("Name") < Rec2->getValueAsString("Name"); 1766 } 1767 }; 1768 1769 struct LessRecordRegister { ascii_isdigitLessRecordRegister1770 static bool ascii_isdigit(char x) { return x >= '0' && x <= '9'; } 1771 1772 struct RecordParts { 1773 SmallVector<std::pair< bool, StringRef>, 4> Parts; 1774 RecordPartsLessRecordRegister::RecordParts1775 RecordParts(StringRef Rec) { 1776 if (Rec.empty()) 1777 return; 1778 1779 size_t Len = 0; 1780 const char *Start = Rec.data(); 1781 const char *Curr = Start; 1782 bool isDigitPart = ascii_isdigit(Curr[0]); 1783 for (size_t I = 0, E = Rec.size(); I != E; ++I, ++Len) { 1784 bool isDigit = ascii_isdigit(Curr[I]); 1785 if (isDigit != isDigitPart) { 1786 Parts.push_back(std::make_pair(isDigitPart, StringRef(Start, Len))); 1787 Len = 0; 1788 Start = &Curr[I]; 1789 isDigitPart = ascii_isdigit(Curr[I]); 1790 } 1791 } 1792 // Push the last part. 1793 Parts.push_back(std::make_pair(isDigitPart, StringRef(Start, Len))); 1794 } 1795 sizeLessRecordRegister::RecordParts1796 size_t size() { return Parts.size(); } 1797 getPartLessRecordRegister::RecordParts1798 std::pair<bool, StringRef> getPart(size_t i) { 1799 assert (i < Parts.size() && "Invalid idx!"); 1800 return Parts[i]; 1801 } 1802 }; 1803 operatorLessRecordRegister1804 bool operator()(const Record *Rec1, const Record *Rec2) const { 1805 RecordParts LHSParts(StringRef(Rec1->getName())); 1806 RecordParts RHSParts(StringRef(Rec2->getName())); 1807 1808 size_t LHSNumParts = LHSParts.size(); 1809 size_t RHSNumParts = RHSParts.size(); 1810 assert (LHSNumParts && RHSNumParts && "Expected at least one part!"); 1811 1812 if (LHSNumParts != RHSNumParts) 1813 return LHSNumParts < RHSNumParts; 1814 1815 // We expect the registers to be of the form [_a-zA-Z]+([0-9]*[_a-zA-Z]*)*. 1816 for (size_t I = 0, E = LHSNumParts; I < E; I+=2) { 1817 std::pair<bool, StringRef> LHSPart = LHSParts.getPart(I); 1818 std::pair<bool, StringRef> RHSPart = RHSParts.getPart(I); 1819 // Expect even part to always be alpha. 1820 assert (LHSPart.first == false && RHSPart.first == false && 1821 "Expected both parts to be alpha."); 1822 if (int Res = LHSPart.second.compare(RHSPart.second)) 1823 return Res < 0; 1824 } 1825 for (size_t I = 1, E = LHSNumParts; I < E; I+=2) { 1826 std::pair<bool, StringRef> LHSPart = LHSParts.getPart(I); 1827 std::pair<bool, StringRef> RHSPart = RHSParts.getPart(I); 1828 // Expect odd part to always be numeric. 1829 assert (LHSPart.first == true && RHSPart.first == true && 1830 "Expected both parts to be numeric."); 1831 if (LHSPart.second.size() != RHSPart.second.size()) 1832 return LHSPart.second.size() < RHSPart.second.size(); 1833 1834 unsigned LHSVal, RHSVal; 1835 1836 bool LHSFailed = LHSPart.second.getAsInteger(10, LHSVal); (void)LHSFailed; 1837 assert(!LHSFailed && "Unable to convert LHS to integer."); 1838 bool RHSFailed = RHSPart.second.getAsInteger(10, RHSVal); (void)RHSFailed; 1839 assert(!RHSFailed && "Unable to convert RHS to integer."); 1840 1841 if (LHSVal != RHSVal) 1842 return LHSVal < RHSVal; 1843 } 1844 return LHSNumParts < RHSNumParts; 1845 } 1846 }; 1847 1848 raw_ostream &operator<<(raw_ostream &OS, const RecordKeeper &RK); 1849 1850 //===----------------------------------------------------------------------===// 1851 // Resolvers 1852 //===----------------------------------------------------------------------===// 1853 1854 /// Interface for looking up the initializer for a variable name, used by 1855 /// Init::resolveReferences. 1856 class Resolver { 1857 Record *CurRec; 1858 bool IsFinal = false; 1859 1860 public: Resolver(Record * CurRec)1861 explicit Resolver(Record *CurRec) : CurRec(CurRec) {} ~Resolver()1862 virtual ~Resolver() {} 1863 getCurrentRecord()1864 Record *getCurrentRecord() const { return CurRec; } 1865 1866 /// Return the initializer for the given variable name (should normally be a 1867 /// StringInit), or nullptr if the name could not be resolved. 1868 virtual Init *resolve(Init *VarName) = 0; 1869 1870 // Whether bits in a BitsInit should stay unresolved if resolving them would 1871 // result in a ? (UnsetInit). This behavior is used to represent instruction 1872 // encodings by keeping references to unset variables within a record. keepUnsetBits()1873 virtual bool keepUnsetBits() const { return false; } 1874 1875 // Whether this is the final resolve step before adding a record to the 1876 // RecordKeeper. Error reporting during resolve and related constant folding 1877 // should only happen when this is true. isFinal()1878 bool isFinal() const { return IsFinal; } 1879 setFinal(bool Final)1880 void setFinal(bool Final) { IsFinal = Final; } 1881 }; 1882 1883 /// Resolve arbitrary mappings. 1884 class MapResolver final : public Resolver { 1885 struct MappedValue { 1886 Init *V; 1887 bool Resolved; 1888 MappedValueMappedValue1889 MappedValue() : V(nullptr), Resolved(false) {} MappedValueMappedValue1890 MappedValue(Init *V, bool Resolved) : V(V), Resolved(Resolved) {} 1891 }; 1892 1893 DenseMap<Init *, MappedValue> Map; 1894 1895 public: Resolver(CurRec)1896 explicit MapResolver(Record *CurRec = nullptr) : Resolver(CurRec) {} 1897 set(Init * Key,Init * Value)1898 void set(Init *Key, Init *Value) { Map[Key] = {Value, false}; } 1899 1900 Init *resolve(Init *VarName) override; 1901 }; 1902 1903 /// Resolve all variables from a record except for unset variables. 1904 class RecordResolver final : public Resolver { 1905 DenseMap<Init *, Init *> Cache; 1906 SmallVector<Init *, 4> Stack; 1907 1908 public: RecordResolver(Record & R)1909 explicit RecordResolver(Record &R) : Resolver(&R) {} 1910 1911 Init *resolve(Init *VarName) override; 1912 keepUnsetBits()1913 bool keepUnsetBits() const override { return true; } 1914 }; 1915 1916 /// Resolve all references to a specific RecordVal. 1917 // 1918 // TODO: This is used for resolving references to template arguments, in a 1919 // rather inefficient way. Change those uses to resolve all template 1920 // arguments simultaneously and get rid of this class. 1921 class RecordValResolver final : public Resolver { 1922 const RecordVal *RV; 1923 1924 public: RecordValResolver(Record & R,const RecordVal * RV)1925 explicit RecordValResolver(Record &R, const RecordVal *RV) 1926 : Resolver(&R), RV(RV) {} 1927 resolve(Init * VarName)1928 Init *resolve(Init *VarName) override { 1929 if (VarName == RV->getNameInit()) 1930 return RV->getValue(); 1931 return nullptr; 1932 } 1933 }; 1934 1935 /// Delegate resolving to a sub-resolver, but shadow some variable names. 1936 class ShadowResolver final : public Resolver { 1937 Resolver &R; 1938 DenseSet<Init *> Shadowed; 1939 1940 public: ShadowResolver(Resolver & R)1941 explicit ShadowResolver(Resolver &R) 1942 : Resolver(R.getCurrentRecord()), R(R) { 1943 setFinal(R.isFinal()); 1944 } 1945 addShadow(Init * Key)1946 void addShadow(Init *Key) { Shadowed.insert(Key); } 1947 resolve(Init * VarName)1948 Init *resolve(Init *VarName) override { 1949 if (Shadowed.count(VarName)) 1950 return nullptr; 1951 return R.resolve(VarName); 1952 } 1953 }; 1954 1955 /// (Optionally) delegate resolving to a sub-resolver, and keep track whether 1956 /// there were unresolved references. 1957 class TrackUnresolvedResolver final : public Resolver { 1958 Resolver *R; 1959 bool FoundUnresolved = false; 1960 1961 public: 1962 explicit TrackUnresolvedResolver(Resolver *R = nullptr) 1963 : Resolver(R ? R->getCurrentRecord() : nullptr), R(R) {} 1964 foundUnresolved()1965 bool foundUnresolved() const { return FoundUnresolved; } 1966 1967 Init *resolve(Init *VarName) override; 1968 }; 1969 1970 /// Do not resolve anything, but keep track of whether a given variable was 1971 /// referenced. 1972 class HasReferenceResolver final : public Resolver { 1973 Init *VarNameToTrack; 1974 bool Found = false; 1975 1976 public: HasReferenceResolver(Init * VarNameToTrack)1977 explicit HasReferenceResolver(Init *VarNameToTrack) 1978 : Resolver(nullptr), VarNameToTrack(VarNameToTrack) {} 1979 found()1980 bool found() const { return Found; } 1981 1982 Init *resolve(Init *VarName) override; 1983 }; 1984 1985 void EmitJSON(RecordKeeper &RK, raw_ostream &OS); 1986 1987 } // end namespace llvm 1988 1989 #endif // LLVM_TABLEGEN_RECORD_H 1990