TableGen: Add !ne, !le, !lt, !ge, and !gt comparisons

[nhaehnle]

Summary

Change-Id: I8e2ece677268972d578a787467f7ef52a1f33a71

[arsenm]

include/llvm/TableGen/Record.h

806 ↗

(On Diff #137062)

Might as well add NE if you're adding the rest?

[nhaehnle]

Add !ne as well

[arsenm]

LGTM

llvm/trunk/docs/TableGen/LangIntro.rst

 ``!if(a,b,c)``
   'b' if the result of 'int' or 'bit' operator 'a' is nonzero, 'c' otherwise.
 
 ``!eq(a,b)``
     'bit 1' if string a is equal to string b, 0 otherwise.  This only operates
     on string, int and bit objects.  Use !cast<string> to compare other types of
     objects.
 
+``!ne(a,b)``
+    The negation of ``!eq(a,b)``.
+
+``!le(a,b), !lt(a,b), !ge(a,b), !gt(a,b)``
+    (Signed) comparison of integer values that returns bit 1 or 0 depending on
+    the result of the comparison.
+
 ``!shl(a,b)`` ``!srl(a,b)`` ``!sra(a,b)``
     The usual shift operators. Operations are on 64-bit integers, the result
     is undefined for shift counts outside [0, 63].
 
 ``!add(a,b,...)`` ``!and(a,b,...)`` ``!or(a,b,...)``
     The usual arithmetic and binary operators.
 
 Note that all of the values have rules specifying how they convert to values

llvm/trunk/docs/TableGen/LangRef.rst

 wide variety of meanings:
 
 .. productionlist::
    BangOperator: one of
                :!eq     !if      !head    !tail      !con
                :!add    !shl     !sra     !srl       !and
                :!or     !empty   !subst   !foreach   !strconcat
                :!cast   !listconcat       !size      !foldl
-               :!isa    !dag
+               :!isa    !dag     !le      !lt        !ge
+               :!gt     !ne
 
 
 Syntax
 ======
 
 TableGen has an ``include`` mechanism. It does not play a role in the
 syntax per se, since it is lexically replaced with the contents of the
 included file.

llvm/trunk/include/llvm/TableGen/Record.h

public:
 
   std::string getAsString() const override;
 };
 
 /// !op (X, Y) - Combine two inits.
 class BinOpInit : public OpInit, public FoldingSetNode {
 public:
   enum BinaryOp : uint8_t { ADD, AND, OR, SHL, SRA, SRL, LISTCONCAT,
-                            STRCONCAT, CONCAT, EQ };
+                            STRCONCAT, CONCAT, EQ, NE, LE, LT, GE, GT };
 
 private:
   Init *LHS, *RHS;
 
   BinOpInit(BinaryOp opc, Init *lhs, Init *rhs, RecTy *Type) :
       OpInit(IK_BinOpInit, Type, opc), LHS(lhs), RHS(rhs) {}
 
 public:

llvm/trunk/lib/TableGen/Record.cpp

Init *BinOpInit::Fold(Record *CurRec, MultiClass *CurMultiClass) const {
   }
   case STRCONCAT: {
     StringInit *LHSs = dyn_cast<StringInit>(LHS);
     StringInit *RHSs = dyn_cast<StringInit>(RHS);
     if (LHSs && RHSs)
       return ConcatStringInits(LHSs, RHSs);
     break;
   }
-  case EQ: {
+  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 =
         dyn_cast_or_null<IntInit>(LHS->convertInitializerTo(IntRecTy::get()));
     IntInit *R =
         dyn_cast_or_null<IntInit>(RHS->convertInitializerTo(IntRecTy::get()));
 
-    if (L && R)
-      return IntInit::get(L->getValue() == R->getValue());
+    if (L && R) {
+      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;
+      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);
 
       // Make sure we've resolved
-    if (LHSs && RHSs)
-      return IntInit::get(LHSs->getValue() == RHSs->getValue());
+      if (LHSs && RHSs) {
+        bool Equal = LHSs->getValue() == RHSs->getValue();
+        return BitInit::get(getOpcode() == EQ ? Equal : !Equal);
+      }
+    }
 
     break;
   }
   case ADD:
   case AND:
   case OR:
   case SHL:
   case SRA:
std::string BinOpInit::getAsString() const {
   case CONCAT: Result = "!con"; break;
   case ADD: Result = "!add"; break;
   case AND: Result = "!and"; break;
   case OR: Result = "!or"; break;
   case SHL: Result = "!shl"; break;
   case SRA: Result = "!sra"; break;
   case SRL: Result = "!srl"; break;
   case EQ: Result = "!eq"; break;
+  case NE: Result = "!ne"; break;
+  case LE: Result = "!le"; break;
+  case LT: Result = "!lt"; break;
+  case GE: Result = "!ge"; break;
+  case GT: Result = "!gt"; break;
   case LISTCONCAT: Result = "!listconcat"; break;
   case STRCONCAT: Result = "!strconcat"; break;
   }
   return Result + "(" + LHS->getAsString() + ", " + RHS->getAsString() + ")";
 }
 
 static void
 ProfileTernOpInit(FoldingSetNodeID &ID, unsigned Opcode, Init *LHS, Init *MHS,

llvm/trunk/lib/TableGen/TGLexer.h

enum TokKind {
 
     // Keywords.
     Bit, Bits, Class, Code, Dag, Def, Foreach, Defm, Field, In, Int, Let, List,
     MultiClass, String, Defset,
 
     // !keywords.
     XConcat, XADD, XAND, XOR, XSRA, XSRL, XSHL, XListConcat, XStrConcat, XCast,
     XSubst, XForEach, XFoldl, XHead, XTail, XSize, XEmpty, XIf, XEq, XIsA, XDag,
+    XNe, XLe, XLt, XGe, XGt,
 
     // Integer value.
     IntVal,
 
     // Binary constant.  Note that these are sized according to the number of
     // bits given.
     BinaryIntVal,
 

llvm/trunk/lib/TableGen/TGLexer.cpp

tgtok::TokKind TGLexer::LexExclaim() {
   const char *Start = CurPtr++;
   while (isalpha(*CurPtr))
     ++CurPtr;
 
   // Check to see which operator this is.
   tgtok::TokKind Kind =
     StringSwitch<tgtok::TokKind>(StringRef(Start, CurPtr - Start))
     .Case("eq", tgtok::XEq)
+    .Case("ne", tgtok::XNe)
+    .Case("le", tgtok::XLe)
+    .Case("lt", tgtok::XLt)
+    .Case("ge", tgtok::XGe)
+    .Case("gt", tgtok::XGt)
     .Case("if", tgtok::XIf)
     .Case("isa", tgtok::XIsA)
     .Case("head", tgtok::XHead)
     .Case("tail", tgtok::XTail)
     .Case("size", tgtok::XSize)
     .Case("con", tgtok::XConcat)
     .Case("dag", tgtok::XDag)
     .Case("add", tgtok::XADD)

llvm/trunk/lib/TableGen/TGParser.cpp

Init *TGParser::ParseOperation(Record *CurRec, RecTy *ItemType) {
   case tgtok::XConcat:
   case tgtok::XADD:
   case tgtok::XAND:
   case tgtok::XOR:
   case tgtok::XSRA:
   case tgtok::XSRL:
   case tgtok::XSHL:
   case tgtok::XEq:
+  case tgtok::XNe:
+  case tgtok::XLe:
+  case tgtok::XLt:
+  case tgtok::XGe:
+  case tgtok::XGt:
   case tgtok::XListConcat:
   case tgtok::XStrConcat: {  // Value ::= !binop '(' Value ',' Value ')'
     tgtok::TokKind OpTok = Lex.getCode();
     SMLoc OpLoc = Lex.getLoc();
     Lex.Lex();  // eat the operation
 
     BinOpInit::BinaryOp Code;
     switch (OpTok) {
     default: llvm_unreachable("Unhandled code!");
     case tgtok::XConcat: Code = BinOpInit::CONCAT; break;
     case tgtok::XADD:    Code = BinOpInit::ADD; break;
     case tgtok::XAND:    Code = BinOpInit::AND; break;
     case tgtok::XOR:     Code = BinOpInit::OR; break;
     case tgtok::XSRA:    Code = BinOpInit::SRA; break;
     case tgtok::XSRL:    Code = BinOpInit::SRL; break;
     case tgtok::XSHL:    Code = BinOpInit::SHL; break;
     case tgtok::XEq:     Code = BinOpInit::EQ; break;
+    case tgtok::XNe:     Code = BinOpInit::NE; break;
+    case tgtok::XLe:     Code = BinOpInit::LE; break;
+    case tgtok::XLt:     Code = BinOpInit::LT; break;
+    case tgtok::XGe:     Code = BinOpInit::GE; break;
+    case tgtok::XGt:     Code = BinOpInit::GT; break;
     case tgtok::XListConcat: Code = BinOpInit::LISTCONCAT; break;
     case tgtok::XStrConcat: Code = BinOpInit::STRCONCAT; break;
     }
 
     RecTy *Type = nullptr;
     RecTy *ArgType = nullptr;
     switch (OpTok) {
     default:
       llvm_unreachable("Unhandled code!");
     case tgtok::XConcat:
       Type = DagRecTy::get();
       ArgType = DagRecTy::get();
       break;
     case tgtok::XAND:
     case tgtok::XOR:
     case tgtok::XSRA:
     case tgtok::XSRL:
     case tgtok::XSHL:
     case tgtok::XADD:
       Type = IntRecTy::get();
       ArgType = IntRecTy::get();
       break;
     case tgtok::XEq:
+    case tgtok::XNe:
       Type = BitRecTy::get();
-      // ArgType for Eq is not known at this point
+      // 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();
       break;
     case tgtok::XListConcat:
       // We don't know the list type until we parse the first argument
       ArgType = ItemType;
       break;
     case tgtok::XStrConcat:
       Type = StringRecTy::get();
       ArgType = StringRecTy::get();
for (;;) {
         case BinOpInit::LISTCONCAT:
           if (!isa<ListRecTy>(ArgType)) {
             Error(InitLoc, Twine("expected a list, got value of type '") +
                            ArgType->getAsString() + "'");
             return nullptr;
           }
           break;
         case BinOpInit::EQ:
+        case BinOpInit::NE:
           if (!ArgType->typeIsConvertibleTo(IntRecTy::get()) &&
               !ArgType->typeIsConvertibleTo(StringRecTy::get())) {
             Error(InitLoc, Twine("expected int, bits, or string; got value of "
                                  "type '") + ArgType->getAsString() + "'");
             return nullptr;
           }
           break;
         default: llvm_unreachable("other ops have fixed argument types");
Init *TGParser::ParseSimpleValue(Record *CurRec, RecTy *ItemType,
   case tgtok::XDag:
   case tgtok::XADD:
   case tgtok::XAND:
   case tgtok::XOR:
   case tgtok::XSRA:
   case tgtok::XSRL:
   case tgtok::XSHL:
   case tgtok::XEq:
+  case tgtok::XNe:
+  case tgtok::XLe:
+  case tgtok::XLt:
+  case tgtok::XGe:
+  case tgtok::XGt:
   case tgtok::XListConcat:
   case tgtok::XStrConcat:   // Value ::= !binop '(' Value ',' Value ')'
   case tgtok::XIf:
   case tgtok::XFoldl:
   case tgtok::XForEach:
   case tgtok::XSubst: {  // Value ::= !ternop '(' Value ',' Value ',' Value ')'
     return ParseOperation(CurRec, ItemType);
   }

llvm/trunk/test/TableGen/compare.td

+// RUN: llvm-tblgen %s | FileCheck %s
+// XFAIL: vg_leak
+
+// CHECK: --- Defs ---
+
+// 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>;

llvm/trunk/test/TableGen/eq.td

 // RUN: llvm-tblgen %s | FileCheck %s
 // XFAIL: vg_leak
-// CHECK: Value = 0
-// CHECK: Value = 1
+
+// CHECK-LABEL: def FALSE {
+//       CHECK:   int Value = 0;
+//       CHECK: }
+
+// CHECK-LABEL: def TRUE {
+//       CHECK:   int Value = 1;
+//       CHECK: }
+
+// CHECK-LABEL: def X_NE {
+//       CHECK:   bit a = 1;
+//       CHECK:   bit b = 0;
+//       CHECK: }
 
 class Base<int V> {
   int Value = V;
 }
 
 class Derived<string Truth> :
   Base<!if(!eq(Truth, "true"), 1, 0)>;
 
 def TRUE : Derived<"true">;
 def FALSE : Derived<"false">;
+
+def X_NE {
+  bit a = !ne("true", "false");
+  bit b = !ne("foo", "foo");
+}

llvm/trunk/test/TableGen/eqbit.td

 // RUN: llvm-tblgen %s | FileCheck %s
 // XFAIL: vg_leak
-// CHECK: a = 6
-// CHECK: a = 5
+
+// CHECK-LABEL: def X {
+//       CHECK:   int a = 6;
+//       CHECK:   int c = 5;
+//       CHECK: }
+
+// CHECK-LABEL: def Y {
+//       CHECK:   int a = 5;
+//       CHECK:   int c = 6;
+//       CHECK: }
 
 class A<bit b = 1> {
   int a = !if(!eq(b, 1), 5, 6);
+  int c = !if(!ne(b, 1), 5, 6);
 }
 
 def X : A<0>;
 def Y : A;