[TableGen] Implement !getdagargs and !getdagargnames.

[fpetrogalli]

Summary

``!getdagargs<``\ *type*\ ``>(``\ *dag*\ ``)``
    This operator extracts the list of arguments of the given *dag*.

    Due to limitations of the type system, it is requires that the
    arguments of the given *dag* can be converted to *type*. In
    practice, this means that for each *arg* in the *dag* the
    predicate ``!isa<type>(arg)`` is true.

``!getdagargnames(``\ *dag*\ ``)``
    This operator extracts the list of argument names of the given *dag*.

[simon_tatham]

I'm confused – isn't D151457 already open for this patch?

[fpetrogalli]

In D151702#4380535, @simon_tatham wrote:

I'm confused – isn't D151457 already open for this patch?

Oh! I didn't know about that! What a coincidence! I'll review D151457.

[fpetrogalli]

Abandoned in favour of the per-element operands getdagarg and getdagname. See https://reviews.llvm.org/D151457#4384382

llvm/docs/TableGen/ProgRef.rst

BangOperator: one of
                : !add         !and         !cast        !con         !dag
                : !div         !empty       !eq          !exists      !filter
                : !find        !foldl       !foreach     !ge          !getdagop
                : !gt          !head        !if          !interleave  !isa
                : !le          !listconcat  !listremove  !listsplat   !logtwo
                : !lt          !mul         !ne          !not         !or
                : !range       !setdagop    !shl         !size        !sra
                : !srl         !strconcat   !sub         !subst       !substr
-               : !tail        !tolower     !toupper     !xor
+               : !tail        !tolower     !toupper     !xor         !getdagargs  !getdagargnames
 
 The ``!cond`` operator has a slightly different
 syntax compared to other bang operators, so it is defined separately:
 
 .. productionlist::
    CondOperator: !cond
 
 See `Appendix A: Bang Operators`_ for a description of each bang operator.
``!foreach(``\ *var*\ ``,`` *sequence*\ ``,`` *expr*\ ``)``
 
     If you simply want to create a list of a certain length containing
     the same value repeated multiple times, see ``!listsplat``.
 
 ``!ge(``\ *a*\ `,` *b*\ ``)``
     This operator produces 1 if *a* is greater than or equal to *b*; 0 otherwise.
     The arguments must be ``bit``, ``bits``, ``int``, or ``string`` values.
 
+``!getdagargs<``\ *type*\ ``>(``\ *dag*\ ``)``
+    This operator extracts the list of arguments of the given *dag*.
+
+    Due to limitations of the type system, it is requires that the
+    arguments of the given *dag* can be converted to *type*. In
+    practice, this means that for each *arg* in the *dag* the
+    predicate ``!isa<type>(arg)`` is true.
+
+``!getdagargnames(``\ *dag*\ ``)``
+    This operator extracts the list of argument names of the given *dag*.
+
 ``!getdagop(``\ *dag*\ ``)`` --or-- ``!getdagop<``\ *type*\ ``>(``\ *dag*\ ``)``
     This operator produces the operator of the given *dag* node.
     Example: ``!getdagop((foo 1, 2))`` results in ``foo``. Recall that
     DAG operators are always records.
 
     The result of ``!getdagop`` can be used directly in a context where
     any record class at all is acceptable (typically placing it into
     another dag value). But in other contexts, it must be explicitly

llvm/include/llvm/TableGen/Record.h

enum UnaryOp : uint8_t {
     TOUPPER,
     CAST,
     NOT,
     HEAD,
     TAIL,
     SIZE,
     EMPTY,
     GETDAGOP,
-    LOG2
+    LOG2,
+    GETDAGARGS,
+    GETDAGARGNAMES
   };
 
 private:
   Init *LHS;
 
   UnOpInit(UnaryOp opc, Init *lhs, RecTy *Type)
     : OpInit(IK_UnOpInit, Type, opc), LHS(lhs) {}
 

llvm/lib/TableGen/Record.cpp

 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
+#include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/SMLoc.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/TableGen/Error.h"
 #include <cassert>
 #include <cstdint>
 #include <map>

 
 void UnOpInit::Profile(FoldingSetNodeID &ID) const {
   ProfileUnOpInit(ID, getOpcode(), getOperand(), getType());
 }
 
 Init *UnOpInit::Fold(Record *CurRec, bool IsFinal) const {
   RecordKeeper &RK = getRecordKeeper();
   switch (getOpcode()) {
+  case GETDAGARGS: {
+    if (DagInit *DAG = dyn_cast<DagInit>(LHS)) {
+
+      auto ListTy = dyn_cast<ListRecTy>(getType());
+      RecTy *ElementTy = ListTy->getElementType();
+      assert(ListTy && "Type is expected to be ListRecTy");
+
+      // Check that the type of each of the argument can be converted
+      // to the type specified by the user in !getdagargs<type>(dag).
+      ArrayRef<Init *> Args = DAG->getArgs();
+      for (Init *ArgInit : Args) {
+        Init *NewInit = ArgInit->getCastTo(ElementTy);
+        if (!NewInit) {
+          PrintFatalError(CurRec->getLoc(),
+                          Twine("Operand `") + ArgInit->getAsString() + "`" +
+                              " of dag `" + DAG->getAsString() +
+                              +"` cannot be cast to type `" +
+                              ElementTy->getAsString() + "`");
+        }
+      }
+      return ListInit::get(Args, ElementTy);
+    }
+    break;
+  }
+  case GETDAGARGNAMES:
+    if (DagInit *DAG = dyn_cast<DagInit>(LHS)) {
+      auto ListTy = dyn_cast<ListRecTy>(getType());
+      assert(ListTy && "Type is expected to be ListRecTy");
+      SmallVector<Init *, 4> Inits;
+      for (StringInit *Name : DAG->getArgNames()) {
+        assert(Name && "Missing name");
+        Inits.push_back(Name);
+      }
+      return ListInit::get(Inits, StringRecTy::get(RK));
+    }
+    break;
   case TOLOWER:
     if (StringInit *LHSs = dyn_cast<StringInit>(LHS))
       return StringInit::get(RK, LHSs->getValue().lower());
     break;
   case TOUPPER:
     if (StringInit *LHSs = dyn_cast<StringInit>(LHS))
       return StringInit::get(RK, LHSs->getValue().upper());
     break;
std::string UnOpInit::getAsString() const {
   case GETDAGOP: Result = "!getdagop"; break;
   case LOG2 : Result = "!logtwo"; break;
   case TOLOWER:
     Result = "!tolower";
     break;
   case TOUPPER:
     Result = "!toupper";
     break;
+  case GETDAGARGS:
+    Result = "!getdagargs";
+    break;
+  case GETDAGARGNAMES:
+    Result = "!getdagargnames";
+    break;
   }
   return Result + "(" + LHS->getAsString() + ")";
 }
 
 static void
 ProfileBinOpInit(FoldingSetNodeID &ID, unsigned Opcode, Init *LHS, Init *RHS,
                  RecTy *Type) {
   ID.AddInteger(Opcode);

llvm/lib/TableGen/TGLexer.h

// existing 'Else' that means the preprocessor #else.)
     FalseKW, Field, Foreach, If, In, Include, Int, Let, List, MultiClass,
     String, Then, TrueKW,
 
   // Bang operators.
     XConcat, XADD, XSUB, XMUL, XDIV, XNOT, XLOG2, XAND, XOR, XXOR, XSRA, XSRL,
     XSHL, XListConcat, XListSplat, XStrConcat, XInterleave, XSubstr, XFind,
     XCast, XSubst, XForEach, XFilter, XFoldl, XHead, XTail, XSize, XEmpty, XIf,
     XCond, XEq, XIsA, XDag, XNe, XLe, XLt, XGe, XGt, XSetDagOp, XGetDagOp,
-    XExists, XListRemove, XToLower, XToUpper, XRange,
+    XExists, XListRemove, XToLower, XToUpper, XRange, XGetDagArgs, XGetDagArgNames,
+
 
   // Boolean literals.
     TrueVal, FalseVal,
 
   // Integer value.
   IntVal,
 
   // Binary constant.  Note that these are sized according to the number of

llvm/lib/TableGen/TGLexer.cpp

tgtok::TokKind Kind =
           .Case("interleave", tgtok::XInterleave)
           .Case("substr", tgtok::XSubstr)
           .Case("find", tgtok::XFind)
           .Cases("setdagop", "setop", tgtok::XSetDagOp) // !setop is deprecated.
           .Cases("getdagop", "getop", tgtok::XGetDagOp) // !getop is deprecated.
           .Case("exists", tgtok::XExists)
           .Case("tolower", tgtok::XToLower)
           .Case("toupper", tgtok::XToUpper)
+          .Case("getdagargs", tgtok::XGetDagArgs)
+          .Case("getdagargnames", tgtok::XGetDagArgNames)
           .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
   // file is not empty.

llvm/lib/TableGen/TGParser.cpp

case tgtok::XIsA: {
 
     if (!consume(tgtok::r_paren)) {
       TokError("expected ')' in !isa");
       return nullptr;
     }
 
     return (IsAOpInit::get(Type, LHS))->Fold();
   }
+  case tgtok::XGetDagArgs: {
+    // Value ::= ! getdagargs '<' Type '>' '(' Value ')'
+    Lex.Lex(); // eat the operation
+
+    // Check the Type argument.
+    RecTy *CastToRecTy = ParseOperatorType();
+
+    if (!consume(tgtok::l_paren)) {
+      TokError("expected '('");
+      return nullptr;
+    }
+    Init *DAG = ParseValue(CurRec);
+    if (!DAG)
+      return nullptr;
+
+    if (!consume(tgtok::r_paren)) {
+      TokError("expected ')'");
+      return nullptr;
+    }
+
+    return UnOpInit::get(UnOpInit::GETDAGARGS, DAG, ListRecTy::get(CastToRecTy))
+        ->Fold(CurRec);
+  }
+  case tgtok::XGetDagArgNames: {
+    // Value ::= ! getdagargnames  '(' Value ')'
+    Lex.Lex(); // eat the operation
+
+    if (!consume(tgtok::l_paren)) {
+      TokError("expected '('");
+      return nullptr;
+    }
+    Init *DAG = ParseValue(CurRec);
+    if (!DAG)
+      return nullptr;
 
+    if (!consume(tgtok::r_paren)) {
+      TokError("expected ')'");
+      return nullptr;
+    }
+
+    return UnOpInit::get(UnOpInit::GETDAGARGNAMES, DAG,
+                         ListRecTy::get(StringRecTy::get(Records)))
+        ->Fold(CurRec);
+  }
   case tgtok::XExists: {
     // Value ::= !exists '<' Type '>' '(' Value ')'
     Lex.Lex(); // eat the operation
 
     RecTy *Type = ParseOperatorType();
     if (!Type)
       return nullptr;
 
Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType,
   case tgtok::XGe:
   case tgtok::XGt:
   case tgtok::XListConcat:
   case tgtok::XListSplat:
   case tgtok::XListRemove:
   case tgtok::XRange:
   case tgtok::XStrConcat:
   case tgtok::XInterleave:
+  case tgtok::XGetDagArgs:
+  case tgtok::XGetDagArgNames:
   case tgtok::XSetDagOp: // Value ::= !binop '(' Value ',' Value ')'
   case tgtok::XIf:
   case tgtok::XCond:
   case tgtok::XFoldl:
   case tgtok::XForEach:
   case tgtok::XFilter:
   case tgtok::XSubst:
   case tgtok::XSubstr:

llvm/test/TableGen/getdagargnames.td

+// RUN: llvm-tblgen %s | FileCheck %s
+
+class Base;
+def operator : Base;
+def A : Base;
+def B : Base;
+defvar DAG = (operator A:$a, B:$b);
+class PrintMe<list<string> t> {
+  list<string> x = t;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Basic tests
+
+// CHECK-LABEL: def test_00 {
+// CHECK-NEXT:    list<string> x = ["a", "b"];
+// CHECK-NEXT:  }
+def test_00: PrintMe<!getdagargnames(DAG)>;
+
+////////////////////////////////////////////////////////////////////////////////
+// Extract from a dag created with !dag.
+
+// CHECK-LABEL: def test_05 {
+// CHECK-NEXT:    list<string> x = ["var1", "var2"];
+// CHECK-NEXT:  }
+def test_05: PrintMe<!getdagargnames(!dag(A, [operator, operator], ["var1", "var2"]))>;
+
+////////////////////////////////////////////////////////////////////////////////
+// Operate on the template parameter of a class.
+
+class Extract<dag D> {
+  list<string> ArgNames =!getdagargnames(D);
+}
+
+// CHECK-LABEL: def test_06 {
+// CHECK-NEXT:    list<string> ArgNames = ["A", "B"];
+// CHECK-NEXT:  }
+def test_06 : Extract<(operator A:$A, B:$B)>;
+
+////////////////////////////////////////////////////////////////////////////////
+// Make sure we can pass template parameters transformed by getdagarg
+// via class inheritance.
+
+class Parent<list<string> input> {
+  list<string> Input = input;
+}
+
+class Child<dag input> : Parent<!getdagargnames(input)>;
+
+// CHECK-LABEL: def test_07 {
+// CHECK-NEXT:    list<string> Input = ["X"];
+// CHECK-NEXT:  }
+def test_07 : Child<(operator (operator A:$A, B:$B):$X)>;
+
+////////////////////////////////////////////////////////////////////////////////
+// Make sure we can use defvar without knowing the underlying type of
+// the argument of the dag in a multiclass;
+
+class UseBase<list<string> x> {
+  list<string> X = x;
+}
+multiclass UseDefVar<dag input> {
+  defvar Input = !getdagargnames(input);
+  def _def: UseBase<Input>;
+}
+
+// CHECK-LABEL: def test_08_def {
+// CHECK-NEXT:    list<string> X = ["x", "y"];
+// CHECK-NEXT:  }
+defm test_08 : UseDefVar<(operator A:$x, B:$y)>;
+
+////////////////////////////////////////////////////////////////////////////////
+// Make sure the type of the result of !getdagargnames can be enquired by
+// other operators
+
+class ChildWithSubListUse<dag input> : Parent<[!interleave(!getdagargnames(input),"@")]>;
+
+// CHECK-LABEL: def test_09 {
+// CHECK-NEXT:    list<string> Input = ["s@t"];
+// CHECK-NEXT:  }
+def test_09 : ChildWithSubListUse<(operator (operator A, B):$s, (A operator, B):$t)>;

llvm/test/TableGen/getdagargs-error.td

+// RUN: not llvm-tblgen 2>&1 %s | FileCheck %s
+
+////////////////////////////////////////////////////////////////////////////////
+// A dag that does not have uniform operands.
+
+class BaseA;
+class BaseB;
+class Base;
+
+def InstanceOfBaseA : BaseA;
+def InstanceOfBaseB : BaseB;
+def operator : Base;
+class Extractor<dag input> {
+  list<BaseA> ExtractedList = !getdagargs<BaseA>(input);
+}
+
+// CHECK:[[@LINE+1]]:5: error: Operand `InstanceOfBaseB` of dag `(operator InstanceOfBaseA, InstanceOfBaseB)` cannot be cast to type `BaseA` 
+def test : Extractor<(operator InstanceOfBaseA, InstanceOfBaseB)>;
+

llvm/test/TableGen/getdagargs.td

+// RUN: llvm-tblgen %s | FileCheck %s
+
+class Base;
+def operator : Base;
+def A : Base;
+def B : Base;
+defvar DAG = (operator A, B);
+class PrintMe<list<Base> t> {
+  list<Base> x = t;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Basic tests
+
+// CHECK-LABEL: def test_00 {
+// CHECK-NEXT:    list<Base> x = [A, B];
+// CHECK-NEXT:  }
+def test_00: PrintMe<!getdagargs<Base>(DAG)>;
+
+////////////////////////////////////////////////////////////////////////////////
+// Extract from a dag with names.
+
+defvar DagWithNames = (operator A:$A, B:$B);
+// CHECK-LABEL: def test_04 {
+// CHECK-NEXT:    list<Base> x = [A, B];
+// CHECK-NEXT:  }
+def test_04: PrintMe<!getdagargs<Base>(DagWithNames)>;
+
+////////////////////////////////////////////////////////////////////////////////
+// Extract from a dag created with !dag.
+
+// CHECK-LABEL: def test_05 {
+// CHECK-NEXT:    list<Base> x = [operator];
+// CHECK-NEXT:  }
+def test_05: PrintMe<!getdagargs<Base>(!dag(A, [operator], ?))>;
+
+////////////////////////////////////////////////////////////////////////////////
+// Operate on the template parameter of a class.
+
+class Extract<dag D> {
+  list<Base> Args =!getdagargs<Base>(D);
+}
+
+// CHECK-LABEL: def test_06 {
+// CHECK-NEXT:    list<Base> Args = [A, B];
+// CHECK-NEXT:  }
+def test_06 : Extract<(operator A, B)>;
+
+////////////////////////////////////////////////////////////////////////////////
+// Make sure we can pass template parameters transformed by getdagarg
+// via class inheritance.
+
+class Parent<list<dag> input> {
+  list<dag> Input = input;
+}
+
+class Child<dag input> : Parent<!getdagargs<dag>(input)>;
+
+// CHECK-LABEL: def test_07 {
+// CHECK-NEXT:    list<dag> Input = [(operator A, B)];
+// CHECK-NEXT:  }
+def test_07 : Child<(operator (operator A, B))>;
+
+////////////////////////////////////////////////////////////////////////////////
+// Make sure we can use defvar without knowing the underlying type of
+// the argument of the dag in a multiclass;
+
+class UseBase<list<Base> x> {
+  list<Base> X = x;
+}
+multiclass UseDefVar<dag input> {
+  defvar Input = !getdagargs<Base>(input);
+  def _def: UseBase<Input>;
+}
+
+// CHECK-LABEL: def test_08_def {
+// CHECK-NEXT:    list<Base> X = [A, B];
+// CHECK-NEXT:  }
+defm test_08 : UseDefVar<(operator A, B)>;
+
+////////////////////////////////////////////////////////////////////////////////
+// Make sure the type of the result of !getdagargs can be enquired by
+// other operators
+
+class ChildWithSubListUse<dag input> : Parent<[!head(!getdagargs<dag>(input))]>;
+
+// CHECK-LABEL: def test_09 {
+// CHECK-NEXT:    list<dag> Input = [(operator A, B)];
+// CHECK-NEXT:  }
+def test_09 : ChildWithSubListUse<(operator (operator A, B), (A operator, B))>;
+
+////////////////////////////////////////////////////////////////////////////////
+// A dag that does not have uniform operands.
+
+class BaseA;
+class BaseB;
+class CommonParent;
+
+def InstanceOfBaseA : BaseA, CommonParent;
+def InstanceOfBaseB : BaseB, CommonParent;
+class Extractor<dag input> {
+  list<CommonParent> ExtractedList = !getdagargs<CommonParent>(input);
+}
+
+def test_10 : Extractor<(operator InstanceOfBaseA, InstanceOfBaseB)>;
+