[mlir] Add support for the attribute verifiers in the dialect declaration generator.

[rriddle]

Summary

This adds bitfields that map to the dialect attribute verifier hooks. This also moves over the Test dialect to have its declaration generated.

[antiagainst]

mlir/include/mlir/Dialect/SPIRV/SPIRVBase.td

52

Nit: can we use an empty line between these bits and the extraClassDeclaration?

[rriddle]

Resolve comments

mlir/include/mlir/Dialect/GPU/GPUOps.td

def IntLikeOrLLVMInt : TypeConstraint<
   "integer, index or LLVM dialect equivalent">;
 
 //===----------------------------------------------------------------------===//
 // GPU Dialect operations.
 //===----------------------------------------------------------------------===//
 
 def GPU_Dialect : Dialect {
   let name = "gpu";
+  let hasOperationAttrVerify = 1;
+
   let extraClassDeclaration = [{
     /// Get the name of the attribute used to annotate the modules that contain
     /// kernel modules.
     static StringRef getContainerModuleAttrName() {
       return "gpu.container_module";
     }
     /// Get the name of the attribute used to annotate external kernel
     /// functions.
let extraClassDeclaration = [{
 
     /// Returns the numeric value used to identify the workgroup memory address
     /// space.
     static unsigned getWorkgroupAddressSpace() { return 3; }
 
     /// Returns the numeric value used to identify the private memory address
     /// space.
     static unsigned getPrivateAddressSpace() { return 5; }
-
-    LogicalResult verifyOperationAttribute(Operation *op,
-                                           NamedAttribute attr) override;
   }];
 }
 
 class GPU_Op<string mnemonic, list<OpTrait> traits = []> :
     Op<GPU_Dialect, mnemonic, traits>;
 
 class GPU_IndexOp<string mnemonic, list<OpTrait> traits = []> :
     GPU_Op<mnemonic, !listconcat(traits, [NoSideEffect])>,

mlir/include/mlir/Dialect/LLVMIR/LLVMOpBase.td

 #ifndef LLVMIR_OP_BASE
 #define LLVMIR_OP_BASE
 
 include "mlir/IR/OpBase.td"
 
 def LLVM_Dialect : Dialect {
   let name = "llvm";
   let cppNamespace = "LLVM";
+  let hasRegionArgAttrVerify = 1;
   let extraClassDeclaration = [{
     ~LLVMDialect();
     llvm::LLVMContext &getLLVMContext();
     llvm::Module &getLLVMModule();
 
-    /// Verify a region argument attribute registered to this dialect.
-    /// Returns failure if the verification failed, success otherwise.
-    LogicalResult verifyRegionArgAttribute(Operation *op, unsigned regionIdx,
-                                           unsigned argIdx,
-                                           NamedAttribute argAttr) override;
-
   private:
     friend LLVMType;
 
     std::unique_ptr<detail::LLVMDialectImpl> impl;
   }];
 }
 
 // LLVM IR type wrapped in MLIR.

mlir/include/mlir/Dialect/SPIRV/SPIRVBase.td

let description = [{
     benefits transformations. The dialect also aims to maintain straightforward
     serialization into and deserialization from the SPIR-V binary format.
     See https://mlir.llvm.org/docs/Dialects/SPIR-V/ for more details regarding
     high-level designs and implementation structures of the SPIR-V dialect.
   }];
 
   let cppNamespace = "spirv";
   let hasConstantMaterializer = 1;
+  let hasOperationAttrVerify = 1;
+  let hasRegionArgAttrVerify = 1;
+  let hasRegionResultAttrVerify = 1;
   let extraClassDeclaration = [{
     //===------------------------------------------------------------------===//
     // Type
     //===------------------------------------------------------------------===//
 
     /// Checks if the given `type` is valid in SPIR-V dialect.
     static bool isValidType(Type type);
 
     /// Checks if the given `scalar type` is valid in SPIR-V dialect.
     static bool isValidScalarType(Type type);
 
     //===------------------------------------------------------------------===//
     // Attribute
     //===------------------------------------------------------------------===//
 
     /// Returns the attribute name to use when specifying decorations on results
     /// of operations.
     static std::string getAttributeName(Decoration decoration);
-
-    /// Provides a hook for verifying SPIR-V dialect attributes attached to the
-    /// given op.
-    LogicalResult verifyOperationAttribute(Operation *op,
-                                           NamedAttribute attribute) override;
-
-    /// Provides a hook for verifying SPIR-V dialect attributes attached to the
-    /// given op's region argument.
-    LogicalResult verifyRegionArgAttribute(Operation *op, unsigned regionIndex,
-                                           unsigned argIndex,
-                                           NamedAttribute attribute) override;
-
-    /// Provides a hook for verifying SPIR-V dialect attributes attached to the
-    /// given op's region result.
-    LogicalResult verifyRegionResultAttribute(
-        Operation *op, unsigned regionIndex, unsigned resultIndex,
-        NamedAttribute attribute) override;
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // Utility definitions
 //===----------------------------------------------------------------------===//
 
 // A predicate that checks whether `$_self` is a known enum case for the

mlir/include/mlir/IR/OpBase.td

class Dialect {
   string cppNamespace = name;
 
   // An optional code block containing extra declarations to place in the
   // dialect declaration.
   code extraClassDeclaration = "";
 
   // If this dialect overrides the hook for materializing constants.
   bit hasConstantMaterializer = 0;
+
+  // If this dialect overrides the hook for verifying operation attributes.
+  bit hasOperationAttrVerify = 0;
+
+  // If this dialect overrides the hook for verifying region argument
+  // attributes.
+  bit hasRegionArgAttrVerify = 0;
+
+  // If this dialect overrides the hook for verifying region result attributes.
+  bit hasRegionResultAttrVerify = 0;
 }
 
 //===----------------------------------------------------------------------===//
 // Type definitions
 //===----------------------------------------------------------------------===//
 
 // A type, carries type constraints.
 class Type<Pred condition, string descr = ""> :

mlir/include/mlir/TableGen/Dialect.h

public:
   StringRef getDescription() const;
 
   // Returns the dialects extra class declaration code.
   llvm::Optional<StringRef> getExtraClassDeclaration() const;
 
   // Returns if this dialect has a constant materializer or not.
   bool hasConstantMaterializer() const;
 
+  /// Returns if this dialect has an operation attribute verifier.
+  bool hasOperationAttrVerify() const;
+
+  /// Returns if this dialect has a region argument attribute verifier.
+  bool hasRegionArgAttrVerify() const;
+
+  /// Returns if this dialect has a region result attribute verifier.
+  bool hasRegionResultAttrVerify() const;
+
   // Returns whether two dialects are equal by checking the equality of the
   // underlying record.
   bool operator==(const Dialect &other) const;
 
   // Compares two dialects by comparing the names of the dialects.
   bool operator<(const Dialect &other) const;
 
   // Returns whether the dialect is defined.

mlir/lib/TableGen/Dialect.cpp

llvm::Optional<StringRef> tblgen::Dialect::getExtraClassDeclaration() const {
   auto value = def->getValueAsString("extraClassDeclaration");
   return value.empty() ? llvm::Optional<StringRef>() : value;
 }
 
 bool tblgen::Dialect::hasConstantMaterializer() const {
   return def->getValueAsBit("hasConstantMaterializer");
 }
 
+bool tblgen::Dialect::hasOperationAttrVerify() const {
+  return def->getValueAsBit("hasOperationAttrVerify");
+}
+
+bool tblgen::Dialect::hasRegionArgAttrVerify() const {
+  return def->getValueAsBit("hasRegionArgAttrVerify");
+}
+
+bool tblgen::Dialect::hasRegionResultAttrVerify() const {
+  return def->getValueAsBit("hasRegionResultAttrVerify");
+}
+
 bool Dialect::operator==(const Dialect &other) const {
   return def == other.def;
 }
 
 bool Dialect::operator<(const Dialect &other) const {
   return getName() < other.getName();
 }
 
 } // end namespace tblgen
 } // end namespace mlir

mlir/test/lib/TestDialect/CMakeLists.txt

 set(LLVM_OPTIONAL_SOURCES
   TestDialect.cpp
   TestPatterns.cpp
 )
 
 set(LLVM_TARGET_DEFINITIONS TestOps.td)
 mlir_tablegen(TestOps.h.inc -gen-op-decls)
 mlir_tablegen(TestOps.cpp.inc -gen-op-defs)
+mlir_tablegen(TestOpsDialect.h.inc -gen-dialect-decls)
 mlir_tablegen(TestOpEnums.h.inc -gen-enum-decls)
 mlir_tablegen(TestOpEnums.cpp.inc -gen-enum-defs)
 mlir_tablegen(TestPatterns.inc -gen-rewriters)
 add_public_tablegen_target(MLIRTestOpsIncGen)
 
 add_llvm_library(MLIRTestDialect
   TestDialect.cpp
   TestPatterns.cpp

mlir/test/lib/TestDialect/TestDialect.h

 #include "mlir/Interfaces/ControlFlowInterfaces.h"
 #include "mlir/Interfaces/InferTypeOpInterface.h"
 #include "mlir/Interfaces/SideEffects.h"
 
 #include "TestOpEnums.h.inc"
 
 namespace mlir {
 
-class TestDialect : public Dialect {
-public:
-  /// Create the dialect in the given `context`.
-  TestDialect(MLIRContext *context);
-
-  /// Get the canonical string name of the dialect.
-  static StringRef getDialectName() { return "test"; }
-
-  LogicalResult verifyOperationAttribute(Operation *op,
-                                         NamedAttribute namedAttr) override;
-  LogicalResult verifyRegionArgAttribute(Operation *op, unsigned regionIndex,
-                                         unsigned argIndex,
-                                         NamedAttribute namedAttr) override;
-  LogicalResult verifyRegionResultAttribute(Operation *op, unsigned regionIndex,
-                                            unsigned resultIndex,
-                                            NamedAttribute namedAttr) override;
-};
+#include "TestOpsDialect.h.inc"
 
 #define GET_OP_CLASSES
 #include "TestOps.h.inc"
 
 } // end namespace mlir
 
 #endif // MLIR_TESTDIALECT_H

mlir/test/lib/TestDialect/TestDialect.cpp

 };
 } // end anonymous namespace
 
 //===----------------------------------------------------------------------===//
 // TestDialect
 //===----------------------------------------------------------------------===//
 
 TestDialect::TestDialect(MLIRContext *context)
-    : Dialect(getDialectName(), context) {
+    : Dialect(getDialectNamespace(), context) {
   addOperations<
 #define GET_OP_LIST
 #include "TestOps.cpp.inc"
       >();
   addInterfaces<TestOpAsmInterface, TestOpFolderDialectInterface,
                 TestInlinerInterface>();
   allowUnknownOperations();
 }

mlir/test/lib/TestDialect/TestOps.td

 include "mlir/IR/OpBase.td"
 include "mlir/IR/OpAsmInterface.td"
 include "mlir/Interfaces/SideEffects.td"
 include "mlir/Interfaces/CallInterfaces.td"
 include "mlir/Interfaces/ControlFlowInterfaces.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Interfaces/SideEffects.td"
 
-def TEST_Dialect : Dialect {
+def Test_Dialect : Dialect {
   let name = "test";
   let cppNamespace = "";
+  let hasOperationAttrVerify = 1;
+  let hasRegionArgAttrVerify = 1;
+  let hasRegionResultAttrVerify = 1;
 }
 
 class TEST_Op<string mnemonic, list<OpTrait> traits = []> :
-    Op<TEST_Dialect, mnemonic, traits>;
+    Op<Test_Dialect, mnemonic, traits>;
 
 //===----------------------------------------------------------------------===//
 // Test Types
 //===----------------------------------------------------------------------===//
 
 def IntTypesOp : TEST_Op<"int_types"> {
   let results = (outs
     AnyI16:$any_i16,

mlir/tools/mlir-tblgen/DialectGen.cpp

static const char *const constantMaterializerDecl = R"(
   /// Materialize a single constant operation from a given attribute value with
   /// the desired resultant type.
   ::mlir::Operation *materializeConstant(::mlir::OpBuilder &builder,
                                          ::mlir::Attribute value,
                                          ::mlir::Type type,
                                          ::mlir::Location loc) override;
 )";
 
+/// The code block for the operation attribute verifier hook.
+static const char *const opAttrVerifierDecl = R"(
+    /// Provides a hook for verifying dialect attributes attached to the given
+    /// op.
+    ::mlir::LogicalResult verifyOperationAttribute(
+        ::mlir::Operation *op, ::mlir::NamedAttribute attribute) override;
+)";
+
+/// The code block for the region argument attribute verifier hook.
+static const char *const regionArgAttrVerifierDecl = R"(
+    /// Provides a hook for verifying dialect attributes attached to the given
+    /// op's region argument.
+    ::mlir::LogicalResult verifyRegionArgAttribute(
+        ::mlir::Operation *op, unsigned regionIndex, unsigned argIndex,
+        ::mlir::NamedAttribute attribute) override;
+)";
+
+/// The code block for the region result attribute verifier hook.
+static const char *const regionResultAttrVerifierDecl = R"(
+    /// Provides a hook for verifying dialect attributes attached to the given
+    /// op's region result.
+    ::mlir::LogicalResult verifyRegionResultAttribute(
+        ::mlir::Operation *op, unsigned regionIndex, unsigned resultIndex,
+        ::mlir::NamedAttribute attribute) override;
+)";
+
 /// Generate the declaration for the given dialect class.
 static void emitDialectDecl(
     Dialect &dialect,
     FunctionTraits<decltype(&filterForDialect<Attribute>)>::result_t
         dialectAttrs,
     FunctionTraits<decltype(&filterForDialect<Type>)>::result_t dialectTypes,
     raw_ostream &os) {
   // Emit the start of the decl.
   std::string cppName = dialect.getCppClassName();
   os << llvm::formatv(dialectDeclBeginStr, cppName, dialect.getName());
 
   // Check for any attributes/types registered to this dialect.  If there are,
   // add the hooks for parsing/printing.
   if (!dialectAttrs.empty())
     os << attrParserDecl;
   if (!dialectTypes.empty())
     os << typeParserDecl;
 
   // Add the decls for the various features of the dialect.
   if (dialect.hasConstantMaterializer())
     os << constantMaterializerDecl;
+  if (dialect.hasOperationAttrVerify())
+    os << opAttrVerifierDecl;
+  if (dialect.hasRegionArgAttrVerify())
+    os << regionArgAttrVerifierDecl;
+  if (dialect.hasRegionResultAttrVerify())
+    os << regionResultAttrVerifierDecl;
   if (llvm::Optional<StringRef> extraDecl = dialect.getExtraClassDeclaration())
     os << *extraDecl;
 
   // End the dialect decl.
   os << "};\n";
 }
 
 static bool emitDialectDecls(const llvm::RecordKeeper &recordKeeper,