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

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

Ooops, thanks for pointing that out! :)

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;
         }

test/TableGen/dag-functional.td

 // RUN: llvm-tblgen %s | FileCheck %s
 // XFAIL: vg_leak
 
 // CHECK: --- Defs ---
 
 // CHECK: def A0 {
 //   dag ret = (ops);
 // }
 
 // CHECK: def A1 {
-//   dag ret = (ops 1:$a, 2:$b);
+//   dag ret = (ops ?:$a, 1:$b, 2);
 // }
 
 // CHECK: def B0 {
 //   dag ret = (ops);
 // }
 
 // CHECK: def B1 {
 //   dag ret = (ops 1:$a, 2:$b);
class Node<int val, string name> {
   string Name = name;
 }
 
 class B<list<Node> nodes> {
   dag ret = !foldl((ops), nodes, lhs, rhs, !con(lhs, !dag(ops, [rhs.Val], [rhs.Name])));
 }
 
 def A0 : A<[], []>;
-def A1 : A<[1, 2], ["a", "b"]>;
+def A1 : A<[?, 1, 2], ["a", "b", ?]>;
 
 def B0 : B<[]>;
 def B1 : B<[Node<1, "a">, Node<2, "b">]>;
 
 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"]>;