[TableGen] Enhance the six comparison bang operators.

[Paul-C-Anagnostopoulos]

Summary

All six comparison operators now work with strings.

In addition, the !eq and !ne operators work with records. This eliminates lots of !cast<string> operations that were necessary to compare record names as strings.

The Programmer's Reference is updated.

[Paul-C-Anagnostopoulos]

llvm/test/TableGen/compare.td

2

Oops, I forgot to add the RUN lines for the errors. I will do this.

[Paul-C-Anagnostopoulos]

I will auto-LGTM this revision in 36 hours.

llvm/docs/TableGen/ProgRef.rst

``!dag(``\ *op*\ ``,`` *arguments*\ ``,`` *names*\ ``)``
     ``(op a1-value:$name1, a2-value:$name2, ?:$name3)``.
 
 ``!empty(``\ *a*\ ``)``
     This operator produces 1 if the string, list, or DAG *a* is empty; 0 otherwise.
     A dag is empty if it has no arguments; the operator does not count.
 
 ``!eq(`` *a*\ `,` *b*\ ``)``
     This operator produces 1 if *a* is equal to *b*; 0 otherwise.
-    The arguments must be ``bit``, ``bits``, ``int``, or ``string`` values.
-    Use ``!cast<string>`` to compare other types of objects.
+    The arguments must be ``bit``, ``bits``, ``int``, ``string``, or 
+    record values. Use ``!cast<string>`` to compare other types of objects.
 
 ``!foldl(``\ *init*\ ``,`` *list*\ ``,`` *acc*\ ``,`` *var*\ ``,`` *expr*\ ``)``
     This operator performs a left-fold over the items in *list*. The
     variable *acc* acts as the accumulator and is initialized to *init*.
     The variable *var* is bound to each element in the *list*. The
     expression is evaluated for each element and presumably uses *acc* and
     *var* to calculate the accumulated value, which ``!foldl`` stores back in
     *acc*. The type of *acc* is the same as *init*; the type of *var* is the
``!foreach(``\ *var*\ ``,`` *sequence*\ ``,`` *expr*\ ``)``
     and then evaluates the expression. The expression presumably refers
     to the variable *var* and calculates the result value.
 
     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``, or ``int`` values.
+    The arguments must be ``bit``, ``bits``, ``int``, or ``string`` values.
 
 ``!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
``!getdagop(``\ *dag*\ ``)`` --or-- ``!getdagop<``\ *type*\ ``>(``\ *dag*\ ``)``
 
     But to create a new DAG node that reuses the operator from another, no
     cast is necessary::
 
       dag d = !dag(!getdagop(someDag), args, names);
 
 ``!gt(``\ *a*\ `,` *b*\ ``)``
     This operator produces 1 if *a* is greater than *b*; 0 otherwise.
-    The arguments must be ``bit``, ``bits``, or ``int`` values.
+    The arguments must be ``bit``, ``bits``, ``int``, or ``string`` values.
 
 ``!head(``\ *a*\ ``)``
     This operator produces the zeroth element of the list *a*.
     (See also ``!tail``.)
 
 ``!if(``\ *test*\ ``,`` *then*\ ``,`` *else*\ ``)``
   This operator evaluates the *test*, which must produce a ``bit`` or
   ``int``. If the result is not 0, the *then* expression is produced; otherwise
   the *else* expression is produced.
 
 ``!interleave(``\ *list*\ ``,`` *delim*\ ``)``
     This operator concatenates the items in the *list*, interleaving the
     *delim* string between each pair, and produces the resulting string.
     The list can be a list of string, int, bits, or bit. An empty list
     results in an empty string. The delimiter can be the empty string.
 
 ``!isa<``\ *type*\ ``>(``\ *a*\ ``)``
     This operator produces 1 if the type of *a* is a subtype of the given *type*; 0
     otherwise.
 
 ``!le(``\ *a*\ ``,`` *b*\ ``)``
     This operator produces 1 if *a* is less than or equal to *b*; 0 otherwise.
-    The arguments must be ``bit``, ``bits``, or ``int`` values.
+    The arguments must be ``bit``, ``bits``, ``int``, or ``string`` values.
 
 ``!listconcat(``\ *list1*\ ``,`` *list2*\ ``, ...)``
     This operator concatenates the list arguments *list1*, *list2*, etc., and
     produces the resulting list. The lists must have the same element type.
 
 ``!listsplat(``\ *value*\ ``,`` *count*\ ``)``
     This operator produces a list of length *count* whose elements are all
     equal to the *value*. For example, ``!listsplat(42, 3)`` results in
     ``[42, 42, 42]``.
 
 ``!lt(``\ *a*\ `,` *b*\ ``)``
     This operator produces 1 if *a* is less than *b*; 0 otherwise.
-    The arguments must be ``bit``, ``bits``, or ``int`` values.
+    The arguments must be ``bit``, ``bits``, ``int``, or ``string`` values.
 
 ``!mul(``\ *a*\ ``,`` *b*\ ``, ...)``
     This operator multiplies *a*, *b*, etc., and produces the product.
 
 ``!ne(``\ *a*\ `,` *b*\ ``)``
     This operator produces 1 if *a* is not equal to *b*; 0 otherwise.
-    The arguments must be ``bit``, ``bits``, ``int``, or ``string`` values.
-    Use ``!cast<string>`` to compare other types of objects.
+    The arguments must be ``bit``, ``bits``, ``int``, ``string``,
+    or record values. Use ``!cast<string>`` to compare other types of objects.
 
 ``!not(``\ *a*\ ``)``
     This operator performs a logical NOT on *a*, which must be
     an integer. The argument 0 results in 1 (true); any other
     argument results in 0 (false).
 
 ``!or(``\ *a*\ ``,`` *b*\ ``, ...)``
     This operator does a bitwise OR on *a*, *b*, etc., and produces the

llvm/lib/TableGen/Record.cpp

case INTERLEAVE: {
     break;
   }
   case EQ:
   case NE:
   case LE:
   case LT:
   case GE:
   case GT: {
-    // try to fold eq comparison for 'bit' and 'int', otherwise fallback
-    // to string objects.
-    IntInit *L =
+    // First see if we have two bit, bits, or int.
+    IntInit *LHSi =
         dyn_cast_or_null<IntInit>(LHS->convertInitializerTo(IntRecTy::get()));
-    IntInit *R =
+    IntInit *RHSi =
         dyn_cast_or_null<IntInit>(RHS->convertInitializerTo(IntRecTy::get()));
 
-    if (L && R) {
+    if (LHSi && RHSi) {
       bool Result;
       switch (getOpcode()) {
-      case EQ: Result = L->getValue() == R->getValue(); break;
-      case NE: Result = L->getValue() != R->getValue(); break;
-      case LE: Result = L->getValue() <= R->getValue(); break;
-      case LT: Result = L->getValue() < R->getValue(); break;
-      case GE: Result = L->getValue() >= R->getValue(); break;
-      case GT: Result = L->getValue() > R->getValue(); break;
+      case EQ: Result = LHSi->getValue() == RHSi->getValue(); break;
+      case NE: Result = LHSi->getValue() != RHSi->getValue(); break;
+      case LE: Result = LHSi->getValue() <= RHSi->getValue(); break;
+      case LT: Result = LHSi->getValue() <  RHSi->getValue(); break;
+      case GE: Result = LHSi->getValue() >= RHSi->getValue(); break;
+      case GT: Result = LHSi->getValue() >  RHSi->getValue(); break;
       default: llvm_unreachable("unhandled comparison");
       }
       return BitInit::get(Result);
     }
 
-    if (getOpcode() == EQ || getOpcode() == NE) {
-      StringInit *LHSs = dyn_cast<StringInit>(LHS);
-      StringInit *RHSs = dyn_cast<StringInit>(RHS);
+    // Next try strings.
 
-      // Make sure we've resolved
-      if (LHSs && RHSs) {
-        bool Equal = LHSs->getValue() == RHSs->getValue();
-        return BitInit::get(getOpcode() == EQ ? Equal : !Equal);
+      bool Result;
+      switch (getOpcode()) {
+      case EQ: Result = LHSs->getValue() == RHSs->getValue(); break;
+      case NE: Result = LHSs->getValue() != RHSs->getValue(); break;
+      case LE: Result = LHSs->getValue() <= RHSs->getValue(); break;
+      case LT: Result = LHSs->getValue() <  RHSs->getValue(); break;
+      case GE: Result = LHSs->getValue() >= RHSs->getValue(); break;
+      case GT: Result = LHSs->getValue() >  RHSs->getValue(); break;
+      default: llvm_unreachable("unhandled comparison");
       }
+      return BitInit::get(Result);
+////      bool Equal = LHSs->getValue() == RHSs->getValue();
+////      return BitInit::get(getOpcode() == EQ ? Equal : !Equal);
+    }
+
+    // Finally, !eq and !ne can be used with records.
+    if (getOpcode() == EQ || getOpcode() == NE) {
+      DefInit *LHSd = dyn_cast<DefInit>(LHS);
+      DefInit *RHSd = dyn_cast<DefInit>(RHS);
+      if (LHSd && RHSd)
+        return BitInit::get((getOpcode() == EQ) ? LHSd == RHSd
+                                                : LHSd != RHSd);
     }
 
     break;
   }
   case SETDAGOP: {
     DagInit *Dag = dyn_cast<DagInit>(LHS);
     DefInit *Op = dyn_cast<DefInit>(RHS);
     if (Dag && Op) {

llvm/lib/TableGen/TGParser.cpp

case tgtok::XSetDagOp: { // Value ::= !binop '(' Value ',' Value ')'
     case tgtok::XADD:
     case tgtok::XSUB:
     case tgtok::XMUL:
       Type = IntRecTy::get();
       ArgType = IntRecTy::get();
       break;
     case tgtok::XEq:
     case tgtok::XNe:
-      Type = BitRecTy::get();
-      // ArgType for Eq / Ne is not known at this point
-      break;
     case tgtok::XLe:
     case tgtok::XLt:
     case tgtok::XGe:
     case tgtok::XGt:
       Type = BitRecTy::get();
-      ArgType = IntRecTy::get();
+      // ArgType for the comparison operators is not yet known.
       break;
     case tgtok::XListConcat:
       // We don't know the list type until we parse the first argument
       ArgType = ItemType;
       break;
     case tgtok::XListSplat:
       // Can't do any typechecking until we parse the first argument.
       break;
for (;;) {
                                ArgType->getAsString() + "'");
             return nullptr;
           }
           ArgType = nullptr; // Broken invariant: types not identical.
           break;
         case BinOpInit::EQ:
         case BinOpInit::NE:
           if (!ArgType->typeIsConvertibleTo(IntRecTy::get()) &&
+              !ArgType->typeIsConvertibleTo(StringRecTy::get()) &&
+              !ArgType->typeIsConvertibleTo(RecordRecTy::get({}))) {
+            Error(InitLoc, Twine("expected bit, bits, int, string, or record; "
+                                 "got value of type '") + ArgType->getAsString() + 
+                                 "'");
+            return nullptr;
+          }
+          break;
+        case BinOpInit::LE:
+        case BinOpInit::LT:
+        case BinOpInit::GE:
+        case BinOpInit::GT:
+          if (!ArgType->typeIsConvertibleTo(IntRecTy::get()) &&
               !ArgType->typeIsConvertibleTo(StringRecTy::get())) {
-            Error(InitLoc, Twine("expected int, bits, or string; got value of "
-                                 "type '") + ArgType->getAsString() + "'");
+            Error(InitLoc, Twine("expected bit, bits, int, or string; "
+                                 "got value of type '") + ArgType->getAsString() + 
+                                 "'");
             return nullptr;
           }
           break;
         case BinOpInit::INTERLEAVE:
           switch (InitList.size()) {
           case 1: // First argument must be a list of strings or integers.
             if (ArgType != StringRecTy::get()->getListTy() &&
                 !ArgType->typeIsConvertibleTo(IntRecTy::get()->getListTy())) {

llvm/test/TableGen/compare.td

 // RUN: llvm-tblgen %s | FileCheck %s
 // XFAIL: vg_leak
 
-// CHECK: --- Defs ---
+// This file tests the comparison bang operators.
+
+class BitCompare<bit a, bit b> {
+  list<bit> compare = [!eq(a, b), !ne(a, b),
+                       !lt(a, b), !le(a, b),
+                       !gt(a, b), !ge(a, b)];
+}
+
+class BitsCompare<bits<3> a, bits<3> b> {
+  list<bit> compare = [!eq(a, b), !ne(a, b),
+                       !lt(a, b), !le(a, b),
+                       !gt(a, b), !ge(a, b)];
+}
+
+class IntCompare<int a, int b> {
+  list<bit> compare = [!eq(a, b), !ne(a, b),
+                       !lt(a, b), !le(a, b),
+                       !gt(a, b), !ge(a, b)];
+}
+
+class StringCompare<string a, string b> {
+  list<bit> compare = [!eq(a, b), !ne(a, b),
+                       !lt(a, b), !le(a, b),
+                       !gt(a, b), !ge(a, b)];
+}
+
+multiclass MC {
+  def _MC;
+}
+
+// CHECK: def Bit00
+// CHECK:   compare = [1, 0, 0, 1, 0, 1];
+// CHECK: def Bit01
+// CHECK:   compare = [0, 1, 1, 1, 0, 0];
+// CHECK: def Bit10
+// CHECK:   compare = [0, 1, 0, 0, 1, 1];
+// CHECK: def Bit11
+// CHECK:   compare = [1, 0, 0, 1, 0, 1];
+
+def Bit00 : BitCompare<0, 0>;
+def Bit01 : BitCompare<0, 1>;
+def Bit10 : BitCompare<1, 0>;
+def Bit11 : BitCompare<1, 1>;
+
+// CHECK: def Bits1
+// CHECK:   compare = [0, 1, 1, 1, 0, 0];
+// CHECK: def Bits2
+// CHECK:   compare = [1, 0, 0, 1, 0, 1];
+// CHECK: def Bits3
+// CHECK:   compare = [0, 1, 0, 0, 1, 1];
+
+def Bits1 : BitsCompare<{0, 1, 0}, {1, 0, 1}>;
+def Bits2 : BitsCompare<{0, 1, 1}, {0, 1, 1}>;
+def Bits3 : BitsCompare<{1, 1, 1}, {0, 1, 1}>;
+
+// CHECK: def Int1
+// CHECK:   compare = [0, 1, 1, 1, 0, 0];
+// CHECK: def Int2
+// CHECK:   compare = [1, 0, 0, 1, 0, 1];
+// CHECK: def Int3
+// CHECK:   compare = [0, 1, 0, 0, 1, 1];
+
+def Int1 : IntCompare<-7, 13>;
+def Int2 : IntCompare<42, 42>;
+def Int3 : IntCompare<108, 42>;
+
+// CHECK: def Record1
+// CHECK:   compare1 = [1, 0];
+// CHECK:   compare2 = [0, 1];
+// CHECK:   compare3 = [1, 1];
+
+defm foo : MC;
+defm bar : MC;
+
+def Record1 {
+  list<bit> compare1 = [!eq(Bit00, Bit00), !eq(Bit00, Bit01)];
+  list<bit> compare2 = [!ne(Bit00, Bit00), !ne(Bit00, Int1)];
+  list<bit> compare3 = [!eq(bar_MC, bar_MC), !ne(bar_MC, foo_MC)];
+}
+
+// CHECK: def String1
+// CHECK:   compare = [0, 1, 1, 1, 0, 0];
+// CHECK: def String2
+// CHECK:   compare = [1, 0, 0, 1, 0, 1];
+// CHECK: def String3
+// CHECK:   compare = [0, 1, 0, 0, 1, 1];
+// CHECK: def String4
+// CHECK:   compare = [0, 1, 0, 0, 1, 1];
+def String1 : StringCompare<"bar", "foo">;
+def String2 : StringCompare<"foo", "foo">;
+def String3 : StringCompare<"foo", "bar">;
+def String4 : StringCompare<"foo", "Foo">;
+
+#ifdef ERROR1
+
+// ERROR1: expected bit, bits, int, string, or record; got value
+
+def Zerror1 {
+  bit compare1 = !eq([0, 1, 2], [0, 1, 2]);
+}
+
+#endif
+
+#ifdef ERROR2
+
+// ERROR2: expected bit, bits, int, or string; got value
+
+def Zerror2 {
+  bit compare1 = !lt(Bit00, Bit00);
+}
+
+#endif
 
-// CHECK: def A0 {
-// CHECK:   bit eq = 1;
-// CHECK:   bit ne = 0;
-// CHECK:   bit le = 1;
-// CHECK:   bit lt = 0;
-// CHECK:   bit ge = 1;
-// CHECK:   bit gt = 0;
-// CHECK: }
-
-// CHECK: def A1 {
-// CHECK:   bit eq = 0;
-// CHECK:   bit ne = 1;
-// CHECK:   bit le = 1;
-// CHECK:   bit lt = 1;
-// CHECK:   bit ge = 0;
-// CHECK:   bit gt = 0;
-// CHECK: }
-
-// CHECK: def A2 {
-// CHECK:   bit eq = 0;
-// CHECK:   bit ne = 1;
-// CHECK:   bit le = 0;
-// CHECK:   bit lt = 0;
-// CHECK:   bit ge = 1;
-// CHECK:   bit gt = 1;
-// CHECK: }
-
-// CHECK: def A3 {
-// CHECK:   bit eq = 0;
-// CHECK:   bit ne = 1;
-// CHECK:   bit le = 0;
-// CHECK:   bit lt = 0;
-// CHECK:   bit ge = 1;
-// CHECK:   bit gt = 1;
-// CHECK: }
-
-class A<int x, int y> {
-  bit eq = !eq(x, y);
-  bit ne = !ne(x, y);
-  bit le = !le(x, y);
-  bit lt = !lt(x, y);
-  bit ge = !ge(x, y);
-  bit gt = !gt(x, y);
-}
-
-def A0 : A<-3, -3>;
-def A1 : A<-1, 4>;
-def A2 : A<3, -2>;
-def A3 : A<4, 2>;