[NFC][TableGen] Refactor the implementation of arguments

[wangpc]

Summary

A new Init type ArgumentInit is added to represent arguments, the
original way that we pass arguments in positional way is represented
as PositionalArgument.

The index of argument in error message is removed.

[tra]

LGTM in general, with a nit.

llvm/include/llvm/TableGen/Record.h

502

changeValue() does not seem to match what the function actually does.

Change implies that we're modifying something already exsting. Based on the implementation, it appears that the function *creates* a new ArgumentInit with the current Index, and the new value. I think the name should reflect it. Perhaps cloneWithValue() would match the intent better?

Also, it appears to be implemented for the PositionalArgumentInit only. If it's needed for other types, then we may need a sensible default implementation. If it's not intended to be used in other circumstances, perhaps we can just construct the new PositionalArgumentInit explicitly in the CheckTemplateArgValues which is the only place where it's used, and drop the virtual function?

[wangpc]

• Rebase.
• Rename changeValue to cloneWithValue.

[wangpc]

llvm/include/llvm/TableGen/Record.h

502

This virtual function will be overrided by PositionalArgumentInit, and NamedArgumentInit in D152998.

[wangpc]

clang-format.

[reames]

Please collapse PositionalArgumentInit into ArgumentInit for this patch. As of this patch, there is no other kind, and the various dispatch logic is just confusing on it's own.

The main value of this patch, and the reason I suggested it, was the type signature change. Having ArgumentInit in place allows you to split it's subclasses in the next change, and focus the review on that.

[wangpc]

• Rebase.
• Collapse PositionalArgumentInit into ArgumentInit.

@reames I don't know if I understond your comment correctly, and I just put PositionalArgumentInit code in followed patch.

[reames]

I went ahead and landed this change after applying a number of stylistic fixes. I also removed a bit of complexity which seems to exist only for the follow up patch, and is worthy of a bit of discussion there.

llvm/include/llvm/TableGen/Record.h

enum InitKind : uint8_t {
     IK_IsAOpInit,
     IK_ExistsOpInit,
     IK_AnonymousNameInit,
     IK_StringInit,
     IK_VarInit,
     IK_VarBitInit,
     IK_VarDefInit,
     IK_LastTypedInit,
-    IK_UnsetInit
+    IK_UnsetInit,
+    IK_ArgumentInit,
   };
 
 private:
   const InitKind Kind;
 
 protected:
   uint8_t Opc; // Used by UnOpInit, BinOpInit, and TernOpInit
 
public:
   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 "?"; }
 };
 
+// Represent an argument.
+class ArgumentInit : public Init, public FoldingSetNode {
+  Init *Value;
+
+protected:
+  explicit ArgumentInit(Init *Value) : Init(IK_ArgumentInit), Value(Value) {}
+
+public:
+  ArgumentInit(const ArgumentInit &) = delete;
+  ArgumentInit &operator=(const ArgumentInit &) = delete;
+
+  static bool classof(const Init *I) { return I->getKind() == IK_ArgumentInit; }
+
+  RecordKeeper &getRecordKeeper() const { return Value->getRecordKeeper(); }
+
+  static ArgumentInit *get(Init *Value);
+
+  Init *getValue() const { return Value; }
+  ArgumentInit *cloneWithValue(Init *Value) const { return get(Value); }
+
+  void Profile(FoldingSetNodeID &ID) const;
+
+  Init *resolveReferences(Resolver &R) const override;
+  std::string getAsString() const override { return Value->getAsString(); }
+
+  bool isComplete() const override { return false; }
+  bool isConcrete() const override { return false; }
+  Init *getBit(unsigned Bit) const override { return Value->getBit(Bit); }
+  Init *getCastTo(RecTy *Ty) const override { return Value->getCastTo(Ty); }
+  Init *convertInitializerTo(RecTy *Ty) const override {
+    return Value->convertInitializerTo(Ty);
+  }
+};
+
 /// 'true'/'false' - Represent a concrete initializer for a bit.
 class BitInit final : public TypedInit {
   friend detail::RecordKeeperImpl;
 
   bool Value;
 
   explicit BitInit(bool V, RecTy *T) : TypedInit(IK_BitInit, T), Value(V) {}
 
public:
 
   Init *getBit(unsigned Bit) const override {
     llvm_unreachable("Illegal bit reference off def");
   }
 };
 
 /// classname<targs...> - Represent an uninstantiated anonymous class
 /// instantiation.
-class VarDefInit final : public TypedInit, public FoldingSetNode,
-                         public TrailingObjects<VarDefInit, Init *> {
+class VarDefInit final : public TypedInit,
+                         public FoldingSetNode,
+                         public TrailingObjects<VarDefInit, ArgumentInit *> {
   Record *Class;
   DefInit *Def = nullptr; // after instantiation
   unsigned NumArgs;
 
   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.
   void operator delete(void *p) { ::operator delete(p); }
 
-  static bool classof(const Init *I) {
-    return I->getKind() == IK_VarDefInit;
-  }
-  static VarDefInit *get(Record *Class, ArrayRef<Init *> Args);
+  static bool classof(const Init *I) { return I->getKind() == IK_VarDefInit; }
+  static VarDefInit *get(Record *Class, ArrayRef<ArgumentInit *> Args);
 
   void Profile(FoldingSetNodeID &ID) const;
 
   Init *resolveReferences(Resolver &R) const override;
   Init *Fold() const;
 
   std::string getAsString() const override;
 
-  Init *getArg(unsigned i) const {
+  ArgumentInit *getArg(unsigned i) const {
     assert(i < NumArgs && "Argument index out of range!");
-    return getTrailingObjects<Init *>()[i];
+    return getTrailingObjects<ArgumentInit *>()[i];
   }
 
-  using const_iterator = Init *const *;
+  using const_iterator = ArgumentInit *const *;
 
-  const_iterator args_begin() const { return getTrailingObjects<Init *>(); }
-  const_iterator args_end  () const { return args_begin() + NumArgs; }
+  const_iterator args_begin() const {
+    return getTrailingObjects<ArgumentInit *>();
+  }
+  const_iterator args_end() const { return args_begin() + NumArgs; }
 
-  size_t         args_size () const { return NumArgs; }
-  bool           args_empty() const { return NumArgs == 0; }
+  size_t args_size() const { return NumArgs; }
+  bool args_empty() const { return NumArgs == 0; }
 
-  ArrayRef<Init *> args() const { return ArrayRef(args_begin(), NumArgs); }
+  ArrayRef<ArgumentInit *> args() const {
+    return ArrayRef(args_begin(), NumArgs);
+  }
 
   Init *getBit(unsigned Bit) const override {
     llvm_unreachable("Illegal bit reference off anonymous def");
   }
 };
 
 /// X.Y - Represent a reference to a subfield of a variable
 class FieldInit : public TypedInit {

llvm/lib/TableGen/Record.cpp

struct RecordKeeperImpl {
   StringRecTy SharedStringRecTy;
   DagRecTy SharedDagRecTy;
 
   RecordRecTy AnyRecord;
   UnsetInit TheUnsetInit;
   BitInit TrueBitInit;
   BitInit FalseBitInit;
 
+  FoldingSet<ArgumentInit> TheArgumentInitPool;
   FoldingSet<BitsInit> TheBitsInitPool;
   std::map<int64_t, IntInit *> TheIntInitPool;
   StringMap<StringInit *, BumpPtrAllocator &> StringInitStringPool;
   StringMap<StringInit *, BumpPtrAllocator &> StringInitCodePool;
   FoldingSet<ListInit> TheListInitPool;
   FoldingSet<UnOpInit> TheUnOpInitPool;
   FoldingSet<BinOpInit> TheBinOpInitPool;
   FoldingSet<TernOpInit> TheTernOpInitPool;

 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 LLVM_DUMP_METHOD void Init::dump() const { return print(errs()); }
 #endif
 
 RecordKeeper &Init::getRecordKeeper() const {
   if (auto *TyInit = dyn_cast<TypedInit>(this))
     return TyInit->getType()->getRecordKeeper();
+  if (auto *ArgInit = dyn_cast<ArgumentInit>(this))
+    return ArgInit->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);
 }
 
+static void ProfileArgumentInit(FoldingSetNodeID &ID, Init *Value) {
+  ID.AddPointer(Value);
+}
+
+void ArgumentInit::Profile(FoldingSetNodeID &ID) const {
+  ProfileArgumentInit(ID, Value);
+}
+
+ArgumentInit *ArgumentInit::get(Init *Value) {
+  FoldingSetNodeID ID;
+  ProfileArgumentInit(ID, Value);
+
+  RecordKeeper &RK = Value->getRecordKeeper();
+  detail::RecordKeeperImpl &RKImpl = RK.getImpl();
+  void *IP = nullptr;
+  if (ArgumentInit *I = RKImpl.TheArgumentInitPool.FindNodeOrInsertPos(ID, IP))
+    return I;
+
+  ArgumentInit *I = new (RKImpl.Allocator) ArgumentInit(Value);
+  RKImpl.TheArgumentInitPool.InsertNode(I, IP);
+  return I;
+}
+
+Init *ArgumentInit::resolveReferences(Resolver &R) const {
+  Init *NewValue = Value->resolveReferences(R);
+  if (NewValue != Value)
+    return cloneWithValue(NewValue);
+
+  return const_cast<ArgumentInit *>(this);
+}
+
 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);
 

 RecTy *DefInit::getFieldType(StringInit *FieldName) const {
   if (const RecordVal *RV = Def->getValue(FieldName))
     return RV->getType();
   return nullptr;
 }
 
 std::string DefInit::getAsString() const { return std::string(Def->getName()); }
 
-static void ProfileVarDefInit(FoldingSetNodeID &ID,
-                              Record *Class,
-                              ArrayRef<Init *> Args) {
+static void ProfileVarDefInit(FoldingSetNodeID &ID, Record *Class,
+                              ArrayRef<ArgumentInit *> 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) {
+VarDefInit *VarDefInit::get(Record *Class, ArrayRef<ArgumentInit *> Args) {
   FoldingSetNodeID ID;
   ProfileVarDefInit(ID, Class, Args);
 
   detail::RecordKeeperImpl &RK = Class->getRecords().getImpl();
   void *IP = nullptr;
   if (VarDefInit *I = RK.TheVarDefInitPool.FindNodeOrInsertPos(ID, IP))
     return I;
 
-  void *Mem = RK.Allocator.Allocate(totalSizeToAlloc<Init *>(Args.size()),
-                                    alignof(VarDefInit));
+  void *Mem = RK.Allocator.Allocate(
+      totalSizeToAlloc<ArgumentInit *>(Args.size()), alignof(VarDefInit));
   VarDefInit *I = new (Mem) VarDefInit(Class, Args.size());
   std::uninitialized_copy(Args.begin(), Args.end(),
-                          I->getTrailingObjects<Init *>());
+                          I->getTrailingObjects<ArgumentInit *>());
   RK.TheVarDefInitPool.InsertNode(I, IP);
   return I;
 }
 
 void VarDefInit::Profile(FoldingSetNodeID &ID) const {
   ProfileVarDefInit(ID, Class, args());
 }
 
 DefInit *VarDefInit::instantiate() {
   if (!Def) {
     RecordKeeper &Records = Class->getRecords();
     auto NewRecOwner = std::make_unique<Record>(Records.getNewAnonymousName(),
                                                 Class->getLoc(), Records,
                                                 /*IsAnonymous=*/true);
     Record *NewRec = NewRecOwner.get();
 
     // Copy values from class to instance
     for (const RecordVal &Val : Class->getValues())
       NewRec->addValue(Val);
 
     // Copy assertions from class to instance.
     NewRec->appendAssertions(Class);
 
     // Substitute and resolve template arguments
     ArrayRef<Init *> TArgs = Class->getTemplateArgs();
     MapResolver R(NewRec);
 
     for (unsigned i = 0, e = TArgs.size(); i != e; ++i) {
       if (i < args_size())
-        R.set(TArgs[i], getArg(i));
+        R.set(TArgs[i], getArg(i)->getValue());
       else
         R.set(TArgs[i], NewRec->getValue(TArgs[i])->getValue());
 
       NewRec->removeValue(TArgs[i]);
     }
 
     NewRec->resolveReferences(R);
 
DefInit *VarDefInit::instantiate() {
   }
 
   return Def;
 }
 
 Init *VarDefInit::resolveReferences(Resolver &R) const {
   TrackUnresolvedResolver UR(&R);
   bool Changed = false;
-  SmallVector<Init *, 8> NewArgs;
+  SmallVector<ArgumentInit *, 8> NewArgs;
   NewArgs.reserve(args_size());
 
-  for (Init *Arg : args()) {
+  for (ArgumentInit *Arg : args()) {
     Init *NewArg = Arg->resolveReferences(UR);
-    NewArgs.push_back(NewArg);
+    assert(isa<ArgumentInit>(NewArg) && "Should be an ArgumentInit");
+    NewArgs.push_back(cast<ArgumentInit>(NewArg));
     Changed |= NewArg != Arg;
   }
 
   if (Changed) {
     auto New = VarDefInit::get(Class, NewArgs);
     if (!UR.foundUnresolved())
       return New->instantiate();
     return New;

llvm/lib/TableGen/TGParser.h

bool resolve(const ForeachLoop &Loop, SubstStack &Stack, bool Final,
                std::vector<RecordsEntry> *Dest, SMLoc *Loc = nullptr);
   bool resolve(const std::vector<RecordsEntry> &Source, SubstStack &Substs,
                bool Final, std::vector<RecordsEntry> *Dest,
                SMLoc *Loc = nullptr);
   bool addDefOne(std::unique_ptr<Record> Rec);
 
   using ArgValueHandler = std::function<void(Init *, Init *)>;
   bool resolveArguments(
-      Record *Rec, ArrayRef<Init *> ArgValues, SMLoc Loc,
+      Record *Rec, ArrayRef<ArgumentInit *> ArgValues, SMLoc Loc,
       ArgValueHandler ArgValueHandler = [](Init *, Init *) {});
   bool resolveArgumentsOfClass(MapResolver &R, Record *Rec,
-                               ArrayRef<Init *> ArgValues, SMLoc Loc);
+                               ArrayRef<ArgumentInit *> ArgValues, SMLoc Loc);
   bool resolveArgumentsOfMultiClass(SubstStack &Substs, MultiClass *MC,
-                                    ArrayRef<Init *> ArgValues, Init *DefmName,
-                                    SMLoc Loc);
+                                    ArrayRef<ArgumentInit *> ArgValues,
+                                    Init *DefmName, SMLoc Loc);
 
 private:  // Parser methods.
   bool consume(tgtok::TokKind K);
   bool ParseObjectList(MultiClass *MC = nullptr);
   bool ParseObject(MultiClass *MC);
   bool ParseClass();
   bool ParseMultiClass();
   bool ParseDefm(MultiClass *CurMultiClass);
private:  // Parser methods.
   Init *ParseIDValue(Record *CurRec, StringInit *Name, SMRange NameLoc,
                      IDParseMode Mode = ParseValueMode);
   Init *ParseSimpleValue(Record *CurRec, RecTy *ItemType = nullptr,
                          IDParseMode Mode = ParseValueMode);
   Init *ParseValue(Record *CurRec, RecTy *ItemType = nullptr,
                    IDParseMode Mode = ParseValueMode);
   void ParseValueList(SmallVectorImpl<llvm::Init*> &Result,
                       Record *CurRec, RecTy *ItemType = nullptr);
-  bool ParseTemplateArgValueList(SmallVectorImpl<llvm::Init *> &Result,
+  bool ParseTemplateArgValueList(SmallVectorImpl<llvm::ArgumentInit *> &Result,
                                  Record *CurRec, Record *ArgsRec);
   void ParseDagArgList(
       SmallVectorImpl<std::pair<llvm::Init*, StringInit*>> &Result,
       Record *CurRec);
   bool ParseOptionalRangeList(SmallVectorImpl<unsigned> &Ranges);
   bool ParseOptionalBitList(SmallVectorImpl<unsigned> &Ranges);
   TypedInit *ParseSliceElement(Record *CurRec);
   TypedInit *ParseSliceElements(Record *CurRec, bool Single = false);
   void ParseRangeList(SmallVectorImpl<unsigned> &Result);
   bool ParseRangePiece(SmallVectorImpl<unsigned> &Ranges,
                        TypedInit *FirstItem = nullptr);
   RecTy *ParseType();
   Init *ParseOperation(Record *CurRec, RecTy *ItemType);
   Init *ParseOperationSubstr(Record *CurRec, RecTy *ItemType);
   Init *ParseOperationFind(Record *CurRec, RecTy *ItemType);
   Init *ParseOperationForEachFilter(Record *CurRec, RecTy *ItemType);
   Init *ParseOperationCond(Record *CurRec, RecTy *ItemType);
   RecTy *ParseOperatorType();
   Init *ParseObjectName(MultiClass *CurMultiClass);
   Record *ParseClassID();
   MultiClass *ParseMultiClassID();
   bool ApplyLetStack(Record *CurRec);
   bool ApplyLetStack(RecordsEntry &Entry);
-  bool CheckTemplateArgValues(SmallVectorImpl<llvm::Init *> &Values,
+  bool CheckTemplateArgValues(SmallVectorImpl<llvm::ArgumentInit *> &Values,
                               SMLoc Loc, Record *ArgsRec);
 };
 
 } // end namespace llvm
 
 #endif

llvm/lib/TableGen/TGParser.cpp

 // Support Code for the Semantic Actions.
 //===----------------------------------------------------------------------===//
 
 namespace llvm {
 
 struct SubClassReference {
   SMRange RefRange;
   Record *Rec;
-  SmallVector<Init*, 4> TemplateArgs;
+  SmallVector<ArgumentInit *, 4> TemplateArgs;
 
   SubClassReference() : Rec(nullptr) {}
 
   bool isInvalid() const { return Rec == nullptr; }
 };
 
 struct SubMultiClassReference {
   SMRange RefRange;
   MultiClass *MC;
-  SmallVector<Init*, 4> TemplateArgs;
+  SmallVector<ArgumentInit *, 4> TemplateArgs;
 
   SubMultiClassReference() : MC(nullptr) {}
 
   bool isInvalid() const { return MC == nullptr; }
   void dump() const;
 };
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
for (DefsetRecord *Defset : Defsets) {
     }
     Defset->Elements.push_back(I);
   }
 
   Records.addDef(std::move(Rec));
   return false;
 }
 
-bool TGParser::resolveArguments(Record *Rec, ArrayRef<Init *> ArgValues,
+bool TGParser::resolveArguments(Record *Rec, ArrayRef<ArgumentInit *> ArgValues,
                                 SMLoc Loc, ArgValueHandler ArgValueHandler) {
   ArrayRef<Init *> ArgNames = Rec->getTemplateArgs();
   assert(ArgValues.size() <= ArgNames.size() &&
          "Too many template arguments allowed");
 
   // Loop over the template argument names. If a value was specified,
   // handle the (name, value) pair. If not and there was no default, complain.
   for (unsigned I = 0, E = ArgNames.size(); I != E; ++I) {
     if (I < ArgValues.size())
-      ArgValueHandler(ArgNames[I], ArgValues[I]);
+      ArgValueHandler(ArgNames[I], ArgValues[I]->getValue());
     else {
       Init *Default = Rec->getValue(ArgNames[I])->getValue();
       if (!Default->isComplete())
         return Error(Loc, "Value not specified for template argument '" +
                               ArgNames[I]->getAsUnquotedString() + "' (#" +
                               Twine(I) + ") of parent class '" +
                               Rec->getNameInitAsString() + "'");
       ArgValueHandler(ArgNames[I], Default);
     }
   }
 
   return false;
 }
 
 /// Resolve the arguments of class and set them to MapResolver.
 /// Returns true if failed.
 bool TGParser::resolveArgumentsOfClass(MapResolver &R, Record *Rec,
-                                       ArrayRef<Init *> ArgValues, SMLoc Loc) {
+                                       ArrayRef<ArgumentInit *> ArgValues,
+                                       SMLoc Loc) {
   return resolveArguments(Rec, ArgValues, Loc,
                           [&](Init *Name, Init *Value) { R.set(Name, Value); });
 }
 
 /// Resolve the arguments of multiclass and store them into SubstStack.
 /// Returns true if failed.
 bool TGParser::resolveArgumentsOfMultiClass(SubstStack &Substs, MultiClass *MC,
-                                            ArrayRef<Init *> ArgValues,
+                                            ArrayRef<ArgumentInit *> ArgValues,
                                             Init *DefmName, SMLoc Loc) {
   // Add an implicit argument NAME.
   Substs.emplace_back(QualifiedNameOfImplicitName(MC), DefmName);
   return resolveArguments(
       &MC->Rec, ArgValues, Loc,
       [&](Init *Name, Init *Value) { Substs.emplace_back(Name, Value); });
 }
 
case tgtok::Id: {
     // from the class with the template arguments, but no body.
     Record *Class = Records.getClass(Name->getValue());
     if (!Class) {
       Error(NameLoc.Start,
             "Expected a class name, got '" + Name->getValue() + "'");
       return nullptr;
     }
 
-    SmallVector<Init *, 8> Args;
+    SmallVector<ArgumentInit *, 8> Args;
     Lex.Lex(); // consume the <
     if (ParseTemplateArgValueList(Args, CurRec, Class))
       return nullptr; // Error parsing value list.
 
     if (CheckTemplateArgValues(Args, NameLoc.Start, Class))
       return nullptr; // Error checking template argument values.
 
     if (resolveArguments(Class, Args, NameLoc.Start))
if (!Result.back()) {
       Result.clear();
       return;
     }
   }
 }
 
 // ParseTemplateArgValueList - Parse a template argument list with the syntax
 // shown, filling in the Result vector. The open angle has been consumed.
-// An empty argument list is allowed. Return false if okay, true if an 
+// An empty argument list is allowed. Return false if okay, true if an
 // error was detected.
 //
 //   TemplateArgList ::= '<' [Value {',' Value}*] '>'
-bool TGParser::ParseTemplateArgValueList(SmallVectorImpl<Init *> &Result,
-                                         Record *CurRec, Record *ArgsRec) {
+bool TGParser::ParseTemplateArgValueList(
+    SmallVectorImpl<ArgumentInit *> &Result, Record *CurRec, Record *ArgsRec) {
 
   assert(Result.empty() && "Result vector is not empty");
   ArrayRef<Init *> TArgs = ArgsRec->getTemplateArgs();
   unsigned ArgIndex = 0;
   RecTy *ItemType;
 
   if (consume(tgtok::greater)) // empty value list
     return false;
 
   while (true) {
     if (ArgIndex >= TArgs.size()) {
       TokError("Too many template arguments: " + utostr(ArgIndex + 1));
       return true;
     }
     const RecordVal *Arg = ArgsRec->getValue(TArgs[ArgIndex]);
     assert(Arg && "Template argument record not found");
 
     ItemType = Arg->getType();
     Init *Value = ParseValue(CurRec, ItemType);
     if (!Value)
       return true;
-    Result.push_back(Value);
+    Result.push_back(ArgumentInit::get(Value));
 
     if (consume(tgtok::greater)) // end of argument list?
       return false;
     if (!consume(tgtok::comma))
       return TokError("Expected comma before next argument");
     ++ArgIndex;
   }
 }
bool TGParser::ParseFile() {
 
   return TokError("Unexpected token at top level");
 }
 
 // Check the types of the template argument values for a class
 // inheritance, multiclass invocation, or anonymous class invocation.
 // If necessary, replace an argument with a cast to the required type.
 // The argument count has already been checked.
-bool TGParser::CheckTemplateArgValues(SmallVectorImpl<llvm::Init *> &Values,
-                                      SMLoc Loc, Record *ArgsRec) {
-
+bool TGParser::CheckTemplateArgValues(
+    SmallVectorImpl<llvm::ArgumentInit *> &Values, SMLoc Loc, Record *ArgsRec) {
   ArrayRef<Init *> TArgs = ArgsRec->getTemplateArgs();
 
   for (unsigned I = 0, E = Values.size(); I < E; ++I) {
     RecordVal *Arg = ArgsRec->getValue(TArgs[I]);
     RecTy *ArgType = Arg->getType();
     auto *Value = Values[I];
 
-    if (TypedInit *ArgValue = dyn_cast<TypedInit>(Value)) { 
+    if (TypedInit *ArgValue = dyn_cast<TypedInit>(Value->getValue())) {
       auto *CastValue = ArgValue->getCastTo(ArgType);
       if (CastValue) {
         assert((!isa<TypedInit>(CastValue) ||
                 cast<TypedInit>(CastValue)->getType()->typeIsA(ArgType)) &&
                "result of template arg value cast has wrong type");
-        Values[I] = CastValue;
+        Values[I] = Value->cloneWithValue(CastValue);
       } else {
         PrintFatalError(Loc,
                         "Value specified for template argument '" +
                             Arg->getNameInitAsString() + "' (#" + Twine(I) +
                             ") is of type " + ArgValue->getType()->getAsString() +
                             "; expected type " + ArgType->getAsString() + ": " +
                             ArgValue->getAsString());
       }