#ifndef _IRMODE_H_
#define _IRMODE_H_
+#include "firm_types.h"
#include "ident.h"
-#ifndef _TARVAL_TYPEDEF_
-#define _TARVAL_TYPEDEF_
- typedef struct tarval tarval;
-#endif
-
/**
* Contains relevant information about a mode.
*
- * Neccessary information about a mode is stored in this struct
+ * Necessary information about a mode is stored in this struct
* which is used by the tarval module to perform calculations
* and comparisons of values of a such described mode.
*
* ATTRIBUTES:
- * - modecode code: An unambigous int (enum) for the mode
+ * - modecode code: An unambiguous int (enum) for the mode
* - ident *name: Name of this mode. Two modes are different if the name is different.
- * - mode_sort sort: sort of mode specifying possible usage kategories
+ * - mode_sort sort: sort of mode specifying possible usage categories
* - int size: size of the mode in Bits.
- * - int align: byte alignment
* - unsigned sign:1: signedness of this mode
* - ... more to come
* - modulo_shift specifies for modes of kind irms_int_number
* The tech report 1999-44 describing FIRM and predefined modes
* tarval.h
*/
+#ifndef _IR_MODE_TYPEDEF_
+#define _IR_MODE_TYPEDEF_
typedef struct ir_mode ir_mode;
+#endif
/* ********** Predefined modes ********** */
irma_ieee754 = 256, /**< Values of the mode are represented according to ieee754
floatingpoint 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 standars??? Only legal for modes of
+ according to @@@ which standards??? Only legal for modes of
sort float_number. */
irma_max
} mode_arithmetic;
* @param name the name of the mode to be created
* @param sort the mode_sort of the mode to be created
* @param bit_size number of bits this mode allocate
- * @param align the byte alignment for an entity of this mode (in bits)
* @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 choosen.
+ * 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_* fuctions
+ * min, max and can be retrieved using the get_mode_* functions
*
* @return
* The new mode or NULL on error.
*
* @note
* It is allowed to construct the default modes. So, a call
- * new_ir_mode("Is", irms_int_number, 32, 4, 1, 32) will return mode_Is.
+ * new_ir_mode("Is", irms_int_number, 32, 1, irma_twos_complement, 32) will return mode_Is.
+ */
+ir_mode *new_ir_mode(const char *name, mode_sort sort, int bit_size, int sign, mode_arithmetic arithmetic, unsigned int modulo_shift);
+
+/**
+ * Creates a new vector mode.
+ *
+ * @param name the name of the mode to be created
+ * @param sort the 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.
*/
-ir_mode *new_ir_mode(const char *name, mode_sort sort, int bit_size, int align,
- int sign, mode_arithmetic arithmetic, unsigned int modulo_shift);
+ir_mode *new_ir_vector_mode(const char *name, mode_sort sort, int bit_size, unsigned num_of_elem, int sign,
+ mode_arithmetic arithmetic, unsigned int modulo_shift );
/**
* Checks whether a pointer points to a mode.
* @return
* true if the thing is a mode, else false
*/
-int is_mode (void *thing);
+int is_mode(void *thing);
/* ********** Access methods to read mode information *********** */
/** Returns the classification of the mode */
-modecode get_mode_modecode(const ir_mode *mode);
+modecode get_mode_modecode(const ir_mode *mode);
/** Returns the ident* of the mode */
-ident *get_mode_ident(const ir_mode *mode);
+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. */
-mode_sort get_mode_sort(const ir_mode *mode);
+mode_sort get_mode_sort(const ir_mode *mode);
/** Returns the size of values of the mode in bits. */
int 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. */
+/** Returns the size of values of the mode in bytes.
+ * If the size is not dividable by 8 returns -1. */
int get_mode_size_bytes(const ir_mode *mode);
-/** Returns the alignment of values of the mode in bytes. */
-int get_mode_align(const ir_mode *mode);
-
-/** Returns the signess of a mode */
-int get_mode_sign (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);
/** Returns the arithmetic of a mode */
-int get_mode_arithmetic (const ir_mode *mode);
+int get_mode_arithmetic(const ir_mode *mode);
-/** Attribute modulo shift specifies for modes of kind irms_int_number
+/** Get 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.
*/
-unsinged int get_mode_modulo_shift(const ir_mode *mode);
+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);
/** Returns the stored intermediate information. */
-void* get_mode_link(const ir_mode *mode);
+void *get_mode_link(const ir_mode *mode);
/** Stores new intermediate information. */
-void set_mode_link(ir_mode *mode, void *l);
+void set_mode_link(ir_mode *mode, void *l);
/**
* Returns the smallest representable value of a given mode.
*
* For modes of the sort float_number this is the most negative value
- * bigger than -infinit.
+ * bigger than -infinite.
*/
tarval *get_mode_min(ir_mode *mode);
* Returns the biggest representable value o f a given mode.
*
* For modes of the sort float_number this is the largest value lower
- * than infinit.
+ * than infinite.
*/
tarval *get_mode_max(ir_mode *mode);
*
* Zero is the additive neutral element and as such
* is defined only for modes allowing addition, i.e.
- * floats and ints, and references (NULL-Pointer)
+ * op_pin_state_floats and ints, and references (NULL-Pointer)
* else returns tarval_bad.
*/
tarval *get_mode_null(ir_mode *mode);
*/
tarval *get_mode_one(ir_mode *mode);
+/**
+ * Returns the value Minus One, represented in this 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);
+
/**
* Returns the positive infinite value of a mode.
*
extern ir_mode *mode_M; /**< memory */
-/* -- A set of predifined, numerical modes according to Techreport 1999-44 -- */
+/* -- 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; /**< unsigened 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_U; /**< 16 bit unicode char */
extern ir_mode *mode_P; /**< pointer */
-extern ir_mode *mode_P_mach; /**< A pointer mode that is set by the client of libfirm. This mode
- represents the pointer size of the target machine. Is initialized
+extern 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
+ represents the pointer size of the target machine data addresses. Is initialized
to mode_P. */
/* -- Auxiliary modes necessary for the Firm representation -- */
ir_mode *get_modeANY(void);
ir_mode *get_modeBAD(void);
-/** Returns the machine specific pointer mode. */
-ir_mode *get_modeP_mach(void);
+/** Returns the machine specific pointer mode for code addresses. */
+ir_mode *get_modeP_code(void);
+
+/** Returns the machine specific pointer mode for data addresses. */
+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);
/**
- * Sets the machine specific pointer mode.
+ * Sets the machine specific pointer mode for data addresses.
* If not set, the predefined mode mode_P will be used.
*/
-void set_modeP_mach(ir_mode *p);
+void set_modeP_data(ir_mode *p);
/**
Functions to check, whether a modecode is signed, float, int, character,
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_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);
/** Returns true if sm can be converted to lm without loss
according to firm definiton */
int smaller_mode(const ir_mode *sm, const ir_mode *lm);
-/** mode module initialization, call once before use of any other function **/
-void init_mode (void);
+/**
+ * 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);
+
+/**
+ * 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);
+
+/**
+ * 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);
+
+/**
+ * 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);
+
+/**
+ * Returns non-zero if the given mode might overflow on unary Minus.
+ */
+int mode_overflow_on_unary_Minus(const ir_mode *mode);
+
+/**
+ * Returns non-zero if the mode has a reversed wrap-aound
+ * logic, especially (a + x) - x == a.
+ * This is normally true for integer modes, not for floating
+ * point modes.
+ */
+int mode_wrap_around(const ir_mode *mode);
#endif /* _IRMODE_H_ */