562 lines · plain
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-exception6//7//===----------------------------------------------------------------------===//8//9// This file declares the operations that are injected into the Transform10// dialect through the extension mechanism, as a test.11//12//===----------------------------------------------------------------------===//13 14#ifndef MLIR_TESTTRANSFORMDIALECTEXTENSION_TD15#define MLIR_TESTTRANSFORMDIALECTEXTENSION_TD16 17include "mlir/Interfaces/SideEffectInterfaces.td"18include "mlir/IR/AttrTypeBase.td"19include "mlir/IR/OpBase.td"20include "mlir/Dialect/Transform/Interfaces/MatchInterfaces.td"21include "mlir/Dialect/Transform/IR/TransformDialect.td"22include "mlir/Dialect/Transform/Interfaces/TransformInterfaces.td"23include "mlir/Dialect/PDL/IR/PDLTypes.td"24 25def TestTransformTestDialectHandleType26 : TypeDef<Transform_Dialect, "TestDialectOp",27 [DeclareTypeInterfaceMethods<TransformHandleTypeInterface>]> {28 let description = [{Handle pointing to an op from the Test dialect.}];29 let mnemonic = "test_dialect_op";30 let assemblyFormat = "";31}32 33def TestTransformTestDialectParamType34 : TypeDef<Transform_Dialect, "TestDialectParam",35 [DeclareTypeInterfaceMethods<TransformParamTypeInterface>]> {36 let description = [{37 Parameter associated with an i32 attribute for testing purposes.38 }];39 let mnemonic = "test_dialect_param";40 let assemblyFormat = "";41}42 43def TestProduceSelfHandleOrForwardOperandOp44 : Op<Transform_Dialect, "test_produce_self_handle_or_forward_operand",45 [DeclareOpInterfaceMethods<TransformOpInterface>,46 DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {47 let arguments = (ins Optional<TransformHandleTypeInterface>:$operand);48 let results = (outs TransformHandleTypeInterface:$res);49 let assemblyFormat =50 "($operand^)? attr-dict `:` functional-type($operand, $res)";51 let cppNamespace = "::mlir::test";52}53 54def TestProduceValueHandleToSelfOperand55 : Op<Transform_Dialect, "test_produce_value_handle_to_self_operand",56 [DeclareOpInterfaceMethods<TransformOpInterface>,57 DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {58 let arguments = (ins TransformHandleTypeInterface:$in);59 let results = (outs TransformValueHandleTypeInterface:$out);60 let assemblyFormat = "$in attr-dict `:` functional-type(operands, results)";61 let cppNamespace = "::mlir::test";62}63 64def TestProduceValueHandleToResult65 : Op<Transform_Dialect, "test_produce_value_handle_to_result",66 [TransformEachOpTrait, TransformOpInterface,67 DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {68 let arguments = (ins TransformHandleTypeInterface:$in,69 I64Attr:$number);70 let results = (outs TransformValueHandleTypeInterface:$out);71 let assemblyFormat = "$in `,` $number attr-dict `:` functional-type(operands, results)";72 let cppNamespace = "::mlir::test";73 let extraClassDeclaration = [{74 ::mlir::DiagnosedSilenceableFailure applyToOne(75 ::mlir::transform::TransformRewriter &rewriter,76 ::mlir::Operation *target,77 ::mlir::transform::ApplyToEachResultList &results,78 ::mlir::transform::TransformState &state);79 }];80}81 82def TestProduceValueHandleToArgumentOfParentBlock83 : Op<Transform_Dialect, "test_produce_value_handle_to_argument_of_parent_block",84 [TransformEachOpTrait, TransformOpInterface,85 DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {86 let arguments = (ins TransformHandleTypeInterface:$in,87 I64Attr:$number);88 let results = (outs TransformValueHandleTypeInterface:$out);89 let assemblyFormat = "$in `,` $number attr-dict `:` functional-type(operands, results)";90 let cppNamespace = "::mlir::test";91 let extraClassDeclaration = [{92 ::mlir::DiagnosedSilenceableFailure applyToOne(93 ::mlir::transform::TransformRewriter &rewriter,94 ::mlir::Operation *target,95 ::mlir::transform::ApplyToEachResultList &results,96 ::mlir::transform::TransformState &state);97 }];98}99 100def TestConsumeOperand : Op<Transform_Dialect, "test_consume_operand",101 [DeclareOpInterfaceMethods<TransformOpInterface, ["allowsRepeatedHandleOperands"]>,102 DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {103 let arguments = (ins104 Transform_AnyHandleOrParamType:$operand,105 Optional<TransformHandleTypeInterface>:$second_operand,106 UnitAttr:$allow_repeated_handles);107 let assemblyFormat = 108 "$operand (`,` $second_operand^)? attr-dict `:` type($operand)"109 "(`,` type($second_operand)^)?";110 let cppNamespace = "::mlir::test";111}112 113def TestConsumeOperandEach : Op<Transform_Dialect, "test_consume_operand_each",114 [TransformOpInterface, TransformEachOpTrait,115 MemoryEffectsOpInterface, FunctionalStyleTransformOpTrait]> {116 let arguments = (ins TransformHandleTypeInterface:$target);117 let assemblyFormat = "$target attr-dict `:` type($target)";118 let cppNamespace = "::mlir::test";119 let extraClassDeclaration = [{120 ::mlir::DiagnosedSilenceableFailure applyToOne(121 ::mlir::transform::TransformRewriter &rewriter,122 ::mlir::Operation *target,123 ::mlir::transform::ApplyToEachResultList &results,124 ::mlir::transform::TransformState &state) {125 return ::mlir::DiagnosedSilenceableFailure::success();126 }127 }];128}129 130def TestConsumeOperandOfOpKindOrFail131 : Op<Transform_Dialect, "test_consume_operand_of_op_kind_or_fail",132 [DeclareOpInterfaceMethods<TransformOpInterface>,133 DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {134 let arguments = (ins135 TransformHandleTypeInterface:$operand,136 StrAttr:$op_kind);137 let assemblyFormat =138 "$operand `,` $op_kind attr-dict `:` type($operand)";139 let cppNamespace = "::mlir::test";140}141 142def TestSucceedIfOperandOfOpKind143 : Op<Transform_Dialect, "test_succeed_if_operand_of_op_kind",144 [MatchOpInterface,145 SingleOpMatcher,146 DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {147 let arguments = (ins148 TransformHandleTypeInterface:$operand_handle,149 StrAttr:$op_kind);150 let assemblyFormat =151 "$operand_handle `,` $op_kind attr-dict `:` type($operand_handle)";152 let extraClassDeclaration = SingleOpMatcher.extraDeclaration;153 let cppNamespace = "::mlir::test";154}155 156def TestAddTestExtensionOp157 : Op<Transform_Dialect, "test_add_test_extension",158 [DeclareOpInterfaceMethods<TransformOpInterface>,159 NoMemoryEffect]> {160 let arguments = (ins StrAttr:$message);161 let assemblyFormat = "$message attr-dict";162 let cppNamespace = "::mlir::test";163}164 165def TestCheckIfTestExtensionPresentOp166 : Op<Transform_Dialect, "test_check_if_test_extension_present",167 [DeclareOpInterfaceMethods<TransformOpInterface>,168 DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {169 let arguments = (ins TransformHandleTypeInterface:$operand);170 let assemblyFormat = "$operand attr-dict `:` type($operand)";171 let cppNamespace = "::mlir::test";172}173 174def TestRemapOperandPayloadToSelfOp175 : Op<Transform_Dialect, "test_remap_operand_to_self",176 [DeclareOpInterfaceMethods<TransformOpInterface>,177 DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {178 let arguments = (ins TransformHandleTypeInterface:$operand);179 let results = (outs Optional<TransformHandleTypeInterface>:$out); 180 let assemblyFormat = "$operand attr-dict `:` functional-type($operand, $out)";181 let cppNamespace = "::mlir::test";182}183 184def TestRemoveTestExtensionOp185 : Op<Transform_Dialect, "test_remove_test_extension",186 [DeclareOpInterfaceMethods<TransformOpInterface>,187 NoMemoryEffect]> {188 let assemblyFormat = "attr-dict";189 let cppNamespace = "::mlir::test";190}191 192def TestReversePayloadOpsOp193 : Op<Transform_Dialect, "test_reverse_payload_ops",194 [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,195 DeclareOpInterfaceMethods<TransformOpInterface>]> {196 let arguments = (ins TransformHandleTypeInterface:$target);197 let results = (outs TransformHandleTypeInterface:$result);198 let assemblyFormat = "$target attr-dict `:` functional-type(operands, results)";199 let cppNamespace = "::mlir::test";200}201 202def TestTransformOpWithRegions203 : Op<Transform_Dialect, "test_transform_op_with_regions",204 [DeclareOpInterfaceMethods<TransformOpInterface>,205 DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {206 let regions = (region AnyRegion:$first, AnyRegion:$second);207 let assemblyFormat = "attr-dict-with-keyword regions";208 let cppNamespace = "::mlir::test";209}210 211def TestBranchingTransformOpTerminator212 : Op<Transform_Dialect, "test_branching_transform_op_terminator",213 [Terminator, DeclareOpInterfaceMethods<TransformOpInterface>,214 DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {215 let successors = (successor VariadicSuccessor<AnySuccessor>:$succ);216 let cppNamespace = "::mlir::test";217}218 219def TestEmitRemarkAndEraseOperandOp220 : Op<Transform_Dialect, "test_emit_remark_and_erase_operand",221 [DeclareOpInterfaceMethods<TransformOpInterface>,222 DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,223 FunctionalStyleTransformOpTrait]> {224 let arguments = (ins TransformHandleTypeInterface:$target, StrAttr:$remark,225 UnitAttr:$fail_after_erase);226 let assemblyFormat = "$target `,` $remark attr-dict `:` type($target)";227 let cppNamespace = "::mlir::test";228}229 230def TestWrongNumberOfResultsOp231 : Op<Transform_Dialect, "test_wrong_number_of_results",232 [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,233 TransformEachOpTrait, TransformOpInterface]> {234 let arguments = (ins TransformHandleTypeInterface:$target);235 let results = (outs TransformHandleTypeInterface:$a,236 TransformHandleTypeInterface:$b,237 TransformHandleTypeInterface:$c);238 let assemblyFormat =239 "$target attr-dict `:` functional-type(operands, results)";240 let cppNamespace = "::mlir::test";241 let extraClassDeclaration = [{242 ::mlir::DiagnosedSilenceableFailure applyToOne(243 ::mlir::transform::TransformRewriter &rewriter,244 ::mlir::Operation * target,245 ::mlir::transform::ApplyToEachResultList &results,246 ::mlir::transform::TransformState &state);247 }];248}249 250def TestWrongNumberOfMultiResultsOp251 : Op<Transform_Dialect, "test_wrong_number_of_multi_results",252 [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,253 TransformEachOpTrait, TransformOpInterface]> {254 let arguments = (ins TransformHandleTypeInterface:$target);255 let results = (outs TransformHandleTypeInterface:$result);256 let assemblyFormat =257 "$target attr-dict `:` functional-type($target, $result)";258 let cppNamespace = "::mlir::test";259 let extraClassDeclaration = [{260 ::mlir::DiagnosedSilenceableFailure applyToOne(261 ::mlir::transform::TransformRewriter &rewriter,262 ::mlir::Operation * target,263 ::mlir::transform::ApplyToEachResultList &results,264 ::mlir::transform::TransformState &state);265 }];266}267 268def TestCorrectNumberOfMultiResultsOp269 : Op<Transform_Dialect, "test_correct_number_of_multi_results",270 [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,271 TransformEachOpTrait, TransformOpInterface]> {272 let arguments = (ins TransformHandleTypeInterface:$target);273 let results = (outs TransformHandleTypeInterface:$result1,274 TransformHandleTypeInterface:$result2);275 let assemblyFormat =276 "$target attr-dict `:` functional-type(operands, results)";277 let cppNamespace = "::mlir::test";278 let extraClassDeclaration = [{279 ::mlir::DiagnosedSilenceableFailure applyToOne(280 ::mlir::transform::TransformRewriter &rewriter,281 ::mlir::Operation * target,282 ::mlir::transform::ApplyToEachResultList &results,283 ::mlir::transform::TransformState &state);284 }];285}286 287def TestMixedNullAndNonNullResultsOp288 : Op<Transform_Dialect, "test_mixed_null_and_non_null_results",289 [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,290 TransformEachOpTrait, TransformOpInterface]> {291 let arguments = (ins TransformHandleTypeInterface:$target);292 let results = (outs TransformHandleTypeInterface:$null,293 TransformHandleTypeInterface:$non_null);294 let assemblyFormat =295 "$target attr-dict `:` functional-type(operands, results)";296 let cppNamespace = "::mlir::test";297 let extraClassDeclaration = [{298 ::mlir::DiagnosedSilenceableFailure applyToOne(299 ::mlir::transform::TransformRewriter &rewriter,300 ::mlir::Operation * target,301 ::mlir::transform::ApplyToEachResultList &results,302 ::mlir::transform::TransformState &state);303 }];304}305 306def TestMixedSuccessAndSilenceableOp307 : Op<Transform_Dialect, "test_mixed_success_and_silenceable",308 [FunctionalStyleTransformOpTrait, MemoryEffectsOpInterface,309 TransformEachOpTrait, TransformOpInterface]> {310 let arguments = (ins TransformHandleTypeInterface:$target);311 let results = (outs);312 let assemblyFormat = "$target attr-dict `:` type($target)";313 let cppNamespace = "::mlir::test";314 let extraClassDeclaration = [{315 ::mlir::DiagnosedSilenceableFailure applyToOne(316 ::mlir::transform::TransformRewriter &rewriter,317 ::mlir::Operation * target,318 ::mlir::transform::ApplyToEachResultList &results,319 ::mlir::transform::TransformState &state);320 }];321}322 323def TestCopyPayloadOp324 : Op<Transform_Dialect, "test_copy_payload",325 [DeclareOpInterfaceMethods<TransformOpInterface>,326 DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {327 let arguments = (ins TransformHandleTypeInterface:$handle);328 let results = (outs TransformHandleTypeInterface:$copy);329 let cppNamespace = "::mlir::test";330 let assemblyFormat =331 "$handle attr-dict `:` functional-type(operands, results)";332}333 334def TestReportNumberOfTrackedHandlesNestedUnder335 : Op<Transform_Dialect, "test_report_number_of_tracked_handles_nested_under",336 [DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,337 DeclareOpInterfaceMethods<TransformOpInterface>]> {338 let arguments = (ins TransformHandleTypeInterface:$target);339 let assemblyFormat = "$target attr-dict `:` type($target)";340 let cppNamespace = "::mlir::test";341}342 343def TestAddToParamOp344 : Op<Transform_Dialect, "test_add_to_param",345 [MatchOpInterface, 346 MemoryEffectsOpInterface,347 ParamProducerTransformOpTrait,348 DeclareOpInterfaceMethods<TransformOpInterface>]> {349 let arguments = (ins Optional<TestTransformTestDialectParamType>:$param,350 I32Attr:$addendum);351 let results = (outs TestTransformTestDialectParamType:$result);352 let assemblyFormat = "($param^ `,`)? $addendum attr-dict";353 let cppNamespace = "::mlir::test";354}355 356def TestProduceParamWithNumberOfTestOps357 : Op<Transform_Dialect, "test_produce_param_with_number_of_test_ops",358 [MatchOpInterface,359 MemoryEffectsOpInterface,360 ParamProducerTransformOpTrait,361 DeclareOpInterfaceMethods<TransformOpInterface>]> {362 let arguments = (ins TransformHandleTypeInterface:$handle);363 let results = (outs TestTransformTestDialectParamType:$result);364 let assemblyFormat = "$handle attr-dict `:` type($handle)";365 let cppNamespace = "::mlir::test";366}367 368def TestProduceParamOp369 : Op<Transform_Dialect, "test_produce_param",370 [MemoryEffectsOpInterface, ParamProducerTransformOpTrait,371 DeclareOpInterfaceMethods<TransformOpInterface>]> {372 let arguments = (ins AnyAttr:$attr);373 let results = (outs TransformParamTypeInterface:$result);374 let assemblyFormat = "`(` $attr `)` attr-dict `:` type($result)";375 let cppNamespace = "::mlir::test";376}377 378def TestProduceTransformParamOrForwardOperandOp379 : Op<Transform_Dialect, "test_produce_transform_param_or_forward_operand",380 [DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,381 TransformEachOpTrait, TransformOpInterface]> {382 let arguments = (ins TransformHandleTypeInterface:$in,383 UnitAttr:$first_result_is_param,384 UnitAttr:$first_result_is_null,385 UnitAttr:$second_result_is_handle);386 let results = (outs AnyType:$out,387 TransformParamTypeInterface:$param);388 let assemblyFormat = "$in attr-dict `:` functional-type(operands, results)";389 let cppNamespace = "::mlir::test";390 391 let extraClassDeclaration = [{392 ::mlir::DiagnosedSilenceableFailure applyToOne(393 ::mlir::transform::TransformRewriter &rewriter,394 ::mlir::Operation *target,395 ::mlir::transform::ApplyToEachResultList &results,396 ::mlir::transform::TransformState &state);397 }];398}399 400def TestProduceNullPayloadOp401 : Op<Transform_Dialect, "test_produce_null_payload",402 [DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,403 DeclareOpInterfaceMethods<TransformOpInterface>]> {404 let results = (outs TransformHandleTypeInterface:$out);405 let assemblyFormat = "attr-dict `:` type($out)";406 let cppNamespace = "::mlir::test";407}408 409def TestProduceEmptyPayloadOp410 : Op<Transform_Dialect, "test_produce_empty_payload",411 [DeclareOpInterfaceMethods<TransformOpInterface>,412 MemoryEffectsOpInterface, FunctionalStyleTransformOpTrait]> {413 let results = (outs TransformHandleTypeInterface:$out);414 let assemblyFormat = "attr-dict `:` type($out)";415 let cppNamespace = "::mlir::test";416}417 418def TestProduceNullParamOp419 : Op<Transform_Dialect, "test_produce_null_param",420 [DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,421 DeclareOpInterfaceMethods<TransformOpInterface>]> {422 let results = (outs TransformParamTypeInterface:$out);423 let assemblyFormat = "attr-dict `:` type($out)";424 let cppNamespace = "::mlir::test";425}426 427def TestProduceNullValueOp428 : Op<Transform_Dialect, "test_produce_null_value",429 [DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,430 DeclareOpInterfaceMethods<TransformOpInterface>]> {431 let results = (outs TransformValueHandleTypeInterface:$out);432 let assemblyFormat = "attr-dict `:` type($out)";433 let cppNamespace = "::mlir::test";434}435 436def TestRequiredMemoryEffectsOp437 : Op<Transform_Dialect, "test_required_memory_effects",438 [DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,439 DeclareOpInterfaceMethods<TransformOpInterface>]> {440 let arguments = (ins TransformHandleTypeInterface:$in,441 UnitAttr:$has_operand_effect,442 UnitAttr:$has_result_effect,443 UnitAttr:$modifies_payload);444 let results = (outs TransformHandleTypeInterface:$out);445 let assemblyFormat = "$in attr-dict `:` functional-type(operands, results)";446 let cppNamespace = "::mlir::test";447}448 449// This op is used as a payload op. It must be a registered op, so that it can450// be created with "RewriterBase::replaceOpWithNewOp" (needed for a test case).451// Since only TransformOpInterface can be injected into the transform dialect,452// this op implements the interface, even though it is not used as a transform453// op.454def TestDummyPayloadOp455 : Op<Transform_Dialect, "test_dummy_payload_op",456 [DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,457 TransformOpInterface]> {458 let arguments = (ins Variadic<AnyType>:$args,459 UnitAttr:$fail_to_verify);460 let results = (outs Variadic<AnyType>:$outs);461 let assemblyFormat = "$args attr-dict `:` functional-type(operands, results)";462 let cppNamespace = "::mlir::test";463 let hasVerifier = 1;464 465 let extraClassDeclaration = [{466 DiagnosedSilenceableFailure apply(transform::TransformRewriter &rewriter,467 transform::TransformResults &results,468 transform::TransformState &state) {469 llvm_unreachable("op should not be used as a transform");470 return DiagnosedSilenceableFailure::definiteFailure();471 }472 }];473}474 475def TestTrackedRewriteOp476 : Op<Transform_Dialect, "test_tracked_rewrite",477 [DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,478 DeclareOpInterfaceMethods<TransformOpInterface>]> {479 let arguments = (ins TransformHandleTypeInterface:$in);480 let results = (outs);481 let assemblyFormat = "$in attr-dict `:` functional-type(operands, results)";482 let cppNamespace = "::mlir::test";483}484 485def ApplyTestPatternsOp486 : Op<Transform_Dialect, "apply_patterns.transform.test_patterns",487 [DeclareOpInterfaceMethods<PatternDescriptorOpInterface>]> {488 let arguments = (ins);489 let results = (outs);490 let assemblyFormat = "attr-dict";491 let cppNamespace = "::mlir::test";492}493 494def ApplyTestConversionPatternsOp495 : Op<Transform_Dialect, "apply_conversion_patterns.transform.test_conversion_patterns",496 [DeclareOpInterfaceMethods<ConversionPatternDescriptorOpInterface>]> {497 let arguments = (ins);498 let results = (outs);499 let assemblyFormat = "attr-dict";500 let cppNamespace = "::mlir::test";501}502 503def TestTypeConverterOp504 : Op<Transform_Dialect, "apply_conversion_patterns.transform.test_type_converter",505 [DeclareOpInterfaceMethods<TypeConverterBuilderOpInterface,506 ["getTypeConverter"]>]> {507 let arguments = (ins);508 let results = (outs);509 let assemblyFormat = "attr-dict";510 let cppNamespace = "::mlir::test";511}512 513def TestReEnterRegionOp514 : Op<Transform_Dialect, "test_re_enter_region",515 [DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,516 DeclareOpInterfaceMethods<TransformOpInterface>]> {517 let arguments = (ins Variadic<AnyType>:$args);518 let regions = (region SizedRegion<1>:$body);519 let assemblyFormat = "($args^ `:` type($args))? attr-dict-with-keyword regions";520 let cppNamespace = "::mlir::test";521 let hasVerifier = 1;522}523 524def TestNotifyPayloadOpReplacedOp525 : Op<Transform_Dialect, "test_notify_payload_op_replaced",526 [DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,527 DeclareOpInterfaceMethods<TransformOpInterface>]> {528 let arguments = (ins TransformHandleTypeInterface:$original,529 TransformHandleTypeInterface:$replacement);530 let results = (outs);531 let assemblyFormat = "$original `,` $replacement attr-dict `:` functional-type(operands, results)";532 let cppNamespace = "::mlir::test";533}534 535def TestProduceInvalidIR536 : Op<Transform_Dialect, "test_produce_invalid_ir",537 [DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,538 TransformOpInterface, TransformEachOpTrait]> {539 let arguments = (ins TransformHandleTypeInterface:$target);540 let results = (outs);541 let assemblyFormat = "$target attr-dict `:` type($target)";542 let cppNamespace = "::mlir::test";543 let extraClassDeclaration = [{544 ::mlir::DiagnosedSilenceableFailure applyToOne(545 ::mlir::transform::TransformRewriter &rewriter,546 ::mlir::Operation *target,547 ::mlir::transform::ApplyToEachResultList &results,548 ::mlir::transform::TransformState &state);549 }];550}551 552def TestInitializerExtensionOp553 : Op<Transform_Dialect, "test_initializer_extension",554 [DeclareOpInterfaceMethods<TransformOpInterface>,555 NoMemoryEffect]> {556 let arguments = (ins StrAttr:$type);557 let assemblyFormat = "$type attr-dict";558 let cppNamespace = "::mlir::test";559}560 561#endif // MLIR_TESTTRANSFORMDIALECTEXTENSION_TD562