75 lines
3.0 KiB
TableGen
75 lines
3.0 KiB
TableGen
//===- 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 {
|
|
let summary = "High level pattern definition dialect";
|
|
let 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 useDefaultTypePrinterParser = 1;
|
|
let extraClassDeclaration = [{
|
|
void registerTypes();
|
|
}];
|
|
}
|
|
|
|
#endif // MLIR_DIALECT_PDL_IR_PDLDIALECT
|