/**
* Predefined mode according to tech report 1999-14.
*/
-typedef enum { /* irm is short for `ir mode' */
+typedef enum ir_modecode { /* irm is short for `ir mode' */
irm_BB, /**< basic block */
irm_X, /**< execution */
irm_F, /**< float(32) */
irm_T, /**< tuple */
irm_ANY, /**< undefined mode */
irm_BAD, /**< bad mode */
- irm_max /**< maximum value for modecode */
-} modecode;
+ irm_max /**< maximum value for ir_modecode */
+} ir_modecode;
/** These values represent the different mode classes of value representations.
*/
-typedef enum {
+typedef enum ir_mode_sort {
/* Predefined sorts of modes */
irms_auxiliary, /**< Only for Firm use. Not extensible. (irm_T) */
irms_control_flow, /**< Marks all control flow modes. Not extensible. (irm_BB, irm_X) */
Integer computations can be performed. */
irms_float_number, /**< A mode to represent float numbers.
Floating point computations can be performed. */
- irms_reference, /**< A mode to represent entities.
+ irms_reference /**< A mode to represent entities.
Restricted int computations can be performed */
-} mode_sort;
+} ir_mode_sort;
/** These values represent the different arithmetic operations possible with a mode.
Further arithmetics can be defined, e.g., for @@@ modes.
*/
-typedef enum {
+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. */
according to @@@ which standards??? Only legal for modes of
sort float_number. */
irma_max
-} mode_arithmetic;
+} 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 mode_sort of the mode to be created
+ * @param sort the ir_mode_sort of the mode to be created
* @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
* 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.
*/
-ir_mode *new_ir_mode(const char *name, mode_sort sort, int bit_size, int sign, mode_arithmetic arithmetic, unsigned int modulo_shift);
+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);
/**
* 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 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
* @return
* The new mode or NULL on error.
*/
-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);
+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);
/**
* Checks whether a pointer points to a mode.
/* ********** Access methods to read mode information *********** */
/** Returns the classification of the mode */
-modecode get_mode_modecode(const ir_mode *mode);
+ir_modecode get_mode_modecode(const ir_mode *mode);
/** Returns the ident* of the mode */
ident *get_mode_ident(const ir_mode *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);
+ir_mode_sort get_mode_sort(const ir_mode *mode);
/** Returns the size of values of the mode in bits. */
unsigned get_mode_size_bits(const ir_mode *mode);
int get_mode_sign(const ir_mode *mode);
/** Returns the arithmetic of a mode */
-mode_arithmetic get_mode_arithmetic(const ir_mode *mode);
+ir_mode_arithmetic get_mode_arithmetic(const ir_mode *mode);
/** Get the modulo shift attribute.
*
*/
void set_modeP_data(ir_mode *p);
+/*@{*/
/**
- Functions to check, whether a modecode is signed, float, int, character,
+ 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
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_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 definition */
+/**
+ * Returns true if sm can be converted to lm without loss
+ * according to firm definition.
+ *
+ * Note that mode_Iu is NOT smaller than mode_Is here.
+ *
+ * @see values_in_mode()
+ */
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.
+ *
+ * Note that mode_Iu values CAN be converted in mode_Is and back.
+ *
+ * @see smaller_mode()
+ */
+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.
*/
void set_reference_mode_unsigned_eq(ir_mode *ref_mode, ir_mode *int_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);
+
#endif
projects / libfirm / blobdiff