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;
165 template <
typename FnT,
typename T =
typename llvm::function_traits<
166 std::decay_t<FnT>>::template arg_t<0>>
168 registerConversion(wrapCallback<T>(std::forward<FnT>(callback)));
185 template <
typename FnT,
typename T =
typename llvm::function_traits<
186 std::decay_t<FnT>>::template arg_t<1>>
188 argumentMaterializations.emplace_back(
189 wrapMaterialization<T>(std::forward<FnT>(callback)));
194 template <
typename FnT,
typename T =
typename llvm::function_traits<
195 std::decay_t<FnT>>::template arg_t<1>>
197 sourceMaterializations.emplace_back(
198 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 targetMaterializations.emplace_back(
206 wrapMaterialization<T>(std::forward<FnT>(callback)));
229 typename llvm::function_traits<std::decay_t<FnT>>::template arg_t<0>,
231 typename llvm::function_traits<std::decay_t<FnT>>::template arg_t<1>>
233 registerTypeAttributeConversion(
234 wrapTypeAttributeConversion<T, A>(std::forward<FnT>(callback)));
251 return dyn_cast_or_null<TargetType>(
convertType(t));
265 template <
typename RangeT>
266 std::enable_if_t<!std::is_convertible<RangeT, Type>::value &&
267 !std::is_convertible<RangeT, Operation *>::value,
270 return llvm::all_of(range, [
this](
Type type) {
return isLegal(type); });
286 SignatureConversion &result)
const;
288 SignatureConversion &result,
289 unsigned origInputOffset = 0)
const;
303 return materializeConversion(argumentMaterializations, builder, loc,
308 return materializeConversion(sourceMaterializations, builder, loc,
313 return materializeConversion(targetMaterializations, builder, loc,
328 using ConversionCallbackFn = std::function<std::optional<LogicalResult>(
332 using MaterializationCallbackFn = std::function<std::optional<Value>(
336 using TypeAttributeConversionCallbackFn =
349 template <
typename T,
typename FnT>
350 std::enable_if_t<std::is_invocable_v<FnT, T>, ConversionCallbackFn>
351 wrapCallback(FnT &&callback)
const {
352 return wrapCallback<T>([callback = std::forward<FnT>(callback)](
354 if (std::optional<Type> resultOpt = callback(type)) {
355 bool wasSuccess =
static_cast<bool>(*resultOpt);
357 results.push_back(*resultOpt);
358 return std::optional<LogicalResult>(
success(wasSuccess));
360 return std::optional<LogicalResult>();
365 template <
typename T,
typename FnT>
366 std::enable_if_t<std::is_invocable_v<FnT, T, SmallVectorImpl<Type> &>,
367 ConversionCallbackFn>
368 wrapCallback(FnT &&callback)
const {
369 return [callback = std::forward<FnT>(callback)](
371 SmallVectorImpl<Type> &results) -> std::optional<LogicalResult> {
372 T derivedType = dyn_cast<T>(type);
375 return callback(derivedType, results);
380 void registerConversion(ConversionCallbackFn callback) {
381 conversions.emplace_back(std::move(callback));
382 cachedDirectConversions.clear();
383 cachedMultiConversions.clear();
389 template <
typename T,
typename FnT>
390 MaterializationCallbackFn wrapMaterialization(FnT &&callback)
const {
391 return [callback = std::forward<FnT>(callback)](
392 OpBuilder &builder,
Type resultType, ValueRange inputs,
393 Location loc) -> std::optional<Value> {
394 if (T derivedType = dyn_cast<T>(resultType))
395 return callback(builder, derivedType, inputs, loc);
404 template <
typename T,
typename A,
typename FnT>
405 TypeAttributeConversionCallbackFn
406 wrapTypeAttributeConversion(FnT &&callback)
const {
407 return [callback = std::forward<FnT>(callback)](
408 Type type, Attribute attr) -> AttributeConversionResult {
409 if (T derivedType = dyn_cast<T>(type)) {
410 if (A derivedAttr = dyn_cast_or_null<A>(attr))
411 return callback(derivedType, derivedAttr);
419 registerTypeAttributeConversion(TypeAttributeConversionCallbackFn callback) {
420 typeAttributeConversions.emplace_back(std::move(callback));
422 cachedDirectConversions.clear();
423 cachedMultiConversions.clear();
427 SmallVector<ConversionCallbackFn, 4> conversions;
430 SmallVector<MaterializationCallbackFn, 2> argumentMaterializations;
431 SmallVector<MaterializationCallbackFn, 2> sourceMaterializations;
432 SmallVector<MaterializationCallbackFn, 2> targetMaterializations;
435 SmallVector<TypeAttributeConversionCallbackFn, 2> typeAttributeConversions;
440 mutable DenseMap<Type, Type> cachedDirectConversions;
442 mutable DenseMap<Type, SmallVector<Type, 2>> cachedMultiConversions;
444 mutable llvm::sys::SmartRWMutex<true> cacheMutex;
463 llvm_unreachable(
"unimplemented rewrite");
472 rewrite(op, operands, rewriter);
484 template <
typename ConverterTy>
485 std::enable_if_t<std::is_base_of<TypeConverter, ConverterTy>::value,
494 using RewritePattern::RewritePattern;
497 template <
typename... Args>
513 template <
typename SourceOp>
528 return match(cast<SourceOp>(op));
532 auto sourceOp = cast<SourceOp>(op);
538 auto sourceOp = cast<SourceOp>(op);
545 llvm_unreachable(
"must override match or matchAndRewrite");
549 llvm_unreachable(
"must override matchAndRewrite or a rewrite method");
556 rewrite(op, adaptor, rewriter);
567 template <
typename SourceOp>
572 SourceOp::getInterfaceID(), benefit, context) {}
576 SourceOp::getInterfaceID(), benefit, context) {}
582 rewrite(cast<SourceOp>(op), operands, rewriter);
594 llvm_unreachable(
"must override matchAndRewrite or a rewrite method");
601 rewrite(op, operands, rewriter);
612 template <
template <
typename>
class TraitType>
617 TypeID::
get<TraitType>(), benefit, context) {}
621 TypeID::
get<TraitType>(), benefit, context) {}
627 FailureOr<Operation *>
629 const TypeConverter &converter,
630 ConversionPatternRewriter &rewriter);
636 StringRef functionLikeOpName, RewritePatternSet &patterns,
637 const TypeConverter &converter);
639 template <
typename FuncOpT>
643 patterns, converter);
647 RewritePatternSet &patterns,
const TypeConverter &converter);
654 struct ConversionPatternRewriterImpl;
740 ValueRange argValues = std::nullopt)
override;
771 std::unique_ptr<detail::ConversionPatternRewriterImpl>
impl;
807 std::function<std::optional<bool>(
Operation *)>;
818 template <
typename OpT>
827 template <
typename OpT>
831 template <
typename OpT,
typename OpT2,
typename... OpTs>
842 setLegalityCallback(op, callback);
844 template <
typename OpT>
849 template <
typename OpT,
typename OpT2,
typename... OpTs>
851 addDynamicallyLegalOp<OpT>(callback);
854 template <
typename OpT,
class Callable>
855 std::enable_if_t<!std::is_invocable_v<Callable, Operation *>>
857 addDynamicallyLegalOp<OpT>(
858 [=](
Operation *op) {
return callback(cast<OpT>(op)); });
866 template <
typename OpT>
870 template <
typename OpT,
typename OpT2,
typename... OpTs>
883 template <
typename OpT>
888 template <
typename OpT,
typename OpT2,
typename... OpTs>
890 markOpRecursivelyLegal<OpT>(callback);
893 template <
typename OpT,
class Callable>
894 std::enable_if_t<!std::is_invocable_v<Callable, Operation *>>
896 markOpRecursivelyLegal<OpT>(
897 [=](
Operation *op) {
return callback(cast<OpT>(op)); });
905 template <
typename... Names>
910 template <
typename... Args>
918 template <
typename... Names>
920 StringRef name, Names... names) {
923 setLegalityCallback(dialectNames, callback);
925 template <
typename... Args>
928 Args::getDialectNamespace()...);
935 setLegalityCallback(fn);
940 template <
typename... Names>
945 template <
typename... Args>
987 struct LegalizationInfo {
992 bool isRecursivelyLegal =
false;
999 std::optional<LegalizationInfo> getOpInfo(OperationName op)
const;
1003 llvm::MapVector<OperationName, LegalizationInfo> legalOperations;
1007 DenseMap<OperationName, DynamicLegalityCallbackFn> opRecursiveLegalityFns;
1011 llvm::StringMap<LegalizationAction> legalDialects;
1014 llvm::StringMap<DynamicLegalityCallbackFn> dialectLegalityFns;
1023 #if MLIR_ENABLE_PDL_IN_PATTERNMATCH
1059 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)
Convert the types of block arguments within 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 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...
Block * applySignatureConversion(Region *region, TypeConverter::SignatureConversion &conversion, const TypeConverter *converter=nullptr)
Apply a signature conversion to the entry block of the given region.
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.
LogicalResult convertNonEntryRegionTypes(Region *region, const TypeConverter &converter, ArrayRef< TypeConverter::SignatureConversion > blockConversions)
Convert the types of block arguments within the given region except for the entry region.
~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 provides support for representing a failure result, or a valid value of type T.
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...
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)
Register a materialization function, which must be convertible to the following form: std::optional<V...
Value materializeSourceConversion(OpBuilder &builder, Location loc, Type resultType, ValueRange inputs) const
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 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)
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 type to an illega...
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 type from an illegal,...
LogicalResult convertTypes(TypeRange types, SmallVectorImpl< Type > &results) const
Convert the given set of types, filling 'results' as necessary.
Value materializeTargetConversion(OpBuilder &builder, Location loc, Type resultType, ValueRange inputs) const
bool isSignatureLegal(FunctionType ty) const
Return true if the inputs and outputs of the given function type are legal.
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.
LogicalResult failure(bool isFailure=true)
Utility function to generate a LogicalResult.
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.
LogicalResult success(bool isSuccess=true)
Utility function to generate a LogicalResult.
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.
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.
bool failed(LogicalResult result)
Utility function that returns true if the provided LogicalResult corresponds to a failure value.
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.
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 represents an efficient way to signal success or failure.
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...