CINXE.COM

<!doctype html><html lang=en-us><head><meta charset=utf-8><meta http-equiv=x-ua-compatible content="IE=edge"><meta name=viewport content="width=device-width,initial-scale=1,maximum-scale=1,user-scalable=no"><title>Chapter 7: Adding a Composite Type to Toy - MLIR</title><meta name=description content="Multi-Level IR Compiler Framework"><meta name=generator content="Hugo 0.119.0"><link href=https://mlir.llvm.org/index.xml rel=alternate type=application/rss+xml><link rel=canonical href=https://mlir.llvm.org/docs/Tutorials/Toy/Ch-7/><link rel=stylesheet href=https://mlir.llvm.org/css/theme.css><script src=https://use.fontawesome.com/releases/v5.0.6/js/all.js></script> <link rel=stylesheet href=https://mlir.llvm.org/css/chroma.min.css><script src=https://cdn.jsdelivr.net/npm/jquery@3.3.1/dist/jquery.min.js></script> <script src=https://cdn.jsdelivr.net/npm/jquery.easing@1.4.1/jquery.easing.min.js></script> <script src=https://mlir.llvm.org/js/bundle.js></script> <script type=text/javascript src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script> <script type=text/x-mathjax-config> MathJax.Hub.Config({ tex2jax: { inlineMath: [['$', '$'] ], displayMath: [ ['$$','$$'], ["\\[","\\]"] ] } }); </script><link rel=apple-touch-icon sizes=180x180 href="/apple-touch-icon.png?v=1"><link rel=icon type=image/png sizes=32x32 href="/favicon-32x32.png?v=1"><link rel=icon type=image/png sizes=16x16 href="/favicon-16x16.png?v=1"><link rel=manifest href="/site.webmanifest?v=1"><link rel=mask-icon href="/safari-pinned-tab.svg?v=1" color=#3775e0><link rel="shortcut icon" href="/favicon.ico?v=1"><meta name=msapplication-TileColor content="#2d89ef"><meta name=theme-color content="#ffffff"><link rel=icon href=/favicon.svg type=image/svg+xml sizes=any><style>:root{}</style></head><body><div class=container><header><h1><div><img src=https://mlir.llvm.org//mlir-logo.png width=40px align=absmiddle> MLIR</div></h1>Multi-Level IR Compiler Framework</header><div class=global-menu><nav><ul><li class=parent><a href>Community</a><ul class=sub-menu><li class=child><a href=https://llvm.discourse.group/c/mlir/31>Forums</a></li><li class=child><a href=https://discord.gg/xS7Z362>Chat</a></li></ul></li><li><a href=/getting_started/Debugging/>Debugging Tips</a></li><li><a href=/getting_started/Faq/>FAQ</a></li><li class=parent><a href=https://github.com/llvm/llvm-project/tree/main/mlir>Source</a><ul class=sub-menu><li class=child><a href=/doxygen/>Doxygen</a></li><li class=child><a href=https://github.com/llvm/llvm-project/tree/main/mlir>GitHub</a></li></ul></li><li><a href="https://bugs.llvm.org/buglist.cgi?bug_status=__open__&list_id=177877&order=changeddate%20DESC%2Cpriority%2Cbug_severity&product=MLIR&query_format=specific">Bugs</a></li><li><a href=https://github.com/llvm/mlir-www/tree/main/website/static/LogoAssets>Logo Assets</a></li><li><a href=https://www.youtube.com/MLIRCompiler>Youtube Channel</a></li></ul></nav></div><div class=content-container><main><h1>Chapter 7: Adding a Composite Type to Toy</h1><nav id=TableOfContents><ul><li><a href=#defining-a-struct-in-toy>Defining a <code>struct</code> in Toy</a></li><li><a href=#defining-a-struct-in-mlir>Defining a <code>struct</code> in MLIR</a><ul><li><a href=#defining-the-type-class>Defining the Type Class</a></li><li><a href=#exposing-to-ods>Exposing to ODS</a></li><li><a href=#parsing-and-printing>Parsing and Printing</a></li><li><a href=#operating-on-structtype>Operating on <code>StructType</code></a></li></ul></li></ul></nav>In the <a href=/docs/Tutorials/Toy/Ch-6/>previous chapter</a>, we demonstrated an end-to-end compilation flow from our Toy front-end to LLVM IR. In this chapter, we will extend the Toy language to support a new composite <code>struct</code> type.<h2 id=defining-a-struct-in-toy>Defining a <code>struct</code> in Toy <a class=headline-hash href=#defining-a-struct-in-toy>¶</a></h2>The first thing we need to define is the interface of this type in our <code>toy</code> source language. The general syntax of a <code>struct</code> type in Toy is as follows:<pre tabindex=0><code class=language-toy data-lang=toy># A struct is defined by using the `struct` keyword followed by a name. struct MyStruct { # Inside of the struct is a list of variable declarations without initializers # or shapes, which may also be other previously defined structs. var a; var b; } </code></pre>Structs may now be used in functions as variables or parameters by using the name of the struct instead of <code>var</code>. The members of the struct are accessed via a <code>.</code> access operator. Values of <code>struct</code> type may be initialized with a composite initializer, or a comma-separated list of other initializers surrounded by <code>{}</code>. An example is shown below:<pre tabindex=0><code class=language-toy data-lang=toy>struct Struct { var a; var b; } # User defined generic function may operate on struct types as well. def multiply_transpose(Struct value) { # We can access the elements of a struct via the '.' operator. return transpose(value.a) * transpose(value.b); } def main() { # We initialize struct values using a composite initializer. Struct value = {[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]}; # We pass these arguments to functions like we do with variables. var c = multiply_transpose(value); print(c); } </code></pre><h2 id=defining-a-struct-in-mlir>Defining a <code>struct</code> in MLIR <a class=headline-hash href=#defining-a-struct-in-mlir>¶</a></h2>In MLIR, we will also need a representation for our struct types. MLIR does not provide a type that does exactly what we need, so we will need to define our own. We will simply define our <code>struct</code> as an unnamed container of a set of element types. The name of the <code>struct</code> and its elements are only useful for the AST of our <code>toy</code> compiler, so we don’t need to encode it in the MLIR representation.<h3 id=defining-the-type-class>Defining the Type Class <a class=headline-hash href=#defining-the-type-class>¶</a></h3><h4 id=defining-the-type-class-1>Defining the Type Class <a class=headline-hash href=#defining-the-type-class-1>¶</a></h4>As mentioned in <a href=/docs/Tutorials/Toy/Ch-2/>chapter 2</a>, <a href=/docs/LangRef/#type-system><code>Type</code></a> objects in MLIR are value-typed and rely on having an internal storage object that holds the actual data for the type. The <code>Type</code> class in itself acts as a simple wrapper around an internal <code>TypeStorage</code> object that is uniqued within an instance of an <code>MLIRContext</code>. When constructing a <code>Type</code>, we are internally just constructing and uniquing an instance of a storage class.When defining a new <code>Type</code> that contains parametric data (e.g. the <code>struct</code> type, which requires additional information to hold the element types), we will need to provide a derived storage class. The <code>singleton</code> types that don’t have any additional data (e.g. the <a href=/docs/Dialects/Builtin/#indextype><code>index</code> type</a>) don’t require a storage class and use the default <code>TypeStorage</code>.<h5 id=defining-the-storage-class>Defining the Storage Class <a class=headline-hash href=#defining-the-storage-class>¶</a></h5>Type storage objects contain all of the data necessary to construct and unique a type instance. Derived storage classes must inherit from the base <code>mlir::TypeStorage</code> and provide a set of aliases and hooks that will be used by the <code>MLIRContext</code> for uniquing. Below is the definition of the storage instance for our <code>struct</code> type, with each of the necessary requirements detailed inline:<div class=highlight><pre tabindex=0 class=chroma><code class=language-c++ data-lang=c++>/// This class represents the internal storage of the Toy `StructType`. struct StructTypeStorage : public mlir::TypeStorage { /// The `KeyTy` is a required type that provides an interface for the storage /// instance. This type will be used when uniquing an instance of the type /// storage. For our struct type, we will unique each instance structurally on /// the elements that it contains. using KeyTy = llvm::ArrayRef<mlir::Type>; /// A constructor for the type storage instance. StructTypeStorage(llvm::ArrayRef<mlir::Type> elementTypes) : elementTypes(elementTypes) {} /// Define the comparison function for the key type with the current storage /// instance. This is used when constructing a new instance to ensure that we /// haven't already uniqued an instance of the given key. bool operator==(const KeyTy &key) const { return key == elementTypes; } /// Define a hash function for the key type. This is used when uniquing /// instances of the storage. /// Note: This method isn't necessary as both llvm::ArrayRef and mlir::Type /// have hash functions available, so we could just omit this entirely. static llvm::hash_code hashKey(const KeyTy &key) { return llvm::hash_value(key); } /// Define a construction function for the key type from a set of parameters. /// These parameters will be provided when constructing the storage instance /// itself, see the `StructType::get` method further below. /// Note: This method isn't necessary because KeyTy can be directly /// constructed with the given parameters. static KeyTy getKey(llvm::ArrayRef<mlir::Type> elementTypes) { return KeyTy(elementTypes); } /// Define a construction method for creating a new instance of this storage. /// This method takes an instance of a storage allocator, and an instance of a /// `KeyTy`. The given allocator must be used for *all* necessary dynamic /// allocations used to create the type storage and its internal. static StructTypeStorage *construct(mlir::TypeStorageAllocator &allocator, const KeyTy &key) { // Copy the elements from the provided `KeyTy` into the allocator. llvm::ArrayRef<mlir::Type> elementTypes = allocator.copyInto(key); // Allocate the storage instance and construct it. return new (allocator.allocate<StructTypeStorage>()) StructTypeStorage(elementTypes); } /// The following field contains the element types of the struct. llvm::ArrayRef<mlir::Type> elementTypes; }; </code></pre></div><h5 id=defining-the-type-class-2>Defining the Type Class <a class=headline-hash href=#defining-the-type-class-2>¶</a></h5>With the storage class defined, we can add the definition for the user-visible <code>StructType</code> class. This is the class that we will actually interface with.<div class=highlight><pre tabindex=0 class=chroma><code class=language-c++ data-lang=c++>/// This class defines the Toy struct type. It represents a collection of /// element types. All derived types in MLIR must inherit from the CRTP class /// 'Type::TypeBase'. It takes as template parameters the concrete type /// (StructType), the base class to use (Type), and the storage class /// (StructTypeStorage). class StructType : public mlir::Type::TypeBase<StructType, mlir::Type, StructTypeStorage> { public: /// Inherit some necessary constructors from 'TypeBase'. using Base::Base; /// Create an instance of a `StructType` with the given element types. There /// *must* be at least one element type. static StructType get(llvm::ArrayRef<mlir::Type> elementTypes) { assert(!elementTypes.empty() && "expected at least 1 element type"); // Call into a helper 'get' method in 'TypeBase' to get a uniqued instance // of this type. The first parameter is the context to unique in. The // parameters after are forwarded to the storage instance. mlir::MLIRContext *ctx = elementTypes.front().getContext(); return Base::get(ctx, elementTypes); } /// Returns the element types of this struct type. llvm::ArrayRef<mlir::Type> getElementTypes() { // 'getImpl' returns a pointer to the internal storage instance. return getImpl()->elementTypes; } /// Returns the number of element type held by this struct. size_t getNumElementTypes() { return getElementTypes().size(); } }; </code></pre></div>We register this type in the <code>ToyDialect</code> initializer in a similar way to how we did with operations:<div class=highlight><pre tabindex=0 class=chroma><code class=language-c++ data-lang=c++>void ToyDialect::initialize() { addTypes<StructType>(); } </code></pre></div>(An important note here is that when registering a type, the definition of the storage class must be visible.)With this we can now use our <code>StructType</code> when generating MLIR from Toy. See examples/toy/Ch7/mlir/MLIRGen.cpp for more details.<h3 id=exposing-to-ods>Exposing to ODS <a class=headline-hash href=#exposing-to-ods>¶</a></h3>After defining a new type, we should make the ODS framework aware of our Type so that we can use it in the operation definitions and auto-generate utilities within the Dialect. A simple example is shown below:<div class=highlight><pre tabindex=0 class=chroma><code class=language-tablegen data-lang=tablegen>// Provide a definition for the Toy StructType for use in ODS. This allows for // using StructType in a similar way to Tensor or MemRef. We use `DialectType` // to demarcate the StructType as belonging to the Toy dialect. def Toy_StructType : DialectType<Toy_Dialect, CPred<"$_self.isa<StructType>()">, "Toy struct type">; // Provide a definition of the types that are used within the Toy dialect. def Toy_Type : AnyTypeOf<[F64Tensor, Toy_StructType]>; </code></pre></div><h3 id=parsing-and-printing>Parsing and Printing <a class=headline-hash href=#parsing-and-printing>¶</a></h3>At this point we can use our <code>StructType</code> during MLIR generation and transformation, but we can’t output or parse <code>.mlir</code>. For this we need to add support for parsing and printing instances of the <code>StructType</code>. This can be done by overriding the <code>parseType</code> and <code>printType</code> methods on the <code>ToyDialect</code>. Declarations for these methods are automatically provided when the type is exposed to ODS as detailed in the previous section.<div class=highlight><pre tabindex=0 class=chroma><code class=language-c++ data-lang=c++>class ToyDialect : public mlir::Dialect { public: /// Parse an instance of a type registered to the toy dialect. mlir::Type parseType(mlir::DialectAsmParser &parser) const override; /// Print an instance of a type registered to the toy dialect. void printType(mlir::Type type, mlir::DialectAsmPrinter &printer) const override; }; </code></pre></div>These methods take an instance of a high-level parser or printer that allows for easily implementing the necessary functionality. Before going into the implementation, let’s think about the syntax that we want for the <code>struct</code> type in the printed IR. As described in the <a href=/docs/LangRef/#dialect-types>MLIR language reference</a>, dialect types are generally represented as: <code>! dialect-namespace < type-data ></code>, with a pretty form available under certain circumstances. The responsibility of our <code>Toy</code> parser and printer is to provide the <code>type-data</code> bits. We will define our <code>StructType</code> as having the following form:<pre tabindex=0><code> struct-type ::= `struct` `<` type (`,` type)* `>` </code></pre><h4 id=parsing>Parsing <a class=headline-hash href=#parsing>¶</a></h4>An implementation of the parser is shown below:<div class=highlight><pre tabindex=0 class=chroma><code class=language-c++ data-lang=c++>/// Parse an instance of a type registered to the toy dialect. mlir::Type ToyDialect::parseType(mlir::DialectAsmParser &parser) const { // Parse a struct type in the following form: // struct-type ::= `struct` `<` type (`,` type)* `>` // NOTE: All MLIR parser function return a ParseResult. This is a // specialization of LogicalResult that auto-converts to a `true` boolean // value on failure to allow for chaining, but may be used with explicit // `mlir::failed/mlir::succeeded` as desired. // Parse: `struct` `<` if (parser.parseKeyword("struct") || parser.parseLess()) return Type(); // Parse the element types of the struct. SmallVector<mlir::Type, 1> elementTypes; do { // Parse the current element type. SMLoc typeLoc = parser.getCurrentLocation(); mlir::Type elementType; if (parser.parseType(elementType)) return nullptr; // Check that the type is either a TensorType or another StructType. if (!elementType.isa<mlir::TensorType, StructType>()) { parser.emitError(typeLoc, "element type for a struct must either " "be a TensorType or a StructType, got: ") << elementType; return Type(); } elementTypes.push_back(elementType); // Parse the optional: `,` } while (succeeded(parser.parseOptionalComma())); // Parse: `>` if (parser.parseGreater()) return Type(); return StructType::get(elementTypes); } </code></pre></div><h4 id=printing>Printing <a class=headline-hash href=#printing>¶</a></h4>An implementation of the printer is shown below:<div class=highlight><pre tabindex=0 class=chroma><code class=language-c++ data-lang=c++>/// Print an instance of a type registered to the toy dialect. void ToyDialect::printType(mlir::Type type, mlir::DialectAsmPrinter &printer) const { // Currently the only toy type is a struct type. StructType structType = type.cast<StructType>(); // Print the struct type according to the parser format. printer << "struct<"; llvm::interleaveComma(structType.getElementTypes(), printer); printer << '>'; } </code></pre></div>Before moving on, let’s look at a quick of example showcasing the functionality we have now:<pre tabindex=0><code class=language-toy data-lang=toy>struct Struct { var a; var b; } def multiply_transpose(Struct value) { } </code></pre>Which generates the following:<div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir>module { toy.func @multiply_transpose(%arg0: !toy.struct<tensor<*xf64>, tensor<*xf64>>) { toy.return } } </code></pre></div><h3 id=operating-on-structtype>Operating on <code>StructType</code> <a class=headline-hash href=#operating-on-structtype>¶</a></h3>Now that the <code>struct</code> type has been defined, and we can round-trip it through the IR. The next step is to add support for using it within our operations.<h4 id=updating-existing-operations>Updating Existing Operations <a class=headline-hash href=#updating-existing-operations>¶</a></h4>A few of our existing operations, e.g. <code>ReturnOp</code>, will need to be updated to handle <code>Toy_StructType</code>.<div class=highlight><pre tabindex=0 class=chroma><code class=language-tablegen data-lang=tablegen>def ReturnOp : Toy_Op<"return", [Terminator, HasParent<"FuncOp">]> { ... let arguments = (ins Variadic<Toy_Type>:$input); ... } </code></pre></div><h4 id=adding-new-toy-operations>Adding New <code>Toy</code> Operations <a class=headline-hash href=#adding-new-toy-operations>¶</a></h4>In addition to the existing operations, we will be adding a few new operations that will provide more specific handling of <code>structs</code>.<h5 id=toystruct_constant><code>toy.struct_constant</code> <a class=headline-hash href=#toystruct_constant>¶</a></h5>This new operation materializes a constant value for a struct. In our current modeling, we just use an <a href=/docs/Dialects/Builtin/#arrayattr>array attribute</a> that contains a set of constant values for each of the <code>struct</code> elements.<div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir> %0 = toy.struct_constant [ dense<[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]> : tensor<2x3xf64> ] : !toy.struct<tensor<*xf64>> </code></pre></div><h5 id=toystruct_access><code>toy.struct_access</code> <a class=headline-hash href=#toystruct_access>¶</a></h5>This new operation materializes the Nth element of a <code>struct</code> value.<div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir> // Using %0 from above %1 = toy.struct_access %0[0] : !toy.struct<tensor<*xf64>> -> tensor<*xf64> </code></pre></div>With these operations, we can revisit our original example:<pre tabindex=0><code class=language-toy data-lang=toy>struct Struct { var a; var b; } # User defined generic function may operate on struct types as well. def multiply_transpose(Struct value) { # We can access the elements of a struct via the '.' operator. return transpose(value.a) * transpose(value.b); } def main() { # We initialize struct values using a composite initializer. Struct value = {[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]}; # We pass these arguments to functions like we do with variables. var c = multiply_transpose(value); print(c); } </code></pre>and finally get a full MLIR module:<div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir>module { toy.func @multiply_transpose(%arg0: !toy.struct<tensor<*xf64>, tensor<*xf64>>) -> tensor<*xf64> { %0 = toy.struct_access %arg0[0] : !toy.struct<tensor<*xf64>, tensor<*xf64>> -> tensor<*xf64> %1 = toy.transpose(%0 : tensor<*xf64>) to tensor<*xf64> %2 = toy.struct_access %arg0[1] : !toy.struct<tensor<*xf64>, tensor<*xf64>> -> tensor<*xf64> %3 = toy.transpose(%2 : tensor<*xf64>) to tensor<*xf64> %4 = toy.mul %1, %3 : tensor<*xf64> toy.return %4 : tensor<*xf64> } toy.func @main() { %0 = toy.struct_constant [ dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>, dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64> ] : !toy.struct<tensor<*xf64>, tensor<*xf64>> %1 = toy.generic_call @multiply_transpose(%0) : (!toy.struct<tensor<*xf64>, tensor<*xf64>>) -> tensor<*xf64> toy.print %1 : tensor<*xf64> toy.return } } </code></pre></div><h4 id=optimizing-operations-on-structtype>Optimizing Operations on <code>StructType</code> <a class=headline-hash href=#optimizing-operations-on-structtype>¶</a></h4>Now that we have a few operations operating on <code>StructType</code>, we also have many new constant folding opportunities.After inlining, the MLIR module in the previous section looks something like:<div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir>module { toy.func @main() { %0 = toy.struct_constant [ dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>, dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64> ] : !toy.struct<tensor<*xf64>, tensor<*xf64>> %1 = toy.struct_access %0[0] : !toy.struct<tensor<*xf64>, tensor<*xf64>> -> tensor<*xf64> %2 = toy.transpose(%1 : tensor<*xf64>) to tensor<*xf64> %3 = toy.struct_access %0[1] : !toy.struct<tensor<*xf64>, tensor<*xf64>> -> tensor<*xf64> %4 = toy.transpose(%3 : tensor<*xf64>) to tensor<*xf64> %5 = toy.mul %2, %4 : tensor<*xf64> toy.print %5 : tensor<*xf64> toy.return } } </code></pre></div>We have several <code>toy.struct_access</code> operations that access into a <code>toy.struct_constant</code>. As detailed in <a href=/docs/Tutorials/Toy/Ch-3/>chapter 3</a> (FoldConstantReshape), we can add folders for these <code>toy</code> operations by setting the <code>hasFolder</code> bit on the operation definition and providing a definition of the <code>*Op::fold</code> method.<div class=highlight><pre tabindex=0 class=chroma><code class=language-c++ data-lang=c++>/// Fold constants. OpFoldResult ConstantOp::fold(FoldAdaptor adaptor) { return value(); } /// Fold struct constants. OpFoldResult StructConstantOp::fold(FoldAdaptor adaptor) { return value(); } /// Fold simple struct access operations that access into a constant. OpFoldResult StructAccessOp::fold(FoldAdaptor adaptor) { auto structAttr = adaptor.getInput().dyn_cast_or_null<mlir::ArrayAttr>(); if (!structAttr) return nullptr; size_t elementIndex = index().getZExtValue(); return structAttr[elementIndex]; } </code></pre></div>To ensure that MLIR generates the proper constant operations when folding our <code>Toy</code> operations, i.e. <code>ConstantOp</code> for <code>TensorType</code> and <code>StructConstant</code> for <code>StructType</code>, we will need to provide an override for the dialect hook <code>materializeConstant</code>. This allows for generic MLIR operations to create constants for the <code>Toy</code> dialect when necessary.<div class=highlight><pre tabindex=0 class=chroma><code class=language-c++ data-lang=c++>mlir::Operation *ToyDialect::materializeConstant(mlir::OpBuilder &builder, mlir::Attribute value, mlir::Type type, mlir::Location loc) { if (type.isa<StructType>()) return builder.create<StructConstantOp>(loc, type, value.cast<mlir::ArrayAttr>()); return builder.create<ConstantOp>(loc, type, value.cast<mlir::DenseElementsAttr>()); } </code></pre></div>With this, we can now generate code that can be generated to LLVM without any changes to our pipeline.<div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir>module { toy.func @main() { %0 = toy.constant dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64> %1 = toy.transpose(%0 : tensor<2x3xf64>) to tensor<3x2xf64> %2 = toy.mul %1, %1 : tensor<3x2xf64> toy.print %2 : tensor<3x2xf64> toy.return } } </code></pre></div>You can build <code>toyc-ch7</code> and try yourself: <code>toyc-ch7 test/Examples/Toy/Ch7/struct-codegen.toy -emit=mlir</code>. More details on defining custom types can be found in <a href=/docs/DefiningDialects/AttributesAndTypes/>DefiningAttributesAndTypes</a>.<div class=edit-meta> </div><nav class=pagination><a class="nav nav-prev" href=https://mlir.llvm.org/docs/Tutorials/Toy/Ch-6/ title="Chapter 6: Lowering to LLVM and CodeGeneration"> Prev - Chapter 6: Lowering to LLVM and CodeGeneration</a> <a class="nav nav-next" href=https://mlir.llvm.org/docs/Tutorials/transform/ title="Transform Dialect Tutorial">Next - Transform Dialect Tutorial </a></nav><footer>Powered by <a href=https://gohugo.io>Hugo</a>. Theme by <a href=https://themes.gohugo.io/hugo-theme-techdoc/>TechDoc</a>. Designed by <a href=https://github.com/thingsym/hugo-theme-techdoc>Thingsym</a>.</footer></main><div class=sidebar><nav class=slide-menu><ul><li><a href=https://mlir.llvm.org/>Home</a></li><li><a href=https://mlir.llvm.org/users/>Users of MLIR</a></li><li><a href=https://mlir.llvm.org/pubs/>MLIR Related Publications</a></li><li><a href=https://mlir.llvm.org/talks/>Talks</a></li><li><a href=https://mlir.llvm.org/deprecation/>Deprecations & Current Refactoring</a></li><li class=has-sub-menu><a href=https://mlir.llvm.org/getting_started/>Getting Started+</a><ul class=sub-menu><li><a href=https://mlir.llvm.org/getting_started/ReportingIssues/>Reporting Issues</a></li><li><a href=https://mlir.llvm.org/getting_started/Debugging/>Debugging Tips</a></li><li><a href=https://mlir.llvm.org/getting_started/Faq/>FAQ</a></li><li><a href=https://mlir.llvm.org/getting_started/Contributing/>How to Contribute</a></li><li><a href=https://mlir.llvm.org/getting_started/DeveloperGuide/>Developer Guide</a></li><li><a href=https://mlir.llvm.org/getting_started/openprojects/>Open Projects</a></li><li><a href=https://mlir.llvm.org/getting_started/Glossary/>Glossary</a></li><li><a href=https://mlir.llvm.org/getting_started/TestingGuide/>Testing Guide</a></li></ul></li><li class="parent has-sub-menu"><a href=https://mlir.llvm.org/docs/>Code Documentation-</a><ul class=sub-menu><li class=has-sub-menu><a href=https://mlir.llvm.org/docs/Bindings/>Bindings+</a><ul class=sub-menu><li><a href=https://mlir.llvm.org/docs/Bindings/Python/>MLIR Python Bindings</a></li></ul></li><li class=has-sub-menu><a href=https://mlir.llvm.org/docs/Tools/>Tools+</a><ul class=sub-menu><li><a href=https://mlir.llvm.org/docs/Tools/MLIRLSP/>MLIR : Language Server Protocol</a></li><li><a href=https://mlir.llvm.org/docs/Tools/mlir-reduce/>MLIR Reduce</a></li><li><a href=https://mlir.llvm.org/docs/Tools/mlir-rewrite/>mlir-rewrite</a></li></ul></li><li><a href=https://mlir.llvm.org/docs/QuantPasses/></a></li><li><a href=https://mlir.llvm.org/docs/ActionTracing/>Action: Tracing and Debugging MLIR-based Compilers</a></li><li><a href=https://mlir.llvm.org/docs/Bufferization/>Bufferization</a></li><li><a href=https://mlir.llvm.org/docs/DataLayout/>Data Layout Modeling</a></li><li class=has-sub-menu><a href=https://mlir.llvm.org/docs/DefiningDialects/>Defining Dialects+</a><ul class=sub-menu><li><a href=https://mlir.llvm.org/docs/DefiningDialects/Constraints/>Constraints</a></li><li><a href=https://mlir.llvm.org/docs/DefiningDialects/Assembly/>Customizing Assembly Behavior</a></li><li><a href=https://mlir.llvm.org/docs/DefiningDialects/AttributesAndTypes/>Defining Dialect Attributes and Types</a></li><li><a href=https://mlir.llvm.org/docs/DefiningDialects/Operations/>Operation Definition Specification (ODS)</a></li></ul></li><li><a href=https://mlir.llvm.org/docs/Diagnostics/>Diagnostic Infrastructure</a></li><li><a href=https://mlir.llvm.org/docs/DialectConversion/>Dialect Conversion</a></li><li class=has-sub-menu><a href=https://mlir.llvm.org/docs/Dialects/>Dialects+</a><ul class=sub-menu><li><a href=https://mlir.llvm.org/docs/Dialects/OpenACCDialect/>'acc' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/Affine/>'affine' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/AMDGPU/>'amdgpu' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/AMX/>'amx' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/ArithOps/>'arith' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/ArmNeon/>'arm_neon' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/ArmSVE/>'arm_sve' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/ArmSME/>'ArmSME' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/AsyncDialect/>'async' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/BufferizationOps/>'bufferization' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/ControlFlowDialect/>'cf' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/ComplexOps/>'complex' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/DLTIDialect/>'dlti' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/EmitC/>'emitc' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/Func/>'func' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/GPU/>'gpu' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/IndexOps/>'index' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/IRDL/>'irdl' Dialect</a></li><li class=has-sub-menu><a href=https://mlir.llvm.org/docs/Dialects/Linalg/>'linalg' Dialect+</a><ul class=sub-menu><li><a href=https://mlir.llvm.org/docs/Dialects/Linalg/OpDSL/>Linalg OpDSL</a></li></ul></li><li><a href=https://mlir.llvm.org/docs/Dialects/LLVM/>'llvm' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/MathOps/>'math' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/MemRef/>'memref' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/Mesh/>'mesh' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/MLProgramOps/>'ml_program' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/MPI/>'mpi' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/NVGPU/>'nvgpu' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/NVVMDialect/>'nvvm' Dialect</a></li><li class=has-sub-menu><a href=https://mlir.llvm.org/docs/Dialects/OpenMPDialect/>'omp' Dialect+</a><ul class=sub-menu><li><a href=https://mlir.llvm.org/docs/Dialects/OpenMPDialect/ODS/>ODS Documentation</a></li></ul></li><li><a href=https://mlir.llvm.org/docs/Dialects/PDLInterpOps/>'pdl_interp' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/PDLOps/>'pdl' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/PolynomialDialect/>'polynomial' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/PtrOps/>'ptr' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/QuantDialect/>'quant' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/ROCDLDialect/>'rocdl' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/SCFDialect/>'scf' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/ShapeDialect/>'shape' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/SparseTensorOps/>'sparse_tensor' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/TensorOps/>'tensor' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/UBOps/>'ub' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/VCIXDialect/>'vcix' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/Vector/>'vector' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/X86Vector/>'x86vector' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/XeGPU/>'xegpu' Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/Builtin/>Builtin Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/MatchOpInterfaces/>OpInterface definitions</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/SPIR-V/>SPIR-V Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/TOSA/>Tensor Operator Set Architecture (TOSA) Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Dialects/Transform/>Transform Dialect</a></li></ul></li><li><a href=https://mlir.llvm.org/docs/Interfaces/>Interfaces</a></li><li><a href=https://mlir.llvm.org/docs/TargetLLVMIR/>LLVM IR Target</a></li><li><a href=https://mlir.llvm.org/docs/BytecodeFormat/>MLIR Bytecode Format</a></li><li><a href=https://mlir.llvm.org/docs/CAPI/>MLIR C API</a></li><li><a href=https://mlir.llvm.org/docs/LangRef/>MLIR Language Reference</a></li><li><a href=https://mlir.llvm.org/docs/ReleaseNotes/>MLIR Release Notes</a></li><li><a href=https://mlir.llvm.org/docs/Canonicalization/>Operation Canonicalization</a></li><li><a href=https://mlir.llvm.org/docs/OwnershipBasedBufferDeallocation/>Ownership-based Buffer Deallocation</a></li><li><a href=https://mlir.llvm.org/docs/PassManagement/>Pass Infrastructure</a></li><li><a href=https://mlir.llvm.org/docs/Passes/>Passes</a></li><li><a href=https://mlir.llvm.org/docs/PatternRewriter/>Pattern Rewriting : Generic DAG-to-DAG Rewriting</a></li><li><a href=https://mlir.llvm.org/docs/PDLL/>PDLL - PDL Language</a></li><li><a href=https://mlir.llvm.org/docs/Quantization/>Quantization</a></li><li class=has-sub-menu><a href=https://mlir.llvm.org/docs/Rationale/>Rationale+</a><ul class=sub-menu><li><a href=https://mlir.llvm.org/docs/Rationale/RationaleGenericDAGRewriter/>Generic DAG Rewriter Infrastructure Rationale</a></li><li><a href=https://mlir.llvm.org/docs/Rationale/RationaleLinalgDialect/>Linalg Dialect Rationale: The Case For Compiler-Friendly Custom Operations</a></li><li><a href=https://mlir.llvm.org/docs/Rationale/Rationale/>MLIR Rationale</a></li><li><a href=https://mlir.llvm.org/docs/Rationale/MLIRForGraphAlgorithms/>MLIR: Incremental Application to Graph Algorithms in ML Frameworks</a></li><li><a href=https://mlir.llvm.org/docs/Rationale/RationaleSimplifiedPolyhedralForm/>MLIR: The case for a simplified polyhedral form</a></li><li><a href=https://mlir.llvm.org/docs/Rationale/SideEffectsAndSpeculation/>Side Effects & Speculation</a></li><li><a href=https://mlir.llvm.org/docs/Rationale/UsageOfConst/>Usage of 'const' in MLIR, for core IR types</a></li></ul></li><li><a href=https://mlir.llvm.org/docs/ShapeInference/>Shape Inference</a></li><li><a href=https://mlir.llvm.org/docs/SPIRVToLLVMDialectConversion/>SPIR-V Dialect to LLVM Dialect conversion manual</a></li><li><a href=https://mlir.llvm.org/docs/SymbolsAndSymbolTables/>Symbols and Symbol Tables</a></li><li><a href=https://mlir.llvm.org/docs/DeclarativeRewrites/>Table-driven Declarative Rewrite Rule (DRR)</a></li><li class=has-sub-menu><a href=https://mlir.llvm.org/docs/Traits/>Traits+</a><ul class=sub-menu><li><a href=https://mlir.llvm.org/docs/Traits/Broadcastable/>The `Broadcastable` Trait</a></li></ul></li><li class="parent has-sub-menu"><a href=https://mlir.llvm.org/docs/Tutorials/>Tutorials-</a><ul class=sub-menu><li><a href=https://mlir.llvm.org/docs/Tutorials/CreatingADialect/>Creating a Dialect</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/QuickstartRewrites/>Quickstart tutorial to adding MLIR graph rewrite</a></li><li class="parent has-sub-menu"><a href=https://mlir.llvm.org/docs/Tutorials/Toy/>Toy Tutorial-</a><ul class=sub-menu><li><a href=https://mlir.llvm.org/docs/Tutorials/Toy/Ch-1/>Chapter 1: Toy Language and AST</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/Toy/Ch-2/>Chapter 2: Emitting Basic MLIR</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/Toy/Ch-3/>Chapter 3: High-level Language-Specific Analysis and Transformation</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/Toy/Ch-4/>Chapter 4: Enabling Generic Transformation with Interfaces</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/Toy/Ch-5/>Chapter 5: Partial Lowering to Lower-Level Dialects for Optimization</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/Toy/Ch-6/>Chapter 6: Lowering to LLVM and CodeGeneration</a></li><li class=active><a href=https://mlir.llvm.org/docs/Tutorials/Toy/Ch-7/>Chapter 7: Adding a Composite Type to Toy</a></li></ul></li><li class=has-sub-menu><a href=https://mlir.llvm.org/docs/Tutorials/transform/>Transform Dialect Tutorial+</a><ul class=sub-menu><li><a href=https://mlir.llvm.org/docs/Tutorials/transform/Ch0/>Chapter 0: A Primer on “Structured” Linalg Operations</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/transform/Ch1/>Chapter 1: Combining Existing Transformations</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/transform/Ch2/>Chapter 2: Adding a Simple New Transformation Operation</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/transform/Ch3/>Chapter 3: More than Simple Transform Operations</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/transform/Ch4/>Chapter 4: Matching Payload with Transform Operations</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/transform/ChH/>Chapter H: Reproducing Halide Schedule</a></li></ul></li><li><a href=https://mlir.llvm.org/docs/Tutorials/UnderstandingTheIRStructure/>Understanding the IR Structure</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/MlirOpt/>Using `mlir-opt`</a></li><li><a href=https://mlir.llvm.org/docs/Tutorials/DataFlowAnalysis/>Writing DataFlow Analyses in MLIR</a></li></ul></li></ul></li></ul></nav><div class=sidebar-footer></div></div></div><a href=# id=backtothetop-fixed class=backtothetop data-backtothetop-duration=600 data-backtothetop-easing=easeOutQuart data-backtothetop-fixed-fadein=1000 data-backtothetop-fixed-fadeout=1000 data-backtothetop-fixed-bottom=10 data-backtothetop-fixed-right=20> </a></div></body></html>