[TableGen] Add !getdagargs and !getdagnames

[hliao]

Summary

• This patch proposes to add !getdagargs and !getdagnames bang operators as the inverse operation of !dag. They allow us to examine arguments of a specified dag.

[simon_tatham]

llvm/docs/TableGen/ProgRef.rst

1718–1720

That seems quite restrictive – it means this system can't be used at all in any context where the arguments to a dag are intentionally heterogeneous.

A couple of possible alternatives:

1. Make !getdagargs<T>(dag) return ? without error for each argument whose type isn't T or a subtype.

2. Instead of an operator to fetch all the arguments at once, have an operator to fetch just one at a time, say !getdagarg<T>(dag, index). Then if I have a dag operator that always expects a Foo and a Bar, I can call !getdagarg<Foo>(d, 0) and !getdagarg<Bar>(d, 1).

With option 2, if there were also an operator to return the number of arguments, then you could still get a list of all of them using !foreach.

[Paul-C-Anagnostopoulos]

I agree with Simon's suggestions.

I also suggest that the tests include some dags that are more complex, with nested dags as operands. And, given Simon's suggestions, some non-homogeneous dags.

[hliao]

llvm/docs/TableGen/ProgRef.rst

1718–1720

Yes, for completeness, !getdagarg(arg, name) and !getdagarg(arg, idx) (without casting to T) are the 2nd part I was preparing together with !getdagname(arg, idx).
I will update the patch to allow arguments with non-common type returned as ?.

[hliao]

Now return ? if an argument has unmatching type. Tests are updated.

[hliao]

Rebase

[hliao]

Allow convertible types and update tests

[hliao]

The alternative approach is uploaded @ https://reviews.llvm.org/D151602

[hliao]

Fix clang-format issue

[hliao]

Rebase and ping for review. The alternative approach is posted @ https://reviews.llvm.org/D151602

[fpetrogalli]

Hey @hliao - thank you for this patch. Apparently we had a similar idea D151702 :)

I just have a couple of comments.

Thanks!

Francesco

llvm/docs/TableGen/ProgRef.rst

1718–1720

You might want to rephrase this sentence. It can be interpreted as "we return ? as the overall result of the operation if any of the arguments cannot be cast to <type>", which is not what you do in your tests, you return ? only for the argument that cannot be cast to type.

Having said that, I'd prefer to avoid this behaviour, and opt for an error, for 2 reasons:

1. If we require the user to specify <type>, we can assume that the user to know what they are doing. Prompting an error would be informative, and could prevent sessions of debugging yablegen failures that might happen quite far away from where the real issue is.
2. At the end of the day, if we decide to return ? for arguments that cannot be cast, we could avoid to require the type argument in the operator, and just get it from the first element of the list, or programmatically find a common ancestor in the types of the arguments.

In my version I opted for the error: https://reviews.llvm.org/differential/changeset/?ref=4198690

Of course, the whole discussion around this fails if you have uses cases in which you "need" to return ? (I didn't have those...)

1722

Why do you need to specify <type> in here? Isn't it obvious a list of strings will be returned? Or do we get issues with those arguments whose name is unset and need to be returned as ?.

llvm/lib/TableGen/TGLexer.h

38

Do you need to clang-format these file? I preferred the original formatting. Please consider reverting back to the original format, just add the two new enums for the operators you have added in the list for bang operators.

llvm/test/TableGen/getsetop.td

72

Would it make sense to have these tests in a separate file, specifically for the two new operators?

[hliao]

In D151457#4380793, @fpetrogalli wrote:

Hey @hliao - thank you for this patch. Apparently we had a similar idea D151702 :)

I just have a couple of comments.

Thanks!

Francesco

I proposed another change introducing !getdagarg and !getdagname to access individual arguments instead of a list of them. Personally, I thought that should be more convenient.

[fpetrogalli]

In D151457#4382119, @hliao wrote:

In D151457#4380793, @fpetrogalli wrote:

Hey @hliao - thank you for this patch. Apparently we had a similar idea D151702 :)

I just have a couple of comments.

Thanks!

Francesco

I proposed another change introducing !getdagarg and !getdagname to access individual arguments instead of a list of them. Personally, I thought that should be more convenient.

Does it mean that you want to abandon this change?

[hliao]

In D151457#4383385, @fpetrogalli wrote:

In D151457#4382119, @hliao wrote:

In D151457#4380793, @fpetrogalli wrote:

Hey @hliao - thank you for this patch. Apparently we had a similar idea D151702 :)

I just have a couple of comments.

Thanks!

Francesco

I proposed another change introducing !getdagarg and !getdagname to access individual arguments instead of a list of them. Personally, I thought that should be more convenient.

Does it mean that you want to abandon this change?

yeah, !getdagargs could be built upon !getdagarg. For example, given a dag input, !getdagargs<T>(input) could be implemented as

!foreach(i, !range(!size(input)), !getdagarg<T>(input, i)

Even though a little bit verbose, getdagarg allows us to examine an individual argument without fetching all arguments. In addition, we also allow using the argument name in addition to the argument index. That allows us to check arguments based on their names conveniently.

[hliao]

As getdagargs and getdagnames could be implemented upon getdagarg and getdagname, this patch is redundant.

llvm/docs/TableGen/ProgRef.rst

 --------------
 
 TableGen provides "bang operators" that have a wide variety of uses:
 
 .. productionlist::
    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
+               : !find        !foldl       !foreach     !ge          !getdagargs
+               : !getdagnames !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
 
 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.

 
 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 argument in a DAG with a particular meaning,
 or to associate an argument in one DAG with a like-named argument in another
 DAG.
 
 The following bang operators are useful for working with DAGs:
-``!con``, ``!dag``, ``!empty``, ``!foreach``, ``!getdagop``, ``!setdagop``, ``!size``.
+``!con``, ``!dag``, ``!empty``, ``!foreach``, ``!getdagargs``,
+``!getdagnames``, ``!getdagop``, ``!setdagop``, ``!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. Template arguments of ``class`` or ``multiclass`` can be
 used in the value expression. The scope of the variable extends from the
``!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 produces the list of arguments of the specified common *type*
+    from the given *dag* node. Due to limitations of the type system, if not
+    all arguments are not of the specified type or derived from the specified
+    base class, ``?`` is returned instead.
+
+``!getdagnames<``\ *type*\ ``>(``\ *dag*\ ``)``
+    This operator produces the list of argument names from the given *dag*
+    node. ``?`` is used for unnamed arguments.
+
 ``!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,
+    GETDAGARGS,
+    GETDAGNAMES,
     LOG2
   };
 
 private:
   Init *LHS;
 
   UnOpInit(UnaryOp opc, Init *lhs, RecTy *Type)
     : OpInit(IK_UnOpInit, Type, opc), LHS(lhs) {}

llvm/lib/TableGen/Record.cpp

if (DagInit *Dag = dyn_cast<DagInit>(LHS)) {
                         DI->getType()->getAsString() + "' in: " +
                         getAsString() + "\n");
       } else {
         return DI;
       }
     }
     break;
 
+  case GETDAGARGS:
+    if (DagInit *Dag = dyn_cast<DagInit>(LHS)) {
+      SmallVector<Init *, 8> Args;
+      RecTy *EltTy = cast<ListRecTy>(getType())->getElementType();
+      for (unsigned i = 0, e = Dag->getNumArgs(); i != e; ++i) {
+        Init *Arg = Dag->getArg(i);
+        // Check argument types. If it's a typed value but not the same type or
+        // derived from the same base class, return `?` instead.
+        if (TypedInit *TI = dyn_cast<TypedInit>(Dag->getArg(i))) {
+          if (!TI->getType()->typeIsConvertibleTo(EltTy))
+            Arg = UnsetInit::get(RK);
+        }
+        Args.push_back(Arg);
+      }
+      return ListInit::get(Args, EltTy);
+    }
+    break;
+
+  case GETDAGNAMES:
+    if (DagInit *Dag = dyn_cast<DagInit>(LHS)) {
+      SmallVector<Init *, 8> ArgNames;
+      for (unsigned i = 0, e = Dag->getNumArgs(); i != e; ++i) {
+        Init *ArgName = Dag->getArgName(i);
+        if (!ArgName)
+          ArgName = UnsetInit::get(RK);
+        ArgNames.push_back(ArgName);
+      }
+      return ListInit::get(ArgNames, StringRecTy::get(Dag->getRecordKeeper()));
+    }
+    break;
+
   case LOG2:
     if (IntInit *LHSi = dyn_cast_or_null<IntInit>(
             LHS->convertInitializerTo(IntRecTy::get(RK)))) {
       int64_t LHSv = LHSi->getValue();
       if (LHSv <= 0) {
         PrintFatalError(CurRec->getLoc(),
                         "Illegal operation: logtwo is undefined "
                         "on arguments less than or equal to 0");
std::string UnOpInit::getAsString() const {
   switch (getOpcode()) {
   case CAST: Result = "!cast<" + getType()->getAsString() + ">"; break;
   case NOT: Result = "!not"; break;
   case HEAD: Result = "!head"; break;
   case TAIL: Result = "!tail"; break;
   case SIZE: Result = "!size"; break;
   case EMPTY: Result = "!empty"; break;
   case GETDAGOP: Result = "!getdagop"; break;
+  case GETDAGARGS:
+    Result = "!getdagargs<" +
+             cast<ListRecTy>(getType())->getElementType()->getAsString() + ">";
+    break;
+  case GETDAGNAMES:
+    Result = "!getdagnames";
+    break;
   case LOG2 : Result = "!logtwo"; break;
   case TOLOWER:
     Result = "!tolower";
     break;
   case TOUPPER:
     Result = "!toupper";
     break;
   }

llvm/lib/TableGen/TGLexer.h

 namespace llvm {
 template <typename T> class ArrayRef;
 class SourceMgr;
 class Twine;
 
 namespace tgtok {
 enum TokKind {
   // Markers
-    Eof, Error,
+  Eof,
+  Error,
 
   // Tokens with no info.
-    minus, plus,        // - +
-    l_square, r_square, // [ ]
-    l_brace, r_brace,   // { }
-    l_paren, r_paren,   // ( )
-    less, greater,      // < >
-    colon, semi,        // : ;
-    comma, dot,         // , .
-    equal, question,    // = ?
-    paste,              // #
-    dotdotdot,          // ...
+  minus,
+  plus, // - +
+  l_square,
+  r_square, // [ ]
+  l_brace,
+  r_brace, // { }
+  l_paren,
+  r_paren, // ( )
+  less,
+  greater, // < >
+  colon,
+  semi, // : ;
+  comma,
+  dot, // , .
+  equal,
+  question,  // = ?
+  paste,     // #
+  dotdotdot, // ...
 
   // Reserved keywords. ('ElseKW' is named to distinguish it from the
   // existing 'Else' that means the preprocessor #else.)
-    Assert, Bit, Bits, Class, Code, Dag, Def, Defm, Defset, Defvar, ElseKW,
-    FalseKW, Field, Foreach, If, In, Include, Int, Let, List, MultiClass,
-    String, Then, TrueKW,
+  Assert,
+  Bit,
+  Bits,
+  Class,
+  Code,
+  Dag,
+  Def,
+  Defm,
+  Defset,
+  Defvar,
+  ElseKW,
+  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,
+  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,
+  XGetDagArgs,
+  XGetDagNames,
 
   // Boolean literals.
-    TrueVal, FalseVal,
+  TrueVal,
+  FalseVal,
 
   // Integer value.
   IntVal,
 
   // Binary constant.  Note that these are sized according to the number of
   // bits given.
   BinaryIntVal,
 
   // String valued tokens.
-    Id, StrVal, VarName, CodeFragment,
+  Id,
+  StrVal,
+  VarName,
+  CodeFragment,
 
   // Preprocessing tokens for internal usage by the lexer.
   // They are never returned as a result of Lex().
-    Ifdef, Ifndef, Else, Endif, Define
+  Ifdef,
+  Ifndef,
+  Else,
+  Endif,
+  Define
 };
 }
 
 /// TGLexer - TableGen Lexer class.
 class TGLexer {
   SourceMgr &SrcMgr;
 
   const char *CurPtr = nullptr;

llvm/lib/TableGen/TGLexer.cpp

tgtok::TokKind Kind =
           .Case("listremove", tgtok::XListRemove)
           .Case("range", tgtok::XRange)
           .Case("strconcat", tgtok::XStrConcat)
           .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("getdagargs", tgtok::XGetDagArgs)
+          .Case("getdagnames", tgtok::XGetDagNames)
           .Case("exists", tgtok::XExists)
           .Case("tolower", tgtok::XToLower)
           .Case("toupper", tgtok::XToUpper)
           .Default(tgtok::Error);
 
   return Kind != tgtok::Error ? Kind : ReturnError(Start-1, "Unknown operator");
 }
 

llvm/lib/TableGen/TGParser.cpp

Init *TGParser::ParseOperation(Record *CurRec, RecTy *ItemType) {
   case tgtok::XToLower:
   case tgtok::XToUpper:
   case tgtok::XLOG2:
   case tgtok::XHead:
   case tgtok::XTail:
   case tgtok::XSize:
   case tgtok::XEmpty:
   case tgtok::XCast:
+  case tgtok::XGetDagArgs:
+  case tgtok::XGetDagNames:
   case tgtok::XGetDagOp: { // Value ::= !unop '(' Value ')'
     UnOpInit::UnaryOp Code;
     RecTy *Type = nullptr;
 
     switch (Lex.getCode()) {
     default: llvm_unreachable("Unhandled code!");
     case tgtok::XCast:
       Lex.Lex();  // eat the operation
case tgtok::XGetDagOp:
           TokError("type for !getdagop must be a record type");
           // but keep parsing, to consume the operand
         }
       } else {
         Type = RecordRecTy::get(Records, {});
       }
       Code = UnOpInit::GETDAGOP;
       break;
+    case tgtok::XGetDagArgs:
+      Lex.Lex(); // eat the operation
+      Code = UnOpInit::GETDAGARGS;
+      Type = ParseOperatorType();
+      if (!Type) {
+        TokError("did not get type for !getdagtypes operator");
+        return nullptr;
+      }
+      Type = ListRecTy::get(Type);
+      break;
+    case tgtok::XGetDagNames:
+      Lex.Lex(); // eat the operation
+      Code = UnOpInit::GETDAGNAMES;
+      Type = ListRecTy::get(StringRecTy::get(Records));
+      break;
     }
     if (!consume(tgtok::l_paren)) {
       TokError("expected '(' after unary operator");
       return nullptr;
     }
 
     Init *LHS = ParseValue(CurRec);
     if (!LHS) return nullptr;
Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType,
 
   case tgtok::XHead:
   case tgtok::XTail:
   case tgtok::XSize:
   case tgtok::XEmpty:
   case tgtok::XCast:
   case tgtok::XToLower:
   case tgtok::XToUpper:
+  case tgtok::XGetDagArgs:
+  case tgtok::XGetDagNames:
   case tgtok::XGetDagOp: // Value ::= !unop '(' Value ')'
   case tgtok::XExists:
   case tgtok::XIsA:
   case tgtok::XConcat:
   case tgtok::XDag:
   case tgtok::XADD:
   case tgtok::XSUB:
   case tgtok::XMUL:

llvm/test/TableGen/getsetop.td

 // RUN: llvm-tblgen %s | FileCheck %s
 // RUN: not llvm-tblgen -DERROR1 %s 2>&1 | FileCheck --check-prefix=ERROR1 %s
 // RUN: not llvm-tblgen -DERROR2 %s 2>&1 | FileCheck --check-prefix=ERROR2 %s
 // RUN: not llvm-tblgen -DERROR3 %s 2>&1 | FileCheck --check-prefix=ERROR3 %s
 
 // !setop and !getop are deprecated in favor of !setdagop and !getdagop.
 // Two tests retain the old names just to be sure they are still supported.
 
 class Base;
 class OtherBase;
 
 def foo: Base;
 def bar: Base;
 def qux: OtherBase;
 
+class OpBase;
+class OpOtherBase;
+
+def opA : OpBase;
+def opB : OpBase;
+def opC : OpOtherBase;
+
 def test {
   dag orig = (foo 1, 2:$a, $b);
   dag another = (qux "hello", $world);
 
   // CHECK: dag replaceWithBar = (bar 1, 2:$a, ?:$b);
   dag replaceWithBar = !setop(orig, bar);
 
   // CHECK: dag replaceWithBaz = (qux 1, 2:$a, ?:$b);

 
 #ifdef ERROR3
   // Obviously, you shouldn't be able to give any type to !getdagop that
   // isn't a class type.
 
   // ERROR3: error: type for !getdagop must be a record type
   int ridiculousCast = !getdagop<int>(orig);
 #endif
+
+  dag in1 = (foo 1:$a, 2:$b, 3:$c);
+  // CHECK: list<int> in1Args = [1, 2, 3];
+  list<int> in1Args = !getdagargs<int>(in1);
+  list<bits<8>> in1ArgsAsB8 = !getdagargs<bits<8>>(in1);
+  // CHECK: list<string> in1Names = ["a", "b", "c"];
+  list<string> in1Names = !getdagnames(in1);
+
+  dag in2 = (foo 1:$a, ?:$b, 3:$c);
+  // CHECK: list<int> in2Args = [1, ?, 3];
+  list<int> in2Args = !getdagargs<int>(in2);
+  // CHECK: list<string> in2Names = ["a", "b", "c"];
+  list<string> in2Names = !getdagnames(in2);
+
+  dag in3 = (foo 1:$a, 2, 3:$c);
+  // CHECK: list<int> in3Args = [1, 2, 3];
+  list<int> in3Args = !getdagargs<int>(in3);
+  // The 2nd argument has no name, `?` is returned.
+  // CHECK: list<string> in3Names = ["a", ?, "c"];
+  list<string> in3Names = !getdagnames(in3);
+
+  dag in4 = (foo 1:$a, "x":$b, 3:$c);
+  // The 2nd argument is not of type `int`, `?` is returned.
+  // CHECK: list<int> in4Args = [1, ?, 3];
+  list<int> in4Args = !getdagargs<int>(in4);
+
+  dag in5 = (foo opA:$a, opB:$b, opC:$c);
+  // The 3rd argument doesn't share the same base class as `OpBase`, `?` is
+  // returned.
+  // CHECK: list<OpBase> in5Args = [opA, opB, ?];
+  list<OpBase> in5Args = !getdagargs<OpBase>(in5);
+
+  dag in6 = (foo opA:$a, opB:$b, opB:$c);
+  // CHECK: list<OpBase> in6Args = [opA, opB, opB];
+  list<OpBase> in6Args = !getdagargs<OpBase>(in6);
+
+  dag in7 = (foo opA:$a, (bar opA:$lhs, opB:$rhs), opB:$c);
+  // The 2nd argument is another dag, `?` is returned.
+  // CHECK: list<OpBase> in7Args = [opA, ?, opB];
+  list<OpBase> in7Args = !getdagargs<OpBase>(in7);
 }