TableGen: Type-check BinOps

[nhaehnle]

Summary

Additionally, allow more than two operands to !con, !add, !and, !or
in the same way as is already allowed for !listconcat and !strconcat.

Change-Id: I9659411f554201b90cd8ed7c7e004d381a66fa93

[tra]

This change should come with an update to the docs.

One thing jumped at me -- we have three different variants of concatenation -- !con, !listconcat and !strconcat (along with '#'). Do we need all of them? I think we could get by with one, which would glue together items of the same kind.

test/TableGen/Paste.td

15–24 ↗

(On Diff #137060)

This does not seem to test anything relevant to this patch.Was this change supposed to be here or in some other patch?

test/TableGen/arithmetic.td

14 ↗

(On Diff #137060)

I'm not sure if this file was meant to be in this patch. It does not seem to use 3+operand variants of !con, !add, !and, !or.

[nhaehnle]

In D44112#1030389, @tra wrote:

This change should come with an update to the docs.

True, I'm adding that.

One thing jumped at me -- we have three different variants of concatenation -- !con, !listconcat and !strconcat (along with '#'). Do we need all of them? I think we could get by with one, which would glue together items of the same kind.

I agree. The nicest option would be for # to cover everything, though it is a bit special in that it does automatic casts to string. Then again, it's probably good enough to just not do those conversions if one of the LHS or RHS are dags or lists.

test/TableGen/Paste.td

15–24 ↗

(On Diff #137060)

This test fails without the change in TGParser.cpp:1957. Previously, parsing the paste passed string as required type to ParseValue, which would fail in the stricter checks when parsing the !add.

test/TableGen/arithmetic.td

14 ↗

(On Diff #137060)

This tests that using different operand types on those operations is still allowed. I've added a comment and the full set of ops.

[nhaehnle]

Update the docs, relax operands to !add, !and, !or in the same
way as shifts and add tests for it.

[tra]

docs/TableGen/LangIntro.rst

270–271 ↗

(On Diff #137721)

We may add few details regarding intended behavior (or lack of guarantees).
I think we should mention that we operate on 64-bit integers and that results of negative shift count or shift overflow is undefined.

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.
 
-``!shl(a,b)`` ``!srl(a,b)`` ``!sra(a,b)`` ``!add(a,b)`` ``!and(a,b)``
-    The usual binary and arithmetic operators.
+``!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
 for different types.  These rules allow you to assign a value like "``7``"
 to a "``bits<4>``" value, for example.
 
 Classes and definitions
 -----------------------
 

llvm/trunk/lib/TableGen/TGParser.cpp

Init *TGParser::ParseOperation(Record *CurRec, RecTy *ItemType) {
   case tgtok::XEq:
   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;
-    RecTy *Type = nullptr;
-
     switch (OpTok) {
     default: llvm_unreachable("Unhandled code!");
-    case tgtok::XConcat: Code = BinOpInit::CONCAT;Type = DagRecTy::get(); break;
-    case tgtok::XADD:    Code = BinOpInit::ADD;   Type = IntRecTy::get(); break;
-    case tgtok::XAND:    Code = BinOpInit::AND;   Type = IntRecTy::get(); break;
-    case tgtok::XOR:     Code = BinOpInit::OR;    Type = IntRecTy::get(); break;
-    case tgtok::XSRA:    Code = BinOpInit::SRA;   Type = IntRecTy::get(); break;
-    case tgtok::XSRL:    Code = BinOpInit::SRL;   Type = IntRecTy::get(); break;
-    case tgtok::XSHL:    Code = BinOpInit::SHL;   Type = IntRecTy::get(); break;
-    case tgtok::XEq:     Code = BinOpInit::EQ;    Type = BitRecTy::get(); break;
+    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::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:
+      Type = BitRecTy::get();
+      // ArgType for Eq is not known at this point
+      break;
     case tgtok::XListConcat:
-      Code = BinOpInit::LISTCONCAT;
       // We don't know the list type until we parse the first argument
+      ArgType = ItemType;
       break;
     case tgtok::XStrConcat:
-      Code = BinOpInit::STRCONCAT;
       Type = StringRecTy::get();
+      ArgType = StringRecTy::get();
       break;
     }
 
+    if (Type && ItemType && !Type->typeIsConvertibleTo(ItemType)) {
+      Error(OpLoc, Twine("expected value of type '") +
+                   ItemType->getAsString() + "', got '" +
+                   Type->getAsString() + "'");
+      return nullptr;
+    }
+
     if (Lex.getCode() != tgtok::l_paren) {
       TokError("expected '(' after binary operator");
       return nullptr;
     }
     Lex.Lex();  // eat the '('
 
     SmallVector<Init*, 2> InitList;
 
-    InitList.push_back(ParseValue(CurRec));
+    for (;;) {
+      SMLoc InitLoc = Lex.getLoc();
+      InitList.push_back(ParseValue(CurRec, ArgType));
       if (!InitList.back()) return nullptr;
 
-    while (Lex.getCode() == tgtok::comma) {
-      Lex.Lex();  // eat the ','
+      // All BinOps require their arguments to be of compatible types.
+      TypedInit *TI = dyn_cast<TypedInit>(InitList.back());
+      if (!ArgType) {
+        ArgType = TI->getType();
 
-      InitList.push_back(ParseValue(CurRec));
-      if (!InitList.back()) return nullptr;
+        switch (Code) {
+        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:
+          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");
+        }
+      } else {
+        RecTy *Resolved = resolveTypes(ArgType, TI->getType());
+        if (!Resolved) {
+          Error(InitLoc, Twine("expected value of type '") +
+                         ArgType->getAsString() + "', got '" +
+                         TI->getType()->getAsString() + "'");
+          return nullptr;
+        }
+        if (Code != BinOpInit::ADD && Code != BinOpInit::AND &&
+            Code != BinOpInit::OR && Code != BinOpInit::SRA &&
+            Code != BinOpInit::SRL && Code != BinOpInit::SHL)
+          ArgType = Resolved;
+      }
+
+      if (Lex.getCode() != tgtok::comma)
+        break;
+      Lex.Lex();  // eat the ','
     }
 
     if (Lex.getCode() != tgtok::r_paren) {
       TokError("expected ')' in operator");
       return nullptr;
     }
     Lex.Lex();  // eat the ')'
 
-    // If we are doing !listconcat, we should know the type by now
-    if (OpTok == tgtok::XListConcat) {
-      if (TypedInit *Arg0 = dyn_cast<TypedInit>(InitList[0]))
-        Type = Arg0->getType();
-      else {
-        InitList[0]->print(errs());
-        Error(OpLoc, "expected a list");
-        return nullptr;
-      }
-    }
+    if (Code == BinOpInit::LISTCONCAT)
+      Type = ArgType;
 
     // We allow multiple operands to associative operators like !strconcat as
     // shorthand for nesting them.
-    if (Code == BinOpInit::STRCONCAT || Code == BinOpInit::LISTCONCAT) {
+    if (Code == BinOpInit::STRCONCAT || Code == BinOpInit::LISTCONCAT ||
+        Code == BinOpInit::CONCAT || Code == BinOpInit::ADD ||
+        Code == BinOpInit::AND || Code == BinOpInit::OR) {
       while (InitList.size() > 2) {
         Init *RHS = InitList.pop_back_val();
         RHS = (BinOpInit::get(Code, InitList.back(), RHS, Type))
                            ->Fold(CurRec, CurMultiClass);
         InitList.back() = RHS;
       }
     }
 
case tgtok::paste:
         // Some of these can also begin values but we disallow those cases
         // because they are unlikely to be useful.
 
         // Trailing paste, concat with an empty string.
         RHS = StringInit::get("");
         break;
 
       default:
-        Init *RHSResult = ParseValue(CurRec, ItemType, ParseNameMode);
+        Init *RHSResult = ParseValue(CurRec, nullptr, ParseNameMode);
         RHS = dyn_cast<TypedInit>(RHSResult);
         if (!RHS) {
           Error(PasteLoc, "RHS of paste is not typed!");
           return nullptr;
         }
 
         if (RHS->getType() != StringRecTy::get()) {
           RHS = UnOpInit::get(UnOpInit::CAST, RHS, StringRecTy::get());

llvm/trunk/test/TableGen/Paste.td

 // RUN: llvm-tblgen %s | FileCheck %s
 // XFAIL: vg_leak
 
 class Instr<int i> {
   int index = i;
 }
 
 multiclass Test {
   def Vx#NAME#PS : Instr<0>;
   def Vx#NAME#PD : Instr<1>;
   def Vy#NAME#PS : Instr<2>;
   def Vy#NAME#PD : Instr<3>;
 }
 
+class Arithmetic<int i> {
+  string name = "number"#!add(i, 1);
+}
+
+def A : Arithmetic<5>;
+
+// CHECK: def A {
+// CHECK:   string name = "number6";
+// CHECK: }
+
 defm ADD : Test;
 defm SUB : Test;
 
 // CHECK: VxADDPD
 // CHECK: index = 1;
 // CHECK: VxADDPS
 // CHECK: index = 0;
 

llvm/trunk/test/TableGen/arithmetic.td

+// RUN: llvm-tblgen %s | FileCheck %s
+// XFAIL: vg_leak
+
+// CHECK: --- Defs ---
+
+// CHECK: def A0 {
+// 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> 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 };
+// CHECK: }
+
+class A<bits<8> a, bits<2> b> {
+  // Operands of different bits types are allowed.
+  bits<8> add = !add(a, b);
+  bits<8> and = !and(a, b);
+  bits<8> or = !or(a, b);
+  bits<8> srl = !srl(a, b);
+  bits<8> sra = !sra(a, b);
+  bits<8> shl = !shl(a, b);
+}
+
+def A0 : A<63, 1>;

llvm/trunk/test/TableGen/dag-functional.td

 // CHECK:   dag ret = (ops 1:$a, 2:$b);
 // CHECK: }
 
 // CHECK: def C0 {
 // CHECK:   dag ret1 = (ops ?:$a, ?:$b);
 // CHECK:   dag ret2 = (ops 1, 2);
 // CHECK: }
 
+// CHECK: def D {
+// CHECK:   dag d1 = (ops 1, ?:$name1, 2, 3);
+// CHECK: }
+
 def ops;
 
 class Node<int val, string name> {
   int Val = val;
   string Name = name;
 }
 
 class Aint<list<int> nodes, list<string> names> {

 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"]>;
+
+def D {
+  dag d1 = !con((ops 1), (ops $name1), (ops), (ops 2, 3));
+}
 No newline at end of file

llvm/trunk/test/TableGen/listconcat.td

 // RUN: llvm-tblgen %s | FileCheck %s
 
 // CHECK: class X<list<int> X:a = ?, list<int> X:b = ?, list<int> X:c = ?> {
 // CHECK:   list<int> x = !listconcat(!listconcat(X:a, X:b), !listconcat(X:b, X:c));
 // CHECK: }
 
 // CHECK: class Y<list<string> Y:S = ?> {
 // CHECK:   list<string> T1 = !listconcat(Y:S, ["foo"]);
 // CHECK:   list<string> T2 = !listconcat(Y:S, !listconcat(["foo"], !listconcat(Y:S, ["bar", "baz"])));
 // CHECK: }
 
+// CHECK: def A0 {
+// CHECK:   list<int> lst = [4];
+// CHECK: }
+
+// CHECK: def A1 {
+// CHECK:   list<int> lst = [];
+// CHECK: }
+
 // CHECK: def DX {
 // CHECK:   list<int> x = [0, 1, 1, 2]
 // CHECK: }
 
 // CHECK: def Z {
 // CHECK:   list<string> T1 = ["fu", "foo"];
 // CHECK:   list<string> T2 = ["fu", "foo", "fu", "bar", "baz"];
 // CHECK: }
 
+class A<bit x> {
+  // The empty lists type-check without issues.
+  list<int> lst = !listconcat([], !if(x, [], [4]));
+}
+
+def A0 : A<0>;
+def A1 : A<1>;
+
 class X<list<int> a, list<int> b, list<int> c> {
     list<int> x = !listconcat(!listconcat(a, b), !listconcat(b, c));
 }
 
 class Y<list<string> S> {
   list<string> T1 = !listconcat(S, ["foo"]);
   list<string> T2 = !listconcat(S, ["foo"], S, ["bar", "baz"]);
 }
 
 def DX : X<[0], [1], [2]>;
 
 def Z : Y<["fu"]>;

llvm/trunk/test/TableGen/math.td

 def v1024   : Int<1024>;
 // CHECK: def v1024
 // CHECK: Value = 1024
 
 def v1025   : Int<!add(v1024.Value, 1)>;
 // CHECK: def v1025
 // CHECK: Value = 1025
 
+// CHECK: def v1a
+// CHECK: Value = 1
+
+// CHECK: def v2
+// CHECK: Value = 2
+def v2 : Int<2>;
+
 def v2048   : Int<!add(v1024.Value, v1024.Value)>;
 // CHECK: def v2048
 // CHECK: Value = 2048
 
 def v0 : Int<!and(v1024.Value, v2048.Value)>;
 def v1 : Int<!and(v1025.Value, 1)>;
 
 // CHECK: def v3072
 // CHECK: Value = 3072
 def v3072 : Int<!or(v1024.Value, v2048.Value)>;
+
+// CHECK: def v4
+// CHECK: Value = 4
+
+// CHECK: def v7
+// CHECK: Value = 7
+
+def v4 : Int<!add(v2.Value, 1, v1.Value)>;
+def v7 : Int<!or(v1.Value, v2.Value, v4.Value)>;
+def v1a : Int<!and(v7.Value, 5, v1.Value)>;