/*
- * Copyright (C) 1995-2007 University of Karlsruhe. All right reserved.
+ * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved.
*
* This file is part of libFirm.
*
irm_Lu, /**< unsigned long(64) */
irm_LLs, /**< signed long long(128) */
irm_LLu, /**< unsigned long long(128) */
- irm_C, /**< character */
irm_P, /**< pointer */
irm_b, /**< internal boolean */
irm_M, /**< memory */
irm_T, /**< tuple */
- irm_U, /**< unicode character */
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.
*/
Floating point computations can be performed. */
irms_reference, /**< A mode to represent entities.
Restricted int computations can be performed */
- irms_character /**< A mode to represent characters/symbols
- ?? Are computations allowed? as int?? */
-} 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.
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
- floatingpoint standard. Only legal for modes of sort float_number. */
+ 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
-} 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. */
-int get_mode_size_bits(const ir_mode *mode);
+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. */
-int get_mode_size_bytes(const ir_mode *mode);
+unsigned get_mode_size_bytes(const ir_mode *mode);
/** Returns the signess of a mode.
*
int get_mode_sign(const ir_mode *mode);
/** Returns the arithmetic of a mode */
-int get_mode_arithmetic(const ir_mode *mode);
+ir_mode_arithmetic get_mode_arithmetic(const ir_mode *mode);
/** Get the modulo shift attribute.
*
*/
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);
+
/**
* Returns the positive infinite value of a mode.
*
extern ir_mode *mode_LLs; /**< signed long long integer */
extern ir_mode *mode_LLu; /**< unsigned long long integer */
-extern ir_mode *mode_C; /**< 8 bit char */
-extern ir_mode *mode_U; /**< 16 bit unicode char */
-
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
represents the pointer size of the target machine code addresses. Is initialized
ir_mode *get_modeLu(void);
ir_mode *get_modeLLs(void);
ir_mode *get_modeLLu(void);
-ir_mode *get_modeC(void);
-ir_mode *get_modeU(void);
ir_mode *get_modeP(void);
ir_mode *get_modeb(void);
ir_mode *get_modeX(void);
void set_modeP_data(ir_mode *p);
/**
- Functions to check, whether a modecode is signed, float, int, character,
- reference, num, numP, data, datab or dataM.
+ 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 "int" is defined as:
int = {irm_Bs, irm_Bu, irm_Hs, irm_Hu, irm_Is, irm_Iu, irm_Ls, irm_Lu}
- The set of "character" is defined as:
- character = {irm_C, irm_U}
-
The set of "reference" is defined as:
reference = {irm_P}
The set of "num" is defined as:
num = {float || int}
- The set of "numP" is defined as:
- numP = {float || int || reference}
-
The set of "data" is defined as:
- data = {num || character || reference}
+ data = {num || reference}
The set of "datab" is defined as:
datab = {data || irm_b }
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_character (const ir_mode *mode);
int mode_is_reference (const ir_mode *mode);
int mode_is_num (const ir_mode *mode);
-int mode_is_numP (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_int_vector (const ir_mode *mode);
/** Returns true if sm can be converted to lm without loss
- according to firm definiton */
+ according to firm definition */
int smaller_mode(const ir_mode *sm, const ir_mode *lm);
/**
projects / libfirm / blobdiff