[mlir] Revamp operation documentation generation

[rriddle]

Summary

This revisions performs several cleanups to the generated dialect documentation:

• Standardizes format of attributes/operands/results sections
• Splits out operation/type/dialect documentation generation to allow for composing generated and hand-written documentation
• Add section for declarative assembly syntax and successors
• General cleanup

[bondhugula]

mlir/tools/mlir-tblgen/OpDocGen.cpp

194

Should this be just changed to `dialect.getName() << " Dialect\n"? It's a bit odd to see Dialect -> Dialect 'xyz' definition here:
https://mlir.llvm.org/docs/Dialects/

[rriddle]

Resolve comments

[rriddle]

Resolve clang-tidy/clang-format errors

[jpienaar]

mlir/tools/mlir-tblgen/OpDocGen.cpp

130–131

I'm pro a table here as then the formatting can be left to markdown generation/CSS etc. and so this produces the content and the formatting/"pretty" parts gets done by markdown generator (then switching between different formats, alternating highlights, left align/center align etc. can be left to the formatters). Markdown generators and CSS already have so many different nobs for all those things ...

194

Yeah the weirdness was due to expecting that one could have multiple dialects in one file, which I don't think has happened really.

[rriddle]

Resolve comments

[rriddle]

Rebase

[rriddle]

Rebase

mlir/cmake/modules/AddMLIR.cmake

FOREACH(LIB ${ARGN})
       string(CONCAT link_flags ${link_flags} "-l${LIB},")
     ENDFOREACH(LIB)
     string(CONCAT link_flags ${link_flags} "--no-whole-archive")
   endif()
   set_target_properties(${target} PROPERTIES LINK_FLAGS ${link_flags})
 endfunction(whole_archive_link)
 
 # Declare a dialect in the include directory
-function(add_mlir_dialect dialect dialect_namespace dialect_doc_filename)
+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}Dialect.h.inc -gen-dialect-decls -dialect=${dialect_namespace})
   add_public_tablegen_target(MLIR${dialect}IncGen)
   add_dependencies(mlir-headers MLIR${dialect}IncGen)
+endfunction()
 
-  # Generate Dialect Documentation
-  set(LLVM_TARGET_DEFINITIONS ${dialect_doc_filename}.td)
-  tablegen(MLIR ${dialect_doc_filename}.md -gen-op-doc "-I${MLIR_MAIN_SRC_DIR}" "-I${MLIR_INCLUDE_DIR}")
-  set(GEN_DOC_FILE ${MLIR_BINARY_DIR}/docs/Dialects/${dialect_doc_filename}.md)
+# Generate Documentation
+function(add_mlir_doc doc_filename command output_file output_directory)
+  set(LLVM_TARGET_DEFINITIONS ${doc_filename}.td)
+  tablegen(MLIR ${output_file}.md ${command} "-I${MLIR_MAIN_SRC_DIR}" "-I${MLIR_INCLUDE_DIR}")
+  set(GEN_DOC_FILE ${MLIR_BINARY_DIR}/docs/${output_directory}${output_file}.md)
   add_custom_command(
           OUTPUT ${GEN_DOC_FILE}
           COMMAND ${CMAKE_COMMAND} -E copy
-                  ${CMAKE_CURRENT_BINARY_DIR}/${dialect_doc_filename}.md
+                  ${CMAKE_CURRENT_BINARY_DIR}/${output_file}.md
                   ${GEN_DOC_FILE}
-          DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${dialect_doc_filename}.md)
-  add_custom_target(${dialect_doc_filename}DocGen DEPENDS ${GEN_DOC_FILE})
-  add_dependencies(mlir-doc ${dialect_doc_filename}DocGen)
+          DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${output_file}.md)
+  add_custom_target(${output_file}DocGen DEPENDS ${GEN_DOC_FILE})
+  add_dependencies(mlir-doc ${output_file}DocGen)
 endfunction()
 
 # Declare a library which can be compiled in libMLIR.so
 macro(add_mlir_library name)
   set_property(GLOBAL APPEND PROPERTY MLIR_ALL_LIBS ${name})
   add_llvm_library(${ARGV})
 endmacro(add_mlir_library)
 

mlir/docs/CreatingADialect.md

 ### TableGen Targets
 
 Operations in dialects are typically declared using the ODS format in
 tablegen in a file FooOps.td.  This file forms the core of a dialect and
 is declared using add_mlir_dialect().
 
 ```cmake
 
-add_mlir_dialect(FooOps foo FooOps)
+add_mlir_dialect(FooOps foo)
+add_mlir_doc(FooOps -gen-dialect-doc FooDialect Dialects/)
 
 ```
 
 This generates the correct rules to run mlir-tblgen, along with a
 'MLIRFooOpsIncGen' target which can be used to declare dependencies.
 
 Dialect transformations are typically declared in a file FooTransforms.td.
 Targets for TableGen are described in typical llvm fashion.

mlir/docs/Dialects/Vector.md

 # Vector Dialect
 
+[TOC]
+
 MLIR supports multi-dimensional `vector` types and custom operations on those
 types. A generic, retargetable, higher-order ``vector`` type (`n-D` with `n >
 1`) is a structured type, that carries semantic information useful for
 transformations. This document discusses retargetable abstractions that exist
 in MLIR today and operate on ssa-values of type `vector` along with pattern
 rewrites and lowerings that enable targeting specific instructions on concrete
 targets. These abstractions serve to separate concerns between operations on
 `memref` (a.k.a buffers) and operations on ``vector`` values. This is not a

 1. it does not hide complexity related to the buffer vs value semantics and
 the memory subsystem and
 2. it does not rely on LLVM to magically make all the things work from a too
 low-level abstraction.
 
 The use of special intrinsics in a `1-D` LLVM world is still available thanks
 to an explicit `vector.cast` op.
 
+## Operations
 
-### Operations
-
+[include "Dialects/VectorOps.md"]

mlir/docs/OpDefinitions.md

 providing include paths via `-I`. For example,
 
 ```sh
 # To see op C++ class declaration
 mlir-tblgen --gen-op-decls -I /path/to/mlir/include /path/to/input/td/file
 # To see op C++ class definition
 mlir-tblgen --gen-op-defs -I /path/to/mlir/include /path/to/input/td/file
 # To see op documentation
-mlir-tblgen --gen-op-doc -I /path/to/mlir/include /path/to/input/td/file
+mlir-tblgen --gen-dialect-doc -I /path/to/mlir/include /path/to/input/td/file
 
 # To see op interface C++ class declaration
 mlir-tblgen --gen-op-interface-decls -I /path/to/mlir/include /path/to/input/td/file
 # To see op interface C++ class definition
 mlir-tblgen --gen-op-interface-defs -I /path/to/mlir/include /path/to/input/td/file
 # To see op interface documentation
 mlir-tblgen --gen-op-interface-doc -I /path/to/mlir/include /path/to/input/td/file
 ```
 
-
 ## Appendix
 
 ### Requirements and existing mechanisms analysis
 
 The op description should as declarative as possible to allow a wide range of
 tools to work with them and query methods generated from them. In particular
 this means specifying traits, constraints and shape inference information in
 a way that is easily analyzable (e.g., avoid opaque calls to C++ functions where

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

-add_mlir_dialect(AffineOps affine AffineOps)
+add_mlir_dialect(AffineOps affine)
+add_mlir_doc(AffineOps -gen-dialect-doc AffineDialect Dialects/)

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

-add_mlir_dialect(FxpMathOps fxpmath FxpMathOps)
+add_mlir_dialect(FxpMathOps fxpmath)
+add_mlir_doc(FxpMathOps -gen-dialect-doc FxpMathDialect Dialects/)

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

-add_mlir_dialect(GPUOps gpu GPUOps)
+add_mlir_dialect(GPUOps gpu)
+add_mlir_doc(GPUOps -gen-dialect-doc GPUDialect Dialects/)

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

 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 nvvm NVVMOps)
-add_mlir_dialect(ROCDLOps rocdl ROCDLOps)
+add_mlir_dialect(NVVMOps nvvm)
+add_mlir_doc(NVVMOps -gen-dialect-doc NVVMDialect Dialects/)
+add_mlir_dialect(ROCDLOps rocdl)
+add_mlir_doc(ROCDLOps -gen-dialect-doc ROCDLDialect Dialects/)
 
 set(LLVM_TARGET_DEFINITIONS LLVMOps.td)
 mlir_tablegen(LLVMConversions.inc -gen-llvmir-conversions)
 mlir_tablegen(LLVMConversionEnumsToLLVM.inc -gen-enum-to-llvmir-conversions)
 mlir_tablegen(LLVMConversionEnumsFromLLVM.inc -gen-enum-from-llvmir-conversions)
 add_public_tablegen_target(MLIRLLVMConversionsIncGen)
 set(LLVM_TARGET_DEFINITIONS NVVMOps.td)
 mlir_tablegen(NVVMConversions.inc -gen-llvmir-conversions)

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

-add_mlir_dialect(LinalgOps linalg LinalgDoc)
+add_mlir_dialect(LinalgOps linalg)
+add_mlir_doc(LinalgDoc -gen-dialect-doc LinalgDialect Dialects/)
 set(LLVM_TARGET_DEFINITIONS LinalgStructuredOps.td)
 mlir_tablegen(LinalgStructuredOps.h.inc -gen-op-decls)
 mlir_tablegen(LinalgStructuredOps.cpp.inc -gen-op-defs)
 add_public_tablegen_target(MLIRLinalgStructuredOpsIncGen)
 
 set(LLVM_TARGET_DEFINITIONS LinalgStructuredOpsInterface.td)
 mlir_tablegen(LinalgStructuredOpsInterfaces.h.inc -gen-op-interface-decls)
 mlir_tablegen(LinalgStructuredOpsInterfaces.cpp.inc -gen-op-interface-defs)
 add_public_tablegen_target(MLIRLinalgStructuredOpsInterfaceIncGen)

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

-add_mlir_dialect(LoopOps loop LoopOps)
+add_mlir_dialect(LoopOps loop)
+add_mlir_doc(LoopOps -gen-dialect-doc LoopDialect Dialects/)

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

-add_mlir_dialect(OpenMPOps omp OpenMPOps)
+add_mlir_dialect(OpenMPOps omp)
+add_mlir_doc(OpenMPOps -gen-dialect-doc OpenMPDialect Dialects/)

mlir/include/mlir/Dialect/Quant/CMakeLists.txt

-add_mlir_dialect(QuantOps quant QuantOps)
+add_mlir_dialect(QuantOps quant)
+add_mlir_doc(QuantOps -gen-dialect-doc QuantDialect Dialects/)

mlir/include/mlir/Dialect/SPIRV/CMakeLists.txt

-add_mlir_dialect(SPIRVOps spv SPIRVOps)
+add_mlir_dialect(SPIRVOps spv)
+add_mlir_doc(SPIRVOps -gen-dialect-doc SPIRVDialect Dialects/)
 
 set(LLVM_TARGET_DEFINITIONS SPIRVBase.td)
 mlir_tablegen(SPIRVEnums.h.inc -gen-enum-decls)
 mlir_tablegen(SPIRVEnums.cpp.inc -gen-enum-defs)
 add_public_tablegen_target(MLIRSPIRVEnumsIncGen)
 
 set(LLVM_TARGET_DEFINITIONS SPIRVBase.td)
 mlir_tablegen(SPIRVEnumAvailability.h.inc -gen-spirv-enum-avail-decls)

mlir/include/mlir/Dialect/Vector/CMakeLists.txt

-add_mlir_dialect(VectorOps vector VectorOps)
+add_mlir_dialect(VectorOps vector)
+add_mlir_doc(VectorOps -gen-op-doc VectorOps Dialects/)
 
 set(LLVM_TARGET_DEFINITIONS VectorTransformPatterns.td)
 mlir_tablegen(VectorTransformPatterns.h.inc -gen-rewriters)
 add_public_tablegen_target(MLIRVectorTransformPatternsIncGen)

mlir/include/mlir/TableGen/Operator.h

public:
   ArrayRef<llvm::SMLoc> getLoc() const;
 
   // Query functions for the documentation of the operator.
   bool hasDescription() const;
   StringRef getDescription() const;
   bool hasSummary() const;
   StringRef getSummary() const;
 
+  // Query functions for the assembly format of the operator.
+  bool hasAssemblyFormat() const;
+  StringRef getAssemblyFormat() const;
+
   // Returns this op's extra class declaration code.
   StringRef getExtraClassDeclaration() const;
 
   // Returns the Tablegen definition this operator was constructed from.
   // TODO(antiagainst,zinenko): do not expose the TableGen record, this is a
   // temporary solution to OpEmitter requiring a Record because Operator does
   // not provide enough methods.
   const llvm::Record &getDef() const;

mlir/lib/TableGen/Operator.cpp

 //===- Operator.cpp - Operator class --------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Operator wrapper to simplify using TableGen Record defining a MLIR Op.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/TableGen/Operator.h"
+#include "mlir/ADT/TypeSwitch.h"
 #include "mlir/TableGen/OpTrait.h"
 #include "mlir/TableGen/Predicate.h"
 #include "mlir/TableGen/Type.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"

 bool tblgen::Operator::hasSummary() const {
   return def.getValue("summary") != nullptr;
 }
 
 StringRef tblgen::Operator::getSummary() const {
   return def.getValueAsString("summary");
 }
 
+bool tblgen::Operator::hasAssemblyFormat() const {
+  auto *valueInit = def.getValueInit("assemblyFormat");
+  return isa<llvm::CodeInit>(valueInit) || isa<llvm::StringInit>(valueInit);
+}
+
+StringRef tblgen::Operator::getAssemblyFormat() const {
+  return TypeSwitch<llvm::Init *, StringRef>(def.getValueInit("assemblyFormat"))
+      .Case<llvm::StringInit, llvm::CodeInit>(
+          [&](auto *init) { return init->getValue(); });
+}
+
 void tblgen::Operator::print(llvm::raw_ostream &os) const {
   os << "op '" << getOperationName() << "'\n";
   for (Argument arg : arguments) {
     if (auto *attr = arg.dyn_cast<NamedAttribute *>())
       os << "[attribute] " << attr->name << '\n';
     else
       os << "[operand] " << arg.get<NamedTypeConstraint *>()->name << '\n';
   }
 }
 
 auto tblgen::Operator::VariableDecoratorIterator::unwrap(llvm::Init *init)
     -> VariableDecorator {
   return VariableDecorator(cast<llvm::DefInit>(init)->getDef());
 }

mlir/tools/mlir-tblgen/OpDocGen.cpp

 // Emits `str` with trailing newline if not empty.
 static void emitIfNotEmpty(StringRef str, raw_ostream &os) {
   if (!str.empty()) {
     emitDescription(str, os);
     os << "\n";
   }
 }
 
-static void emitOpDocForDialect(const Dialect &dialect,
-                                const std::vector<Operator> &ops,
-                                const std::vector<Type> &types,
-                                raw_ostream &os) {
-  os << "# Dialect '" << dialect.getName() << "' definition\n\n";
-  emitIfNotEmpty(dialect.getSummary(), os);
-  emitIfNotEmpty(dialect.getDescription(), os);
+/// Emit the given named constraint.
+template <typename T>
+static void emitNamedConstraint(const T &it, raw_ostream &os) {
+  if (!it.name.empty())
+    os << "`" << it.name << "`";
+  else
+    os << "&laquo;unnamed&raquo;";
+  os << " | " << it.constraint.getDescription() << "\n";
+}
 
-  // TODO(b/143543720) Generate TOC where extension is not supported.
-  os << "[TOC]\n\n";
+//===----------------------------------------------------------------------===//
+// Operation Documentation
+//===----------------------------------------------------------------------===//
 
-  // TODO(antiagainst): Add link between use and def for types
-  if (!types.empty())
-    os << "## Type definition\n\n";
-  for (auto type : types) {
-    os << "### " << type.getDescription() << "\n";
-    emitDescription(type.getTypeDescription(), os);
-    os << "\n";
-  }
+/// Emit the assembly format of an operation.
+static void emitAssemblyFormat(StringRef opName, StringRef format,
+                               raw_ostream &os) {
+  os << "\nSyntax:\n\n```\noperation ::= `" << opName << "` ";
 
-  if (!ops.empty())
-    os << "## Operation definition\n\n";
-  for (auto op : ops) {
-    os << "### " << op.getOperationName() << " (" << op.getQualCppClassName()
-       << ")";
+  // Print the assembly format aligned.
+  unsigned indent = strlen("operation ::= ");
+  std::pair<StringRef, StringRef> split = format.split('\n');
+  os << split.first.trim() << "\n";
+  do {
+    split = split.second.split('\n');
+    StringRef formatChunk = split.first.trim();
+    if (!formatChunk.empty())
+      os.indent(indent) << formatChunk << "\n";
+  } while (!split.second.empty());
+  os << "```\n\n";
+}
+
+static void emitOpDoc(Operator op, raw_ostream &os) {
+  os << llvm::formatv("### `{0}` ({1})\n", op.getOperationName(),
+                      op.getQualCppClassName());
 
-    // Emit summary & description of operator.
-    if (op.hasSummary())
-      os << "\n" << op.getSummary() << "\n";
-    os << "\n#### Description:\n\n";
-    if (op.hasDescription())
-      mlir::tblgen::emitDescription(op.getDescription(), os);
+  // Emit the summary, syntax, and description if present.
+  if (op.hasAssemblyFormat())
+    emitAssemblyFormat(op.getOperationName(), op.getAssemblyFormat().trim(),
+                       os);
 
-    // Emit operands & type of operand. All operands are numbered, some may be
-    // named too.
-    os << "\n#### Operands:\n\n";
-    for (const auto &operand : op.getOperands()) {
-      os << "1. ";
-      if (!operand.name.empty())
-        os << "`" << operand.name << "`: ";
-      else
-        os << "&laquo;unnamed&raquo;: ";
-      os << operand.constraint.getDescription() << "\n";
-    }
-
-    // Emit attributes.
+  if (op.getNumAttributes() != 0) {
     // TODO: Attributes are only documented by TableGen name, with no further
     // info. This should be improved.
     os << "\n#### Attributes:\n\n";
-    if (op.getNumAttributes() > 0) {
-      os << "| Attribute | MLIR Type | Description |\n"
-         << "| :-------: | :-------: | ----------- |\n";
+    for (const auto &it : op.getAttributes()) {
+      StringRef storageType = it.attr.getStorageType();
+      os << "`" << it.name << "` | " << storageType << " | "
+         << it.attr.getDescription() << "\n";
     }
-    for (auto namedAttr : op.getAttributes()) {
-      os << "| `" << namedAttr.name << "` | `"
-         << namedAttr.attr.getStorageType() << "` | "
-         << namedAttr.attr.getDescription() << " attribute |\n";
-    }
+  }
+
+  // Emit each of the operands.
+  if (op.getNumOperands() != 0) {
+    os << "\n#### Operands:\n\n";
+    os << "| Operand | Description |\n"
+       << "| :-----: | ----------- |\n";
+    for (const auto &it : op.getOperands())
+      emitNamedConstraint(it, os);
 
-    // Emit results.
+  if (op.getNumResults() != 0) {
     os << "\n#### Results:\n\n";
-    for (unsigned i = 0, e = op.getNumResults(); i < e; ++i) {
-      os << "1. ";
-      auto name = op.getResultName(i);
-      if (name.empty())
-        os << "&laquo;unnamed&raquo;: ";
-      else
-        os << "`" << name << "`: ";
-      os << op.getResultTypeConstraint(i).getDescription() << "\n";
-    }
+    os << "| Result | Description |\n"
+       << "| :----: | ----------- |\n";
+    for (const auto &it : op.getResults())
+      emitNamedConstraint(it, os);
 
-    os << "\n";
+  // Emit successors.
+  if (op.getNumSuccessors() != 0) {
+    os << "\n#### Successors:\n\n";
+    os << "| Successor | Description |\n"
+       << "| :-------: | ----------- |\n";
+    for (const auto &it : op.getSuccessors())
+      emitNamedConstraint(it, os);
   }
+
+  os << "\n";
 }
 
 static void emitOpDoc(const RecordKeeper &recordKeeper, raw_ostream &os) {
+  auto opDefs = recordKeeper.getAllDerivedDefinitions("Op");
+
+  os << "<!-- Autogenerated by mlir-tblgen; don't manually edit -->\n";
+  for (const llvm::Record *opDef : opDefs)
+    emitOpDoc(Operator(opDef), os);
+}
+
+//===----------------------------------------------------------------------===//
+// Type Documentation
+//===----------------------------------------------------------------------===//
+
+static void emitTypeDoc(const Type &type, raw_ostream &os) {
+  os << "### " << type.getDescription() << "\n";
+  emitDescription(type.getTypeDescription(), os);
+  os << "\n";
+}
+
+//===----------------------------------------------------------------------===//
+// Dialect Documentation
+//===----------------------------------------------------------------------===//
+
+static void emitDialectDoc(const Dialect &dialect, ArrayRef<Operator> ops,
+                           ArrayRef<Type> types, raw_ostream &os) {
+  os << "# '" << dialect.getName() << "' Dialect\n\n";
+  emitIfNotEmpty(dialect.getSummary(), os);
+  emitIfNotEmpty(dialect.getDescription(), os);
+
+  os << "[TOC]\n\n";
+
+  // TODO(antiagainst): Add link between use and def for types
+  if (!types.empty()) {
+    os << "## Type definition\n\n";
+    for (const Type &type : types)
+      emitTypeDoc(type, os);
+  }
+
+  if (!ops.empty()) {
+    os << "## Operation definition\n\n";
+    for (const Operator &op : ops)
+      emitOpDoc(op, os);
+  }
+}
+
+static void emitDialectDoc(const RecordKeeper &recordKeeper, raw_ostream &os) {
   const auto &opDefs = recordKeeper.getAllDerivedDefinitions("Op");
   const auto &typeDefs = recordKeeper.getAllDerivedDefinitions("DialectType");
 
   std::map<Dialect, std::vector<Operator>> dialectOps;
   std::map<Dialect, std::vector<Type>> dialectTypes;
   for (auto *opDef : opDefs) {
     Operator op(opDef);
     dialectOps[op.getDialect()].push_back(op);
   }
   for (auto *typeDef : typeDefs) {
     Type type(typeDef);
     if (auto dialect = type.getDialect())
       dialectTypes[dialect].push_back(type);
   }
 
   os << "<!-- Autogenerated by mlir-tblgen; don't manually edit -->\n";
   for (auto dialectWithOps : dialectOps)
-    emitOpDocForDialect(dialectWithOps.first, dialectWithOps.second,
-                        dialectTypes[dialectWithOps.first], os);
+    emitDialectDoc(dialectWithOps.first, dialectWithOps.second,
 }
 
+//===----------------------------------------------------------------------===//
+// Gen Registration
+//===----------------------------------------------------------------------===//
+
 static mlir::GenRegistration
-    genRegister("gen-op-doc", "Generate operation documentation",
+    genOpRegister("gen-op-doc", "Generate dialect documentation",
                   [](const RecordKeeper &records, raw_ostream &os) {
                     emitOpDoc(records, os);
                     return false;
                   });
+
+static mlir::GenRegistration
+    genRegister("gen-dialect-doc", "Generate dialect documentation",
+                [](const RecordKeeper &records, raw_ostream &os) {
+                  emitDialectDoc(records, os);
+                  return false;
+                });

mlir/tools/mlir-tblgen/OpFormatGen.cpp

 //===----------------------------------------------------------------------===//
 // Interface
 //===----------------------------------------------------------------------===//
 
 void mlir::tblgen::generateOpFormat(const Operator &constOp, OpClass &opClass) {
   // TODO(riverriddle) Operator doesn't expose all necessary functionality via
   // the const interface.
   Operator &op = const_cast<Operator &>(constOp);
-
-  // Check if the operation specified the format field.
-  StringRef formatStr;
-  TypeSwitch<llvm::Init *>(op.getDef().getValueInit("assemblyFormat"))
-      .Case<llvm::StringInit, llvm::CodeInit>(
-          [&](auto *init) { formatStr = init->getValue(); });
-  if (formatStr.empty())
+  if (!op.hasAssemblyFormat())
     return;
 
   // Parse the format description.
   llvm::SourceMgr mgr;
-  mgr.AddNewSourceBuffer(llvm::MemoryBuffer::getMemBuffer(formatStr),
-                         llvm::SMLoc());
+  mgr.AddNewSourceBuffer(
+      llvm::MemoryBuffer::getMemBuffer(op.getAssemblyFormat()), llvm::SMLoc());
   OperationFormat format(op);
   if (failed(FormatParser(mgr, format, op).parse())) {
     // Exit the process if format errors are treated as fatal.
     if (formatErrorIsFatal) {
       // Invoke the interrupt handlers to run the file cleanup handlers.
       llvm::sys::RunInterruptHandlers();
       std::exit(1);
     }
     return;
   }
 
   // Generate the printer and parser based on the parsed format.
   format.genParser(op, opClass);
   format.genPrinter(op, opClass);
 }