1//===- TestTransformDialectExtension.cpp ----------------------------------===//
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 defines an extension of the MLIR Transform dialect for testing
10// purposes.
11//
12//===----------------------------------------------------------------------===//
13
14#include "TestTransformDialectExtension.h"
15#include "TestTransformStateExtension.h"
16#include "mlir/Dialect/PDL/IR/PDL.h"
17#include "mlir/Dialect/Transform/IR/TransformDialect.h"
18#include "mlir/Dialect/Transform/IR/TransformOps.h"
19#include "mlir/Dialect/Transform/Interfaces/TransformInterfaces.h"
20#include "mlir/Dialect/Transform/PDLExtension/PDLExtensionOps.h"
21#include "mlir/IR/Diagnostics.h"
22#include "mlir/IR/OpImplementation.h"
23#include "mlir/IR/PatternMatch.h"
24#include "llvm/ADT/STLExtras.h"
25#include "llvm/ADT/SmallVectorExtras.h"
26#include "llvm/Support/Compiler.h"
27#include "llvm/Support/raw_ostream.h"
28
29using namespace mlir;
30
31namespace {
32/// Simple transform op defined outside of the dialect. Just emits a remark when
33/// applied. This op is defined in C++ to test that C++ definitions also work
34/// for op injection into the Transform dialect.
35class TestTransformOp
36 : public Op<TestTransformOp, transform::TransformOpInterface::Trait,
37 MemoryEffectOpInterface::Trait> {
38public:
39 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestTransformOp)
40
41 using Op::Op;
42
43 static ArrayRef<StringRef> getAttributeNames() { return {}; }
44
45 static constexpr llvm::StringLiteral getOperationName() {
46 return llvm::StringLiteral("transform.test_transform_op");
47 }
48
49 DiagnosedSilenceableFailure apply(transform::TransformRewriter &rewriter,
50 transform::TransformResults &results,
51 transform::TransformState &state) {
52 InFlightDiagnostic remark = emitRemark() << "applying transformation";
53 if (Attribute message = getMessage())
54 remark << " " << message;
55
56 return DiagnosedSilenceableFailure::success();
57 }
58
59 Attribute getMessage() {
60 return getOperation()->getDiscardableAttr(name: "message");
61 }
62
63 static ParseResult parse(OpAsmParser &parser, OperationState &state) {
64 StringAttr message;
65 OptionalParseResult result = parser.parseOptionalAttribute(result&: message);
66 if (!result.has_value())
67 return success();
68
69 if (result.value().succeeded())
70 state.addAttribute(name: "message", attr: message);
71 return result.value();
72 }
73
74 void print(OpAsmPrinter &printer) {
75 if (getMessage())
76 printer << " " << getMessage();
77 }
78
79 // No side effects.
80 void getEffects(SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {}
81};
82
83/// A test op to exercise the verifier of the PossibleTopLevelTransformOpTrait
84/// in cases where it is attached to ops that do not comply with the trait
85/// requirements. This op cannot be defined in ODS because ODS generates strict
86/// verifiers that overalp with those in the trait and run earlier.
87class TestTransformUnrestrictedOpNoInterface
88 : public Op<TestTransformUnrestrictedOpNoInterface,
89 transform::PossibleTopLevelTransformOpTrait,
90 transform::TransformOpInterface::Trait,
91 MemoryEffectOpInterface::Trait> {
92public:
93 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(
94 TestTransformUnrestrictedOpNoInterface)
95
96 using Op::Op;
97
98 static ArrayRef<StringRef> getAttributeNames() { return {}; }
99
100 static constexpr llvm::StringLiteral getOperationName() {
101 return llvm::StringLiteral(
102 "transform.test_transform_unrestricted_op_no_interface");
103 }
104
105 DiagnosedSilenceableFailure apply(transform::TransformRewriter &rewriter,
106 transform::TransformResults &results,
107 transform::TransformState &state) {
108 return DiagnosedSilenceableFailure::success();
109 }
110
111 // No side effects.
112 void getEffects(SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {}
113};
114} // namespace
115
116DiagnosedSilenceableFailure
117mlir::test::TestProduceSelfHandleOrForwardOperandOp::apply(
118 transform::TransformRewriter &rewriter,
119 transform::TransformResults &results, transform::TransformState &state) {
120 if (getOperation()->getNumOperands() != 0) {
121 results.set(cast<OpResult>(getResult()),
122 {getOperation()->getOperand(0).getDefiningOp()});
123 } else {
124 results.set(cast<OpResult>(getResult()), {getOperation()});
125 }
126 return DiagnosedSilenceableFailure::success();
127}
128
129void mlir::test::TestProduceSelfHandleOrForwardOperandOp::getEffects(
130 SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
131 if (getOperand())
132 transform::onlyReadsHandle(getOperandMutable(), effects);
133 transform::producesHandle(getOperation()->getOpResults(), effects);
134}
135
136DiagnosedSilenceableFailure
137mlir::test::TestProduceValueHandleToSelfOperand::apply(
138 transform::TransformRewriter &rewriter,
139 transform::TransformResults &results, transform::TransformState &state) {
140 results.setValues(llvm::cast<OpResult>(getOut()), {getIn()});
141 return DiagnosedSilenceableFailure::success();
142}
143
144void mlir::test::TestProduceValueHandleToSelfOperand::getEffects(
145 SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
146 transform::onlyReadsHandle(getInMutable(), effects);
147 transform::producesHandle(getOperation()->getOpResults(), effects);
148 transform::onlyReadsPayload(effects);
149}
150
151DiagnosedSilenceableFailure
152mlir::test::TestProduceValueHandleToResult::applyToOne(
153 transform::TransformRewriter &rewriter, Operation *target,
154 transform::ApplyToEachResultList &results,
155 transform::TransformState &state) {
156 if (target->getNumResults() <= getNumber())
157 return emitSilenceableError() << "payload has no result #" << getNumber();
158 results.push_back(target->getResult(getNumber()));
159 return DiagnosedSilenceableFailure::success();
160}
161
162void mlir::test::TestProduceValueHandleToResult::getEffects(
163 SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
164 transform::onlyReadsHandle(getInMutable(), effects);
165 transform::producesHandle(getOperation()->getOpResults(), effects);
166 transform::onlyReadsPayload(effects);
167}
168
169DiagnosedSilenceableFailure
170mlir::test::TestProduceValueHandleToArgumentOfParentBlock::applyToOne(
171 transform::TransformRewriter &rewriter, Operation *target,
172 transform::ApplyToEachResultList &results,
173 transform::TransformState &state) {
174 if (!target->getBlock())
175 return emitSilenceableError() << "payload has no parent block";
176 if (target->getBlock()->getNumArguments() <= getNumber())
177 return emitSilenceableError()
178 << "parent of the payload has no argument #" << getNumber();
179 results.push_back(target->getBlock()->getArgument(getNumber()));
180 return DiagnosedSilenceableFailure::success();
181}
182
183void mlir::test::TestProduceValueHandleToArgumentOfParentBlock::getEffects(
184 SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
185 transform::onlyReadsHandle(getInMutable(), effects);
186 transform::producesHandle(getOperation()->getOpResults(), effects);
187 transform::onlyReadsPayload(effects);
188}
189
190bool mlir::test::TestConsumeOperand::allowsRepeatedHandleOperands() {
191 return getAllowRepeatedHandles();
192}
193
194DiagnosedSilenceableFailure
195mlir::test::TestConsumeOperand::apply(transform::TransformRewriter &rewriter,
196 transform::TransformResults &results,
197 transform::TransformState &state) {
198 return DiagnosedSilenceableFailure::success();
199}
200
201void mlir::test::TestConsumeOperand::getEffects(
202 SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
203 transform::consumesHandle(getOperation()->getOpOperands(), effects);
204 if (getSecondOperand())
205 transform::consumesHandle(getSecondOperandMutable(), effects);
206 transform::modifiesPayload(effects);
207}
208
209DiagnosedSilenceableFailure mlir::test::TestConsumeOperandOfOpKindOrFail::apply(
210 transform::TransformRewriter &rewriter,
211 transform::TransformResults &results, transform::TransformState &state) {
212 auto payload = state.getPayloadOps(getOperand());
213 assert(llvm::hasSingleElement(payload) && "expected a single target op");
214 if ((*payload.begin())->getName().getStringRef() != getOpKind()) {
215 return emitSilenceableError()
216 << "op expected the operand to be associated a payload op of kind "
217 << getOpKind() << " got "
218 << (*payload.begin())->getName().getStringRef();
219 }
220
221 emitRemark() << "succeeded";
222 return DiagnosedSilenceableFailure::success();
223}
224
225void mlir::test::TestConsumeOperandOfOpKindOrFail::getEffects(
226 SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
227 transform::consumesHandle(getOperation()->getOpOperands(), effects);
228 transform::modifiesPayload(effects);
229}
230
231DiagnosedSilenceableFailure
232mlir::test::TestSucceedIfOperandOfOpKind::matchOperation(
233 Operation *op, transform::TransformResults &results,
234 transform::TransformState &state) {
235 if (op->getName().getStringRef() != getOpKind()) {
236 return emitSilenceableError()
237 << "op expected the operand to be associated with a payload op of "
238 "kind "
239 << getOpKind() << " got " << op->getName().getStringRef();
240 }
241 return DiagnosedSilenceableFailure::success();
242}
243
244void mlir::test::TestSucceedIfOperandOfOpKind::getEffects(
245 SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
246 transform::onlyReadsHandle(getOperation()->getOpOperands(), effects);
247 transform::onlyReadsPayload(effects);
248}
249
250DiagnosedSilenceableFailure mlir::test::TestAddTestExtensionOp::apply(
251 transform::TransformRewriter &rewriter,
252 transform::TransformResults &results, transform::TransformState &state) {
253 state.addExtension<TestTransformStateExtension>(getMessageAttr());
254 return DiagnosedSilenceableFailure::success();
255}
256
257DiagnosedSilenceableFailure
258mlir::test::TestCheckIfTestExtensionPresentOp::apply(
259 transform::TransformRewriter &rewriter,
260 transform::TransformResults &results, transform::TransformState &state) {
261 auto *extension = state.getExtension<TestTransformStateExtension>();
262 if (!extension) {
263 emitRemark() << "extension absent";
264 return DiagnosedSilenceableFailure::success();
265 }
266
267 InFlightDiagnostic diag = emitRemark()
268 << "extension present, " << extension->getMessage();
269 for (Operation *payload : state.getPayloadOps(getOperand())) {
270 diag.attachNote(payload->getLoc()) << "associated payload op";
271#ifndef NDEBUG
272 SmallVector<Value> handles;
273 assert(succeeded(state.getHandlesForPayloadOp(payload, handles)));
274 assert(llvm::is_contained(handles, getOperand()) &&
275 "inconsistent mapping between transform IR handles and payload IR "
276 "operations");
277#endif // NDEBUG
278 }
279
280 return DiagnosedSilenceableFailure::success();
281}
282
283void mlir::test::TestCheckIfTestExtensionPresentOp::getEffects(
284 SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
285 transform::onlyReadsHandle(getOperation()->getOpOperands(), effects);
286 transform::onlyReadsPayload(effects);
287}
288
289DiagnosedSilenceableFailure mlir::test::TestRemapOperandPayloadToSelfOp::apply(
290 transform::TransformRewriter &rewriter,
291 transform::TransformResults &results, transform::TransformState &state) {
292 auto *extension = state.getExtension<TestTransformStateExtension>();
293 if (!extension)
294 return emitDefiniteFailure("TestTransformStateExtension missing");
295
296 if (failed(extension->updateMapping(
297 *state.getPayloadOps(getOperand()).begin(), getOperation())))
298 return DiagnosedSilenceableFailure::definiteFailure();
299 if (getNumResults() > 0)
300 results.set(cast<OpResult>(getResult(0)), {getOperation()});
301 return DiagnosedSilenceableFailure::success();
302}
303
304void mlir::test::TestRemapOperandPayloadToSelfOp::getEffects(
305 SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
306 transform::onlyReadsHandle(getOperation()->getOpOperands(), effects);
307 transform::producesHandle(getOperation()->getOpResults(), effects);
308 transform::onlyReadsPayload(effects);
309}
310
311DiagnosedSilenceableFailure mlir::test::TestRemoveTestExtensionOp::apply(
312 transform::TransformRewriter &rewriter,
313 transform::TransformResults &results, transform::TransformState &state) {
314 state.removeExtension<TestTransformStateExtension>();
315 return DiagnosedSilenceableFailure::success();
316}
317
318DiagnosedSilenceableFailure mlir::test::TestReversePayloadOpsOp::apply(
319 transform::TransformRewriter &rewriter,
320 transform::TransformResults &results, transform::TransformState &state) {
321 auto payloadOps = state.getPayloadOps(getTarget());
322 auto reversedOps = llvm::to_vector(llvm::reverse(payloadOps));
323 results.set(llvm::cast<OpResult>(getResult()), reversedOps);
324 return DiagnosedSilenceableFailure::success();
325}
326
327DiagnosedSilenceableFailure mlir::test::TestTransformOpWithRegions::apply(
328 transform::TransformRewriter &rewriter,
329 transform::TransformResults &results, transform::TransformState &state) {
330 return DiagnosedSilenceableFailure::success();
331}
332
333void mlir::test::TestTransformOpWithRegions::getEffects(
334 SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {}
335
336DiagnosedSilenceableFailure
337mlir::test::TestBranchingTransformOpTerminator::apply(
338 transform::TransformRewriter &rewriter,
339 transform::TransformResults &results, transform::TransformState &state) {
340 return DiagnosedSilenceableFailure::success();
341}
342
343void mlir::test::TestBranchingTransformOpTerminator::getEffects(
344 SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {}
345
346DiagnosedSilenceableFailure mlir::test::TestEmitRemarkAndEraseOperandOp::apply(
347 transform::TransformRewriter &rewriter,
348 transform::TransformResults &results, transform::TransformState &state) {
349 emitRemark() << getRemark();
350 for (Operation *op : state.getPayloadOps(getTarget())) {
351 if (!op->getUses().empty())
352 return emitSilenceableError() << "cannot erase an op that has uses";
353 rewriter.eraseOp(op);
354 }
355
356 if (getFailAfterErase())
357 return emitSilenceableError() << "silenceable error";
358 return DiagnosedSilenceableFailure::success();
359}
360
361void mlir::test::TestEmitRemarkAndEraseOperandOp::getEffects(
362 SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
363 transform::consumesHandle(getTargetMutable(), effects);
364 transform::modifiesPayload(effects);
365}
366
367DiagnosedSilenceableFailure mlir::test::TestWrongNumberOfResultsOp::applyToOne(
368 transform::TransformRewriter &rewriter, Operation *target,
369 transform::ApplyToEachResultList &results,
370 transform::TransformState &state) {
371 OperationState opState(target->getLoc(), "foo");
372 results.push_back(OpBuilder(target).create(opState));
373 return DiagnosedSilenceableFailure::success();
374}
375
376DiagnosedSilenceableFailure
377mlir::test::TestWrongNumberOfMultiResultsOp::applyToOne(
378 transform::TransformRewriter &rewriter, Operation *target,
379 transform::ApplyToEachResultList &results,
380 transform::TransformState &state) {
381 static int count = 0;
382 if (count++ == 0) {
383 OperationState opState(target->getLoc(), "foo");
384 results.push_back(OpBuilder(target).create(opState));
385 }
386 return DiagnosedSilenceableFailure::success();
387}
388
389DiagnosedSilenceableFailure
390mlir::test::TestCorrectNumberOfMultiResultsOp::applyToOne(
391 transform::TransformRewriter &rewriter, Operation *target,
392 transform::ApplyToEachResultList &results,
393 transform::TransformState &state) {
394 OperationState opState(target->getLoc(), "foo");
395 results.push_back(OpBuilder(target).create(opState));
396 results.push_back(OpBuilder(target).create(opState));
397 return DiagnosedSilenceableFailure::success();
398}
399
400DiagnosedSilenceableFailure
401mlir::test::TestMixedNullAndNonNullResultsOp::applyToOne(
402 transform::TransformRewriter &rewriter, Operation *target,
403 transform::ApplyToEachResultList &results,
404 transform::TransformState &state) {
405 OperationState opState(target->getLoc(), "foo");
406 results.push_back(nullptr);
407 results.push_back(OpBuilder(target).create(opState));
408 return DiagnosedSilenceableFailure::success();
409}
410
411DiagnosedSilenceableFailure
412mlir::test::TestMixedSuccessAndSilenceableOp::applyToOne(
413 transform::TransformRewriter &rewriter, Operation *target,
414 transform::ApplyToEachResultList &results,
415 transform::TransformState &state) {
416 if (target->hasAttr("target_me"))
417 return DiagnosedSilenceableFailure::success();
418 return emitDefaultSilenceableFailure(target);
419}
420
421DiagnosedSilenceableFailure
422mlir::test::TestCopyPayloadOp::apply(transform::TransformRewriter &rewriter,
423 transform::TransformResults &results,
424 transform::TransformState &state) {
425 results.set(llvm::cast<OpResult>(getCopy()),
426 state.getPayloadOps(getHandle()));
427 return DiagnosedSilenceableFailure::success();
428}
429
430void mlir::test::TestCopyPayloadOp::getEffects(
431 SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
432 transform::onlyReadsHandle(getHandleMutable(), effects);
433 transform::producesHandle(getOperation()->getOpResults(), effects);
434 transform::onlyReadsPayload(effects);
435}
436
437DiagnosedSilenceableFailure mlir::transform::TestDialectOpType::checkPayload(
438 Location loc, ArrayRef<Operation *> payload) const {
439 if (payload.empty())
440 return DiagnosedSilenceableFailure::success();
441
442 for (Operation *op : payload) {
443 if (op->getName().getDialectNamespace() != "test") {
444 return emitSilenceableError(loc) << "expected the payload operation to "
445 "belong to the 'test' dialect";
446 }
447 }
448
449 return DiagnosedSilenceableFailure::success();
450}
451
452DiagnosedSilenceableFailure mlir::transform::TestDialectParamType::checkPayload(
453 Location loc, ArrayRef<Attribute> payload) const {
454 for (Attribute attr : payload) {
455 auto integerAttr = llvm::dyn_cast<IntegerAttr>(attr);
456 if (integerAttr && integerAttr.getType().isSignlessInteger(32))
457 continue;
458 return emitSilenceableError(loc)
459 << "expected the parameter to be a i32 integer attribute";
460 }
461
462 return DiagnosedSilenceableFailure::success();
463}
464
465void mlir::test::TestReportNumberOfTrackedHandlesNestedUnder::getEffects(
466 SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
467 transform::onlyReadsHandle(getTargetMutable(), effects);
468}
469
470DiagnosedSilenceableFailure
471mlir::test::TestReportNumberOfTrackedHandlesNestedUnder::apply(
472 transform::TransformRewriter &rewriter,
473 transform::TransformResults &results, transform::TransformState &state) {
474 int64_t count = 0;
475 for (Operation *op : state.getPayloadOps(getTarget())) {
476 op->walk([&](Operation *nested) {
477 SmallVector<Value> handles;
478 (void)state.getHandlesForPayloadOp(nested, handles);
479 count += handles.size();
480 });
481 }
482 emitRemark() << count << " handles nested under";
483 return DiagnosedSilenceableFailure::success();
484}
485
486DiagnosedSilenceableFailure
487mlir::test::TestAddToParamOp::apply(transform::TransformRewriter &rewriter,
488 transform::TransformResults &results,
489 transform::TransformState &state) {
490 SmallVector<uint32_t> values(/*Size=*/1, /*Value=*/0);
491 if (Value param = getParam()) {
492 values = llvm::map_to_vector(
493 state.getParams(param), [](Attribute attr) -> uint32_t {
494 return llvm::cast<IntegerAttr>(attr).getValue().getLimitedValue(
495 UINT32_MAX);
496 });
497 }
498
499 Builder builder(getContext());
500 SmallVector<Attribute> result = llvm::map_to_vector(
501 values, [this, &builder](uint32_t value) -> Attribute {
502 return builder.getI32IntegerAttr(value + getAddendum());
503 });
504 results.setParams(llvm::cast<OpResult>(getResult()), result);
505 return DiagnosedSilenceableFailure::success();
506}
507
508DiagnosedSilenceableFailure
509mlir::test::TestProduceParamWithNumberOfTestOps::apply(
510 transform::TransformRewriter &rewriter,
511 transform::TransformResults &results, transform::TransformState &state) {
512 Builder builder(getContext());
513 SmallVector<Attribute> result =
514 llvm::map_to_vector(state.getPayloadOps(getHandle()),
515 [&builder](Operation *payload) -> Attribute {
516 int32_t count = 0;
517 payload->walk([&count](Operation *op) {
518 if (op->getName().getDialectNamespace() == "test")
519 ++count;
520 });
521 return builder.getI32IntegerAttr(count);
522 });
523 results.setParams(llvm::cast<OpResult>(getResult()), result);
524 return DiagnosedSilenceableFailure::success();
525}
526
527DiagnosedSilenceableFailure
528mlir::test::TestProduceParamOp::apply(transform::TransformRewriter &rewriter,
529 transform::TransformResults &results,
530 transform::TransformState &state) {
531 results.setParams(llvm::cast<OpResult>(getResult()), getAttr());
532 return DiagnosedSilenceableFailure::success();
533}
534
535void mlir::test::TestProduceTransformParamOrForwardOperandOp::getEffects(
536 SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
537 transform::onlyReadsHandle(getInMutable(), effects);
538 transform::producesHandle(getOperation()->getOpResults(), effects);
539}
540
541DiagnosedSilenceableFailure
542mlir::test::TestProduceTransformParamOrForwardOperandOp::applyToOne(
543 transform::TransformRewriter &rewriter, Operation *target,
544 ::transform::ApplyToEachResultList &results,
545 ::transform::TransformState &state) {
546 Builder builder(getContext());
547 if (getFirstResultIsParam()) {
548 results.push_back(builder.getI64IntegerAttr(0));
549 } else if (getFirstResultIsNull()) {
550 results.push_back(nullptr);
551 } else {
552 results.push_back(*state.getPayloadOps(getIn()).begin());
553 }
554
555 if (getSecondResultIsHandle()) {
556 results.push_back(*state.getPayloadOps(getIn()).begin());
557 } else {
558 results.push_back(builder.getI64IntegerAttr(42));
559 }
560
561 return DiagnosedSilenceableFailure::success();
562}
563
564void mlir::test::TestProduceNullPayloadOp::getEffects(
565 SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
566 transform::producesHandle(getOperation()->getOpResults(), effects);
567}
568
569DiagnosedSilenceableFailure mlir::test::TestProduceNullPayloadOp::apply(
570 transform::TransformRewriter &rewriter,
571 transform::TransformResults &results, transform::TransformState &state) {
572 SmallVector<Operation *, 1> null({nullptr});
573 results.set(llvm::cast<OpResult>(getOut()), null);
574 return DiagnosedSilenceableFailure::success();
575}
576
577DiagnosedSilenceableFailure mlir::test::TestProduceEmptyPayloadOp::apply(
578 transform::TransformRewriter &rewriter,
579 transform::TransformResults &results, transform::TransformState &state) {
580 results.set(cast<OpResult>(getOut()), {});
581 return DiagnosedSilenceableFailure::success();
582}
583
584void mlir::test::TestProduceNullParamOp::getEffects(
585 SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
586 transform::producesHandle(getOperation()->getOpResults(), effects);
587}
588
589DiagnosedSilenceableFailure mlir::test::TestProduceNullParamOp::apply(
590 transform::TransformRewriter &rewriter,
591 transform::TransformResults &results, transform::TransformState &state) {
592 results.setParams(llvm::cast<OpResult>(getOut()), Attribute());
593 return DiagnosedSilenceableFailure::success();
594}
595
596void mlir::test::TestProduceNullValueOp::getEffects(
597 SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
598 transform::producesHandle(getOperation()->getOpResults(), effects);
599}
600
601DiagnosedSilenceableFailure mlir::test::TestProduceNullValueOp::apply(
602 transform::TransformRewriter &rewriter,
603 transform::TransformResults &results, transform::TransformState &state) {
604 results.setValues(llvm::cast<OpResult>(getOut()), {Value()});
605 return DiagnosedSilenceableFailure::success();
606}
607
608void mlir::test::TestRequiredMemoryEffectsOp::getEffects(
609 SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
610 if (getHasOperandEffect())
611 transform::consumesHandle(getInMutable(), effects);
612
613 if (getHasResultEffect()) {
614 transform::producesHandle(getOperation()->getOpResults(), effects);
615 } else {
616 effects.emplace_back(MemoryEffects::Read::get(),
617 llvm::cast<OpResult>(getOut()),
618 transform::TransformMappingResource::get());
619 }
620
621 if (getModifiesPayload())
622 transform::modifiesPayload(effects);
623}
624
625DiagnosedSilenceableFailure mlir::test::TestRequiredMemoryEffectsOp::apply(
626 transform::TransformRewriter &rewriter,
627 transform::TransformResults &results, transform::TransformState &state) {
628 results.set(llvm::cast<OpResult>(getOut()), state.getPayloadOps(getIn()));
629 return DiagnosedSilenceableFailure::success();
630}
631
632void mlir::test::TestTrackedRewriteOp::getEffects(
633 SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
634 transform::onlyReadsHandle(getInMutable(), effects);
635 transform::modifiesPayload(effects);
636}
637
638void mlir::test::TestDummyPayloadOp::getEffects(
639 SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
640 transform::producesHandle(getOperation()->getOpResults(), effects);
641}
642
643LogicalResult mlir::test::TestDummyPayloadOp::verify() {
644 if (getFailToVerify())
645 return emitOpError() << "fail_to_verify is set";
646 return success();
647}
648
649DiagnosedSilenceableFailure
650mlir::test::TestTrackedRewriteOp::apply(transform::TransformRewriter &rewriter,
651 transform::TransformResults &results,
652 transform::TransformState &state) {
653 int64_t numIterations = 0;
654
655 // `getPayloadOps` returns an iterator that skips ops that are erased in the
656 // loop body. Replacement ops are not enumerated.
657 for (Operation *op : state.getPayloadOps(getIn())) {
658 ++numIterations;
659 (void)op;
660
661 // Erase all payload ops. The outer loop should have only one iteration.
662 for (Operation *op : state.getPayloadOps(getIn())) {
663 rewriter.setInsertionPoint(op);
664 if (op->hasAttr("erase_me")) {
665 rewriter.eraseOp(op);
666 continue;
667 }
668 if (!op->hasAttr("replace_me")) {
669 continue;
670 }
671
672 SmallVector<NamedAttribute> attributes;
673 attributes.emplace_back(rewriter.getStringAttr("new_op"),
674 rewriter.getUnitAttr());
675 OperationState opState(op->getLoc(), op->getName().getIdentifier(),
676 /*operands=*/ValueRange(),
677 /*types=*/op->getResultTypes(), attributes);
678 Operation *newOp = rewriter.create(opState);
679 rewriter.replaceOp(op, newOp->getResults());
680 }
681 }
682
683 emitRemark() << numIterations << " iterations";
684 return DiagnosedSilenceableFailure::success();
685}
686
687namespace {
688// Test pattern to replace an operation with a new op.
689class ReplaceWithNewOp : public RewritePattern {
690public:
691 ReplaceWithNewOp(MLIRContext *context)
692 : RewritePattern(MatchAnyOpTypeTag(), /*benefit=*/1, context) {}
693
694 LogicalResult matchAndRewrite(Operation *op,
695 PatternRewriter &rewriter) const override {
696 auto newName = op->getAttrOfType<StringAttr>(name: "replace_with_new_op");
697 if (!newName)
698 return failure();
699 Operation *newOp = rewriter.create(
700 loc: op->getLoc(), opName: OperationName(newName, op->getContext()).getIdentifier(),
701 operands: op->getOperands(), types: op->getResultTypes());
702 rewriter.replaceOp(op, newValues: newOp->getResults());
703 return success();
704 }
705};
706
707// Test pattern to erase an operation.
708class EraseOp : public RewritePattern {
709public:
710 EraseOp(MLIRContext *context)
711 : RewritePattern("test.erase_op", /*benefit=*/1, context) {}
712 LogicalResult matchAndRewrite(Operation *op,
713 PatternRewriter &rewriter) const override {
714 rewriter.eraseOp(op);
715 return success();
716 }
717};
718} // namespace
719
720void mlir::test::ApplyTestPatternsOp::populatePatterns(
721 RewritePatternSet &patterns) {
722 patterns.insert<ReplaceWithNewOp, EraseOp>(patterns.getContext());
723}
724
725void mlir::test::TestReEnterRegionOp::getEffects(
726 SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
727 transform::consumesHandle(getOperation()->getOpOperands(), effects);
728 transform::modifiesPayload(effects);
729}
730
731DiagnosedSilenceableFailure
732mlir::test::TestReEnterRegionOp::apply(transform::TransformRewriter &rewriter,
733 transform::TransformResults &results,
734 transform::TransformState &state) {
735
736 SmallVector<SmallVector<transform::MappedValue>> mappings;
737 for (BlockArgument arg : getBody().front().getArguments()) {
738 mappings.emplace_back(llvm::map_to_vector(
739 state.getPayloadOps(getOperand(arg.getArgNumber())),
740 [](Operation *op) -> transform::MappedValue { return op; }));
741 }
742
743 for (int i = 0; i < 4; ++i) {
744 auto scope = state.make_region_scope(getBody());
745 for (BlockArgument arg : getBody().front().getArguments()) {
746 if (failed(state.mapBlockArgument(arg, mappings[arg.getArgNumber()])))
747 return DiagnosedSilenceableFailure::definiteFailure();
748 }
749 for (Operation &op : getBody().front().without_terminator()) {
750 DiagnosedSilenceableFailure diag =
751 state.applyTransform(cast<transform::TransformOpInterface>(op));
752 if (!diag.succeeded())
753 return diag;
754 }
755 }
756 return DiagnosedSilenceableFailure::success();
757}
758
759LogicalResult mlir::test::TestReEnterRegionOp::verify() {
760 if (getNumOperands() != getBody().front().getNumArguments()) {
761 return emitOpError() << "expects as many operands as block arguments";
762 }
763 return success();
764}
765
766DiagnosedSilenceableFailure mlir::test::TestNotifyPayloadOpReplacedOp::apply(
767 transform::TransformRewriter &rewriter,
768 transform::TransformResults &results, transform::TransformState &state) {
769 auto originalOps = state.getPayloadOps(getOriginal());
770 auto replacementOps = state.getPayloadOps(getReplacement());
771 if (llvm::range_size(originalOps) != llvm::range_size(replacementOps))
772 return emitSilenceableError() << "expected same number of original and "
773 "replacement payload operations";
774 for (const auto &[original, replacement] :
775 llvm::zip(originalOps, replacementOps)) {
776 if (failed(
777 rewriter.notifyPayloadOperationReplaced(original, replacement))) {
778 auto diag = emitSilenceableError()
779 << "unable to replace payload op in transform mapping";
780 diag.attachNote(original->getLoc()) << "original payload op";
781 diag.attachNote(replacement->getLoc()) << "replacement payload op";
782 return diag;
783 }
784 }
785 return DiagnosedSilenceableFailure::success();
786}
787
788void mlir::test::TestNotifyPayloadOpReplacedOp::getEffects(
789 SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
790 transform::onlyReadsHandle(getOriginalMutable(), effects);
791 transform::onlyReadsHandle(getReplacementMutable(), effects);
792}
793
794DiagnosedSilenceableFailure mlir::test::TestProduceInvalidIR::applyToOne(
795 transform::TransformRewriter &rewriter, Operation *target,
796 transform::ApplyToEachResultList &results,
797 transform::TransformState &state) {
798 // Provide some IR that does not verify.
799 rewriter.setInsertionPointToStart(&target->getRegion(0).front());
800 TestDummyPayloadOp::create(rewriter, target->getLoc(), TypeRange(),
801 ValueRange(), /*fail_to_verify=*/true);
802 return DiagnosedSilenceableFailure::success();
803}
804
805void mlir::test::TestProduceInvalidIR::getEffects(
806 SmallVectorImpl<MemoryEffects::EffectInstance> &effects) {
807 transform::onlyReadsHandle(getTargetMutable(), effects);
808 transform::modifiesPayload(effects);
809}
810
811DiagnosedSilenceableFailure mlir::test::TestInitializerExtensionOp::apply(
812 transform::TransformRewriter &rewriter,
813 transform::TransformResults &results, transform::TransformState &state) {
814 std::string opName =
815 this->getOperationName().str() + "_" + getTypeAttr().str();
816 TransformStateInitializerExtension *initExt =
817 state.getExtension<TransformStateInitializerExtension>();
818 if (!initExt) {
819 emitRemark() << "\nSpecified extension not found, adding a new one!\n";
820 SmallVector<std::string> opCollection = {opName};
821 state.addExtension<TransformStateInitializerExtension>(1, opCollection);
822 } else {
823 initExt->setNumOp(initExt->getNumOp() + 1);
824 initExt->pushRegisteredOps(opName);
825 InFlightDiagnostic diag = emitRemark()
826 << "Number of currently registered op: "
827 << initExt->getNumOp() << "\n"
828 << initExt->printMessage() << "\n";
829 }
830 return DiagnosedSilenceableFailure::success();
831}
832
833namespace {
834/// Test conversion pattern that replaces ops with the "replace_with_new_op"
835/// attribute with "test.new_op".
836class ReplaceWithNewOpConversion : public ConversionPattern {
837public:
838 ReplaceWithNewOpConversion(TypeConverter &typeConverter, MLIRContext *context)
839 : ConversionPattern(typeConverter, RewritePattern::MatchAnyOpTypeTag(),
840 /*benefit=*/1, context) {}
841
842 LogicalResult
843 matchAndRewrite(Operation *op, ArrayRef<Value> operands,
844 ConversionPatternRewriter &rewriter) const override {
845 if (!op->hasAttr(name: "replace_with_new_op"))
846 return failure();
847 SmallVector<Type> newResultTypes;
848 if (failed(Result: getTypeConverter()->convertTypes(types: op->getResultTypes(),
849 results&: newResultTypes)))
850 return failure();
851 Operation *newOp = rewriter.create(
852 loc: op->getLoc(),
853 opName: OperationName("test.new_op", op->getContext()).getIdentifier(),
854 operands, types: newResultTypes);
855 rewriter.replaceOp(op, newValues: newOp->getResults());
856 return success();
857 }
858};
859} // namespace
860
861void mlir::test::ApplyTestConversionPatternsOp::populatePatterns(
862 TypeConverter &typeConverter, RewritePatternSet &patterns) {
863 patterns.insert<ReplaceWithNewOpConversion>(typeConverter,
864 patterns.getContext());
865}
866
867namespace {
868/// Test type converter that converts tensor types to memref types.
869class TestTypeConverter : public TypeConverter {
870public:
871 TestTypeConverter() {
872 addConversion(callback: [](Type t) { return t; });
873 addConversion(callback: [](RankedTensorType type) -> Type {
874 return MemRefType::get(shape: type.getShape(), elementType: type.getElementType());
875 });
876 auto unrealizedCastConverter = [&](OpBuilder &builder, Type resultType,
877 ValueRange inputs,
878 Location loc) -> Value {
879 if (inputs.size() != 1)
880 return Value();
881 return UnrealizedConversionCastOp::create(builder, location: loc, resultTypes: resultType,
882 operands: inputs)
883 .getResult(i: 0);
884 };
885 addSourceMaterialization(callback&: unrealizedCastConverter);
886 addTargetMaterialization(callback&: unrealizedCastConverter);
887 }
888};
889} // namespace
890
891std::unique_ptr<::mlir::TypeConverter>
892mlir::test::TestTypeConverterOp::getTypeConverter() {
893 return std::make_unique<TestTypeConverter>();
894}
895
896DiagnosedSilenceableFailure
897mlir::transform::TestSingleBlockNormalFormAttr::checkOperation(
898 Operation *op) const {
899 auto check = [](Operation *nested) {
900 for (Region &region : nested->getRegions())
901 if (!region.hasOneBlock())
902 return failure();
903
904 return success();
905 };
906
907 auto wrapResult = [&](Location loc, LogicalResult result) {
908 if (failed(result)) {
909 return emitSilenceableFailure(loc)
910 << "normal form " << getMnemonic()
911 << " requires payload operations to have a single region";
912 }
913 return DiagnosedSilenceableFailure::success();
914 };
915
916 if (!getCheckNested().getValue())
917 return wrapResult(op->getLoc(), check(op));
918
919 Location loc = op->getLoc();
920 WalkResult walkResult = op->walk<WalkOrder::PreOrder>([&](Operation *nested) {
921 if (failed(check(nested))) {
922 loc = nested->getLoc();
923 return WalkResult::interrupt();
924 }
925 return WalkResult::advance();
926 });
927 return wrapResult(loc, failure(walkResult.wasInterrupted()));
928}
929
930DiagnosedSilenceableFailure
931mlir::transform::TestCountingNormalFormAttr::checkOperation(
932 Operation *op) const {
933 // Record the number of invocations of this check on `op` as a discardable
934 // integer attribute. Tests that need to detect redundant checks can simply
935 // `FileCheck` the printed IR for the expected count.
936 Builder builder(op->getContext());
937 StringAttr counterName =
938 builder.getStringAttr("test.counting_normal_form_count");
939 unsigned count = 0;
940 if (auto prev = op->getAttrOfType<IntegerAttr>(counterName))
941 count = prev.getValue().getZExtValue();
942 op->setDiscardableAttr(counterName, builder.getI64IntegerAttr(count + 1));
943 return DiagnosedSilenceableFailure::success();
944}
945
946namespace {
947/// Test extension of the Transform dialect. Registers additional ops and
948/// declares PDL as dependent dialect since the additional ops are using PDL
949/// types for operands and results.
950class TestTransformDialectExtension
951 : public transform::TransformDialectExtension<
952 TestTransformDialectExtension> {
953public:
954 MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestTransformDialectExtension)
955
956 using Base::Base;
957
958 void init() {
959 declareDependentDialect<pdl::PDLDialect>();
960 registerTransformOps<TestTransformOp,
961 TestTransformUnrestrictedOpNoInterface,
962#define GET_OP_LIST
963#include "TestTransformDialectExtension.cpp.inc"
964 >();
965 registerAttributes<
966#define GET_ATTRDEF_LIST
967#include "TestTransformDialectExtensionAttrs.cpp.inc"
968 >();
969 registerTypes<
970#define GET_TYPEDEF_LIST
971#include "TestTransformDialectExtensionTypes.cpp.inc"
972 >();
973
974 auto verboseConstraint = [](PatternRewriter &rewriter, PDLResultList &,
975 ArrayRef<PDLValue> pdlValues) {
976 for (const PDLValue &pdlValue : pdlValues) {
977 if (Operation *op = dyn_cast_if_present<Operation *>(pdlValue)) {
978 op->emitWarning() << "from PDL constraint";
979 }
980 }
981 return success();
982 };
983
984 addDialectDataInitializer<transform::PDLMatchHooks>(
985 [&](transform::PDLMatchHooks &hooks) {
986 llvm::StringMap<PDLConstraintFunction> constraints;
987 constraints.try_emplace("verbose_constraint", verboseConstraint);
988 hooks.mergeInPDLMatchHooks(constraintFns: std::move(constraints));
989 });
990 }
991};
992} // namespace
993
994// These are automatically generated by ODS but are not used as the Transform
995// dialect uses a different dispatch mechanism to support dialect extensions.
996[[maybe_unused]] static OptionalParseResult
997generatedTypeParser(AsmParser &parser, StringRef *mnemonic, Type &value);
998[[maybe_unused]] static LogicalResult generatedTypePrinter(Type def,
999 AsmPrinter &printer);
1000[[maybe_unused]] static OptionalParseResult
1001generatedAttributeParser(AsmParser &parser, StringRef *mnemonic, Type type,
1002 Attribute &value);
1003[[maybe_unused]] static LogicalResult
1004generatedAttributePrinter(Attribute def, AsmPrinter &printer);
1005
1006#define GET_ATTRDEF_CLASSES
1007#include "TestTransformDialectExtensionAttrs.cpp.inc"
1008
1009#define GET_TYPEDEF_CLASSES
1010#include "TestTransformDialectExtensionTypes.cpp.inc"
1011
1012#define GET_OP_CLASSES
1013#include "TestTransformDialectExtension.cpp.inc"
1014
1015void ::test::registerTestTransformDialectExtension(DialectRegistry &registry) {
1016 registry.addExtensions<TestTransformDialectExtension>();
1017}
1018