[TableGen] Add the !not and !xor operators.

[Paul-C-Anagnostopoulos]

Summary

This patch adds two new bang operators. !not produces the logical not of its argument. Using this clarifies code such as

!if(!eq(bool, 0), ...  --versus--  !if(!not(bool), ...

The !xor operator completes the usual complement of three bitwise operators.

[lattner]

Makes sense to me. Please do follow-on patches to adopt this in the various users of tblgen. Thanks!

[Paul-C-Anagnostopoulos]

I will look through the various TableGen files and use these where appropriate.

Before I push this, I have to update the TableGen Programmer's Reference.

[Paul-C-Anagnostopoulos]

I update the TableGen Programmer's Reference to document the two new bang operators.

[Paul-C-Anagnostopoulos]

This patch has been pushed.

llvm/docs/TableGen/ProgRef.rst

 
 .. productionlist::
    BangOperator: one of
-               : !add    !and         !cast         !con         !dag
-               : !empty  !eq          !foldl        !foreach     !ge
-               : !getop  !gt          !head         !if          !isa
-               : !le     !listconcat  !listsplat    !lt          !mul
-               : !ne     !or          !setop        !shl         !size
-               : !sra    !srl         !strconcat    !subst       !tail
+               : !add     !and         !cast        !con         !dag
+               : !empty   !eq          !foldl       !foreach     !ge
+               : !getop   !gt          !head        !if          !isa
+               : !le      !listconcat  !listsplat   !lt          !mul
+               : !ne      !not         !or          !setop       !shl
+               : !size    !sra         !srl         !strconcat   !subst
+               : !tail    !xor
 
 The ``!cond`` operator has a slightly different
 syntax compared to other bang operators, so it is defined separately:

 
 ``!and(``\ *a*\ ``,`` *b*\ ``, ...)``
     This operator does a bitwise AND on *a*, *b*, etc., and produces the
-    result.
+    result. A logical AND can be performed if all the arguments are either
+    0 or 1.
 
 ``!cast<``\ *type*\ ``>(``\ *a*\ ``)``
     This operator performs a cast on *a* and produces the result.

     The arguments must be ``bit``, ``int``, or ``string`` 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
-    result.
+    result. A logical OR can be performed if all the arguments are either
+    0 or 1.
 
 ``!setop(``\ *dag*\ ``,`` *op*\ ``)``
     This operator produces a DAG node with the same arguments as *dag*, but with its

     This operator produces a new list with all the elements
     of the list *a* except for the zeroth one. (See also ``!head``.)
 
+``!xor(``\ *a*\ ``,`` *b*\ ``, ...)``
+    This operator does a bitwise EXCLUSIVE OR on *a*, *b*, etc., and produces
+    the result. A logical XOR can be performed if all the arguments are either
+    0 or 1.
+
 
 Appendix B: Sample Record
 =========================

llvm/include/llvm/TableGen/Record.h

 ///
 class UnOpInit : public OpInit, public FoldingSetNode {
 public:
-  enum UnaryOp : uint8_t { CAST, HEAD, TAIL, SIZE, EMPTY, GETOP };
+  enum UnaryOp : uint8_t { CAST, NOT, HEAD, TAIL, SIZE, EMPTY, GETOP };
 
 private:
   Init *LHS;

 /// !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,
+  enum BinaryOp : uint8_t { ADD, MUL, AND, OR, XOR, SHL, SRA, SRL, LISTCONCAT,
                             LISTSPLAT, STRCONCAT, CONCAT, EQ, NE, LE, LT, GE,
                             GT, SETOP };
 

llvm/lib/TableGen/Record.cpp

       return NewInit;
     break;
 
+  case NOT:
+    if (IntInit *LHSi =
+            dyn_cast_or_null<IntInit>(LHS->convertInitializerTo(IntRecTy::get())))
+      return IntInit::get(LHSi->getValue() ? 0 : 1);
+    break;
+
   case HEAD:
     if (ListInit *LHSl = dyn_cast<ListInit>(LHS)) {
       assert(!LHSl->empty() && "Empty list in head");

   std::string Result;
   switch (getOpcode()) {
   case CAST: Result = "!cast<" + getType()->getAsString() + ">"; break;
+  case NOT: Result = "!not"; break;
   case HEAD: Result = "!head"; break;
   case TAIL: Result = "!tail"; break;
   case SIZE: Result = "!size"; break;

   case MUL:
   case AND:
   case OR:
+  case XOR:
   case SHL:
   case SRA:
   case SRL: {

       case ADD: Result = LHSv +  RHSv; break;
       case MUL: Result = LHSv *  RHSv; break;
       case AND: Result = LHSv &  RHSv; break;
-      case OR: Result = LHSv | RHSv; break;
+      case OR:  Result = LHSv | RHSv; break;
+      case XOR: Result = LHSv ^ RHSv; break;
       case SHL: Result = (uint64_t)LHSv << (uint64_t)RHSv; break;
       case SRA: Result = LHSv >> RHSv; break;
       case SRL: Result = (uint64_t)LHSv >> (uint64_t)RHSv; break;

   case MUL: Result = "!mul"; break;
   case AND: Result = "!and"; break;
   case OR: Result = "!or"; break;
+  case XOR: Result = "!xor"; break;
   case SHL: Result = "!shl"; break;
   case SRA: Result = "!sra"; break;
   case SRL: Result = "!srl"; break;

llvm/lib/TableGen/TGLexer.h

     MultiClass, String, Defset, Defvar, If, Then, ElseKW,
 
     // !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, XSetOp, XGetOp,
+    XConcat, XADD, XMUL, XNOT, XAND, XOR, XXOR, XSRA, XSRL, XSHL,
+    XListConcat, XListSplat, XStrConcat, XCast, XSubst, XForEach, XFoldl,
+    XHead, XTail, XSize, XEmpty, XIf, XCond, XEq, XIsA, XDag, XNe, XLe,
+    XLt, XGe, XGt, XSetOp, XGetOp,
 
     // Integer value.
     IntVal,

llvm/lib/TableGen/TGLexer.cpp

     .Case("dag", tgtok::XDag)
     .Case("add", tgtok::XADD)
     .Case("mul", tgtok::XMUL)
+    .Case("not", tgtok::XNOT)
     .Case("and", tgtok::XAND)
     .Case("or", tgtok::XOR)
+    .Case("xor", tgtok::XXOR)
     .Case("shl", tgtok::XSHL)
     .Case("sra", tgtok::XSRA)
     .Case("srl", tgtok::XSRL)

llvm/lib/TableGen/TGParser.cpp

   default:
     TokError("unknown operation");
     return nullptr;
+  case tgtok::XNOT:
   case tgtok::XHead:
   case tgtok::XTail:
   case tgtok::XSize:

         return nullptr;
       }
 
+      break;
+    case tgtok::XNOT:
+      Lex.Lex();  // eat the operation
+      Code = UnOpInit::NOT;
+      Type = IntRecTy::get();
       break;
     case tgtok::XHead:
       Lex.Lex();  // eat the operation

   case tgtok::XMUL:
   case tgtok::XAND:
   case tgtok::XOR:
+  case tgtok::XXOR:
   case tgtok::XSRA:
   case tgtok::XSRL:
   case tgtok::XSHL:

     case tgtok::XMUL:    Code = BinOpInit::MUL; break;
     case tgtok::XAND:    Code = BinOpInit::AND; break;
     case tgtok::XOR:     Code = BinOpInit::OR; break;
+    case tgtok::XXOR:    Code = BinOpInit::XOR; break;
     case tgtok::XSRA:    Code = BinOpInit::SRA; break;
     case tgtok::XSRL:    Code = BinOpInit::SRL; break;
     case tgtok::XSHL:    Code = BinOpInit::SHL; break;

       break;
     case tgtok::XAND:
     case tgtok::XOR:
+    case tgtok::XXOR:
     case tgtok::XSRA:
     case tgtok::XSRL:
     case tgtok::XSHL:

           return nullptr;
         }
         if (Code != BinOpInit::ADD && Code != BinOpInit::AND &&
-            Code != BinOpInit::OR && Code != BinOpInit::SRA &&
-            Code != BinOpInit::SRL && Code != BinOpInit::SHL &&
-            Code != BinOpInit::MUL)
+            Code != BinOpInit::OR && Code != BinOpInit::XOR &&
+            Code != BinOpInit::SRA && Code != BinOpInit::SRL &&
+            Code != BinOpInit::SHL && Code != BinOpInit::MUL)
           ArgType = Resolved;
       }
 

     if (Code == BinOpInit::STRCONCAT || Code == BinOpInit::LISTCONCAT ||
         Code == BinOpInit::CONCAT || Code == BinOpInit::ADD ||
         Code == BinOpInit::AND || Code == BinOpInit::OR ||
-        Code == BinOpInit::MUL) {
+        Code == BinOpInit::XOR || Code == BinOpInit::MUL) {
       while (InitList.size() > 2) {
         Init *RHS = InitList.pop_back_val();
         RHS = (BinOpInit::get(Code, InitList.back(), RHS, Type))->Fold(CurRec);

   case tgtok::XDag:
   case tgtok::XADD:
   case tgtok::XMUL:
+  case tgtok::XNOT:
   case tgtok::XAND:
   case tgtok::XOR:
+  case tgtok::XXOR:
   case tgtok::XSRA:
   case tgtok::XSRL:
   case tgtok::XSHL:

llvm/test/TableGen/arithmetic.td

 // CHECK:   bits<8> add = { 0, 1, 0, 0, 0, 0, 0, 0 };
 // CHECK:   bits<8> and = { 0, 0, 0, 0, 0, 0, 0, 1 };
 // CHECK:   bits<8> or =  { 0, 0, 1, 1, 1, 1, 1, 1 };
+// CHECK:   bits<8> xor = { 0, 0, 1, 1, 1, 1, 1, 0 };
 // CHECK:   bits<8> srl = { 0, 0, 0, 1, 1, 1, 1, 1 };
 // CHECK:   bits<8> sra = { 0, 0, 0, 1, 1, 1, 1, 1 };
 // CHECK:   bits<8> shl = { 0, 1, 1, 1, 1, 1, 1, 0 };

   bits<8> add = !add(a, b);
   bits<8> and = !and(a, b);
   bits<8> or = !or(a, b);
+  bits<8> xor = !xor(a, b);
   bits<8> srl = !srl(a, b);
   bits<8> sra = !sra(a, b);
   bits<8> shl = !shl(a, b);

llvm/test/TableGen/if.td

 def EXd1 : EX<1, E1d, E2d>;
 def EXd2 : EX<0, E1d, E2d>;
 
+// CHECK: def Not1
+// CHECK: Result1a = "OK"
+// CHECK: Result1b = "OK"
+// CHECK: Result1c = "OK"
+// CHECK: Result1d = "OK"
+// CHECK: Result1e = "OK"
+// CHECK: def Not2
+// CHECK: Result2a = "OK"
+// CHECK: Result2b = "OK"
+// CHECK: Result2c = "OK"
+// CHECK: Result2d = "OK"
+
+def Not1 {
+  bit true = 1;
+  string Result1a = !if(true, "OK", "not OK");
+  string Result1b = !if(!not(true), "not OK", "OK");
+
+  bit false = 0;
+  string Result1c = !if(false, "not OK", "OK");
+  string Result1d = !if(!not(false), "OK", "not OK");
+  string Result1e = !if(!not(!not(false)), "not OK", "OK");
+}
+
+def Not2 {
+  int one = 1;
+  string Result2a = !if(one, "OK", "not OK");
+  string Result2b = !if(!not(one), "not OK", "OK");
+
+  int zero = 0;
+  string Result2c = !if(zero, "not OK", "OK");
+  string Result2d = !if(!not(zero), "OK", "not OK");
+}
+
 // CHECK:      def One
 // CHECK-NEXT: list<int> first = [1, 2, 3];
 // CHECK-NEXT: list<int> rest = [1, 2, 3];

llvm/test/TableGen/math.td

 // CHECK: Value = 84
 def v84   : Int<!mul(v12.Value, v7.Value)>;
 
+// CHECK: def v9
+// CHECK: Value = 9
+def v9 : Int<!xor(v7.Value, 0x0E)>;
+
 // CHECK: def v924
 // CHECK: Value = 924
 def v924   : Int<!mul(v84.Value, 11)>;
+
+