TableGen: Add !size operation

[nhaehnle]

Summary

Returns the size of a list. I have found this to be rather useful in some
development for the AMDGPU backend where we could simplify our .td files
by concatenating list<LLVMType> for complex intrinsics. Doing so requires
us to compute the position argument for LLVMMatchType.

Basically, the usage is in a pattern that looks somewhat like this:

list<LLVMType> argtypes =
    !listconcat(base,
                [llvm_any_ty, LLVMMatchType<!size(base)>]);

Change-Id: I360a0b000fd488d18bea412228230fd93722bd2c

[tra]

docs/TableGen/LangRef.rst

101 ↗

(On Diff #135214)

It would be good to add more details about !size in docs/TableGen/LangIntro.rst

test/TableGen/size.td

6–20 ↗

(On Diff #135214)

I'd interleave those with the def An:... below.

[nhaehnle]

Add some documentation

[nhaehnle]

docs/TableGen/LangRef.rst

101 ↗

(On Diff #135214)

Done.

test/TableGen/size.td

6–20 ↗

(On Diff #135214)

I'd prefer to leave it as-is. Unlike other tools, TableGen output is not in the order of the input file but sorted alphabetically, so I find interleaving the CHECK lines misleading. I think it's easier to work with this way.

[tra]

test/TableGen/size.td

6–20 ↗

(On Diff #135214)

OK. In this case your defs are also sorted, that's why I've suggested interleaving the checks. It's fine either way.

llvm/trunk/docs/TableGen/LangIntro.rst

``!head(a)``
     The first element of list 'a.'
 
 ``!tail(a)``
     The 2nd-N elements of list 'a.'
 
 ``!empty(a)``
     An integer {0,1} indicating whether list 'a' is empty.
 
+``!size(a)``
+    An integer indicating the number of elements in list 'a'.
+
 ``!if(a,b,c)``
   'b' if the result of 'int' or 'bit' operator 'a' is nonzero, 'c' otherwise.
 
 ``!eq(a,b)``
     'bit 1' if string a is equal to string b, 0 otherwise.  This only operates
     on string, int and bit objects.  Use !cast<string> to compare other types of
     objects.
 

llvm/trunk/docs/TableGen/LangRef.rst

 TableGen also has "bang operators" which have a
 wide variety of meanings:
 
 .. productionlist::
    BangOperator: one of
                :!eq     !if      !head    !tail      !con
                :!add    !shl     !sra     !srl       !and
                :!or     !empty   !subst   !foreach   !strconcat
-               :!cast   !listconcat
+               :!cast   !listconcat       !size
 
 
 Syntax
 ======
 
 TableGen has an ``include`` mechanism. It does not play a role in the
 syntax per se, since it is lexically replaced with the contents of the
 included file.

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

public:
 
   Init *getBit(unsigned Bit) const override;
 };
 
 /// !op (X) - Transform an init.
 ///
 class UnOpInit : public OpInit, public FoldingSetNode {
 public:
-  enum UnaryOp : uint8_t { CAST, HEAD, TAIL, EMPTY };
+  enum UnaryOp : uint8_t { CAST, HEAD, TAIL, SIZE, EMPTY };
 
 private:
   Init *LHS;
 
   UnOpInit(UnaryOp opc, Init *lhs, RecTy *Type)
     : OpInit(IK_UnOpInit, Type, opc), LHS(lhs) {}
 
 public:

llvm/trunk/lib/TableGen/Record.cpp

case TAIL:
     if (ListInit *LHSl = dyn_cast<ListInit>(LHS)) {
       assert(!LHSl->empty() && "Empty list in tail");
       // Note the +1.  We can't just pass the result of getValues()
       // directly.
       return ListInit::get(LHSl->getValues().slice(1), LHSl->getElementType());
     }
     break;
 
+  case SIZE:
+    if (ListInit *LHSl = dyn_cast<ListInit>(LHS))
+      return IntInit::get(LHSl->size());
+    break;
+
   case EMPTY:
     if (ListInit *LHSl = dyn_cast<ListInit>(LHS))
       return IntInit::get(LHSl->empty());
     if (StringInit *LHSs = dyn_cast<StringInit>(LHS))
       return IntInit::get(LHSs->getValue().empty());
     break;
   }
   return const_cast<UnOpInit *>(this);
 }
 
 Init *UnOpInit::resolveReferences(Record &R, const RecordVal *RV) const {
   Init *lhs = LHS->resolveReferences(R, RV);
 
   if (LHS != lhs)
     return (UnOpInit::get(getOpcode(), lhs, getType()))->Fold(&R, nullptr);
   return Fold(&R, nullptr);
 }
 
 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;
+  case SIZE: Result = "!size"; break;
   case EMPTY: Result = "!empty"; break;
   }
   return Result + "(" + LHS->getAsString() + ")";
 }
 
 static void
 ProfileBinOpInit(FoldingSetNodeID &ID, unsigned Opcode, Init *LHS, Init *RHS,
                  RecTy *Type) {

llvm/trunk/lib/TableGen/TGLexer.h

enum TokKind {
     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,
+    XSubst, XForEach, XHead, XTail, XSize, XEmpty, XIf, XEq,
 
     // Integer value.
     IntVal,
 
     // Binary constant.  Note that these are sized according to the number of
     // bits given.
     BinaryIntVal,
     

llvm/trunk/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("size", tgtok::XSize)
     .Case("con", tgtok::XConcat)
     .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)

llvm/trunk/lib/TableGen/TGParser.cpp

 ///
 Init *TGParser::ParseOperation(Record *CurRec, RecTy *ItemType) {
   switch (Lex.getCode()) {
   default:
     TokError("unknown operation");
     return nullptr;
   case tgtok::XHead:
   case tgtok::XTail:
+  case tgtok::XSize:
   case tgtok::XEmpty:
   case tgtok::XCast: {  // Value ::= !unop '(' Value ')'
     UnOpInit::UnaryOp Code;
     RecTy *Type = nullptr;
 
     switch (Lex.getCode()) {
     default: llvm_unreachable("Unhandled code!");
     case tgtok::XCast:
case tgtok::XCast: {  // Value ::= !unop '(' Value ')'
     case tgtok::XHead:
       Lex.Lex();  // eat the operation
       Code = UnOpInit::HEAD;
       break;
     case tgtok::XTail:
       Lex.Lex();  // eat the operation
       Code = UnOpInit::TAIL;
       break;
+    case tgtok::XSize:
+      Lex.Lex();
+      Code = UnOpInit::SIZE;
+      Type = IntRecTy::get();
+      break;
     case tgtok::XEmpty:
       Lex.Lex();  // eat the operation
       Code = UnOpInit::EMPTY;
       Type = IntRecTy::get();
       break;
     }
     if (Lex.getCode() != tgtok::l_paren) {
       TokError("expected '(' after unary operator");
if (Code == UnOpInit::HEAD ||
         ListRecTy *LType = dyn_cast<ListRecTy>(LHSt->getType());
         StringRecTy *SType = dyn_cast<StringRecTy>(LHSt->getType());
         if (!LType && !SType) {
           TokError("expected list or string type argument in unary operator");
           return nullptr;
         }
       }
 
-      if (Code == UnOpInit::HEAD || Code == UnOpInit::TAIL) {
+      if (Code == UnOpInit::HEAD || Code == UnOpInit::TAIL ||
+          Code == UnOpInit::SIZE) {
         if (!LHSl && !LHSt) {
           TokError("expected list type argument in unary operator");
           return nullptr;
         }
+      }
 
+      if (Code == UnOpInit::HEAD || Code == UnOpInit::TAIL) {
         if (LHSl && LHSl->empty()) {
           TokError("empty list argument in unary operator");
           return nullptr;
         }
         if (LHSl) {
           Init *Item = LHSl->getElement(0);
           TypedInit *Itemt = dyn_cast<TypedInit>(Item);
           if (!Itemt) {
case tgtok::l_paren: {         // Value ::= '(' IDValue DagArgList ')'
     }
     Lex.Lex();  // eat the ')'
 
     return DagInit::get(Operator, OperatorName, DagArgs);
   }
 
   case tgtok::XHead:
   case tgtok::XTail:
+  case tgtok::XSize:
   case tgtok::XEmpty:
   case tgtok::XCast:  // Value ::= !unop '(' Value ')'
   case tgtok::XConcat:
   case tgtok::XADD:
   case tgtok::XAND:
   case tgtok::XOR:
   case tgtok::XSRA:
   case tgtok::XSRL:

llvm/trunk/test/TableGen/size.td

+// RUN: llvm-tblgen %s | FileCheck %s
+// XFAIL: vg_leak
+
+// CHECK: --- Defs ---
+
+// CHECK: def A1 {
+// CHECK:   int Val = 0;
+// CHECK: }
+
+// CHECK: def A2 {
+// CHECK:   int Val = 3;
+// CHECK: }
+
+// CHECK: def B1 {
+// CHECK:   int Val = 0;
+// CHECK: }
+
+// CHECK: def B2 {
+// CHECK:   int Val = 2;
+// CHECK: }
+
+class A<list<int> L> {
+  int Val = !size(L);
+}
+
+class B<list<string> L> {
+  int Val = !size(L);
+}
+
+def A1 : A<[]>;
+def A2 : A<[1, 1, 2]>;
+
+def B1 : B<[]>;
+def B2 : B<["a", "b"]>;