X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firmode.c;h=d926e90c4c035af4b33cc253f7fdae8efbe2087b;hb=e570f00fb465d212dde403160e97ab45d36d1d7e;hp=69a26e69d69153346a40b2e3e2864dc07234f4db;hpb=920031da93cfdffb8a3cffafbe7b240ae481dd03;p=libfirm diff --git a/ir/ir/irmode.c b/ir/ir/irmode.c index 69a26e69d..d926e90c4 100644 --- a/ir/ir/irmode.c +++ b/ir/ir/irmode.c @@ -56,17 +56,31 @@ static int num_modes; 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->align == n->align && - m->sign == n->sign && - m->modulo_shift == n->modulo_shift) + 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) return 1; 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); + + adr += s + mask; + + return __INT_TO_PTR(adr & ~mask); +} + /** * searches the modes obstack for the given mode and returns * a pointer on an equal mode already in the array, NULL if @@ -74,21 +88,32 @@ INLINE static int modes_are_equal(const ir_mode *m, const ir_mode *n) */ static ir_mode *find_mode(const ir_mode *m) { - ir_mode *n; + ir_mode *n, *nn; struct _obstack_chunk *p; - p = modes.chunk; - for ( n = (ir_mode *)p->contents; (char *)(n+1) <= modes.next_free; ++n) { + 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) { - for (n = (ir_mode *)p->contents; (char *)(n+1) < p->limit; ++n) + 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; @@ -101,6 +126,7 @@ 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); @@ -119,11 +145,10 @@ static void set_mode_values(ir_mode* mode) case irms_reference: mode->min = tarval_bad; mode->max = tarval_bad; - mode->null = (get_mode_modecode(mode)==irm_P)?tarval_P_void:tarval_bad; + mode->null = (get_mode_modecode(mode) == irm_P) ? tarval_P_void : tarval_bad; mode->one = tarval_bad; break; - case irms_character: case irms_auxiliary: case irms_memory: case irms_control_flow: @@ -218,7 +243,7 @@ static ir_mode *register_mode(const ir_mode* new_mode) assert(new_mode); /* copy mode struct to modes array */ - mode=(ir_mode*) obstack_copy(&modes, new_mode, sizeof(ir_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; @@ -244,6 +269,7 @@ ir_mode *new_ir_mode(const char *name, mode_sort sort, int bit_size, int align, 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; mode_tmpl.arithmetic = arithmetic; mode_tmpl.link = NULL; mode_tmpl.tv_priv = NULL; @@ -276,6 +302,60 @@ ir_mode *new_ir_mode(const char *name, mode_sort sort, int bit_size, int align, return NULL; /* to shut up gcc */ } +/* + * 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, + mode_arithmetic arithmetic, unsigned int modulo_shift ) +{ + ir_mode mode_tmpl; + ir_mode *mode; + + 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; + mode_tmpl.arithmetic = arithmetic; + mode_tmpl.link = NULL; + mode_tmpl.tv_priv = NULL; + + mode = find_mode(&mode_tmpl); + if (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"); + return NULL; + + case irms_reference: + case irms_character: + assert(0 && "only integer and floating point modes can be vectorized"); + return NULL; + + case irms_float_number: + assert(0 && "not yet implemented"); + return NULL; + + case irms_int_number: + return register_mode(&mode_tmpl); + } + return NULL; /* to shut up gcc */ +} + /* Functions for the direct access to all attributes od a ir_mode */ modecode get_mode_modecode(const ir_mode *mode) @@ -344,11 +424,15 @@ 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. */ -unsinged int get_mode_modulo_shift(const ir_mode *mode) { +unsigned int get_mode_modulo_shift(const ir_mode *mode) { return mode->modulo_shift; } -void* get_mode_link(const ir_mode *mode) +unsigned int get_mode_vector_elems(const ir_mode *mode) { + return mode->vector_elem; +} + +void *get_mode_link(const ir_mode *mode) { ANNOUNCE(); return mode->link; @@ -559,6 +643,23 @@ mode_is_dataM (const ir_mode *mode) assert(mode); return (mode_is_data(mode) || get_mode_modecode(mode) == irm_M); } + +int +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); +} + +int +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) @@ -567,17 +668,24 @@ mode_is_dataM (const ir_mode *mode) # 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 /* 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: @@ -588,18 +696,23 @@ smaller_mode(const ir_mode *sm, const ir_mode *lm) * - 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 (mode_is_signed(sm)) + 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) && (get_mode_size_bits(lm) > get_mode_size_bits(sm)) ) + if ( mode_is_signed(lm) && (lm_bits >= sm_bits) ) return 1; } else if (mode_is_signed(lm)) { - if (get_mode_size_bits(lm) > get_mode_size_bits(sm) + 1) + if (lm_bits > sm_bits + 1) return 1; } - else if (get_mode_size_bits(lm) > get_mode_size_bits(sm)) + else if (lm_bits >= sm_bits) { return 1; } @@ -615,11 +728,11 @@ smaller_mode(const ir_mode *sm, const ir_mode *lm) break; case irms_float_number: - /* XXX currently only the three standard 32,64,80 bit floats - * are supported which can safely be converted */ - if ( (get_mode_sort(lm) == irms_float_number) - && (get_mode_size_bits(lm) > get_mode_size_bits(sm)) ) - return 1; + 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: @@ -653,6 +766,7 @@ init_mode (void) newmode.align = 0; newmode.sign = 0; newmode.modulo_shift = 0; + newmode.vector_elem = 0; newmode.link = NULL; newmode.tv_priv = NULL; @@ -711,6 +825,7 @@ init_mode (void) mode_b = register_mode(&newmode); /* Data Modes */ + newmode.vector_elem = 1; /* Float Number Modes */ newmode.sort = irms_float_number; @@ -869,3 +984,35 @@ init_mode (void) /* set the machine specific modes to the predifined ones */ mode_P_mach = mode_P; } + + +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_mach = NULL; +}