From: Michael Beck Date: Fri, 2 Feb 2007 16:27:57 +0000 (+0000) Subject: add signed and unsigned eq modes for reference modes X-Git-Url: http://nsz.repo.hu/git/?a=commitdiff_plain;h=60d444376e2653f52d36775d6f552eed7e621291;p=libfirm add signed and unsigned eq modes for reference modes [r8588] --- diff --git a/ir/ir/irmode.c b/ir/ir/irmode.c index d1b487bb9..6dfb28400 100644 --- a/ir/ir/irmode.c +++ b/ir/ir/irmode.c @@ -30,13 +30,6 @@ # include "irhooks.h" # include "irtools.h" -#if 0 -static long long count = 0; -# define ANNOUNCE() printf(__FILE__": call no. %lld (%s)\n", count++, __FUNCTION__) -#else -# define ANNOUNCE() ((void)0) -#endif - /* * * * local values * * */ @@ -58,31 +51,29 @@ static int num_modes; * * TODO: Add other fields **/ -INLINE static int modes_are_equal(const ir_mode *m, const ir_mode *n) -{ - if (m == n) return 1; - if (m->sort == n->sort && - m->arithmetic == n->arithmetic && - m->size == n->size && - m->sign == n->sign && - m->modulo_shift == n->modulo_shift && - m->vector_elem == n->vector_elem) - return 1; +INLINE static int modes_are_equal(const ir_mode *m, const ir_mode *n) { + if (m == n) return 1; + if (m->sort == n->sort && + m->arithmetic == n->arithmetic && + m->size == n->size && + m->sign == n->sign && + m->modulo_shift == n->modulo_shift && + m->vector_elem == n->vector_elem) + return 1; - return 0; + return 0; } /* * calculates the next obstack address */ -static void *next_obstack_adr(struct obstack *o, void *p, size_t s) -{ - PTR_INT_TYPE adr = PTR_TO_INT((char *)p); - int mask = obstack_alignment_mask(o); +static void *next_obstack_adr(struct obstack *o, void *p, size_t s) { + PTR_INT_TYPE adr = PTR_TO_INT((char *)p); + int mask = obstack_alignment_mask(o); - adr += s + mask; + adr += s + mask; - return INT_TO_PTR(adr & ~mask); + return INT_TO_PTR(adr & ~mask); } /** @@ -90,82 +81,79 @@ static void *next_obstack_adr(struct obstack *o, void *p, size_t s) * a pointer on an equal mode already in the array, NULL if * none found */ -static ir_mode *find_mode(const ir_mode *m) -{ - ir_mode *n, *nn; - struct _obstack_chunk *p; - - p = modes.chunk; - n = (ir_mode *)p->contents; - nn = next_obstack_adr(&modes, n, sizeof(*n)); - for (; (char *)nn <= modes.next_free;) { - assert(is_mode(n)); - if (modes_are_equal(n, m)) - return n; - - n = nn; - nn = next_obstack_adr(&modes, n, sizeof(*n)); - } - - for (p = p->prev; p; p = p->prev) { - n = (ir_mode *)p->contents; - nn = next_obstack_adr(&modes, n, sizeof(*n)); - for (; (char *)nn < p->limit;) { - assert(is_mode(n)); - if (modes_are_equal(n, m)) - return n; - - n = nn; - nn = next_obstack_adr(&modes, n, sizeof(*n)); - } - } - - return NULL; +static ir_mode *find_mode(const ir_mode *m) { + ir_mode *n, *nn; + struct _obstack_chunk *p; + + p = modes.chunk; + n = (ir_mode *)p->contents; + nn = next_obstack_adr(&modes, n, sizeof(*n)); + for (; (char *)nn <= modes.next_free;) { + assert(is_mode(n)); + if (modes_are_equal(n, m)) + return n; + + n = nn; + nn = next_obstack_adr(&modes, n, sizeof(*n)); + } + + for (p = p->prev; p; p = p->prev) { + n = (ir_mode *)p->contents; + nn = next_obstack_adr(&modes, n, sizeof(*n)); + for (; (char *)nn < p->limit;) { + assert(is_mode(n)); + if (modes_are_equal(n, m)) + return n; + + n = nn; + nn = next_obstack_adr(&modes, n, sizeof(*n)); + } + } + + return NULL; } /** * sets special values of modes */ -static void set_mode_values(ir_mode* mode) -{ - switch (get_mode_sort(mode)) - { - case irms_character: - case irms_int_number: - case irms_float_number: - mode->min = get_tarval_min(mode); - mode->max = get_tarval_max(mode); - mode->null = get_tarval_null(mode); - mode->one = get_tarval_one(mode); - mode->minus_one = get_tarval_minus_one(mode); - break; - - case irms_internal_boolean: - mode->min = tarval_b_false; - mode->max = tarval_b_true; - mode->null = tarval_b_false; - mode->one = tarval_b_true; - mode->minus_one = tarval_bad; - break; - - case irms_reference: - mode->min = tarval_bad; - mode->max = tarval_bad; - mode->null = get_tarval_null(mode); - mode->one = tarval_bad; - mode->minus_one = tarval_bad; - break; - - case irms_auxiliary: - case irms_memory: - case irms_control_flow: - mode->min = tarval_bad; - mode->max = tarval_bad; - mode->null = tarval_bad; - mode->one = tarval_bad; - mode->minus_one = tarval_bad; - break; - } +static void set_mode_values(ir_mode* mode) { + switch (get_mode_sort(mode)) { + case irms_character: + case irms_int_number: + case irms_float_number: + mode->min = get_tarval_min(mode); + mode->max = get_tarval_max(mode); + mode->null = get_tarval_null(mode); + mode->one = get_tarval_one(mode); + mode->minus_one = get_tarval_minus_one(mode); + break; + + case irms_internal_boolean: + mode->min = tarval_b_false; + mode->max = tarval_b_true; + mode->null = tarval_b_false; + mode->one = tarval_b_true; + mode->minus_one = tarval_bad; + break; + + case irms_reference: + mode->min = tarval_bad; + mode->max = tarval_bad; + mode->null = get_tarval_null(mode); + mode->one = tarval_bad; + mode->minus_one = tarval_bad; + break; + + case irms_auxiliary: + case irms_memory: + case irms_control_flow: + mode->min = tarval_bad; + mode->max = tarval_bad; + mode->null = tarval_bad; + mode->one = tarval_bad; + mode->minus_one = tarval_bad; + break; + } } /* * * @@ -202,57 +190,53 @@ ir_mode *mode_b; ir_mode *mode_P; /* machine specific modes */ -ir_mode *mode_P_code; /**< machine specific pointer mode for code addresses */ -ir_mode *mode_P_data; /**< machine specific pointer mode for data addresses */ +ir_mode *mode_P_code; /**< machine specific pointer mode for code addresses */ +ir_mode *mode_P_data; /**< machine specific pointer mode for data addresses */ /* * * * functions defined in irmode.h * * */ /* JNI access functions */ -ir_mode *get_modeT(void) { ANNOUNCE(); return mode_T; } -ir_mode *get_modeF(void) { ANNOUNCE(); return mode_F; } -ir_mode *get_modeD(void) { ANNOUNCE(); return mode_D; } -ir_mode *get_modeE(void) { ANNOUNCE(); return mode_E; } -ir_mode *get_modeBs(void) { ANNOUNCE(); return mode_Bs; } -ir_mode *get_modeBu(void) { ANNOUNCE(); return mode_Bu; } -ir_mode *get_modeHs(void) { ANNOUNCE(); return mode_Hs; } -ir_mode *get_modeHu(void) { ANNOUNCE(); return mode_Hu; } -ir_mode *get_modeIs(void) { ANNOUNCE(); return mode_Is; } -ir_mode *get_modeIu(void) { ANNOUNCE(); return mode_Iu; } -ir_mode *get_modeLs(void) { ANNOUNCE(); return mode_Ls; } -ir_mode *get_modeLu(void) { ANNOUNCE(); return mode_Lu; } -ir_mode *get_modeC(void) { ANNOUNCE(); return mode_C; } -ir_mode *get_modeU(void) { ANNOUNCE(); return mode_U; } -ir_mode *get_modeb(void) { ANNOUNCE(); return mode_b; } -ir_mode *get_modeP(void) { ANNOUNCE(); return mode_P; } -ir_mode *get_modeX(void) { ANNOUNCE(); return mode_X; } -ir_mode *get_modeM(void) { ANNOUNCE(); return mode_M; } -ir_mode *get_modeBB(void) { ANNOUNCE(); return mode_BB; } -ir_mode *get_modeANY(void) { ANNOUNCE(); return mode_ANY; } -ir_mode *get_modeBAD(void) { ANNOUNCE(); return mode_BAD; } +ir_mode *get_modeT(void) { return mode_T; } +ir_mode *get_modeF(void) { return mode_F; } +ir_mode *get_modeD(void) { return mode_D; } +ir_mode *get_modeE(void) { return mode_E; } +ir_mode *get_modeBs(void) { return mode_Bs; } +ir_mode *get_modeBu(void) { return mode_Bu; } +ir_mode *get_modeHs(void) { return mode_Hs; } +ir_mode *get_modeHu(void) { return mode_Hu; } +ir_mode *get_modeIs(void) { return mode_Is; } +ir_mode *get_modeIu(void) { return mode_Iu; } +ir_mode *get_modeLs(void) { return mode_Ls; } +ir_mode *get_modeLu(void) { return mode_Lu; } +ir_mode *get_modeC(void) { return mode_C; } +ir_mode *get_modeU(void) { return mode_U; } +ir_mode *get_modeb(void) { return mode_b; } +ir_mode *get_modeP(void) { return mode_P; } +ir_mode *get_modeX(void) { return mode_X; } +ir_mode *get_modeM(void) { return mode_M; } +ir_mode *get_modeBB(void) { return mode_BB; } +ir_mode *get_modeANY(void) { return mode_ANY; } +ir_mode *get_modeBAD(void) { return mode_BAD; } ir_mode *(get_modeP_code)(void) { - ANNOUNCE(); - return _get_modeP_code(); + return _get_modeP_code(); } ir_mode *(get_modeP_data)(void) { - ANNOUNCE(); - return _get_modeP_data(); + return _get_modeP_data(); } void set_modeP_code(ir_mode *p) { - assert(mode_is_reference(p)); - - mode_P_code = p; + assert(mode_is_reference(p)); + mode_P_code = p; } void set_modeP_data(ir_mode *p) { - assert(mode_is_reference(p)); - - mode_P_data = p; + assert(mode_is_reference(p)); + mode_P_data = p; } /** @@ -260,182 +244,163 @@ void set_modeP_data(ir_mode *p) { * * @param new_mode The new mode template. */ -static ir_mode *register_mode(const ir_mode *new_mode) -{ - ir_mode *mode = NULL; +static ir_mode *register_mode(const ir_mode *new_mode) { + ir_mode *mode = NULL; - ANNOUNCE(); - assert(new_mode); + assert(new_mode); - /* copy mode struct to modes array */ - mode = (ir_mode *)obstack_copy(&modes, new_mode, sizeof(*mode)); + /* copy mode struct to modes array */ + mode = (ir_mode *)obstack_copy(&modes, new_mode, sizeof(*mode)); - mode->kind = k_ir_mode; - if (num_modes >= irm_max) mode->code = num_modes; - num_modes++; + mode->kind = k_ir_mode; + if (num_modes >= irm_max) mode->code = num_modes; + num_modes++; - /* add the new mode to the irp list of modes */ - add_irp_mode(mode); + /* add the new mode to the irp list of modes */ + add_irp_mode(mode); - set_mode_values(mode); + set_mode_values(mode); - hook_new_mode(new_mode, mode); - return mode; + hook_new_mode(new_mode, mode); + return mode; } /* * Creates a new mode. */ ir_mode *new_ir_mode(const char *name, mode_sort sort, int bit_size, int sign, - mode_arithmetic arithmetic, unsigned int modulo_shift ) + mode_arithmetic arithmetic, unsigned int modulo_shift) { - ir_mode mode_tmpl; - ir_mode *mode = NULL; - - mode_tmpl.name = new_id_from_str(name); - mode_tmpl.sort = sort; - mode_tmpl.size = bit_size; - mode_tmpl.sign = sign ? 1 : 0; - mode_tmpl.modulo_shift = (mode_tmpl.sort == irms_int_number) ? modulo_shift : 0; - mode_tmpl.vector_elem = 1; - mode_tmpl.arithmetic = arithmetic; - mode_tmpl.link = NULL; - mode_tmpl.tv_priv = NULL; - - mode = find_mode(&mode_tmpl); - if (mode) { - hook_new_mode(&mode_tmpl, mode); - return mode; - } - - /* sanity checks */ - switch (sort) - { - case irms_auxiliary: - case irms_control_flow: - case irms_memory: - case irms_internal_boolean: - assert(0 && "internal modes cannot be user defined"); - break; - - case irms_float_number: - case irms_int_number: - case irms_reference: - case irms_character: - mode = register_mode(&mode_tmpl); - } - return mode; + ir_mode mode_tmpl; + ir_mode *mode = NULL; + + mode_tmpl.name = new_id_from_str(name); + mode_tmpl.sort = sort; + mode_tmpl.size = bit_size; + mode_tmpl.sign = sign ? 1 : 0; + mode_tmpl.modulo_shift = (mode_tmpl.sort == irms_int_number) ? modulo_shift : 0; + mode_tmpl.vector_elem = 1; + mode_tmpl.arithmetic = arithmetic; + mode_tmpl.link = NULL; + mode_tmpl.tv_priv = NULL; + + mode = find_mode(&mode_tmpl); + if (mode) { + hook_new_mode(&mode_tmpl, mode); + return mode; + } + + /* sanity checks */ + switch (sort) { + case irms_auxiliary: + case irms_control_flow: + case irms_memory: + case irms_internal_boolean: + assert(0 && "internal modes cannot be user defined"); + break; + + case irms_float_number: + case irms_int_number: + case irms_reference: + case irms_character: + mode = register_mode(&mode_tmpl); + } + 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 sign, - mode_arithmetic arithmetic, unsigned int modulo_shift ) + mode_arithmetic arithmetic, unsigned int modulo_shift) { - ir_mode mode_tmpl; - 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.sign = sign ? 1 : 0; - mode_tmpl.modulo_shift = (mode_tmpl.sort == irms_int_number) ? modulo_shift : 0; - mode_tmpl.vector_elem = num_of_elem; - mode_tmpl.arithmetic = arithmetic; - mode_tmpl.link = NULL; - mode_tmpl.tv_priv = NULL; - - mode = find_mode(&mode_tmpl); - 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; - } - - /* sanity checks */ - switch (sort) - { - case irms_auxiliary: - case irms_control_flow: - case irms_memory: - case irms_internal_boolean: - assert(0 && "internal modes cannot be user defined"); - break; - - case irms_reference: - case irms_character: - assert(0 && "only integer and floating point modes can be vectorized"); - break; - - case irms_float_number: - assert(0 && "not yet implemented"); - break; - - case irms_int_number: - mode = register_mode(&mode_tmpl); - } - return mode; + ir_mode mode_tmpl; + 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.sign = sign ? 1 : 0; + mode_tmpl.modulo_shift = (mode_tmpl.sort == irms_int_number) ? modulo_shift : 0; + mode_tmpl.vector_elem = num_of_elem; + mode_tmpl.arithmetic = arithmetic; + mode_tmpl.link = NULL; + mode_tmpl.tv_priv = NULL; + + mode = find_mode(&mode_tmpl); + 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; + } + + /* sanity checks */ + switch (sort) { + case irms_auxiliary: + case irms_control_flow: + case irms_memory: + case irms_internal_boolean: + assert(0 && "internal modes cannot be user defined"); + break; + + case irms_reference: + case irms_character: + assert(0 && "only integer and floating point modes can be vectorized"); + break; + + case irms_float_number: + assert(0 && "not yet implemented"); + break; + + case irms_int_number: + mode = register_mode(&mode_tmpl); + } + return mode; } /* Functions for the direct access to all attributes of an ir_mode */ modecode -(get_mode_modecode)(const ir_mode *mode) -{ - ANNOUNCE(); - return _get_mode_modecode(mode); +(get_mode_modecode)(const ir_mode *mode) { + return _get_mode_modecode(mode); } ident * -(get_mode_ident)(const ir_mode *mode) -{ - ANNOUNCE(); - return _get_mode_ident(mode); +(get_mode_ident)(const ir_mode *mode) { + return _get_mode_ident(mode); } const char * -get_mode_name(const ir_mode *mode) -{ - ANNOUNCE(); - return get_id_str(mode->name); +get_mode_name(const ir_mode *mode) { + return get_id_str(mode->name); } mode_sort -(get_mode_sort)(const ir_mode* mode) -{ - ANNOUNCE(); - return _get_mode_sort(mode); +(get_mode_sort)(const ir_mode* mode) { + return _get_mode_sort(mode); } int -(get_mode_size_bits)(const ir_mode *mode) -{ - ANNOUNCE(); - return _get_mode_size_bits(mode); +(get_mode_size_bits)(const ir_mode *mode) { + return _get_mode_size_bits(mode); } int (get_mode_size_bytes)(const ir_mode *mode) { - ANNOUNCE(); - return _get_mode_size_bytes(mode); + return _get_mode_size_bytes(mode); } int -(get_mode_sign)(const ir_mode *mode) -{ - ANNOUNCE(); - return _get_mode_sign(mode); +(get_mode_sign)(const ir_mode *mode) { + return _get_mode_sign(mode); } int -(get_mode_arithmetic)(const ir_mode *mode) -{ - ANNOUNCE(); - return get_mode_arithmetic(mode); +(get_mode_arithmetic)(const ir_mode *mode) { + return get_mode_arithmetic(mode); } @@ -445,523 +410,510 @@ int */ unsigned int (get_mode_modulo_shift)(const ir_mode *mode) { - return _get_mode_modulo_shift(mode); + return _get_mode_modulo_shift(mode); } unsigned int (get_mode_n_vector_elems)(const ir_mode *mode) { - return _get_mode_vector_elems(mode); + return _get_mode_vector_elems(mode); } void * -(get_mode_link)(const ir_mode *mode) -{ - ANNOUNCE(); - return _get_mode_link(mode); +(get_mode_link)(const ir_mode *mode) { + return _get_mode_link(mode); } void -(set_mode_link)(ir_mode *mode, void *l) -{ - _set_mode_link(mode, l); +(set_mode_link)(ir_mode *mode, void *l) { + _set_mode_link(mode, l); } tarval * -get_mode_min (ir_mode *mode) -{ - ANNOUNCE(); - assert(mode); - assert(get_mode_modecode(mode) < num_modes); - assert(mode_is_data(mode)); +get_mode_min(ir_mode *mode) { + assert(mode); + assert(get_mode_modecode(mode) < num_modes); + assert(mode_is_data(mode)); - return mode->min; + return mode->min; } tarval * -get_mode_max (ir_mode *mode) -{ - ANNOUNCE(); - assert(mode); - assert(get_mode_modecode(mode) < num_modes); - assert(mode_is_data(mode)); +get_mode_max(ir_mode *mode) { + assert(mode); + assert(get_mode_modecode(mode) < num_modes); + assert(mode_is_data(mode)); - return mode->max; + return mode->max; } tarval * -get_mode_null (ir_mode *mode) -{ - ANNOUNCE(); - assert(mode); - assert(get_mode_modecode(mode) < num_modes); - assert(mode_is_data(mode)); +get_mode_null(ir_mode *mode) { + assert(mode); + assert(get_mode_modecode(mode) < num_modes); + assert(mode_is_data(mode)); - return mode->null; + return mode->null; } tarval * -get_mode_one (ir_mode *mode) -{ - ANNOUNCE(); - assert(mode); - assert(get_mode_modecode(mode) < num_modes); - assert(mode_is_data(mode)); +get_mode_one(ir_mode *mode) { + assert(mode); + assert(get_mode_modecode(mode) < num_modes); + assert(mode_is_data(mode)); - return mode->one; + return mode->one; } tarval * -get_mode_minus_one (ir_mode *mode) -{ - ANNOUNCE(); - assert(mode); - assert(get_mode_modecode(mode) < num_modes); - assert(mode_is_data(mode)); +get_mode_minus_one(ir_mode *mode) { + assert(mode); + assert(get_mode_modecode(mode) < num_modes); + assert(mode_is_data(mode)); - return mode->minus_one; + return mode->minus_one; } tarval * -get_mode_infinite(ir_mode *mode) -{ - ANNOUNCE(); - assert(mode); - assert(get_mode_modecode(mode) < num_modes); - assert(mode_is_float(mode)); +get_mode_infinite(ir_mode *mode) { + assert(mode); + assert(get_mode_modecode(mode) < num_modes); + assert(mode_is_float(mode)); - return get_tarval_plus_inf(mode); + return get_tarval_plus_inf(mode); } tarval * -get_mode_NAN(ir_mode *mode) -{ - ANNOUNCE(); - assert(mode); - assert(get_mode_modecode(mode) < num_modes); - assert(mode_is_float(mode)); +get_mode_NAN(ir_mode *mode) { + assert(mode); + assert(get_mode_modecode(mode) < num_modes); + assert(mode_is_float(mode)); - return get_tarval_nan(mode); + return get_tarval_nan(mode); } int -is_mode (void *thing) { - if (get_kind(thing) == k_ir_mode) - return 1; - else - return 0; +is_mode(void *thing) { + if (get_kind(thing) == k_ir_mode) + return 1; + else + return 0; } int (mode_is_signed)(const ir_mode *mode) { - ANNOUNCE(); - return _mode_is_signed(mode); + return _mode_is_signed(mode); } int (mode_is_float)(const ir_mode *mode) { - ANNOUNCE(); - return _mode_is_float(mode); + return _mode_is_float(mode); } int (mode_is_int)(const ir_mode *mode) { - ANNOUNCE(); - return _mode_is_int(mode); + return _mode_is_int(mode); } int (mode_is_character)(const ir_mode *mode) { - ANNOUNCE(); - return _mode_is_character(mode); + return _mode_is_character(mode); } int (mode_is_reference)(const ir_mode *mode) { - ANNOUNCE(); - return _mode_is_reference(mode); + return _mode_is_reference(mode); } int (mode_is_num)(const ir_mode *mode) { - ANNOUNCE(); - return _mode_is_num(mode); + return _mode_is_num(mode); } int (mode_is_numP)(const ir_mode *mode) { - ANNOUNCE(); - return _mode_is_numP(mode); + return _mode_is_numP(mode); } int (mode_is_data)(const ir_mode *mode) { - ANNOUNCE(); - return _mode_is_data(mode); + return _mode_is_data(mode); } int (mode_is_datab)(const ir_mode *mode) { - ANNOUNCE(); - return _mode_is_datab(mode); + return _mode_is_datab(mode); } int (mode_is_dataM)(const ir_mode *mode) { - ANNOUNCE(); - return _mode_is_dataM(mode); + return _mode_is_dataM(mode); } int (mode_is_float_vector)(const ir_mode *mode) { - ANNOUNCE(); - return _mode_is_float_vector(mode); + return _mode_is_float_vector(mode); } int (mode_is_int_vector)(const ir_mode *mode) { - ANNOUNCE(); - return _mode_is_int_vector(mode); + 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) -{ - int sm_bits, lm_bits; - - ANNOUNCE(); - assert(sm); - assert(lm); - - if (sm == lm) return 1; - - sm_bits = get_mode_size_bits(sm); - lm_bits = get_mode_size_bits(lm); - - switch(get_mode_sort(sm)) - { - case irms_int_number: - switch(get_mode_sort(lm)) - { - case irms_int_number: - /* integers are convertable if - * - both have the same sign and lm is the larger one - * - lm is the signed one and is at least two bits larger - * (one for the sign, one for the highest bit of sm) - * - sm & lm are two_complement and lm has greater or equal number of bits - */ - if ( get_mode_arithmetic(sm) == get_mode_arithmetic(lm) - && get_mode_arithmetic(sm) == irma_twos_complement) { - return lm_bits >= sm_bits; - } - else if (mode_is_signed(sm)) - { - if ( mode_is_signed(lm) && (lm_bits >= sm_bits) ) - return 1; - } - else if (mode_is_signed(lm)) - { - if (lm_bits > sm_bits + 1) - return 1; - } - else if (lm_bits >= sm_bits) - { - return 1; - } - break; - - case irms_float_number: - /* int to float works if the float is large enough */ - return 0; - - default: - break; - } - break; - - case irms_float_number: - if (get_mode_arithmetic(sm) == get_mode_arithmetic(lm)) { - if ( (get_mode_sort(lm) == irms_float_number) - && (get_mode_size_bits(lm) >= get_mode_size_bits(sm)) ) - return 1; - } - break; - - case irms_reference: - /* do exist machines out there with different pointer lenghts ?*/ - return 0; - - default: - break; - } - - /* else */ - return 0; +smaller_mode(const ir_mode *sm, const ir_mode *lm) { + int sm_bits, lm_bits; + + assert(sm); + assert(lm); + + if (sm == lm) return 1; + + sm_bits = get_mode_size_bits(sm); + lm_bits = get_mode_size_bits(lm); + + switch (get_mode_sort(sm)) { + case irms_int_number: + switch (get_mode_sort(lm)) { + case irms_int_number: + /* integers are convertable if + * - both have the same sign and lm is the larger one + * - lm is the signed one and is at least two bits larger + * (one for the sign, one for the highest bit of sm) + * - sm & lm are two_complement and lm has greater or equal number of bits + */ + if ( get_mode_arithmetic(sm) == get_mode_arithmetic(lm) + && get_mode_arithmetic(sm) == irma_twos_complement) { + return lm_bits >= sm_bits; + } else if (mode_is_signed(sm)) { + if ( mode_is_signed(lm) && (lm_bits >= sm_bits) ) + return 1; + } else if (mode_is_signed(lm)) { + if (lm_bits > sm_bits + 1) + return 1; + } else if (lm_bits >= sm_bits) { + return 1; + } + break; + + case irms_float_number: + /* int to float works if the float is large enough */ + return 0; + + default: + break; + } + break; + + case irms_float_number: + if (get_mode_arithmetic(sm) == get_mode_arithmetic(lm)) { + if ( (get_mode_sort(lm) == irms_float_number) + && (get_mode_size_bits(lm) >= get_mode_size_bits(sm)) ) + return 1; + } + break; + + case irms_reference: + /* do exist machines out there with different pointer lenghts ?*/ + return 0; + + default: + break; + } + + /* else */ + return 0; +} + +/* Return the signed integer equivalent mode for an reference mode. */ +ir_mode *get_reference_mode_signed_eq(ir_mode *mode) { + assert(mode_is_reference(mode)); + return mode->eq_signed; +} + +/* Sets the signed integer equivalent mode for an reference mode. */ +void set_reference_mode_signed_eq(ir_mode *ref_mode, ir_mode *int_mode) { + assert(mode_is_reference(ref_mode)); + assert(mode_is_int(int_mode)); + ref_mode->eq_signed = int_mode; +} + +/* Return the unsigned integer equivalent mode for an reference mode. */ +ir_mode *get_reference_mode_unsigned_eq(ir_mode *mode) { + assert(mode_is_reference(mode)); + return mode->eq_unsigned; +} + +/* Sets the unsigned integer equivalent mode for an reference mode. */ +void set_reference_mode_unsigned_eq(ir_mode *ref_mode, ir_mode *int_mode) { + assert(mode_is_reference(ref_mode)); + assert(mode_is_int(int_mode)); + ref_mode->eq_unsigned = int_mode; } /* initialization, build the default modes */ void -init_mode (void) -{ - ir_mode newmode; - ANNOUNCE(); - /* init flexible array */ - - obstack_init(&modes); - - num_modes = 0; - /* initialize predefined modes */ - - /* Internal Modes */ - newmode.arithmetic = irma_none; - newmode.size = 0; - newmode.sign = 0; - newmode.modulo_shift = 0; - newmode.vector_elem = 0; - newmode.link = NULL; - newmode.tv_priv = NULL; +init_mode (void) { + ir_mode newmode; - /* Control Flow Modes*/ - newmode.sort = irms_control_flow; + obstack_init(&modes); - /* Basic Block */ - newmode.name = new_id_from_chars("BB", 2); - newmode.code = irm_BB; + num_modes = 0; + /* initialize predefined modes */ - mode_BB = register_mode(&newmode); + /* Internal Modes */ + newmode.arithmetic = irma_none; + newmode.size = 0; + newmode.sign = 0; + newmode.modulo_shift = 0; + newmode.vector_elem = 0; + newmode.eq_signed = NULL; + newmode.eq_unsigned = NULL; + newmode.link = NULL; + newmode.tv_priv = NULL; -/* eXecution */ - newmode.name = new_id_from_chars("X", 1); - newmode.code = irm_X; + /* Control Flow Modes*/ + newmode.sort = irms_control_flow; - mode_X = register_mode(&newmode); + /* Basic Block */ + newmode.name = new_id_from_chars("BB", 2); + newmode.code = irm_BB; - /* Memory Modes */ - newmode.sort = irms_memory; + mode_BB = register_mode(&newmode); - /* Memory */ - newmode.name = new_id_from_chars("M", 1); - newmode.code = irm_M; + /* eXecution */ + newmode.name = new_id_from_chars("X", 1); + newmode.code = irm_X; - mode_M = register_mode(&newmode); + mode_X = register_mode(&newmode); - /* Auxiliary Modes */ - newmode.sort = irms_auxiliary, + /* Memory Modes */ + newmode.sort = irms_memory; - /* Tuple */ - newmode.name = new_id_from_chars("T", 1); - newmode.code = irm_T; + /* Memory */ + newmode.name = new_id_from_chars("M", 1); + newmode.code = irm_M; - mode_T = register_mode(&newmode); + mode_M = register_mode(&newmode); - /* ANY */ - newmode.name = new_id_from_chars("ANY", 3); - newmode.code = irm_ANY; + /* Auxiliary Modes */ + newmode.sort = irms_auxiliary, - mode_ANY = register_mode(&newmode); + /* Tuple */ + newmode.name = new_id_from_chars("T", 1); + newmode.code = irm_T; - /* BAD */ - newmode.name = new_id_from_chars("BAD", 3); - newmode.code = irm_BAD; + mode_T = register_mode(&newmode); - mode_BAD = register_mode(&newmode); + /* ANY */ + newmode.name = new_id_from_chars("ANY", 3); + newmode.code = irm_ANY; - /* Internal Boolean Modes */ - newmode.sort = irms_internal_boolean; + mode_ANY = register_mode(&newmode); - /* boolean */ - newmode.name = new_id_from_chars("b", 1); - newmode.code = irm_b; + /* BAD */ + newmode.name = new_id_from_chars("BAD", 3); + newmode.code = irm_BAD; - mode_b = register_mode(&newmode); + mode_BAD = register_mode(&newmode); -/* Data Modes */ - newmode.vector_elem = 1; + /* Internal Boolean Modes */ + newmode.sort = irms_internal_boolean; - /* Float Number Modes */ - newmode.sort = irms_float_number; - newmode.arithmetic = irma_ieee754; + /* boolean */ + newmode.name = new_id_from_chars("b", 1); + newmode.code = irm_b; - /* float */ - newmode.name = new_id_from_chars("F", 1); - newmode.code = irm_F; - newmode.sign = 1; - newmode.size = 32; + mode_b = register_mode(&newmode); - mode_F = register_mode(&newmode); + /* Data Modes */ + newmode.vector_elem = 1; - /* double */ - newmode.name = new_id_from_chars("D", 1); - newmode.code = irm_D; - newmode.sign = 1; - newmode.size = 64; + /* Float Number Modes */ + newmode.sort = irms_float_number; + newmode.arithmetic = irma_ieee754; - mode_D = register_mode(&newmode); + /* float */ + newmode.name = new_id_from_chars("F", 1); + newmode.code = irm_F; + newmode.sign = 1; + newmode.size = 32; - /* extended */ - newmode.name = new_id_from_chars("E", 1); - newmode.code = irm_E; - newmode.sign = 1; - newmode.size = 80; + mode_F = register_mode(&newmode); - mode_E = register_mode(&newmode); + /* double */ + newmode.name = new_id_from_chars("D", 1); + newmode.code = irm_D; + newmode.sign = 1; + newmode.size = 64; - /* Integer Number Modes */ - newmode.sort = irms_int_number; - newmode.arithmetic = irma_twos_complement; + mode_D = register_mode(&newmode); - /* signed byte */ - newmode.name = new_id_from_chars("Bs", 2); - newmode.code = irm_Bs; - newmode.sign = 1; - newmode.size = 8; - newmode.modulo_shift = 32; + /* extended */ + newmode.name = new_id_from_chars("E", 1); + newmode.code = irm_E; + newmode.sign = 1; + newmode.size = 80; - mode_Bs = register_mode(&newmode); + mode_E = register_mode(&newmode); - /* unsigned byte */ - 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; + /* Integer Number Modes */ + newmode.sort = irms_int_number; + newmode.arithmetic = irma_twos_complement; - mode_Bu = register_mode(&newmode); + /* signed byte */ + newmode.name = new_id_from_chars("Bs", 2); + newmode.code = irm_Bs; + newmode.sign = 1; + newmode.size = 8; + newmode.modulo_shift = 32; - /* signed short integer */ - newmode.name = new_id_from_chars("Hs", 2); - newmode.code = irm_Hs; - newmode.sign = 1; - newmode.size = 16; - newmode.modulo_shift = 32; + mode_Bs = register_mode(&newmode); - mode_Hs = register_mode(&newmode); + /* unsigned byte */ + 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; - /* unsigned short integer */ - newmode.name = new_id_from_chars("Hu", 2); - newmode.code = irm_Hu; - newmode.sign = 0; - newmode.size = 16; - newmode.modulo_shift = 32; + mode_Bu = register_mode(&newmode); - mode_Hu = register_mode(&newmode); + /* signed short integer */ + newmode.name = new_id_from_chars("Hs", 2); + newmode.code = irm_Hs; + newmode.sign = 1; + newmode.size = 16; + newmode.modulo_shift = 32; - /* signed integer */ - newmode.name = new_id_from_chars("Is", 2); - newmode.code = irm_Is; - newmode.sign = 1; - newmode.size = 32; - newmode.modulo_shift = 32; + mode_Hs = register_mode(&newmode); - mode_Is = register_mode(&newmode); + /* unsigned short integer */ + newmode.name = new_id_from_chars("Hu", 2); + newmode.code = irm_Hu; + newmode.sign = 0; + newmode.size = 16; + newmode.modulo_shift = 32; - /* unsigned integer */ - newmode.name = new_id_from_chars("Iu", 2); - newmode.code = irm_Iu; - newmode.sign = 0; - newmode.size = 32; - newmode.modulo_shift = 32; + mode_Hu = register_mode(&newmode); - mode_Iu = register_mode(&newmode); + /* signed integer */ + newmode.name = new_id_from_chars("Is", 2); + newmode.code = irm_Is; + newmode.sign = 1; + newmode.size = 32; + newmode.modulo_shift = 32; - /* signed long integer */ - newmode.name = new_id_from_chars("Ls", 2); - newmode.code = irm_Ls; - newmode.sign = 1; - newmode.size = 64; - newmode.modulo_shift = 64; + mode_Is = register_mode(&newmode); - mode_Ls = register_mode(&newmode); - - /* unsigned long integer */ - 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_twos_complement; - newmode.modulo_shift = 0; + /* unsigned integer */ + newmode.name = new_id_from_chars("Iu", 2); + newmode.code = irm_Iu; + newmode.sign = 0; + newmode.size = 32; + newmode.modulo_shift = 32; - /* Character */ - newmode.name = new_id_from_chars("C", 1); - newmode.code = irm_C; - newmode.sign = 0; - newmode.size = 8; - - mode_C = register_mode(&newmode); - - /* Unicode character */ - newmode.name = new_id_from_chars("U", 1); - newmode.code = irm_U; - newmode.sign = 0; - newmode.size = 16; - - mode_U = register_mode(&newmode); - - /* Reference Modes */ - newmode.sort = irms_reference; - newmode.arithmetic = irma_twos_complement; - - /* pointer */ - 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); - - /* set the machine specific modes to the predefined ones */ - mode_P_code = mode_P; - mode_P_data = mode_P; + mode_Iu = register_mode(&newmode); + + /* signed long integer */ + 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 = 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_twos_complement; + newmode.modulo_shift = 0; + + /* Character */ + newmode.name = new_id_from_chars("C", 1); + newmode.code = irm_C; + newmode.sign = 0; + newmode.size = 8; + + mode_C = register_mode(&newmode); + + /* Unicode character */ + newmode.name = new_id_from_chars("U", 1); + newmode.code = irm_U; + newmode.sign = 0; + newmode.size = 16; + + mode_U = register_mode(&newmode); + + /* Reference Modes */ + newmode.sort = irms_reference; + newmode.arithmetic = irma_twos_complement; + + /* pointer */ + newmode.name = new_id_from_chars("P", 1); + newmode.code = irm_P; + newmode.sign = 0; + newmode.size = 32; + newmode.modulo_shift = 0; + newmode.eq_signed = mode_Is; + newmode.eq_unsigned = mode_Iu; + + mode_P = register_mode(&newmode); + + /* set the machine specific modes to the predefined ones */ + mode_P_code = mode_P; + mode_P_data = mode_P; } /* find a signed mode for an unsigned integer mode */ ir_mode *find_unsigned_mode(const ir_mode *mode) { - ir_mode n = *mode; + ir_mode n = *mode; - if (mode->sort != irms_int_number); - n.sign = 0; - return find_mode(&n); + assert(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; + ir_mode n = *mode; - assert(mode->sort == irms_int_number); - n.sign = 1; - return find_mode(&n); + 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; + ir_mode n = *mode; - assert(mode->sort == irms_int_number && mode->arithmetic == irma_twos_complement); + assert(mode->sort == irms_int_number && mode->arithmetic == irma_twos_complement); - n.size = 2*mode->size; - return find_mode(&n); + 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; +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; } /* @@ -969,53 +921,52 @@ int mode_honor_signed_zeros(const ir_mode *mode) * * 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; +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; } /* - * Returns non-zero if the mode has a reversed wrap-aound + * Returns non-zero if the mode has a reversed wrap-around * 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) { - /* FIXME: better would be an extra mode property */ - return mode_is_int(mode); + /* FIXME: better would be an extra mode property */ + return mode_is_int(mode); } void finish_mode(void) { - obstack_free(&modes, 0); - - 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_P_code = NULL; - mode_P_data = NULL; + obstack_free(&modes, 0); + + 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_P_code = NULL; + mode_P_data = NULL; } diff --git a/ir/ir/irmode.h b/ir/ir/irmode.h index a23872964..cbf257355 100644 --- a/ir/ir/irmode.h +++ b/ir/ir/irmode.h @@ -3,10 +3,10 @@ * File name: ir/ir/irmode.h * Purpose: Data modes of operations. * Author: Martin Trapp, Christian Schaefer - * Modified by: Goetz Lindenmaier, Mathias Heil + * Modified by: Goetz Lindenmaier, Mathias Heil, Michael Beck * Created: * CVS-ID: $Id$ - * Copyright: (c) 1998-2003 Universität Karlsruhe + * Copyright: (c) 1998-2007 Universität Karlsruhe * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE. */ @@ -64,70 +64,69 @@ typedef struct ir_mode ir_mode; * Predefined mode according to tech report 1999-14. */ typedef enum { /* irm is short for `ir mode' */ - irm_BB, /**< basic block */ - irm_X, /**< execution */ - irm_F, /**< float(32) */ - irm_D, /**< double(64) */ - irm_E, /**< extended(80) */ - irm_Bs, /**< signed byte(8) */ - irm_Bu, /**< unsigned byte(8) */ - irm_Hs, /**< signed short(16) */ - irm_Hu, /**< unsigned short(16) */ - irm_Is, /**< signed int(32) */ - irm_Iu, /**< unsigned int(32) */ - irm_Ls, /**< signed long(64) */ - irm_Lu, /**< unsigned long(64) */ - 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 */ + irm_BB, /**< basic block */ + irm_X, /**< execution */ + irm_F, /**< float(32) */ + irm_D, /**< double(64) */ + irm_E, /**< extended(80) */ + irm_Bs, /**< signed byte(8) */ + irm_Bu, /**< unsigned byte(8) */ + irm_Hs, /**< signed short(16) */ + irm_Hu, /**< unsigned short(16) */ + irm_Is, /**< signed int(32) */ + irm_Iu, /**< unsigned int(32) */ + irm_Ls, /**< signed long(64) */ + irm_Lu, /**< unsigned long(64) */ + 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; /** These values represent the different mode classes of value representations. */ typedef enum { - /* 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) */ - irms_memory, /**< Marks the memory mode. Not extensible. (irm_M) */ - irms_internal_boolean, /**< Internal boolean representation. - 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. - 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?? */ + /* 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) */ + irms_memory, /**< Marks the memory mode. Not extensible. (irm_M) */ + irms_internal_boolean, /**< Internal boolean representation. + 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. + 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; /** 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 standards??? Only legal for modes of - sort float_number. */ - irma_max + 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 standards??? Only legal for modes of + sort float_number. */ + irma_max } mode_arithmetic; @@ -135,10 +134,10 @@ typedef enum { /** * 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 bit_size number of bits this mode allocate - * @param sign non-zero if this is a signed 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 this mode allocate + * @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. * @@ -150,22 +149,22 @@ typedef enum { * min, max and can be retrieved using the get_mode_* functions * * @return - * The new mode or NULL on error. + * 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, 1, irma_twos_complement, 32) will return mode_Is. + * 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); /** * 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 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 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. * @@ -176,18 +175,18 @@ ir_mode *new_ir_mode(const char *name, mode_sort sort, int bit_size, int sign, m * min, max and can be retrieved using the get_mode_* functions * * @return - * The new mode or NULL on error. + * 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 ); + mode_arithmetic arithmetic, unsigned int modulo_shift); /** - * Checks whether a pointer points to a mode. + * Checks whether a pointer points to a mode. * - * @param thing an arbitrary pointer + * @param thing an arbitrary pointer * - * @return - * true if the thing is a mode, else false + * @return + * true if the thing is a mode, else false */ int is_mode(void *thing); @@ -321,11 +320,11 @@ 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 - to mode_P. */ + 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. */ + represents the pointer size of the target machine data addresses. Is initialized + to mode_P. */ /* -- Auxiliary modes necessary for the Firm representation -- */ extern ir_mode *mode_b; /**< internal boolean */ @@ -464,11 +463,31 @@ int mode_honor_signed_zeros(const ir_mode *mode); int mode_overflow_on_unary_Minus(const ir_mode *mode); /** - * Returns non-zero if the mode has a reversed wrap-aound + * Returns non-zero if the mode has a reversed wrap-around * 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); +/** + * Return the signed integer equivalent mode for an reference mode. + */ +ir_mode *get_reference_mode_signed_eq(ir_mode *mode); + +/** + * Sets the signed integer equivalent mode for an reference mode. + */ +void set_reference_mode_signed_eq(ir_mode *ref_mode, ir_mode *int_mode); + +/** + * Return the unsigned integer equivalent mode for an reference mode. + */ +ir_mode *get_reference_mode_unsigned_eq(ir_mode *mode); + +/** + * Sets the unsigned integer equivalent mode for an reference mode. + */ +void set_reference_mode_unsigned_eq(ir_mode *ref_mode, ir_mode *int_mode); + #endif /* _FIRM_IR_IRMODE_H_ */ diff --git a/ir/ir/irmode_t.h b/ir/ir/irmode_t.h index 720c34260..ac5f5412b 100644 --- a/ir/ir/irmode_t.h +++ b/ir/ir/irmode_t.h @@ -3,10 +3,10 @@ * File name: ir/ir/irmode_t.h * Purpose: Data modes of operations -- private header. * Author: Martin Trapp, Christian Schaefer - * Modified by: Goetz Lindenmaier, Mathias Heil + * Modified by: Goetz Lindenmaier, Mathias Heil, Michael Beck * Created: * CVS-ID: $Id$ - * Copyright: (c) 1998-2003 Universität Karlsruhe + * Copyright: (c) 1998-2007 Universität Karlsruhe * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE. */ @@ -14,41 +14,42 @@ /** * @file irmode_t.h */ +#ifndef _IRMODE_T_H_ +#define _IRMODE_T_H_ -# ifndef _IRMODE_T_H_ -# define _IRMODE_T_H_ - -# include -# include "irmode.h" -# include "tv.h" +#include +#include "irmode.h" +#include "tv.h" /** This struct is supposed to completely define a mode. **/ struct ir_mode { - firm_kind kind; /**< distinguishes this node from others */ - modecode code; /**< unambiguous identifier of a mode */ - ident *name; /**< Name ident of this mode */ - - /* ----------------------------------------------------------------------- */ - /* On changing this struct you have to evaluate the mode_are_equal function!*/ - mode_sort sort; /**< coarse classification of this mode: - int, float, reference ... - (see irmode.h) */ - mode_arithmetic arithmetic; /**< different arithmetic operations possible with a mode */ - int size; /**< size of the mode in Bits. */ - unsigned sign:1; /**< signedness of this mode */ - unsigned int modulo_shift; /**< number of bits a values of this mode will be shifted */ - unsigned vector_elem; /**< if this is not equal 1, this is a vector mode with - vector_elem number of elements, size contains the size - of all bits and must be dividable by vector_elem */ - - /* ----------------------------------------------------------------------- */ - tarval *min; /**< the minimum value that can be expressed */ - tarval *max; /**< the maximum value that can be expressed */ - tarval *null; /**< the value 0 */ - tarval *one; /**< the value 1 */ - tarval *minus_one; /**< the value -1 */ - void *link; /**< To store some intermediate information */ - const void *tv_priv; /**< tarval module will save private data here */ + firm_kind kind; /**< distinguishes this node from others */ + modecode code; /**< unambiguous identifier of a mode */ + ident *name; /**< Name ident of this mode */ + + /* ----------------------------------------------------------------------- */ + /* On changing this struct you have to evaluate the mode_are_equal function!*/ + mode_sort sort; /**< coarse classification of this mode: + int, float, reference ... + (see irmode.h) */ + mode_arithmetic arithmetic; /**< different arithmetic operations possible with a mode */ + int size; /**< size of the mode in Bits. */ + unsigned sign:1; /**< signedness of this mode */ + unsigned int modulo_shift; /**< number of bits a values of this mode will be shifted */ + unsigned vector_elem; /**< if this is not equal 1, this is a vector mode with + vector_elem number of elements, size contains the size + of all bits and must be dividable by vector_elem */ + + /* ----------------------------------------------------------------------- */ + tarval *min; /**< the minimum value that can be expressed */ + tarval *max; /**< the maximum value that can be expressed */ + tarval *null; /**< the value 0 */ + tarval *one; /**< the value 1 */ + tarval *minus_one; /**< the value -1 */ + ir_mode *eq_signed; /**< For pointer modes, the equivalent signed integer one. */ + ir_mode *eq_unsigned; /**< For pointer modes, the equivalent unsigned integer one. */ + void *link; /**< To store some intermediate information */ + const void *tv_priv; /**< tarval module will save private data here */ }; @@ -77,9 +78,9 @@ _get_mode_size_bits(const ir_mode *mode) { return mode->size; } static INLINE int _get_mode_size_bytes(const ir_mode *mode) { - int size = _get_mode_size_bits(mode); - if ((size & 7) != 0) return -1; - return size >> 3; + int size = _get_mode_size_bits(mode); + if ((size & 7) != 0) return -1; + return size >> 3; } static INLINE int @@ -139,74 +140,74 @@ _set_mode_link(ir_mode *mode, void *l) { mode->link = l; } static INLINE int _mode_is_signed(const ir_mode *mode) { - assert(mode); - return mode->sign; + assert(mode); + return mode->sign; } static INLINE int _mode_is_float(const ir_mode *mode) { - assert(mode); - return (_get_mode_sort(mode) == irms_float_number); + assert(mode); + return (_get_mode_sort(mode) == irms_float_number); } static INLINE int _mode_is_int(const ir_mode *mode) { - assert(mode); - return (_get_mode_sort(mode) == irms_int_number); + assert(mode); + return (_get_mode_sort(mode) == irms_int_number); } static INLINE int _mode_is_character(const ir_mode *mode) { - assert(mode); - return (_get_mode_sort(mode) == irms_character); + assert(mode); + return (_get_mode_sort(mode) == irms_character); } static INLINE int _mode_is_reference(const ir_mode *mode) { - assert(mode); - return (_get_mode_sort(mode) == irms_reference); + assert(mode); + return (_get_mode_sort(mode) == irms_reference); } static INLINE int _mode_is_num(const ir_mode *mode) { - assert(mode); - return (_mode_is_int(mode) || _mode_is_float(mode)); + assert(mode); + return (_mode_is_int(mode) || _mode_is_float(mode)); } static INLINE int _mode_is_numP(const ir_mode *mode) { - assert(mode); - return (_mode_is_int(mode) || _mode_is_float(mode) || _mode_is_reference(mode)); + assert(mode); + return (_mode_is_int(mode) || _mode_is_float(mode) || _mode_is_reference(mode)); } static INLINE int _mode_is_data(const ir_mode *mode) { - assert(mode); - return (_mode_is_num(mode) || _get_mode_sort(mode) == irms_character || _get_mode_sort(mode) == irms_reference); + assert(mode); + return (_mode_is_num(mode) || _get_mode_sort(mode) == irms_character || _get_mode_sort(mode) == irms_reference); } static INLINE int _mode_is_datab(const ir_mode *mode) { - assert(mode); - return (_mode_is_data(mode) || _get_mode_sort(mode) == irms_internal_boolean); + assert(mode); + return (_mode_is_data(mode) || _get_mode_sort(mode) == irms_internal_boolean); } static INLINE int _mode_is_dataM(const ir_mode *mode) { - assert(mode); - return (_mode_is_data(mode) || _get_mode_modecode(mode) == irm_M); + assert(mode); + return (_mode_is_data(mode) || _get_mode_modecode(mode) == irm_M); } static INLINE int _mode_is_float_vector(const ir_mode *mode) { - assert(mode); - return (_get_mode_sort(mode) == irms_float_number) && (_get_mode_vector_elems(mode) > 1); + assert(mode); + return (_get_mode_sort(mode) == irms_float_number) && (_get_mode_vector_elems(mode) > 1); } static INLINE int _mode_is_int_vector(const ir_mode *mode) { - assert(mode); - return (_get_mode_sort(mode) == irms_int_number) && (_get_mode_vector_elems(mode) > 1); + assert(mode); + return (_get_mode_sort(mode) == irms_int_number) && (_get_mode_vector_elems(mode) > 1); } /** mode module initialization, call once before use of any other function **/