| //===- PDLDialect.td - PDL dialect definition --------------*- tablegen -*-===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // Defines the MLIR PDL dialect. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef MLIR_DIALECT_PDL_IR_PDLDIALECT |
| #define MLIR_DIALECT_PDL_IR_PDLDIALECT |
| |
| include "mlir/IR/OpBase.td" |
| |
| //===----------------------------------------------------------------------===// |
| // PDL Dialect |
| //===----------------------------------------------------------------------===// |
| |
| def PDL_Dialect : Dialect { |
| string summary = "High level pattern definition dialect"; |
| string description = [{ |
| PDL presents a high level abstraction for the rewrite pattern infrastructure |
| available in MLIR. This abstraction allows for representing patterns |
| transforming MLIR, as MLIR. This allows for applying all of the benefits |
| that the general MLIR infrastructure provides, to the infrastructure itself. |
| This means that pattern matching can be more easily verified for |
| correctness, targeted by frontends, and optimized. |
| |
| PDL abstracts over various different aspects of patterns and core MLIR data |
| structures. Patterns are specified via a `pdl.pattern` operation. These |
| operations contain a region body for the "matcher" code, and terminate with |
| a `pdl.rewrite` that either dispatches to an external rewriter or contains |
| a region for the rewrite specified via `pdl`. The types of values in `pdl` |
| are handle types to MLIR C++ types, with `!pdl.attribute`, `!pdl.operation`, |
| `!pdl.value`, and `!pdl.type` directly mapping to `mlir::Attribute`, |
| `mlir::Operation*`, `mlir::Value`, and `mlir::Type` respectively. |
| |
| An example pattern is shown below: |
| |
| ```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) |
| } |
| } |
| ``` |
| |
| 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. |
| }]; |
| |
| let name = "pdl"; |
| let cppNamespace = "::mlir::pdl"; |
| let extraClassDeclaration = [{ |
| void registerTypes(); |
| }]; |
| } |
| |
| #endif // MLIR_DIALECT_PDL_IR_PDLDIALECT |