X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=include%2Flibfirm%2Firmode.h;h=b22e347535c4e3f5835a7b30fc76d76aa75540a2;hb=e824e6962c4532b2d1ef5ad9097df6754f8e560a;hp=dfbbc7577a6af3b6adbfe4f505cf244a2483dd21;hpb=1d42e84c329d51db8274fac120db2d8add15849d;p=libfirm diff --git a/include/libfirm/irmode.h b/include/libfirm/irmode.h index dfbbc7577..b22e34753 100644 --- a/include/libfirm/irmode.h +++ b/include/libfirm/irmode.h @@ -22,8 +22,17 @@ * @brief Data modes of operations. * @author Martin Trapp, Christian Schaefer, Goetz Lindenmaier, Mathias Heil, * Michael Beck - * @version $Id$ - * @summary + */ +#ifndef FIRM_IR_IRMODE_H +#define FIRM_IR_IRMODE_H + +#include "firm_types.h" +#include "begin.h" + +#include + +/** + * @defgroup ir_mode Value Modes * This module specifies the modes that type the firm nodes. It defines * a datasturcture that describes a mode and implements constructors and * access routines to this datastructure. Further it defines a set of @@ -31,150 +40,72 @@ * * SEE ALSO: * UKA tech report 1999-44 for more information about modes. + * @{ */ -#ifndef FIRM_IR_IRMODE_H -#define FIRM_IR_IRMODE_H -#include "firm_types.h" -#include "ident.h" - -/* ********** Predefined modes ********** */ - -/** - * Predefined mode according to tech report 1999-14. - */ -typedef enum ir_modecode { /* irm is short for `ir mode' */ - irm_BB, /**< basic block */ - irm_X, /**< execution */ - irm_F, /**< float(32) */ - irm_D, /**< double(64) */ - irm_E, /**< extended(80) */ - irm_Bs, /**< signed byte(8) */ - irm_Bu, /**< unsigned byte(8) */ - irm_Hs, /**< signed short(16) */ - irm_Hu, /**< unsigned short(16) */ - irm_Is, /**< signed int(32) */ - irm_Iu, /**< unsigned int(32) */ - irm_Ls, /**< signed long(64) */ - irm_Lu, /**< unsigned long(64) */ - irm_LLs, /**< signed long long(128) */ - irm_LLu, /**< unsigned long long(128) */ - irm_P, /**< pointer */ - irm_b, /**< internal boolean */ - irm_M, /**< memory */ - irm_T, /**< tuple */ - irm_ANY, /**< undefined mode */ - irm_BAD, /**< bad mode */ - irm_max /**< maximum value for ir_modecode */ -} ir_modecode; - -/** Helper values for ir_mode_sort. */ -enum ir_mode_sort_helper { - irmsh_is_num = 0x10, /**< mode represents a number */ - irmsh_is_data = 0x20, /**< mode represents data (can be carried in registers) */ - irmsh_is_datab = 0x40, /**< mode represents data or is internal boolean */ - irmsh_is_dataM = 0x80, /**< mode represents data or is memory */ -}; - -/** - * These values represent the different mode classes of value representations. - * Beware: do not change the order of these values without checking - * the mode_is - */ -typedef enum ir_mode_sort { - /* Predefined sorts of modes */ - irms_auxiliary = 0, /**< Only for Firm use. Not extensible. (irm_T) */ - irms_control_flow = 1, /**< Marks all control flow modes. Not extensible. (irm_BB, irm_X) */ - irms_memory = 2, /**< Marks the memory mode. Not extensible. (irm_M) */ - - /** Internal boolean representation. - Storing to memory impossible, convert first. (irm_b) */ - irms_internal_boolean = 3 | irmsh_is_datab, - - /* user-extensible sorts of modes */ - /** A mode to represent entities. - Restricted int computations can be performed */ - irms_reference = 4 | irmsh_is_data | irmsh_is_datab | irmsh_is_dataM, - /** A mode to represent int numbers. - Integer computations can be performed. */ - irms_int_number = 5 | irmsh_is_data | irmsh_is_datab | irmsh_is_dataM | irmsh_is_num, - /** A mode to represent float numbers. - Floating point computations can be performed. */ - irms_float_number = 6 | irmsh_is_data | irmsh_is_datab | irmsh_is_dataM | irmsh_is_num, -} ir_mode_sort; - -/** These values represent the different arithmetic operations possible with a mode. - Further arithmetics can be defined, e.g., for @@@ modes. +/** + * These values represent the different arithmetic operations possible with a + * mode. */ typedef enum ir_mode_arithmetic { - irma_uninitialized = 0, - irma_none = 1, /**< For modes for which no representation is specified. - These are modes of sort auxiliary, internal_boolean and character. */ - irma_twos_complement = 2, /**< Values of the mode are represented as two's complement. - Only legal for modes of sort int_number and reference. */ - irma_ones_complement, /**< Values of the mode are represented as one's complement. - Only legal for modes of sort int_number and reference. */ - irma_int_BCD, /**< Values of the mode are represented as binary coded decimals. - Only legal for modes of sort int_number and reference. */ - irma_ieee754 = 256, /**< Values of the mode are represented according to ieee754 - floating point standard. Only legal for modes of sort float_number. */ - irma_float_BCD, /**< Values of the mode are represented as binary coded decimals - according to @@@ which standards??? Only legal for modes of - sort float_number. */ - irma_max + irma_none = 1, /**< For modes for which no representation is + specified. These are modes of sort auxiliary, + internal_boolean and character. */ + irma_twos_complement = 2, /**< Values of the mode are represented as two's + complement. Only legal for modes of sort + int_number and reference. */ + irma_ieee754 = 256, /**< Values of the mode are represented according + to ieee754 floating point standard. Only + legal for modes of sort float_number. */ + irma_x86_extended_float, /**< x86 extended floatingpoint values */ + irma_last = irma_x86_extended_float, } ir_mode_arithmetic; - -/* ********** Constructor for user defined modes **************** */ /** * Creates a new mode. * * @param name the name of the mode to be created - * @param sort the ir_mode_sort of the mode to be created + * @param arithmetic arithmetic operations possible with a mode * @param bit_size number of bits this mode allocate * @param sign non-zero if this is a signed mode - * @param arithmetic arithmetic operations possible with a mode * @param modulo_shift Is ignored for modes other than integer. * * This function constructs a new mode given by the parameters. * If the parameters match an already defined mode, this mode is returned * (including the default modes). - * If the mode is newly allocated, a new unique mode_code is chosen. - * Also, special value tarvals will be calculated such as null, - * min, max and can be retrieved using the get_mode_* functions * * @return * The new mode or NULL on error. + */ +FIRM_API ir_mode *new_int_mode(const char *name, + ir_mode_arithmetic arithmetic, + unsigned bit_size, int sign, + unsigned modulo_shift); + +/** + * Create a new reference mode. * - * @note - * It is allowed to construct the default modes. So, a call - * new_ir_mode("Is", irms_int_number, 32, 1, irma_twos_complement, 32) will return mode_Is. + * Reference modes are always unsigned. */ -ir_mode *new_ir_mode(const char *name, ir_mode_sort sort, int bit_size, int sign, - ir_mode_arithmetic arithmetic, unsigned int modulo_shift); +FIRM_API ir_mode *new_reference_mode(const char *name, + ir_mode_arithmetic arithmetic, + unsigned bit_size, + unsigned modulo_shift); /** - * Creates a new vector mode. + * Create a new ieee754 float mode. * + * float-modes are always signed and have no modulo shift. * @param name the name of the mode to be created - * @param sort the ir_mode_sort of the mode to be created - * @param bit_size number of bits for one element of this mode - * @param num_of_elem number of elements in this vector mode - * @param sign non-zero if this is a signed mode - * @param arithmetic arithmetic operations possible with a mode - * @param modulo_shift Is ignored for modes other than integer. - * - * This function constructs a new vector mode given by the parameters. - * If the parameters match an already defined mode, this mode is returned. - * If the mode is newly allocated, a new unique mode_code is chosen. - * Also, special value tarvals will be calculated such as null, - * min, max and can be retrieved using the get_mode_* functions - * - * @return - * The new mode or NULL on error. + * @param arithmetic arithmetic/representation of the mode + * @param exponent_size size of exponent in bits + * @param mantissa_size size of mantissa in bits (number of bits after the + * leading one). */ -ir_mode *new_ir_vector_mode(const char *name, ir_mode_sort sort, int bit_size, unsigned num_of_elem, int sign, - ir_mode_arithmetic arithmetic, unsigned int modulo_shift); +FIRM_API ir_mode *new_float_mode(const char *name, + ir_mode_arithmetic arithmetic, + unsigned exponent_size, + unsigned mantissa_size); /** * Checks whether a pointer points to a mode. @@ -184,58 +115,42 @@ ir_mode *new_ir_vector_mode(const char *name, ir_mode_sort sort, int bit_size, u * @return * true if the thing is a mode, else false */ -int is_mode(void *thing); - -/* ********** Access methods to read mode information *********** */ - -/** Returns the classification of the mode */ -ir_modecode get_mode_modecode(const ir_mode *mode); +FIRM_API int is_mode(const void *thing); /** Returns the ident* of the mode */ -ident *get_mode_ident(const ir_mode *mode); +FIRM_API ident *get_mode_ident(const ir_mode *mode); /** Returns the null-terminated name of this mode. */ -const char *get_mode_name(const ir_mode *mode); - -/** Returns a coarse classification of the mode. */ -ir_mode_sort get_mode_sort(const ir_mode *mode); +FIRM_API const char *get_mode_name(const ir_mode *mode); /** Returns the size of values of the mode in bits. */ -unsigned get_mode_size_bits(const ir_mode *mode); +FIRM_API unsigned get_mode_size_bits(const ir_mode *mode); /** Returns the size of values of the mode in bytes. * If the size is not dividable by 8 returns -1. */ -unsigned get_mode_size_bytes(const ir_mode *mode); +FIRM_API unsigned get_mode_size_bytes(const ir_mode *mode); /** Returns the signess of a mode. * * Returns the signess of a mode: 1 if mode is signed. */ -int get_mode_sign(const ir_mode *mode); +FIRM_API int get_mode_sign(const ir_mode *mode); /** Returns the arithmetic of a mode */ -ir_mode_arithmetic get_mode_arithmetic(const ir_mode *mode); +FIRM_API ir_mode_arithmetic get_mode_arithmetic(const ir_mode *mode); -/** Get the modulo shift attribute. +/** Returns the modulo shift attribute. * * Attribute modulo shift specifies for modes of kind irms_int_number * whether shift applies modulo to value of bits to shift. Zero for * modes that are not integer. */ -unsigned int get_mode_modulo_shift(const ir_mode *mode); - -/** Return the number of vector elements. - * - * Attribute vector_elem specifies the number of vector elements of - * a vector mode. For non-vector modes it returns 1 for data and 0 - * for all other modes - */ -unsigned int get_mode_n_vector_elems(const ir_mode *mode); +FIRM_API unsigned int get_mode_modulo_shift(const ir_mode *mode); /** Returns the stored intermediate information. */ -void *get_mode_link(const ir_mode *mode); +FIRM_API void *get_mode_link(const ir_mode *mode); /** Stores new intermediate information. */ -void set_mode_link(ir_mode *mode, void *l); +FIRM_API void set_mode_link(ir_mode *mode, void *l); /** * Returns the smallest representable value of a given mode. @@ -243,7 +158,7 @@ void set_mode_link(ir_mode *mode, void *l); * For modes of the sort float_number this is the most negative value * bigger than -infinite. */ -tarval *get_mode_min(ir_mode *mode); +FIRM_API ir_tarval *get_mode_min(ir_mode *mode); /** * Returns the biggest representable value o f a given mode. @@ -251,7 +166,7 @@ tarval *get_mode_min(ir_mode *mode); * For modes of the sort float_number this is the largest value lower * than infinite. */ -tarval *get_mode_max(ir_mode *mode); +FIRM_API ir_tarval *get_mode_max(ir_mode *mode); /** * Returns the value Zero represented in this mode. @@ -261,7 +176,7 @@ tarval *get_mode_max(ir_mode *mode); * op_pin_state_floats and ints, and references (NULL-Pointer) * else returns tarval_bad. */ -tarval *get_mode_null(ir_mode *mode); +FIRM_API ir_tarval *get_mode_null(ir_mode *mode); /** * Returns the value One, represented in this mode. @@ -270,7 +185,7 @@ tarval *get_mode_null(ir_mode *mode); * is defined only for modes allowing multiplication, * i.e. ints and floats. */ -tarval *get_mode_one(ir_mode *mode); +FIRM_API ir_tarval *get_mode_one(ir_mode *mode); /** * Returns the value Minus One, represented in this mode. @@ -278,14 +193,14 @@ tarval *get_mode_one(ir_mode *mode); * Minus One is defined only for modes allowing * multiplication with signed values, i.e. signed ints and floats. */ -tarval *get_mode_minus_one(ir_mode *mode); +FIRM_API ir_tarval *get_mode_minus_one(ir_mode *mode); /** * Returns the value where all bits are One, represented in this mode. * * All One is defined only for modes integer, reference and boolean modes */ -tarval *get_mode_all_one(ir_mode *mode); +FIRM_API ir_tarval *get_mode_all_one(ir_mode *mode); /** * Returns the positive infinite value of a mode. @@ -293,7 +208,7 @@ tarval *get_mode_all_one(ir_mode *mode); * This is only valid for float_numbers, other modes * will result in tarval_bad. */ -tarval *get_mode_infinite(ir_mode *mode); +FIRM_API ir_tarval *get_mode_infinite(ir_mode *mode); /** * Returns the NAN value of a given mode. @@ -301,177 +216,172 @@ tarval *get_mode_infinite(ir_mode *mode); * This is only valid for float_numbers, other modes * will result in tarval_bad. */ -tarval *get_mode_NAN(ir_mode *mode); - -extern ir_mode *mode_M; /**< memory */ - -/* -- A set of predefined, numerical modes according to Techreport 1999-44 -- */ -extern ir_mode *mode_F; /**< signed float(32) */ -extern ir_mode *mode_D; /**< signed double(64) */ -extern ir_mode *mode_E; /**< signed extended(80) */ -extern ir_mode *mode_Bs; /**< signed byte (former char) */ -extern ir_mode *mode_Bu; /**< unsigned byte (former char) */ -extern ir_mode *mode_Hs; /**< signed short integer */ -extern ir_mode *mode_Hu; /**< unsigned short integer */ -extern ir_mode *mode_Is; /**< signed integer */ -extern ir_mode *mode_Iu; /**< unsigned integer */ -extern ir_mode *mode_Ls; /**< signed long integer */ -extern ir_mode *mode_Lu; /**< unsigned long integer */ -extern ir_mode *mode_LLs; /**< signed long long integer */ -extern ir_mode *mode_LLu; /**< unsigned long long integer */ - -extern ir_mode *mode_P; /**< pointer */ -extern ir_mode *mode_P_code; /**< A pointer mode that is set by the client of libfirm. This mode +FIRM_API ir_tarval *get_mode_NAN(ir_mode *mode); + +FIRM_API ir_mode *mode_M; /**< memory */ + +FIRM_API ir_mode *mode_F; /**< ieee754 binary32 float (single precision) */ +FIRM_API ir_mode *mode_D; /**< ieee754 binary64 float (double precision) */ +FIRM_API ir_mode *mode_Q; /**< ieee754 binary128 float (quadruple precision)*/ +FIRM_API ir_mode *mode_Bs; /**< int8 */ +FIRM_API ir_mode *mode_Bu; /**< uint8 */ +FIRM_API ir_mode *mode_Hs; /**< int16 */ +FIRM_API ir_mode *mode_Hu; /**< uint16 */ +FIRM_API ir_mode *mode_Is; /**< int32 */ +FIRM_API ir_mode *mode_Iu; /**< uint32 */ +FIRM_API ir_mode *mode_Ls; /**< int64 */ +FIRM_API ir_mode *mode_Lu; /**< uint64 */ +FIRM_API ir_mode *mode_LLs; /**< int128 */ +FIRM_API ir_mode *mode_LLu; /**< uint128 */ + +FIRM_API ir_mode *mode_P; /**< pointer */ +FIRM_API ir_mode *mode_P_code; /**< A pointer mode that is set by the client of libfirm. This mode represents the pointer size of the target machine code addresses. Is initialized to mode_P. */ -extern ir_mode *mode_P_data; /**< A pointer mode that is set by the client of libfirm. This mode +FIRM_API ir_mode *mode_P_data; /**< A pointer mode that is set by the client of libfirm. This mode represents the pointer size of the target machine data addresses. Is initialized to mode_P. */ -/* -- Auxiliary modes necessary for the Firm representation -- */ -extern ir_mode *mode_b; /**< internal boolean */ - -extern ir_mode *mode_X; /**< execution */ -extern ir_mode *mode_BB; /**< block */ - -extern ir_mode *mode_T; /**< tuple (none) */ -extern ir_mode *mode_ANY;/**< undefined mode */ -extern ir_mode *mode_BAD;/**< bad mode */ - -/*@{*/ -/** Access routines for JNI Interface */ -ir_mode *get_modeF(void); -ir_mode *get_modeD(void); -ir_mode *get_modeE(void); -ir_mode *get_modeBs(void); -ir_mode *get_modeBu(void); -ir_mode *get_modeHs(void); -ir_mode *get_modeHu(void); -ir_mode *get_modeIs(void); -ir_mode *get_modeIu(void); -ir_mode *get_modeLs(void); -ir_mode *get_modeLu(void); -ir_mode *get_modeLLs(void); -ir_mode *get_modeLLu(void); -ir_mode *get_modeP(void); -ir_mode *get_modeb(void); -ir_mode *get_modeX(void); -ir_mode *get_modeBB(void); -ir_mode *get_modeM(void); -ir_mode *get_modeT(void); -ir_mode *get_modeANY(void); -ir_mode *get_modeBAD(void); +FIRM_API ir_mode *mode_b; /**< internal boolean */ + +FIRM_API ir_mode *mode_X; /**< execution */ +FIRM_API ir_mode *mode_BB; /**< block */ + +FIRM_API ir_mode *mode_T; /**< tuple (none) */ +FIRM_API ir_mode *mode_ANY;/**< undefined mode */ +FIRM_API ir_mode *mode_BAD;/**< bad mode */ + +/** Returns float mode */ +FIRM_API ir_mode *get_modeF(void); +/** Returns double mode */ +FIRM_API ir_mode *get_modeD(void); +/** Returns quadruple prevision mode */ +FIRM_API ir_mode *get_modeQ(void); +/** Returns byte signed mode */ +FIRM_API ir_mode *get_modeBs(void); +/** Returns byte unsigned mode */ +FIRM_API ir_mode *get_modeBu(void); +/** Returns halfword signed mode */ +FIRM_API ir_mode *get_modeHs(void); +/** Returns halfword unsigned mode */ +FIRM_API ir_mode *get_modeHu(void); +/** Returns integer signed mode */ +FIRM_API ir_mode *get_modeIs(void); +/** Returns integer unsigned mode */ +FIRM_API ir_mode *get_modeIu(void); +/** Returns long signed mode */ +FIRM_API ir_mode *get_modeLs(void); +/** Returns long unsigned mode */ +FIRM_API ir_mode *get_modeLu(void); +/** Returns long long signed mode */ +FIRM_API ir_mode *get_modeLLs(void); +/** Returns long long unsigned mode */ +FIRM_API ir_mode *get_modeLLu(void); +/** Returns pointer mode */ +FIRM_API ir_mode *get_modeP(void); +/** Returns internal boolean mode */ +FIRM_API ir_mode *get_modeb(void); +/** Returns control-flow mode */ +FIRM_API ir_mode *get_modeX(void); +/** Returns Basic-Block mode */ +FIRM_API ir_mode *get_modeBB(void); +/** Returns memory mode */ +FIRM_API ir_mode *get_modeM(void); +/** Returns tuple mode */ +FIRM_API ir_mode *get_modeT(void); +/** Returns ANY mode */ +FIRM_API ir_mode *get_modeANY(void); +/** Returns BAD mode */ +FIRM_API ir_mode *get_modeBAD(void); /** Returns the machine specific pointer mode for code addresses. */ -ir_mode *get_modeP_code(void); +FIRM_API ir_mode *get_modeP_code(void); /** Returns the machine specific pointer mode for data addresses. */ -ir_mode *get_modeP_data(void); +FIRM_API ir_mode *get_modeP_data(void); /** * Sets the machine specific pointer mode for code addresses. * If not set, the predefined mode mode_P will be used. */ -void set_modeP_code(ir_mode *p); +FIRM_API void set_modeP_code(ir_mode *p); /** * Sets the machine specific pointer mode for data addresses. * If not set, the predefined mode mode_P will be used. */ -void set_modeP_data(ir_mode *p); - -/*@{*/ -/** - Functions to check, whether a ir_modecode is signed, float, int, character, - reference, num, data, datab or dataM. - - For more exact definitions read the corresponding pages - in the firm documentation or the following enumeration - - The set of "float" is defined as: - float = {irm_F, irm_D, irm_E} - - The set of "int" is defined as: - int = {irm_Bs, irm_Bu, irm_Hs, irm_Hu, irm_Is, irm_Iu, irm_Ls, irm_Lu} - - The set of "reference" is defined as: - reference = {irm_P} - - The set of "num" is defined as: - num = {float || int} - - The set of "data" is defined as: - data = {num || reference} - - The set of "datab" is defined as: - datab = {data || irm_b } - - The set of "dataM" is defined as: - dataM = {data || irm_M} - - Vector "int" and "float" are defined by the arithmetic and vector_elem > 1. -*/ -/* Test for a certain class of modes. */ -int mode_is_signed (const ir_mode *mode); -int mode_is_float (const ir_mode *mode); -int mode_is_int (const ir_mode *mode); -int mode_is_reference (const ir_mode *mode); -int mode_is_num (const ir_mode *mode); -int mode_is_data (const ir_mode *mode); -int mode_is_datab (const ir_mode *mode); -int mode_is_dataM (const ir_mode *mode); -int mode_is_float_vector (const ir_mode *mode); -int mode_is_int_vector (const ir_mode *mode); -/*@}*/ +FIRM_API void set_modeP_data(ir_mode *p); + +/** Returns 1 if @p mode is signed, 0 otherwise */ +FIRM_API int mode_is_signed (const ir_mode *mode); +/** Returns 1 if @p mode is for floatingpoint numbers, 0 otherwise */ +FIRM_API int mode_is_float (const ir_mode *mode); +/** Returns 1 if @p mode is for integer numbers, 0 otherwise */ +FIRM_API int mode_is_int (const ir_mode *mode); +/** Returns 1 if @p mode is for references/pointers, 0 otherwise */ +FIRM_API int mode_is_reference (const ir_mode *mode); +/** Returns 1 if @p mode is for numeric values, 0 otherwise */ +FIRM_API int mode_is_num (const ir_mode *mode); +/** Returns 1 if @p mode is for data values, 0 otherwise */ +FIRM_API int mode_is_data (const ir_mode *mode); +/** Returns 1 if @p mode is for data values or internal booleans, 0 otherwise */ +FIRM_API int mode_is_datab (const ir_mode *mode); +/** Returns 1 if @p mode is for data values or memory, 0 otherwise */ +FIRM_API int mode_is_dataM (const ir_mode *mode); /** - * Returns true if sm can be converted to lm without loss - * according to firm definition. + * Returns true if a value of mode @p sm can be converted to mode @p lm without + * loss. * - * Note that mode_Iu is NOT smaller than mode_Is here. + * That is the interpretation of the numbers does not changes, so you a signed + * integer mode is never smaller than an unsigned integer mode since the + * unsigned mode can't represent negative numbers in a way that they are + * interpreted as negative numbers. * * @see values_in_mode() */ -int smaller_mode(const ir_mode *sm, const ir_mode *lm); +FIRM_API int smaller_mode(const ir_mode *sm, const ir_mode *lm); /** - * Returns true if a value of mode sm can be converted into mode lm - * and backwards without loss. + * Returns true if no information is lost when converting a value of mode @p sm + * into mode @p lm (and back to mode @p sm). * - * Note that mode_Iu values CAN be converted in mode_Is and back. + * So the interpretation of the values may change in the intermediate mode @p sm + * (for example when converting negative signed integer numbers into unsigned + * integers) but after a conversion back they are exactly the same value. * * @see smaller_mode() */ -int values_in_mode(const ir_mode *sm, const ir_mode *lm); +FIRM_API int values_in_mode(const ir_mode *sm, const ir_mode *lm); /** * Returns a matching unsigned mode for a given integer signed mode. * Returns NULL if no matching mode exists. */ -ir_mode *find_unsigned_mode(const ir_mode *mode); +FIRM_API ir_mode *find_unsigned_mode(const ir_mode *mode); /** * Returns a matching signed mode for a given integer unsigned mode. * Returns NULL if no matching mode exists. */ -ir_mode *find_signed_mode(const ir_mode *mode); +FIRM_API ir_mode *find_signed_mode(const ir_mode *mode); /** * Returns an integer mode with 2*n bits for a given integer mode with n bits. * Returns NULL if no matching mode exists. */ -ir_mode *find_double_bits_int_mode(const ir_mode *mode); +FIRM_API ir_mode *find_double_bits_int_mode(const ir_mode *mode); /** * Returns non-zero if the given mode honors signed zero's, i.e., * a +0 and a -0 exists and handled differently. */ -int mode_honor_signed_zeros(const ir_mode *mode); +FIRM_API int mode_honor_signed_zeros(const ir_mode *mode); /** * Returns non-zero if the given mode might overflow on unary Minus. */ -int mode_overflow_on_unary_Minus(const ir_mode *mode); +FIRM_API int mode_overflow_on_unary_Minus(const ir_mode *mode); /** * Returns non-zero if the mode has a reversed wrap-around @@ -479,33 +389,62 @@ int mode_overflow_on_unary_Minus(const ir_mode *mode); * This is normally true for integer modes, not for floating * point modes. */ -int mode_wrap_around(const ir_mode *mode); +FIRM_API int mode_wrap_around(const ir_mode *mode); /** - * Return the signed integer equivalent mode for an reference mode. + * Returns the signed integer equivalent mode for an reference mode. */ -ir_mode *get_reference_mode_signed_eq(ir_mode *mode); +FIRM_API ir_mode *get_reference_mode_signed_eq(ir_mode *mode); /** * Sets the signed integer equivalent mode for an reference mode. */ -void set_reference_mode_signed_eq(ir_mode *ref_mode, ir_mode *int_mode); +FIRM_API void set_reference_mode_signed_eq(ir_mode *ref_mode, ir_mode *int_mode); /** - * Return the unsigned integer equivalent mode for an reference mode. + * Returns the unsigned integer equivalent mode for an reference mode. */ -ir_mode *get_reference_mode_unsigned_eq(ir_mode *mode); +FIRM_API ir_mode *get_reference_mode_unsigned_eq(ir_mode *mode); /** * Sets the unsigned integer equivalent mode for an reference mode. */ -void set_reference_mode_unsigned_eq(ir_mode *ref_mode, ir_mode *int_mode); +FIRM_API void set_reference_mode_unsigned_eq(ir_mode *ref_mode, ir_mode *int_mode); + +/** + * Returns size of mantissa in bits (for float modes). + * Note: This is the number of bits used after the leading one. So the actual + * accuracy of the significand is get_mode_mantissa_size()+1. The number of bits + * used in the encoding depends on wether the floatingpoint mode has an implicit + * (ieee754) or explicit (x86_extended) encoding of the leading one. + */ +FIRM_API unsigned get_mode_mantissa_size(const ir_mode *mode); + +/** + * Returns size of exponent in bits (for float modes) + */ +FIRM_API unsigned get_mode_exponent_size(const ir_mode *mode); /** * Returns non-zero if the cast from mode src to mode dst is a * reinterpret cast (ie. only the bit pattern is reinterpreted, * no conversion is done) */ -int is_reinterpret_cast(const ir_mode *src, const ir_mode *dst); +FIRM_API int is_reinterpret_cast(const ir_mode *src, const ir_mode *dst); + +/** + * Returns the primitive type matching the given mode + */ +FIRM_API ir_type *get_type_for_mode(const ir_mode *mode); + +/** Returns number of known modes. */ +FIRM_API size_t ir_get_n_modes(void); + +/** Returns known mode number @p num. */ +FIRM_API ir_mode *ir_get_mode(size_t num); + +/** @} */ + +#include "end.h" #endif