* @brief Data modes of operations.
* @author Martin Trapp, Christian Schaefer, Goetz Lindenmaier, Mathias Heil,
* Michael Beck
- * @version $Id$
- * @brief
- * 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
- * predefined modes.
- *
- * 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 "begin.h"
-/** 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 */
-};
+#include <stddef.h>
/**
- * These values represent the different mode classes of value representations.
- * Beware: do not change the order of these values without checking
- * the mode_is
+ * @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
+ * predefined modes.
+ *
+ * SEE ALSO:
+ * UKA tech report 1999-44 for more information about modes.
+ * @{
*/
-typedef enum ir_mode_sort {
- 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 | irmsh_is_dataM, /**< 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,
-
- /** 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.
*/
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_ieee754 = 256, /**< Values of the mode are represented according
to ieee754 floating point standard. Only
legal for modes of sort float_number. */
- irma_max
+ irma_x86_extended_float, /**< x86 extended floatingpoint values */
+ irma_last = irma_x86_extended_float,
} ir_mode_arithmetic;
-/** Returns the name of the arithmetic type. */
-FIRM_API const char *get_mode_arithmetic_name(ir_mode_arithmetic ari);
-
/**
* 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.
*/
-FIRM_API 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).
*/
-FIRM_API 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.
/** Returns the null-terminated name of this mode. */
FIRM_API const char *get_mode_name(const ir_mode *mode);
-/** Returns a coarse classification of the mode. */
-FIRM_API ir_mode_sort get_mode_sort(const ir_mode *mode);
-
/** Returns the size of values of the mode in bits. */
FIRM_API unsigned get_mode_size_bits(const ir_mode *mode);
/** Returns the arithmetic of a 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
*/
FIRM_API 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
- */
-FIRM_API unsigned int get_mode_n_vector_elems(const ir_mode *mode);
-
/** Returns the stored intermediate information. */
FIRM_API void *get_mode_link(const ir_mode *mode);
FIRM_API ir_mode *mode_M; /**< memory */
-FIRM_API ir_mode *mode_F; /**< float (32) */
-FIRM_API ir_mode *mode_D; /**< double (64) */
-FIRM_API ir_mode *mode_E; /**< long double (80/128/...) */
+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_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);
-FIRM_API ir_mode *get_modeE(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. */
*/
FIRM_API void set_modeP_data(ir_mode *p);
-/*@{
- Functions to check, whether a mode 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.
-*/
-
+/** 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);
-FIRM_API int mode_is_float_vector (const ir_mode *mode);
-FIRM_API int mode_is_int_vector (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()
*/
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()
*/
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.
*/
FIRM_API ir_mode *get_reference_mode_signed_eq(ir_mode *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.
*/
FIRM_API ir_mode *get_reference_mode_unsigned_eq(ir_mode *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,
*/
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
projects / libfirm / blobdiff