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 TestTransformOpWithRegions
105  : Op<Transform_Dialect, "test_transform_op_with_regions",
106       [DeclareOpInterfaceMethods<TransformOpInterface>,
107        DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
108  let regions = (region AnyRegion:$first, AnyRegion:$second);
109  let assemblyFormat = "attr-dict-with-keyword regions";
110  let cppNamespace = "::mlir::test";
111}
112
113def TestBranchingTransformOpTerminator
114  : Op<Transform_Dialect, "test_branching_transform_op_terminator",
115       [Terminator, DeclareOpInterfaceMethods<TransformOpInterface>,
116        DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
117  let successors = (successor VariadicSuccessor<AnySuccessor>:$succ);
118  let cppNamespace = "::mlir::test";
119}
120
121def TestEmitRemarkAndEraseOperandOp
122  : Op<Transform_Dialect, "test_emit_remark_and_erase_operand",
123    [DeclareOpInterfaceMethods<TransformOpInterface>,
124     MemoryEffectsOpInterface, FunctionalStyleTransformOpTrait]> {
125  let arguments = (ins PDL_Operation:$target, StrAttr:$remark,
126                   UnitAttr:$fail_after_erase);
127  let assemblyFormat = "$target `,` $remark attr-dict";
128  let cppNamespace = "::mlir::test";
129}
130
131def TestWrongNumberOfResultsOp
132  : Op<Transform_Dialect, "test_wrong_number_of_results",
133    [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,
134     TransformEachOpTrait, TransformOpInterface]> {
135  let arguments = (ins PDL_Operation:$target);
136  let results = (outs PDL_Operation:$a,
137                      PDL_Operation:$b,
138                      PDL_Operation:$c);
139  let assemblyFormat = "$target attr-dict";
140  let cppNamespace = "::mlir::test";
141  let extraClassDeclaration = [{
142    ::mlir::DiagnosedSilenceableFailure applyToOne(
143        ::mlir::Operation * target,
144        ::llvm::SmallVectorImpl<::mlir::Operation *> &results,
145        ::mlir::transform::TransformState &state);
146  }];
147}
148
149def TestWrongNumberOfMultiResultsOp
150  : Op<Transform_Dialect, "test_wrong_number_of_multi_results",
151    [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,
152     TransformEachOpTrait, TransformOpInterface]> {
153  let arguments = (ins PDL_Operation:$target);
154  let results = (outs PDL_Operation:$result);
155  let assemblyFormat = "$target attr-dict";
156  let cppNamespace = "::mlir::test";
157  let extraClassDeclaration = [{
158    ::mlir::DiagnosedSilenceableFailure applyToOne(
159        ::mlir::Operation * target,
160        ::llvm::SmallVectorImpl<::mlir::Operation *> &results,
161        ::mlir::transform::TransformState &state);
162  }];
163}
164
165def TestCorrectNumberOfMultiResultsOp
166  : Op<Transform_Dialect, "test_correct_number_of_multi_results",
167    [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,
168     TransformEachOpTrait, TransformOpInterface]> {
169  let arguments = (ins PDL_Operation:$target);
170  let results = (outs PDL_Operation:$result1,
171                      PDL_Operation:$result2);
172  let assemblyFormat = "$target attr-dict";
173  let cppNamespace = "::mlir::test";
174  let extraClassDeclaration = [{
175    ::mlir::DiagnosedSilenceableFailure applyToOne(
176        ::mlir::Operation * target,
177        ::llvm::SmallVectorImpl<::mlir::Operation *> &results,
178        ::mlir::transform::TransformState &state);
179  }];
180}
181
182def TestMixedNullAndNonNullResultsOp
183  : Op<Transform_Dialect, "test_mixed_null_and_non_null_results",
184    [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,
185     TransformEachOpTrait, TransformOpInterface]> {
186  let arguments = (ins PDL_Operation:$target);
187  let results = (outs PDL_Operation:$null,
188                      PDL_Operation:$non_null);
189  let assemblyFormat = "$target attr-dict";
190  let cppNamespace = "::mlir::test";
191  let extraClassDeclaration = [{
192    ::mlir::DiagnosedSilenceableFailure applyToOne(
193        ::mlir::Operation * target,
194        ::llvm::SmallVectorImpl<::mlir::Operation *> &results,
195        ::mlir::transform::TransformState &state);
196  }];
197}
198
199def TestMixedSuccessAndSilenceableOp
200  : Op<Transform_Dialect, "test_mixed_sucess_and_silenceable",
201    [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,
202     TransformEachOpTrait, TransformOpInterface]> {
203  let arguments = (ins PDL_Operation:$target);
204  let results = (outs);
205  let assemblyFormat = "$target attr-dict";
206  let cppNamespace = "::mlir::test";
207  let extraClassDeclaration = [{
208    ::mlir::DiagnosedSilenceableFailure applyToOne(
209        ::mlir::Operation * target,
210        ::llvm::SmallVectorImpl<::mlir::Operation *> &results,
211        ::mlir::transform::TransformState &state);
212  }];
213}
214
215def TestPrintNumberOfAssociatedPayloadIROps
216  : Op<Transform_Dialect, "test_print_number_of_associated_payload_ir_ops",
217       [DeclareOpInterfaceMethods<TransformOpInterface>,
218        DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
219  let arguments = (ins PDL_Operation:$handle);
220  let assemblyFormat = "$handle attr-dict";
221  let cppNamespace = "::mlir::test";
222}
223
224#endif // MLIR_TESTTRANSFORMDIALECTEXTENSION_TD
225