[TableGen] Allow lists to be concatenated through '#'

[javedabsar]

Summary

Currently one can concatenate strings using hash(#), but not lists, although that would be a natural thing to do.
This was highlighted by Nicolai at a FOSDEM talk as well.
This patch allows one to write something like:

def : A<!listconcat([1,2], [3,4])>;

simply as :

def : A<[1,2] # [3,4]>;

[hfinkel]

lib/TableGen/TGParser.cpp

2124 ↗

(On Diff #189126)

Does this change any current behavior? (i.e., if you try this now, does it cast each list to a string, or does it give an error, or something else?

[nhaehnle]

Awesome :)
LGTM

lib/TableGen/TGParser.cpp

2124 ↗

(On Diff #189126)

$ llvm-tblgen
def A {
  list<int> x = [4] # [5];
}
^D
<stdin>:2:17: error: Value 'x' of type 'list<int>' is incompatible with initializer '!strconcat(!cast<string>([4]), !cast<string>([5]))' of type 'string'
  list<int> x = [4] # [5];

The error isn't exactly user-friendly. If you try to make x a string it doesn't work either:

$ llvm-tblgen
def A {
  string x = [4] # [5];
}
^D
<stdin>:2:15: error: Type mismatch for list, expected list type, got string
  string x = [4] # [5];
              ^
<stdin>:2:15: error: expected ';' after declaration
  string x = [4] # [5];

Those errors seem even more confusing and I'm not sure where they're from, but the underlying point is that you cannot cast a list to a string:

$ llvm-tblgen
def A {
  string x = !cast<string>([4]);
}
^D
<stdin>:1:1: error: Initializer of 'x' in 'A' could not be fully resolved: !cast<string>([4])
def A {
^

[hfinkel]

In D58895#1418111, @nhaehnle wrote:

Awesome :)
LGTM

Thanks, LGTM too.

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

public:
 
   static bool classof(const Init *I) {
     return I->getKind() == IK_BinOpInit;
   }
 
   static BinOpInit *get(BinaryOp opc, Init *lhs, Init *rhs,
                         RecTy *Type);
   static Init *getStrConcat(Init *lhs, Init *rhs);
+  static Init *getListConcat(TypedInit *lhs, Init *rhs);
 
   void Profile(FoldingSetNodeID &ID) const;
 
   // Clone - Clone this operator, replacing arguments with the new list
   OpInit *clone(ArrayRef<Init *> Operands) const override {
     assert(Operands.size() == 2 &&
            "Wrong number of operands for binary operation");
     return BinOpInit::get(getOpcode(), Operands[0], Operands[1], getType());

llvm/trunk/lib/TableGen/Record.cpp

 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());
 }
 
+static ListInit *ConcatListInits(const ListInit *LHS,
+                                 const ListInit *RHS) {
+  SmallVector<Init *, 8> Args;
+  Args.insert(Args.end(), LHS->begin(), LHS->end());
+  Args.insert(Args.end(), RHS->begin(), RHS->end());
+  return ListInit::get(Args, LHS->getElementType());
+}
+
+Init *BinOpInit::getListConcat(TypedInit *LHS, Init *RHS) {
+  assert(isa<ListRecTy>(LHS->getType()) && "First arg must be a list");
+
+  // Shortcut for the common case of concatenating two lists.
+   if (const ListInit *LHSList = dyn_cast<ListInit>(LHS))
+     if (const ListInit *RHSList = dyn_cast<ListInit>(RHS))
+       return ConcatListInits(LHSList, RHSList);
+   return BinOpInit::get(BinOpInit::LISTCONCAT, LHS, RHS, LHS->getType());
+}
+
 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());

llvm/trunk/lib/TableGen/TGParser.cpp

case tgtok::period: {
       }
       Result = FieldInit::get(Result, FieldName)->Fold(CurRec);
       Lex.Lex();  // eat field name
       break;
     }
 
     case tgtok::paste:
       SMLoc PasteLoc = Lex.getLoc();
-
-      // Create a !strconcat() 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;
       }
 
+      // Check if it's a 'listA # listB'
+      if (isa<ListRecTy>(LHS->getType())) {
+        Lex.Lex();  // Eat the '#'.
+
+        switch (Lex.getCode()) {
+        case tgtok::colon:
+        case tgtok::semi:
+        case tgtok::l_brace:
+          Result = LHS; // trailing paste, ignore.
+          break;
+        default:
+          Init *RHSResult = ParseValue(CurRec, ItemType, ParseNameMode);
+          Result = BinOpInit::getListConcat(LHS, RHSResult);
+        }
+        break;
+      }
+
+      // Create a !strconcat() operation, first casting each operand to
+      // a string if necessary.
       if (LHS->getType() != StringRecTy::get()) {
         LHS = dyn_cast<TypedInit>(
             UnOpInit::get(UnOpInit::CAST, LHS, StringRecTy::get())
                 ->Fold(CurRec));
         if (!LHS) {
           Error(PasteLoc, Twine("can't cast '") + LHS->getAsString() +
                               "' to string");
           return nullptr;

llvm/trunk/test/TableGen/listpaste.td

+// RUN: llvm-tblgen %s | FileCheck %s
+
+// CHECK: class A<bit A:x = ?> {
+// CHECK: list<int> lst = !listconcat([], !if(A:x, [], [4]));
+// CHECK: }
+class A<bit x> {
+  list<int> lst = []  # !if(x, [], [4]);
+}
+
+// CHECK: class A1<list<int> A1:l = ?> {
+// CHECK:   list<int> A1List = A1:l;
+// CHECK: }
+class A1<list<int> l> {
+  list<int> A1List = l;
+}
+
+// CHECK: def A0 {
+// CHECK:   list<int> lst = [4];
+// CHECK: }
+def A0 : A<0>;
+
+// CHECK: def A1 {
+// CHECK:   list<int> lst = [];
+// CHECK: }
+def A1 : A<1>;
+
+// CHECK: def A1_0 {
+// CHECK:   list<int> A1List = [1, 2, 3, 4];
+// CHECK: }
+def A1_0 : A1<[1,2] # [3,4]>;
+
+// CHECK: def A1_1 {
+// CHECK:   list<int> A1List = [1, 2];
+// CHECK: }
+def A1_1 : A1<[] # [1,2]>;
+
+// CHECK: def A1_2 {      // A1
+// CHECK:   list<int> A1List = [1, 2];
+// CHECK: }
+def A1_2 : A1<[1,2] # []>;