[TableGen] Permit dag operators to be unset.

[simon_tatham]

Summary

This is not a new semantic feature. The syntax (? 1, 2, 3) was
disallowed by the parser in a dag expression, but there were
already ways to sneak a ? into the operator field of a dag
value, e.g. by initializing it from a class template parameter
which is then set to ? by the instantiating def.

This patch makes ? in the operator slot syntactically legal, so it's
now easy to construct dags with an unset operator. Also, the semantics
of !con are relaxed so that it will allow a combination of set and
unset operator fields in the dag nodes it's concatenating, with the
restriction that all the operators that are not unset still have
to agree with each other.

[hfinkel]

LGTM

[nhaehnle]

LGTM

llvm/lib/TableGen/Record.cpp

 Init *BinOpInit::Fold(Record *CurRec) const {
   switch (getOpcode()) {
   case CONCAT: {
     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)
+      if ((!LOp && !isa<UnsetInit>(LHSs->getOperator())) ||
+          (!ROp && !isa<UnsetInit>(RHSs->getOperator())))
         break;
-      if (LOp->getDef() != ROp->getDef()) {
+      if (LOp && ROp && LOp->getDef() != ROp->getDef()) {
         PrintFatalError(Twine("Concatenated Dag operators do not match: '") +
                         LHSs->getAsString() + "' vs. '" + RHSs->getAsString() +
                         "'");
       }
+      Init *Op = LOp ? LOp : ROp;
+      if (!Op)
+        Op = UnsetInit::get();
+
       SmallVector<Init*, 8> Args;
       SmallVector<StringInit*, 8> ArgNames;
       for (unsigned i = 0, e = LHSs->getNumArgs(); i != e; ++i) {
         Args.push_back(LHSs->getArg(i));
         ArgNames.push_back(LHSs->getArgName(i));
       }
       for (unsigned i = 0, e = RHSs->getNumArgs(); i != e; ++i) {
         Args.push_back(RHSs->getArg(i));
         ArgNames.push_back(RHSs->getArgName(i));
       }
-      return DagInit::get(LHSs->getOperator(), nullptr, Args, ArgNames);
+      return DagInit::get(Op, nullptr, Args, ArgNames);
     }
     break;
   }
   case LISTCONCAT: {
     ListInit *LHSs = dyn_cast<ListInit>(LHS);
     ListInit *RHSs = dyn_cast<ListInit>(RHS);
     if (LHSs && RHSs) {
       SmallVector<Init *, 8> Args;

llvm/lib/TableGen/TGParser.cpp

if (!EltTy) {
       }
       DeducedEltTy = EltTy;
     }
 
     return ListInit::get(Vals, DeducedEltTy);
   }
   case tgtok::l_paren: {         // Value ::= '(' IDValue DagArgList ')'
     Lex.Lex();   // eat the '('
-    if (Lex.getCode() != tgtok::Id && Lex.getCode() != tgtok::XCast) {
+    if (Lex.getCode() != tgtok::Id && Lex.getCode() != tgtok::XCast &&
+        Lex.getCode() != tgtok::question) {
       TokError("expected identifier in dag init");
       return nullptr;
     }
 
     Init *Operator = ParseValue(CurRec);
     if (!Operator) return nullptr;
 
     // If the operator name is present, parse it.

llvm/test/TableGen/unsetop.td

+// RUN: llvm-tblgen %s | FileCheck %s
+// RUN: not llvm-tblgen -DERROR %s 2>&1 | FileCheck --check-prefix=ERROR %s
+
+def op;
+def otherop;
+
+def test {
+  // CHECK: dag d = (? "hello":$world);
+  dag d = (? "hello":$world);
+
+  // CHECK: dag undefNeither = (op 1, 2);
+  dag undefNeither = !con((op 1), (op 2));
+  // CHECK: dag undefFirst = (op 1, 2);
+  dag undefFirst   = !con((?  1), (op 2));
+  // CHECK: dag undefSecond = (op 1, 2);
+  dag undefSecond  = !con((op 1), (?  2));
+  // CHECK: dag undefBoth = (? 1, 2);
+  dag undefBoth    = !con((?  1), (?  2));
+
+#ifdef ERROR
+  // ERROR: Concatenated Dag operators do not match: '(op 1)' vs. '(otherop 2)'
+  dag mismatch     = !con((op 1), (otherop 2));
+#endif
+}