Lines Matching full:op
40 OpSymbolBindingNoResult op) {
41 // Turn the no result op to a one-result op.
42 rewriter.create<OpSymbolBindingB>(op.getLoc(), op.getOperand().getType(),
43 op.getOperand());
46 static bool getFirstI32Result(Operation *op, Value &value) {
47 if (!Type(op->getResult(0).getType()).isSignlessInteger(32))
49 value = op->getResult(0);
93 LogicalResult matchAndRewrite(Operation *op,
101 op->getLoc(), rewriter.getIntegerType(32), op->getOperand(0));
103 rewriter.replaceOp(op, result);
117 LogicalResult matchAndRewrite(TestCastOp op,
119 if (!op->hasAttr("test_fold_before_previously_folded_op"))
121 rewriter.setInsertionPointToStart(op->getBlock());
124 op.getLoc(), rewriter.getBoolAttr(true));
125 rewriter.replaceOpWithNewOp<TestCastOp>(op, rewriter.getI32Type(),
140 LogicalResult matchAndRewrite(TestCommutative2Op op,
143 dyn_cast_or_null<TestCommutative2Op>(op->getOperand(0).getDefiningOp());
149 rewriter.replaceOp(op, operand->getOperand(1));
160 LogicalResult matchAndRewrite(AnyAttrOfOp op,
162 auto intAttr = dyn_cast<IntegerAttr>(op.getAttr());
169 op, [&]() { op.setAttrAttr(rewriter.getI32IntegerAttr(val + 1)); });
179 LogicalResult matchAndRewrite(Operation *op,
181 if (op->hasAttr("eligible"))
184 op, [&]() { op->setAttr("eligible", rewriter.getUnitAttr()); });
193 LogicalResult matchAndRewrite(test::OneRegionOp op,
195 Operation *terminator = op.getRegion().front().getTerminator();
197 if (toBeHoisted->getParentOp() != op)
201 rewriter.moveOpBefore(toBeHoisted, op);
206 /// This pattern moves "test.move_before_parent_op" before the parent op.
211 LogicalResult matchAndRewrite(Operation *op,
214 if (isa<FunctionOpInterface>(op->getParentOp()))
216 rewriter.moveOpBefore(op, op->getParentOp());
221 /// This pattern moves "test.move_after_parent_op" after the parent op.
226 LogicalResult matchAndRewrite(Operation *op,
229 if (isa<FunctionOpInterface>(op->getParentOp()))
233 if (auto advanceBy = op->getAttrOfType<IntegerAttr>("advance"))
236 Operation *moveAfter = op->getParentOp();
240 rewriter.moveOpAfter(op, moveAfter);
252 LogicalResult matchAndRewrite(Operation *op,
255 for (Region &r : op->getRegions()) {
257 rewriter.inlineBlockBefore(&r.front(), op);
265 /// This pattern splits blocks at "test.split_block_here" and replaces the op
266 /// with a new op (to prevent an infinite loop of block splitting).
271 LogicalResult matchAndRewrite(Operation *op,
273 rewriter.splitBlock(op->getBlock(), op->getIterator());
275 op->getLoc(),
276 OperationName("test.new_op", op->getContext()).getIdentifier(),
277 op->getOperands(), op->getResultTypes());
278 rewriter.replaceOp(op, newOp);
288 LogicalResult matchAndRewrite(Operation *op,
291 if (op->hasAttr("was_cloned"))
293 Operation *cloned = rewriter.clone(*op);
305 LogicalResult matchAndRewrite(Operation *op,
308 if (op->hasAttr("was_cloned"))
310 for (Region &r : op->getRegions())
311 rewriter.cloneRegionBefore(r, op->getBlock());
312 op->setAttr("was_cloned", rewriter.getUnitAttr());
323 LogicalResult matchAndRewrite(Operation *op,
326 if (op->hasAttr("create_erase_op")) {
328 op->getLoc(),
329 OperationName("test.erase_op", op->getContext()).getIdentifier(),
333 op->getLoc(),
334 OperationName("test.new_op", op->getContext()).getIdentifier(),
335 op->getOperands(), op->getResultTypes());
339 rewriter.replaceAllOpUsesWith(op, newOp->getResults());
340 rewriter.eraseOp(op);
352 LogicalResult matchAndRewrite(Operation *op,
354 for (Region &r : op->getRegions()) {
418 llvm::outs() << " into unknown op: ";
426 void notifyOperationInserted(Operation *op,
428 llvm::outs() << "notifyOperationInserted: " << op->getName();
445 void notifyOperationErased(Operation *op) override {
446 llvm::outs() << "notifyOperationErased: " << op->getName() << "\n";
448 void notifyOperationModified(Operation *op) override {
449 llvm::outs() << "notifyOperationModified: " << op->getName() << "\n";
451 void notifyOperationReplaced(Operation *op, ValueRange values) override {
452 llvm::outs() << "notifyOperationReplaced: " << op->getName() << "\n";
490 getOperation()->walk([&](Operation *op) {
491 StringRef opName = op->getName().getStringRef();
498 ops.push_back(op);
540 LogicalResult matchAndRewrite(Operation *op,
542 if (op->hasAttr("skip"))
546 rewriter.create(op->getLoc(), op->getName().getIdentifier(),
547 op->getOperands(), op->getResultTypes());
549 op, [&]() { op->setAttr("skip", rewriter.getBoolAttr(true)); });
561 LogicalResult matchAndRewrite(Operation *op,
563 rewriter.eraseOp(op);
573 // worklist: when an op is modified, it is added to the worklist. The two
586 LogicalResult matchAndRewrite(Operation *op,
588 if (op->getNumSuccessors() < 2)
590 Block *firstSuccessor = op->getSuccessor(0);
591 Block *secondSuccessor = op->getSuccessor(1);
607 LogicalResult matchAndRewrite(Operation *op,
609 if (op->getNumSuccessors() < 1 || op->getSuccessor(0) == op->getBlock())
611 rewriter.modifyOpInPlace(op,
612 [&]() { op->setSuccessor(op->getBlock(), 0); });
660 static void invokeCreateWithInferredReturnType(Operation *op) {
661 auto *context = op->getContext();
662 auto fop = op->getParentOfType<func::FuncOp>();
664 OpBuilder b(op);
665 b.setInsertionPointAfter(op);
674 context, std::nullopt, values, op->getDiscardableAttrDictionary(),
675 op->getPropertiesStorage(), op->getRegions(),
679 OpTy::build(b, state, values, op->getAttrs());
686 static void reifyReturnShape(Operation *op) {
687 OpBuilder b(op);
690 auto shapedOp = cast<OpWithShapedTypeInferTypeInterfaceOp>(op);
692 if (failed(shapedOp.reifyReturnTypeShapes(b, op->getOperands(), shapes)) ||
696 op->emitRemark() << "value " << it.index() << ": "
715 for (auto &op : getOperation().getBody().front())
716 ops.push_back(&op);
718 for (auto *op : llvm::ArrayRef(ops).drop_back()) {
719 // Test create method of each of the Op classes below. The resultant
720 // output would be in reverse order underneath `op` from which
722 invokeCreateWithInferredReturnType<OpWithInferTypeInterfaceOp>(op);
724 op);
726 OpWithShapedTypeInferTypeInterfaceOp>(op);
733 for (auto &op : getOperation().getBody().front())
734 if (isa<OpWithShapedTypeInferTypeInterfaceOp>(op))
735 ops.push_back(&op);
737 for (auto *op : ops)
738 reifyReturnShape(op);
784 matchAndRewrite(Operation *op, ArrayRef<Value> operands,
786 if (op->getNumRegions() != 1)
788 OperationState state(op->getLoc(), "test.legal_op", operands,
789 op->getResultTypes(), {}, BlockRange());
791 rewriter.inlineRegionBefore(op->getRegion(0), *newRegion,
798 rewriter.replaceOp(op, newOp->getResults());
810 matchAndRewrite(Operation *op, ArrayRef<Value> operands,
813 auto &parentRegion = *op->getParentRegion();
814 auto &opRegion = op->getRegion(0);
815 if (op->getDiscardableAttr("legalizer.should_clone"))
820 if (op->getDiscardableAttr("legalizer.erase_old_blocks")) {
826 rewriter.eraseOp(op);
836 LogicalResult matchAndRewrite(Operation *op,
839 OperationState newRegion(op->getLoc(), "test.region");
847 rewriter.create<ILLegalOpF>(op->getLoc(), rewriter.getIntegerType(32));
848 rewriter.create<TestValidOp>(op->getLoc(), ArrayRef<Value>());
851 rewriter.eraseOp(op);
861 LogicalResult matchAndRewrite(Operation *op,
863 Region ®ion = *op->getParentRegion();
865 Location loc = op->getLoc();
868 rewriter.eraseOp(op);
879 LogicalResult matchAndRewrite(Operation *op,
881 Region ®ion = *op->getParentRegion();
883 Location loc = op->getLoc();
885 // Create an illegal op to ensure the conversion fails.
888 rewriter.eraseOp(op);
900 matchAndRewrite(Operation *op, ArrayRef<Value> operands,
903 rewriter.create<ILLegalOpF>(op->getLoc(), rewriter.getF32Type());
904 rewriter.replaceUsesOfBlockArgument(op->getRegion(0).getArgument(0),
906 rewriter.modifyOpInPlace(op, [] {});
918 matchAndRewrite(Operation *op, ArrayRef<Value> operands,
920 rewriter.moveOpBefore(op, op->getParentOp());
921 // Replace with an illegal op to ensure the conversion fails.
922 rewriter.replaceOpWithNewOp<ILLegalOpF>(op, rewriter.getF32Type());
933 matchAndRewrite(Operation *op, ArrayRef<Value> operands,
935 Block *secondBlock = &*std::next(op->getRegion(0).begin());
937 rewriter.create<ILLegalOpF>(op->getLoc(), rewriter.getF32Type());
939 rewriter.modifyOpInPlace(op, [] {});
944 /// A pattern that modifies a property in-place, but keeps the op illegal.
949 matchAndRewrite(Operation *op, ArrayRef<Value> operands,
951 if (!op->hasAttr("modify_inplace"))
954 op, [&]() { cast<TestOpWithProperties>(op).getProperties().setA(42); });
968 matchAndRewrite(Operation *op, ArrayRef<Value> operands,
970 Region ®ion = op->getRegion(0);
982 rewriter.eraseOp(op);
991 matchAndRewrite(Operation *op, ArrayRef<ValueRange> operands,
1001 // This is a 1:N replacement. Insert a test.cast op. (That's what the
1005 .create<TestCastOp>(op->getLoc(),
1006 op->getOperand(it.index()).getType(), range)
1009 rewriter.replaceOpWithNewOp<TestValidOp>(op, std::nullopt, flattened,
1014 /// Replace with valid op, but simply drop the operands. This is used in a
1023 matchAndRewrite(Operation *op, ArrayRef<Value> operands,
1025 rewriter.replaceOpWithNewOp<TestValidOp>(op, std::nullopt, ValueRange(),
1035 matchAndRewrite(Operation *op, ArrayRef<ValueRange> operands,
1038 if (op->getNumOperands() != 1 || !op->getOperand(0).getType().isF32())
1040 rewriter.replaceOpWithNewOp<TestReturnOp>(op, operands[0]);
1051 matchAndRewrite(Operation *op, ArrayRef<Value> operands,
1054 if (!Type(*op->result_type_begin()).isSignlessInteger(32))
1056 rewriter.replaceOpWithNewOp<TestTypeProducerOp>(op, rewriter.getF32Type());
1064 matchAndRewrite(Operation *op, ArrayRef<Value> operands,
1067 if (!Type(*op->result_type_begin()).isF32())
1068 return rewriter.notifyMatchFailure(op, "expected single f32 operand");
1069 rewriter.replaceOpWithNewOp<TestTypeProducerOp>(op, rewriter.getF64Type());
1077 matchAndRewrite(Operation *op, ArrayRef<Value> operands,
1081 rewriter.replaceOpWithNewOp<TestTypeProducerOp>(op, rewriter.getBF16Type());
1089 matchAndRewrite(Operation *op, ArrayRef<Value> operands,
1094 rewriter.replaceOpWithNewOp<TestTypeConsumerOp>(op, operands[0]);
1103 /// temporary op.
1108 LogicalResult matchAndRewrite(Operation *op,
1110 auto resultType = *op->result_type_begin();
1111 auto illegalOp = rewriter.create<ILLegalOpF>(op->getLoc(), resultType);
1112 auto legalOp = rewriter.create<LegalOpB>(op->getLoc(), resultType);
1115 rewriter.replaceOp(op, illegalOp);
1133 LogicalResult matchAndRewrite(TestRecursiveRewriteOp op,
1135 // Decrement the depth of the op in-place.
1136 rewriter.modifyOpInPlace(op, [&] {
1137 op->setAttr("depth", rewriter.getI64IntegerAttr(op.getDepth() - 1));
1147 LogicalResult matchAndRewrite(IllegalOpWithRegionAnchor op,
1149 // rewriter.replaceOpWithNewOp<IllegalOpWithRegion>(op);
1150 rewriter.replaceOpWithNewOp<IllegalOpWithRegion>(op);
1155 // This pattern matches `test.blackhole` and delete this op and its producer.
1159 LogicalResult matchAndRewrite(BlackHoleOp op,
1161 Operation *producer = op.getOperand().getDefiningOp();
1164 rewriter.eraseOp(op);
1170 // This pattern replaces explicitly illegal op with explicitly legal op,
1175 LogicalResult matchAndRewrite(ILLegalOpG op,
1178 Value val = rewriter.create<arith::ConstantOp>(op->getLoc(), attr);
1179 rewriter.replaceOpWithNewOp<LegalOpC>(op, val);
1188 matchAndRewrite(Operation *op, ArrayRef<Value> operands,
1190 // Erase op without replacements.
1191 rewriter.eraseOp(op);
1196 /// This pattern matches a test.duplicate_block_args op and duplicates all
1203 matchAndRewrite(DuplicateBlockArgsOp op, OpAdaptor adaptor,
1205 if (op.getIsLegal())
1207 rewriter.startOpModification(op);
1208 Block *body = &op.getBody().front();
1213 op.setIsLegal(true);
1214 rewriter.finalizeOpModification(op);
1220 /// op. The pattern supports 1:N replacements and forwards the replacement
1227 matchAndRewrite(Operation *op, ArrayRef<ValueRange> operands,
1230 if (op->getNumOperands() != 1)
1232 rewriter.replaceOpWithNewOp<TestValidOp>(op, operands.front());
1237 /// A pattern that tests two back-to-back 1 -> 2 op replacements.
1244 matchAndRewrite(Operation *op, ArrayRef<ValueRange> operands,
1246 // Helper function that replaces the given op with a new op of the given
1248 auto replaceWithDoubleResults = [&](Operation *op, StringRef name) {
1250 for (Type t : op->getResultTypes()) {
1254 OperationState state(op->getLoc(), name,
1255 /*operands=*/{}, types, op->getAttrs());
1258 for (size_t i = 0, e = op->getNumResults(); i < e; ++i)
1260 rewriter.replaceOpWithMultiple(op, repls);
1265 Operation *repl1 = replaceWithDoubleResults(op, "test.step_1");
1371 target.addDynamicallyLegalOp<TestReturnOp>([](TestReturnOp op) {
1373 return llvm::none_of(op.getOperandTypes(),
1376 target.addDynamicallyLegalOp<func::FuncOp>([&](func::FuncOp op) {
1377 return converter.isSignatureLegal(op.getFunctionType()) &&
1378 converter.isLegal(&op.getBody());
1381 [&](func::CallOp op) { return converter.isLegal(op); });
1390 [](TestTypeProducerOp op) { return op.getType().isF64(); });
1391 target.addDynamicallyLegalOp<TestTypeConsumerOp>([](TestTypeConsumerOp op) {
1392 return op.getOperand().getType().isF64();
1396 target.markOpRecursivelyLegal<func::FuncOp, ModuleOp>([](Operation *op) {
1398 op->getAttrOfType<UnitAttr>("test.recursively_legal"));
1403 [](TestRecursiveRewriteOp op) { return op.getDepth() == 0; });
1407 [](TestOpInPlaceSelfFold op) { return op.getFolded(); });
1410 [](DuplicateBlockArgsOp op) { return op.getIsLegal(); });
1424 for (auto *op : unlegalizedOps)
1425 op->emitRemark() << "op '" << op->getName() << "' is not legalizable";
1432 target.markUnknownOpDynamicallyLegal([](Operation *op) {
1433 return (bool)op->getAttrOfType<UnitAttr>("test.dynamically_legal");
1458 for (auto *op : legalizedOps)
1459 op->emitRemark() << "op '" << op->getName() << "' is legalizable";
1508 matchAndRewrite(OneVResOneVOperandOp1 op, OpAdaptor adaptor,
1510 auto origOps = op.getOperands();
1520 rewriter.replaceOpWithNewOp<OneVResOneVOperandOp1>(op, op.getResultTypes(),
1532 matchAndRewrite(TestRemappedValueRegionOp op, OpAdaptor adaptor,
1534 Block &block = op.getBody().front();
1538 Block *parentBlock = op->getBlock();
1539 Block *finalBlock = rewriter.splitBlock(parentBlock, op->getIterator());
1551 rewriter.replaceOp(op, terminatorOperands);
1578 [](TestTypeProducerOp op) { return op.getType().isF64(); });
1579 target.addDynamicallyLegalOp<TestTypeConsumerOp>([](TestTypeConsumerOp op) {
1580 return op.getOperand().getType().isF64();
1587 [](Operation *op) { return op->getNumOperands() > 1; });
1607 LogicalResult matchAndRewrite(Operation *op,
1609 if (!isa<TestDialect>(op->getDialect()))
1611 rewriter.eraseOp(op);
1651 LogicalResult matchAndRewrite(Operation *op,
1653 assert(op->getName().getStringRef() ==
1657 OperationState state(op->getLoc(), "test.dynamic_generic",
1658 op->getOperands(), op->getResultTypes(),
1659 op->getAttrs());
1661 rewriter.replaceOp(op, newOp->getResults());
1673 StringRef getArgument() const final { return "test-rewrite-dynamic-op"; }
1701 matchAndRewrite(TestTypeProducerOp op, OpAdaptor adaptor,
1703 Type resultType = op.getType();
1717 rewriter.replaceOpWithNewOp<TestTypeProducerOp>(op, resultType);
1729 matchAndRewrite(TestSignatureConversionUndoOp op, OpAdaptor adaptor,
1731 (void)rewriter.convertRegionTypes(&op->getRegion(0), *getTypeConverter());
1746 matchAndRewrite(TestSignatureConversionNoConverterOp op, OpAdaptor adaptor,
1748 Region ®ion = op->getRegion(0);
1756 rewriter.modifyOpInPlace(op, [&] {
1765 /// Just forward the operands to the root op. This is essentially a no-op
1772 matchAndRewrite(TestTypeConsumerOp op, OpAdaptor adaptor,
1774 rewriter.modifyOpInPlace(op,
1775 [&] { op->setOperands(adaptor.getOperands()); });
1784 LogicalResult matchAndRewrite(TestAnotherTypeProducerOp op,
1786 rewriter.replaceOpWithNewOp<TestTypeProducerOp>(op, op.getType());
1796 matchAndRewrite(Operation *op, ArrayRef<Value> operands,
1798 rewriter.replaceOpWithNewOp<LegalOpD>(op, operands[0]);
1895 target.addDynamicallyLegalOp<TestTypeProducerOp>([](TestTypeProducerOp op) {
1896 auto recursiveType = dyn_cast<test::TestRecursiveType>(op.getType());
1897 return op.getType().isF64() || op.getType().isInteger(64) ||
1901 target.addDynamicallyLegalOp<func::FuncOp>([&](func::FuncOp op) {
1902 return converter.isSignatureLegal(op.getFunctionType()) &&
1903 converter.isLegal(&op.getBody());
1905 target.addDynamicallyLegalOp<TestCastOp>([&](TestCastOp op) {
1907 return (*op.operand_type_begin()).isF64() && op.getType().isF32();
1910 [&](TestSignatureConversionNoConverterOp op) {
1911 return converter.isLegal(op.getRegion().front().getArgumentTypes());
1941 matchAndRewrite(TestTypeChangerOp op, OpAdaptor adaptor,
1943 rewriter.replaceOp(op, adaptor.getOperands());
1996 matchAndRewrite(TestMergeBlocksOp op, OpAdaptor adaptor,
1998 Block &firstBlock = op.getBody().front();
2000 Block *secondBlock = &*(std::next(op.getBody().begin()));
2005 rewriter.modifyOpInPlace(op, [] {});
2015 matchAndRewrite(Operation *op, ArrayRef<Value> operands,
2017 Block &firstBlock = op->getRegion(0).front();
2019 Block *secondBlock = &*(std::next(op->getRegion(0).begin()));
2021 rewriter.create<ILLegalOpF>(op->getLoc(), rewriter.getF32Type());
2026 rewriter.modifyOpInPlace(op, [] {});
2031 /// A rewrite mechanism to inline the body of the op into its parent, when both
2039 matchAndRewrite(SingleBlockImplicitTerminatorOp op, OpAdaptor adaptor,
2042 op->getParentOfType<SingleBlockImplicitTerminatorOp>();
2045 Block &innerBlock = op.getRegion().front();
2048 rewriter.inlineBlockBefore(&innerBlock, op);
2050 rewriter.eraseOp(op);
2073 /// Expect the op to have a single block after legalization.
2075 [&](TestMergeBlocksOp op) -> bool {
2076 return llvm::hasSingleElement(op.getBody());
2079 /// Only allow `test.br` within test.merge_blocks op.
2080 target.addDynamicallyLegalOp<TestBranchOp>([&](TestBranchOp op) -> bool {
2081 return op->getParentOfType<TestMergeBlocksOp>();
2087 [&](SingleBlockImplicitTerminatorOp op) -> bool {
2088 return !op->getParentOfType<SingleBlockImplicitTerminatorOp>();
2096 for (auto *op : unlegalizedOps)
2097 op->emitRemark() << "op '" << op->getName() << "' is not legalizable";
2107 /// A rewrite mechanism to inline the body of the op into its parent, when both
2112 LogicalResult matchAndRewrite(TestCastOp op,
2114 if (op.getNumOperands() != 2)
2116 OperandRange operands = op.getOperands();
2119 rewriter.replaceUsesWithIf(op, operands[0], [](OpOperand &operand) {
2124 rewriter.replaceOp(op, op.getOperand(1));