This is the interface that must be implemented by the dialects of operations to be inlined. More...
#include "mlir/Transforms/InliningUtils.h"
Inheritance diagram for mlir::DialectInlinerInterface:
Public Member Functions | |
| DialectInlinerInterface (Dialect *dialect) | |
| virtual bool | isLegalToInline (Operation *call, Operation *callable, bool wouldBeCloned) const |
Returns true if the given operation 'callable', that implements the 'CallableOpInterface', can be inlined into the position given call operation 'call', that is registered to the current dialect and implements the CallOpInterface. More... | |
| virtual bool | isLegalToInline (Region *dest, Region *src, bool wouldBeCloned, IRMapping &valueMapping) const |
| Returns true if the given region 'src' can be inlined into the region 'dest' that is attached to an operation registered to the current dialect. More... | |
| virtual bool | isLegalToInline (Operation *op, Region *dest, bool wouldBeCloned, IRMapping &valueMapping) const |
| Returns true if the given operation 'op', that is registered to this dialect, can be inlined into the given region, false otherwise. More... | |
| virtual bool | shouldAnalyzeRecursively (Operation *op) const |
| This hook is invoked on an operation that contains regions. More... | |
| virtual void | handleTerminator (Operation *op, Block *newDest) const |
| Handle the given inlined terminator by replacing it with a new operation as necessary. More... | |
| virtual void | handleTerminator (Operation *op, ValueRange valuesToReplace) const |
| Handle the given inlined terminator by replacing it with a new operation as necessary. More... | |
| virtual Operation * | materializeCallConversion (OpBuilder &builder, Value input, Type resultType, Location conversionLoc) const |
| Attempt to materialize a conversion for a type mismatch between a call from this dialect, and a callable region. More... | |
| virtual Value | handleArgument (OpBuilder &builder, Operation *call, Operation *callable, Value argument, DictionaryAttr argumentAttrs) const |
| Hook to transform the call arguments before using them to replace the callee arguments. More... | |
| virtual Value | handleResult (OpBuilder &builder, Operation *call, Operation *callable, Value result, DictionaryAttr resultAttrs) const |
| Hook to transform the callee results before using them to replace the call results. More... | |
| virtual void | processInlinedCallBlocks (Operation *call, iterator_range< Region::iterator > inlinedBlocks) const |
| Process a set of blocks that have been inlined for a call. More... | |
Additional Inherited Members | |
| Public Types inherited from mlir::detail::DialectInterfaceBase< ConcreteType, BaseT > | |
| using | Base = DialectInterfaceBase< ConcreteType, BaseT > |
| Static Public Member Functions inherited from mlir::detail::DialectInterfaceBase< ConcreteType, BaseT > | |
| static TypeID | getInterfaceID () |
| Get a unique id for the derived interface type. More... | |
| Protected Member Functions inherited from mlir::detail::DialectInterfaceBase< ConcreteType, BaseT > | |
| DialectInterfaceBase (Dialect *dialect) | |
Detailed Description
This is the interface that must be implemented by the dialects of operations to be inlined.
This interface should only handle the operations of the given dialect.
Definition at line 43 of file InliningUtils.h.
Constructor & Destructor Documentation
◆ DialectInlinerInterface()
|
inline |
Definition at line 46 of file InliningUtils.h.
Member Function Documentation
◆ handleArgument()
|
inlinevirtual |
Hook to transform the call arguments before using them to replace the callee arguments.
Returns a value of the same type or the argument itself if nothing changed. The argumentAttrs dictionary is non-null even if no attribute is present. The hook is called after converting the callsite argument types using the materializeCallConversion callback, and right before inlining the callee region. Any operations created using the provided builder are inserted right before the inlined callee region. An example use case is the insertion of copies for by value arguments.
Definition at line 154 of file InliningUtils.h.
◆ handleResult()
|
inlinevirtual |
Hook to transform the callee results before using them to replace the call results.
Returns a value of the same type or the result itself if nothing changed. The resultAttrs dictionary is non-null even if no attribute is present. The hook is called right before handling terminators, and obtains the callee result before converting its type using the materializeCallConversion callback. Any operations created using the provided builder are inserted right after the inlined callee region. An example use case is the insertion of copies for by value results. NOTE: This hook is invoked after inlining the callable region.
Definition at line 169 of file InliningUtils.h.
◆ handleTerminator() [1/2]
|
inlinevirtual |
Handle the given inlined terminator by replacing it with a new operation as necessary.
This overload is called when the inlined region has more than one block. The 'newDest' block represents the new final branching destination of blocks within this region, i.e. operations that release control to the parent operation will likely now branch to this block. Its block arguments correspond to any values that need to be replaced by terminators within the inlined region.
Definition at line 106 of file InliningUtils.h.
◆ handleTerminator() [2/2]
|
inlinevirtual |
Handle the given inlined terminator by replacing it with a new operation as necessary.
This overload is called when the inlined region only contains one block. 'valuesToReplace' contains the previously returned values of the call site before inlining. These values must be replaced by this callback if they had any users (for example for traditional function calls, these are directly replaced with the operands of the return operation). The given 'op' will be removed by the caller, after this function has been called.
Definition at line 119 of file InliningUtils.h.
◆ isLegalToInline() [1/3]
|
inlinevirtual |
Returns true if the given operation 'callable', that implements the 'CallableOpInterface', can be inlined into the position given call operation 'call', that is registered to the current dialect and implements the CallOpInterface.
'wouldBeCloned' is set to true if the region of the given 'callable' is set to be cloned during the inlining process, or false if the region is set to be moved in-place(i.e. no duplicates would be created).
Definition at line 59 of file InliningUtils.h.
◆ isLegalToInline() [2/3]
|
inlinevirtual |
Returns true if the given operation 'op', that is registered to this dialect, can be inlined into the given region, false otherwise.
'wouldBeCloned' is set to true if the given 'op' is set to be cloned during the inlining process, or false if the operation is set to be moved in-place(i.e. no duplicates would be created). 'valueMapping' contains any remapped values from within the 'src' region. This can be used to examine what values may potentially replace the operands to 'op'.
Definition at line 84 of file InliningUtils.h.
◆ isLegalToInline() [3/3]
|
inlinevirtual |
Returns true if the given region 'src' can be inlined into the region 'dest' that is attached to an operation registered to the current dialect.
'wouldBeCloned' is set to true if the given 'src' region is set to be cloned during the inlining process, or false if the region is set to be moved in-place(i.e. no duplicates would be created). 'valueMapping' contains any remapped values from within the 'src' region. This can be used to examine what values will replace entry arguments into the 'src' region for example.
Definition at line 72 of file InliningUtils.h.
◆ materializeCallConversion()
|
inlinevirtual |
Attempt to materialize a conversion for a type mismatch between a call from this dialect, and a callable region.
This method should generate an operation that takes 'input' as the only operand, and produces a single result of 'resultType'. If a conversion can not be generated, nullptr should be returned. For example, this hook may be invoked in the following scenarios: func @foo(i32) -> i32 { ... }
// Mismatched input operand ... = foo.call @foo(input : i16) -> i32
// Mismatched result type. ... = foo.call @foo(input : i32) -> i16
NOTE: This hook may be invoked before the 'isLegal' checks above.
Definition at line 140 of file InliningUtils.h.
Referenced by materializeConversion().
◆ processInlinedCallBlocks()
|
inlinevirtual |
Process a set of blocks that have been inlined for a call.
This callback is invoked before inlined terminator operations have been processed.
Definition at line 177 of file InliningUtils.h.
◆ shouldAnalyzeRecursively()
|
inlinevirtual |
This hook is invoked on an operation that contains regions.
It should return true if the analyzer should recurse within the regions of this operation when computing legality and cost, false otherwise. The default implementation returns true.
Definition at line 93 of file InliningUtils.h.
The documentation for this class was generated from the following file:
- include/mlir/Transforms/InliningUtils.h
