X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Ftv%2Ftv.c;h=5015ad2d648290a183d62ddbeb788eb6e57ebffe;hb=7bc3861ada78b88c3d45ef6b1042f7265695da79;hp=e7c189291d1d296f6c2e94abefc38581b321b8d4;hpb=4e28c552ca19e1778dd39c616b0d72956de678c3;p=libfirm diff --git a/ir/tv/tv.c b/ir/tv/tv.c index e7c189291..5015ad2d6 100644 --- a/ir/tv/tv.c +++ b/ir/tv/tv.c @@ -28,11 +28,15 @@ #include /* assertions */ #include /* atoi() */ -#include /* nice things for strings */ +#ifdef HAVE_STRING_H +# include /* nice things for strings */ +#endif #ifdef HAVE_STRINGS_H #include /* strings.h also includes bsd only function strcasecmp */ #endif -#include +#ifdef HAVE_STDLIB_H +# include +#endif #ifdef HAVE_ALLOCA_H # include #endif @@ -42,27 +46,27 @@ #include "tv_t.h" #include "set.h" /* to store tarvals in */ -/* #include "tune.h" */ /* some constants */ #include "entity_t.h" /* needed to store pointers to entities */ #include "irmode_t.h" #include "irnode.h" /* defines boolean return values (pnc_number)*/ -#include "host.h" #include "strcalc.h" #include "fltcalc.h" +#include "irtools.h" +#include "firm_common.h" /** Size of hash tables. Should correspond to average number of distinct constant target values */ #define N_CONSTANTS 2048 -/* XXX hack until theres's a proper interface */ -#define BAD 1 -#define SATURATE 2 -#define WRAP 3 -#define GET_OVERFLOW_MODE() BAD +/* get the integer overflow mode */ +#define GET_OVERFLOW_MODE() int_overflow_mode /* unused, float to int doesn't work yet */ -#define TRUNCATE 1 -#define ROUND 2 +enum float_to_int_mode { + TRUNCATE, + ROUND +}; + #define GET_FLOAT_TO_INT_MODE() TRUNCATE #define SWITCH_NOINFINITY 0 @@ -95,6 +99,7 @@ static long long count = 0; ****************************************************************************/ static struct set *tarvals; /* container for tarval structs */ static struct set *values; /* container for values */ +static tarval_int_overflow_mode_t int_overflow_mode = TV_OVERFLOW_WRAP; /**************************************************************************** * private functions @@ -133,7 +138,7 @@ INLINE static void tarval_verify(tarval *tv) static int hash_tv(tarval *tv) { - return ((unsigned int)tv->value ^ (unsigned int)tv->mode) + tv->length; + return (PTR_TO_INT(tv->value) ^ PTR_TO_INT(tv->mode)) + tv->length; } static int hash_val(const void *value, unsigned int length) @@ -151,12 +156,13 @@ static int hash_val(const void *value, unsigned int length) return hash; } -/* finds tarval with value/mode or creates new tarval */ +/** finds tarval with value/mode or creates new tarval */ static tarval *get_tarval(const void *value, int length, ir_mode *mode) { tarval tv; - tv.mode = mode; + tv.kind = k_tarval; + tv.mode = mode; tv.length = length; if (length > 0) { /* if there already is such a value, it is returned, else value @@ -170,6 +176,9 @@ static tarval *get_tarval(const void *value, int length, ir_mode *mode) return (tarval *)INSERT_TARVAL(&tv); } +/** + * handle overflow + */ static tarval *get_tarval_overflow(const void *value, int length, ir_mode *mode) { switch (get_mode_sort(mode)) @@ -177,9 +186,9 @@ static tarval *get_tarval_overflow(const void *value, int length, ir_mode *mode) case irms_int_number: if (sc_comp(value, get_mode_max(mode)->value) == 1) { switch (GET_OVERFLOW_MODE()) { - case SATURATE: + case TV_OVERFLOW_SATURATE: return get_mode_max(mode); - case WRAP: + case TV_OVERFLOW_WRAP: { char *temp = alloca(sc_get_buffer_length()); char *diff = alloca(sc_get_buffer_length()); @@ -191,7 +200,7 @@ static tarval *get_tarval_overflow(const void *value, int length, ir_mode *mode) sc_sub(temp, diff, temp); return get_tarval(temp, length, mode); } - case BAD: + case TV_OVERFLOW_BAD: return tarval_bad; default: return get_tarval(value, length, mode); @@ -199,9 +208,9 @@ static tarval *get_tarval_overflow(const void *value, int length, ir_mode *mode) } if (sc_comp(value, get_mode_min(mode)->value) == -1) { switch (GET_OVERFLOW_MODE()) { - case SATURATE: + case TV_OVERFLOW_SATURATE: return get_mode_min(mode); - case WRAP: + case TV_OVERFLOW_WRAP: { char *temp = alloca(sc_get_buffer_length()); char *diff = alloca(sc_get_buffer_length()); @@ -213,7 +222,7 @@ static tarval *get_tarval_overflow(const void *value, int length, ir_mode *mode) sc_add(temp, diff, temp); return get_tarval(temp, length, mode); } - case BAD: + case TV_OVERFLOW_BAD: return tarval_bad; default: return get_tarval(value, length, mode); @@ -296,7 +305,7 @@ tarval *new_tarval_from_str(const char *str, size_t len, ir_mode *mode) case irms_int_number: case irms_character: - sc_val_from_str(str, len, NULL); + sc_val_from_str(str, len, NULL, mode); return get_tarval(sc_get_buffer(), sc_get_buffer_length(), mode); case irms_reference: @@ -313,7 +322,7 @@ tarval *new_tarval_from_str(const char *str, size_t len, ir_mode *mode) tarval *new_tarval_from_long(long l, ir_mode *mode) { ANNOUNCE(); - assert(mode && !((get_mode_sort(mode) == irms_memory)||(get_mode_sort(mode)==irms_control_flow)||(get_mode_sort(mode)==irms_auxiliary))); + assert(mode); switch(get_mode_sort(mode)) { @@ -333,7 +342,7 @@ tarval *new_tarval_from_long(long l, ir_mode *mode) return l ? tarval_bad : get_tarval(NULL, 0, mode); /* null pointer or tarval_bad */ default: - assert(0); + assert(0 && "unsupported mode sort"); } return NULL; } @@ -341,8 +350,10 @@ tarval *new_tarval_from_long(long l, ir_mode *mode) /* returns non-zero if can be converted to long */ int tarval_is_long(tarval *tv) { + mode_sort sort = get_mode_sort(tv->mode); + ANNOUNCE(); - if (get_mode_sort(tv->mode) != irms_int_number) return 0; + if (sort != irms_int_number && sort != irms_character) return 0; if (get_mode_size_bits(tv->mode) > sizeof(long)<<3) { @@ -406,11 +417,10 @@ long double get_tarval_double(tarval *tv) /* * Access routines for tarval fields ======================================== */ -ir_mode *get_tarval_mode (tarval *tv) /* get the mode of the tarval */ -{ - ANNOUNCE(); - assert(tv); - return tv->mode; + +/* get the mode of the tarval */ +ir_mode *(get_tarval_mode)(const tarval *tv) { + return _get_tarval_mode(tv); } /* @@ -423,30 +433,24 @@ ir_mode *get_tarval_mode (tarval *tv) /* get the mode of the tarval */ * therefore the irmode functions should be prefered to the functions below. */ -tarval *get_tarval_bad(void) -{ - ANNOUNCE(); - return tarval_bad; +tarval *(get_tarval_bad)(void) { + return _get_tarval_bad(); } -tarval *get_tarval_undefined(void) -{ - ANNOUNCE(); - return tarval_undefined; + +tarval *(get_tarval_undefined)(void) { + return _get_tarval_undefined(); } -tarval *get_tarval_b_false(void) -{ - ANNOUNCE(); - return tarval_b_false; + +tarval *(get_tarval_b_false)(void) { + return _get_tarval_b_false(); } -tarval *get_tarval_b_true(void) -{ - ANNOUNCE(); - return tarval_b_true; + +tarval *(get_tarval_b_true)(void) { + return _get_tarval_b_true(); } -tarval *get_tarval_P_void(void) -{ - ANNOUNCE(); - return tarval_P_void; + +tarval *(get_tarval_P_void)(void) { + return _get_tarval_P_void(); } tarval *get_tarval_max(ir_mode *mode) @@ -602,6 +606,36 @@ tarval *get_tarval_one(ir_mode *mode) return tarval_bad; } +tarval *get_tarval_minus_one(ir_mode *mode) +{ + ANNOUNCE(); + assert(mode); + + if (get_mode_n_vector_elems(mode) > 1) { + /* vector arithmetic not implemented yet */ + return tarval_bad; + } + + switch(get_mode_sort(mode)) + { + case irms_control_flow: + case irms_memory: + case irms_auxiliary: + case irms_internal_boolean: + case irms_reference: + assert(0); + break; + + case irms_float_number: + return mode_is_signed(mode) ? new_tarval_from_double(-1.0, mode) : tarval_bad; + + case irms_int_number: + case irms_character: + return mode_is_signed(mode) ? new_tarval_from_long(-1l, mode) : tarval_bad; + } + return tarval_bad; +} + tarval *get_tarval_nan(ir_mode *mode) { ANNOUNCE(); @@ -633,7 +667,7 @@ tarval *get_tarval_nan(ir_mode *mode) } } -tarval *get_tarval_inf(ir_mode *mode) +tarval *get_tarval_plus_inf(ir_mode *mode) { ANNOUNCE(); assert(mode); @@ -664,6 +698,37 @@ tarval *get_tarval_inf(ir_mode *mode) } } +tarval *get_tarval_minus_inf(ir_mode *mode) +{ + ANNOUNCE(); + assert(mode); + + if (get_mode_n_vector_elems(mode) > 1) { + /* vector arithmetic not implemented yet */ + return tarval_bad; + } + + if (get_mode_sort(mode) == irms_float_number) { + switch(get_mode_size_bits(mode)) + { + case 32: + fc_get_minusinf(8, 23, NULL); + break; + case 64: + fc_get_minusinf(11, 52, NULL); + break; + case 80: + fc_get_minusinf(15, 64, NULL); + break; + } + return get_tarval(fc_get_buffer(), fc_get_buffer_length(), mode); + } + else { + assert(0 && "tarval is not floating point"); + return tarval_bad; + } +} + /* * Arithmethic operations on tarvals ======================================== */ @@ -721,16 +786,22 @@ int tarval_is_one(tarval *a) /* * comparison */ -pnc_number tarval_cmp(tarval *a, tarval *b) +pn_Cmp tarval_cmp(tarval *a, tarval *b) { ANNOUNCE(); assert(a); assert(b); - if (a == tarval_bad || b == tarval_bad) assert(0 && "Comparison with tarval_bad"); - if (a == tarval_undefined || b == tarval_undefined) return False; - if (a == b) return Eq; - if (a->mode != b->mode) return False; + if (a == tarval_bad || b == tarval_bad) { + assert(0 && "Comparison with tarval_bad"); + return pn_Cmp_False; + } + + if (a == tarval_undefined || b == tarval_undefined) + return pn_Cmp_False; + + if (a->mode != b->mode) + return pn_Cmp_False; if (get_mode_n_vector_elems(a->mode) > 1) { /* vector arithmetic not implemented yet */ @@ -744,24 +815,34 @@ pnc_number tarval_cmp(tarval *a, tarval *b) case irms_memory: case irms_auxiliary: case irms_reference: - return False; + if (a == b) + return pn_Cmp_Eq; + return pn_Cmp_False; case irms_float_number: + /* + * BEWARE: we cannot compare a == b here, because + * a NaN is always Unordered to any other value, even to itself! + */ switch (fc_comp(a->value, b->value)) { - case -1: return Lt; - case 0: assert(0 && "different tarvals compare equal"); return Eq; - case 1: return Gt; - case 2: return Uo; - default: return False; + case -1: return pn_Cmp_Lt; + case 0: return pn_Cmp_Eq; + case 1: return pn_Cmp_Gt; + case 2: return pn_Cmp_Uo; + default: return pn_Cmp_False; } case irms_int_number: case irms_character: - return (sc_comp(a->value, b->value)==1)?(Gt):(Lt); + if (a == b) + return pn_Cmp_Eq; + return sc_comp(a->value, b->value) == 1 ? pn_Cmp_Gt : pn_Cmp_Lt; case irms_internal_boolean: - return (a == tarval_b_true)?(Gt):(Lt); + if (a == b) + return pn_Cmp_Eq; + return a == tarval_b_true ? pn_Cmp_Gt : pn_Cmp_Lt; } - return False; + return pn_Cmp_False; } /* @@ -792,7 +873,7 @@ tarval *tarval_convert_to(tarval *src, ir_mode *m) /* cast float to something */ case irms_float_number: switch (get_mode_sort(m)) { - case irms_float_number: + case irms_float_number: switch (get_mode_size_bits(m)) { case 32: @@ -808,7 +889,6 @@ tarval *tarval_convert_to(tarval *src, ir_mode *m) break; } return get_tarval(fc_get_buffer(), fc_get_buffer_length(), m); - break; case irms_int_number: switch (GET_FLOAT_TO_INT_MODE()) @@ -820,14 +900,14 @@ tarval *tarval_convert_to(tarval *src, ir_mode *m) fc_rnd(src->value, NULL); break; default: + assert(0); break; } - /* XXX floating point unit can't produce a value in integer + /* FIXME: floating point unit can't produce a value in integer * representation * an intermediate representation is needed here first. */ /* return get_tarval(); */ return tarval_bad; - break; default: /* the rest can't be converted */ @@ -869,7 +949,13 @@ tarval *tarval_convert_to(tarval *src, ir_mode *m) break; } return get_tarval(fc_get_buffer(), fc_get_buffer_length(), m); - +#if 0 + case irms_reference: + /* allow 0 to be casted */ + if (src == get_mode_null(src->mode)) + return get_mode_null(m); + break; +#endif default: break; } @@ -905,7 +991,6 @@ tarval *tarval_not(tarval *a) ANNOUNCE(); assert(a); - assert(mode_is_int(a->mode)); /* bitwise negation is only allowed for integer */ /* works for vector mode without changes */ @@ -916,7 +1001,15 @@ tarval *tarval_not(tarval *a) sc_not(a->value, buffer); return get_tarval(buffer, a->length, a->mode); + case irms_internal_boolean: + if (a == tarval_b_true) + return tarval_b_false; + if (a == tarval_b_false) + return tarval_b_true; + return tarval_bad; + default: + assert(0 && "bitwise negation is only allowed for integer and boolean"); return tarval_bad; } } @@ -931,7 +1024,8 @@ tarval *tarval_neg(tarval *a) ANNOUNCE(); assert(a); assert(mode_is_num(a->mode)); /* negation only for numerical values */ - assert(mode_is_signed(a->mode)); /* negation is difficult without negative numbers, isn't it */ + + /* note: negation is allowed even for unsigned modes. */ if (get_mode_n_vector_elems(a->mode) > 1) { /* vector arithmetic not implemented yet */ @@ -964,7 +1058,7 @@ tarval *tarval_add(tarval *a, tarval *b) ANNOUNCE(); assert(a); assert(b); - assert((a->mode == b->mode) || (get_mode_sort(a->mode) == irms_character && mode_is_int(b->mode))); + assert(a->mode == b->mode); if (get_mode_n_vector_elems(a->mode) > 1 || get_mode_n_vector_elems(b->mode) > 1) { /* vector arithmetic not implemented yet */ @@ -999,7 +1093,7 @@ tarval *tarval_sub(tarval *a, tarval *b) ANNOUNCE(); assert(a); assert(b); - assert((a->mode == b->mode) || (get_mode_sort(a->mode) == irms_character && mode_is_int(b->mode))); + assert(a->mode == b->mode); if (get_mode_n_vector_elems(a->mode) > 1 || get_mode_n_vector_elems(b->mode) > 1) { /* vector arithmetic not implemented yet */ @@ -1033,7 +1127,7 @@ tarval *tarval_mul(tarval *a, tarval *b) ANNOUNCE(); assert(a); assert(b); - assert((a->mode == b->mode) && mode_is_num(a->mode)); + assert(a->mode == b->mode); if (get_mode_n_vector_elems(a->mode) > 1) { /* vector arithmetic not implemented yet */ @@ -1364,6 +1458,13 @@ tarval *tarval_rot(tarval *a, tarval *b) return get_tarval(sc_get_buffer(), sc_get_buffer_length(), a->mode); } +/* + * carry flag of the last operation + */ +int tarval_carry(void) +{ + return sc_had_carry(); +} /* * Output of tarvals @@ -1425,19 +1526,19 @@ int tarval_snprintf(char *buf, size_t len, tarval *tv) case irms_reference: if (tv == tarval_P_void) return snprintf(buf, len, "NULL"); if (tv->value != NULL){ - if (len > tv->length) { - memcpy(buf, tv->value, tv->length); - buf[tv->length] = '\0'; - } - else { - /* truncated */ - memcpy(buf, tv->value, len-1); - buf[len-1] = '\0'; - } - return tv->length; + if (len > tv->length) { + memcpy(buf, tv->value, tv->length); + buf[tv->length] = '\0'; + } + else { + /* truncated */ + memcpy(buf, tv->value, len-1); + buf[len-1] = '\0'; + } + return tv->length; } else - return snprintf(buf, len, "void"); + return snprintf(buf, len, "void"); case irms_internal_boolean: switch (mode_info->mode_output) { @@ -1456,7 +1557,7 @@ int tarval_snprintf(char *buf, size_t len, tarval *tv) case irms_control_flow: case irms_memory: case irms_auxiliary: - return snprintf(buf, len, ""); + return snprintf(buf, len, ""); } return 0; @@ -1489,7 +1590,7 @@ char *get_tarval_bitpattern(tarval *tv) byte = get_tarval_sub_bits(tv, i); for(j = 1; j < 256; j <<= 1) if(pos < n) - res[pos++] = j & byte ? '1' : '0'; + res[pos++] = j & byte ? '1' : '0'; } res[n] = '\0'; @@ -1533,7 +1634,7 @@ int set_tarval_mode_output_option(ir_mode *mode, const tarval_mode_info *modein /* * Returns the output options of one mode. * - * This functions returns the modinfo of a given mode. + * This functions returns the mode info of a given mode. */ const tarval_mode_info *get_tarval_mode_output_option(ir_mode *mode) { @@ -1567,6 +1668,20 @@ tarval_classification_t classify_tarval(tarval *tv) return TV_CLASSIFY_OTHER; } +/** + * Sets the overflow mode for integer operations. + */ +void tarval_set_integer_overflow_mode(tarval_int_overflow_mode_t ov_mode) { + int_overflow_mode = ov_mode; +} + +/** + * Get the overflow mode for integer operations. + */ +tarval_int_overflow_mode_t tarval_get_integer_overflow_mode(void) { + return int_overflow_mode; +} + /** * default mode_info for output as HEX */ @@ -1609,10 +1724,19 @@ void init_tarval_2(void) { ANNOUNCE(); + tarval_bad->kind = k_tarval; tarval_bad->mode = mode_BAD; + + tarval_undefined->kind = k_tarval; tarval_undefined->mode = mode_ANY; + + tarval_b_true->kind = k_tarval; tarval_b_true->mode = mode_b; + + tarval_b_false->kind = k_tarval; tarval_b_false->mode = mode_b; + + tarval_P_void->kind = k_tarval; tarval_P_void->mode = mode_P; /*