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, GETOP }; 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, SETOP }; 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 #ifndef NDEBUG 1267 if (!getType()) { 1268 llvm::errs() << "In Record = " << Rec->getAsString() 1269 << ", got FieldName = " << *FieldName 1270 << " with non-record type!\n"; 1271 llvm_unreachable("FieldInit with non-record type!"); 1272 } 1273 #endif 1274 } 1275 1276 public: 1277 FieldInit(const FieldInit &) = delete; 1278 FieldInit &operator=(const FieldInit &) = delete; 1279 classof(const Init * I)1280 static bool classof(const Init *I) { 1281 return I->getKind() == IK_FieldInit; 1282 } 1283 1284 static FieldInit *get(Init *R, StringInit *FN); 1285 getRecord()1286 Init *getRecord() const { return Rec; } getFieldName()1287 StringInit *getFieldName() const { return FieldName; } 1288 1289 Init *getBit(unsigned Bit) const override; 1290 1291 Init *resolveReferences(Resolver &R) const override; 1292 Init *Fold(Record *CurRec) const; 1293 getAsString()1294 std::string getAsString() const override { 1295 return Rec->getAsString() + "." + FieldName->getValue().str(); 1296 } 1297 }; 1298 1299 /// (v a, b) - Represent a DAG tree value. DAG inits are required 1300 /// to have at least one value then a (possibly empty) list of arguments. Each 1301 /// argument can have a name associated with it. 1302 class DagInit final : public TypedInit, public FoldingSetNode, 1303 public TrailingObjects<DagInit, Init *, StringInit *> { 1304 friend TrailingObjects; 1305 1306 Init *Val; 1307 StringInit *ValName; 1308 unsigned NumArgs; 1309 unsigned NumArgNames; 1310 DagInit(Init * V,StringInit * VN,unsigned NumArgs,unsigned NumArgNames)1311 DagInit(Init *V, StringInit *VN, unsigned NumArgs, unsigned NumArgNames) 1312 : TypedInit(IK_DagInit, DagRecTy::get()), Val(V), ValName(VN), 1313 NumArgs(NumArgs), NumArgNames(NumArgNames) {} 1314 numTrailingObjects(OverloadToken<Init * >)1315 size_t numTrailingObjects(OverloadToken<Init *>) const { return NumArgs; } 1316 1317 public: 1318 DagInit(const DagInit &) = delete; 1319 DagInit &operator=(const DagInit &) = delete; 1320 classof(const Init * I)1321 static bool classof(const Init *I) { 1322 return I->getKind() == IK_DagInit; 1323 } 1324 1325 static DagInit *get(Init *V, StringInit *VN, ArrayRef<Init *> ArgRange, 1326 ArrayRef<StringInit*> NameRange); 1327 static DagInit *get(Init *V, StringInit *VN, 1328 ArrayRef<std::pair<Init*, StringInit*>> Args); 1329 1330 void Profile(FoldingSetNodeID &ID) const; 1331 getOperator()1332 Init *getOperator() const { return Val; } 1333 Record *getOperatorAsDef(ArrayRef<SMLoc> Loc) const; 1334 getName()1335 StringInit *getName() const { return ValName; } 1336 getNameStr()1337 StringRef getNameStr() const { 1338 return ValName ? ValName->getValue() : StringRef(); 1339 } 1340 getNumArgs()1341 unsigned getNumArgs() const { return NumArgs; } 1342 getArg(unsigned Num)1343 Init *getArg(unsigned Num) const { 1344 assert(Num < NumArgs && "Arg number out of range!"); 1345 return getTrailingObjects<Init *>()[Num]; 1346 } 1347 getArgName(unsigned Num)1348 StringInit *getArgName(unsigned Num) const { 1349 assert(Num < NumArgNames && "Arg number out of range!"); 1350 return getTrailingObjects<StringInit *>()[Num]; 1351 } 1352 getArgNameStr(unsigned Num)1353 StringRef getArgNameStr(unsigned Num) const { 1354 StringInit *Init = getArgName(Num); 1355 return Init ? Init->getValue() : StringRef(); 1356 } 1357 getArgs()1358 ArrayRef<Init *> getArgs() const { 1359 return makeArrayRef(getTrailingObjects<Init *>(), NumArgs); 1360 } 1361 getArgNames()1362 ArrayRef<StringInit *> getArgNames() const { 1363 return makeArrayRef(getTrailingObjects<StringInit *>(), NumArgNames); 1364 } 1365 1366 Init *resolveReferences(Resolver &R) const override; 1367 1368 bool isConcrete() const override; 1369 std::string getAsString() const override; 1370 1371 using const_arg_iterator = SmallVectorImpl<Init*>::const_iterator; 1372 using const_name_iterator = SmallVectorImpl<StringInit*>::const_iterator; 1373 arg_begin()1374 inline const_arg_iterator arg_begin() const { return getArgs().begin(); } arg_end()1375 inline const_arg_iterator arg_end () const { return getArgs().end(); } 1376 arg_size()1377 inline size_t arg_size () const { return NumArgs; } arg_empty()1378 inline bool arg_empty() const { return NumArgs == 0; } 1379 name_begin()1380 inline const_name_iterator name_begin() const { return getArgNames().begin();} name_end()1381 inline const_name_iterator name_end () const { return getArgNames().end(); } 1382 name_size()1383 inline size_t name_size () const { return NumArgNames; } name_empty()1384 inline bool name_empty() const { return NumArgNames == 0; } 1385 getBit(unsigned Bit)1386 Init *getBit(unsigned Bit) const override { 1387 llvm_unreachable("Illegal bit reference off dag"); 1388 } 1389 }; 1390 1391 //===----------------------------------------------------------------------===// 1392 // High-Level Classes 1393 //===----------------------------------------------------------------------===// 1394 1395 class RecordVal { 1396 friend class Record; 1397 1398 Init *Name; 1399 PointerIntPair<RecTy *, 1, bool> TyAndPrefix; 1400 Init *Value; 1401 1402 public: 1403 RecordVal(Init *N, RecTy *T, bool P); 1404 1405 StringRef getName() const; getNameInit()1406 Init *getNameInit() const { return Name; } 1407 getNameInitAsString()1408 std::string getNameInitAsString() const { 1409 return getNameInit()->getAsUnquotedString(); 1410 } 1411 getPrefix()1412 bool getPrefix() const { return TyAndPrefix.getInt(); } getType()1413 RecTy *getType() const { return TyAndPrefix.getPointer(); } getValue()1414 Init *getValue() const { return Value; } 1415 1416 bool setValue(Init *V); 1417 1418 void dump() const; 1419 void print(raw_ostream &OS, bool PrintSem = true) const; 1420 }; 1421 1422 inline raw_ostream &operator<<(raw_ostream &OS, const RecordVal &RV) { 1423 RV.print(OS << " "); 1424 return OS; 1425 } 1426 1427 class Record { 1428 static unsigned LastID; 1429 1430 Init *Name; 1431 // Location where record was instantiated, followed by the location of 1432 // multiclass prototypes used. 1433 SmallVector<SMLoc, 4> Locs; 1434 SmallVector<Init *, 0> TemplateArgs; 1435 SmallVector<RecordVal, 0> Values; 1436 1437 // All superclasses in the inheritance forest in reverse preorder (yes, it 1438 // must be a forest; diamond-shaped inheritance is not allowed). 1439 SmallVector<std::pair<Record *, SMRange>, 0> SuperClasses; 1440 1441 // Tracks Record instances. Not owned by Record. 1442 RecordKeeper &TrackedRecords; 1443 1444 DefInit *TheInit = nullptr; 1445 1446 // Unique record ID. 1447 unsigned ID; 1448 1449 bool IsAnonymous; 1450 bool IsClass; 1451 1452 void checkName(); 1453 1454 public: 1455 // Constructs a record. 1456 explicit Record(Init *N, ArrayRef<SMLoc> locs, RecordKeeper &records, 1457 bool Anonymous = false, bool Class = false) Name(N)1458 : Name(N), Locs(locs.begin(), locs.end()), TrackedRecords(records), 1459 ID(LastID++), IsAnonymous(Anonymous), IsClass(Class) { 1460 checkName(); 1461 } 1462 1463 explicit Record(StringRef N, ArrayRef<SMLoc> locs, RecordKeeper &records, 1464 bool Class = false) Record(StringInit::get (N),locs,records,false,Class)1465 : Record(StringInit::get(N), locs, records, false, Class) {} 1466 1467 // When copy-constructing a Record, we must still guarantee a globally unique 1468 // ID number. Don't copy TheInit either since it's owned by the original 1469 // record. All other fields can be copied normally. Record(const Record & O)1470 Record(const Record &O) 1471 : Name(O.Name), Locs(O.Locs), TemplateArgs(O.TemplateArgs), 1472 Values(O.Values), SuperClasses(O.SuperClasses), 1473 TrackedRecords(O.TrackedRecords), ID(LastID++), 1474 IsAnonymous(O.IsAnonymous), IsClass(O.IsClass) { } 1475 getNewUID()1476 static unsigned getNewUID() { return LastID++; } 1477 getID()1478 unsigned getID() const { return ID; } 1479 getName()1480 StringRef getName() const { return cast<StringInit>(Name)->getValue(); } 1481 getNameInit()1482 Init *getNameInit() const { 1483 return Name; 1484 } 1485 getNameInitAsString()1486 const std::string getNameInitAsString() const { 1487 return getNameInit()->getAsUnquotedString(); 1488 } 1489 1490 void setName(Init *Name); // Also updates RecordKeeper. 1491 getLoc()1492 ArrayRef<SMLoc> getLoc() const { return Locs; } appendLoc(SMLoc Loc)1493 void appendLoc(SMLoc Loc) { Locs.push_back(Loc); } 1494 1495 // Make the type that this record should have based on its superclasses. 1496 RecordRecTy *getType(); 1497 1498 /// get the corresponding DefInit. 1499 DefInit *getDefInit(); 1500 isClass()1501 bool isClass() const { return IsClass; } 1502 getTemplateArgs()1503 ArrayRef<Init *> getTemplateArgs() const { 1504 return TemplateArgs; 1505 } 1506 getValues()1507 ArrayRef<RecordVal> getValues() const { return Values; } 1508 getSuperClasses()1509 ArrayRef<std::pair<Record *, SMRange>> getSuperClasses() const { 1510 return SuperClasses; 1511 } 1512 1513 /// Append the direct super classes of this record to Classes. 1514 void getDirectSuperClasses(SmallVectorImpl<Record *> &Classes) const; 1515 isTemplateArg(Init * Name)1516 bool isTemplateArg(Init *Name) const { 1517 for (Init *TA : TemplateArgs) 1518 if (TA == Name) return true; 1519 return false; 1520 } 1521 getValue(const Init * Name)1522 const RecordVal *getValue(const Init *Name) const { 1523 for (const RecordVal &Val : Values) 1524 if (Val.Name == Name) return &Val; 1525 return nullptr; 1526 } 1527 getValue(StringRef Name)1528 const RecordVal *getValue(StringRef Name) const { 1529 return getValue(StringInit::get(Name)); 1530 } 1531 getValue(const Init * Name)1532 RecordVal *getValue(const Init *Name) { 1533 return const_cast<RecordVal *>(static_cast<const Record *>(this)->getValue(Name)); 1534 } 1535 getValue(StringRef Name)1536 RecordVal *getValue(StringRef Name) { 1537 return const_cast<RecordVal *>(static_cast<const Record *>(this)->getValue(Name)); 1538 } 1539 addTemplateArg(Init * Name)1540 void addTemplateArg(Init *Name) { 1541 assert(!isTemplateArg(Name) && "Template arg already defined!"); 1542 TemplateArgs.push_back(Name); 1543 } 1544 addValue(const RecordVal & RV)1545 void addValue(const RecordVal &RV) { 1546 assert(getValue(RV.getNameInit()) == nullptr && "Value already added!"); 1547 Values.push_back(RV); 1548 } 1549 removeValue(Init * Name)1550 void removeValue(Init *Name) { 1551 for (unsigned i = 0, e = Values.size(); i != e; ++i) 1552 if (Values[i].getNameInit() == Name) { 1553 Values.erase(Values.begin()+i); 1554 return; 1555 } 1556 llvm_unreachable("Cannot remove an entry that does not exist!"); 1557 } 1558 removeValue(StringRef Name)1559 void removeValue(StringRef Name) { 1560 removeValue(StringInit::get(Name)); 1561 } 1562 isSubClassOf(const Record * R)1563 bool isSubClassOf(const Record *R) const { 1564 for (const auto &SCPair : SuperClasses) 1565 if (SCPair.first == R) 1566 return true; 1567 return false; 1568 } 1569 isSubClassOf(StringRef Name)1570 bool isSubClassOf(StringRef Name) const { 1571 for (const auto &SCPair : SuperClasses) { 1572 if (const auto *SI = dyn_cast<StringInit>(SCPair.first->getNameInit())) { 1573 if (SI->getValue() == Name) 1574 return true; 1575 } else if (SCPair.first->getNameInitAsString() == Name) { 1576 return true; 1577 } 1578 } 1579 return false; 1580 } 1581 addSuperClass(Record * R,SMRange Range)1582 void addSuperClass(Record *R, SMRange Range) { 1583 assert(!TheInit && "changing type of record after it has been referenced"); 1584 assert(!isSubClassOf(R) && "Already subclassing record!"); 1585 SuperClasses.push_back(std::make_pair(R, Range)); 1586 } 1587 1588 /// If there are any field references that refer to fields 1589 /// that have been filled in, we can propagate the values now. 1590 /// 1591 /// This is a final resolve: any error messages, e.g. due to undefined 1592 /// !cast references, are generated now. 1593 void resolveReferences(); 1594 1595 /// Apply the resolver to the name of the record as well as to the 1596 /// initializers of all fields of the record except SkipVal. 1597 /// 1598 /// The resolver should not resolve any of the fields itself, to avoid 1599 /// recursion / infinite loops. 1600 void resolveReferences(Resolver &R, const RecordVal *SkipVal = nullptr); 1601 1602 /// If anything in this record refers to RV, replace the 1603 /// reference to RV with the RHS of RV. If RV is null, we resolve all 1604 /// possible references. 1605 void resolveReferencesTo(const RecordVal *RV); 1606 getRecords()1607 RecordKeeper &getRecords() const { 1608 return TrackedRecords; 1609 } 1610 isAnonymous()1611 bool isAnonymous() const { 1612 return IsAnonymous; 1613 } 1614 1615 void print(raw_ostream &OS) const; 1616 void dump() const; 1617 1618 //===--------------------------------------------------------------------===// 1619 // High-level methods useful to tablegen back-ends 1620 // 1621 1622 /// Return the initializer for a value with the specified name, 1623 /// or throw an exception if the field does not exist. 1624 Init *getValueInit(StringRef FieldName) const; 1625 1626 /// Return true if the named field is unset. isValueUnset(StringRef FieldName)1627 bool isValueUnset(StringRef FieldName) const { 1628 return isa<UnsetInit>(getValueInit(FieldName)); 1629 } 1630 1631 /// This method looks up the specified field and returns 1632 /// its value as a string, throwing an exception if the field does not exist 1633 /// or if the value is not a string. 1634 StringRef getValueAsString(StringRef FieldName) const; 1635 1636 /// This method looks up the specified field and returns 1637 /// its value as a BitsInit, throwing an exception if the field does not exist 1638 /// or if the value is not the right type. 1639 BitsInit *getValueAsBitsInit(StringRef FieldName) const; 1640 1641 /// This method looks up the specified field and returns 1642 /// its value as a ListInit, throwing an exception if the field does not exist 1643 /// or if the value is not the right type. 1644 ListInit *getValueAsListInit(StringRef FieldName) const; 1645 1646 /// This method looks up the specified field and 1647 /// returns its value as a vector of records, throwing an exception if the 1648 /// field does not exist or if the value is not the right type. 1649 std::vector<Record*> getValueAsListOfDefs(StringRef FieldName) const; 1650 1651 /// This method looks up the specified field and 1652 /// returns its value as a vector of integers, throwing an exception if the 1653 /// field does not exist or if the value is not the right type. 1654 std::vector<int64_t> getValueAsListOfInts(StringRef FieldName) const; 1655 1656 /// This method looks up the specified field and 1657 /// returns its value as a vector of strings, throwing an exception if the 1658 /// field does not exist or if the value is not the right type. 1659 std::vector<StringRef> getValueAsListOfStrings(StringRef FieldName) const; 1660 1661 /// This method looks up the specified field and returns its 1662 /// value as a Record, throwing an exception if the field does not exist or if 1663 /// the value is not the right type. 1664 Record *getValueAsDef(StringRef FieldName) const; 1665 1666 /// This method looks up the specified field and returns its value as a 1667 /// Record, returning null if the field exists but is "uninitialized" 1668 /// (i.e. set to `?`), and throwing an exception if the field does not 1669 /// exist or if its value is not the right type. 1670 Record *getValueAsOptionalDef(StringRef FieldName) const; 1671 1672 /// This method looks up the specified field and returns its 1673 /// value as a bit, throwing an exception if the field does not exist or if 1674 /// the value is not the right type. 1675 bool getValueAsBit(StringRef FieldName) const; 1676 1677 /// This method looks up the specified field and 1678 /// returns its value as a bit. If the field is unset, sets Unset to true and 1679 /// returns false. 1680 bool getValueAsBitOrUnset(StringRef FieldName, bool &Unset) const; 1681 1682 /// This method looks up the specified field and returns its 1683 /// value as an int64_t, throwing an exception if the field does not exist or 1684 /// if the value is not the right type. 1685 int64_t getValueAsInt(StringRef FieldName) const; 1686 1687 /// This method looks up the specified field and returns its 1688 /// value as an Dag, throwing an exception if the field does not exist or if 1689 /// the value is not the right type. 1690 DagInit *getValueAsDag(StringRef FieldName) const; 1691 }; 1692 1693 raw_ostream &operator<<(raw_ostream &OS, const Record &R); 1694 1695 class RecordKeeper { 1696 friend class RecordRecTy; 1697 using RecordMap = std::map<std::string, std::unique_ptr<Record>, std::less<>>; 1698 RecordMap Classes, Defs; 1699 FoldingSet<RecordRecTy> RecordTypePool; 1700 std::map<std::string, Init *, std::less<>> ExtraGlobals; 1701 unsigned AnonCounter = 0; 1702 1703 public: getClasses()1704 const RecordMap &getClasses() const { return Classes; } getDefs()1705 const RecordMap &getDefs() const { return Defs; } 1706 getClass(StringRef Name)1707 Record *getClass(StringRef Name) const { 1708 auto I = Classes.find(Name); 1709 return I == Classes.end() ? nullptr : I->second.get(); 1710 } 1711 getDef(StringRef Name)1712 Record *getDef(StringRef Name) const { 1713 auto I = Defs.find(Name); 1714 return I == Defs.end() ? nullptr : I->second.get(); 1715 } 1716 getGlobal(StringRef Name)1717 Init *getGlobal(StringRef Name) const { 1718 if (Record *R = getDef(Name)) 1719 return R->getDefInit(); 1720 auto It = ExtraGlobals.find(Name); 1721 return It == ExtraGlobals.end() ? nullptr : It->second; 1722 } 1723 addClass(std::unique_ptr<Record> R)1724 void addClass(std::unique_ptr<Record> R) { 1725 bool Ins = Classes.insert(std::make_pair(R->getName(), 1726 std::move(R))).second; 1727 (void)Ins; 1728 assert(Ins && "Class already exists"); 1729 } 1730 addDef(std::unique_ptr<Record> R)1731 void addDef(std::unique_ptr<Record> R) { 1732 bool Ins = Defs.insert(std::make_pair(R->getName(), 1733 std::move(R))).second; 1734 (void)Ins; 1735 assert(Ins && "Record already exists"); 1736 } 1737 addExtraGlobal(StringRef Name,Init * I)1738 void addExtraGlobal(StringRef Name, Init *I) { 1739 bool Ins = ExtraGlobals.insert(std::make_pair(Name, I)).second; 1740 (void)Ins; 1741 assert(!getDef(Name)); 1742 assert(Ins && "Global already exists"); 1743 } 1744 1745 Init *getNewAnonymousName(); 1746 1747 //===--------------------------------------------------------------------===// 1748 // High-level helper methods, useful for tablegen backends... 1749 1750 /// This method returns all concrete definitions 1751 /// that derive from the specified class name. A class with the specified 1752 /// name must exist. 1753 std::vector<Record *> getAllDerivedDefinitions(StringRef ClassName) const; 1754 1755 void dump() const; 1756 }; 1757 1758 /// Sorting predicate to sort record pointers by name. 1759 struct LessRecord { operatorLessRecord1760 bool operator()(const Record *Rec1, const Record *Rec2) const { 1761 return StringRef(Rec1->getName()).compare_numeric(Rec2->getName()) < 0; 1762 } 1763 }; 1764 1765 /// Sorting predicate to sort record pointers by their 1766 /// unique ID. If you just need a deterministic order, use this, since it 1767 /// just compares two `unsigned`; the other sorting predicates require 1768 /// string manipulation. 1769 struct LessRecordByID { operatorLessRecordByID1770 bool operator()(const Record *LHS, const Record *RHS) const { 1771 return LHS->getID() < RHS->getID(); 1772 } 1773 }; 1774 1775 /// Sorting predicate to sort record pointers by their 1776 /// name field. 1777 struct LessRecordFieldName { operatorLessRecordFieldName1778 bool operator()(const Record *Rec1, const Record *Rec2) const { 1779 return Rec1->getValueAsString("Name") < Rec2->getValueAsString("Name"); 1780 } 1781 }; 1782 1783 struct LessRecordRegister { ascii_isdigitLessRecordRegister1784 static bool ascii_isdigit(char x) { return x >= '0' && x <= '9'; } 1785 1786 struct RecordParts { 1787 SmallVector<std::pair< bool, StringRef>, 4> Parts; 1788 RecordPartsLessRecordRegister::RecordParts1789 RecordParts(StringRef Rec) { 1790 if (Rec.empty()) 1791 return; 1792 1793 size_t Len = 0; 1794 const char *Start = Rec.data(); 1795 const char *Curr = Start; 1796 bool isDigitPart = ascii_isdigit(Curr[0]); 1797 for (size_t I = 0, E = Rec.size(); I != E; ++I, ++Len) { 1798 bool isDigit = ascii_isdigit(Curr[I]); 1799 if (isDigit != isDigitPart) { 1800 Parts.push_back(std::make_pair(isDigitPart, StringRef(Start, Len))); 1801 Len = 0; 1802 Start = &Curr[I]; 1803 isDigitPart = ascii_isdigit(Curr[I]); 1804 } 1805 } 1806 // Push the last part. 1807 Parts.push_back(std::make_pair(isDigitPart, StringRef(Start, Len))); 1808 } 1809 sizeLessRecordRegister::RecordParts1810 size_t size() { return Parts.size(); } 1811 getPartLessRecordRegister::RecordParts1812 std::pair<bool, StringRef> getPart(size_t i) { 1813 assert (i < Parts.size() && "Invalid idx!"); 1814 return Parts[i]; 1815 } 1816 }; 1817 operatorLessRecordRegister1818 bool operator()(const Record *Rec1, const Record *Rec2) const { 1819 RecordParts LHSParts(StringRef(Rec1->getName())); 1820 RecordParts RHSParts(StringRef(Rec2->getName())); 1821 1822 size_t LHSNumParts = LHSParts.size(); 1823 size_t RHSNumParts = RHSParts.size(); 1824 assert (LHSNumParts && RHSNumParts && "Expected at least one part!"); 1825 1826 if (LHSNumParts != RHSNumParts) 1827 return LHSNumParts < RHSNumParts; 1828 1829 // We expect the registers to be of the form [_a-zA-Z]+([0-9]*[_a-zA-Z]*)*. 1830 for (size_t I = 0, E = LHSNumParts; I < E; I+=2) { 1831 std::pair<bool, StringRef> LHSPart = LHSParts.getPart(I); 1832 std::pair<bool, StringRef> RHSPart = RHSParts.getPart(I); 1833 // Expect even part to always be alpha. 1834 assert (LHSPart.first == false && RHSPart.first == false && 1835 "Expected both parts to be alpha."); 1836 if (int Res = LHSPart.second.compare(RHSPart.second)) 1837 return Res < 0; 1838 } 1839 for (size_t I = 1, E = LHSNumParts; I < E; I+=2) { 1840 std::pair<bool, StringRef> LHSPart = LHSParts.getPart(I); 1841 std::pair<bool, StringRef> RHSPart = RHSParts.getPart(I); 1842 // Expect odd part to always be numeric. 1843 assert (LHSPart.first == true && RHSPart.first == true && 1844 "Expected both parts to be numeric."); 1845 if (LHSPart.second.size() != RHSPart.second.size()) 1846 return LHSPart.second.size() < RHSPart.second.size(); 1847 1848 unsigned LHSVal, RHSVal; 1849 1850 bool LHSFailed = LHSPart.second.getAsInteger(10, LHSVal); (void)LHSFailed; 1851 assert(!LHSFailed && "Unable to convert LHS to integer."); 1852 bool RHSFailed = RHSPart.second.getAsInteger(10, RHSVal); (void)RHSFailed; 1853 assert(!RHSFailed && "Unable to convert RHS to integer."); 1854 1855 if (LHSVal != RHSVal) 1856 return LHSVal < RHSVal; 1857 } 1858 return LHSNumParts < RHSNumParts; 1859 } 1860 }; 1861 1862 raw_ostream &operator<<(raw_ostream &OS, const RecordKeeper &RK); 1863 1864 //===----------------------------------------------------------------------===// 1865 // Resolvers 1866 //===----------------------------------------------------------------------===// 1867 1868 /// Interface for looking up the initializer for a variable name, used by 1869 /// Init::resolveReferences. 1870 class Resolver { 1871 Record *CurRec; 1872 bool IsFinal = false; 1873 1874 public: Resolver(Record * CurRec)1875 explicit Resolver(Record *CurRec) : CurRec(CurRec) {} ~Resolver()1876 virtual ~Resolver() {} 1877 getCurrentRecord()1878 Record *getCurrentRecord() const { return CurRec; } 1879 1880 /// Return the initializer for the given variable name (should normally be a 1881 /// StringInit), or nullptr if the name could not be resolved. 1882 virtual Init *resolve(Init *VarName) = 0; 1883 1884 // Whether bits in a BitsInit should stay unresolved if resolving them would 1885 // result in a ? (UnsetInit). This behavior is used to represent instruction 1886 // encodings by keeping references to unset variables within a record. keepUnsetBits()1887 virtual bool keepUnsetBits() const { return false; } 1888 1889 // Whether this is the final resolve step before adding a record to the 1890 // RecordKeeper. Error reporting during resolve and related constant folding 1891 // should only happen when this is true. isFinal()1892 bool isFinal() const { return IsFinal; } 1893 setFinal(bool Final)1894 void setFinal(bool Final) { IsFinal = Final; } 1895 }; 1896 1897 /// Resolve arbitrary mappings. 1898 class MapResolver final : public Resolver { 1899 struct MappedValue { 1900 Init *V; 1901 bool Resolved; 1902 MappedValueMappedValue1903 MappedValue() : V(nullptr), Resolved(false) {} MappedValueMappedValue1904 MappedValue(Init *V, bool Resolved) : V(V), Resolved(Resolved) {} 1905 }; 1906 1907 DenseMap<Init *, MappedValue> Map; 1908 1909 public: Resolver(CurRec)1910 explicit MapResolver(Record *CurRec = nullptr) : Resolver(CurRec) {} 1911 set(Init * Key,Init * Value)1912 void set(Init *Key, Init *Value) { Map[Key] = {Value, false}; } 1913 1914 Init *resolve(Init *VarName) override; 1915 }; 1916 1917 /// Resolve all variables from a record except for unset variables. 1918 class RecordResolver final : public Resolver { 1919 DenseMap<Init *, Init *> Cache; 1920 SmallVector<Init *, 4> Stack; 1921 1922 public: RecordResolver(Record & R)1923 explicit RecordResolver(Record &R) : Resolver(&R) {} 1924 1925 Init *resolve(Init *VarName) override; 1926 keepUnsetBits()1927 bool keepUnsetBits() const override { return true; } 1928 }; 1929 1930 /// Resolve all references to a specific RecordVal. 1931 // 1932 // TODO: This is used for resolving references to template arguments, in a 1933 // rather inefficient way. Change those uses to resolve all template 1934 // arguments simultaneously and get rid of this class. 1935 class RecordValResolver final : public Resolver { 1936 const RecordVal *RV; 1937 1938 public: RecordValResolver(Record & R,const RecordVal * RV)1939 explicit RecordValResolver(Record &R, const RecordVal *RV) 1940 : Resolver(&R), RV(RV) {} 1941 resolve(Init * VarName)1942 Init *resolve(Init *VarName) override { 1943 if (VarName == RV->getNameInit()) 1944 return RV->getValue(); 1945 return nullptr; 1946 } 1947 }; 1948 1949 /// Delegate resolving to a sub-resolver, but shadow some variable names. 1950 class ShadowResolver final : public Resolver { 1951 Resolver &R; 1952 DenseSet<Init *> Shadowed; 1953 1954 public: ShadowResolver(Resolver & R)1955 explicit ShadowResolver(Resolver &R) 1956 : Resolver(R.getCurrentRecord()), R(R) { 1957 setFinal(R.isFinal()); 1958 } 1959 addShadow(Init * Key)1960 void addShadow(Init *Key) { Shadowed.insert(Key); } 1961 resolve(Init * VarName)1962 Init *resolve(Init *VarName) override { 1963 if (Shadowed.count(VarName)) 1964 return nullptr; 1965 return R.resolve(VarName); 1966 } 1967 }; 1968 1969 /// (Optionally) delegate resolving to a sub-resolver, and keep track whether 1970 /// there were unresolved references. 1971 class TrackUnresolvedResolver final : public Resolver { 1972 Resolver *R; 1973 bool FoundUnresolved = false; 1974 1975 public: 1976 explicit TrackUnresolvedResolver(Resolver *R = nullptr) 1977 : Resolver(R ? R->getCurrentRecord() : nullptr), R(R) {} 1978 foundUnresolved()1979 bool foundUnresolved() const { return FoundUnresolved; } 1980 1981 Init *resolve(Init *VarName) override; 1982 }; 1983 1984 /// Do not resolve anything, but keep track of whether a given variable was 1985 /// referenced. 1986 class HasReferenceResolver final : public Resolver { 1987 Init *VarNameToTrack; 1988 bool Found = false; 1989 1990 public: HasReferenceResolver(Init * VarNameToTrack)1991 explicit HasReferenceResolver(Init *VarNameToTrack) 1992 : Resolver(nullptr), VarNameToTrack(VarNameToTrack) {} 1993 found()1994 bool found() const { return Found; } 1995 1996 Init *resolve(Init *VarName) override; 1997 }; 1998 1999 void EmitJSON(RecordKeeper &RK, raw_ostream &OS); 2000 2001 } // end namespace llvm 2002 2003 #endif // LLVM_TABLEGEN_RECORD_H 2004