[TableGen] Introduce !listsplat 'binary' operator

[lebedev.ri]

Summary

``!listsplat(a, size)``
    A list value that contains the value ``a`` ``size`` times.
    Example: ``!listsplat(0, 2)`` results in ``[0, 0]``.

The X86ScheduleBdVer2.td change highlights the use-case.

This is a little bit controversial because unlike every other binary operator
the types aren't identical.

[craig.topper]

Not objecting to this feature. Just asking a question.

lib/Target/X86/X86ScheduleBdVer2.td

214

Doesn’t WriteRes already treat an empty list as 1 cycle per port?

[lebedev.ri]

lib/Target/X86/X86ScheduleBdVer2.td

214

The problem is that you can't concatenate an empty list (implied all-ones) with non-empty list here.
The result will be the non-empty list, and it won't match the length of the ExePorts list.

[lebedev.ri]

Streamline

[lebedev.ri]

lib/Target/X86/X86ScheduleBdVer2.td

214

Or, to actually answer your question, the problems begin when LoadRes != 1 here,
which is the case in PdWriteResYMMPair, and more importantly i think it will be the case for PdWriteResExPair

[craig.topper]

I wonder if !listfill might be a better name? I feel like splat has a meaning to those of us who have worked on vectors within LLVM IR, but may not be meaningful right away to other people?

lib/Target/X86/X86ScheduleBdVer2.td

214

Ok that makes sense.

[lebedev.ri]

In D60367#1457471, @craig.topper wrote:

I wonder if !listfill might be a better name? I feel like splat has a meaning to those of us who have worked on vectors within LLVM IR, but may not be meaningful right away to other people?

Normally std::fill() sets all the specified elements to the specified value.
To me, this isn't the case here, while we do fill the list, we don't 'fill the list', since we don't get any list..
That is at least how i see this. I totall can change it if other reviewers also agree that it would be better.

[javed.absar]

Thanks for this. Its good you show a use-case but probably the use case can be a separate commit.

lib/TableGen/TGParser.cpp

1154

'output type' ? Would that be a bit confusing to user. I can't think of a better option though since the context (assignment?) won't be known.

[lebedev.ri]

In D60367#1460454, @javed.absar wrote:

Thanks for this. Its good you show a use-case but probably the use case can be a separate commit.

I absolutely can split that up during commit.

lib/TableGen/TGParser.cpp

1154

IIRC this is checking for

class X<int a, int b> {
  str x = !listsplat(a, b);
}
def DX00 : X<0, 0>;

We know the type !listsplat is supposed to return since we know the LHS of the assignment.
I'm not sure how to spell this out best.

[lebedev.ri]

In D60367#1460454, @javed.absar wrote:

Thanks for this.

Thank you for looking at this!

[lebedev.ri]

Alright, thank you for the review!

docs/TableGen/LangIntro.rst

``!dag(op, children, names)``
     (op a1:$name1, a2:$name2, ?:$name3).
 
 ``!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.
 
+``!listsplat(a, size)``
+    A list value that contains the value ``a`` ``size`` times.
+    Example: ``!listsplat(0, 2)`` results in ``[0, 0]``.
+
 ``!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.
 
 ``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

docs/TableGen/LangRef.rst

 
 .. productionlist::
    BangOperator: one of
                :!eq     !if      !head    !tail      !con
                :!add    !shl     !sra     !srl       !and
                :!or     !empty   !subst   !foreach   !strconcat
                :!cast   !listconcat       !size      !foldl
                :!isa    !dag     !le      !lt        !ge
-               :!gt     !ne      !mul
+               :!gt     !ne      !mul     !listsplat
 
 TableGen also has !cond operator that needs a slightly different
 syntax compared to other "bang operators":
 
 .. productionlist::
    CondOperator: !cond
 
 

include/llvm/TableGen/Record.h

public:
 
   std::string getAsString() const override;
 };
 
 /// !op (X, Y) - Combine two inits.
 class BinOpInit : public OpInit, public FoldingSetNode {
 public:
   enum BinaryOp : uint8_t { ADD, MUL, AND, OR, SHL, SRA, SRL, LISTCONCAT,
-                            STRCONCAT, CONCAT, EQ, NE, LE, LT, GE, GT };
+                            LISTSPLAT, STRCONCAT, CONCAT, EQ, NE, LE, LT, GE,
+                            GT };
 
 private:
   Init *LHS, *RHS;
 
   BinOpInit(BinaryOp opc, Init *lhs, Init *rhs, RecTy *Type) :
       OpInit(IK_BinOpInit, Type, opc), LHS(lhs), RHS(rhs) {}
 
 public:
   BinOpInit(const BinOpInit &) = delete;
   BinOpInit &operator=(const BinOpInit &) = delete;
 
   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);
+  static Init *getListSplat(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());

lib/TableGen/Record.cpp

Init *BinOpInit::getListConcat(TypedInit *LHS, Init *RHS) {
 
   // 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::getListSplat(TypedInit *LHS, Init *RHS) {
+  return BinOpInit::get(BinOpInit::LISTSPLAT, 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());
case LISTCONCAT: {
     if (LHSs && RHSs) {
       SmallVector<Init *, 8> Args;
       Args.insert(Args.end(), LHSs->begin(), LHSs->end());
       Args.insert(Args.end(), RHSs->begin(), RHSs->end());
       return ListInit::get(Args, LHSs->getElementType());
     }
     break;
   }
+  case LISTSPLAT: {
+    TypedInit *Value = dyn_cast<TypedInit>(LHS);
+    IntInit *Size = dyn_cast<IntInit>(RHS);
+    if (Value && Size) {
+      SmallVector<Init *, 8> Args(Size->getValue(), Value);
+      return ListInit::get(Args, Value->getType());
+    }
+    break;
+  }
   case STRCONCAT: {
     StringInit *LHSs = dyn_cast<StringInit>(LHS);
     StringInit *RHSs = dyn_cast<StringInit>(RHS);
     if (LHSs && RHSs)
       return ConcatStringInits(LHSs, RHSs);
     break;
   }
   case EQ:
std::string BinOpInit::getAsString() const {
   case SRL: Result = "!srl"; break;
   case EQ: Result = "!eq"; break;
   case NE: Result = "!ne"; break;
   case LE: Result = "!le"; break;
   case LT: Result = "!lt"; break;
   case GE: Result = "!ge"; break;
   case GT: Result = "!gt"; break;
   case LISTCONCAT: Result = "!listconcat"; break;
+  case LISTSPLAT: Result = "!listsplat"; break;
   case STRCONCAT: Result = "!strconcat"; break;
   }
   return Result + "(" + LHS->getAsString() + ", " + RHS->getAsString() + ")";
 }
 
 static void
 ProfileTernOpInit(FoldingSetNodeID &ID, unsigned Opcode, Init *LHS, Init *MHS,
                   Init *RHS, RecTy *Type) {

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, Defset,
 
     // !keywords.
-    XConcat, XADD, XMUL, XAND, XOR, XSRA, XSRL, XSHL, XListConcat, XStrConcat,
-    XCast, XSubst, XForEach, XFoldl, XHead, XTail, XSize, XEmpty, XIf, XCond,
-    XEq, XIsA, XDag, XNe, XLe, XLt, XGe, XGt,
+    XConcat, XADD, XMUL, XAND, XOR, XSRA, XSRL, XSHL, XListConcat, XListSplat,
+    XStrConcat, XCast, XSubst, XForEach, XFoldl, XHead, XTail, XSize, XEmpty,
+    XIf, XCond, XEq, XIsA, XDag, XNe, XLe, XLt, XGe, XGt,
 
     // Integer value.
     IntVal,
 
     // Binary constant.  Note that these are sized according to the number of
     // bits given.
     BinaryIntVal,
 

lib/TableGen/TGLexer.cpp

tgtok::TokKind Kind =
     .Case("sra", tgtok::XSRA)
     .Case("srl", tgtok::XSRL)
     .Case("cast", tgtok::XCast)
     .Case("empty", tgtok::XEmpty)
     .Case("subst", tgtok::XSubst)
     .Case("foldl", tgtok::XFoldl)
     .Case("foreach", tgtok::XForEach)
     .Case("listconcat", tgtok::XListConcat)
+    .Case("listsplat", tgtok::XListSplat)
     .Case("strconcat", tgtok::XStrConcat)
     .Default(tgtok::Error);
 
   return Kind != tgtok::Error ? Kind : ReturnError(Start-1, "Unknown operator");
 }
 
 bool TGLexer::prepExitInclude(bool IncludeStackMustBeEmpty) {
   // Report an error, if preprocessor control stack for the current

lib/TableGen/TGParser.cpp

Init *TGParser::ParseOperation(Record *CurRec, RecTy *ItemType) {
   case tgtok::XSHL:
   case tgtok::XEq:
   case tgtok::XNe:
   case tgtok::XLe:
   case tgtok::XLt:
   case tgtok::XGe:
   case tgtok::XGt:
   case tgtok::XListConcat:
+  case tgtok::XListSplat:
   case tgtok::XStrConcat: {  // Value ::= !binop '(' Value ',' Value ')'
     tgtok::TokKind OpTok = Lex.getCode();
     SMLoc OpLoc = Lex.getLoc();
     Lex.Lex();  // eat the operation
 
     BinOpInit::BinaryOp Code;
     switch (OpTok) {
     default: llvm_unreachable("Unhandled code!");
     case tgtok::XConcat: Code = BinOpInit::CONCAT; break;
     case tgtok::XADD:    Code = BinOpInit::ADD; break;
     case tgtok::XMUL:    Code = BinOpInit::MUL; break;
     case tgtok::XAND:    Code = BinOpInit::AND; break;
     case tgtok::XOR:     Code = BinOpInit::OR; break;
     case tgtok::XSRA:    Code = BinOpInit::SRA; break;
     case tgtok::XSRL:    Code = BinOpInit::SRL; break;
     case tgtok::XSHL:    Code = BinOpInit::SHL; break;
     case tgtok::XEq:     Code = BinOpInit::EQ; break;
     case tgtok::XNe:     Code = BinOpInit::NE; break;
     case tgtok::XLe:     Code = BinOpInit::LE; break;
     case tgtok::XLt:     Code = BinOpInit::LT; break;
     case tgtok::XGe:     Code = BinOpInit::GE; break;
     case tgtok::XGt:     Code = BinOpInit::GT; break;
     case tgtok::XListConcat: Code = BinOpInit::LISTCONCAT; break;
+    case tgtok::XListSplat: Code = BinOpInit::LISTSPLAT; break;
     case tgtok::XStrConcat: Code = BinOpInit::STRCONCAT; break;
     }
 
     RecTy *Type = nullptr;
     RecTy *ArgType = nullptr;
     switch (OpTok) {
     default:
       llvm_unreachable("Unhandled code!");
case tgtok::XStrConcat: {  // Value ::= !binop '(' Value ',' Value ')'
     case tgtok::XGt:
       Type = BitRecTy::get();
       ArgType = IntRecTy::get();
       break;
     case tgtok::XListConcat:
       // We don't know the list type until we parse the first argument
       ArgType = ItemType;
       break;
+    case tgtok::XListSplat:
+      // Can't do any typechecking until we parse the first argument.
+      break;
     case tgtok::XStrConcat:
       Type = StringRecTy::get();
       ArgType = StringRecTy::get();
       break;
     }
 
     if (Type && ItemType && !Type->typeIsConvertibleTo(ItemType)) {
       Error(OpLoc, Twine("expected value of type '") +
for (;;) {
         switch (Code) {
         case BinOpInit::LISTCONCAT:
           if (!isa<ListRecTy>(ArgType)) {
             Error(InitLoc, Twine("expected a list, got value of type '") +
                            ArgType->getAsString() + "'");
             return nullptr;
           }
           break;
+        case BinOpInit::LISTSPLAT:
+          if (ItemType && InitList.size() == 1) {
+            if (!isa<ListRecTy>(ItemType)) {
+              Error(OpLoc,
+                    Twine("expected output type to be a list, got type '") +
+                        ItemType->getAsString() + "'");
+              return nullptr;
+            }
+            if (!ArgType->getListTy()->typeIsConvertibleTo(ItemType)) {
+              Error(OpLoc, Twine("expected first arg type to be '") +
+                               ArgType->getAsString() +
+                               "', got value of type '" +
+                               cast<ListRecTy>(ItemType)
+                                   ->getElementType()
+                                   ->getAsString() +
+                               "'");
+              return nullptr;
+            }
+          }
+          if (InitList.size() == 2 && !isa<IntRecTy>(ArgType)) {
+            Error(InitLoc, Twine("expected second parameter to be an int, got "
+                                 "value of type '") +
+                               ArgType->getAsString() + "'");
+            return nullptr;
+          }
+          ArgType = nullptr; // Broken invariant: types not identical.
+          break;
         case BinOpInit::EQ:
         case BinOpInit::NE:
           if (!ArgType->typeIsConvertibleTo(IntRecTy::get()) &&
               !ArgType->typeIsConvertibleTo(StringRecTy::get())) {
             Error(InitLoc, Twine("expected int, bits, or string; got value of "
                                  "type '") + ArgType->getAsString() + "'");
             return nullptr;
           }
case tgtok::XStrConcat: {  // Value ::= !binop '(' Value ',' Value ')'
     }
 
     if (Lex.getCode() != tgtok::r_paren) {
       TokError("expected ')' in operator");
       return nullptr;
     }
     Lex.Lex();  // eat the ')'
 
+    // listconcat returns a list with type of the argument.
     if (Code == BinOpInit::LISTCONCAT)
       Type = ArgType;
+    // listsplat returns a list of type of the *first* argument.
+    if (Code == BinOpInit::LISTSPLAT)
+      Type = cast<TypedInit>(InitList.front())->getType()->getListTy();
 
     // 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 ||
         Code == BinOpInit::MUL) {
       while (InitList.size() > 2) {

 ///   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 ::= LISTSPLATTOK '(' Value ',' Value ')'
 ///   SimpleValue ::= STRCONCATTOK '(' Value ',' Value ')'
 ///   SimpleValue ::= COND '(' [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;
Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType,
   case tgtok::XSHL:
   case tgtok::XEq:
   case tgtok::XNe:
   case tgtok::XLe:
   case tgtok::XLt:
   case tgtok::XGe:
   case tgtok::XGt:
   case tgtok::XListConcat:
+  case tgtok::XListSplat:
   case tgtok::XStrConcat:   // Value ::= !binop '(' Value ',' Value ')'
   case tgtok::XIf:
   case tgtok::XCond:
   case tgtok::XFoldl:
   case tgtok::XForEach:
   case tgtok::XSubst: {  // Value ::= !ternop '(' Value ',' Value ',' Value ')'
     return ParseOperation(CurRec, ItemType);
   }

lib/Target/X86/X86ScheduleBdVer2.td

multiclass __pdWriteResPair<X86FoldableSchedWrite SchedRW,
                             int LoadLat, int LoadRes, int LoadUOps> {
   defm : PdWriteRes<SchedRW, ExePorts, Lat, Res, UOps>;
 
   defm : PdWriteRes<SchedRW.Folded,
                     !listconcat([PdLoad], ExePorts),
                     !add(Lat, LoadLat),
                     !if(!and(!empty(Res), !eq(LoadRes, 1)),
                       [],
-                      !listconcat([LoadRes], Res)),
+                      !listconcat([LoadRes],
+                        !if(!empty(Res),
+                          !listsplat(1, !size(ExePorts)),
+                          Res))),
                     !add(UOps, LoadUOps)>;
 }
 
 multiclass PdWriteResExPair<X86FoldableSchedWrite SchedRW,
                             list<ProcResourceKind> ExePorts, int Lat = 1,
                             list<int> Res = [], int UOps = 1,
                             int LoadUOps = 0> {
   defm : __pdWriteResPair<SchedRW, ExePorts, Lat, Res, UOps,
                           /*LoadLat*/4, /*LoadRes*/1, LoadUOps>;
 }
 
 multiclass PdWriteResXMMPair<X86FoldableSchedWrite SchedRW,
                              list<ProcResourceKind> ExePorts, int Lat = 1,
                              list<int> Res = [], int UOps = 1,
                              int LoadUOps = 0> {
   defm : __pdWriteResPair<SchedRW, ExePorts, Lat, Res, UOps,
                            /*LoadLat*/5, /*LoadRes*/1, LoadUOps>;
 }
 
 multiclass PdWriteResYMMPair<X86FoldableSchedWrite SchedRW,
                              list<ProcResourceKind> ExePorts, int Lat,
-                             list<int> Res, int UOps = 2,
+                             list<int> Res = [], int UOps = 2,
                              int LoadUOps = 0> {
   defm : __pdWriteResPair<SchedRW, ExePorts, Lat, Res, UOps,
                            /*LoadLat*/5, /*LoadRes*/2, LoadUOps>;
 }
 
 //===----------------------------------------------------------------------===//
 // Here be dragons.
 //===----------------------------------------------------------------------===//

 
 defm : PdWriteResXMMPair<WriteFMul64,       [PdFPU1, PdFPFMA],  5>;
 defm : PdWriteResXMMPair<WriteFMul64X,      [PdFPU1, PdFPFMA],  5>;
 defm : PdWriteResYMMPair<WriteFMul64Y,      [PdFPU1, PdFPFMA],  5, [2, 1]>;
 defm : X86WriteResPairUnsupported<WriteFMul64Z>;
 
 defm : PdWriteResXMMPair<WriteFMA,          [PdFPU, PdFPFMA], 5>;
 defm : PdWriteResXMMPair<WriteFMAX,         [PdFPU, PdFPFMA], 5>;
-defm : PdWriteResYMMPair<WriteFMAY,         [PdFPU, PdFPFMA], 5,   [1, 1]>;
+defm : PdWriteResYMMPair<WriteFMAY,         [PdFPU, PdFPFMA], 5>;
 defm : X86WriteResPairUnsupported<WriteFMAZ>;
 
 
 defm : PdWriteResXMMPair<WriteDPPD,         [PdFPU1, PdFPFMA], 15, [1, 3],  15, 2>;
 
 defm : PdWriteResXMMPair<WriteDPPS,         [PdFPU1, PdFPFMA], 25, [1, 3],  16, 2>;
 defm : PdWriteResYMMPair<WriteDPPSY,        [PdFPU1, PdFPFMA], 27, [2, 6], /*or 29*/ 25, 4>;
 defm : X86WriteResPairUnsupported<WriteDPPSZ>;

 defm : PdWriteResXMMPair<WritePSADBWX,       [PdFPU01, PdFPMAL], 4, [], 2>;
 defm : X86WriteResPairUnsupported<WritePSADBWY>;
 defm : X86WriteResPairUnsupported<WritePSADBWZ>;
 
 defm : PdWriteResXMMPair<WritePHMINPOS,      [PdFPU0,  PdFPMAL], 4, [], 2>;
 
 defm : PdWriteResXMMPair<WriteShuffle,       [PdFPU01, PdFPMAL], 2>;
 defm : PdWriteResXMMPair<WriteShuffleX,      [PdFPU01, PdFPMAL], 2>;
-defm : PdWriteResYMMPair<WriteShuffleY,      [PdFPU01, PdFPMAL], 2,   [1, 1]>;
+defm : PdWriteResYMMPair<WriteShuffleY,      [PdFPU01, PdFPMAL], 2>;
 defm : X86WriteResPairUnsupported<WriteShuffleZ>;
 
 defm : PdWriteResXMMPair<WriteVarShuffle,    [PdFPU01, PdFPMAL], 3, [1, 4]>;
 defm : PdWriteResXMMPair<WriteVarShuffleX,   [PdFPU01, PdFPMAL], 3, [1, 4]>;
 defm : X86WriteResPairUnsupported<WriteVarShuffleY>;
 defm : X86WriteResPairUnsupported<WriteVarShuffleZ>;
 
 def PdWriteVPPERM : SchedWriteRes<[PdFPU01, PdFPMAL]> {

test/TableGen/listsplat.td

+// RUN: llvm-tblgen %s | FileCheck %s
+
+// CHECK: ------------- Classes -----------------
+// CHECK-NEXT: class X<int X:a = ?, int X:b = ?> {
+// CHECK-NEXT:   list<int> x = !listsplat(X:a, X:b);
+// CHECK-NEXT: }
+// CHECK-NEXT: class Y<string Y:a = ?, int Y:b = ?> {
+// CHECK-NEXT:   list<string> x = !listsplat(Y:a, Y:b);
+// CHECK-NEXT: }
+// CHECK-NEXT: ------------- Defs -----------------
+// CHECK-NEXT: def DX00 {      // X
+// CHECK-NEXT:   list<int> x = [];
+// CHECK-NEXT: }
+// CHECK-NEXT: def DX01 {      // X
+// CHECK-NEXT:   list<int> x = [0];
+// CHECK-NEXT: }
+// CHECK-NEXT: def DX02 {      // X
+// CHECK-NEXT:   list<int> x = [0, 0];
+// CHECK-NEXT: }
+// CHECK-NEXT: def DX10 {      // X
+// CHECK-NEXT:   list<int> x = [];
+// CHECK-NEXT: }
+// CHECK-NEXT: def DX11 {      // X
+// CHECK-NEXT:   list<int> x = [1];
+// CHECK-NEXT: }
+// CHECK-NEXT: def DX12 {      // X
+// CHECK-NEXT:   list<int> x = [1, 1];
+// CHECK-NEXT: }
+// CHECK-NEXT: def DYa0 {      // Y
+// CHECK-NEXT:   list<string> x = [];
+// CHECK-NEXT: }
+// CHECK-NEXT: def DYa1 {      // Y
+// CHECK-NEXT:   list<string> x = ["a"];
+// CHECK-NEXT: }
+// CHECK-NEXT: def DYa2 {      // Y
+// CHECK-NEXT:   list<string> x = ["a", "a"];
+// CHECK-NEXT: }
+// CHECK-NEXT: def DYe0 {      // Y
+// CHECK-NEXT:   list<string> x = [];
+// CHECK-NEXT: }
+// CHECK-NEXT: def DYe1 {      // Y
+// CHECK-NEXT:   list<string> x = [""];
+// CHECK-NEXT: }
+// CHECK-NEXT: def DYe2 {      // Y
+// CHECK-NEXT:   list<string> x = ["", ""];
+// CHECK-NEXT: }
+// CHECK-NEXT: def DZ {        // X
+// CHECK-NEXT:   list<int> x = [42, 42, 42];
+// CHECK-NEXT: }
+
+class X<int a, int b> {
+  list<int> x = !listsplat(a, b);
+}
+
+class Y<string a, int b> {
+  list<string> x = !listsplat(a, b);
+}
+
+def DX00 : X<0, 0>;
+def DX01 : X<0, 1>;
+def DX02 : X<0, 2>;
+
+def DX10 : X<1, 0>;
+def DX11 : X<1, 1>;
+def DX12 : X<1, 2>;
+
+def DYe0 : Y<"", 0>;
+def DYe1 : Y<"", 1>;
+def DYe2 : Y<"", 2>;
+
+def DYa0 : Y<"a", 0>;
+def DYa1 : Y<"a", 1>;
+def DYa2 : Y<"a", 2>;
+
+def DZ : X<42, !size([1, 2, 3])>;

utils/kate/llvm-tablegen.xml

<highlighting>
     </list>
     <list name="bang-operators">
       <item> !eq </item>
       <item> !if </item>
       <item> !head </item>
       <item> !tail </item>
       <item> !con </item>
       <item> !add </item>
+      <item> !mul </item>
       <item> !shl </item>
       <item> !sra </item>
       <item> !srl </item>
       <item> !and </item>
       <item> !or </item>
       <item> !empty </item>
       <item> !subst </item>
       <item> !foreach </item>
       <item> !strconcat </item>
       <item> !cast </item>
       <item> !listconcat </item>
+      <item> !listsplat </item>
       <item> !size </item>
       <item> !foldl </item>
       <item> !isa </item>
       <item> !dag </item>
       <item> !le </item>
       <item> !lt </item>
       <item> !ge </item>
       <item> !gt </item>