mlir/include/mlir/Transforms/DialectInlinerInterface.td - llvm-project - Git at Google

 #ifndef MLIR_INTERFACES_DIALECTINLINERINTERFACE
 #define MLIR_INTERFACES_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<[{
         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).
       }],
       "bool", "isLegalToInline",
       (ins "::mlir::Operation *":$call, "::mlir::Operation *":$callable,
            "bool":$wouldBeCloned),
       [{
         return false;
       }]
     >,
     InterfaceMethod<[{
         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.
       }],
       "bool", "isLegalToInline",
       (ins "::mlir::Region *":$dest, "::mlir::Region *":$src, "bool":$wouldBeCloned,
                         "::mlir::IRMapping &":$valueMapping),
       [{
         return false;
       }]
     >,
     InterfaceMethod<[{
         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.
       }],
       "bool", "isLegalToInline",
       (ins "::mlir::Operation *":$op, "::mlir::Region *":$dest,
            "bool":$wouldBeCloned, "::mlir::IRMapping &":$valueMapping),
       [{
         return false;
       }]
     >,
     InterfaceMethod<[{
         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.
       }],
       "bool", "shouldAnalyzeRecursively",
       (ins "::mlir::Operation *":$op),
       [{
         return true;
       }]
     >,
     InterfaceMethod<[{
         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.
       }],
       "void", "handleTerminator",
       (ins "::mlir::Operation *":$op, "::mlir::Block *":$newDest),
       [{
         llvm_unreachable("must implement handleTerminator in the case of multiple "
                          "inlined blocks");
       }]
     >,
     InterfaceMethod<[{
         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.
       }],
       "void", "handleTerminator",
       (ins "::mlir::Operation *":$op, "::mlir::ValueRange":$valuesToReplace),
       [{
         llvm_unreachable(
             "must implement handleTerminator in the case of one inlined block");
       }]
     >,
     InterfaceMethod<[{
         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:

           ```mlir
           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.
       }],
       "::mlir::Operation *", "materializeCallConversion",
       (ins "::mlir::OpBuilder &":$builder, "::mlir::Value":$input,
            "::mlir::Type":$resultType, "::mlir::Location":$conversionLoc),
       [{
         return nullptr;
       }]
     >,
     InterfaceMethod<[{
         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.
       }],
       "::mlir::Value", "handleArgument",
       (ins "::mlir::OpBuilder &":$builder, "::mlir::Operation *":$call,
            "::mlir::Operation *":$callable, "::mlir::Value":$argument,
            "::mlir::DictionaryAttr":$argumentAttrs),
       [{
         return argument;
       }]
     >,
     InterfaceMethod<[{
         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.
       }],
       "::mlir::Value", "handleResult",
       (ins "::mlir::OpBuilder &":$builder, "::mlir::Operation *":$call,
            "::mlir::Operation *":$callable, "::mlir::Value":$result,
            "::mlir::DictionaryAttr":$resultAttrs),
       [{
         return result;
       }]
     >,
     InterfaceMethod<[{
         Process a set of blocks that have been inlined for a call. This callback
         is invoked before inlined terminator operations have been processed.
       }],
       "void", "processInlinedCallBlocks",
       (ins "::mlir::Operation *":$call,
            "::mlir::iterator_range<::mlir::Region::iterator>":$inlinedBlocks),
       [{}]
     >,
     InterfaceMethod<[{
         Returns true if the inliner can assume a fast path of not creating a new
         block, if there is only one block.
       }],
       "bool", "allowSingleBlockOptimization",
       (ins "::mlir::iterator_range<::mlir::Region::iterator>":$inlinedBlocks),
       [{
         return true;
       }]
     >
   ];
 }


 #endif
	#ifndef MLIR_INTERFACES_DIALECTINLINERINTERFACE
	#define MLIR_INTERFACES_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<[{
	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).
	}],
	"bool", "isLegalToInline",
	(ins "::mlir::Operation ":$call, "::mlir::Operation ":$callable,
	"bool":$wouldBeCloned),
	[{
	return false;
	}]
	>,
	InterfaceMethod<[{
	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.
	}],
	"bool", "isLegalToInline",
	(ins "::mlir::Region ":$dest, "::mlir::Region ":$src, "bool":$wouldBeCloned,
	"::mlir::IRMapping &":$valueMapping),
	[{
	return false;
	}]
	>,
	InterfaceMethod<[{
	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.
	}],
	"bool", "isLegalToInline",
	(ins "::mlir::Operation ":$op, "::mlir::Region ":$dest,
	"bool":$wouldBeCloned, "::mlir::IRMapping &":$valueMapping),
	[{
	return false;
	}]
	>,
	InterfaceMethod<[{
	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.
	}],
	"bool", "shouldAnalyzeRecursively",
	(ins "::mlir::Operation *":$op),
	[{
	return true;
	}]
	>,
	InterfaceMethod<[{
	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.
	}],
	"void", "handleTerminator",
	(ins "::mlir::Operation ":$op, "::mlir::Block ":$newDest),
	[{
	llvm_unreachable("must implement handleTerminator in the case of multiple "
	"inlined blocks");
	}]
	>,
	InterfaceMethod<[{
	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.
	}],
	"void", "handleTerminator",
	(ins "::mlir::Operation *":$op, "::mlir::ValueRange":$valuesToReplace),
	[{
	llvm_unreachable(
	"must implement handleTerminator in the case of one inlined block");
	}]
	>,
	InterfaceMethod<[{
	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:

	```mlir
	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.
	}],
	"::mlir::Operation *", "materializeCallConversion",
	(ins "::mlir::OpBuilder &":$builder, "::mlir::Value":$input,
	"::mlir::Type":$resultType, "::mlir::Location":$conversionLoc),
	[{
	return nullptr;
	}]
	>,
	InterfaceMethod<[{
	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.
	}],
	"::mlir::Value", "handleArgument",
	(ins "::mlir::OpBuilder &":$builder, "::mlir::Operation *":$call,
	"::mlir::Operation *":$callable, "::mlir::Value":$argument,
	"::mlir::DictionaryAttr":$argumentAttrs),
	[{
	return argument;
	}]
	>,
	InterfaceMethod<[{
	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.
	}],
	"::mlir::Value", "handleResult",
	(ins "::mlir::OpBuilder &":$builder, "::mlir::Operation *":$call,
	"::mlir::Operation *":$callable, "::mlir::Value":$result,
	"::mlir::DictionaryAttr":$resultAttrs),
	[{
	return result;
	}]
	>,
	InterfaceMethod<[{
	Process a set of blocks that have been inlined for a call. This callback
	is invoked before inlined terminator operations have been processed.
	}],
	"void", "processInlinedCallBlocks",
	(ins "::mlir::Operation *":$call,
	"::mlir::iterator_range<::mlir::Region::iterator>":$inlinedBlocks),
	[{}]
	>,
	InterfaceMethod<[{
	Returns true if the inliner can assume a fast path of not creating a new
	block, if there is only one block.
	}],
	"bool", "allowSingleBlockOptimization",
	(ins "::mlir::iterator_range<::mlir::Region::iterator>":$inlinedBlocks),
	[{
	return true;
	}]
	>
	];
	}


	#endif