TableGen: Remove the cast-from-string-to-variable-reference feature

[nhaehnle]

Summary

Cast-from-string for records isn't going away, but cast-from-string for
variables is a pretty dodgy feature to have, especially when referencing
template arguments. It's doubtful that this ever worked in a reliable
way, and nobody seems to be using it, so let's get rid of it and get
some related cleanups.

Change-Id: I395ac8a43fef4cf98e611f2f552300d21e99b66a

[tra]

What happens now when someone attempts to cast a variable name?
Will the !cast remain unresolved or will we see a "symbol X not found" error? Both would be somewhat confusing as that X may be something that is obviously there (e.g. template parameter). I'd rather see an explicit error telling me exactly what's wrong. Something like "!cast to a local symbol is not allowed".

[nhaehnle]

In D44195#1033009, @tra wrote:

What happens now when someone attempts to cast a variable name?
Will the !cast remain unresolved or will we see a "symbol X not found" error? Both would be somewhat confusing as that X may be something that is obviously there (e.g. template parameter). I'd rather see an explicit error telling me exactly what's wrong. Something like "!cast to a local symbol is not allowed".

You'd get an "Undefined reference: 'xxx'" error as if you were referencing a record that doesn't exist. I'm changing that to "Undefined reference to record" to be even more explicit about it.

[nhaehnle]

More explicit error message on undefined reference.

llvm/trunk/docs/TableGen/LangIntro.rst

``!cast<type>(a)``
     a template argument, then the lookup is delayed until defm statements
     instantiating the multiclass (or later, if the defm occurs in another
     multiclass and template arguments of the inner multiclass that are
     referenced by 'a' are substituted by values that themselves contain
     references to template arguments of the outer multiclass).
 
     If the type of 'a' does not match *type*, TableGen aborts with an error.
 
-    For historical reasons, 'a' can also be the name of a variable or a
-    template argument in some cases, but this use is unreliable and is
-    discouraged.
-
     Otherwise, perform a normal type cast e.g. between an int and a bit, or
     between record types. This allows casting a record to a subclass, though if
     the types do not match, constant folding will be inhibited. !cast<string>
     is a special case in that the argument can be an int or a record. In the
     latter case, the record's name is returned.
 
 ``!isa<type>(a)``
     Returns an integer: 1 if 'a' is dynamically of the given type, 0 otherwise.

llvm/trunk/include/llvm/TableGen/Record.h

public:
   // Clone - Clone this operator, replacing arguments with the new list
   virtual OpInit *clone(ArrayRef<Init *> Operands) const = 0;
 
   virtual unsigned getNumOperands() const = 0;
   virtual Init *getOperand(unsigned i) const = 0;
 
   // Fold - If possible, fold this to a simpler init.  Return this if not
   // possible to fold.
-  virtual Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const = 0;
+  virtual Init *Fold(Record *CurRec) const = 0;
 
   Init *getBit(unsigned Bit) const override;
 };
 
 /// !op (X) - Transform an init.
 ///
 class UnOpInit : public OpInit, public FoldingSetNode {
 public:
Init *getOperand(unsigned i) const override {
     return getOperand();
   }
 
   UnaryOp getOpcode() const { return (UnaryOp)Opc; }
   Init *getOperand() const { return LHS; }
 
   // Fold - If possible, fold this to a simpler init.  Return this if not
   // possible to fold.
-  Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const override;
+  Init *Fold(Record *CurRec) const override;
 
   Init *resolveReferences(Resolver &R) const override;
 
   std::string getAsString() const override;
 };
 
 /// !op (X, Y) - Combine two inits.
 class BinOpInit : public OpInit, public FoldingSetNode {
public:
   }
 
   BinaryOp getOpcode() const { return (BinaryOp)Opc; }
   Init *getLHS() const { return LHS; }
   Init *getRHS() const { return RHS; }
 
   // Fold - If possible, fold this to a simpler init.  Return this if not
   // possible to fold.
-  Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const override;
+  Init *Fold(Record *CurRec) const override;
 
   Init *resolveReferences(Resolver &R) const override;
 
   std::string getAsString() const override;
 };
 
 /// !op (X, Y, Z) - Combine two inits.
 class TernOpInit : public OpInit, public FoldingSetNode {
public:
 
   TernaryOp getOpcode() const { return (TernaryOp)Opc; }
   Init *getLHS() const { return LHS; }
   Init *getMHS() const { return MHS; }
   Init *getRHS() const { return RHS; }
 
   // Fold - If possible, fold this to a simpler init.  Return this if not
   // possible to fold.
-  Init *Fold(Record *CurRec, MultiClass *CurMultiClass) const override;
+  Init *Fold(Record *CurRec) const override;
 
   bool isComplete() const override {
     return LHS->isComplete() && MHS->isComplete() && RHS->isComplete();
   }
 
   Init *resolveReferences(Resolver &R) const override;
 
   std::string getAsString() const override;

llvm/trunk/lib/TableGen/Record.cpp

UnOpInit *UnOpInit::get(UnaryOp Opc, Init *LHS, RecTy *Type) {
   ThePool.InsertNode(I, IP);
   return I;
 }
 
 void UnOpInit::Profile(FoldingSetNodeID &ID) const {
   ProfileUnOpInit(ID, getOpcode(), getOperand(), getType());
 }
 
-Init *UnOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
+Init *UnOpInit::Fold(Record *CurRec) const {
   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());
 
       if (IntInit *LHSi = dyn_cast<IntInit>(LHS))
         return StringInit::get(LHSi->getAsString());
     } else if (isa<RecordRecTy>(getType())) {
       if (StringInit *Name = dyn_cast<StringInit>(LHS)) {
-        // From TGParser::ParseIDValue
-        if (CurRec) {
-          if (const RecordVal *RV = CurRec->getValue(Name)) {
-            if (RV->getType() != getType())
-              PrintFatalError("type mismatch in cast");
-            return VarInit::get(Name, RV->getType());
-          }
-
-          Init *TemplateArgName = QualifyName(*CurRec, CurMultiClass, Name,
-                                              ":");
-
-          if (CurRec->isTemplateArg(TemplateArgName)) {
-            const RecordVal *RV = CurRec->getValue(TemplateArgName);
-            assert(RV && "Template arg doesn't exist??");
-
-            if (RV->getType() != getType())
-              PrintFatalError("type mismatch in cast");
-
-            return VarInit::get(TemplateArgName, RV->getType());
-          }
-        }
-
-        if (CurMultiClass) {
-          Init *MCName = QualifyName(CurMultiClass->Rec, CurMultiClass, Name,
-                                     "::");
-
-          if (CurMultiClass->Rec.isTemplateArg(MCName)) {
-            const RecordVal *RV = CurMultiClass->Rec.getValue(MCName);
-            assert(RV && "Template arg doesn't exist??");
-
-            if (RV->getType() != getType())
-              PrintFatalError("type mismatch in cast");
-
-            return VarInit::get(MCName, RV->getType());
-          }
-        }
         assert(CurRec && "NULL pointer");
         if (Record *D = (CurRec->getRecords()).getDef(Name->getValue()))
           return DefInit::get(D);
 
         PrintFatalError(CurRec->getLoc(),
-                        "Undefined reference:'" + Name->getValue() + "'\n");
+                        Twine("Undefined reference to record: '") +
+                        Name->getValue() + "'\n");
       }
     }
 
     if (Init *NewInit = LHS->convertInitializerTo(getType()))
       return NewInit;
     break;
 
   case HEAD:
Init *UnOpInit::Fold(Record *CurRec) const {
   return const_cast<UnOpInit *>(this);
 }
 
 Init *UnOpInit::resolveReferences(Resolver &R) const {
   Init *lhs = LHS->resolveReferences(R);
 
   if (LHS != lhs)
     return (UnOpInit::get(getOpcode(), lhs, getType()))
-        ->Fold(R.getCurrentRecord(), nullptr);
-  return Fold(R.getCurrentRecord(), nullptr);
+        ->Fold(R.getCurrentRecord());
+  return Fold(R.getCurrentRecord());
 }
 
 std::string UnOpInit::getAsString() const {
   std::string Result;
   switch (getOpcode()) {
   case CAST: Result = "!cast<" + getType()->getAsString() + ">"; break;
   case HEAD: Result = "!head"; break;
   case TAIL: Result = "!tail"; break;

 
 static StringInit *ConcatStringInits(const StringInit *I0,
                                      const StringInit *I1) {
   SmallString<80> Concat(I0->getValue());
   Concat.append(I1->getValue());
   return StringInit::get(Concat);
 }
 
-Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
+Init *BinOpInit::Fold(Record *CurRec) const {
   switch (getOpcode()) {
   case CONCAT: {
     DagInit *LHSs = dyn_cast<DagInit>(LHS);
     DagInit *RHSs = dyn_cast<DagInit>(RHS);
     if (LHSs && RHSs) {
       DefInit *LOp = dyn_cast<DefInit>(LHSs->getOperator());
       DefInit *ROp = dyn_cast<DefInit>(RHSs->getOperator());
       if (!LOp || !ROp)

 }
 
 Init *BinOpInit::resolveReferences(Resolver &R) const {
   Init *lhs = LHS->resolveReferences(R);
   Init *rhs = RHS->resolveReferences(R);
 
   if (LHS != lhs || RHS != rhs)
     return (BinOpInit::get(getOpcode(), lhs, rhs, getType()))
-        ->Fold(R.getCurrentRecord(), nullptr);
-  return Fold(R.getCurrentRecord(), nullptr);
+        ->Fold(R.getCurrentRecord());
+  return Fold(R.getCurrentRecord());
 }
 
 std::string BinOpInit::getAsString() const {
   std::string Result;
   switch (getOpcode()) {
   case CONCAT: Result = "!con"; break;
   case ADD: Result = "!add"; break;
   case AND: Result = "!and"; break;
for (Init *&Item : NewList) {
         Item = NewItem;
     }
     return ListInit::get(NewList, cast<ListRecTy>(Type)->getElementType());
   }
 
   return nullptr;
 }
 
-Init *TernOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
+Init *TernOpInit::Fold(Record *CurRec) const {
   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 (getOpcode() == FOREACH) {
     SR.addShadow(lhs);
     rhs = RHS->resolveReferences(SR);
   } else {
     rhs = RHS->resolveReferences(R);
   }
 
   if (LHS != lhs || MHS != mhs || RHS != rhs)
     return (TernOpInit::get(getOpcode(), lhs, mhs, rhs, getType()))
-        ->Fold(R.getCurrentRecord(), nullptr);
-  return Fold(R.getCurrentRecord(), nullptr);
+        ->Fold(R.getCurrentRecord());
+  return Fold(R.getCurrentRecord());
 }
 
 std::string TernOpInit::getAsString() const {
   std::string Result;
   switch (getOpcode()) {
   case SUBST: Result = "!subst"; break;
   case FOREACH: Result = "!foreach"; break;
   case IF: Result = "!if"; break;
assert(!isa<TypedInit>(Converted) ||
            cast<TypedInit>(Converted)->getType()->typeIsA(Ty));
     return Converted;
   }
 
   if (!getType()->typeIsConvertibleTo(Ty))
     return nullptr;
 
   return UnOpInit::get(UnOpInit::CAST, const_cast<TypedInit *>(this), Ty)
-             ->Fold(nullptr, nullptr);
+      ->Fold(nullptr);
 }
 
 Init *TypedInit::convertInitListSlice(ArrayRef<unsigned> Elements) const {
   ListRecTy *T = dyn_cast<ListRecTy>(getType());
   if (!T) return nullptr;  // Cannot subscript a non-list variable.
 
   if (Elements.size() == 1)
     return VarListElementInit::get(const_cast<TypedInit *>(this), Elements[0]);
Init *llvm::QualifyName(Record &CurRec, MultiClass *CurMultiClass,
   NewName = GetStrConcat(NewName, Name);
   if (CurMultiClass && Scoper != "::") {
     Init *Prefix = GetStrConcat(CurMultiClass->Rec.getNameInit(),
                                 StringInit::get("::"));
     NewName = GetStrConcat(Prefix, NewName);
   }
 
   if (BinOpInit *BinOp = dyn_cast<BinOpInit>(NewName))
-    NewName = BinOp->Fold(&CurRec, CurMultiClass);
+    NewName = BinOp->Fold(&CurRec);
   return NewName;
 }
 
 Init *MapResolver::resolve(Init *VarName) {
   auto It = Map.find(VarName);
   if (It == Map.end())
     return nullptr;
 

llvm/trunk/lib/TableGen/TGParser.cpp

if (Code == UnOpInit::HEAD ||
       }
     }
 
     if (Lex.getCode() != tgtok::r_paren) {
       TokError("expected ')' in unary operator");
       return nullptr;
     }
     Lex.Lex();  // eat the ')'
-    return (UnOpInit::get(Code, LHS, Type))->Fold(CurRec, CurMultiClass);
+    return (UnOpInit::get(Code, LHS, Type))->Fold(CurRec);
   }
 
   case tgtok::XIsA: {
     // Value ::= !isa '<' Type '>' '(' Value ')'
     Lex.Lex(); // eat the operation
 
     RecTy *Type = ParseOperatorType();
     if (!Type)
case tgtok::XStrConcat: {  // Value ::= !binop '(' Value ',' Value ')'
 
     // We allow multiple operands to associative operators like !strconcat as
     // shorthand for nesting them.
     if (Code == BinOpInit::STRCONCAT || Code == BinOpInit::LISTCONCAT ||
         Code == BinOpInit::CONCAT || Code == BinOpInit::ADD ||
         Code == BinOpInit::AND || Code == BinOpInit::OR) {
       while (InitList.size() > 2) {
         Init *RHS = InitList.pop_back_val();
-        RHS = (BinOpInit::get(Code, InitList.back(), RHS, Type))
-                           ->Fold(CurRec, CurMultiClass);
+        RHS = (BinOpInit::get(Code, InitList.back(), RHS, Type))->Fold(CurRec);
         InitList.back() = RHS;
       }
     }
 
     if (InitList.size() == 2)
       return (BinOpInit::get(Code, InitList[0], InitList[1], Type))
-        ->Fold(CurRec, CurMultiClass);
+          ->Fold(CurRec);
 
     Error(OpLoc, "expected two operands to operator");
     return nullptr;
   }
 
   case tgtok::XForEach: { // Value ::= !foreach '(' Id ',' Value ',' Value ')'
     SMLoc OpLoc = Lex.getLoc();
     Lex.Lex(); // eat the operation
if (IsDAG) {
       if (!RHSt) {
         TokError("could not get type of !foreach result");
         return nullptr;
       }
       OutType = RHSt->getType()->getListTy();
     }
 
     return (TernOpInit::get(TernOpInit::FOREACH, LHS, MHS, RHS, OutType))
-               ->Fold(CurRec, CurMultiClass);
+        ->Fold(CurRec);
   }
 
   case tgtok::XDag:
   case tgtok::XIf:
   case tgtok::XSubst: {  // Value ::= !ternop '(' Value ',' Value ',' Value ')'
     TernOpInit::TernaryOp Code;
     RecTy *Type = nullptr;
 
case tgtok::XSubst: {
       if (!RHSt) {
         TokError("could not get type for !subst");
         return nullptr;
       }
       Type = RHSt->getType();
       break;
     }
     }
-    return (TernOpInit::get(Code, LHS, MHS, RHS, Type))->Fold(CurRec,
-                                                             CurMultiClass);
+    return (TernOpInit::get(Code, LHS, MHS, RHS, Type))->Fold(CurRec);
   }
 
   case tgtok::XFoldl: {
     // Value ::= !foldl '(' Id ',' Id ',' Value ',' Value ',' Value ')'
     Lex.Lex(); // eat the operation
     if (Lex.getCode() != tgtok::l_paren) {
       TokError("expected '(' after !foldl");
       return nullptr;
case tgtok::paste:
 
         if (RHS->getType() != StringRecTy::get()) {
           RHS = UnOpInit::get(UnOpInit::CAST, RHS, StringRecTy::get());
         }
 
         break;
       }
 
-      Result = BinOpInit::get(BinOpInit::STRCONCAT, LHS, RHS,
-                              StringRecTy::get())->Fold(CurRec, CurMultiClass);
+      Result =
+          BinOpInit::get(BinOpInit::STRCONCAT, LHS, RHS, StringRecTy::get())
+              ->Fold(CurRec);
       break;
     }
   }
 }
 
 /// ParseDagArgList - Parse the argument list for a dag literal expression.
 ///
 ///    DagArg     ::= Value (':' VARNAME)?
Record *TGParser::InstantiateMulticlassDef(MultiClass &MC, Record *DefProto,
   }
 
   Init *DefName = DefProto->getNameInit();
   StringInit *DefNameString = dyn_cast<StringInit>(DefName);
 
   if (DefNameString) {
     // We have a fully expanded string so there are no operators to
     // resolve.  We should concatenate the given prefix and name.
-    DefName =
-      BinOpInit::get(BinOpInit::STRCONCAT,
-                     UnOpInit::get(UnOpInit::CAST, DefmPrefix,
-                                   StringRecTy::get())->Fold(DefProto, &MC),
-                     DefName, StringRecTy::get())->Fold(DefProto, &MC);
+    DefName = BinOpInit::get(
+                  BinOpInit::STRCONCAT,
+                  UnOpInit::get(UnOpInit::CAST, DefmPrefix, StringRecTy::get())
+                      ->Fold(DefProto),
+                  DefName, StringRecTy::get())
+                  ->Fold(DefProto);
   }
 
   // Make a trail of SMLocs from the multiclass instantiations.
   SmallVector<SMLoc, 4> Locs(1, DefmPrefixRange.Start);
   Locs.append(DefProto->getLoc().begin(), DefProto->getLoc().end());
   auto CurRec = make_unique<Record>(DefName, Locs, Records, IsAnonymous);
 
   SubClassReference Ref;

llvm/trunk/test/TableGen/MultiClass-defm-fail.td

 // RUN: not llvm-tblgen %s 2>&1 | FileCheck %s
 // XFAIL: vg_leak
 
 // This test verifies that tablegen does fail if it can't resolve an unresolved
 // !cast() during processing top-level defm.
 
 class A {}
 class B<A a> {
   A ba = a;
 }
 
 multiclass M0<string s> {
   // This should work fine.
   def _m00 : B<!cast<A>(s)>;
-  // CHECK: error: Undefined reference:'d1_r1_no_such_record'
+  // CHECK: error: Undefined reference to record: 'd1_r1_no_such_record'
   def _m01: B<!cast<A>(s#"_no_such_record")>;
 }
 
 multiclass M1<string s> {
   def _r1 : A;
   // It would be nice if we could refer to _r1's name without having to pass it
   // explicitly via 's'.
   // XCHECK-DAG: note: instantiated from multiclass