[mlir] Add support for generating dialect declarations via tablegen.

Summary: This generates the class declarations for dialects using the existing 'Dialect' tablegen classes.

Differential Revision: https://reviews.llvm.org/D76185

Author: River707

mlir/cmake/modules/AddMLIR.cmake

@@ -28,10 +28,11 @@ function(whole_archive_link target)
 endfunction(whole_archive_link)
 
 # Declare a dialect in the include directory
-function(add_mlir_dialect dialect dialect_doc_filename)
+function(add_mlir_dialect dialect dialect_namespace dialect_doc_filename)
   set(LLVM_TARGET_DEFINITIONS ${dialect}.td)
   mlir_tablegen(${dialect}.h.inc -gen-op-decls)
   mlir_tablegen(${dialect}.cpp.inc -gen-op-defs)
+  mlir_tablegen(${dialect}Dialect.h.inc -gen-dialect-decls -dialect=${dialect_namespace})
   add_public_tablegen_target(MLIR${dialect}IncGen)
   add_dependencies(mlir-headers MLIR${dialect}IncGen)
 

mlir/docs/CreatingADialect.md

@@ -39,7 +39,7 @@ is declared using add_mlir_dialect().
 
 ```cmake
 
-add_mlir_dialect(FooOps FooOps)
+add_mlir_dialect(FooOps foo FooOps)
 
 ```
 

mlir/include/mlir/Dialect/AffineOps/AffineOps.h

@@ -36,17 +36,6 @@ class OpBuilder;
 /// symbol.
 bool isTopLevelValue(Value value);
 
-class AffineOpsDialect : public Dialect {
-public:
-  AffineOpsDialect(MLIRContext *context);
-  static StringRef getDialectNamespace() { return "affine"; }
-
-  /// Materialize a single constant operation from a given attribute value with
-  /// the desired resultant type.
-  Operation *materializeConstant(OpBuilder &builder, Attribute value, Type type,
-                                 Location loc) override;
-};
-
 /// AffineDmaStartOp starts a non-blocking DMA operation that transfers data
 /// from a source memref to a destination memref. The source and destination
 /// memref need not be of the same dimensionality, but need to have the same
@@ -504,6 +493,8 @@ AffineApplyOp makeComposedAffineApply(OpBuilder &b, Location loc, AffineMap map,
 void fullyComposeAffineMapAndOperands(AffineMap *map,
                                       SmallVectorImpl<Value> *operands);
 
+#include "mlir/Dialect/AffineOps/AffineOpsDialect.h.inc"
+
 #define GET_OP_CLASSES
 #include "mlir/Dialect/AffineOps/AffineOps.h.inc"
 

mlir/include/mlir/Dialect/AffineOps/AffineOps.td

@@ -17,14 +17,15 @@ include "mlir/Dialect/AffineOps/AffineOpsBase.td"
 include "mlir/Interfaces/LoopLikeInterface.td"
 include "mlir/Interfaces/SideEffects.td"
 
-def Affine_Dialect : Dialect {
+def AffineOps_Dialect : Dialect {
   let name = "affine";
   let cppNamespace = "";
+  let hasConstantMaterializer = 1;
 }
 
 // Base class for Affine dialect ops.
 class Affine_Op<string mnemonic, list<OpTrait> traits = []> :
-    Op<Affine_Dialect, mnemonic, traits> {
+    Op<AffineOps_Dialect, mnemonic, traits> {
   // For every affine op, there needs to be a:
   //   * void print(OpAsmPrinter &p, ${C++ class of Op} op)
   //   * LogicalResult verify(${C++ class of Op} op)
@@ -290,7 +291,7 @@ def AffineIfOp : Affine_Op<"if",
 }
 
 class AffineMinMaxOpBase<string mnemonic, list<OpTrait> traits = []> :
-    Op<Affine_Dialect, mnemonic, traits> {
+    Op<AffineOps_Dialect, mnemonic, traits> {
   let arguments = (ins AffineMapAttr:$map, Variadic<Index>:$operands);
   let results = (outs Index);
 

mlir/include/mlir/Dialect/AffineOps/CMakeLists.txt

@@ -1 +1 @@
-add_mlir_dialect(AffineOps AffineOps)
+add_mlir_dialect(AffineOps affine AffineOps)

mlir/include/mlir/Dialect/FxpMathOps/CMakeLists.txt

@@ -1 +1 @@
-add_mlir_dialect(FxpMathOps FxpMathOps)
+add_mlir_dialect(FxpMathOps fxpmath FxpMathOps)

mlir/include/mlir/Dialect/FxpMathOps/FxpMathOps.h

@@ -17,11 +17,7 @@
 namespace mlir {
 namespace fxpmath {
 
-/// Defines the 'FxpMathOps' dialect.
-class FxpMathOpsDialect : public Dialect {
-public:
-  FxpMathOpsDialect(MLIRContext *context);
-};
+#include "mlir/Dialect/FxpMathOps/FxpMathOpsDialect.h.inc"
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/FxpMathOps/FxpMathOps.h.inc"

mlir/include/mlir/Dialect/FxpMathOps/FxpMathOps.td

@@ -15,10 +15,10 @@
 #define DIALECT_FXPMATHOPS_FXPMATH_OPS_
 
 include "mlir/IR/OpBase.td"
-include "mlir/Dialect/QuantOps/QuantPredicates.td"
+include "mlir/Dialect/QuantOps/QuantOpsBase.td"
 include "mlir/Interfaces/SideEffects.td"
 
-def fxpmath_Dialect : Dialect {
+def FxpMathOps_Dialect : Dialect {
   let name = "fxpmath";
 }
 
@@ -78,7 +78,7 @@ def fxpmath_CompareFnAttr : StrEnumAttr<"ComparisonFn",
 //===----------------------------------------------------------------------===//
 
 class fxpmath_Op<string mnemonic, list<OpTrait> traits> :
-    Op<fxpmath_Dialect, mnemonic, traits>;
+    Op<FxpMathOps_Dialect, mnemonic, traits>;
 
 //===----------------------------------------------------------------------===//
 // Fixed-point (fxp) arithmetic ops used by kernels.

mlir/include/mlir/Dialect/GPU/CMakeLists.txt

@@ -1 +1 @@
-add_mlir_dialect(GPUOps GPUOps)
+add_mlir_dialect(GPUOps gpu GPUOps)

mlir/include/mlir/Dialect/GPU/GPUDialect.h

@@ -26,51 +26,6 @@ class FuncOp;
 
 namespace gpu {
 
-/// The dialect containing GPU kernel launching operations and related
-/// facilities.
-class GPUDialect : public Dialect {
-public:
-  /// Create the dialect in the given `context`.
-  explicit GPUDialect(MLIRContext *context);
-  /// Get dialect namespace.
-  static StringRef getDialectNamespace() { return "gpu"; }
-
-  /// Get the name of the attribute used to annotate the modules that contain
-  /// kernel modules.
-  static StringRef getContainerModuleAttrName() {
-    return "gpu.container_module";
-  }
-
-  /// Get the canonical string name of the dialect.
-  static StringRef getDialectName();
-
-  /// Get the name of the attribute used to annotate external kernel functions.
-  static StringRef getKernelFuncAttrName() { return "gpu.kernel"; }
-
-  /// Get the name of the attribute used to annotate kernel modules.
-  static StringRef getKernelModuleAttrName() { return "gpu.kernel_module"; }
-
-  /// Returns whether the given function is a kernel function, i.e., has the
-  /// 'gpu.kernel' attribute.
-  static bool isKernel(Operation *op);
-
-  /// Returns the number of workgroup (thread, block) dimensions supported in
-  /// the GPU dialect.
-  // TODO(zinenko,herhut): consider generalizing this.
-  static unsigned getNumWorkgroupDimensions() { return 3; }
-
-  /// 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;
-};
-
 /// Utility class for the GPU dialect to represent triples of `Value`s
 /// accessible through `.x`, `.y`, and `.z` similarly to CUDA notation.
 struct KernelDim3 {
@@ -79,6 +34,8 @@ struct KernelDim3 {
   Value z;
 };
 
+#include "mlir/Dialect/GPU/GPUOpsDialect.h.inc"
+
 #define GET_OP_CLASSES
 #include "mlir/Dialect/GPU/GPUOps.h.inc"
 

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

@@ -28,6 +28,39 @@ def IntLikeOrLLVMInt : TypeConstraint<
 
 def GPU_Dialect : Dialect {
   let name = "gpu";
+  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.
+    static StringRef getKernelFuncAttrName() { return "gpu.kernel"; }
+
+    /// Get the name of the attribute used to annotate kernel modules.
+    static StringRef getKernelModuleAttrName() { return "gpu.kernel_module"; }
+
+    /// Returns whether the given function is a kernel function, i.e., has the
+    /// 'gpu.kernel' attribute.
+    static bool isKernel(Operation *op);
+
+    /// Returns the number of workgroup (thread, block) dimensions supported in
+    /// the GPU dialect.
+    // TODO(zinenko,herhut): consider generalizing this.
+    static unsigned getNumWorkgroupDimensions() { return 3; }
+
+    /// 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 = []> :

mlir/include/mlir/Dialect/LLVMIR/CMakeLists.txt

@@ -1,12 +1,13 @@
 set(LLVM_TARGET_DEFINITIONS LLVMOps.td)
 mlir_tablegen(LLVMOps.h.inc -gen-op-decls)
 mlir_tablegen(LLVMOps.cpp.inc -gen-op-defs)
+mlir_tablegen(LLVMOpsDialect.h.inc -gen-dialect-decls)
 mlir_tablegen(LLVMOpsEnums.h.inc -gen-enum-decls)
 mlir_tablegen(LLVMOpsEnums.cpp.inc -gen-enum-defs)
 add_public_tablegen_target(MLIRLLVMOpsIncGen)
 
-add_mlir_dialect(NVVMOps NVVMOps)
-add_mlir_dialect(ROCDLOps ROCDLOps)
+add_mlir_dialect(NVVMOps nvvm NVVMOps)
+add_mlir_dialect(ROCDLOps rocdl ROCDLOps)
 
 set(LLVM_TARGET_DEFINITIONS LLVMOps.td)
 mlir_tablegen(LLVMConversions.inc -gen-llvmir-conversions)

mlir/include/mlir/Dialect/LLVMIR/LLVMDialect.h

@@ -201,32 +201,7 @@ class LLVMType : public mlir::Type::TypeBase<LLVMType, mlir::Type,
 #define GET_OP_CLASSES
 #include "mlir/Dialect/LLVMIR/LLVMOps.h.inc"
 
-class LLVMDialect : public Dialect {
-public:
-  explicit LLVMDialect(MLIRContext *context);
-  ~LLVMDialect();
-  static StringRef getDialectNamespace() { return "llvm"; }
-
-  llvm::LLVMContext &getLLVMContext();
-  llvm::Module &getLLVMModule();
-
-  /// Parse a type registered to this dialect.
-  Type parseType(DialectAsmParser &parser) const override;
-
-  /// Print a type registered to this dialect.
-  void printType(Type type, DialectAsmPrinter &os) const override;
-
-  /// 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;
-};
+#include "mlir/Dialect/LLVMIR/LLVMOpsDialect.h.inc"
 
 /// Create an LLVM global containing the string "value" at the module containing
 /// surrounding the insertion point of builder. Obtain the address of that

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

@@ -19,11 +19,28 @@ include "mlir/IR/OpBase.td"
 def LLVM_Dialect : Dialect {
   let name = "llvm";
   let cppNamespace = "LLVM";
+  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.
-def LLVM_Type : Type<CPred<"$_self.isa<::mlir::LLVM::LLVMType>()">,
-                     "LLVM dialect type">;
+def LLVM_Type : DialectType<LLVM_Dialect,
+                            CPred<"$_self.isa<::mlir::LLVM::LLVMType>()">,
+                            "LLVM dialect type">;
 
 // Type constraint accepting only wrapped LLVM integer types.
 def LLVMInt : TypeConstraint<

mlir/include/mlir/Dialect/LLVMIR/NVVMDialect.h

@@ -25,12 +25,7 @@ namespace NVVM {
 #define GET_OP_CLASSES
 #include "mlir/Dialect/LLVMIR/NVVMOps.h.inc"
 
-class NVVMDialect : public Dialect {
-public:
-  explicit NVVMDialect(MLIRContext *context);
-
-  static StringRef getDialectNamespace() { return "nvvm"; }
-};
+#include "mlir/Dialect/LLVMIR/NVVMOpsDialect.h.inc"
 
 } // namespace NVVM
 } // namespace mlir

mlir/include/mlir/Dialect/LLVMIR/ROCDLDialect.h

@@ -33,12 +33,7 @@ namespace ROCDL {
 #define GET_OP_CLASSES
 #include "mlir/Dialect/LLVMIR/ROCDLOps.h.inc"
 
-class ROCDLDialect : public Dialect {
-public:
-  explicit ROCDLDialect(MLIRContext *context);
-
-  static StringRef getDialectNamespace() { return "rocdl"; }
-};
+#include "mlir/Dialect/LLVMIR/ROCDLOpsDialect.h.inc"
 
 } // namespace ROCDL
 } // namespace mlir

mlir/include/mlir/Dialect/Linalg/IR/CMakeLists.txt

@@ -1,4 +1,4 @@
-add_mlir_dialect(LinalgOps LinalgDoc)
+add_mlir_dialect(LinalgOps linalg LinalgDoc)
 set(LLVM_TARGET_DEFINITIONS LinalgStructuredOps.td)
 mlir_tablegen(LinalgStructuredOps.h.inc -gen-op-decls)
 mlir_tablegen(LinalgStructuredOps.cpp.inc -gen-op-defs)

mlir/include/mlir/Dialect/Linalg/IR/LinalgBase.td

@@ -34,6 +34,6 @@ def Linalg_Dialect : Dialect {
 
 // Whether a type is a RangeType.
 def LinalgIsRangeTypePred : CPred<"$_self.isa<RangeType>()">;
-def Range : Type<LinalgIsRangeTypePred, "range">;
+def Range : DialectType<Linalg_Dialect, LinalgIsRangeTypePred, "range">;
 
 #endif // LINALG_BASE

mlir/include/mlir/Dialect/Linalg/IR/LinalgTypes.h

@@ -21,17 +21,7 @@ enum LinalgTypes {
   LAST_USED_LINALG_TYPE = Range,
 };
 
-class LinalgDialect : public Dialect {
-public:
-  explicit LinalgDialect(MLIRContext *context);
-  static StringRef getDialectNamespace() { return "linalg"; }
-
-  /// Parse a type registered to this dialect.
-  Type parseType(DialectAsmParser &parser) const override;
-
-  /// Print a type registered to this dialect.
-  void printType(Type type, DialectAsmPrinter &os) const override;
-};
+#include "mlir/Dialect/Linalg/IR/LinalgOpsDialect.h.inc"
 
 /// A RangeType represents a minimal range abstraction (min, max, step).
 /// It is constructed by calling the linalg.range op with three values index of

mlir/include/mlir/Dialect/LoopOps/CMakeLists.txt

@@ -1 +1 @@
-add_mlir_dialect(LoopOps LoopOps)
+add_mlir_dialect(LoopOps loop LoopOps)

mlir/include/mlir/Dialect/LoopOps/LoopOps.h

@@ -25,11 +25,7 @@ namespace loop {
 
 class TerminatorOp;
 
-class LoopOpsDialect : public Dialect {
-public:
-  LoopOpsDialect(MLIRContext *context);
-  static StringRef getDialectNamespace() { return "loop"; }
-};
+#include "mlir/Dialect/LoopOps/LoopOpsDialect.h.inc"
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/LoopOps/LoopOps.h.inc"

mlir/include/mlir/Dialect/LoopOps/LoopOps.td

@@ -16,14 +16,14 @@
 include "mlir/Interfaces/LoopLikeInterface.td"
 include "mlir/Interfaces/SideEffects.td"
 
-def Loop_Dialect : Dialect {
+def LoopOps_Dialect : Dialect {
   let name = "loop";
   let cppNamespace = "";
 }
 
 // Base class for Loop dialect ops.
 class Loop_Op<string mnemonic, list<OpTrait> traits = []> :
-    Op<Loop_Dialect, mnemonic, traits> {
+    Op<LoopOps_Dialect, mnemonic, traits> {
   // For every standard op, there needs to be a:
   //   * void print(OpAsmPrinter &p, ${C++ class of Op} op)
   //   * LogicalResult verify(${C++ class of Op} op)

mlir/include/mlir/Dialect/OpenMP/CMakeLists.txt

@@ -1 +1 @@
-add_mlir_dialect(OpenMPOps OpenMPOps)
+add_mlir_dialect(OpenMPOps omp OpenMPOps)