TableGen: Allow lists to be concatenated through '#'

Currently one can concatenate strings using hash(#),
but not lists, although that would be a natural thing to do.

This patch allows one to write something like:
def : A<!listconcat([1,2], [3,4])>;
simply as :
def : A<[1,2] # [3,4]>;

This was missing feature was highlighted by Nicolai
at FOSDEM talk.

Reviewed by: nhaehnle, hfinkel

Differential Revision: https://reviews.llvm.org/D58895

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@355414 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/TableGen/Record.h b/include/llvm/TableGen/Record.h
index 2cb0548a4cab83be1c9010e57e5653e7dbd64efc..17b63ec87e9068ea677be08c5043506ef53b9f88 100644 (file)
--- a/include/llvm/TableGen/Record.h
+++ b/include/llvm/TableGen/Record.h
@@ -820,6 +820,7 @@ public:
   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;
 

diff --git a/lib/TableGen/Record.cpp b/lib/TableGen/Record.cpp
index 480a002b64af9f3d9034a1f499dfe4f3857f39c2..4222a0b57fb86125d2085002140000f404d6865f 100644 (file)
--- a/lib/TableGen/Record.cpp
+++ b/lib/TableGen/Record.cpp
@@ -856,6 +856,24 @@ Init *BinOpInit::getStrConcat(Init *I0, Init *I1) {
   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: {

diff --git a/lib/TableGen/TGParser.cpp b/lib/TableGen/TGParser.cpp
index 58343bda27593e7e3a9cf03fb92dd980571d2e40..90c9b390e103f281c8416326cd82feb1e69a6a0f 100644 (file)
--- a/lib/TableGen/TGParser.cpp
+++ b/lib/TableGen/TGParser.cpp
@@ -2119,16 +2119,31 @@ Init *TGParser::ParseValue(Record *CurRec, RecTy *ItemType, IDParseMode Mode) {
 
     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())

diff --git a/test/TableGen/listpaste.td b/test/TableGen/listpaste.td
new file mode 100644 (file)
index 0000000..3ce761d
--- /dev/null
+++ b/test/TableGen/listpaste.td
@@ -0,0 +1,40 @@
+// 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] # []>;