[mlir][ods] Simplify useDefaultType/AttributePrinterParser

[Mogball]

Summary

The current behaviour of useDefaultTypePrinterParser and useDefaultAttributePrinterParser is that they are set by default, but the dialect generator only generates the declarations for the parsing and printing hooks if it sees dialect types and attributes. Same goes for the definitions generated by the AttrOrTypeDef generator.

This can lead to confusing and undesirable behaviour if the dialect generator doesn't see the definitions of the attributes and types, for example, if they are sensibly separated into different files: Dialect.td, Ops.td, Attributes.td, and Types.td.

Now, these bits are unset by default. Setting them will always result in the dialect generator emitting the declarations for the parsing hooks. And if the AttrOrTypeDef generator sees it set, it will generate the default implementations.

[rriddle]

mlir/tools/mlir-tblgen/DialectGen.cpp

184–185

Do we need dialectAttrs or dialectTypes anymore?

[Mogball]

remove unused args/variables

[stellaraccident]

Thanks!

[mehdi_amini]

I am not totally sure I quite grasp the problem you were solving, but I find the current solution unsatisfactory in that we are making the default much less friendly to use. Can we revisit this?

Can you provide an example of the problem?

mlir/examples/toy/Ch7/include/toy/Ops.td

 def Toy_Dialect : Dialect {
   let name = "toy";
   let cppNamespace = "::mlir::toy";
   let emitAccessorPrefix = kEmitAccessorPrefix_Prefixed;
 
   // We set this bit to generate a declaration of the `materializeConstant`
   // method so that we can materialize constants for our toy operations.
   let hasConstantMaterializer = 1;
+
+  // We set this bit to generate the declarations for the dialect's type parsing
+  // and printing hooks.
+  let useDefaultTypePrinterParser = 1;
 }
 
 // Base class for toy dialect operations. This operation inherits from the base
 // `Op` class in OpBase.td, and provides:
 //   * The parent dialect of the operation.
 //   * The mnemonic for the operation, or the name without the dialect prefix.
 //   * A list of traits for the operation.
 class Toy_Op<string mnemonic, list<Trait> traits = []> :

mlir/include/mlir/Dialect/Async/IR/AsyncDialect.td

 include "mlir/IR/OpBase.td"
 
 //===----------------------------------------------------------------------===//
 // Async dialect definitions
 //===----------------------------------------------------------------------===//
 
 def AsyncDialect : Dialect {
   let name = "async";
+  let cppNamespace = "::mlir::async";
 
   let summary = "Types and operations for async dialect";
   let description = [{
     This dialect contains operations for modeling asynchronous execution.
   }];
 
-  let cppNamespace = "::mlir::async";
+  let useDefaultTypePrinterParser = 1;
 
   let extraClassDeclaration = [{
-    // The name of a unit attribute on funcs that are allowed to have a blocking
-    // async.runtime.await ops. Only useful in combination with
-    // 'eliminate-blocking-await-ops' option, which in absence of this attribute
-    // might convert a func to a coroutine.
-    static constexpr StringRef kAllowedToBlockAttrName = "async.allowed_to_block";
+    /// The name of a unit attribute on funcs that are allowed to have a
+    /// blocking async.runtime.await ops. Only useful in combination with
+    /// 'eliminate-blocking-await-ops' option, which in absence of this
+    /// attribute might convert a func to a coroutine.
+    static constexpr StringRef kAllowedToBlockAttrName =
+        "async.allowed_to_block";
   }];
 
 }
 
 #endif // ASYNC_DIALECT_TD

mlir/include/mlir/Dialect/DLTI/DLTIBase.td

let extraClassDeclaration = [{
     kDataLayoutEndiannessKey = "dlti.endianness";
 
     constexpr const static ::llvm::StringLiteral
     kDataLayoutEndiannessBig = "big";
 
     constexpr const static ::llvm::StringLiteral
     kDataLayoutEndiannessLittle = "little";
   }];
+
+  let useDefaultAttributePrinterParser = 1;
 }
 
 def DLTI_DataLayoutEntryAttr : DialectAttr<
     DLTI_Dialect,
     CPred<"$_self.isa<::mlir::DataLayoutEntryAttr>()">,
     "Target data layout entry"> {
   let storageType = "::mlir::DataLayoutEntryAttr";
   let returnType = "::mlir::DataLayoutEntryAttr";

mlir/include/mlir/Dialect/EmitC/IR/EmitCBase.td

def EmitC_Dialect : Dialect {
 
   let summary = "Dialect to generate C/C++ from MLIR.";
   let description = [{
     [include "Dialects/emitc.md"]
   }];
 
   let hasConstantMaterializer = 1;
   let useDefaultTypePrinterParser = 1;
+  let useDefaultAttributePrinterParser = 1;
 }
 
 #endif // MLIR_DIALECT_EMITC_IR_EMITCBASE

mlir/include/mlir/Dialect/GPU/GPUBase.td

let extraClassDeclaration = [{
 
     /// Returns the numeric value used to identify the private memory address
     /// space.
     static unsigned getPrivateAddressSpace() { return 5; }
   }];
 
   let dependentDialects = ["arith::ArithmeticDialect"];
   let useDefaultAttributePrinterParser = 1;
+  let useDefaultTypePrinterParser = 1;
 }
 
 def GPU_AsyncToken : DialectType<
   GPU_Dialect, CPred<"$_self.isa<::mlir::gpu::AsyncTokenType>()">, "async token type">,
              BuildableType<"mlir::gpu::AsyncTokenType::get($_builder.getContext())">;
 
 // Predicat to check if type is gpu::MMAMatrixType.
 def IsMMAMatrixTypePred : CPred<"$_self.isa<::mlir::gpu::MMAMatrixType>()">;

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

 //===----------------------------------------------------------------------===//
 // LLVM Dialect.
 //===----------------------------------------------------------------------===//
 
 def LLVM_Dialect : Dialect {
   let name = "llvm";
   let cppNamespace = "::mlir::LLVM";
 
+  let useDefaultTypePrinterParser = 1;
+  let useDefaultAttributePrinterParser = 1;
   let hasRegionArgAttrVerify = 1;
   let hasRegionResultAttrVerify = 1;
   let hasOperationAttrVerify = 1;
+
   let extraClassDeclaration = [{
     /// Name of the data layout attributes.
     static StringRef getDataLayoutAttrName() { return "llvm.data_layout"; }
     static StringRef getAlignAttrName() { return "llvm.align"; }
     static StringRef getNoAliasAttrName() { return "llvm.noalias"; }
     static StringRef getNoAliasScopesAttrName() { return "noalias_scopes"; }
     static StringRef getAliasScopesAttrName() { return "alias_scopes"; }
     static StringRef getLoopAttrName() { return "llvm.loop"; }

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

def Linalg_Dialect : Dialect {
   let cppNamespace = "::mlir::linalg";
   let dependentDialects = [
     "arith::ArithmeticDialect",
     "AffineDialect",
     "math::MathDialect",
     "memref::MemRefDialect",
     "tensor::TensorDialect",
   ];
+  let useDefaultAttributePrinterParser = 1;
   let hasCanonicalizer = 1;
   let hasOperationAttrVerify = 1;
   let hasConstantMaterializer = 1;
   let extraClassDeclaration = [{
     /// Attribute name used to to memoize indexing maps for named ops.
     constexpr const static ::llvm::StringLiteral
         kMemoizedIndexingMapsAttrName = "linalg.memoized_indexing_maps";
 

mlir/include/mlir/Dialect/NVGPU/NVGPU.td

def NVGPU_Dialect : Dialect {
   let name = "nvgpu";
   let cppNamespace = "::mlir::nvgpu";
   let description = [{
     This `NVGPU` dialect provides a bridge between the target agnostic GPU and
     Vector dialects and the lower level LLVM IR based NVVM dialect. This allow
     representing PTX specific operations while using MLIR high level concepts
     like memref and 2-D vector.
   }];
-  let useDefaultAttributePrinterParser = 1;
+
+  let useDefaultTypePrinterParser = 1;
 }
 
 /// Device-side synchronization token.
 def NVGPU_DeviceAsyncToken : DialectType<
   NVGPU_Dialect, CPred<"$_self.isa<::mlir::nvgpu::DeviceAsyncTokenType>()">,
    "device async token type">,
    BuildableType<
      "mlir::nvgpu::DeviceAsyncTokenType::get($_builder.getContext())">;

mlir/include/mlir/Dialect/PDL/IR/PDLDialect.td

 
 include "mlir/IR/OpBase.td"
 
 //===----------------------------------------------------------------------===//
 // PDL Dialect
 //===----------------------------------------------------------------------===//
 
 def PDL_Dialect : Dialect {
-  string summary = "High level pattern definition dialect";
-  string description = [{
+  let summary = "High level pattern definition dialect";
+  let description = [{
     PDL presents a high level abstraction for the rewrite pattern infrastructure
     available in MLIR. This abstraction allows for representing patterns
     transforming MLIR, as MLIR. This allows for applying all of the benefits
     that the general MLIR infrastructure provides, to the infrastructure itself.
     This means that pattern matching can be more easily verified for
     correctness, targeted by frontends, and optimized.
 
     PDL abstracts over various different aspects of patterns and core MLIR data
let description = [{
     how the input operation is specified structurally, similarly to how it would
     look in memory. This is a simple example and pdl provides support for many
     other features such as applying external constraints or external generator
     methods. These features and more are detailed below.
   }];
 
   let name = "pdl";
   let cppNamespace = "::mlir::pdl";
+
+  let useDefaultTypePrinterParser = 1;
   let extraClassDeclaration = [{
     void registerTypes();
   }];
 }
 
 #endif // MLIR_DIALECT_PDL_IR_PDLDIALECT

mlir/include/mlir/Dialect/Quant/QuantOpsBase.td

 #ifndef DIALECT_QUANT_QUANT_OPS_BASE_
 #define DIALECT_QUANT_QUANT_OPS_BASE_
 
 include "mlir/IR/OpBase.td"
 
 def Quantization_Dialect : Dialect {
   let name = "quant";
   let cppNamespace = "::mlir::quant";
+
+  let useDefaultTypePrinterParser = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // Quantization type definitions
 //===----------------------------------------------------------------------===//
 
 class quant_TypedPrimitiveOrContainer<Type etype> :
     Type<Or<[etype.predicate,

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

let description = [{
     to utilize MLIR mechanisms if it results in better representation and thus
     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 = "::mlir::spirv";
+  let useDefaultTypePrinterParser = 1;
+  let useDefaultAttributePrinterParser = 1;
   let hasConstantMaterializer = 1;
   let hasOperationAttrVerify = 1;
   let hasRegionArgAttrVerify = 1;
   let hasRegionResultAttrVerify = 1;
 
   let extraClassDeclaration = [{
     void registerAttributes();
     void registerTypes();

mlir/include/mlir/Dialect/Shape/IR/ShapeBase.td

let description = [{
     failure. The dialect itself does not specify how errors should be combined
     (there are multiple different options, from always choosing first operand,
     concatting etc. on how to combine them).
   }];
 
   let cppNamespace = "::mlir::shape";
   let dependentDialects = ["arith::ArithmeticDialect", "tensor::TensorDialect"];
 
+  let useDefaultTypePrinterParser = 1;
   let hasConstantMaterializer = 1;
   let hasOperationAttrVerify = 1;
   let emitAccessorPrefix = kEmitAccessorPrefix_Prefixed;
 }
 
 def Shape_ShapeType : DialectType<ShapeDialect,
     CPred<"$_self.isa<::mlir::shape::ShapeType>()">, "shape">,
     BuildableType<"$_builder.getType<::mlir::shape::ShapeType>()"> {

mlir/include/mlir/Dialect/Shape/IR/ShapeOps.td

-//===- Shape.td - Shape operations definition --------------*- tablegen -*-===//
+//===- ShapeOps.td - Shape operations definition -----------*- tablegen -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This is the operation definition file for Shape dialect operations.

mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensorBase.td

let description = [{
     the ACM on Programming Languages, October 2017.
     * [Kjolstad19] Fredrik Berg Kjolstad, Peter Ahrens, Shoaib Ashraf Kamil,
     and Saman Amarasinghe. Tensor Algebra Compilation with Workspaces,
     Proceedings of the IEEE/ACM International Symposium on Code Generation
     and Optimization, 2019.
     * [Kjolstad20] Fredrik Berg Kjolstad. Sparse Tensor Algebra Compilation.
     PhD thesis, MIT, February, 2020.
   }];
+
+  let useDefaultAttributePrinterParser = 1;
 }
 
 #endif // SPARSETENSOR_BASE

mlir/include/mlir/Dialect/Vector/IR/VectorOps.td

 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 include "mlir/Interfaces/VectorInterfaces.td"
 include "mlir/Interfaces/ViewLikeInterface.td"
 
 def Vector_Dialect : Dialect {
   let name = "vector";
   let cppNamespace = "::mlir::vector";
+
+  let useDefaultAttributePrinterParser = 1;
   let hasConstantMaterializer = 1;
   let dependentDialects = ["arith::ArithmeticDialect"];
   let emitAccessorPrefix = kEmitAccessorPrefix_Prefixed;
 }
 
 // Base class for Vector dialect ops.
 class Vector_Op<string mnemonic, list<Trait> traits = []> :
     Op<Vector_Dialect, mnemonic, traits>;

mlir/include/mlir/IR/DialectBase.td

class Dialect {
   bit hasRegionArgAttrVerify = 0;
 
   // If this dialect overrides the hook for verifying region result attributes.
   bit hasRegionResultAttrVerify = 0;
 
   // If this dialect overrides the hook for op interface fallback.
   bit hasOperationInterfaceFallback = 0;
 
-  // If this dialect should use default generated attribute parser boilerplate:
-  // it'll dispatch the parsing to every individual attributes directly.
-  bit useDefaultAttributePrinterParser = 1;
+  // If this dialect should use default generated attribute parser boilerplate.
+  // When set, ODS will generate declarations for the attribute parsing and
+  // printing hooks in the dialect and default implementations that dispatch to
+  // each individual attribute directly.
+  bit useDefaultAttributePrinterParser = 0;
 
   // If this dialect should use default generated type parser boilerplate:
-  // it'll dispatch the parsing to every individual types directly.
-  bit useDefaultTypePrinterParser = 1;
+  // When set, ODS will generate declarations for the type parsing and printing
+  // hooks in the dialect and default implementations that dispatch to each
+  // individual type directly.
+  bit useDefaultTypePrinterParser = 0;
 
   // If this dialect overrides the hook for canonicalization patterns.
   bit hasCanonicalizer = 0;
 
   // Whether to emit raw/with no prefix or format changes, or emit with
   // accessor with prefix only and UpperCamel suffix or to emit accessors with
   // both.
   //

mlir/test/python/python_test_ops.td

 include "mlir/IR/AttrTypeBase.td"
 include "mlir/Bindings/Python/Attributes.td"
 include "mlir/IR/OpBase.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 
 def Python_Test_Dialect : Dialect {
   let name = "python_test";
   let cppNamespace = "python_test";
+
+  let useDefaultTypePrinterParser = 1;
+  let useDefaultAttributePrinterParser = 1;
 }
 
 class TestType<string name, string typeMnemonic>
     : TypeDef<Python_Test_Dialect, name> {
   let mnemonic = typeMnemonic;
 }
 
 class TestAttr<string name, string attrMnemonic>

mlir/tools/mlir-tblgen/AttrOrTypeDefGen.cpp

 /// This struct is the base generator used when processing tablegen interfaces.
 class DefGenerator {
 public:
   bool emitDecls(StringRef selectedDialect);
   bool emitDefs(StringRef selectedDialect);
 
 protected:
   DefGenerator(std::vector<llvm::Record *> &&defs, raw_ostream &os,
-               StringRef defType, StringRef valueType, bool isAttrGenerator,
-               bool needsDialectParserPrinter)
+               StringRef defType, StringRef valueType, bool isAttrGenerator)
       : defRecords(std::move(defs)), os(os), defType(defType),
-        valueType(valueType), isAttrGenerator(isAttrGenerator),
-        needsDialectParserPrinter(needsDialectParserPrinter) {}
+        valueType(valueType), isAttrGenerator(isAttrGenerator) {}
 
   /// Emit the list of def type names.
   void emitTypeDefList(ArrayRef<AttrOrTypeDef> defs);
   /// Emit the code to dispatch between different defs during parsing/printing.
   void emitParsePrintDispatch(ArrayRef<AttrOrTypeDef> defs);
 
   /// The set of def records to emit.
   std::vector<llvm::Record *> defRecords;
   /// The attribute or type class to emit.
   /// The stream to emit to.
   raw_ostream &os;
   /// The prefix of the tablegen def name, e.g. Attr or Type.
   StringRef defType;
   /// The C++ base value type of the def, e.g. Attribute or Type.
   StringRef valueType;
   /// Flag indicating if this generator is for Attributes. False if the
   /// generator is for types.
   bool isAttrGenerator;
-  /// Track if we need to emit the printAttribute/parseAttribute
-  /// implementations.
-  bool needsDialectParserPrinter;
 };
 
 /// A specialized generator for AttrDefs.
 struct AttrDefGenerator : public DefGenerator {
   AttrDefGenerator(const llvm::RecordKeeper &records, raw_ostream &os)
       : DefGenerator(records.getAllDerivedDefinitionsIfDefined("AttrDef"), os,
-                     "Attr", "Attribute",
-                     /*isAttrGenerator=*/true,
-                     /*needsDialectParserPrinter=*/
-                     !records.getAllDerivedDefinitions("DialectAttr").empty()) {
-  }
+                     "Attr", "Attribute", /*isAttrGenerator=*/true) {}
 };
 /// A specialized generator for TypeDefs.
 struct TypeDefGenerator : public DefGenerator {
   TypeDefGenerator(const llvm::RecordKeeper &records, raw_ostream &os)
       : DefGenerator(records.getAllDerivedDefinitionsIfDefined("TypeDef"), os,
-                     "Type", "Type",
-                     /*isAttrGenerator=*/false,
-                     /*needsDialectParserPrinter=*/
-                     !records.getAllDerivedDefinitions("DialectType").empty()) {
-  }
+                     "Type", "Type", /*isAttrGenerator=*/false) {}
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // GEN: Declarations
 //===----------------------------------------------------------------------===//
 
 /// Print this above all the other declarations. Contains type declarations used
for (const AttrOrTypeDef &def : defs) {
     // Emit the TypeID explicit specializations to have a single symbol def.
     if (!def.getDialect().getCppNamespace().empty())
       os << "MLIR_DEFINE_EXPLICIT_TYPE_ID("
          << def.getDialect().getCppNamespace() << "::" << def.getCppClassName()
          << ")\n";
   }
 
   Dialect firstDialect = defs.front().getDialect();
-  // Emit the default parser/printer for Attributes if the dialect asked for
-  // it.
-  if (valueType == "Attribute" && needsDialectParserPrinter &&
-      firstDialect.useDefaultAttributePrinterParser()) {
+
+  // Emit the default parser/printer for Attributes if the dialect asked for it.
+  if (isAttrGenerator && firstDialect.useDefaultAttributePrinterParser()) {
     NamespaceEmitter nsEmitter(os, firstDialect);
     if (firstDialect.isExtensible()) {
       os << llvm::formatv(dialectDefaultAttrPrinterParserDispatch,
                           firstDialect.getCppClassName(),
                           dialectDynamicAttrParserDispatch,
                           dialectDynamicAttrPrinterDispatch);
     } else {
       os << llvm::formatv(dialectDefaultAttrPrinterParserDispatch,
                           firstDialect.getCppClassName(), "", "");
     }
   }
 
   // Emit the default parser/printer for Types if the dialect asked for it.
-  if (valueType == "Type" && needsDialectParserPrinter &&
-      firstDialect.useDefaultTypePrinterParser()) {
+  if (!isAttrGenerator && firstDialect.useDefaultTypePrinterParser()) {
     NamespaceEmitter nsEmitter(os, firstDialect);
     if (firstDialect.isExtensible()) {
       os << llvm::formatv(dialectDefaultTypePrinterParserDispatch,
                           firstDialect.getCppClassName(),
                           dialectDynamicTypeParserDispatch,
                           dialectDynamicTypePrinterDispatch);
     } else {
       os << llvm::formatv(dialectDefaultTypePrinterParserDispatch,

mlir/tools/mlir-tblgen/DialectGen.cpp

 
 /// The code block for the op interface fallback hook.
 static const char *const operationInterfaceFallbackDecl = R"(
     /// Provides a hook for op interface.
     void *getRegisteredInterfaceForOp(mlir::TypeID interfaceID,
                                       mlir::OperationName opName) override;
 )";
 
 /// Generate the declaration for the given dialect class.
-static void
-emitDialectDecl(Dialect &dialect,
-                const iterator_range<DialectFilterIterator> &dialectAttrs,
-                const iterator_range<DialectFilterIterator> &dialectTypes,
-                raw_ostream &os) {
+static void emitDialectDecl(Dialect &dialect, raw_ostream &os) {
   // Emit all nested namespaces.
   {
     NamespaceEmitter nsEmitter(os, dialect);
 
     // Emit the start of the decl.
     std::string cppName = dialect.getCppClassName();
     StringRef superClassName =
         dialect.isExtensible() ? "ExtensibleDialect" : "Dialect";
     os << llvm::formatv(dialectDeclBeginStr, cppName, dialect.getName(),
                         superClassName);
 
-    // Check for any attributes/types registered to this dialect.  If there are,
-    // add the hooks for parsing/printing.
-    if (!dialectAttrs.empty() && dialect.useDefaultAttributePrinterParser())
+    // If the dialect requested the default attribute printer and parser, emit
+    // the declarations for the hooks.
+    if (dialect.useDefaultAttributePrinterParser())
       os << attrParserDecl;
-    if (!dialectTypes.empty() && dialect.useDefaultTypePrinterParser())
+    // If the dialect requested the default type printer and parser, emit the
+    // delcarations for the hooks.
+    if (dialect.useDefaultTypePrinterParser())
       os << typeParserDecl;
 
     // Add the decls for the various features of the dialect.
     if (dialect.hasCanonicalizer())
       os << canonicalizerDecl;
     if (dialect.hasConstantMaterializer())
       os << constantMaterializerDecl;
     if (dialect.hasOperationAttrVerify())
static bool emitDialectDecls(const llvm::RecordKeeper &recordKeeper,
   auto dialectDefs = recordKeeper.getAllDerivedDefinitions("Dialect");
   if (dialectDefs.empty())
     return false;
 
   SmallVector<Dialect> dialects(dialectDefs.begin(), dialectDefs.end());
   Optional<Dialect> dialect = findDialectToGenerate(dialects);
   if (!dialect)
     return true;
-  auto attrDefs = recordKeeper.getAllDerivedDefinitions("DialectAttr");
-  auto typeDefs = recordKeeper.getAllDerivedDefinitions("DialectType");
-  emitDialectDecl(*dialect, filterForDialect<Attribute>(attrDefs, *dialect),
-                  filterForDialect<Type>(typeDefs, *dialect), os);
+  emitDialectDecl(*dialect, os);
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 // GEN: Dialect definitions
 //===----------------------------------------------------------------------===//
 
 /// The code block to generate a dialect constructor definition.