TableGen: Allow ? in lists

[nhaehnle]

Summary

This makes using !dag more convenient in some cases.

Change-Id: I0a8c35e15ccd1ecec778fd1c8d64eee38d74517c

[tra]

One test nit. Perhaps should be fixed in a separate patch before this one. LGTM otherwise.

test/TableGen/dag-functional.td

11 ↗

(On Diff #137059)

I assume we do care about the value of the dag ret, not just the fact that the record got defined. If so, I think there's a CHECK missing here and in the rest of the checks in the file.

[nhaehnle]

test/TableGen/dag-functional.td

11 ↗

(On Diff #137059)

Ooops, thanks for pointing that out! :)

llvm/trunk/docs/TableGen/LangIntro.rst

 
 ``!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
-    items is not possible.
+    items is not possible. However, '?' can be used.
 
-    Example: !dag(op, [a1, a2], ["name1", "name2"]) results in
-    (op a1:$name1, a2:$name2).
+    Example: !dag(op, [a1, a2, ?], ["name1", "name2", "name3"]) results in
+    (op a1:$name1, a2:$name2, ?:$name3).
 
 ``!listconcat(a, b, ...)``
     A list value that is the result of concatenating the 'a' and 'b' lists.
     The lists must have the same element type.
     More than two arguments are accepted with the result being the concatenation
     of all the lists given.
 
 ``!strconcat(a, b, ...)``

llvm/trunk/lib/TableGen/TGParser.cpp

if (Lex.getCode() == tgtok::less) {
       }
       Lex.Lex();  // eat the '>'
     }
 
     // Check elements
     RecTy *EltTy = nullptr;
     for (Init *V : Vals) {
       TypedInit *TArg = dyn_cast<TypedInit>(V);
-      if (!TArg) {
-        TokError("Untyped list element");
-        return nullptr;
-      }
+      if (TArg) {
         if (EltTy) {
           EltTy = resolveTypes(EltTy, TArg->getType());
           if (!EltTy) {
             TokError("Incompatible types in list elements");
             return nullptr;
           }
         } else {
           EltTy = TArg->getType();
         }
       }
+    }
 
     if (GivenEltTy) {
       if (EltTy) {
         // Verify consistency
         if (!EltTy->typeIsConvertibleTo(GivenEltTy)) {
           TokError("Incompatible types in list elements");
           return nullptr;
         }

llvm/trunk/test/TableGen/dag-functional.td

 // RUN: llvm-tblgen %s | FileCheck %s
 // XFAIL: vg_leak
 
 // CHECK: --- Defs ---
 
 // CHECK: def A0 {
 // CHECK:   dag ret = (ops);
 // CHECK: }
 
 // CHECK: def A1 {
-// CHECK:   dag ret = (ops 1:$a, 2:$b);
+// CHECK:   dag ret = (ops ?:$a, 1:$b, 2);
 // CHECK: }
 
 // CHECK: def A2 {
 // CHECK:   dag ret = (ops (ops ?:$name):$a, (ops 1):$b, (ops "foo"):$c);
 // CHECK: }
 
 // CHECK: def A3 {
 // CHECK:   dag ret = (ops NodeA0:$a, NodeB0:$b);
class Anode<list<NodeBase> nodes, list<string> names> {
   dag ret = !dag(ops, nodes, names);
 }
 
 class B<list<Node> nodes> {
   dag ret = !foldl((ops), nodes, lhs, rhs, !con(lhs, !dag(ops, [rhs.Val], [rhs.Name])));
 }
 
 def A0 : Aint<[], []>;
-def A1 : Aint<[1, 2], ["a", "b"]>;
+def A1 : Aint<[?, 1, 2], ["a", "b", ?]>;
 
 def A2 : Adag<[(ops $name), (ops 1), (ops "foo")], ["a", "b", "c"]>;
 
 def NodeA0 : NodeA<0>;
 def NodeB0 : NodeB<0>;
 
 def A3 : Anode<[NodeA0, NodeB0], ["a", "b"]>;