[MLIR] feat(mlir-tblgen): Add support for dialect interfaces #170046
+520
−156
There are no files selected for viewing
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,217 @@ | ||
| #ifndef DIALECTINLINERINTERFACE | ||
| #define DIALECTINLINERINTERFACE | ||
|
|
||
| include "mlir/IR/Interfaces.td" | ||
|
|
||
| def DialectInlinerInterface : DialectInterface<"DialectInlinerInterface"> { | ||
| let 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. | ||
| }]; | ||
|
|
||
|
||
|
|
||
| let cppNamespace = "::mlir"; | ||
|
|
||
| let methods = [ | ||
| InterfaceMethod< | ||
| /*desc=*/ [{ | ||
| 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). | ||
| }], | ||
| /*returnType=*/ "bool", | ||
| /*methodName=*/ "isLegalToInline", | ||
| /*args=*/ (ins "::mlir::Operation *":$call, "::mlir::Operation *":$callable, "bool":$wouldBeCloned), | ||
| /*methodBody=*/ [{ | ||
| return false; | ||
| }] | ||
| >, | ||
| InterfaceMethod< | ||
| /*desc=*/ [{ | ||
| 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. | ||
| }], | ||
| /*returnType=*/ "bool", | ||
| /*methodName=*/ "isLegalToInline", | ||
| /*args=*/ (ins "::mlir::Region *":$dest, "::mlir::Region *":$src, "bool":$wouldBeCloned, | ||
| "::mlir::IRMapping &":$valueMapping), | ||
| /*methodBody=*/ [{ | ||
| return false; | ||
| }] | ||
| >, | ||
| InterfaceMethod< | ||
| /*desc=*/ [{ | ||
| 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. | ||
| }], | ||
| /*returnType=*/ "bool", | ||
| /*methodName=*/ "isLegalToInline", | ||
| /*args=*/ (ins "::mlir::Operation *":$op, "::mlir::Region *":$dest, "bool":$wouldBeCloned, | ||
| "::mlir::IRMapping &":$valueMapping), | ||
| /*methodBody=*/ [{ | ||
| return false; | ||
| }] | ||
| >, | ||
| InterfaceMethod< | ||
| /*desc=*/ [{ | ||
| 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. | ||
| }], | ||
| /*returnType=*/ "bool", | ||
| /*methodName=*/ "shouldAnalyzeRecursively", | ||
| /*args=*/ (ins "::mlir::Operation *":$op), | ||
| /*methodBody=*/ [{ | ||
| return true; | ||
| }] | ||
| >, | ||
| InterfaceMethod< | ||
| /*desc=*/ [{ | ||
| 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. | ||
| }], | ||
| /*returnType=*/ "void", | ||
| /*methodName=*/ "handleTerminator", | ||
| /*args=*/ (ins "::mlir::Operation *":$op, "::mlir::Block *":$newDest), | ||
| /*methodBody=*/ [{ | ||
| llvm_unreachable("must implement handleTerminator in the case of multiple " | ||
| "inlined blocks"); | ||
| }] | ||
| >, | ||
| InterfaceMethod< | ||
| /*desc=*/ [{ | ||
| 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. | ||
| }], | ||
| /*returnType=*/ "void", | ||
| /*methodName=*/ "handleTerminator", | ||
| /*args=*/ (ins "::mlir::Operation *":$op, "::mlir::ValueRange":$valuesToReplace), | ||
| /*methodBody=*/ [{ | ||
| llvm_unreachable( | ||
| "must implement handleTerminator in the case of one inlined block"); | ||
| }] | ||
| >, | ||
| InterfaceMethod< | ||
| /*desc=*/ [{ | ||
| 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. | ||
| }], | ||
| /*returnType=*/ "::mlir::Operation *", | ||
| /*methodName=*/ "materializeCallConversion", | ||
| /*args=*/ (ins "::mlir::OpBuilder &":$builder, "::mlir::Value":$input, | ||
| "::mlir::Type":$resultType, "::mlir::Location":$conversionLoc), | ||
| /*methodBody=*/ [{ | ||
| return nullptr; | ||
| }] | ||
| >, | ||
| InterfaceMethod< | ||
| /*desc=*/ [{ | ||
| 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. | ||
| }], | ||
| /*returnType=*/ "::mlir::Value", | ||
| /*methodName=*/ "handleArgument", | ||
| /*args=*/ (ins "::mlir::OpBuilder &":$builder, "::mlir::Operation *":$call, | ||
| "::mlir::Operation *":$callable, "::mlir::Value":$argument, | ||
| "::mlir::DictionaryAttr":$argumentAttrs), | ||
| /*methodBody=*/ [{ | ||
| return argument; | ||
| }] | ||
| >, | ||
| InterfaceMethod< | ||
| /*desc=*/ [{ | ||
| 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. | ||
| }], | ||
| /*returnType=*/ "::mlir::Value", | ||
| /*methodName=*/ "handleResult", | ||
| /*args=*/ (ins "::mlir::OpBuilder &":$builder, "::mlir::Operation *":$call, | ||
| "::mlir::Operation *":$callable, "::mlir::Value":$result, | ||
| "::mlir::DictionaryAttr":$resultAttrs), | ||
| /*methodBody=*/ [{ | ||
| return result; | ||
| }] | ||
| >, | ||
| InterfaceMethod< | ||
| /*desc=*/ [{ | ||
| Process a set of blocks that have been inlined for a call. This callback | ||
| is invoked before inlined terminator operations have been processed. | ||
| }], | ||
| /*returnType=*/ "void", | ||
| /*methodName=*/ "processInlinedCallBlocks", | ||
| /*args=*/ (ins "::mlir::Operation *":$call, | ||
| "::mlir::iterator_range<::mlir::Region::iterator>":$inlinedBlocks), | ||
| /*methodBody=*/ [{}] | ||
| >, | ||
| InterfaceMethod< | ||
| /*desc=*/ [{ | ||
| Returns true if the inliner can assume a fast path of not creating a new | ||
| block, if there is only one block. | ||
| }], | ||
| /*returnType=*/ "bool", | ||
| /*methodName=*/ "allowSingleBlockOptimization", | ||
| /*args=*/ (ins "::mlir::iterator_range<::mlir::Region::iterator>":$inlinedBlocks), | ||
| /*methodBody=*/ [{ | ||
| return true; | ||
| }] | ||
| > | ||
| ]; | ||
| } | ||
|
|
||
|
|
||
| #endif | ||
Oops, something went wrong.
Oops, something went wrong.
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Nit: newline above (certain markdown renders require separation between text and codeblock)