*
* @author Christian Schaefer, Matthias Heil
*
- * This module specifies the modes that type the firm nodes.
+ * 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.
* Contains relevant information about a mode.
*
* Neccessary information about a mode is stored in this struct
- * which is used by the tarval modul to perform calculations
+ * 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 for the mode
- * - ident *name: Name of this mode
+ * - modecode code: An unambigous 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
* - int size: size of the mode in Bits.
* - int align: byte alignment
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;
-/** These values represent the different arithmetics used to
- * manipulate values.
+/** These values represent the different mode classes of value representations.
*/
typedef enum {
/* Predefined sorts of modes */
- irms_auxiliary, /**< Only for Firm use, predefined. */
+ irms_auxiliary, /**< Only for Firm use. Not extensible. (irm_T) */
+ irms_control_flow, /**< Marks all control flow modes. Not extensible. (irm_BB, irm_X) */
+ irms_memory, /**< Marks the memory mode. Not extensible. (irm_M) */
irms_internal_boolean, /**< Internal boolean representation.
- Storing to memory impossible, convert first. */
- /** user-extensible sorts of modes **/
+ Storing to memory impossible, convert first. (irm_b) */
+ /** user-extensible sorts of modes **/
irms_int_number, /**< A mode to represent int numbers.
Integer computations can be performed. */
irms_float_number, /**< A mode to represent float numbers.
?? Are computations allowed? as int?? */
} mode_sort;
+/** These values represent the different arithmetic operations possible with a mode.
+ Further arithmetics can be defined, e.g., for @@@ modes.
+ */
+typedef enum {
+ 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
+ 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
+ sort float_number. */
+ irma_max
+} 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 teh 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
*
* This function constructs a new mode given by the parameters.
* If the parameters match an already defined mode, this mode is returned
* The new mode or NULL on error.
*
* @note
- * FIRM modes are unique independant of its name. So, you cannot expect
- * that the returned mode will have the mode name.
* It is allowed to construct the default modes. So, a call
- * new_ir_mode("Int", irms_int_number, 32, 4, 1) will return mode_Is.
+ * new_ir_mode("Is", irms_int_number, 32, 4, 1) will return mode_Is.
+ */
+ir_mode *new_ir_mode(const char *name, mode_sort sort, int bit_size, int align, int sign, mode_arithmetic arithmetic);
+
+/**
+ * Checks whether a pointer points to a mode.
+ *
+ * @param thing an arbitrary pointer
+ *
+ * @return
+ * true if the thing is a mode, else false
*/
-ir_mode *new_ir_mode(const char *name, mode_sort sort, int bit_size, int align, int sign);
+int is_mode (void *thing);
/* ********** Access methods to read mode information *********** */
/** Returns the classification of the mode */
-modecode get_mode_modecode(ir_mode *mode);
+modecode get_mode_modecode(const ir_mode *mode);
/** Returns the ident* of the mode */
-ident *get_mode_ident(ir_mode *mode);
+ident *get_mode_ident(const ir_mode *mode);
/** Returns the null-terminated name of this mode. */
-const char *get_mode_name(ir_mode *mode);
+const char *get_mode_name(const ir_mode *mode);
/** Returns a coarse classification of the mode. */
-mode_sort get_mode_sort(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(ir_mode *mode);
+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. */
-int get_mode_size_bytes(ir_mode *mode);
+int get_mode_size_bytes(const ir_mode *mode);
/** Returns the alignment of values of the mode in bytes. */
-int get_mode_align(ir_mode *mode);
+int get_mode_align(const ir_mode *mode);
/** Returns the signess of a mode */
-int get_mode_sign (ir_mode *mode);
+int get_mode_sign (const ir_mode *mode);
+
+/** Returns the arithmetic of a mode */
+int get_mode_arithmetic (const ir_mode *mode);
+
+/** Returns the stored intermediate information. */
+void* get_mode_link(const ir_mode *mode);
+
+/** Stores new intermediate information. */
+void set_mode_link(ir_mode *mode, void *l);
/**
* Returns the smallest representable value of a given mode.
*/
tarval *get_mode_NAN(ir_mode *mode);
-/* -- Auxiliary modes necessary for the Firm representation -- */
-extern ir_mode *mode_T; /**< tuple (none) */
-extern ir_mode *mode_X; /**< execution */
extern ir_mode *mode_M; /**< memory */
-extern ir_mode *mode_BB; /**< block */
/* -- A set of predifined, numerical modes according to Techreport 1999-44 -- */
extern ir_mode *mode_F; /**< signed float(32) */
extern ir_mode *mode_Ls; /**< signed long integer */
extern ir_mode *mode_Lu; /**< unsigned long integer */
-extern ir_mode *mode_b; /**< internal boolean */
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_mach; /**< A pointer mode that is set by the client of libfirm. This mode
+ represents the pointer size of the target machine. 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_modeT(void);
ir_mode *get_modeF(void);
ir_mode *get_modeD(void);
ir_mode *get_modeE(void);
ir_mode *get_modeP(void);
ir_mode *get_modeb(void);
ir_mode *get_modeX(void);
-ir_mode *get_modeM(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);
+
+/** Returns the machine specific pointer mode. */
+ir_mode *get_modeP_mach(void);
+
+/**
+ * Sets the machine specific pointer mode.
+ * If not set, the predefined mode mode_P will be used.
+ */
+void set_modeP_mach(ir_mode *p);
/**
- Functions to check, whether a modecode is signed, float, int, num, data,
- datab or dataM.
+ Functions to check, whether a modecode is signed, float, int, character,
+ reference, num, numP, data, datab or dataM.
For more exact definitions read the corresponding pages
- in the firm documentation or the followingenumeration
+ 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 "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 = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
- irm_Is, irm_Iu, irm_Ls, irm_Lu}
- = {float || int}
+ num = {float || int}
+
+ The set of "numP" is defined as:
+ numP = {float || int || reference}
The set of "data" is defined as:
- data = {irm_F, irm_D, irm_E irm_Bs, irm_Bu, irm_Hs, irm_Hu,
- irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P}
- = {num || irm_C || irm_P}
+ data = {num || character || reference}
The set of "datab" is defined as:
- datab = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
- irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_b}
- = {data || irm_b }
+ datab = {data || irm_b }
The set of "dataM" is defined as:
- dataM = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
- irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_M}
- = {data || irm_M}
+ dataM = {data || irm_M}
*/
/*@}*/
/* Test for a certain class of modes. */
-int mode_is_signed (ir_mode *mode);
-int mode_is_float (ir_mode *mode);
-int mode_is_int (ir_mode *mode);
-int mode_is_num (ir_mode *mode);
-int mode_is_data (ir_mode *mode);
-int mode_is_datab (ir_mode *mode);
-int mode_is_dataM (ir_mode *mode);
+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);
+
/** Returns true if sm can be converted to lm without loss
according to firm definiton */
-int smaller_mode(ir_mode *sm, ir_mode *lm);
+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);
projects / libfirm / blobdiff