Converts integer types that are too wide for the target by splitting them in two halves and thus turning into supported ones, i.e., i2*N --> iN, where N is the widest integer bitwidth supported by the target. More...

#include "mlir/Dialect/Arith/Transforms/WideIntEmulationConverter.h"

Inheritance diagram for mlir::arith::WideIntEmulationConverter:

Public Member Functions
	WideIntEmulationConverter (unsigned widestIntSupportedByTarget)

unsigned	getMaxTargetIntBitWidth () const

Public Member Functions inherited from mlir::TypeConverter
virtual	~TypeConverter ()=default

	TypeConverter ()=default

	TypeConverter (const TypeConverter &other)

TypeConverter &	operator= (const TypeConverter &other)

template<typename FnT , typename T = typename llvm::function_traits< std::decay_t<FnT>>::template arg_t<0>>
void	addConversion (FnT &&callback)
	Register a conversion function. More...

template<typename FnT , typename T = typename llvm::function_traits< std::decay_t<FnT>>::template arg_t<1>>
void	addArgumentMaterialization (FnT &&callback)
	All of the following materializations require function objects that are convertible to the following form: `Value(OpBuilder &, T, ValueRange, Location)`, where `T` is any subclass of `Type`. More...

template<typename FnT , typename T = typename llvm::function_traits< std::decay_t<FnT>>::template arg_t<1>>
void	addSourceMaterialization (FnT &&callback)
	This method registers a materialization that will be called when converting a replacement value back to its original source type. More...

template<typename FnT , typename T = typename llvm::function_traits< std::decay_t<FnT>>::template arg_t<1>>
void	addTargetMaterialization (FnT &&callback)
	This method registers a materialization that will be called when converting a value to a target type according to a pattern's type converter. More...

template<typename FnT , typename T = typename llvm::function_traits<std::decay_t<FnT>>::template arg_t<0>, typename A = typename llvm::function_traits<std::decay_t<FnT>>::template arg_t<1>>
void	addTypeAttributeConversion (FnT &&callback)
	Register a conversion function for attributes within types. More...

LogicalResult	convertType (Type t, SmallVectorImpl< Type > &results) const
	Convert the given type. More...

Type	convertType (Type t) const
	This hook simplifies defining 1-1 type conversions. More...

template<typename TargetType >
TargetType	convertType (Type t) const
	Attempts a 1-1 type conversion, expecting the result type to be `TargetType`. More...

LogicalResult	convertTypes (TypeRange types, SmallVectorImpl< Type > &results) const
	Convert the given set of types, filling 'results' as necessary. More...

bool	isLegal (Type type) const
	Return true if the given type is legal for this type converter, i.e. More...

template<typename RangeT >
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. More...

bool	isLegal (Operation *op) const
	Return true if the given operation has legal operand and result types. More...

bool	isLegal (Region *region) const
	Return true if the types of block arguments within the region are legal. More...

bool	isSignatureLegal (FunctionType ty) const
	Return true if the inputs and outputs of the given function type are legal. More...

LogicalResult	convertSignatureArg (unsigned inputNo, Type type, SignatureConversion &result) const
	This method allows for converting a specific argument of a signature. More...

LogicalResult	convertSignatureArgs (TypeRange types, SignatureConversion &result, unsigned origInputOffset=0) const

std::optional< SignatureConversion >	convertBlockSignature (Block *block) const
	This function converts the type signature of the given block, by invoking 'convertSignatureArg' for each argument. More...

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 some kind. More...

Value	materializeSourceConversion (OpBuilder &builder, Location loc, Type resultType, ValueRange inputs) const

Value	materializeTargetConversion (OpBuilder &builder, Location loc, Type resultType, ValueRange inputs, Type originalType={}) const

SmallVector< Value >	materializeTargetConversion (OpBuilder &builder, Location loc, TypeRange resultType, ValueRange inputs, Type originalType={}) const

std::optional< Attribute >	convertTypeAttribute (Type type, Attribute attr) const
	Convert an attribute present `attr` from within the type `type` using the registered conversion functions. More...

Detailed Description

Converts integer types that are too wide for the target by splitting them in two halves and thus turning into supported ones, i.e., i2*N --> iN, where N is the widest integer bitwidth supported by the target.

Currently, we only handle power-of-two integer types and support conversions of integers twice as wide as the maximum supported by the target. Wide integers are represented as vectors, e.g., i64 --> vector<2xi32>, where the first element is the low half of the original integer, and the second element the high half.

Definition at line 23 of file WideIntEmulationConverter.h.