[TableGen] Enhance !empty and !size to handle strings and DAGs

[Paul-C-Anagnostopoulos]

Summary

This patch enhances the TableGen !empty and !size operators so they can handle strings and DAGs in addition to lists. This is the first in a series of patches to improve TableGen's ability to build complex DAGs.

In the process, I fixed a bug in the type checking for !first, !empty, !size, and !tail.

[lattner]

nice!

llvm/docs/TableGen/ProgRef.rst

``string``
     length.
 
 ``code``
     The ``code`` type represents a code fragment. The values are the same as
     those for the ``string`` type; the ``code`` type is provided just to indicate
     the programmer's intention.
 
 ``bits<``\ *n*\ ``>``
-    The ``bits`` type is a fixed-size integer of arbitrary length *n* that
+    The ``bits`` type is a fixed-sized integer of arbitrary length *n* that
     is treated as separate bits. These bits can be accessed individually.
     A field of this type is useful for representing an instruction operation
     code, register number, or address mode/register/displacement.  The bits of
     the field can be set individually or as subfields. For example, in an
     instruction address, the addressing mode, base register number, and
     displacement can be set separately.
 
 ``list<``\ *type*\ ``>``

 ====================== =============================================
 
 The *value* can be any TableGen value. The *name*, if present, must be a
 :token:`TokVarName`, which starts with a dollar sign (``$``). The purpose of
 a name is to tag an operator or operand in a DAG with a particular meaning,
 or to associate an operand in one DAG with a like-named operand in another
 DAG.
 
-The following bang operators manipulate DAGs: ``!con``, ``!dag``, ``!foreach``, 
-``!getop``, ``!setop``.
+The following bang operators are useful for working with DAGs:
+``!con``, ``!dag``, ``!empty``, ``!foreach``, ``!getop``, ``!setop``, ``!size``.
 
 Defvar in a record body
 -----------------------
 
 In addition to defining global variables, the ``defvar`` statement can
 be used inside the :token:`Body` of a class or record definition to define
 local variables. The scope of the variable extends from the ``defvar``
 statement to the end of the body. It cannot be set to a different value
``!dag(``\ *op*\ ``,`` *children*\ ``,`` *names*\ ``)``
     Due to limitations of the type system, *children* must be a list of items
     of a common type. In practice, this means that they should either have the
     same type or be records with a common superclass. Mixing ``dag`` and
     non-``dag`` items is not possible. However, ``?`` can be used.
 
     Example: ``!dag(op, [a1, a2, ?], ["name1", "name2", "name3"])`` results in
     ``(op a1:$name1, a2:$name2, ?:$name3)``.
 
-``!empty(``\ *list*\ ``)``
-    This operator produces 1 if the *list* is empty; 0 otherwise.
+``!empty(``\ *a*\ ``)``
+    This operator produces 1 if the string, list, or DAG *a* is empty; 0 otherwise.
+    A dag is empty if it has no arguments; the operator does not count.
 
 ``!eq(`` *a*\ `,` *b*\ ``)``
     This operator produces 1 if *a* is equal to *b*; 0 otherwise.
     The arguments must be ``bit``, ``int``, or ``string`` values.
     Use ``!cast<string>`` to compare other types of objects.
 
 ``!foldl(``\ *start*\ ``,`` *list*\ ``,`` *a*\ ``,`` *b*\ ``,`` *expr*\ ``)``
     This operator performs a left-fold over the items in *list*. The
``!setop(``\ *dag*\ ``,`` *op*\ ``)``
     Example: ``!setop((foo 1, 2), bar)`` results in ``(bar 1, 2)``.
 
 ``!shl(``\ *a*\ ``,`` *count*\ ``)``
     This operator shifts *a* left logically by *count* bits and produces the resulting
     value. The operation is performed on a 64-bit integer; the result
     is undefined for shift counts outside 0...63.
 
 ``!size(``\ *a*\ ``)``
-    This operator produces the number of elements in the list *a*.
+    This operator produces the size of the string, list, or dag *a*.
+    The size of a DAG is the number of arguments; the operator does not count.
 
 ``!sra(``\ *a*\ ``,`` *count*\ ``)``
     This operator shifts *a* right arithmetically by *count* bits and produces the resulting
     value. The operation is performed on a 64-bit integer; the result
     is undefined for shift counts outside 0...63.
 
 ``!srl(``\ *a*\ ``,`` *count*\ ``)``
     This operator shifts *a* right logically by *count* bits and produces the resulting

llvm/lib/TableGen/Record.cpp

if (ListInit *LHSl = dyn_cast<ListInit>(LHS)) {
       // 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());
+    if (DagInit *LHSd = dyn_cast<DagInit>(LHS))
+      return IntInit::get(LHSd->arg_size());
+    if (StringInit *LHSs = dyn_cast<StringInit>(LHS))
+      return IntInit::get(LHSs->getValue().size());
     break;
 
   case EMPTY:
     if (ListInit *LHSl = dyn_cast<ListInit>(LHS))
       return IntInit::get(LHSl->empty());
+    if (DagInit *LHSd = dyn_cast<DagInit>(LHS))
+      return IntInit::get(LHSd->arg_empty());
     if (StringInit *LHSs = dyn_cast<StringInit>(LHS))
       return IntInit::get(LHSs->getValue().empty());
     break;
 
   case GETOP:
     if (DagInit *Dag = dyn_cast<DagInit>(LHS)) {
       DefInit *DI = DefInit::get(Dag->getOperatorAsDef({}));
       if (!DI->getType()->typeIsA(getType())) {

llvm/lib/TableGen/TGParser.cpp

case tgtok::XGetOp: {  // Value ::= !unop '(' Value ')'
     if (!consume(tgtok::l_paren)) {
       TokError("expected '(' after unary operator");
       return nullptr;
     }
 
     Init *LHS = ParseValue(CurRec);
     if (!LHS) return nullptr;
 
-    if (Code == UnOpInit::HEAD ||
-        Code == UnOpInit::TAIL ||
-        Code == UnOpInit::EMPTY) {
+    if (Code == UnOpInit::EMPTY || Code == UnOpInit::SIZE) {
       ListInit *LHSl = dyn_cast<ListInit>(LHS);
       StringInit *LHSs = dyn_cast<StringInit>(LHS);
+      DagInit *LHSd = dyn_cast<DagInit>(LHS);
       TypedInit *LHSt = dyn_cast<TypedInit>(LHS);
-      if (!LHSl && !LHSs && !LHSt) {
-        TokError("expected list or string type argument in unary operator");
+      if (!LHSl && !LHSs && !LHSd && !LHSt) {
+        TokError("expected string, list, or dag type argument in unary operator");
         return nullptr;
       }
       if (LHSt) {
         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");
+        DagRecTy *DType = dyn_cast<DagRecTy>(LHSt->getType());
+        if (!LType && !SType && !DType) {
+          TokError("expected string, list, or dag type argument in unary operator");
           return nullptr;
         }
       }
+    }
 
-      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) {
+      ListInit *LHSl = dyn_cast<ListInit>(LHS);
+      TypedInit *LHSt = dyn_cast<TypedInit>(LHS);
+      if (LHSt) {
+        ListRecTy *LType = dyn_cast<ListRecTy>(LHSt->getType());
+        if (!LType) {
+          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) {
-            TokError("untyped list element in unary operator");
-            return nullptr;
-          }
-          Type = (Code == UnOpInit::HEAD) ? Itemt->getType()
-                                          : ListRecTy::get(Itemt->getType());
-        } else {
-          assert(LHSt && "expected list type argument in unary operator");
-          ListRecTy *LType = dyn_cast<ListRecTy>(LHSt->getType());
-          if (!LType) {
-            TokError("expected list type argument in unary operator");
-            return nullptr;
-          }
-          Type = (Code == UnOpInit::HEAD) ? LType->getElementType() : LType;
-        }
-      }
-    }
 
     if (!consume(tgtok::r_paren)) {
       TokError("expected ')' in unary operator");
       return nullptr;
     }
     return (UnOpInit::get(Code, LHS, Type))->Fold(CurRec);
   }
 

llvm/test/TableGen/empty.td

+// RUN: llvm-tblgen %s | FileCheck %s
+// XFAIL: vg_leak
+
+defvar LongList = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+defvar EmptyStr = "";
+
+// Test !empty(dag).
+
+// CHECK: def Drec1 {
+// CHECK:   bit Empty = 1;
+// CHECK:   bit NotEmpty = 0;
+// CHECK: def Drec2 {
+// CHECK:   bit Empty = 0;
+// CHECK:   bit NotEmpty = 1;
+// CHECK: def Drec3 {
+// CHECK:   bit Empty = 0;
+// CHECK:   bit NotEmpty = 1;
+
+class D<dag ADag> {
+  bit Empty = !empty(ADag);
+  bit NotEmpty = !not(!empty(ADag));
+}
+
+def op;
+
+def Drec1 : D<(op)>;
+def Drec2 : D<(op "string")>;
+def Drec3 : D<(op "string", 42)>;
+
+// Test !empty(list).
+
+// CHECK: def Lrec1 {
+// CHECK:   bit Empty = 1;
+// CHECK:   bit NotEmpty = 0;
+// CHECK: def Lrec2 {
+// CHECK:   bit Empty = 0;
+// CHECK:   bit NotEmpty = 1;
+// CHECK: def Lrec3 {
+// CHECK:   bit Empty = 0;
+// CHECK:   bit NotEmpty = 1;
+
+class L<list<int> Ints> {
+  bit Empty = !empty(Ints);
+  bit NotEmpty = !not(!empty(Ints));
+}
+
+def Lrec1 : L<[]>;
+def Lrec2 : L<[1]>;
+def Lrec3 : L<LongList>;
+
+// Test !empty(string).
+
+// CHECK: def Srec1 {
+// CHECK:   bit Empty = 1;
+// CHECK:   bit NotEmpty = 0;
+// CHECK: def Srec2 {
+// CHECK:   bit Empty = 0;
+// CHECK:   bit NotEmpty = 1;
+// CHECK: def Srec3 {
+// CHECK:   bit Empty = 0;
+// CHECK:   bit NotEmpty = 1;
+
+class S<string Str> {
+  bit Empty = !empty(Str);
+  bit NotEmpty = !not(!empty(Str));
+}
+
+def Srec1 : S<EmptyStr>;
+def Srec2 : S<"a">;
+def Srec3 : S<"ab">;
+

llvm/test/TableGen/size.td

 // RUN: llvm-tblgen %s | FileCheck %s
 // XFAIL: vg_leak
 
+// Test !size of lists.
+
 // CHECK: --- Defs ---
 
 // CHECK: def A1 {
 // CHECK:   int Val = 0;
 // CHECK: }
 
 // CHECK: def A2 {
 // CHECK:   int Val = 3;
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"]>;
+
+// Test !size of DAGs.
+
+// CHECK: def D0 {
+// CHECK:   int Val = 0;
+// CHECK: }
+
+// CHECK: def D1 {
+// CHECK:   int Val = 1;
+// CHECK: }
+
+// CHECK: def D2 {
+// CHECK:   int Val = 2;
+// CHECK: }
+
+// CHECK: def D3 {
+// CHECK:   int Val = 3;
+// CHECK: }
+
+// CHECK: def D4 {
+// CHECK:   int Val = 4;
+// CHECK: }
+
+class D<dag D> {
+  int Val = !size(D);
+}
+
+def op;
+
+def D0 : D<(op)>;
+def D1 : D<(op "string")>;
+def D2 : D<(op "string", 42)>;
+def D3 : D<(op "string", 42, (op "sub-dag"))>;
+def D4 : D<(op "string", 42, (op "sub-dag"), D0.Val)>;
+
+// Test !size of strings.
+
+// CHECK: def S0 {
+// CHECK:   int Val = 0;
+// CHECK: }
+
+// CHECK: def S1 {
+// CHECK:   int Val = 1;
+// CHECK: }
+
+// CHECK: def S2 {
+// CHECK:   int Val = 2;
+// CHECK: }
+
+// CHECK: def S3 {
+// CHECK:   int Val = 3;
+// CHECK: }
+
+// CHECK: def S4 {
+// CHECK:   int Val = 29;
+// CHECK: }
+
+class S<string S> {
+  int Val = !size(S);
+}
+
+def S0 : S<"">;
+def S1 : S<"a">;
+def S2 : S<"ab">;
+def S3 : S<"abc">;
+def S4 : S<"This is the end of the world!">;
+