[TableGen] Remove the use of global Record state

[rriddle]

Summary

This commits removes TableGens reliance on managed static global record state
by moving the RecordContext into the RecordKeeper. The RecordKeeper is now
treated similarly to a (LLVM|MLIR|etc)Context object and is passed to static
construction functions. This is an important step forward in removing TableGens
reliance on global state, and in a followup will allow for users that parse tablegen
to parse multiple tablegen files without worrying about Record lifetime.

[rriddle]

Some context here is that I'm building language tooling for TableGen (diagnostics, go-to definition, find references, etc.) and I can't really do that effectively if TableGen relies on global record state.

[craig.topper]

llvm/include/llvm/TableGen/Record.h

328

Most Inits inherit from TypedInit which has a RecTy. Is possible for the TypedInits to use the RecordKeeper from the the Type? Then only UnsetInit needs an explicit RecordKeeper?

But I guess that means Init::getRecordKeeper would need to examine the Opc to determine where to find the RecordKeeper.

1816

Why not make the whole Context a member of RecordKeeper? Why go through a pointer?

[lattner]

llvm/include/llvm/TableGen/Record.h

328

Agreed, it would be nice to use an approach like MLIR does with MLIRContext: since types have access to a MLIRContext, other things that are guaranteed to have types don't need to carry it around. Is this possible in tblgen?

Ah it seems that init doesn't carry a type. :(

[rriddle]

llvm/include/llvm/TableGen/Record.h

328

Given that all but one of the Inits are Typed, used the suggestion. I don't think it will be too bad in practice, and we can update if we ever add more inits.

1816

Using pImpl helps to keep the uniquers implementation details out of the public header, and also helps to reduce the number of friends of RecordKeeper. If we move the uniquer data directly into RecordKeeper, as opposed to an external struct, we would need to add ~20 friends. Given all of that, feels much cleaner to just use pImpl here.

[craig.topper]

llvm/utils/TableGen/WebAssemblyDisassemblerEmitter.cpp

45

I know you didn't write, this but can the reinterpret_cast be a cast<>. reinterpret_cast looks suspicious.

[craig.topper]

LGTM

[rriddle]

llvm/utils/TableGen/WebAssemblyDisassemblerEmitter.cpp

45

Thanks for pointing this out! Fixed.

[nhaehnle]

+1 for doing this, thank you!

llvm/include/llvm/TableGen/Record.h

 #include <map>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 namespace llvm {
 namespace detail {
-struct RecordContext;
+struct RecordKeeperImpl;
 } // namespace detail
 
 class ListRecTy;
 class Record;
 class RecordKeeper;
 class RecordVal;
 class Resolver;
 class StringInit;
enum RecTyKind {
     StringRecTyKind,
     ListRecTyKind,
     DagRecTyKind,
     RecordRecTyKind
   };
 
 private:
   RecTyKind Kind;
+  /// The RecordKeeper that uniqued this Type.
+  RecordKeeper &RK;
   /// ListRecTy of the list that has elements of this type.
   ListRecTy *ListTy = nullptr;
 
 public:
-  RecTy(RecTyKind K) : Kind(K) {}
+  RecTy(RecTyKind K, RecordKeeper &RK) : Kind(K), RK(RK) {}
   virtual ~RecTy() = default;
 
   RecTyKind getRecTyKind() const { return Kind; }
 
+  /// Return the RecordKeeper that uniqued this Type.
+  RecordKeeper &getRecordKeeper() const { return RK; }
+
   virtual std::string getAsString() const = 0;
   void print(raw_ostream &OS) const { OS << getAsString(); }
   void dump() const;
 
   /// Return true if all values of 'this' type can be converted to the specified
   /// type.
   virtual bool typeIsConvertibleTo(const RecTy *RHS) const;
 
   /// Return true if 'this' type is equal to or a subtype of RHS. For example,
   /// a bit set is not an int, but they are convertible.
   virtual bool typeIsA(const RecTy *RHS) const;
 
   /// Returns the type representing list<thistype>.
   ListRecTy *getListTy();
 };
 
 inline raw_ostream &operator<<(raw_ostream &OS, const RecTy &Ty) {
   Ty.print(OS);
   return OS;
 }
 
 /// 'bit' - Represent a single bit
 class BitRecTy : public RecTy {
-  friend detail::RecordContext;
+  friend detail::RecordKeeperImpl;
 
-  BitRecTy() : RecTy(BitRecTyKind) {}
+  BitRecTy(RecordKeeper &RK) : RecTy(BitRecTyKind, RK) {}
 
 public:
   static bool classof(const RecTy *RT) {
     return RT->getRecTyKind() == BitRecTyKind;
   }
 
-  static BitRecTy *get();
+  static BitRecTy *get(RecordKeeper &RK);
 
   std::string getAsString() const override { return "bit"; }
 
   bool typeIsConvertibleTo(const RecTy *RHS) const override;
 };
 
 /// 'bits<n>' - Represent a fixed number of bits
 class BitsRecTy : public RecTy {
   unsigned Size;
 
-  explicit BitsRecTy(unsigned Sz) : RecTy(BitsRecTyKind), Size(Sz) {}
+  explicit BitsRecTy(RecordKeeper &RK, unsigned Sz)
+      : RecTy(BitsRecTyKind, RK), Size(Sz) {}
 
 public:
   static bool classof(const RecTy *RT) {
     return RT->getRecTyKind() == BitsRecTyKind;
   }
 
-  static BitsRecTy *get(unsigned Sz);
+  static BitsRecTy *get(RecordKeeper &RK, unsigned Sz);
 
   unsigned getNumBits() const { return Size; }
 
   std::string getAsString() const override;
 
   bool typeIsConvertibleTo(const RecTy *RHS) const override;
 
   bool typeIsA(const RecTy *RHS) const override;
 };
 
 /// 'int' - Represent an integer value of no particular size
 class IntRecTy : public RecTy {
-  friend detail::RecordContext;
+  friend detail::RecordKeeperImpl;
 
-  IntRecTy() : RecTy(IntRecTyKind) {}
+  IntRecTy(RecordKeeper &RK) : RecTy(IntRecTyKind, RK) {}
 
 public:
   static bool classof(const RecTy *RT) {
     return RT->getRecTyKind() == IntRecTyKind;
   }
 
-  static IntRecTy *get();
+  static IntRecTy *get(RecordKeeper &RK);
 
   std::string getAsString() const override { return "int"; }
 
   bool typeIsConvertibleTo(const RecTy *RHS) const override;
 };
 
 /// 'string' - Represent an string value
 class StringRecTy : public RecTy {
-  friend detail::RecordContext;
+  friend detail::RecordKeeperImpl;
 
-  StringRecTy() : RecTy(StringRecTyKind) {}
+  StringRecTy(RecordKeeper &RK) : RecTy(StringRecTyKind, RK) {}
 
 public:
   static bool classof(const RecTy *RT) {
     return RT->getRecTyKind() == StringRecTyKind;
   }
 
-  static StringRecTy *get();
+  static StringRecTy *get(RecordKeeper &RK);
 
   std::string getAsString() const override;
 
   bool typeIsConvertibleTo(const RecTy *RHS) const override;
 };
 
 /// 'list<Ty>' - Represent a list of element values, all of which must be of
 /// the specified type. The type is stored in ElementTy.
 class ListRecTy : public RecTy {
   friend ListRecTy *RecTy::getListTy();
 
   RecTy *ElementTy;
 
-  explicit ListRecTy(RecTy *T) : RecTy(ListRecTyKind), ElementTy(T) {}
+  explicit ListRecTy(RecTy *T)
+      : RecTy(ListRecTyKind, T->getRecordKeeper()), ElementTy(T) {}
 
 public:
   static bool classof(const RecTy *RT) {
     return RT->getRecTyKind() == ListRecTyKind;
   }
 
   static ListRecTy *get(RecTy *T) { return T->getListTy(); }
   RecTy *getElementType() const { return ElementTy; }
 
   std::string getAsString() const override;
 
   bool typeIsConvertibleTo(const RecTy *RHS) const override;
 
   bool typeIsA(const RecTy *RHS) const override;
 };
 
 /// 'dag' - Represent a dag fragment
 class DagRecTy : public RecTy {
-  friend detail::RecordContext;
+  friend detail::RecordKeeperImpl;
 
-  DagRecTy() : RecTy(DagRecTyKind) {}
+  DagRecTy(RecordKeeper &RK) : RecTy(DagRecTyKind, RK) {}
 
 public:
   static bool classof(const RecTy *RT) {
     return RT->getRecTyKind() == DagRecTyKind;
   }
 
-  static DagRecTy *get();
+  static DagRecTy *get(RecordKeeper &RK);
 
   std::string getAsString() const override;
 };
 
 /// '[classname]' - Type of record values that have zero or more superclasses.
 ///
 /// The list of superclasses is non-redundant, i.e. only contains classes that
 /// are not the superclass of some other listed class.
 class RecordRecTy final : public RecTy, public FoldingSetNode,
                           public TrailingObjects<RecordRecTy, Record *> {
   friend class Record;
-  friend detail::RecordContext;
+  friend detail::RecordKeeperImpl;
 
   unsigned NumClasses;
 
-  explicit RecordRecTy(unsigned Num)
-      : RecTy(RecordRecTyKind), NumClasses(Num) {}
+  explicit RecordRecTy(RecordKeeper &RK, unsigned Num)
+      : RecTy(RecordRecTyKind, RK), NumClasses(Num) {}
 
 public:
   RecordRecTy(const RecordRecTy &) = delete;
   RecordRecTy &operator=(const RecordRecTy &) = delete;
 
   // Do not use sized deallocation due to trailing objects.
   void operator delete(void *p) { ::operator delete(p); }
 
   static bool classof(const RecTy *RT) {
     return RT->getRecTyKind() == RecordRecTyKind;
   }
 
   /// Get the record type with the given non-redundant list of superclasses.
-  static RecordRecTy *get(ArrayRef<Record *> Classes);
+  static RecordRecTy *get(RecordKeeper &RK, ArrayRef<Record *> Classes);
+  static RecordRecTy *get(Record *Class);
 
   void Profile(FoldingSetNodeID &ID) const;
 
   ArrayRef<Record *> getClasses() const {
     return makeArrayRef(getTrailingObjects<Record *>(), NumClasses);
   }
 
   using const_record_iterator = Record * const *;
enum InitKind : uint8_t {
     IK_LastTypedInit,
     IK_UnsetInit
   };
 
 private:
   const InitKind Kind;
 
 protected:
   uint8_t Opc; // Used by UnOpInit, BinOpInit, and TernOpInit
 
 private:
   virtual void anchor();
 
 public:
   /// Get the kind (type) of the value.
   InitKind getKind() const { return Kind; }
 
+  /// Get the record keeper that initialized this Init.
+  RecordKeeper &getRecordKeeper() const;
+
 protected:
   explicit Init(InitKind K, uint8_t Opc = 0) : Kind(K), Opc(Opc) {}
 
 public:
   Init(const Init &) = delete;
   Init &operator=(const Init &) = delete;
   virtual ~Init() = default;
 
public:
   static bool classof(const Init *I) {
     return I->getKind() >= IK_FirstTypedInit &&
            I->getKind() <= IK_LastTypedInit;
   }
 
   /// Get the type of the Init as a RecTy.
   RecTy *getType() const { return ValueTy; }
 
+  /// Get the record keeper that initialized this Init.
+  RecordKeeper &getRecordKeeper() const { return ValueTy->getRecordKeeper(); }
+
   Init *getCastTo(RecTy *Ty) const override;
   Init *convertInitializerTo(RecTy *Ty) const override;
 
   Init *convertInitializerBitRange(ArrayRef<unsigned> Bits) const override;
   Init *convertInitListSlice(ArrayRef<unsigned> Elements) const override;
 
   /// This method is used to implement the FieldInit class.
   /// Implementors of this method should return the type of the named field if
   /// they are of type record.
   RecTy *getFieldType(StringInit *FieldName) const override;
 };
 
 /// '?' - Represents an uninitialized value.
 class UnsetInit : public Init {
-  friend detail::RecordContext;
+  friend detail::RecordKeeperImpl;
 
-  UnsetInit() : Init(IK_UnsetInit) {}
+  /// The record keeper that initialized this Init.
+  RecordKeeper &RK;
+
+  UnsetInit(RecordKeeper &RK) : Init(IK_UnsetInit), RK(RK) {}
 
 public:
   UnsetInit(const UnsetInit &) = delete;
   UnsetInit &operator=(const UnsetInit &) = delete;
 
   static bool classof(const Init *I) {
     return I->getKind() == IK_UnsetInit;
   }
 
   /// Get the singleton unset Init.
-  static UnsetInit *get();
+  static UnsetInit *get(RecordKeeper &RK);
+
+  /// Get the record keeper that initialized this Init.
+  RecordKeeper &getRecordKeeper() const { return RK; }
 
   Init *getCastTo(RecTy *Ty) const override;
   Init *convertInitializerTo(RecTy *Ty) const override;
 
   Init *getBit(unsigned Bit) const override {
     return const_cast<UnsetInit*>(this);
   }
 
   /// Is this a complete value with no unset (uninitialized) subvalues?
   bool isComplete() const override { return false; }
 
   bool isConcrete() const override { return true; }
 
   /// Get the string representation of the Init.
   std::string getAsString() const override { return "?"; }
 };
 
 /// 'true'/'false' - Represent a concrete initializer for a bit.
 class BitInit final : public TypedInit {
-  friend detail::RecordContext;
+  friend detail::RecordKeeperImpl;
 
   bool Value;
 
   explicit BitInit(bool V, RecTy *T) : TypedInit(IK_BitInit, T), Value(V) {}
 
 public:
   BitInit(const BitInit &) = delete;
   BitInit &operator=(BitInit &) = delete;
 
   static bool classof(const Init *I) {
     return I->getKind() == IK_BitInit;
   }
 
-  static BitInit *get(bool V);
+  static BitInit *get(RecordKeeper &RK, bool V);
 
   bool getValue() const { return Value; }
 
   Init *convertInitializerTo(RecTy *Ty) const override;
 
   Init *getBit(unsigned Bit) const override {
     assert(Bit < 1 && "Bit index out of range!");
     return const_cast<BitInit*>(this);
   }
 
   bool isConcrete() const override { return true; }
   std::string getAsString() const override { return Value ? "1" : "0"; }
 };
 
 /// '{ a, b, c }' - Represents an initializer for a BitsRecTy value.
 /// It contains a vector of bits, whose size is determined by the type.
 class BitsInit final : public TypedInit, public FoldingSetNode,
                        public TrailingObjects<BitsInit, Init *> {
   unsigned NumBits;
 
-  BitsInit(unsigned N)
-    : TypedInit(IK_BitsInit, BitsRecTy::get(N)), NumBits(N) {}
+  BitsInit(RecordKeeper &RK, unsigned N)
+      : TypedInit(IK_BitsInit, BitsRecTy::get(RK, N)), NumBits(N) {}
 
 public:
   BitsInit(const BitsInit &) = delete;
   BitsInit &operator=(const BitsInit &) = delete;
 
   // Do not use sized deallocation due to trailing objects.
   void operator delete(void *p) { ::operator delete(p); }
 
   static bool classof(const Init *I) {
     return I->getKind() == IK_BitsInit;
   }
 
-  static BitsInit *get(ArrayRef<Init *> Range);
+  static BitsInit *get(RecordKeeper &RK, ArrayRef<Init *> Range);
 
   void Profile(FoldingSetNodeID &ID) const;
 
   unsigned getNumBits() const { return NumBits; }
 
   Init *convertInitializerTo(RecTy *Ty) const override;
   Init *convertInitializerBitRange(ArrayRef<unsigned> Bits) const override;
 
Init *getBit(unsigned Bit) const override {
     return getTrailingObjects<Init *>()[Bit];
   }
 };
 
 /// '7' - Represent an initialization by a literal integer value.
 class IntInit : public TypedInit {
   int64_t Value;
 
-  explicit IntInit(int64_t V)
-    : TypedInit(IK_IntInit, IntRecTy::get()), Value(V) {}
+  explicit IntInit(RecordKeeper &RK, int64_t V)
+      : TypedInit(IK_IntInit, IntRecTy::get(RK)), Value(V) {}
 
 public:
   IntInit(const IntInit &) = delete;
   IntInit &operator=(const IntInit &) = delete;
 
   static bool classof(const Init *I) {
     return I->getKind() == IK_IntInit;
   }
 
-  static IntInit *get(int64_t V);
+  static IntInit *get(RecordKeeper &RK, int64_t V);
 
   int64_t getValue() const { return Value; }
 
   Init *convertInitializerTo(RecTy *Ty) const override;
   Init *convertInitializerBitRange(ArrayRef<unsigned> Bits) const override;
 
   bool isConcrete() const override { return true; }
   std::string getAsString() const override;
 
   Init *getBit(unsigned Bit) const override {
-    return BitInit::get((Value & (1ULL << Bit)) != 0);
+    return BitInit::get(getRecordKeeper(), (Value & (1ULL << Bit)) != 0);
   }
 };
 
 /// "anonymous_n" - Represent an anonymous record name
 class AnonymousNameInit : public TypedInit {
   unsigned Value;
 
-  explicit AnonymousNameInit(unsigned V)
-      : TypedInit(IK_AnonymousNameInit, StringRecTy::get()), Value(V) {}
+  explicit AnonymousNameInit(RecordKeeper &RK, unsigned V)
+      : TypedInit(IK_AnonymousNameInit, StringRecTy::get(RK)), Value(V) {}
 
 public:
   AnonymousNameInit(const AnonymousNameInit &) = delete;
   AnonymousNameInit &operator=(const AnonymousNameInit &) = delete;
 
   static bool classof(const Init *I) {
     return I->getKind() == IK_AnonymousNameInit;
   }
 
-  static AnonymousNameInit *get(unsigned);
+  static AnonymousNameInit *get(RecordKeeper &RK, unsigned);
 
   unsigned getValue() const { return Value; }
 
   StringInit *getNameInit() const;
 
   std::string getAsString() const override;
 
   Init *resolveReferences(Resolver &R) const override;
enum StringFormat {
     SF_String, // Format as "text"
     SF_Code,   // Format as [{text}]
   };
 
 private:
   StringRef Value;
   StringFormat Format;
 
-  explicit StringInit(StringRef V, StringFormat Fmt)
-      : TypedInit(IK_StringInit, StringRecTy::get()), Value(V), Format(Fmt) {}
+  explicit StringInit(RecordKeeper &RK, StringRef V, StringFormat Fmt)
+      : TypedInit(IK_StringInit, StringRecTy::get(RK)), Value(V), Format(Fmt) {}
 
 public:
   StringInit(const StringInit &) = delete;
   StringInit &operator=(const StringInit &) = delete;
 
   static bool classof(const Init *I) {
     return I->getKind() == IK_StringInit;
   }
 
-  static StringInit *get(StringRef, StringFormat Fmt = SF_String);
+  static StringInit *get(RecordKeeper &RK, StringRef,
+                         StringFormat Fmt = SF_String);
 
   static StringFormat determineFormat(StringFormat Fmt1, StringFormat Fmt2) {
     return (Fmt1 == SF_Code || Fmt2 == SF_Code) ? SF_Code : SF_String;
   }
 
   StringRef getValue() const { return Value; }
   StringFormat getFormat() const { return Format; }
   bool hasCodeFormat() const { return Format == SF_Code; }
class ListInit final : public TypedInit, public FoldingSetNode,
                        public TrailingObjects<ListInit, Init *> {
   unsigned NumValues;
 
 public:
   using const_iterator = Init *const *;
 
 private:
   explicit ListInit(unsigned N, RecTy *EltTy)
       : TypedInit(IK_ListInit, ListRecTy::get(EltTy)), NumValues(N) {}
 
 public:
   ListInit(const ListInit &) = delete;
   ListInit &operator=(const ListInit &) = delete;
 
   // Do not use sized deallocation due to trailing objects.
   void operator delete(void *p) { ::operator delete(p); }
 

 
 /// !isa<type>(expr) - Dynamically determine the type of an expression.
 class IsAOpInit : public TypedInit, public FoldingSetNode {
 private:
   RecTy *CheckType;
   Init *Expr;
 
   IsAOpInit(RecTy *CheckType, Init *Expr)
-      : TypedInit(IK_IsAOpInit, IntRecTy::get()), CheckType(CheckType),
-        Expr(Expr) {}
+      : TypedInit(IK_IsAOpInit, IntRecTy::get(CheckType->getRecordKeeper())),
+        CheckType(CheckType), Expr(Expr) {}
 
 public:
   IsAOpInit(const IsAOpInit &) = delete;
   IsAOpInit &operator=(const IsAOpInit &) = delete;
 
   static bool classof(const Init *I) { return I->getKind() == IK_IsAOpInit; }
 
   static IsAOpInit *get(RecTy *CheckType, Init *Expr);

 };
 
 /// Opcode{0} - Represent access to one bit of a variable or field.
 class VarBitInit final : public TypedInit {
   TypedInit *TI;
   unsigned Bit;
 
   VarBitInit(TypedInit *T, unsigned B)
-      : TypedInit(IK_VarBitInit, BitRecTy::get()), TI(T), Bit(B) {
+      : TypedInit(IK_VarBitInit, BitRecTy::get(T->getRecordKeeper())), TI(T),
+        Bit(B) {
     assert(T->getType() &&
            (isa<IntRecTy>(T->getType()) ||
             (isa<BitsRecTy>(T->getType()) &&
              cast<BitsRecTy>(T->getType())->getNumBits() > B)) &&
            "Illegal VarBitInit expression!");
   }
 
 public:

 /// classname<targs...> - Represent an uninstantiated anonymous class
 /// instantiation.
 class VarDefInit final : public TypedInit, public FoldingSetNode,
                          public TrailingObjects<VarDefInit, Init *> {
   Record *Class;
   DefInit *Def = nullptr; // after instantiation
   unsigned NumArgs;
 
-  explicit VarDefInit(Record *Class, unsigned N)
-    : TypedInit(IK_VarDefInit, RecordRecTy::get(Class)), Class(Class), NumArgs(N) {}
+  explicit VarDefInit(Record *Class, unsigned N);
 
   DefInit *instantiate();
 
 public:
   VarDefInit(const VarDefInit &) = delete;
   VarDefInit &operator=(const VarDefInit &) = delete;
 
   // Do not use sized deallocation due to trailing objects.
class DagInit final : public TypedInit, public FoldingSetNode,
   friend TrailingObjects;
 
   Init *Val;
   StringInit *ValName;
   unsigned NumArgs;
   unsigned NumArgNames;
 
   DagInit(Init *V, StringInit *VN, unsigned NumArgs, unsigned NumArgNames)
-      : TypedInit(IK_DagInit, DagRecTy::get()), Val(V), ValName(VN),
-        NumArgs(NumArgs), NumArgNames(NumArgNames) {}
+      : TypedInit(IK_DagInit, DagRecTy::get(V->getRecordKeeper())), Val(V),
+        ValName(VN), NumArgs(NumArgs), NumArgNames(NumArgNames) {}
 
   size_t numTrailingObjects(OverloadToken<Init *>) const { return NumArgs; }
 
 public:
   DagInit(const DagInit &) = delete;
   DagInit &operator=(const DagInit &) = delete;
 
   static bool classof(const Init *I) {
private:
   PointerIntPair<RecTy *, 2, FieldKind> TyAndKind;
   Init *Value;
   bool IsUsed = false;
 
 public:
   RecordVal(Init *N, RecTy *T, FieldKind K);
   RecordVal(Init *N, SMLoc Loc, RecTy *T, FieldKind K);
 
+  /// Get the record keeper used to unique this value.
+  RecordKeeper &getRecordKeeper() const { return Name->getRecordKeeper(); }
+
   /// Get the name of the field as a StringRef.
   StringRef getName() const;
 
   /// Get the name of the field as an Init.
   Init *getNameInit() const { return Name; }
 
   /// Get the name of the field as a std::string.
   std::string getNameInitAsString() const {
private:
 
   void checkName();
 
 public:
   // Constructs a record.
   explicit Record(Init *N, ArrayRef<SMLoc> locs, RecordKeeper &records,
                   bool Anonymous = false, bool Class = false)
       : Name(N), Locs(locs.begin(), locs.end()), TrackedRecords(records),
-        ID(getNewUID()), IsAnonymous(Anonymous), IsClass(Class) {
+        ID(getNewUID(N->getRecordKeeper())), IsAnonymous(Anonymous),
+        IsClass(Class) {
     checkName();
   }
 
   explicit Record(StringRef N, ArrayRef<SMLoc> locs, RecordKeeper &records,
                   bool Class = false)
-      : Record(StringInit::get(N), locs, records, false, Class) {}
+      : Record(StringInit::get(records, N), locs, records, false, Class) {}
 
   // When copy-constructing a Record, we must still guarantee a globally unique
   // ID number. Don't copy CorrespondingDefInit either, since it's owned by the
   // original record. All other fields can be copied normally.
   Record(const Record &O)
       : Name(O.Name), Locs(O.Locs), TemplateArgs(O.TemplateArgs),
         Values(O.Values), Assertions(O.Assertions),
         SuperClasses(O.SuperClasses), TrackedRecords(O.TrackedRecords),
-        ID(getNewUID()), IsAnonymous(O.IsAnonymous), IsClass(O.IsClass) {}
+        ID(getNewUID(O.getRecords())), IsAnonymous(O.IsAnonymous),
+        IsClass(O.IsClass) {}
 
-  static unsigned getNewUID();
+  static unsigned getNewUID(RecordKeeper &RK);
 
   unsigned getID() const { return ID; }
 
   StringRef getName() const { return cast<StringInit>(Name)->getValue(); }
 
   Init *getNameInit() const {
     return Name;
   }
public:
 
   const RecordVal *getValue(const Init *Name) const {
     for (const RecordVal &Val : Values)
       if (Val.Name == Name) return &Val;
     return nullptr;
   }
 
   const RecordVal *getValue(StringRef Name) const {
-    return getValue(StringInit::get(Name));
+    return getValue(StringInit::get(getRecords(), Name));
   }
 
   RecordVal *getValue(const Init *Name) {
     return const_cast<RecordVal *>(static_cast<const Record *>(this)->getValue(Name));
   }
 
   RecordVal *getValue(StringRef Name) {
     return const_cast<RecordVal *>(static_cast<const Record *>(this)->getValue(Name));
for (unsigned i = 0, e = Values.size(); i != e; ++i)
       if (Values[i].getNameInit() == Name) {
         Values.erase(Values.begin()+i);
         return;
       }
     llvm_unreachable("Cannot remove an entry that does not exist!");
   }
 
   void removeValue(StringRef Name) {
-    removeValue(StringInit::get(Name));
+    removeValue(StringInit::get(getRecords(), Name));
   }
 
   void addAssertion(SMLoc Loc, Init *Condition, Init *Message) {
     Assertions.push_back(AssertionInfo(Loc, Condition, Message));
   }
 
   void appendAssertions(const Record *Rec) {
     Assertions.append(Rec->Assertions);
public:
   /// throwing an exception if the field does not exist or if the value is not
   /// the right type.
   DagInit *getValueAsDag(StringRef FieldName) const;
 };
 
 raw_ostream &operator<<(raw_ostream &OS, const Record &R);
 
 class RecordKeeper {
-  friend class RecordRecTy;
-
   using RecordMap = std::map<std::string, std::unique_ptr<Record>, std::less<>>;
   using GlobalMap = std::map<std::string, Init *, std::less<>>;
 
-  std::string InputFilename;
-  RecordMap Classes, Defs;
-  mutable StringMap<std::vector<Record *>> ClassRecordsMap;
-  FoldingSet<RecordRecTy> RecordTypePool;
-  std::map<std::string, Init *, std::less<>> ExtraGlobals;
-  unsigned AnonCounter = 0;
+public:
+  RecordKeeper();
+  ~RecordKeeper();
 
-  // These members are for the phase timing feature. We need a timer group,
-  // the last timer started, and a flag to say whether the last timer
-  // is the special "backend overall timer."
-  TimerGroup *TimingGroup = nullptr;
-  Timer *LastTimer = nullptr;
-  bool BackendTimer = false;
+  /// Return the internal implementation of the RecordKeeper.
+  detail::RecordKeeperImpl &getImpl() { return *Impl; }
 
-public:
   /// Get the main TableGen input file's name.
   const std::string getInputFilename() const { return InputFilename; }
 
   /// Get the map of classes.
   const RecordMap &getClasses() const { return Classes; }
 
   /// Get the map of records (defs).
   const RecordMap &getDefs() const { return Defs; }
std::vector<Record *> getAllDerivedDefinitions(
       ArrayRef<StringRef> ClassNames) const;
 
   /// Get all the concrete records that inherit from specified class, if the
   /// class is defined. Returns an empty vector if the class is not defined.
   std::vector<Record *>
   getAllDerivedDefinitionsIfDefined(StringRef ClassName) const;
 
   void dump() const;
+
+private:
+  RecordKeeper(RecordKeeper &&) = delete;
+  RecordKeeper(const RecordKeeper &) = delete;
+  RecordKeeper &operator=(RecordKeeper &&) = delete;
+  RecordKeeper &operator=(const RecordKeeper &) = delete;
+
+  std::string InputFilename;
+  RecordMap Classes, Defs;
+  mutable StringMap<std::vector<Record *>> ClassRecordsMap;
+  GlobalMap ExtraGlobals;
+
+  // These members are for the phase timing feature. We need a timer group,
+  // the last timer started, and a flag to say whether the last timer
+  // is the special "backend overall timer."
+  TimerGroup *TimingGroup = nullptr;
+  Timer *LastTimer = nullptr;
+  bool BackendTimer = false;
+
+  /// The internal uniquer implementation of the RecordKeeper.
+  std::unique_ptr<detail::RecordKeeperImpl> Impl;
 };
 
 /// Sorting predicate to sort record pointers by name.
 struct LessRecord {
   bool operator()(const Record *Rec1, const Record *Rec2) const {
     return StringRef(Rec1->getName()).compare_numeric(Rec2->getName()) < 0;
   }
 };

llvm/lib/TableGen/Error.cpp

void PrintFatalError(const RecordVal *RecVal, const Twine &Msg) {
   // The following call runs the file cleanup handlers.
   sys::RunInterruptHandlers();
   std::exit(1);
 }
 
 // Check an assertion: Obtain the condition value and be sure it is true.
 // If not, print a nonfatal error along with the message.
 void CheckAssert(SMLoc Loc, Init *Condition, Init *Message) {
-  auto *CondValue = dyn_cast_or_null<IntInit>(
-                        Condition->convertInitializerTo(IntRecTy::get()));
+  auto *CondValue = dyn_cast_or_null<IntInit>(Condition->convertInitializerTo(
+      IntRecTy::get(Condition->getRecordKeeper())));
   if (!CondValue)
     PrintError(Loc, "assert condition must of type bit, bits, or int.");
   else if (!CondValue->getValue()) {
     PrintError(Loc, "assertion failed");
     if (auto *MessageInit = dyn_cast<StringInit>(Message))
       PrintNote(MessageInit->getValue());
     else
       PrintNote("(assert message is not a string)");
   }
 }
 
 } // end namespace llvm

llvm/lib/TableGen/Parser.cpp

 //===- Parser.cpp - Top-Level TableGen Parser implementation --------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/TableGen/Parser.h"
-#include "RecordContext.h"
 #include "TGParser.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 
 using namespace llvm;
 
 bool llvm::TableGenParseFile(std::unique_ptr<MemoryBuffer> Buffer,
bool llvm::TableGenParseFile(std::unique_ptr<MemoryBuffer> Buffer,
   if (Parser.ParseFile())
     return true;
 
   // Invoke the provided handler function.
   if (ParserFn(Records))
     return true;
 
   // After parsing, reset the tablegen data.
-  detail::resetTablegenRecordContext();
   SrcMgr = SourceMgr();
   return false;
 }

llvm/lib/TableGen/Record.cpp

 //===- Record.cpp - Record implementation ---------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Implement the tablegen record classes.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/TableGen/Record.h"
-#include "RecordContext.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"

 #define DEBUG_TYPE "tblgen-records"
 
 //===----------------------------------------------------------------------===//
 //    Context
 //===----------------------------------------------------------------------===//
 
 namespace llvm {
 namespace detail {
-/// This class contains all of the contextual static state of the Record
-/// classes. This allows for better lifetime management and control of the used
-/// static data.
-struct RecordContext {
-  RecordContext()
-      : AnyRecord(0), TrueBitInit(true, &SharedBitRecTy),
+/// This class represents the internal implementation of the RecordKeeper.
+/// It contains all of the contextual static state of the Record classes. It is
+/// kept out-of-line to simplify dependencies, and also make it easier for
+/// internal classes to access the uniquer state of the keeper.
+struct RecordKeeperImpl {
+  RecordKeeperImpl(RecordKeeper &RK)
+      : SharedBitRecTy(RK), SharedIntRecTy(RK), SharedStringRecTy(RK),
+        SharedDagRecTy(RK), AnyRecord(RK, 0), TheUnsetInit(RK),
+        TrueBitInit(true, &SharedBitRecTy),
         FalseBitInit(false, &SharedBitRecTy), StringInitStringPool(Allocator),
-        StringInitCodePool(Allocator), LastRecordID(0) {}
+        StringInitCodePool(Allocator), AnonCounter(0), LastRecordID(0) {}
 
   BumpPtrAllocator Allocator;
   std::vector<BitsRecTy *> SharedBitsRecTys;
   BitRecTy SharedBitRecTy;
   IntRecTy SharedIntRecTy;
   StringRecTy SharedStringRecTy;
   DagRecTy SharedDagRecTy;
 
struct RecordKeeperImpl {
   DenseMap<std::pair<RecTy *, Init *>, VarInit *> TheVarInitPool;
   DenseMap<std::pair<TypedInit *, unsigned>, VarBitInit *> TheVarBitInitPool;
   DenseMap<std::pair<TypedInit *, unsigned>, VarListElementInit *>
       TheVarListElementInitPool;
   FoldingSet<VarDefInit> TheVarDefInitPool;
   DenseMap<std::pair<Init *, StringInit *>, FieldInit *> TheFieldInitPool;
   FoldingSet<CondOpInit> TheCondOpInitPool;
   FoldingSet<DagInit> TheDagInitPool;
+  FoldingSet<RecordRecTy> RecordTypePool;
 
+  unsigned AnonCounter;
   unsigned LastRecordID;
 };
 } // namespace detail
 } // namespace llvm
 
-ManagedStatic<detail::RecordContext> Context;
-
-void llvm::detail::resetTablegenRecordContext() { Context.destroy(); }
-
 //===----------------------------------------------------------------------===//
 //    Type implementations
 //===----------------------------------------------------------------------===//
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 LLVM_DUMP_METHOD void RecTy::dump() const { print(errs()); }
 #endif
 
 ListRecTy *RecTy::getListTy() {
   if (!ListTy)
-    ListTy = new(Context->Allocator) ListRecTy(this);
+    ListTy = new (RK.getImpl().Allocator) ListRecTy(this);
   return ListTy;
 }
 
 bool RecTy::typeIsConvertibleTo(const RecTy *RHS) const {
   assert(RHS && "NULL pointer");
   return Kind == RHS->getRecTyKind();
 }
 
 bool RecTy::typeIsA(const RecTy *RHS) const { return this == RHS; }
 
-BitRecTy *BitRecTy::get() { return &Context->SharedBitRecTy; }
+BitRecTy *BitRecTy::get(RecordKeeper &RK) {
+  return &RK.getImpl().SharedBitRecTy;
+}
 
 bool BitRecTy::typeIsConvertibleTo(const RecTy *RHS) const{
   if (RecTy::typeIsConvertibleTo(RHS) || RHS->getRecTyKind() == IntRecTyKind)
     return true;
   if (const BitsRecTy *BitsTy = dyn_cast<BitsRecTy>(RHS))
     return BitsTy->getNumBits() == 1;
   return false;
 }
 
-BitsRecTy *BitsRecTy::get(unsigned Sz) {
-  if (Sz >= Context->SharedBitsRecTys.size())
-    Context->SharedBitsRecTys.resize(Sz + 1);
-  BitsRecTy *&Ty = Context->SharedBitsRecTys[Sz];
+BitsRecTy *BitsRecTy::get(RecordKeeper &RK, unsigned Sz) {
+  detail::RecordKeeperImpl &RKImpl = RK.getImpl();
+  if (Sz >= RKImpl.SharedBitsRecTys.size())
+    RKImpl.SharedBitsRecTys.resize(Sz + 1);
+  BitsRecTy *&Ty = RKImpl.SharedBitsRecTys[Sz];
   if (!Ty)
-    Ty = new (Context->Allocator) BitsRecTy(Sz);
+    Ty = new (RKImpl.Allocator) BitsRecTy(RK, Sz);
   return Ty;
 }
 
 std::string BitsRecTy::getAsString() const {
   return "bits<" + utostr(Size) + ">";
 }
 
 bool BitsRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
   if (RecTy::typeIsConvertibleTo(RHS)) //argument and the sender are same type
     return cast<BitsRecTy>(RHS)->Size == Size;
   RecTyKind kind = RHS->getRecTyKind();
   return (kind == BitRecTyKind && Size == 1) || (kind == IntRecTyKind);
 }
 
 bool BitsRecTy::typeIsA(const RecTy *RHS) const {
   if (const BitsRecTy *RHSb = dyn_cast<BitsRecTy>(RHS))
     return RHSb->Size == Size;
   return false;
 }
 
-IntRecTy *IntRecTy::get() { return &Context->SharedIntRecTy; }
+IntRecTy *IntRecTy::get(RecordKeeper &RK) {
+  return &RK.getImpl().SharedIntRecTy;
+}
 
 bool IntRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
   RecTyKind kind = RHS->getRecTyKind();
   return kind==BitRecTyKind || kind==BitsRecTyKind || kind==IntRecTyKind;
 }
 
-StringRecTy *StringRecTy::get() { return &Context->SharedStringRecTy; }
+StringRecTy *StringRecTy::get(RecordKeeper &RK) {
+  return &RK.getImpl().SharedStringRecTy;
+}
 
 std::string StringRecTy::getAsString() const {
   return "string";
 }
 
 bool StringRecTy::typeIsConvertibleTo(const RecTy *RHS) const {
   RecTyKind Kind = RHS->getRecTyKind();
   return Kind == StringRecTyKind;

 }
 
 bool ListRecTy::typeIsA(const RecTy *RHS) const {
   if (const ListRecTy *RHSl = dyn_cast<ListRecTy>(RHS))
     return getElementType()->typeIsA(RHSl->getElementType());
   return false;
 }
 
-DagRecTy *DagRecTy::get() { return &Context->SharedDagRecTy; }
+DagRecTy *DagRecTy::get(RecordKeeper &RK) {
+  return &RK.getImpl().SharedDagRecTy;
+}
 
 std::string DagRecTy::getAsString() const {
   return "dag";
 }
 
 static void ProfileRecordRecTy(FoldingSetNodeID &ID,
                                ArrayRef<Record *> Classes) {
   ID.AddInteger(Classes.size());
   for (Record *R : Classes)
     ID.AddPointer(R);
 }
 
-RecordRecTy *RecordRecTy::get(ArrayRef<Record *> UnsortedClasses) {
+RecordRecTy *RecordRecTy::get(RecordKeeper &RK,
+                              ArrayRef<Record *> UnsortedClasses) {
+  detail::RecordKeeperImpl &RKImpl = RK.getImpl();
   if (UnsortedClasses.empty())
-    return &Context->AnyRecord;
+    return &RKImpl.AnyRecord;
 
-  FoldingSet<RecordRecTy> &ThePool =
-      UnsortedClasses[0]->getRecords().RecordTypePool;
+  FoldingSet<RecordRecTy> &ThePool = RKImpl.RecordTypePool;
 
   SmallVector<Record *, 4> Classes(UnsortedClasses.begin(),
                                    UnsortedClasses.end());
   llvm::sort(Classes, [](Record *LHS, Record *RHS) {
     return LHS->getNameInitAsString() < RHS->getNameInitAsString();
   });
 
   FoldingSetNodeID ID;
   ProfileRecordRecTy(ID, Classes);
 
   void *IP = nullptr;
   if (RecordRecTy *Ty = ThePool.FindNodeOrInsertPos(ID, IP))
     return Ty;
 
 #ifndef NDEBUG
   // Check for redundancy.
   for (unsigned i = 0; i < Classes.size(); ++i) {
     for (unsigned j = 0; j < Classes.size(); ++j) {
       assert(i == j || !Classes[i]->isSubClassOf(Classes[j]));
     }
     assert(&Classes[0]->getRecords() == &Classes[i]->getRecords());
   }
 #endif
 
-  void *Mem = Context->Allocator.Allocate(
+  void *Mem = RKImpl.Allocator.Allocate(
       totalSizeToAlloc<Record *>(Classes.size()), alignof(RecordRecTy));
-  RecordRecTy *Ty = new(Mem) RecordRecTy(Classes.size());
+  RecordRecTy *Ty = new (Mem) RecordRecTy(RK, Classes.size());
   std::uninitialized_copy(Classes.begin(), Classes.end(),
                           Ty->getTrailingObjects<Record *>());
   ThePool.InsertNode(Ty, IP);
   return Ty;
 }
+RecordRecTy *RecordRecTy::get(Record *Class) {
+  assert(Class && "unexpected null class");
+  return get(Class->getRecords(), Class);
+}
 
 void RecordRecTy::Profile(FoldingSetNodeID &ID) const {
   ProfileRecordRecTy(ID, getClasses());
 }
 
 std::string RecordRecTy::getAsString() const {
   if (NumClasses == 1)
     return getClasses()[0]->getNameInitAsString();
while (!Stack.empty()) {
 
     if (T2->isSubClassOf(R)) {
       CommonSuperClasses.push_back(R);
     } else {
       R->getDirectSuperClasses(Stack);
     }
   }
 
-  return RecordRecTy::get(CommonSuperClasses);
+  return RecordRecTy::get(T1->getRecordKeeper(), CommonSuperClasses);
 }
 
 RecTy *llvm::resolveTypes(RecTy *T1, RecTy *T2) {
   if (T1 == T2)
     return T1;
 
   if (RecordRecTy *RecTy1 = dyn_cast<RecordRecTy>(T1)) {
     if (RecordRecTy *RecTy2 = dyn_cast<RecordRecTy>(T2))

 //===----------------------------------------------------------------------===//
 
 void Init::anchor() {}
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 LLVM_DUMP_METHOD void Init::dump() const { return print(errs()); }
 #endif
 
-UnsetInit *UnsetInit::get() { return &Context->TheUnsetInit; }
+RecordKeeper &Init::getRecordKeeper() const {
+  if (auto *TyInit = dyn_cast<TypedInit>(this))
+    return TyInit->getType()->getRecordKeeper();
+  return cast<UnsetInit>(this)->getRecordKeeper();
+}
+
+UnsetInit *UnsetInit::get(RecordKeeper &RK) {
+  return &RK.getImpl().TheUnsetInit;
+}
 
 Init *UnsetInit::getCastTo(RecTy *Ty) const {
   return const_cast<UnsetInit *>(this);
 }
 
 Init *UnsetInit::convertInitializerTo(RecTy *Ty) const {
   return const_cast<UnsetInit *>(this);
 }
 
-BitInit *BitInit::get(bool V) {
-  return V ? &Context->TrueBitInit : &Context->FalseBitInit;
+BitInit *BitInit::get(RecordKeeper &RK, bool V) {
+  return V ? &RK.getImpl().TrueBitInit : &RK.getImpl().FalseBitInit;
 }
 
 Init *BitInit::convertInitializerTo(RecTy *Ty) const {
   if (isa<BitRecTy>(Ty))
     return const_cast<BitInit *>(this);
 
   if (isa<IntRecTy>(Ty))
-    return IntInit::get(getValue());
+    return IntInit::get(getRecordKeeper(), getValue());
 
   if (auto *BRT = dyn_cast<BitsRecTy>(Ty)) {
     // Can only convert single bit.
     if (BRT->getNumBits() == 1)
-      return BitsInit::get(const_cast<BitInit *>(this));
+      return BitsInit::get(getRecordKeeper(), const_cast<BitInit *>(this));
   }
 
   return nullptr;
 }
 
 static void
 ProfileBitsInit(FoldingSetNodeID &ID, ArrayRef<Init *> Range) {
   ID.AddInteger(Range.size());
 
   for (Init *I : Range)
     ID.AddPointer(I);
 }
 
-BitsInit *BitsInit::get(ArrayRef<Init *> Range) {
+BitsInit *BitsInit::get(RecordKeeper &RK, ArrayRef<Init *> Range) {
   FoldingSetNodeID ID;
   ProfileBitsInit(ID, Range);
 
+  detail::RecordKeeperImpl &RKImpl = RK.getImpl();
   void *IP = nullptr;
-  if (BitsInit *I = Context->TheBitsInitPool.FindNodeOrInsertPos(ID, IP))
+  if (BitsInit *I = RKImpl.TheBitsInitPool.FindNodeOrInsertPos(ID, IP))
     return I;
 
-  void *Mem = Context->Allocator.Allocate(
-      totalSizeToAlloc<Init *>(Range.size()), alignof(BitsInit));
-  BitsInit *I = new(Mem) BitsInit(Range.size());
+  void *Mem = RKImpl.Allocator.Allocate(totalSizeToAlloc<Init *>(Range.size()),
+                                        alignof(BitsInit));
+  BitsInit *I = new (Mem) BitsInit(RK, Range.size());
   std::uninitialized_copy(Range.begin(), Range.end(),
                           I->getTrailingObjects<Init *>());
-  Context->TheBitsInitPool.InsertNode(I, IP);
+  RKImpl.TheBitsInitPool.InsertNode(I, IP);
   return I;
 }
 
 void BitsInit::Profile(FoldingSetNodeID &ID) const {
   ProfileBitsInit(ID, makeArrayRef(getTrailingObjects<Init *>(), NumBits));
 }
 
 Init *BitsInit::convertInitializerTo(RecTy *Ty) const {
Init *BitsInit::convertInitializerTo(RecTy *Ty) const {
 
   if (isa<IntRecTy>(Ty)) {
     int64_t Result = 0;
     for (unsigned i = 0, e = getNumBits(); i != e; ++i)
       if (auto *Bit = dyn_cast<BitInit>(getBit(i)))
         Result |= static_cast<int64_t>(Bit->getValue()) << i;
       else
         return nullptr;
-    return IntInit::get(Result);
+    return IntInit::get(getRecordKeeper(), Result);
   }
 
   return nullptr;
 }
 
 Init *
 BitsInit::convertInitializerBitRange(ArrayRef<unsigned> Bits) const {
   SmallVector<Init *, 16> NewBits(Bits.size());
 
   for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
     if (Bits[i] >= getNumBits())
       return nullptr;
     NewBits[i] = getBit(Bits[i]);
   }
-  return BitsInit::get(NewBits);
+  return BitsInit::get(getRecordKeeper(), NewBits);
 }
 
 bool BitsInit::isConcrete() const {
   for (unsigned i = 0, e = getNumBits(); i != e; ++i) {
     if (!getBit(i)->isConcrete())
       return false;
   }
   return true;
for (unsigned i = 0, e = getNumBits(); i != e; ++i) {
 
     if (isa<UnsetInit>(NewBit) && R.keepUnsetBits())
       NewBit = CurBit;
     NewBits[i] = NewBit;
     Changed |= CurBit != NewBit;
   }
 
   if (Changed)
-    return BitsInit::get(NewBits);
+    return BitsInit::get(getRecordKeeper(), NewBits);
 
   return const_cast<BitsInit *>(this);
 }
 
-IntInit *IntInit::get(int64_t V) {
-  IntInit *&I = Context->TheIntInitPool[V];
+IntInit *IntInit::get(RecordKeeper &RK, int64_t V) {
+  IntInit *&I = RK.getImpl().TheIntInitPool[V];
   if (!I)
-    I = new (Context->Allocator) IntInit(V);
+    I = new (RK.getImpl().Allocator) IntInit(RK, V);
   return I;
 }
 
 std::string IntInit::getAsString() const {
   return itostr(Value);
 }
 
 static bool canFitInBitfield(int64_t Value, unsigned NumBits) {
   // For example, with NumBits == 4, we permit Values from [-7 .. 15].
   return (NumBits >= sizeof(Value) * 8) ||
          (Value >> NumBits == 0) || (Value >> (NumBits-1) == -1);
 }
 
 Init *IntInit::convertInitializerTo(RecTy *Ty) const {
   if (isa<IntRecTy>(Ty))
     return const_cast<IntInit *>(this);
 
   if (isa<BitRecTy>(Ty)) {
     int64_t Val = getValue();
     if (Val != 0 && Val != 1) return nullptr;  // Only accept 0 or 1 for a bit!
-    return BitInit::get(Val != 0);
+    return BitInit::get(getRecordKeeper(), Val != 0);
   }
 
   if (auto *BRT = dyn_cast<BitsRecTy>(Ty)) {
     int64_t Value = getValue();
     // Make sure this bitfield is large enough to hold the integer value.
     if (!canFitInBitfield(Value, BRT->getNumBits()))
       return nullptr;
 
     SmallVector<Init *, 16> NewBits(BRT->getNumBits());
     for (unsigned i = 0; i != BRT->getNumBits(); ++i)
-      NewBits[i] = BitInit::get(Value & ((i < 64) ? (1LL << i) : 0));
+      NewBits[i] =
+          BitInit::get(getRecordKeeper(), Value & ((i < 64) ? (1LL << i) : 0));
 
-    return BitsInit::get(NewBits);
+    return BitsInit::get(getRecordKeeper(), NewBits);
   }
 
   return nullptr;
 }
 
 Init *
 IntInit::convertInitializerBitRange(ArrayRef<unsigned> Bits) const {
   SmallVector<Init *, 16> NewBits(Bits.size());
 
   for (unsigned i = 0, e = Bits.size(); i != e; ++i) {
     if (Bits[i] >= 64)
       return nullptr;
 
-    NewBits[i] = BitInit::get(Value & (INT64_C(1) << Bits[i]));
+    NewBits[i] =
+        BitInit::get(getRecordKeeper(), Value & (INT64_C(1) << Bits[i]));
   }
-  return BitsInit::get(NewBits);
+  return BitsInit::get(getRecordKeeper(), NewBits);
 }
 
-AnonymousNameInit *AnonymousNameInit::get(unsigned V) {
-  return new (Context->Allocator) AnonymousNameInit(V);
+AnonymousNameInit *AnonymousNameInit::get(RecordKeeper &RK, unsigned V) {
+  return new (RK.getImpl().Allocator) AnonymousNameInit(RK, V);
 }
 
 StringInit *AnonymousNameInit::getNameInit() const {
-  return StringInit::get(getAsString());
+  return StringInit::get(getRecordKeeper(), getAsString());
 }
 
 std::string AnonymousNameInit::getAsString() const {
   return "anonymous_" + utostr(Value);
 }
 
 Init *AnonymousNameInit::resolveReferences(Resolver &R) const {
   auto *Old = const_cast<Init *>(static_cast<const Init *>(this));
   auto *New = R.resolve(Old);
   New = New ? New : Old;
   if (R.isFinal())
     if (auto *Anonymous = dyn_cast<AnonymousNameInit>(New))
       return Anonymous->getNameInit();
   return New;
 }
 
-StringInit *StringInit::get(StringRef V, StringFormat Fmt) {
-  auto &InitMap = Fmt == SF_String ? Context->StringInitStringPool
-                                   : Context->StringInitCodePool;
+StringInit *StringInit::get(RecordKeeper &RK, StringRef V, StringFormat Fmt) {
+  detail::RecordKeeperImpl &RKImpl = RK.getImpl();
+  auto &InitMap = Fmt == SF_String ? RKImpl.StringInitStringPool
+                                   : RKImpl.StringInitCodePool;
   auto &Entry = *InitMap.insert(std::make_pair(V, nullptr)).first;
   if (!Entry.second)
-    Entry.second = new (Context->Allocator) StringInit(Entry.getKey(), Fmt);
+    Entry.second = new (RKImpl.Allocator) StringInit(RK, Entry.getKey(), Fmt);
   return Entry.second;
 }
 
 Init *StringInit::convertInitializerTo(RecTy *Ty) const {
   if (isa<StringRecTy>(Ty))
     return const_cast<StringInit *>(this);
 
   return nullptr;
 }
 
 static void ProfileListInit(FoldingSetNodeID &ID,
                             ArrayRef<Init *> Range,
                             RecTy *EltTy) {
   ID.AddInteger(Range.size());
   ID.AddPointer(EltTy);
 
   for (Init *I : Range)
     ID.AddPointer(I);
 }
 
 ListInit *ListInit::get(ArrayRef<Init *> Range, RecTy *EltTy) {
   FoldingSetNodeID ID;
   ProfileListInit(ID, Range, EltTy);
 
+  detail::RecordKeeperImpl &RK = EltTy->getRecordKeeper().getImpl();
   void *IP = nullptr;
-  if (ListInit *I = Context->TheListInitPool.FindNodeOrInsertPos(ID, IP))
+  if (ListInit *I = RK.TheListInitPool.FindNodeOrInsertPos(ID, IP))
     return I;
 
   assert(Range.empty() || !isa<TypedInit>(Range[0]) ||
          cast<TypedInit>(Range[0])->getType()->typeIsConvertibleTo(EltTy));
 
-  void *Mem = Context->Allocator.Allocate(
-      totalSizeToAlloc<Init *>(Range.size()), alignof(ListInit));
+  void *Mem = RK.Allocator.Allocate(totalSizeToAlloc<Init *>(Range.size()),
+                                    alignof(ListInit));
   ListInit *I = new (Mem) ListInit(Range.size(), EltTy);
   std::uninitialized_copy(Range.begin(), Range.end(),
                           I->getTrailingObjects<Init *>());
-  Context->TheListInitPool.InsertNode(I, IP);
+  RK.TheListInitPool.InsertNode(I, IP);
   return I;
 }
 
 void ListInit::Profile(FoldingSetNodeID &ID) const {
   RecTy *EltTy = cast<ListRecTy>(getType())->getElementType();
 
   ProfileListInit(ID, getValues(), EltTy);
 }
for (Init *Element : *this) {
     Result += sep;
     sep = ", ";
     Result += Element->getAsString();
   }
   return Result + "]";
 }
 
 Init *OpInit::getBit(unsigned Bit) const {
-  if (getType() == BitRecTy::get())
+  if (getType() == BitRecTy::get(getRecordKeeper()))
     return const_cast<OpInit*>(this);
   return VarBitInit::get(const_cast<OpInit*>(this), Bit);
 }
 
 static void
 ProfileUnOpInit(FoldingSetNodeID &ID, unsigned Opcode, Init *Op, RecTy *Type) {
   ID.AddInteger(Opcode);
   ID.AddPointer(Op);
   ID.AddPointer(Type);
 }
 
 UnOpInit *UnOpInit::get(UnaryOp Opc, Init *LHS, RecTy *Type) {
   FoldingSetNodeID ID;
   ProfileUnOpInit(ID, Opc, LHS, Type);
 
+  detail::RecordKeeperImpl &RK = Type->getRecordKeeper().getImpl();
   void *IP = nullptr;
-  if (UnOpInit *I = Context->TheUnOpInitPool.FindNodeOrInsertPos(ID, IP))
+  if (UnOpInit *I = RK.TheUnOpInitPool.FindNodeOrInsertPos(ID, IP))
     return I;
 
-  UnOpInit *I = new (Context->Allocator) UnOpInit(Opc, LHS, Type);
-  Context->TheUnOpInitPool.InsertNode(I, IP);
+  UnOpInit *I = new (RK.Allocator) UnOpInit(Opc, LHS, Type);
+  RK.TheUnOpInitPool.InsertNode(I, IP);
   return I;
 }
 
 void UnOpInit::Profile(FoldingSetNodeID &ID) const {
   ProfileUnOpInit(ID, getOpcode(), getOperand(), getType());
 }
 
 Init *UnOpInit::Fold(Record *CurRec, bool IsFinal) const {
+  RecordKeeper &RK = getRecordKeeper();
   switch (getOpcode()) {
   case CAST:
     if (isa<StringRecTy>(getType())) {
       if (StringInit *LHSs = dyn_cast<StringInit>(LHS))
         return LHSs;
 
       if (DefInit *LHSd = dyn_cast<DefInit>(LHS))
-        return StringInit::get(LHSd->getAsString());
+        return StringInit::get(RK, LHSd->getAsString());
 
-      if (IntInit *LHSi =
-              dyn_cast_or_null<IntInit>(LHS->convertInitializerTo(IntRecTy::get())))
-        return StringInit::get(LHSi->getAsString());
+      if (IntInit *LHSi = dyn_cast_or_null<IntInit>(
+              LHS->convertInitializerTo(IntRecTy::get(RK))))
+        return StringInit::get(RK, LHSi->getAsString());
 
     } else if (isa<RecordRecTy>(getType())) {
       if (StringInit *Name = dyn_cast<StringInit>(LHS)) {
         if (!CurRec && !IsFinal)
           break;
         assert(CurRec && "NULL pointer");
         Record *D;
 
if (isa<StringRecTy>(getType())) {
       }
     }
 
     if (Init *NewInit = LHS->convertInitializerTo(getType()))
       return NewInit;
     break;
 
   case NOT:
-    if (IntInit *LHSi =
-            dyn_cast_or_null<IntInit>(LHS->convertInitializerTo(IntRecTy::get())))
-      return IntInit::get(LHSi->getValue() ? 0 : 1);
+    if (IntInit *LHSi = dyn_cast_or_null<IntInit>(
+            LHS->convertInitializerTo(IntRecTy::get(RK))))
+      return IntInit::get(RK, LHSi->getValue() ? 0 : 1);
     break;
 
   case HEAD:
     if (ListInit *LHSl = dyn_cast<ListInit>(LHS)) {
       assert(!LHSl->empty() && "Empty list in head");
       return LHSl->getElement(0);
     }
     break;
 
   case TAIL:
     if (ListInit *LHSl = dyn_cast<ListInit>(LHS)) {
       assert(!LHSl->empty() && "Empty list in tail");
       // Note the +1.  We can't just pass the result of getValues()
       // directly.
       return ListInit::get(LHSl->getValues().slice(1), LHSl->getElementType());
     }
     break;
 
   case SIZE:
     if (ListInit *LHSl = dyn_cast<ListInit>(LHS))
-      return IntInit::get(LHSl->size());
+      return IntInit::get(RK, LHSl->size());
     if (DagInit *LHSd = dyn_cast<DagInit>(LHS))
-      return IntInit::get(LHSd->arg_size());
+      return IntInit::get(RK, LHSd->arg_size());
     if (StringInit *LHSs = dyn_cast<StringInit>(LHS))
-      return IntInit::get(LHSs->getValue().size());
+      return IntInit::get(RK, LHSs->getValue().size());
     break;
 
   case EMPTY:
     if (ListInit *LHSl = dyn_cast<ListInit>(LHS))
-      return IntInit::get(LHSl->empty());
+      return IntInit::get(RK, LHSl->empty());
     if (DagInit *LHSd = dyn_cast<DagInit>(LHS))
-      return IntInit::get(LHSd->arg_empty());
+      return IntInit::get(RK, LHSd->arg_empty());
     if (StringInit *LHSs = dyn_cast<StringInit>(LHS))
-      return IntInit::get(LHSs->getValue().empty());
+      return IntInit::get(RK, LHSs->getValue().empty());
     break;
 
   case GETDAGOP:
     if (DagInit *Dag = dyn_cast<DagInit>(LHS)) {
       DefInit *DI = DefInit::get(Dag->getOperatorAsDef({}));
       if (!DI->getType()->typeIsA(getType())) {
         PrintFatalError(CurRec->getLoc(),
                         Twine("Expected type '") +
ProfileBinOpInit(FoldingSetNodeID &ID, unsigned Opcode, Init *LHS, Init *RHS,
   ID.AddPointer(RHS);
   ID.AddPointer(Type);
 }
 
 BinOpInit *BinOpInit::get(BinaryOp Opc, Init *LHS, Init *RHS, RecTy *Type) {
   FoldingSetNodeID ID;
   ProfileBinOpInit(ID, Opc, LHS, RHS, Type);
 
+  detail::RecordKeeperImpl &RK = LHS->getRecordKeeper().getImpl();
   void *IP = nullptr;
-  if (BinOpInit *I = Context->TheBinOpInitPool.FindNodeOrInsertPos(ID, IP))
+  if (BinOpInit *I = RK.TheBinOpInitPool.FindNodeOrInsertPos(ID, IP))
     return I;
 
-  BinOpInit *I = new (Context->Allocator) BinOpInit(Opc, LHS, RHS, Type);
-  Context->TheBinOpInitPool.InsertNode(I, IP);
+  BinOpInit *I = new (RK.Allocator) BinOpInit(Opc, LHS, RHS, Type);
+  RK.TheBinOpInitPool.InsertNode(I, IP);
   return I;
 }
 
 void BinOpInit::Profile(FoldingSetNodeID &ID) const {
   ProfileBinOpInit(ID, getOpcode(), getLHS(), getRHS(), getType());
 }
 
 static StringInit *ConcatStringInits(const StringInit *I0,
                                      const StringInit *I1) {
   SmallString<80> Concat(I0->getValue());
   Concat.append(I1->getValue());
-  return StringInit::get(Concat,
-                         StringInit::determineFormat(I0->getFormat(),
-                                                     I1->getFormat()));
+  return StringInit::get(
+      I0->getRecordKeeper(), Concat,
+      StringInit::determineFormat(I0->getFormat(), I1->getFormat()));
 }
 
 static StringInit *interleaveStringList(const ListInit *List,
                                         const StringInit *Delim) {
   if (List->size() == 0)
-    return StringInit::get("");
+    return StringInit::get(List->getRecordKeeper(), "");
   StringInit *Element = dyn_cast<StringInit>(List->getElement(0));
   if (!Element)
     return nullptr;
   SmallString<80> Result(Element->getValue());
   StringInit::StringFormat Fmt = StringInit::SF_String;
 
   for (unsigned I = 1, E = List->size(); I < E; ++I) {
     Result.append(Delim->getValue());
     StringInit *Element = dyn_cast<StringInit>(List->getElement(I));
     if (!Element)
       return nullptr;
     Result.append(Element->getValue());
     Fmt = StringInit::determineFormat(Fmt, Element->getFormat());
   }
-  return StringInit::get(Result, Fmt);
+  return StringInit::get(List->getRecordKeeper(), Result, Fmt);
 }
 
 static StringInit *interleaveIntList(const ListInit *List,
                                      const StringInit *Delim) {
+  RecordKeeper &RK = List->getRecordKeeper();
   if (List->size() == 0)
-    return StringInit::get("");
-  IntInit *Element =
-      dyn_cast_or_null<IntInit>(List->getElement(0)
-                                    ->convertInitializerTo(IntRecTy::get()));
+    return StringInit::get(RK, "");
+  IntInit *Element = dyn_cast_or_null<IntInit>(
+      List->getElement(0)->convertInitializerTo(IntRecTy::get(RK)));
   if (!Element)
     return nullptr;
   SmallString<80> Result(Element->getAsString());
 
   for (unsigned I = 1, E = List->size(); I < E; ++I) {
     Result.append(Delim->getValue());
-    IntInit *Element =
-        dyn_cast_or_null<IntInit>(List->getElement(I)
-                                      ->convertInitializerTo(IntRecTy::get()));
+    IntInit *Element = dyn_cast_or_null<IntInit>(
+        List->getElement(I)->convertInitializerTo(IntRecTy::get(RK)));
     if (!Element)
       return nullptr;
     Result.append(Element->getAsString());
   }
-  return StringInit::get(Result);
+  return StringInit::get(RK, Result);
 }
 
 Init *BinOpInit::getStrConcat(Init *I0, Init *I1) {
   // Shortcut for the common case of concatenating two strings.
   if (const StringInit *I0s = dyn_cast<StringInit>(I0))
     if (const StringInit *I1s = dyn_cast<StringInit>(I1))
       return ConcatStringInits(I0s, I1s);
-  return BinOpInit::get(BinOpInit::STRCONCAT, I0, I1, StringRecTy::get());
+  return BinOpInit::get(BinOpInit::STRCONCAT, I0, I1,
+                        StringRecTy::get(I0->getRecordKeeper()));
 }
 
 static ListInit *ConcatListInits(const ListInit *LHS,
                                  const ListInit *RHS) {
   SmallVector<Init *, 8> Args;
   llvm::append_range(Args, *LHS);
   llvm::append_range(Args, *RHS);
   return ListInit::get(Args, LHS->getElementType());
if (LHSs && RHSs) {
         break;
       if (LOp && ROp && LOp->getDef() != ROp->getDef()) {
         PrintFatalError(Twine("Concatenated Dag operators do not match: '") +
                         LHSs->getAsString() + "' vs. '" + RHSs->getAsString() +
                         "'");
       }
       Init *Op = LOp ? LOp : ROp;
       if (!Op)
-        Op = UnsetInit::get();
+        Op = UnsetInit::get(getRecordKeeper());
 
       SmallVector<Init*, 8> Args;
       SmallVector<StringInit*, 8> ArgNames;
       for (unsigned i = 0, e = LHSs->getNumArgs(); i != e; ++i) {
         Args.push_back(LHSs->getArg(i));
         ArgNames.push_back(LHSs->getArgName(i));
       }
       for (unsigned i = 0, e = RHSs->getNumArgs(); i != e; ++i) {
Init *BinOpInit::Fold(Record *CurRec) const {
   }
   case EQ:
   case NE:
   case LE:
   case LT:
   case GE:
   case GT: {
     // First see if we have two bit, bits, or int.
-    IntInit *LHSi =
-        dyn_cast_or_null<IntInit>(LHS->convertInitializerTo(IntRecTy::get()));
-    IntInit *RHSi =
-        dyn_cast_or_null<IntInit>(RHS->convertInitializerTo(IntRecTy::get()));
+    IntInit *LHSi = dyn_cast_or_null<IntInit>(
+        LHS->convertInitializerTo(IntRecTy::get(getRecordKeeper())));
+    IntInit *RHSi = dyn_cast_or_null<IntInit>(
+        RHS->convertInitializerTo(IntRecTy::get(getRecordKeeper())));
 
     if (LHSi && RHSi) {
       bool Result;
       switch (getOpcode()) {
       case EQ: Result = LHSi->getValue() == RHSi->getValue(); break;
       case NE: Result = LHSi->getValue() != RHSi->getValue(); break;
       case LE: Result = LHSi->getValue() <= RHSi->getValue(); break;
       case LT: Result = LHSi->getValue() <  RHSi->getValue(); break;
       case GE: Result = LHSi->getValue() >= RHSi->getValue(); break;
       case GT: Result = LHSi->getValue() >  RHSi->getValue(); break;
       default: llvm_unreachable("unhandled comparison");
       }
-      return BitInit::get(Result);
+      return BitInit::get(getRecordKeeper(), Result);
     }
 
     // Next try strings.
     StringInit *LHSs = dyn_cast<StringInit>(LHS);
     StringInit *RHSs = dyn_cast<StringInit>(RHS);
 
     if (LHSs && RHSs) {
       bool Result;
       switch (getOpcode()) {
       case EQ: Result = LHSs->getValue() == RHSs->getValue(); break;
       case NE: Result = LHSs->getValue() != RHSs->getValue(); break;
       case LE: Result = LHSs->getValue() <= RHSs->getValue(); break;
       case LT: Result = LHSs->getValue() <  RHSs->getValue(); break;
       case GE: Result = LHSs->getValue() >= RHSs->getValue(); break;
       case GT: Result = LHSs->getValue() >  RHSs->getValue(); break;
       default: llvm_unreachable("unhandled comparison");
       }
-      return BitInit::get(Result);
+      return BitInit::get(getRecordKeeper(), Result);
     }
 
     // Finally, !eq and !ne can be used with records.
     if (getOpcode() == EQ || getOpcode() == NE) {
       DefInit *LHSd = dyn_cast<DefInit>(LHS);
       DefInit *RHSd = dyn_cast<DefInit>(RHS);
       if (LHSd && RHSd)
-        return BitInit::get((getOpcode() == EQ) ? LHSd == RHSd
-                                                : LHSd != RHSd);
+        return BitInit::get(getRecordKeeper(),
+                            (getOpcode() == EQ) ? LHSd == RHSd : LHSd != RHSd);
     }
 
     break;
   }
   case SETDAGOP: {
     DagInit *Dag = dyn_cast<DagInit>(LHS);
     DefInit *Op = dyn_cast<DefInit>(RHS);
     if (Dag && Op) {
Init *BinOpInit::Fold(Record *CurRec) const {
   case SUB:
   case MUL:
   case AND:
   case OR:
   case XOR:
   case SHL:
   case SRA:
   case SRL: {
-    IntInit *LHSi =
-      dyn_cast_or_null<IntInit>(LHS->convertInitializerTo(IntRecTy::get()));
-    IntInit *RHSi =
-      dyn_cast_or_null<IntInit>(RHS->convertInitializerTo(IntRecTy::get()));
+    IntInit *LHSi = dyn_cast_or_null<IntInit>(
+        LHS->convertInitializerTo(IntRecTy::get(getRecordKeeper())));
+    IntInit *RHSi = dyn_cast_or_null<IntInit>(
+        RHS->convertInitializerTo(IntRecTy::get(getRecordKeeper())));
     if (LHSi && RHSi) {
       int64_t LHSv = LHSi->getValue(), RHSv = RHSi->getValue();
       int64_t Result;
       switch (getOpcode()) {
       default: llvm_unreachable("Bad opcode!");
       case ADD: Result = LHSv + RHSv; break;
       case SUB: Result = LHSv - RHSv; break;
       case MUL: Result = LHSv * RHSv; break;
       case AND: Result = LHSv & RHSv; break;
       case OR:  Result = LHSv | RHSv; break;
       case XOR: Result = LHSv ^ RHSv; break;
       case SHL: Result = (uint64_t)LHSv << (uint64_t)RHSv; break;
       case SRA: Result = LHSv >> RHSv; break;
       case SRL: Result = (uint64_t)LHSv >> (uint64_t)RHSv; break;
       }
-      return IntInit::get(Result);
+      return IntInit::get(getRecordKeeper(), Result);
     }
     break;
   }
   }
   return const_cast<BinOpInit *>(this);
 }
 
 Init *BinOpInit::resolveReferences(Resolver &R) const {
ProfileTernOpInit(FoldingSetNodeID &ID, unsigned Opcode, Init *LHS, Init *MHS,
   ID.AddPointer(Type);
 }
 
 TernOpInit *TernOpInit::get(TernaryOp Opc, Init *LHS, Init *MHS, Init *RHS,
                             RecTy *Type) {
   FoldingSetNodeID ID;
   ProfileTernOpInit(ID, Opc, LHS, MHS, RHS, Type);
 
+  detail::RecordKeeperImpl &RK = LHS->getRecordKeeper().getImpl();
   void *IP = nullptr;
-  if (TernOpInit *I = Context->TheTernOpInitPool.FindNodeOrInsertPos(ID, IP))
+  if (TernOpInit *I = RK.TheTernOpInitPool.FindNodeOrInsertPos(ID, IP))
     return I;
 
-  TernOpInit *I = new (Context->Allocator) TernOpInit(Opc, LHS, MHS, RHS, Type);
-  Context->TheTernOpInitPool.InsertNode(I, IP);
+  TernOpInit *I = new (RK.Allocator) TernOpInit(Opc, LHS, MHS, RHS, Type);
+  RK.TheTernOpInitPool.InsertNode(I, IP);
   return I;
 }
 
 void TernOpInit::Profile(FoldingSetNodeID &ID) const {
   ProfileTernOpInit(ID, getOpcode(), getLHS(), getMHS(), getRHS(), getType());
 }
 
 static Init *ItemApply(Init *LHS, Init *MHSe, Init *RHS, Record *CurRec) {
static Init *FilterHelper(Init *LHS, Init *MHS, Init *RHS, RecTy *Type,
                           Record *CurRec) {
   if (ListInit *MHSl = dyn_cast<ListInit>(MHS)) {
     SmallVector<Init *, 8> NewList;
 
     for (Init *Item : MHSl->getValues()) {
       Init *Include = ItemApply(LHS, Item, RHS, CurRec);
       if (!Include)
         return nullptr;
-      if (IntInit *IncludeInt = dyn_cast_or_null<IntInit>(
-              Include->convertInitializerTo(IntRecTy::get()))) {
+      if (IntInit *IncludeInt =
+              dyn_cast_or_null<IntInit>(Include->convertInitializerTo(
+                  IntRecTy::get(LHS->getRecordKeeper())))) {
         if (IncludeInt->getValue())
           NewList.push_back(Item);
       } else {
         return nullptr;
       }
     }
     return ListInit::get(NewList, cast<ListRecTy>(Type)->getElementType());
   }
 
   return nullptr;
 }
 
 Init *TernOpInit::Fold(Record *CurRec) const {
+  RecordKeeper &RK = getRecordKeeper();
   switch (getOpcode()) {
   case SUBST: {
     DefInit *LHSd = dyn_cast<DefInit>(LHS);
     VarInit *LHSv = dyn_cast<VarInit>(LHS);
     StringInit *LHSs = dyn_cast<StringInit>(LHS);
 
     DefInit *MHSd = dyn_cast<DefInit>(MHS);
     VarInit *MHSv = dyn_cast<VarInit>(MHS);
if (LHSs && MHSs && RHSs) {
         found = Val.find(std::string(LHSs->getValue()), idx);
         if (found == std::string::npos)
           break;
         Val.replace(found, LHSs->getValue().size(),
                     std::string(MHSs->getValue()));
         idx = found + MHSs->getValue().size();
       }
 
-      return StringInit::get(Val);
+      return StringInit::get(RK, Val);
     }
     break;
   }
 
   case FOREACH: {
     if (Init *Result = ForeachHelper(LHS, MHS, RHS, getType(), CurRec))
       return Result;
     break;
   }
 
   case FILTER: {
     if (Init *Result = FilterHelper(LHS, MHS, RHS, getType(), CurRec))
       return Result;
     break;
   }
 
   case IF: {
     if (IntInit *LHSi = dyn_cast_or_null<IntInit>(
-                            LHS->convertInitializerTo(IntRecTy::get()))) {
+            LHS->convertInitializerTo(IntRecTy::get(RK)))) {
       if (LHSi->getValue())
         return MHS;
       return RHS;
     }
     break;
   }
 
   case DAG: {
     ListInit *MHSl = dyn_cast<ListInit>(MHS);
     ListInit *RHSl = dyn_cast<ListInit>(RHS);
     bool MHSok = MHSl || isa<UnsetInit>(MHS);
     bool RHSok = RHSl || isa<UnsetInit>(RHS);
 
     if (isa<UnsetInit>(MHS) && isa<UnsetInit>(RHS))
       break; // Typically prevented by the parser, but might happen with template args
 
     if (MHSok && RHSok && (!MHSl || !RHSl || MHSl->size() == RHSl->size())) {
       SmallVector<std::pair<Init *, StringInit *>, 8> Children;
       unsigned Size = MHSl ? MHSl->size() : RHSl->size();
       for (unsigned i = 0; i != Size; ++i) {
-        Init *Node = MHSl ? MHSl->getElement(i) : UnsetInit::get();
-        Init *Name = RHSl ? RHSl->getElement(i) : UnsetInit::get();
+        Init *Node = MHSl ? MHSl->getElement(i) : UnsetInit::get(RK);
+        Init *Name = RHSl ? RHSl->getElement(i) : UnsetInit::get(RK);
         if (!isa<StringInit>(Name) && !isa<UnsetInit>(Name))
           return const_cast<TernOpInit *>(this);
         Children.emplace_back(Node, dyn_cast<StringInit>(Name));
       }
       return DagInit::get(LHS, nullptr, Children);
     }
     break;
   }
 
   case SUBSTR: {
     StringInit *LHSs = dyn_cast<StringInit>(LHS);
     IntInit *MHSi = dyn_cast<IntInit>(MHS);
     IntInit *RHSi = dyn_cast<IntInit>(RHS);
     if (LHSs && MHSi && RHSi) {
       int64_t StringSize = LHSs->getValue().size();
       int64_t Start = MHSi->getValue();
       int64_t Length = RHSi->getValue();
       if (Start < 0 || Start > StringSize)
         PrintError(CurRec->getLoc(),
                    Twine("!substr start position is out of range 0...") +
                        std::to_string(StringSize) + ": " +
                        std::to_string(Start));
       if (Length < 0)
         PrintError(CurRec->getLoc(), "!substr length must be nonnegative");
-      return StringInit::get(LHSs->getValue().substr(Start, Length),
+      return StringInit::get(RK, LHSs->getValue().substr(Start, Length),
                              LHSs->getFormat());
     }
     break;
   }
 
   case FIND: {
     StringInit *LHSs = dyn_cast<StringInit>(LHS);
     StringInit *MHSs = dyn_cast<StringInit>(MHS);
     IntInit *RHSi = dyn_cast<IntInit>(RHS);
     if (LHSs && MHSs && RHSi) {
       int64_t SourceSize = LHSs->getValue().size();
       int64_t Start = RHSi->getValue();
       if (Start < 0 || Start > SourceSize)
         PrintError(CurRec->getLoc(),
                    Twine("!find start position is out of range 0...") +
                        std::to_string(SourceSize) + ": " +
                        std::to_string(Start));
       auto I = LHSs->getValue().find(MHSs->getValue(), Start);
       if (I == std::string::npos)
-        return IntInit::get(-1);
-      return IntInit::get(I);
+        return IntInit::get(RK, -1);
+      return IntInit::get(RK, I);
     }
     break;
   }
   }
 
   return const_cast<TernOpInit *>(this);
 }
 
 Init *TernOpInit::resolveReferences(Resolver &R) const {
   Init *lhs = LHS->resolveReferences(R);
 
   if (getOpcode() == IF && lhs != LHS) {
     if (IntInit *Value = dyn_cast_or_null<IntInit>(
-                             lhs->convertInitializerTo(IntRecTy::get()))) {
+            lhs->convertInitializerTo(IntRecTy::get(getRecordKeeper())))) {
       // Short-circuit
       if (Value->getValue())
         return MHS->resolveReferences(R);
       return RHS->resolveReferences(R);
     }
   }
 
   Init *mhs = MHS->resolveReferences(R);
static void ProfileFoldOpInit(FoldingSetNodeID &ID, Init *Start, Init *List,
   ID.AddPointer(A);
   ID.AddPointer(B);
   ID.AddPointer(Expr);
   ID.AddPointer(Type);
 }
 
 FoldOpInit *FoldOpInit::get(Init *Start, Init *List, Init *A, Init *B,
                             Init *Expr, RecTy *Type) {
-
   FoldingSetNodeID ID;
   ProfileFoldOpInit(ID, Start, List, A, B, Expr, Type);
 
+  detail::RecordKeeperImpl &RK = Start->getRecordKeeper().getImpl();
   void *IP = nullptr;
-  if (FoldOpInit *I = Context->TheFoldOpInitPool.FindNodeOrInsertPos(ID, IP))
+  if (FoldOpInit *I = RK.TheFoldOpInitPool.FindNodeOrInsertPos(ID, IP))
     return I;
 
-  FoldOpInit *I =
-      new (Context->Allocator) FoldOpInit(Start, List, A, B, Expr, Type);
-  Context->TheFoldOpInitPool.InsertNode(I, IP);
+  FoldOpInit *I = new (RK.Allocator) FoldOpInit(Start, List, A, B, Expr, Type);
+  RK.TheFoldOpInitPool.InsertNode(I, IP);
   return I;
 }
 
 void FoldOpInit::Profile(FoldingSetNodeID &ID) const {
   ProfileFoldOpInit(ID, Start, List, A, B, Expr, getType());
 }
 
 Init *FoldOpInit::Fold(Record *CurRec) const {
static void ProfileIsAOpInit(FoldingSetNodeID &ID, RecTy *CheckType,
   ID.AddPointer(Expr);
 }
 
 IsAOpInit *IsAOpInit::get(RecTy *CheckType, Init *Expr) {
 
   FoldingSetNodeID ID;
   ProfileIsAOpInit(ID, CheckType, Expr);
 
+  detail::RecordKeeperImpl &RK = Expr->getRecordKeeper().getImpl();
   void *IP = nullptr;
-  if (IsAOpInit *I = Context->TheIsAOpInitPool.FindNodeOrInsertPos(ID, IP))
+  if (IsAOpInit *I = RK.TheIsAOpInitPool.FindNodeOrInsertPos(ID, IP))
     return I;
 
-  IsAOpInit *I = new (Context->Allocator) IsAOpInit(CheckType, Expr);
-  Context->TheIsAOpInitPool.InsertNode(I, IP);
+  IsAOpInit *I = new (RK.Allocator) IsAOpInit(CheckType, Expr);
+  RK.TheIsAOpInitPool.InsertNode(I, IP);
   return I;
 }
 
 void IsAOpInit::Profile(FoldingSetNodeID &ID) const {
   ProfileIsAOpInit(ID, CheckType, Expr);
 }
 
 Init *IsAOpInit::Fold() const {
   if (TypedInit *TI = dyn_cast<TypedInit>(Expr)) {
     // Is the expression type known to be (a subclass of) the desired type?
     if (TI->getType()->typeIsConvertibleTo(CheckType))
-      return IntInit::get(1);
+      return IntInit::get(getRecordKeeper(), 1);
 
     if (isa<RecordRecTy>(CheckType)) {
       // If the target type is not a subclass of the expression type, or if
       // the expression has fully resolved to a record, we know that it can't
       // be of the required type.
       if (!CheckType->typeIsConvertibleTo(TI->getType()) || isa<DefInit>(Expr))
-        return IntInit::get(0);
+        return IntInit::get(getRecordKeeper(), 0);
     } else {
       // We treat non-record types as not castable.
-      return IntInit::get(0);
+      return IntInit::get(getRecordKeeper(), 0);
     }
   }
   return const_cast<IsAOpInit *>(this);
 }
 
 Init *IsAOpInit::resolveReferences(Resolver &R) const {
   Init *NewExpr = Expr->resolveReferences(R);
   if (Expr != NewExpr)

 
 Init *
 TypedInit::convertInitializerTo(RecTy *Ty) const {
   if (getType() == Ty || getType()->typeIsA(Ty))
     return const_cast<TypedInit *>(this);
 
   if (isa<BitRecTy>(getType()) && isa<BitsRecTy>(Ty) &&
       cast<BitsRecTy>(Ty)->getNumBits() == 1)
-    return BitsInit::get({const_cast<TypedInit *>(this)});
+    return BitsInit::get(getRecordKeeper(), {const_cast<TypedInit *>(this)});
 
   return nullptr;
 }
 
 Init *TypedInit::convertInitializerBitRange(ArrayRef<unsigned> Bits) const {
   BitsRecTy *T = dyn_cast<BitsRecTy>(getType());
   if (!T) return nullptr;  // Cannot subscript a non-bits variable.
   unsigned NumBits = T->getNumBits();
 
   SmallVector<Init *, 16> NewBits;
   NewBits.reserve(Bits.size());
   for (unsigned Bit : Bits) {
     if (Bit >= NumBits)
       return nullptr;
 
     NewBits.push_back(VarBitInit::get(const_cast<TypedInit *>(this), Bit));
   }
-  return BitsInit::get(NewBits);
+  return BitsInit::get(getRecordKeeper(), NewBits);
 }
 
 Init *TypedInit::getCastTo(RecTy *Ty) const {
   // Handle the common case quickly
   if (getType() == Ty || getType()->typeIsA(Ty))
     return const_cast<TypedInit *>(this);
 
   if (Init *Converted = convertInitializerTo(Ty)) {
Init *TypedInit::convertInitListSlice(ArrayRef<unsigned> Elements) const {
   for (unsigned Element : Elements)
     ListInits.push_back(VarListElementInit::get(const_cast<TypedInit *>(this),
                                                 Element));
   return ListInit::get(ListInits, T->getElementType());
 }
 
 
 VarInit *VarInit::get(StringRef VN, RecTy *T) {
-  Init *Value = StringInit::get(VN);
+  Init *Value = StringInit::get(T->getRecordKeeper(), VN);
   return VarInit::get(Value, T);
 }
 
 VarInit *VarInit::get(Init *VN, RecTy *T) {
-  VarInit *&I = Context->TheVarInitPool[std::make_pair(T, VN)];
+  detail::RecordKeeperImpl &RK = T->getRecordKeeper().getImpl();
+  VarInit *&I = RK.TheVarInitPool[std::make_pair(T, VN)];
   if (!I)
-    I = new (Context->Allocator) VarInit(VN, T);
+    I = new (RK.Allocator) VarInit(VN, T);
   return I;
 }
 
 StringRef VarInit::getName() const {
   StringInit *NameString = cast<StringInit>(getNameInit());
   return NameString->getValue();
 }
 
 Init *VarInit::getBit(unsigned Bit) const {
-  if (getType() == BitRecTy::get())
+  if (getType() == BitRecTy::get(getRecordKeeper()))
     return const_cast<VarInit*>(this);
   return VarBitInit::get(const_cast<VarInit*>(this), Bit);
 }
 
 Init *VarInit::resolveReferences(Resolver &R) const {
   if (Init *Val = R.resolve(VarName))
     return Val;
   return const_cast<VarInit *>(this);
 }
 
 VarBitInit *VarBitInit::get(TypedInit *T, unsigned B) {
-  VarBitInit *&I = Context->TheVarBitInitPool[std::make_pair(T, B)];
+  detail::RecordKeeperImpl &RK = T->getRecordKeeper().getImpl();
+  VarBitInit *&I = RK.TheVarBitInitPool[std::make_pair(T, B)];
   if (!I)
-    I = new(Context->Allocator) VarBitInit(T, B);
+    I = new (RK.Allocator) VarBitInit(T, B);
   return I;
 }
 
 std::string VarBitInit::getAsString() const {
   return TI->getAsString() + "{" + utostr(Bit) + "}";
 }
 
 Init *VarBitInit::resolveReferences(Resolver &R) const {
   Init *I = TI->resolveReferences(R);
   if (TI != I)
     return I->getBit(getBitNum());
 
   return const_cast<VarBitInit*>(this);
 }
 
 VarListElementInit *VarListElementInit::get(TypedInit *T, unsigned E) {
-  VarListElementInit *&I =
-      Context->TheVarListElementInitPool[std::make_pair(T, E)];
+  detail::RecordKeeperImpl &RK = T->getRecordKeeper().getImpl();
+  VarListElementInit *&I = RK.TheVarListElementInitPool[std::make_pair(T, E)];
   if (!I)
-    I = new (Context->Allocator) VarListElementInit(T, E);
+    I = new (RK.Allocator) VarListElementInit(T, E);
   return I;
 }
 
 std::string VarListElementInit::getAsString() const {
   return TI->getAsString() + "[" + utostr(Element) + "]";
 }
 
 Init *VarListElementInit::resolveReferences(Resolver &R) const {
   Init *NewTI = TI->resolveReferences(R);
   if (ListInit *List = dyn_cast<ListInit>(NewTI)) {
     // Leave out-of-bounds array references as-is. This can happen without
     // being an error, e.g. in the untaken "branch" of an !if expression.
     if (getElementNum() < List->size())
       return List->getElement(getElementNum());
   }
   if (NewTI != TI && isa<TypedInit>(NewTI))
     return VarListElementInit::get(cast<TypedInit>(NewTI), getElementNum());
   return const_cast<VarListElementInit *>(this);
 }
 
 Init *VarListElementInit::getBit(unsigned Bit) const {
-  if (getType() == BitRecTy::get())
+  if (getType() == BitRecTy::get(getRecordKeeper()))
     return const_cast<VarListElementInit*>(this);
   return VarBitInit::get(const_cast<VarListElementInit*>(this), Bit);
 }
 
 DefInit::DefInit(Record *D)
     : TypedInit(IK_DefInit, D->getType()), Def(D) {}
 
 DefInit *DefInit::get(Record *R) {
static void ProfileVarDefInit(FoldingSetNodeID &ID,
                               ArrayRef<Init *> Args) {
   ID.AddInteger(Args.size());
   ID.AddPointer(Class);
 
   for (Init *I : Args)
     ID.AddPointer(I);
 }
 
+VarDefInit::VarDefInit(Record *Class, unsigned N)
+    : TypedInit(IK_VarDefInit, RecordRecTy::get(Class)), Class(Class),
+      NumArgs(N) {}
+
 VarDefInit *VarDefInit::get(Record *Class, ArrayRef<Init *> Args) {
   FoldingSetNodeID ID;
   ProfileVarDefInit(ID, Class, Args);
 
+  detail::RecordKeeperImpl &RK = Class->getRecords().getImpl();
   void *IP = nullptr;
-  if (VarDefInit *I = Context->TheVarDefInitPool.FindNodeOrInsertPos(ID, IP))
+  if (VarDefInit *I = RK.TheVarDefInitPool.FindNodeOrInsertPos(ID, IP))
     return I;
 
-  void *Mem = Context->Allocator.Allocate(totalSizeToAlloc<Init *>(Args.size()),
-                                          alignof(VarDefInit));
+  void *Mem = RK.Allocator.Allocate(totalSizeToAlloc<Init *>(Args.size()),
   VarDefInit *I = new (Mem) VarDefInit(Class, Args.size());
   std::uninitialized_copy(Args.begin(), Args.end(),
                           I->getTrailingObjects<Init *>());
-  Context->TheVarDefInitPool.InsertNode(I, IP);
+  RK.TheVarDefInitPool.InsertNode(I, IP);
   return I;
 }
 
 void VarDefInit::Profile(FoldingSetNodeID &ID) const {
   ProfileVarDefInit(ID, Class, args());
 }
 
 DefInit *VarDefInit::instantiate() {
for (Init *Arg : args()) {
     Result += sep;
     sep = ", ";
     Result += Arg->getAsString();
   }
   return Result + ">";
 }
 
 FieldInit *FieldInit::get(Init *R, StringInit *FN) {
-  FieldInit *&I = Context->TheFieldInitPool[std::make_pair(R, FN)];
+  detail::RecordKeeperImpl &RK = R->getRecordKeeper().getImpl();
+  FieldInit *&I = RK.TheFieldInitPool[std::make_pair(R, FN)];
   if (!I)
-    I = new (Context->Allocator) FieldInit(R, FN);
+    I = new (RK.Allocator) FieldInit(R, FN);
   return I;
 }
 
 Init *FieldInit::getBit(unsigned Bit) const {
-  if (getType() == BitRecTy::get())
+  if (getType() == BitRecTy::get(getRecordKeeper()))
     return const_cast<FieldInit*>(this);
   return VarBitInit::get(const_cast<FieldInit*>(this), Bit);
 }
 
 Init *FieldInit::resolveReferences(Resolver &R) const {
   Init *NewRec = Rec->resolveReferences(R);
   if (NewRec != Rec)
     return FieldInit::get(NewRec, FieldName)->Fold(R.getCurrentRecord());

 
 void CondOpInit::Profile(FoldingSetNodeID &ID) const {
   ProfileCondOpInit(ID,
       makeArrayRef(getTrailingObjects<Init *>(), NumConds),
       makeArrayRef(getTrailingObjects<Init *>() + NumConds, NumConds),
       ValType);
 }
 
-CondOpInit *
-CondOpInit::get(ArrayRef<Init *> CondRange,
+CondOpInit *CondOpInit::get(ArrayRef<Init *> CondRange,
                             ArrayRef<Init *> ValRange, RecTy *Ty) {
   assert(CondRange.size() == ValRange.size() &&
          "Number of conditions and values must match!");
 
   FoldingSetNodeID ID;
   ProfileCondOpInit(ID, CondRange, ValRange, Ty);
 
+  detail::RecordKeeperImpl &RK = Ty->getRecordKeeper().getImpl();
   void *IP = nullptr;
-  if (CondOpInit *I = Context->TheCondOpInitPool.FindNodeOrInsertPos(ID, IP))
+  if (CondOpInit *I = RK.TheCondOpInitPool.FindNodeOrInsertPos(ID, IP))
     return I;
 
-  void *Mem = Context->Allocator.Allocate(
+  void *Mem = RK.Allocator.Allocate(
       totalSizeToAlloc<Init *>(2 * CondRange.size()), alignof(BitsInit));
   CondOpInit *I = new(Mem) CondOpInit(CondRange.size(), Ty);
 
   std::uninitialized_copy(CondRange.begin(), CondRange.end(),
                           I->getTrailingObjects<Init *>());
   std::uninitialized_copy(ValRange.begin(), ValRange.end(),
                           I->getTrailingObjects<Init *>()+CondRange.size());
-  Context->TheCondOpInitPool.InsertNode(I, IP);
+  RK.TheCondOpInitPool.InsertNode(I, IP);
   return I;
 }
 
 Init *CondOpInit::resolveReferences(Resolver &R) const {
   SmallVector<Init*, 4> NewConds;
   bool Changed = false;
   for (const Init *Case : getConds()) {
     Init *NewCase = Case->resolveReferences(R);
Init *CondOpInit::resolveReferences(Resolver &R) const {
   if (Changed)
     return (CondOpInit::get(NewConds, NewVals,
             getValType()))->Fold(R.getCurrentRecord());
 
   return const_cast<CondOpInit *>(this);
 }
 
 Init *CondOpInit::Fold(Record *CurRec) const {
+  RecordKeeper &RK = getRecordKeeper();
   for ( unsigned i = 0; i < NumConds; ++i) {
     Init *Cond = getCond(i);
     Init *Val = getVal(i);
 
     if (IntInit *CondI = dyn_cast_or_null<IntInit>(
-            Cond->convertInitializerTo(IntRecTy::get()))) {
+            Cond->convertInitializerTo(IntRecTy::get(RK)))) {
       if (CondI->getValue())
         return Val->convertInitializerTo(getValType());
-    } else
+    } else {
       return const_cast<CondOpInit *>(this);
     }
+  }
 
   PrintFatalError(CurRec->getLoc(),
                   CurRec->getName() +
                   " does not have any true condition in:" +
                   this->getAsString());
   return nullptr;
 }
 
static void ProfileDagInit(FoldingSetNodeID &ID, Init *V, StringInit *VN,
   assert(Name == NameRange.end() && "Arg name overflow!");
 }
 
 DagInit *DagInit::get(Init *V, StringInit *VN, ArrayRef<Init *> ArgRange,
                       ArrayRef<StringInit *> NameRange) {
   FoldingSetNodeID ID;
   ProfileDagInit(ID, V, VN, ArgRange, NameRange);
 
+  detail::RecordKeeperImpl &RK = V->getRecordKeeper().getImpl();
   void *IP = nullptr;
-  if (DagInit *I = Context->TheDagInitPool.FindNodeOrInsertPos(ID, IP))
+  if (DagInit *I = RK.TheDagInitPool.FindNodeOrInsertPos(ID, IP))
     return I;
 
-  void *Mem = Context->Allocator.Allocate(
+  void *Mem = RK.Allocator.Allocate(
       totalSizeToAlloc<Init *, StringInit *>(ArgRange.size(), NameRange.size()),
       alignof(BitsInit));
   DagInit *I = new (Mem) DagInit(V, VN, ArgRange.size(), NameRange.size());
   std::uninitialized_copy(ArgRange.begin(), ArgRange.end(),
                           I->getTrailingObjects<Init *>());
   std::uninitialized_copy(NameRange.begin(), NameRange.end(),
                           I->getTrailingObjects<StringInit *>());
-  Context->TheDagInitPool.InsertNode(I, IP);
+  RK.TheDagInitPool.InsertNode(I, IP);
   return I;
 }
 
 DagInit *
 DagInit::get(Init *V, StringInit *VN,
              ArrayRef<std::pair<Init*, StringInit*>> args) {
   SmallVector<Init *, 8> Args;
   SmallVector<StringInit *, 8> Names;

 }
 
 //===----------------------------------------------------------------------===//
 //    Other implementations
 //===----------------------------------------------------------------------===//
 
 RecordVal::RecordVal(Init *N, RecTy *T, FieldKind K)
     : Name(N), TyAndKind(T, K) {
-  setValue(UnsetInit::get());
+  setValue(UnsetInit::get(N->getRecordKeeper()));
   assert(Value && "Cannot create unset value for current type!");
 }
 
 // This constructor accepts the same arguments as the above, but also
 // a source location.
 RecordVal::RecordVal(Init *N, SMLoc Loc, RecTy *T, FieldKind K)
     : Name(N), Loc(Loc), TyAndKind(T, K) {
-  setValue(UnsetInit::get());
+  setValue(UnsetInit::get(N->getRecordKeeper()));
   assert(Value && "Cannot create unset value for current type!");
 }
 
 StringRef RecordVal::getName() const {
   return cast<StringInit>(getNameInit())->getValue();
 }
 
 std::string RecordVal::getPrintType() const {
-  if (getType() == StringRecTy::get()) {
+  if (getType() == StringRecTy::get(getRecordKeeper())) {
     if (auto *StrInit = dyn_cast<StringInit>(Value)) {
       if (StrInit->hasCodeFormat())
         return "code";
       else
         return "string";
     } else {
       return "string";
     }
if (Value) {
       assert(!isa<TypedInit>(Value) ||
              cast<TypedInit>(Value)->getType()->typeIsA(getType()));
       if (BitsRecTy *BTy = dyn_cast<BitsRecTy>(getType())) {
         if (!isa<BitsInit>(Value)) {
           SmallVector<Init *, 64> Bits;
           Bits.reserve(BTy->getNumBits());
           for (unsigned I = 0, E = BTy->getNumBits(); I < E; ++I)
             Bits.push_back(Value->getBit(I));
-          Value = BitsInit::get(Bits);
+          Value = BitsInit::get(V->getRecordKeeper(), Bits);
         }
       }
     }
     return Value == nullptr;
   }
   Value = nullptr;
   return false;
 }
 
 // This version of setValue takes a source location and resets the
 // location in the RecordVal.
 bool RecordVal::setValue(Init *V, SMLoc NewLoc) {
   Loc = NewLoc;
   if (V) {
     Value = V->getCastTo(getType());
     if (Value) {
       assert(!isa<TypedInit>(Value) ||
              cast<TypedInit>(Value)->getType()->typeIsA(getType()));
       if (BitsRecTy *BTy = dyn_cast<BitsRecTy>(getType())) {
         if (!isa<BitsInit>(Value)) {
           SmallVector<Init *, 64> Bits;
           Bits.reserve(BTy->getNumBits());
           for (unsigned I = 0, E = BTy->getNumBits(); I < E; ++I)
             Bits.push_back(Value->getBit(I));
-          Value = BitsInit::get(Bits);
+          Value = BitsInit::get(getRecordKeeper(), Bits);
         }
       }
     }
     return Value == nullptr;
   }
   Value = nullptr;
   return false;
 }
void Record::checkName() {
   if (!isa<StringRecTy>(TypedName->getType()))
     PrintFatalError(getLoc(), Twine("Record name '") + Name->getAsString() +
                                   "' is not a string!");
 }
 
 RecordRecTy *Record::getType() {
   SmallVector<Record *, 4> DirectSCs;
   getDirectSuperClasses(DirectSCs);
-  return RecordRecTy::get(DirectSCs);
+  return RecordRecTy::get(TrackedRecords, DirectSCs);
 }
 
 DefInit *Record::getDefInit() {
-  if (!CorrespondingDefInit)
-    CorrespondingDefInit = new (Context->Allocator) DefInit(this);
+  if (!CorrespondingDefInit) {
+    CorrespondingDefInit =
+        new (TrackedRecords.getImpl().Allocator) DefInit(this);
+  }
   return CorrespondingDefInit;
 }
 
-unsigned Record::getNewUID() { return Context->LastRecordID++; }
+unsigned Record::getNewUID(RecordKeeper &RK) {
+  return RK.getImpl().LastRecordID++;
+}
 
 void Record::setName(Init *NewName) {
   Name = NewName;
   checkName();
   // DO NOT resolve record values to the name at this point because
   // there might be default values for arguments of this def.  Those
   // arguments might not have been resolved yet so we don't want to
   // prematurely assume values for those arguments were not passed to
void Record::checkUnusedTemplateArgs() {
   for (const Init *TA : getTemplateArgs()) {
     const RecordVal *Arg = getValue(TA);
     if (!Arg->isUsed())
       PrintWarning(Arg->getLoc(),
                    "unused template argument: " + Twine(Arg->getName()));
   }
 }
 
+RecordKeeper::RecordKeeper()
+    : Impl(std::make_unique<detail::RecordKeeperImpl>(*this)) {}
+RecordKeeper::~RecordKeeper() = default;
+
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 LLVM_DUMP_METHOD void RecordKeeper::dump() const { errs() << *this; }
 #endif
 
 raw_ostream &llvm::operator<<(raw_ostream &OS, const RecordKeeper &RK) {
   OS << "------------- Classes -----------------\n";
   for (const auto &C : RK.getClasses())
     OS << "class " << *C.second;
 
   OS << "------------- Defs -----------------\n";
   for (const auto &D : RK.getDefs())
     OS << "def " << *D.second;
   return OS;
 }
 
 /// GetNewAnonymousName - Generate a unique anonymous name that can be used as
 /// an identifier.
 Init *RecordKeeper::getNewAnonymousName() {
-  return AnonymousNameInit::get(AnonCounter++);
+  return AnonymousNameInit::get(*this, getImpl().AnonCounter++);
 }
 
 // These functions implement the phase timing facility. Starting a timer
 // when one is already running stops the running one.
 
 void RecordKeeper::startTimer(StringRef Name) {
   if (TimingGroup) {
     if (LastTimer && LastTimer->isRunning()) {

llvm/lib/TableGen/RecordContext.h

-//===- RecordContext.h - RecordContext implementation ---------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file contains functions for interacting with the tablegen record
-// context.
-//
-//===----------------------------------------------------------------------===//
-
-namespace llvm {
-namespace detail {
-
-/// Resets the Tablegen record context and all currently parsed record data.
-/// Tablegen currently relies on a lot of static data to keep track of parsed
-/// records, which accumulates into static fields. This method resets all of
-/// that data to enable successive executions of the tablegen parser.
-/// FIXME: Ideally tablegen would use a properly scoped (non-static) context,
-/// which would remove any need for managing the context in this way. In that
-/// case, this method could be removed.
-void resetTablegenRecordContext();
-
-} // end namespace detail
-} // end namespace llvm

llvm/lib/TableGen/TGParser.cpp

if (Init *V = RV.getValue()) {
                    RV.getValue()->getAsString());
       }
     }
   }
 }
 
 /// Return an Init with a qualifier prefix referring
 /// to CurRec's name.
-static Init *QualifyName(Record &CurRec, MultiClass *CurMultiClass,
-                        Init *Name, StringRef Scoper) {
-  Init *NewName =
-      BinOpInit::getStrConcat(CurRec.getNameInit(), StringInit::get(Scoper));
+static Init *QualifyName(Record &CurRec, MultiClass *CurMultiClass, Init *Name,
+                         StringRef Scoper) {
+  RecordKeeper &RK = CurRec.getRecords();
+  Init *NewName = BinOpInit::getStrConcat(CurRec.getNameInit(),
+                                          StringInit::get(RK, Scoper));
   NewName = BinOpInit::getStrConcat(NewName, Name);
   if (CurMultiClass && Scoper != "::") {
     Init *Prefix = BinOpInit::getStrConcat(CurMultiClass->Rec.getNameInit(),
-                                           StringInit::get("::"));
+                                           StringInit::get(RK, "::"));
     NewName = BinOpInit::getStrConcat(Prefix, NewName);
   }
 
   if (BinOpInit *BinOp = dyn_cast<BinOpInit>(NewName))
     NewName = BinOp->Fold(&CurRec);
   return NewName;
 }
 
 /// Return the qualified version of the implicit 'NAME' template argument.
 static Init *QualifiedNameOfImplicitName(Record &Rec,
                                          MultiClass *MC = nullptr) {
-  return QualifyName(Rec, MC, StringInit::get("NAME"), MC ? "::" : ":");
+  return QualifyName(Rec, MC, StringInit::get(Rec.getRecords(), "NAME"),
+                     MC ? "::" : ":");
 }
 
 static Init *QualifiedNameOfImplicitName(MultiClass *MC) {
   return QualifiedNameOfImplicitName(MC->Rec, MC);
 }
 
 bool TGParser::AddValue(Record *CurRec, SMLoc Loc, const RecordVal &RV) {
   if (!CurRec)
bool TGParser::SetValue(Record *CurRec, SMLoc Loc, Init *ValName,
   //
   if (!BitList.empty()) {
     BitsInit *CurVal = dyn_cast<BitsInit>(RV->getValue());
     if (!CurVal)
       return Error(Loc, "Value '" + ValName->getAsUnquotedString() +
                    "' is not a bits type");
 
     // Convert the incoming value to a bits type of the appropriate size...
-    Init *BI = V->getCastTo(BitsRecTy::get(BitList.size()));
+    Init *BI = V->getCastTo(BitsRecTy::get(Records, BitList.size()));
     if (!BI)
       return Error(Loc, "Initializer is not compatible with bit range");
 
     SmallVector<Init *, 16> NewBits(CurVal->getNumBits());
 
     // Loop over bits, assigning values as appropriate.
     for (unsigned i = 0, e = BitList.size(); i != e; ++i) {
       unsigned Bit = BitList[i];
       if (NewBits[Bit])
         return Error(Loc, "Cannot set bit #" + Twine(Bit) + " of value '" +
                      ValName->getAsUnquotedString() + "' more than once");
       NewBits[Bit] = BI->getBit(i);
     }
 
     for (unsigned i = 0, e = CurVal->getNumBits(); i != e; ++i)
       if (!NewBits[i])
         NewBits[i] = CurVal->getBit(i);
 
-    V = BitsInit::get(NewBits);
+    V = BitsInit::get(Records, NewBits);
   }
 
   if (RV->setValue(V, Loc)) {
     std::string InitType;
     if (BitsInit *BI = dyn_cast<BitsInit>(V))
       InitType = (Twine("' of type bit initializer with length ") +
                   Twine(BI->getNumBits())).str();
     else if (TypedInit *TI = dyn_cast<TypedInit>(V))
else if (!R.isComplete(TArgs[I]))
                        ") of parent class '" + SC->getNameInitAsString() + "'");
   }
 
   // Copy the subclass record's assertions to the new record.
   CurRec->appendAssertions(SC);
 
   Init *Name;
   if (CurRec->isClass())
-    Name =
-        VarInit::get(QualifiedNameOfImplicitName(*CurRec), StringRecTy::get());
+    Name = VarInit::get(QualifiedNameOfImplicitName(*CurRec),
+                        StringRecTy::get(Records));
   else
     Name = CurRec->getNameInit();
   R.set(QualifiedNameOfImplicitName(*SC), Name);
 
   CurRec->resolveReferences(R);
 
   // Since everything went well, we can now set the "superclass" list for the
   // current record.
if (i < SubMultiClass.TemplateArgs.size()) {
                          " (" + SMCTArgs[i]->getAsUnquotedString() +
                          ") of multiclass '" + SMC->Rec.getNameInitAsString() +
                          "'");
       }
       TemplateArgs.emplace_back(SMCTArgs[i], Default);
     }
   }
 
-  TemplateArgs.emplace_back(
-      QualifiedNameOfImplicitName(SMC),
-      VarInit::get(QualifiedNameOfImplicitName(CurMC), StringRecTy::get()));
+  TemplateArgs.emplace_back(QualifiedNameOfImplicitName(SMC),
+                            VarInit::get(QualifiedNameOfImplicitName(CurMC),
+                                         StringRecTy::get(Records)));
 
   // Add all of the defs in the subclass into the current multiclass.
   return resolve(SMC->Entries, TemplateArgs, false, &CurMC->Entries);
 }
 
 /// Add a record, foreach loop, or assertion to the current context.
 bool TGParser::addEntry(RecordsEntry E) {
   assert((!!E.Rec + !!E.Loop + !!E.Assertion) == 1 &&

 Init *TGParser::ParseObjectName(MultiClass *CurMultiClass) {
   switch (Lex.getCode()) {
   case tgtok::colon:
   case tgtok::semi:
   case tgtok::l_brace:
     // These are all of the tokens that can begin an object body.
     // Some of these can also begin values but we disallow those cases
     // because they are unlikely to be useful.
-    return UnsetInit::get();
+    return UnsetInit::get(Records);
   default:
     break;
   }
 
   Record *CurRec = nullptr;
   if (CurMultiClass)
     CurRec = &CurMultiClass->Rec;
 
-  Init *Name = ParseValue(CurRec, StringRecTy::get(), ParseNameMode);
+  Init *Name = ParseValue(CurRec, StringRecTy::get(Records), ParseNameMode);
   if (!Name)
     return nullptr;
 
   if (CurMultiClass) {
     Init *NameStr = QualifiedNameOfImplicitName(CurMultiClass);
     HasReferenceResolver R(NameStr);
     Name->resolveReferences(R);
     if (!R.found())
-      Name = BinOpInit::getStrConcat(VarInit::get(NameStr, StringRecTy::get()),
-                                     Name);
+      Name = BinOpInit::getStrConcat(
+          VarInit::get(NameStr, StringRecTy::get(Records)), Name);
   }
 
   return Name;
 }
 
 /// ParseClassID - Parse and resolve a reference to a class name.  This returns
 /// null on error.
 ///

 ///   Type ::= LIST '<' Type '>'            // list<x> type
 ///   Type ::= DAG                          // dag type
 ///   Type ::= ClassID                      // Record Type
 ///
 RecTy *TGParser::ParseType() {
   switch (Lex.getCode()) {
   default: TokError("Unknown token when expecting a type"); return nullptr;
   case tgtok::String:
-  case tgtok::Code:   Lex.Lex(); return StringRecTy::get();
-  case tgtok::Bit:    Lex.Lex(); return BitRecTy::get();
-  case tgtok::Int:    Lex.Lex(); return IntRecTy::get();
-  case tgtok::Dag:    Lex.Lex(); return DagRecTy::get();
+  case tgtok::Code:
+    Lex.Lex();
+    return StringRecTy::get(Records);
+  case tgtok::Bit:
+    Lex.Lex();
+    return BitRecTy::get(Records);
+  case tgtok::Int:
+    Lex.Lex();
+    return IntRecTy::get(Records);
+  case tgtok::Dag:
+    Lex.Lex();
+    return DagRecTy::get(Records);
   case tgtok::Id:
-    if (Record *R = ParseClassID()) return RecordRecTy::get(R);
+    if (Record *R = ParseClassID())
+      return RecordRecTy::get(R);
     TokError("unknown class name");
     return nullptr;
   case tgtok::Bits: {
     if (Lex.Lex() != tgtok::less) { // Eat 'bits'
       TokError("expected '<' after bits type");
       return nullptr;
     }
     if (Lex.Lex() != tgtok::IntVal) { // Eat '<'
       TokError("expected integer in bits<n> type");
       return nullptr;
     }
     uint64_t Val = Lex.getCurIntVal();
     if (Lex.Lex() != tgtok::greater) { // Eat count.
       TokError("expected '>' at end of bits<n> type");
       return nullptr;
     }
     Lex.Lex();  // Eat '>'
-    return BitsRecTy::get(Val);
+    return BitsRecTy::get(Records, Val);
   }
   case tgtok::List: {
     if (Lex.Lex() != tgtok::less) { // Eat 'bits'
       TokError("expected '<' after list type");
       return nullptr;
     }
     Lex.Lex();  // Eat '<'
     RecTy *SubType = ParseType();
if ((CurRec && CurRec->isClass()) || CurMultiClass) {
 
     Record *TemplateRec = CurMultiClass ? &CurMultiClass->Rec : CurRec;
     if (TemplateRec->isTemplateArg(TemplateArgName)) {
       RecordVal *RV = TemplateRec->getValue(TemplateArgName);
       assert(RV && "Template arg doesn't exist??");
       RV->setUsed(true);
       return VarInit::get(TemplateArgName, RV->getType());
     } else if (Name->getValue() == "NAME") {
-      return VarInit::get(TemplateArgName, StringRecTy::get());
+      return VarInit::get(TemplateArgName, StringRecTy::get(Records));
     }
   }
 
   if (CurLocalScope)
     if (Init *I = CurLocalScope->getVar(Name->getValue()))
       return I;
 
   // If this is in a foreach loop, make sure it's not a loop iterator
case tgtok::XCast:
         TokError("did not get type for unary operator");
         return nullptr;
       }
 
       break;
     case tgtok::XNOT:
       Lex.Lex();  // eat the operation
       Code = UnOpInit::NOT;
-      Type = IntRecTy::get();
+      Type = IntRecTy::get(Records);
       break;
     case tgtok::XHead:
       Lex.Lex();  // eat the operation
       Code = UnOpInit::HEAD;
       break;
     case tgtok::XTail:
       Lex.Lex();  // eat the operation
       Code = UnOpInit::TAIL;
       break;
     case tgtok::XSize:
       Lex.Lex();
       Code = UnOpInit::SIZE;
-      Type = IntRecTy::get();
+      Type = IntRecTy::get(Records);
       break;
     case tgtok::XEmpty:
       Lex.Lex();  // eat the operation
       Code = UnOpInit::EMPTY;
-      Type = IntRecTy::get();
+      Type = IntRecTy::get(Records);
       break;
     case tgtok::XGetDagOp:
       Lex.Lex();  // eat the operation
       if (Lex.getCode() == tgtok::less) {
         // Parse an optional type suffix, so that you can say
         // !getdagop<BaseClass>(someDag) as a shorthand for
         // !cast<BaseClass>(!getdagop(someDag)).
         Type = ParseOperatorType();
 
         if (!Type) {
           TokError("did not get type for unary operator");
           return nullptr;
         }
 
         if (!isa<RecordRecTy>(Type)) {
           TokError("type for !getdagop must be a record type");
           // but keep parsing, to consume the operand
         }
       } else {
-        Type = RecordRecTy::get({});
+        Type = RecordRecTy::get(Records, {});
       }
       Code = UnOpInit::GETDAGOP;
       break;
     }
     if (!consume(tgtok::l_paren)) {
       TokError("expected '(' after unary operator");
       return nullptr;
     }
case tgtok::XSetDagOp: { // Value ::= !binop '(' Value ',' Value ')'
 
     RecTy *Type = nullptr;
     RecTy *ArgType = nullptr;
     switch (OpTok) {
     default:
       llvm_unreachable("Unhandled code!");
     case tgtok::XConcat:
     case tgtok::XSetDagOp:
-      Type = DagRecTy::get();
-      ArgType = DagRecTy::get();
+      Type = DagRecTy::get(Records);
+      ArgType = DagRecTy::get(Records);
       break;
     case tgtok::XAND:
     case tgtok::XOR:
     case tgtok::XXOR:
     case tgtok::XSRA:
     case tgtok::XSRL:
     case tgtok::XSHL:
     case tgtok::XADD:
     case tgtok::XSUB:
     case tgtok::XMUL:
-      Type = IntRecTy::get();
-      ArgType = IntRecTy::get();
+      Type = IntRecTy::get(Records);
+      ArgType = IntRecTy::get(Records);
       break;
     case tgtok::XEq:
     case tgtok::XNe:
     case tgtok::XLe:
     case tgtok::XLt:
     case tgtok::XGe:
     case tgtok::XGt:
-      Type = BitRecTy::get();
+      Type = BitRecTy::get(Records);
       // ArgType for the comparison operators is not yet known.
       break;
     case tgtok::XListConcat:
       // We don't know the list type until we parse the first argument
       ArgType = ItemType;
       break;
     case tgtok::XListSplat:
       // Can't do any typechecking until we parse the first argument.
       break;
     case tgtok::XStrConcat:
-      Type = StringRecTy::get();
-      ArgType = StringRecTy::get();
+      Type = StringRecTy::get(Records);
+      ArgType = StringRecTy::get(Records);
       break;
     case tgtok::XInterleave:
-      Type = StringRecTy::get();
+      Type = StringRecTy::get(Records);
       // The first argument type is not yet known.
     }
 
     if (Type && ItemType && !Type->typeIsConvertibleTo(ItemType)) {
       Error(OpLoc, Twine("expected value of type '") +
                    ItemType->getAsString() + "', got '" +
                    Type->getAsString() + "'");
       return nullptr;
for (;;) {
                                  "value of type '") +
                                ArgType->getAsString() + "'");
             return nullptr;
           }
           ArgType = nullptr; // Broken invariant: types not identical.
           break;
         case BinOpInit::EQ:
         case BinOpInit::NE:
-          if (!ArgType->typeIsConvertibleTo(IntRecTy::get()) &&
-              !ArgType->typeIsConvertibleTo(StringRecTy::get()) &&
-              !ArgType->typeIsConvertibleTo(RecordRecTy::get({}))) {
+          if (!ArgType->typeIsConvertibleTo(IntRecTy::get(Records)) &&
+              !ArgType->typeIsConvertibleTo(StringRecTy::get(Records)) &&
+              !ArgType->typeIsConvertibleTo(RecordRecTy::get(Records, {}))) {
             Error(InitLoc, Twine("expected bit, bits, int, string, or record; "
                                  "got value of type '") + ArgType->getAsString() + 
                                  "'");
             return nullptr;
           }
           break;
         case BinOpInit::LE:
         case BinOpInit::LT:
         case BinOpInit::GE:
         case BinOpInit::GT:
-          if (!ArgType->typeIsConvertibleTo(IntRecTy::get()) &&
-              !ArgType->typeIsConvertibleTo(StringRecTy::get())) {
+          if (!ArgType->typeIsConvertibleTo(IntRecTy::get(Records)) &&
+              !ArgType->typeIsConvertibleTo(StringRecTy::get(Records))) {
             Error(InitLoc, Twine("expected bit, bits, int, or string; "
                                  "got value of type '") + ArgType->getAsString() + 
                                  "'");
             return nullptr;
           }
           break;
         case BinOpInit::INTERLEAVE:
           switch (InitList.size()) {
           case 1: // First argument must be a list of strings or integers.
-            if (ArgType != StringRecTy::get()->getListTy() &&
-                !ArgType->typeIsConvertibleTo(IntRecTy::get()->getListTy())) {
+            if (ArgType != StringRecTy::get(Records)->getListTy() &&
+                !ArgType->typeIsConvertibleTo(
+                    IntRecTy::get(Records)->getListTy())) {
               Error(InitLoc, Twine("expected list of string, int, bits, or bit; "
                                    "got value of type '") +
                                    ArgType->getAsString() + "'");
               return nullptr;
             }
             break;
           case 2: // Second argument must be a string.
             if (!isa<StringRecTy>(ArgType)) {
for (;;) {
       }
 
       // Deal with BinOps whose arguments have different types, by
       // rewriting ArgType in between them.
       switch (Code) {
         case BinOpInit::SETDAGOP:
           // After parsing the first dag argument, switch to expecting
           // a record, with no restriction on its superclasses.
-          ArgType = RecordRecTy::get({});
+          ArgType = RecordRecTy::get(Records, {});
           break;
         default:
           break;
       }
 
       if (!consume(tgtok::comma))
         break;
     }
case tgtok::XSubst: { // Value ::= !ternop '(' Value ',' Value ',' Value ')'
     RecTy *Type = nullptr;
 
     tgtok::TokKind LexCode = Lex.getCode();
     Lex.Lex();  // eat the operation
     switch (LexCode) {
     default: llvm_unreachable("Unhandled code!");
     case tgtok::XDag:
       Code = TernOpInit::DAG;
-      Type = DagRecTy::get();
+      Type = DagRecTy::get(Records);
       ItemType = nullptr;
       break;
     case tgtok::XIf:
       Code = TernOpInit::IF;
       break;
     case tgtok::XSubst:
       Code = TernOpInit::SUBST;
       break;
case tgtok::XDag: {
         return nullptr;
       }
 
       TypedInit *RHSt = dyn_cast<TypedInit>(RHS);
       if (!RHSt && !isa<UnsetInit>(RHS)) {
         Error(RHSLoc, "could not determine type of the name list in !dag");
         return nullptr;
       }
-      if (RHSt && StringRecTy::get()->getListTy() != RHSt->getType()) {
+      if (RHSt && StringRecTy::get(Records)->getListTy() != RHSt->getType()) {
         Error(RHSLoc, Twine("expected list<string>, got type '") +
                           RHSt->getType()->getAsString() + "'");
         return nullptr;
       }
 
       if (!MHSt && !RHSt) {
         Error(MHSLoc,
               "cannot have both unset children and unset names in !dag");
         return nullptr;
       }
       break;
     }
     case tgtok::XIf: {
       RecTy *MHSTy = nullptr;
       RecTy *RHSTy = nullptr;
 
       if (TypedInit *MHSt = dyn_cast<TypedInit>(MHS))
         MHSTy = MHSt->getType();
       if (BitsInit *MHSbits = dyn_cast<BitsInit>(MHS))
-        MHSTy = BitsRecTy::get(MHSbits->getNumBits());
+        MHSTy = BitsRecTy::get(Records, MHSbits->getNumBits());
       if (isa<BitInit>(MHS))
-        MHSTy = BitRecTy::get();
+        MHSTy = BitRecTy::get(Records);
 
       if (TypedInit *RHSt = dyn_cast<TypedInit>(RHS))
         RHSTy = RHSt->getType();
       if (BitsInit *RHSbits = dyn_cast<BitsInit>(RHS))
-        RHSTy = BitsRecTy::get(RHSbits->getNumBits());
+        RHSTy = BitsRecTy::get(Records, RHSbits->getNumBits());
       if (isa<BitInit>(RHS))
-        RHSTy = BitRecTy::get();
+        RHSTy = BitRecTy::get(Records);
 
       // For UnsetInit, it's typed from the other hand.
       if (isa<UnsetInit>(MHS))
         MHSTy = RHSTy;
       if (isa<UnsetInit>(RHS))
         RHSTy = MHSTy;
 
       if (!MHSTy || !RHSTy) {
if (Lex.getCode() != tgtok::comma) {
       return nullptr;
     }
 
     if (Lex.Lex() != tgtok::Id) { // eat the ','
       TokError("third argument of !foldl must be an identifier");
       return nullptr;
     }
 
-    Init *A = StringInit::get(Lex.getCurStrVal());
+    Init *A = StringInit::get(Records, Lex.getCurStrVal());
     if (CurRec && CurRec->getValue(A)) {
       TokError((Twine("left !foldl variable '") + A->getAsString() +
                 "' already defined")
                    .str());
       return nullptr;
     }
 
     if (Lex.Lex() != tgtok::comma) { // eat the id
       TokError("expected ',' in !foldl");
       return nullptr;
     }
 
     if (Lex.Lex() != tgtok::Id) { // eat the ','
       TokError("fourth argument of !foldl must be an identifier");
       return nullptr;
     }
 
-    Init *B = StringInit::get(Lex.getCurStrVal());
+    Init *B = StringInit::get(Records, Lex.getCurStrVal());
     if (CurRec && CurRec->getValue(B)) {
       TokError((Twine("right !foldl variable '") + B->getAsString() +
                 "' already defined")
                    .str());
       return nullptr;
     }
 
     if (Lex.Lex() != tgtok::comma) { // eat the id
RecTy *TGParser::ParseOperatorType() {
   return Type;
 }
 
 /// Parse the !substr operation. Return null on error.
 ///
 /// Substr ::= !substr(string, start-int [, length-int]) => string
 Init *TGParser::ParseOperationSubstr(Record *CurRec, RecTy *ItemType) {
   TernOpInit::TernaryOp Code = TernOpInit::SUBSTR;
-  RecTy *Type = StringRecTy::get();
+  RecTy *Type = StringRecTy::get(Records);
 
   Lex.Lex(); // eat the operation
 
   if (!consume(tgtok::l_paren)) {
     TokError("expected '(' after !substr operator");
     return nullptr;
   }
 
Init *TGParser::ParseOperationSubstr(Record *CurRec, RecTy *ItemType) {
   SMLoc RHSLoc = Lex.getLoc();
   Init *RHS;
   if (consume(tgtok::comma)) {
     RHSLoc = Lex.getLoc();
     RHS = ParseValue(CurRec);
     if (!RHS)
       return nullptr;
   } else {
-    RHS = IntInit::get(std::numeric_limits<int64_t>::max());
+    RHS = IntInit::get(Records, std::numeric_limits<int64_t>::max());
   }
 
   if (!consume(tgtok::r_paren)) {
     TokError("expected ')' in !substr operator");
     return nullptr;
   }
 
   if (ItemType && !Type->typeIsConvertibleTo(ItemType)) {
Init *TGParser::ParseOperationSubstr(Record *CurRec, RecTy *ItemType) {
   return (TernOpInit::get(Code, LHS, MHS, RHS, Type))->Fold(CurRec);
 }
 
 /// Parse the !find operation. Return null on error.
 ///
 /// Substr ::= !find(string, string [, start-int]) => int
 Init *TGParser::ParseOperationFind(Record *CurRec, RecTy *ItemType) {
   TernOpInit::TernaryOp Code = TernOpInit::FIND;
-  RecTy *Type = IntRecTy::get();
+  RecTy *Type = IntRecTy::get(Records);
 
   Lex.Lex(); // eat the operation
 
   if (!consume(tgtok::l_paren)) {
     TokError("expected '(' after !find operator");
     return nullptr;
   }
 
Init *TGParser::ParseOperationFind(Record *CurRec, RecTy *ItemType) {
   SMLoc RHSLoc = Lex.getLoc();
   Init *RHS;
   if (consume(tgtok::comma)) {
     RHSLoc = Lex.getLoc();
     RHS = ParseValue(CurRec);
     if (!RHS)
       return nullptr;
   } else {
-    RHS = IntInit::get(0);
+    RHS = IntInit::get(Records, 0);
   }
 
   if (!consume(tgtok::r_paren)) {
     TokError("expected ')' in !find operator");
     return nullptr;
   }
 
   if (ItemType && !Type->typeIsConvertibleTo(ItemType)) {
if (Lex.getCode() != tgtok::l_paren) {
     return nullptr;
   }
 
   if (Lex.Lex() != tgtok::Id) { // eat the '('
     TokError("first argument of !foreach/!filter must be an identifier");
     return nullptr;
   }
 
-  Init *LHS = StringInit::get(Lex.getCurStrVal());
+  Init *LHS = StringInit::get(Records, Lex.getCurStrVal());
   Lex.Lex(); // eat the ID.
 
   if (CurRec && CurRec->getValue(LHS)) {
     TokError((Twine("iteration variable '") + LHS->getAsString() +
               "' is already defined")
                  .str());
     return nullptr;
   }
Init *TGParser::ParseOperationForEachFilter(Record *CurRec, RecTy *ItemType) {
   bool IsDAG = false;
 
   if (ListRecTy *InListTy = dyn_cast<ListRecTy>(MHSt->getType())) {
     InEltType = InListTy->getElementType();
     if (ItemType) {
       if (ListRecTy *OutListTy = dyn_cast<ListRecTy>(ItemType)) {
         ExprEltType = (Operation == tgtok::XForEach)
                           ? OutListTy->getElementType()
-                          : IntRecTy::get();
+                          : IntRecTy::get(Records);
       } else {
         Error(OpLoc,
               "expected value of type '" +
                   Twine(ItemType->getAsString()) +
                   "', but got list type");
         return nullptr;
       }
     }
Init *TGParser::ParseOperationCond(Record *CurRec, RecTy *ItemType) {
 
   // resolve type
   RecTy *Type = nullptr;
   for (Init *V : Val) {
     RecTy *VTy = nullptr;
     if (TypedInit *Vt = dyn_cast<TypedInit>(V))
       VTy = Vt->getType();
     if (BitsInit *Vbits = dyn_cast<BitsInit>(V))
-      VTy = BitsRecTy::get(Vbits->getNumBits());
+      VTy = BitsRecTy::get(Records, Vbits->getNumBits());
     if (isa<BitInit>(V))
-      VTy = BitRecTy::get();
+      VTy = BitRecTy::get(Records);
 
     if (Type == nullptr) {
       if (!isa<UnsetInit>(V))
         Type = VTy;
     } else {
       if (!isa<UnsetInit>(V)) {
         RecTy *RType = resolveTypes(Type, VTy);
         if (!RType) {

 ///
 Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType,
                                  IDParseMode Mode) {
   Init *R = nullptr;
   switch (Lex.getCode()) {
   default: TokError("Unknown or reserved token when parsing a value"); break;
 
   case tgtok::TrueVal:
-    R = IntInit::get(1);
+    R = IntInit::get(Records, 1);
     Lex.Lex();
     break;
   case tgtok::FalseVal:
-    R = IntInit::get(0);
+    R = IntInit::get(Records, 0);
     Lex.Lex();
     break;
   case tgtok::IntVal:
-    R = IntInit::get(Lex.getCurIntVal());
+    R = IntInit::get(Records, Lex.getCurIntVal());
     Lex.Lex();
     break;
   case tgtok::BinaryIntVal: {
     auto BinaryVal = Lex.getCurBinaryIntVal();
     SmallVector<Init*, 16> Bits(BinaryVal.second);
     for (unsigned i = 0, e = BinaryVal.second; i != e; ++i)
-      Bits[i] = BitInit::get(BinaryVal.first & (1LL << i));
-    R = BitsInit::get(Bits);
+      Bits[i] = BitInit::get(Records, BinaryVal.first & (1LL << i));
+    R = BitsInit::get(Records, Bits);
     Lex.Lex();
     break;
   }
   case tgtok::StrVal: {
     std::string Val = Lex.getCurStrVal();
     Lex.Lex();
 
     // Handle multiple consecutive concatenated strings.
     while (Lex.getCode() == tgtok::StrVal) {
       Val += Lex.getCurStrVal();
       Lex.Lex();
     }
 
-    R = StringInit::get(Val);
+    R = StringInit::get(Records, Val);
     break;
   }
   case tgtok::CodeFragment:
-    R = StringInit::get(Lex.getCurStrVal(), StringInit::SF_Code);
+    R = StringInit::get(Records, Lex.getCurStrVal(), StringInit::SF_Code);
     Lex.Lex();
     break;
   case tgtok::question:
-    R = UnsetInit::get();
+    R = UnsetInit::get(Records);
     Lex.Lex();
     break;
   case tgtok::Id: {
     SMLoc NameLoc = Lex.getLoc();
-    StringInit *Name = StringInit::get(Lex.getCurStrVal());
+    StringInit *Name = StringInit::get(Records, Lex.getCurStrVal());
     if (Lex.Lex() != tgtok::less)  // consume the Id.
       return ParseIDValue(CurRec, Name, NameLoc, Mode);    // Value ::= IDValue
 
     // Value ::= CLASSID '<' ValueListNE '>' (CLASSID has been consumed)
     // This is supposed to synthesize a new anonymous definition, deriving
     // from the class with the template arguments, but no body.
     Record *Class = Records.getClass(Name->getValue());
     if (!Class) {
for (unsigned i = 0, e = Vals.size(); i != e; ++i) {
         if (BitsRecTy *BitsRec = dyn_cast<BitsRecTy>(VI->getType())) {
           for (unsigned i = 0, e = BitsRec->getNumBits(); i != e; ++i)
             NewBits.push_back(VI->getBit((e - i) - 1));
           continue;
         }
         // Fallthrough to try convert this to a bit.
       }
       // All other values must be convertible to just a single bit.
-      Init *Bit = Vals[i]->getCastTo(BitRecTy::get());
+      Init *Bit = Vals[i]->getCastTo(BitRecTy::get(Records));
       if (!Bit) {
         Error(BraceLoc, "Element #" + Twine(i) + " (" + Vals[i]->getAsString() +
               ") is not convertable to a bit");
         return nullptr;
       }
       NewBits.push_back(Bit);
     }
     std::reverse(NewBits.begin(), NewBits.end());
-    return BitsInit::get(NewBits);
+    return BitsInit::get(Records, NewBits);
   }
   case tgtok::l_square: {          // Value ::= '[' ValueList ']'
     Lex.Lex(); // eat the '['
     SmallVector<Init*, 16> Vals;
 
     RecTy *DeducedEltTy = nullptr;
     ListRecTy *GivenListTy = nullptr;
 
case tgtok::l_paren: {         // Value ::= '(' IDValue DagArgList ')'
 
     // If the operator name is present, parse it.
     StringInit *OperatorName = nullptr;
     if (consume(tgtok::colon)) {
       if (Lex.getCode() != tgtok::VarName) { // eat the ':'
         TokError("expected variable name in dag operator");
         return nullptr;
       }
-      OperatorName = StringInit::get(Lex.getCurStrVal());
+      OperatorName = StringInit::get(Records, Lex.getCurStrVal());
       Lex.Lex();  // eat the VarName.
     }
 
     SmallVector<std::pair<llvm::Init*, StringInit*>, 8> DagArgs;
     if (Lex.getCode() != tgtok::r_paren) {
       ParseDagArgList(DagArgs, CurRec);
       if (DagArgs.empty()) return nullptr;
     }
case tgtok::l_square: {
       }
       break;
     }
     case tgtok::dot: {
       if (Lex.Lex() != tgtok::Id) { // eat the .
         TokError("expected field identifier after '.'");
         return nullptr;
       }
-      StringInit *FieldName = StringInit::get(Lex.getCurStrVal());
+      StringInit *FieldName = StringInit::get(Records, Lex.getCurStrVal());
       if (!Result->getFieldType(FieldName)) {
         TokError("Cannot access field '" + Lex.getCurStrVal() + "' of value '" +
                  Result->getAsString() + "'");
         return nullptr;
       }
       Result = FieldInit::get(Result, FieldName)->Fold(CurRec);
       Lex.Lex();  // eat field name
       break;
case tgtok::paste:
           Result = BinOpInit::getListConcat(LHS, RHSResult);
           break;
         }
         break;
       }
 
       // Create a !strconcat() operation, first casting each operand to
       // a string if necessary.
-      if (LHS->getType() != StringRecTy::get()) {
+      if (LHS->getType() != StringRecTy::get(Records)) {
         auto CastLHS = dyn_cast<TypedInit>(
-            UnOpInit::get(UnOpInit::CAST, LHS, StringRecTy::get())
+            UnOpInit::get(UnOpInit::CAST, LHS, StringRecTy::get(Records))
                 ->Fold(CurRec));
         if (!CastLHS) {
           Error(PasteLoc,
                 Twine("can't cast '") + LHS->getAsString() + "' to string");
           return nullptr;
         }
         LHS = CastLHS;
       }
 
       TypedInit *RHS = nullptr;
 
       Lex.Lex();  // Eat the '#'.
       switch (Lex.getCode()) {
       case tgtok::colon:
       case tgtok::semi:
       case tgtok::l_brace:
         // These are all of the tokens that can begin an object body.
         // Some of these can also begin values but we disallow those cases
         // because they are unlikely to be useful.
 
         // Trailing paste, concat with an empty string.
-        RHS = StringInit::get("");
+        RHS = StringInit::get(Records, "");
         break;
 
       default:
         Init *RHSResult = ParseValue(CurRec, nullptr, ParseNameMode);
         if (!RHSResult)
           return nullptr;
         RHS = dyn_cast<TypedInit>(RHSResult);
         if (!RHS) {
           Error(PasteLoc, "RHS of paste is not typed!");
           return nullptr;
         }
 
-        if (RHS->getType() != StringRecTy::get()) {
+        if (RHS->getType() != StringRecTy::get(Records)) {
           auto CastRHS = dyn_cast<TypedInit>(
-              UnOpInit::get(UnOpInit::CAST, RHS, StringRecTy::get())
+              UnOpInit::get(UnOpInit::CAST, RHS, StringRecTy::get(Records))
                   ->Fold(CurRec));
           if (!CastRHS) {
             Error(PasteLoc,
                   Twine("can't cast '") + RHS->getAsString() + "' to string");
             return nullptr;
           }
           RHS = CastRHS;
         }

 void TGParser::ParseDagArgList(
     SmallVectorImpl<std::pair<llvm::Init*, StringInit*>> &Result,
     Record *CurRec) {
 
   while (true) {
     // DagArg ::= VARNAME
     if (Lex.getCode() == tgtok::VarName) {
       // A missing value is treated like '?'.
-      StringInit *VarName = StringInit::get(Lex.getCurStrVal());
-      Result.emplace_back(UnsetInit::get(), VarName);
+      StringInit *VarName = StringInit::get(Records, Lex.getCurStrVal());
+      Result.emplace_back(UnsetInit::get(Records), VarName);
       Lex.Lex();
     } else {
       // DagArg ::= Value (':' VARNAME)?
       Init *Val = ParseValue(CurRec);
       if (!Val) {
         Result.clear();
         return;
       }
 
       // If the variable name is present, add it.
       StringInit *VarName = nullptr;
       if (Lex.getCode() == tgtok::colon) {
         if (Lex.Lex() != tgtok::VarName) { // eat the ':'
           TokError("expected variable name in dag literal");
           Result.clear();
           return;
         }
-        VarName = StringInit::get(Lex.getCurStrVal());
+        VarName = StringInit::get(Records, Lex.getCurStrVal());
         Lex.Lex();  // eat the VarName.
       }
 
       Result.push_back(std::make_pair(Val, VarName));
     }
     if (!consume(tgtok::comma))
       break;
   }
Init *TGParser::ParseDeclaration(Record *CurRec,
 
   std::string Str = Lex.getCurStrVal();
   if (Str == "NAME") {
     TokError("'" + Str + "' is a reserved variable name");
     return nullptr;
   }
 
   SMLoc IdLoc = Lex.getLoc();
-  Init *DeclName = StringInit::get(Str);
+  Init *DeclName = StringInit::get(Records, Str);
   Lex.Lex();
 
   bool BadField;
   if (!ParsingTemplateArgs) { // def, possibly in a multiclass
     BadField = AddValue(CurRec, IdLoc,
                         RecordVal(DeclName, IdLoc, Type,
                                   HasField ? RecordVal::FK_NonconcreteOK
                                            : RecordVal::FK_Normal));

 ///  ForeachDeclaration ::= ID '=' Value
 ///
 VarInit *TGParser::ParseForeachDeclaration(Init *&ForeachListValue) {
   if (Lex.getCode() != tgtok::Id) {
     TokError("Expected identifier in foreach declaration");
     return nullptr;
   }
 
-  Init *DeclName = StringInit::get(Lex.getCurStrVal());
+  Init *DeclName = StringInit::get(Records, Lex.getCurStrVal());
   Lex.Lex();
 
   // If a value is present, parse it.
   if (!consume(tgtok::equal)) {
     TokError("Expected '=' in foreach declaration");
     return nullptr;
   }
 
default: {
     }
     return nullptr;
   }
   }
 
 
   if (!Ranges.empty()) {
     assert(!IterType && "Type already initialized?");
-    IterType = IntRecTy::get();
+    IterType = IntRecTy::get(Records);
     std::vector<Init *> Values;
     for (unsigned R : Ranges)
-      Values.push_back(IntInit::get(R));
+      Values.push_back(IntInit::get(Records, R));
     ForeachListValue = ListInit::get(Values, IterType);
   }
 
   if (!IterType)
     return nullptr;
 
   return VarInit::get(DeclName, IterType);
 }
if (Lex.getCode() != tgtok::Let) {
     return false;
   }
 
   // LET ID OptionalRangeList '=' Value ';'
   if (Lex.Lex() != tgtok::Id)
     return TokError("expected field identifier after let");
 
   SMLoc IdLoc = Lex.getLoc();
-  StringInit *FieldName = StringInit::get(Lex.getCurStrVal());
+  StringInit *FieldName = StringInit::get(Records, Lex.getCurStrVal());
   Lex.Lex();  // eat the field name.
 
   SmallVector<unsigned, 16> BitList;
   if (ParseOptionalBitList(BitList))
     return true;
   std::reverse(BitList.begin(), BitList.end());
 
   if (!consume(tgtok::equal))
     return TokError("expected '=' in let expression");
 
   RecordVal *Field = CurRec->getValue(FieldName);
   if (!Field)
     return TokError("Value '" + FieldName->getValue() + "' unknown!");
 
   RecTy *Type = Field->getType();
   if (!BitList.empty() && isa<BitsRecTy>(Type)) {
     // When assigning to a subset of a 'bits' object, expect the RHS to have
     // the type of that subset instead of the type of the whole object.
-    Type = BitsRecTy::get(BitList.size());
+    Type = BitsRecTy::get(Records, BitList.size());
   }
 
   Init *Val = ParseValue(CurRec, Type);
   if (!Val) return true;
 
   if (!consume(tgtok::semi))
     return TokError("expected ';' after let expression");
 
bool TGParser::ParseDefset() {
   if (!Type)
     return true;
   if (!isa<ListRecTy>(Type))
     return Error(Defset.Loc, "expected list type");
   Defset.EltTy = cast<ListRecTy>(Type)->getElementType();
 
   if (Lex.getCode() != tgtok::Id)
     return TokError("expected identifier");
-  StringInit *DeclName = StringInit::get(Lex.getCurStrVal());
+  StringInit *DeclName = StringInit::get(Records, Lex.getCurStrVal());
   if (Records.getGlobal(DeclName->getValue()))
     return TokError("def or global variable of this name already exists");
 
   if (Lex.Lex() != tgtok::equal) // Eat the identifier
     return TokError("expected '='");
   if (Lex.Lex() != tgtok::l_brace) // Eat the '='
     return TokError("expected '{'");
   SMLoc BraceLoc = Lex.getLoc();

 ///   Defvar ::= DEFVAR Id '=' Value ';'
 ///
 bool TGParser::ParseDefvar() {
   assert(Lex.getCode() == tgtok::Defvar);
   Lex.Lex(); // Eat the 'defvar' token
 
   if (Lex.getCode() != tgtok::Id)
     return TokError("expected identifier");
-  StringInit *DeclName = StringInit::get(Lex.getCurStrVal());
+  StringInit *DeclName = StringInit::get(Records, Lex.getCurStrVal());
   if (CurLocalScope) {
     if (CurLocalScope->varAlreadyDefined(DeclName->getValue()))
       return TokError("local variable of this name already exists");
   } else {
     if (Records.getGlobal(DeclName->getValue()))
       return TokError("def or global variable of this name already exists");
   }
 
if (!consume(tgtok::Then))
     return TokError("Unknown tok");
 
   // We have to be able to save if statements to execute later, and they have
   // to live on the same stack as foreach loops. The simplest implementation
   // technique is to convert each 'then' or 'else' clause *into* a foreach
   // loop, over a list of length 0 or 1 depending on the condition, and with no
   // iteration variable being assigned.
 
-  ListInit *EmptyList = ListInit::get({}, BitRecTy::get());
+  ListInit *EmptyList = ListInit::get({}, BitRecTy::get(Records));
   ListInit *SingletonList =
-      ListInit::get({BitInit::get(true)}, BitRecTy::get());
-  RecTy *BitListTy = ListRecTy::get(BitRecTy::get());
+      ListInit::get({BitInit::get(Records, true)}, BitRecTy::get(Records));
+  RecTy *BitListTy = ListRecTy::get(BitRecTy::get(Records));
 
   // The foreach containing the then-clause selects SingletonList if
   // the condition is true.
   Init *ThenClauseList =
       TernOpInit::get(TernOpInit::IF, Condition, SingletonList, EmptyList,
                       BitListTy)
           ->Fold(nullptr);
   Loops.push_back(std::make_unique<ForeachLoop>(Loc, nullptr, ThenClauseList));

 void TGParser::ParseLetList(SmallVectorImpl<LetRecord> &Result) {
   do {
     if (Lex.getCode() != tgtok::Id) {
       TokError("expected identifier in let definition");
       Result.clear();
       return;
     }
 
-    StringInit *Name = StringInit::get(Lex.getCurStrVal());
+    StringInit *Name = StringInit::get(Records, Lex.getCurStrVal());
     SMLoc NameLoc = Lex.getLoc();
     Lex.Lex();  // Eat the identifier.
 
     // Check for an optional RangeList.
     SmallVector<unsigned, 16> Bits;
     if (ParseOptionalRangeList(Bits)) {
       Result.clear();
       return;
bool TGParser::ParseDefm(MultiClass *CurMultiClass) {
   Init *DefmName = ParseObjectName(CurMultiClass);
   if (!DefmName)
     return true;
   if (isa<UnsetInit>(DefmName)) {
     DefmName = Records.getNewAnonymousName();
     if (CurMultiClass)
       DefmName = BinOpInit::getStrConcat(
           VarInit::get(QualifiedNameOfImplicitName(CurMultiClass),
-                       StringRecTy::get()),
+                       StringRecTy::get(Records)),
           DefmName);
   }
 
   if (Lex.getCode() != tgtok::colon)
     return TokError("expected ':' after defm identifier");
 
   // Keep track of the new generated record definitions.
   std::vector<RecordsEntry> NewEntries;

llvm/utils/TableGen/CodeGenDAGPatterns.cpp

if (!N->getName().empty())
     NamedNodes[N->getName()].push_back(N);
 
   for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i)
     ComputeNamedNodes(N->getChild(i));
 }
 
 TreePatternNodePtr TreePattern::ParseTreePattern(Init *TheInit,
                                                  StringRef OpName) {
+  RecordKeeper &RK = TheInit->getRecordKeeper();
   if (DefInit *DI = dyn_cast<DefInit>(TheInit)) {
     Record *R = DI->getDef();
 
     // Direct reference to a leaf DagNode or PatFrag?  Turn it into a
     // TreePatternNode of its own.  For example:
     ///   (foo GPR, imm) -> (foo GPR, (imm))
     if (R->isSubClassOf("SDNode") || R->isSubClassOf("PatFrags"))
       return ParseTreePattern(
if (isa<UnsetInit>(TheInit)) {
     Res->setName(OpName);
     return Res;
   }
 
   if (isa<IntInit>(TheInit) || isa<BitInit>(TheInit)) {
     if (!OpName.empty())
       error("Constant int or bit argument should not have a name!");
     if (isa<BitInit>(TheInit))
-      TheInit = TheInit->convertInitializerTo(IntRecTy::get());
+      TheInit = TheInit->convertInitializerTo(IntRecTy::get(RK));
     return std::make_shared<TreePatternNode>(TheInit, 1);
   }
 
   if (BitsInit *BI = dyn_cast<BitsInit>(TheInit)) {
     // Turn this into an IntInit.
-    Init *II = BI->convertInitializerTo(IntRecTy::get());
+    Init *II = BI->convertInitializerTo(IntRecTy::get(RK));
     if (!II || !isa<IntInit>(II))
       error("Bits value must be constants!");
     return ParseTreePattern(II, OpName);
   }
 
   DagInit *Dag = dyn_cast<DagInit>(TheInit);
   if (!Dag) {
     TheInit->print(errs());
if (Operator->isSubClassOf("Intrinsic")) {
     if (Int.IS.RetVTs.empty())
       Operator = getDAGPatterns().get_intrinsic_void_sdnode();
     else if (Int.ModRef != CodeGenIntrinsic::NoMem || Int.hasSideEffects)
       // Has side-effects, requires chain.
       Operator = getDAGPatterns().get_intrinsic_w_chain_sdnode();
     else // Otherwise, no chain.
       Operator = getDAGPatterns().get_intrinsic_wo_chain_sdnode();
 
-    Children.insert(Children.begin(),
-                    std::make_shared<TreePatternNode>(IntInit::get(IID), 1));
+    Children.insert(Children.begin(), std::make_shared<TreePatternNode>(
+                                          IntInit::get(RK, IID), 1));
   }
 
   if (Operator->isSubClassOf("ComplexPattern")) {
     for (unsigned i = 0; i < Children.size(); ++i) {
       TreePatternNodePtr Child = Children[i];
 
       if (Child->getName().empty())
         error("All arguments to a ComplexPattern must be named");
auto AppendPattern = [this](PatternToMatch &P, unsigned Mode,
     TreePatternNodePtr NewDst = P.getDstPattern()->clone();
     if (!NewSrc->setDefaultMode(Mode) || !NewDst->setDefaultMode(Mode)) {
       return;
     }
 
     PatternsToMatch.emplace_back(P.getSrcRecord(), P.getPredicates(),
                                  std::move(NewSrc), std::move(NewDst),
                                  P.getDstRegs(), P.getAddedComplexity(),
-                                 Record::getNewUID(), Mode, Check);
+                                 Record::getNewUID(Records), Mode, Check);
   };
 
   for (PatternToMatch &P : Copy) {
     TreePatternNodePtr SrcP = nullptr, DstP = nullptr;
     if (P.getSrcPattern()->hasProperTypeByHwMode())
       SrcP = P.getSrcPatternShared();
     if (P.getDstPattern()->hasProperTypeByHwMode())
       DstP = P.getDstPatternShared();
for (unsigned v = 0, e = Variants.size(); v != e; ++v) {
       // If we already have it, ignore the variant.
       if (AlreadyExists) continue;
 
       // Otherwise, add it to the list of patterns we have.
       PatternsToMatch.emplace_back(
           PatternsToMatch[i].getSrcRecord(), PatternsToMatch[i].getPredicates(),
           Variant, PatternsToMatch[i].getDstPatternShared(),
           PatternsToMatch[i].getDstRegs(),
-          PatternsToMatch[i].getAddedComplexity(), Record::getNewUID(),
+          PatternsToMatch[i].getAddedComplexity(), Record::getNewUID(Records),
           PatternsToMatch[i].getForceMode(),
           PatternsToMatch[i].getHwModeFeatures());
     }
 
     LLVM_DEBUG(errs() << "\n");
   }
 }

llvm/utils/TableGen/CodeGenInstruction.cpp

bool CodeGenInstAlias::tryAliasOpMatch(DagInit *Result, unsigned AliasOpNo,
 
   // Bits<n> (also used for 0bxx literals)
   if (BitsInit *BI = dyn_cast<BitsInit>(Arg)) {
     if (hasSubOps || !InstOpRec->isSubClassOf("Operand"))
       return false;
     if (!BI->isComplete())
       return false;
     // Convert the bits init to an integer and use that for the result.
-    IntInit *II =
-      dyn_cast_or_null<IntInit>(BI->convertInitializerTo(IntRecTy::get()));
+    IntInit *II = dyn_cast_or_null<IntInit>(
+        BI->convertInitializerTo(IntRecTy::get(BI->getRecordKeeper())));
     if (!II)
       return false;
     ResOp = ResultOperand(II->getValue());
     return true;
   }
 
   // If both are Operands with the same MVT, allow the conversion. It's
   // up to the user to make sure the values are appropriate, just like

llvm/utils/TableGen/CodeGenRegisters.cpp

void expand(SetTheory &ST, Record *Def, SetTheory::RecSet &Elts) override {
 
     // Precompute some types.
     Record *RegisterCl = Def->getRecords().getClass("Register");
     RecTy *RegisterRecTy = RecordRecTy::get(RegisterCl);
     std::vector<StringRef> RegNames =
       Def->getValueAsListOfStrings("RegAsmNames");
 
     // Zip them up.
+    RecordKeeper &RK = Def->getRecords();
     for (unsigned n = 0; n != Length; ++n) {
       std::string Name;
       Record *Proto = Lists[0][n];
       std::vector<Init*> Tuple;
       for (unsigned i = 0; i != Dim; ++i) {
         Record *Reg = Lists[i][n];
         if (i) Name += '_';
         Name += Reg->getName();
         Tuple.push_back(DefInit::get(Reg));
       }
 
       // Take the cost list of the first register in the tuple.
       ListInit *CostList = Proto->getValueAsListInit("CostPerUse");
       SmallVector<Init *, 2> CostPerUse;
       CostPerUse.insert(CostPerUse.end(), CostList->begin(), CostList->end());
 
-      StringInit *AsmName = StringInit::get("");
+      StringInit *AsmName = StringInit::get(RK, "");
       if (!RegNames.empty()) {
         if (RegNames.size() <= n)
           PrintFatalError(Def->getLoc(),
                           "Register tuple definition missing name for '" +
                             Name + "'.");
-        AsmName = StringInit::get(RegNames[n]);
+        AsmName = StringInit::get(RK, RegNames[n]);
       }
 
       // Create a new Record representing the synthesized register. This record
       // is only for consumption by CodeGenRegister, it is not added to the
       // RecordKeeper.
       SynthDefs.emplace_back(
           std::make_unique<Record>(Name, Def->getLoc(), Def->getRecords()));
       Record *NewReg = SynthDefs.back().get();
for (unsigned n = 0; n != Length; ++n) {
           RV.setValue(AsmName);
 
         // CostPerUse is aggregated from all Tuple members.
         if (Field == "CostPerUse")
           RV.setValue(ListInit::get(CostPerUse, CostList->getElementType()));
 
         // Composite registers are always covered by sub-registers.
         if (Field == "CoveredBySubRegs")
-          RV.setValue(BitInit::get(true));
+          RV.setValue(BitInit::get(RK, true));
 
         // Copy fields from the RegisterTuples def.
         if (Field == "SubRegIndices" ||
             Field == "CompositeIndices") {
           NewReg->addValue(*Def->getValue(Field));
           continue;
         }
 

llvm/utils/TableGen/CodeGenTarget.cpp

for (unsigned bit = 0, end = numBits / 2; bit != end; ++bit) {
       NewBits[bit]        = BitSwap;
       NewBits[bitSwapIdx] = OrigBit;
     }
     if (numBits % 2) {
       unsigned middle = (numBits + 1) / 2;
       NewBits[middle] = BI->getBit(middle);
     }
 
-    BitsInit *NewBI = BitsInit::get(NewBits);
+    BitsInit *NewBI = BitsInit::get(Records, NewBits);
 
     // Update the bits in reversed order so that emitInstrOpBits will get the
     // correct endianness.
     R->getValue("Inst")->setValue(NewBI);
   }
 }
 
 /// guessInstructionProperties - Return true if it's OK to guess instruction

llvm/utils/TableGen/DecoderEmitter.cpp

for (auto &SI : VLI) {
     if (const BitsInit *BI = dyn_cast<BitsInit>(SI.Value)) {
       for (unsigned Idx = 0U; Idx < BI->getNumBits(); ++Idx) {
         Bits.push_back(BI->getBit(Idx));
       }
     } else if (const BitInit *BI = dyn_cast<BitInit>(SI.Value)) {
       Bits.push_back(const_cast<BitInit *>(BI));
     } else {
       for (unsigned Idx = 0U; Idx < SI.BitWidth; ++Idx)
-        Bits.push_back(UnsetInit::get());
+        Bits.push_back(UnsetInit::get(def.getRecords()));
     }
   }
 
-  return *BitsInit::get(Bits);
+  return *BitsInit::get(def.getRecords(), Bits);
 }
 
 // Representation of the instruction to work on.
 typedef std::vector<bit_value_t> insn_t;
 
 namespace {
 
 static const uint64_t NO_FIXED_SEGMENTS_SENTINEL = -1ULL;

llvm/utils/TableGen/PseudoLoweringEmitter.cpp

if (DefInit *DI = dyn_cast<DefInit>(Dag->getArg(i))) {
       for (unsigned I = 0, E = Insn.Operands[i].MINumOperands; I != E; ++I)
         OperandMap[BaseIdx + i + I].Kind = OpData::Operand;
       OpsAdded += Insn.Operands[i].MINumOperands;
     } else if (IntInit *II = dyn_cast<IntInit>(Dag->getArg(i))) {
       OperandMap[BaseIdx + i].Kind = OpData::Imm;
       OperandMap[BaseIdx + i].Data.Imm = II->getValue();
       ++OpsAdded;
     } else if (auto *BI = dyn_cast<BitsInit>(Dag->getArg(i))) {
-      auto *II = cast<IntInit>(BI->convertInitializerTo(IntRecTy::get()));
+      auto *II =
+          cast<IntInit>(BI->convertInitializerTo(IntRecTy::get(Records)));
       OperandMap[BaseIdx + i].Kind = OpData::Imm;
       OperandMap[BaseIdx + i].Data.Imm = II->getValue();
       ++OpsAdded;
     } else if (DagInit *SubDag = dyn_cast<DagInit>(Dag->getArg(i))) {
       // Just add the operands recursively. This is almost certainly
       // a constant value for a complex operand (> 1 MI operand).
       unsigned NewOps =
         addDagOperandMapping(Rec, SubDag, Insn, OperandMap, BaseIdx + i);

llvm/utils/TableGen/SearchableTableEmitter.cpp

 
 using namespace llvm;
 
 #define DEBUG_TYPE "searchable-table-emitter"
 
 namespace {
 
 int getAsInt(Init *B) {
-  return cast<IntInit>(B->convertInitializerTo(IntRecTy::get()))->getValue();
+  return cast<IntInit>(
+             B->convertInitializerTo(IntRecTy::get(B->getRecordKeeper())))
+      ->getValue();
 }
 int getInt(Record *R, StringRef Field) {
   return getAsInt(R->getValueInit(Field));
 }
 
 struct GenericEnum {
   using Entry = std::pair<StringRef, int64_t>;
 

llvm/utils/TableGen/WebAssemblyDisassemblerEmitter.cpp

std::map<unsigned,
            std::map<unsigned, std::pair<unsigned, const CodeGenInstruction *>>>
       OpcodeTable;
   for (unsigned I = 0; I != NumberedInstructions.size(); ++I) {
     auto &CGI = *NumberedInstructions[I];
     auto &Def = *CGI.TheDef;
     if (!Def.getValue("Inst"))
       continue;
     auto &Inst = *Def.getValueAsBitsInit("Inst");
-    auto Opc = static_cast<unsigned>(
-        reinterpret_cast<IntInit *>(Inst.convertInitializerTo(IntRecTy::get()))
+    RecordKeeper &RK = Inst.getRecordKeeper();
+    unsigned Opc = static_cast<unsigned>(
+        cast<IntInit>(Inst.convertInitializerTo(IntRecTy::get(RK)))
             ->getValue());
     if (Opc == 0xFFFFFFFF)
       continue; // No opcode defined.
     assert(Opc <= 0xFFFFFF);
     unsigned Prefix;
     if (Opc <= 0xFFFF) {
       Prefix = Opc >> 8;
       Opc = Opc & 0xFF;
     } else {
       Prefix = Opc >> 16;
       Opc = Opc & 0xFFFF;
     }
     auto &CGIP = OpcodeTable[Prefix][Opc];
     // All wasm instructions have a StackBased field of type string, we only
     // want the instructions for which this is "true".
     auto StackString =
-        Def.getValue("StackBased")->getValue()->getCastTo(StringRecTy::get());
+        Def.getValue("StackBased")->getValue()->getCastTo(StringRecTy::get(RK));
     auto IsStackBased =
         StackString &&
         reinterpret_cast<const StringInit *>(StackString)->getValue() == "true";
     if (!IsStackBased)
       continue;
     if (CGIP.second) {
       // We already have an instruction for this slot, so decide which one
       // should be the canonical one. This determines which variant gets