[Mlir-commits] [mlir] [mlir] Add property combinators, initial ODS support (PR #94732)
llvmlistbot at llvm.org
llvmlistbot at llvm.org
Fri Jun 7 00:30:21 PDT 2024
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-mlir-llvm
@llvm/pr-subscribers-mlir-ods
@llvm/pr-subscribers-mlir
Author: Krzysztof Drewniak (krzysz00)
<details>
<summary>Changes</summary>
While we have had a Properties.td that allowed for defining non-attribute-backed properties, such properties were not plumbed through the basic autogeneration facilities available to attributes, forcing those who want to migrate to the new system to write such code by hand.
## Potentially breaking changes
- The `setFoo()` methods on `Properties` struct no longer take their inputs by const reference. Those wishing to pass non-owned values of a property by reference to constructors and setters should set the interface type to `const [storageType]&`
- Adapters and operations now define getters and setters for properties listed in ODS, which may conflict with custom getters.
- Builders now include properties listed in ODS specifications, potentially conflicting with custom builders with the same type signature.
## Extensions to the `Property` class
This commit adds several fields to the `Property` class, including:
- `parser`, `optionalParser`, and `printer` (for parsing/printing properties of a given type in ODS syntax)
- `storageTypeValueOverride`, an extension of `defaultValue` to allow the storage and interface type defaults to differ
- `baseProperty` (allowing for classes like `DefaultValuedProperty`)
Existing fields have also had their documentation comments updated.
This commit does not add a `PropertyConstraint` analogous to `AttrConstraint`, but this is a natural evolution of the work here.
This commit also adds the concrete property kinds `I32Property`, `I64Property`, `UnitProperty` (and special handling for it like for UnitAttr), and `BoolProperty`.
## Property combinators
`Properties.td` also now includes several ways to combine properties.
One is `ArrayProperty<Property elem>`, which now stores a variable-length array of some property as `SmallVector<elem.storageType>` and uses `ArrayRef<elem.storageType>` as its interface type. It has `IntArrayProperty` subclasses that change its conversion to attributes to use `DenseI[N]Attr`s instead of an `ArrayAttr`.
Similarly, `OptionalProperty<Property p>` wraps a property's storage in `std::optional<>` and adds a `std::nullopt` default value. In the case where the underlying property can be parsed optionally but doesn't have its own default value, `OptionalProperty` can piggyback off the optional parser to produce a cleaner syntax, as opposed to its general form, which is either `none` or `some<[value]>`.
(Note that `OptionalProperty` can be nested if desired).
## Autogeneration changes
Operations and adaptors now support getters and setters for properties like those for attributes. Unlike for attributes, there aren't separate value and attribute forms, since there is no `FooAttr()` available for a `getFooAttr()` to return.
The largest change is to operation formats. Previously, properties could only be used in custom directives. Now, they can be used anywhere an attribute could be used, and have parsers and printers defined in their tablegen records.
These updates include special `UnitProperty` logic like that used for `UnitAttr`.
## Misc.
Some attempt has been made to test the new functionality.
This commit takes tentative steps towards updating the documentation to account for properties. A full update will be in order once any followup work has been completed and the interfaces have stabilized.
---
Patch is 111.67 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/94732.diff
20 Files Affected:
- (modified) mlir/docs/DefiningDialects/Operations.md (+42-11)
- (modified) mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td (+1-14)
- (modified) mlir/include/mlir/IR/ODSSupport.h (+47-1)
- (modified) mlir/include/mlir/IR/Properties.td (+540-22)
- (modified) mlir/include/mlir/TableGen/Operator.h (+1-1)
- (modified) mlir/include/mlir/TableGen/Property.h (+49-4)
- (modified) mlir/lib/IR/ODSSupport.cpp (+71)
- (modified) mlir/lib/TableGen/Property.cpp (+44-15)
- (modified) mlir/test/IR/properties.mlir (+41-11)
- (modified) mlir/test/IR/traits.mlir (+19)
- (modified) mlir/test/Transforms/test-legalizer.mlir (+2-2)
- (modified) mlir/test/lib/Dialect/Test/TestFormatUtils.cpp (+11-5)
- (modified) mlir/test/lib/Dialect/Test/TestFormatUtils.h (+2-1)
- (modified) mlir/test/lib/Dialect/Test/TestOps.td (+72-13)
- (modified) mlir/test/lib/Dialect/Test/TestOpsSyntax.td (+22)
- (modified) mlir/test/mlir-tblgen/op-format.mlir (+10)
- (modified) mlir/test/mlir-tblgen/op-format.td (+2-2)
- (modified) mlir/test/mlir-tblgen/op-properties.td (+115-5)
- (modified) mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp (+170-30)
- (modified) mlir/tools/mlir-tblgen/OpFormatGen.cpp (+223-67)
``````````diff
diff --git a/mlir/docs/DefiningDialects/Operations.md b/mlir/docs/DefiningDialects/Operations.md
index 01fadef5c3dbe..b011375bb3f9a 100644
--- a/mlir/docs/DefiningDialects/Operations.md
+++ b/mlir/docs/DefiningDialects/Operations.md
@@ -101,6 +101,9 @@ their semantics via a special [TableGen backend][TableGenBackend]:
* The `AttrConstraint` class hierarchy: They are used to specify the
constraints over attributes. A notable subclass hierarchy is `Attr`, which
stands for constraints for attributes whose values are of common types.
+* The `Property` class hierarchy: They are used to specify non-attribute-backed
+ properties that are inherent to operations. This will be expanded to a
+ `PropertyConstraint` class or something similar in the future.
An operation is defined by specializing the `Op` class with concrete contents
for all the fields it requires. For example, `tf.AvgPool` is defined as
@@ -172,9 +175,9 @@ understanding the operation.
### Operation arguments
-There are two kinds of arguments: operands and attributes. Operands are runtime
-values produced by other ops; while attributes are compile-time known constant
-values, including two categories:
+There are three kinds of arguments: operands, attributes, and properties.
+Operands are runtime values produced by other ops; while attributes and properties
+are compile-time known constant values, including two categories:
1. Natural attributes: these attributes affect the behavior of the operations
(e.g., padding for convolution);
@@ -187,8 +190,11 @@ values, including two categories:
even though they are not materialized, it should be possible to store as an
attribute.
-Both operands and attributes are specified inside the `dag`-typed `arguments`,
-led by `ins`:
+Properties are similar to attributes, except that they are not stored within
+the MLIR context but are stored inline with the operation.
+
+Operands, attributes, and properties are specified inside the `dag`-typed
+`arguments`, led by `ins`:
```tablegen
let arguments = (ins
@@ -196,13 +202,15 @@ let arguments = (ins
...
<attr-constraint>:$<attr-name>,
...
+ <property-constraint>:$<property-name>,
);
```
Here `<type-constraint>` is a TableGen `def` from the `TypeConstraint` class
hierarchy. Similarly, `<attr-constraint>` is a TableGen `def` from the
-`AttrConstraint` class hierarchy. See [Constraints](#constraints) for more
-information.
+`AttrConstraint` class hierarchy and `<property-constraint>` is a subclass
+of `Property` (though a `PropertyConstraint` hierarchy is planned).
+See [Constraints](#constraints) for more information.
There is no requirements on the relative order of operands and attributes; they
can mix freely. The relative order of operands themselves matters. From each
@@ -324,6 +332,18 @@ Right now, the following primitive constraints are supported:
TODO: Design and implement more primitive constraints
+#### Optional and default-valued properties
+
+To declare a property with a default value, use `DefaultValuedProperty<..., "...">`.
+If the property's storage data type is different from its interface type,
+for example, in the case of array properties (which are stored as `SmallVector`s
+but use `ArrayRef` as an interface type), add the storage-type equivalent
+of the default value as the third argument.
+
+To declare an optional property, use `OptionalProperty<...>`.
+This wraps the underlying property in an `std::optional` and gives it a
+default value of `std::nullopt`.
+
#### Combining constraints
`AllAttrOf` is provided to allow combination of multiple constraints which
@@ -429,6 +449,8 @@ def MyOp : ... {
I32Attr:$i32_attr,
F32Attr:$f32_attr,
...
+ I32Property:$i32_prop,
+ ...
);
let results = (outs
@@ -453,7 +475,8 @@ static void build(OpBuilder &odsBuilder, OperationState &odsState,
static void build(OpBuilder &odsBuilder, OperationState &odsState,
Type i32_result, Type f32_result, ...,
Value i32_operand, Value f32_operand, ...,
- IntegerAttr i32_attr, FloatAttr f32_attr, ...);
+ IntegerAttr i32_attr, FloatAttr f32_attr, ...,
+ int32_t i32_prop);
// Each result-type/operand/attribute has a separate parameter. The parameters
// for attributes are raw values unwrapped with mlir::Attribute instances.
@@ -462,13 +485,15 @@ static void build(OpBuilder &odsBuilder, OperationState &odsState,
static void build(OpBuilder &odsBuilder, OperationState &odsState,
Type i32_result, Type f32_result, ...,
Value i32_operand, Value f32_operand, ...,
- APInt i32_attr, StringRef f32_attr, ...);
+ APInt i32_attr, StringRef f32_attr, ...,
+ int32_t i32_prop, ...);
// Each operand/attribute has a separate parameter but result type is aggregate.
static void build(OpBuilder &odsBuilder, OperationState &odsState,
TypeRange resultTypes,
Value i32_operand, Value f32_operand, ...,
- IntegerAttr i32_attr, FloatAttr f32_attr, ...);
+ IntegerAttr i32_attr, FloatAttr f32_attr, ...,
+ int32_t i32_prop, ...);
// All operands/attributes have aggregate parameters.
// Generated if return type can be inferred.
@@ -921,8 +946,10 @@ optional-group: `(` then-elements `)` (`:` `(` else-elements `)`)? `?`
The elements of an optional group have the following requirements:
* The first element of `then-elements` must either be a attribute, literal,
- operand, or region.
+ operand,property, or region.
- This is because the first element must be optionally parsable.
+ - If a property is used, it must have an `optionalParser` defined and have a
+ default value.
* Exactly one argument variable or type directive within either
`then-elements` or `else-elements` must be marked as the anchor of the
group.
@@ -984,6 +1011,8 @@ foo.op is_read_only
foo.op
```
+The same logic applies to a `UnitProperty`.
+
##### Optional "else" Group
Optional groups also have support for an "else" group of elements. These are
@@ -1026,6 +1055,8 @@ to:
1. All operand and result types must appear within the format using the various
`type` directives, either individually or with the `operands` or `results`
directives.
+1. Unless all non-attribute properties appear in the format, the `prop-dict`
+ directive must be present.
1. The `attr-dict` directive must always be present.
1. Must not contain overlapping information; e.g. multiple instances of
'attr-dict', types, operands, etc.
diff --git a/mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td b/mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td
index f6f907f39a4b4..4708006a5390d 100644
--- a/mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td
+++ b/mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td
@@ -59,22 +59,9 @@ class LLVM_IntArithmeticOpWithOverflowFlag<string mnemonic, string instName,
list<Trait> traits = []> :
LLVM_ArithmeticOpBase<AnySignlessInteger, mnemonic, instName,
!listconcat([DeclareOpInterfaceMethods<IntegerOverflowFlagsInterface>], traits)> {
- dag iofArg = (ins EnumProperty<"IntegerOverflowFlags">:$overflowFlags);
+ dag iofArg = (ins EnumProperty<"IntegerOverflowFlags", "", "IntegerOverflowFlags::none">:$overflowFlags);
let arguments = !con(commonArgs, iofArg);
- let builders = [
- OpBuilder<(ins "Type":$type, "Value":$lhs, "Value":$rhs,
- "IntegerOverflowFlags":$overflowFlags), [{
- $_state.getOrAddProperties<Properties>().overflowFlags = overflowFlags;
- build($_builder, $_state, type, lhs, rhs);
- }]>,
- OpBuilder<(ins "Value":$lhs, "Value":$rhs,
- "IntegerOverflowFlags":$overflowFlags), [{
- $_state.getOrAddProperties<Properties>().overflowFlags = overflowFlags;
- build($_builder, $_state, lhs, rhs);
- }]>
- ];
-
string mlirBuilder = [{
auto op = $_builder.create<$_qualCppClassName>($_location, $lhs, $rhs);
moduleImport.setIntegerOverflowFlags(inst, op);
diff --git a/mlir/include/mlir/IR/ODSSupport.h b/mlir/include/mlir/IR/ODSSupport.h
index 70e3f986431e2..25d6f3da6a861 100644
--- a/mlir/include/mlir/IR/ODSSupport.h
+++ b/mlir/include/mlir/IR/ODSSupport.h
@@ -33,6 +33,37 @@ convertFromAttribute(int64_t &storage, Attribute attr,
/// Convert the provided int64_t to an IntegerAttr attribute.
Attribute convertToAttribute(MLIRContext *ctx, int64_t storage);
+/// Convert an IntegerAttr attribute to an int32_t, or return an error if the
+/// attribute isn't an IntegerAttr. If the optional diagnostic is provided an
+/// error message is also emitted.
+LogicalResult
+convertFromAttribute(int32_t &storage, Attribute attr,
+ function_ref<InFlightDiagnostic()> emitError);
+
+/// Convert the provided int32_t to an IntegerAttr attribute.
+Attribute convertToAttribute(MLIRContext *ctx, int32_t storage);
+
+/// Extract the string from `attr` into `storage`. If `attr` is not a
+/// `StringAttr`, return failure and emit an error into the diagnostic from
+/// `emitError`.
+LogicalResult
+convertFromAttribute(std::string &storage, Attribute attr,
+ function_ref<InFlightDiagnostic()> emitError);
+
+/// Convert the given string into a StringAttr. Note that this takes a reference
+/// to the storage of a string property, which is an std::string.
+Attribute convertToAttribute(MLIRContext *ctx, const std::string &storage);
+
+/// Extract the boolean from `attr` into `storage`. If `attr` is not a
+/// `BoolAttr`, return failure and emit an error into the diagnostic from
+/// `emitError`.
+LogicalResult
+convertFromAttribute(bool &storage, Attribute attr,
+ function_ref<InFlightDiagnostic()> emitError);
+
+/// Convert the given string into a BooleanAttr.
+Attribute convertToAttribute(MLIRContext *ctx, bool storage);
+
/// Convert a DenseI64ArrayAttr to the provided storage. It is expected that the
/// storage has the same size as the array. An error is returned if the
/// attribute isn't a DenseI64ArrayAttr or it does not have the same size. If
@@ -49,9 +80,24 @@ LogicalResult
convertFromAttribute(MutableArrayRef<int32_t> storage, Attribute attr,
function_ref<InFlightDiagnostic()> emitError);
+/// Convert a DenseI64ArrayAttr to the provided storage, which will be
+/// cleared before writing. An error is returned and emitted to the optional
+/// `emitError` function if the attribute isn't a DenseI64ArrayAttr.
+LogicalResult
+convertFromAttribute(SmallVectorImpl<int64_t> &storage, Attribute attr,
+ function_ref<InFlightDiagnostic()> emitError);
+
+/// Convert a DenseI32ArrayAttr to the provided storage, which will be
+/// cleared before writing. It is expected that the storage has the same size as
+/// the array. An error is returned and emitted to the optional `emitError`
+/// function if the attribute isn't a DenseI32ArrayAttr.
+LogicalResult
+convertFromAttribute(SmallVectorImpl<int32_t> &storage, Attribute attr,
+ function_ref<InFlightDiagnostic()> emitError);
+
/// Convert the provided ArrayRef<int64_t> to a DenseI64ArrayAttr attribute.
Attribute convertToAttribute(MLIRContext *ctx, ArrayRef<int64_t> storage);
} // namespace mlir
-#endif // MLIR_IR_ODSSUPPORT_H
\ No newline at end of file
+#endif // MLIR_IR_ODSSUPPORT_H
diff --git a/mlir/include/mlir/IR/Properties.td b/mlir/include/mlir/IR/Properties.td
index 0babdbbfa05bc..1b6f5aa68c83b 100644
--- a/mlir/include/mlir/IR/Properties.td
+++ b/mlir/include/mlir/IR/Properties.td
@@ -29,7 +29,6 @@ class Property<string storageTypeParam = "", string desc = ""> {
//
// Format:
// - `$_storage` will contain the property in the storage type.
- // - `$_ctxt` will contain an `MLIRContext *`.
code convertFromStorage = "$_storage";
// The call expression to build a property storage from the interface type.
@@ -40,24 +39,26 @@ class Property<string storageTypeParam = "", string desc = ""> {
code assignToStorage = "$_storage = $_value";
// The call expression to convert from the storage type to an attribute.
+ // The resulting attribute must be non-null in non-error cases.
//
// Format:
// - `$_storage` is the storage type value.
// - `$_ctxt` is a `MLIRContext *`.
//
- // The expression must result in an Attribute.
+ // The expression must return an `Attribute` and will be used as a function body.
code convertToAttribute = [{
- convertToAttribute($_ctxt, $_storage)
+ return convertToAttribute($_ctxt, $_storage);
}];
// The call expression to convert from an Attribute to the storage type.
//
// Format:
- // - `$_storage` is the storage type value.
+ // - `$_storage` is a reference to a value of the storage type.
// - `$_attr` is the attribute.
// - `$_diag` is a callback to get a Diagnostic to emit error.
//
- // The expression must return a LogicalResult
+ // The expression must return a LogicalResult and will be used as a function body
+ // or in other similar contexts.
code convertFromAttribute = [{
return convertFromAttribute($_storage, $_attr, $_diag);
}];
@@ -68,18 +69,67 @@ class Property<string storageTypeParam = "", string desc = ""> {
// - `$_storage` is the variable to hash.
//
// The expression should define a llvm::hash_code.
- code hashProperty = [{
- llvm::hash_value($_storage);
+ // If unspecified, defaults to `llvm::hash_value($_storage)`.
+ // The default is not specified in tablegen because many combinators, like
+ // ArrayProperty, can fall back to more efficient implementations of
+ // `hashProperty` when their underlying elements have trivial hashing.
+ code hashProperty = "";
+
+ // The body of the parser for a value of this property.
+ // Format:
+ // - `$_parser` is the OpAsmParser.
+ // - `$_storage` is the location into which the value is to be placed if it is
+ // present.
+ // - `$_cxtx` is a `MLIRContext *`
+ //
+ // This defines the body of a function (typically a lambda) that returns a
+ // ParseResult. There is an implicit `return success()` at the end of the parser
+ // code.
+ //
+ // When this code executes, `$_storage` will be initialized to the property's
+ // default value (if any, accounting for the storage type override).
+ code parser = [{
+ auto value = ::mlir::FieldParser<}] # storageType # [{>::parse($_parser);
+ if (::mlir::failed(value))
+ return ::mlir::failure();
+ $_storage = std::move(*value);
}];
+ // The body of the parser for a value of this property as the anchor of an optional
+ // group. This should parse the property if possible and do nothing if a value of
+ // the relevant type is not next in the parse stream.
+ // You are not required to define this parser if it cannot be meaningfully
+ // implemented.
+ // This has the same context and substitutions as `parser` except that it is
+ // required to return an OptionalParseResult.
+ //
+ // Note that the printer for a property should always print a non-empty value.
+ //
+ // If the optional parser doesn't parse anything, it should not set
+ // $_storage, since the parser doesn't know if the default value has been
+ // overwritten.
+ code optionalParser = "";
+
+ // The printer for a value of this property.
+ // Format:
+ // - `$_storage` is the storage data.
+ // - `$_printer` is the OpAsmPrinter instance.
+ // - `$_ctxt` is a `MLIRContext *`
+ //
+ // This may be called in an expression context, so variable declarations must
+ // be praced within a new scope.
+ code printer = "$_printer << $_storage";
+
// The call expression to emit the storage type to bytecode.
//
// Format:
// - `$_storage` is the storage type value.
// - `$_writer` is a `DialectBytecodeWriter`.
// - `$_ctxt` is a `MLIRContext *`.
+ //
+ // This will become the body af a function returning void.
code writeToMlirBytecode = [{
- writeToMlirBytecode($_writer, $_storage)
+ writeToMlirBytecode($_writer, $_storage);
}];
// The call expression to read the storage type from bytecode.
@@ -88,13 +138,31 @@ class Property<string storageTypeParam = "", string desc = ""> {
// - `$_storage` is the storage type value.
// - `$_reader` is a `DialectBytecodeReader`.
// - `$_ctxt` is a `MLIRContext *`.
+ //
+ // This will become the body of a function returning LogicalResult.
+ // There is an implicit `return success()` at the end of this function.
+ //
+ // When this code executes, `$_storage` will be initialized to the property's
+ // default value (if any, accounting for the storage type override).
code readFromMlirBytecode = [{
if (::mlir::failed(readFromMlirBytecode($_reader, $_storage)))
return ::mlir::failure();
}];
- // Default value for the property.
- string defaultValue = ?;
+ // Base definition for the property. (Will be) used for `OptionalProperty` and
+ // such cases, analogously to `baseAttr`.
+ Property baseProperty = ?;
+
+ // Default value for the property within its storage. This should be an expression
+ // of type `interfaceType` and should be comparable with other types of that
+ // interface typ with `==`. The empty string means there is no default value.
+ string defaultValue = "";
+
+ // If set, the default value the storage of the property should be initilized to.
+ // This is only needed when the storage and interface types of the property
+ // are distinct (ex. SmallVector for storage vs. ArrayRef for interfacing), as it
+ // will fall back to defaultValue when unspecified.
+ string storageTypeValueOverride = "";
}
/// Implementation of the Property class's `readFromMlirBytecode` field using
@@ -133,12 +201,16 @@ defvar writeMlirBytecodeWithConvertToAttribute = [{
// Primitive property kinds
// Any kind of integer stored as properties.
-class IntProperty<string storageTypeParam = "", string desc = ""> :
+class IntProperty<string storageTypeParam, string desc = ""> :
Property<storageTypeParam, desc> {
- code writeToMlirBytecode = [{
+ let summary = !if(!empty(desc), storageTypeParam, desc);
+ let optionalParser = [{
+ return $_parser.parseOptionalInteger($_storage);
+ }];
+ let writeToMlirBytecode = [{
$_writer.writeVarInt($_storage);
}];
- code readFromMlirBytecode = [{
+ let readFromMlirBytecode = [{
uint64_t val;
if (failed($_reader.readVarInt(val)))
return ::mlir::failure();
@@ -146,24 +218,470 @@ class IntProperty<string storageTypeParam = "", string desc = ""> :
}];
}
-class ArrayProperty<string storageTypeParam = "", int n, string desc = ""> :
- Property<storageTypeParam # "[" # n # "]", desc> {
- let interfaceType = "::llvm::ArrayRef<" # storageTypeParam # ">";
- let convertFromStorage = "$_storage";
- let assignToStorage = "::llvm::copy($_value, $_storage)";
-}
+def I32Property : IntProperty<"int32_t">;
+def I64Property : IntProperty<"int64_t">;
-class EnumProperty<string storageTypeParam, string desc = ""> :
+class EnumProperty<string storageTypeParam, string desc = "", string default = ""> :
Property<storageTypeParam, desc> {
- code writeToMlirBytecode = [{
+ // TODO: take advantage of EnumAttrInfo and the like to make this share nice
+ // parsing code with EnumAttr.
+ let writeToMlirBytecode = [{
$_writer.writeVarInt(static_cast<uint64_t>($_storage));
}];
- code readFromMlirBytecode = [{
+ let readFromMlirBytecode = [{
uint64_t val;
if (failed($_reader.readVarInt(val)))
return ::mlir::failure();
$_storage = static_cast<}] # storageTypeParam # [{>(val);
}];
+ let defaultValue = default;
}
+def StringProperty : Property<"std::string", "string"> {
+ let interfaceType = "::llvm::StringRef";
+ let convertFromStorage = "::llvm::StringRef{$_storage}";
+ let assignToStorage = "$_storage = $_value.str()";
+ let optionalParser = [{
+ if (::mlir::failed($_parser.parseOptionalString(&$_storage)))
+ return std::nullopt;
+ }];
+ let printer = "$_printer.printString($_storage)";
+ let readFromMlirBytecode = [{
+ StringRef val;
+ if (::mlir::failed($_reader.readString(val)))
+ return ::mlir::failure();
+ $_storage = val.str();
+ }];
+ let writeToMlirBytecode = [{
+ ...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/94732
More information about the Mlir-commits
mailing list