[tablegen] Replace strconcat, listconcat by concat

[johannes]

Summary

Previously, the name concat was used by the operator !con. These
usages are renamed to just con, so that concat can be used by the new operation
which subsumes strconcat, listconcat and also works for code fragments. The old
!strconcat and !listconcat are just aliases for !concat.

[johannes]

adhere to the column limit

[stettberger]

I think there should be some documentation for this new TableGen command.

[johannes]

add documentation + test

[hfinkel]

lib/TableGen/Record.cpp

766

Maybe call this ConcatStringLikeInits or ConcatInits? It should be renamed now that it is not specific to StringInits.

[johannes]

remove codeconcat, make strconcat return code if all arguments are

[johannes]

I use a different approach now, WDYT?

lib/TableGen/Record.cpp

766

yeah, makes sense, done

[hfinkel]

In D40782#958027, @johannes wrote:

I use a different approach now, WDYT?

I'm not sure I like this. Before it was clear: !strconcat is for strings, !codeconcat was for code. Having !strconcat also work on code, and return something which isn't a string, seems unfortunate. And we also have !listconcat. If we want to unify things, I think it would make sense to add !concat (which works on all of those things). [If you do this, then also support !strconcat and !listconcat as aliases to be nice to out-of-tree backends].

[stettberger]

From a user's perspective, I got the impression that code [{}] is just a handy shortcut for multiline strings and I was quite surprised that they are internally actual different datatypes. So for me, changing the semantic of !strconcat would remain rather intuitive.

[johannes]

In D40782#960474, @hfinkel wrote:

In D40782#958027, @johannes wrote:

I use a different approach now, WDYT?

I'm not sure I like this. Before it was clear: !strconcat is for strings, !codeconcat was for code. Having !strconcat also work on code, and return something which isn't a string, seems unfortunate. And we also have !listconcat. If we want to unify things, I think it would make sense to add !concat (which works on all of those things). [If you do this, then also support !strconcat and !listconcat as aliases to be nice to out-of-tree backends].

Oh right, thanks, implementing !concat plus the aliases for the old functions seems to be the cleanest solution, assuming that this change won't cause too much confusion in existing code. I think it should be fine but I don't know how many people are using these operators.

[johannes]

use generic concat

If this will be approved I can also update existing usages of strconcat to concat

docs/TableGen/LangIntro.rst

 ``foreach <var> = {0-15,32-47} in ...``
     Loop over ranges of integers. The braces are required for multiple ranges.
 
 ``(DEF a, b)``
     a dag value.  The first element is required to be a record definition, the
     remaining elements in the list may be arbitrary other values, including
     nested ```dag``' values.
 
+``!concat(a, b, ...)``
+    A string, code fragment or list that is the result of concatenating the 'a'
+    and 'b' elements. More than two arguments are accepted with the result being
+    the concatenation of all the elements given.
+
 ``!listconcat(a, b, ...)``
-    A list value that is the result of concatenating the 'a' and 'b' lists.
-    The lists must have the same element type.
-    More than two arguments are accepted with the result being the concatenation
-    of all the lists given.
+    Alias for !concat.
 
 ``!strconcat(a, b, ...)``
-    A string value that is the result of concatenating the 'a' and 'b' strings.
-    More than two arguments are accepted with the result being the concatenation
-    of all the strings given.
+   Alias for !concat.
 
 ``str1#str2``
-    "#" (paste) is a shorthand for !strconcat.  It may concatenate things that
-    are not quoted strings, in which case an implicit !cast<string> is done on
-    the operand of the paste.
+    "#" (paste) is a shorthand for !concat.  It may concatenate things that are
+    not quoted strings, in which case an implicit !cast<string> is done on the
+    operand of the paste.
 
 ``!cast<type>(a)``
     A symbol of type *type* obtained by looking up the string 'a' in the symbol
     table.  If the type of 'a' does not match *type*, TableGen aborts with an
     error. !cast<string> is a special case in that the argument must be an
     object defined by a 'def' construct.
 
 ``!subst(a, b, c)``

 .. code-block:: text
 
   def ops;
   def GPR;
   def Imm;
   class inst<int opc, string asmstr, dag operandlist>;
 
   multiclass ri_inst<int opc, string asmstr> {
-    def _rr : inst<opc, !strconcat(asmstr, " $dst, $src1, $src2"),
+    def _rr : inst<opc, !concat(asmstr, " $dst, $src1, $src2"),
                    (ops GPR:$dst, GPR:$src1, GPR:$src2)>;
-    def _ri : inst<opc, !strconcat(asmstr, " $dst, $src1, $src2"),
+    def _ri : inst<opc, !concat(asmstr, " $dst, $src1, $src2"),
                    (ops GPR:$dst, GPR:$src1, Imm:$src2)>;
   }
 
   // Instantiations of the ri_inst multiclass.
   defm ADD : ri_inst<0b111, "add">;
   defm SUB : ri_inst<0b101, "sub">;
   defm MUL : ri_inst<0b100, "mul">;
   ...
 
 The name of the resultant definitions has the multidef fragment names appended
 to them, so this defines ``ADD_rr``, ``ADD_ri``, ``SUB_rr``, etc.  A defm may
 inherit from multiple multiclasses, instantiating definitions from each
 multiclass.  Using a multiclass this way is exactly equivalent to instantiating
 the classes multiple times yourself, e.g. by writing:
 
 .. code-block:: text
 
   def ops;
   def GPR;
   def Imm;
   class inst<int opc, string asmstr, dag operandlist>;
 
   class rrinst<int opc, string asmstr>
-    : inst<opc, !strconcat(asmstr, " $dst, $src1, $src2"),
+    : inst<opc, !concat(asmstr, " $dst, $src1, $src2"),
            (ops GPR:$dst, GPR:$src1, GPR:$src2)>;
 
   class riinst<int opc, string asmstr>
-    : inst<opc, !strconcat(asmstr, " $dst, $src1, $src2"),
+    : inst<opc, !concat(asmstr, " $dst, $src1, $src2"),
            (ops GPR:$dst, GPR:$src1, Imm:$src2)>;
 
   // Instantiations of the ri_inst multiclass.
   def ADD_rr : rrinst<0b111, "add">;
   def ADD_ri : riinst<0b111, "add">;
   def SUB_rr : rrinst<0b101, "sub">;
   def SUB_ri : riinst<0b101, "sub">;
   def MUL_rr : rrinst<0b100, "mul">;

include/llvm/TableGen/Record.h

public:
   Init *resolveReferences(Record &R, const RecordVal *RV) const override;
 
   std::string getAsString() const override;
 };
 
 /// !op (X, Y) - Combine two inits.
 class BinOpInit : public OpInit, public FoldingSetNode {
 public:
-  enum BinaryOp : uint8_t { ADD, AND, OR, SHL, SRA, SRL, LISTCONCAT,
-                            STRCONCAT, CONCAT, EQ };
+  enum BinaryOp : uint8_t { ADD, AND, OR, SHL, SRA, SRL, CONCAT, CON, EQ };
 
 private:
   Init *LHS, *RHS;
 
   BinOpInit(BinaryOp opc, Init *lhs, Init *rhs, RecTy *Type) :
       OpInit(IK_BinOpInit, Type, opc), LHS(lhs), RHS(rhs) {}
 
 public:

lib/TableGen/Record.cpp

BinOpInit *BinOpInit::get(BinaryOp Opc, Init *LHS,
   ThePool.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) {
+template <class T> static T *ConcatStringLikeInits(const T *I0, const T *I1) {
   SmallString<80> Concat(I0->getValue());
   Concat.append(I1->getValue());
-  return StringInit::get(Concat);
+  return T::get(Concat);
 }
 
 Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
   switch (getOpcode()) {
-  case CONCAT: {
+  case CON: {
     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 || LOp->getDef() != ROp->getDef())
         PrintFatalError("Concated Dag operators do not match!");
       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) {
         Args.push_back(RHSs->getArg(i));
         ArgNames.push_back(RHSs->getArgName(i));
       }
       return DagInit::get(LHSs->getOperator(), nullptr, Args, ArgNames);
     }
     break;
   }
-  case LISTCONCAT: {
-    ListInit *LHSs = dyn_cast<ListInit>(LHS);
-    ListInit *RHSs = dyn_cast<ListInit>(RHS);
-    if (LHSs && RHSs) {
+  case CONCAT: {
+    ListInit *LHSl = dyn_cast<ListInit>(LHS);
+    ListInit *RHSl = dyn_cast<ListInit>(RHS);
+    if (LHSl && RHSl) {
       SmallVector<Init *, 8> Args;
-      Args.insert(Args.end(), LHSs->begin(), LHSs->end());
-      Args.insert(Args.end(), RHSs->begin(), RHSs->end());
+      Args.insert(Args.end(), LHSl->begin(), LHSl->end());
+      Args.insert(Args.end(), RHSl->begin(), RHSl->end());
       return ListInit::get(
-          Args, cast<ListRecTy>(LHSs->getType())->getElementType());
-    }
-    break;
+          Args, cast<ListRecTy>(LHSl->getType())->getElementType());
     }
-  case STRCONCAT: {
+    CodeInit *LHSc = dyn_cast<CodeInit>(LHS);
+    CodeInit *RHSc = dyn_cast<CodeInit>(RHS);
+    if (LHSc && RHSc)
+      return ConcatStringLikeInits(LHSc, RHSc);
     StringInit *LHSs = dyn_cast<StringInit>(LHS);
     StringInit *RHSs = dyn_cast<StringInit>(RHS);
     if (LHSs && RHSs)
-      return ConcatStringInits(LHSs, RHSs);
+      return ConcatStringLikeInits(LHSs, RHSs);
     break;
   }
   case EQ: {
     // try to fold eq comparison for 'bit' and 'int', otherwise fallback
     // to string objects.
     IntInit *L =
       dyn_cast_or_null<IntInit>(LHS->convertInitializerTo(IntRecTy::get()));
     IntInit *R =
Init *BinOpInit::resolveReferences(Record &R, const RecordVal *RV) const {
   if (LHS != lhs || RHS != rhs)
     return (BinOpInit::get(getOpcode(), lhs, rhs, getType()))->Fold(&R,nullptr);
   return Fold(&R, nullptr);
 }
 
 std::string BinOpInit::getAsString() const {
   std::string Result;
   switch (getOpcode()) {
-  case CONCAT: Result = "!con"; break;
+  case CON: Result = "!con"; break;
   case ADD: Result = "!add"; break;
   case AND: Result = "!and"; break;
   case OR: Result = "!or"; break;
   case SHL: Result = "!shl"; break;
   case SRA: Result = "!sra"; break;
   case SRL: Result = "!srl"; break;
   case EQ: Result = "!eq"; break;
-  case LISTCONCAT: Result = "!listconcat"; break;
-  case STRCONCAT: Result = "!strconcat"; break;
+  case CONCAT: Result = "!concat"; break;
   }
   return Result + "(" + LHS->getAsString() + ", " + RHS->getAsString() + ")";
 }
 
 static void
 ProfileTernOpInit(FoldingSetNodeID &ID, unsigned Opcode, Init *LHS, Init *MHS,
                   Init *RHS, RecTy *Type) {
   ID.AddInteger(Opcode);
RecordKeeper::getAllDerivedDefinitions(StringRef ClassName) const {
 
   return Defs;
 }
 
 static Init *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 ConcatStringLikeInits(I0s, I1s);
+  return BinOpInit::get(BinOpInit::CONCAT, I0, I1, StringRecTy::get());
 }
 
 Init *llvm::QualifyName(Record &CurRec, MultiClass *CurMultiClass,
                         Init *Name, StringRef Scoper) {
   Init *NewName = GetStrConcat(CurRec.getNameInit(), StringInit::get(Scoper));
   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);
   return NewName;
 }

lib/TableGen/TGLexer.h

enum TokKind {
     equal, question,    // = ?
     paste,              // #
 
     // Keywords.
     Bit, Bits, Class, Code, Dag, Def, Foreach, Defm, Field, In, Int, Let, List,
     MultiClass, String,
 
     // !keywords.
-    XConcat, XADD, XAND, XOR, XSRA, XSRL, XSHL, XListConcat, XStrConcat, XCast,
-    XSubst, XForEach, XHead, XTail, XEmpty, XIf, XEq,
+    XCon, XADD, XAND, XOR, XSRA, XSRL, XSHL, XConcat, XCast, XSubst, XForEach,
+    XHead, XTail, XEmpty, XIf, XEq,
 
     // Integer value.
     IntVal,
 
     // Binary constant.  Note that these are sized according to the number of
     // bits given.
     BinaryIntVal,
     

lib/TableGen/TGLexer.cpp

tgtok::TokKind TGLexer::LexExclaim() {
   
   // Check to see which operator this is.
   tgtok::TokKind Kind =
     StringSwitch<tgtok::TokKind>(StringRef(Start, CurPtr - Start))
     .Case("eq", tgtok::XEq)
     .Case("if", tgtok::XIf)
     .Case("head", tgtok::XHead)
     .Case("tail", tgtok::XTail)
-    .Case("con", tgtok::XConcat)
+    .Case("con", tgtok::XCon)
     .Case("add", tgtok::XADD)
     .Case("and", tgtok::XAND)
     .Case("or", tgtok::XOR)
     .Case("shl", tgtok::XSHL)
     .Case("sra", tgtok::XSRA)
     .Case("srl", tgtok::XSRL)
     .Case("cast", tgtok::XCast)
     .Case("empty", tgtok::XEmpty)
     .Case("subst", tgtok::XSubst)
     .Case("foreach", tgtok::XForEach)
-    .Case("listconcat", tgtok::XListConcat)
-    .Case("strconcat", tgtok::XStrConcat)
+    .Case("concat", tgtok::XConcat)
+    .Case("listconcat", tgtok::XConcat)
+    .Case("strconcat", tgtok::XConcat)
     .Default(tgtok::Error);
 
   return Kind != tgtok::Error ? Kind : ReturnError(Start-1, "Unknown operator");
 }

lib/TableGen/TGParser.cpp

case tgtok::XCast: {  // Value ::= !unop '(' Value ')'
     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);
   }
 
-  case tgtok::XConcat:
+  case tgtok::XCon:
   case tgtok::XADD:
   case tgtok::XAND:
   case tgtok::XOR:
   case tgtok::XSRA:
   case tgtok::XSRL:
   case tgtok::XSHL:
   case tgtok::XEq:
-  case tgtok::XListConcat:
-  case tgtok::XStrConcat: {  // Value ::= !binop '(' Value ',' Value ')'
+  case tgtok::XConcat: {  // Value ::= !binop '(' Value ',' Value ')'
     tgtok::TokKind OpTok = Lex.getCode();
     SMLoc OpLoc = Lex.getLoc();
     Lex.Lex();  // eat the operation
 
     BinOpInit::BinaryOp Code;
     RecTy *Type = nullptr;
 
     switch (OpTok) {
     default: llvm_unreachable("Unhandled code!");
-    case tgtok::XConcat: Code = BinOpInit::CONCAT;Type = DagRecTy::get(); break;
+    case tgtok::XCon:    Code = BinOpInit::CON;   Type = DagRecTy::get(); break;
     case tgtok::XADD:    Code = BinOpInit::ADD;   Type = IntRecTy::get(); break;
     case tgtok::XAND:    Code = BinOpInit::AND;   Type = IntRecTy::get(); break;
     case tgtok::XOR:     Code = BinOpInit::OR;    Type = IntRecTy::get(); break;
     case tgtok::XSRA:    Code = BinOpInit::SRA;   Type = IntRecTy::get(); break;
     case tgtok::XSRL:    Code = BinOpInit::SRL;   Type = IntRecTy::get(); break;
     case tgtok::XSHL:    Code = BinOpInit::SHL;   Type = IntRecTy::get(); break;
     case tgtok::XEq:     Code = BinOpInit::EQ;    Type = BitRecTy::get(); break;
-    case tgtok::XListConcat:
-      Code = BinOpInit::LISTCONCAT;
-      // We don't know the list type until we parse the first argument
       break;
-    case tgtok::XStrConcat:
-      Code = BinOpInit::STRCONCAT;
-      Type = StringRecTy::get();
+    case tgtok::XConcat:
+      Code = BinOpInit::CONCAT;
+      // We don't know the list type until we parse the first argument
       break;
     }
 
     if (Lex.getCode() != tgtok::l_paren) {
       TokError("expected '(' after binary operator");
       return nullptr;
     }
     Lex.Lex();  // eat the '('
case tgtok::XConcat: {  // Value ::= !binop '(' Value ',' Value ')'
     }
 
     if (Lex.getCode() != tgtok::r_paren) {
       TokError("expected ')' in operator");
       return nullptr;
     }
     Lex.Lex();  // eat the ')'
 
-    // If we are doing !listconcat, we should know the type by now
-    if (OpTok == tgtok::XListConcat) {
-      if (VarInit *Arg0 = dyn_cast<VarInit>(InitList[0]))
-        Type = Arg0->getType();
-      else if (ListInit *Arg0 = dyn_cast<ListInit>(InitList[0]))
-        Type = Arg0->getType();
+    // If we are doing !concat, we should know the type by now
+    if (OpTok == tgtok::XConcat) {
+      if (TypedInit *TI = dyn_cast<TypedInit>(InitList[0]))
+        Type = TI->getType();
       else {
         InitList[0]->print(errs());
-        Error(OpLoc, "expected a list");
+        Error(OpLoc, "expected a typed expression.");
         return nullptr;
       }
     }
 
-    // We allow multiple operands to associative operators like !strconcat as
+    // We allow multiple operands to associative operators like !concat as
     // shorthand for nesting them.
-    if (Code == BinOpInit::STRCONCAT || Code == BinOpInit::LISTCONCAT) {
+    if (Code == BinOpInit::CONCAT) {
       while (InitList.size() > 2) {
         Init *RHS = InitList.pop_back_val();
         RHS = (BinOpInit::get(Code, InitList.back(), RHS, Type))
                            ->Fold(CurRec, CurMultiClass);
         InitList.back() = RHS;
       }
     }
 

 ///   SimpleValue ::= ID '<' ValueListNE '>'
 ///   SimpleValue ::= '[' ValueList ']'
 ///   SimpleValue ::= '(' IDValue DagArgList ')'
 ///   SimpleValue ::= CONCATTOK '(' Value ',' Value ')'
 ///   SimpleValue ::= ADDTOK '(' Value ',' Value ')'
 ///   SimpleValue ::= SHLTOK '(' Value ',' Value ')'
 ///   SimpleValue ::= SRATOK '(' Value ',' Value ')'
 ///   SimpleValue ::= SRLTOK '(' Value ',' Value ')'
-///   SimpleValue ::= LISTCONCATTOK '(' Value ',' Value ')'
-///   SimpleValue ::= STRCONCATTOK '(' Value ',' Value ')'
 ///
 Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType,
                                  IDParseMode Mode) {
   Init *R = nullptr;
   switch (Lex.getCode()) {
   default: TokError("Unknown token when parsing a value"); break;
   case tgtok::paste:
     // This is a leading paste operation.  This is deprecated but
if (!CurMultiClass) {
       // Copy the template arguments for the multiclass into the def.
       for (Init *TArg : CurMultiClass->Rec.getTemplateArgs()) {
         const RecordVal *RV = CurMultiClass->Rec.getValue(TArg);
         assert(RV && "Template arg doesn't exist?");
         NewRec->addValue(*RV);
       }
 
       // We can't return the prototype def here, instead return:
-      // !cast<ItemType>(!strconcat(NAME, AnonName)).
+      // !cast<ItemType>(!concat(NAME, AnonName)).
       const RecordVal *MCNameRV = CurMultiClass->Rec.getValue("NAME");
       assert(MCNameRV && "multiclass record must have a NAME");
 
       return UnOpInit::get(UnOpInit::CAST,
-                           BinOpInit::get(BinOpInit::STRCONCAT,
+                           BinOpInit::get(BinOpInit::CONCAT,
                                           VarInit::get(MCNameRV->getName(),
                                                        MCNameRV->getType()),
                                           NewRec->getNameInit(),
                                           StringRecTy::get()),
                            Class->getDefInit()->getType());
     }
 
     // The result of the expression is a reference to the new record.
case tgtok::l_paren: {         // Value ::= '(' IDValue DagArgList ')'
 
     return DagInit::get(Operator, OperatorName, DagArgs);
   }
 
   case tgtok::XHead:
   case tgtok::XTail:
   case tgtok::XEmpty:
   case tgtok::XCast:  // Value ::= !unop '(' Value ')'
-  case tgtok::XConcat:
+  case tgtok::XCon:
   case tgtok::XADD:
   case tgtok::XAND:
   case tgtok::XOR:
   case tgtok::XSRA:
   case tgtok::XSRL:
   case tgtok::XSHL:
   case tgtok::XEq:
-  case tgtok::XListConcat:
-  case tgtok::XStrConcat:   // Value ::= !binop '(' Value ',' Value ')'
+  case tgtok::XConcat:      // Value ::= !binop '(' Value ',' Value ')'
   case tgtok::XIf:
   case tgtok::XForEach:
   case tgtok::XSubst: {  // Value ::= !ternop '(' Value ',' Value ',' Value ')'
     return ParseOperation(CurRec, ItemType);
   }
   }
 
   return R;
case tgtok::period: {
       Result = FieldInit::get(Result, FieldName);
       Lex.Lex();  // eat field name
       break;
     }
 
     case tgtok::paste:
       SMLoc PasteLoc = Lex.getLoc();
 
-      // Create a !strconcat() operation, first casting each operand to
+      // Create a !concat() operation, first casting each operand to
       // a string if necessary.
 
       TypedInit *LHS = dyn_cast<TypedInit>(Result);
       if (!LHS) {
         Error(PasteLoc, "LHS of paste is not typed!");
         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,
+      Result = BinOpInit::get(BinOpInit::CONCAT, LHS, RHS,
                               StringRecTy::get())->Fold(CurRec, CurMultiClass);
       break;
     }
   }
 }
 
 /// ParseDagArgList - Parse the argument list for a dag literal expression.
 ///
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,
+      BinOpInit::get(BinOpInit::CONCAT,
                      UnOpInit::get(UnOpInit::CAST, DefmPrefix,
                                    StringRecTy::get())->Fold(DefProto, &MC),
                      DefName, StringRecTy::get())->Fold(DefProto, &MC);
   }
 
   // Make a trail of SMLocs from the multiclass instantiations.
   SmallVector<SMLoc, 4> Locs(1, DefmPrefixRange.Start);
   Locs.append(DefProto->getLoc().begin(), DefProto->getLoc().end());

test/TableGen/listconcat.td

 // RUN: llvm-tblgen %s | FileCheck %s
 
 // CHECK: class Y<list<string> Y:S = ?> {
-// CHECK:   list<string> T1 = !listconcat(Y:S, ["foo"]);
-// CHECK:   list<string> T2 = !listconcat(Y:S, !listconcat(["foo"], !listconcat(Y:S, ["bar", "baz"])));
+// CHECK:   list<string> T1 = !concat(Y:S, ["foo"]);
+// CHECK:   list<string> T2 = !concat(Y:S, !concat(["foo"], !concat(Y:S, ["bar", "baz"])));
 // CHECK: }
 
 // CHECK: def Z {
 // CHECK:   list<string> T1 = ["fu", "foo"];
 // CHECK:   list<string> T2 = ["fu", "foo", "fu", "bar", "baz"];
 // CHECK: }
 
 class Y<list<string> S> {
   list<string> T1 = !listconcat(S, ["foo"]);
   list<string> T2 = !listconcat(S, ["foo"], S, ["bar", "baz"]);
 }
 
 def Z : Y<["fu"]>;

test/TableGen/strconcat.td

 // RUN: llvm-tblgen %s | FileCheck %s
 
-// CHECK: class Y<string Y:S = ?> {
-// CHECK:   string T = !strconcat(Y:S, "foo");
-// CHECK:   string T2 = !strconcat(Y:S, !strconcat("foo", !strconcat(Y:S, "bar")));
+// CHECK: class Y<string Y:S = ?, code Y:C = ?> {
+// CHECK:   string T = !concat(Y:S, "foo");
+// CHECK:   string T2 = !concat(Y:S, !concat("foo", !concat(Y:S, "bar")));
 // CHECK:   string S = "foobar";
+// CHECK:   code T3 = !concat(Y:C, [{ ; }]);
 // CHECK: }
 
 // CHECK: def Z {
 // CHECK:   string T = "fufoo";
 // CHECK:   string T2 = "fufoofubar";
 // CHECK:   string S = "foobar";
+// CHECK:   code T3 = [{ 1 ; }];
 // CHECK: }
 
-class Y<string S> {
+class Y<string S, code C> {
   string T = !strconcat(S, "foo");
   // More than two arguments is equivalent to nested calls
   string T2 = !strconcat(S, "foo", S, "bar");
 
   // String values concatenate lexically, as in C.
   string S = "foo" "bar";
+
+  code T3 = !strconcat(C, [{ ; }]);
 }
 
-def Z : Y<"fu">;
+def Z : Y<"fu", [{ 1 }]>;