Record.h revision 360784
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 39namespace llvm { 40 41class ListRecTy; 42struct MultiClass; 43class Record; 44class RecordKeeper; 45class RecordVal; 46class Resolver; 47class StringInit; 48class TypedInit; 49 50//===----------------------------------------------------------------------===// 51// Type Classes 52//===----------------------------------------------------------------------===// 53 54class RecTy { 55public: 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 68private: 69 RecTyKind Kind; 70 ListRecTy *ListTy = nullptr; 71 72public: 73 RecTy(RecTyKind K) : Kind(K) {} 74 virtual ~RecTy() = default; 75 76 RecTyKind getRecTyKind() const { return Kind; } 77 78 virtual std::string getAsString() const = 0; 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 94inline raw_ostream &operator<<(raw_ostream &OS, const RecTy &Ty) { 95 Ty.print(OS); 96 return OS; 97} 98 99/// 'bit' - Represent a single bit 100class BitRecTy : public RecTy { 101 static BitRecTy Shared; 102 103 BitRecTy() : RecTy(BitRecTyKind) {} 104 105public: 106 static bool classof(const RecTy *RT) { 107 return RT->getRecTyKind() == BitRecTyKind; 108 } 109 110 static BitRecTy *get() { return &Shared; } 111 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 118class BitsRecTy : public RecTy { 119 unsigned Size; 120 121 explicit BitsRecTy(unsigned Sz) : RecTy(BitsRecTyKind), Size(Sz) {} 122 123public: 124 static bool classof(const RecTy *RT) { 125 return RT->getRecTyKind() == BitsRecTyKind; 126 } 127 128 static BitsRecTy *get(unsigned Sz); 129 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 140class CodeRecTy : public RecTy { 141 static CodeRecTy Shared; 142 143 CodeRecTy() : RecTy(CodeRecTyKind) {} 144 145public: 146 static bool classof(const RecTy *RT) { 147 return RT->getRecTyKind() == CodeRecTyKind; 148 } 149 150 static CodeRecTy *get() { return &Shared; } 151 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 158class IntRecTy : public RecTy { 159 static IntRecTy Shared; 160 161 IntRecTy() : RecTy(IntRecTyKind) {} 162 163public: 164 static bool classof(const RecTy *RT) { 165 return RT->getRecTyKind() == IntRecTyKind; 166 } 167 168 static IntRecTy *get() { return &Shared; } 169 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 176class StringRecTy : public RecTy { 177 static StringRecTy Shared; 178 179 StringRecTy() : RecTy(StringRecTyKind) {} 180 181public: 182 static bool classof(const RecTy *RT) { 183 return RT->getRecTyKind() == StringRecTyKind; 184 } 185 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. 195class ListRecTy : public RecTy { 196 friend ListRecTy *RecTy::getListTy(); 197 198 RecTy *Ty; 199 200 explicit ListRecTy(RecTy *T) : RecTy(ListRecTyKind), Ty(T) {} 201 202public: 203 static bool classof(const RecTy *RT) { 204 return RT->getRecTyKind() == ListRecTyKind; 205 } 206 207 static ListRecTy *get(RecTy *T) { return T->getListTy(); } 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 218class DagRecTy : public RecTy { 219 static DagRecTy Shared; 220 221 DagRecTy() : RecTy(DagRecTyKind) {} 222 223public: 224 static bool classof(const RecTy *RT) { 225 return RT->getRecTyKind() == DagRecTyKind; 226 } 227 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. 237class RecordRecTy final : public RecTy, public FoldingSetNode, 238 public TrailingObjects<RecordRecTy, Record *> { 239 friend class Record; 240 241 unsigned NumClasses; 242 243 explicit RecordRecTy(unsigned Num) 244 : RecTy(RecordRecTyKind), NumClasses(Num) {} 245 246public: 247 RecordRecTy(const RecordRecTy &) = delete; 248 RecordRecTy &operator=(const RecordRecTy &) = delete; 249 250 // Do not use sized deallocation due to trailing objects. 251 void operator delete(void *p) { ::operator delete(p); } 252 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 262 ArrayRef<Record *> getClasses() const { 263 return makeArrayRef(getTrailingObjects<Record *>(), NumClasses); 264 } 265 266 using const_record_iterator = Record * const *; 267 268 const_record_iterator classes_begin() const { return getClasses().begin(); } 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. 281RecTy *resolveTypes(RecTy *T1, RecTy *T2); 282 283//===----------------------------------------------------------------------===// 284// Initializer Classes 285//===----------------------------------------------------------------------===// 286 287class Init { 288protected: 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 330private: 331 const InitKind Kind; 332 333protected: 334 uint8_t Opc; // Used by UnOpInit, BinOpInit, and TernOpInit 335 336private: 337 virtual void anchor(); 338 339public: 340 InitKind getKind() const { return Kind; } 341 342protected: 343 explicit Init(InitKind K, uint8_t Opc = 0) : Kind(K), Opc(Opc) {} 344 345public: 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. 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. 356 virtual bool isConcrete() const { return false; } 357 358 /// Print out this value. 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. 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. 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. 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. 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. 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 419inline 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. 425class TypedInit : public Init { 426 RecTy *Ty; 427 428protected: 429 explicit TypedInit(InitKind K, RecTy *T, uint8_t Opc = 0) 430 : Init(K, Opc), Ty(T) {} 431 432public: 433 TypedInit(const TypedInit &) = delete; 434 TypedInit &operator=(const TypedInit &) = delete; 435 436 static bool classof(const Init *I) { 437 return I->getKind() >= IK_FirstTypedInit && 438 I->getKind() <= IK_LastTypedInit; 439 } 440 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 457class UnsetInit : public Init { 458 UnsetInit() : Init(IK_UnsetInit) {} 459 460public: 461 UnsetInit(const UnsetInit &) = delete; 462 UnsetInit &operator=(const UnsetInit &) = delete; 463 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 473 Init *getBit(unsigned Bit) const override { 474 return const_cast<UnsetInit*>(this); 475 } 476 477 bool isComplete() const override { return false; } 478 bool isConcrete() const override { return true; } 479 std::string getAsString() const override { return "?"; } 480}; 481 482/// 'true'/'false' - Represent a concrete initializer for a bit. 483class BitInit final : public TypedInit { 484 bool Value; 485 486 explicit BitInit(bool V) : TypedInit(IK_BitInit, BitRecTy::get()), Value(V) {} 487 488public: 489 BitInit(const BitInit &) = delete; 490 BitInit &operator=(BitInit &) = delete; 491 492 static bool classof(const Init *I) { 493 return I->getKind() == IK_BitInit; 494 } 495 496 static BitInit *get(bool V); 497 498 bool getValue() const { return Value; } 499 500 Init *convertInitializerTo(RecTy *Ty) const override; 501 502 Init *getBit(unsigned Bit) const override { 503 assert(Bit < 1 && "Bit index out of range!"); 504 return const_cast<BitInit*>(this); 505 } 506 507 bool isConcrete() const override { return true; } 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. 513class BitsInit final : public TypedInit, public FoldingSetNode, 514 public TrailingObjects<BitsInit, Init *> { 515 unsigned NumBits; 516 517 BitsInit(unsigned N) 518 : TypedInit(IK_BitsInit, BitsRecTy::get(N)), NumBits(N) {} 519 520public: 521 BitsInit(const BitsInit &) = delete; 522 BitsInit &operator=(const BitsInit &) = delete; 523 524 // Do not use sized deallocation due to trailing objects. 525 void operator delete(void *p) { ::operator delete(p); } 526 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 535 unsigned getNumBits() const { return NumBits; } 536 537 Init *convertInitializerTo(RecTy *Ty) const override; 538 Init *convertInitializerBitRange(ArrayRef<unsigned> Bits) const override; 539 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 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 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. 564class IntInit : public TypedInit { 565 int64_t Value; 566 567 explicit IntInit(int64_t V) 568 : TypedInit(IK_IntInit, IntRecTy::get()), Value(V) {} 569 570public: 571 IntInit(const IntInit &) = delete; 572 IntInit &operator=(const IntInit &) = delete; 573 574 static bool classof(const Init *I) { 575 return I->getKind() == IK_IntInit; 576 } 577 578 static IntInit *get(int64_t V); 579 580 int64_t getValue() const { return Value; } 581 582 Init *convertInitializerTo(RecTy *Ty) const override; 583 Init *convertInitializerBitRange(ArrayRef<unsigned> Bits) const override; 584 585 bool isConcrete() const override { return true; } 586 std::string getAsString() const override; 587 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. 594class StringInit : public TypedInit { 595 StringRef Value; 596 597 explicit StringInit(StringRef V) 598 : TypedInit(IK_StringInit, StringRecTy::get()), Value(V) {} 599 600public: 601 StringInit(const StringInit &) = delete; 602 StringInit &operator=(const StringInit &) = delete; 603 604 static bool classof(const Init *I) { 605 return I->getKind() == IK_StringInit; 606 } 607 608 static StringInit *get(StringRef); 609 610 StringRef getValue() const { return Value; } 611 612 Init *convertInitializerTo(RecTy *Ty) const override; 613 614 bool isConcrete() const override { return true; } 615 std::string getAsString() const override { return "\"" + Value.str() + "\""; } 616 617 std::string getAsUnquotedString() const override { return Value; } 618 619 Init *getBit(unsigned Bit) const override { 620 llvm_unreachable("Illegal bit reference off string"); 621 } 622}; 623 624class CodeInit : public TypedInit { 625 StringRef Value; 626 SMLoc Loc; 627 628 explicit CodeInit(StringRef V, const SMLoc &Loc) 629 : TypedInit(IK_CodeInit, static_cast<RecTy *>(CodeRecTy::get())), 630 Value(V), Loc(Loc) {} 631 632public: 633 CodeInit(const StringInit &) = delete; 634 CodeInit &operator=(const StringInit &) = delete; 635 636 static bool classof(const Init *I) { 637 return I->getKind() == IK_CodeInit; 638 } 639 640 static CodeInit *get(StringRef, const SMLoc &Loc); 641 642 StringRef getValue() const { return Value; } 643 const SMLoc &getLoc() const { return Loc; } 644 645 Init *convertInitializerTo(RecTy *Ty) const override; 646 647 bool isConcrete() const override { return true; } 648 std::string getAsString() const override { 649 return "[{" + Value.str() + "}]"; 650 } 651 652 std::string getAsUnquotedString() const override { return Value; } 653 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/// 661class ListInit final : public TypedInit, public FoldingSetNode, 662 public TrailingObjects<ListInit, Init *> { 663 unsigned NumValues; 664 665public: 666 using const_iterator = Init *const *; 667 668private: 669 explicit ListInit(unsigned N, RecTy *EltTy) 670 : TypedInit(IK_ListInit, ListRecTy::get(EltTy)), NumValues(N) {} 671 672public: 673 ListInit(const ListInit &) = delete; 674 ListInit &operator=(const ListInit &) = delete; 675 676 // Do not use sized deallocation due to trailing objects. 677 void operator delete(void *p) { ::operator delete(p); } 678 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 686 Init *getElement(unsigned i) const { 687 assert(i < NumValues && "List element index out of range!"); 688 return getTrailingObjects<Init *>()[i]; 689 } 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 710 ArrayRef<Init*> getValues() const { 711 return makeArrayRef(getTrailingObjects<Init *>(), NumValues); 712 } 713 714 const_iterator begin() const { return getTrailingObjects<Init *>(); } 715 const_iterator end () const { return begin() + NumValues; } 716 717 size_t size () const { return NumValues; } 718 bool empty() const { return NumValues == 0; } 719 720 Init *getBit(unsigned Bit) const override { 721 llvm_unreachable("Illegal bit reference off list"); 722 } 723}; 724 725/// Base class for operators 726/// 727class OpInit : public TypedInit { 728protected: 729 explicit OpInit(InitKind K, RecTy *Type, uint8_t Opc) 730 : TypedInit(K, Type, Opc) {} 731 732public: 733 OpInit(const OpInit &) = delete; 734 OpInit &operator=(OpInit &) = delete; 735 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/// 752class UnOpInit : public OpInit, public FoldingSetNode { 753public: 754 enum UnaryOp : uint8_t { CAST, HEAD, TAIL, SIZE, EMPTY, GETOP }; 755 756private: 757 Init *LHS; 758 759 UnOpInit(UnaryOp opc, Init *lhs, RecTy *Type) 760 : OpInit(IK_UnOpInit, Type, opc), LHS(lhs) {} 761 762public: 763 UnOpInit(const UnOpInit &) = delete; 764 UnOpInit &operator=(const UnOpInit &) = delete; 765 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 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 781 unsigned getNumOperands() const override { return 1; } 782 783 Init *getOperand(unsigned i) const override { 784 assert(i == 0 && "Invalid operand id for unary operator"); 785 return getOperand(); 786 } 787 788 UnaryOp getOpcode() const { return (UnaryOp)Opc; } 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. 801class BinOpInit : public OpInit, public FoldingSetNode { 802public: 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 807private: 808 Init *LHS, *RHS; 809 810 BinOpInit(BinaryOp opc, Init *lhs, Init *rhs, RecTy *Type) : 811 OpInit(IK_BinOpInit, Type, opc), LHS(lhs), RHS(rhs) {} 812 813public: 814 BinOpInit(const BinOpInit &) = delete; 815 BinOpInit &operator=(const BinOpInit &) = delete; 816 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 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 836 unsigned getNumOperands() const override { return 2; } 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 845 BinaryOp getOpcode() const { return (BinaryOp)Opc; } 846 Init *getLHS() const { return LHS; } 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. 859class TernOpInit : public OpInit, public FoldingSetNode { 860public: 861 enum TernaryOp : uint8_t { SUBST, FOREACH, IF, DAG }; 862 863private: 864 Init *LHS, *MHS, *RHS; 865 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 870public: 871 TernOpInit(const TernOpInit &) = delete; 872 TernOpInit &operator=(const TernOpInit &) = delete; 873 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 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 892 unsigned getNumOperands() const override { return 3; } 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 902 TernaryOp getOpcode() const { return (TernaryOp)Opc; } 903 Init *getLHS() const { return LHS; } 904 Init *getMHS() const { return MHS; } 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 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. 923class CondOpInit final : public TypedInit, public FoldingSetNode, 924 public TrailingObjects<CondOpInit, Init *> { 925 unsigned NumConds; 926 RecTy *ValType; 927 928 CondOpInit(unsigned NC, RecTy *Type) 929 : TypedInit(IK_CondOpInit, Type), 930 NumConds(NC), ValType(Type) {} 931 932 size_t numTrailingObjects(OverloadToken<Init *>) const { 933 return 2*NumConds; 934 } 935 936public: 937 CondOpInit(const CondOpInit &) = delete; 938 CondOpInit &operator=(const CondOpInit &) = delete; 939 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 949 RecTy *getValType() const { return ValType; } 950 951 unsigned getNumConds() const { return NumConds; } 952 953 Init *getCond(unsigned Num) const { 954 assert(Num < NumConds && "Condition number out of range!"); 955 return getTrailingObjects<Init *>()[Num]; 956 } 957 958 Init *getVal(unsigned Num) const { 959 assert(Num < NumConds && "Val number out of range!"); 960 return getTrailingObjects<Init *>()[Num+NumConds]; 961 } 962 963 ArrayRef<Init *> getConds() const { 964 return makeArrayRef(getTrailingObjects<Init *>(), NumConds); 965 } 966 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 982 inline const_case_iterator arg_begin() const { return getConds().begin(); } 983 inline const_case_iterator arg_end () const { return getConds().end(); } 984 985 inline size_t case_size () const { return NumConds; } 986 inline bool case_empty() const { return NumConds == 0; } 987 988 inline const_val_iterator name_begin() const { return getVals().begin();} 989 inline const_val_iterator name_end () const { return getVals().end(); } 990 991 inline size_t val_size () const { return NumConds; } 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. 998class FoldOpInit : public TypedInit, public FoldingSetNode { 999private: 1000 Init *Start; 1001 Init *List; 1002 Init *A; 1003 Init *B; 1004 Init *Expr; 1005 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 1010public: 1011 FoldOpInit(const FoldOpInit &) = delete; 1012 FoldOpInit &operator=(const FoldOpInit &) = delete; 1013 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 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. 1035class IsAOpInit : public TypedInit, public FoldingSetNode { 1036private: 1037 RecTy *CheckType; 1038 Init *Expr; 1039 1040 IsAOpInit(RecTy *CheckType, Init *Expr) 1041 : TypedInit(IK_IsAOpInit, IntRecTy::get()), CheckType(CheckType), 1042 Expr(Expr) {} 1043 1044public: 1045 IsAOpInit(const IsAOpInit &) = delete; 1046 IsAOpInit &operator=(const IsAOpInit &) = delete; 1047 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 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. 1068class VarInit : public TypedInit { 1069 Init *VarName; 1070 1071 explicit VarInit(Init *VN, RecTy *T) 1072 : TypedInit(IK_VarInit, T), VarName(VN) {} 1073 1074public: 1075 VarInit(const VarInit &) = delete; 1076 VarInit &operator=(const VarInit &) = delete; 1077 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; 1086 Init *getNameInit() const { return VarName; } 1087 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 1101 std::string getAsString() const override { return getName(); } 1102}; 1103 1104/// Opcode{0} - Represent access to one bit of a variable or field. 1105class VarBitInit final : public TypedInit { 1106 TypedInit *TI; 1107 unsigned Bit; 1108 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 1118public: 1119 VarBitInit(const VarBitInit &) = delete; 1120 VarBitInit &operator=(const VarBitInit &) = delete; 1121 1122 static bool classof(const Init *I) { 1123 return I->getKind() == IK_VarBitInit; 1124 } 1125 1126 static VarBitInit *get(TypedInit *T, unsigned B); 1127 1128 Init *getBitVar() const { return TI; } 1129 unsigned getBitNum() const { return Bit; } 1130 1131 std::string getAsString() const override; 1132 Init *resolveReferences(Resolver &R) const override; 1133 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. 1142class VarListElementInit : public TypedInit { 1143 TypedInit *TI; 1144 unsigned Element; 1145 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 1154public: 1155 VarListElementInit(const VarListElementInit &) = delete; 1156 VarListElementInit &operator=(const VarListElementInit &) = delete; 1157 1158 static bool classof(const Init *I) { 1159 return I->getKind() == IK_VarListElementInit; 1160 } 1161 1162 static VarListElementInit *get(TypedInit *T, unsigned E); 1163 1164 TypedInit *getVariable() const { return TI; } 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 1174class DefInit : public TypedInit { 1175 friend class Record; 1176 1177 Record *Def; 1178 1179 explicit DefInit(Record *D); 1180 1181public: 1182 DefInit(const DefInit &) = delete; 1183 DefInit &operator=(const DefInit &) = delete; 1184 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 1193 Record *getDef() const { return Def; } 1194 1195 //virtual Init *convertInitializerBitRange(ArrayRef<unsigned> Bits); 1196 1197 RecTy *getFieldType(StringInit *FieldName) const override; 1198 1199 bool isConcrete() const override { return true; } 1200 std::string getAsString() const override; 1201 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. 1209class VarDefInit final : public TypedInit, public FoldingSetNode, 1210 public TrailingObjects<VarDefInit, Init *> { 1211 Record *Class; 1212 DefInit *Def = nullptr; // after instantiation 1213 unsigned NumArgs; 1214 1215 explicit VarDefInit(Record *Class, unsigned N) 1216 : TypedInit(IK_VarDefInit, RecordRecTy::get(Class)), Class(Class), NumArgs(N) {} 1217 1218 DefInit *instantiate(); 1219 1220public: 1221 VarDefInit(const VarDefInit &) = delete; 1222 VarDefInit &operator=(const VarDefInit &) = delete; 1223 1224 // Do not use sized deallocation due to trailing objects. 1225 void operator delete(void *p) { ::operator delete(p); } 1226 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 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 1246 const_iterator args_begin() const { return getTrailingObjects<Init *>(); } 1247 const_iterator args_end () const { return args_begin() + NumArgs; } 1248 1249 size_t args_size () const { return NumArgs; } 1250 bool args_empty() const { return NumArgs == 0; } 1251 1252 ArrayRef<Init *> args() const { return makeArrayRef(args_begin(), NumArgs); } 1253 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 1260class FieldInit : public TypedInit { 1261 Init *Rec; // Record we are referring to 1262 StringInit *FieldName; // Field we are accessing 1263 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 1276public: 1277 FieldInit(const FieldInit &) = delete; 1278 FieldInit &operator=(const FieldInit &) = delete; 1279 1280 static bool classof(const Init *I) { 1281 return I->getKind() == IK_FieldInit; 1282 } 1283 1284 static FieldInit *get(Init *R, StringInit *FN); 1285 1286 Init *getRecord() const { return Rec; } 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 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. 1302class 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 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 1315 size_t numTrailingObjects(OverloadToken<Init *>) const { return NumArgs; } 1316 1317public: 1318 DagInit(const DagInit &) = delete; 1319 DagInit &operator=(const DagInit &) = delete; 1320 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 1332 Init *getOperator() const { return Val; } 1333 Record *getOperatorAsDef(ArrayRef<SMLoc> Loc) const; 1334 1335 StringInit *getName() const { return ValName; } 1336 1337 StringRef getNameStr() const { 1338 return ValName ? ValName->getValue() : StringRef(); 1339 } 1340 1341 unsigned getNumArgs() const { return NumArgs; } 1342 1343 Init *getArg(unsigned Num) const { 1344 assert(Num < NumArgs && "Arg number out of range!"); 1345 return getTrailingObjects<Init *>()[Num]; 1346 } 1347 1348 StringInit *getArgName(unsigned Num) const { 1349 assert(Num < NumArgNames && "Arg number out of range!"); 1350 return getTrailingObjects<StringInit *>()[Num]; 1351 } 1352 1353 StringRef getArgNameStr(unsigned Num) const { 1354 StringInit *Init = getArgName(Num); 1355 return Init ? Init->getValue() : StringRef(); 1356 } 1357 1358 ArrayRef<Init *> getArgs() const { 1359 return makeArrayRef(getTrailingObjects<Init *>(), NumArgs); 1360 } 1361 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 1374 inline const_arg_iterator arg_begin() const { return getArgs().begin(); } 1375 inline const_arg_iterator arg_end () const { return getArgs().end(); } 1376 1377 inline size_t arg_size () const { return NumArgs; } 1378 inline bool arg_empty() const { return NumArgs == 0; } 1379 1380 inline const_name_iterator name_begin() const { return getArgNames().begin();} 1381 inline const_name_iterator name_end () const { return getArgNames().end(); } 1382 1383 inline size_t name_size () const { return NumArgNames; } 1384 inline bool name_empty() const { return NumArgNames == 0; } 1385 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 1395class RecordVal { 1396 friend class Record; 1397 1398 Init *Name; 1399 PointerIntPair<RecTy *, 1, bool> TyAndPrefix; 1400 Init *Value; 1401 1402public: 1403 RecordVal(Init *N, RecTy *T, bool P); 1404 1405 StringRef getName() const; 1406 Init *getNameInit() const { return Name; } 1407 1408 std::string getNameInitAsString() const { 1409 return getNameInit()->getAsUnquotedString(); 1410 } 1411 1412 bool getPrefix() const { return TyAndPrefix.getInt(); } 1413 RecTy *getType() const { return TyAndPrefix.getPointer(); } 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 1422inline raw_ostream &operator<<(raw_ostream &OS, const RecordVal &RV) { 1423 RV.print(OS << " "); 1424 return OS; 1425} 1426 1427class 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 1454public: 1455 // Constructs a record. 1456 explicit Record(Init *N, ArrayRef<SMLoc> locs, RecordKeeper &records, 1457 bool Anonymous = false, bool Class = false) 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) 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. 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 1476 static unsigned getNewUID() { return LastID++; } 1477 1478 unsigned getID() const { return ID; } 1479 1480 StringRef getName() const { return cast<StringInit>(Name)->getValue(); } 1481 1482 Init *getNameInit() const { 1483 return Name; 1484 } 1485 1486 const std::string getNameInitAsString() const { 1487 return getNameInit()->getAsUnquotedString(); 1488 } 1489 1490 void setName(Init *Name); // Also updates RecordKeeper. 1491 1492 ArrayRef<SMLoc> getLoc() const { return Locs; } 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 1501 bool isClass() const { return IsClass; } 1502 1503 ArrayRef<Init *> getTemplateArgs() const { 1504 return TemplateArgs; 1505 } 1506 1507 ArrayRef<RecordVal> getValues() const { return Values; } 1508 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 1516 bool isTemplateArg(Init *Name) const { 1517 for (Init *TA : TemplateArgs) 1518 if (TA == Name) return true; 1519 return false; 1520 } 1521 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 1528 const RecordVal *getValue(StringRef Name) const { 1529 return getValue(StringInit::get(Name)); 1530 } 1531 1532 RecordVal *getValue(const Init *Name) { 1533 return const_cast<RecordVal *>(static_cast<const Record *>(this)->getValue(Name)); 1534 } 1535 1536 RecordVal *getValue(StringRef Name) { 1537 return const_cast<RecordVal *>(static_cast<const Record *>(this)->getValue(Name)); 1538 } 1539 1540 void addTemplateArg(Init *Name) { 1541 assert(!isTemplateArg(Name) && "Template arg already defined!"); 1542 TemplateArgs.push_back(Name); 1543 } 1544 1545 void addValue(const RecordVal &RV) { 1546 assert(getValue(RV.getNameInit()) == nullptr && "Value already added!"); 1547 Values.push_back(RV); 1548 } 1549 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 1559 void removeValue(StringRef Name) { 1560 removeValue(StringInit::get(Name)); 1561 } 1562 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 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 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 1607 RecordKeeper &getRecords() const { 1608 return TrackedRecords; 1609 } 1610 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. 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 1693raw_ostream &operator<<(raw_ostream &OS, const Record &R); 1694 1695class 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 1703public: 1704 const RecordMap &getClasses() const { return Classes; } 1705 const RecordMap &getDefs() const { return Defs; } 1706 1707 Record *getClass(StringRef Name) const { 1708 auto I = Classes.find(Name); 1709 return I == Classes.end() ? nullptr : I->second.get(); 1710 } 1711 1712 Record *getDef(StringRef Name) const { 1713 auto I = Defs.find(Name); 1714 return I == Defs.end() ? nullptr : I->second.get(); 1715 } 1716 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 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 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 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. 1759struct LessRecord { 1760 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. 1769struct LessRecordByID { 1770 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. 1777struct LessRecordFieldName { 1778 bool operator()(const Record *Rec1, const Record *Rec2) const { 1779 return Rec1->getValueAsString("Name") < Rec2->getValueAsString("Name"); 1780 } 1781}; 1782 1783struct LessRecordRegister { 1784 static bool ascii_isdigit(char x) { return x >= '0' && x <= '9'; } 1785 1786 struct RecordParts { 1787 SmallVector<std::pair< bool, StringRef>, 4> Parts; 1788 1789 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 1810 size_t size() { return Parts.size(); } 1811 1812 std::pair<bool, StringRef> getPart(size_t i) { 1813 assert (i < Parts.size() && "Invalid idx!"); 1814 return Parts[i]; 1815 } 1816 }; 1817 1818 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 1862raw_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. 1870class Resolver { 1871 Record *CurRec; 1872 bool IsFinal = false; 1873 1874public: 1875 explicit Resolver(Record *CurRec) : CurRec(CurRec) {} 1876 virtual ~Resolver() {} 1877 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. 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. 1892 bool isFinal() const { return IsFinal; } 1893 1894 void setFinal(bool Final) { IsFinal = Final; } 1895}; 1896 1897/// Resolve arbitrary mappings. 1898class MapResolver final : public Resolver { 1899 struct MappedValue { 1900 Init *V; 1901 bool Resolved; 1902 1903 MappedValue() : V(nullptr), Resolved(false) {} 1904 MappedValue(Init *V, bool Resolved) : V(V), Resolved(Resolved) {} 1905 }; 1906 1907 DenseMap<Init *, MappedValue> Map; 1908 1909public: 1910 explicit MapResolver(Record *CurRec = nullptr) : Resolver(CurRec) {} 1911 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. 1918class RecordResolver final : public Resolver { 1919 DenseMap<Init *, Init *> Cache; 1920 SmallVector<Init *, 4> Stack; 1921 1922public: 1923 explicit RecordResolver(Record &R) : Resolver(&R) {} 1924 1925 Init *resolve(Init *VarName) override; 1926 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. 1935class RecordValResolver final : public Resolver { 1936 const RecordVal *RV; 1937 1938public: 1939 explicit RecordValResolver(Record &R, const RecordVal *RV) 1940 : Resolver(&R), RV(RV) {} 1941 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. 1950class ShadowResolver final : public Resolver { 1951 Resolver &R; 1952 DenseSet<Init *> Shadowed; 1953 1954public: 1955 explicit ShadowResolver(Resolver &R) 1956 : Resolver(R.getCurrentRecord()), R(R) { 1957 setFinal(R.isFinal()); 1958 } 1959 1960 void addShadow(Init *Key) { Shadowed.insert(Key); } 1961 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. 1971class TrackUnresolvedResolver final : public Resolver { 1972 Resolver *R; 1973 bool FoundUnresolved = false; 1974 1975public: 1976 explicit TrackUnresolvedResolver(Resolver *R = nullptr) 1977 : Resolver(R ? R->getCurrentRecord() : nullptr), R(R) {} 1978 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. 1986class HasReferenceResolver final : public Resolver { 1987 Init *VarNameToTrack; 1988 bool Found = false; 1989 1990public: 1991 explicit HasReferenceResolver(Init *VarNameToTrack) 1992 : Resolver(nullptr), VarNameToTrack(VarNameToTrack) {} 1993 1994 bool found() const { return Found; } 1995 1996 Init *resolve(Init *VarName) override; 1997}; 1998 1999void EmitJSON(RecordKeeper &RK, raw_ostream &OS); 2000 2001} // end namespace llvm 2002 2003#endif // LLVM_TABLEGEN_RECORD_H 2004