[TableGen] Add a permissive version of !con.

[simon_tatham]

Summary

It can be inconvenient that !con will only let you concatenate dag
nodes if their operators match, because sometimes you need to combine
a dag fragment you've already got (e.g. passed in as a template
argument) with an operator you're making up on the spot (e.g. by
instantiating some other templated class, or constructing a string and
casting it to a record).

This patch introduces !conp, which works just like !con except
that it uses the operator from its first argument, and doesn't care
what the operators of subsequent arguments are.

!conp provides an alternative approach to programmatic dag node
construction, without the limitation of !dag that all the arguments
have to be of the same type: now you can give your sublists of dag
arguments in dag form, so they can take any types valid in a dag at
all, even if they're all different.

Another simple use of !conp is to replace just the operator of an
existing dag: !conp((foo), (bar x, y, z)) returns (foo x, y, z).

[simon_tatham]

(The name !conp was just the first name that sprang to my fingers when I had to call it something. I don't at all mind changing the name to something completely different, but I'd prefer it if it was still something reasonably short :-)

[hfinkel]

Did you consider introducing something to change the dag operator instead of this? I think it might be cleaner to have some kind of thing which changes the dag operator, and after that, if you wish to !con them, everything works as expected.

[simon_tatham]

Yes, I did. I prefer this way, because it comes out considerably shorter in the use case I had in mind. Compare these two (inside a templated class with a parameter dag extraArgs which might be, say, (args 3, 4)):

dag d = !conp((MyRealOperator<...> a, b), extraArgs);
dag d = !setop(MyRealOperator<...>, !con((args a, b), extraArgs));

But I can implement !setop if you prefer. (And while I'm at it, perhaps !getop too.)

[simon_tatham]

Another even sillier thought I considered was to change !con itself so that it can accept an unset ? value as a dag operator, and only insists that the operands that have defined operators should all agree with each other. That would have been even terser!

But you can't write a dag with an unset operator node easily: (? 1, 2, 3) isn't valid input syntax for a dag, even though there are things you can do that will cause -print-records to produce it as output. Also, it's surely setting a bad precedent...

[hfinkel]

But I can implement !setop if you prefer. (And while I'm at it, perhaps !getop too.)

Personally, I'd prefer this. I realize that the code is longer, but I think it will be much clearer what's going on.

[nhaehnle]

I don't feel particularly strongly either way, but it seems to me that allowing an unset operator could perhaps be the most elegant solution after all. I'm lacking the context of your particular use case, but it seems to me you're attempting to piece together DAG fragments in a generic way where the operator simply isn't known yet by some of the pieces of TableGen you're writing, and using an unset operator could be a more natural way of expressing that than coming up with some artificial operator that is simply thrown away later.

[simon_tatham]

I think !getop and !setop are likely to be useful whether or not I end up using them for this particular use case, so I've written them anyway, and submitted them as the separate patch D71191.

[simon_tatham]

In D71115#1774317, @nhaehnle wrote:

using an unset operator could be a more natural way of expressing that than coming up with some artificial operator that is simply thrown away later.

Artificial operators are quite common already in the Tablegen idiom, though, to get round the fact that all dags have to have an operator. For example, the inputs and outputs of MC instructions have the form of dags so that each one can have a type and a name, and then they have to have the dummy operators ins and outs because something has to go in the operator slot.

But if you're not opposed to making an unset dag operator legal, then I'll at least look into it!

[simon_tatham]

And D71195 is the change to allow dag operators to be ?. Now I have three potential ways to do the thing I wanted :-)

[simon_tatham]

D71191 and D71195 are both now committed (thanks!), so I have a choice of two ways to achieve my original objective, and no further need for this third one.

llvm/docs/TableGen/LangIntro.rst

``foreach <var> = {0-15,32-47} in ...``
     Loop over ranges of integers. The braces are required for multiple ranges.
 
 ``(DEF a, b)``
     a dag value.  The first element is required to be a record definition, the
     remaining elements in the list may be arbitrary other values, including
     nested ```dag``' values.
 
 ``!con(a, b, ...)``
-    Concatenate two or more DAG nodes. Their operations must equal.
 
-    Example: !con((op a1:$name1, a2:$name2), (op b1:$name3)) results in
-    the DAG node (op a1:$name1, a2:$name2, b1:$name3).
+``!conp(a, b, ...)``
+    Concatenate two or more DAG nodes. For ``!con``, their operations must be
+    equal. For ``!conp`` ('permissive'), they need not be equal, and the first
+    DAG node's operation is copied into the result.
+
+    Example: ``!con((op a1:$name1, a2:$name2), (op b1:$name3))`` results in
+    the DAG node ``(op a1:$name1, a2:$name2, b1:$name3)``.
+
+    ``!conp((FirstOp a1:$name1, a2:$name2), (SecondOp b1:$name3))`` results in
+    the DAG node ``(FirstOp a1:$name1, a2:$name2, b1:$name3)``. This would be
+    an error if it had used ``!con`` instead of ``!conp``.
 
 ``!dag(op, children, names)``
     Generate a DAG node programmatically. 'children' and 'names' must be lists
     of equal length or unset ('?'). 'names' must be a 'list<string>'.
 
     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

llvm/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     !listsplat
+               :!gt     !ne      !mul     !listsplat !conp
 
 TableGen also has !cond operator that needs a slightly different
 syntax compared to other "bang operators":
 
 .. productionlist::
    CondOperator: !cond
 
 

llvm/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,
-                            LISTSPLAT, STRCONCAT, CONCAT, EQ, NE, LE, LT, GE,
-                            GT };
+                            LISTSPLAT, STRCONCAT, CONCAT, CONCAT_PERMISSIVE,
+                            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:

llvm/lib/TableGen/Record.cpp

 }
 
 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: {
+  case CONCAT:
+  case CONCAT_PERMISSIVE: {
     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());
       if (!LOp || !ROp)
         break;
-      if (LOp->getDef() != ROp->getDef()) {
+      if (getOpcode() != CONCAT_PERMISSIVE && LOp->getDef() != ROp->getDef()) {
         PrintFatalError(Twine("Concatenated Dag operators do not match: '") +
                         LHSs->getAsString() + "' vs. '" + RHSs->getAsString() +
                         "'");
       }
       SmallVector<Init*, 8> Args;
       SmallVector<StringInit*, 8> ArgNames;
       for (unsigned i = 0, e = LHSs->getNumArgs(); i != e; ++i) {
         Args.push_back(LHSs->getArg(i));
return (BinOpInit::get(getOpcode(), lhs, rhs, getType()))
         ->Fold(R.getCurrentRecord());
   return const_cast<BinOpInit *>(this);
 }
 
 std::string BinOpInit::getAsString() const {
   std::string Result;
   switch (getOpcode()) {
   case CONCAT: Result = "!con"; break;
+  case CONCAT_PERMISSIVE: Result = "!conp"; break;
   case ADD: Result = "!add"; break;
   case MUL: Result = "!mul"; break;
   case AND: Result = "!and"; break;
   case OR: Result = "!or"; break;
   case SHL: Result = "!shl"; break;
   case SRA: Result = "!sra"; break;
   case SRL: Result = "!srl"; break;
   case EQ: Result = "!eq"; break;

llvm/lib/TableGen/TGLexer.h

enum TokKind {
 
     // 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, XListSplat,
     XStrConcat, XCast, XSubst, XForEach, XFoldl, XHead, XTail, XSize, XEmpty,
-    XIf, XCond, XEq, XIsA, XDag, XNe, XLe, XLt, XGe, XGt,
+    XIf, XCond, XEq, XIsA, XDag, XNe, XLe, XLt, XGe, XGt, XConcatP,
 
     // Integer value.
     IntVal,
 
     // Binary constant.  Note that these are sized according to the number of
     // bits given.
     BinaryIntVal,
 

llvm/lib/TableGen/TGLexer.cpp

tgtok::TokKind Kind =
     .Case("gt", tgtok::XGt)
     .Case("if", tgtok::XIf)
     .Case("cond", tgtok::XCond)
     .Case("isa", tgtok::XIsA)
     .Case("head", tgtok::XHead)
     .Case("tail", tgtok::XTail)
     .Case("size", tgtok::XSize)
     .Case("con", tgtok::XConcat)
+    .Case("conp", tgtok::XConcatP)
     .Case("dag", tgtok::XDag)
     .Case("add", tgtok::XADD)
     .Case("mul", tgtok::XMUL)
     .Case("and", tgtok::XAND)
     .Case("or", tgtok::XOR)
     .Case("shl", tgtok::XSHL)
     .Case("sra", tgtok::XSRA)
     .Case("srl", tgtok::XSRL)

llvm/lib/TableGen/TGParser.cpp

if (Lex.getCode() != tgtok::r_paren) {
       return nullptr;
     }
     Lex.Lex(); // eat the ')'
 
     return (IsAOpInit::get(Type, LHS))->Fold();
   }
 
   case tgtok::XConcat:
+  case tgtok::XConcatP:
   case tgtok::XADD:
   case tgtok::XMUL:
   case tgtok::XAND:
   case tgtok::XOR:
   case tgtok::XSRA:
   case tgtok::XSRL:
   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::XConcatP: Code = BinOpInit::CONCAT_PERMISSIVE; 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::XConcat:
+    case tgtok::XConcatP:
       Type = DagRecTy::get();
       ArgType = DagRecTy::get();
       break;
     case tgtok::XAND:
     case tgtok::XOR:
     case tgtok::XSRA:
     case tgtok::XSRL:
     case tgtok::XSHL:
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) {
+        Code == BinOpInit::CONCAT || Code == BinOpInit::CONCAT_PERMISSIVE ||
+        Code == BinOpInit::ADD || Code == BinOpInit::MUL ||
+        Code == BinOpInit::AND || Code == BinOpInit::OR) {
       while (InitList.size() > 2) {
         Init *RHS = InitList.pop_back_val();
         RHS = (BinOpInit::get(Code, InitList.back(), RHS, Type))->Fold(CurRec);
         InitList.back() = RHS;
       }
     }
 
     if (InitList.size() == 2)
Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType,
 
   case tgtok::XHead:
   case tgtok::XTail:
   case tgtok::XSize:
   case tgtok::XEmpty:
   case tgtok::XCast:  // Value ::= !unop '(' Value ')'
   case tgtok::XIsA:
   case tgtok::XConcat:
+  case tgtok::XConcatP:
   case tgtok::XDag:
   case tgtok::XADD:
   case tgtok::XMUL:
   case tgtok::XAND:
   case tgtok::XOR:
   case tgtok::XSRA:
   case tgtok::XSRL:
   case tgtok::XSHL:

llvm/test/TableGen/dag-functional.td

 
 // CHECK: def C0 {
 // CHECK:   dag ret1 = (ops ?:$a, ?:$b);
 // CHECK:   dag ret2 = (ops 1, 2);
 // CHECK: }
 
 // CHECK: def D {
 // CHECK:   dag d1 = (ops 1, ?:$name1, 2, 3);
+// CHECK:   dag d2 = (ops 1, ?:$name1, 2, 3);
 // CHECK: }
 
 // CHECK: def E0 {
 // CHECK:   dag ret = (ops 1, 2);
 // CHECK: }
 
 class Ops;
 
 def ops : Ops;
+def dummy : Ops;
+def dummy2 : Ops;
 
 class Node<int val, string name> {
   int Val = val;
   string Name = name;
 }
 
 class Aint<list<int> nodes, list<string> names> {
   dag ret = !dag(ops, nodes, names);
class C<list<int> nodes, list<string> names> {
   dag ret1 = !dag(ops, ?, names);
   dag ret2 = !dag(ops, nodes, ?);
 }
 
 def C0 : C<[1, 2], ["a", "b"]>;
 
 def D {
   dag d1 = !con((ops 1), (ops $name1), (ops), (ops 2, 3));
+  dag d2 = !conp((ops 1), (dummy $name1), (dummy2), (dummy 2, 3));
 }
 
 class E<Ops op> {
   // Allow concatenation of DAG nodes with operators from template arguments.
   dag ret = !con((op 1), (op 2));
 }
 
 def E0 : E<ops>;