80 lines
2.9 KiB
TableGen
80 lines
2.9 KiB
TableGen
//===- IRDL.td - IR Definition Language Dialect ------------*- tablegen -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file declares the IR Definition Language dialect.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef MLIR_DIALECT_IRDL_IR_IRDL
|
|
#define MLIR_DIALECT_IRDL_IR_IRDL
|
|
|
|
include "mlir/IR/OpBase.td"
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// IRDL Dialect
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
def IRDL_Dialect : Dialect {
|
|
let summary = "IR Definition Language Dialect";
|
|
let description = [{
|
|
IRDL is an SSA-based declarative representation of dynamic dialects.
|
|
It allows the definition of dialects, operations, attributes, and types,
|
|
with a declarative description of their verifiers. IRDL code is meant to
|
|
be generated and not written by hand. As such, the design focuses on ease
|
|
of generation/analysis instead of ease of writing/reading.
|
|
|
|
Users can define a new dialect with `irdl.dialect`, operations with
|
|
`irdl.operation`, types with `irdl.type`, and attributes with
|
|
`irdl.attribute`.
|
|
|
|
An example dialect is shown below:
|
|
|
|
```mlir
|
|
irdl.dialect @cmath {
|
|
irdl.type @complex {
|
|
%0 = irdl.is f32
|
|
%1 = irdl.is f64
|
|
%2 = irdl.any_of(%0, %1)
|
|
irdl.parameters(%2)
|
|
}
|
|
|
|
irdl.operation @mul {
|
|
%0 = irdl.is f32
|
|
%1 = irdl.is f64
|
|
%2 = irdl.any_of(%0, %1)
|
|
%3 = irdl.parametric @cmath::@complex<%2>
|
|
irdl.operands(%3, %3)
|
|
irdl.results(%3)
|
|
}
|
|
}
|
|
```
|
|
|
|
This program defines a `cmath` dialect that defines a `complex` type, and
|
|
a `mul` operation. Both express constraints over their parameters using
|
|
SSA constraint operations. Informally, one can see those SSA values as
|
|
constraint variables that evaluate to a single type at constraint
|
|
evaluation. For example, the result of the `irdl.any_of` stored in `%2`
|
|
in the `mul` operation will collapse into either `f32` or `f64` for the
|
|
entirety of this instance of `mul` constraint evaluation. As such,
|
|
both operands and the result of `mul` must be of equal type (and not just
|
|
satisfy the same constraint).
|
|
|
|
IRDL variables are handle over `mlir::Attribute`. In order to support
|
|
manipulating `mlir::Type`, IRDL wraps all types in an `mlir::TypeAttr`
|
|
attribute. The rationale of this is to simplify the dialect.
|
|
}];
|
|
|
|
let useDefaultAttributePrinterParser = 1;
|
|
let useDefaultTypePrinterParser = 1;
|
|
|
|
let name = "irdl";
|
|
let cppNamespace = "::mlir::irdl";
|
|
}
|
|
|
|
#endif // MLIR_DIALECT_IRDL_IR_IRDL
|