[mlir] Generare .cpp.inc files for dialects.

[stellaraccident]

Summary

• Previously, we were only generating .h.inc files. We foresee the need to also generate implementations and this is a step towards that.
• Discussed in https://llvm.discourse.group/t/generating-cpp-inc-files-for-dialects/3732/2
• Deviates from the discussion above by generating a default destructor in the .cpp.inc file (and adding a tablegen bit that disables this in case if this is user provided). The Test dialect uses this feature but others appear not to.
• Generating the destructor started as a way to flush out the missing includes (produces a link error), but it is a strict improvement on its own that is worth doing (i.e. by emitting key methods in the .cpp file, we root vtables in one translation unit, which is a non-controversial improvement).

[rriddle]

Generally looks good to me.

mlir/include/mlir/IR/OpBase.td

272

I couldn't tell from the description, is this supposed to be temporary?

mlir/tools/mlir-tblgen/DialectGen.cpp

63

nit: Drop else after returns.

269

Drop trivial braces here.

[lattner]

This looks great to me Stella, nice work. I don't have any additional comments on top of River's

[stellaraccident]

mlir/include/mlir/IR/OpBase.td

272

No: I added it because the test dialect does define its own destructor and I needed to support that (it appears to be the only one). Open to other ways to do this, but it seemed neighborly to leave the option open to folks who need it.

[stellaraccident]

Comments

[stellaraccident]

Patch all dialects

[stellaraccident]

Fix samples.

[stellaraccident]

Update bazel build files.

[stellaraccident]

Rename hasExplicitDestructor to hasNonDefaultDestructor (on a second read, this seemed like an improvement to me).

Rebase and fix standalone dialect template.

[newling]

mlir/examples/standalone/lib/Standalone/StandaloneDialect.cpp

15

This seems to have broken the standalone example for me. Is the standalone example tested?

[mehdi_amini]

mlir/examples/standalone/lib/Standalone/StandaloneDialect.cpp

15

It should be: is it broken at HEAD?

mlir/cmake/modules/AddMLIR.cmake

 # Declare a dialect in the include directory
 function(add_mlir_dialect dialect dialect_namespace)
   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}Types.h.inc -gen-typedef-decls)
   mlir_tablegen(${dialect}Types.cpp.inc -gen-typedef-defs)
   mlir_tablegen(${dialect}Dialect.h.inc -gen-dialect-decls -dialect=${dialect_namespace})
+  mlir_tablegen(${dialect}Dialect.cpp.inc -gen-dialect-defs -dialect=${dialect_namespace})
   add_public_tablegen_target(MLIR${dialect}IncGen)
   add_dependencies(mlir-headers MLIR${dialect}IncGen)
 endfunction()
 
 # Declare a dialect in the include directory
 function(add_mlir_interface interface)
   set(LLVM_TARGET_DEFINITIONS ${interface}.td)
   mlir_tablegen(${interface}.h.inc -gen-op-interface-decls)

mlir/examples/standalone/lib/Standalone/StandaloneDialect.cpp

 //===- StandaloneDialect.cpp - Standalone dialect ---------------*- C++ -*-===//
 //
 // This file is licensed under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Standalone/StandaloneDialect.h"
 #include "Standalone/StandaloneOps.h"
 
 using namespace mlir;
 using namespace mlir::standalone;
 
+#include "Standalone/StandaloneOpsDialect.cpp.inc"
+
 //===----------------------------------------------------------------------===//
 // Standalone dialect.
 //===----------------------------------------------------------------------===//
 
 void StandaloneDialect::initialize() {
   addOperations<
 #define GET_OP_LIST
 #include "Standalone/StandaloneOps.cpp.inc"
       >();
 }

mlir/examples/toy/Ch2/include/toy/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS Ops.td)
 mlir_tablegen(Ops.h.inc -gen-op-decls)
 mlir_tablegen(Ops.cpp.inc -gen-op-defs)
 mlir_tablegen(Dialect.h.inc -gen-dialect-decls)
+mlir_tablegen(Dialect.cpp.inc -gen-dialect-defs)
 add_public_tablegen_target(ToyCh2OpsIncGen)

mlir/examples/toy/Ch2/mlir/Dialect.cpp

 
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/OpImplementation.h"
 
 using namespace mlir;
 using namespace mlir::toy;
 
+#include "toy/Dialect.cpp.inc"
+
 //===----------------------------------------------------------------------===//
 // ToyDialect
 //===----------------------------------------------------------------------===//
 
 /// Dialect initialization, the instance will be owned by the context. This is
 /// the point of registration of types and operations for the dialect.
 void ToyDialect::initialize() {
   addOperations<

mlir/examples/toy/Ch3/include/toy/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS Ops.td)
 mlir_tablegen(Ops.h.inc -gen-op-decls)
 mlir_tablegen(Ops.cpp.inc -gen-op-defs)
 mlir_tablegen(Dialect.h.inc -gen-dialect-decls)
+mlir_tablegen(Dialect.cpp.inc -gen-dialect-defs)
 add_public_tablegen_target(ToyCh3OpsIncGen)

mlir/examples/toy/Ch3/mlir/Dialect.cpp

 
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/OpImplementation.h"
 
 using namespace mlir;
 using namespace mlir::toy;
 
+#include "toy/Dialect.cpp.inc"
+
 //===----------------------------------------------------------------------===//
 // ToyDialect
 //===----------------------------------------------------------------------===//
 
 /// Dialect initialization, the instance will be owned by the context. This is
 /// the point of registration of types and operations for the dialect.
 void ToyDialect::initialize() {
   addOperations<

mlir/examples/toy/Ch4/include/toy/CMakeLists.txt

 # Most dialects should use add_mlir_dialect().  See examples/standalone.
 set(LLVM_TARGET_DEFINITIONS Ops.td)
 mlir_tablegen(Ops.h.inc -gen-op-decls)
 mlir_tablegen(Ops.cpp.inc -gen-op-defs)
 mlir_tablegen(Dialect.h.inc -gen-dialect-decls)
+mlir_tablegen(Dialect.cpp.inc -gen-dialect-defs)
 add_public_tablegen_target(ToyCh4OpsIncGen)
 
 # Most dialects should use add_mlir_interfaces().
 set(LLVM_TARGET_DEFINITIONS ShapeInferenceInterface.td)
 mlir_tablegen(ShapeInferenceOpInterfaces.h.inc -gen-op-interface-decls)
 mlir_tablegen(ShapeInferenceOpInterfaces.cpp.inc -gen-op-interface-defs)
 add_public_tablegen_target(ToyCh4ShapeInferenceInterfaceIncGen)

mlir/examples/toy/Ch4/mlir/Dialect.cpp

 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/Transforms/InliningUtils.h"
 
 using namespace mlir;
 using namespace mlir::toy;
 
+#include "toy/Dialect.cpp.inc"
+
 //===----------------------------------------------------------------------===//
 // ToyInlinerInterface
 //===----------------------------------------------------------------------===//
 
 /// This class defines the interface for handling inlining with Toy
 /// operations.
 struct ToyInlinerInterface : public DialectInlinerInterface {
   using DialectInlinerInterface::DialectInlinerInterface;

mlir/examples/toy/Ch5/include/toy/CMakeLists.txt

 # Most dialects should use add_mlir_dialect().  See examples/standalone.
 set(LLVM_TARGET_DEFINITIONS Ops.td)
 mlir_tablegen(Ops.h.inc -gen-op-decls)
 mlir_tablegen(Ops.cpp.inc -gen-op-defs)
 mlir_tablegen(Dialect.h.inc -gen-dialect-decls)
+mlir_tablegen(Dialect.cpp.inc -gen-dialect-defs)
 add_public_tablegen_target(ToyCh5OpsIncGen)
 
 # Most dialects should use add_mlir_interfaces().
 set(LLVM_TARGET_DEFINITIONS ShapeInferenceInterface.td)
 mlir_tablegen(ShapeInferenceOpInterfaces.h.inc -gen-op-interface-decls)
 mlir_tablegen(ShapeInferenceOpInterfaces.cpp.inc -gen-op-interface-defs)
 add_public_tablegen_target(ToyCh5ShapeInferenceInterfaceIncGen)

mlir/examples/toy/Ch5/mlir/Dialect.cpp

 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/Transforms/InliningUtils.h"
 
 using namespace mlir;
 using namespace mlir::toy;
 
+#include "toy/Dialect.cpp.inc"
+
 //===----------------------------------------------------------------------===//
 // ToyInlinerInterface
 //===----------------------------------------------------------------------===//
 
 /// This class defines the interface for handling inlining with Toy
 /// operations.
 struct ToyInlinerInterface : public DialectInlinerInterface {
   using DialectInlinerInterface::DialectInlinerInterface;

mlir/examples/toy/Ch6/include/toy/CMakeLists.txt

 # Most dialects should use add_mlir_dialect().  See examples/standalone.
 set(LLVM_TARGET_DEFINITIONS Ops.td)
 mlir_tablegen(Ops.h.inc -gen-op-decls)
 mlir_tablegen(Ops.cpp.inc -gen-op-defs)
 mlir_tablegen(Dialect.h.inc -gen-dialect-decls)
+mlir_tablegen(Dialect.cpp.inc -gen-dialect-defs)
 add_public_tablegen_target(ToyCh6OpsIncGen)
 
 # Most dialects should use add_mlir_interfaces().
 set(LLVM_TARGET_DEFINITIONS ShapeInferenceInterface.td)
 mlir_tablegen(ShapeInferenceOpInterfaces.h.inc -gen-op-interface-decls)
 mlir_tablegen(ShapeInferenceOpInterfaces.cpp.inc -gen-op-interface-defs)
 add_public_tablegen_target(ToyCh6ShapeInferenceInterfaceIncGen)

mlir/examples/toy/Ch6/mlir/Dialect.cpp

 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/Transforms/InliningUtils.h"
 
 using namespace mlir;
 using namespace mlir::toy;
 
+#include "toy/Dialect.cpp.inc"
+
 //===----------------------------------------------------------------------===//
 // ToyInlinerInterface
 //===----------------------------------------------------------------------===//
 
 /// This class defines the interface for handling inlining with Toy
 /// operations.
 struct ToyInlinerInterface : public DialectInlinerInterface {
   using DialectInlinerInterface::DialectInlinerInterface;

mlir/examples/toy/Ch7/include/toy/CMakeLists.txt

 # Most dialects should use add_mlir_dialect().  See examples/standalone.
 set(LLVM_TARGET_DEFINITIONS Ops.td)
 mlir_tablegen(Ops.h.inc -gen-op-decls)
 mlir_tablegen(Ops.cpp.inc -gen-op-defs)
 mlir_tablegen(Dialect.h.inc -gen-dialect-decls)
+mlir_tablegen(Dialect.cpp.inc -gen-dialect-defs)
 add_public_tablegen_target(ToyCh7OpsIncGen)
 
 # Most dialects should use add_mlir_interfaces().
 set(LLVM_TARGET_DEFINITIONS ShapeInferenceInterface.td)
 mlir_tablegen(ShapeInferenceOpInterfaces.h.inc -gen-op-interface-decls)
 mlir_tablegen(ShapeInferenceOpInterfaces.cpp.inc -gen-op-interface-defs)
 add_public_tablegen_target(ToyCh7ShapeInferenceInterfaceIncGen)

mlir/examples/toy/Ch7/mlir/Dialect.cpp

 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/Transforms/InliningUtils.h"
 
 using namespace mlir;
 using namespace mlir::toy;
 
+#include "toy/Dialect.cpp.inc"
+
 //===----------------------------------------------------------------------===//
 // ToyInlinerInterface
 //===----------------------------------------------------------------------===//
 
 /// This class defines the interface for handling inlining with Toy
 /// operations.
 struct ToyInlinerInterface : public DialectInlinerInterface {
   using DialectInlinerInterface::DialectInlinerInterface;

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

 add_subdirectory(Transforms)
 
 set(LLVM_TARGET_DEFINITIONS LLVMAttrDefs.td)
 mlir_tablegen(LLVMOpsAttrDefs.h.inc -gen-attrdef-decls)
 mlir_tablegen(LLVMOpsAttrDefs.cpp.inc -gen-attrdef-defs)
 add_public_tablegen_target(MLIRLLVMAttrsIncGen)
 
 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(LLVMOpsDialect.cpp.inc -gen-dialect-defs)
 mlir_tablegen(LLVMOpsEnums.h.inc -gen-enum-decls)
 mlir_tablegen(LLVMOpsEnums.cpp.inc -gen-enum-defs)
 add_public_tablegen_target(MLIRLLVMOpsIncGen)
 
 add_mlir_doc(LLVMOps LLVMOps Dialects/ -gen-op-doc)
 
 add_mlir_interface(LLVMOpsInterfaces)
 

mlir/include/mlir/Dialect/OpenACC/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS ${LLVM_MAIN_INCLUDE_DIR}/llvm/Frontend/OpenACC/ACC.td)
 mlir_tablegen(AccCommon.td --gen-directive-decl)
 add_public_tablegen_target(acc_common_td)
 
 set(LLVM_TARGET_DEFINITIONS OpenACCOps.td)
 mlir_tablegen(OpenACCOpsDialect.h.inc -gen-dialect-decls -dialect=acc)
+mlir_tablegen(OpenACCOpsDialect.cpp.inc -gen-dialect-defs -dialect=acc)
 mlir_tablegen(OpenACCOps.h.inc -gen-op-decls)
 mlir_tablegen(OpenACCOps.cpp.inc -gen-op-defs)
 mlir_tablegen(OpenACCOpsEnums.h.inc -gen-enum-decls)
 mlir_tablegen(OpenACCOpsEnums.cpp.inc -gen-enum-defs)
 add_mlir_doc(OpenACCOps OpenACCDialect Dialects/ -gen-dialect-doc)
 add_public_tablegen_target(MLIROpenACCOpsIncGen)
 add_dependencies(OpenACCDialectDocGen acc_common_td)

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

 set(LLVM_TARGET_DEFINITIONS ${LLVM_MAIN_INCLUDE_DIR}/llvm/Frontend/OpenMP/OMP.td)
 mlir_tablegen(OmpCommon.td --gen-directive-decl)
 add_public_tablegen_target(omp_common_td)
 
 set(LLVM_TARGET_DEFINITIONS OpenMPOps.td)
 mlir_tablegen(OpenMPOpsDialect.h.inc -gen-dialect-decls -dialect=omp)
+mlir_tablegen(OpenMPOpsDialect.cpp.inc -gen-dialect-defs -dialect=omp)
 mlir_tablegen(OpenMPOps.h.inc -gen-op-decls)
 mlir_tablegen(OpenMPOps.cpp.inc -gen-op-defs)
 mlir_tablegen(OpenMPOpsEnums.h.inc -gen-enum-decls)
 mlir_tablegen(OpenMPOpsEnums.cpp.inc -gen-enum-defs)
 add_mlir_doc(OpenMPOps OpenMPDialect Dialects/ -gen-dialect-doc)
 add_public_tablegen_target(MLIROpenMPOpsIncGen)
 add_dependencies(OpenMPDialectDocGen omp_common_td)

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

 set(LLVM_TARGET_DEFINITIONS Ops.td)
 mlir_tablegen(Ops.h.inc -gen-op-decls)
 mlir_tablegen(Ops.cpp.inc -gen-op-defs)
 mlir_tablegen(OpsDialect.h.inc -gen-dialect-decls)
+mlir_tablegen(OpsDialect.cpp.inc -gen-dialect-defs)
 mlir_tablegen(OpsEnums.h.inc -gen-enum-decls)
 mlir_tablegen(OpsEnums.cpp.inc -gen-enum-defs)
 add_public_tablegen_target(MLIRStandardOpsIncGen)
 
 add_mlir_doc(Ops StandardOps Dialects/ -gen-op-doc)

mlir/include/mlir/IR/CMakeLists.txt

 add_mlir_interface(OpAsmInterface)
 add_mlir_interface(SymbolInterfaces)
 add_mlir_interface(RegionKindInterface)
 
 set(LLVM_TARGET_DEFINITIONS BuiltinAttributes.td)
 mlir_tablegen(BuiltinAttributes.h.inc -gen-attrdef-decls)
 mlir_tablegen(BuiltinAttributes.cpp.inc -gen-attrdef-defs)
 add_public_tablegen_target(MLIRBuiltinAttributesIncGen)
 
 set(LLVM_TARGET_DEFINITIONS BuiltinDialect.td)
 mlir_tablegen(BuiltinDialect.h.inc -gen-dialect-decls)
+mlir_tablegen(BuiltinDialect.cpp.inc -gen-dialect-defs)
 add_public_tablegen_target(MLIRBuiltinDialectIncGen)
 
 set(LLVM_TARGET_DEFINITIONS BuiltinLocationAttributes.td)
 mlir_tablegen(BuiltinLocationAttributes.h.inc -gen-attrdef-decls)
 mlir_tablegen(BuiltinLocationAttributes.cpp.inc -gen-attrdef-defs)
 add_public_tablegen_target(MLIRBuiltinLocationAttributesIncGen)
 
 set(LLVM_TARGET_DEFINITIONS BuiltinOps.td)

mlir/include/mlir/IR/OpBase.td

class Dialect {
 
   // 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 the dialect definition provides a non-default destructor.
+  /// If false, a default destructor implementation will be generated.
+  bit hasNonDefaultDestructor = 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.

mlir/include/mlir/TableGen/Dialect.h

public:
   ArrayRef<StringRef> getDependentDialects() const;
 
   // Returns the dialects extra class declaration code.
   llvm::Optional<StringRef> getExtraClassDeclaration() const;
 
   /// Returns true if this dialect has a canonicalizer.
   bool hasCanonicalizer() const;
 
-  // Returns true if this dialect has a constant materializer.
+  /// Returns true if this dialect has a constant materializer.
   bool hasConstantMaterializer() const;
 
+  /// Returns true if the destructor definition is provided explicitly or
+  /// false if a default should be generated.
+  bool hasNonDefaultDestructor() const;
+
   /// Returns true if this dialect has an operation attribute verifier.
   bool hasOperationAttrVerify() const;
 
   /// Returns true if this dialect has a region argument attribute verifier.
   bool hasRegionArgAttrVerify() const;
 
   /// Returns true if this dialect has a region result attribute verifier.
   bool hasRegionResultAttrVerify() const;

mlir/lib/Dialect/AMX/IR/AMXDialect.cpp

 #include "mlir/Dialect/AMX/AMXDialect.h"
 #include "mlir/Dialect/LLVMIR/LLVMTypes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/TypeUtilities.h"
 
 using namespace mlir;
 
+#include "mlir/Dialect/AMX/AMXDialect.cpp.inc"
+
 void amx::AMXDialect::initialize() {
   addOperations<
 #define GET_OP_LIST
 #include "mlir/Dialect/AMX/AMX.cpp.inc"
       >();
 }
 
 /// Verify that AMX supports the implied tile shape.

mlir/lib/Dialect/Affine/IR/AffineOps.cpp

 #include "llvm/ADT/SmallBitVector.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/Debug.h"
 
 using namespace mlir;
 
 #define DEBUG_TYPE "affine-analysis"
 
+#include "mlir/Dialect/Affine/IR/AffineOpsDialect.cpp.inc"
+
 /// A utility function to check if a value is defined at the top level of
 /// `region` or is an argument of `region`. A value of index type defined at the
 /// top level of a `AffineScope` region is always a valid symbol for all
 /// uses in that region.
 static bool isTopLevelValue(Value value, Region *region) {
   if (auto arg = value.dyn_cast<BlockArgument>())
     return arg.getParentRegion() == region;
   return value.getDefiningOp()->getParentRegion() == region;

mlir/lib/Dialect/ArmNeon/IR/ArmNeonDialect.cpp

 #include "mlir/Dialect/ArmNeon/ArmNeonDialect.h"
 #include "mlir/Dialect/Vector/VectorOps.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/TypeUtilities.h"
 
 using namespace mlir;
 
+#include "mlir/Dialect/ArmNeon/ArmNeonDialect.cpp.inc"
+
 void arm_neon::ArmNeonDialect::initialize() {
   addOperations<
 #define GET_OP_LIST
 #include "mlir/Dialect/ArmNeon/ArmNeon.cpp.inc"
       >();
 }
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/ArmNeon/ArmNeon.cpp.inc"

mlir/lib/Dialect/ArmSVE/IR/ArmSVEDialect.cpp

 #include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/TypeUtilities.h"
 #include "llvm/ADT/TypeSwitch.h"
 
 using namespace mlir;
 using namespace arm_sve;
 
+#include "mlir/Dialect/ArmSVE/ArmSVEDialect.cpp.inc"
+
 static Type getI1SameShape(Type type);
 static void buildScalableCmpIOp(OpBuilder &build, OperationState &result,
                                 CmpIPredicate predicate, Value lhs, Value rhs);
 static void buildScalableCmpFOp(OpBuilder &build, OperationState &result,
                                 CmpFPredicate predicate, Value lhs, Value rhs);
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/ArmSVE/ArmSVE.cpp.inc"

mlir/lib/Dialect/Async/IR/Async.cpp

 //===- Async.cpp - MLIR Async Operations ----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Async/IR/Async.h"
 
 #include "mlir/IR/DialectImplementation.h"
 #include "llvm/ADT/TypeSwitch.h"
 
 using namespace mlir;
 using namespace mlir::async;
 
+#include "mlir/Dialect/Async/IR/AsyncOpsDialect.cpp.inc"
+
 void AsyncDialect::initialize() {
   addOperations<
 #define GET_OP_LIST
 #include "mlir/Dialect/Async/IR/AsyncOps.cpp.inc"
       >();
   addTypes<
 #define GET_TYPEDEF_LIST
 #include "mlir/Dialect/Async/IR/AsyncOpsTypes.cpp.inc"

mlir/lib/Dialect/Complex/IR/ComplexDialect.cpp

 //===- ComplexDialect.cpp - MLIR Complex Dialect --------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Complex/IR/Complex.h"
 
+#include "mlir/Dialect/Complex/IR/ComplexOpsDialect.cpp.inc"
+
 void mlir::complex::ComplexDialect::initialize() {
   addOperations<
 #define GET_OP_LIST
 #include "mlir/Dialect/Complex/IR/ComplexOps.cpp.inc"
       >();
 }

mlir/lib/Dialect/DLTI/DLTI.cpp

 #include "mlir/IR/BuiltinDialect.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "llvm/ADT/TypeSwitch.h"
 
 using namespace mlir;
 
+#include "mlir/Dialect/DLTI/DLTIDialect.cpp.inc"
+
 //===----------------------------------------------------------------------===//
 // DataLayoutEntryAttr
 //===----------------------------------------------------------------------===//
 //
 constexpr const StringLiteral mlir::DataLayoutEntryAttr::kAttrKeyword;
 
 namespace mlir {
 namespace impl {

mlir/lib/Dialect/EmitC/IR/EmitC.cpp

 //===- EmitC.cpp - EmitC Dialect ------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/EmitC/IR/EmitC.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "llvm/ADT/TypeSwitch.h"
 
 using namespace mlir;
 using namespace mlir::emitc;
 
+#include "mlir/Dialect/EmitC/IR/EmitCDialect.cpp.inc"
+
 //===----------------------------------------------------------------------===//
 // EmitCDialect
 //===----------------------------------------------------------------------===//
 
 void EmitCDialect::initialize() {
   addOperations<
 #define GET_OP_LIST
 #include "mlir/Dialect/EmitC/IR/EmitC.cpp.inc"

mlir/lib/Dialect/GPU/IR/GPUDialect.cpp

 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/IR/TypeUtilities.h"
 #include "llvm/ADT/TypeSwitch.h"
 
 using namespace mlir;
 using namespace mlir::gpu;
 
+#include "mlir/Dialect/GPU/GPUOpsDialect.cpp.inc"
+
 //===----------------------------------------------------------------------===//
 // MMAMatrixType
 //===----------------------------------------------------------------------===//
 
 MMAMatrixType MMAMatrixType::get(ArrayRef<int64_t> shape, Type elementType,
                                  StringRef operand) {
   return Base::get(elementType.getContext(), shape, elementType, operand);
 }

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

 #include "llvm/Support/Mutex.h"
 #include "llvm/Support/SourceMgr.h"
 
 #include <iostream>
 
 using namespace mlir;
 using namespace mlir::LLVM;
 
+#include "mlir/Dialect/LLVMIR/LLVMOpsDialect.cpp.inc"
+
 static constexpr const char kVolatileAttrName[] = "volatile_";
 static constexpr const char kNonTemporalAttrName[] = "nontemporal";
 
 #include "mlir/Dialect/LLVMIR/LLVMOpsEnums.cpp.inc"
 #include "mlir/Dialect/LLVMIR/LLVMOpsInterfaces.cpp.inc"
 #define GET_ATTRDEF_CLASSES
 #include "mlir/Dialect/LLVMIR/LLVMOpsAttrDefs.cpp.inc"
 

mlir/lib/Dialect/LLVMIR/IR/NVVMDialect.cpp

 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Type.h"
 #include "llvm/Support/SourceMgr.h"
 
 using namespace mlir;
 using namespace NVVM;
 
+#include "mlir/Dialect/LLVMIR/NVVMOpsDialect.cpp.inc"
+
 //===----------------------------------------------------------------------===//
 // Printing/parsing for NVVM ops
 //===----------------------------------------------------------------------===//
 
 static void printNVVMIntrinsicOp(OpAsmPrinter &p, Operation *op) {
   p << op->getName() << " " << op->getOperands();
   if (op->getNumResults() > 0)
     p << " : " << op->getResultTypes();

mlir/lib/Dialect/LLVMIR/IR/ROCDLDialect.cpp

 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Type.h"
 #include "llvm/Support/SourceMgr.h"
 
 using namespace mlir;
 using namespace ROCDL;
 
+#include "mlir/Dialect/LLVMIR/ROCDLOpsDialect.cpp.inc"
+
 //===----------------------------------------------------------------------===//
 // Parsing for ROCDL ops
 //===----------------------------------------------------------------------===//
 
 // <operation> ::=
 //     `llvm.amdgcn.buffer.load.* %rsrc, %vindex, %offset, %glc, %slc :
 //     result_type`
 static ParseResult parseROCDLMubufLoadOp(OpAsmParser &parser,

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

 #include "llvm/ADT/StringSet.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace mlir;
 using namespace mlir::linalg;
 
+#include "mlir/Dialect/Linalg/IR/LinalgOpsDialect.cpp.inc"
+
 /// Forward declarations.
 
 /// Generic entry point to create the block for the region of a LinalgOp.
 /// This is used by both named structured ops created by ods-gen and by manually
 /// defined C++ ops.
 /// This is used by both builders and parsers.
 /// This function creates the block in the region with arguments corresponding
 /// to the elemental types of `inputTypes` and `outputTypes`. The latter are

mlir/lib/Dialect/Math/IR/MathDialect.cpp

 //===- MathDialect.cpp - MLIR dialect for Math implementation -------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Math/IR/Math.h"
 #include "mlir/Transforms/InliningUtils.h"
 
 using namespace mlir;
 using namespace mlir::math;
 
+#include "mlir/Dialect/Math/IR/MathOpsDialect.cpp.inc"
+
 namespace {
 /// This class defines the interface for handling inlining with math
 /// operations.
 struct MathInlinerInterface : public DialectInlinerInterface {
   using DialectInlinerInterface::DialectInlinerInterface;
 
   /// All operations within math ops can be inlined.
   bool isLegalToInline(Operation *, Region *, bool,

mlir/lib/Dialect/MemRef/IR/MemRefDialect.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Transforms/InliningUtils.h"
 
 using namespace mlir;
 using namespace mlir::memref;
 
+#include "mlir/Dialect/MemRef/IR/MemRefOpsDialect.cpp.inc"
+
 //===----------------------------------------------------------------------===//
 // MemRefDialect Dialect Interfaces
 //===----------------------------------------------------------------------===//
 
 namespace {
 struct MemRefInlinerInterface : public DialectInlinerInterface {
   using DialectInlinerInterface::DialectInlinerInterface;
   bool isLegalToInline(Region *dest, Region *src, bool wouldBeCloned,

mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp

 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/Transforms/DialectConversion.h"
 
 using namespace mlir;
 using namespace acc;
 
+#include "mlir/Dialect/OpenACC/OpenACCOpsDialect.cpp.inc"
+
 //===----------------------------------------------------------------------===//
 // OpenACC operations
 //===----------------------------------------------------------------------===//
 
 void OpenACCDialect::initialize() {
   addOperations<
 #define GET_OP_LIST
 #include "mlir/Dialect/OpenACC/OpenACCOps.cpp.inc"

mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp

 #include "mlir/IR/OperationSupport.h"
 
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include <cstddef>
 
+#include "mlir/Dialect/OpenMP/OpenMPOpsDialect.cpp.inc"
 #include "mlir/Dialect/OpenMP/OpenMPOpsEnums.cpp.inc"
 
 using namespace mlir;
 using namespace mlir::omp;
 
 void OpenMPDialect::initialize() {
   addOperations<
 #define GET_OP_LIST

mlir/lib/Dialect/PDL/IR/PDL.cpp

 #include "mlir/Dialect/PDL/IR/PDLTypes.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/Interfaces/InferTypeOpInterface.h"
 #include "llvm/ADT/StringSwitch.h"
 
 using namespace mlir;
 using namespace mlir::pdl;
 
+#include "mlir/Dialect/PDL/IR/PDLOpsDialect.cpp.inc"
+
 //===----------------------------------------------------------------------===//
 // PDLDialect
 //===----------------------------------------------------------------------===//
 
 void PDLDialect::initialize() {
   addOperations<
 #define GET_OP_LIST
 #include "mlir/Dialect/PDL/IR/PDLOps.cpp.inc"

mlir/lib/Dialect/PDLInterp/IR/PDLInterp.cpp

 //===- PDLInterp.cpp - PDL Interpreter Dialect ------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/PDLInterp/IR/PDLInterp.h"
 #include "mlir/Dialect/PDL/IR/PDLTypes.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/DialectImplementation.h"
 
 using namespace mlir;
 using namespace mlir::pdl_interp;
 
+#include "mlir/Dialect/PDLInterp/IR/PDLInterpOpsDialect.cpp.inc"
+
 //===----------------------------------------------------------------------===//
 // PDLInterp Dialect
 //===----------------------------------------------------------------------===//
 
 void PDLInterpDialect::initialize() {
   addOperations<
 #define GET_OP_LIST
 #include "mlir/Dialect/PDLInterp/IR/PDLInterpOps.cpp.inc"

mlir/lib/Dialect/Quant/IR/QuantOps.cpp

 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/MathExtras.h"
 #include <numeric>
 
 using namespace mlir;
 using namespace mlir::quant;
 using namespace mlir::quant::detail;
 
+#include "mlir/Dialect/Quant/QuantOpsDialect.cpp.inc"
+
 void QuantizationDialect::initialize() {
   addTypes<AnyQuantizedType, CalibratedQuantizedType, UniformQuantizedType,
            UniformQuantizedPerAxisType>();
   addOperations<
 #define GET_OP_LIST
 #include "mlir/Dialect/Quant/QuantOps.cpp.inc"
       >();
 }

mlir/lib/Dialect/SCF/SCF.cpp

 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Support/MathExtras.h"
 #include "mlir/Transforms/InliningUtils.h"
 
 using namespace mlir;
 using namespace mlir::scf;
 
+#include "mlir/Dialect/SCF/SCFOpsDialect.cpp.inc"
+
 //===----------------------------------------------------------------------===//
 // SCFDialect Dialect Interfaces
 //===----------------------------------------------------------------------===//
 
 namespace {
 struct SCFInlinerInterface : public DialectInlinerInterface {
   using DialectInlinerInterface::DialectInlinerInterface;
   // We don't have any special restrictions on what can be inlined into

mlir/lib/Dialect/SPIRV/IR/SPIRVDialect.cpp

 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace mlir;
 using namespace mlir::spirv;
 
+#include "mlir/Dialect/SPIRV/IR/SPIRVOpsDialect.cpp.inc"
+
 //===----------------------------------------------------------------------===//
 // InlinerInterface
 //===----------------------------------------------------------------------===//
 
 /// Returns true if the given region contains spv.Return or spv.ReturnValue ops.
 static inline bool containsReturn(Region &region) {
   return llvm::any_of(region, [](Block &block) {
     Operation *terminator = block.getTerminator();

mlir/lib/Dialect/Shape/IR/Shape.cpp

 #include "mlir/Transforms/InliningUtils.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace mlir;
 using namespace mlir::shape;
 
+#include "mlir/Dialect/Shape/IR/ShapeOpsDialect.cpp.inc"
+
 namespace {
 #include "ShapeCanonicalization.inc"
 }
 
 RankedTensorType shape::getExtentTensorType(MLIRContext *ctx, int64_t rank) {
   return RankedTensorType::get({rank}, IndexType::get(ctx));
 }
 

mlir/lib/Dialect/SparseTensor/IR/SparseTensorDialect.cpp

 #include "mlir/IR/Builders.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/OpImplementation.h"
 #include "llvm/ADT/TypeSwitch.h"
 
 using namespace mlir;
 using namespace mlir::sparse_tensor;
 
+#include "mlir/Dialect/SparseTensor/IR/SparseTensorOpsDialect.cpp.inc"
+
 //===----------------------------------------------------------------------===//
 // TensorDialect Attribute Methods.
 //===----------------------------------------------------------------------===//
 
 #define GET_ATTRDEF_CLASSES
 #include "mlir/Dialect/SparseTensor/IR/SparseTensorAttrDefs.cpp.inc"
 
 static bool acceptBitWidth(unsigned bitWidth) {

mlir/lib/Dialect/StandardOps/IR/Ops.cpp

 #include "mlir/IR/Value.h"
 #include "mlir/Support/MathExtras.h"
 #include "mlir/Transforms/InliningUtils.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/raw_ostream.h"
 
+#include "mlir/Dialect/StandardOps/IR/OpsDialect.cpp.inc"
+
 // Pull in all enum type definitions and utility function declarations.
 #include "mlir/Dialect/StandardOps/IR/OpsEnums.cpp.inc"
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // StandardOpsDialect Interfaces
 //===----------------------------------------------------------------------===//

mlir/lib/Dialect/Tensor/IR/TensorDialect.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/Transforms/InliningUtils.h"
 
 using namespace mlir;
 using namespace mlir::tensor;
 
+#include "mlir/Dialect/Tensor/IR/TensorOpsDialect.cpp.inc"
+
 //===----------------------------------------------------------------------===//
 // TensorDialect Dialect Interfaces
 //===----------------------------------------------------------------------===//
 
 namespace {
 struct TensorInlinerInterface : public DialectInlinerInterface {
   using DialectInlinerInterface::DialectInlinerInterface;
   bool isLegalToInline(Region *dest, Region *src, bool wouldBeCloned,

mlir/lib/Dialect/Tosa/IR/TosaOps.cpp

 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/Transforms/FoldUtils.h"
 #include "mlir/Transforms/InliningUtils.h"
 #include "mlir/Transforms/RegionUtils.h"
 
 using namespace mlir;
 using namespace mlir::tosa;
 
+#include "mlir/Dialect/Tosa/IR/TosaOpsDialect.cpp.inc"
+
 //===----------------------------------------------------------------------===//
 // Tosa dialect structs and interface includes.
 //===----------------------------------------------------------------------===//
 #include "mlir/Dialect/Tosa/IR/TosaInterfaces.cpp.inc"
 #include "mlir/Dialect/Tosa/IR/TosaStructs.cpp.inc"
 
 namespace {
 //===----------------------------------------------------------------------===//

mlir/lib/Dialect/Vector/VectorOps.cpp

 #include "mlir/IR/PatternMatch.h"
 #include "mlir/IR/TypeUtilities.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Support/MathExtras.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/bit.h"
 #include <numeric>
 
+#include "mlir/Dialect/Vector/VectorOpsDialect.cpp.inc"
 // Pull in all enum type and utility function definitions.
 #include "mlir/Dialect/Vector/VectorOpsEnums.cpp.inc"
 
 using namespace mlir;
 using namespace mlir::vector;
 
 /// Helper enum to classify mask value.
 enum class MaskFormat {

mlir/lib/Dialect/X86Vector/IR/X86VectorDialect.cpp

 #include "mlir/Dialect/X86Vector/X86VectorDialect.h"
 #include "mlir/Dialect/LLVMIR/LLVMTypes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/TypeUtilities.h"
 
 using namespace mlir;
 
+#include "mlir/Dialect/X86Vector/X86VectorDialect.cpp.inc"
+
 void x86vector::X86VectorDialect::initialize() {
   addOperations<
 #define GET_OP_LIST
 #include "mlir/Dialect/X86Vector/X86Vector.cpp.inc"
       >();
 }
 
 static LogicalResult verify(x86vector::MaskCompressOp op) {

mlir/lib/IR/BuiltinDialect.cpp

 #include "llvm/ADT/MapVector.h"
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // Builtin Dialect
 //===----------------------------------------------------------------------===//
 
+#include "mlir/IR/BuiltinDialect.cpp.inc"
+
 namespace {
 struct BuiltinOpAsmDialectInterface : public OpAsmDialectInterface {
   using OpAsmDialectInterface::OpAsmDialectInterface;
 
   LogicalResult getAlias(Attribute attr, raw_ostream &os) const override {
     if (attr.isa<AffineMapAttr>()) {
       os << "map";
       return success();

mlir/lib/TableGen/Dialect.cpp

 bool Dialect::hasCanonicalizer() const {
   return def->getValueAsBit("hasCanonicalizer");
 }
 
 bool Dialect::hasConstantMaterializer() const {
   return def->getValueAsBit("hasConstantMaterializer");
 }
 
+bool Dialect::hasNonDefaultDestructor() const {
+  return def->getValueAsBit("hasNonDefaultDestructor");
+}
+
 bool Dialect::hasOperationAttrVerify() const {
   return def->getValueAsBit("hasOperationAttrVerify");
 }
 
 bool Dialect::hasRegionArgAttrVerify() const {
   return def->getValueAsBit("hasRegionArgAttrVerify");
 }
 

mlir/test/lib/Dialect/Test/CMakeLists.txt

 mlir_tablegen(TestTypeDefs.cpp.inc -gen-typedef-defs -typedefs-dialect=test)
 add_public_tablegen_target(MLIRTestTypeDefIncGen)
 
 
 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 -dialect=test)
+mlir_tablegen(TestOpsDialect.cpp.inc -gen-dialect-defs -dialect=test)
 mlir_tablegen(TestOpEnums.h.inc -gen-enum-decls)
 mlir_tablegen(TestOpEnums.cpp.inc -gen-enum-defs)
 mlir_tablegen(TestOpStructs.h.inc -gen-struct-attr-decls)
 mlir_tablegen(TestOpStructs.cpp.inc -gen-struct-attr-defs)
 mlir_tablegen(TestPatterns.inc -gen-rewriters)
 add_public_tablegen_target(MLIRTestOpsIncGen)
 
 # Exclude tests from libMLIR.so

mlir/test/lib/Dialect/Test/TestDialect.cpp

 #include "mlir/Reducer/ReductionPatternInterface.h"
 #include "mlir/Transforms/FoldUtils.h"
 #include "mlir/Transforms/InliningUtils.h"
 #include "llvm/ADT/StringSwitch.h"
 
 using namespace mlir;
 using namespace mlir::test;
 
+#include "TestOpsDialect.cpp.inc"
+
 void mlir::test::registerTestDialect(DialectRegistry &registry) {
   registry.insert<TestDialect>();
 }
 
 //===----------------------------------------------------------------------===//
 // TestDialect Interfaces
 //===----------------------------------------------------------------------===//
 

mlir/test/lib/Dialect/Test/TestOps.td

def Test_Dialect : Dialect {
   let name = "test";
   let cppNamespace = "::mlir::test";
   let hasCanonicalizer = 1;
   let hasConstantMaterializer = 1;
   let hasOperationAttrVerify = 1;
   let hasRegionArgAttrVerify = 1;
   let hasRegionResultAttrVerify = 1;
   let hasOperationInterfaceFallback = 1;
+  let hasNonDefaultDestructor = 1;
   let dependentDialects = ["::mlir::DLTIDialect"];
 
   let extraClassDeclaration = [{
     void registerAttributes();
     void registerTypes();
 
     Attribute parseAttribute(DialectAsmParser &parser,
                              Type type) const override;
     void printAttribute(Attribute attr,
                         DialectAsmPrinter &printer) const override;
 
     // Provides a custom printing/parsing for some operations.
     Optional<ParseOpHook>
       getParseOperationHook(StringRef opName) const override;
     LogicalResult printOperation(Operation *op,
                                  OpAsmPrinter &printer) const override;
-
-    ~TestDialect();
   private:
     // Storage for a custom fallback interface.
     void *fallbackEffectOpInterfaces;
 
   }];
 }
 
 class TEST_Op<string mnemonic, list<OpTrait> traits = []> :

mlir/tools/mlir-tblgen/DialectGen.cpp

 
 #include "mlir/TableGen/CodeGenHelpers.h"
 #include "mlir/TableGen/Format.h"
 #include "mlir/TableGen/GenInfo.h"
 #include "mlir/TableGen/Interfaces.h"
 #include "mlir/TableGen/OpClass.h"
 #include "mlir/TableGen/Operator.h"
 #include "mlir/TableGen/Trait.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 #include "llvm/TableGen/TableGenBackend.h"
 

 filterForDialect(ArrayRef<llvm::Record *> records, Dialect &dialect) {
   auto filterFn = [&](const llvm::Record *record) {
     return T(record).getDialect() == dialect;
   };
   return {DialectFilterIterator(records.begin(), records.end(), filterFn),
           DialectFilterIterator(records.end(), records.end(), filterFn)};
 }
 
+static Optional<Dialect>
+findSelectedDialect(ArrayRef<const llvm::Record *> dialectDefs) {
+  // Select the dialect to gen for.
+  if (dialectDefs.size() == 1 && selectedDialect.getNumOccurrences() == 0) {
+    return Dialect(dialectDefs.front());
+  }
+
+  if (selectedDialect.getNumOccurrences() == 0) {
+    llvm::errs() << "when more than 1 dialect is present, one must be selected "
+                    "via '-dialect'\n";
+    return llvm::None;
+  }
+
+  auto dialectIt = llvm::find_if(dialectDefs, [](const llvm::Record *def) {
+    return Dialect(def).getName() == selectedDialect;
+  });
+  if (dialectIt == dialectDefs.end()) {
+    llvm::errs() << "selected dialect with '-dialect' does not exist\n";
+    return llvm::None;
+  }
+  return Dialect(*dialectIt);
+}
+
 //===----------------------------------------------------------------------===//
 // GEN: Dialect declarations
 //===----------------------------------------------------------------------===//
 
 /// The code block for the start of a dialect class declaration.
 ///
 /// {0}: The name of the dialect class.
 /// {1}: The dialect namespace.
 /// {2}: initialization code that is emitted in the ctor body before calling
 /// initialize()
 static const char *const dialectDeclBeginStr = R"(
 class {0} : public ::mlir::Dialect {
   explicit {0}(::mlir::MLIRContext *context)
     : ::mlir::Dialect(getDialectNamespace(), context,
       ::mlir::TypeID::get<{0}>()) {{
     {2}
     initialize();
   }
+
   void initialize();
   friend class ::mlir::MLIRContext;
 public:
+  ~{0}() override;
   static constexpr ::llvm::StringLiteral getDialectNamespace() {
     return ::llvm::StringLiteral("{1}");
   }
 )";
 
 /// Registration for a single dependent dialect: to be inserted in the ctor
 /// above for each dependent dialect.
 const char *const dialectRegistrationTemplate = R"(
static void emitDialectDecl(Dialect &dialect,
   // End the dialect decl.
   os << "};\n";
 }
 
 static bool emitDialectDecls(const llvm::RecordKeeper &recordKeeper,
                              raw_ostream &os) {
   emitSourceFileHeader("Dialect Declarations", os);
 
-  auto defs = recordKeeper.getAllDerivedDefinitions("Dialect");
-  if (defs.empty())
+  auto dialectDefs = recordKeeper.getAllDerivedDefinitions("Dialect");
+  if (dialectDefs.empty())
     return false;
 
-  // Select the dialect to gen for.
-  const llvm::Record *dialectDef = nullptr;
-  if (defs.size() == 1 && selectedDialect.getNumOccurrences() == 0) {
-    dialectDef = defs.front();
-  } else if (selectedDialect.getNumOccurrences() == 0) {
-    llvm::errs() << "when more than 1 dialect is present, one must be selected "
-                    "via '-dialect'";
-    return true;
-  } else {
-    auto dialectIt = llvm::find_if(defs, [](const llvm::Record *def) {
-      return Dialect(def).getName() == selectedDialect;
-    });
-    if (dialectIt == defs.end()) {
-      llvm::errs() << "selected dialect with '-dialect' does not exist";
-      return true;
-    }
-    dialectDef = *dialectIt;
-  }
+  Optional<Dialect> dialect = findSelectedDialect(dialectDefs);
+  if (!dialect)
+  auto attrDefs = recordKeeper.getAllDerivedDefinitions("DialectAttr");
+  auto typeDefs = recordKeeper.getAllDerivedDefinitions("DialectType");
+  emitDialectDecl(*dialect, filterForDialect<Attribute>(attrDefs, *dialect),
+                  filterForDialect<Type>(typeDefs, *dialect), os);
+  return false;
+
+//===----------------------------------------------------------------------===//
+// GEN: Dialect definitions
+//===----------------------------------------------------------------------===//
+
+/// The code block to generate a default desturctor definition.
+///
+/// {0}: The name of the dialect class.
+static const char *const dialectDestructorStr = R"(
+{0}::~{0}() = default;
+
+)";
+
+static void emitDialectDef(Dialect &dialect, raw_ostream &os) {
+  // Emit all nested namespaces.
+  NamespaceEmitter nsEmitter(os, dialect);
+
+  if (!dialect.hasNonDefaultDestructor())
+    os << llvm::formatv(dialectDestructorStr, dialect.getCppClassName());
 
-  auto attrDefs = recordKeeper.getAllDerivedDefinitions("DialectAttr");
-  auto typeDefs = recordKeeper.getAllDerivedDefinitions("DialectType");
-  Dialect dialect(dialectDef);
-  emitDialectDecl(dialect, filterForDialect<Attribute>(attrDefs, dialect),
-                  filterForDialect<Type>(typeDefs, dialect), os);
+static bool emitDialectDefs(const llvm::RecordKeeper &recordKeeper,
+                            raw_ostream &os) {
+  emitSourceFileHeader("Dialect Definitions", os);
+
+  auto dialectDefs = recordKeeper.getAllDerivedDefinitions("Dialect");
+  if (dialectDefs.empty())
+    return false;
+
+  Optional<Dialect> dialect = findSelectedDialect(dialectDefs);
+  if (!dialect)
+    return true;
+  emitDialectDef(*dialect, os);
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // GEN: Dialect registration hooks
 //===----------------------------------------------------------------------===//
 
 static mlir::GenRegistration
     genDialectDecls("gen-dialect-decls", "Generate dialect declarations",
                     [](const llvm::RecordKeeper &records, raw_ostream &os) {
                       return emitDialectDecls(records, os);
                     });
+
+static mlir::GenRegistration
+    genDialectDefs("gen-dialect-defs", "Generate dialect definitions",
+                   [](const llvm::RecordKeeper &records, raw_ostream &os) {
+                     return emitDialectDefs(records, os);
+                   });

utils/bazel/llvm-project-overlay/mlir/BUILD.bazel

 gentbl_cc_library(
     name = "BuiltinDialectIncGen",
     strip_include_prefix = "include",
     tbl_outs = [
         (
             ["-gen-dialect-decls"],
             "include/mlir/IR/BuiltinDialect.h.inc",
         ),
+        (
+            ["-gen-dialect-defs"],
+            "include/mlir/IR/BuiltinDialect.cpp.inc",
+        ),
     ],
     tblgen = ":mlir-tblgen",
     td_file = "include/mlir/IR/BuiltinDialect.td",
     deps = [":BuiltinDialectTdFiles"],
 )
 
 gentbl_cc_library(
     name = "BuiltinAttributesIncGen",
tbl_outs = [
         (
             ["-gen-op-defs"],
             "include/mlir/Dialect/Affine/IR/AffineOps.cpp.inc",
         ),
         (
             ["-gen-dialect-decls"],
             "include/mlir/Dialect/Affine/IR/AffineOpsDialect.h.inc",
         ),
+        (
+            ["-gen-dialect-defs"],
+            "include/mlir/Dialect/Affine/IR/AffineOpsDialect.cpp.inc",
+        ),
     ],
     tblgen = ":mlir-tblgen",
     td_file = "include/mlir/Dialect/Affine/IR/AffineOps.td",
     deps = [":AffineOpsTdFiles"],
 )
 
 gentbl_cc_library(
     name = "AffineMemoryOpInterfacesIncGen",
gentbl_cc_library(
     name = "EmitCOpsIncGen",
     strip_include_prefix = "include",
     tbl_outs = [
         (
             ["-gen-dialect-decls"],
             "include/mlir/Dialect/EmitC/IR/EmitCDialect.h.inc",
         ),
         (
+            ["-gen-dialect-defs"],
+            "include/mlir/Dialect/EmitC/IR/EmitCDialect.cpp.inc",
+        ),
+        (
             ["-gen-op-decls"],
             "include/mlir/Dialect/EmitC/IR/EmitC.h.inc",
         ),
         (
             ["-gen-op-defs"],
             "include/mlir/Dialect/EmitC/IR/EmitC.cpp.inc",
         ),
         (
tbl_outs = [
             ["-gen-op-defs"],
             "include/mlir/Dialect/Async/IR/AsyncOps.cpp.inc",
         ),
         (
             ["-gen-dialect-decls"],
             "include/mlir/Dialect/Async/IR/AsyncOpsDialect.h.inc",
         ),
         (
+            ["-gen-dialect-defs"],
+            "include/mlir/Dialect/Async/IR/AsyncOpsDialect.cpp.inc",
+        ),
+        (
             ["-gen-typedef-decls"],
             "include/mlir/Dialect/Async/IR/AsyncOpsTypes.h.inc",
         ),
         (
             ["-gen-typedef-defs"],
             "include/mlir/Dialect/Async/IR/AsyncOpsTypes.cpp.inc",
         ),
     ],
tbl_outs = [
         (
             [
                 "-gen-dialect-decls",
                 "-dialect=arm_neon",
             ],
             "include/mlir/Dialect/ArmNeon/ArmNeonDialect.h.inc",
         ),
         (
+            [
+                "-gen-dialect-defs",
+                "-dialect=arm_neon",
+            ],
+            "include/mlir/Dialect/ArmNeon/ArmNeonDialect.cpp.inc",
+        ),
+        (
             ["-gen-op-decls"],
             "include/mlir/Dialect/ArmNeon/ArmNeon.h.inc",
         ),
         (
             ["-gen-op-defs"],
             "include/mlir/Dialect/ArmNeon/ArmNeon.cpp.inc",
         ),
         (
tbl_outs = [
         ),
         (
             [
                 "-gen-dialect-decls",
                 "-dialect=arm_sve",
             ],
             "include/mlir/Dialect/ArmSVE/ArmSVEDialect.h.inc",
         ),
+        (
+            [
+                "-gen-dialect-defs",
+                "-dialect=arm_sve",
+            ],
+            "include/mlir/Dialect/ArmSVE/ArmSVEDialect.cpp.inc",
+        ),
     ],
     tblgen = ":mlir-tblgen",
     td_file = "include/mlir/Dialect/ArmSVE/ArmSVE.td",
     deps = [":ArmSVETdFiles"],
 )
 
 cc_library(
     name = "ArmSVE",
tbl_outs = [
         (
             [
                 "-gen-dialect-decls",
                 "-dialect=amx",
             ],
             "include/mlir/Dialect/AMX/AMXDialect.h.inc",
         ),
         (
+            [
+                "-gen-dialect-defs",
+                "-dialect=amx",
+            ],
+            "include/mlir/Dialect/AMX/AMXDialect.cpp.inc",
+        ),
+        (
             ["-gen-op-decls"],
             "include/mlir/Dialect/AMX/AMX.h.inc",
         ),
         (
             ["-gen-op-defs"],
             "include/mlir/Dialect/AMX/AMX.cpp.inc",
         ),
         (
tbl_outs = [
         (
             [
                 "-gen-dialect-decls",
                 "-dialect=x86vector",
             ],
             "include/mlir/Dialect/X86Vector/X86VectorDialect.h.inc",
         ),
         (
+            [
+                "-gen-dialect-defs",
+                "-dialect=x86vector",
+            ],
+            "include/mlir/Dialect/X86Vector/X86VectorDialect.cpp.inc",
+        ),
+        (
             ["-gen-op-decls"],
             "include/mlir/Dialect/X86Vector/X86Vector.h.inc",
         ),
         (
             ["-gen-op-defs"],
             "include/mlir/Dialect/X86Vector/X86Vector.cpp.inc",
         ),
         (
tbl_outs = [
         (
             ["-gen-op-defs"],
             "include/mlir/Dialect/SCF/SCFOps.cpp.inc",
         ),
         (
             ["-gen-dialect-decls"],
             "include/mlir/Dialect/SCF/SCFOpsDialect.h.inc",
         ),
+        (
+            ["-gen-dialect-defs"],
+            "include/mlir/Dialect/SCF/SCFOpsDialect.cpp.inc",
+        ),
     ],
     tblgen = ":mlir-tblgen",
     td_file = "include/mlir/Dialect/SCF/SCFOps.td",
     deps = [":SCFTdFiles"],
 )
 
 gentbl_cc_library(
     name = "SCFPassIncGen",
tbl_outs = [
         (
             [
                 "-gen-dialect-decls",
                 "-dialect=sparse_tensor",
             ],
             "include/mlir/Dialect/SparseTensor/IR/SparseTensorOpsDialect.h.inc",
         ),
         (
+            [
+                "-gen-dialect-defs",
+                "-dialect=sparse_tensor",
+            ],
+            "include/mlir/Dialect/SparseTensor/IR/SparseTensorOpsDialect.cpp.inc",
+        ),
+        (
             ["-gen-op-decls"],
             "include/mlir/Dialect/SparseTensor/IR/SparseTensorOps.h.inc",
         ),
         (
             ["-gen-op-defs"],
             "include/mlir/Dialect/SparseTensor/IR/SparseTensorOps.cpp.inc",
         ),
         (
tbl_outs = [
             ["-gen-op-defs"],
             "include/mlir/Dialect/StandardOps/IR/Ops.cpp.inc",
         ),
         (
             ["-gen-dialect-decls"],
             "include/mlir/Dialect/StandardOps/IR/OpsDialect.h.inc",
         ),
         (
+            ["-gen-dialect-defs"],
+            "include/mlir/Dialect/StandardOps/IR/OpsDialect.cpp.inc",
+        ),
+        (
             ["-gen-enum-decls"],
             "include/mlir/Dialect/StandardOps/IR/OpsEnums.h.inc",
         ),
         (
             ["-gen-enum-defs"],
             "include/mlir/Dialect/StandardOps/IR/OpsEnums.cpp.inc",
         ),
     ],
tbl_outs = [
         (
             ["-gen-op-defs"],
             "include/mlir/Dialect/Shape/IR/ShapeOps.cpp.inc",
         ),
         (
             ["-gen-dialect-decls"],
             "include/mlir/Dialect/Shape/IR/ShapeOpsDialect.h.inc",
         ),
+        (
+            ["-gen-dialect-defs"],
+            "include/mlir/Dialect/Shape/IR/ShapeOpsDialect.cpp.inc",
+        ),
     ],
     tblgen = ":mlir-tblgen",
     td_file = "include/mlir/Dialect/Shape/IR/ShapeOps.td",
     deps = [":ShapeOpsTdFiles"],
 )
 
 gentbl_cc_library(
     name = "MLIRShapeCanonicalizationIncGen",
tbl_outs = [
         (
             [
                 "-gen-dialect-decls",
                 "-dialect=gpu",
             ],
             "include/mlir/Dialect/GPU/GPUOpsDialect.h.inc",
         ),
         (
+            [
+                "-gen-dialect-defs",
+                "-dialect=gpu",
+            ],
+            "include/mlir/Dialect/GPU/GPUOpsDialect.cpp.inc",
+        ),
+        (
             ["-gen-op-interface-decls"],
             "include/mlir/Dialect/GPU/GPUOpInterfaces.h.inc",
         ),
         (
             ["-gen-op-interface-defs"],
             "include/mlir/Dialect/GPU/GPUOpInterfaces.cpp.inc",
         ),
     ],
tbl_outs = [
             ["-gen-op-defs"],
             "include/mlir/Dialect/LLVMIR/LLVMOps.cpp.inc",
         ),
         (
             ["-gen-dialect-decls"],
             "include/mlir/Dialect/LLVMIR/LLVMOpsDialect.h.inc",
         ),
         (
+            ["-gen-dialect-defs"],
+            "include/mlir/Dialect/LLVMIR/LLVMOpsDialect.cpp.inc",
+        ),
+        (
             ["-gen-enum-decls"],
             "include/mlir/Dialect/LLVMIR/LLVMOpsEnums.h.inc",
         ),
         (
             ["-gen-enum-defs"],
             "include/mlir/Dialect/LLVMIR/LLVMOpsEnums.cpp.inc",
         ),
     ],
tbl_outs = [
         ),
         (
             [
                 "-gen-dialect-decls",
                 "-dialect=nvvm",
             ],
             "include/mlir/Dialect/LLVMIR/NVVMOpsDialect.h.inc",
         ),
+        (
+            [
+                "-gen-dialect-defs",
+                "-dialect=nvvm",
+            ],
+            "include/mlir/Dialect/LLVMIR/NVVMOpsDialect.cpp.inc",
+        ),
     ],
     tblgen = ":mlir-tblgen",
     td_file = "include/mlir/Dialect/LLVMIR/NVVMOps.td",
     deps = [":NVVMOpsTdFiles"],
 )
 
 gentbl_cc_library(
     name = "NVVMConversionIncGen",
tbl_outs = [
         ),
         (
             [
                 "-gen-dialect-decls",
                 "-dialect=rocdl",
             ],
             "include/mlir/Dialect/LLVMIR/ROCDLOpsDialect.h.inc",
         ),
+        (
+            [
+                "-gen-dialect-defs",
+                "-dialect=rocdl",
+            ],
+            "include/mlir/Dialect/LLVMIR/ROCDLOpsDialect.cpp.inc",
+        ),
     ],
     tblgen = ":mlir-tblgen",
     td_file = "include/mlir/Dialect/LLVMIR/ROCDLOps.td",
     deps = [":ROCDLOpsTdFiles"],
 )
 
 gentbl_cc_library(
     name = "ROCDLConversionIncGen",
tbl_outs = [
         (
             ["-gen-op-defs"],
             "include/mlir/Dialect/PDL/IR/PDLOps.cpp.inc",
         ),
         (
             ["-gen-dialect-decls"],
             "include/mlir/Dialect/PDL/IR/PDLOpsDialect.h.inc",
         ),
+        (
+            ["-gen-dialect-defs"],
+            "include/mlir/Dialect/PDL/IR/PDLOpsDialect.cpp.inc",
+        ),
     ],
     tblgen = ":mlir-tblgen",
     td_file = "include/mlir/Dialect/PDL/IR/PDLOps.td",
     deps = [":PDLDialectTdFiles"],
 )
 
 gentbl_cc_library(
     name = "PDLTypesIncGen",
tbl_outs = [
         ),
         (
             [
                 "-gen-dialect-decls",
                 "-dialect=pdl_interp",
             ],
             "include/mlir/Dialect/PDLInterp/IR/PDLInterpOpsDialect.h.inc",
         ),
+        (
+            [
+                "-gen-dialect-defs",
+                "-dialect=pdl_interp",
+            ],
+            "include/mlir/Dialect/PDLInterp/IR/PDLInterpOpsDialect.cpp.inc",
+        ),
     ],
     tblgen = ":mlir-tblgen",
     td_file = "include/mlir/Dialect/PDLInterp/IR/PDLInterpOps.td",
     deps = [":PDLInterpOpsTdFiles"],
 )
 
 td_library(
     name = "SPIRVOpsTdFiles",
tbl_outs = [
             ["-gen-op-defs"],
             "include/mlir/Dialect/SPIRV/IR/SPIRVOps.cpp.inc",
         ),
         (
             ["-gen-dialect-decls"],
             "include/mlir/Dialect/SPIRV/IR/SPIRVOpsDialect.h.inc",
         ),
         (
+            ["-gen-dialect-defs"],
+            "include/mlir/Dialect/SPIRV/IR/SPIRVOpsDialect.cpp.inc",
+        ),
+        (
             ["-gen-op-doc"],
             "g3doc/Dialects/SPIRV/SPIRVOps.md",
         ),
         (
             ["-gen-enum-decls"],
             "include/mlir/Dialect/SPIRV/IR/SPIRVEnums.h.inc",
         ),
         (
tbl_outs = [
         (
             [
                 "-gen-dialect-decls",
                 "-dialect=tensor",
             ],
             "include/mlir/Dialect/Tensor/IR/TensorOpsDialect.h.inc",
         ),
         (
+            [
+                "-gen-dialect-defs",
+                "-dialect=tensor",
+            ],
+            "include/mlir/Dialect/Tensor/IR/TensorOpsDialect.cpp.inc",
+        ),
+        (
             ["-gen-op-decls"],
             "include/mlir/Dialect/Tensor/IR/TensorOps.h.inc",
         ),
         (
             ["-gen-op-defs"],
             "include/mlir/Dialect/Tensor/IR/TensorOps.cpp.inc",
         ),
     ],
tbl_outs = [
         (
             [
                 "-gen-dialect-decls",
                 "-dialect=acc",
             ],
             "include/mlir/Dialect/OpenACC/OpenACCOpsDialect.h.inc",
         ),
         (
+            [
+                "-gen-dialect-defs",
+                "-dialect=acc",
+            ],
+            "include/mlir/Dialect/OpenACC/OpenACCOpsDialect.cpp.inc",
+        ),
+        (
             ["-gen-op-decls"],
             "include/mlir/Dialect/OpenACC/OpenACCOps.h.inc",
         ),
         (
             ["-gen-op-defs"],
             "include/mlir/Dialect/OpenACC/OpenACCOps.cpp.inc",
         ),
         (
tbl_outs = [
         (
             [
                 "-gen-dialect-decls",
                 "-dialect=omp",
             ],
             "include/mlir/Dialect/OpenMP/OpenMPOpsDialect.h.inc",
         ),
         (
+            [
+                "-gen-dialect-defs",
+                "-dialect=omp",
+            ],
+            "include/mlir/Dialect/OpenMP/OpenMPOpsDialect.cpp.inc",
+        ),
+        (
             ["-gen-op-doc"],
             "g3doc/Dialects/OpenMP/OpenMPOps.md",
         ),
     ],
     tblgen = ":mlir-tblgen",
     td_file = "include/mlir/Dialect/OpenMP/OpenMPOps.td",
     deps = [":OpenMPOpsTdFiles"],
 )
tbl_outs = [
             ["-gen-op-defs"],
             "include/mlir/Dialect/Quant/QuantOps.cpp.inc",
         ),
         (
             ["-gen-dialect-decls"],
             "include/mlir/Dialect/Quant/QuantOpsDialect.h.inc",
         ),
         (
+            ["-gen-dialect-defs"],
+            "include/mlir/Dialect/Quant/QuantOpsDialect.cpp.inc",
+        ),
+        (
             ["-gen-op-doc"],
             "g3doc/Dialects/QuantOps/QuantOps.md",
         ),
     ],
     tblgen = ":mlir-tblgen",
     td_file = "include/mlir/Dialect/Quant/QuantOps.td",
     deps = [":QuantizationOpsTdFiles"],
 )
tbl_outs = [
         ),
         (
             [
                 "-gen-dialect-decls",
                 "-dialect=linalg",
             ],
             "include/mlir/Dialect/Linalg/IR/LinalgOpsDialect.h.inc",
         ),
+        (
+            [
+                "-gen-dialect-defs",
+                "-dialect=linalg",
+            ],
+            "include/mlir/Dialect/Linalg/IR/LinalgOpsDialect.cpp.inc",
+        ),
     ],
     tblgen = ":mlir-tblgen",
     td_file = "include/mlir/Dialect/Linalg/IR/LinalgOps.td",
     deps = [":LinalgOpsTdFiles"],
 )
 
 genlinalg(
     name = "LinalgNamedStructuredOpsTcIncGen",
tbl_outs = [
         (
             [
                 "-gen-dialect-decls",
                 "-dialect=vector",
             ],
             "include/mlir/Dialect/Vector/VectorOpsDialect.h.inc",
         ),
         (
+            [
+                "-gen-dialect-defs",
+                "-dialect=vector",
+            ],
+            "include/mlir/Dialect/Vector/VectorOpsDialect.cpp.inc",
+        ),
+        (
             ["-gen-enum-decls"],
             "include/mlir/Dialect/Vector/VectorOpsEnums.h.inc",
         ),
         (
             ["-gen-enum-defs"],
             "include/mlir/Dialect/Vector/VectorOpsEnums.cpp.inc",
         ),
         (
tbl_outs = [
             ["-gen-struct-attr-defs"],
             "include/mlir/Dialect/Tosa/IR/TosaStructs.cpp.inc",
         ),
         (
             ["-gen-dialect-decls"],
             "include/mlir/Dialect/Tosa/IR/TosaOpsDialect.h.inc",
         ),
         (
+            ["-gen-dialect-defs"],
+            "include/mlir/Dialect/Tosa/IR/TosaOpsDialect.cpp.inc",
+        ),
+        (
             ["-gen-op-doc"],
             "g3doc/Dialects/Tosa/TosaOps.md",
         ),
     ],
     tblgen = ":mlir-tblgen",
     td_file = "include/mlir/Dialect/Tosa/IR/TosaOps.td",
     deps = [":TosaDialectTdFiles"],
 )
gentbl_cc_library(
     tbl_outs = [
         (
             [
                 "-gen-dialect-decls",
                 "-dialect=complex",
             ],
             "include/mlir/Dialect/Complex/IR/ComplexOpsDialect.h.inc",
         ),
+        (
+            [
+                "-gen-dialect-defs",
+                "-dialect=complex",
+            ],
+            "include/mlir/Dialect/Complex/IR/ComplexOpsDialect.cpp.inc",
+        ),
     ],
     tblgen = ":mlir-tblgen",
     td_file = "include/mlir/Dialect/Complex/IR/ComplexBase.td",
     deps = [":ComplexOpsTdFiles"],
 )
 
 gentbl_cc_library(
     name = "ComplexOpsIncGen",
gentbl_cc_library(
     tbl_outs = [
         (
             [
                 "-gen-dialect-decls",
                 "-dialect=math",
             ],
             "include/mlir/Dialect/Math/IR/MathOpsDialect.h.inc",
         ),
+        (
+            [
+                "-gen-dialect-defs",
+                "-dialect=math",
+            ],
+            "include/mlir/Dialect/Math/IR/MathOpsDialect.cpp.inc",
+        ),
     ],
     tblgen = ":mlir-tblgen",
     td_file = "include/mlir/Dialect/Math/IR/MathBase.td",
     deps = [":MathOpsTdFiles"],
 )
 
 gentbl_cc_library(
     name = "MathOpsIncGen",
gentbl_cc_library(
     tbl_outs = [
         (
             [
                 "-gen-dialect-decls",
                 "-dialect=memref",
             ],
             "include/mlir/Dialect/MemRef/IR/MemRefOpsDialect.h.inc",
         ),
+        (
+            [
+                "-gen-dialect-defs",
+                "-dialect=memref",
+            ],
+            "include/mlir/Dialect/MemRef/IR/MemRefOpsDialect.cpp.inc",
+        ),
     ],
     tblgen = ":mlir-tblgen",
     td_file = "include/mlir/Dialect/MemRef/IR/MemRefBase.td",
     deps = [":MemRefOpsTdFiles"],
 )
 
 gentbl_cc_library(
     name = "MemRefOpsIncGen",
gentbl_cc_library(
     tbl_outs = [
         (
             [
                 "-gen-dialect-decls",
                 "-dialect=dlti",
             ],
             "include/mlir/Dialect/DLTI/DLTIDialect.h.inc",
         ),
+        (
+            [
+                "-gen-dialect-defs",
+                "-dialect=dlti",
+            ],
+            "include/mlir/Dialect/DLTI/DLTIDialect.cpp.inc",
+        ),
     ],
     tblgen = ":mlir-tblgen",
     td_file = "include/mlir/Dialect/DLTI/DLTIBase.td",
     deps = [":OpBaseTdFiles"],
 )
 
 cc_library(
     name = "DLTIDialect",

utils/bazel/llvm-project-overlay/mlir/test/BUILD.bazel

tbl_outs = [
         (
             [
                 "-gen-dialect-decls",
                 "-dialect=test",
             ],
             "lib/Dialect/Test/TestOpsDialect.h.inc",
         ),
         (
+            [
+                "-gen-dialect-defs",
+                "-dialect=test",
+            ],
+            "lib/Dialect/Test/TestOpsDialect.cpp.inc",
+        ),
+        (
             ["-gen-enum-decls"],
             "lib/Dialect/Test/TestOpEnums.h.inc",
         ),
         (
             ["-gen-enum-defs"],
             "lib/Dialect/Test/TestOpEnums.cpp.inc",
         ),
         (