X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firmode.c;h=79cc1c6271c3f618f0917c9706222f169095fd66;hb=637542932dc27dcdfc7def09b58d9d5d4c34fb77;hp=7c1c9a193da8e9c134fededce26d5a3385f8c263;hpb=9c561faae53d3d57e2e72b9b0679a2eda15f7377;p=libfirm diff --git a/ir/ir/irmode.c b/ir/ir/irmode.c index 7c1c9a193..79cc1c627 100644 --- a/ir/ir/irmode.c +++ b/ir/ir/irmode.c @@ -9,21 +9,24 @@ * Copyright: (c) 1998-2003 Universität Karlsruhe * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE. */ - - #ifdef HAVE_CONFIG_H -# include +# include "config.h" #endif +#ifdef HAVE_STDLIB_H # include -# include +#endif +#ifdef HAVE_STRING_H # include -# include +#endif + +# include # include "irmode_t.h" # include "ident.h" # include "tv.h" # include "obst.h" +# include "irhooks.h" #if 0 static long long count = 0; @@ -59,7 +62,6 @@ INLINE static int modes_are_equal(const ir_mode *m, const ir_mode *n) if (m->sort == n->sort && m->arithmetic == n->arithmetic && m->size == n->size && - m->align == n->align && m->sign == n->sign && m->modulo_shift == n->modulo_shift && m->vector_elem == n->vector_elem) @@ -224,16 +226,20 @@ INLINE ir_mode *get_modeANY(void) { ANNOUNCE(); return mode_ANY; } INLINE ir_mode *get_modeBAD(void) { ANNOUNCE(); return mode_BAD; } -ir_mode *get_modeP_mach(void) { ANNOUNCE(); return mode_P_mach; } -void set_modeP_mach(ir_mode *p) { +ir_mode *(get_modeP_mach)(void) { ANNOUNCE(); - assert(mode_is_reference(p)); - mode_P_mach = p; - } + return __get_modeP_mach(); +} + +void (set_modeP_mach)(ir_mode *p) { + ANNOUNCE(); + __set_modeP_mach(p); +} /** - * Registers a new mode if not defined yet, else returns - * the "equivalent" one. + * Registers a new mode. + * + * @param new_mode The new mode template. */ static ir_mode *register_mode(const ir_mode* new_mode) { @@ -246,7 +252,7 @@ static ir_mode *register_mode(const ir_mode* new_mode) mode = (ir_mode*)obstack_copy(&modes, new_mode, sizeof(ir_mode)); mode->kind = k_ir_mode; - if(num_modes>=irm_max) mode->code = num_modes; + if (num_modes >= irm_max) mode->code = num_modes; num_modes++; set_mode_values(mode); @@ -257,16 +263,15 @@ static ir_mode *register_mode(const ir_mode* new_mode) /* * Creates a new mode. */ -ir_mode *new_ir_mode(const char *name, mode_sort sort, int bit_size, int align, int sign, +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 mode_tmpl; - ir_mode *mode; + ir_mode *mode = NULL; mode_tmpl.name = new_id_from_str(name); mode_tmpl.sort = sort; mode_tmpl.size = bit_size; - mode_tmpl.align = align; mode_tmpl.sign = sign ? 1 : 0; mode_tmpl.modulo_shift = (mode_tmpl.sort == irms_int_number) ? modulo_shift : 0; mode_tmpl.vector_elem = 1; @@ -275,8 +280,8 @@ ir_mode *new_ir_mode(const char *name, mode_sort sort, int bit_size, int align, mode_tmpl.tv_priv = NULL; mode = find_mode(&mode_tmpl); - if (mode) - { + if (mode) { + hook_new_mode(&mode_tmpl, mode); return mode; } @@ -288,30 +293,30 @@ ir_mode *new_ir_mode(const char *name, mode_sort sort, int bit_size, int align, case irms_memory: case irms_internal_boolean: assert(0 && "internal modes cannot be user defined"); - return NULL; + break; case irms_float_number: case irms_int_number: case irms_reference: case irms_character: - return register_mode(&mode_tmpl); + mode = register_mode(&mode_tmpl); } - return NULL; /* to shut up gcc */ + hook_new_mode(&mode_tmpl, mode); + return mode; } /* * Creates a new vector mode. */ -ir_mode *new_ir_vector_mode(const char *name, mode_sort sort, int bit_size, unsigned num_of_elem, int align, int sign, +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 mode_tmpl; - ir_mode *mode; + ir_mode *mode = NULL; mode_tmpl.name = new_id_from_str(name); mode_tmpl.sort = sort; mode_tmpl.size = bit_size * num_of_elem; - mode_tmpl.align = align; mode_tmpl.sign = sign ? 1 : 0; mode_tmpl.modulo_shift = (mode_tmpl.sort == irms_int_number) ? modulo_shift : 0; mode_tmpl.vector_elem = num_of_elem; @@ -320,12 +325,15 @@ ir_mode *new_ir_vector_mode(const char *name, mode_sort sort, int bit_size, unsi mode_tmpl.tv_priv = NULL; mode = find_mode(&mode_tmpl); - if (mode) + if (mode) { + hook_new_mode(&mode_tmpl, mode); return mode; + } if (num_of_elem <= 1) { assert(0 && "vector modes should have at least 2 elements"); - return NULL; + hook_new_mode(&mode_tmpl, mode); + return mode; } /* sanity checks */ @@ -336,36 +344,37 @@ ir_mode *new_ir_vector_mode(const char *name, mode_sort sort, int bit_size, unsi case irms_memory: case irms_internal_boolean: assert(0 && "internal modes cannot be user defined"); - return NULL; + break; case irms_reference: case irms_character: assert(0 && "only integer and floating point modes can be vectorized"); - return NULL; + break; case irms_float_number: assert(0 && "not yet implemented"); - return NULL; + break; case irms_int_number: - return register_mode(&mode_tmpl); + mode = register_mode(&mode_tmpl); } - return NULL; /* to shut up gcc */ + hook_new_mode(&mode_tmpl, mode); + return mode; } /* Functions for the direct access to all attributes od a ir_mode */ modecode -get_mode_modecode(const ir_mode *mode) +(get_mode_modecode)(const ir_mode *mode) { ANNOUNCE(); - return mode->code; + return __get_mode_modecode(mode); } ident * -get_mode_ident(const ir_mode *mode) +(get_mode_ident)(const ir_mode *mode) { ANNOUNCE(); - return mode->name; + return __get_mode_ident(mode); } const char * @@ -376,44 +385,37 @@ get_mode_name(const ir_mode *mode) } mode_sort -get_mode_sort(const ir_mode* mode) +(get_mode_sort)(const ir_mode* mode) { ANNOUNCE(); - return mode->sort; + return __get_mode_sort(mode); } -INLINE int -get_mode_size_bits(const ir_mode *mode) +int +(get_mode_size_bits)(const ir_mode *mode) { ANNOUNCE(); - return mode->size; -} - -int get_mode_size_bytes(const ir_mode *mode) { - int size = get_mode_size_bits(mode); - ANNOUNCE(); - if ((size & 7) != 0) return -1; - return size >> 3; + return __get_mode_size_bits(mode); } int -get_mode_align (const ir_mode *mode) -{ +(get_mode_size_bytes)(const ir_mode *mode) { ANNOUNCE(); - return mode->align; + return __get_mode_size_bytes(mode); } int -get_mode_sign (const ir_mode *mode) +(get_mode_sign)(const ir_mode *mode) { ANNOUNCE(); - return mode->sign; + return __get_mode_sign(mode); } -int get_mode_arithmetic (const ir_mode *mode) +int +(get_mode_arithmetic)(const ir_mode *mode) { ANNOUNCE(); - return mode->arithmetic; + return get_mode_arithmetic(mode); } @@ -421,24 +423,27 @@ int get_mode_arithmetic (const ir_mode *mode) * whether shift applies modulo to value of bits to shift. Asserts * if mode is not irms_int_number. */ -unsigned int get_mode_modulo_shift(const ir_mode *mode) { - return mode->modulo_shift; +unsigned int +(get_mode_modulo_shift)(const ir_mode *mode) { + return __get_mode_modulo_shift(mode); } -unsigned int get_mode_vector_elems(const ir_mode *mode) { - return mode->vector_elem; +unsigned int +(get_mode_n_vector_elems)(const ir_mode *mode) { + return __get_mode_vector_elems(mode); } -void *get_mode_link(const ir_mode *mode) +void * +(get_mode_link)(const ir_mode *mode) { ANNOUNCE(); - return mode->link; + return __get_mode_link(mode); } -void set_mode_link(ir_mode *mode, void *l) +void +(set_mode_link)(ir_mode *mode, void *l) { - mode->link=l; - return; + __set_mode_link(mode, l); } tarval * @@ -493,7 +498,7 @@ get_mode_infinite(ir_mode *mode) assert(get_mode_modecode(mode) < num_modes); assert(mode_is_float(mode)); - return get_tarval_inf(mode); + return get_tarval_plus_inf(mode); } tarval * @@ -509,165 +514,84 @@ get_mode_NAN(ir_mode *mode) int is_mode (void *thing) { - assert(thing); if (get_kind(thing) == k_ir_mode) return 1; else return 0; } -/* Functions to check, whether a modecode is signed, float, int, num, data, - datab or dataM. For more exact definitions read the corresponding pages - in the firm documentation or the followingenumeration - - 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 "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} - - 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_U || irm_P} - - 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 } - - 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} -*/ - -#ifdef MODE_ACCESS_DEFINES -# undef mode_is_signed -# undef mode_is_float -# undef mode_is_int -# undef mode_is_num -# undef mode_is_numP -# undef mode_is_data -# undef mode_is_datab -# undef mode_is_dataM -#endif int -mode_is_signed (const ir_mode *mode) -{ +(mode_is_signed)(const ir_mode *mode) { ANNOUNCE(); - assert(mode); - return mode->sign; + return __mode_is_signed(mode); } int -mode_is_float (const ir_mode *mode) -{ +(mode_is_float)(const ir_mode *mode) { ANNOUNCE(); - assert(mode); - return (get_mode_sort(mode) == irms_float_number); + return __mode_is_float(mode); } int -mode_is_int (const ir_mode *mode) -{ +(mode_is_int)(const ir_mode *mode) { ANNOUNCE(); - assert(mode); - return (get_mode_sort(mode) == irms_int_number); + return __mode_is_int(mode); } -int mode_is_character (const ir_mode *mode) -{ +int +(mode_is_character)(const ir_mode *mode) { ANNOUNCE(); - assert(mode); - return (get_mode_sort(mode) == irms_character); + return __mode_is_character(mode); } -int mode_is_reference (const ir_mode *mode) -{ +int +(mode_is_reference)(const ir_mode *mode) { ANNOUNCE(); - assert(mode); - return (get_mode_sort(mode) == irms_reference); + return __mode_is_reference(mode); } int -mode_is_num (const ir_mode *mode) -{ +(mode_is_num)(const ir_mode *mode) { ANNOUNCE(); - assert(mode); - return (mode_is_int(mode) || mode_is_float(mode)); + return __mode_is_num(mode); } int -mode_is_numP (const ir_mode *mode) -{ +(mode_is_numP)(const ir_mode *mode) { ANNOUNCE(); - assert(mode); - return (mode_is_int(mode) || mode_is_float(mode) || mode_is_reference(mode)); + return __mode_is_numP(mode); } int -mode_is_data (const ir_mode *mode) -{ +(mode_is_data)(const ir_mode *mode) { ANNOUNCE(); - assert(mode); - return (mode_is_num(mode) || get_mode_sort(mode) == irms_character || get_mode_sort(mode) == irms_reference); + return __mode_is_data(mode); } int -mode_is_datab (const ir_mode *mode) -{ +(mode_is_datab)(const ir_mode *mode) { ANNOUNCE(); - assert(mode); - return (mode_is_data(mode) || get_mode_sort(mode) == irms_internal_boolean); + return __mode_is_datab(mode); } int -mode_is_dataM (const ir_mode *mode) -{ +(mode_is_dataM)(const ir_mode *mode) { ANNOUNCE(); - assert(mode); - return (mode_is_data(mode) || get_mode_modecode(mode) == irm_M); + return __mode_is_dataM(mode); } int -mode_is_float_vector (const ir_mode *mode) -{ +(mode_is_float_vector)(const ir_mode *mode) { ANNOUNCE(); - assert(mode); - return (get_mode_sort(mode) == irms_float_number) && (get_mode_vector_elems(mode) > 1); + return __mode_is_float_vector(mode); } int -mode_is_int_vector (const ir_mode *mode) -{ +(mode_is_int_vector)(const ir_mode *mode) { ANNOUNCE(); - assert(mode); - return (get_mode_sort(mode) == irms_int_number) && (get_mode_vector_elems(mode) > 1); -} - -#ifdef MODE_ACCESS_DEFINES -# define mode_is_signed(mode) (mode)->sign -# define mode_is_float(mode) ((mode)->sort == irms_float_number) -# define mode_is_int(mode) ((mode)->sort == irms_int_number) -# define mode_is_num(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number)) -# define mode_is_data(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number) || ((mode)->sort == irms_character) || ((mode)->sort == irms_reference)) -# define mode_is_datab(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number) || ((mode)->sort == irms_character) || ((mode)->sort == irms_reference) || ((mode)->sort == irms_internal_boolean)) -# define mode_is_dataM(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number) || ((mode)->sort == irms_character) || ((mode)->sort == irms_reference) || ((mode)->code == irm_M)) -# define mode_is_float_vector(mode) (((mode)->sort == irms_float_number) && ((mode)->vector_elem > 1)) -# define mode_is_int_vector(mode) (((mode)->sort == irms_int_number) && ((mode)->vector_elem > 1)) -#endif + return __mode_is_int_vector(mode); +} + /* Returns true if sm can be converted to lm without loss. */ int smaller_mode(const ir_mode *sm, const ir_mode *lm) @@ -744,7 +668,7 @@ smaller_mode(const ir_mode *sm, const ir_mode *lm) return 0; } -/* ** initialization ** */ +/* initialization, build the default modes */ void init_mode (void) { @@ -760,7 +684,6 @@ init_mode (void) /* Internal Modes */ newmode.arithmetic = irma_none; newmode.size = 0; - newmode.align = 0; newmode.sign = 0; newmode.modulo_shift = 0; newmode.vector_elem = 0; @@ -771,13 +694,13 @@ init_mode (void) newmode.sort = irms_control_flow; /* Basic Block */ - newmode.name = id_from_str("BB", 2); + newmode.name = new_id_from_chars("BB", 2); newmode.code = irm_BB; mode_BB = register_mode(&newmode); /* eXecution */ - newmode.name = id_from_str("X", 1); + newmode.name = new_id_from_chars("X", 1); newmode.code = irm_X; mode_X = register_mode(&newmode); @@ -786,7 +709,7 @@ init_mode (void) newmode.sort = irms_memory; /* Memory */ - newmode.name = id_from_str("M", 1); + newmode.name = new_id_from_chars("M", 1); newmode.code = irm_M; mode_M = register_mode(&newmode); @@ -795,19 +718,19 @@ init_mode (void) newmode.sort = irms_auxiliary, /* Tuple */ - newmode.name = id_from_str("T", 1); + newmode.name = new_id_from_chars("T", 1); newmode.code = irm_T; mode_T = register_mode(&newmode); /* ANY */ - newmode.name = id_from_str("ANY", 3); + newmode.name = new_id_from_chars("ANY", 3); newmode.code = irm_ANY; mode_ANY = register_mode(&newmode); /* BAD */ - newmode.name = id_from_str("BAD", 3); + newmode.name = new_id_from_chars("BAD", 3); newmode.code = irm_BAD; mode_BAD = register_mode(&newmode); @@ -816,7 +739,7 @@ init_mode (void) newmode.sort = irms_internal_boolean; /* boolean */ - newmode.name = id_from_str("b", 1); + newmode.name = new_id_from_chars("b", 1); newmode.code = irm_b; mode_b = register_mode(&newmode); @@ -825,141 +748,128 @@ init_mode (void) newmode.vector_elem = 1; /* Float Number Modes */ - newmode.sort = irms_float_number; + newmode.sort = irms_float_number; newmode.arithmetic = irma_ieee754; /* float */ - newmode.name = id_from_str("F", 1); + newmode.name = new_id_from_chars("F", 1); newmode.code = irm_F; newmode.sign = 1; - newmode.align = 4; newmode.size = 32; mode_F = register_mode(&newmode); /* double */ - newmode.name = id_from_str("D", 1); + newmode.name = new_id_from_chars("D", 1); newmode.code = irm_D; newmode.sign = 1; - newmode.align = 4; newmode.size = 64; mode_D = register_mode(&newmode); /* extended */ - newmode.name = id_from_str("E", 1); + newmode.name = new_id_from_chars("E", 1); newmode.code = irm_E; newmode.sign = 1; - newmode.align = 4; newmode.size = 80; mode_E = register_mode(&newmode); /* Integer Number Modes */ - newmode.sort = irms_int_number; - newmode.arithmetic = irma_twos_complement; + newmode.sort = irms_int_number; + newmode.arithmetic = irma_twos_complement; /* signed byte */ - newmode.name = id_from_str("Bs", 2); - newmode.code = irm_Bs; - newmode.sign = 1; - newmode.align = 1; - newmode.size = 8; + newmode.name = new_id_from_chars("Bs", 2); + newmode.code = irm_Bs; + newmode.sign = 1; + newmode.size = 8; newmode.modulo_shift = 32; mode_Bs = register_mode(&newmode); /* unsigned byte */ - newmode.name = id_from_str("Bu", 2); - newmode.code = irm_Bu; - newmode.arithmetic = irma_twos_complement; - newmode.sign = 0; - newmode.align = 1; - newmode.size = 8; + newmode.name = new_id_from_chars("Bu", 2); + newmode.code = irm_Bu; + newmode.arithmetic = irma_twos_complement; + newmode.sign = 0; + newmode.size = 8; newmode.modulo_shift = 32; mode_Bu = register_mode(&newmode); /* signed short integer */ - newmode.name = id_from_str("Hs", 2); - newmode.code = irm_Hs; - newmode.sign = 1; - newmode.align = 2; - newmode.size = 16; + newmode.name = new_id_from_chars("Hs", 2); + newmode.code = irm_Hs; + newmode.sign = 1; + newmode.size = 16; newmode.modulo_shift = 32; mode_Hs = register_mode(&newmode); /* unsigned short integer */ - newmode.name = id_from_str("Hu", 2); - newmode.code = irm_Hu; - newmode.sign = 0; - newmode.align = 2; - newmode.size = 16; + newmode.name = new_id_from_chars("Hu", 2); + newmode.code = irm_Hu; + newmode.sign = 0; + newmode.size = 16; newmode.modulo_shift = 32; mode_Hu = register_mode(&newmode); /* signed integer */ - newmode.name = id_from_str("Is", 2); - newmode.code = irm_Is; - newmode.sign = 1; - newmode.align = 4; - newmode.size = 32; + newmode.name = new_id_from_chars("Is", 2); + newmode.code = irm_Is; + newmode.sign = 1; + newmode.size = 32; newmode.modulo_shift = 32; mode_Is = register_mode(&newmode); /* unsigned integer */ - newmode.name = id_from_str("Iu", 2); - newmode.code = irm_Iu; - newmode.sign = 0; - newmode.align = 4; - newmode.size = 32; + newmode.name = new_id_from_chars("Iu", 2); + newmode.code = irm_Iu; + newmode.sign = 0; + newmode.size = 32; newmode.modulo_shift = 32; mode_Iu = register_mode(&newmode); /* signed long integer */ - newmode.name = id_from_str("Ls", 2); - newmode.code = irm_Ls; - newmode.sign = 1; - newmode.align = 4; - newmode.size = 64; + newmode.name = new_id_from_chars("Ls", 2); + newmode.code = irm_Ls; + newmode.sign = 1; + newmode.size = 64; newmode.modulo_shift = 64; mode_Ls = register_mode(&newmode); /* unsigned long integer */ - newmode.name = id_from_str("Lu", 2); - newmode.code = irm_Lu; - newmode.sign = 0; - newmode.align = 4; - newmode.size = 64; + newmode.name = new_id_from_chars("Lu", 2); + newmode.code = irm_Lu; + newmode.sign = 0; + newmode.size = 64; newmode.modulo_shift = 64; mode_Lu = register_mode(&newmode); /* Character Modes */ - newmode.sort = irms_character; - newmode.arithmetic = irma_none; + newmode.sort = irms_character; + newmode.arithmetic = irma_none; /* Character */ - newmode.name = id_from_str("C", 1); - newmode.code = irm_C; - newmode.sign = 0; - newmode.align = 1; - newmode.size = 8; + newmode.name = new_id_from_chars("C", 1); + newmode.code = irm_C; + newmode.sign = 0; + newmode.size = 8; newmode.modulo_shift = 32; mode_C = register_mode(&newmode); /* Unicode character */ - newmode.name = id_from_str("U", 1); - newmode.code = irm_U; - newmode.sign = 0; - newmode.align = 2; - newmode.size = 16; + newmode.name = new_id_from_chars("U", 1); + newmode.code = irm_U; + newmode.sign = 0; + newmode.size = 16; newmode.modulo_shift = 32; mode_U = register_mode(&newmode); @@ -969,11 +879,10 @@ init_mode (void) newmode.arithmetic = irma_twos_complement; /* pointer */ - newmode.name = id_from_str("P", 1); - newmode.code = irm_P; - newmode.sign = 0; - newmode.align = 4; - newmode.size = 32; + newmode.name = new_id_from_chars("P", 1); + newmode.code = irm_P; + newmode.sign = 0; + newmode.size = 32; newmode.modulo_shift = 0; mode_P = register_mode(&newmode); @@ -982,34 +891,87 @@ init_mode (void) mode_P_mach = mode_P; } +/* find a signed mode for an unsigned integer mode */ +ir_mode *find_unsigned_mode(const ir_mode *mode) { + ir_mode n = *mode; + + if (mode->sort != irms_int_number); + n.sign = 0; + return find_mode(&n); +} + +/* find an unsigned mode for a signed integer mode */ +ir_mode *find_signed_mode(const ir_mode *mode) { + ir_mode n = *mode; + + assert(mode->sort == irms_int_number); + n.sign = 1; + return find_mode(&n); +} + +/* finds a integer mode with 2*n bits for an integer mode with n bits. */ +ir_mode *find_double_bits_int_mode(const ir_mode *mode) { + ir_mode n = *mode; + + assert(mode->sort == irms_int_number && mode->arithmetic == irma_twos_complement); + + n.size = 2*mode->size; + return find_mode(&n); +} + +/* + * 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) +{ + /* for floating point, we know that IEEE 754 has +0 and -0, + * but always handles it identical. + */ + if (mode->sort == irms_float_number) + return mode->arithmetic == irma_ieee754 ? 0 : 1; + return 0; +} + +/* + * Returns non-zero if the given mode might overflow on unary Minus. + * + * This does NOT happen on IEEE 754. + */ +int mode_overflow_on_unary_Minus(const ir_mode *mode) +{ + if (mode->sort == irms_float_number) + return mode->arithmetic == irma_ieee754 ? 0 : 1; + return 1; +} void finish_mode(void) { obstack_free(&modes, 0); - mode_T = NULL; - mode_X = NULL; - mode_M = NULL; - mode_BB = NULL; + mode_T = NULL; + mode_X = NULL; + mode_M = NULL; + mode_BB = NULL; mode_ANY = NULL; mode_BAD = NULL; - mode_F = NULL; - mode_D = NULL; - mode_E = NULL; - - mode_Bs = NULL; - mode_Bu = NULL; - mode_Hs = NULL; - mode_Hu = NULL; - mode_Is = NULL; - mode_Iu = NULL; - mode_Ls = NULL; - mode_Lu = NULL; - - mode_C = NULL; - mode_U = NULL; - mode_b = NULL; - mode_P = NULL; + mode_F = NULL; + mode_D = NULL; + mode_E = NULL; + + mode_Bs = NULL; + mode_Bu = NULL; + mode_Hs = NULL; + mode_Hu = NULL; + mode_Is = NULL; + mode_Iu = NULL; + mode_Ls = NULL; + mode_Lu = NULL; + + mode_C = NULL; + mode_U = NULL; + mode_b = NULL; + mode_P = NULL; mode_P_mach = NULL; }