1//===- TestTransformDialectExtension.td --------------------*- tablegen -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file declares the operations that are injected into the Transform
10// dialect through the extension mechanism, as a test.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef MLIR_TESTTRANSFORMDIALECTEXTENSION_TD
15#define MLIR_TESTTRANSFORMDIALECTEXTENSION_TD
16
17include "mlir/IR/OpBase.td"
18include "mlir/Dialect/Transform/IR/TransformDialect.td"
19include "mlir/Dialect/Transform/IR/TransformEffects.td"
20include "mlir/Dialect/Transform/IR/TransformInterfaces.td"
21include "mlir/Dialect/PDL/IR/PDLTypes.td"
22
23def TestProduceParamOrForwardOperandOp
24  : Op<Transform_Dialect, "test_produce_param_or_forward_operand",
25       [DeclareOpInterfaceMethods<TransformOpInterface>]> {
26  let arguments = (ins
27     Arg<Optional<PDL_Operation>, "", [TransformMappingRead]>:$operand,
28     OptionalAttr<I64Attr>:$parameter);
29  let results = (outs
30     Res<PDL_Operation, "",
31         [TransformMappingAlloc, TransformMappingWrite]>:$res);
32  let assemblyFormat = "(`from` $operand^)? ($parameter^)? attr-dict";
33  let cppNamespace = "::mlir::test";
34  let hasVerifier = 1;
35}
36
37def TestConsumeOperand : Op<Transform_Dialect, "test_consume_operand",
38     [DeclareOpInterfaceMethods<TransformOpInterface>]> {
39  let arguments = (ins
40    Arg<PDL_Operation, "",
41        [TransformMappingRead, TransformMappingFree]>:$operand);
42  let assemblyFormat = "$operand attr-dict";
43  let cppNamespace = "::mlir::test";
44}
45
46def TestConsumeOperandIfMatchesParamOrFail
47  : Op<Transform_Dialect, "test_consume_operand_if_matches_param_or_fail",
48       [DeclareOpInterfaceMethods<TransformOpInterface>]> {
49  let arguments = (ins
50    Arg<PDL_Operation, "",
51        [TransformMappingRead, TransformMappingFree]>:$operand,
52    I64Attr:$parameter);
53  let assemblyFormat = "$operand `[` $parameter `]` attr-dict";
54  let cppNamespace = "::mlir::test";
55}
56
57def TestPrintRemarkAtOperandOp
58  : Op<Transform_Dialect, "test_print_remark_at_operand",
59       [DeclareOpInterfaceMethods<TransformOpInterface>]> {
60  let arguments = (ins
61    Arg<PDL_Operation, "",
62        [TransformMappingRead, PayloadIRRead]>:$operand,
63    StrAttr:$message);
64  let assemblyFormat = "$operand `,` $message attr-dict";
65  let cppNamespace = "::mlir::test";
66}
67
68def TestAddTestExtensionOp
69  : Op<Transform_Dialect, "test_add_test_extension",
70       [DeclareOpInterfaceMethods<TransformOpInterface>,
71        NoSideEffect]> {
72  let arguments = (ins StrAttr:$message);
73  let assemblyFormat = "$message attr-dict";
74  let cppNamespace = "::mlir::test";
75}
76
77def TestCheckIfTestExtensionPresentOp
78  : Op<Transform_Dialect, "test_check_if_test_extension_present",
79       [DeclareOpInterfaceMethods<TransformOpInterface>]> {
80  let arguments = (ins
81    Arg<PDL_Operation, "", [TransformMappingRead, PayloadIRRead]>:$operand);
82  let assemblyFormat = "$operand attr-dict";
83  let cppNamespace = "::mlir::test";
84}
85
86def TestRemapOperandPayloadToSelfOp
87  : Op<Transform_Dialect, "test_remap_operand_to_self",
88       [DeclareOpInterfaceMethods<TransformOpInterface>]> {
89  let arguments = (ins
90    Arg<PDL_Operation, "",
91        [TransformMappingRead, TransformMappingWrite, PayloadIRRead]>:$operand);
92  let assemblyFormat = "$operand attr-dict";
93  let cppNamespace = "::mlir::test";
94}
95
96def TestRemoveTestExtensionOp
97  : Op<Transform_Dialect, "test_remove_test_extension",
98       [DeclareOpInterfaceMethods<TransformOpInterface>,
99        NoSideEffect]> {
100  let assemblyFormat = "attr-dict";
101  let cppNamespace = "::mlir::test";
102}
103
104def TestReversePayloadOpsOp
105  : Op<Transform_Dialect, "test_reverse_payload_ops",
106    [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,
107     DeclareOpInterfaceMethods<TransformOpInterface>]> {
108  let arguments = (ins PDL_Operation:$target);
109  let results = (outs PDL_Operation:$result);
110  let assemblyFormat = "$target attr-dict";
111  let cppNamespace = "::mlir::test";
112}
113
114def TestTransformOpWithRegions
115  : Op<Transform_Dialect, "test_transform_op_with_regions",
116       [DeclareOpInterfaceMethods<TransformOpInterface>,
117        DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
118  let regions = (region AnyRegion:$first, AnyRegion:$second);
119  let assemblyFormat = "attr-dict-with-keyword regions";
120  let cppNamespace = "::mlir::test";
121}
122
123def TestBranchingTransformOpTerminator
124  : Op<Transform_Dialect, "test_branching_transform_op_terminator",
125       [Terminator, DeclareOpInterfaceMethods<TransformOpInterface>,
126        DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
127  let successors = (successor VariadicSuccessor<AnySuccessor>:$succ);
128  let cppNamespace = "::mlir::test";
129}
130
131def TestEmitRemarkAndEraseOperandOp
132  : Op<Transform_Dialect, "test_emit_remark_and_erase_operand",
133    [DeclareOpInterfaceMethods<TransformOpInterface>,
134     MemoryEffectsOpInterface, FunctionalStyleTransformOpTrait]> {
135  let arguments = (ins PDL_Operation:$target, StrAttr:$remark,
136                   UnitAttr:$fail_after_erase);
137  let assemblyFormat = "$target `,` $remark attr-dict";
138  let cppNamespace = "::mlir::test";
139}
140
141def TestWrongNumberOfResultsOp
142  : Op<Transform_Dialect, "test_wrong_number_of_results",
143    [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,
144     TransformEachOpTrait, TransformOpInterface]> {
145  let arguments = (ins PDL_Operation:$target);
146  let results = (outs PDL_Operation:$a,
147                      PDL_Operation:$b,
148                      PDL_Operation:$c);
149  let assemblyFormat = "$target attr-dict";
150  let cppNamespace = "::mlir::test";
151  let extraClassDeclaration = [{
152    ::mlir::DiagnosedSilenceableFailure applyToOne(
153        ::mlir::Operation * target,
154        ::llvm::SmallVectorImpl<::mlir::Operation *> &results,
155        ::mlir::transform::TransformState &state);
156  }];
157}
158
159def TestWrongNumberOfMultiResultsOp
160  : Op<Transform_Dialect, "test_wrong_number_of_multi_results",
161    [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,
162     TransformEachOpTrait, TransformOpInterface]> {
163  let arguments = (ins PDL_Operation:$target);
164  let results = (outs PDL_Operation:$result);
165  let assemblyFormat = "$target attr-dict";
166  let cppNamespace = "::mlir::test";
167  let extraClassDeclaration = [{
168    ::mlir::DiagnosedSilenceableFailure applyToOne(
169        ::mlir::Operation * target,
170        ::llvm::SmallVectorImpl<::mlir::Operation *> &results,
171        ::mlir::transform::TransformState &state);
172  }];
173}
174
175def TestCorrectNumberOfMultiResultsOp
176  : Op<Transform_Dialect, "test_correct_number_of_multi_results",
177    [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,
178     TransformEachOpTrait, TransformOpInterface]> {
179  let arguments = (ins PDL_Operation:$target);
180  let results = (outs PDL_Operation:$result1,
181                      PDL_Operation:$result2);
182  let assemblyFormat = "$target attr-dict";
183  let cppNamespace = "::mlir::test";
184  let extraClassDeclaration = [{
185    ::mlir::DiagnosedSilenceableFailure applyToOne(
186        ::mlir::Operation * target,
187        ::llvm::SmallVectorImpl<::mlir::Operation *> &results,
188        ::mlir::transform::TransformState &state);
189  }];
190}
191
192def TestMixedNullAndNonNullResultsOp
193  : Op<Transform_Dialect, "test_mixed_null_and_non_null_results",
194    [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,
195     TransformEachOpTrait, TransformOpInterface]> {
196  let arguments = (ins PDL_Operation:$target);
197  let results = (outs PDL_Operation:$null,
198                      PDL_Operation:$non_null);
199  let assemblyFormat = "$target attr-dict";
200  let cppNamespace = "::mlir::test";
201  let extraClassDeclaration = [{
202    ::mlir::DiagnosedSilenceableFailure applyToOne(
203        ::mlir::Operation * target,
204        ::llvm::SmallVectorImpl<::mlir::Operation *> &results,
205        ::mlir::transform::TransformState &state);
206  }];
207}
208
209def TestMixedSuccessAndSilenceableOp
210  : Op<Transform_Dialect, "test_mixed_sucess_and_silenceable",
211    [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,
212     TransformEachOpTrait, TransformOpInterface]> {
213  let arguments = (ins PDL_Operation:$target);
214  let results = (outs);
215  let assemblyFormat = "$target attr-dict";
216  let cppNamespace = "::mlir::test";
217  let extraClassDeclaration = [{
218    ::mlir::DiagnosedSilenceableFailure applyToOne(
219        ::mlir::Operation * target,
220        ::llvm::SmallVectorImpl<::mlir::Operation *> &results,
221        ::mlir::transform::TransformState &state);
222  }];
223}
224
225def TestPrintNumberOfAssociatedPayloadIROps
226  : Op<Transform_Dialect, "test_print_number_of_associated_payload_ir_ops",
227       [DeclareOpInterfaceMethods<TransformOpInterface>,
228        DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
229  let arguments = (ins PDL_Operation:$handle);
230  let assemblyFormat = "$handle attr-dict";
231  let cppNamespace = "::mlir::test";
232}
233
234#endif // MLIR_TESTTRANSFORMDIALECTEXTENSION_TD
235