13 #ifndef MLIR_TRANSFORMS_DIALECTCONVERSION_H_
14 #define MLIR_TRANSFORMS_DIALECTCONVERSION_H_
16 #include "mlir/Config/mlir-config.h"
18 #include "llvm/ADT/MapVector.h"
19 #include "llvm/ADT/StringMap.h"
20 #include <type_traits>
27 struct ConversionConfig;
28 class ConversionPatternRewriter;
31 struct OperationConverter;
47 : conversions(other.conversions),
48 argumentMaterializations(other.argumentMaterializations),
49 sourceMaterializations(other.sourceMaterializations),
50 targetMaterializations(other.targetMaterializations),
51 typeAttributeConversions(other.typeAttributeConversions) {}
53 conversions = other.conversions;
54 argumentMaterializations = other.argumentMaterializations;
55 sourceMaterializations = other.sourceMaterializations;
56 targetMaterializations = other.targetMaterializations;
57 typeAttributeConversions = other.typeAttributeConversions;
66 : remappedInputs(numOrigInputs) {}
83 return remappedInputs[input];
105 void remapInput(
unsigned origInputNo,
unsigned newInputNo,
106 unsigned newInputCount = 1);
135 llvm::PointerIntPair<Attribute, 2>
impl;
138 static constexpr
unsigned naTag = 0;
139 static constexpr
unsigned resultTag = 1;
140 static constexpr
unsigned abortTag = 2;
161 template <
typename FnT,
typename T =
typename llvm::function_traits<
162 std::decay_t<FnT>>::template arg_t<0>>
164 registerConversion(wrapCallback<T>(std::forward<FnT>(callback)));
191 template <
typename FnT,
typename T =
typename llvm::function_traits<
192 std::decay_t<FnT>>::template arg_t<1>>
194 argumentMaterializations.emplace_back(
195 wrapMaterialization<T>(std::forward<FnT>(callback)));
202 template <
typename FnT,
typename T =
typename llvm::function_traits<
203 std::decay_t<FnT>>::template arg_t<1>>
205 sourceMaterializations.emplace_back(
206 wrapMaterialization<T>(std::forward<FnT>(callback)));
226 template <
typename FnT,
typename T =
typename llvm::function_traits<
227 std::decay_t<FnT>>::template arg_t<1>>
229 targetMaterializations.emplace_back(
230 wrapTargetMaterialization<T>(std::forward<FnT>(callback)));
253 typename llvm::function_traits<std::decay_t<FnT>>::template arg_t<0>,
255 typename llvm::function_traits<std::decay_t<FnT>>::template arg_t<1>>
257 registerTypeAttributeConversion(
258 wrapTypeAttributeConversion<T, A>(std::forward<FnT>(callback)));
274 template <
typename TargetType>
276 return dyn_cast_or_null<TargetType>(
convertType(t));
290 template <
typename RangeT>
291 std::enable_if_t<!std::is_convertible<RangeT, Type>::value &&
292 !std::is_convertible<RangeT, Operation *>::value,
295 return llvm::all_of(range, [
this](
Type type) {
return isLegal(type); });
311 SignatureConversion &result)
const;
313 SignatureConversion &result,
314 unsigned origInputOffset = 0)
const;
331 Type originalType = {})
const;
334 TypeRange resultType,
336 Type originalType = {})
const;
343 Attribute attr)
const;
349 using ConversionCallbackFn = std::function<std::optional<LogicalResult>(
350 Type, SmallVectorImpl<Type> &)>;
356 using MaterializationCallbackFn =
357 std::function<
Value(OpBuilder &, Type, ValueRange, Location)>;
362 using TargetMaterializationCallbackFn = std::function<SmallVector<Value>(
363 OpBuilder &, TypeRange, ValueRange, Location, Type)>;
366 using TypeAttributeConversionCallbackFn =
367 std::function<AttributeConversionResult(Type, Attribute)>;
372 template <
typename T,
typename FnT>
373 std::enable_if_t<std::is_invocable_v<FnT, T>, ConversionCallbackFn>
374 wrapCallback(FnT &&callback)
const {
375 return wrapCallback<T>([callback = std::forward<FnT>(callback)](
376 T type, SmallVectorImpl<Type> &results) {
377 if (std::optional<Type> resultOpt = callback(type)) {
378 bool wasSuccess =
static_cast<bool>(*resultOpt);
380 results.push_back(*resultOpt);
381 return std::optional<LogicalResult>(success(wasSuccess));
383 return std::optional<LogicalResult>();
388 template <
typename T,
typename FnT>
389 std::enable_if_t<std::is_invocable_v<FnT, T, SmallVectorImpl<Type> &>,
390 ConversionCallbackFn>
391 wrapCallback(FnT &&callback)
const {
392 return [callback = std::forward<FnT>(callback)](
394 SmallVectorImpl<Type> &results) -> std::optional<LogicalResult> {
395 T derivedType = dyn_cast<T>(type);
398 return callback(derivedType, results);
403 void registerConversion(ConversionCallbackFn callback) {
404 conversions.emplace_back(std::move(callback));
405 cachedDirectConversions.clear();
406 cachedMultiConversions.clear();
413 template <
typename T,
typename FnT>
414 MaterializationCallbackFn wrapMaterialization(FnT &&callback)
const {
415 return [callback = std::forward<FnT>(callback)](
416 OpBuilder &builder,
Type resultType, ValueRange inputs,
417 Location loc) -> Value {
418 if (T derivedType = dyn_cast<T>(resultType))
419 return callback(builder, derivedType, inputs, loc);
432 template <
typename T,
typename FnT>
434 std::is_invocable_v<FnT, OpBuilder &, T, ValueRange, Location, Type>,
435 TargetMaterializationCallbackFn>
436 wrapTargetMaterialization(FnT &&callback)
const {
437 return [callback = std::forward<FnT>(callback)](
438 OpBuilder &builder, TypeRange resultTypes, ValueRange inputs,
439 Location loc,
Type originalType) -> SmallVector<Value> {
440 SmallVector<Value> result;
441 if constexpr (std::is_same<T, TypeRange>::value) {
444 result = callback(builder, resultTypes, inputs, loc, originalType);
445 }
else if constexpr (std::is_assignable<Type, T>::value) {
448 if (resultTypes.size() == 1) {
451 if (T derivedType = dyn_cast<T>(resultTypes.front())) {
456 callback(builder, derivedType, inputs, loc, originalType);
458 result.push_back(val);
462 static_assert(
sizeof(T) == 0,
"T must be a Type or a TypeRange");
470 template <
typename T,
typename FnT>
472 std::is_invocable_v<FnT, OpBuilder &, T, ValueRange, Location>,
473 TargetMaterializationCallbackFn>
474 wrapTargetMaterialization(FnT &&callback)
const {
475 return wrapTargetMaterialization<T>(
476 [callback = std::forward<FnT>(callback)](
477 OpBuilder &builder, T resultTypes, ValueRange inputs, Location loc,
479 return callback(builder, resultTypes, inputs, loc);
487 template <
typename T,
typename A,
typename FnT>
488 TypeAttributeConversionCallbackFn
489 wrapTypeAttributeConversion(FnT &&callback)
const {
490 return [callback = std::forward<FnT>(callback)](
491 Type type, Attribute attr) -> AttributeConversionResult {
492 if (T derivedType = dyn_cast<T>(type)) {
493 if (A derivedAttr = dyn_cast_or_null<A>(attr))
494 return callback(derivedType, derivedAttr);
502 registerTypeAttributeConversion(TypeAttributeConversionCallbackFn callback) {
503 typeAttributeConversions.emplace_back(std::move(callback));
505 cachedDirectConversions.clear();
506 cachedMultiConversions.clear();
510 SmallVector<ConversionCallbackFn, 4> conversions;
513 SmallVector<MaterializationCallbackFn, 2> argumentMaterializations;
514 SmallVector<MaterializationCallbackFn, 2> sourceMaterializations;
515 SmallVector<TargetMaterializationCallbackFn, 2> targetMaterializations;
518 SmallVector<TypeAttributeConversionCallbackFn, 2> typeAttributeConversions;
523 mutable DenseMap<Type, Type> cachedDirectConversions;
525 mutable DenseMap<Type, SmallVector<Type, 2>> cachedMultiConversions;
527 mutable llvm::sys::SmartRWMutex<true> cacheMutex;
538 template <
typename PatternT>
540 using PatternT::PatternT;
546 virtual LogicalResult match(
typename PatternT::OperationT op)
const = 0;
551 virtual void rewrite(
typename PatternT::OperationT op,
552 typename PatternT::OpAdaptor adaptor,
555 llvm_unreachable(
"rewrite is not implemented");
558 virtual void rewrite(
typename PatternT::OperationT op,
559 typename PatternT::OneToNOpAdaptor adaptor,
561 if constexpr (std::is_same<
typename PatternT::OpAdaptor,
563 rewrite(op, PatternT::getOneToOneAdaptorOperands(adaptor), rewriter);
566 PatternT::getOneToOneAdaptorOperands(adaptor.getOperands());
567 rewrite(op,
typename PatternT::OpAdaptor(oneToOneOperands, adaptor),
573 matchAndRewrite(
typename PatternT::OperationT op,
574 typename PatternT::OneToNOpAdaptor adaptor,
576 if (succeeded(match(op))) {
577 rewrite(op, adaptor, rewriter);
584 matchAndRewrite(
typename PatternT::OperationT op,
585 typename PatternT::OpAdaptor adaptor,
591 llvm_unreachable(
"this function is unreachable");
614 virtual LogicalResult
617 llvm_unreachable(
"matchAndRewrite is not implemented");
622 virtual LogicalResult
636 template <
typename ConverterTy>
637 std::enable_if_t<std::is_base_of<TypeConverter, ConverterTy>::value,
646 using RewritePattern::RewritePattern;
649 template <
typename... Args>
671 template <
typename SourceOp>
677 typename SourceOp::template GenericAdaptor<ArrayRef<ValueRange>>;
696 auto sourceOp = cast<SourceOp>(op);
702 auto sourceOp = cast<SourceOp>(op);
709 virtual LogicalResult
712 llvm_unreachable(
"matchAndRewrite is not implemented");
714 virtual LogicalResult
729 template <
typename SourceOp>
734 SourceOp::getInterfaceID(), benefit, context) {}
738 SourceOp::getInterfaceID(), benefit, context) {}
755 virtual LogicalResult
758 llvm_unreachable(
"matchAndRewrite is not implemented");
760 virtual LogicalResult
773 template <
template <
typename>
class TraitType>
778 TypeID::
get<TraitType>(), benefit, context) {}
782 TypeID::
get<TraitType>(), benefit, context) {}
788 FailureOr<Operation *>
790 const TypeConverter &converter,
791 ConversionPatternRewriter &rewriter);
797 StringRef functionLikeOpName, RewritePatternSet &
patterns,
798 const TypeConverter &converter);
800 template <
typename FuncOpT>
808 RewritePatternSet &
patterns,
const TypeConverter &converter);
815 struct ConversionPatternRewriterImpl;
902 template <
typename RangeT = ValueRange>
907 template <
typename RangeT>
910 ArrayRef(llvm::to_vector_of<ValueRange>(newValues)));
924 ValueRange argValues = std::nullopt)
override;
955 std::unique_ptr<detail::ConversionPatternRewriterImpl>
impl;
991 std::function<std::optional<bool>(
Operation *)>;
1002 template <
typename OpT>
1011 template <
typename OpT>
1015 template <
typename OpT,
typename OpT2,
typename... OpTs>
1026 setLegalityCallback(op, callback);
1028 template <
typename OpT>
1033 template <
typename OpT,
typename OpT2,
typename... OpTs>
1035 addDynamicallyLegalOp<OpT>(callback);
1038 template <
typename OpT,
class Callable>
1039 std::enable_if_t<!std::is_invocable_v<Callable, Operation *>>
1041 addDynamicallyLegalOp<OpT>(
1042 [=](
Operation *op) {
return callback(cast<OpT>(op)); });
1050 template <
typename OpT>
1054 template <
typename OpT,
typename OpT2,
typename... OpTs>
1056 addIllegalOp<OpT>();
1067 template <
typename OpT>
1072 template <
typename OpT,
typename OpT2,
typename... OpTs>
1074 markOpRecursivelyLegal<OpT>(callback);
1077 template <
typename OpT,
class Callable>
1078 std::enable_if_t<!std::is_invocable_v<Callable, Operation *>>
1080 markOpRecursivelyLegal<OpT>(
1081 [=](
Operation *op) {
return callback(cast<OpT>(op)); });
1089 template <
typename... Names>
1094 template <
typename... Args>
1102 template <
typename... Names>
1104 StringRef name, Names... names) {
1107 setLegalityCallback(dialectNames, callback);
1109 template <
typename... Args>
1112 Args::getDialectNamespace()...);
1119 setLegalityCallback(fn);
1124 template <
typename... Names>
1129 template <
typename... Args>
1171 struct LegalizationInfo {
1176 bool isRecursivelyLegal =
false;
1183 std::optional<LegalizationInfo> getOpInfo(OperationName op)
const;
1187 llvm::MapVector<OperationName, LegalizationInfo> legalOperations;
1191 DenseMap<OperationName, DynamicLegalityCallbackFn> opRecursiveLegalityFns;
1195 llvm::StringMap<LegalizationAction> legalDialects;
1198 llvm::StringMap<DynamicLegalityCallbackFn> dialectLegalityFns;
1207 #if MLIR_ENABLE_PDL_IN_PATTERNMATCH
1243 class PDLConversionConfig final {
Attributes are known-constant values of operations.
This class represents an argument of a Block.
Block represents an ordered list of Operations.
OpListType::iterator iterator
This class implements a pattern rewriter for use with ConversionPatterns.
void replaceOp(Operation *op, ValueRange newValues) override
Replace the given operation with the new values.
LogicalResult getRemappedValues(ValueRange keys, SmallVectorImpl< Value > &results)
Return the converted values that replace 'keys' with types defined by the type converter of the curre...
FailureOr< Block * > convertRegionTypes(Region *region, const TypeConverter &converter, TypeConverter::SignatureConversion *entryConversion=nullptr)
Apply a signature conversion to each block in the given region.
void inlineBlockBefore(Block *source, Block *dest, Block::iterator before, ValueRange argValues=std::nullopt) override
PatternRewriter hook for inlining the ops of a block into another block.
void replaceOpWithMultiple(Operation *op, SmallVector< SmallVector< Value >> &&newValues)
Replace the given operation with the new value ranges.
Block * applySignatureConversion(Block *block, TypeConverter::SignatureConversion &conversion, const TypeConverter *converter=nullptr)
Apply a signature conversion to given block.
void replaceOpWithMultiple(Operation *op, ArrayRef< RangeT > newValues)
void startOpModification(Operation *op) override
PatternRewriter hook for updating the given operation in-place.
void eraseOp(Operation *op) override
PatternRewriter hook for erasing a dead operation.
void replaceOpWithMultiple(Operation *op, RangeT &&newValues)
detail::ConversionPatternRewriterImpl & getImpl()
Return a reference to the internal implementation.
void eraseBlock(Block *block) override
PatternRewriter hook for erase all operations in a block.
void cancelOpModification(Operation *op) override
PatternRewriter hook for updating the given operation in-place.
bool canRecoverFromRewriteFailure() const override
Indicate that the conversion rewriter can recover from rewrite failure.
Value getRemappedValue(Value key)
Return the converted value of 'key' with a type defined by the type converter of the currently execut...
void finalizeOpModification(Operation *op) override
PatternRewriter hook for updating the given operation in-place.
void replaceUsesOfBlockArgument(BlockArgument from, Value to)
Replace all the uses of the block argument from with value to.
~ConversionPatternRewriter() override
Base class for the conversion patterns.
SmallVector< Value > getOneToOneAdaptorOperands(ArrayRef< ValueRange > operands) const
Given an array of value ranges, which are the inputs to a 1:N adaptor, try to extract the single valu...
const TypeConverter * typeConverter
An optional type converter for use by this pattern.
ConversionPattern(const TypeConverter &typeConverter, Args &&...args)
Construct a conversion pattern with the given converter, and forward the remaining arguments to Rewri...
const TypeConverter * getTypeConverter() const
Return the type converter held by this pattern, or nullptr if the pattern does not require type conve...
std::enable_if_t< std::is_base_of< TypeConverter, ConverterTy >::value, const ConverterTy * > getTypeConverter() const
virtual LogicalResult matchAndRewrite(Operation *op, ArrayRef< Value > operands, ConversionPatternRewriter &rewriter) const
Hook for derived classes to implement combined matching and rewriting.
virtual LogicalResult matchAndRewrite(Operation *op, ArrayRef< ValueRange > operands, ConversionPatternRewriter &rewriter) const
Hook for derived classes to implement combined matching and rewriting.
This class describes a specific conversion target.
void setDialectAction(ArrayRef< StringRef > dialectNames, LegalizationAction action)
Register a legality action for the given dialects.
void setOpAction(LegalizationAction action)
void addLegalOp(OperationName op)
Register the given operations as legal.
void addDynamicallyLegalDialect(DynamicLegalityCallbackFn callback)
void setOpAction(OperationName op, LegalizationAction action)
Register a legality action for the given operation.
void addDynamicallyLegalDialect(const DynamicLegalityCallbackFn &callback, StringRef name, Names... names)
Register the operations of the given dialects as dynamically legal, i.e.
void addDynamicallyLegalOp(const DynamicLegalityCallbackFn &callback)
void addLegalDialect(StringRef name, Names... names)
Register the operations of the given dialects as legal.
std::optional< LegalOpDetails > isLegal(Operation *op) const
If the given operation instance is legal on this target, a structure containing legality information ...
std::enable_if_t<!std::is_invocable_v< Callable, Operation * > > markOpRecursivelyLegal(Callable &&callback)
void markUnknownOpDynamicallyLegal(const DynamicLegalityCallbackFn &fn)
Register unknown operations as dynamically legal.
std::optional< LegalizationAction > getOpAction(OperationName op) const
Get the legality action for the given operation.
void addDynamicallyLegalOp(OperationName op, const DynamicLegalityCallbackFn &callback)
Register the given operation as dynamically legal and set the dynamic legalization callback to the on...
void addIllegalDialect(StringRef name, Names... names)
Register the operations of the given dialects as illegal, i.e.
std::enable_if_t<!std::is_invocable_v< Callable, Operation * > > addDynamicallyLegalOp(Callable &&callback)
void addDynamicallyLegalOp(const DynamicLegalityCallbackFn &callback)
void markOpRecursivelyLegal(const DynamicLegalityCallbackFn &callback={})
void addIllegalOp(OperationName op)
Register the given operation as illegal, i.e.
LegalizationAction
This enumeration corresponds to the specific action to take when considering an operation legal for t...
@ Illegal
The target explicitly does not support this operation.
@ Dynamic
This operation has dynamic legalization constraints that must be checked by the target.
@ Legal
The target supports this operation.
ConversionTarget(MLIRContext &ctx)
void markOpRecursivelyLegal(OperationName name, const DynamicLegalityCallbackFn &callback)
Mark an operation, that must have either been set as Legal or DynamicallyLegal, as being recursively ...
void markOpRecursivelyLegal(const DynamicLegalityCallbackFn &callback={})
std::function< std::optional< bool >(Operation *)> DynamicLegalityCallbackFn
The signature of the callback used to determine if an operation is dynamically legal on the target.
bool isIllegal(Operation *op) const
Returns true is operation instance is illegal on this target.
virtual ~ConversionTarget()=default
This class contains all of the information necessary to report a diagnostic to the DiagnosticEngine.
This class represents a frozen set of patterns that can be processed by a pattern applicator.
This class defines the main interface for locations in MLIR and acts as a non-nullable wrapper around...
MLIRContext is the top-level object for a collection of MLIR operations.
This class helps build Operations.
void setListener(Listener *newListener)
Sets the listener of this builder to the one provided.
OpConversionPattern is a wrapper around ConversionPattern that allows for matching and rewriting agai...
LogicalResult matchAndRewrite(Operation *op, ArrayRef< ValueRange > operands, ConversionPatternRewriter &rewriter) const final
Hook for derived classes to implement combined matching and rewriting.
typename SourceOp::Adaptor OpAdaptor
virtual LogicalResult matchAndRewrite(SourceOp op, OneToNOpAdaptor adaptor, ConversionPatternRewriter &rewriter) const
OpConversionPattern(MLIRContext *context, PatternBenefit benefit=1)
typename SourceOp::template GenericAdaptor< ArrayRef< ValueRange > > OneToNOpAdaptor
OpConversionPattern(const TypeConverter &typeConverter, MLIRContext *context, PatternBenefit benefit=1)
virtual LogicalResult matchAndRewrite(SourceOp op, OpAdaptor adaptor, ConversionPatternRewriter &rewriter) const
Methods that operate on the SourceOp type.
LogicalResult matchAndRewrite(Operation *op, ArrayRef< Value > operands, ConversionPatternRewriter &rewriter) const final
Wrappers around the ConversionPattern methods that pass the derived op type.
OpInterfaceConversionPattern is a wrapper around ConversionPattern that allows for matching and rewri...
LogicalResult matchAndRewrite(Operation *op, ArrayRef< ValueRange > operands, ConversionPatternRewriter &rewriter) const final
Hook for derived classes to implement combined matching and rewriting.
virtual LogicalResult matchAndRewrite(SourceOp op, ArrayRef< ValueRange > operands, ConversionPatternRewriter &rewriter) const
LogicalResult matchAndRewrite(Operation *op, ArrayRef< Value > operands, ConversionPatternRewriter &rewriter) const final
Wrappers around the ConversionPattern methods that pass the derived op type.
OpInterfaceConversionPattern(MLIRContext *context, PatternBenefit benefit=1)
OpInterfaceConversionPattern(const TypeConverter &typeConverter, MLIRContext *context, PatternBenefit benefit=1)
virtual LogicalResult matchAndRewrite(SourceOp op, ArrayRef< Value > operands, ConversionPatternRewriter &rewriter) const
Methods that operate on the SourceOp type.
OpTraitConversionPattern is a wrapper around ConversionPattern that allows for matching and rewriting...
OpTraitConversionPattern(const TypeConverter &typeConverter, MLIRContext *context, PatternBenefit benefit=1)
OpTraitConversionPattern(MLIRContext *context, PatternBenefit benefit=1)
Operation is the basic unit of execution within MLIR.
A PDL configuration that is used to supported dialect conversion functionality.
void notifyRewriteEnd(PatternRewriter &rewriter) final
void notifyRewriteBegin(PatternRewriter &rewriter) final
Hooks that are invoked at the beginning and end of a rewrite of a matched pattern.
const TypeConverter * getTypeConverter() const
Return the type converter used by this configuration, which may be nullptr if no type conversions are...
PDLConversionConfig(const TypeConverter *converter)
~PDLConversionConfig() final=default
This class represents the benefit of a pattern match in a unitless scheme that ranges from 0 (very li...
A special type of RewriterBase that coordinates the application of a rewrite pattern on the current I...
This class contains all of the data related to a pattern, but does not contain any methods or logic f...
This class contains a list of basic blocks and a link to the parent operation it is attached to.
RewritePattern is the common base class for all DAG to DAG replacements.
virtual void inlineBlockBefore(Block *source, Block *dest, Block::iterator before, ValueRange argValues=std::nullopt)
Inline the operations of block 'source' into block 'dest' before the given position.
The general result of a type attribute conversion callback, allowing for early termination.
Attribute getResult() const
constexpr AttributeConversionResult()
static AttributeConversionResult abort()
static AttributeConversionResult na()
AttributeConversionResult(Attribute attr)
static AttributeConversionResult result(Attribute attr)
This class provides all of the information necessary to convert a type signature.
void addInputs(unsigned origInputNo, ArrayRef< Type > types)
Remap an input of the original signature with a new set of types.
std::optional< InputMapping > getInputMapping(unsigned input) const
Get the input mapping for the given argument.
ArrayRef< Type > getConvertedTypes() const
Return the argument types for the new signature.
void remapInput(unsigned origInputNo, ArrayRef< Value > replacements)
Remap an input of the original signature to replacements values.
SignatureConversion(unsigned numOrigInputs)
std::optional< Attribute > convertTypeAttribute(Type type, Attribute attr) const
Convert an attribute present attr from within the type type using the registered conversion functions...
Value materializeSourceConversion(OpBuilder &builder, Location loc, Type resultType, ValueRange inputs) const
void addConversion(FnT &&callback)
Register a conversion function.
bool isLegal(Type type) const
Return true if the given type is legal for this type converter, i.e.
void addArgumentMaterialization(FnT &&callback)
All of the following materializations require function objects that are convertible to the following ...
LogicalResult convertSignatureArgs(TypeRange types, SignatureConversion &result, unsigned origInputOffset=0) const
std::enable_if_t<!std::is_convertible< RangeT, Type >::value &&!std::is_convertible< RangeT, Operation * >::value, bool > isLegal(RangeT &&range) const
Return true if all of the given types are legal for this type converter.
TargetType convertType(Type t) const
Attempts a 1-1 type conversion, expecting the result type to be TargetType.
LogicalResult convertSignatureArg(unsigned inputNo, Type type, SignatureConversion &result) const
This method allows for converting a specific argument of a signature.
TypeConverter(const TypeConverter &other)
TypeConverter & operator=(const TypeConverter &other)
Value materializeArgumentConversion(OpBuilder &builder, Location loc, Type resultType, ValueRange inputs) const
Materialize a conversion from a set of types into one result type by generating a cast sequence of so...
LogicalResult convertType(Type t, SmallVectorImpl< Type > &results) const
Convert the given type.
std::optional< SignatureConversion > convertBlockSignature(Block *block) const
This function converts the type signature of the given block, by invoking 'convertSignatureArg' for e...
void addSourceMaterialization(FnT &&callback)
This method registers a materialization that will be called when converting a replacement value back ...
virtual ~TypeConverter()=default
void addTypeAttributeConversion(FnT &&callback)
Register a conversion function for attributes within types.
void addTargetMaterialization(FnT &&callback)
This method registers a materialization that will be called when converting a value to a target type ...
LogicalResult convertTypes(TypeRange types, SmallVectorImpl< Type > &results) const
Convert the given set of types, filling 'results' as necessary.
bool isSignatureLegal(FunctionType ty) const
Return true if the inputs and outputs of the given function type are legal.
Value materializeTargetConversion(OpBuilder &builder, Location loc, Type resultType, ValueRange inputs, Type originalType={}) const
This class provides an efficient unique identifier for a specific C++ type.
This class provides an abstraction over the various different ranges of value types.
Instances of the Type class are uniqued, have an immutable identifier and an optional mutable compone...
This class provides an abstraction over the different types of ranges over Values.
This class represents an instance of an SSA value in the MLIR system, representing a computable value...
Helper class that derives from a ConversionRewritePattern class and provides separate match and rewri...
Helper class that derives from a RewritePattern class and provides separate match and rewrite entry p...
@ Type
An inlay hint that for a type annotation.
Include the generated interface declarations.
void populateFunctionOpInterfaceTypeConversionPattern(StringRef functionLikeOpName, RewritePatternSet &patterns, const TypeConverter &converter)
Add a pattern to the given pattern list to convert the signature of a FunctionOpInterface op with the...
void populateAnyFunctionOpInterfaceTypeConversionPattern(RewritePatternSet &patterns, const TypeConverter &converter)
const FrozenRewritePatternSet GreedyRewriteConfig config
LogicalResult applyFullConversion(ArrayRef< Operation * > ops, const ConversionTarget &target, const FrozenRewritePatternSet &patterns, ConversionConfig config=ConversionConfig())
Apply a complete conversion on the given operations, and all nested operations.
FailureOr< Operation * > convertOpResultTypes(Operation *op, ValueRange operands, const TypeConverter &converter, ConversionPatternRewriter &rewriter)
Generic utility to convert op result types according to type converter without knowing exact op type.
const FrozenRewritePatternSet & patterns
LogicalResult applyAnalysisConversion(ArrayRef< Operation * > ops, ConversionTarget &target, const FrozenRewritePatternSet &patterns, ConversionConfig config=ConversionConfig())
Apply an analysis conversion on the given operations, and all nested operations.
void reconcileUnrealizedCasts(ArrayRef< UnrealizedConversionCastOp > castOps, SmallVectorImpl< UnrealizedConversionCastOp > *remainingCastOps=nullptr)
Try to reconcile all given UnrealizedConversionCastOps and store the left-over ops in remainingCastOp...
auto get(MLIRContext *context, Ts &&...params)
Helper method that injects context only if needed, this helps unify some of the attribute constructio...
void registerConversionPDLFunctions(RewritePatternSet &patterns)
Register the dialect conversion PDL functions with the given pattern set.
LogicalResult applyPartialConversion(ArrayRef< Operation * > ops, const ConversionTarget &target, const FrozenRewritePatternSet &patterns, ConversionConfig config=ConversionConfig())
Below we define several entry points for operation conversion.
Dialect conversion configuration.
RewriterBase::Listener * listener
An optional listener that is notified about all IR modifications in case dialect conversion succeeds.
function_ref< void(Diagnostic &)> notifyCallback
An optional callback used to notify about match failure diagnostics during the conversion.
DenseSet< Operation * > * legalizableOps
Analysis conversion only.
DenseSet< Operation * > * unlegalizedOps
Partial conversion only.
bool buildMaterializations
If set to "true", the dialect conversion attempts to build source/target materializations through the...
A structure containing additional information describing a specific legal operation instance.
bool isRecursivelyLegal
A flag that indicates if this operation is 'recursively' legal.
This class acts as a special tag that makes the desire to match any operation that implements a given...
This class acts as a special tag that makes the desire to match any operation that implements a given...