[mlir] Split out AttrDef/TypeDef and pattern constructs from OpBase.td

[rriddle]

Summary

OpBase.td has formed into a huge monolith of all ODS constructs. This
commits starts to rectify that by splitting out some constructs to their
own .td files.

[aartbik]

LG for sparse, thin as it is. Heads up, I am about to refactor the attribute definition into its own build module (separate for sparse tensor dialect) to provide a less convoluted build graph. But I will wait with that until this goes in.

[rriddle]

In D118636#3312355, @aartbik wrote:

LG for sparse, thin as it is. Heads up, I am about to refactor the attribute definition into its own build module (separate for sparse tensor dialect) to provide a less convoluted build graph. But I will wait with that until this goes in.

Do not block yourself on any of this! This was super easy to write, and will likely be super easy to rebase on whatever you do.

flang/include/flang/Optimizer/Dialect/CanonicalizationPatterns.td

 /// Defines pattern rewrites for fir optimizations
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_FIR_REWRITE_PATTERNS
 #define FORTRAN_FIR_REWRITE_PATTERNS
 
 include "mlir/IR/OpBase.td"
+include "mlir/IR/PatternBase.td"
 include "mlir/Dialect/Arithmetic/IR/ArithmeticOps.td"
 include "mlir/Dialect/StandardOps/IR/Ops.td"
 include "flang/Optimizer/Dialect/FIROps.td"
 
 def IdenticalTypePred : Constraint<CPred<"$0.getType() == $1.getType()">>;
 def IntegerTypePred : Constraint<CPred<"fir::isa_integer($0.getType())">>;
 def IndexTypePred : Constraint<CPred<"$0.getType().isa<mlir::IndexType>()">>;
 

flang/include/flang/Optimizer/Dialect/FIRTypes.td

 //===- FIRTypes.td - FIR types -----------------------------*- 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 file declares the FIR dialect types.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FIR_DIALECT_FIR_TYPES
 #define FIR_DIALECT_FIR_TYPES
 
+include "mlir/IR/AttrTypeBase.td"
 include "flang/Optimizer/Dialect/FIRDialect.td"
 
 //===----------------------------------------------------------------------===//
 // FIR Types
 //===----------------------------------------------------------------------===//
 
 class FIR_Type<string name, string typeMnemonic> : TypeDef<fir_Dialect, name> {
   let mnemonic = typeMnemonic;

llvm/include/llvm/TableGen/Record.h

public:
   /// class. The class must be defined.
   std::vector<Record *> getAllDerivedDefinitions(StringRef ClassName) const;
 
   /// Get all the concrete records that inherit from all the specified
   /// classes. The classes must be defined.
   std::vector<Record *> getAllDerivedDefinitions(
       ArrayRef<StringRef> ClassNames) const;
 
+  /// Get all the concrete records that inherit from specified class, if the
+  /// class is defined. Returns an empty vector if the class is not defined.
+  std::vector<Record *>
+  getAllDerivedDefinitionsIfDefined(StringRef ClassName) const;
+
   void dump() const;
 };
 
 /// Sorting predicate to sort record pointers by name.
 struct LessRecord {
   bool operator()(const Record *Rec1, const Record *Rec2) const {
     return StringRef(Rec1->getName()).compare_numeric(Rec2->getName()) < 0;
   }

llvm/lib/TableGen/Record.cpp

void RecordKeeper::stopBackendTimer() {
   if (TimingGroup) {
     if (BackendTimer) {
       stopTimer();
       BackendTimer = false;
     }
   }
 }
 
+std::vector<Record *>
+RecordKeeper::getAllDerivedDefinitions(StringRef ClassName) const {
   // We cache the record vectors for single classes. Many backends request
   // the same vectors multiple times.
-std::vector<Record *> RecordKeeper::getAllDerivedDefinitions(
-    StringRef ClassName) const {
-
   auto Pair = ClassRecordsMap.try_emplace(ClassName);
   if (Pair.second)
     Pair.first->second = getAllDerivedDefinitions(makeArrayRef(ClassName));
 
   return Pair.first->second;
 }
 
 std::vector<Record *> RecordKeeper::getAllDerivedDefinitions(
if (all_of(ClassRecs, [&OneDef](const Record *Class) {
                             return OneDef.second->isSubClassOf(Class);
                           }))
       Defs.push_back(OneDef.second.get());
   }
 
   return Defs;
 }
 
+std::vector<Record *>
+RecordKeeper::getAllDerivedDefinitionsIfDefined(StringRef ClassName) const {
+  return getClass(ClassName) ? getAllDerivedDefinitions(ClassName)
+                             : std::vector<Record *>();
+}
+
 Init *MapResolver::resolve(Init *VarName) {
   auto It = Map.find(VarName);
   if (It == Map.end())
     return nullptr;
 
   Init *I = It->second.V;
 
   if (!It->second.Resolved && Map.size() > 1) {

mlir/examples/toy/Ch3/mlir/ToyCombine.td

 //===- ToyCombine.td - Pattern Match Optimizations for Toy -*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines language-specific pattern match optimizations for Toy using
 // Declarative Rewrite Rules (DRR) specified using TableGen records.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef TOY_COMBINE
 #define TOY_COMBINE
 
+include "mlir/IR/PatternBase.td"
 include "toy/Ops.td"
 
 /// Note: The DRR definition used for defining patterns is shown below:
 ///
 /// class Pattern<
 ///    dag sourcePattern, list<dag> resultPatterns,
 ///    list<dag> additionalConstraints = [],
 ///    dag benefitsAdded = (addBenefit 0)

mlir/examples/toy/Ch4/mlir/ToyCombine.td

 //===- ToyCombine.td - Pattern Match Optimizations for Toy -*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines language-specific pattern match optimizations for Toy using
 // Declarative Rewrite Rules (DRR) specified using TableGen records.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef TOY_COMBINE
 #define TOY_COMBINE
 
+include "mlir/IR/PatternBase.td"
 include "toy/Ops.td"
 
 /// Note: The DRR definition used for defining patterns is shown below:
 ///
 /// class Pattern<
 ///    dag sourcePattern, list<dag> resultPatterns,
 ///    list<dag> additionalConstraints = [],
 ///    dag benefitsAdded = (addBenefit 0)

mlir/examples/toy/Ch5/mlir/ToyCombine.td

 //===- ToyCombine.td - Pattern Match Optimizations for Toy -*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines language-specific pattern match optimizations for Toy using
 // Declarative Rewrite Rules (DRR) specified using TableGen records.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef TOY_COMBINE
 #define TOY_COMBINE
 
+include "mlir/IR/PatternBase.td"
 include "toy/Ops.td"
 
 /// Note: The DRR definition used for defining patterns is shown below:
 ///
 /// class Pattern<
 ///    dag sourcePattern, list<dag> resultPatterns,
 ///    list<dag> additionalConstraints = [],
 ///    dag benefitsAdded = (addBenefit 0)

mlir/examples/toy/Ch6/mlir/ToyCombine.td

 //===- ToyCombine.td - Pattern Match Optimizations for Toy -*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines language-specific pattern match optimizations for Toy using
 // Declarative Rewrite Rules (DRR) specified using TableGen records.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef TOY_COMBINE
 #define TOY_COMBINE
 
+include "mlir/IR/PatternBase.td"
 include "toy/Ops.td"
 
 /// Note: The DRR definition used for defining patterns is shown below:
 ///
 /// class Pattern<
 ///    dag sourcePattern, list<dag> resultPatterns,
 ///    list<dag> additionalConstraints = [],
 ///    dag benefitsAdded = (addBenefit 0)

mlir/examples/toy/Ch7/mlir/ToyCombine.td

 //===- ToyCombine.td - Pattern Match Optimizations for Toy -*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines language-specific pattern match optimizations for Toy using
 // Declarative Rewrite Rules (DRR) specified using TableGen records.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef TOY_COMBINE
 #define TOY_COMBINE
 
+include "mlir/IR/PatternBase.td"
 include "toy/Ops.td"
 
 /// Note: The DRR definition used for defining patterns is shown below:
 ///
 /// class Pattern<
 ///    dag sourcePattern, list<dag> resultPatterns,
 ///    list<dag> additionalConstraints = [],
 ///    dag benefitsAdded = (addBenefit 0)

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

 //===- AsyncTypes.td - Async dialect types -----------------*- 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 file declares the Async dialect types.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_ASYNC_IR_ASYNCTYPES
 #define MLIR_DIALECT_ASYNC_IR_ASYNCTYPES
 
+include "mlir/IR/AttrTypeBase.td"
 include "mlir/Dialect/Async/IR/AsyncDialect.td"
 
 //===----------------------------------------------------------------------===//
 // Async Types
 //===----------------------------------------------------------------------===//
 
 class Async_Type<string name, string typeMnemonic> : TypeDef<AsyncDialect,
                                                              name> {

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

 //===- EmitCAttributes.td - EmitC attributes ---------------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines the MLIR EmitC attributes.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_EMITC_IR_EMITCATTRIBUTES
 #define MLIR_DIALECT_EMITC_IR_EMITCATTRIBUTES
 
+include "mlir/IR/AttrTypeBase.td"
 include "mlir/Dialect/EmitC/IR/EmitCBase.td"
 
 //===----------------------------------------------------------------------===//
 // EmitC attribute definitions
 //===----------------------------------------------------------------------===//
 
 class EmitC_Attr<string name, string attrMnemonic>
     : AttrDef<EmitC_Dialect, name> {

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

 //===- EmitCTypes.td - EmitC types -------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines the MLIR EmitC types.
 //
 //===----------------------------------------------------------------------===//
 
 
 #ifndef MLIR_DIALECT_EMITC_IR_EMITCTYPES
 #define MLIR_DIALECT_EMITC_IR_EMITCTYPES
 
+include "mlir/IR/AttrTypeBase.td"
 include "mlir/Dialect/EmitC/IR/EmitCBase.td"
 
 //===----------------------------------------------------------------------===//
 // EmitC type definitions
 //===----------------------------------------------------------------------===//
 
 class EmitC_Type<string name, string typeMnemonic>
     : TypeDef<EmitC_Dialect, name> {

mlir/include/mlir/Dialect/LLVMIR/LLVMAttrDefs.td

 //===-- LLVMAttrDefs.td - LLVM Attributes definition file --*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVMIR_ATTRDEFS
 #define LLVMIR_ATTRDEFS
 
+include "mlir/IR/AttrTypeBase.td"
 include "mlir/Dialect/LLVMIR/LLVMOpBase.td"
 
-
 // All of the attributes will extend this class.
 class LLVM_Attr<string name> : AttrDef<LLVM_Dialect, name>;
 
 // The "FastMath" flags associated with floating point LLVM instructions.
 def FastmathFlagsAttr : LLVM_Attr<"FMF"> {
   let mnemonic = "fastmath";
 
   // List of type parameters.

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

 //===- PDLTypes.td - Pattern descriptor types --------------*- 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 file declares the Pattern Descriptor Language dialect types.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_PDL_IR_PDLTYPES
 #define MLIR_DIALECT_PDL_IR_PDLTYPES
 
+include "mlir/IR/AttrTypeBase.td"
 include "mlir/Dialect/PDL/IR/PDLDialect.td"
 
 //===----------------------------------------------------------------------===//
 // PDL Types
 //===----------------------------------------------------------------------===//
 
 class PDL_Type<string name, string typeMnemonic>
     : TypeDef<PDL_Dialect, name, [], "::mlir::pdl::PDLType"> {

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

 //===-- SparseTensorAttrDefs.td - attributes definitions ---*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SPARSETENSOR_ATTRDEFS
 #define SPARSETENSOR_ATTRDEFS
 
+include "mlir/IR/AttrTypeBase.td"
 include "mlir/Dialect/SparseTensor/IR/SparseTensorBase.td"
 include "mlir/IR/TensorEncoding.td"
 
 // All of the Tensor attributes will extend this class.
 class SparseTensor_Attr<string name,
                         list<Trait> traits = []>
   : AttrDef<SparseTensor_Dialect, name, traits>;
 

mlir/include/mlir/IR/AttrTypeBase.td

+//===-- AttrTypeBase.td - Base Attr/Type definition file ---*- 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 file contains the base set of constructs for defining Attribute and
+// Type classes.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef ATTRTYPEBASE_TD
+#define ATTRTYPEBASE_TD
+
+include "mlir/IR/OpBase.td"
+
+//-------------------------------------------------------------------------===//
+// AttrTrait definitions
+//===----------------------------------------------------------------------===//
+
+// These classes are used to define attribute specific traits.
+class NativeAttrTrait<string name> : NativeTrait<name, "Attribute">;
+class ParamNativeAttrTrait<string prop, string params>
+    : ParamNativeTrait<prop, params, "Attribute">;
+class GenInternalAttrTrait<string prop> : GenInternalTrait<prop, "Attribute">;
+class PredAttrTrait<string descr, Pred pred> : PredTrait<descr, pred>;
+
+//===----------------------------------------------------------------------===//
+// TypeTrait definitions
+//===----------------------------------------------------------------------===//
+
+// These classes are used to define type specific traits.
+class NativeTypeTrait<string name> : NativeTrait<name, "Type">;
+class ParamNativeTypeTrait<string prop, string params>
+    : ParamNativeTrait<prop, params, "Type">;
+class GenInternalTypeTrait<string prop> : GenInternalTrait<prop, "Type">;
+class PredTypeTrait<string descr, Pred pred> : PredTrait<descr, pred>;
+
+//===----------------------------------------------------------------------===//
+// Builders
+//===----------------------------------------------------------------------===//
+
+// Class for defining a custom getter.
+//
+// TableGen generates several generic getter methods for each attribute and type
+// by default, corresponding to the specified dag parameters. If the default
+// generated ones cannot cover some use case, custom getters can be defined
+// using instances of this class.
+//
+// The signature of the `get` is always either:
+//
+// ```c++
+// static <ClassName> get(MLIRContext *context, <other-parameters>...) {
+//   <body>...
+// }
+// ```
+//
+// or:
+//
+// ```c++
+// static <ClassName> get(MLIRContext *context, <parameters>...);
+// ```
+//
+// To define a custom getter, the parameter list and body should be passed
+// in as separate template arguments to this class. The parameter list is a
+// TableGen DAG with `ins` operation with named arguments, which has either:
+//   - string initializers ("Type":$name) to represent a typed parameter, or
+//   - CArg-typed initializers (CArg<"Type", "default">:$name) to represent a
+//     typed parameter that may have a default value.
+// The type string is used verbatim to produce code and, therefore, must be a
+// valid C++ type. It is used inside the C++ namespace of the parent Type's
+// dialect; explicit namespace qualification like `::mlir` may be necessary if
+// Types are not placed inside the `mlir` namespace. The default value string is
+// used verbatim to produce code and must be a valid C++ initializer the given
+// type. For example, the following signature specification
+//
+// ```
+// AttrOrTypeBuilder<(ins "int":$integerArg, CArg<"float", "3.0f">:$floatArg)>
+// ```
+//
+// has an integer parameter and a float parameter with a default value.
+//
+// If an empty string is passed in for `body`, then *only* the builder
+// declaration will be generated; this provides a way to define complicated
+// builders entirely in C++. If a `body` string is provided, the `Base::get`
+// method should be invoked using `$_get`, e.g.:
+//
+// ```
+// AttrOrTypeBuilder<(ins "int":$integerArg, CArg<"float", "3.0f">:$floatArg), [{
+//   return $_get($_ctxt, integerArg, floatArg);
+// }]>
+// ```
+//
+// This is necessary because the `body` is also used to generate `getChecked`
+// methods, which have a different underlying `Base::get*` call.
+//
+class AttrOrTypeBuilder<dag parameters, code bodyCode = ""> {
+  dag dagParams = parameters;
+  code body = bodyCode;
+
+  // The context parameter can be inferred from one of the other parameters and
+  // is not implicitly added to the parameter list.
+  bit hasInferredContextParam = 0;
+}
+class AttrBuilder<dag parameters, code bodyCode = "">
+  : AttrOrTypeBuilder<parameters, bodyCode>;
+class TypeBuilder<dag parameters, code bodyCode = "">
+  : AttrOrTypeBuilder<parameters, bodyCode>;
+
+// A class of AttrOrTypeBuilder that is able to infer the MLIRContext parameter
+// from one of the other builder parameters. Instances of this builder do not
+// have `MLIRContext *` implicitly added to the parameter list.
+class AttrOrTypeBuilderWithInferredContext<dag parameters, code bodyCode = "">
+  : TypeBuilder<parameters, bodyCode> {
+  let hasInferredContextParam = 1;
+}
+class AttrBuilderWithInferredContext<dag parameters, code bodyCode = "">
+  : AttrOrTypeBuilderWithInferredContext<parameters, bodyCode>;
+class TypeBuilderWithInferredContext<dag parameters, code bodyCode = "">
+  : AttrOrTypeBuilderWithInferredContext<parameters, bodyCode>;
+
+//===----------------------------------------------------------------------===//
+// Definitions
+//===----------------------------------------------------------------------===//
+
+// Define a new attribute or type, named `name`, that inherits from the given
+// C++ base class.
+class AttrOrTypeDef<string valueType, string name, list<Trait> defTraits,
+                    string baseCppClass> {
+  // The name of the C++ base class to use for this def.
+  string cppBaseClassName = baseCppClass;
+
+  // Additional, longer human-readable description of what the def does.
+  string description = "";
+
+  // Name of storage class to generate or use.
+  string storageClass = name # valueType # "Storage";
+
+  // Namespace (withing dialect c++ namespace) in which the storage class
+  // resides.
+  string storageNamespace = "detail";
+
+  // Specify if the storage class is to be generated.
+  bit genStorageClass = 1;
+
+  // Specify that the generated storage class has a constructor which is written
+  // in C++.
+  bit hasStorageCustomConstructor = 0;
+
+  // The list of parameters for this type. Parameters will become both
+  // parameters to the get() method and storage class member variables.
+  //
+  // The format of this dag is:
+  //    (ins
+  //        "<c++ type>":$param1Name,
+  //        "<c++ type>":$param2Name,
+  //        AttrOrTypeParameter<"c++ type", "param description">:$param3Name)
+  // AttrOrTypeParameters (or more likely one of their subclasses) are required
+  // to add more information about the parameter, specifically:
+  //  - Documentation
+  //  - Code to allocate the parameter (if allocation is needed in the storage
+  //    class constructor)
+  //
+  // For example:
+  //    (ins "int":$width,
+  //         ArrayRefParameter<"bool", "list of bools">:$yesNoArray)
+  //
+  // (ArrayRefParameter is a subclass of AttrOrTypeParameter which has
+  // allocation code for re-allocating ArrayRefs. It is defined below.)
+  dag parameters = (ins);
+
+  // Custom builder methods.
+  // In addition to the custom builders provided here, and unless
+  // skipDefaultBuilders is set, a default builder is generated with the
+  // following signature:
+  //
+  // ```c++
+  // static <ClassName> get(MLIRContext *, <parameters>);
+  // ```
+  //
+  // Note that builders should only be provided when a def has parameters.
+  list<AttrOrTypeBuilder> builders = ?;
+
+  // The list of traits attached to this def.
+  list<Trait> traits = defTraits;
+
+  // Use the lowercased name as the keyword for parsing/printing. Specify only
+  // if you want tblgen to generate declarations and/or definitions of
+  // the printer/parser.
+  string mnemonic = ?;
+
+  // If 'mnemonic' specified,
+  //   If null, generate just the declarations.
+  //   If a non-empty code block, just use that code as the definition code.
+  //   Error if an empty code block.
+  code printer = ?;
+  code parser = ?;
+
+  // Custom assembly format. Requires 'mnemonic' to be specified. Cannot be
+  // specified at the same time as either 'printer' or 'parser'. The generated
+  // printer requires 'genAccessors' to be true.
+  string assemblyFormat = ?;
+
+  // If set, generate accessors for each parameter.
+  bit genAccessors = 1;
+
+  // Avoid generating default get/getChecked functions. Custom get methods must
+  // be provided.
+  bit skipDefaultBuilders = 0;
+
+  // Generate the verify and getChecked methods.
+  bit genVerifyDecl = 0;
+
+  // Extra code to include in the class declaration.
+  code extraClassDeclaration = [{}];
+}
+
+// Define a new attribute, named `name`, belonging to `dialect` that inherits
+// from the given C++ base class.
+class AttrDef<Dialect dialect, string name, list<Trait> traits = [],
+              string baseCppClass = "::mlir::Attribute">
+    : DialectAttr<dialect, CPred<"">, /*descr*/"">,
+      AttrOrTypeDef<"Attr", name, traits, baseCppClass> {
+  // The name of the C++ Attribute class.
+  string cppClassName = name # "Attr";
+  let storageType = dialect.cppNamespace # "::" # name # "Attr";
+
+  // The underlying C++ value type
+  let returnType = dialect.cppNamespace # "::" # cppClassName;
+
+  // Make it possible to use such attributes as parameters for other attributes.
+  string cppType = dialect.cppNamespace # "::" # cppClassName;
+
+  // The call expression to convert from the storage type to the return
+  // type. For example, an enum can be stored as an int but returned as an
+  // enum class.
+  //
+  // Format: $_self will be expanded to the attribute.
+  //
+  // For example, `$_self.getValue().getSExtValue()` for `IntegerAttr val` will
+  // expand to `getAttrOfType<IntegerAttr>("val").getValue().getSExtValue()`.
+  let convertFromStorage = "$_self.cast<" # dialect.cppNamespace #
+                                 "::" # cppClassName # ">()";
+
+  // A code block used to build the value 'Type' of an Attribute when
+  // initializing its storage instance. This field is optional, and if not
+  // present the attribute will have its value type set to `NoneType`. This code
+  // block may reference any of the attributes parameters via
+  // `$_<parameter-name`. If one of the parameters of the attribute is of type
+  // `AttributeSelfTypeParameter`, this field is ignored.
+  code typeBuilder = ?;
+
+  // The predicate for when this def is used as a constraint.
+  let predicate = CPred<"$_self.isa<" # dialect.cppNamespace #
+                                 "::" # cppClassName # ">()">;
+}
+
+// Define a new type, named `name`, belonging to `dialect` that inherits from
+// the given C++ base class.
+class TypeDef<Dialect dialect, string name, list<Trait> traits = [],
+              string baseCppClass = "::mlir::Type">
+    : DialectType<dialect, CPred<"">, /*descr*/"", name # "Type">,
+      AttrOrTypeDef<"Type", name, traits, baseCppClass> {
+  // Make it possible to use such type as parameters for other types.
+  string cppType = dialect.cppNamespace # "::" # cppClassName;
+
+  // A constant builder provided when the type has no parameters.
+  let builderCall = !if(!empty(parameters),
+                           "$_builder.getType<" # dialect.cppNamespace #
+                               "::" # cppClassName # ">()",
+                           "");
+  // The predicate for when this def is used as a constraint.
+  let predicate = CPred<"$_self.isa<" # dialect.cppNamespace #
+                                 "::" # cppClassName # ">()">;
+}
+
+//===----------------------------------------------------------------------===//
+// Parameters
+//===----------------------------------------------------------------------===//
+
+// 'Parameters' should be subclasses of this or simple strings (which is a
+// shorthand for AttrOrTypeParameter<"C++Type">).
+class AttrOrTypeParameter<string type, string desc, string accessorType = ""> {
+  // Custom memory allocation code for storage constructor.
+  code allocator = ?;
+  // Comparator used to compare two instances for equality. By default, it uses
+  // the C++ equality operator.
+  code comparator = ?;
+  // The C++ type of this parameter.
+  string cppType = type;
+  // The C++ type of the accessor for this parameter.
+  string cppAccessorType = !if(!empty(accessorType), type, accessorType);
+  // The C++ storage type of of this parameter if it is a reference, e.g.
+  // `std::string` for `StringRef` or `SmallVector` for `ArrayRef`.
+  string cppStorageType = ?;
+  // One-line human-readable description of the argument.
+  string summary = desc;
+  // The format string for the asm syntax (documentation only).
+  string syntax = ?;
+  // The default parameter parser is `::mlir::FieldParser<T>::parse($_parser)`,
+  // which returns `FailureOr<T>`. Specialize `FieldParser` to support parsing
+  // for your type. Or you can provide a customer printer. For attributes,
+  // "$_type" will be replaced with the required attribute type.
+  string parser = ?;
+  // The default parameter printer is `$_printer << $_self`. Overload the stream
+  // operator of `AsmPrinter` as necessary to print your type. Or you can
+  // provide a custom printer.
+  string printer = ?;
+  // Mark a parameter as optional. The C++ type of parameters marked as optional
+  // must be default constructible and be contextually convertible to `bool`.
+  // Any `Optional<T>` and any attribute type satisfies these requirements.
+  bit isOptional = 0;
+  // Provide a default value for the parameter. Parameters with default values
+  // are considered optional. If a value was not parsed for the parameter, it
+  // will be set to the default value. Parameters equal to their default values
+  // are elided when printing. Equality is checked using the `comparator` field,
+  // which by default is the C++ equality operator. The current MLIR context is
+  // made available through `$_ctx`, e.g., for constructing default values for
+  // attributes and types.
+  string defaultValue = ?;
+}
+class AttrParameter<string type, string desc, string accessorType = "">
+ : AttrOrTypeParameter<type, desc, accessorType>;
+class TypeParameter<string type, string desc, string accessorType = "">
+ : AttrOrTypeParameter<type, desc, accessorType>;
+
+// For StringRefs, which require allocation.
+class StringRefParameter<string desc = ""> :
+    AttrOrTypeParameter<"::llvm::StringRef", desc> {
+  let allocator = [{$_dst = $_allocator.copyInto($_self);}];
+  let printer = [{$_printer << '"' << $_self << '"';}];
+  let cppStorageType = "std::string";
+}
+
+// For APFloats, which require comparison.
+class APFloatParameter<string desc> :
+    AttrOrTypeParameter<"::llvm::APFloat", desc> {
+  let comparator = "$_lhs.bitwiseIsEqual($_rhs)";
+}
+
+// For standard ArrayRefs, which require allocation.
+class ArrayRefParameter<string arrayOf, string desc = ""> :
+    AttrOrTypeParameter<"::llvm::ArrayRef<" # arrayOf # ">", desc> {
+  let allocator = [{$_dst = $_allocator.copyInto($_self);}];
+  let cppStorageType = "::llvm::SmallVector<" # arrayOf # ">";
+}
+
+// For classes which require allocation and have their own allocateInto method.
+class SelfAllocationParameter<string type, string desc> :
+    AttrOrTypeParameter<type, desc> {
+  let allocator = [{$_dst = $_self.allocateInto($_allocator);}];
+}
+
+// For ArrayRefs which contain things which allocate themselves.
+class ArrayRefOfSelfAllocationParameter<string arrayOf, string desc> :
+    AttrOrTypeParameter<"::llvm::ArrayRef<" # arrayOf # ">", desc> {
+  let allocator = [{
+    llvm::SmallVector<}] # arrayOf # [{, 4> tmpFields;
+    for (size_t i = 0, e = $_self.size(); i < e; ++i)
+      tmpFields.push_back($_self[i].allocateInto($_allocator));
+    $_dst = $_allocator.copyInto(ArrayRef<}] # arrayOf # [{>(tmpFields));
+  }];
+}
+
+// An optional parameter.
+class OptionalParameter<string type, string desc = ""> :
+    AttrOrTypeParameter<type, desc> {
+  let isOptional = 1;
+}
+
+// A parameter with a default value.
+class DefaultValuedParameter<string type, string value, string desc = ""> :
+    AttrOrTypeParameter<type, desc> {
+  let isOptional = 1;
+  let defaultValue = value;
+}
+
+// This is a special parameter used for AttrDefs that represents a `mlir::Type`
+// that is also used as the value `Type` of the attribute. Only one parameter
+// of the attribute may be of this type.
+class AttributeSelfTypeParameter<string desc,
+                                 string derivedType = "::mlir::Type"> :
+    AttrOrTypeParameter<derivedType, desc> {}
+
+#endif // ATTRTYPEBASE_TD

mlir/include/mlir/IR/BuiltinAttributes.td

 //===- BuiltinAttributes.td - Builtin attr definitions -----*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines the set of builtin MLIR types, or the set of types necessary for the
 // validity of and defining the IR.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef BUILTIN_ATTRIBUTES
 #define BUILTIN_ATTRIBUTES
 
+include "mlir/IR/AttrTypeBase.td"
 include "mlir/IR/BuiltinDialect.td"
 include "mlir/IR/BuiltinAttributeInterfaces.td"
 include "mlir/IR/SubElementInterfaces.td"
 
 // TODO: Currently the attributes defined in this file are prefixed with
 // `Builtin_`.  This is to differentiate the attributes here with the ones in
 // OpBase.td. We should remove the definitions in OpBase.td, and repoint users
 // to this file instead.

mlir/include/mlir/IR/BuiltinLocationAttributes.td

 //===- BuiltinLocationAttributes.td - Builtin Locations ----*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines the set of builtin MLIR location attributes.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef BUILTIN_LOCATION_ATTRIBUTES_TD
 #define BUILTIN_LOCATION_ATTRIBUTES_TD
 
+include "mlir/IR/AttrTypeBase.td"
 include "mlir/IR/BuiltinDialect.td"
 
 // Base class for Builtin dialect location attributes.
 class Builtin_LocationAttr<string name>
     : AttrDef<Builtin_Dialect, name, [], "::mlir::LocationAttr"> {
   let cppClassName = name;
   let mnemonic = ?;
 }

mlir/include/mlir/IR/BuiltinTypes.td

 //===- BuiltinTypes.td - Builtin type definitions ----------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines the set of builtin MLIR types, or the set of types necessary for the
 // validity of and defining the IR.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef BUILTIN_TYPES
 #define BUILTIN_TYPES
 
+include "mlir/IR/AttrTypeBase.td"
 include "mlir/IR/BuiltinDialect.td"
 include "mlir/IR/BuiltinTypeInterfaces.td"
 include "mlir/IR/SubElementInterfaces.td"
 
 // TODO: Currently the types defined in this file are prefixed with `Builtin_`.
 // This is to differentiate the types here with the ones in OpBase.td. We should
 // remove the definitions in OpBase.td, and repoint users to this file instead.
 

mlir/include/mlir/IR/EnumAttr.td

 //===-- EnumAttr.td - Enum attributes ----------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef ENUM_ATTR
-#define ENUM_ATTR
+#ifndef ENUMATTR_TD
+#define ENUMATTR_TD
 
-include "mlir/IR/OpBase.td"
+include "mlir/IR/AttrTypeBase.td"
 
 // A C++ enum as an attribute parameter. The parameter implements a parser and
 // printer for the enum by dispatching calls to `stringToSymbol` and
 // `symbolToString`.
 class EnumParameter<EnumAttrInfo enumInfo>
     : AttrParameter<enumInfo.cppNamespace # "::" # enumInfo.className,
                     "an enum of type " # enumInfo.className> {
   // Parse a keyword and pass it to `stringToSymbol`. Emit an error if a the
class EnumAttr<Dialect dialect, EnumAttrInfo enumInfo, string name = "",
   // If a mnemonic was provided, use it to generate a custom assembly format.
   let mnemonic = name;
 
   // The default assembly format for enum attributes. Selected to best work with
   // operation assembly formats.
   let assemblyFormat = "$value";
 }
 
-#endif // ENUM_ATTR
+#endif // ENUMATTR_TD

mlir/include/mlir/IR/OpBase.td

 
 // PredTrait is a trait implemented by way of a predicate on an entity.
 class PredTrait<string descr, Pred pred> : Trait {
   string summary = descr;
   Pred predicate = pred;
 }
 
 //===----------------------------------------------------------------------===//
-// TypeTrait definitions
-//===----------------------------------------------------------------------===//
-
-// These classes are used to define type specific traits.
-class NativeTypeTrait<string name> : NativeTrait<name, "Type">;
-class ParamNativeTypeTrait<string prop, string params>
-    : ParamNativeTrait<prop, params, "Type">;
-class GenInternalTypeTrait<string prop> : GenInternalTrait<prop, "Type">;
-class PredTypeTrait<string descr, Pred pred> : PredTrait<descr, pred>;
-
-//===----------------------------------------------------------------------===//
-// AttrTrait definitions
-//===----------------------------------------------------------------------===//
-
-// These classes are used to define attribute specific traits.
-class NativeAttrTrait<string name> : NativeTrait<name, "Attribute">;
-class ParamNativeAttrTrait<string prop, string params>
-    : ParamNativeTrait<prop, params, "Attribute">;
-class GenInternalAttrTrait<string prop> : GenInternalTrait<prop, "Attribute">;
-class PredAttrTrait<string descr, Pred pred> : PredTrait<descr, pred>;
-
-//===----------------------------------------------------------------------===//
 // OpTrait definitions
 //===----------------------------------------------------------------------===//
 
 // These classes are used to define operation specific traits.
 class NativeOpTrait<string name, list<Trait> traits = []>
     : NativeTrait<name, "Op"> {
   // Specify the list of traits that need to be verified before the verification
   // of this NativeOpTrait.

 }
 
 // The results of an op.
 class Results<dag rets> {
   dag results = rets;
 }
 
 //===----------------------------------------------------------------------===//
-// Common value constraints
-//===----------------------------------------------------------------------===//
-
-def HasNoUseOf: Constraint<
-    CPred<"$_self.use_empty()">, "has no use">;
-
-//===----------------------------------------------------------------------===//
 // Common op type constraints
 //===----------------------------------------------------------------------===//
 
 // These traits are for verifying properties of an op that require knowledge of
 // multiple arguments or results. For verifying properties of a single argument
 // or result, prefer operand type constraints.
 
 // These traits often require including "mlir/IR/TypeUtilities.h".

 // 1) all operands involved are of shaped type and
 // 2) the indices are not out of range.
 class TCopVTEtAreSameAt<list<int> indices> : CPred<
   "::llvm::is_splat(::llvm::map_range("
       "::mlir::ArrayRef<unsigned>({" # !interleave(indices, ", ") # "}), "
       "[this](unsigned i) { return getElementTypeOrSelf(this->getOperand(i)); "
       "}))">;
 
-//===----------------------------------------------------------------------===//
-// Pattern definitions
-//===----------------------------------------------------------------------===//
-
-// Marker used to identify the delta value added to the default benefit value.
-def addBenefit;
-
-// Base class for op+ -> op+ rewrite rules. These allow declaratively
-// specifying rewrite rules.
-//
-// A rewrite rule contains two components: a source pattern and one or more
-// result patterns. Each pattern is specified as a (recursive) DAG node (tree)
-// in the form of `(node arg0, arg1, ...)`.
-//
-// The `node` are normally MLIR ops, but it can also be one of the directives
-// listed later in this section.
-//
-// ## Symbol binding
-//
-// In the source pattern, `argN` can be used to specify matchers (e.g., using
-// type/attribute type constraints, etc.) and bound to a name for later use.
-// We can also bind names to op instances to reference them later in
-// multi-entity constraints. Operands in the source pattern can have
-// the same name. This bounds one operand to the name while verifying
-// the rest are all equal.
-//
-//
-// In the result pattern, `argN` can be used to refer to a previously bound
-// name, with potential transformations (e.g., using tAttr, etc.). `argN` can
-// itself be nested DAG node. We can also bound names to ops to reference
-// them later in other result patterns.
-//
-// For example,
-//
-// ```
-// def : Pattern<(OneResultOp1:$op1 $arg0, $arg1, $arg0),
-//               [(OneResultOp2:$op2 $arg0, $arg1),
-//                (OneResultOp3 $op2 (OneResultOp4))],
-//               [(HasStaticShapePred $op1)]>;
-// ```
-//
-// First `$arg0` and '$arg1' are bound to the `OneResultOp1`'s first
-// and second arguments and used later to build `OneResultOp2`. Second '$arg0'
-// is verified to be equal to the first '$arg0' operand.
-// `$op1` is bound to `OneResultOp1` and used to check whether the result's
-// shape is static. `$op2` is bound to `OneResultOp2` and used to
-// build `OneResultOp3`.
-//
-// ## Multi-result op
-//
-// To create multi-result ops in result pattern, you can use a syntax similar
-// to uni-result op, and it will act as a value pack for all results:
-//
-// ```
-// def : Pattern<(ThreeResultOp ...),
-//               [(TwoResultOp ...), (OneResultOp ...)]>;
-// ```
-//
-// Then `TwoResultOp` will replace the first two values of `ThreeResultOp`.
-//
-// You can also use `$<name>__N` to explicitly access the N-th result.
-// ```
-// def : Pattern<(FiveResultOp ...),
-//               [(TwoResultOp1:$res1__1 ...), (replaceWithValue $res1__0),
-//                (TwoResultOp2:$res2 ...), (replaceWithValue $res2__1)]>;
-// ```
-//
-// Then the values generated by `FiveResultOp` will be replaced by
-//
-// * `FiveResultOp`#0: `TwoResultOp1`#1
-// * `FiveResultOp`#1: `TwoResultOp1`#0
-// * `FiveResultOp`#2: `TwoResultOp2`#0
-// * `FiveResultOp`#3: `TwoResultOp2`#1
-// * `FiveResultOp`#4: `TwoResultOp2`#1
-class Pattern<dag source, list<dag> results, list<dag> preds = [],
-  dag benefitAdded = (addBenefit 0)> {
-  dag sourcePattern = source;
-  // Result patterns. Each result pattern is expected to replace one result
-  // of the root op in the source pattern. In the case of more result patterns
-  // than needed to replace the source op, only the last N results generated
-  // by the last N result pattern is used to replace a N-result source op.
-  // So that the beginning result patterns can be used to generate additional
-  // ops to aid building the results used for replacement.
-  list<dag> resultPatterns = results;
-  // Multi-entity constraints. Each constraint here involves multiple entities
-  // matched in source pattern and places further constraints on them as a
-  // whole.
-  list<dag> constraints = preds;
-  // The delta value added to the default benefit value. The default value is
-  // the number of ops in the source pattern. The rule with the highest final
-  // benefit value will be applied first if there are multiple rules matches.
-  // This delta value can be either positive or negative.
-  dag benefitDelta = benefitAdded;
-}
-
-// Form of a pattern which produces a single result.
-class Pat<dag pattern, dag result, list<dag> preds = [],
-  dag benefitAdded = (addBenefit 0)> :
-  Pattern<pattern, [result], preds, benefitAdded>;
-
-// Native code call wrapper. This allows invoking an arbitrary C++ expression
-// to create an op operand/attribute or replace an op result.
-//
-// ## Placeholders
-//
-// If used as a DAG leaf, i.e., `(... NativeCodeCall<"...">:$arg, ...)`,
-// the wrapped expression can take special placeholders listed below:
-//
-// * `$_builder` will be replaced by the current `mlir::PatternRewriter`.
-// * `$_self` will be replaced by the defining operation in a source pattern.
-//   E.g., `NativeCodeCall<"Foo($_self, &$0)> I32Attr:$attr)>`, `$_self` will be
-//   replaced with the defining operation of the first operand of OneArgOp.
-//
-// If used as a DAG node, i.e., `(NativeCodeCall<"..."> <arg0>, ..., <argN>)`,
-// then positional placeholders are also supported; placeholder `$N` in the
-// wrapped C++ expression will be replaced by `<argN>`.
-//
-// ## Bind multiple results
-//
-// To bind multi-results and access the N-th result with `$<name>__N`, specify
-// the number of return values in the template. Note that only `Value` type is
-// supported for multiple results binding.
-
-class NativeCodeCall<string expr, int returns = 1> {
-  string expression = expr;
-  int numReturns = returns;
-}
-
-class NativeCodeCallVoid<string expr> : NativeCodeCall<expr, 0>;
-
-def ConstantLikeMatcher : NativeCodeCall<"::mlir::success("
-    "::mlir::matchPattern($_self->getResult(0), ::mlir::m_Constant(&$0)))">;
-
-//===----------------------------------------------------------------------===//
-// Rewrite directives
-//===----------------------------------------------------------------------===//
-
-// Directive used in result pattern to indicate that no new op are generated,
-// so to replace the matched DAG with an existing SSA value.
-def replaceWithValue;
-
-// Directive used in result patterns to specify the location of the generated
-// op. This directive must be used as a trailing argument to op creation or
-// native code calls.
-//
-// Usage:
-// * Create a named location: `(location "myLocation")`
-// * Copy the location of a captured symbol: `(location $arg)`
-// * Create a fused location: `(location "metadata", $arg0, $arg1)`
-
-def location;
-
-// Directive used in result patterns to specify return types for a created op.
-// This allows ops to be created without relying on type inference with
-// `OpTraits` or an op builder with deduction.
-//
-// This directive must be used as a trailing argument to op creation.
-//
-// Specify one return type with a string literal:
-//
-// ```
-// (AnOp $val, (returnType "$_builder.getI32Type()"))
-// ```
-//
-// Pass a captured value to copy its return type:
-//
-// ```
-// (AnOp $val, (returnType $val));
-// ```
-//
-// Pass a native code call inside a DAG to create a new type with arguments.
-//
-// ```
-// (AnOp $val,
-//       (returnType (NativeCodeCall<"$_builder.getTupleType({$0})"> $val)));
-// ```
-//
-// Specify multiple return types with multiple of any of the above.
-
-def returnType;
-
-// Directive used to specify the operands may be matched in either order. When
-// two adjacents are marked with `either`, it'll try to match the operands in
-// either ordering of constraints. Example:
-//
-// ```
-// (TwoArgOp (either $firstArg, (AnOp $secondArg)))
-// ```
-// The above pattern will accept either `"test.TwoArgOp"(%I32Arg, %AnOpArg)` and
-// `"test.TwoArgOp"(%AnOpArg, %I32Arg)`.
-//
-// Only operand is supported with `either` and note that an operation with
-// `Commutative` trait doesn't imply that it'll have the same behavior than
-// `either` while pattern matching.
-def either;
-
-//===----------------------------------------------------------------------===//
-// Attribute and Type generation
-//===----------------------------------------------------------------------===//
-
-// Class for defining a custom getter.
-//
-// TableGen generates several generic getter methods for each attribute and type
-// by default, corresponding to the specified dag parameters. If the default
-// generated ones cannot cover some use case, custom getters can be defined
-// using instances of this class.
-//
-// The signature of the `get` is always either:
-//
-// ```c++
-// static <ClassName> get(MLIRContext *context, <other-parameters>...) {
-//   <body>...
-// }
-// ```
-//
-// or:
-//
-// ```c++
-// static <ClassName> get(MLIRContext *context, <parameters>...);
-// ```
-//
-// To define a custom getter, the parameter list and body should be passed
-// in as separate template arguments to this class. The parameter list is a
-// TableGen DAG with `ins` operation with named arguments, which has either:
-//   - string initializers ("Type":$name) to represent a typed parameter, or
-//   - CArg-typed initializers (CArg<"Type", "default">:$name) to represent a
-//     typed parameter that may have a default value.
-// The type string is used verbatim to produce code and, therefore, must be a
-// valid C++ type. It is used inside the C++ namespace of the parent Type's
-// dialect; explicit namespace qualification like `::mlir` may be necessary if
-// Types are not placed inside the `mlir` namespace. The default value string is
-// used verbatim to produce code and must be a valid C++ initializer the given
-// type. For example, the following signature specification
-//
-// ```
-// AttrOrTypeBuilder<(ins "int":$integerArg, CArg<"float", "3.0f">:$floatArg)>
-// ```
-//
-// has an integer parameter and a float parameter with a default value.
-//
-// If an empty string is passed in for `body`, then *only* the builder
-// declaration will be generated; this provides a way to define complicated
-// builders entirely in C++. If a `body` string is provided, the `Base::get`
-// method should be invoked using `$_get`, e.g.:
-//
-// ```
-// AttrOrTypeBuilder<(ins "int":$integerArg, CArg<"float", "3.0f">:$floatArg), [{
-//   return $_get($_ctxt, integerArg, floatArg);
-// }]>
-// ```
-//
-// This is necessary because the `body` is also used to generate `getChecked`
-// methods, which have a different underlying `Base::get*` call.
-//
-class AttrOrTypeBuilder<dag parameters, code bodyCode = ""> {
-  dag dagParams = parameters;
-  code body = bodyCode;
-
-  // The context parameter can be inferred from one of the other parameters and
-  // is not implicitly added to the parameter list.
-  bit hasInferredContextParam = 0;
-}
-class AttrBuilder<dag parameters, code bodyCode = "">
-  : AttrOrTypeBuilder<parameters, bodyCode>;
-class TypeBuilder<dag parameters, code bodyCode = "">
-  : AttrOrTypeBuilder<parameters, bodyCode>;
-
-// A class of AttrOrTypeBuilder that is able to infer the MLIRContext parameter
-// from one of the other builder parameters. Instances of this builder do not
-// have `MLIRContext *` implicitly added to the parameter list.
-class AttrOrTypeBuilderWithInferredContext<dag parameters, code bodyCode = "">
-  : TypeBuilder<parameters, bodyCode> {
-  let hasInferredContextParam = 1;
-}
-class AttrBuilderWithInferredContext<dag parameters, code bodyCode = "">
-  : AttrOrTypeBuilderWithInferredContext<parameters, bodyCode>;
-class TypeBuilderWithInferredContext<dag parameters, code bodyCode = "">
-  : AttrOrTypeBuilderWithInferredContext<parameters, bodyCode>;
-
-// Define a new attribute or type, named `name`, that inherits from the given
-// C++ base class.
-class AttrOrTypeDef<string valueType, string name, list<Trait> defTraits,
-                    string baseCppClass> {
-  // The name of the C++ base class to use for this def.
-  string cppBaseClassName = baseCppClass;
-
-  // Additional, longer human-readable description of what the def does.
-  string description = "";
-
-  // Name of storage class to generate or use.
-  string storageClass = name # valueType # "Storage";
-
-  // Namespace (withing dialect c++ namespace) in which the storage class
-  // resides.
-  string storageNamespace = "detail";
-
-  // Specify if the storage class is to be generated.
-  bit genStorageClass = 1;
-
-  // Specify that the generated storage class has a constructor which is written
-  // in C++.
-  bit hasStorageCustomConstructor = 0;
-
-  // The list of parameters for this type. Parameters will become both
-  // parameters to the get() method and storage class member variables.
-  //
-  // The format of this dag is:
-  //    (ins
-  //        "<c++ type>":$param1Name,
-  //        "<c++ type>":$param2Name,
-  //        AttrOrTypeParameter<"c++ type", "param description">:$param3Name)
-  // AttrOrTypeParameters (or more likely one of their subclasses) are required
-  // to add more information about the parameter, specifically:
-  //  - Documentation
-  //  - Code to allocate the parameter (if allocation is needed in the storage
-  //    class constructor)
-  //
-  // For example:
-  //    (ins "int":$width,
-  //         ArrayRefParameter<"bool", "list of bools">:$yesNoArray)
-  //
-  // (ArrayRefParameter is a subclass of AttrOrTypeParameter which has
-  // allocation code for re-allocating ArrayRefs. It is defined below.)
-  dag parameters = (ins);
-
-  // Custom builder methods.
-  // In addition to the custom builders provided here, and unless
-  // skipDefaultBuilders is set, a default builder is generated with the
-  // following signature:
-  //
-  // ```c++
-  // static <ClassName> get(MLIRContext *, <parameters>);
-  // ```
-  //
-  // Note that builders should only be provided when a def has parameters.
-  list<AttrOrTypeBuilder> builders = ?;
-
-  // The list of traits attached to this def.
-  list<Trait> traits = defTraits;
-
-  // Use the lowercased name as the keyword for parsing/printing. Specify only
-  // if you want tblgen to generate declarations and/or definitions of
-  // the printer/parser.
-  string mnemonic = ?;
-
-  // If 'mnemonic' specified,
-  //   If null, generate just the declarations.
-  //   If a non-empty code block, just use that code as the definition code.
-  //   Error if an empty code block.
-  code printer = ?;
-  code parser = ?;
-
-  // Custom assembly format. Requires 'mnemonic' to be specified. Cannot be
-  // specified at the same time as either 'printer' or 'parser'. The generated
-  // printer requires 'genAccessors' to be true.
-  string assemblyFormat = ?;
-
-  // If set, generate accessors for each parameter.
-  bit genAccessors = 1;
-
-  // Avoid generating default get/getChecked functions. Custom get methods must
-  // be provided.
-  bit skipDefaultBuilders = 0;
-
-  // Generate the verify and getChecked methods.
-  bit genVerifyDecl = 0;
-
-  // Extra code to include in the class declaration.
-  code extraClassDeclaration = [{}];
-}
-
-// Define a new attribute, named `name`, belonging to `dialect` that inherits
-// from the given C++ base class.
-class AttrDef<Dialect dialect, string name, list<Trait> traits = [],
-              string baseCppClass = "::mlir::Attribute">
-    : DialectAttr<dialect, CPred<"">, /*descr*/"">,
-      AttrOrTypeDef<"Attr", name, traits, baseCppClass> {
-  // The name of the C++ Attribute class.
-  string cppClassName = name # "Attr";
-  let storageType = dialect.cppNamespace # "::" # name # "Attr";
-
-  // The underlying C++ value type
-  let returnType = dialect.cppNamespace # "::" # cppClassName;
-
-  // Make it possible to use such attributes as parameters for other attributes.
-  string cppType = dialect.cppNamespace # "::" # cppClassName;
-
-  // The call expression to convert from the storage type to the return
-  // type. For example, an enum can be stored as an int but returned as an
-  // enum class.
-  //
-  // Format: $_self will be expanded to the attribute.
-  //
-  // For example, `$_self.getValue().getSExtValue()` for `IntegerAttr val` will
-  // expand to `getAttrOfType<IntegerAttr>("val").getValue().getSExtValue()`.
-  let convertFromStorage = "$_self.cast<" # dialect.cppNamespace #
-                                 "::" # cppClassName # ">()";
-
-  // A code block used to build the value 'Type' of an Attribute when
-  // initializing its storage instance. This field is optional, and if not
-  // present the attribute will have its value type set to `NoneType`. This code
-  // block may reference any of the attributes parameters via
-  // `$_<parameter-name`. If one of the parameters of the attribute is of type
-  // `AttributeSelfTypeParameter`, this field is ignored.
-  code typeBuilder = ?;
-
-  // The predicate for when this def is used as a constraint.
-  let predicate = CPred<"$_self.isa<" # dialect.cppNamespace #
-                                 "::" # cppClassName # ">()">;
-}
-
-// Define a new type, named `name`, belonging to `dialect` that inherits from
-// the given C++ base class.
-class TypeDef<Dialect dialect, string name, list<Trait> traits = [],
-              string baseCppClass = "::mlir::Type">
-    : DialectType<dialect, CPred<"">, /*descr*/"", name # "Type">,
-      AttrOrTypeDef<"Type", name, traits, baseCppClass> {
-  // Make it possible to use such type as parameters for other types.
-  string cppType = dialect.cppNamespace # "::" # cppClassName;
-
-  // A constant builder provided when the type has no parameters.
-  let builderCall = !if(!empty(parameters),
-                           "$_builder.getType<" # dialect.cppNamespace #
-                               "::" # cppClassName # ">()",
-                           "");
-  // The predicate for when this def is used as a constraint.
-  let predicate = CPred<"$_self.isa<" # dialect.cppNamespace #
-                                 "::" # cppClassName # ">()">;
-}
-
-// 'Parameters' should be subclasses of this or simple strings (which is a
-// shorthand for AttrOrTypeParameter<"C++Type">).
-class AttrOrTypeParameter<string type, string desc, string accessorType = ""> {
-  // Custom memory allocation code for storage constructor.
-  code allocator = ?;
-  // Comparator used to compare two instances for equality. By default, it uses
-  // the C++ equality operator.
-  code comparator = ?;
-  // The C++ type of this parameter.
-  string cppType = type;
-  // The C++ type of the accessor for this parameter.
-  string cppAccessorType = !if(!empty(accessorType), type, accessorType);
-  // The C++ storage type of of this parameter if it is a reference, e.g.
-  // `std::string` for `StringRef` or `SmallVector` for `ArrayRef`.
-  string cppStorageType = ?;
-  // One-line human-readable description of the argument.
-  string summary = desc;
-  // The format string for the asm syntax (documentation only).
-  string syntax = ?;
-  // The default parameter parser is `::mlir::FieldParser<T>::parse($_parser)`,
-  // which returns `FailureOr<T>`. Specialize `FieldParser` to support parsing
-  // for your type. Or you can provide a customer printer. For attributes,
-  // "$_type" will be replaced with the required attribute type.
-  string parser = ?;
-  // The default parameter printer is `$_printer << $_self`. Overload the stream
-  // operator of `AsmPrinter` as necessary to print your type. Or you can
-  // provide a custom printer.
-  string printer = ?;
-  // Mark a parameter as optional. The C++ type of parameters marked as optional
-  // must be default constructible and be contextually convertible to `bool`.
-  // Any `Optional<T>` and any attribute type satisfies these requirements.
-  bit isOptional = 0;
-  // Provide a default value for the parameter. Parameters with default values
-  // are considered optional. If a value was not parsed for the parameter, it
-  // will be set to the default value. Parameters equal to their default values
-  // are elided when printing. Equality is checked using the `comparator` field,
-  // which by default is the C++ equality operator. The current MLIR context is
-  // made available through `$_ctx`, e.g., for constructing default values for
-  // attributes and types.
-  string defaultValue = ?;
-}
-class AttrParameter<string type, string desc, string accessorType = "">
- : AttrOrTypeParameter<type, desc, accessorType>;
-class TypeParameter<string type, string desc, string accessorType = "">
- : AttrOrTypeParameter<type, desc, accessorType>;
-
-// For StringRefs, which require allocation.
-class StringRefParameter<string desc = ""> :
-    AttrOrTypeParameter<"::llvm::StringRef", desc> {
-  let allocator = [{$_dst = $_allocator.copyInto($_self);}];
-  let printer = [{$_printer << '"' << $_self << '"';}];
-  let cppStorageType = "std::string";
-}
-
-// For APFloats, which require comparison.
-class APFloatParameter<string desc> :
-    AttrOrTypeParameter<"::llvm::APFloat", desc> {
-  let comparator = "$_lhs.bitwiseIsEqual($_rhs)";
-}
-
-// For standard ArrayRefs, which require allocation.
-class ArrayRefParameter<string arrayOf, string desc = ""> :
-    AttrOrTypeParameter<"::llvm::ArrayRef<" # arrayOf # ">", desc> {
-  let allocator = [{$_dst = $_allocator.copyInto($_self);}];
-  let cppStorageType = "::llvm::SmallVector<" # arrayOf # ">";
-}
-
-// For classes which require allocation and have their own allocateInto method.
-class SelfAllocationParameter<string type, string desc> :
-    AttrOrTypeParameter<type, desc> {
-  let allocator = [{$_dst = $_self.allocateInto($_allocator);}];
-}
-
-// For ArrayRefs which contain things which allocate themselves.
-class ArrayRefOfSelfAllocationParameter<string arrayOf, string desc> :
-    AttrOrTypeParameter<"::llvm::ArrayRef<" # arrayOf # ">", desc> {
-  let allocator = [{
-    llvm::SmallVector<}] # arrayOf # [{, 4> tmpFields;
-    for (size_t i = 0, e = $_self.size(); i < e; ++i)
-      tmpFields.push_back($_self[i].allocateInto($_allocator));
-    $_dst = $_allocator.copyInto(ArrayRef<}] # arrayOf # [{>(tmpFields));
-  }];
-}
-
-// An optional parameter.
-class OptionalParameter<string type, string desc = ""> :
-    AttrOrTypeParameter<type, desc> {
-  let isOptional = 1;
-}
-
-// A parameter with a default value.
-class DefaultValuedParameter<string type, string value, string desc = ""> :
-    AttrOrTypeParameter<type, desc> {
-  let isOptional = 1;
-  let defaultValue = value;
-}
-
-// This is a special parameter used for AttrDefs that represents a `mlir::Type`
-// that is also used as the value `Type` of the attribute. Only one parameter
-// of the attribute may be of this type.
-class AttributeSelfTypeParameter<string desc,
-                                 string derivedType = "::mlir::Type"> :
-    AttrOrTypeParameter<derivedType, desc> {}
-
 #endif // OP_BASE

mlir/include/mlir/IR/PatternBase.td

+//===-- PatternBase.td - Base pattern definition file ------*- 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 files contains all of the base constructs for defining DRR patterns.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef PATTERNBASE_TD
+#define PATTERNBASE_TD
+
+include "mlir/IR/OpBase.td"
+
+//===----------------------------------------------------------------------===//
+// Pattern definitions
+//===----------------------------------------------------------------------===//
+
+// Marker used to identify the delta value added to the default benefit value.
+def addBenefit;
+
+// Base class for op+ -> op+ rewrite rules. These allow declaratively
+// specifying rewrite rules.
+//
+// A rewrite rule contains two components: a source pattern and one or more
+// result patterns. Each pattern is specified as a (recursive) DAG node (tree)
+// in the form of `(node arg0, arg1, ...)`.
+//
+// The `node` are normally MLIR ops, but it can also be one of the directives
+// listed later in this section.
+//
+// ## Symbol binding
+//
+// In the source pattern, `argN` can be used to specify matchers (e.g., using
+// type/attribute type constraints, etc.) and bound to a name for later use.
+// We can also bind names to op instances to reference them later in
+// multi-entity constraints. Operands in the source pattern can have
+// the same name. This bounds one operand to the name while verifying
+// the rest are all equal.
+//
+//
+// In the result pattern, `argN` can be used to refer to a previously bound
+// name, with potential transformations (e.g., using tAttr, etc.). `argN` can
+// itself be nested DAG node. We can also bound names to ops to reference
+// them later in other result patterns.
+//
+// For example,
+//
+// ```
+// def : Pattern<(OneResultOp1:$op1 $arg0, $arg1, $arg0),
+//               [(OneResultOp2:$op2 $arg0, $arg1),
+//                (OneResultOp3 $op2 (OneResultOp4))],
+//               [(HasStaticShapePred $op1)]>;
+// ```
+//
+// First `$arg0` and '$arg1' are bound to the `OneResultOp1`'s first
+// and second arguments and used later to build `OneResultOp2`. Second '$arg0'
+// is verified to be equal to the first '$arg0' operand.
+// `$op1` is bound to `OneResultOp1` and used to check whether the result's
+// shape is static. `$op2` is bound to `OneResultOp2` and used to
+// build `OneResultOp3`.
+//
+// ## Multi-result op
+//
+// To create multi-result ops in result pattern, you can use a syntax similar
+// to uni-result op, and it will act as a value pack for all results:
+//
+// ```
+// def : Pattern<(ThreeResultOp ...),
+//               [(TwoResultOp ...), (OneResultOp ...)]>;
+// ```
+//
+// Then `TwoResultOp` will replace the first two values of `ThreeResultOp`.
+//
+// You can also use `$<name>__N` to explicitly access the N-th result.
+// ```
+// def : Pattern<(FiveResultOp ...),
+//               [(TwoResultOp1:$res1__1 ...), (replaceWithValue $res1__0),
+//                (TwoResultOp2:$res2 ...), (replaceWithValue $res2__1)]>;
+// ```
+//
+// Then the values generated by `FiveResultOp` will be replaced by
+//
+// * `FiveResultOp`#0: `TwoResultOp1`#1
+// * `FiveResultOp`#1: `TwoResultOp1`#0
+// * `FiveResultOp`#2: `TwoResultOp2`#0
+// * `FiveResultOp`#3: `TwoResultOp2`#1
+// * `FiveResultOp`#4: `TwoResultOp2`#1
+class Pattern<dag source, list<dag> results, list<dag> preds = [],
+  dag benefitAdded = (addBenefit 0)> {
+  dag sourcePattern = source;
+  // Result patterns. Each result pattern is expected to replace one result
+  // of the root op in the source pattern. In the case of more result patterns
+  // than needed to replace the source op, only the last N results generated
+  // by the last N result pattern is used to replace a N-result source op.
+  // So that the beginning result patterns can be used to generate additional
+  // ops to aid building the results used for replacement.
+  list<dag> resultPatterns = results;
+  // Multi-entity constraints. Each constraint here involves multiple entities
+  // matched in source pattern and places further constraints on them as a
+  // whole.
+  list<dag> constraints = preds;
+  // The delta value added to the default benefit value. The default value is
+  // the number of ops in the source pattern. The rule with the highest final
+  // benefit value will be applied first if there are multiple rules matches.
+  // This delta value can be either positive or negative.
+  dag benefitDelta = benefitAdded;
+}
+
+// Form of a pattern which produces a single result.
+class Pat<dag pattern, dag result, list<dag> preds = [],
+  dag benefitAdded = (addBenefit 0)> :
+  Pattern<pattern, [result], preds, benefitAdded>;
+
+// Native code call wrapper. This allows invoking an arbitrary C++ expression
+// to create an op operand/attribute or replace an op result.
+//
+// ## Placeholders
+//
+// If used as a DAG leaf, i.e., `(... NativeCodeCall<"...">:$arg, ...)`,
+// the wrapped expression can take special placeholders listed below:
+//
+// * `$_builder` will be replaced by the current `mlir::PatternRewriter`.
+// * `$_self` will be replaced by the defining operation in a source pattern.
+//   E.g., `NativeCodeCall<"Foo($_self, &$0)> I32Attr:$attr)>`, `$_self` will be
+//   replaced with the defining operation of the first operand of OneArgOp.
+//
+// If used as a DAG node, i.e., `(NativeCodeCall<"..."> <arg0>, ..., <argN>)`,
+// then positional placeholders are also supported; placeholder `$N` in the
+// wrapped C++ expression will be replaced by `<argN>`.
+//
+// ## Bind multiple results
+//
+// To bind multi-results and access the N-th result with `$<name>__N`, specify
+// the number of return values in the template. Note that only `Value` type is
+// supported for multiple results binding.
+
+class NativeCodeCall<string expr, int returns = 1> {
+  string expression = expr;
+  int numReturns = returns;
+}
+
+class NativeCodeCallVoid<string expr> : NativeCodeCall<expr, 0>;
+
+def ConstantLikeMatcher : NativeCodeCall<"::mlir::success("
+    "::mlir::matchPattern($_self->getResult(0), ::mlir::m_Constant(&$0)))">;
+
+//===----------------------------------------------------------------------===//
+// Rewrite directives
+//===----------------------------------------------------------------------===//
+
+// Directive used in result pattern to indicate that no new op are generated,
+// so to replace the matched DAG with an existing SSA value.
+def replaceWithValue;
+
+// Directive used in result patterns to specify the location of the generated
+// op. This directive must be used as a trailing argument to op creation or
+// native code calls.
+//
+// Usage:
+// * Create a named location: `(location "myLocation")`
+// * Copy the location of a captured symbol: `(location $arg)`
+// * Create a fused location: `(location "metadata", $arg0, $arg1)`
+
+def location;
+
+// Directive used in result patterns to specify return types for a created op.
+// This allows ops to be created without relying on type inference with
+// `OpTraits` or an op builder with deduction.
+//
+// This directive must be used as a trailing argument to op creation.
+//
+// Specify one return type with a string literal:
+//
+// ```
+// (AnOp $val, (returnType "$_builder.getI32Type()"))
+// ```
+//
+// Pass a captured value to copy its return type:
+//
+// ```
+// (AnOp $val, (returnType $val));
+// ```
+//
+// Pass a native code call inside a DAG to create a new type with arguments.
+//
+// ```
+// (AnOp $val,
+//       (returnType (NativeCodeCall<"$_builder.getTupleType({$0})"> $val)));
+// ```
+//
+// Specify multiple return types with multiple of any of the above.
+
+def returnType;
+
+// Directive used to specify the operands may be matched in either order. When
+// two adjacents are marked with `either`, it'll try to match the operands in
+// either ordering of constraints. Example:
+//
+// ```
+// (TwoArgOp (either $firstArg, (AnOp $secondArg)))
+// ```
+// The above pattern will accept either `"test.TwoArgOp"(%I32Arg, %AnOpArg)` and
+// `"test.TwoArgOp"(%AnOpArg, %I32Arg)`.
+//
+// Only operand is supported with `either` and note that an operation with
+// `Commutative` trait doesn't imply that it'll have the same behavior than
+// `either` while pattern matching.
+def either;
+
+//===----------------------------------------------------------------------===//
+// Common value constraints
+//===----------------------------------------------------------------------===//
+
+def HasNoUseOf: Constraint<
+    CPred<"$_self.use_empty()">, "has no use">;
+
+#endif // PATTERNBASE_TD

mlir/lib/Conversion/GPUToNVVM/GPUToNVVM.td

 //==-- GPUToNVVM.td - GPU Ops to NVVM Patterns ---------------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines Patterns to lower GPU ops to NVVM.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_CONVERSION_GPUTONVVM_TD
 #define MLIR_CONVERSION_GPUTONVVM_TD
 
+include "mlir/IR/PatternBase.td"
 include "mlir/Dialect/GPU/GPUOps.td"
 include "mlir/Dialect/LLVMIR/NVVMOps.td"
 
 def : Pat<(GPU_BarrierOp), (NVVM_Barrier0Op)>;
 
 #endif // MLIR_CONVERSION_GPUTONVVM_TD

mlir/lib/Conversion/GPUToROCDL/GPUToROCDL.td

 //==-- GPUToROCDL.td - GPU Ops to ROCDL Patterns -------------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines Patterns to lower GPU ops to ROCDL.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_CONVERSION_GPUTOROCDL_TD
 #define MLIR_CONVERSION_GPUTOROCDL_TD
 
+include "mlir/IR/PatternBase.td"
 include "mlir/Dialect/GPU/GPUOps.td"
 include "mlir/Dialect/LLVMIR/ROCDLOps.td"
 
 def : Pat<(GPU_BarrierOp), (ROCDL_BarrierOp)>;
 
 #endif // MLIR_CONVERSION_GPUTOROCDL_TD

mlir/lib/Conversion/ShapeToStandard/ShapeToStandard.td

 //==-- ShapeToStandard.td - Shape to Standard Patterns -------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines Patterns to lower Shape ops to Std.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_CONVERSION_SHAPETOSTANDARD_TD
 #define MLIR_CONVERSION_SHAPETOSTANDARD_TD
 
+include "mlir/IR/PatternBase.td"
 include "mlir/Dialect/Shape/IR/ShapeOps.td"
 
 def BroadcastableStringAttr : NativeCodeCall<[{
   $_builder.getStringAttr("required broadcastable shapes")
 }]>;
 
 def CstrBroadcastableToRequire : Pat<(Shape_CstrBroadcastableOp $shapes),
             (Shape_CstrRequireOp

mlir/lib/Dialect/Arithmetic/IR/ArithmeticCanonicalization.td

 //===- ArithmeticPatterns.td - Arithmetic dialect patterns -*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef ARITHMETIC_PATTERNS
 #define ARITHMETIC_PATTERNS
 
+include "mlir/IR/PatternBase.td"
 include "mlir/Dialect/Arithmetic/IR/ArithmeticOps.td"
 
 // Add two integer attributes and create a new one with the result.
 def AddIntAttrs : NativeCodeCall<"addIntegerAttrs($_builder, $0, $1, $2)">;
 
 // Subtract two integer attributes and createa a new one with the result.
 def SubIntAttrs : NativeCodeCall<"subIntegerAttrs($_builder, $0, $1, $2)">;
 

mlir/lib/Dialect/SPIRV/IR/SPIRVCanonicalization.td

 //==- SPIRVCanonicalization.td - Canonicalization Patterns ---*- 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 file defines SPIR-V canonicalization patterns.
 //
 //===----------------------------------------------------------------------===//
 
+include "mlir/IR/PatternBase.td"
 include "mlir/Dialect/SPIRV/IR/SPIRVOps.td"
 
 //===----------------------------------------------------------------------===//
 // spv.Bitcast
 //===----------------------------------------------------------------------===//
 
 def ConvertChainedBitcast : Pat<(SPV_BitcastOp (SPV_BitcastOp $operand)),
                                 (SPV_BitcastOp $operand)>;

mlir/lib/Dialect/Shape/IR/ShapeCanonicalization.td

+include "mlir/IR/PatternBase.td"
 include "mlir/Dialect/Shape/IR/ShapeOps.td"
 include "mlir/Dialect/Tensor/IR/TensorOps.td"
 
 def AllInputShapesEq : Constraint<CPred< [{
   llvm::all_of($0, [&](mlir::Value val) {
     return $0[0] == val;
   })
 }]>>;

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

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef TEST_ATTRDEFS
 #define TEST_ATTRDEFS
 
 // To get the test dialect definition.
 include "TestDialect.td"
+include "mlir/IR/AttrTypeBase.td"
 include "mlir/IR/BuiltinAttributeInterfaces.td"
 include "mlir/IR/SubElementInterfaces.td"
 
 // All of the attributes will extend this class.
 class Test_Attr<string name, list<Trait> traits = []>
     : AttrDef<Test_Dialect, name, traits>;
 
 def SimpleAttrA : Test_Attr<"SimpleA"> {

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

 //===-- TestOps.td - Test dialect operation definitions ----*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef TEST_OPS
 #define TEST_OPS
 
 include "TestDialect.td"
 include "mlir/Dialect/DLTI/DLTIBase.td"
 include "mlir/IR/EnumAttr.td"
 include "mlir/IR/OpBase.td"
 include "mlir/IR/OpAsmInterface.td"
+include "mlir/IR/PatternBase.td"
 include "mlir/IR/RegionKindInterface.td"
 include "mlir/IR/SymbolInterfaces.td"
 include "mlir/Interfaces/CallInterfaces.td"
 include "mlir/Interfaces/ControlFlowInterfaces.td"
 include "mlir/Interfaces/CopyOpInterface.td"
 include "mlir/Interfaces/DataLayoutInterfaces.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"

mlir/test/mlir-tblgen/attr-or-type-format-invalid.td

 // RUN: mlir-tblgen -gen-typedef-defs -I %S/../../include -asmformat-error-is-fatal=false %s 2>&1 | FileCheck %s
 
+include "mlir/IR/AttrTypeBase.td"
 include "mlir/IR/OpBase.td"
 
 def Test_Dialect : Dialect {
   let name = "TestDialect";
   let cppNamespace = "::test";
 }
 
 class InvalidType<string name, string asm> : TypeDef<Test_Dialect, name> {

mlir/test/mlir-tblgen/attr-or-type-format.td

 // RUN: mlir-tblgen -gen-attrdef-defs -I %S/../../include %s | FileCheck %s --check-prefix=ATTR
 // RUN: mlir-tblgen -gen-typedef-defs -I %S/../../include %s | FileCheck %s --check-prefix=TYPE
 
+include "mlir/IR/AttrTypeBase.td"
 include "mlir/IR/OpBase.td"
 
 /// Test that attribute and type printers and parsers are correctly generated.
 def Test_Dialect : Dialect {
   let name = "TestDialect";
   let cppNamespace = "::test";
   let useDefaultTypePrinterParser = 0;
 }

mlir/test/mlir-tblgen/attrdefs.td

 // RUN: mlir-tblgen -gen-attrdef-decls -I %S/../../include %s | FileCheck %s --check-prefix=DECL
 // RUN: mlir-tblgen -gen-attrdef-defs -I %S/../../include %s | FileCheck %s --check-prefix=DEF
 
+include "mlir/IR/AttrTypeBase.td"
 include "mlir/IR/OpBase.td"
 
 // DECL: #ifdef GET_ATTRDEF_CLASSES
 // DECL: #undef GET_ATTRDEF_CLASSES
 
 // DECL: namespace mlir {
 // DECL: class AsmParser;
 // DECL: class AsmPrinter;

mlir/test/mlir-tblgen/default-type-attr-print-parser.td

 // RUN: mlir-tblgen -gen-attrdef-defs -I %S/../../include %s | FileCheck %s --check-prefix=ATTR
 // RUN: mlir-tblgen -gen-typedef-defs -I %S/../../include %s | FileCheck %s --check-prefix=TYPE
 
+include "mlir/IR/AttrTypeBase.td"
 include "mlir/IR/OpBase.td"
 
 /// Test that attribute and type printers and parsers are correctly generated.
 def Test_Dialect : Dialect {
   let name = "TestDialect";
   let cppNamespace = "::test";
 
   let useDefaultAttributePrinterParser = 1;

mlir/test/mlir-tblgen/expect-symbol.td

 // RUN: not mlir-tblgen -gen-rewriters -I %S/../../include %s 2>&1 | FileCheck %s
 
 include "mlir/IR/OpBase.td"
+include "mlir/IR/PatternBase.td"
 
 def Test_Dialect : Dialect {
   let name = "test";
 }
 
 def OpA : Op<Test_Dialect, "a"> {
   let arguments = (ins I32Attr:$attr);
 }
 def OpB : Op<Test_Dialect, "b"> {
   let arguments = (ins I32Attr:$attr);
 }
 
 def : Pat<(OpA $attr), (OpB $attr),
           // CHECK: operands to additional constraints can only be symbol references
           [(Constraint<CPred<"$0->getValue() == $1">> $attr, 42)]>;

mlir/test/mlir-tblgen/op-attribute.td

 // RUN: mlir-tblgen -gen-op-decls -I %S/../../include %s | FileCheck %s --check-prefix=DECL
 // RUN: mlir-tblgen -gen-op-defs -I %S/../../include %s | FileCheck %s --check-prefix=DEF
 // RUN: mlir-tblgen -print-records -I %S/../../include %s | FileCheck %s --check-prefix=RECORD
 
+include "mlir/IR/AttrTypeBase.td"
 include "mlir/IR/OpBase.td"
 
 def Test_Dialect : Dialect {
   let name = "test";
   let cppNamespace = "foobar";
 }
 class NS_Op<string mnemonic, list<Trait> traits> :
     Op<Test_Dialect, mnemonic, traits>;

mlir/test/mlir-tblgen/op-decl-and-defs.td

 // RUN: mlir-tblgen -gen-op-decls -I %S/../../include %s | FileCheck %s
 // RUN: mlir-tblgen -gen-op-decls -op-include-regex="test.a_op" -I %S/../../include %s | FileCheck  %s --check-prefix=REDUCE_INC
 // RUN: mlir-tblgen -gen-op-decls -op-exclude-regex="test.a_op" -I %S/../../include %s | FileCheck  %s --check-prefix=REDUCE_EXC
 
 // RUN: mlir-tblgen -gen-op-defs -I %S/../../include %s | FileCheck %s --check-prefix=DEFS
 
+include "mlir/IR/AttrTypeBase.td"
 include "mlir/IR/OpBase.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 def Test_Dialect : Dialect {
   let name = "test";
   let cppNamespace = "NS";
   let emitAccessorPrefix = kEmitAccessorPrefix_Prefixed;

mlir/test/mlir-tblgen/rewriter-errors.td

 // RUN: not mlir-tblgen -gen-rewriters -I %S/../../include -DERROR1 %s 2>&1 | FileCheck --check-prefix=ERROR1 %s
 // RUN: not mlir-tblgen -gen-rewriters -I %S/../../include -DERROR2 %s 2>&1 | FileCheck --check-prefix=ERROR2 %s
 // RUN: not mlir-tblgen -gen-rewriters -I %S/../../include -DERROR3 %s 2>&1 | FileCheck --check-prefix=ERROR3 %s
 // RUN: not mlir-tblgen -gen-rewriters -I %S/../../include -DERROR4 %s 2>&1 | FileCheck --check-prefix=ERROR4 %s
 // RUN: not mlir-tblgen -gen-rewriters -I %S/../../include -DERROR5 %s 2>&1 | FileCheck --check-prefix=ERROR5 %s
 // RUN: not mlir-tblgen -gen-rewriters -I %S/../../include -DERROR6 %s 2>&1 | FileCheck --check-prefix=ERROR6 %s
 // RUN: not mlir-tblgen -gen-rewriters -I %S/../../include -DERROR7 %s 2>&1 | FileCheck --check-prefix=ERROR7 %s
 
 include "mlir/IR/OpBase.td"
+include "mlir/IR/PatternBase.td"
 
 // Check using the dialect name as the namespace
 def A_Dialect : Dialect {
   let name = "a";
 }
 
 class A_Op<string mnemonic, list<Trait> traits = []> :
     Op<A_Dialect, mnemonic, traits>;

mlir/test/mlir-tblgen/rewriter-indexing.td

 // RUN: mlir-tblgen -gen-rewriters -I %S/../../include %s | FileCheck %s
 
 include "mlir/IR/OpBase.td"
+include "mlir/IR/PatternBase.td"
 
 def Test_Dialect : Dialect {
   let name = "test";
 }
 class NS_Op<string mnemonic, list<Trait> traits> :
     Op<Test_Dialect, mnemonic, traits>;
 
 def AOp : NS_Op<"a_op", []> {

mlir/test/mlir-tblgen/rewriter-static-matcher.td

 // RUN: mlir-tblgen -gen-rewriters -I %S/../../include %s | FileCheck %s
 
 include "mlir/IR/OpBase.td"
+include "mlir/IR/PatternBase.td"
 
 def Test_Dialect : Dialect {
   let name = "test";
 }
 class NS_Op<string mnemonic, list<Trait> traits> :
     Op<Test_Dialect, mnemonic, traits>;
 
 def AOp : NS_Op<"a_op", []> {

mlir/test/mlir-tblgen/typedefs.td

 // RUN: mlir-tblgen -gen-typedef-decls -I %S/../../include %s | FileCheck %s --check-prefix=DECL
 // RUN: mlir-tblgen -gen-typedef-defs -I %S/../../include %s | FileCheck %s --check-prefix=DEF
 
+include "mlir/IR/AttrTypeBase.td"
 include "mlir/IR/OpBase.td"
 
 // DECL: #ifdef GET_TYPEDEF_CLASSES
 // DECL: #undef GET_TYPEDEF_CLASSES
 
 // DECL: namespace mlir {
 // DECL: class AsmParser;
 // DECL: class AsmPrinter;

mlir/test/python/python_test_ops.td

 //===-- python_test_ops.td - Python test Op definitions ----*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef PYTHON_TEST_OPS
 #define PYTHON_TEST_OPS
 
+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";
 }

mlir/tools/mlir-tblgen/AttrOrTypeDefGen.cpp

protected:
   /// 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.getAllDerivedDefinitions("AttrDef"), os, "Attr",
-                     "Attribute",
+      : DefGenerator(records.getAllDerivedDefinitionsIfDefined("AttrDef"), os,
+                     "Attr", "Attribute",
                      /*isAttrGenerator=*/true,
                      /*needsDialectParserPrinter=*/
                      !records.getAllDerivedDefinitions("DialectAttr").empty()) {
   }
 };
 /// A specialized generator for TypeDefs.
 struct TypeDefGenerator : public DefGenerator {
   TypeDefGenerator(const llvm::RecordKeeper &records, raw_ostream &os)
-      : DefGenerator(records.getAllDerivedDefinitions("TypeDef"), os, "Type",
-                     "Type", /*isAttrGenerator=*/false,
+      : DefGenerator(records.getAllDerivedDefinitionsIfDefined("TypeDef"), os,
+                     "Type", "Type",
+                     /*isAttrGenerator=*/false,
                      /*needsDialectParserPrinter=*/
                      !records.getAllDerivedDefinitions("DialectType").empty()) {
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // GEN: Declarations

mlir/tools/mlir-tblgen/OpDocGen.cpp

if (!typeDefs.empty()) {
     for (const TypeDef &def : typeDefs)
       emitAttrOrTypeDefDoc(def, os);
   }
 }
 
 static void emitDialectDoc(const RecordKeeper &recordKeeper, raw_ostream &os) {
   std::vector<Record *> opDefs = getRequestedOpDefinitions(recordKeeper);
   std::vector<Record *> typeDefs =
-      recordKeeper.getAllDerivedDefinitions("DialectType");
+      recordKeeper.getAllDerivedDefinitionsIfDefined("DialectType");
   std::vector<Record *> typeDefDefs =
-      recordKeeper.getAllDerivedDefinitions("TypeDef");
+      recordKeeper.getAllDerivedDefinitionsIfDefined("TypeDef");
   std::vector<Record *> attrDefDefs =
-      recordKeeper.getAllDerivedDefinitions("AttrDef");
+      recordKeeper.getAllDerivedDefinitionsIfDefined("AttrDef");
 
   std::set<Dialect> dialectsWithDocs;
 
   llvm::StringMap<std::vector<AttrDef>> dialectAttrDefs;
   llvm::StringMap<std::vector<Operator>> dialectOps;
   llvm::StringMap<std::vector<Type>> dialectTypes;
   llvm::StringMap<std::vector<TypeDef>> dialectTypeDefs;
   for (auto *attrDef : attrDefDefs) {