LCOV - code coverage report
Current view: top level - include/llvm/TableGen - Record.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 217 321 67.6 %
Date: 2018-10-14 09:39:32 Functions: 46 123 37.4 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.13