convention are described in the documentation of Transform IR ops.
The transform IR values have transform IR types, which implement either
-[TransformTypeInterface](Transform.md#transformtypeinterface-transformtypeinterface)
+[TransformHandleTypeInterface](Transform.md#transformhandletypeinterface-transformhandletypeinterface)
or
[TransformParamTypeInterface](Transform.md##transformparamtypeinterface-transformparamtypeinterface).
The former interface verifiers properties of payload IR operations associated
Similarly to operations, additional types can be injected into the dialect using
the same extension mechanism. The types must:
- * Implement exactly one of `TransformTypeInterface`,
+ * Implement exactly one of `TransformHandleTypeInterface`,
`TransformParamTypeInterface`.
## Side Effects
}];
let arguments =
- (ins TransformTypeInterface:$target,
+ (ins TransformHandleTypeInterface:$target,
DefaultValuedAttr<ConfinedAttr<I64Attr, [IntPositive]>,
"1">:$num_loops,
DefaultValuedAttr<BoolAttr, "false">:$affine);
- let results = (outs TransformTypeInterface : $parent);
+ let results = (outs TransformHandleTypeInterface : $parent);
let assemblyFormat =
"$target attr-dict `:` functional-type(operands, results)";
// Note that despite the name of the transform operation and related utility
// functions, the actual implementation does not require the operation to be
// a loop.
- let arguments = (ins TransformTypeInterface:$target,
+ let arguments = (ins TransformHandleTypeInterface:$target,
StrAttr:$func_name);
- let results = (outs TransformTypeInterface:$transformed);
+ let results = (outs TransformHandleTypeInterface:$transformed);
let assemblyFormat =
"$target attr-dict `:` functional-type(operands, results)";
(ins Transform_ScfForOp:$target,
DefaultValuedAttr<BoolAttr, "false">:$fail_if_already_divisible);
// TODO: Return both the peeled loop and the remainder loop.
- let results = (outs TransformTypeInterface:$transformed);
+ let results = (outs TransformHandleTypeInterface:$transformed);
let assemblyFormat =
"$target attr-dict `:` functional-type(operands, results)";
let arguments = (ins Transform_ScfForOp:$target,
DefaultValuedAttr<I64Attr, "1">:$iteration_interval,
DefaultValuedAttr<I64Attr, "10">:$read_latency);
- let results = (outs TransformTypeInterface:$transformed);
+ let results = (outs TransformHandleTypeInterface:$transformed);
let assemblyFormat =
"$target attr-dict `:` functional-type(operands, results)";
removed after a full unrolling.
}];
- let arguments = (ins TransformTypeInterface:$target,
+ let arguments = (ins TransformHandleTypeInterface:$target,
ConfinedAttr<I64Attr, [IntPositive]>:$factor);
let assemblyFormat = "$target attr-dict `:` type($target)";
void checkImplementsTransformOpInterface(StringRef name, MLIRContext *context);
/// Asserts that the type provided as template argument implements the
-/// TransformTypeInterface. This must be a dynamic assertion since interface
-/// implementations may be registered at runtime.
-void checkImplementsTransformTypeInterface(TypeID typeID, MLIRContext *context);
+/// TransformHandleTypeInterface. This must be a dynamic assertion since
+/// interface implementations may be registered at runtime.
+void checkImplementsTransformHandleTypeInterface(TypeID typeID,
+ MLIRContext *context);
} // namespace detail
#endif // NDEBUG
} // namespace transform
}
/// Injects the types into the Transform dialect. The types must implement
- /// the TransformTypeInterface and the implementation must be already
+ /// the TransformHandleTypeInterface and the implementation must be already
/// available when the type is injected. Furthermore, the types must provide
/// a `getMnemonic` static method returning an object convertible to
/// `StringRef` that is unique across all injected types.
addTypes<Type>();
#ifndef NDEBUG
- detail::checkImplementsTransformTypeInterface(TypeID::get<Type>(),
- getContext());
+ detail::checkImplementsTransformHandleTypeInterface(TypeID::get<Type>(),
+ getContext());
#endif // NDEBUG
}
///
/// Returns failure if the payload does not satisfy the conditions associated
/// with the type of the handle value. The value is expected to have a type
- /// implementing TransformTypeInterface.
+ /// implementing TransformHandleTypeInterface.
LogicalResult setPayloadOps(Value value, ArrayRef<Operation *> targets);
/// Sets the parameters associated with the given transform IR value. Returns
/// Indicates that the result of the transform IR op at the given position
/// corresponds to the given list of payload IR ops. Each result must be set
/// by the transformation exactly once. The value must have a type
- /// implementing TransformTypeInterface.
+ /// implementing TransformHandleTypeInterface.
void set(OpResult value, ArrayRef<Operation *> ops);
/// Indicates that the result of the transform IR op at the given position
}];
}
-def TransformTypeInterface
- : TransformTypeInterfaceBase<"TransformTypeInterface",
+def TransformHandleTypeInterface
+ : TransformTypeInterfaceBase<"TransformHandleTypeInterface",
"::mlir::Operation *"> {
let description = [{
Types that can be used for the Transform dialect handle values. Such types
```
}];
- let arguments = (ins Optional<TransformTypeInterface>:$scope);
- let results = (outs Variadic<TransformTypeInterface>:$results);
+ let arguments = (ins Optional<TransformHandleTypeInterface>:$scope);
+ let results = (outs Variadic<TransformHandleTypeInterface>:$results);
let regions = (region VariadicRegion<SizedRegion<1>>:$alternatives);
let assemblyFormat =
[TransformOpInterface, TransformEachOpTrait,
DeclareOpInterfaceMethods<CastOpInterface>,
DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
- let arguments = (ins TransformTypeInterface:$input);
- let results = (outs TransformTypeInterface:$output);
+ let arguments = (ins TransformHandleTypeInterface:$input);
+ let results = (outs TransformHandleTypeInterface:$output);
let assemblyFormat = "$input attr-dict `:` type($input) `to` type($output)";
let extraClassDeclaration = [{
merged and mapped to the same resulting handle.
}];
- let arguments = (ins TransformTypeInterface:$target);
- let results = (outs Variadic<TransformTypeInterface>:$results);
+ let arguments = (ins TransformHandleTypeInterface:$target);
+ let results = (outs Variadic<TransformHandleTypeInterface>:$results);
let regions = (region SizedRegion<1>:$body);
let assemblyFormat =
"$target `:` type($target) (`->` type($results)^)? $body attr-dict";
on the further transformation applied to the handle produced here.
}];
- let arguments = (ins TransformTypeInterface:$target);
- let results = (outs TransformTypeInterface:$parent);
+ let arguments = (ins TransformHandleTypeInterface:$target);
+ let results = (outs TransformHandleTypeInterface:$parent);
let assemblyFormat =
"$target attr-dict `:` functional-type(operands, results)";
}
computational operations, which can be empty.
}];
- let arguments = (ins TransformTypeInterface:$target,
+ let arguments = (ins TransformHandleTypeInterface:$target,
I64Attr:$operand_number);
- let results = (outs TransformTypeInterface:$parent);
+ let results = (outs TransformHandleTypeInterface:$parent);
let assemblyFormat = "$target `[` $operand_number `]` attr-dict `:` "
"functional-type(operands, results)";
}
same or different handles. Consumes the operands and produces a new handle.
}];
- let arguments = (ins Variadic<TransformTypeInterface>:$handles,
+ let arguments = (ins Variadic<TransformHandleTypeInterface>:$handles,
UnitAttr:$deduplicate);
- let results = (outs TransformTypeInterface:$result);
+ let results = (outs TransformHandleTypeInterface:$result);
let assemblyFormat = "($deduplicate^)? $handles attr-dict `:` type($result)";
let hasFolder = 1;
}
operations contained in the source `handle`. Otherwise it silently fails.
}];
- let arguments = (ins TransformTypeInterface:$handle,
+ let arguments = (ins TransformHandleTypeInterface:$handle,
I64Attr:$num_result_handles);
- let results = (outs Variadic<TransformTypeInterface>:$results);
+ let results = (outs Variadic<TransformHandleTypeInterface>:$results);
let builders = [
OpBuilder<(ins "Value":$handle, "int64_t":$numResultHandles)>
}];
let arguments = (ins
- Arg<TransformTypeInterface, "Payload IR scope to match within">:$root,
+ Arg<TransformHandleTypeInterface, "Payload IR scope to match within">:$root,
SymbolRefAttr:$pattern_name);
let results = (outs
- Res<TransformTypeInterface, "Handle to the matched Payload IR ops">:$matched);
+ Res<TransformHandleTypeInterface, "Handle to the matched Payload IR ops">:$matched);
let assemblyFormat = "$pattern_name `in` $root attr-dict `:` "
"functional-type(operands, results)";
This op is useful for printf-style debugging.
}];
- let arguments = (ins Optional<TransformTypeInterface>:$target,
+ let arguments = (ins Optional<TransformHandleTypeInterface>:$target,
OptionalAttr<StrAttr>:$name);
let results = (outs);
MergeHandlesOp can be used to construct arbitrary lists with repetitions.
}];
- let arguments = (ins TransformTypeInterface:$pattern,
- Variadic<TransformTypeInterface>:$handles);
- let results = (outs Variadic<TransformTypeInterface>:$replicated);
+ let arguments = (ins TransformHandleTypeInterface:$pattern,
+ Variadic<TransformHandleTypeInterface>:$handles);
+ let results = (outs Variadic<TransformHandleTypeInterface>:$replicated);
let assemblyFormat = "`num` `(` $pattern `)` $handles attr-dict `:` "
"type($pattern) `,` type($handles)";
}
}];
let arguments = (ins FailurePropagationMode:$failure_propagation_mode,
- Optional<TransformTypeInterface>:$root);
- let results = (outs Variadic<TransformTypeInterface>:$results);
+ Optional<TransformHandleTypeInterface>:$root);
+ let results = (outs Variadic<TransformHandleTypeInterface>:$results);
let regions = (region SizedRegion<1>:$body);
let assemblyFormat =
}];
let arguments = (ins
- Arg<Optional<TransformTypeInterface>, "Root operation of the Payload IR",
+ Arg<Optional<TransformHandleTypeInterface>, "Root operation of the Payload IR",
[TransformMappingRead]>:$root);
let regions = (region SizedRegion<1>:$body);
let assemblyFormat = "($root^ `:` type($root))? attr-dict-with-keyword regions";
}];
let arguments = (ins
- Arg<Variadic<TransformTypeInterface>, "Operation handles yielded back to the parent",
+ Arg<Variadic<TransformHandleTypeInterface>, "Operation handles yielded back to the parent",
[TransformMappingRead]>:$operands);
let assemblyFormat = "operands attr-dict (`:` type($operands)^)?";
include "mlir/Dialect/Transform/IR/TransformDialect.td"
def Transform_AnyOpType : TypeDef<Transform_Dialect, "AnyOp",
- [DeclareTypeInterfaceMethods<TransformTypeInterface>]> {
+ [DeclareTypeInterfaceMethods<TransformHandleTypeInterface>]> {
let description = [{
Transform IR handle that can be associated with a list of arbitrary
Payload IR operations.
}
def Transform_OperationType : TypeDef<Transform_Dialect, "Operation",
- [DeclareTypeInterfaceMethods<TransformTypeInterface>]> {
+ [DeclareTypeInterfaceMethods<TransformHandleTypeInterface>]> {
let description = [{
Transform IR handle that can be associated with a list of Payload IR
operations with the specified operation name.
"MemoryEffectsOpInterface");
}
-void transform::detail::checkImplementsTransformTypeInterface(
+void transform::detail::checkImplementsTransformHandleTypeInterface(
TypeID typeID, MLIRContext *context) {
const auto &abstractType = AbstractType::lookup(typeID, context);
assert(
- (abstractType.hasInterface(TransformTypeInterface::getInterfaceID()) ||
+ (abstractType.hasInterface(
+ TransformHandleTypeInterface::getInterfaceID()) ||
abstractType.hasInterface(
TransformParamTypeInterface::getInterfaceID())) &&
"expected Transform dialect type to implement one of the two interfaces");
#endif // NDEBUG
namespace {
-struct PDLOperationTypeTransformTypeInterfaceImpl
- : public transform::TransformTypeInterface::ExternalModel<
- PDLOperationTypeTransformTypeInterfaceImpl, pdl::OperationType> {
+struct PDLOperationTypeTransformHandleTypeInterfaceImpl
+ : public transform::TransformHandleTypeInterface::ExternalModel<
+ PDLOperationTypeTransformHandleTypeInterfaceImpl,
+ pdl::OperationType> {
DiagnosedSilenceableFailure
checkPayload(Type type, Location loc, ArrayRef<Operation *> payload) const {
return DiagnosedSilenceableFailure::success();
initializeTypes();
pdl::OperationType::attachInterface<
- PDLOperationTypeTransformTypeInterfaceImpl>(*getContext());
+ PDLOperationTypeTransformHandleTypeInterfaceImpl>(*getContext());
}
void transform::TransformDialect::mergeInPDLMatchHooks(
assert(!value.getType().isa<TransformParamTypeInterface>() &&
"cannot associate payload ops with a value of parameter type");
- auto iface = value.getType().cast<TransformTypeInterface>();
+ auto iface = value.getType().cast<TransformHandleTypeInterface>();
DiagnosedSilenceableFailure result =
iface.checkPayload(value.getLoc(), targets);
if (failed(result.checkAndReport()))
}
}
- auto iface = value.getType().cast<TransformTypeInterface>();
+ auto iface = value.getType().cast<TransformHandleTypeInterface>();
DiagnosedSilenceableFailure result =
iface.checkPayload(value.getLoc(), updated);
if (failed(result.checkAndReport()))
Block *body = &bodyRegion->front();
if (body->getNumArguments() != 1 ||
- !body->getArgumentTypes()[0].isa<TransformTypeInterface>()) {
- return op->emitOpError() << "expects the entry block to have one argument "
- "of type implementing TransformTypeInterface";
+ !body->getArgumentTypes()[0].isa<TransformHandleTypeInterface>()) {
+ return op->emitOpError()
+ << "expects the entry block to have one argument "
+ "of type implementing TransformHandleTypeInterface";
}
if (auto *parent =
bool hasPayloadOperands = false;
for (Value operand : op->getOperands()) {
onlyReadsHandle(operand, effects);
- if (operand.getType().isa<TransformTypeInterface>())
+ if (operand.getType().isa<TransformHandleTypeInterface>())
hasPayloadOperands = true;
}
if (hasPayloadOperands)
return llvm::all_of(
std::initializer_list<Type>{inputs.front(), outputs.front()},
[](Type ty) {
- return ty.isa<pdl::OperationType, transform::TransformTypeInterface>();
+ return ty
+ .isa<pdl::OperationType, transform::TransformHandleTypeInterface>();
});
}
return emitOpError() << "expects the same number of results as the "
"terminator has operands";
for (Value v : yieldOp.getOperands())
- if (!v.getType().isa<TransformTypeInterface>())
- return yieldOp->emitOpError(
- "expects operands to have types implementing TransformTypeInterface");
+ if (!v.getType().isa<TransformHandleTypeInterface>())
+ return yieldOp->emitOpError("expects operands to have types implementing "
+ "TransformHandleTypeInterface");
return success();
}
// RUN: mlir-opt %s -split-input-file -verify-diagnostics
-// expected-error @below {{expects the entry block to have one argument of type implementing TransformTypeInterface}}
+// expected-error @below {{expects the entry block to have one argument of type implementing TransformHandleTypeInterface}}
transform.sequence failures(propagate) {
}
// -----
-// expected-error @below {{expects the entry block to have one argument of type implementing TransformTypeInterface}}
+// expected-error @below {{expects the entry block to have one argument of type implementing TransformHandleTypeInterface}}
transform.alternatives {
^bb0:
transform.yield
def TestTransformTestDialectHandleType
: TypeDef<Transform_Dialect, "TestDialectOp",
- [DeclareTypeInterfaceMethods<TransformTypeInterface>]> {
+ [DeclareTypeInterfaceMethods<TransformHandleTypeInterface>]> {
let description = [{Handle pointing to an op from the Test dialect.}];
let mnemonic = "test_dialect_op";
let assemblyFormat = "";
: Op<Transform_Dialect, "test_print_remark_at_operand",
[DeclareOpInterfaceMethods<TransformOpInterface>]> {
let arguments = (ins
- Arg<TransformTypeInterface, "",
+ Arg<TransformHandleTypeInterface, "",
[TransformMappingRead, PayloadIRRead]>:$operand,
StrAttr:$message);
let assemblyFormat =
: Op<Transform_Dialect, "test_produce_param_with_number_of_test_ops",
[MemoryEffectsOpInterface, ParamProducerTransformOpTrait,
DeclareOpInterfaceMethods<TransformOpInterface>]> {
- let arguments = (ins TransformTypeInterface:$handle);
+ let arguments = (ins TransformHandleTypeInterface:$handle);
let results = (outs TestTransformTestDialectParamType:$result);
let assemblyFormat = "$handle attr-dict `:` type($handle)";
let cppNamespace = "::mlir::test";
projects / platform / upstream / llvm.git / commitdiff