Home | History | Annotate | Download | only in TableGen 
      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/TableGen/Record.h"
     15 #include "llvm/ADT/DenseMap.h"
     16 #include "llvm/ADT/FoldingSet.h"
     17 #include "llvm/ADT/Hashing.h"
     18 #include "llvm/ADT/STLExtras.h"
     19 #include "llvm/ADT/SmallVector.h"
     20 #include "llvm/ADT/StringExtras.h"
     21 #include "llvm/ADT/StringMap.h"
     22 #include "llvm/Support/DataTypes.h"
     23 #include "llvm/Support/ErrorHandling.h"
     24 #include "llvm/Support/Format.h"
     25 #include "llvm/TableGen/Error.h"
     26 
     27 using namespace llvm;
     28 
     29 //===----------------------------------------------------------------------===//
     30 //    std::string wrapper for DenseMap purposes
     31 //===----------------------------------------------------------------------===//
     32 
     33 namespace llvm {
     34 
     35 /// TableGenStringKey - This is a wrapper for std::string suitable for
     36 /// using as a key to a DenseMap.  Because there isn't a particularly
     37 /// good way to indicate tombstone or empty keys for strings, we want
     38 /// to wrap std::string to indicate that this is a "special" string
     39 /// not expected to take on certain values (those of the tombstone and
     40 /// empty keys).  This makes things a little safer as it clarifies
     41 /// that DenseMap is really not appropriate for general strings.
     42 
     43 class TableGenStringKey {
     44 public:
     45   TableGenStringKey(const std::string &str) : data(str) {}
     46   TableGenStringKey(const char *str) : data(str) {}
     47 
     48   const std::string &str() const { return data; }
     49 
     50   friend hash_code hash_value(const TableGenStringKey &Value) {
     51     using llvm::hash_value;
     52     return hash_value(Value.str());
     53   }
     54 private:
     55   std::string data;
     56 };
     57 
     58 /// Specialize DenseMapInfo for TableGenStringKey.
     59 template<> struct DenseMapInfo<TableGenStringKey> {
     60   static inline TableGenStringKey getEmptyKey() {
     61     TableGenStringKey Empty("<<<EMPTY KEY>>>");
     62     return Empty;
     63   }
     64   static inline TableGenStringKey getTombstoneKey() {
     65     TableGenStringKey Tombstone("<<<TOMBSTONE KEY>>>");
     66     return Tombstone;
     67   }
     68   static unsigned getHashValue(const TableGenStringKey& Val) {
     69     using llvm::hash_value;
     70     return hash_value(Val);
     71   }
     72   static bool isEqual(const TableGenStringKey& LHS,
     73                       const TableGenStringKey& RHS) {
     74     return LHS.str() == RHS.str();
     75   }
     76 };
     77 
     78 } // namespace llvm
     79 
     80 //===----------------------------------------------------------------------===//
     81 //    Type implementations
     82 //===----------------------------------------------------------------------===//
     83 
     84 BitRecTy BitRecTy::Shared;
     85 IntRecTy IntRecTy::Shared;
     86 StringRecTy StringRecTy::Shared;
     87 DagRecTy DagRecTy::Shared;
     88 
     89 void RecTy::dump() const { print(errs()); }
     90 
     91 ListRecTy *RecTy::getListTy() {
     92   if (!ListTy)
     93     ListTy.reset(new ListRecTy(this));
     94   return ListTy.get();
     95 }
     96 
     97 bool RecTy::typeIsConvertibleTo(const RecTy *RHS) const {
     98   assert(RHS && "NULL pointer");
     99   return Kind == RHS->getRecTyKind();
    100 }
    101 
    102 bool BitRecTy::typeIsConvertibleTo(const RecTy *RHS) const{
    103   if (RecTy::typeIsConvertibleTo(RHS) || RHS->getRecTyKind() == IntRecTyKind)
    104     return true;
    105   if (const BitsRecTy *BitsTy = dyn_cast<BitsRecTy>(RHS))
    106     return BitsTy->getNumBits() == 1;
    107   return false;
    108 }
    109 
    110 BitsRecTy *BitsRecTy::get(unsigned Sz) {
    111   static std::vector<std::unique_ptr<BitsRecTy>> Shared;
    112   if (Sz >= Shared.size())
    113     Shared.resize(Sz + 1);
    114   std::unique_ptr<BitsRecTy> &Ty = Shared[Sz];
    115   if (!Ty)
    116     Ty.reset(new BitsRecTy(Sz));
    117   return Ty.get();
    118 }
    119 
    120 std::string BitsRecTy::getAsString() const {
    121   return "bits<" + utostr(Size) + ">";
    122 }
    123 
    124 bool BitsRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
    125   if (RecTy::typeIsConvertibleTo(RHS)) //argument and the sender are same type
    126     return cast<BitsRecTy>(RHS)->Size == Size;
    127   RecTyKind kind = RHS->getRecTyKind();
    128   return (kind == BitRecTyKind && Size == 1) || (kind == IntRecTyKind);
    129 }
    130 
    131 bool IntRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
    132   RecTyKind kind = RHS->getRecTyKind();
    133   return kind==BitRecTyKind || kind==BitsRecTyKind || kind==IntRecTyKind;
    134 }
    135 
    136 std::string StringRecTy::getAsString() const {
    137   return "string";
    138 }
    139 
    140 std::string ListRecTy::getAsString() const {
    141   return "list<" + Ty->getAsString() + ">";
    142 }
    143 
    144 bool ListRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
    145   if (const auto *ListTy = dyn_cast<ListRecTy>(RHS))
    146     return Ty->typeIsConvertibleTo(ListTy->getElementType());
    147   return false;
    148 }
    149 
    150 std::string DagRecTy::getAsString() const {
    151   return "dag";
    152 }
    153 
    154 RecordRecTy *RecordRecTy::get(Record *R) {
    155   return dyn_cast<RecordRecTy>(R->getDefInit()->getType());
    156 }
    157 
    158 std::string RecordRecTy::getAsString() const {
    159   return Rec->getName();
    160 }
    161 
    162 bool RecordRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
    163   const RecordRecTy *RTy = dyn_cast<RecordRecTy>(RHS);
    164   if (!RTy)
    165     return false;
    166 
    167   if (RTy->getRecord() == Rec || Rec->isSubClassOf(RTy->getRecord()))
    168     return true;
    169 
    170   for (Record *SC : RTy->getRecord()->getSuperClasses())
    171     if (Rec->isSubClassOf(SC))
    172       return true;
    173 
    174   return false;
    175 }
    176 
    177 /// resolveTypes - Find a common type that T1 and T2 convert to.
    178 /// Return null if no such type exists.
    179 ///
    180 RecTy *llvm::resolveTypes(RecTy *T1, RecTy *T2) {
    181   if (T1->typeIsConvertibleTo(T2))
    182     return T2;
    183   if (T2->typeIsConvertibleTo(T1))
    184     return T1;
    185 
    186   // If one is a Record type, check superclasses
    187   if (RecordRecTy *RecTy1 = dyn_cast<RecordRecTy>(T1)) {
    188     // See if T2 inherits from a type T1 also inherits from
    189     for (Record *SuperRec1 : RecTy1->getRecord()->getSuperClasses()) {
    190       RecordRecTy *SuperRecTy1 = RecordRecTy::get(SuperRec1);
    191       RecTy *NewType1 = resolveTypes(SuperRecTy1, T2);
    192       if (NewType1)
    193         return NewType1;
    194     }
    195   }
    196   if (RecordRecTy *RecTy2 = dyn_cast<RecordRecTy>(T2)) {
    197     // See if T1 inherits from a type T2 also inherits from
    198     for (Record *SuperRec2 : RecTy2->getRecord()->getSuperClasses()) {
    199       RecordRecTy *SuperRecTy2 = RecordRecTy::get(SuperRec2);
    200       RecTy *NewType2 = resolveTypes(T1, SuperRecTy2);
    201       if (NewType2)
    202         return NewType2;
    203     }
    204   }
    205   return nullptr;
    206 }
    207 
    208 
    209 //===----------------------------------------------------------------------===//
    210 //    Initializer implementations
    211 //===----------------------------------------------------------------------===//
    212 
    213 void Init::anchor() { }
    214 void Init::dump() const { return print(errs()); }
    215 
    216 UnsetInit *UnsetInit::get() {
    217   static UnsetInit TheInit;
    218   return &TheInit;
    219 }
    220 
    221 Init *UnsetInit::convertInitializerTo(RecTy *Ty) const {
    222   if (auto *BRT = dyn_cast<BitsRecTy>(Ty)) {
    223     SmallVector<Init *, 16> NewBits(BRT->getNumBits());
    224 
    225     for (unsigned i = 0; i != BRT->getNumBits(); ++i)
    226       NewBits[i] = UnsetInit::get();
    227 
    228     return BitsInit::get(NewBits);
    229   }
    230 
    231   // All other types can just be returned.
    232   return const_cast<UnsetInit *>(this);
    233 }
    234 
    235 BitInit *BitInit::get(bool V) {
    236   static BitInit True(true);
    237   static BitInit False(false);
    238 
    239   return V ? &True : &False;
    240 }
    241 
    242 Init *BitInit::convertInitializerTo(RecTy *Ty) const {
    243   if (isa<BitRecTy>(Ty))
    244     return const_cast<BitInit *>(this);
    245 
    246   if (isa<IntRecTy>(Ty))
    247     return IntInit::get(getValue());
    248 
    249   if (auto *BRT = dyn_cast<BitsRecTy>(Ty)) {
    250     // Can only convert single bit.
    251     if (BRT->getNumBits() == 1)
    252       return BitsInit::get(const_cast<BitInit *>(this));
    253   }
    254 
    255   return nullptr;
    256 }
    257 
    258 static void
    259 ProfileBitsInit(FoldingSetNodeID &ID, ArrayRef<Init *> Range) {
    260   ID.AddInteger(Range.size());
    261 
    262   for (Init *I : Range)
    263     ID.AddPointer(I);
    264 }
    265 
    266 BitsInit *BitsInit::get(ArrayRef<Init *> Range) {
    267   static FoldingSet<BitsInit> ThePool;
    268   static std::vector<std::unique_ptr<BitsInit>> TheActualPool;
    269 
    270   FoldingSetNodeID ID;
    271   ProfileBitsInit(ID, Range);
    272 
    273   void *IP = nullptr;
    274   if (BitsInit *I = ThePool.FindNodeOrInsertPos(ID, IP))
    275     return I;
    276 
    277   BitsInit *I = new BitsInit(Range);
    278   ThePool.InsertNode(I, IP);
    279   TheActualPool.push_back(std::unique_ptr<BitsInit>(I));
    280   return I;
    281 }
    282 
    283 void BitsInit::Profile(FoldingSetNodeID &ID) const {
    284   ProfileBitsInit(ID, Bits);
    285 }
    286 
    287 Init *BitsInit::convertInitializerTo(RecTy *Ty) const {
    288   if (isa<BitRecTy>(Ty)) {
    289     if (getNumBits() != 1) return nullptr; // Only accept if just one bit!
    290     return getBit(0);
    291   }
    292 
    293   if (auto *BRT = dyn_cast<BitsRecTy>(Ty)) {
    294     // If the number of bits is right, return it.  Otherwise we need to expand
    295     // or truncate.
    296     if (getNumBits() != BRT->getNumBits()) return nullptr;
    297     return const_cast<BitsInit *>(this);
    298   }
    299 
    300   if (isa<IntRecTy>(Ty)) {
    301     int64_t Result = 0;
    302     for (unsigned i = 0, e = getNumBits(); i != e; ++i)
    303       if (auto *Bit = dyn_cast<BitInit>(getBit(i)))
    304         Result |= static_cast<int64_t>(Bit->getValue()) << i;
    305       else
    306         return nullptr;
    307     return IntInit::get(Result);
    308   }
    309 
    310   return nullptr;
    311 }
    312 
    313 Init *
    314 BitsInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const {
    315   SmallVector<Init *, 16> NewBits(Bits.size());
    316 
    317   for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
    318     if (Bits[i] >= getNumBits())
    319       return nullptr;
    320     NewBits[i] = getBit(Bits[i]);
    321   }
    322   return BitsInit::get(NewBits);
    323 }
    324 
    325 std::string BitsInit::getAsString() const {
    326   std::string Result = "{ ";
    327   for (unsigned i = 0, e = getNumBits(); i != e; ++i) {
    328     if (i) Result += ", ";
    329     if (Init *Bit = getBit(e-i-1))
    330       Result += Bit->getAsString();
    331     else
    332       Result += "*";
    333   }
    334   return Result + " }";
    335 }
    336 
    337 // Fix bit initializer to preserve the behavior that bit reference from a unset
    338 // bits initializer will resolve into VarBitInit to keep the field name and bit
    339 // number used in targets with fixed insn length.
    340 static Init *fixBitInit(const RecordVal *RV, Init *Before, Init *After) {
    341   if (RV || !isa<UnsetInit>(After))
    342     return After;
    343   return Before;
    344 }
    345 
    346 // resolveReferences - If there are any field references that refer to fields
    347 // that have been filled in, we can propagate the values now.
    348 //
    349 Init *BitsInit::resolveReferences(Record &R, const RecordVal *RV) const {
    350   bool Changed = false;
    351   SmallVector<Init *, 16> NewBits(getNumBits());
    352 
    353   Init *CachedInit = nullptr;
    354   Init *CachedBitVar = nullptr;
    355   bool CachedBitVarChanged = false;
    356 
    357   for (unsigned i = 0, e = getNumBits(); i != e; ++i) {
    358     Init *CurBit = Bits[i];
    359     Init *CurBitVar = CurBit->getBitVar();
    360 
    361     NewBits[i] = CurBit;
    362 
    363     if (CurBitVar == CachedBitVar) {
    364       if (CachedBitVarChanged) {
    365         Init *Bit = CachedInit->getBit(CurBit->getBitNum());
    366         NewBits[i] = fixBitInit(RV, CurBit, Bit);
    367       }
    368       continue;
    369     }
    370     CachedBitVar = CurBitVar;
    371     CachedBitVarChanged = false;
    372 
    373     Init *B;
    374     do {
    375       B = CurBitVar;
    376       CurBitVar = CurBitVar->resolveReferences(R, RV);
    377       CachedBitVarChanged |= B != CurBitVar;
    378       Changed |= B != CurBitVar;
    379     } while (B != CurBitVar);
    380     CachedInit = CurBitVar;
    381 
    382     if (CachedBitVarChanged) {
    383       Init *Bit = CurBitVar->getBit(CurBit->getBitNum());
    384       NewBits[i] = fixBitInit(RV, CurBit, Bit);
    385     }
    386   }
    387 
    388   if (Changed)
    389     return BitsInit::get(NewBits);
    390 
    391   return const_cast<BitsInit *>(this);
    392 }
    393 
    394 IntInit *IntInit::get(int64_t V) {
    395   static DenseMap<int64_t, std::unique_ptr<IntInit>> ThePool;
    396 
    397   std::unique_ptr<IntInit> &I = ThePool[V];
    398   if (!I) I.reset(new IntInit(V));
    399   return I.get();
    400 }
    401 
    402 std::string IntInit::getAsString() const {
    403   return itostr(Value);
    404 }
    405 
    406 /// canFitInBitfield - Return true if the number of bits is large enough to hold
    407 /// the integer value.
    408 static bool canFitInBitfield(int64_t Value, unsigned NumBits) {
    409   // For example, with NumBits == 4, we permit Values from [-7 .. 15].
    410   return (NumBits >= sizeof(Value) * 8) ||
    411          (Value >> NumBits == 0) || (Value >> (NumBits-1) == -1);
    412 }
    413 
    414 Init *IntInit::convertInitializerTo(RecTy *Ty) const {
    415   if (isa<IntRecTy>(Ty))
    416     return const_cast<IntInit *>(this);
    417 
    418   if (isa<BitRecTy>(Ty)) {
    419     int64_t Val = getValue();
    420     if (Val != 0 && Val != 1) return nullptr;  // Only accept 0 or 1 for a bit!
    421     return BitInit::get(Val != 0);
    422   }
    423 
    424   if (auto *BRT = dyn_cast<BitsRecTy>(Ty)) {
    425     int64_t Value = getValue();
    426     // Make sure this bitfield is large enough to hold the integer value.
    427     if (!canFitInBitfield(Value, BRT->getNumBits()))
    428       return nullptr;
    429 
    430     SmallVector<Init *, 16> NewBits(BRT->getNumBits());
    431     for (unsigned i = 0; i != BRT->getNumBits(); ++i)
    432       NewBits[i] = BitInit::get(Value & (1LL << i));
    433 
    434     return BitsInit::get(NewBits);
    435   }
    436 
    437   return nullptr;
    438 }
    439 
    440 Init *
    441 IntInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const {
    442   SmallVector<Init *, 16> NewBits(Bits.size());
    443 
    444   for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
    445     if (Bits[i] >= 64)
    446       return nullptr;
    447 
    448     NewBits[i] = BitInit::get(Value & (INT64_C(1) << Bits[i]));
    449   }
    450   return BitsInit::get(NewBits);
    451 }
    452 
    453 StringInit *StringInit::get(StringRef V) {
    454   static StringMap<std::unique_ptr<StringInit>> ThePool;
    455 
    456   std::unique_ptr<StringInit> &I = ThePool[V];
    457   if (!I) I.reset(new StringInit(V));
    458   return I.get();
    459 }
    460 
    461 Init *StringInit::convertInitializerTo(RecTy *Ty) const {
    462   if (isa<StringRecTy>(Ty))
    463     return const_cast<StringInit *>(this);
    464 
    465   return nullptr;
    466 }
    467 
    468 static void ProfileListInit(FoldingSetNodeID &ID,
    469                             ArrayRef<Init *> Range,
    470                             RecTy *EltTy) {
    471   ID.AddInteger(Range.size());
    472   ID.AddPointer(EltTy);
    473 
    474   for (Init *I : Range)
    475     ID.AddPointer(I);
    476 }
    477 
    478 ListInit *ListInit::get(ArrayRef<Init *> Range, RecTy *EltTy) {
    479   static FoldingSet<ListInit> ThePool;
    480   static std::vector<std::unique_ptr<ListInit>> TheActualPool;
    481 
    482   FoldingSetNodeID ID;
    483   ProfileListInit(ID, Range, EltTy);
    484 
    485   void *IP = nullptr;
    486   if (ListInit *I = ThePool.FindNodeOrInsertPos(ID, IP))
    487     return I;
    488 
    489   ListInit *I = new ListInit(Range, EltTy);
    490   ThePool.InsertNode(I, IP);
    491   TheActualPool.push_back(std::unique_ptr<ListInit>(I));
    492   return I;
    493 }
    494 
    495 void ListInit::Profile(FoldingSetNodeID &ID) const {
    496   RecTy *EltTy = cast<ListRecTy>(getType())->getElementType();
    497 
    498   ProfileListInit(ID, Values, EltTy);
    499 }
    500 
    501 Init *ListInit::convertInitializerTo(RecTy *Ty) const {
    502   if (auto *LRT = dyn_cast<ListRecTy>(Ty)) {
    503     std::vector<Init*> Elements;
    504 
    505     // Verify that all of the elements of the list are subclasses of the
    506     // appropriate class!
    507     for (Init *I : getValues())
    508       if (Init *CI = I->convertInitializerTo(LRT->getElementType()))
    509         Elements.push_back(CI);
    510       else
    511         return nullptr;
    512 
    513     if (isa<ListRecTy>(getType()))
    514       return ListInit::get(Elements, Ty);
    515   }
    516 
    517   return nullptr;
    518 }
    519 
    520 Init *
    521 ListInit::convertInitListSlice(const std::vector<unsigned> &Elements) const {
    522   std::vector<Init*> Vals;
    523   for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
    524     if (Elements[i] >= size())
    525       return nullptr;
    526     Vals.push_back(getElement(Elements[i]));
    527   }
    528   return ListInit::get(Vals, getType());
    529 }
    530 
    531 Record *ListInit::getElementAsRecord(unsigned i) const {
    532   assert(i < Values.size() && "List element index out of range!");
    533   DefInit *DI = dyn_cast<DefInit>(Values[i]);
    534   if (!DI)
    535     PrintFatalError("Expected record in list!");
    536   return DI->getDef();
    537 }
    538 
    539 Init *ListInit::resolveReferences(Record &R, const RecordVal *RV) const {
    540   std::vector<Init*> Resolved;
    541   Resolved.reserve(size());
    542   bool Changed = false;
    543 
    544   for (Init *CurElt : getValues()) {
    545     Init *E;
    546 
    547     do {
    548       E = CurElt;
    549       CurElt = CurElt->resolveReferences(R, RV);
    550       Changed |= E != CurElt;
    551     } while (E != CurElt);
    552     Resolved.push_back(E);
    553   }
    554 
    555   if (Changed)
    556     return ListInit::get(Resolved, getType());
    557   return const_cast<ListInit *>(this);
    558 }
    559 
    560 Init *ListInit::resolveListElementReference(Record &R, const RecordVal *IRV,
    561                                             unsigned Elt) const {
    562   if (Elt >= size())
    563     return nullptr;  // Out of range reference.
    564   Init *E = getElement(Elt);
    565   // If the element is set to some value, or if we are resolving a reference
    566   // to a specific variable and that variable is explicitly unset, then
    567   // replace the VarListElementInit with it.
    568   if (IRV || !isa<UnsetInit>(E))
    569     return E;
    570   return nullptr;
    571 }
    572 
    573 std::string ListInit::getAsString() const {
    574   std::string Result = "[";
    575   for (unsigned i = 0, e = Values.size(); i != e; ++i) {
    576     if (i) Result += ", ";
    577     Result += Values[i]->getAsString();
    578   }
    579   return Result + "]";
    580 }
    581 
    582 Init *OpInit::resolveListElementReference(Record &R, const RecordVal *IRV,
    583                                           unsigned Elt) const {
    584   Init *Resolved = resolveReferences(R, IRV);
    585   OpInit *OResolved = dyn_cast<OpInit>(Resolved);
    586   if (OResolved) {
    587     Resolved = OResolved->Fold(&R, nullptr);
    588   }
    589 
    590   if (Resolved != this) {
    591     TypedInit *Typed = cast<TypedInit>(Resolved);
    592     if (Init *New = Typed->resolveListElementReference(R, IRV, Elt))
    593       return New;
    594     return VarListElementInit::get(Typed, Elt);
    595   }
    596 
    597   return nullptr;
    598 }
    599 
    600 Init *OpInit::getBit(unsigned Bit) const {
    601   if (getType() == BitRecTy::get())
    602     return const_cast<OpInit*>(this);
    603   return VarBitInit::get(const_cast<OpInit*>(this), Bit);
    604 }
    605 
    606 UnOpInit *UnOpInit::get(UnaryOp opc, Init *lhs, RecTy *Type) {
    607   typedef std::pair<std::pair<unsigned, Init *>, RecTy *> Key;
    608   static DenseMap<Key, std::unique_ptr<UnOpInit>> ThePool;
    609 
    610   Key TheKey(std::make_pair(std::make_pair(opc, lhs), Type));
    611 
    612   std::unique_ptr<UnOpInit> &I = ThePool[TheKey];
    613   if (!I) I.reset(new UnOpInit(opc, lhs, Type));
    614   return I.get();
    615 }
    616 
    617 Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
    618   switch (getOpcode()) {
    619   case CAST: {
    620     if (isa<StringRecTy>(getType())) {
    621       if (StringInit *LHSs = dyn_cast<StringInit>(LHS))
    622         return LHSs;
    623 
    624       if (DefInit *LHSd = dyn_cast<DefInit>(LHS))
    625         return StringInit::get(LHSd->getAsString());
    626 
    627       if (IntInit *LHSi = dyn_cast<IntInit>(LHS))
    628         return StringInit::get(LHSi->getAsString());
    629     } else {
    630       if (StringInit *LHSs = dyn_cast<StringInit>(LHS)) {
    631         std::string Name = LHSs->getValue();
    632 
    633         // From TGParser::ParseIDValue
    634         if (CurRec) {
    635           if (const RecordVal *RV = CurRec->getValue(Name)) {
    636             if (RV->getType() != getType())
    637               PrintFatalError("type mismatch in cast");
    638             return VarInit::get(Name, RV->getType());
    639           }
    640 
    641           Init *TemplateArgName = QualifyName(*CurRec, CurMultiClass, Name,
    642                                               ":");
    643 
    644           if (CurRec->isTemplateArg(TemplateArgName)) {
    645             const RecordVal *RV = CurRec->getValue(TemplateArgName);
    646             assert(RV && "Template arg doesn't exist??");
    647 
    648             if (RV->getType() != getType())
    649               PrintFatalError("type mismatch in cast");
    650 
    651             return VarInit::get(TemplateArgName, RV->getType());
    652           }
    653         }
    654 
    655         if (CurMultiClass) {
    656           Init *MCName = QualifyName(CurMultiClass->Rec, CurMultiClass, Name,
    657                                      "::");
    658 
    659           if (CurMultiClass->Rec.isTemplateArg(MCName)) {
    660             const RecordVal *RV = CurMultiClass->Rec.getValue(MCName);
    661             assert(RV && "Template arg doesn't exist??");
    662 
    663             if (RV->getType() != getType())
    664               PrintFatalError("type mismatch in cast");
    665 
    666             return VarInit::get(MCName, RV->getType());
    667           }
    668         }
    669         assert(CurRec && "NULL pointer");
    670         if (Record *D = (CurRec->getRecords()).getDef(Name))
    671           return DefInit::get(D);
    672 
    673         PrintFatalError(CurRec->getLoc(),
    674                         "Undefined reference:'" + Name + "'\n");
    675       }
    676 
    677       if (isa<IntRecTy>(getType())) {
    678         if (BitsInit *BI = dyn_cast<BitsInit>(LHS)) {
    679           if (Init *NewInit = BI->convertInitializerTo(IntRecTy::get()))
    680             return NewInit;
    681           break;
    682         }
    683       }
    684     }
    685     break;
    686   }
    687   case HEAD: {
    688     if (ListInit *LHSl = dyn_cast<ListInit>(LHS)) {
    689       assert(!LHSl->empty() && "Empty list in head");
    690       return LHSl->getElement(0);
    691     }
    692     break;
    693   }
    694   case TAIL: {
    695     if (ListInit *LHSl = dyn_cast<ListInit>(LHS)) {
    696       assert(!LHSl->empty() && "Empty list in tail");
    697       // Note the +1.  We can't just pass the result of getValues()
    698       // directly.
    699       return ListInit::get(LHSl->getValues().slice(1), LHSl->getType());
    700     }
    701     break;
    702   }
    703   case EMPTY: {
    704     if (ListInit *LHSl = dyn_cast<ListInit>(LHS))
    705       return IntInit::get(LHSl->empty());
    706     if (StringInit *LHSs = dyn_cast<StringInit>(LHS))
    707       return IntInit::get(LHSs->getValue().empty());
    708 
    709     break;
    710   }
    711   }
    712   return const_cast<UnOpInit *>(this);
    713 }
    714 
    715 Init *UnOpInit::resolveReferences(Record &R, const RecordVal *RV) const {
    716   Init *lhs = LHS->resolveReferences(R, RV);
    717 
    718   if (LHS != lhs)
    719     return (UnOpInit::get(getOpcode(), lhs, getType()))->Fold(&R, nullptr);
    720   return Fold(&R, nullptr);
    721 }
    722 
    723 std::string UnOpInit::getAsString() const {
    724   std::string Result;
    725   switch (Opc) {
    726   case CAST: Result = "!cast<" + getType()->getAsString() + ">"; break;
    727   case HEAD: Result = "!head"; break;
    728   case TAIL: Result = "!tail"; break;
    729   case EMPTY: Result = "!empty"; break;
    730   }
    731   return Result + "(" + LHS->getAsString() + ")";
    732 }
    733 
    734 BinOpInit *BinOpInit::get(BinaryOp opc, Init *lhs,
    735                           Init *rhs, RecTy *Type) {
    736   typedef std::pair<
    737     std::pair<std::pair<unsigned, Init *>, Init *>,
    738     RecTy *
    739     > Key;
    740 
    741   static DenseMap<Key, std::unique_ptr<BinOpInit>> ThePool;
    742 
    743   Key TheKey(std::make_pair(std::make_pair(std::make_pair(opc, lhs), rhs),
    744                             Type));
    745 
    746   std::unique_ptr<BinOpInit> &I = ThePool[TheKey];
    747   if (!I) I.reset(new BinOpInit(opc, lhs, rhs, Type));
    748   return I.get();
    749 }
    750 
    751 Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
    752   switch (getOpcode()) {
    753   case CONCAT: {
    754     DagInit *LHSs = dyn_cast<DagInit>(LHS);
    755     DagInit *RHSs = dyn_cast<DagInit>(RHS);
    756     if (LHSs && RHSs) {
    757       DefInit *LOp = dyn_cast<DefInit>(LHSs->getOperator());
    758       DefInit *ROp = dyn_cast<DefInit>(RHSs->getOperator());
    759       if (!LOp || !ROp || LOp->getDef() != ROp->getDef())
    760         PrintFatalError("Concated Dag operators do not match!");
    761       std::vector<Init*> Args;
    762       std::vector<std::string> ArgNames;
    763       for (unsigned i = 0, e = LHSs->getNumArgs(); i != e; ++i) {
    764         Args.push_back(LHSs->getArg(i));
    765         ArgNames.push_back(LHSs->getArgName(i));
    766       }
    767       for (unsigned i = 0, e = RHSs->getNumArgs(); i != e; ++i) {
    768         Args.push_back(RHSs->getArg(i));
    769         ArgNames.push_back(RHSs->getArgName(i));
    770       }
    771       return DagInit::get(LHSs->getOperator(), "", Args, ArgNames);
    772     }
    773     break;
    774   }
    775   case LISTCONCAT: {
    776     ListInit *LHSs = dyn_cast<ListInit>(LHS);
    777     ListInit *RHSs = dyn_cast<ListInit>(RHS);
    778     if (LHSs && RHSs) {
    779       std::vector<Init *> Args;
    780       Args.insert(Args.end(), LHSs->begin(), LHSs->end());
    781       Args.insert(Args.end(), RHSs->begin(), RHSs->end());
    782       return ListInit::get(
    783           Args, cast<ListRecTy>(LHSs->getType())->getElementType());
    784     }
    785     break;
    786   }
    787   case STRCONCAT: {
    788     StringInit *LHSs = dyn_cast<StringInit>(LHS);
    789     StringInit *RHSs = dyn_cast<StringInit>(RHS);
    790     if (LHSs && RHSs)
    791       return StringInit::get(LHSs->getValue() + RHSs->getValue());
    792     break;
    793   }
    794   case EQ: {
    795     // try to fold eq comparison for 'bit' and 'int', otherwise fallback
    796     // to string objects.
    797     IntInit *L =
    798       dyn_cast_or_null<IntInit>(LHS->convertInitializerTo(IntRecTy::get()));
    799     IntInit *R =
    800       dyn_cast_or_null<IntInit>(RHS->convertInitializerTo(IntRecTy::get()));
    801 
    802     if (L && R)
    803       return IntInit::get(L->getValue() == R->getValue());
    804 
    805     StringInit *LHSs = dyn_cast<StringInit>(LHS);
    806     StringInit *RHSs = dyn_cast<StringInit>(RHS);
    807 
    808     // Make sure we've resolved
    809     if (LHSs && RHSs)
    810       return IntInit::get(LHSs->getValue() == RHSs->getValue());
    811 
    812     break;
    813   }
    814   case ADD:
    815   case AND:
    816   case SHL:
    817   case SRA:
    818   case SRL: {
    819     IntInit *LHSi =
    820       dyn_cast_or_null<IntInit>(LHS->convertInitializerTo(IntRecTy::get()));
    821     IntInit *RHSi =
    822       dyn_cast_or_null<IntInit>(RHS->convertInitializerTo(IntRecTy::get()));
    823     if (LHSi && RHSi) {
    824       int64_t LHSv = LHSi->getValue(), RHSv = RHSi->getValue();
    825       int64_t Result;
    826       switch (getOpcode()) {
    827       default: llvm_unreachable("Bad opcode!");
    828       case ADD: Result = LHSv +  RHSv; break;
    829       case AND: Result = LHSv &  RHSv; break;
    830       case SHL: Result = LHSv << RHSv; break;
    831       case SRA: Result = LHSv >> RHSv; break;
    832       case SRL: Result = (uint64_t)LHSv >> (uint64_t)RHSv; break;
    833       }
    834       return IntInit::get(Result);
    835     }
    836     break;
    837   }
    838   }
    839   return const_cast<BinOpInit *>(this);
    840 }
    841 
    842 Init *BinOpInit::resolveReferences(Record &R, const RecordVal *RV) const {
    843   Init *lhs = LHS->resolveReferences(R, RV);
    844   Init *rhs = RHS->resolveReferences(R, RV);
    845 
    846   if (LHS != lhs || RHS != rhs)
    847     return (BinOpInit::get(getOpcode(), lhs, rhs, getType()))->Fold(&R,nullptr);
    848   return Fold(&R, nullptr);
    849 }
    850 
    851 std::string BinOpInit::getAsString() const {
    852   std::string Result;
    853   switch (Opc) {
    854   case CONCAT: Result = "!con"; break;
    855   case ADD: Result = "!add"; break;
    856   case AND: Result = "!and"; break;
    857   case SHL: Result = "!shl"; break;
    858   case SRA: Result = "!sra"; break;
    859   case SRL: Result = "!srl"; break;
    860   case EQ: Result = "!eq"; break;
    861   case LISTCONCAT: Result = "!listconcat"; break;
    862   case STRCONCAT: Result = "!strconcat"; break;
    863   }
    864   return Result + "(" + LHS->getAsString() + ", " + RHS->getAsString() + ")";
    865 }
    866 
    867 TernOpInit *TernOpInit::get(TernaryOp opc, Init *lhs, Init *mhs, Init *rhs,
    868                             RecTy *Type) {
    869   typedef std::pair<
    870     std::pair<
    871       std::pair<std::pair<unsigned, RecTy *>, Init *>,
    872       Init *
    873       >,
    874     Init *
    875     > Key;
    876 
    877   static DenseMap<Key, std::unique_ptr<TernOpInit>> ThePool;
    878 
    879   Key TheKey(std::make_pair(std::make_pair(std::make_pair(std::make_pair(opc,
    880                                                                          Type),
    881                                                           lhs),
    882                                            mhs),
    883                             rhs));
    884 
    885   std::unique_ptr<TernOpInit> &I = ThePool[TheKey];
    886   if (!I) I.reset(new TernOpInit(opc, lhs, mhs, rhs, Type));
    887   return I.get();
    888 }
    889 
    890 static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type,
    891                            Record *CurRec, MultiClass *CurMultiClass);
    892 
    893 static Init *EvaluateOperation(OpInit *RHSo, Init *LHS, Init *Arg,
    894                                RecTy *Type, Record *CurRec,
    895                                MultiClass *CurMultiClass) {
    896   // If this is a dag, recurse
    897   if (auto *TArg = dyn_cast<TypedInit>(Arg))
    898     if (isa<DagRecTy>(TArg->getType()))
    899       return ForeachHelper(LHS, Arg, RHSo, Type, CurRec, CurMultiClass);
    900 
    901   std::vector<Init *> NewOperands;
    902   for (unsigned i = 0; i < RHSo->getNumOperands(); ++i) {
    903     if (auto *RHSoo = dyn_cast<OpInit>(RHSo->getOperand(i))) {
    904       if (Init *Result = EvaluateOperation(RHSoo, LHS, Arg,
    905                                            Type, CurRec, CurMultiClass))
    906         NewOperands.push_back(Result);
    907       else
    908         NewOperands.push_back(Arg);
    909     } else if (LHS->getAsString() == RHSo->getOperand(i)->getAsString()) {
    910       NewOperands.push_back(Arg);
    911     } else {
    912       NewOperands.push_back(RHSo->getOperand(i));
    913     }
    914   }
    915 
    916   // Now run the operator and use its result as the new leaf
    917   const OpInit *NewOp = RHSo->clone(NewOperands);
    918   Init *NewVal = NewOp->Fold(CurRec, CurMultiClass);
    919   return (NewVal != NewOp) ? NewVal : nullptr;
    920 }
    921 
    922 static Init *ForeachHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type,
    923                            Record *CurRec, MultiClass *CurMultiClass) {
    924 
    925   OpInit *RHSo = dyn_cast<OpInit>(RHS);
    926 
    927   if (!RHSo)
    928     PrintFatalError(CurRec->getLoc(), "!foreach requires an operator\n");
    929 
    930   TypedInit *LHSt = dyn_cast<TypedInit>(LHS);
    931 
    932   if (!LHSt)
    933     PrintFatalError(CurRec->getLoc(), "!foreach requires typed variable\n");
    934 
    935   DagInit *MHSd = dyn_cast<DagInit>(MHS);
    936   if (MHSd && isa<DagRecTy>(Type)) {
    937     Init *Val = MHSd->getOperator();
    938     if (Init *Result = EvaluateOperation(RHSo, LHS, Val,
    939                                          Type, CurRec, CurMultiClass))
    940       Val = Result;
    941 
    942     std::vector<std::pair<Init *, std::string> > args;
    943     for (unsigned int i = 0; i < MHSd->getNumArgs(); ++i) {
    944       Init *Arg = MHSd->getArg(i);
    945       std::string ArgName = MHSd->getArgName(i);
    946 
    947       // Process args
    948       if (Init *Result = EvaluateOperation(RHSo, LHS, Arg, Type,
    949                                            CurRec, CurMultiClass))
    950         Arg = Result;
    951 
    952       // TODO: Process arg names
    953       args.push_back(std::make_pair(Arg, ArgName));
    954     }
    955 
    956     return DagInit::get(Val, "", args);
    957   }
    958 
    959   ListInit *MHSl = dyn_cast<ListInit>(MHS);
    960   if (MHSl && isa<ListRecTy>(Type)) {
    961     std::vector<Init *> NewOperands;
    962     std::vector<Init *> NewList(MHSl->begin(), MHSl->end());
    963 
    964     for (Init *&Item : NewList) {
    965       NewOperands.clear();
    966       for(unsigned i = 0; i < RHSo->getNumOperands(); ++i) {
    967         // First, replace the foreach variable with the list item
    968         if (LHS->getAsString() == RHSo->getOperand(i)->getAsString())
    969           NewOperands.push_back(Item);
    970         else
    971           NewOperands.push_back(RHSo->getOperand(i));
    972       }
    973 
    974       // Now run the operator and use its result as the new list item
    975       const OpInit *NewOp = RHSo->clone(NewOperands);
    976       Init *NewItem = NewOp->Fold(CurRec, CurMultiClass);
    977       if (NewItem != NewOp)
    978         Item = NewItem;
    979     }
    980     return ListInit::get(NewList, MHSl->getType());
    981   }
    982   return nullptr;
    983 }
    984 
    985 Init *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
    986   switch (getOpcode()) {
    987   case SUBST: {
    988     DefInit *LHSd = dyn_cast<DefInit>(LHS);
    989     VarInit *LHSv = dyn_cast<VarInit>(LHS);
    990     StringInit *LHSs = dyn_cast<StringInit>(LHS);
    991 
    992     DefInit *MHSd = dyn_cast<DefInit>(MHS);
    993     VarInit *MHSv = dyn_cast<VarInit>(MHS);
    994     StringInit *MHSs = dyn_cast<StringInit>(MHS);
    995 
    996     DefInit *RHSd = dyn_cast<DefInit>(RHS);
    997     VarInit *RHSv = dyn_cast<VarInit>(RHS);
    998     StringInit *RHSs = dyn_cast<StringInit>(RHS);
    999 
   1000     if (LHSd && MHSd && RHSd) {
   1001       Record *Val = RHSd->getDef();
   1002       if (LHSd->getAsString() == RHSd->getAsString())
   1003         Val = MHSd->getDef();
   1004       return DefInit::get(Val);
   1005     }
   1006     if (LHSv && MHSv && RHSv) {
   1007       std::string Val = RHSv->getName();
   1008       if (LHSv->getAsString() == RHSv->getAsString())
   1009         Val = MHSv->getName();
   1010       return VarInit::get(Val, getType());
   1011     }
   1012     if (LHSs && MHSs && RHSs) {
   1013       std::string Val = RHSs->getValue();
   1014 
   1015       std::string::size_type found;
   1016       std::string::size_type idx = 0;
   1017       while (true) {
   1018         found = Val.find(LHSs->getValue(), idx);
   1019         if (found == std::string::npos)
   1020           break;
   1021         Val.replace(found, LHSs->getValue().size(), MHSs->getValue());
   1022         idx = found + MHSs->getValue().size();
   1023       }
   1024 
   1025       return StringInit::get(Val);
   1026     }
   1027     break;
   1028   }
   1029 
   1030   case FOREACH: {
   1031     if (Init *Result = ForeachHelper(LHS, MHS, RHS, getType(),
   1032                                      CurRec, CurMultiClass))
   1033       return Result;
   1034     break;
   1035   }
   1036 
   1037   case IF: {
   1038     IntInit *LHSi = dyn_cast<IntInit>(LHS);
   1039     if (Init *I = LHS->convertInitializerTo(IntRecTy::get()))
   1040       LHSi = dyn_cast<IntInit>(I);
   1041     if (LHSi) {
   1042       if (LHSi->getValue())
   1043         return MHS;
   1044       return RHS;
   1045     }
   1046     break;
   1047   }
   1048   }
   1049 
   1050   return const_cast<TernOpInit *>(this);
   1051 }
   1052 
   1053 Init *TernOpInit::resolveReferences(Record &R,
   1054                                     const RecordVal *RV) const {
   1055   Init *lhs = LHS->resolveReferences(R, RV);
   1056 
   1057   if (Opc == IF && lhs != LHS) {
   1058     IntInit *Value = dyn_cast<IntInit>(lhs);
   1059     if (Init *I = lhs->convertInitializerTo(IntRecTy::get()))
   1060       Value = dyn_cast<IntInit>(I);
   1061     if (Value) {
   1062       // Short-circuit
   1063       if (Value->getValue()) {
   1064         Init *mhs = MHS->resolveReferences(R, RV);
   1065         return (TernOpInit::get(getOpcode(), lhs, mhs,
   1066                                 RHS, getType()))->Fold(&R, nullptr);
   1067       }
   1068       Init *rhs = RHS->resolveReferences(R, RV);
   1069       return (TernOpInit::get(getOpcode(), lhs, MHS,
   1070                               rhs, getType()))->Fold(&R, nullptr);
   1071     }
   1072   }
   1073 
   1074   Init *mhs = MHS->resolveReferences(R, RV);
   1075   Init *rhs = RHS->resolveReferences(R, RV);
   1076 
   1077   if (LHS != lhs || MHS != mhs || RHS != rhs)
   1078     return (TernOpInit::get(getOpcode(), lhs, mhs, rhs,
   1079                             getType()))->Fold(&R, nullptr);
   1080   return Fold(&R, nullptr);
   1081 }
   1082 
   1083 std::string TernOpInit::getAsString() const {
   1084   std::string Result;
   1085   switch (Opc) {
   1086   case SUBST: Result = "!subst"; break;
   1087   case FOREACH: Result = "!foreach"; break;
   1088   case IF: Result = "!if"; break;
   1089   }
   1090   return Result + "(" + LHS->getAsString() + ", " + MHS->getAsString() + ", " +
   1091          RHS->getAsString() + ")";
   1092 }
   1093 
   1094 RecTy *TypedInit::getFieldType(const std::string &FieldName) const {
   1095   if (RecordRecTy *RecordType = dyn_cast<RecordRecTy>(getType()))
   1096     if (RecordVal *Field = RecordType->getRecord()->getValue(FieldName))
   1097       return Field->getType();
   1098   return nullptr;
   1099 }
   1100 
   1101 Init *
   1102 TypedInit::convertInitializerTo(RecTy *Ty) const {
   1103   if (isa<IntRecTy>(Ty)) {
   1104     if (getType()->typeIsConvertibleTo(Ty))
   1105       return const_cast<TypedInit *>(this);
   1106     return nullptr;
   1107   }
   1108 
   1109   if (isa<StringRecTy>(Ty)) {
   1110     if (isa<StringRecTy>(getType()))
   1111       return const_cast<TypedInit *>(this);
   1112     return nullptr;
   1113   }
   1114 
   1115   if (isa<BitRecTy>(Ty)) {
   1116     // Accept variable if it is already of bit type!
   1117     if (isa<BitRecTy>(getType()))
   1118       return const_cast<TypedInit *>(this);
   1119     if (auto *BitsTy = dyn_cast<BitsRecTy>(getType())) {
   1120       // Accept only bits<1> expression.
   1121       if (BitsTy->getNumBits() == 1)
   1122         return const_cast<TypedInit *>(this);
   1123       return nullptr;
   1124     }
   1125     // Ternary !if can be converted to bit, but only if both sides are
   1126     // convertible to a bit.
   1127     if (const auto *TOI = dyn_cast<TernOpInit>(this)) {
   1128       if (TOI->getOpcode() == TernOpInit::TernaryOp::IF &&
   1129           TOI->getMHS()->convertInitializerTo(BitRecTy::get()) &&
   1130           TOI->getRHS()->convertInitializerTo(BitRecTy::get()))
   1131         return const_cast<TypedInit *>(this);
   1132       return nullptr;
   1133     }
   1134     return nullptr;
   1135   }
   1136 
   1137   if (auto *BRT = dyn_cast<BitsRecTy>(Ty)) {
   1138     if (BRT->getNumBits() == 1 && isa<BitRecTy>(getType()))
   1139       return BitsInit::get(const_cast<TypedInit *>(this));
   1140 
   1141     if (getType()->typeIsConvertibleTo(BRT)) {
   1142       SmallVector<Init *, 16> NewBits(BRT->getNumBits());
   1143 
   1144       for (unsigned i = 0; i != BRT->getNumBits(); ++i)
   1145         NewBits[i] = VarBitInit::get(const_cast<TypedInit *>(this), i);
   1146       return BitsInit::get(NewBits);
   1147     }
   1148 
   1149     return nullptr;
   1150   }
   1151 
   1152   if (auto *DLRT = dyn_cast<ListRecTy>(Ty)) {
   1153     if (auto *SLRT = dyn_cast<ListRecTy>(getType()))
   1154       if (SLRT->getElementType()->typeIsConvertibleTo(DLRT->getElementType()))
   1155         return const_cast<TypedInit *>(this);
   1156     return nullptr;
   1157   }
   1158 
   1159   if (auto *DRT = dyn_cast<DagRecTy>(Ty)) {
   1160     if (getType()->typeIsConvertibleTo(DRT))
   1161       return const_cast<TypedInit *>(this);
   1162     return nullptr;
   1163   }
   1164 
   1165   if (auto *SRRT = dyn_cast<RecordRecTy>(Ty)) {
   1166     // Ensure that this is compatible with Rec.
   1167     if (RecordRecTy *DRRT = dyn_cast<RecordRecTy>(getType()))
   1168       if (DRRT->getRecord()->isSubClassOf(SRRT->getRecord()) ||
   1169           DRRT->getRecord() == SRRT->getRecord())
   1170         return const_cast<TypedInit *>(this);
   1171     return nullptr;
   1172   }
   1173 
   1174   return nullptr;
   1175 }
   1176 
   1177 Init *
   1178 TypedInit::convertInitializerBitRange(const std::vector<unsigned> &Bits) const {
   1179   BitsRecTy *T = dyn_cast<BitsRecTy>(getType());
   1180   if (!T) return nullptr;  // Cannot subscript a non-bits variable.
   1181   unsigned NumBits = T->getNumBits();
   1182 
   1183   SmallVector<Init *, 16> NewBits(Bits.size());
   1184   for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
   1185     if (Bits[i] >= NumBits)
   1186       return nullptr;
   1187 
   1188     NewBits[i] = VarBitInit::get(const_cast<TypedInit *>(this), Bits[i]);
   1189   }
   1190   return BitsInit::get(NewBits);
   1191 }
   1192 
   1193 Init *
   1194 TypedInit::convertInitListSlice(const std::vector<unsigned> &Elements) const {
   1195   ListRecTy *T = dyn_cast<ListRecTy>(getType());
   1196   if (!T) return nullptr;  // Cannot subscript a non-list variable.
   1197 
   1198   if (Elements.size() == 1)
   1199     return VarListElementInit::get(const_cast<TypedInit *>(this), Elements[0]);
   1200 
   1201   std::vector<Init*> ListInits;
   1202   ListInits.reserve(Elements.size());
   1203   for (unsigned i = 0, e = Elements.size(); i != e; ++i)
   1204     ListInits.push_back(VarListElementInit::get(const_cast<TypedInit *>(this),
   1205                                                 Elements[i]));
   1206   return ListInit::get(ListInits, T);
   1207 }
   1208 
   1209 
   1210 VarInit *VarInit::get(const std::string &VN, RecTy *T) {
   1211   Init *Value = StringInit::get(VN);
   1212   return VarInit::get(Value, T);
   1213 }
   1214 
   1215 VarInit *VarInit::get(Init *VN, RecTy *T) {
   1216   typedef std::pair<RecTy *, Init *> Key;
   1217   static DenseMap<Key, std::unique_ptr<VarInit>> ThePool;
   1218 
   1219   Key TheKey(std::make_pair(T, VN));
   1220 
   1221   std::unique_ptr<VarInit> &I = ThePool[TheKey];
   1222   if (!I) I.reset(new VarInit(VN, T));
   1223   return I.get();
   1224 }
   1225 
   1226 const std::string &VarInit::getName() const {
   1227   StringInit *NameString = cast<StringInit>(getNameInit());
   1228   return NameString->getValue();
   1229 }
   1230 
   1231 Init *VarInit::getBit(unsigned Bit) const {
   1232   if (getType() == BitRecTy::get())
   1233     return const_cast<VarInit*>(this);
   1234   return VarBitInit::get(const_cast<VarInit*>(this), Bit);
   1235 }
   1236 
   1237 Init *VarInit::resolveListElementReference(Record &R,
   1238                                            const RecordVal *IRV,
   1239                                            unsigned Elt) const {
   1240   if (R.isTemplateArg(getNameInit())) return nullptr;
   1241   if (IRV && IRV->getNameInit() != getNameInit()) return nullptr;
   1242 
   1243   RecordVal *RV = R.getValue(getNameInit());
   1244   assert(RV && "Reference to a non-existent variable?");
   1245   ListInit *LI = dyn_cast<ListInit>(RV->getValue());
   1246   if (!LI)
   1247     return VarListElementInit::get(cast<TypedInit>(RV->getValue()), Elt);
   1248 
   1249   if (Elt >= LI->size())
   1250     return nullptr;  // Out of range reference.
   1251   Init *E = LI->getElement(Elt);
   1252   // If the element is set to some value, or if we are resolving a reference
   1253   // to a specific variable and that variable is explicitly unset, then
   1254   // replace the VarListElementInit with it.
   1255   if (IRV || !isa<UnsetInit>(E))
   1256     return E;
   1257   return nullptr;
   1258 }
   1259 
   1260 
   1261 RecTy *VarInit::getFieldType(const std::string &FieldName) const {
   1262   if (RecordRecTy *RTy = dyn_cast<RecordRecTy>(getType()))
   1263     if (const RecordVal *RV = RTy->getRecord()->getValue(FieldName))
   1264       return RV->getType();
   1265   return nullptr;
   1266 }
   1267 
   1268 Init *VarInit::getFieldInit(Record &R, const RecordVal *RV,
   1269                             const std::string &FieldName) const {
   1270   if (isa<RecordRecTy>(getType()))
   1271     if (const RecordVal *Val = R.getValue(VarName)) {
   1272       if (RV != Val && (RV || isa<UnsetInit>(Val->getValue())))
   1273         return nullptr;
   1274       Init *TheInit = Val->getValue();
   1275       assert(TheInit != this && "Infinite loop detected!");
   1276       if (Init *I = TheInit->getFieldInit(R, RV, FieldName))
   1277         return I;
   1278       return nullptr;
   1279     }
   1280   return nullptr;
   1281 }
   1282 
   1283 /// resolveReferences - This method is used by classes that refer to other
   1284 /// variables which may not be defined at the time the expression is formed.
   1285 /// If a value is set for the variable later, this method will be called on
   1286 /// users of the value to allow the value to propagate out.
   1287 ///
   1288 Init *VarInit::resolveReferences(Record &R, const RecordVal *RV) const {
   1289   if (RecordVal *Val = R.getValue(VarName))
   1290     if (RV == Val || (!RV && !isa<UnsetInit>(Val->getValue())))
   1291       return Val->getValue();
   1292   return const_cast<VarInit *>(this);
   1293 }
   1294 
   1295 VarBitInit *VarBitInit::get(TypedInit *T, unsigned B) {
   1296   typedef std::pair<TypedInit *, unsigned> Key;
   1297   static DenseMap<Key, std::unique_ptr<VarBitInit>> ThePool;
   1298 
   1299   Key TheKey(std::make_pair(T, B));
   1300 
   1301   std::unique_ptr<VarBitInit> &I = ThePool[TheKey];
   1302   if (!I) I.reset(new VarBitInit(T, B));
   1303   return I.get();
   1304 }
   1305 
   1306 Init *VarBitInit::convertInitializerTo(RecTy *Ty) const {
   1307   if (isa<BitRecTy>(Ty))
   1308     return const_cast<VarBitInit *>(this);
   1309 
   1310   return nullptr;
   1311 }
   1312 
   1313 std::string VarBitInit::getAsString() const {
   1314   return TI->getAsString() + "{" + utostr(Bit) + "}";
   1315 }
   1316 
   1317 Init *VarBitInit::resolveReferences(Record &R, const RecordVal *RV) const {
   1318   Init *I = TI->resolveReferences(R, RV);
   1319   if (TI != I)
   1320     return I->getBit(getBitNum());
   1321 
   1322   return const_cast<VarBitInit*>(this);
   1323 }
   1324 
   1325 VarListElementInit *VarListElementInit::get(TypedInit *T,
   1326                                             unsigned E) {
   1327   typedef std::pair<TypedInit *, unsigned> Key;
   1328   static DenseMap<Key, std::unique_ptr<VarListElementInit>> ThePool;
   1329 
   1330   Key TheKey(std::make_pair(T, E));
   1331 
   1332   std::unique_ptr<VarListElementInit> &I = ThePool[TheKey];
   1333   if (!I) I.reset(new VarListElementInit(T, E));
   1334   return I.get();
   1335 }
   1336 
   1337 std::string VarListElementInit::getAsString() const {
   1338   return TI->getAsString() + "[" + utostr(Element) + "]";
   1339 }
   1340 
   1341 Init *
   1342 VarListElementInit::resolveReferences(Record &R, const RecordVal *RV) const {
   1343   if (Init *I = getVariable()->resolveListElementReference(R, RV,
   1344                                                            getElementNum()))
   1345     return I;
   1346   return const_cast<VarListElementInit *>(this);
   1347 }
   1348 
   1349 Init *VarListElementInit::getBit(unsigned Bit) const {
   1350   if (getType() == BitRecTy::get())
   1351     return const_cast<VarListElementInit*>(this);
   1352   return VarBitInit::get(const_cast<VarListElementInit*>(this), Bit);
   1353 }
   1354 
   1355 Init *VarListElementInit:: resolveListElementReference(Record &R,
   1356                                                        const RecordVal *RV,
   1357                                                        unsigned Elt) const {
   1358   if (Init *Result = TI->resolveListElementReference(R, RV, Element)) {
   1359     if (TypedInit *TInit = dyn_cast<TypedInit>(Result)) {
   1360       if (Init *Result2 = TInit->resolveListElementReference(R, RV, Elt))
   1361         return Result2;
   1362       return VarListElementInit::get(TInit, Elt);
   1363     }
   1364     return Result;
   1365   }
   1366 
   1367   return nullptr;
   1368 }
   1369 
   1370 DefInit *DefInit::get(Record *R) {
   1371   return R->getDefInit();
   1372 }
   1373 
   1374 Init *DefInit::convertInitializerTo(RecTy *Ty) const {
   1375   if (auto *RRT = dyn_cast<RecordRecTy>(Ty))
   1376     if (getDef()->isSubClassOf(RRT->getRecord()))
   1377       return const_cast<DefInit *>(this);
   1378   return nullptr;
   1379 }
   1380 
   1381 RecTy *DefInit::getFieldType(const std::string &FieldName) const {
   1382   if (const RecordVal *RV = Def->getValue(FieldName))
   1383     return RV->getType();
   1384   return nullptr;
   1385 }
   1386 
   1387 Init *DefInit::getFieldInit(Record &R, const RecordVal *RV,
   1388                             const std::string &FieldName) const {
   1389   return Def->getValue(FieldName)->getValue();
   1390 }
   1391 
   1392 
   1393 std::string DefInit::getAsString() const {
   1394   return Def->getName();
   1395 }
   1396 
   1397 FieldInit *FieldInit::get(Init *R, const std::string &FN) {
   1398   typedef std::pair<Init *, TableGenStringKey> Key;
   1399   static DenseMap<Key, std::unique_ptr<FieldInit>> ThePool;
   1400 
   1401   Key TheKey(std::make_pair(R, FN));
   1402 
   1403   std::unique_ptr<FieldInit> &I = ThePool[TheKey];
   1404   if (!I) I.reset(new FieldInit(R, FN));
   1405   return I.get();
   1406 }
   1407 
   1408 Init *FieldInit::getBit(unsigned Bit) const {
   1409   if (getType() == BitRecTy::get())
   1410     return const_cast<FieldInit*>(this);
   1411   return VarBitInit::get(const_cast<FieldInit*>(this), Bit);
   1412 }
   1413 
   1414 Init *FieldInit::resolveListElementReference(Record &R, const RecordVal *RV,
   1415                                              unsigned Elt) const {
   1416   if (Init *ListVal = Rec->getFieldInit(R, RV, FieldName))
   1417     if (ListInit *LI = dyn_cast<ListInit>(ListVal)) {
   1418       if (Elt >= LI->size()) return nullptr;
   1419       Init *E = LI->getElement(Elt);
   1420 
   1421       // If the element is set to some value, or if we are resolving a
   1422       // reference to a specific variable and that variable is explicitly
   1423       // unset, then replace the VarListElementInit with it.
   1424       if (RV || !isa<UnsetInit>(E))
   1425         return E;
   1426     }
   1427   return nullptr;
   1428 }
   1429 
   1430 Init *FieldInit::resolveReferences(Record &R, const RecordVal *RV) const {
   1431   Init *NewRec = RV ? Rec->resolveReferences(R, RV) : Rec;
   1432 
   1433   if (Init *BitsVal = NewRec->getFieldInit(R, RV, FieldName)) {
   1434     Init *BVR = BitsVal->resolveReferences(R, RV);
   1435     return BVR->isComplete() ? BVR : const_cast<FieldInit *>(this);
   1436   }
   1437 
   1438   if (NewRec != Rec)
   1439     return FieldInit::get(NewRec, FieldName);
   1440   return const_cast<FieldInit *>(this);
   1441 }
   1442 
   1443 static void ProfileDagInit(FoldingSetNodeID &ID, Init *V, const std::string &VN,
   1444                            ArrayRef<Init *> ArgRange,
   1445                            ArrayRef<std::string> NameRange) {
   1446   ID.AddPointer(V);
   1447   ID.AddString(VN);
   1448 
   1449   ArrayRef<Init *>::iterator Arg  = ArgRange.begin();
   1450   ArrayRef<std::string>::iterator  Name = NameRange.begin();
   1451   while (Arg != ArgRange.end()) {
   1452     assert(Name != NameRange.end() && "Arg name underflow!");
   1453     ID.AddPointer(*Arg++);
   1454     ID.AddString(*Name++);
   1455   }
   1456   assert(Name == NameRange.end() && "Arg name overflow!");
   1457 }
   1458 
   1459 DagInit *
   1460 DagInit::get(Init *V, const std::string &VN,
   1461              ArrayRef<Init *> ArgRange,
   1462              ArrayRef<std::string> NameRange) {
   1463   static FoldingSet<DagInit> ThePool;
   1464   static std::vector<std::unique_ptr<DagInit>> TheActualPool;
   1465 
   1466   FoldingSetNodeID ID;
   1467   ProfileDagInit(ID, V, VN, ArgRange, NameRange);
   1468 
   1469   void *IP = nullptr;
   1470   if (DagInit *I = ThePool.FindNodeOrInsertPos(ID, IP))
   1471     return I;
   1472 
   1473   DagInit *I = new DagInit(V, VN, ArgRange, NameRange);
   1474   ThePool.InsertNode(I, IP);
   1475   TheActualPool.push_back(std::unique_ptr<DagInit>(I));
   1476   return I;
   1477 }
   1478 
   1479 DagInit *
   1480 DagInit::get(Init *V, const std::string &VN,
   1481              const std::vector<std::pair<Init*, std::string> > &args) {
   1482   std::vector<Init *> Args;
   1483   std::vector<std::string> Names;
   1484 
   1485   for (const auto &Arg : args) {
   1486     Args.push_back(Arg.first);
   1487     Names.push_back(Arg.second);
   1488   }
   1489 
   1490   return DagInit::get(V, VN, Args, Names);
   1491 }
   1492 
   1493 void DagInit::Profile(FoldingSetNodeID &ID) const {
   1494   ProfileDagInit(ID, Val, ValName, Args, ArgNames);
   1495 }
   1496 
   1497 Init *DagInit::convertInitializerTo(RecTy *Ty) const {
   1498   if (isa<DagRecTy>(Ty))
   1499     return const_cast<DagInit *>(this);
   1500 
   1501   return nullptr;
   1502 }
   1503 
   1504 Init *DagInit::resolveReferences(Record &R, const RecordVal *RV) const {
   1505   std::vector<Init*> NewArgs;
   1506   for (unsigned i = 0, e = Args.size(); i != e; ++i)
   1507     NewArgs.push_back(Args[i]->resolveReferences(R, RV));
   1508 
   1509   Init *Op = Val->resolveReferences(R, RV);
   1510 
   1511   if (Args != NewArgs || Op != Val)
   1512     return DagInit::get(Op, ValName, NewArgs, ArgNames);
   1513 
   1514   return const_cast<DagInit *>(this);
   1515 }
   1516 
   1517 
   1518 std::string DagInit::getAsString() const {
   1519   std::string Result = "(" + Val->getAsString();
   1520   if (!ValName.empty())
   1521     Result += ":" + ValName;
   1522   if (!Args.empty()) {
   1523     Result += " " + Args[0]->getAsString();
   1524     if (!ArgNames[0].empty()) Result += ":$" + ArgNames[0];
   1525     for (unsigned i = 1, e = Args.size(); i != e; ++i) {
   1526       Result += ", " + Args[i]->getAsString();
   1527       if (!ArgNames[i].empty()) Result += ":$" + ArgNames[i];
   1528     }
   1529   }
   1530   return Result + ")";
   1531 }
   1532 
   1533 
   1534 //===----------------------------------------------------------------------===//
   1535 //    Other implementations
   1536 //===----------------------------------------------------------------------===//
   1537 
   1538 RecordVal::RecordVal(Init *N, RecTy *T, bool P)
   1539   : NameAndPrefix(N, P), Ty(T) {
   1540   Value = UnsetInit::get()->convertInitializerTo(Ty);
   1541   assert(Value && "Cannot create unset value for current type!");
   1542 }
   1543 
   1544 RecordVal::RecordVal(const std::string &N, RecTy *T, bool P)
   1545   : NameAndPrefix(StringInit::get(N), P), Ty(T) {
   1546   Value = UnsetInit::get()->convertInitializerTo(Ty);
   1547   assert(Value && "Cannot create unset value for current type!");
   1548 }
   1549 
   1550 const std::string &RecordVal::getName() const {
   1551   return cast<StringInit>(getNameInit())->getValue();
   1552 }
   1553 
   1554 void RecordVal::dump() const { errs() << *this; }
   1555 
   1556 void RecordVal::print(raw_ostream &OS, bool PrintSem) const {
   1557   if (getPrefix()) OS << "field ";
   1558   OS << *getType() << " " << getNameInitAsString();
   1559 
   1560   if (getValue())
   1561     OS << " = " << *getValue();
   1562 
   1563   if (PrintSem) OS << ";\n";
   1564 }
   1565 
   1566 unsigned Record::LastID = 0;
   1567 
   1568 void Record::init() {
   1569   checkName();
   1570 
   1571   // Every record potentially has a def at the top.  This value is
   1572   // replaced with the top-level def name at instantiation time.
   1573   RecordVal DN("NAME", StringRecTy::get(), 0);
   1574   addValue(DN);
   1575 }
   1576 
   1577 void Record::checkName() {
   1578   // Ensure the record name has string type.
   1579   const TypedInit *TypedName = cast<const TypedInit>(Name);
   1580   if (!isa<StringRecTy>(TypedName->getType()))
   1581     PrintFatalError(getLoc(), "Record name is not a string!");
   1582 }
   1583 
   1584 DefInit *Record::getDefInit() {
   1585   if (!TheInit)
   1586     TheInit.reset(new DefInit(this, new RecordRecTy(this)));
   1587   return TheInit.get();
   1588 }
   1589 
   1590 const std::string &Record::getName() const {
   1591   return cast<StringInit>(Name)->getValue();
   1592 }
   1593 
   1594 void Record::setName(Init *NewName) {
   1595   Name = NewName;
   1596   checkName();
   1597   // DO NOT resolve record values to the name at this point because
   1598   // there might be default values for arguments of this def.  Those
   1599   // arguments might not have been resolved yet so we don't want to
   1600   // prematurely assume values for those arguments were not passed to
   1601   // this def.
   1602   //
   1603   // Nonetheless, it may be that some of this Record's values
   1604   // reference the record name.  Indeed, the reason for having the
   1605   // record name be an Init is to provide this flexibility.  The extra
   1606   // resolve steps after completely instantiating defs takes care of
   1607   // this.  See TGParser::ParseDef and TGParser::ParseDefm.
   1608 }
   1609 
   1610 void Record::setName(const std::string &Name) {
   1611   setName(StringInit::get(Name));
   1612 }
   1613 
   1614 /// resolveReferencesTo - If anything in this record refers to RV, replace the
   1615 /// reference to RV with the RHS of RV.  If RV is null, we resolve all possible
   1616 /// references.
   1617 void Record::resolveReferencesTo(const RecordVal *RV) {
   1618   for (unsigned i = 0, e = Values.size(); i != e; ++i) {
   1619     if (RV == &Values[i]) // Skip resolve the same field as the given one
   1620       continue;
   1621     if (Init *V = Values[i].getValue())
   1622       if (Values[i].setValue(V->resolveReferences(*this, RV)))
   1623         PrintFatalError(getLoc(), "Invalid value is found when setting '" +
   1624                         Values[i].getNameInitAsString() +
   1625                         "' after resolving references" +
   1626                         (RV ? " against '" + RV->getNameInitAsString() +
   1627                               "' of (" + RV->getValue()->getAsUnquotedString() +
   1628                               ")"
   1629                             : "") + "\n");
   1630   }
   1631   Init *OldName = getNameInit();
   1632   Init *NewName = Name->resolveReferences(*this, RV);
   1633   if (NewName != OldName) {
   1634     // Re-register with RecordKeeper.
   1635     setName(NewName);
   1636   }
   1637 }
   1638 
   1639 void Record::dump() const { errs() << *this; }
   1640 
   1641 raw_ostream &llvm::operator<<(raw_ostream &OS, const Record &R) {
   1642   OS << R.getNameInitAsString();
   1643 
   1644   ArrayRef<Init *> TArgs = R.getTemplateArgs();
   1645   if (!TArgs.empty()) {
   1646     OS << "<";
   1647     bool NeedComma = false;
   1648     for (const Init *TA : TArgs) {
   1649       if (NeedComma) OS << ", ";
   1650       NeedComma = true;
   1651       const RecordVal *RV = R.getValue(TA);
   1652       assert(RV && "Template argument record not found??");
   1653       RV->print(OS, false);
   1654     }
   1655     OS << ">";
   1656   }
   1657 
   1658   OS << " {";
   1659   ArrayRef<Record *> SC = R.getSuperClasses();
   1660   if (!SC.empty()) {
   1661     OS << "\t//";
   1662     for (const Record *Super : SC)
   1663       OS << " " << Super->getNameInitAsString();
   1664   }
   1665   OS << "\n";
   1666 
   1667   for (const RecordVal &Val : R.getValues())
   1668     if (Val.getPrefix() && !R.isTemplateArg(Val.getName()))
   1669       OS << Val;
   1670   for (const RecordVal &Val : R.getValues())
   1671     if (!Val.getPrefix() && !R.isTemplateArg(Val.getName()))
   1672       OS << Val;
   1673 
   1674   return OS << "}\n";
   1675 }
   1676 
   1677 /// getValueInit - Return the initializer for a value with the specified name,
   1678 /// or abort if the field does not exist.
   1679 ///
   1680 Init *Record::getValueInit(StringRef FieldName) const {
   1681   const RecordVal *R = getValue(FieldName);
   1682   if (!R || !R->getValue())
   1683     PrintFatalError(getLoc(), "Record `" + getName() +
   1684       "' does not have a field named `" + FieldName + "'!\n");
   1685   return R->getValue();
   1686 }
   1687 
   1688 
   1689 /// getValueAsString - This method looks up the specified field and returns its
   1690 /// value as a string, aborts if the field does not exist or if
   1691 /// the value is not a string.
   1692 ///
   1693 std::string Record::getValueAsString(StringRef FieldName) const {
   1694   const RecordVal *R = getValue(FieldName);
   1695   if (!R || !R->getValue())
   1696     PrintFatalError(getLoc(), "Record `" + getName() +
   1697       "' does not have a field named `" + FieldName + "'!\n");
   1698 
   1699   if (StringInit *SI = dyn_cast<StringInit>(R->getValue()))
   1700     return SI->getValue();
   1701   PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
   1702     FieldName + "' does not have a string initializer!");
   1703 }
   1704 
   1705 /// getValueAsBitsInit - This method looks up the specified field and returns
   1706 /// its value as a BitsInit, aborts if the field does not exist or if
   1707 /// the value is not the right type.
   1708 ///
   1709 BitsInit *Record::getValueAsBitsInit(StringRef FieldName) const {
   1710   const RecordVal *R = getValue(FieldName);
   1711   if (!R || !R->getValue())
   1712     PrintFatalError(getLoc(), "Record `" + getName() +
   1713       "' does not have a field named `" + FieldName + "'!\n");
   1714 
   1715   if (BitsInit *BI = dyn_cast<BitsInit>(R->getValue()))
   1716     return BI;
   1717   PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
   1718     FieldName + "' does not have a BitsInit initializer!");
   1719 }
   1720 
   1721 /// getValueAsListInit - This method looks up the specified field and returns
   1722 /// its value as a ListInit, aborting if the field does not exist or if
   1723 /// the value is not the right type.
   1724 ///
   1725 ListInit *Record::getValueAsListInit(StringRef FieldName) const {
   1726   const RecordVal *R = getValue(FieldName);
   1727   if (!R || !R->getValue())
   1728     PrintFatalError(getLoc(), "Record `" + getName() +
   1729       "' does not have a field named `" + FieldName + "'!\n");
   1730 
   1731   if (ListInit *LI = dyn_cast<ListInit>(R->getValue()))
   1732     return LI;
   1733   PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
   1734     FieldName + "' does not have a list initializer!");
   1735 }
   1736 
   1737 /// getValueAsListOfDefs - This method looks up the specified field and returns
   1738 /// its value as a vector of records, aborting if the field does not exist
   1739 /// or if the value is not the right type.
   1740 ///
   1741 std::vector<Record*>
   1742 Record::getValueAsListOfDefs(StringRef FieldName) const {
   1743   ListInit *List = getValueAsListInit(FieldName);
   1744   std::vector<Record*> Defs;
   1745   for (Init *I : List->getValues()) {
   1746     if (DefInit *DI = dyn_cast<DefInit>(I))
   1747       Defs.push_back(DI->getDef());
   1748     else
   1749       PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
   1750         FieldName + "' list is not entirely DefInit!");
   1751   }
   1752   return Defs;
   1753 }
   1754 
   1755 /// getValueAsInt - This method looks up the specified field and returns its
   1756 /// value as an int64_t, aborting if the field does not exist or if the value
   1757 /// is not the right type.
   1758 ///
   1759 int64_t Record::getValueAsInt(StringRef FieldName) const {
   1760   const RecordVal *R = getValue(FieldName);
   1761   if (!R || !R->getValue())
   1762     PrintFatalError(getLoc(), "Record `" + getName() +
   1763       "' does not have a field named `" + FieldName + "'!\n");
   1764 
   1765   if (IntInit *II = dyn_cast<IntInit>(R->getValue()))
   1766     return II->getValue();
   1767   PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
   1768     FieldName + "' does not have an int initializer!");
   1769 }
   1770 
   1771 /// getValueAsListOfInts - This method looks up the specified field and returns
   1772 /// its value as a vector of integers, aborting if the field does not exist or
   1773 /// if the value is not the right type.
   1774 ///
   1775 std::vector<int64_t>
   1776 Record::getValueAsListOfInts(StringRef FieldName) const {
   1777   ListInit *List = getValueAsListInit(FieldName);
   1778   std::vector<int64_t> Ints;
   1779   for (Init *I : List->getValues()) {
   1780     if (IntInit *II = dyn_cast<IntInit>(I))
   1781       Ints.push_back(II->getValue());
   1782     else
   1783       PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
   1784         FieldName + "' does not have a list of ints initializer!");
   1785   }
   1786   return Ints;
   1787 }
   1788 
   1789 /// getValueAsListOfStrings - This method looks up the specified field and
   1790 /// returns its value as a vector of strings, aborting if the field does not
   1791 /// exist or if the value is not the right type.
   1792 ///
   1793 std::vector<std::string>
   1794 Record::getValueAsListOfStrings(StringRef FieldName) const {
   1795   ListInit *List = getValueAsListInit(FieldName);
   1796   std::vector<std::string> Strings;
   1797   for (Init *I : List->getValues()) {
   1798     if (StringInit *SI = dyn_cast<StringInit>(I))
   1799       Strings.push_back(SI->getValue());
   1800     else
   1801       PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
   1802         FieldName + "' does not have a list of strings initializer!");
   1803   }
   1804   return Strings;
   1805 }
   1806 
   1807 /// getValueAsDef - This method looks up the specified field and returns its
   1808 /// value as a Record, aborting if the field does not exist or if the value
   1809 /// is not the right type.
   1810 ///
   1811 Record *Record::getValueAsDef(StringRef FieldName) const {
   1812   const RecordVal *R = getValue(FieldName);
   1813   if (!R || !R->getValue())
   1814     PrintFatalError(getLoc(), "Record `" + getName() +
   1815       "' does not have a field named `" + FieldName + "'!\n");
   1816 
   1817   if (DefInit *DI = dyn_cast<DefInit>(R->getValue()))
   1818     return DI->getDef();
   1819   PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
   1820     FieldName + "' does not have a def initializer!");
   1821 }
   1822 
   1823 /// getValueAsBit - This method looks up the specified field and returns its
   1824 /// value as a bit, aborting if the field does not exist or if the value is
   1825 /// not the right type.
   1826 ///
   1827 bool Record::getValueAsBit(StringRef FieldName) const {
   1828   const RecordVal *R = getValue(FieldName);
   1829   if (!R || !R->getValue())
   1830     PrintFatalError(getLoc(), "Record `" + getName() +
   1831       "' does not have a field named `" + FieldName + "'!\n");
   1832 
   1833   if (BitInit *BI = dyn_cast<BitInit>(R->getValue()))
   1834     return BI->getValue();
   1835   PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
   1836     FieldName + "' does not have a bit initializer!");
   1837 }
   1838 
   1839 bool Record::getValueAsBitOrUnset(StringRef FieldName, bool &Unset) const {
   1840   const RecordVal *R = getValue(FieldName);
   1841   if (!R || !R->getValue())
   1842     PrintFatalError(getLoc(), "Record `" + getName() +
   1843       "' does not have a field named `" + FieldName.str() + "'!\n");
   1844 
   1845   if (isa<UnsetInit>(R->getValue())) {
   1846     Unset = true;
   1847     return false;
   1848   }
   1849   Unset = false;
   1850   if (BitInit *BI = dyn_cast<BitInit>(R->getValue()))
   1851     return BI->getValue();
   1852   PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
   1853     FieldName + "' does not have a bit initializer!");
   1854 }
   1855 
   1856 /// getValueAsDag - This method looks up the specified field and returns its
   1857 /// value as an Dag, aborting if the field does not exist or if the value is
   1858 /// not the right type.
   1859 ///
   1860 DagInit *Record::getValueAsDag(StringRef FieldName) const {
   1861   const RecordVal *R = getValue(FieldName);
   1862   if (!R || !R->getValue())
   1863     PrintFatalError(getLoc(), "Record `" + getName() +
   1864       "' does not have a field named `" + FieldName + "'!\n");
   1865 
   1866   if (DagInit *DI = dyn_cast<DagInit>(R->getValue()))
   1867     return DI;
   1868   PrintFatalError(getLoc(), "Record `" + getName() + "', field `" +
   1869     FieldName + "' does not have a dag initializer!");
   1870 }
   1871 
   1872 
   1873 void MultiClass::dump() const {
   1874   errs() << "Record:\n";
   1875   Rec.dump();
   1876 
   1877   errs() << "Defs:\n";
   1878   for (const auto &Proto : DefPrototypes)
   1879     Proto->dump();
   1880 }
   1881 
   1882 
   1883 void RecordKeeper::dump() const { errs() << *this; }
   1884 
   1885 raw_ostream &llvm::operator<<(raw_ostream &OS, const RecordKeeper &RK) {
   1886   OS << "------------- Classes -----------------\n";
   1887   for (const auto &C : RK.getClasses())
   1888     OS << "class " << *C.second;
   1889 
   1890   OS << "------------- Defs -----------------\n";
   1891   for (const auto &D : RK.getDefs())
   1892     OS << "def " << *D.second;
   1893   return OS;
   1894 }
   1895 
   1896 
   1897 /// getAllDerivedDefinitions - This method returns all concrete definitions
   1898 /// that derive from the specified class name.  If a class with the specified
   1899 /// name does not exist, an error is printed and true is returned.
   1900 std::vector<Record*>
   1901 RecordKeeper::getAllDerivedDefinitions(const std::string &ClassName) const {
   1902   Record *Class = getClass(ClassName);
   1903   if (!Class)
   1904     PrintFatalError("ERROR: Couldn't find the `" + ClassName + "' class!\n");
   1905 
   1906   std::vector<Record*> Defs;
   1907   for (const auto &D : getDefs())
   1908     if (D.second->isSubClassOf(Class))
   1909       Defs.push_back(D.second.get());
   1910 
   1911   return Defs;
   1912 }
   1913 
   1914 /// QualifyName - Return an Init with a qualifier prefix referring
   1915 /// to CurRec's name.
   1916 Init *llvm::QualifyName(Record &CurRec, MultiClass *CurMultiClass,
   1917                         Init *Name, const std::string &Scoper) {
   1918   RecTy *Type = cast<TypedInit>(Name)->getType();
   1919 
   1920   BinOpInit *NewName =
   1921     BinOpInit::get(BinOpInit::STRCONCAT,
   1922                    BinOpInit::get(BinOpInit::STRCONCAT,
   1923                                   CurRec.getNameInit(),
   1924                                   StringInit::get(Scoper),
   1925                                   Type)->Fold(&CurRec, CurMultiClass),
   1926                    Name,
   1927                    Type);
   1928 
   1929   if (CurMultiClass && Scoper != "::") {
   1930     NewName =
   1931       BinOpInit::get(BinOpInit::STRCONCAT,
   1932                      BinOpInit::get(BinOpInit::STRCONCAT,
   1933                                     CurMultiClass->Rec.getNameInit(),
   1934                                     StringInit::get("::"),
   1935                                     Type)->Fold(&CurRec, CurMultiClass),
   1936                      NewName->Fold(&CurRec, CurMultiClass),
   1937                      Type);
   1938   }
   1939 
   1940   return NewName->Fold(&CurRec, CurMultiClass);
   1941 }
   1942 
   1943 /// QualifyName - Return an Init with a qualifier prefix referring
   1944 /// to CurRec's name.
   1945 Init *llvm::QualifyName(Record &CurRec, MultiClass *CurMultiClass,
   1946                         const std::string &Name,
   1947                         const std::string &Scoper) {
   1948   return QualifyName(CurRec, CurMultiClass, StringInit::get(Name), Scoper);
   1949 }
   1950