Lines Matching +full:actions +full:- +full:builder
1 //===- TransformOps.cpp - Transform dialect operations --------------------===//
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
46 #define DEBUG_TYPE "transform-dialect"
49 #define DEBUG_TYPE_MATCHER "transform-matcher"
65 ArrayAttr matchers, ArrayAttr actions);
68 ArrayAttr &actions);
82 diag.attachNote(payload->getLoc()) << "target payload op";
85 transformAncestor = transformAncestor->getParentOp();
93 //===----------------------------------------------------------------------===//
95 //===----------------------------------------------------------------------===//
99 if (!point.isParent() && getOperation()->getNumOperands() == 1)
100 return getOperation()->getOperands();
101 return OperandRange(getOperation()->operand_end(),
102 getOperation()->operand_end());
110 : point.getRegionOrNull()->getRegionNumber() + 1)) {
116 regions.emplace_back(getOperation()->getResults());
131 for (const auto &res : block->getParentOp()->getOpResults())
146 if (original->isAncestor(getOperation())) {
149 diag.attachNote(original->getLoc()) << "scope";
152 if (!original->hasTrait<OpTrait::IsIsolatedFromAbove>()) {
154 << "only isolated-from-above ops can be alternative scopes";
155 diag.attachNote(original->getLoc()) << "scope";
167 llvm::map_range(originals, [](Operation *op) { return op->clone(); }));
170 clone->erase();
201 original->getBlock()->getOperations().insert(original->getIterator(),
203 rewriter.replaceOp(original, clone->getResults());
214 consumesHandle(getOperation()->getOpOperands(), effects);
215 producesHandle(getOperation()->getOpResults(), effects);
217 if (!region->empty())
218 producesHandle(region->front().getArguments(), effects);
227 if (terminator->getOperands().getTypes() != getResults().getTypes()) {
231 diag.attachNote(terminator->getLoc()) << "terminator";
239 //===----------------------------------------------------------------------===//
241 //===----------------------------------------------------------------------===//
260 target->setAttr(getName(), attr);
266 target->setAttr(getName(), attr);
277 //===----------------------------------------------------------------------===//
279 //===----------------------------------------------------------------------===//
303 //===----------------------------------------------------------------------===//
305 //===----------------------------------------------------------------------===//
323 op->walk([&](Operation *op) {
324 for (Value v : op->getOperands())
326 if (target->isProperAncestor(defOp))
334 op->walk([&](Operation *op) {
343 target->walk<WalkOrder::PostOrder>([&](Operation *op) {
368 //===----------------------------------------------------------------------===//
370 //===----------------------------------------------------------------------===//
385 MLIRContext *ctx = target->getContext();
400 config.maxIterations = getMaxIterations() == static_cast<uint64_t>(-1)
403 config.maxNumRewrites = getMaxNumRewrites() == static_cast<uint64_t>(-1)
417 if (target->hasTrait<OpTrait::IsIsolatedFromAbove>()) {
428 target->walk([&](Operation *nestedOp) {
477 OpBuilder &builder, OperationState &result, Value target,
481 OpBuilder::InsertionGuard g(builder);
483 builder.createBlock(region);
485 bodyBuilder(builder, result.location);
488 //===----------------------------------------------------------------------===//
490 //===----------------------------------------------------------------------===//
495 for (Dialect *dialect : ctx->getLoadedDialects())
496 dialect->getCanonicalizationPatterns(patterns);
497 for (RegisteredOperationName op : ctx->getRegisteredOperations())
501 //===----------------------------------------------------------------------===//
503 //===----------------------------------------------------------------------===//
510 // Instantiate the default type converter if a type converter builder is
566 // Add descriptor-specific updates to the conversion target, which may
608 diag.attachNote(target->getLoc()) << "target op";
658 diag.attachNote(maybeTypeConverter->getLoc()) << "op without interface";
685 OpBuilder &builder, OperationState &result, Value target,
691 OpBuilder::InsertionGuard g(builder);
693 builder.createBlock(region1);
695 patternsBodyBuilder(builder, result.location);
698 OpBuilder::InsertionGuard g(builder);
700 builder.createBlock(region2);
702 typeConverterBodyBuilder(builder, result.location);
706 //===----------------------------------------------------------------------===//
708 //===----------------------------------------------------------------------===//
712 Dialect *dialect = getContext()->getLoadedDialect(getDialectName());
718 iface->populateConvertToLLVMConversionPatterns(
723 transform::TypeConverterBuilderOpInterface builder) {
724 if (builder.getTypeConverterType() != "LLVMTypeConverter")
730 Dialect *dialect = getContext()->getLoadedDialect(getDialectName());
743 //===----------------------------------------------------------------------===//
745 //===----------------------------------------------------------------------===//
764 //===----------------------------------------------------------------------===//
766 //===----------------------------------------------------------------------===//
790 if (failed(info->addToPipeline(pm, getOptions(), [&](const Twine &msg) {
800 diag.attachNote(target->getLoc()) << "target op";
808 //===----------------------------------------------------------------------===//
810 //===----------------------------------------------------------------------===//
824 producesHandle(getOperation()->getOpResults(), effects);
835 //===----------------------------------------------------------------------===//
837 //===----------------------------------------------------------------------===//
874 ValueRange yieldedValues = block.getTerminator()->getOperands();
898 //===----------------------------------------------------------------------===//
900 //===----------------------------------------------------------------------===//
914 rawResults.resize(getOperation()->getNumResults());
917 WalkResult walkResult = root->walk([&](Operation *op) {
920 op->print(llvm::dbgs(),
958 llvm::zip_equal(getOperation()->getResults(), rawResults)) {
968 producesHandle(getOperation()->getOpResults(), effects);
992 if (resultTypes.size() != getOperation()->getNumResults()) {
995 << getOperation()->getNumResults() << "), got "
1000 llvm::enumerate(resultTypes, getOperation()->getResultTypes())) {
1012 //===----------------------------------------------------------------------===//
1014 //===----------------------------------------------------------------------===//
1061 WalkResult walkResult = root->walk([&](Operation *op) {
1069 op->print(llvm::dbgs(),
1105 overallDiag = emitSilenceableError() << "actions failed";
1107 overallDiag.attachNote(action->getLoc())
1109 overallDiag.attachNote(op->getLoc())
1117 action.getFunctionBody().front().getTerminator()->getOperands(),
1136 // by actions, are invalidated.
1157 if (getOperation()->getNumOperands() < 1 ||
1158 getOperation()->getNumResults() < 1) {
1164 producesHandle(getOperation()->getOpResults(), effects);
1168 /// Parses the comma-separated list of symbol reference pairs of the format
1169 /// `@matcher -> @action`.
1172 ArrayAttr &actions) {
1187 actions = parser.getBuilder().getArrayAttr(actionList);
1191 /// Prints the comma-separated list of symbol reference pairs of the format
1192 /// `@matcher -> @action`.
1194 ArrayAttr matchers, ArrayAttr actions) {
1198 matchers, actions, llvm::seq<unsigned>(0, matchers.size()))) {
1200 printer << cast<SymbolRefAttr>(matcher) << " -> "
1202 if (idx != matchers.size() - 1)
1211 return emitOpError() << "expected the same number of matchers and actions";
1226 /// Checks that the attributes of the function-like operation have correct
1265 emitWarning(op->getLoc())
1307 // Input -> matcher forwarding.
1315 diag.attachNote(matcherSymbol->getLoc()) << "symbol declaration";
1324 diag.attachNote(matcherSymbol->getLoc()) << "symbol declaration";
1335 diag.attachNote(matcherSymbol->getLoc()) << "symbol declaration";
1339 // Matcher -> action forwarding.
1359 // Action -> result forwarding.
1368 diag.attachNote(actionSymbol->getLoc()) << "symbol declaration";
1379 diag.attachNote(actionSymbol->getLoc()) << "symbol declaration";
1386 //===----------------------------------------------------------------------===//
1388 //===----------------------------------------------------------------------===//
1408 })->size();
1428 // call the body with - each slice of payloads at the same argument index
1475 // NB: this `zip` should be `zip_equal` - while this op's verifier catches
1500 producesHandle(getOperation()->getOpResults(), effects);
1507 regions.emplace_back(bodyRegion, bodyRegion->getArguments());
1513 regions.emplace_back(bodyRegion, bodyRegion->getArguments());
1522 return getOperation()->getOperands();
1537 "expects co-indexed targets and the body's "
1547 return emitOpError("expects co-indexed results and yield "
1554 //===----------------------------------------------------------------------===//
1556 //===----------------------------------------------------------------------===//
1567 parent = parent->getParentOp();
1571 parent->hasTrait<OpTrait::IsIsolatedFromAbove>();
1573 parent->getName().getStringRef() == *getOpName();
1576 parent = parent->getParentOp();
1586 diag.attachNote(target->getLoc()) << "target op";
1601 //===----------------------------------------------------------------------===//
1603 //===----------------------------------------------------------------------===//
1620 if (target->getNumResults() <= resultNumber)
1623 llvm::to_vector(target->getResult(resultNumber).getUsers()));
1627 //===----------------------------------------------------------------------===//
1629 //===----------------------------------------------------------------------===//
1649 //===----------------------------------------------------------------------===//
1651 //===----------------------------------------------------------------------===//
1661 target->getNumOperands() <= operandNumber
1663 : target->getOperand(operandNumber).getDefiningOp();
1669 diag.attachNote(target->getLoc()) << "target op";
1678 //===----------------------------------------------------------------------===//
1680 //===----------------------------------------------------------------------===//
1691 target->getNumOperands(), operandPositions);
1693 diag.attachNote(target->getLoc())
1699 return target->getOperand(pos);
1711 //===----------------------------------------------------------------------===//
1713 //===----------------------------------------------------------------------===//
1724 target->getNumResults(), resultPositions);
1726 diag.attachNote(target->getLoc())
1732 return target->getResult(pos);
1744 //===----------------------------------------------------------------------===//
1746 //===----------------------------------------------------------------------===//
1751 producesHandle(getOperation()->getOpResults(), effects);
1773 //===----------------------------------------------------------------------===//
1775 //===----------------------------------------------------------------------===//
1831 mappings, callee.getBody().front().getTerminator()->getOperands(), state);
1850 producesHandle(getOperation()->getOpResults(), effects);
1856 onlyReadsHandle(getOperation()->getOpOperands(), effects);
1862 getOperation()->getAttrOfType<SymbolRefAttr>(getTargetAttrName());
1878 consumesHandle(getOperation()->getOpOperand(i), effects);
1880 onlyReadsHandle(getOperation()->getOpOperand(i), effects);
1888 auto targetAttr = getOperation()->getAttrOfType<SymbolRefAttr>("target");
1928 //===----------------------------------------------------------------------===//
1930 //===----------------------------------------------------------------------===//
1943 //===----------------------------------------------------------------------===//
1945 //===----------------------------------------------------------------------===//
1950 StringRef currentOpName = current->getName().getStringRef();
1958 //===----------------------------------------------------------------------===//
1960 //===----------------------------------------------------------------------===//
1987 << "non-integer parameter value not expected";
2045 //===----------------------------------------------------------------------===//
2047 //===----------------------------------------------------------------------===//
2057 //===----------------------------------------------------------------------===//
2059 //===----------------------------------------------------------------------===//
2118 producesHandle(getOperation()->getOpResults(), effects);
2133 //===----------------------------------------------------------------------===//
2135 //===----------------------------------------------------------------------===//
2147 // dangling top-level op that does not get "called".
2150 state, this->getOperation(), getBody())))
2165 [](Builder &builder, ArrayRef<Type> inputs, ArrayRef<Type> results,
2167 std::string &) { return builder.getFunctionType(inputs, results); },
2178 /// Verifies that a symbol function-like transform dialect operation has the
2185 if (auto parent = op->getParentOfType<transform::TransformOpInterface>()) {
2201 return emitSilenceableFailure(op) << "expected a non-empty body block";
2209 diag.attachNote(terminator->getLoc()) << "terminator";
2213 if (terminator->getNumOperands() != op.getResultTypes().size()) {
2219 llvm::seq<unsigned>(0, terminator->getNumOperands()),
2220 terminator->getOperands().getType(), op.getResultTypes())) {
2233 /// immediately, so it can be used to check for op's well-formedness before the
2237 if (Operation *parent = op->getParentWithTrait<OpTrait::SymbolTable>()) {
2238 if (!parent->getAttr(
2245 diag.attachNote(parent->getLoc()) << "symbol table operation";
2250 if (auto parent = op->getParentOfType<transform::TransformOpInterface>()) {
2263 return emitSilenceableFailure(op) << "expected a non-empty body block";
2271 diag.attachNote(terminator->getLoc()) << "terminator";
2275 if (terminator->getNumOperands() != op.getFunctionType().getNumResults()) {
2281 llvm::zip_equal(llvm::seq<unsigned>(0, terminator->getNumOperands()),
2282 terminator->getOperands().getType(),
2308 static void buildSequenceBody(OpBuilder &builder, OperationState &state,
2316 OpBuilder::InsertionGuard guard(builder);
2319 builder.createBlock(region, region->begin(), types,
2323 builder.setInsertionPointToStart(bodyBlock);
2325 bodyBuilder(builder, state.location, bodyBlock->getArgument(0));
2327 bodyBuilder(builder, state.location, bodyBlock->getArgument(0),
2328 bodyBlock->getArguments().drop_front());
2332 void transform::NamedSequenceOp::build(OpBuilder &builder,
2339 builder.getStringAttr(symName));
2341 TypeAttr::get(FunctionType::get(builder.getContext(),
2346 buildSequenceBody(builder, state, rootType,
2350 //===----------------------------------------------------------------------===//
2352 //===----------------------------------------------------------------------===//
2382 .checkPayload(getLoc(), {Builder(getContext()).getI64IntegerAttr(0)})
2386 //===----------------------------------------------------------------------===//
2388 //===----------------------------------------------------------------------===//
2397 if (op->getName().getStringRef() == getOpName())
2404 //===----------------------------------------------------------------------===//
2406 //===----------------------------------------------------------------------===//
2408 void transform::SplitHandleOp::build(OpBuilder &builder, OperationState &result,
2431 return -1;
2436 << getHandle() << " expected to contain " << this->getNumResults()
2446 // - "fail_on_payload_too_small" is set to "false", or
2447 // - "pass_through_empty_handle" is set to "true" and there are 0 payload ops.
2455 resultHandles[*getOverflowResult()].reserve(numPayloads - getNumResults());
2461 [](Operation *op) -> MappedValue { return op; });
2465 [](Value v) -> MappedValue { return v; });
2470 [](Attribute a) -> MappedValue { return a; });
2491 producesHandle(getOperation()->getOpResults(), effects);
2512 //===----------------------------------------------------------------------===//
2514 //===----------------------------------------------------------------------===//
2550 producesHandle(getOperation()->getOpResults(), effects);
2553 //===----------------------------------------------------------------------===//
2555 //===----------------------------------------------------------------------===//
2562 auto scope = state.make_region_scope(*getBodyBlock()->getParent());
2666 diag.attachNote(potentialConsumer->getOwner()->getLoc())
2667 << "used here as operand #" << potentialConsumer->getOperandNumber();
2668 diag.attachNote(use.getOwner()->getLoc())
2677 assert(getBodyBlock()->getNumArguments() >= 1 &&
2683 << "does not expect extra operands when used as top-level";
2687 for (BlockArgument arg : getBodyBlock()->getArguments()) {
2698 &child != &getBodyBlock()->back()) {
2715 if (!getBodyBlock()->mightHaveTerminator())
2718 if (getBodyBlock()->getTerminator()->getOperandTypes() !=
2719 getOperation()->getResultTypes()) {
2723 diag.attachNote(getBodyBlock()->getTerminator()->getLoc()) << "terminator";
2737 if (getOperation()->getNumOperands() > 0)
2738 return getOperation()->getOperands();
2739 return OperandRange(getOperation()->operand_end(),
2740 getOperation()->operand_end());
2748 ? bodyRegion->getArguments()
2754 regions.emplace_back(getOperation()->getResults());
2763 void transform::SequenceOp::build(OpBuilder &builder, OperationState &state,
2768 build(builder, state, resultTypes, failurePropagationMode, root,
2771 buildSequenceBody(builder, state, bbArgType,
2775 void transform::SequenceOp::build(OpBuilder &builder, OperationState &state,
2780 build(builder, state, resultTypes, failurePropagationMode, root,
2782 buildSequenceBody(builder, state, root.getType(), extraBindings.getTypes(),
2786 void transform::SequenceOp::build(OpBuilder &builder, OperationState &state,
2791 build(builder, state, resultTypes, failurePropagationMode, /*root=*/Value(),
2793 buildSequenceBody(builder, state, bbArgType,
2797 void transform::SequenceOp::build(OpBuilder &builder, OperationState &state,
2802 build(builder, state, resultTypes, failurePropagationMode, /*root=*/Value(),
2804 buildSequenceBody(builder, state, bbArgType, extraBindingTypes, bodyBuilder);
2807 //===----------------------------------------------------------------------===//
2809 //===----------------------------------------------------------------------===//
2811 void transform::PrintOp::build(OpBuilder &builder, OperationState &result,
2814 result.getOrAddProperties<Properties>().name = builder.getStringAttr(name);
2817 void transform::PrintOp::build(OpBuilder &builder, OperationState &result,
2820 build(builder, result, name);
2840 llvm::outs() << "top-level ]]]\n";
2841 state.getTopLevel()->print(llvm::outs(), printFlags);
2849 target->print(llvm::outs(), printFlags);
2871 //===----------------------------------------------------------------------===//
2873 //===----------------------------------------------------------------------===//
2883 diag.attachNote(target->getLoc()) << "payload op";
2894 //===----------------------------------------------------------------------===//
2896 //===----------------------------------------------------------------------===//