tablegen: add CppConstant and fix some constraint language bugs

As seen in the test, the verifier errors can become a bit verbose,
and could benefit from better indentation; but I leave tweaking that
to subsequent changes.

Author: nhaehnle

example/ExampleDialect.cpp

@@ -26,5 +26,28 @@
 #include "ExampleDialect.h"
 
 #define GET_INCLUDES
+#include "ExampleDialect.cpp.inc"
+
+const char *xd::toString(VectorKind kind) {
+  switch (kind) {
+  case VectorKind::LittleEndian:
+    return "LittleEndian";
+  case VectorKind::BigEndian:
+    return "BigEndian";
+  case VectorKind::MiddleEndian:
+    return "MiddleEndian";
+  default:
+    return "(bad)";
+  }
+}
+
+template <> struct llvm_dialects::Printable<xd::VectorKind> {
+  xd::VectorKind x;
+
+  explicit Printable(xd::VectorKind x) : x(x) {}
+
+  void print(llvm::raw_ostream &out) const { out << toString(x); }
+};
+
 #define GET_DIALECT_DEFS
 #include "ExampleDialect.cpp.inc"

example/ExampleDialect.h

@@ -36,6 +36,8 @@ enum class VectorKind {
   MiddleEndian = 2,
 };
 
+const char *toString(VectorKind kind);
+
 } // namespace xd
 
 #define GET_DIALECT_DECLS

example/ExampleDialect.td

@@ -32,6 +32,14 @@ def ExampleDialect : Dialect {
 
 defm AttrVectorKind : AttrEnum<"VectorKind">;
 
+def VectorKindLittleEndian : CppConstant<"xd::VectorKind::LittleEndian">;
+def VectorKindBigEndian : CppConstant<"xd::VectorKind::BigEndian">;
+def VectorKindMiddleEndian : CppConstant<"xd::VectorKind::MiddleEndian">;
+
+def isReasonableVectorKind : TgPredicate<
+    (args AttrVectorKind:$kind),
+    (eq $kind, (or VectorKindLittleEndian, VectorKindBigEndian))>;
+
 def XdVectorType : DialectType<ExampleDialect, "vector"> {
   let typeArguments = (args AttrVectorKind:$kind, type:$element_type,
                             AttrI32:$num_elements);
@@ -149,6 +157,10 @@ def FromFixedVectorOp : ExampleOp<"fromfixedvector", [Memory<[]>, NoUnwind,
 
   let defaultBuilderHasExplicitResultType = true;
 
+  let verifier = [
+    (isReasonableVectorKind $kind),
+  ];
+
   let summary = "convert <n x T> to our custom vector type";
   let description = [{
     Demonstrate a more complex unification case.

include/llvm-dialects/Dialect/Dialect.td

@@ -205,6 +205,13 @@ def or;
 /// Misc. predicates
 // ============================================================================
 
+class CppConstant<string cppExpr_> : Predicate, CppPredicateMixin {
+  let arguments = (args any:$self);
+  let evaluate = cppExpr_;
+  let check = "$self == " # cppExpr_;
+  let capture = [];
+}
+
 def ScalarOrFixedVector : TgPredicate<
     (args type:$self, type:$scalar_type),
     (or (eq $self, $scalar_type),
@@ -247,6 +254,9 @@ def : AttrLlvmType<AttrI64, I64>;
 
 // Define a custom enum attribute that can be used as in operations and dialect
 // types
+//
+// The llvm_dialects::Printable struct template must be specialized for the enum
+// type, or automatically generated verifier code may fail to compile.
 multiclass AttrEnum<string cppType_> {
   def NAME : Attr<cppType_> {
     let toLlvmValue = "::llvm::ConstantInt::get($1, static_cast<unsigned>($0))";

include/llvm-dialects/Dialect/Utils.h

@@ -42,23 +42,27 @@ bool runInstructionVerifier(
 bool runTypeVerifier(llvm::function_ref<bool(llvm::raw_ostream &)> verifier,
                      llvm::Type *type, llvm::raw_ostream *errs = nullptr);
 
+/// Wrap a value to be printed to an llvm::raw_ostream.
+///
+/// Specialize this struct if you use AttrEnum arguments in operations or
+/// types.
 template <typename T> struct Printable {
   T x;
 
   explicit Printable(const T &x) : x(x) {}
-};
 
-template <typename T>
-llvm::raw_ostream &operator<<(llvm::raw_ostream &out,
-                              const Printable<T> &p) {
-  out << p.x;
-  return out;
-}
+  void print(llvm::raw_ostream &out) const {
+    if constexpr (std::is_pointer_v<T>) {
+      out << *x;
+    } else {
+      out << x;
+    }
+  }
+};
 
 template <typename T>
-llvm::raw_ostream &operator<<(llvm::raw_ostream &out,
-                              const Printable<T *> &p) {
-  out << *p.x;
+llvm::raw_ostream &operator<<(llvm::raw_ostream &out, const Printable<T> &p) {
+  p.print(out);
   return out;
 }
 

lib/TableGen/Constraints.cpp

@@ -109,6 +109,9 @@ bool ConstraintSystem::addConstraintImpl(raw_ostream &errs, Init *init,
       result->m_init = init;
       result->m_self = self;
 
+      if (self)
+        result->addVariable(self);
+
       for (size_t i = 0; i < dag->getNumArgs(); ++i) {
         if (!dag->getArgNameStr(i).empty()) {
           errs << "'or' operands cannot be captured\n";
@@ -197,8 +200,10 @@ bool ConstraintSystem::addConstraintImpl(raw_ostream &errs, Init *init,
           return false;
       }
 
-      if (variable)
+      if (variable) {
         addVariable(variable);
+        result->addVariable(variable);
+      }
       result->m_arguments.push_back(variable);
     }
   } else {

lib/TableGen/Evaluator.cpp

@@ -507,6 +507,7 @@ bool Evaluator::checkApplyCapture(const Apply *apply) {
       m_fmt.addSubst("with", with);
 
       m_out << tgfmt(R"(
+          return true;
         }()) {
           $_errs << "  while checking $constraint\n";
           $with
@@ -571,7 +572,7 @@ bool Evaluator::checkApplyCapture(const Apply *apply) {
 
 bool Evaluator::checkLogicOr(const LogicOr *logicOr) {
   for (Variable *variable : logicOr->variables()) {
-    if (variable->isNamed() && m_assignment.lookup(variable).empty()) {
+    if (m_assignment.lookup(variable).empty()) {
       m_errs << "cannot check " << logicOr->toString() << '\n';
       m_errs << "because " << variable->toString() << " is not known\n";
       return false;
@@ -584,7 +585,7 @@ bool Evaluator::checkLogicOr(const LogicOr *logicOr) {
   {
     m_out << tgfmt(R"(
       {
-        std::array<std::string, $0> $orErrors;
+        std::array<std::string, $0> $_orErrors;
         if (true
     )",
                    &m_fmt, logicOr->branches().size());
@@ -596,7 +597,7 @@ bool Evaluator::checkLogicOr(const LogicOr *logicOr) {
 
     m_out << tgfmt(R"(
       && !([&]() {
-        ::llvm::raw_string_ostream $_errs($orErrors[$0]);
+        ::llvm::raw_string_ostream $_errs($_orErrors[$0]);
     )",
                    &m_fmt, index);
 
@@ -621,7 +622,7 @@ bool Evaluator::checkLogicOr(const LogicOr *logicOr) {
     m_fmt.addSubst("value", m_assignment.lookup(self));
 
     m_out << tgfmt(R"(
-      $_errs << "  $name (" << printable($value))
+      $_errs << "  $name (" << printable($value)
              << ") does not match any available option\n";
     )",
                    &m_fmt);
@@ -635,7 +636,7 @@ bool Evaluator::checkLogicOr(const LogicOr *logicOr) {
                    &m_fmt, i, logicOr->branchInits()[i]->getAsString());
   }
 
-  m_out << "}\n\n";
+  m_out << "return false;\n}\n}\n";
   return true;
 }
 

test/example/generated/ExampleDialect.cpp.inc

@@ -640,6 +640,59 @@ source,
           errs << "    actual:    " << printable(::llvm::cast<::llvm::FixedVectorType>(sourceType)->getNumElements()) << '\n';
           return false;
         }
+      if (![&]() {
+
+      {
+        std::array<std::string, 2> orErrors;
+        if (true
+    
+      && !([&]() {
+        ::llvm::raw_string_ostream errs(orErrors[0]);
+    
+        if (xd::VectorKind::LittleEndian != ::llvm::cast<XdVectorType>(resultType)->getKind()) {
+          errs << "  inconsistent value of eq:$rhs found\n";
+          errs << "  while checking VectorKindLittleEndian:\n";
+          errs << "    here:       " << printable(xd::VectorKind::LittleEndian) << '\n';
+          errs << "    previously: " << printable(::llvm::cast<XdVectorType>(resultType)->getKind()) << '\n';
+          return false;
+        }
+      return true;
+}())
+
+      && !([&]() {
+        ::llvm::raw_string_ostream errs(orErrors[1]);
+    
+        if (xd::VectorKind::BigEndian != ::llvm::cast<XdVectorType>(resultType)->getKind()) {
+          errs << "  inconsistent value of eq:$rhs found\n";
+          errs << "  while checking VectorKindBigEndian:\n";
+          errs << "    here:       " << printable(xd::VectorKind::BigEndian) << '\n';
+          errs << "    previously: " << printable(::llvm::cast<XdVectorType>(resultType)->getKind()) << '\n';
+          return false;
+        }
+      return true;
+}())
+) {
+
+      errs << "  eq:$rhs (" << printable(::llvm::cast<XdVectorType>(resultType)->getKind())
+             << ") does not match any available option\n";
+    
+      errs << "  failed option 0 (VectorKindLittleEndian):\n"
+             << orErrors[0];
+    
+      errs << "  failed option 1 (VectorKindBigEndian):\n"
+             << orErrors[1];
+    return false;
+}
+}
+
+          return true;
+        }()) {
+          errs << "  while checking (isReasonableVectorKind ?:$kind)\n";
+          
+    errs << "  with $kind = " << printable(::llvm::cast<XdVectorType>(resultType)->getKind()) << '\n';
+  
+          return false;
+        }
         return true;
 }
 

test/example/verifier-basic.ll

@@ -35,11 +35,29 @@ entry:
 ; CHECK-LABEL: Verifier error in:   %stream.min1 =
 ; CHECK:  wrong number of arguments: 2, expected 3
   %stream.min1 = call i8 (...) @xd.stream.min.i8(ptr %p, i64 14)
+
+; CHECK-LABEL: Verifier error in:   %fromfixedvector3 =
+; CHECK:  eq:$rhs (MiddleEndian) does not match any available option
+; CHECK:  failed option 0 (VectorKindLittleEndian):
+; CHECK:  inconsistent value of eq:$rhs found
+; CHECK:  while checking VectorKindLittleEndian:
+; CHECK:    here:       LittleEndian
+; CHECK:    previously: MiddleEndian
+; CHECK:  failed option 1 (VectorKindBigEndian):
+; CHECK:  inconsistent value of eq:$rhs found
+; CHECK:  while checking VectorKindBigEndian:
+; CHECK:    here:       BigEndian
+; CHECK:    previously: MiddleEndian
+; CHECK:  while checking (isReasonableVectorKind ?:$kind)
+; CHECK:  with $kind = MiddleEndian
+  %fromfixedvector3 = call target("xd.vector", i32, 2, 2) (...) @xd.fromfixedvector.txd.vector_i32_2_2t(<2 x i32> poison)
+
   ret void
 }
 
 declare i32 @xd.sizeof(...)
 declare i64 @xd.itrunc.i64(...)
 declare target("xd.vector", i32, 0, 2) @xd.fromfixedvector.txd.vector_i32_0_2t(...)
+declare target("xd.vector", i32, 2, 2) @xd.fromfixedvector.txd.vector_i32_2_2t(...)
 declare <2 x i16> @xd.stream.max.v2i16(...)
 declare i8 @xd.stream.min.i8(...)