LCOV - code coverage report
Current view: top level - lib/TableGen - Record.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 975 1072 91.0 %
Date: 2018-10-20 13:21:21 Functions: 156 165 94.5 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- Record.cpp - Record implementation ---------------------------------===//
       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             : // Implement the tablegen record classes.
      11             : //
      12             : //===----------------------------------------------------------------------===//
      13             : 
      14             : #include "llvm/ADT/ArrayRef.h"
      15             : #include "llvm/ADT/DenseMap.h"
      16             : #include "llvm/ADT/FoldingSet.h"
      17             : #include "llvm/ADT/SmallString.h"
      18             : #include "llvm/ADT/SmallVector.h"
      19             : #include "llvm/ADT/StringExtras.h"
      20             : #include "llvm/ADT/StringMap.h"
      21             : #include "llvm/ADT/StringRef.h"
      22             : #include "llvm/Config/llvm-config.h"
      23             : #include "llvm/Support/Allocator.h"
      24             : #include "llvm/Support/Casting.h"
      25             : #include "llvm/Support/Compiler.h"
      26             : #include "llvm/Support/ErrorHandling.h"
      27             : #include "llvm/Support/SMLoc.h"
      28             : #include "llvm/Support/raw_ostream.h"
      29             : #include "llvm/TableGen/Error.h"
      30             : #include "llvm/TableGen/Record.h"
      31             : #include <cassert>
      32             : #include <cstdint>
      33             : #include <memory>
      34             : #include <string>
      35             : #include <utility>
      36             : #include <vector>
      37             : 
      38             : using namespace llvm;
      39             : 
      40             : static BumpPtrAllocator Allocator;
      41             : 
      42             : //===----------------------------------------------------------------------===//
      43             : //    Type implementations
      44             : //===----------------------------------------------------------------------===//
      45             : 
      46             : BitRecTy BitRecTy::Shared;
      47             : CodeRecTy CodeRecTy::Shared;
      48             : IntRecTy IntRecTy::Shared;
      49             : StringRecTy StringRecTy::Shared;
      50             : DagRecTy DagRecTy::Shared;
      51             : 
      52             : #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
      53             : LLVM_DUMP_METHOD void RecTy::dump() const { print(errs()); }
      54             : #endif
      55             : 
      56     1270742 : ListRecTy *RecTy::getListTy() {
      57     1270742 :   if (!ListTy)
      58       14170 :     ListTy = new(Allocator) ListRecTy(this);
      59     1270742 :   return ListTy;
      60             : }
      61             : 
      62       62633 : bool RecTy::typeIsConvertibleTo(const RecTy *RHS) const {
      63             :   assert(RHS && "NULL pointer");
      64       62633 :   return Kind == RHS->getRecTyKind();
      65             : }
      66             : 
      67     1107380 : bool RecTy::typeIsA(const RecTy *RHS) const { return this == RHS; }
      68             : 
      69        2728 : bool BitRecTy::typeIsConvertibleTo(const RecTy *RHS) const{
      70        2728 :   if (RecTy::typeIsConvertibleTo(RHS) || RHS->getRecTyKind() == IntRecTyKind)
      71             :     return true;
      72             :   if (const BitsRecTy *BitsTy = dyn_cast<BitsRecTy>(RHS))
      73          15 :     return BitsTy->getNumBits() == 1;
      74             :   return false;
      75             : }
      76             : 
      77     1130458 : BitsRecTy *BitsRecTy::get(unsigned Sz) {
      78     1130458 :   static std::vector<BitsRecTy*> Shared;
      79     2260916 :   if (Sz >= Shared.size())
      80         603 :     Shared.resize(Sz + 1);
      81     1130458 :   BitsRecTy *&Ty = Shared[Sz];
      82     1130458 :   if (!Ty)
      83        2954 :     Ty = new(Allocator) BitsRecTy(Sz);
      84     1130458 :   return Ty;
      85             : }
      86             : 
      87         250 : std::string BitsRecTy::getAsString() const {
      88         500 :   return "bits<" + utostr(Size) + ">";
      89             : }
      90             : 
      91        3356 : bool BitsRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
      92        3356 :   if (RecTy::typeIsConvertibleTo(RHS)) //argument and the sender are same type
      93          11 :     return cast<BitsRecTy>(RHS)->Size == Size;
      94        3345 :   RecTyKind kind = RHS->getRecTyKind();
      95        3345 :   return (kind == BitRecTyKind && Size == 1) || (kind == IntRecTyKind);
      96             : }
      97             : 
      98       27810 : bool BitsRecTy::typeIsA(const RecTy *RHS) const {
      99             :   if (const BitsRecTy *RHSb = dyn_cast<BitsRecTy>(RHS))
     100           8 :     return RHSb->Size == Size;
     101             :   return false;
     102             : }
     103             : 
     104      362022 : bool IntRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
     105      362022 :   RecTyKind kind = RHS->getRecTyKind();
     106      362022 :   return kind==BitRecTyKind || kind==BitsRecTyKind || kind==IntRecTyKind;
     107             : }
     108             : 
     109         143 : bool CodeRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
     110         143 :   RecTyKind Kind = RHS->getRecTyKind();
     111         143 :   return Kind == CodeRecTyKind || Kind == StringRecTyKind;
     112             : }
     113             : 
     114         516 : std::string StringRecTy::getAsString() const {
     115         516 :   return "string";
     116             : }
     117             : 
     118       59850 : bool StringRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
     119       59850 :   RecTyKind Kind = RHS->getRecTyKind();
     120       59850 :   return Kind == StringRecTyKind || Kind == CodeRecTyKind;
     121             : }
     122             : 
     123         248 : std::string ListRecTy::getAsString() const {
     124         496 :   return "list<" + Ty->getAsString() + ">";
     125             : }
     126             : 
     127      164410 : bool ListRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
     128             :   if (const auto *ListTy = dyn_cast<ListRecTy>(RHS))
     129      164410 :     return Ty->typeIsConvertibleTo(ListTy->getElementType());
     130             :   return false;
     131             : }
     132             : 
     133     3154909 : bool ListRecTy::typeIsA(const RecTy *RHS) const {
     134             :   if (const ListRecTy *RHSl = dyn_cast<ListRecTy>(RHS))
     135     3154909 :     return getElementType()->typeIsA(RHSl->getElementType());
     136             :   return false;
     137             : }
     138             : 
     139         178 : std::string DagRecTy::getAsString() const {
     140         178 :   return "dag";
     141             : }
     142             : 
     143     3844850 : static void ProfileRecordRecTy(FoldingSetNodeID &ID,
     144             :                                ArrayRef<Record *> Classes) {
     145     3844850 :   ID.AddInteger(Classes.size());
     146     8858871 :   for (Record *R : Classes)
     147     5014021 :     ID.AddPointer(R);
     148     3844850 : }
     149             : 
     150     1651259 : RecordRecTy *RecordRecTy::get(ArrayRef<Record *> UnsortedClasses) {
     151     1651259 :   if (UnsortedClasses.empty()) {
     152        2506 :     static RecordRecTy AnyRecord(0);
     153        2506 :     return &AnyRecord;
     154             :   }
     155             : 
     156             :   FoldingSet<RecordRecTy> &ThePool =
     157     1648753 :       UnsortedClasses[0]->getRecords().RecordTypePool;
     158             : 
     159             :   SmallVector<Record *, 4> Classes(UnsortedClasses.begin(),
     160             :                                    UnsortedClasses.end());
     161             :   llvm::sort(Classes, [](Record *LHS, Record *RHS) {
     162             :     return LHS->getNameInitAsString() < RHS->getNameInitAsString();
     163             :   });
     164             : 
     165             :   FoldingSetNodeID ID;
     166     1648753 :   ProfileRecordRecTy(ID, Classes);
     167             : 
     168     1648753 :   void *IP = nullptr;
     169     1580013 :   if (RecordRecTy *Ty = ThePool.FindNodeOrInsertPos(ID, IP))
     170             :     return Ty;
     171             : 
     172             : #ifndef NDEBUG
     173             :   // Check for redundancy.
     174             :   for (unsigned i = 0; i < Classes.size(); ++i) {
     175             :     for (unsigned j = 0; j < Classes.size(); ++j) {
     176             :       assert(i == j || !Classes[i]->isSubClassOf(Classes[j]));
     177             :     }
     178             :     assert(&Classes[0]->getRecords() == &Classes[i]->getRecords());
     179             :   }
     180             : #endif
     181             : 
     182      137480 :   void *Mem = Allocator.Allocate(totalSizeToAlloc<Record *>(Classes.size()),
     183             :                                  alignof(RecordRecTy));
     184       68740 :   RecordRecTy *Ty = new(Mem) RecordRecTy(Classes.size());
     185             :   std::uninitialized_copy(Classes.begin(), Classes.end(),
     186             :                           Ty->getTrailingObjects<Record *>());
     187       68740 :   ThePool.InsertNode(Ty, IP);
     188       68740 :   return Ty;
     189             : }
     190             : 
     191     2196097 : void RecordRecTy::Profile(FoldingSetNodeID &ID) const {
     192     2196097 :   ProfileRecordRecTy(ID, getClasses());
     193     2196097 : }
     194             : 
     195         127 : std::string RecordRecTy::getAsString() const {
     196         127 :   if (NumClasses == 1)
     197         125 :     return getClasses()[0]->getNameInitAsString();
     198             : 
     199           2 :   std::string Str = "{";
     200             :   bool First = true;
     201           2 :   for (Record *R : getClasses()) {
     202           0 :     if (!First)
     203             :       Str += ", ";
     204             :     First = false;
     205           0 :     Str += R->getNameInitAsString();
     206             :   }
     207             :   Str += "}";
     208             :   return Str;
     209             : }
     210             : 
     211     7704059 : bool RecordRecTy::isSubClassOf(Record *Class) const {
     212             :   return llvm::any_of(getClasses(), [Class](Record *MySuperClass) {
     213           0 :                                       return MySuperClass == Class ||
     214             :                                              MySuperClass->isSubClassOf(Class);
     215     7704059 :                                     });
     216             : }
     217             : 
     218    10636093 : bool RecordRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
     219    10636093 :   if (this == RHS)
     220             :     return true;
     221             : 
     222             :   const RecordRecTy *RTy = dyn_cast<RecordRecTy>(RHS);
     223             :   if (!RTy)
     224             :     return false;
     225             : 
     226             :   return llvm::all_of(RTy->getClasses(), [this](Record *TargetClass) {
     227           0 :                                            return isSubClassOf(TargetClass);
     228             :                                          });
     229             : }
     230             : 
     231     6741791 : bool RecordRecTy::typeIsA(const RecTy *RHS) const {
     232     6741791 :   return typeIsConvertibleTo(RHS);
     233             : }
     234             : 
     235      235713 : static RecordRecTy *resolveRecordTypes(RecordRecTy *T1, RecordRecTy *T2) {
     236             :   SmallVector<Record *, 4> CommonSuperClasses;
     237             :   SmallVector<Record *, 4> Stack;
     238             : 
     239      235713 :   Stack.insert(Stack.end(), T1->classes_begin(), T1->classes_end());
     240             : 
     241      667497 :   while (!Stack.empty()) {
     242      431784 :     Record *R = Stack.back();
     243             :     Stack.pop_back();
     244             : 
     245      431784 :     if (T2->isSubClassOf(R)) {
     246      240897 :       CommonSuperClasses.push_back(R);
     247             :     } else {
     248      190887 :       R->getDirectSuperClasses(Stack);
     249             :     }
     250             :   }
     251             : 
     252      235713 :   return RecordRecTy::get(CommonSuperClasses);
     253             : }
     254             : 
     255     2190248 : RecTy *llvm::resolveTypes(RecTy *T1, RecTy *T2) {
     256     2190248 :   if (T1 == T2)
     257             :     return T1;
     258             : 
     259             :   if (RecordRecTy *RecTy1 = dyn_cast<RecordRecTy>(T1)) {
     260             :     if (RecordRecTy *RecTy2 = dyn_cast<RecordRecTy>(T2))
     261      235713 :       return resolveRecordTypes(RecTy1, RecTy2);
     262             :   }
     263             : 
     264        4416 :   if (T1->typeIsConvertibleTo(T2))
     265             :     return T2;
     266         602 :   if (T2->typeIsConvertibleTo(T1))
     267             :     return T1;
     268             : 
     269             :   if (ListRecTy *ListTy1 = dyn_cast<ListRecTy>(T1)) {
     270             :     if (ListRecTy *ListTy2 = dyn_cast<ListRecTy>(T2)) {
     271           0 :       RecTy* NewType = resolveTypes(ListTy1->getElementType(),
     272             :                                     ListTy2->getElementType());
     273           0 :       if (NewType)
     274           0 :         return NewType->getListTy();
     275             :     }
     276             :   }
     277             : 
     278             :   return nullptr;
     279             : }
     280             : 
     281             : //===----------------------------------------------------------------------===//
     282             : //    Initializer implementations
     283             : //===----------------------------------------------------------------------===//
     284             : 
     285           0 : void Init::anchor() {}
     286             : 
     287             : #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
     288             : LLVM_DUMP_METHOD void Init::dump() const { return print(errs()); }
     289             : #endif
     290             : 
     291     1032694 : UnsetInit *UnsetInit::get() {
     292     1032694 :   static UnsetInit TheInit;
     293     1032694 :   return &TheInit;
     294             : }
     295             : 
     296    11829417 : Init *UnsetInit::getCastTo(RecTy *Ty) const {
     297    11829417 :   return const_cast<UnsetInit *>(this);
     298             : }
     299             : 
     300       23820 : Init *UnsetInit::convertInitializerTo(RecTy *Ty) const {
     301       23820 :   return const_cast<UnsetInit *>(this);
     302             : }
     303             : 
     304    12112811 : BitInit *BitInit::get(bool V) {
     305    12112811 :   static BitInit True(true);
     306    12112811 :   static BitInit False(false);
     307             : 
     308    12112811 :   return V ? &True : &False;
     309             : }
     310             : 
     311     3133206 : Init *BitInit::convertInitializerTo(RecTy *Ty) const {
     312     3133206 :   if (isa<BitRecTy>(Ty))
     313        2175 :     return const_cast<BitInit *>(this);
     314             : 
     315     3131031 :   if (isa<IntRecTy>(Ty))
     316     3131031 :     return IntInit::get(getValue());
     317             : 
     318             :   if (auto *BRT = dyn_cast<BitsRecTy>(Ty)) {
     319             :     // Can only convert single bit.
     320           0 :     if (BRT->getNumBits() == 1)
     321           0 :       return BitsInit::get(const_cast<BitInit *>(this));
     322             :   }
     323             : 
     324             :   return nullptr;
     325             : }
     326             : 
     327             : static void
     328    22010063 : ProfileBitsInit(FoldingSetNodeID &ID, ArrayRef<Init *> Range) {
     329    22010063 :   ID.AddInteger(Range.size());
     330             : 
     331   505646599 :   for (Init *I : Range)
     332   483636536 :     ID.AddPointer(I);
     333    22010063 : }
     334             : 
     335     7683084 : BitsInit *BitsInit::get(ArrayRef<Init *> Range) {
     336     7683299 :   static FoldingSet<BitsInit> ThePool;
     337             : 
     338             :   FoldingSetNodeID ID;
     339     7683084 :   ProfileBitsInit(ID, Range);
     340             : 
     341     7683084 :   void *IP = nullptr;
     342     6880109 :   if (BitsInit *I = ThePool.FindNodeOrInsertPos(ID, IP))
     343             :     return I;
     344             : 
     345      802975 :   void *Mem = Allocator.Allocate(totalSizeToAlloc<Init *>(Range.size()),
     346             :                                  alignof(BitsInit));
     347      802975 :   BitsInit *I = new(Mem) BitsInit(Range.size());
     348             :   std::uninitialized_copy(Range.begin(), Range.end(),
     349             :                           I->getTrailingObjects<Init *>());
     350      802975 :   ThePool.InsertNode(I, IP);
     351      802975 :   return I;
     352             : }
     353             : 
     354    14326979 : void BitsInit::Profile(FoldingSetNodeID &ID) const {
     355    28653958 :   ProfileBitsInit(ID, makeArrayRef(getTrailingObjects<Init *>(), NumBits));
     356    14326979 : }
     357             : 
     358     2613358 : Init *BitsInit::convertInitializerTo(RecTy *Ty) const {
     359     2613358 :   if (isa<BitRecTy>(Ty)) {
     360        1393 :     if (getNumBits() != 1) return nullptr; // Only accept if just one bit!
     361        1393 :     return getBit(0);
     362             :   }
     363             : 
     364             :   if (auto *BRT = dyn_cast<BitsRecTy>(Ty)) {
     365             :     // If the number of bits is right, return it.  Otherwise we need to expand
     366             :     // or truncate.
     367      147818 :     if (getNumBits() != BRT->getNumBits()) return nullptr;
     368      147810 :     return const_cast<BitsInit *>(this);
     369             :   }
     370             : 
     371     2464147 :   if (isa<IntRecTy>(Ty)) {
     372             :     int64_t Result = 0;
     373     7848671 :     for (unsigned i = 0, e = getNumBits(); i != e; ++i)
     374             :       if (auto *Bit = dyn_cast<BitInit>(getBit(i)))
     375     5384524 :         Result |= static_cast<int64_t>(Bit->getValue()) << i;
     376             :       else
     377             :         return nullptr;
     378     2462792 :     return IntInit::get(Result);
     379             :   }
     380             : 
     381             :   return nullptr;
     382             : }
     383             : 
     384             : Init *
     385           0 : BitsInit::convertInitializerBitRange(ArrayRef<unsigned> Bits) const {
     386           0 :   SmallVector<Init *, 16> NewBits(Bits.size());
     387             : 
     388           0 :   for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
     389           0 :     if (Bits[i] >= getNumBits())
     390             :       return nullptr;
     391           0 :     NewBits[i] = getBit(Bits[i]);
     392             :   }
     393           0 :   return BitsInit::get(NewBits);
     394             : }
     395             : 
     396       12187 : bool BitsInit::isConcrete() const {
     397       67586 :   for (unsigned i = 0, e = getNumBits(); i != e; ++i) {
     398       55399 :     if (!getBit(i)->isConcrete())
     399             :       return false;
     400             :   }
     401             :   return true;
     402             : }
     403             : 
     404        1150 : std::string BitsInit::getAsString() const {
     405        1150 :   std::string Result = "{ ";
     406        6122 :   for (unsigned i = 0, e = getNumBits(); i != e; ++i) {
     407        4972 :     if (i) Result += ", ";
     408        9944 :     if (Init *Bit = getBit(e-i-1))
     409        9944 :       Result += Bit->getAsString();
     410             :     else
     411             :       Result += "*";
     412             :   }
     413        1150 :   return Result + " }";
     414             : }
     415             : 
     416             : // resolveReferences - If there are any field references that refer to fields
     417             : // that have been filled in, we can propagate the values now.
     418    31139611 : Init *BitsInit::resolveReferences(Resolver &R) const {
     419             :   bool Changed = false;
     420    31139611 :   SmallVector<Init *, 16> NewBits(getNumBits());
     421             : 
     422             :   Init *CachedBitVarRef = nullptr;
     423             :   Init *CachedBitVarResolved = nullptr;
     424             : 
     425   322580399 :   for (unsigned i = 0, e = getNumBits(); i != e; ++i) {
     426             :     Init *CurBit = getBit(i);
     427             :     Init *NewBit = CurBit;
     428             : 
     429             :     if (VarBitInit *CurBitVar = dyn_cast<VarBitInit>(CurBit)) {
     430   115068335 :       if (CurBitVar->getBitVar() != CachedBitVarRef) {
     431             :         CachedBitVarRef = CurBitVar->getBitVar();
     432    29286976 :         CachedBitVarResolved = CachedBitVarRef->resolveReferences(R);
     433             :       }
     434             : 
     435   115068335 :       NewBit = CachedBitVarResolved->getBit(CurBitVar->getBitNum());
     436             :     } else {
     437             :       // getBit(0) implicitly converts int and bits<1> values to bit.
     438   176372453 :       NewBit = CurBit->resolveReferences(R)->getBit(0);
     439             :     }
     440             : 
     441   291440788 :     if (isa<UnsetInit>(NewBit) && R.keepUnsetBits())
     442             :       NewBit = CurBit;
     443   291440788 :     NewBits[i] = NewBit;
     444   291440788 :     Changed |= CurBit != NewBit;
     445             :   }
     446             : 
     447    31139611 :   if (Changed)
     448     5844714 :     return BitsInit::get(NewBits);
     449             : 
     450    25294897 :   return const_cast<BitsInit *>(this);
     451             : }
     452             : 
     453     9961560 : IntInit *IntInit::get(int64_t V) {
     454     9961883 :   static DenseMap<int64_t, IntInit*> ThePool;
     455             : 
     456             :   IntInit *&I = ThePool[V];
     457    10101302 :   if (!I) I = new(Allocator) IntInit(V);
     458     9961560 :   return I;
     459             : }
     460             : 
     461     4497415 : std::string IntInit::getAsString() const {
     462     4497415 :   return itostr(Value);
     463             : }
     464             : 
     465             : static bool canFitInBitfield(int64_t Value, unsigned NumBits) {
     466             :   // For example, with NumBits == 4, we permit Values from [-7 .. 15].
     467     1135277 :   return (NumBits >= sizeof(Value) * 8) ||
     468     1135277 :          (Value >> NumBits == 0) || (Value >> (NumBits-1) == -1);
     469             : }
     470             : 
     471     6189485 : Init *IntInit::convertInitializerTo(RecTy *Ty) const {
     472     6189485 :   if (isa<IntRecTy>(Ty))
     473     4356500 :     return const_cast<IntInit *>(this);
     474             : 
     475     1832985 :   if (isa<BitRecTy>(Ty)) {
     476      697429 :     int64_t Val = getValue();
     477      697429 :     if (Val != 0 && Val != 1) return nullptr;  // Only accept 0 or 1 for a bit!
     478      697426 :     return BitInit::get(Val != 0);
     479             :   }
     480             : 
     481             :   if (auto *BRT = dyn_cast<BitsRecTy>(Ty)) {
     482     1135556 :     int64_t Value = getValue();
     483             :     // Make sure this bitfield is large enough to hold the integer value.
     484     1135556 :     if (!canFitInBitfield(Value, BRT->getNumBits()))
     485             :       return nullptr;
     486             : 
     487     1135553 :     SmallVector<Init *, 16> NewBits(BRT->getNumBits());
     488     8284169 :     for (unsigned i = 0; i != BRT->getNumBits(); ++i)
     489     7148616 :       NewBits[i] = BitInit::get(Value & ((i < 64) ? (1LL << i) : 0));
     490             : 
     491     1135553 :     return BitsInit::get(NewBits);
     492             :   }
     493             : 
     494             :   return nullptr;
     495             : }
     496             : 
     497             : Init *
     498           0 : IntInit::convertInitializerBitRange(ArrayRef<unsigned> Bits) const {
     499           0 :   SmallVector<Init *, 16> NewBits(Bits.size());
     500             : 
     501           0 :   for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
     502           0 :     if (Bits[i] >= 64)
     503             :       return nullptr;
     504             : 
     505           0 :     NewBits[i] = BitInit::get(Value & (INT64_C(1) << Bits[i]));
     506             :   }
     507           0 :   return BitsInit::get(NewBits);
     508             : }
     509             : 
     510       21770 : CodeInit *CodeInit::get(StringRef V) {
     511       21770 :   static StringMap<CodeInit*, BumpPtrAllocator &> ThePool(Allocator);
     512             : 
     513       21770 :   auto &Entry = *ThePool.insert(std::make_pair(V, nullptr)).first;
     514       21770 :   if (!Entry.second)
     515       17475 :     Entry.second = new(Allocator) CodeInit(Entry.getKey());
     516       21770 :   return Entry.second;
     517             : }
     518             : 
     519   123607674 : StringInit *StringInit::get(StringRef V) {
     520   123607674 :   static StringMap<StringInit*, BumpPtrAllocator &> ThePool(Allocator);
     521             : 
     522   123607674 :   auto &Entry = *ThePool.insert(std::make_pair(V, nullptr)).first;
     523   123607674 :   if (!Entry.second)
     524     7922508 :     Entry.second = new(Allocator) StringInit(Entry.getKey());
     525   123607674 :   return Entry.second;
     526             : }
     527             : 
     528      436847 : Init *StringInit::convertInitializerTo(RecTy *Ty) const {
     529      436847 :   if (isa<StringRecTy>(Ty))
     530           0 :     return const_cast<StringInit *>(this);
     531      436847 :   if (isa<CodeRecTy>(Ty))
     532        1040 :     return CodeInit::get(getValue());
     533             : 
     534             :   return nullptr;
     535             : }
     536             : 
     537          60 : Init *CodeInit::convertInitializerTo(RecTy *Ty) const {
     538          60 :   if (isa<CodeRecTy>(Ty))
     539           0 :     return const_cast<CodeInit *>(this);
     540          60 :   if (isa<StringRecTy>(Ty))
     541          60 :     return StringInit::get(getValue());
     542             : 
     543             :   return nullptr;
     544             : }
     545             : 
     546    18098855 : static void ProfileListInit(FoldingSetNodeID &ID,
     547             :                             ArrayRef<Init *> Range,
     548             :                             RecTy *EltTy) {
     549    18098855 :   ID.AddInteger(Range.size());
     550    18098855 :   ID.AddPointer(EltTy);
     551             : 
     552    62914202 :   for (Init *I : Range)
     553    44815347 :     ID.AddPointer(I);
     554    18098855 : }
     555             : 
     556     6388959 : ListInit *ListInit::get(ArrayRef<Init *> Range, RecTy *EltTy) {
     557     6389242 :   static FoldingSet<ListInit> ThePool;
     558             : 
     559             :   FoldingSetNodeID ID;
     560     6388959 :   ProfileListInit(ID, Range, EltTy);
     561             : 
     562     6388959 :   void *IP = nullptr;
     563     5183701 :   if (ListInit *I = ThePool.FindNodeOrInsertPos(ID, IP))
     564             :     return I;
     565             : 
     566             :   assert(Range.empty() || !isa<TypedInit>(Range[0]) ||
     567             :          cast<TypedInit>(Range[0])->getType()->typeIsConvertibleTo(EltTy));
     568             : 
     569     1205258 :   void *Mem = Allocator.Allocate(totalSizeToAlloc<Init *>(Range.size()),
     570             :                                  alignof(ListInit));
     571     1205258 :   ListInit *I = new(Mem) ListInit(Range.size(), EltTy);
     572             :   std::uninitialized_copy(Range.begin(), Range.end(),
     573             :                           I->getTrailingObjects<Init *>());
     574     1205258 :   ThePool.InsertNode(I, IP);
     575     1205258 :   return I;
     576             : }
     577             : 
     578    11709896 : void ListInit::Profile(FoldingSetNodeID &ID) const {
     579    11709896 :   RecTy *EltTy = cast<ListRecTy>(getType())->getElementType();
     580             : 
     581    11709896 :   ProfileListInit(ID, getValues(), EltTy);
     582    11709896 : }
     583             : 
     584          26 : Init *ListInit::convertInitializerTo(RecTy *Ty) const {
     585          26 :   if (getType() == Ty)
     586           0 :     return const_cast<ListInit*>(this);
     587             : 
     588             :   if (auto *LRT = dyn_cast<ListRecTy>(Ty)) {
     589             :     SmallVector<Init*, 8> Elements;
     590             :     Elements.reserve(getValues().size());
     591             : 
     592             :     // Verify that all of the elements of the list are subclasses of the
     593             :     // appropriate class!
     594             :     bool Changed = false;
     595          26 :     RecTy *ElementType = LRT->getElementType();
     596          91 :     for (Init *I : getValues())
     597          65 :       if (Init *CI = I->convertInitializerTo(ElementType)) {
     598          65 :         Elements.push_back(CI);
     599          65 :         if (CI != I)
     600             :           Changed = true;
     601             :       } else
     602           0 :         return nullptr;
     603             : 
     604          26 :     if (!Changed)
     605           0 :       return const_cast<ListInit*>(this);
     606          26 :     return ListInit::get(Elements, ElementType);
     607             :   }
     608             : 
     609             :   return nullptr;
     610             : }
     611             : 
     612        1118 : Init *ListInit::convertInitListSlice(ArrayRef<unsigned> Elements) const {
     613             :   SmallVector<Init*, 8> Vals;
     614             :   Vals.reserve(Elements.size());
     615       11930 :   for (unsigned Element : Elements) {
     616       10812 :     if (Element >= size())
     617             :       return nullptr;
     618       10812 :     Vals.push_back(getElement(Element));
     619             :   }
     620        1118 :   return ListInit::get(Vals, getElementType());
     621             : }
     622             : 
     623     2014601 : Record *ListInit::getElementAsRecord(unsigned i) const {
     624             :   assert(i < NumValues && "List element index out of range!");
     625             :   DefInit *DI = dyn_cast<DefInit>(getElement(i));
     626             :   if (!DI)
     627           0 :     PrintFatalError("Expected record in list!");
     628     2014601 :   return DI->getDef();
     629             : }
     630             : 
     631    29709601 : Init *ListInit::resolveReferences(Resolver &R) const {
     632             :   SmallVector<Init*, 8> Resolved;
     633    29709601 :   Resolved.reserve(size());
     634             :   bool Changed = false;
     635             : 
     636    62134344 :   for (Init *CurElt : getValues()) {
     637    32424743 :     Init *E = CurElt->resolveReferences(R);
     638    32424743 :     Changed |= E != CurElt;
     639    32424743 :     Resolved.push_back(E);
     640             :   }
     641             : 
     642    29709601 :   if (Changed)
     643     1496999 :     return ListInit::get(Resolved, getElementType());
     644    28212602 :   return const_cast<ListInit *>(this);
     645             : }
     646             : 
     647    10223267 : bool ListInit::isConcrete() const {
     648    20782060 :   for (Init *Element : *this) {
     649    10558793 :     if (!Element->isConcrete())
     650             :       return false;
     651             :   }
     652             :   return true;
     653             : }
     654             : 
     655         131 : std::string ListInit::getAsString() const {
     656         131 :   std::string Result = "[";
     657             :   const char *sep = "";
     658         425 :   for (Init *Element : *this) {
     659             :     Result += sep;
     660             :     sep = ", ";
     661         588 :     Result += Element->getAsString();
     662             :   }
     663         131 :   return Result + "]";
     664             : }
     665             : 
     666     8103102 : Init *OpInit::getBit(unsigned Bit) const {
     667     8103102 :   if (getType() == BitRecTy::get())
     668         211 :     return const_cast<OpInit*>(this);
     669     8102891 :   return VarBitInit::get(const_cast<OpInit*>(this), Bit);
     670             : }
     671             : 
     672             : static void
     673    10116671 : ProfileUnOpInit(FoldingSetNodeID &ID, unsigned Opcode, Init *Op, RecTy *Type) {
     674    10116671 :   ID.AddInteger(Opcode);
     675    10116671 :   ID.AddPointer(Op);
     676    10116671 :   ID.AddPointer(Type);
     677    10116671 : }
     678             : 
     679     3967195 : UnOpInit *UnOpInit::get(UnaryOp Opc, Init *LHS, RecTy *Type) {
     680     3967433 :   static FoldingSet<UnOpInit> ThePool;
     681             : 
     682             :   FoldingSetNodeID ID;
     683     3967195 :   ProfileUnOpInit(ID, Opc, LHS, Type);
     684             : 
     685     3967195 :   void *IP = nullptr;
     686     3567557 :   if (UnOpInit *I = ThePool.FindNodeOrInsertPos(ID, IP))
     687             :     return I;
     688             : 
     689             :   UnOpInit *I = new(Allocator) UnOpInit(Opc, LHS, Type);
     690      399638 :   ThePool.InsertNode(I, IP);
     691      399638 :   return I;
     692             : }
     693             : 
     694     6149476 : void UnOpInit::Profile(FoldingSetNodeID &ID) const {
     695     6149476 :   ProfileUnOpInit(ID, getOpcode(), getOperand(), getType());
     696     6149476 : }
     697             : 
     698     3966685 : Init *UnOpInit::Fold(Record *CurRec, bool IsFinal) const {
     699     3966685 :   switch (getOpcode()) {
     700     3724032 :   case CAST:
     701     7448064 :     if (isa<StringRecTy>(getType())) {
     702      254103 :       if (StringInit *LHSs = dyn_cast<StringInit>(LHS))
     703             :         return LHSs;
     704             : 
     705             :       if (DefInit *LHSd = dyn_cast<DefInit>(LHS))
     706       69220 :         return StringInit::get(LHSd->getAsString());
     707             : 
     708             :       if (IntInit *LHSi = dyn_cast<IntInit>(LHS))
     709      166267 :         return StringInit::get(LHSi->getAsString());
     710     3469929 :     } else if (isa<RecordRecTy>(getType())) {
     711     2001049 :       if (StringInit *Name = dyn_cast<StringInit>(LHS)) {
     712     1896262 :         if (!CurRec && !IsFinal)
     713             :           break;
     714             :         assert(CurRec && "NULL pointer");
     715             :         Record *D;
     716             : 
     717             :         // Self-references are allowed, but their resolution is delayed until
     718             :         // the final resolve to ensure that we get the correct type for them.
     719     1896260 :         if (Name == CurRec->getNameInit()) {
     720      109838 :           if (!IsFinal)
     721             :             break;
     722             :           D = CurRec;
     723             :         } else {
     724     1786422 :           D = CurRec->getRecords().getDef(Name->getValue());
     725     1786422 :           if (!D) {
     726      234737 :             if (IsFinal)
     727           1 :               PrintFatalError(CurRec->getLoc(),
     728             :                               Twine("Undefined reference to record: '") +
     729           1 :                               Name->getValue() + "'\n");
     730             :             break;
     731             :           }
     732             :         }
     733             : 
     734     1659969 :         DefInit *DI = DefInit::get(D);
     735     1659969 :         if (!DI->getType()->typeIsA(getType())) {
     736           1 :           PrintFatalError(CurRec->getLoc(),
     737             :                           Twine("Expected type '") +
     738           1 :                           getType()->getAsString() + "', got '" +
     739           1 :                           DI->getType()->getAsString() + "' in: " +
     740           1 :                           getAsString() + "\n");
     741             :         }
     742             :         return DI;
     743             :       }
     744             :     }
     745             : 
     746     1595853 :     if (Init *NewInit = LHS->convertInitializerTo(getType()))
     747      120263 :       return NewInit;
     748             :     break;
     749             : 
     750        2472 :   case HEAD:
     751        2472 :     if (ListInit *LHSl = dyn_cast<ListInit>(LHS)) {
     752             :       assert(!LHSl->empty() && "Empty list in head");
     753        2233 :       return LHSl->getElement(0);
     754             :     }
     755             :     break;
     756             : 
     757        4472 :   case TAIL:
     758        4472 :     if (ListInit *LHSl = dyn_cast<ListInit>(LHS)) {
     759             :       assert(!LHSl->empty() && "Empty list in tail");
     760             :       // Note the +1.  We can't just pass the result of getValues()
     761             :       // directly.
     762        4210 :       return ListInit::get(LHSl->getValues().slice(1), LHSl->getElementType());
     763             :     }
     764             :     break;
     765             : 
     766      199815 :   case SIZE:
     767      199815 :     if (ListInit *LHSl = dyn_cast<ListInit>(LHS))
     768      180523 :       return IntInit::get(LHSl->size());
     769             :     break;
     770             : 
     771       35894 :   case EMPTY:
     772       35894 :     if (ListInit *LHSl = dyn_cast<ListInit>(LHS))
     773       71066 :       return IntInit::get(LHSl->empty());
     774             :     if (StringInit *LHSs = dyn_cast<StringInit>(LHS))
     775           0 :       return IntInit::get(LHSs->getValue().empty());
     776             :     break;
     777             :   }
     778      376709 :   return const_cast<UnOpInit *>(this);
     779             : }
     780             : 
     781     5695981 : Init *UnOpInit::resolveReferences(Resolver &R) const {
     782     5695981 :   Init *lhs = LHS->resolveReferences(R);
     783             : 
     784     5695981 :   if (LHS != lhs || (R.isFinal() && getOpcode() == CAST))
     785     3923327 :     return (UnOpInit::get(getOpcode(), lhs, getType()))
     786     3923327 :         ->Fold(R.getCurrentRecord(), R.isFinal());
     787     1772654 :   return const_cast<UnOpInit *>(this);
     788             : }
     789             : 
     790          82 : std::string UnOpInit::getAsString() const {
     791             :   std::string Result;
     792          82 :   switch (getOpcode()) {
     793         136 :   case CAST: Result = "!cast<" + getType()->getAsString() + ">"; break;
     794             :   case HEAD: Result = "!head"; break;
     795             :   case TAIL: Result = "!tail"; break;
     796             :   case SIZE: Result = "!size"; break;
     797             :   case EMPTY: Result = "!empty"; break;
     798             :   }
     799         165 :   return Result + "(" + LHS->getAsString() + ")";
     800             : }
     801             : 
     802             : static void
     803    29247772 : ProfileBinOpInit(FoldingSetNodeID &ID, unsigned Opcode, Init *LHS, Init *RHS,
     804             :                  RecTy *Type) {
     805    29247772 :   ID.AddInteger(Opcode);
     806    29247772 :   ID.AddPointer(LHS);
     807    29247772 :   ID.AddPointer(RHS);
     808    29247772 :   ID.AddPointer(Type);
     809    29247772 : }
     810             : 
     811    11146454 : BinOpInit *BinOpInit::get(BinaryOp Opc, Init *LHS,
     812             :                           Init *RHS, RecTy *Type) {
     813    11146702 :   static FoldingSet<BinOpInit> ThePool;
     814             : 
     815             :   FoldingSetNodeID ID;
     816    11146454 :   ProfileBinOpInit(ID, Opc, LHS, RHS, Type);
     817             : 
     818    11146454 :   void *IP = nullptr;
     819     8349158 :   if (BinOpInit *I = ThePool.FindNodeOrInsertPos(ID, IP))
     820             :     return I;
     821             : 
     822             :   BinOpInit *I = new(Allocator) BinOpInit(Opc, LHS, RHS, Type);
     823     2797296 :   ThePool.InsertNode(I, IP);
     824     2797296 :   return I;
     825             : }
     826             : 
     827    18101318 : void BinOpInit::Profile(FoldingSetNodeID &ID) const {
     828    18101318 :   ProfileBinOpInit(ID, getOpcode(), getLHS(), getRHS(), getType());
     829    18101318 : }
     830             : 
     831    17578841 : static StringInit *ConcatStringInits(const StringInit *I0,
     832             :                                      const StringInit *I1) {
     833             :   SmallString<80> Concat(I0->getValue());
     834             :   Concat.append(I1->getValue());
     835    17578841 :   return StringInit::get(Concat);
     836             : }
     837             : 
     838    12195650 : Init *BinOpInit::getStrConcat(Init *I0, Init *I1) {
     839             :   // Shortcut for the common case of concatenating two strings.
     840             :   if (const StringInit *I0s = dyn_cast<StringInit>(I0))
     841             :     if (const StringInit *I1s = dyn_cast<StringInit>(I1))
     842    12035005 :       return ConcatStringInits(I0s, I1s);
     843      160645 :   return BinOpInit::get(BinOpInit::STRCONCAT, I0, I1, StringRecTy::get());
     844             : }
     845             : 
     846    10985809 : Init *BinOpInit::Fold(Record *CurRec) const {
     847    10985809 :   switch (getOpcode()) {
     848       75213 :   case CONCAT: {
     849       75213 :     DagInit *LHSs = dyn_cast<DagInit>(LHS);
     850       75213 :     DagInit *RHSs = dyn_cast<DagInit>(RHS);
     851       75213 :     if (LHSs && RHSs) {
     852       60114 :       DefInit *LOp = dyn_cast<DefInit>(LHSs->getOperator());
     853       60114 :       DefInit *ROp = dyn_cast<DefInit>(RHSs->getOperator());
     854       60114 :       if (!LOp || !ROp)
     855             :         break;
     856       60113 :       if (LOp->getDef() != ROp->getDef()) {
     857           0 :         PrintFatalError(Twine("Concatenated Dag operators do not match: '") +
     858           0 :                         LHSs->getAsString() + "' vs. '" + RHSs->getAsString() +
     859             :                         "'");
     860             :       }
     861             :       SmallVector<Init*, 8> Args;
     862             :       SmallVector<StringInit*, 8> ArgNames;
     863      385610 :       for (unsigned i = 0, e = LHSs->getNumArgs(); i != e; ++i) {
     864      325497 :         Args.push_back(LHSs->getArg(i));
     865      325497 :         ArgNames.push_back(LHSs->getArgName(i));
     866             :       }
     867      138551 :       for (unsigned i = 0, e = RHSs->getNumArgs(); i != e; ++i) {
     868       78438 :         Args.push_back(RHSs->getArg(i));
     869       78438 :         ArgNames.push_back(RHSs->getArgName(i));
     870             :       }
     871       60113 :       return DagInit::get(LHSs->getOperator(), nullptr, Args, ArgNames);
     872             :     }
     873             :     break;
     874             :   }
     875     1583015 :   case LISTCONCAT: {
     876     1583015 :     ListInit *LHSs = dyn_cast<ListInit>(LHS);
     877     1583015 :     ListInit *RHSs = dyn_cast<ListInit>(RHS);
     878     1583015 :     if (LHSs && RHSs) {
     879             :       SmallVector<Init *, 8> Args;
     880     1405739 :       Args.insert(Args.end(), LHSs->begin(), LHSs->end());
     881     1405739 :       Args.insert(Args.end(), RHSs->begin(), RHSs->end());
     882     1405739 :       return ListInit::get(Args, LHSs->getElementType());
     883             :     }
     884             :     break;
     885             :   }
     886     6360939 :   case STRCONCAT: {
     887     6360939 :     StringInit *LHSs = dyn_cast<StringInit>(LHS);
     888     6360939 :     StringInit *RHSs = dyn_cast<StringInit>(RHS);
     889     6360939 :     if (LHSs && RHSs)
     890     5543836 :       return ConcatStringInits(LHSs, RHSs);
     891             :     break;
     892             :   }
     893      880061 :   case EQ:
     894             :   case NE:
     895             :   case LE:
     896             :   case LT:
     897             :   case GE:
     898             :   case GT: {
     899             :     // try to fold eq comparison for 'bit' and 'int', otherwise fallback
     900             :     // to string objects.
     901             :     IntInit *L =
     902      880061 :         dyn_cast_or_null<IntInit>(LHS->convertInitializerTo(IntRecTy::get()));
     903             :     IntInit *R =
     904      880061 :         dyn_cast_or_null<IntInit>(RHS->convertInitializerTo(IntRecTy::get()));
     905             : 
     906      880061 :     if (L && R) {
     907             :       bool Result;
     908      641893 :       switch (getOpcode()) {
     909      628391 :       case EQ: Result = L->getValue() == R->getValue(); break;
     910         696 :       case NE: Result = L->getValue() != R->getValue(); break;
     911       12784 :       case LE: Result = L->getValue() <= R->getValue(); break;
     912          14 :       case LT: Result = L->getValue() < R->getValue(); break;
     913           4 :       case GE: Result = L->getValue() >= R->getValue(); break;
     914           4 :       case GT: Result = L->getValue() > R->getValue(); break;
     915           0 :       default: llvm_unreachable("unhandled comparison");
     916             :       }
     917      641893 :       return BitInit::get(Result);
     918             :     }
     919             : 
     920      238168 :     if (getOpcode() == EQ || getOpcode() == NE) {
     921      235564 :       StringInit *LHSs = dyn_cast<StringInit>(LHS);
     922      235564 :       StringInit *RHSs = dyn_cast<StringInit>(RHS);
     923             : 
     924             :       // Make sure we've resolved
     925      235564 :       if (LHSs && RHSs) {
     926             :         bool Equal = LHSs->getValue() == RHSs->getValue();
     927      208875 :         return BitInit::get(getOpcode() == EQ ? Equal : !Equal);
     928             :       }
     929             :     }
     930             : 
     931             :     break;
     932             :   }
     933     2086581 :   case ADD:
     934             :   case AND:
     935             :   case OR:
     936             :   case SHL:
     937             :   case SRA:
     938             :   case SRL: {
     939             :     IntInit *LHSi =
     940     2086581 :       dyn_cast_or_null<IntInit>(LHS->convertInitializerTo(IntRecTy::get()));
     941             :     IntInit *RHSi =
     942     2086581 :       dyn_cast_or_null<IntInit>(RHS->convertInitializerTo(IntRecTy::get()));
     943     2086581 :     if (LHSi && RHSi) {
     944     2004870 :       int64_t LHSv = LHSi->getValue(), RHSv = RHSi->getValue();
     945             :       int64_t Result;
     946     2004870 :       switch (getOpcode()) {
     947           0 :       default: llvm_unreachable("Bad opcode!");
     948      581115 :       case ADD: Result = LHSv +  RHSv; break;
     949       45591 :       case AND: Result = LHSv &  RHSv; break;
     950      801519 :       case OR: Result = LHSv | RHSv; break;
     951      323756 :       case SHL: Result = LHSv << RHSv; break;
     952           1 :       case SRA: Result = LHSv >> RHSv; break;
     953      252888 :       case SRL: Result = (uint64_t)LHSv >> (uint64_t)RHSv; break;
     954             :       }
     955     2004870 :       return IntInit::get(Result);
     956             :     }
     957             :     break;
     958             :   }
     959             :   }
     960     1120483 :   return const_cast<BinOpInit *>(this);
     961             : }
     962             : 
     963    16829246 : Init *BinOpInit::resolveReferences(Resolver &R) const {
     964    16829246 :   Init *lhs = LHS->resolveReferences(R);
     965    16829246 :   Init *rhs = RHS->resolveReferences(R);
     966             : 
     967    16829246 :   if (LHS != lhs || RHS != rhs)
     968    10941078 :     return (BinOpInit::get(getOpcode(), lhs, rhs, getType()))
     969    10941078 :         ->Fold(R.getCurrentRecord());
     970     5888168 :   return const_cast<BinOpInit *>(this);
     971             : }
     972             : 
     973         103 : std::string BinOpInit::getAsString() const {
     974             :   std::string Result;
     975         103 :   switch (getOpcode()) {
     976             :   case CONCAT: Result = "!con"; break;
     977             :   case ADD: Result = "!add"; break;
     978             :   case AND: Result = "!and"; break;
     979             :   case OR: Result = "!or"; break;
     980             :   case SHL: Result = "!shl"; break;
     981             :   case SRA: Result = "!sra"; break;
     982             :   case SRL: Result = "!srl"; break;
     983             :   case EQ: Result = "!eq"; break;
     984             :   case NE: Result = "!ne"; break;
     985             :   case LE: Result = "!le"; break;
     986             :   case LT: Result = "!lt"; break;
     987             :   case GE: Result = "!ge"; break;
     988             :   case GT: Result = "!gt"; break;
     989             :   case LISTCONCAT: Result = "!listconcat"; break;
     990             :   case STRCONCAT: Result = "!strconcat"; break;
     991             :   }
     992         216 :   return Result + "(" + LHS->getAsString() + ", " + RHS->getAsString() + ")";
     993             : }
     994             : 
     995             : static void
     996     3604587 : ProfileTernOpInit(FoldingSetNodeID &ID, unsigned Opcode, Init *LHS, Init *MHS,
     997             :                   Init *RHS, RecTy *Type) {
     998     3604587 :   ID.AddInteger(Opcode);
     999     3604587 :   ID.AddPointer(LHS);
    1000     3604587 :   ID.AddPointer(MHS);
    1001     3604587 :   ID.AddPointer(RHS);
    1002     3604587 :   ID.AddPointer(Type);
    1003     3604587 : }
    1004             : 
    1005     1296017 : TernOpInit *TernOpInit::get(TernaryOp Opc, Init *LHS, Init *MHS, Init *RHS,
    1006             :                             RecTy *Type) {
    1007     1296233 :   static FoldingSet<TernOpInit> ThePool;
    1008             : 
    1009             :   FoldingSetNodeID ID;
    1010     1296017 :   ProfileTernOpInit(ID, Opc, LHS, MHS, RHS, Type);
    1011             : 
    1012     1296017 :   void *IP = nullptr;
    1013     1054278 :   if (TernOpInit *I = ThePool.FindNodeOrInsertPos(ID, IP))
    1014             :     return I;
    1015             : 
    1016             :   TernOpInit *I = new(Allocator) TernOpInit(Opc, LHS, MHS, RHS, Type);
    1017      241739 :   ThePool.InsertNode(I, IP);
    1018      241739 :   return I;
    1019             : }
    1020             : 
    1021     2308570 : void TernOpInit::Profile(FoldingSetNodeID &ID) const {
    1022     2308570 :   ProfileTernOpInit(ID, getOpcode(), getLHS(), getMHS(), getRHS(), getType());
    1023     2308570 : }
    1024             : 
    1025     1398305 : static Init *ForeachApply(Init *LHS, Init *MHSe, Init *RHS, Record *CurRec) {
    1026             :   MapResolver R(CurRec);
    1027     1398305 :   R.set(LHS, MHSe);
    1028     1398305 :   return RHS->resolveReferences(R);
    1029             : }
    1030             : 
    1031       21450 : static Init *ForeachDagApply(Init *LHS, DagInit *MHSd, Init *RHS,
    1032             :                              Record *CurRec) {
    1033             :   bool Change = false;
    1034       21450 :   Init *Val = ForeachApply(LHS, MHSd->getOperator(), RHS, CurRec);
    1035       21450 :   if (Val != MHSd->getOperator())
    1036             :     Change = true;
    1037             : 
    1038             :   SmallVector<std::pair<Init *, StringInit *>, 8> NewArgs;
    1039      140998 :   for (unsigned int i = 0; i < MHSd->getNumArgs(); ++i) {
    1040             :     Init *Arg = MHSd->getArg(i);
    1041             :     Init *NewArg;
    1042             :     StringInit *ArgName = MHSd->getArgName(i);
    1043             : 
    1044             :     if (DagInit *Argd = dyn_cast<DagInit>(Arg))
    1045          14 :       NewArg = ForeachDagApply(LHS, Argd, RHS, CurRec);
    1046             :     else
    1047      119534 :       NewArg = ForeachApply(LHS, Arg, RHS, CurRec);
    1048             : 
    1049      119548 :     NewArgs.push_back(std::make_pair(NewArg, ArgName));
    1050      119548 :     if (Arg != NewArg)
    1051             :       Change = true;
    1052             :   }
    1053             : 
    1054       21450 :   if (Change)
    1055       21450 :     return DagInit::get(Val, nullptr, NewArgs);
    1056             :   return MHSd;
    1057             : }
    1058             : 
    1059             : // Applies RHS to all elements of MHS, using LHS as a temp variable.
    1060      490282 : static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type,
    1061             :                            Record *CurRec) {
    1062             :   if (DagInit *MHSd = dyn_cast<DagInit>(MHS))
    1063       21436 :     return ForeachDagApply(LHS, MHSd, RHS, CurRec);
    1064             : 
    1065             :   if (ListInit *MHSl = dyn_cast<ListInit>(MHS)) {
    1066             :     SmallVector<Init *, 8> NewList(MHSl->begin(), MHSl->end());
    1067             : 
    1068     1715097 :     for (Init *&Item : NewList) {
    1069     1257321 :       Init *NewItem = ForeachApply(LHS, Item, RHS, CurRec);
    1070     1257321 :       if (NewItem != Item)
    1071     1125552 :         Item = NewItem;
    1072             :     }
    1073      915552 :     return ListInit::get(NewList, cast<ListRecTy>(Type)->getElementType());
    1074             :   }
    1075             : 
    1076             :   return nullptr;
    1077             : }
    1078             : 
    1079     1296017 : Init *TernOpInit::Fold(Record *CurRec) const {
    1080     1296017 :   switch (getOpcode()) {
    1081      340530 :   case SUBST: {
    1082      340530 :     DefInit *LHSd = dyn_cast<DefInit>(LHS);
    1083             :     VarInit *LHSv = dyn_cast<VarInit>(LHS);
    1084             :     StringInit *LHSs = dyn_cast<StringInit>(LHS);
    1085             : 
    1086      340530 :     DefInit *MHSd = dyn_cast<DefInit>(MHS);
    1087             :     VarInit *MHSv = dyn_cast<VarInit>(MHS);
    1088             :     StringInit *MHSs = dyn_cast<StringInit>(MHS);
    1089             : 
    1090      340530 :     DefInit *RHSd = dyn_cast<DefInit>(RHS);
    1091             :     VarInit *RHSv = dyn_cast<VarInit>(RHS);
    1092             :     StringInit *RHSs = dyn_cast<StringInit>(RHS);
    1093             : 
    1094      340530 :     if (LHSd && MHSd && RHSd) {
    1095      288624 :       Record *Val = RHSd->getDef();
    1096      321024 :       if (LHSd->getAsString() == RHSd->getAsString())
    1097       28591 :         Val = MHSd->getDef();
    1098      288624 :       return DefInit::get(Val);
    1099             :     }
    1100       51906 :     if (LHSv && MHSv && RHSv) {
    1101           0 :       std::string Val = RHSv->getName();
    1102           0 :       if (LHSv->getAsString() == RHSv->getAsString())
    1103           0 :         Val = MHSv->getName();
    1104           0 :       return VarInit::get(Val, getType());
    1105             :     }
    1106       51906 :     if (LHSs && MHSs && RHSs) {
    1107             :       std::string Val = RHSs->getValue();
    1108             : 
    1109             :       std::string::size_type found;
    1110             :       std::string::size_type idx = 0;
    1111             :       while (true) {
    1112        9154 :         found = Val.find(LHSs->getValue(), idx);
    1113        6503 :         if (found == std::string::npos)
    1114             :           break;
    1115        2651 :         Val.replace(found, LHSs->getValue().size(), MHSs->getValue());
    1116        2651 :         idx = found + MHSs->getValue().size();
    1117             :       }
    1118             : 
    1119        3852 :       return StringInit::get(Val);
    1120             :     }
    1121             :     break;
    1122             :   }
    1123             : 
    1124      490282 :   case FOREACH: {
    1125      490282 :     if (Init *Result = ForeachHelper(LHS, MHS, RHS, getType(), CurRec))
    1126             :       return Result;
    1127             :     break;
    1128             :   }
    1129             : 
    1130      465190 :   case IF: {
    1131      465190 :     if (IntInit *LHSi = dyn_cast_or_null<IntInit>(
    1132      465190 :                             LHS->convertInitializerTo(IntRecTy::get()))) {
    1133           0 :       if (LHSi->getValue())
    1134           0 :         return MHS;
    1135           0 :       return RHS;
    1136             :     }
    1137             :     break;
    1138             :   }
    1139             : 
    1140          15 :   case DAG: {
    1141          15 :     ListInit *MHSl = dyn_cast<ListInit>(MHS);
    1142          15 :     ListInit *RHSl = dyn_cast<ListInit>(RHS);
    1143          15 :     bool MHSok = MHSl || isa<UnsetInit>(MHS);
    1144          15 :     bool RHSok = RHSl || isa<UnsetInit>(RHS);
    1145             : 
    1146          15 :     if (isa<UnsetInit>(MHS) && isa<UnsetInit>(RHS))
    1147             :       break; // Typically prevented by the parser, but might happen with template args
    1148             : 
    1149          15 :     if (MHSok && RHSok && (!MHSl || !RHSl || MHSl->size() == RHSl->size())) {
    1150             :       SmallVector<std::pair<Init *, StringInit *>, 8> Children;
    1151          10 :       unsigned Size = MHSl ? MHSl->size() : RHSl->size();
    1152          26 :       for (unsigned i = 0; i != Size; ++i) {
    1153          17 :         Init *Node = MHSl ? MHSl->getElement(i) : UnsetInit::get();
    1154          17 :         Init *Name = RHSl ? RHSl->getElement(i) : UnsetInit::get();
    1155          17 :         if (!isa<StringInit>(Name) && !isa<UnsetInit>(Name))
    1156           1 :           return const_cast<TernOpInit *>(this);
    1157          16 :         Children.emplace_back(Node, dyn_cast<StringInit>(Name));
    1158             :       }
    1159           9 :       return DagInit::get(LHS, nullptr, Children);
    1160             :     }
    1161             :     break;
    1162             :   }
    1163             :   }
    1164             : 
    1165      524319 :   return const_cast<TernOpInit *>(this);
    1166             : }
    1167             : 
    1168    10868543 : Init *TernOpInit::resolveReferences(Resolver &R) const {
    1169    10868543 :   Init *lhs = LHS->resolveReferences(R);
    1170             : 
    1171    10868543 :   if (getOpcode() == IF && lhs != LHS) {
    1172     4605707 :     if (IntInit *Value = dyn_cast_or_null<IntInit>(
    1173     4605707 :                              lhs->convertInitializerTo(IntRecTy::get()))) {
    1174             :       // Short-circuit
    1175     4538282 :       if (Value->getValue())
    1176     2132287 :         return MHS->resolveReferences(R);
    1177     2405995 :       return RHS->resolveReferences(R);
    1178             :     }
    1179             :   }
    1180             : 
    1181     6330261 :   Init *mhs = MHS->resolveReferences(R);
    1182             :   Init *rhs;
    1183             : 
    1184     6330261 :   if (getOpcode() == FOREACH) {
    1185             :     ShadowResolver SR(R);
    1186      863046 :     SR.addShadow(lhs);
    1187      863046 :     rhs = RHS->resolveReferences(SR);
    1188             :   } else {
    1189     5467215 :     rhs = RHS->resolveReferences(R);
    1190             :   }
    1191             : 
    1192     6330261 :   if (LHS != lhs || MHS != mhs || RHS != rhs)
    1193     1276673 :     return (TernOpInit::get(getOpcode(), lhs, mhs, rhs, getType()))
    1194     1276673 :         ->Fold(R.getCurrentRecord());
    1195     5053588 :   return const_cast<TernOpInit *>(this);
    1196             : }
    1197             : 
    1198         109 : std::string TernOpInit::getAsString() const {
    1199             :   std::string Result;
    1200             :   bool UnquotedLHS = false;
    1201         109 :   switch (getOpcode()) {
    1202             :   case SUBST: Result = "!subst"; break;
    1203          24 :   case FOREACH: Result = "!foreach"; UnquotedLHS = true; break;
    1204             :   case IF: Result = "!if"; break;
    1205             :   case DAG: Result = "!dag"; break;
    1206             :   }
    1207         218 :   return (Result + "(" +
    1208         436 :           (UnquotedLHS ? LHS->getAsUnquotedString() : LHS->getAsString()) +
    1209         485 :           ", " + MHS->getAsString() + ", " + RHS->getAsString() + ")");
    1210             : }
    1211             : 
    1212      587842 : static void ProfileFoldOpInit(FoldingSetNodeID &ID, Init *A, Init *B,
    1213             :                               Init *Start, Init *List, Init *Expr,
    1214             :                               RecTy *Type) {
    1215      587842 :   ID.AddPointer(Start);
    1216      587842 :   ID.AddPointer(List);
    1217      587842 :   ID.AddPointer(A);
    1218      587842 :   ID.AddPointer(B);
    1219      587842 :   ID.AddPointer(Expr);
    1220      587842 :   ID.AddPointer(Type);
    1221      587842 : }
    1222             : 
    1223      229638 : FoldOpInit *FoldOpInit::get(Init *Start, Init *List, Init *A, Init *B,
    1224             :                             Init *Expr, RecTy *Type) {
    1225      229834 :   static FoldingSet<FoldOpInit> ThePool;
    1226             : 
    1227             :   FoldingSetNodeID ID;
    1228      229638 :   ProfileFoldOpInit(ID, Start, List, A, B, Expr, Type);
    1229             : 
    1230      229638 :   void *IP = nullptr;
    1231      188352 :   if (FoldOpInit *I = ThePool.FindNodeOrInsertPos(ID, IP))
    1232             :     return I;
    1233             : 
    1234             :   FoldOpInit *I = new (Allocator) FoldOpInit(Start, List, A, B, Expr, Type);
    1235       41286 :   ThePool.InsertNode(I, IP);
    1236       41286 :   return I;
    1237             : }
    1238             : 
    1239      358204 : void FoldOpInit::Profile(FoldingSetNodeID &ID) const {
    1240      358204 :   ProfileFoldOpInit(ID, Start, List, A, B, Expr, getType());
    1241      358204 : }
    1242             : 
    1243      229638 : Init *FoldOpInit::Fold(Record *CurRec) const {
    1244      229638 :   if (ListInit *LI = dyn_cast<ListInit>(List)) {
    1245      229042 :     Init *Accum = Start;
    1246      566700 :     for (Init *Elt : *LI) {
    1247             :       MapResolver R(CurRec);
    1248      337658 :       R.set(A, Accum);
    1249      337658 :       R.set(B, Elt);
    1250      337658 :       Accum = Expr->resolveReferences(R);
    1251             :     }
    1252      229042 :     return Accum;
    1253             :   }
    1254         596 :   return const_cast<FoldOpInit *>(this);
    1255             : }
    1256             : 
    1257      353019 : Init *FoldOpInit::resolveReferences(Resolver &R) const {
    1258      353019 :   Init *NewStart = Start->resolveReferences(R);
    1259      353019 :   Init *NewList = List->resolveReferences(R);
    1260             :   ShadowResolver SR(R);
    1261      353019 :   SR.addShadow(A);
    1262      353019 :   SR.addShadow(B);
    1263      353019 :   Init *NewExpr = Expr->resolveReferences(SR);
    1264             : 
    1265      353019 :   if (Start == NewStart && List == NewList && Expr == NewExpr)
    1266      124033 :     return const_cast<FoldOpInit *>(this);
    1267             : 
    1268      228986 :   return get(NewStart, NewList, A, B, NewExpr, getType())
    1269      228986 :       ->Fold(R.getCurrentRecord());
    1270             : }
    1271             : 
    1272           0 : Init *FoldOpInit::getBit(unsigned Bit) const {
    1273           0 :   return VarBitInit::get(const_cast<FoldOpInit *>(this), Bit);
    1274             : }
    1275             : 
    1276           4 : std::string FoldOpInit::getAsString() const {
    1277           8 :   return (Twine("!foldl(") + Start->getAsString() + ", " + List->getAsString() +
    1278           8 :           ", " + A->getAsUnquotedString() + ", " + B->getAsUnquotedString() +
    1279          12 :           ", " + Expr->getAsString() + ")")
    1280           4 :       .str();
    1281             : }
    1282             : 
    1283             : static void ProfileIsAOpInit(FoldingSetNodeID &ID, RecTy *CheckType,
    1284             :                              Init *Expr) {
    1285      806082 :   ID.AddPointer(CheckType);
    1286     1630009 :   ID.AddPointer(Expr);
    1287             : }
    1288             : 
    1289      806082 : IsAOpInit *IsAOpInit::get(RecTy *CheckType, Init *Expr) {
    1290      806275 :   static FoldingSet<IsAOpInit> ThePool;
    1291             : 
    1292             :   FoldingSetNodeID ID;
    1293             :   ProfileIsAOpInit(ID, CheckType, Expr);
    1294             : 
    1295      806082 :   void *IP = nullptr;
    1296      804480 :   if (IsAOpInit *I = ThePool.FindNodeOrInsertPos(ID, IP))
    1297             :     return I;
    1298             : 
    1299             :   IsAOpInit *I = new (Allocator) IsAOpInit(CheckType, Expr);
    1300        1602 :   ThePool.InsertNode(I, IP);
    1301        1602 :   return I;
    1302             : }
    1303             : 
    1304      823927 : void IsAOpInit::Profile(FoldingSetNodeID &ID) const {
    1305      823927 :   ProfileIsAOpInit(ID, CheckType, Expr);
    1306      823927 : }
    1307             : 
    1308      806082 : Init *IsAOpInit::Fold() const {
    1309      806082 :   if (TypedInit *TI = dyn_cast<TypedInit>(Expr)) {
    1310             :     // Is the expression type known to be (a subclass of) the desired type?
    1311      806082 :     if (TI->getType()->typeIsConvertibleTo(CheckType))
    1312      433967 :       return IntInit::get(1);
    1313             : 
    1314      744230 :     if (isa<RecordRecTy>(CheckType)) {
    1315             :       // If the target type is not a subclass of the expression type, or if
    1316             :       // the expression has fully resolved to a record, we know that it can't
    1317             :       // be of the required type.
    1318      372115 :       if (!CheckType->typeIsConvertibleTo(TI->getType()) || isa<DefInit>(Expr))
    1319      371522 :         return IntInit::get(0);
    1320             :     } else {
    1321             :       // We treat non-record types as not castable.
    1322           0 :       return IntInit::get(0);
    1323             :     }
    1324             :   }
    1325         593 :   return const_cast<IsAOpInit *>(this);
    1326             : }
    1327             : 
    1328     1170289 : Init *IsAOpInit::resolveReferences(Resolver &R) const {
    1329     1170289 :   Init *NewExpr = Expr->resolveReferences(R);
    1330     1170289 :   if (Expr != NewExpr)
    1331      805489 :     return get(CheckType, NewExpr)->Fold();
    1332      364800 :   return const_cast<IsAOpInit *>(this);
    1333             : }
    1334             : 
    1335           0 : Init *IsAOpInit::getBit(unsigned Bit) const {
    1336           0 :   return VarBitInit::get(const_cast<IsAOpInit *>(this), Bit);
    1337             : }
    1338             : 
    1339           2 : std::string IsAOpInit::getAsString() const {
    1340           2 :   return (Twine("!isa<") + CheckType->getAsString() + ">(" +
    1341           4 :           Expr->getAsString() + ")")
    1342           2 :       .str();
    1343             : }
    1344             : 
    1345      293961 : RecTy *TypedInit::getFieldType(StringInit *FieldName) const {
    1346      293961 :   if (RecordRecTy *RecordType = dyn_cast<RecordRecTy>(getType())) {
    1347      293961 :     for (Record *Rec : RecordType->getClasses()) {
    1348      293961 :       if (RecordVal *Field = Rec->getValue(FieldName))
    1349      293961 :         return Field->getType();
    1350             :     }
    1351             :   }
    1352             :   return nullptr;
    1353             : }
    1354             : 
    1355             : Init *
    1356      852580 : TypedInit::convertInitializerTo(RecTy *Ty) const {
    1357      852580 :   if (getType() == Ty || getType()->typeIsA(Ty))
    1358      352379 :     return const_cast<TypedInit *>(this);
    1359             : 
    1360     1000402 :   if (isa<BitRecTy>(getType()) && isa<BitsRecTy>(Ty) &&
    1361        7689 :       cast<BitsRecTy>(Ty)->getNumBits() == 1)
    1362       15378 :     return BitsInit::get({const_cast<TypedInit *>(this)});
    1363             : 
    1364             :   return nullptr;
    1365             : }
    1366             : 
    1367       45863 : Init *TypedInit::convertInitializerBitRange(ArrayRef<unsigned> Bits) const {
    1368       45863 :   BitsRecTy *T = dyn_cast<BitsRecTy>(getType());
    1369             :   if (!T) return nullptr;  // Cannot subscript a non-bits variable.
    1370       45863 :   unsigned NumBits = T->getNumBits();
    1371             : 
    1372             :   SmallVector<Init *, 16> NewBits;
    1373             :   NewBits.reserve(Bits.size());
    1374      210839 :   for (unsigned Bit : Bits) {
    1375      164976 :     if (Bit >= NumBits)
    1376             :       return nullptr;
    1377             : 
    1378      164976 :     NewBits.push_back(VarBitInit::get(const_cast<TypedInit *>(this), Bit));
    1379             :   }
    1380       45863 :   return BitsInit::get(NewBits);
    1381             : }
    1382             : 
    1383   221488673 : Init *TypedInit::getCastTo(RecTy *Ty) const {
    1384             :   // Handle the common case quickly
    1385   221488673 :   if (getType() == Ty || getType()->typeIsA(Ty))
    1386   220845536 :     return const_cast<TypedInit *>(this);
    1387             : 
    1388      643137 :   if (Init *Converted = convertInitializerTo(Ty)) {
    1389             :     assert(!isa<TypedInit>(Converted) ||
    1390             :            cast<TypedInit>(Converted)->getType()->typeIsA(Ty));
    1391             :     return Converted;
    1392             :   }
    1393             : 
    1394        5037 :   if (!getType()->typeIsConvertibleTo(Ty))
    1395             :     return nullptr;
    1396             : 
    1397             :   return UnOpInit::get(UnOpInit::CAST, const_cast<TypedInit *>(this), Ty)
    1398        5027 :       ->Fold(nullptr);
    1399             : }
    1400             : 
    1401         349 : Init *TypedInit::convertInitListSlice(ArrayRef<unsigned> Elements) const {
    1402         349 :   ListRecTy *T = dyn_cast<ListRecTy>(getType());
    1403             :   if (!T) return nullptr;  // Cannot subscript a non-list variable.
    1404             : 
    1405         349 :   if (Elements.size() == 1)
    1406         348 :     return VarListElementInit::get(const_cast<TypedInit *>(this), Elements[0]);
    1407             : 
    1408             :   SmallVector<Init*, 8> ListInits;
    1409             :   ListInits.reserve(Elements.size());
    1410           3 :   for (unsigned Element : Elements)
    1411           2 :     ListInits.push_back(VarListElementInit::get(const_cast<TypedInit *>(this),
    1412             :                                                 Element));
    1413           2 :   return ListInit::get(ListInits, T->getElementType());
    1414             : }
    1415             : 
    1416             : 
    1417           0 : VarInit *VarInit::get(StringRef VN, RecTy *T) {
    1418           0 :   Init *Value = StringInit::get(VN);
    1419           0 :   return VarInit::get(Value, T);
    1420             : }
    1421             : 
    1422     1137021 : VarInit *VarInit::get(Init *VN, RecTy *T) {
    1423             :   using Key = std::pair<RecTy *, Init *>;
    1424     1137363 :   static DenseMap<Key, VarInit*> ThePool;
    1425             : 
    1426     1137021 :   Key TheKey(std::make_pair(T, VN));
    1427             : 
    1428             :   VarInit *&I = ThePool[TheKey];
    1429     1137021 :   if (!I)
    1430      641220 :     I = new(Allocator) VarInit(VN, T);
    1431     1137021 :   return I;
    1432             : }
    1433             : 
    1434     6432133 : StringRef VarInit::getName() const {
    1435     6432133 :   StringInit *NameString = cast<StringInit>(getNameInit());
    1436     6432133 :   return NameString->getValue();
    1437             : }
    1438             : 
    1439    55521114 : Init *VarInit::getBit(unsigned Bit) const {
    1440    55521114 :   if (getType() == BitRecTy::get())
    1441    12931201 :     return const_cast<VarInit*>(this);
    1442    42589913 :   return VarBitInit::get(const_cast<VarInit*>(this), Bit);
    1443             : }
    1444             : 
    1445    87920162 : Init *VarInit::resolveReferences(Resolver &R) const {
    1446    87920162 :   if (Init *Val = R.resolve(VarName))
    1447             :     return Val;
    1448    44589640 :   return const_cast<VarInit *>(this);
    1449             : }
    1450             : 
    1451    69899877 : VarBitInit *VarBitInit::get(TypedInit *T, unsigned B) {
    1452             :   using Key = std::pair<TypedInit *, unsigned>;
    1453    69900090 :   static DenseMap<Key, VarBitInit*> ThePool;
    1454             : 
    1455    69899877 :   Key TheKey(std::make_pair(T, B));
    1456             : 
    1457             :   VarBitInit *&I = ThePool[TheKey];
    1458    69899877 :   if (!I)
    1459      649904 :     I = new(Allocator) VarBitInit(T, B);
    1460    69899877 :   return I;
    1461             : }
    1462             : 
    1463         240 : std::string VarBitInit::getAsString() const {
    1464         480 :   return TI->getAsString() + "{" + utostr(Bit) + "}";
    1465             : }
    1466             : 
    1467         922 : Init *VarBitInit::resolveReferences(Resolver &R) const {
    1468         922 :   Init *I = TI->resolveReferences(R);
    1469         922 :   if (TI != I)
    1470         616 :     return I->getBit(getBitNum());
    1471             : 
    1472         306 :   return const_cast<VarBitInit*>(this);
    1473             : }
    1474             : 
    1475         402 : VarListElementInit *VarListElementInit::get(TypedInit *T,
    1476             :                                             unsigned E) {
    1477             :   using Key = std::pair<TypedInit *, unsigned>;
    1478         603 :   static DenseMap<Key, VarListElementInit*> ThePool;
    1479             : 
    1480         402 :   Key TheKey(std::make_pair(T, E));
    1481             : 
    1482             :   VarListElementInit *&I = ThePool[TheKey];
    1483         789 :   if (!I) I = new(Allocator) VarListElementInit(T, E);
    1484         402 :   return I;
    1485             : }
    1486             : 
    1487          25 : std::string VarListElementInit::getAsString() const {
    1488          50 :   return TI->getAsString() + "[" + utostr(Element) + "]";
    1489             : }
    1490             : 
    1491       24478 : Init *VarListElementInit::resolveReferences(Resolver &R) const {
    1492       24478 :   Init *NewTI = TI->resolveReferences(R);
    1493             :   if (ListInit *List = dyn_cast<ListInit>(NewTI)) {
    1494             :     // Leave out-of-bounds array references as-is. This can happen without
    1495             :     // being an error, e.g. in the untaken "branch" of an !if expression.
    1496       15836 :     if (getElementNum() < List->size())
    1497       11741 :       return List->getElement(getElementNum());
    1498             :   }
    1499       12737 :   if (NewTI != TI && isa<TypedInit>(NewTI))
    1500          52 :     return VarListElementInit::get(cast<TypedInit>(NewTI), getElementNum());
    1501       12685 :   return const_cast<VarListElementInit *>(this);
    1502             : }
    1503             : 
    1504           0 : Init *VarListElementInit::getBit(unsigned Bit) const {
    1505           0 :   if (getType() == BitRecTy::get())
    1506           0 :     return const_cast<VarListElementInit*>(this);
    1507           0 :   return VarBitInit::get(const_cast<VarListElementInit*>(this), Bit);
    1508             : }
    1509             : 
    1510      914693 : DefInit::DefInit(Record *D)
    1511      914693 :     : TypedInit(IK_DefInit, D->getType()), Def(D) {}
    1512             : 
    1513     2300104 : DefInit *DefInit::get(Record *R) {
    1514     2300104 :   return R->getDefInit();
    1515             : }
    1516             : 
    1517       26210 : Init *DefInit::convertInitializerTo(RecTy *Ty) const {
    1518             :   if (auto *RRT = dyn_cast<RecordRecTy>(Ty))
    1519       26210 :     if (getType()->typeIsConvertibleTo(RRT))
    1520       26210 :       return const_cast<DefInit *>(this);
    1521             :   return nullptr;
    1522             : }
    1523             : 
    1524     1403523 : RecTy *DefInit::getFieldType(StringInit *FieldName) const {
    1525     2807046 :   if (const RecordVal *RV = Def->getValue(FieldName))
    1526     1403523 :     return RV->getType();
    1527             :   return nullptr;
    1528             : }
    1529             : 
    1530     7272105 : std::string DefInit::getAsString() const {
    1531     7272105 :   return Def->getName();
    1532             : }
    1533             : 
    1534     7336402 : static void ProfileVarDefInit(FoldingSetNodeID &ID,
    1535             :                               Record *Class,
    1536             :                               ArrayRef<Init *> Args) {
    1537     7336402 :   ID.AddInteger(Args.size());
    1538     7336402 :   ID.AddPointer(Class);
    1539             : 
    1540    24852198 :   for (Init *I : Args)
    1541    17515796 :     ID.AddPointer(I);
    1542     7336402 : }
    1543             : 
    1544     2920531 : VarDefInit *VarDefInit::get(Record *Class, ArrayRef<Init *> Args) {
    1545     2920768 :   static FoldingSet<VarDefInit> ThePool;
    1546             : 
    1547             :   FoldingSetNodeID ID;
    1548     2920531 :   ProfileVarDefInit(ID, Class, Args);
    1549             : 
    1550     2920531 :   void *IP = nullptr;
    1551     2635452 :   if (VarDefInit *I = ThePool.FindNodeOrInsertPos(ID, IP))
    1552             :     return I;
    1553             : 
    1554      285079 :   void *Mem = Allocator.Allocate(totalSizeToAlloc<Init *>(Args.size()),
    1555             :                                  alignof(VarDefInit));
    1556      285079 :   VarDefInit *I = new(Mem) VarDefInit(Class, Args.size());
    1557             :   std::uninitialized_copy(Args.begin(), Args.end(),
    1558             :                           I->getTrailingObjects<Init *>());
    1559      285079 :   ThePool.InsertNode(I, IP);
    1560      285079 :   return I;
    1561             : }
    1562             : 
    1563     4415871 : void VarDefInit::Profile(FoldingSetNodeID &ID) const {
    1564     4415871 :   ProfileVarDefInit(ID, Class, args());
    1565     4415871 : }
    1566             : 
    1567     2301390 : DefInit *VarDefInit::instantiate() {
    1568     2301390 :   if (!Def) {
    1569      265165 :     RecordKeeper &Records = Class->getRecords();
    1570      265165 :     auto NewRecOwner = make_unique<Record>(Records.getNewAnonymousName(),
    1571      530330 :                                            Class->getLoc(), Records,
    1572      530330 :                                            /*IsAnonymous=*/true);
    1573             :     Record *NewRec = NewRecOwner.get();
    1574             : 
    1575             :     // Copy values from class to instance
    1576     2827424 :     for (const RecordVal &Val : Class->getValues())
    1577             :       NewRec->addValue(Val);
    1578             : 
    1579             :     // Substitute and resolve template arguments
    1580      265165 :     ArrayRef<Init *> TArgs = Class->getTemplateArgs();
    1581             :     MapResolver R(NewRec);
    1582             : 
    1583      996950 :     for (unsigned i = 0, e = TArgs.size(); i != e; ++i) {
    1584      731785 :       if (i < args_size())
    1585      660161 :         R.set(TArgs[i], getArg(i));
    1586             :       else
    1587      143248 :         R.set(TArgs[i], NewRec->getValue(TArgs[i])->getValue());
    1588             : 
    1589      731785 :       NewRec->removeValue(TArgs[i]);
    1590             :     }
    1591             : 
    1592      265165 :     NewRec->resolveReferences(R);
    1593             : 
    1594             :     // Add superclasses.
    1595      265165 :     ArrayRef<std::pair<Record *, SMRange>> SCs = Class->getSuperClasses();
    1596      421372 :     for (const auto &SCPair : SCs)
    1597      156207 :       NewRec->addSuperClass(SCPair.first, SCPair.second);
    1598             : 
    1599             :     NewRec->addSuperClass(Class,
    1600             :                           SMRange(Class->getLoc().back(),
    1601      265165 :                                   Class->getLoc().back()));
    1602             : 
    1603             :     // Resolve internal references and store in record keeper
    1604      265165 :     NewRec->resolveReferences();
    1605      265165 :     Records.addDef(std::move(NewRecOwner));
    1606             : 
    1607      265165 :     Def = DefInit::get(NewRec);
    1608             :   }
    1609             : 
    1610     2301390 :   return Def;
    1611             : }
    1612             : 
    1613     4299486 : Init *VarDefInit::resolveReferences(Resolver &R) const {
    1614             :   TrackUnresolvedResolver UR(&R);
    1615             :   bool Changed = false;
    1616             :   SmallVector<Init *, 8> NewArgs;
    1617     4299486 :   NewArgs.reserve(args_size());
    1618             : 
    1619    14919871 :   for (Init *Arg : args()) {
    1620    10620385 :     Init *NewArg = Arg->resolveReferences(UR);
    1621    10620385 :     NewArgs.push_back(NewArg);
    1622    10620385 :     Changed |= NewArg != Arg;
    1623             :   }
    1624             : 
    1625     4299486 :   if (Changed) {
    1626     2609114 :     auto New = VarDefInit::get(Class, NewArgs);
    1627     2609114 :     if (!UR.foundUnresolved())
    1628     2215177 :       return New->instantiate();
    1629             :     return New;
    1630             :   }
    1631     1690372 :   return const_cast<VarDefInit *>(this);
    1632             : }
    1633             : 
    1634      311417 : Init *VarDefInit::Fold() const {
    1635      311417 :   if (Def)
    1636             :     return Def;
    1637             : 
    1638             :   TrackUnresolvedResolver R;
    1639      286406 :   for (Init *Arg : args())
    1640      191418 :     Arg->resolveReferences(R);
    1641             : 
    1642       94988 :   if (!R.foundUnresolved())
    1643       86213 :     return const_cast<VarDefInit *>(this)->instantiate();
    1644        8775 :   return const_cast<VarDefInit *>(this);
    1645             : }
    1646             : 
    1647           8 : std::string VarDefInit::getAsString() const {
    1648          16 :   std::string Result = Class->getNameInitAsString() + "<";
    1649             :   const char *sep = "";
    1650          18 :   for (Init *Arg : args()) {
    1651             :     Result += sep;
    1652             :     sep = ", ";
    1653          20 :     Result += Arg->getAsString();
    1654             :   }
    1655           8 :   return Result + ">";
    1656             : }
    1657             : 
    1658    15228741 : FieldInit *FieldInit::get(Init *R, StringInit *FN) {
    1659             :   using Key = std::pair<Init *, StringInit *>;
    1660    15228968 :   static DenseMap<Key, FieldInit*> ThePool;
    1661             : 
    1662    15228741 :   Key TheKey(std::make_pair(R, FN));
    1663             : 
    1664             :   FieldInit *&I = ThePool[TheKey];
    1665    16802602 :   if (!I) I = new(Allocator) FieldInit(R, FN);
    1666    15228741 :   return I;
    1667             : }
    1668             : 
    1669    19043732 : Init *FieldInit::getBit(unsigned Bit) const {
    1670    19043732 :   if (getType() == BitRecTy::get())
    1671        1635 :     return const_cast<FieldInit*>(this);
    1672    19042097 :   return VarBitInit::get(const_cast<FieldInit*>(this), Bit);
    1673             : }
    1674             : 
    1675    27257073 : Init *FieldInit::resolveReferences(Resolver &R) const {
    1676    27257073 :   Init *NewRec = Rec->resolveReferences(R);
    1677    27257073 :   if (NewRec != Rec)
    1678    15105118 :     return FieldInit::get(NewRec, FieldName)->Fold(R.getCurrentRecord());
    1679    12151955 :   return const_cast<FieldInit *>(this);
    1680             : }
    1681             : 
    1682    15228741 : Init *FieldInit::Fold(Record *CurRec) const {
    1683    15228741 :   if (DefInit *DI = dyn_cast<DefInit>(Rec)) {
    1684    14526567 :     Record *Def = DI->getDef();
    1685    14526567 :     if (Def == CurRec)
    1686           1 :       PrintFatalError(CurRec->getLoc(),
    1687             :                       Twine("Attempting to access field '") +
    1688           1 :                       FieldName->getAsUnquotedString() + "' of '" +
    1689           1 :                       Rec->getAsString() + "' is a forbidden self-reference");
    1690    14526566 :     Init *FieldVal = Def->getValue(FieldName)->getValue();
    1691    14526566 :     if (FieldVal->isComplete())
    1692             :       return FieldVal;
    1693             :   }
    1694      702174 :   return const_cast<FieldInit *>(this);
    1695             : }
    1696             : 
    1697           0 : static void ProfileDagInit(FoldingSetNodeID &ID, Init *V, StringInit *VN,
    1698             :                            ArrayRef<Init *> ArgRange,
    1699             :                            ArrayRef<StringInit *> NameRange) {
    1700           0 :   ID.AddPointer(V);
    1701           0 :   ID.AddPointer(VN);
    1702             : 
    1703             :   ArrayRef<Init *>::iterator Arg = ArgRange.begin();
    1704           0 :   ArrayRef<StringInit *>::iterator Name = NameRange.begin();
    1705           0 :   while (Arg != ArgRange.end()) {
    1706             :     assert(Name != NameRange.end() && "Arg name underflow!");
    1707           0 :     ID.AddPointer(*Arg++);
    1708           0 :     ID.AddPointer(*Name++);
    1709             :   }
    1710             :   assert(Name == NameRange.end() && "Arg name overflow!");
    1711           0 : }
    1712             : 
    1713             : DagInit *
    1714     3709700 : DagInit::get(Init *V, StringInit *VN, ArrayRef<Init *> ArgRange,
    1715             :              ArrayRef<StringInit *> NameRange) {
    1716     3709906 :   static FoldingSet<DagInit> ThePool;
    1717             : 
    1718             :   FoldingSetNodeID ID;
    1719     3709700 :   ProfileDagInit(ID, V, VN, ArgRange, NameRange);
    1720             : 
    1721     3709700 :   void *IP = nullptr;
    1722     1845930 :   if (DagInit *I = ThePool.FindNodeOrInsertPos(ID, IP))
    1723             :     return I;
    1724             : 
    1725     1863770 :   void *Mem = Allocator.Allocate(totalSizeToAlloc<Init *, StringInit *>(ArgRange.size(), NameRange.size()), alignof(BitsInit));
    1726     1863770 :   DagInit *I = new(Mem) DagInit(V, VN, ArgRange.size(), NameRange.size());
    1727             :   std::uninitialized_copy(ArgRange.begin(), ArgRange.end(),
    1728             :                           I->getTrailingObjects<Init *>());
    1729             :   std::uninitialized_copy(NameRange.begin(), NameRange.end(),
    1730             :                           I->getTrailingObjects<StringInit *>());
    1731     1863770 :   ThePool.InsertNode(I, IP);
    1732     1863770 :   return I;
    1733             : }
    1734             : 
    1735             : DagInit *
    1736     1224311 : DagInit::get(Init *V, StringInit *VN,
    1737             :              ArrayRef<std::pair<Init*, StringInit*>> args) {
    1738             :   SmallVector<Init *, 8> Args;
    1739             :   SmallVector<StringInit *, 8> Names;
    1740             : 
    1741     3108907 :   for (const auto &Arg : args) {
    1742     1884596 :     Args.push_back(Arg.first);
    1743     1884596 :     Names.push_back(Arg.second);
    1744             :   }
    1745             : 
    1746     1224311 :   return DagInit::get(V, VN, Args, Names);
    1747             : }
    1748             : 
    1749     7504050 : void DagInit::Profile(FoldingSetNodeID &ID) const {
    1750     7504050 :   ProfileDagInit(ID, Val, ValName, makeArrayRef(getTrailingObjects<Init *>(), NumArgs), makeArrayRef(getTrailingObjects<StringInit *>(), NumArgNames));
    1751     7504050 : }
    1752             : 
    1753    11784875 : Init *DagInit::resolveReferences(Resolver &R) const {
    1754             :   SmallVector<Init*, 8> NewArgs;
    1755    11784875 :   NewArgs.reserve(arg_size());
    1756             :   bool ArgsChanged = false;
    1757    31949727 :   for (const Init *Arg : getArgs()) {
    1758    20164852 :     Init *NewArg = Arg->resolveReferences(R);
    1759    20164852 :     NewArgs.push_back(NewArg);
    1760    20164852 :     ArgsChanged |= NewArg != Arg;
    1761             :   }
    1762             : 
    1763    11784875 :   Init *Op = Val->resolveReferences(R);
    1764    11784875 :   if (Op != Val || ArgsChanged)
    1765     2425276 :     return DagInit::get(Op, ValName, NewArgs, getArgNames());
    1766             : 
    1767     9359599 :   return const_cast<DagInit *>(this);
    1768             : }
    1769             : 
    1770     4229517 : bool DagInit::isConcrete() const {
    1771     4229517 :   if (!Val->isConcrete())
    1772             :     return false;
    1773    11916460 :   for (const Init *Elt : getArgs()) {
    1774     7686943 :     if (!Elt->isConcrete())
    1775             :       return false;
    1776             :   }
    1777             :   return true;
    1778             : }
    1779             : 
    1780        4929 : std::string DagInit::getAsString() const {
    1781        4929 :   std::string Result = "(" + Val->getAsString();
    1782        4929 :   if (ValName)
    1783           2 :     Result += ":" + ValName->getAsUnquotedString();
    1784        4929 :   if (!arg_empty()) {
    1785        9838 :     Result += " " + getArg(0)->getAsString();
    1786        8464 :     if (getArgName(0)) Result += ":$" + getArgName(0)->getAsUnquotedString();
    1787       14241 :     for (unsigned i = 1, e = getNumArgs(); i != e; ++i) {
    1788       18644 :       Result += ", " + getArg(i)->getAsString();
    1789       15335 :       if (getArgName(i)) Result += ":$" + getArgName(i)->getAsUnquotedString();
    1790             :     }
    1791             :   }
    1792        4929 :   return Result + ")";
    1793             : }
    1794             : 
    1795             : //===----------------------------------------------------------------------===//
    1796             : //    Other implementations
    1797             : //===----------------------------------------------------------------------===//
    1798             : 
    1799      620007 : RecordVal::RecordVal(Init *N, RecTy *T, bool P)
    1800      620007 :   : Name(N), TyAndPrefix(T, P) {
    1801      620007 :   setValue(UnsetInit::get());
    1802             :   assert(Value && "Cannot create unset value for current type!");
    1803      620007 : }
    1804             : 
    1805     1487002 : StringRef RecordVal::getName() const {
    1806     1487002 :   return cast<StringInit>(getNameInit())->getValue();
    1807             : }
    1808             : 
    1809   233078435 : bool RecordVal::setValue(Init *V) {
    1810   233078435 :   if (V) {
    1811   466156870 :     Value = V->getCastTo(getType());
    1812   233078435 :     if (Value) {
    1813             :       assert(!isa<TypedInit>(Value) ||
    1814             :              cast<TypedInit>(Value)->getType()->typeIsA(getType()));
    1815             :       if (BitsRecTy *BTy = dyn_cast<BitsRecTy>(getType())) {
    1816    22759395 :         if (!isa<BitsInit>(Value)) {
    1817             :           SmallVector<Init *, 64> Bits;
    1818      169138 :           Bits.reserve(BTy->getNumBits());
    1819     1327260 :           for (unsigned i = 0, e = BTy->getNumBits(); i < e; ++i)
    1820     1158122 :             Bits.push_back(Value->getBit(i));
    1821      169138 :           Value = BitsInit::get(Bits);
    1822             :         }
    1823             :       }
    1824             :     }
    1825   233078435 :     return Value == nullptr;
    1826             :   }
    1827           0 :   Value = nullptr;
    1828           0 :   return false;
    1829             : }
    1830             : 
    1831             : #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
    1832             : LLVM_DUMP_METHOD void RecordVal::dump() const { errs() << *this; }
    1833             : #endif
    1834             : 
    1835        1838 : void RecordVal::print(raw_ostream &OS, bool PrintSem) const {
    1836        1838 :   if (getPrefix()) OS << "field ";
    1837        1838 :   OS << *getType() << " " << getNameInitAsString();
    1838             : 
    1839        1838 :   if (getValue())
    1840        1829 :     OS << " = " << *getValue();
    1841             : 
    1842        1838 :   if (PrintSem) OS << ";\n";
    1843        1838 : }
    1844             : 
    1845             : unsigned Record::LastID = 0;
    1846             : 
    1847     3669987 : void Record::checkName() {
    1848             :   // Ensure the record name has string type.
    1849     3669987 :   const TypedInit *TypedName = cast<const TypedInit>(Name);
    1850     7339974 :   if (!isa<StringRecTy>(TypedName->getType()))
    1851           0 :     PrintFatalError(getLoc(), Twine("Record name '") + Name->getAsString() +
    1852             :                                   "' is not a string!");
    1853     3669987 : }
    1854             : 
    1855      915203 : RecordRecTy *Record::getType() {
    1856             :   SmallVector<Record *, 4> DirectSCs;
    1857      915203 :   getDirectSuperClasses(DirectSCs);
    1858      915203 :   return RecordRecTy::get(DirectSCs);
    1859             : }
    1860             : 
    1861     9665551 : DefInit *Record::getDefInit() {
    1862     9665551 :   if (!TheInit)
    1863      914693 :     TheInit = new(Allocator) DefInit(this);
    1864     9665551 :   return TheInit;
    1865             : }
    1866             : 
    1867     1080297 : void Record::setName(Init *NewName) {
    1868     1080297 :   Name = NewName;
    1869     1080297 :   checkName();
    1870             :   // DO NOT resolve record values to the name at this point because
    1871             :   // there might be default values for arguments of this def.  Those
    1872             :   // arguments might not have been resolved yet so we don't want to
    1873             :   // prematurely assume values for those arguments were not passed to
    1874             :   // this def.
    1875             :   //
    1876             :   // Nonetheless, it may be that some of this Record's values
    1877             :   // reference the record name.  Indeed, the reason for having the
    1878             :   // record name be an Init is to provide this flexibility.  The extra
    1879             :   // resolve steps after completely instantiating defs takes care of
    1880             :   // this.  See TGParser::ParseDef and TGParser::ParseDefm.
    1881     1080297 : }
    1882             : 
    1883     1106090 : void Record::getDirectSuperClasses(SmallVectorImpl<Record *> &Classes) const {
    1884             :   ArrayRef<std::pair<Record *, SMRange>> SCs = getSuperClasses();
    1885     2558651 :   while (!SCs.empty()) {
    1886             :     // Superclasses are in reverse preorder, so 'back' is a direct superclass,
    1887             :     // and its transitive superclasses are directly preceding it.
    1888     1452561 :     Record *SC = SCs.back().first;
    1889     1452561 :     SCs = SCs.drop_back(1 + SC->getSuperClasses().size());
    1890     1452561 :     Classes.push_back(SC);
    1891             :   }
    1892     1106090 : }
    1893             : 
    1894     7919753 : void Record::resolveReferences(Resolver &R, const RecordVal *SkipVal) {
    1895   230466568 :   for (RecordVal &Value : Values) {
    1896   222546818 :     if (SkipVal == &Value) // Skip resolve the same field as the given one
    1897             :       continue;
    1898   222546818 :     if (Init *V = Value.getValue()) {
    1899   222546810 :       Init *VR = V->resolveReferences(R);
    1900   222546807 :       if (Value.setValue(VR)) {
    1901             :         std::string Type;
    1902             :         if (TypedInit *VRT = dyn_cast<TypedInit>(VR))
    1903             :           Type =
    1904           0 :               (Twine("of type '") + VRT->getType()->getAsString() + "' ").str();
    1905           0 :         PrintFatalError(getLoc(), Twine("Invalid value ") + Type +
    1906             :                                       "is found when setting '" +
    1907             :                                       Value.getNameInitAsString() +
    1908             :                                       "' of type '" +
    1909           0 :                                       Value.getType()->getAsString() +
    1910             :                                       "' after resolving references: " +
    1911           0 :                                       VR->getAsUnquotedString() + "\n");
    1912             :       }
    1913             :     }
    1914             :   }
    1915     7919750 :   Init *OldName = getNameInit();
    1916     7919750 :   Init *NewName = Name->resolveReferences(R);
    1917     7919750 :   if (NewName != OldName) {
    1918             :     // Re-register with RecordKeeper.
    1919      863893 :     setName(NewName);
    1920             :   }
    1921     7919750 : }
    1922             : 
    1923     3209586 : void Record::resolveReferences() {
    1924     3209584 :   RecordResolver R(*this);
    1925             :   R.setFinal(true);
    1926     3209586 :   resolveReferences(R);
    1927     3209584 : }
    1928             : 
    1929           0 : void Record::resolveReferencesTo(const RecordVal *RV) {
    1930             :   RecordValResolver R(*this, RV);
    1931           0 :   resolveReferences(R, RV);
    1932           0 : }
    1933             : 
    1934             : #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
    1935             : LLVM_DUMP_METHOD void Record::dump() const { errs() << *this; }
    1936             : #endif
    1937             : 
    1938         912 : raw_ostream &llvm::operator<<(raw_ostream &OS, const Record &R) {
    1939         912 :   OS << R.getNameInitAsString();
    1940             : 
    1941             :   ArrayRef<Init *> TArgs = R.getTemplateArgs();
    1942         912 :   if (!TArgs.empty()) {
    1943         171 :     OS << "<";
    1944             :     bool NeedComma = false;
    1945         419 :     for (const Init *TA : TArgs) {
    1946         248 :       if (NeedComma) OS << ", ";
    1947             :       NeedComma = true;
    1948             :       const RecordVal *RV = R.getValue(TA);
    1949             :       assert(RV && "Template argument record not found??");
    1950         248 :       RV->print(OS, false);
    1951             :     }
    1952         171 :     OS << ">";
    1953             :   }
    1954             : 
    1955         912 :   OS << " {";
    1956             :   ArrayRef<std::pair<Record *, SMRange>> SC = R.getSuperClasses();
    1957         912 :   if (!SC.empty()) {
    1958         632 :     OS << "\t//";
    1959        1353 :     for (const auto &SuperPair : SC)
    1960        1442 :       OS << " " << SuperPair.first->getNameInitAsString();
    1961             :   }
    1962         912 :   OS << "\n";
    1963             : 
    1964        2750 :   for (const RecordVal &Val : R.getValues())
    1965        1841 :     if (Val.getPrefix() && !R.isTemplateArg(Val.getNameInit()))
    1966           3 :       OS << Val;
    1967        2750 :   for (const RecordVal &Val : R.getValues())
    1968        3673 :     if (!Val.getPrefix() && !R.isTemplateArg(Val.getNameInit()))
    1969        1587 :       OS << Val;
    1970             : 
    1971         912 :   return OS << "}\n";
    1972             : }
    1973             : 
    1974      837989 : Init *Record::getValueInit(StringRef FieldName) const {
    1975      837989 :   const RecordVal *R = getValue(FieldName);
    1976      837989 :   if (!R || !R->getValue())
    1977           0 :     PrintFatalError(getLoc(), "Record `" + getName() +
    1978             :       "' does not have a field named `" + FieldName + "'!\n");
    1979      837989 :   return R->getValue();
    1980             : }
    1981             : 
    1982     8981556 : StringRef Record::getValueAsString(StringRef FieldName) const {
    1983     8981556 :   const RecordVal *R = getValue(FieldName);
    1984     8981556 :   if (!R || !R->getValue())
    1985           0 :     PrintFatalError(getLoc(), "Record `" + getName() +
    1986             :       "' does not have a field named `" + FieldName + "'!\n");
    1987             : 
    1988             :   if (StringInit *SI = dyn_cast<StringInit>(R->getValue()))
    1989     8685076 :     return SI->getValue();
    1990             :   if (CodeInit *CI = dyn_cast<CodeInit>(R->getValue()))
    1991      296480 :     return CI->getValue();
    1992             : 
    1993           0 :   PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
    1994             :     FieldName + "' does not have a string initializer!");
    1995             : }
    1996             : 
    1997      804412 : BitsInit *Record::getValueAsBitsInit(StringRef FieldName) const {
    1998      804412 :   const RecordVal *R = getValue(FieldName);
    1999      804412 :   if (!R || !R->getValue())
    2000           0 :     PrintFatalError(getLoc(), "Record `" + getName() +
    2001             :       "' does not have a field named `" + FieldName + "'!\n");
    2002             : 
    2003             :   if (BitsInit *BI = dyn_cast<BitsInit>(R->getValue()))
    2004      804412 :     return BI;
    2005           0 :   PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
    2006             :     FieldName + "' does not have a BitsInit initializer!");
    2007             : }
    2008             : 
    2009     5787829 : ListInit *Record::getValueAsListInit(StringRef FieldName) const {
    2010     5787829 :   const RecordVal *R = getValue(FieldName);
    2011     5787829 :   if (!R || !R->getValue())
    2012           0 :     PrintFatalError(getLoc(), "Record `" + getName() +
    2013             :       "' does not have a field named `" + FieldName + "'!\n");
    2014             : 
    2015             :   if (ListInit *LI = dyn_cast<ListInit>(R->getValue()))
    2016     5787829 :     return LI;
    2017           0 :   PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
    2018             :     FieldName + "' does not have a list initializer!");
    2019             : }
    2020             : 
    2021             : std::vector<Record*>
    2022     4172028 : Record::getValueAsListOfDefs(StringRef FieldName) const {
    2023     4172028 :   ListInit *List = getValueAsListInit(FieldName);
    2024             :   std::vector<Record*> Defs;
    2025     9575187 :   for (Init *I : List->getValues()) {
    2026             :     if (DefInit *DI = dyn_cast<DefInit>(I))
    2027     5403159 :       Defs.push_back(DI->getDef());
    2028             :     else
    2029           0 :       PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
    2030             :         FieldName + "' list is not entirely DefInit!");
    2031             :   }
    2032     4172028 :   return Defs;
    2033             : }
    2034             : 
    2035     3905828 : int64_t Record::getValueAsInt(StringRef FieldName) const {
    2036     3905828 :   const RecordVal *R = getValue(FieldName);
    2037     3905828 :   if (!R || !R->getValue())
    2038           0 :     PrintFatalError(getLoc(), "Record `" + getName() +
    2039             :       "' does not have a field named `" + FieldName + "'!\n");
    2040             : 
    2041             :   if (IntInit *II = dyn_cast<IntInit>(R->getValue()))
    2042     3905828 :     return II->getValue();
    2043           0 :   PrintFatalError(getLoc(), Twine("Record `") + getName() + "', field `" +
    2044             :                                 FieldName +
    2045             :                                 "' does not have an int initializer: " +
    2046           0 :                                 R->getValue()->getAsString());
    2047             : }
    2048             : 
    2049             : std::vector<int64_t>
    2050       72845 : Record::getValueAsListOfInts(StringRef FieldName) const {
    2051       72845 :   ListInit *List = getValueAsListInit(FieldName);
    2052             :   std::vector<int64_t> Ints;
    2053      111496 :   for (Init *I : List->getValues()) {
    2054             :     if (IntInit *II = dyn_cast<IntInit>(I))
    2055       38651 :       Ints.push_back(II->getValue());
    2056             :     else
    2057           0 :       PrintFatalError(getLoc(),
    2058           0 :                       Twine("Record `") + getName() + "', field `" + FieldName +
    2059             :                           "' does not have a list of ints initializer: " +
    2060           0 :                           I->getAsString());
    2061             :   }
    2062       72845 :   return Ints;
    2063             : }
    2064             : 
    2065             : std::vector<StringRef>
    2066       11384 : Record::getValueAsListOfStrings(StringRef FieldName) const {
    2067       11384 :   ListInit *List = getValueAsListInit(FieldName);
    2068             :   std::vector<StringRef> Strings;
    2069       23522 :   for (Init *I : List->getValues()) {
    2070             :     if (StringInit *SI = dyn_cast<StringInit>(I))
    2071       12138 :       Strings.push_back(SI->getValue());
    2072             :     else
    2073           0 :       PrintFatalError(getLoc(),
    2074           0 :                       Twine("Record `") + getName() + "', field `" + FieldName +
    2075             :                           "' does not have a list of strings initializer: " +
    2076           0 :                           I->getAsString());
    2077             :   }
    2078       11384 :   return Strings;
    2079             : }
    2080             : 
    2081    15789114 : Record *Record::getValueAsDef(StringRef FieldName) const {
    2082    15789114 :   const RecordVal *R = getValue(FieldName);
    2083    15789114 :   if (!R || !R->getValue())
    2084           0 :     PrintFatalError(getLoc(), "Record `" + getName() +
    2085             :       "' does not have a field named `" + FieldName + "'!\n");
    2086             : 
    2087             :   if (DefInit *DI = dyn_cast<DefInit>(R->getValue()))
    2088    15789114 :     return DI->getDef();
    2089           0 :   PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
    2090             :     FieldName + "' does not have a def initializer!");
    2091             : }
    2092             : 
    2093    36213795 : bool Record::getValueAsBit(StringRef FieldName) const {
    2094    36213795 :   const RecordVal *R = getValue(FieldName);
    2095    36213795 :   if (!R || !R->getValue())
    2096           0 :     PrintFatalError(getLoc(), "Record `" + getName() +
    2097             :       "' does not have a field named `" + FieldName + "'!\n");
    2098             : 
    2099             :   if (BitInit *BI = dyn_cast<BitInit>(R->getValue()))
    2100    36213795 :     return BI->getValue();
    2101           0 :   PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
    2102             :     FieldName + "' does not have a bit initializer!");
    2103             : }
    2104             : 
    2105     2450045 : bool Record::getValueAsBitOrUnset(StringRef FieldName, bool &Unset) const {
    2106     2450045 :   const RecordVal *R = getValue(FieldName);
    2107     2450045 :   if (!R || !R->getValue())
    2108           0 :     PrintFatalError(getLoc(), "Record `" + getName() +
    2109           0 :       "' does not have a field named `" + FieldName.str() + "'!\n");
    2110             : 
    2111     2450045 :   if (isa<UnsetInit>(R->getValue())) {
    2112     1815631 :     Unset = true;
    2113     1815631 :     return false;
    2114             :   }
    2115      634414 :   Unset = false;
    2116             :   if (BitInit *BI = dyn_cast<BitInit>(R->getValue()))
    2117      634414 :     return BI->getValue();
    2118           0 :   PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
    2119             :     FieldName + "' does not have a bit initializer!");
    2120             : }
    2121             : 
    2122     2421303 : DagInit *Record::getValueAsDag(StringRef FieldName) const {
    2123     2421303 :   const RecordVal *R = getValue(FieldName);
    2124     2421303 :   if (!R || !R->getValue())
    2125           0 :     PrintFatalError(getLoc(), "Record `" + getName() +
    2126             :       "' does not have a field named `" + FieldName + "'!\n");
    2127             : 
    2128             :   if (DagInit *DI = dyn_cast<DagInit>(R->getValue()))
    2129     2421303 :     return DI;
    2130           0 :   PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
    2131             :     FieldName + "' does not have a dag initializer!");
    2132             : }
    2133             : 
    2134             : #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
    2135             : LLVM_DUMP_METHOD void RecordKeeper::dump() const { errs() << *this; }
    2136             : #endif
    2137             : 
    2138          80 : raw_ostream &llvm::operator<<(raw_ostream &OS, const RecordKeeper &RK) {
    2139          80 :   OS << "------------- Classes -----------------\n";
    2140         283 :   for (const auto &C : RK.getClasses())
    2141         203 :     OS << "class " << *C.second;
    2142             : 
    2143          80 :   OS << "------------- Defs -----------------\n";
    2144         789 :   for (const auto &D : RK.getDefs())
    2145         709 :     OS << "def " << *D.second;
    2146          80 :   return OS;
    2147             : }
    2148             : 
    2149             : /// GetNewAnonymousName - Generate a unique anonymous name that can be used as
    2150             : /// an identifier.
    2151      830948 : Init *RecordKeeper::getNewAnonymousName() {
    2152      830948 :   return StringInit::get("anonymous_" + utostr(AnonCounter++));
    2153             : }
    2154             : 
    2155             : std::vector<Record *>
    2156        3474 : RecordKeeper::getAllDerivedDefinitions(StringRef ClassName) const {
    2157        3474 :   Record *Class = getClass(ClassName);
    2158        3474 :   if (!Class)
    2159           0 :     PrintFatalError("ERROR: Couldn't find the `" + ClassName + "' class!\n");
    2160             : 
    2161             :   std::vector<Record*> Defs;
    2162    52488416 :   for (const auto &D : getDefs())
    2163    52484942 :     if (D.second->isSubClassOf(Class))
    2164     1993753 :       Defs.push_back(D.second.get());
    2165             : 
    2166        3474 :   return Defs;
    2167             : }
    2168             : 
    2169    64310960 : Init *MapResolver::resolve(Init *VarName) {
    2170    64310960 :   auto It = Map.find(VarName);
    2171    64310960 :   if (It == Map.end())
    2172             :     return nullptr;
    2173             : 
    2174    22500956 :   Init *I = It->second.V;
    2175             : 
    2176    22500956 :   if (!It->second.Resolved && Map.size() > 1) {
    2177             :     // Resolve mutual references among the mapped variables, but prevent
    2178             :     // infinite recursion.
    2179             :     Map.erase(It);
    2180    12964260 :     I = I->resolveReferences(*this);
    2181    12964260 :     Map[VarName] = {I, true};
    2182             :   }
    2183             : 
    2184             :   return I;
    2185             : }
    2186             : 
    2187    20831560 : Init *RecordResolver::resolve(Init *VarName) {
    2188    36943767 :   Init *Val = Cache.lookup(VarName);
    2189     4719353 :   if (Val)
    2190             :     return Val;
    2191             : 
    2192    17967385 :   for (Init *S : Stack) {
    2193     1855177 :     if (S == VarName)
    2194             :       return nullptr; // prevent infinite recursion
    2195             :   }
    2196             : 
    2197    32224416 :   if (RecordVal *RV = getCurrentRecord()->getValue(VarName)) {
    2198    32224416 :     if (!isa<UnsetInit>(RV->getValue())) {
    2199             :       Val = RV->getValue();
    2200    16110214 :       Stack.push_back(VarName);
    2201    16110214 :       Val = Val->resolveReferences(*this);
    2202             :       Stack.pop_back();
    2203             :     }
    2204             :   }
    2205             : 
    2206    16112208 :   Cache[VarName] = Val;
    2207    16112208 :   return Val;
    2208             : }
    2209             : 
    2210    14176062 : Init *TrackUnresolvedResolver::resolve(Init *VarName) {
    2211             :   Init *I = nullptr;
    2212             : 
    2213    14176062 :   if (R) {
    2214    14111622 :     I = R->resolve(VarName);
    2215    14111622 :     if (I && !FoundUnresolved) {
    2216             :       // Do not recurse into the resolved initializer, as that would change
    2217             :       // the behavior of the resolver we're delegating, but do check to see
    2218             :       // if there are unresolved variables remaining.
    2219             :       TrackUnresolvedResolver Sub;
    2220     6013373 :       I->resolveReferences(Sub);
    2221     6013373 :       FoundUnresolved |= Sub.FoundUnresolved;
    2222             :     }
    2223             :   }
    2224             : 
    2225    14111622 :   if (!I)
    2226     7594318 :     FoundUnresolved = true;
    2227    14176062 :   return I;
    2228             : }
    2229             : 
    2230       14656 : Init *HasReferenceResolver::resolve(Init *VarName)
    2231             : {
    2232       14656 :   if (VarName == VarNameToTrack)
    2233       12590 :     Found = true;
    2234       14656 :   return nullptr;
    2235             : }

Generated by: LCOV version 1.13