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>'pdl' Dialect - 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/Dialects/PDLOps/><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>'pdl' Dialect</h1>High level pattern definition dialectPDL presents a high level abstraction for the rewrite pattern infrastructure available in MLIR. This abstraction allows for representing patterns transforming MLIR, as MLIR. This allows for applying all of the benefits that the general MLIR infrastructure provides, to the infrastructure itself. This means that pattern matching can be more easily verified for correctness, targeted by frontends, and optimized.PDL abstracts over various different aspects of patterns and core MLIR data structures. Patterns are specified via a <code>pdl.pattern</code> operation. These operations contain a region body for the “matcher” code, and terminate with a <code>pdl.rewrite</code> that either dispatches to an external rewriter or contains a region for the rewrite specified via <code>pdl</code>. The types of values in <code>pdl</code> are handle types to MLIR C++ types, with <code>!pdl.attribute</code>, <code>!pdl.operation</code>, <code>!pdl.value</code>, and <code>!pdl.type</code> directly mapping to <code>mlir::Attribute</code>, <code>mlir::Operation*</code>, <code>mlir::Value</code>, and <code>mlir::Type</code> respectively.An example pattern is shown below:<div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir>// pdl.pattern contains metadata similarly to a `RewritePattern`. pdl.pattern : benefit(1) { // External input operand values are specified via `pdl.operand` operations. // Result types are constrainted via `pdl.type` operations. %resultType = pdl.type %inputOperand = pdl.operand %root = pdl.operation "foo.op"(%inputOperand) -> %resultType pdl.rewrite %root { pdl.replace %root with (%inputOperand) } } </code></pre></div>The above pattern simply replaces an operation with its first operand. Note how the input operation is specified structurally, similarly to how it would look in memory. This is a simple example and pdl provides support for many other features such as applying external constraints or external generator methods. These features and more are detailed below.<nav id=TableOfContents><ul><li><a href=#operations>Operations</a><ul><li><a href=#pdlapply_native_constraint-pdlapplynativeconstraintop><code>pdl.apply_native_constraint</code> (pdl::ApplyNativeConstraintOp)</a></li><li><a href=#pdlapply_native_rewrite-pdlapplynativerewriteop><code>pdl.apply_native_rewrite</code> (pdl::ApplyNativeRewriteOp)</a></li><li><a href=#pdlattribute-pdlattributeop><code>pdl.attribute</code> (pdl::AttributeOp)</a></li><li><a href=#pdlerase-pdleraseop><code>pdl.erase</code> (pdl::EraseOp)</a></li><li><a href=#pdloperand-pdloperandop><code>pdl.operand</code> (pdl::OperandOp)</a></li><li><a href=#pdloperands-pdloperandsop><code>pdl.operands</code> (pdl::OperandsOp)</a></li><li><a href=#pdloperation-pdloperationop><code>pdl.operation</code> (pdl::OperationOp)</a></li><li><a href=#pdlpattern-pdlpatternop><code>pdl.pattern</code> (pdl::PatternOp)</a></li><li><a href=#pdlrange-pdlrangeop><code>pdl.range</code> (pdl::RangeOp)</a></li><li><a href=#pdlreplace-pdlreplaceop><code>pdl.replace</code> (pdl::ReplaceOp)</a></li><li><a href=#pdlresult-pdlresultop><code>pdl.result</code> (pdl::ResultOp)</a></li><li><a href=#pdlresults-pdlresultsop><code>pdl.results</code> (pdl::ResultsOp)</a></li><li><a href=#pdlrewrite-pdlrewriteop><code>pdl.rewrite</code> (pdl::RewriteOp)</a></li><li><a href=#pdltype-pdltypeop><code>pdl.type</code> (pdl::TypeOp)</a></li><li><a href=#pdltypes-pdltypesop><code>pdl.types</code> (pdl::TypesOp)</a></li></ul></li><li><a href=#types>Types</a><ul><li><a href=#attributetype>AttributeType</a></li><li><a href=#operationtype>OperationType</a></li><li><a href=#rangetype>RangeType</a></li><li><a href=#typetype>TypeType</a></li><li><a href=#valuetype>ValueType</a></li></ul></li></ul></nav><h2 id=operations>Operations <a class=headline-hash href=#operations>¶</a></h2><a href=https://github.com/llvm/llvm-project/blob/main/mlir/include/mlir/Dialect/PDL/IR/PDLOps.td>source</a><h3 id=pdlapply_native_constraint-pdlapplynativeconstraintop><code>pdl.apply_native_constraint</code> (pdl::ApplyNativeConstraintOp) <a class=headline-hash href=#pdlapply_native_constraint-pdlapplynativeconstraintop>¶</a></h3>Apply a native constraint to a set of provided entitiesSyntax:<pre tabindex=0><code>operation ::= `pdl.apply_native_constraint` $name `(` $args `:` type($args) `)` (`:` type($results)^ )? attr-dict </code></pre><code>pdl.apply_native_constraint</code> operations apply a native C++ constraint, that has been registered externally with the consumer of PDL, to a given set of entities and optionally return a number of values.Example:<div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir>// Apply `myConstraint` to the entities defined by `input`, `attr`, and `op`. pdl.apply_native_constraint "myConstraint"(%input, %attr, %op : !pdl.value, !pdl.attribute, !pdl.operation) // Apply constraint `with_result` to `root`. This constraint returns an attribute. %attr = pdl.apply_native_constraint "with_result"(%root : !pdl.operation) : !pdl.attribute </code></pre></div>Traits: <code>HasParent<pdl::PatternOp></code><h4 id=attributes>Attributes: <a class=headline-hash href=#attributes>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>name</code></td><td>::mlir::StringAttr</td><td>string attribute</td></tr><tr><td><code>isNegated</code></td><td>::mlir::BoolAttr</td><td>bool attribute</td></tr></table><h4 id=operands>Operands: <a class=headline-hash href=#operands>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>args</code></td><td>variadic of pdl type</td></tr></tbody></table><h4 id=results>Results: <a class=headline-hash href=#results>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>results</code></td><td>variadic of pdl type</td></tr></tbody></table><h3 id=pdlapply_native_rewrite-pdlapplynativerewriteop><code>pdl.apply_native_rewrite</code> (pdl::ApplyNativeRewriteOp) <a class=headline-hash href=#pdlapply_native_rewrite-pdlapplynativerewriteop>¶</a></h3>Apply a native rewrite method inside of pdl.rewrite regionSyntax:<pre tabindex=0><code>operation ::= `pdl.apply_native_rewrite` $name (`(` $args^ `:` type($args) `)`)? (`:` type($results)^)? attr-dict </code></pre><code>pdl.apply_native_rewrite</code> operations apply a native C++ function, that has been registered externally with the consumer of PDL, to perform a rewrite and optionally return a number of values. The native function may accept any number of arguments. This operation is used within a pdl.rewrite region to enable the interleaving of native rewrite methods with other pdl constructs.Example:<div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir>// Apply a native rewrite method that returns an attribute. %ret = pdl.apply_native_rewrite "myNativeFunc"(%arg0, %attr1) : !pdl.attribute </code></pre></div><div class=highlight><pre tabindex=0 class=chroma><code class=language-c++ data-lang=c++>// The native rewrite as defined in C++: static Attribute myNativeFunc(PatternRewriter &rewriter, Value arg0, Attribute arg1) { // Just return the second arg. return arg1; } void registerNativeRewrite(PDLPatternModule &pdlModule) { pdlModule.registerRewriteFunction("myNativeFunc", myNativeFunc); } </code></pre></div>Traits: <code>HasParent<pdl::RewriteOp></code><h4 id=attributes-1>Attributes: <a class=headline-hash href=#attributes-1>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>name</code></td><td>::mlir::StringAttr</td><td>string attribute</td></tr></table><h4 id=operands-1>Operands: <a class=headline-hash href=#operands-1>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>args</code></td><td>variadic of pdl type</td></tr></tbody></table><h4 id=results-1>Results: <a class=headline-hash href=#results-1>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>results</code></td><td>variadic of pdl type</td></tr></tbody></table><h3 id=pdlattribute-pdlattributeop><code>pdl.attribute</code> (pdl::AttributeOp) <a class=headline-hash href=#pdlattribute-pdlattributeop>¶</a></h3>Define an input attribute in a patternSyntax:<pre tabindex=0><code>operation ::= `pdl.attribute` (`:` $valueType^)? (`=` $value^)? attr-dict-with-keyword </code></pre><code>pdl.attribute</code> operations capture named attribute edges into an operation. Instances of this operation define, and partially constrain, attributes of a given operation. A <code>pdl.attribute</code> may partially constrain the input by specifying an expected attribute value type (via a <code>pdl.type</code> operation), or a constant value for the attribute (via <code>val</code>). Only one of these may be set for a given input, as the type of the constant value provides the type. When defined within a <code>pdl.rewrite</code> region, the constant value must be specified.Example:<div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir>// Define an attribute: %attr = pdl.attribute // Define an attribute with an expected type: %type = pdl.type : i32 %attr = pdl.attribute : %type // Define an attribute with a constant value: %attr = pdl.attribute = "hello" </code></pre></div><h4 id=attributes-2>Attributes: <a class=headline-hash href=#attributes-2>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>value</code></td><td>::mlir::Attribute</td><td>any attribute</td></tr></table><h4 id=operands-2>Operands: <a class=headline-hash href=#operands-2>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>valueType</code></td><td>PDL handle to an <code>mlir::Type</code></td></tr></tbody></table><h4 id=results-2>Results: <a class=headline-hash href=#results-2>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>attr</code></td><td>PDL handle to an <code>mlir::Attribute</code></td></tr></tbody></table><h3 id=pdlerase-pdleraseop><code>pdl.erase</code> (pdl::EraseOp) <a class=headline-hash href=#pdlerase-pdleraseop>¶</a></h3>Mark an input operation as <code>erased</code>Syntax:<pre tabindex=0><code>operation ::= `pdl.erase` $opValue attr-dict </code></pre><code>pdl.erase</code> operations are used within <code>pdl.rewrite</code> regions to specify that an input operation should be marked as erased. The semantics of this operation correspond with the <code>eraseOp</code> method on a <code>PatternRewriter</code>.Example:<div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir>pdl.erase %root </code></pre></div>Traits: <code>HasParent<pdl::RewriteOp></code><h4 id=operands-3>Operands: <a class=headline-hash href=#operands-3>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>opValue</code></td><td>PDL handle to an <code>mlir::Operation *</code></td></tr></tbody></table><h3 id=pdloperand-pdloperandop><code>pdl.operand</code> (pdl::OperandOp) <a class=headline-hash href=#pdloperand-pdloperandop>¶</a></h3>Define an external input operand in a patternSyntax:<pre tabindex=0><code>operation ::= `pdl.operand` (`:` $valueType^)? attr-dict </code></pre><code>pdl.operand</code> operations capture external operand edges into an operation node that originate from operations or block arguments not otherwise specified within the pattern (i.e. via <code>pdl.result</code> or <code>pdl.results</code>). These operations define individual operands of a given operation. A <code>pdl.operand</code> may partially constrain an operand by specifying an expected value type (via a <code>pdl.type</code> operation).Example:<div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir>// Define an external operand: %operand = pdl.operand // Define an external operand with an expected type: %type = pdl.type : i32 %operand = pdl.operand : %type </code></pre></div>Traits: <code>HasParent<pdl::PatternOp></code><h4 id=operands-4>Operands: <a class=headline-hash href=#operands-4>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>valueType</code></td><td>PDL handle to an <code>mlir::Type</code></td></tr></tbody></table><h4 id=results-3>Results: <a class=headline-hash href=#results-3>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>value</code></td><td>PDL handle for an <code>mlir::Value</code></td></tr></tbody></table><h3 id=pdloperands-pdloperandsop><code>pdl.operands</code> (pdl::OperandsOp) <a class=headline-hash href=#pdloperands-pdloperandsop>¶</a></h3>Define a range of input operands in a patternSyntax:<pre tabindex=0><code>operation ::= `pdl.operands` (`:` $valueType^)? attr-dict </code></pre><code>pdl.operands</code> operations capture external operand range edges into an operation node that originate from operations or block arguments not otherwise specified within the pattern (i.e. via <code>pdl.result</code> or <code>pdl.results</code>). These operations define groups of input operands into a given operation. A <code>pdl.operands</code> may partially constrain a set of input operands by specifying expected value types (via <code>pdl.types</code> operations).Example:<div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir>// Define a range of input operands: %operands = pdl.operands // Define a range of input operands with expected types: %types = pdl.types : [i32, i64, i32] %typed_operands = pdl.operands : %types </code></pre></div>Traits: <code>HasParent<pdl::PatternOp></code><h4 id=operands-5>Operands: <a class=headline-hash href=#operands-5>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>valueType</code></td><td>range of PDL handle to an <code>mlir::Type</code> values</td></tr></tbody></table><h4 id=results-4>Results: <a class=headline-hash href=#results-4>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>value</code></td><td>range of PDL handle for an <code>mlir::Value</code> values</td></tr></tbody></table><h3 id=pdloperation-pdloperationop><code>pdl.operation</code> (pdl::OperationOp) <a class=headline-hash href=#pdloperation-pdloperationop>¶</a></h3>Define an operation within a patternSyntax:<pre tabindex=0><code>operation ::= `pdl.operation` ($opName^)? (`(` $operandValues^ `:` type($operandValues) `)`)? custom<OperationOpAttributes>($attributeValues, $attributeValueNames) (`->` `(` $typeValues^ `:` type($typeValues) `)`)? attr-dict </code></pre><code>pdl.operation</code> operations define operation nodes within a pattern. Within a match sequence, i.e. when directly nested within a <code>pdl.pattern</code>, these operations correspond to input operations, or those that already existing within the MLIR module. Inside of a <code>pdl.rewrite</code>, these operations correspond to operations that should be created as part of the replacement sequence.<code>pdl.operation</code>s are composed of a name, and a set of attribute, operand, and result type values, that map to what those that would be on a constructed instance of that operation. The results of a <code>pdl.operation</code> are a handle to the operation itself. Handles to the results of the operation can be extracted via <code>pdl.result</code>.Example:<div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir>// Define an instance of a `foo.op` operation. %op = pdl.operation "foo.op"(%arg0, %arg1 : !pdl.value, !pdl.value) {"attrA" = %attr0} -> (%type, %type : !pdl.type, !pdl.type) </code></pre></div>When used within a matching context, the name of the operation may be omitted.When used within a rewriting context, i.e. when defined within a <code>pdl.rewrite</code>, all of the result types must be “inferable”. This means that the type must be attributable to either a constant type value or the result type of another entity, such as an attribute, the result of a <code>apply_native_rewrite</code>, or the result type of another operation. If the result type value does not meet any of these criteria, the operation must override the <code>InferTypeOpInterface</code> to ensure that the result types can be inferred.The operands of the operation are interpreted in the following ways:<ol><li>A single !pdl.range<value>:</li></ol>In this case, the single range is treated as all of the operands of the operation.<div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir>// Define an instance with single range of operands. %op = pdl.operation "func.return"(%allArgs : !pdl.range<value>) </code></pre></div><ol start=2><li>A variadic number of either !pdl.value or !pdl.range<value>:</li></ol>In this case, the inputs are expected to correspond with the operand groups defined on the operation in ODS.<pre tabindex=0><code class=language-tablgen data-lang=tablgen>// Given the following operation definition in ODS: def MyIndirectCallOp { let results = (outs FunctionType:$call, Variadic<AnyType>:$args); } </code></pre><div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir>// We can match the operands as so: %op = pdl.operation "my.indirect_call"(%call, %args : !pdl.value, !pdl.range<value>) </code></pre></div>The results of the operation are interpreted in the following ways:<ol><li>A single !pdl.range<type>:</li></ol>In this case, the single range is treated as all of the result types of the operation.<div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir>// Define an instance with single range of types. %allResultTypes = pdl.types %op = pdl.operation "builtin.unrealized_conversion_cast" -> (%allResultTypes : !pdl.types) </code></pre></div><ol start=2><li>A variadic number of either !pdl.type or !pdl.range<type>:</li></ol>In this case, the inputs are expected to correspond with the result groups defined on the operation in ODS.<pre tabindex=0><code class=language-tablgen data-lang=tablgen>// Given the following operation definition in ODS: def MyOp { let results = (outs SomeType:$result, Variadic<SomeType>:$otherResults); } </code></pre><div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir>// We can match the results as so: %result = pdl.type %otherResults = pdl.types %op = pdl.operation "foo.op" -> (%result, %otherResults : !pdl.type, !pdl.range<type>) </code></pre></div>Traits: <code>AttrSizedOperandSegments</code><h4 id=attributes-3>Attributes: <a class=headline-hash href=#attributes-3>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>opName</code></td><td>::mlir::StringAttr</td><td>string attribute</td></tr><tr><td><code>attributeValueNames</code></td><td>::mlir::ArrayAttr</td><td>string array attribute</td></tr></table><h4 id=operands-6>Operands: <a class=headline-hash href=#operands-6>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>operandValues</code></td><td>variadic of single element or range of PDL handle for an <code>mlir::Value</code></td></tr><tr><td style=text-align:center><code>attributeValues</code></td><td>variadic of PDL handle to an <code>mlir::Attribute</code></td></tr><tr><td style=text-align:center><code>typeValues</code></td><td>variadic of single element or range of PDL handle to an <code>mlir::Type</code></td></tr></tbody></table><h4 id=results-5>Results: <a class=headline-hash href=#results-5>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>op</code></td><td>PDL handle to an <code>mlir::Operation *</code></td></tr></tbody></table><h3 id=pdlpattern-pdlpatternop><code>pdl.pattern</code> (pdl::PatternOp) <a class=headline-hash href=#pdlpattern-pdlpatternop>¶</a></h3>Define a rewrite patternSyntax:<pre tabindex=0><code>operation ::= `pdl.pattern` ($sym_name^)? `:` `benefit` `(` $benefit `)` attr-dict-with-keyword $bodyRegion </code></pre><code>pdl.pattern</code> operations provide a transformable representation for a <code>RewritePattern</code>. The attributes on this operation correspond to the various metadata on a <code>RewritePattern</code>, such as the benefit. The match section of the pattern is specified within the region body, with the rewrite provided by a terminating <code>pdl.rewrite</code>.Example:<div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir>// Provide a pattern matching "foo.op" that replaces the root with its // operand. pdl.pattern : benefit(1) { %resultType = pdl.type %inputOperand = pdl.operand %root = pdl.operation "foo.op"(%inputOperand) -> (%resultType) pdl.rewrite %root { pdl.replace %root with (%inputOperand) } } </code></pre></div>Traits: <code>IsolatedFromAbove</code>, <code>SingleBlock</code>Interfaces: <code>OpAsmOpInterface</code>, <code>Symbol</code><h4 id=attributes-4>Attributes: <a class=headline-hash href=#attributes-4>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>benefit</code></td><td>::mlir::IntegerAttr</td><td>16-bit signless integer attribute whose value is non-negative</td></tr><tr><td><code>sym_name</code></td><td>::mlir::StringAttr</td><td>string attribute</td></tr></table><h3 id=pdlrange-pdlrangeop><code>pdl.range</code> (pdl::RangeOp) <a class=headline-hash href=#pdlrange-pdlrangeop>¶</a></h3>Construct a range of pdl entitiesSyntax:<pre tabindex=0><code>operation ::= `pdl.range` ($arguments^ `:` type($arguments))? custom<RangeType>(ref(type($arguments)), type($result)) attr-dict </code></pre><code>pdl.range</code> operations construct a range from a given set of PDL entities, which all share the same underlying element type. For example, a <code>!pdl.range<value></code> may be constructed from a list of <code>!pdl.value</code> or <code>!pdl.range<value></code> entities.Example:<div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir>// Construct a range of values. %valueRange = pdl.range %inputValue, %inputRange : !pdl.value, !pdl.range<value> // Construct a range of types. %typeRange = pdl.range %inputType, %inputRange : !pdl.type, !pdl.range<type> // Construct an empty range of types. %valueRange = pdl.range : !pdl.range<type> </code></pre></div>TODO: Range construction is currently limited to rewrites, but it could be extended to constraints under certain circustances; i.e., if we can determine how to extract the underlying elements. If we can’t, e.g. if there are multiple sub ranges used for construction, we won’t be able to determine their sizes during constraint time.Traits: <code>AlwaysSpeculatableImplTrait</code>, <code>HasParent<pdl::RewriteOp></code>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code>Effects: <code>MemoryEffects::Effect{}</code><h4 id=operands-7>Operands: <a class=headline-hash href=#operands-7>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>arguments</code></td><td>variadic of pdl type</td></tr></tbody></table><h4 id=results-6>Results: <a class=headline-hash href=#results-6>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>result</code></td><td>range of PDL handle to an <code>mlir::Type</code> or PDL handle for an <code>mlir::Value</code> values</td></tr></tbody></table><h3 id=pdlreplace-pdlreplaceop><code>pdl.replace</code> (pdl::ReplaceOp) <a class=headline-hash href=#pdlreplace-pdlreplaceop>¶</a></h3>Mark an input operation as <code>replaced</code>Syntax:<pre tabindex=0><code>operation ::= `pdl.replace` $opValue `with` (`(` $replValues^ `:` type($replValues) `)`)? ($replOperation^)? attr-dict </code></pre><code>pdl.replace</code> operations are used within <code>pdl.rewrite</code> regions to specify that an input operation should be marked as replaced. The semantics of this operation correspond with the <code>replaceOp</code> method on a <code>PatternRewriter</code>. The set of replacement values can be either:<ul><li>a single <code>Operation</code> (<code>replOperation</code> should be populated)<ul><li>The operation will be replaced with the results of this operation.</li></ul></li><li>a set of <code>Value</code>s (<code>replValues</code> should be populated)<ul><li>The operation will be replaced with these values.</li></ul></li></ul>Example:<div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir>// Replace root node with 2 values: pdl.replace %root with (%val0, %val1 : !pdl.value, !pdl.value) // Replace root node with a range of values: pdl.replace %root with (%vals : !pdl.range<value>) // Replace root with another operation: pdl.replace %root with %otherOp </code></pre></div>Traits: <code>AttrSizedOperandSegments</code>, <code>HasParent<pdl::RewriteOp></code><h4 id=operands-8>Operands: <a class=headline-hash href=#operands-8>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>opValue</code></td><td>PDL handle to an <code>mlir::Operation *</code></td></tr><tr><td style=text-align:center><code>replOperation</code></td><td>PDL handle to an <code>mlir::Operation *</code></td></tr><tr><td style=text-align:center><code>replValues</code></td><td>variadic of single element or range of PDL handle for an <code>mlir::Value</code></td></tr></tbody></table><h3 id=pdlresult-pdlresultop><code>pdl.result</code> (pdl::ResultOp) <a class=headline-hash href=#pdlresult-pdlresultop>¶</a></h3>Extract a result from an operationSyntax:<pre tabindex=0><code>operation ::= `pdl.result` $index `of` $parent attr-dict </code></pre><code>pdl.result</code> operations extract result edges from an operation node within a pattern or rewrite region. The provided index is zero-based, and represents the concrete result to extract, i.e. this is not the result index as defined by the ODS definition of the operation.Example:<div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir>// Extract a result: %operation = pdl.operation ... %pdl_result = pdl.result 1 of %operation // Imagine the following IR being matched: %result_0, %result_1 = foo.op ... // If the example pattern snippet above were matching against `foo.op` in // the IR snippet, `%pdl_result` would correspond to `%result_1`. </code></pre></div>Traits: <code>AlwaysSpeculatableImplTrait</code>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code>Effects: <code>MemoryEffects::Effect{}</code><h4 id=attributes-5>Attributes: <a class=headline-hash href=#attributes-5>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>index</code></td><td>::mlir::IntegerAttr</td><td>32-bit signless integer attribute</td></tr></table><h4 id=operands-9>Operands: <a class=headline-hash href=#operands-9>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>parent</code></td><td>PDL handle to an <code>mlir::Operation *</code></td></tr></tbody></table><h4 id=results-7>Results: <a class=headline-hash href=#results-7>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>val</code></td><td>PDL handle for an <code>mlir::Value</code></td></tr></tbody></table><h3 id=pdlresults-pdlresultsop><code>pdl.results</code> (pdl::ResultsOp) <a class=headline-hash href=#pdlresults-pdlresultsop>¶</a></h3>Extract a result group from an operationSyntax:<pre tabindex=0><code>operation ::= `pdl.results` ($index^)? `of` $parent custom<ResultsValueType>(ref($index), type($val)) attr-dict </code></pre><code>pdl.results</code> operations extract a result group from an operation within a pattern or rewrite region. If an index is provided, this operation extracts a result group as defined by the ODS definition of the operation. In this case the result of this operation may be either a single <code>pdl.value</code> or a <code>pdl.range<value></code>, depending on the constraint of the result in ODS. If no index is provided, this operation extracts the full result range of the operation.Example:<div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir>// Extract all of the results of an operation: %operation = pdl.operation ... %results = pdl.results of %operation // Extract the results in the first result group of an operation, which is // variadic: %operation = pdl.operation ... %results = pdl.results 0 of %operation -> !pdl.range<value> // Extract the results in the second result group of an operation, which is // not variadic: %operation = pdl.operation ... %results = pdl.results 1 of %operation -> !pdl.value </code></pre></div>Traits: <code>AlwaysSpeculatableImplTrait</code>Interfaces: <code>ConditionallySpeculatable</code>, <code>NoMemoryEffect (MemoryEffectOpInterface)</code>Effects: <code>MemoryEffects::Effect{}</code><h4 id=attributes-6>Attributes: <a class=headline-hash href=#attributes-6>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>index</code></td><td>::mlir::IntegerAttr</td><td>32-bit signless integer attribute</td></tr></table><h4 id=operands-10>Operands: <a class=headline-hash href=#operands-10>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>parent</code></td><td>PDL handle to an <code>mlir::Operation *</code></td></tr></tbody></table><h4 id=results-8>Results: <a class=headline-hash href=#results-8>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>val</code></td><td>single element or range of PDL handle for an <code>mlir::Value</code></td></tr></tbody></table><h3 id=pdlrewrite-pdlrewriteop><code>pdl.rewrite</code> (pdl::RewriteOp) <a class=headline-hash href=#pdlrewrite-pdlrewriteop>¶</a></h3>Specify the rewrite of a matched patternSyntax:<pre tabindex=0><code>operation ::= `pdl.rewrite` ($root^)? (`with` $name^ (`(` $externalArgs^ `:` type($externalArgs) `)`)?)? ($bodyRegion^)? attr-dict-with-keyword </code></pre><code>pdl.rewrite</code> operations terminate the region of a <code>pdl.pattern</code> and specify the main rewrite of a <code>pdl.pattern</code>, on the optional root operation. The rewrite is specified either via a string name (<code>name</code>) to a native rewrite function, or via the region body. The rewrite region, if specified, must contain a single block. If the rewrite is external it functions similarly to <code>pdl.apply_native_rewrite</code>, and takes a set of additional positional values defined within the matcher as arguments. If the rewrite is external, the root operation is passed to the native function as the leading arguments. The root operation, if provided, specifies the starting point in the pattern for the subgraph isomorphism search. Pattern matching will proceed from this node downward (towards the defining operation) or upward (towards the users) until all the operations in the pattern have been matched. If the root is omitted, the pdl_interp lowering will automatically select the best root of the pdl.rewrite among all the operations in the pattern.Example:<div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir>// Specify an external rewrite function: pdl.rewrite %root with "myExternalRewriter"(%value : !pdl.value) // Specify a rewrite inline using PDL with the given root: pdl.rewrite %root { %op = pdl.operation "foo.op"(%arg0, %arg1) pdl.replace %root with %op } // Specify a rewrite inline using PDL, automatically selecting root: pdl.rewrite { %op1 = pdl.operation "foo.op"(%arg0, %arg1) %op2 = pdl.operation "bar.op"(%arg0, %arg1) pdl.replace %root1 with %op1 pdl.replace %root2 with %op2 } </code></pre></div>Traits: <code>AttrSizedOperandSegments</code>, <code>HasParent<pdl::PatternOp></code>, <code>NoRegionArguments</code>, <code>NoTerminator</code>, <code>SingleBlock</code>, <code>Terminator</code>Interfaces: <code>OpAsmOpInterface</code><h4 id=attributes-7>Attributes: <a class=headline-hash href=#attributes-7>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>name</code></td><td>::mlir::StringAttr</td><td>string attribute</td></tr></table><h4 id=operands-11>Operands: <a class=headline-hash href=#operands-11>¶</a></h4><table><thead><tr><th style=text-align:center>Operand</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>root</code></td><td>PDL handle to an <code>mlir::Operation *</code></td></tr><tr><td style=text-align:center><code>externalArgs</code></td><td>variadic of pdl type</td></tr></tbody></table><h3 id=pdltype-pdltypeop><code>pdl.type</code> (pdl::TypeOp) <a class=headline-hash href=#pdltype-pdltypeop>¶</a></h3>Define a type handle within a patternSyntax:<pre tabindex=0><code>operation ::= `pdl.type` attr-dict (`:` $constantType^)? </code></pre><code>pdl.type</code> operations capture result type constraints of <code>Attributes</code>, <code>Values</code>, and <code>Operations</code>. Instances of this operation define, and partially constrain, results types of a given entity. A <code>pdl.type</code> may partially constrain the result by specifying a constant <code>Type</code>.Example:<div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir>// Define a type: %type = pdl.type // Define a type with a constant value: %type = pdl.type : i32 </code></pre></div><h4 id=attributes-8>Attributes: <a class=headline-hash href=#attributes-8>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>constantType</code></td><td>::mlir::TypeAttr</td><td>any type attribute</td></tr></table><h4 id=results-9>Results: <a class=headline-hash href=#results-9>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>result</code></td><td>PDL handle to an <code>mlir::Type</code></td></tr></tbody></table><h3 id=pdltypes-pdltypesop><code>pdl.types</code> (pdl::TypesOp) <a class=headline-hash href=#pdltypes-pdltypesop>¶</a></h3>Define a range of type handles within a patternSyntax:<pre tabindex=0><code>operation ::= `pdl.types` attr-dict (`:` $constantTypes^)? </code></pre><code>pdl.types</code> operations capture result type constraints of <code>Value</code>s, and <code>Operation</code>s. Instances of this operation define results types of a given entity. A <code>pdl.types</code> may partially constrain the results by specifying an array of <code>Type</code>s.Example:<div class=highlight><pre tabindex=0 class=chroma><code class=language-mlir data-lang=mlir>// Define a range of types: %types = pdl.types // Define a range of types with a range of constant values: %types = pdl.types : [i32, i64, i32] </code></pre></div><h4 id=attributes-9>Attributes: <a class=headline-hash href=#attributes-9>¶</a></h4><table><tr><th>Attribute</th><th>MLIR Type</th><th>Description</th></tr><tr><td><code>constantTypes</code></td><td>::mlir::ArrayAttr</td><td>type array attribute</td></tr></table><h4 id=results-10>Results: <a class=headline-hash href=#results-10>¶</a></h4><table><thead><tr><th style=text-align:center>Result</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center><code>result</code></td><td>range of PDL handle to an <code>mlir::Type</code> values</td></tr></tbody></table><h2 id=types>Types <a class=headline-hash href=#types>¶</a></h2><h3 id=attributetype>AttributeType <a class=headline-hash href=#attributetype>¶</a></h3>PDL handle to an <code>mlir::Attribute</code>Syntax: <code>!pdl.attribute</code>This type represents a handle to an instance of an <code>mlir::Attribute</code>, bound to a value that is usable within a PDL pattern or rewrite.<h3 id=operationtype>OperationType <a class=headline-hash href=#operationtype>¶</a></h3>PDL handle to an <code>mlir::Operation *</code>Syntax: <code>!pdl.operation</code>This type represents a handle to an instance of an <code>mlir::Operation *</code>, bound to a value that is usable within a PDL pattern or rewrite.<h3 id=rangetype>RangeType <a class=headline-hash href=#rangetype>¶</a></h3>PDL handle to a range of a given sub-typeThis type represents a range of instances of the given PDL element type, i.e. <code>Attribute</code>, <code>Operation</code>, <code>Type</code>, or <code>Value</code>.<h4 id=parameters>Parameters: <a class=headline-hash href=#parameters>¶</a></h4><table><thead><tr><th style=text-align:center>Parameter</th><th style=text-align:center>C++ type</th><th>Description</th></tr></thead><tbody><tr><td style=text-align:center>elementType</td><td style=text-align:center><code>Type</code></td><td></td></tr></tbody></table><h3 id=typetype>TypeType <a class=headline-hash href=#typetype>¶</a></h3>PDL handle to an <code>mlir::Type</code>Syntax: <code>!pdl.type</code>This type represents a handle to an instance of an <code>mlir::Type</code>, bound to a value that is usable within a PDL pattern or rewrite.<h3 id=valuetype>ValueType <a class=headline-hash href=#valuetype>¶</a></h3>PDL handle for an <code>mlir::Value</code>Syntax: <code>!pdl.value</code>This type represents a handle to an instance of an <code>mlir::Value</code>, bound to a value that is usable within a PDL pattern or rewrite.<div class=edit-meta> </div><nav class=pagination><a class="nav nav-prev" href=https://mlir.llvm.org/docs/Dialects/PDLInterpOps/ title="'pdl_interp' Dialect"> Prev - 'pdl_interp' Dialect</a> <a class="nav nav-next" href=https://mlir.llvm.org/docs/Dialects/PolynomialDialect/ title="'polynomial' Dialect">Next - 'polynomial' Dialect </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/BufferDeallocationInternals/>Buffer Deallocation - Internals</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/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="parent 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/DLTITransformOps/></a></li><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 class=active><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=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=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><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>