LCOV - code coverage report
Current view: top level - include/llvm/TableGen - Record.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 236 312 75.6 %
Date: 2018-05-20 00:06:23 Functions: 65 144 45.1 %
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       73288 :   RecTy(RecTyKind K) : Kind(K) {}
      75             :   virtual ~RecTy() = default;
      76             : 
      77             :   RecTyKind getRecTyKind() const { return Kind; }
      78             : 
      79             :   virtual std::string getAsString() const = 0;
      80        5464 :   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        2732 :   Ty.print(OS);
      97             :   return OS;
      98             : }
      99             : 
     100             : /// 'bit' - Represent a single bit
     101         315 : class BitRecTy : public RecTy {
     102             :   static BitRecTy Shared;
     103             : 
     104         315 :   BitRecTy() : RecTy(BitRecTyKind) {}
     105             : 
     106             : public:
     107             :   static bool classof(const RecTy *RT) {
     108     6760726 :     return RT->getRecTyKind() == BitRecTyKind;
     109             :   }
     110             : 
     111             :   static BitRecTy *get() { return &Shared; }
     112             : 
     113          71 :   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           0 : class BitsRecTy : public RecTy {
     120             :   unsigned Size;
     121             : 
     122        5184 :   explicit BitsRecTy(unsigned Sz) : RecTy(BitsRecTyKind), Size(Sz) {}
     123             : 
     124             : public:
     125             :   static bool classof(const RecTy *RT) {
     126   389197132 :     return RT->getRecTyKind() == BitsRecTyKind;
     127             :   }
     128             : 
     129             :   static BitsRecTy *get(unsigned Sz);
     130             : 
     131             :   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         315 : class CodeRecTy : public RecTy {
     142             :   static CodeRecTy Shared;
     143             : 
     144         315 :   CodeRecTy() : RecTy(CodeRecTyKind) {}
     145             : 
     146             : public:
     147             :   static bool classof(const RecTy *RT) {
     148          30 :     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         315 : class IntRecTy : public RecTy {
     160             :   static IntRecTy Shared;
     161             : 
     162         315 :   IntRecTy() : RecTy(IntRecTyKind) {}
     163             : 
     164             : public:
     165             :   static bool classof(const RecTy *RT) {
     166     5974834 :     return RT->getRecTyKind() == IntRecTyKind;
     167             :   }
     168             : 
     169             :   static IntRecTy *get() { return &Shared; }
     170             : 
     171         792 :   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         315 : class StringRecTy : public RecTy {
     178             :   static StringRecTy Shared;
     179             : 
     180         315 :   StringRecTy() : RecTy(StringRecTyKind) {}
     181             : 
     182             : public:
     183             :   static bool classof(const RecTy *RT) {
     184     8181844 :     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           0 : class ListRecTy : public RecTy {
     197             :   friend ListRecTy *RecTy::getListTy();
     198             : 
     199             :   RecTy *Ty;
     200             : 
     201       22002 :   explicit ListRecTy(RecTy *T) : RecTy(ListRecTyKind), Ty(T) {}
     202             : 
     203             : public:
     204             :   static bool classof(const RecTy *RT) {
     205     7770944 :     return RT->getRecTyKind() == ListRecTyKind;
     206             :   }
     207             : 
     208     1182411 :   static ListRecTy *get(RecTy *T) { return T->getListTy(); }
     209             :   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         315 : class DagRecTy : public RecTy {
     220             :   static DagRecTy Shared;
     221             : 
     222         315 :   DagRecTy() : RecTy(DagRecTyKind) {}
     223             : 
     224             : public:
     225             :   static bool classof(const RecTy *RT) {
     226          43 :     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         177 : 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      116240 :       : 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           0 :   void operator delete(void *p) { ::operator delete(p); }
     253             : 
     254             :   static bool classof(const RecTy *RT) {
     255    12478066 :     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    25754469 :     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             :   InitKind getKind() const { return Kind; }
     341             : 
     342             : protected:
     343    23830574 :   explicit Init(InitKind K, uint8_t Opc = 0) : Kind(K), Opc(Opc) {}
     344             : 
     345             : public:
     346             :   Init(const Init &) = delete;
     347             :   Init &operator=(const Init &) = delete;
     348             :   virtual ~Init() = default;
     349             : 
     350             :   /// This virtual method should be overridden by values that may
     351             :   /// not be completely specified yet.
     352    35944911 :   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    10256300 :   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      139522 :   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   685486852 :   virtual Init *resolveReferences(Resolver &R) const {
     411   685486852 :     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     5128150 :   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    47660518 :     : 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     5809618 :     return I->getKind() >= IK_FirstTypedInit &&
     438             :            I->getKind() <= IK_LastTypedInit;
     439             :   }
     440             : 
     441             :   RecTy *getType() const { return Ty; }
     442             : 
     443             :   Init *getCastTo(RecTy *Ty) const override;
     444             :   Init *convertInitializerTo(RecTy *Ty) const override;
     445             : 
     446             :   Init *convertInitializerBitRange(ArrayRef<unsigned> Bits) const override;
     447             :   Init *convertInitListSlice(ArrayRef<unsigned> Elements) const override;
     448             : 
     449             :   /// This method is used to implement the FieldInit class.
     450             :   /// Implementors of this method should return the type of the named field if
     451             :   /// they are of record type.
     452             :   ///
     453             :   RecTy *getFieldType(StringInit *FieldName) const override;
     454             : };
     455             : 
     456             : /// '?' - Represents an uninitialized value
     457         315 : class UnsetInit : public Init {
     458         315 :   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   518766232 :     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    57539979 :   Init *getBit(unsigned Bit) const override {
     474    57539979 :     return const_cast<UnsetInit*>(this);
     475             :   }
     476             : 
     477      258657 :   bool isComplete() const override { return false; }
     478    18146775 :   bool isConcrete() const override { return true; }
     479      839610 :   std::string getAsString() const override { return "?"; }
     480             : };
     481             : 
     482             : /// 'true'/'false' - Represent a concrete initializer for a bit.
     483         490 : class BitInit final : public TypedInit {
     484             :   bool Value;
     485             : 
     486         980 :   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    44602882 :     return I->getKind() == IK_BitInit;
     494             :   }
     495             : 
     496             :   static BitInit *get(bool V);
     497             : 
     498             :   bool getValue() const { return Value; }
     499             : 
     500             :   Init *convertInitializerTo(RecTy *Ty) const override;
     501             : 
     502   220936833 :   Init *getBit(unsigned Bit) const override {
     503             :     assert(Bit < 1 && "Bit index out of range!");
     504   220936833 :     return const_cast<BitInit*>(this);
     505             :   }
     506             : 
     507    82864556 :   bool isConcrete() const override { return true; }
     508       13102 :   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           0 : class BitsInit final : public TypedInit, public FoldingSetNode,
     514             :                        public TrailingObjects<BitsInit, Init *> {
     515             :   unsigned NumBits;
     516             : 
     517             :   BitsInit(unsigned N)
     518     1611074 :     : 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           0 :   void operator delete(void *p) { ::operator delete(p); }
     526             : 
     527             :   static bool classof(const Init *I) {
     528   114419608 :     return I->getKind() == IK_BitsInit;
     529             :   }
     530             : 
     531             :   static BitsInit *get(ArrayRef<Init *> Range);
     532             : 
     533             :   void Profile(FoldingSetNodeID &ID) const;
     534             : 
     535             :   unsigned getNumBits() const { return NumBits; }
     536             : 
     537             :   Init *convertInitializerTo(RecTy *Ty) const override;
     538             :   Init *convertInitializerBitRange(ArrayRef<unsigned> Bits) const override;
     539             : 
     540     4546119 :   bool isComplete() const override {
     541    39975216 :     for (unsigned i = 0; i != getNumBits(); ++i)
     542    17840209 :       if (!getBit(i)->isComplete()) return false;
     543             :     return true;
     544             :   }
     545             : 
     546             :   bool allInComplete() const {
     547       29071 :     for (unsigned i = 0; i != getNumBits(); ++i)
     548       23959 :       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    44891799 :   Init *getBit(unsigned Bit) const override {
     558             :     assert(Bit < NumBits && "Bit index out of range!");
     559   667242408 :     return getTrailingObjects<Init *>()[Bit];
     560             :   }
     561             : };
     562             : 
     563             : /// '7' - Represent an initialization by a literal integer value.
     564           0 : class IntInit : public TypedInit {
     565             :   int64_t Value;
     566             : 
     567             :   explicit IntInit(int64_t V)
     568      126084 :     : 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    24561553 :     return I->getKind() == IK_IntInit;
     576             :   }
     577             : 
     578             :   static IntInit *get(int64_t V);
     579             : 
     580             :   int64_t getValue() const { return Value; }
     581             : 
     582             :   Init *convertInitializerTo(RecTy *Ty) const override;
     583             :   Init *convertInitializerBitRange(ArrayRef<unsigned> Bits) const override;
     584             : 
     585     3820968 :   bool isConcrete() const override { return true; }
     586             :   std::string getAsString() const override;
     587             : 
     588     2336357 :   Init *getBit(unsigned Bit) const override {
     589     2336357 :     return BitInit::get((Value & (1ULL << Bit)) != 0);
     590             :   }
     591             : };
     592             : 
     593             : /// "foo" - Represent an initialization by a string value.
     594           0 : class StringInit : public TypedInit {
     595             :   StringRef Value;
     596             : 
     597             :   explicit StringInit(StringRef V)
     598    25860156 :       : 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   242567704 :     return I->getKind() == IK_StringInit;
     606             :   }
     607             : 
     608             :   static StringInit *get(StringRef);
     609             : 
     610             :   StringRef getValue() const { return Value; }
     611             : 
     612             :   Init *convertInitializerTo(RecTy *Ty) const override;
     613             : 
     614    11227105 :   bool isConcrete() const override { return true; }
     615       55416 :   std::string getAsString() const override { return "\"" + Value.str() + "\""; }
     616             : 
     617     8084000 :   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           0 : class CodeInit : public TypedInit {
     625             :   StringRef Value;
     626             : 
     627             :   explicit CodeInit(StringRef V)
     628       20737 :       : TypedInit(IK_CodeInit, static_cast<RecTy *>(CodeRecTy::get())),
     629       20737 :         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          10 :     return I->getKind() == IK_CodeInit;
     637             :   }
     638             : 
     639             :   static CodeInit *get(StringRef);
     640             : 
     641             :   StringRef getValue() const { return Value; }
     642             : 
     643             :   Init *convertInitializerTo(RecTy *Ty) const override;
     644             : 
     645      215425 :   bool isConcrete() const override { return true; }
     646           3 :   std::string getAsString() const override {
     647           9 :     return "[{" + Value.str() + "}]";
     648             :   }
     649             : 
     650          66 :   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           0 : 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     2259482 :     : 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           0 :   void operator delete(void *p) { ::operator delete(p); }
     676             : 
     677             :   static bool classof(const Init *I) {
     678    10124950 :     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     3284872 :     return getTrailingObjects<Init *>()[i];
     687             :   }
     688             :   RecTy *getElementType() const {
     689     2986412 :     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    57722955 :     return makeArrayRef(getTrailingObjects<Init *>(), NumValues);
     710             :   }
     711             : 
     712             :   const_iterator begin() const { return getTrailingObjects<Init *>(); }
     713    13964928 :   const_iterator end  () const { return begin() + NumValues; }
     714             : 
     715    41221494 :   size_t         size () const { return NumValues;  }
     716        6441 :   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           0 : 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      658146 :     : 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             :   UnaryOp getOpcode() const { return (UnaryOp)Opc; }
     787             :   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           0 : 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     2501199 :   BinOpInit(BinaryOp opc, Init *lhs, Init *rhs, RecTy *Type) :
     808     2501199 :       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     8647861 :     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             :   BinaryOp getOpcode() const { return (BinaryOp)Opc; }
     841             :   Init *getLHS() const { return LHS; }
     842             :   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           0 : 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      248169 :              RecTy *Type) :
     863      248169 :       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             :   TernaryOp getOpcode() const { return (TernaryOp)Opc; }
     898             :   Init *getLHS() const { return LHS; }
     899             :   Init *getMHS() const { return MHS; }
     900             :   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           0 : 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       36173 :       : TypedInit(IK_FoldOpInit, Type), Start(Start), List(List), A(A), B(B),
     926       36173 :         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           0 : class IsAOpInit : public TypedInit, public FoldingSetNode {
     954             : private:
     955             :   RecTy *CheckType;
     956             :   Init *Expr;
     957             : 
     958             :   IsAOpInit(RecTy *CheckType, Init *Expr)
     959        1294 :       : TypedInit(IK_IsAOpInit, IntRecTy::get()), CheckType(CheckType),
     960        1294 :         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           0 : class VarInit : public TypedInit {
     987             :   Init *VarName;
     988             : 
     989             :   explicit VarInit(Init *VN, RecTy *T)
     990      775464 :       : 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    15182303 :     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             :   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        1150 :   std::string getAsString() const override { return getName(); }
    1020             : };
    1021             : 
    1022             : /// Opcode{0} - Represent access to one bit of a variable or field.
    1023           0 : class VarBitInit final : public TypedInit {
    1024             :   TypedInit *TI;
    1025             :   unsigned Bit;
    1026             : 
    1027             :   VarBitInit(TypedInit *T, unsigned B)
    1028      980314 :       : 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   571384952 :     return I->getKind() == IK_VarBitInit;
    1042             :   }
    1043             : 
    1044             :   static VarBitInit *get(TypedInit *T, unsigned B);
    1045             : 
    1046             :   Init *getBitVar() const { return TI; }
    1047             :   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           0 : class VarListElementInit : public TypedInit {
    1061             :   TypedInit *TI;
    1062             :   unsigned Element;
    1063             : 
    1064             :   VarListElementInit(TypedInit *T, unsigned E)
    1065         321 :       : TypedInit(IK_VarListElementInit,
    1066             :                   cast<ListRecTy>(T->getType())->getElementType()),
    1067         642 :         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             :   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           0 : 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    71134379 :     return I->getKind() == IK_DefInit;
    1105             :   }
    1106             : 
    1107             :   static DefInit *get(Record*);
    1108             : 
    1109             :   Init *convertInitializerTo(RecTy *Ty) const override;
    1110             : 
    1111             :   Record *getDef() const { return Def; }
    1112             : 
    1113             :   //virtual Init *convertInitializerBitRange(ArrayRef<unsigned> Bits);
    1114             : 
    1115             :   RecTy *getFieldType(StringInit *FieldName) const override;
    1116             : 
    1117    28852036 :   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           0 : 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     1015520 :     : 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           0 :   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      593362 :     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     2986484 :   size_t         args_size () const { return NumArgs; }
    1168             :   bool           args_empty() const { return NumArgs == 0; }
    1169             : 
    1170     7170937 :   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           0 : 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     3056998 :       : 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          95 :     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           0 : 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     2236520 :       : TypedInit(IK_DagInit, DagRecTy::get()), Val(V), ValName(VN),
    1224     2236520 :         NumArgs(NumArgs), NumArgNames(NumArgNames) {}
    1225             : 
    1226    29633865 :   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     9204089 :     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             :   Init *getOperator() const { return Val; }
    1244             : 
    1245             :   StringInit *getName() const { return ValName; }
    1246             : 
    1247             :   StringRef getNameStr() const {
    1248             :     return ValName ? ValName->getValue() : StringRef();
    1249             :   }
    1250             : 
    1251             :   unsigned getNumArgs() const { return NumArgs; }
    1252             : 
    1253             :   Init *getArg(unsigned Num) const {
    1254             :     assert(Num < NumArgs && "Arg number out of range!");
    1255    14254115 :     return getTrailingObjects<Init *>()[Num];
    1256             :   }
    1257             : 
    1258             :   StringInit *getArgName(unsigned Num) const {
    1259             :     assert(Num < NumArgNames && "Arg number out of range!");
    1260    13098250 :     return getTrailingObjects<StringInit *>()[Num];
    1261             :   }
    1262             : 
    1263             :   StringRef getArgNameStr(unsigned Num) const {
    1264             :     StringInit *Init = getArgName(Num);
    1265     4147003 :     return Init ? Init->getValue() : StringRef();
    1266             :   }
    1267             : 
    1268             :   ArrayRef<Init *> getArgs() const {
    1269    29157215 :     return makeArrayRef(getTrailingObjects<Init *>(), NumArgs);
    1270             :   }
    1271             : 
    1272             :   ArrayRef<StringInit *> getArgNames() const {
    1273     3368211 :     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    22867239 :   inline size_t              arg_size () const { return NumArgs; }
    1288             :   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             :   Init *getNameInit() const { return Name; }
    1317             : 
    1318             :   std::string getNameInitAsString() const {
    1319        2734 :     return getNameInit()->getAsUnquotedString();
    1320             :   }
    1321             : 
    1322             :   bool getPrefix() const { return TyAndPrefix.getInt(); }
    1323             :   RecTy *getType() const { return TyAndPrefix.getPointer(); }
    1324             :   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        2487 : inline raw_ostream &operator<<(raw_ostream &OS, const RecordVal &RV) {
    1333        2487 :   RV.print(OS << "  ");
    1334        2487 :   return OS;
    1335             : }
    1336             : 
    1337     6862442 : 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             : 
    1361             :   void init();
    1362             :   void checkName();
    1363             : 
    1364             : public:
    1365             :   // Constructs a record.
    1366     2312495 :   explicit Record(Init *N, ArrayRef<SMLoc> locs, RecordKeeper &records,
    1367     2312495 :                   bool Anonymous = false) :
    1368             :     Name(N), Locs(locs.begin(), locs.end()), TrackedRecords(records),
    1369     4624990 :     ID(LastID++), IsAnonymous(Anonymous) {
    1370     2312495 :     init();
    1371     2312495 :   }
    1372             : 
    1373             :   explicit Record(StringRef N, ArrayRef<SMLoc> locs, RecordKeeper &records)
    1374      217682 :       : Record(StringInit::get(N), locs, records) {}
    1375             : 
    1376             :   // When copy-constructing a Record, we must still guarantee a globally unique
    1377             :   // ID number.  Don't copy TheInit either since it's owned by the original
    1378             :   // record. All other fields can be copied normally.
    1379     1155253 :   Record(const Record &O) :
    1380     1155253 :     Name(O.Name), Locs(O.Locs), TemplateArgs(O.TemplateArgs),
    1381             :     Values(O.Values), SuperClasses(O.SuperClasses),
    1382     2310506 :     TrackedRecords(O.TrackedRecords), ID(LastID++),
    1383     3465759 :     IsAnonymous(O.IsAnonymous) { }
    1384             : 
    1385       19628 :   static unsigned getNewUID() { return LastID++; }
    1386             : 
    1387             :   unsigned getID() const { return ID; }
    1388             : 
    1389             :   StringRef getName() const { return cast<StringInit>(Name)->getValue(); }
    1390             : 
    1391             :   Init *getNameInit() const {
    1392             :     return Name;
    1393             :   }
    1394             : 
    1395             :   const std::string getNameInitAsString() const {
    1396     3301292 :     return getNameInit()->getAsUnquotedString();
    1397             :   }
    1398             : 
    1399             :   void setName(Init *Name);      // Also updates RecordKeeper.
    1400             : 
    1401             :   ArrayRef<SMLoc> getLoc() const { return Locs; }
    1402      957467 :   void appendLoc(SMLoc Loc) { Locs.push_back(Loc); }
    1403             : 
    1404             :   // Make the type that this record should have based on its superclasses.
    1405             :   RecordRecTy *getType();
    1406             : 
    1407             :   /// get the corresponding DefInit.
    1408             :   DefInit *getDefInit();
    1409             : 
    1410             :   ArrayRef<Init *> getTemplateArgs() const {
    1411             :     return TemplateArgs;
    1412             :   }
    1413             : 
    1414             :   ArrayRef<RecordVal> getValues() const { return Values; }
    1415             : 
    1416             :   ArrayRef<std::pair<Record *, SMRange>>  getSuperClasses() const {
    1417             :     return SuperClasses;
    1418             :   }
    1419             : 
    1420             :   /// Append the direct super classes of this record to Classes.
    1421             :   void getDirectSuperClasses(SmallVectorImpl<Record *> &Classes) const;
    1422             : 
    1423             :   bool isTemplateArg(Init *Name) const {
    1424    15600630 :     for (Init *TA : TemplateArgs)
    1425     4628120 :       if (TA == Name) return true;
    1426             :     return false;
    1427             :   }
    1428             : 
    1429             :   const RecordVal *getValue(const Init *Name) const {
    1430  8757096989 :     for (const RecordVal &Val : Values)
    1431  4417405038 :       if (Val.Name == Name) return &Val;
    1432             :     return nullptr;
    1433             :   }
    1434             : 
    1435             :   const RecordVal *getValue(StringRef Name) const {
    1436    61121610 :     return getValue(StringInit::get(Name));
    1437             :   }
    1438             : 
    1439             :   RecordVal *getValue(const Init *Name) {
    1440             :     return const_cast<RecordVal *>(static_cast<const Record *>(this)->getValue(Name));
    1441             :   }
    1442             : 
    1443     2235679 :   RecordVal *getValue(StringRef Name) {
    1444     2235679 :     return const_cast<RecordVal *>(static_cast<const Record *>(this)->getValue(Name));
    1445             :   }
    1446             : 
    1447             :   void addTemplateArg(Init *Name) {
    1448             :     assert(!isTemplateArg(Name) && "Template arg already defined!");
    1449      370203 :     TemplateArgs.push_back(Name);
    1450             :   }
    1451             : 
    1452    47858034 :   void addValue(const RecordVal &RV) {
    1453             :     assert(getValue(RV.getNameInit()) == nullptr && "Value already added!");
    1454    47858034 :     Values.push_back(RV);
    1455    47858034 :     if (Values.size() > 1)
    1456             :       // Keep NAME at the end of the list.  It makes record dumps a
    1457             :       // bit prettier and allows TableGen tests to be written more
    1458             :       // naturally.  Tests can use CHECK-NEXT to look for Record
    1459             :       // fields they expect to see after a def.  They can't do that if
    1460             :       // NAME is the first Record field.
    1461    91091078 :       std::swap(Values[Values.size() - 2], Values[Values.size() - 1]);
    1462    47858034 :   }
    1463             : 
    1464     7819859 :   void removeValue(Init *Name) {
    1465    34402725 :     for (unsigned i = 0, e = Values.size(); i != e; ++i)
    1466    68805450 :       if (Values[i].getNameInit() == Name) {
    1467             :         Values.erase(Values.begin()+i);
    1468     7819859 :         return;
    1469             :       }
    1470           0 :     llvm_unreachable("Cannot remove an entry that does not exist!");
    1471             :   }
    1472             : 
    1473             :   void removeValue(StringRef Name) {
    1474             :     removeValue(StringInit::get(Name));
    1475             :   }
    1476             : 
    1477             :   bool isSubClassOf(const Record *R) const {
    1478   459253250 :     for (const auto &SCPair : SuperClasses)
    1479   204597343 :       if (SCPair.first == R)
    1480             :         return true;
    1481             :     return false;
    1482             :   }
    1483             : 
    1484    98001579 :   bool isSubClassOf(StringRef Name) const {
    1485   388752847 :     for (const auto &SCPair : SuperClasses) {
    1486   176922656 :       if (const auto *SI = dyn_cast<StringInit>(SCPair.first->getNameInit())) {
    1487             :         if (SI->getValue() == Name)
    1488             :           return true;
    1489           0 :       } else if (SCPair.first->getNameInitAsString() == Name) {
    1490             :         return true;
    1491             :       }
    1492             :     }
    1493             :     return false;
    1494             :   }
    1495             : 
    1496             :   void addSuperClass(Record *R, SMRange Range) {
    1497             :     assert(!TheInit && "changing type of record after it has been referenced");
    1498             :     assert(!isSubClassOf(R) && "Already subclassing record!");
    1499    14974390 :     SuperClasses.push_back(std::make_pair(R, Range));
    1500             :   }
    1501             : 
    1502             :   /// If there are any field references that refer to fields
    1503             :   /// that have been filled in, we can propagate the values now.
    1504             :   ///
    1505             :   /// This is a final resolve: any error messages, e.g. due to undefined
    1506             :   /// !cast references, are generated now.
    1507             :   void resolveReferences();
    1508             : 
    1509             :   /// Apply the resolver to the name of the record as well as to the
    1510             :   /// initializers of all fields of the record except SkipVal.
    1511             :   ///
    1512             :   /// The resolver should not resolve any of the fields itself, to avoid
    1513             :   /// recursion / infinite loops.
    1514             :   void resolveReferences(Resolver &R, const RecordVal *SkipVal = nullptr);
    1515             : 
    1516             :   /// If anything in this record refers to RV, replace the
    1517             :   /// reference to RV with the RHS of RV.  If RV is null, we resolve all
    1518             :   /// possible references.
    1519             :   void resolveReferencesTo(const RecordVal *RV);
    1520             : 
    1521             :   RecordKeeper &getRecords() const {
    1522             :     return TrackedRecords;
    1523             :   }
    1524             : 
    1525             :   bool isAnonymous() const {
    1526             :     return IsAnonymous;
    1527             :   }
    1528             : 
    1529             :   void print(raw_ostream &OS) const;
    1530             :   void dump() const;
    1531             : 
    1532             :   //===--------------------------------------------------------------------===//
    1533             :   // High-level methods useful to tablegen back-ends
    1534             :   //
    1535             : 
    1536             :   /// Return the initializer for a value with the specified name,
    1537             :   /// or throw an exception if the field does not exist.
    1538             :   Init *getValueInit(StringRef FieldName) const;
    1539             : 
    1540             :   /// Return true if the named field is unset.
    1541             :   bool isValueUnset(StringRef FieldName) const {
    1542      251945 :     return isa<UnsetInit>(getValueInit(FieldName));
    1543             :   }
    1544             : 
    1545             :   /// This method looks up the specified field and returns
    1546             :   /// its value as a string, throwing an exception if the field does not exist
    1547             :   /// or if the value is not a string.
    1548             :   StringRef getValueAsString(StringRef FieldName) const;
    1549             : 
    1550             :   /// This method looks up the specified field and returns
    1551             :   /// its value as a BitsInit, throwing an exception if the field does not exist
    1552             :   /// or if the value is not the right type.
    1553             :   BitsInit *getValueAsBitsInit(StringRef FieldName) const;
    1554             : 
    1555             :   /// This method looks up the specified field and returns
    1556             :   /// its value as a ListInit, throwing an exception if the field does not exist
    1557             :   /// or if the value is not the right type.
    1558             :   ListInit *getValueAsListInit(StringRef FieldName) const;
    1559             : 
    1560             :   /// This method looks up the specified field and
    1561             :   /// returns its value as a vector of records, throwing an exception if the
    1562             :   /// field does not exist or if the value is not the right type.
    1563             :   std::vector<Record*> getValueAsListOfDefs(StringRef FieldName) const;
    1564             : 
    1565             :   /// This method looks up the specified field and
    1566             :   /// returns its value as a vector of integers, throwing an exception if the
    1567             :   /// field does not exist or if the value is not the right type.
    1568             :   std::vector<int64_t> getValueAsListOfInts(StringRef FieldName) const;
    1569             : 
    1570             :   /// This method looks up the specified field and
    1571             :   /// returns its value as a vector of strings, throwing an exception if the
    1572             :   /// field does not exist or if the value is not the right type.
    1573             :   std::vector<StringRef> getValueAsListOfStrings(StringRef FieldName) const;
    1574             : 
    1575             :   /// This method looks up the specified field and returns its
    1576             :   /// value as a Record, throwing an exception if the field does not exist or if
    1577             :   /// the value is not the right type.
    1578             :   Record *getValueAsDef(StringRef FieldName) const;
    1579             : 
    1580             :   /// This method looks up the specified field and returns its
    1581             :   /// value as a bit, throwing an exception if the field does not exist or if
    1582             :   /// the value is not the right type.
    1583             :   bool getValueAsBit(StringRef FieldName) const;
    1584             : 
    1585             :   /// This method looks up the specified field and
    1586             :   /// returns its value as a bit. If the field is unset, sets Unset to true and
    1587             :   /// returns false.
    1588             :   bool getValueAsBitOrUnset(StringRef FieldName, bool &Unset) const;
    1589             : 
    1590             :   /// This method looks up the specified field and returns its
    1591             :   /// value as an int64_t, throwing an exception if the field does not exist or
    1592             :   /// if the value is not the right type.
    1593             :   int64_t getValueAsInt(StringRef FieldName) const;
    1594             : 
    1595             :   /// This method looks up the specified field and returns its
    1596             :   /// value as an Dag, throwing an exception if the field does not exist or if
    1597             :   /// the value is not the right type.
    1598             :   DagInit *getValueAsDag(StringRef FieldName) const;
    1599             : };
    1600             : 
    1601             : raw_ostream &operator<<(raw_ostream &OS, const Record &R);
    1602             : 
    1603       27981 : struct MultiClass {
    1604             :   Record Rec;  // Placeholder for template args and Name.
    1605             :   using RecordVector = std::vector<std::unique_ptr<Record>>;
    1606             :   RecordVector DefPrototypes;
    1607             : 
    1608             :   void dump() const;
    1609             : 
    1610       28095 :   MultiClass(StringRef Name, SMLoc Loc, RecordKeeper &Records) :
    1611       56190 :     Rec(Name, Loc, Records) {}
    1612             : };
    1613             : 
    1614        1250 : class RecordKeeper {
    1615             :   friend class RecordRecTy;
    1616             :   using RecordMap = std::map<std::string, std::unique_ptr<Record>>;
    1617             :   RecordMap Classes, Defs;
    1618             :   FoldingSet<RecordRecTy> RecordTypePool;
    1619             :   std::map<std::string, Init *> ExtraGlobals;
    1620             :   unsigned AnonCounter = 0;
    1621             : 
    1622             : public:
    1623             :   const RecordMap &getClasses() const { return Classes; }
    1624             :   const RecordMap &getDefs() const { return Defs; }
    1625             : 
    1626     3423564 :   Record *getClass(StringRef Name) const {
    1627     3423564 :     auto I = Classes.find(Name);
    1628     6847128 :     return I == Classes.end() ? nullptr : I->second.get();
    1629             :   }
    1630             : 
    1631    11644278 :   Record *getDef(StringRef Name) const {
    1632    11644278 :     auto I = Defs.find(Name);
    1633    23288556 :     return I == Defs.end() ? nullptr : I->second.get();
    1634             :   }
    1635             : 
    1636     6640224 :   Init *getGlobal(StringRef Name) const {
    1637     6640224 :     if (Record *R = getDef(Name))
    1638     6637888 :       return R->getDefInit();
    1639        2336 :     auto It = ExtraGlobals.find(Name);
    1640        2336 :     return It == ExtraGlobals.end() ? nullptr : It->second;
    1641             :   }
    1642             : 
    1643      173284 :   void addClass(std::unique_ptr<Record> R) {
    1644      346568 :     bool Ins = Classes.insert(std::make_pair(R->getName(),
    1645             :                                              std::move(R))).second;
    1646             :     (void)Ins;
    1647             :     assert(Ins && "Class already exists");
    1648      173284 :   }
    1649             : 
    1650     3017029 :   void addDef(std::unique_ptr<Record> R) {
    1651     6034058 :     bool Ins = Defs.insert(std::make_pair(R->getName(),
    1652             :                                           std::move(R))).second;
    1653             :     (void)Ins;
    1654             :     assert(Ins && "Record already exists");
    1655     3017029 :   }
    1656             : 
    1657             :   void addExtraGlobal(StringRef Name, Init *I) {
    1658        1290 :     bool Ins = ExtraGlobals.insert(std::make_pair(Name, I)).second;
    1659             :     (void)Ins;
    1660             :     assert(!getDef(Name));
    1661             :     assert(Ins && "Global already exists");
    1662             :   }
    1663             : 
    1664             :   Init *getNewAnonymousName();
    1665             : 
    1666             :   //===--------------------------------------------------------------------===//
    1667             :   // High-level helper methods, useful for tablegen backends...
    1668             : 
    1669             :   /// This method returns all concrete definitions
    1670             :   /// that derive from the specified class name.  A class with the specified
    1671             :   /// name must exist.
    1672             :   std::vector<Record *> getAllDerivedDefinitions(StringRef ClassName) const;
    1673             : 
    1674             :   void dump() const;
    1675             : };
    1676             : 
    1677             : /// Sorting predicate to sort record pointers by name.
    1678             : struct LessRecord {
    1679      739582 :   bool operator()(const Record *Rec1, const Record *Rec2) const {
    1680      739582 :     return StringRef(Rec1->getName()).compare_numeric(Rec2->getName()) < 0;
    1681             :   }
    1682             : };
    1683             : 
    1684             : /// Sorting predicate to sort record pointers by their
    1685             : /// unique ID. If you just need a deterministic order, use this, since it
    1686             : /// just compares two `unsigned`; the other sorting predicates require
    1687             : /// string manipulation.
    1688             : struct LessRecordByID {
    1689             :   bool operator()(const Record *LHS, const Record *RHS) const {
    1690   113972998 :     return LHS->getID() < RHS->getID();
    1691             :   }
    1692             : };
    1693             : 
    1694             : /// Sorting predicate to sort record pointers by their
    1695             : /// name field.
    1696             : struct LessRecordFieldName {
    1697       13128 :   bool operator()(const Record *Rec1, const Record *Rec2) const {
    1698       26256 :     return Rec1->getValueAsString("Name") < Rec2->getValueAsString("Name");
    1699             :   }
    1700             : };
    1701             : 
    1702             : struct LessRecordRegister {
    1703    35418637 :   static bool ascii_isdigit(char x) { return x >= '0' && x <= '9'; }
    1704             : 
    1705      910252 :   struct RecordParts {
    1706             :     SmallVector<std::pair< bool, StringRef>, 4> Parts;
    1707             : 
    1708     1820504 :     RecordParts(StringRef Rec) {
    1709     1820504 :       if (Rec.empty())
    1710             :         return;
    1711             : 
    1712             :       size_t Len = 0;
    1713             :       const char *Start = Rec.data();
    1714             :       const char *Curr = Start;
    1715     1820504 :       bool isDigitPart = ascii_isdigit(Curr[0]);
    1716    54568318 :       for (size_t I = 0, E = Rec.size(); I != E; ++I, ++Len) {
    1717    26373907 :         bool isDigit = ascii_isdigit(Curr[I]);
    1718    26373907 :         if (isDigit != isDigitPart) {
    1719    14448452 :           Parts.push_back(std::make_pair(isDigitPart, StringRef(Start, Len)));
    1720             :           Len = 0;
    1721             :           Start = &Curr[I];
    1722     7224226 :           isDigitPart = ascii_isdigit(Curr[I]);
    1723             :         }
    1724             :       }
    1725             :       // Push the last part.
    1726     3641008 :       Parts.push_back(std::make_pair(isDigitPart, StringRef(Start, Len)));
    1727             :     }
    1728             : 
    1729             :     size_t size() { return Parts.size(); }
    1730             : 
    1731             :     std::pair<bool, StringRef> getPart(size_t i) {
    1732             :       assert (i < Parts.size() && "Invalid idx!");
    1733     4715336 :       return Parts[i];
    1734             :     }
    1735             :   };
    1736             : 
    1737      910252 :   bool operator()(const Record *Rec1, const Record *Rec2) const {
    1738      910252 :     RecordParts LHSParts(StringRef(Rec1->getName()));
    1739      910252 :     RecordParts RHSParts(StringRef(Rec2->getName()));
    1740             : 
    1741             :     size_t LHSNumParts = LHSParts.size();
    1742             :     size_t RHSNumParts = RHSParts.size();
    1743             :     assert (LHSNumParts && RHSNumParts && "Expected at least one part!");
    1744             : 
    1745      910252 :     if (LHSNumParts != RHSNumParts)
    1746      163282 :       return LHSNumParts < RHSNumParts;
    1747             : 
    1748             :     // We expect the registers to be of the form [_a-zA-Z]+([0-9]*[_a-zA-Z]*)*.
    1749     3921292 :     for (size_t I = 0, E = LHSNumParts; I < E; I+=2) {
    1750             :       std::pair<bool, StringRef> LHSPart = LHSParts.getPart(I);
    1751             :       std::pair<bool, StringRef> RHSPart = RHSParts.getPart(I);
    1752             :       // Expect even part to always be alpha.
    1753             :       assert (LHSPart.first == false && RHSPart.first == false &&
    1754             :               "Expected both parts to be alpha.");
    1755             :       if (int Res = LHSPart.second.compare(RHSPart.second))
    1756      242293 :         return Res < 0;
    1757             :     }
    1758      556151 :     for (size_t I = 1, E = LHSNumParts; I < E; I+=2) {
    1759             :       std::pair<bool, StringRef> LHSPart = LHSParts.getPart(I);
    1760             :       std::pair<bool, StringRef> RHSPart = RHSParts.getPart(I);
    1761             :       // Expect odd part to always be numeric.
    1762             :       assert (LHSPart.first == true && RHSPart.first == true &&
    1763             :               "Expected both parts to be numeric.");
    1764      528214 :       if (LHSPart.second.size() != RHSPart.second.size())
    1765      600729 :         return LHSPart.second.size() < RHSPart.second.size();
    1766             : 
    1767             :       unsigned LHSVal, RHSVal;
    1768             : 
    1769             :       bool LHSFailed = LHSPart.second.getAsInteger(10, LHSVal); (void)LHSFailed;
    1770             :       assert(!LHSFailed && "Unable to convert LHS to integer.");
    1771             :       bool RHSFailed = RHSPart.second.getAsInteger(10, RHSVal); (void)RHSFailed;
    1772             :       assert(!RHSFailed && "Unable to convert RHS to integer.");
    1773             : 
    1774      429962 :       if (LHSVal != RHSVal)
    1775      404225 :         return LHSVal < RHSVal;
    1776             :     }
    1777             :     return LHSNumParts < RHSNumParts;
    1778             :   }
    1779             : };
    1780             : 
    1781             : raw_ostream &operator<<(raw_ostream &OS, const RecordKeeper &RK);
    1782             : 
    1783             : /// Return an Init with a qualifier prefix referring
    1784             : /// to CurRec's name.
    1785             : Init *QualifyName(Record &CurRec, MultiClass *CurMultiClass,
    1786             :                   Init *Name, StringRef Scoper);
    1787             : 
    1788             : //===----------------------------------------------------------------------===//
    1789             : //  Resolvers
    1790             : //===----------------------------------------------------------------------===//
    1791             : 
    1792             : /// Interface for looking up the initializer for a variable name, used by
    1793             : /// Init::resolveReferences.
    1794             : class Resolver {
    1795             :   Record *CurRec;
    1796             :   bool IsFinal = false;
    1797             : 
    1798             : public:
    1799    23945462 :   explicit Resolver(Record *CurRec) : CurRec(CurRec) {}
    1800             :   virtual ~Resolver() {}
    1801             : 
    1802             :   Record *getCurrentRecord() const { return CurRec; }
    1803             : 
    1804             :   /// Return the initializer for the given variable name (should normally be a
    1805             :   /// StringInit), or nullptr if the name could not be resolved.
    1806             :   virtual Init *resolve(Init *VarName) = 0;
    1807             : 
    1808             :   // Whether bits in a BitsInit should stay unresolved if resolving them would
    1809             :   // result in a ? (UnsetInit). This behavior is used to represent instruction
    1810             :   // encodings by keeping references to unset variables within a record.
    1811    38173294 :   virtual bool keepUnsetBits() const { return false; }
    1812             : 
    1813             :   // Whether this is the final resolve step before adding a record to the
    1814             :   // RecordKeeper. Error reporting during resolve and related constant folding
    1815             :   // should only happen when this is true.
    1816             :   bool isFinal() const { return IsFinal; }
    1817             : 
    1818     4738631 :   void setFinal(bool Final) { IsFinal = Final; }
    1819             : };
    1820             : 
    1821             : /// Resolve arbitrary mappings.
    1822    12249759 : class MapResolver final : public Resolver {
    1823             :   struct MappedValue {
    1824             :     Init *V;
    1825             :     bool Resolved;
    1826             : 
    1827    25964813 :     MappedValue() : V(nullptr), Resolved(false) {}
    1828             :     MappedValue(Init *V, bool Resolved) : V(V), Resolved(Resolved) {}
    1829             :   };
    1830             : 
    1831             :   DenseMap<Init *, MappedValue> Map;
    1832             : 
    1833             : public:
    1834    22109902 :   explicit MapResolver(Record *CurRec = nullptr) : Resolver(CurRec) {}
    1835             : 
    1836    15843419 :   void set(Init *Key, Init *Value) { Map[Key] = {Value, false}; }
    1837             : 
    1838             :   Init *resolve(Init *VarName) override;
    1839             : };
    1840             : 
    1841             : /// Resolve all variables from a record except for unset variables.
    1842     6034060 : class RecordResolver final : public Resolver {
    1843             :   DenseMap<Init *, Init *> Cache;
    1844             :   SmallVector<Init *, 4> Stack;
    1845             : 
    1846             : public:
    1847     6034064 :   explicit RecordResolver(Record &R) : Resolver(&R) {}
    1848             : 
    1849             :   Init *resolve(Init *VarName) override;
    1850             : 
    1851    25920820 :   bool keepUnsetBits() const override { return true; }
    1852             : };
    1853             : 
    1854             : /// Resolve all references to a specific RecordVal.
    1855             : //
    1856             : // TODO: This is used for resolving references to template arguments, in a
    1857             : //       rather inefficient way. Change those uses to resolve all template
    1858             : //       arguments simultaneously and get rid of this class.
    1859           0 : class RecordValResolver final : public Resolver {
    1860             :   const RecordVal *RV;
    1861             : 
    1862             : public:
    1863             :   explicit RecordValResolver(Record &R, const RecordVal *RV)
    1864           0 :       : Resolver(&R), RV(RV) {}
    1865             : 
    1866           0 :   Init *resolve(Init *VarName) override {
    1867           0 :     if (VarName == RV->getNameInit())
    1868           0 :       return RV->getValue();
    1869             :     return nullptr;
    1870             :   }
    1871             : };
    1872             : 
    1873             : /// Delegate resolving to a sub-resolver, but shadow some variable names.
    1874     1721599 : class ShadowResolver final : public Resolver {
    1875             :   Resolver &R;
    1876             :   DenseSet<Init *> Shadowed;
    1877             : 
    1878             : public:
    1879             :   explicit ShadowResolver(Resolver &R)
    1880     3443198 :       : Resolver(R.getCurrentRecord()), R(R) {
    1881     1721599 :     setFinal(R.isFinal());
    1882             :   }
    1883             : 
    1884             :   void addShadow(Init *Key) { Shadowed.insert(Key); }
    1885             : 
    1886     3388762 :   Init *resolve(Init *VarName) override {
    1887             :     if (Shadowed.count(VarName))
    1888             :       return nullptr;
    1889      397245 :     return R.resolve(VarName);
    1890             :   }
    1891             : };
    1892             : 
    1893             : /// (Optionally) delegate resolving to a sub-resolver, and keep track whether
    1894             : /// there were unresolved references.
    1895           0 : class TrackUnresolvedResolver final : public Resolver {
    1896             :   Resolver *R;
    1897             :   bool FoundUnresolved = false;
    1898             : 
    1899             : public:
    1900             :   explicit TrackUnresolvedResolver(Resolver *R = nullptr)
    1901    16303760 :       : Resolver(R ? R->getCurrentRecord() : nullptr), R(R) {}
    1902             : 
    1903             :   bool foundUnresolved() const { return FoundUnresolved; }
    1904             : 
    1905             :   Init *resolve(Init *VarName) override;
    1906             : };
    1907             : 
    1908             : } // end namespace llvm
    1909             : 
    1910             : #endif // LLVM_TABLEGEN_RECORD_H

Generated by: LCOV version 1.13