================
@@ -601,32 +610,105 @@ mlirTypeConverterAddConversion(MlirTypeConverter
typeConverter,
MlirTypeConverterConversionCallback convertType,
void *userData);
-/// Convert the given type using the given TypeConverter.
+/// Opaque accumulator for the result types of a 1:N type conversion. It is
+/// passed to a MlirTypeConverter1ToNConversionCallback, which appends
converted
+/// types to it via mlirTypeConverterConversionResultsAppend.
+typedef struct MlirTypeConverterConversionResults {
+ void *ptr;
+} MlirTypeConverterConversionResults;
+
+/// Append a converted result type to the given 1:N conversion result
+/// accumulator.
+MLIR_CAPI_EXPORTED void mlirTypeConverterConversionResultsAppend(
+ MlirTypeConverterConversionResults results, MlirType type);
+
+/// Outcome of a 1:N type conversion callback
+/// (MlirTypeConverter1ToNConversionCallback). Mirrors the three states of the
+/// underlying C++ `std::optional<LogicalResult>` return.
+typedef enum MlirTypeConverterConversionStatus {
+ /// The type was converted; the types appended to the results accumulator
make
+ /// up the conversion (appending none erases the type).
+ MlirTypeConverterConversionStatusSuccess = 0,
+ /// The conversion failed hard; no further conversion function will be tried.
+ /// Any types appended before returning failure are discarded.
+ MlirTypeConverterConversionStatusFailure = 1,
+ /// The conversion was declined; another registered conversion function may
be
+ /// tried. Any types appended before declining are discarded.
+ MlirTypeConverterConversionStatusDeclined = 2,
+} MlirTypeConverterConversionStatus;
+
+/// Callback type for 1:N type conversion functions. For the given `type`, the
+/// callback appends zero or more converted result types to `results` (via
+/// mlirTypeConverterConversionResultsAppend) and returns a status.
+typedef MlirTypeConverterConversionStatus (
+ *MlirTypeConverter1ToNConversionCallback)(
+ MlirType type, MlirTypeConverterConversionResults results, void *userData);
+
+/// Add a 1:N type conversion function to the given TypeConverter.
+MLIR_CAPI_EXPORTED void mlirTypeConverterAdd1ToNConversion(
+ MlirTypeConverter typeConverter,
+ MlirTypeConverter1ToNConversionCallback convertType, void *userData);
+
+/// Convert the given type using the given TypeConverter. This is the 1:1
+/// convenience form: it returns the single converted type, or a null MlirType
+/// on failure or if the type converts to anything other than exactly one type
+/// (e.g. a 1:N conversion registered via mlirTypeConverterAdd1ToNConversion,
or
+/// an erasure to zero types).
MLIR_CAPI_EXPORTED MlirType
mlirTypeConverterConvertType(MlirTypeConverter typeConverter, MlirType type);
-/// Callback type for type materializations. Given a builder (passed as a
+/// Callback type for source materializations. Given a builder (passed as a
/// rewriter), the desired output type, the input values, and a location, the
/// callback must build a cast-like operation that produces a single value of
/// `outputType` and return it. Returning a null MlirValue indicates failure,
in
/// which case another registered materialization may be attempted.
-typedef MlirValue (*MlirTypeConverterMaterializationCallback)(
+typedef MlirValue (*MlirTypeConverterSourceMaterializationCallback)(
MlirRewriterBase rewriter, MlirType outputType, intptr_t nInputs,
MlirValue *inputs, MlirLocation loc, void *userData);
+/// Callback type for 1:1 target materializations. Behaves like
+/// MlirTypeConverterSourceMaterializationCallback, but additionally receives
+/// `originalType`: the original type of the SSA value being materialized.
+///
+/// Note: This callback is single-output. For the 1:N (multiple-output) form,
+/// use MlirTypeConverter1ToNTargetMaterializationCallback.
+typedef MlirValue (*MlirTypeConverterTargetMaterializationCallback)(
+ MlirRewriterBase rewriter, MlirType outputType, intptr_t nInputs,
+ MlirValue *inputs, MlirLocation loc, MlirType originalType, void
*userData);
+
/// Register a source materialization with the given TypeConverter. This is
/// invoked when a replacement value must be converted back to its original
/// source type because some uses persist beyond the main conversion.
MLIR_CAPI_EXPORTED void mlirTypeConverterAddSourceMaterialization(
MlirTypeConverter typeConverter,
- MlirTypeConverterMaterializationCallback callback, void *userData);
+ MlirTypeConverterSourceMaterializationCallback callback, void *userData);
/// Register a target materialization with the given TypeConverter. This is
/// invoked when a value must be converted to a target type according to a
/// pattern's type converter.
MLIR_CAPI_EXPORTED void mlirTypeConverterAddTargetMaterialization(
MlirTypeConverter typeConverter,
- MlirTypeConverterMaterializationCallback callback, void *userData);
+ MlirTypeConverterTargetMaterializationCallback callback, void *userData);
+
+/// Callback type for 1:N target materializations. Like
+/// MlirTypeConverterTargetMaterializationCallback, but produces a value for
+/// each of the `nOutputTypes` requested output types instead of a single
value.
+/// The callback must fill `outputs` -- a caller-allocated array of length
+/// `nOutputTypes` -- with that many values and return success. Returning
+/// failure signals that this materialization declined (so another may be
+/// attempted); in that case `outputs` is ignored. A success that leaves any of
----------------
jpienaar wrote:
success with any null meaning declined seems confusing. I thought from above
null would mean remove.
https://github.com/llvm/llvm-project/pull/208935
_______________________________________________
llvm-branch-commits mailing list
[email protected]
https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
