faf42264e5
These functions allow for defining pattern fragments usable within the `match` and `rewrite` sections of a pattern. The main structure of Constraints and Rewrites functions are the same, and are similar to functions in other languages; they contain a signature (i.e. name, argument list, result list) and a body:
```pdll
// Constraint that takes a value as an input, and produces a value:
Constraint Cst(arg: Value) -> Value { ... }
// Constraint that returns multiple values:
Constraint Cst() -> (result1: Value, result2: ValueRange);
```
When returning multiple results, each result can be optionally be named (the result of a Constraint/Rewrite in the case of multiple results is a tuple).
These body of a Constraint/Rewrite functions can be specified in several ways:
* Externally
In this case we are importing an external function (registered by the user outside of PDLL):
```pdll
Constraint Foo(op: Op);
Rewrite Bar();
```
* In PDLL (using PDLL constructs)
In this case, the body is defined using PDLL constructs:
```pdll
Rewrite BuildFooOp() {
// The result type of the Rewrite is inferred from the return.
return op<my_dialect.foo>;
}
// Constraints/Rewrites can also implement a lambda/expression
// body for simple one line bodies.
Rewrite BuildFooOp() => op<my_dialect.foo>;
```
* In PDLL (using a native/C++ code block)
In this case the body is specified using a C++(or potentially other language at some point) code block. When building PDLL in AOT mode this will generate a native constraint/rewrite and register it with the PDL bytecode.
```pdll
Rewrite BuildFooOp() -> Op<my_dialect.foo> [{
return rewriter.create<my_dialect::FooOp>(...);
}];
```
Differential Revision: https://reviews.llvm.org/D115836
94 lines
1.9 KiB
Plaintext
94 lines
1.9 KiB
Plaintext
// RUN: not mlir-pdll %s -split-input-file 2>&1 | FileCheck %s
|
|
|
|
// CHECK: expected `{` or `=>` to start pattern body
|
|
Pattern }
|
|
|
|
// -----
|
|
|
|
// CHECK: :6:9: error: `Foo` has already been defined
|
|
// CHECK: :5:9: note: see previous definition here
|
|
Pattern Foo { erase root: Op; }
|
|
Pattern Foo { erase root: Op; }
|
|
|
|
// -----
|
|
|
|
// CHECK: `return` statements are only permitted within a `Constraint` or `Rewrite` body
|
|
Pattern {
|
|
return _: Value;
|
|
}
|
|
|
|
// -----
|
|
|
|
// CHECK: expected Pattern body to terminate with an operation rewrite statement
|
|
Pattern {
|
|
let value: Value;
|
|
}
|
|
|
|
// -----
|
|
|
|
// CHECK: Pattern body was terminated by an operation rewrite statement, but found trailing statements
|
|
Pattern {
|
|
erase root: Op;
|
|
let value: Value;
|
|
}
|
|
|
|
// -----
|
|
|
|
// CHECK: expected Pattern lambda body to contain a single operation rewrite statement, such as `erase`, `replace`, or `rewrite`
|
|
Pattern => op<>;
|
|
|
|
// -----
|
|
|
|
Rewrite SomeRewrite();
|
|
|
|
// CHECK: unable to invoke `Rewrite` within a match section
|
|
Pattern {
|
|
SomeRewrite();
|
|
}
|
|
|
|
// -----
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Metadata
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// CHECK: expected pattern metadata identifier
|
|
Pattern with {}
|
|
|
|
// -----
|
|
|
|
// CHECK: unknown pattern metadata
|
|
Pattern with unknown {}
|
|
|
|
// -----
|
|
|
|
// CHECK: expected `(` before pattern benefit
|
|
Pattern with benefit) {}
|
|
|
|
// -----
|
|
|
|
// CHECK: expected integral pattern benefit
|
|
Pattern with benefit(foo) {}
|
|
|
|
// -----
|
|
|
|
// CHECK: expected pattern benefit to fit within a 16-bit integer
|
|
Pattern with benefit(65536) {}
|
|
|
|
// -----
|
|
|
|
// CHECK: expected `)` after pattern benefit
|
|
Pattern with benefit(1( {}
|
|
|
|
// -----
|
|
|
|
// CHECK: pattern benefit has already been specified
|
|
// CHECK: see previous definition here
|
|
Pattern with benefit(1), benefit(1) {}
|
|
|
|
// -----
|
|
|
|
// CHECK: pattern recursion metadata has already been specified
|
|
// CHECK: see previous definition here
|
|
Pattern with recursion, recursion {}
|