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) {}
80 return remappedInputs[input];
102 void remapInput(
unsigned origInputNo,
unsigned newInputNo,
103 unsigned newInputCount = 1);
132 llvm::PointerIntPair<Attribute, 2>
impl;
135 static constexpr
unsigned naTag = 0;
136 static constexpr
unsigned resultTag = 1;
137 static constexpr
unsigned abortTag = 2;
158 template <
typename FnT,
typename T =
typename llvm::function_traits<
159 std::decay_t<FnT>>::template arg_t<0>>
161 registerConversion(wrapCallback<T>(std::forward<FnT>(callback)));
182 template <
typename FnT,
typename T =
typename llvm::function_traits<
183 std::decay_t<FnT>>::template arg_t<1>>
185 argumentMaterializations.emplace_back(
186 wrapMaterialization<T>(std::forward<FnT>(callback)));
193 template <
typename FnT,
typename T =
typename llvm::function_traits<
194 std::decay_t<FnT>>::template arg_t<1>>
196 sourceMaterializations.emplace_back(
197 wrapMaterialization<T>(std::forward<FnT>(callback)));
213 template <
typename FnT,
typename T =
typename llvm::function_traits<
214 std::decay_t<FnT>>::template arg_t<1>>
216 targetMaterializations.emplace_back(
217 wrapTargetMaterialization<T>(std::forward<FnT>(callback)));
240 typename llvm::function_traits<std::decay_t<FnT>>::template arg_t<0>,
242 typename llvm::function_traits<std::decay_t<FnT>>::template arg_t<1>>
244 registerTypeAttributeConversion(
245 wrapTypeAttributeConversion<T, A>(std::forward<FnT>(callback)));
261 template <
typename TargetType>
263 return dyn_cast_or_null<TargetType>(
convertType(t));
277 template <
typename RangeT>
278 std::enable_if_t<!std::is_convertible<RangeT, Type>::value &&
279 !std::is_convertible<RangeT, Operation *>::value,
282 return llvm::all_of(range, [
this](
Type type) {
return isLegal(type); });
298 SignatureConversion &result)
const;
300 SignatureConversion &result,
301 unsigned origInputOffset = 0)
const;
318 Type originalType = {})
const;
325 Attribute attr)
const;
331 using ConversionCallbackFn = std::function<std::optional<LogicalResult>(
332 Type, SmallVectorImpl<Type> &)>;
338 using MaterializationCallbackFn = std::function<std::optional<Value>(
339 OpBuilder &, Type, ValueRange, Location)>;
344 using TargetMaterializationCallbackFn = std::function<std::optional<Value>(
345 OpBuilder &, Type, ValueRange, Location, Type)>;
348 using TypeAttributeConversionCallbackFn =
349 std::function<AttributeConversionResult(Type, Attribute)>;
354 template <
typename T,
typename FnT>
355 std::enable_if_t<std::is_invocable_v<FnT, T>, ConversionCallbackFn>
356 wrapCallback(FnT &&callback)
const {
357 return wrapCallback<T>([callback = std::forward<FnT>(callback)](
358 T type, SmallVectorImpl<Type> &results) {
359 if (std::optional<Type> resultOpt = callback(type)) {
360 bool wasSuccess =
static_cast<bool>(*resultOpt);
362 results.push_back(*resultOpt);
363 return std::optional<LogicalResult>(success(wasSuccess));
365 return std::optional<LogicalResult>();
370 template <
typename T,
typename FnT>
371 std::enable_if_t<std::is_invocable_v<FnT, T, SmallVectorImpl<Type> &>,
372 ConversionCallbackFn>
373 wrapCallback(FnT &&callback)
const {
374 return [callback = std::forward<FnT>(callback)](
376 SmallVectorImpl<Type> &results) -> std::optional<LogicalResult> {
377 T derivedType = dyn_cast<T>(type);
380 return callback(derivedType, results);
385 void registerConversion(ConversionCallbackFn callback) {
386 conversions.emplace_back(std::move(callback));
387 cachedDirectConversions.clear();
388 cachedMultiConversions.clear();
395 template <
typename T,
typename FnT>
396 MaterializationCallbackFn wrapMaterialization(FnT &&callback)
const {
397 return [callback = std::forward<FnT>(callback)](
398 OpBuilder &builder,
Type resultType, ValueRange inputs,
399 Location loc) -> std::optional<Value> {
400 if (T derivedType = dyn_cast<T>(resultType))
401 return callback(builder, derivedType, inputs, loc);
413 template <
typename T,
typename FnT>
415 std::is_invocable_v<FnT, OpBuilder &, T, ValueRange, Location, Type>,
416 TargetMaterializationCallbackFn>
417 wrapTargetMaterialization(FnT &&callback)
const {
418 return [callback = std::forward<FnT>(callback)](
419 OpBuilder &builder,
Type resultType, ValueRange inputs,
420 Location loc,
Type originalType) -> std::optional<Value> {
421 if (T derivedType = dyn_cast<T>(resultType))
422 return callback(builder, derivedType, inputs, loc, originalType);
428 template <
typename T,
typename FnT>
430 std::is_invocable_v<FnT, OpBuilder &, T, ValueRange, Location>,
431 TargetMaterializationCallbackFn>
432 wrapTargetMaterialization(FnT &&callback)
const {
433 return wrapTargetMaterialization<T>(
434 [callback = std::forward<FnT>(callback)](
435 OpBuilder &builder, T resultType, ValueRange inputs, Location loc,
436 Type originalType) -> std::optional<Value> {
437 return callback(builder, resultType, inputs, loc);
445 template <
typename T,
typename A,
typename FnT>
446 TypeAttributeConversionCallbackFn
447 wrapTypeAttributeConversion(FnT &&callback)
const {
448 return [callback = std::forward<FnT>(callback)](
449 Type type, Attribute attr) -> AttributeConversionResult {
450 if (T derivedType = dyn_cast<T>(type)) {
451 if (A derivedAttr = dyn_cast_or_null<A>(attr))
452 return callback(derivedType, derivedAttr);
460 registerTypeAttributeConversion(TypeAttributeConversionCallbackFn callback) {
461 typeAttributeConversions.emplace_back(std::move(callback));
463 cachedDirectConversions.clear();
464 cachedMultiConversions.clear();
468 SmallVector<ConversionCallbackFn, 4> conversions;
471 SmallVector<MaterializationCallbackFn, 2> argumentMaterializations;
472 SmallVector<MaterializationCallbackFn, 2> sourceMaterializations;
473 SmallVector<TargetMaterializationCallbackFn, 2> targetMaterializations;
476 SmallVector<TypeAttributeConversionCallbackFn, 2> typeAttributeConversions;
481 mutable DenseMap<Type, Type> cachedDirectConversions;
483 mutable DenseMap<Type, SmallVector<Type, 2>> cachedMultiConversions;
485 mutable llvm::sys::SmartRWMutex<true> cacheMutex;
504 llvm_unreachable(
"unimplemented rewrite");
508 virtual LogicalResult
511 if (failed(
match(op)))
513 rewrite(op, operands, rewriter);
525 template <
typename ConverterTy>
526 std::enable_if_t<std::is_base_of<TypeConverter, ConverterTy>::value,
535 using RewritePattern::RewritePattern;
538 template <
typename... Args>
554 template <
typename SourceOp>
569 return match(cast<SourceOp>(op));
573 auto sourceOp = cast<SourceOp>(op);
579 auto sourceOp = cast<SourceOp>(op);
585 virtual LogicalResult
match(SourceOp op)
const {
586 llvm_unreachable(
"must override match or matchAndRewrite");
590 llvm_unreachable(
"must override matchAndRewrite or a rewrite method");
592 virtual LogicalResult
595 if (failed(
match(op)))
597 rewrite(op, adaptor, rewriter);
608 template <
typename SourceOp>
613 SourceOp::getInterfaceID(), benefit, context) {}
617 SourceOp::getInterfaceID(), benefit, context) {}
623 rewrite(cast<SourceOp>(op), operands, rewriter);
635 llvm_unreachable(
"must override matchAndRewrite or a rewrite method");
637 virtual LogicalResult
640 if (failed(
match(op)))
642 rewrite(op, operands, rewriter);
653 template <
template <
typename>
class TraitType>
658 TypeID::
get<TraitType>(), benefit, context) {}
662 TypeID::
get<TraitType>(), benefit, context) {}
668 FailureOr<Operation *>
670 const TypeConverter &converter,
671 ConversionPatternRewriter &rewriter);
677 StringRef functionLikeOpName, RewritePatternSet &patterns,
678 const TypeConverter &converter);
680 template <
typename FuncOpT>
684 patterns, converter);
688 RewritePatternSet &patterns,
const TypeConverter &converter);
695 struct ConversionPatternRewriterImpl;
781 ValueRange argValues = std::nullopt)
override;
812 std::unique_ptr<detail::ConversionPatternRewriterImpl>
impl;
848 std::function<std::optional<bool>(
Operation *)>;
859 template <
typename OpT>
868 template <
typename OpT>
872 template <
typename OpT,
typename OpT2,
typename... OpTs>
883 setLegalityCallback(op, callback);
885 template <
typename OpT>
890 template <
typename OpT,
typename OpT2,
typename... OpTs>
892 addDynamicallyLegalOp<OpT>(callback);
895 template <
typename OpT,
class Callable>
896 std::enable_if_t<!std::is_invocable_v<Callable, Operation *>>
898 addDynamicallyLegalOp<OpT>(
899 [=](
Operation *op) {
return callback(cast<OpT>(op)); });
907 template <
typename OpT>
911 template <
typename OpT,
typename OpT2,
typename... OpTs>
924 template <
typename OpT>
929 template <
typename OpT,
typename OpT2,
typename... OpTs>
931 markOpRecursivelyLegal<OpT>(callback);
934 template <
typename OpT,
class Callable>
935 std::enable_if_t<!std::is_invocable_v<Callable, Operation *>>
937 markOpRecursivelyLegal<OpT>(
938 [=](
Operation *op) {
return callback(cast<OpT>(op)); });
946 template <
typename... Names>
951 template <
typename... Args>
959 template <
typename... Names>
961 StringRef name, Names... names) {
964 setLegalityCallback(dialectNames, callback);
966 template <
typename... Args>
969 Args::getDialectNamespace()...);
976 setLegalityCallback(fn);
981 template <
typename... Names>
986 template <
typename... Args>
1028 struct LegalizationInfo {
1033 bool isRecursivelyLegal =
false;
1040 std::optional<LegalizationInfo> getOpInfo(OperationName op)
const;
1044 llvm::MapVector<OperationName, LegalizationInfo> legalOperations;
1048 DenseMap<OperationName, DynamicLegalityCallbackFn> opRecursiveLegalityFns;
1052 llvm::StringMap<LegalizationAction> legalDialects;
1055 llvm::StringMap<DynamicLegalityCallbackFn> dialectLegalityFns;
1064 #if MLIR_ENABLE_PDL_IN_PATTERNMATCH
1100 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
PatternRewriter hook for replacing an operation.
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.
Block * applySignatureConversion(Block *block, TypeConverter::SignatureConversion &conversion, const TypeConverter *converter=nullptr)
Apply a signature conversion to given block.
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.
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.
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...
virtual void rewrite(Operation *op, ArrayRef< Value > operands, ConversionPatternRewriter &rewriter) const
Hook for derived classes to implement rewriting.
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.
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...
void rewrite(Operation *op, ArrayRef< Value > operands, ConversionPatternRewriter &rewriter) const final
Hook for derived classes to implement rewriting.
LogicalResult match(Operation *op) const final
Wrappers around the ConversionPattern methods that pass the derived op type.
typename SourceOp::Adaptor OpAdaptor
OpConversionPattern(MLIRContext *context, PatternBenefit benefit=1)
virtual LogicalResult match(SourceOp op) const
Rewrite and Match methods that operate on the SourceOp type.
OpConversionPattern(const TypeConverter &typeConverter, MLIRContext *context, PatternBenefit benefit=1)
virtual LogicalResult matchAndRewrite(SourceOp op, OpAdaptor adaptor, ConversionPatternRewriter &rewriter) const
virtual void rewrite(SourceOp op, OpAdaptor adaptor, ConversionPatternRewriter &rewriter) const
LogicalResult matchAndRewrite(Operation *op, ArrayRef< Value > operands, ConversionPatternRewriter &rewriter) const final
Hook for derived classes to implement combined matching and rewriting.
OpInterfaceConversionPattern is a wrapper around ConversionPattern that allows for matching and rewri...
void rewrite(Operation *op, ArrayRef< Value > operands, ConversionPatternRewriter &rewriter) const final
Wrappers around the ConversionPattern methods that pass the derived op type.
LogicalResult matchAndRewrite(Operation *op, ArrayRef< Value > operands, ConversionPatternRewriter &rewriter) const final
Hook for derived classes to implement combined matching and rewriting.
OpInterfaceConversionPattern(MLIRContext *context, PatternBenefit benefit=1)
OpInterfaceConversionPattern(const TypeConverter &typeConverter, MLIRContext *context, PatternBenefit benefit=1)
virtual void rewrite(SourceOp op, ArrayRef< Value > operands, ConversionPatternRewriter &rewriter) const
Rewrite and Match methods that operate on the SourceOp type.
virtual LogicalResult matchAndRewrite(SourceOp op, ArrayRef< Value > operands, ConversionPatternRewriter &rewriter) const
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 LogicalResult match(Operation *op) const
Attempt to match against code rooted at the specified operation, which is the same operation code as ...
virtual void rewrite(Operation *op, PatternRewriter &rewriter) const
Rewrite the IR rooted at the specified operation with the result of this pattern, generating any new ...
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, Value replacement)
Remap an input of the original signature to another replacement value.
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 legal replacement value...
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 an illegal (source) value...
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...
@ 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)
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.
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/ argument materializations t...
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...