X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Ftv%2Ftv.c;h=6c50d1dd69a703ea73defbbfbea836e00df8acad;hb=9d1fda9a8933dda2c16e90f1528b68d6d8c34685;hp=518bc8afda61f06c5f857b5309d8377d01f7aaff;hpb=d7cbb84770860c70a90e96ae3bd4350d24e20120;p=libfirm diff --git a/ir/tv/tv.c b/ir/tv/tv.c index 518bc8afd..6c50d1dd6 100644 --- a/ir/tv/tv.c +++ b/ir/tv/tv.c @@ -1,48 +1,73 @@ -/* TV --- Target Values, aka Constant Table. - Copyright (C) 1995, 1996 Christian von Roques */ - -/* $Id$ */ +/* + * Project: libFIRM + * File name: ir/tv/tv.c + * Purpose: Representation of and static computations on target machine + * values. + * Author: Mathias Heil + * Modified by: + * Created: + * CVS-ID: $Id$ + * Copyright: (c) 2003 Universität Karlsruhe + * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE. + */ -/****i* tv/implementation - * - * AUTHORS - * Matthias Heil - * - * NOTES +/* * Values are stored in a format depending upon chosen arithmetic * module. Default uses strcalc and fltcalc. - ******/ + * + */ /* This implementation assumes: * - target has IEEE-754 floating-point arithmetic. */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + + #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 */ -#include -#include +#endif +#ifdef HAVE_STDLIB_H +# include +#endif +#ifdef HAVE_ALLOCA_H +# include +#endif +#ifdef HAVE_MALLOC_H +# include +#endif #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.h" /* defines modes etc */ #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 "xmalloc.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 @@ -75,6 +100,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 @@ -113,7 +139,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) @@ -131,12 +157,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 @@ -150,6 +177,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)) @@ -157,21 +187,16 @@ 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()); - sc_sub(get_mode_max(mode)->value, get_mode_min(mode)->value, diff); - sc_val_from_ulong(1, temp); - sc_add(diff, temp, diff); - sc_sub(value, diff, temp); - while (sc_comp(temp, get_mode_max(mode)->value) == 1) - sc_sub(temp, diff, temp); + sc_val_from_ulong(-1, temp); + sc_and(temp, value, temp); return get_tarval(temp, length, mode); } - case BAD: + case TV_OVERFLOW_BAD: return tarval_bad; default: return get_tarval(value, length, mode); @@ -179,21 +204,16 @@ 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()); - sc_sub(get_mode_max(mode)->value, get_mode_min(mode)->value, diff); - sc_val_from_ulong(1, temp); - sc_add(diff, temp, diff); - sc_add(value, diff, temp); - while (sc_comp(temp, get_mode_max(mode)->value) == 1) - sc_add(temp, diff, temp); + sc_val_from_ulong(-1, temp); + sc_and(temp, value, temp); return get_tarval(temp, length, mode); } - case BAD: + case TV_OVERFLOW_BAD: return tarval_bad; default: return get_tarval(value, length, mode); @@ -212,21 +232,22 @@ static tarval *get_tarval_overflow(const void *value, int length, ir_mode *mode) return get_mode_null(mode); } break; + default: break; } return get_tarval(value, length, mode); } - /* * public variables declared in tv.h */ -tarval *tarval_bad; -tarval *tarval_undefined; -tarval *tarval_b_false; -tarval *tarval_b_true; -tarval *tarval_P_void; +static tarval reserved_tv[4]; + +tarval *tarval_bad = &reserved_tv[0]; +tarval *tarval_undefined = &reserved_tv[1]; +tarval *tarval_b_false = &reserved_tv[2]; +tarval *tarval_b_true = &reserved_tv[3]; /* * public functions declared in tv.h @@ -256,7 +277,7 @@ tarval *new_tarval_from_str(const char *str, size_t len, ir_mode *mode) else if (strcasecmp(str, "false")) return tarval_b_true; else /* XXX This is C semantics */ - return atoi(str) ? tarval_b_true : tarval_b_false; + return atoi(str) ? tarval_b_true : tarval_b_false; case irms_float_number: switch(get_mode_size_bits(mode)) { @@ -272,13 +293,12 @@ tarval *new_tarval_from_str(const char *str, size_t len, ir_mode *mode) } return get_tarval(fc_get_buffer(), fc_get_buffer_length(), mode); + case irms_reference: + /* same as integer modes */ 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: - return get_tarval(str, len, mode); } assert(0); /* can't be reached, can it? */ @@ -291,7 +311,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)) { @@ -299,6 +319,8 @@ tarval *new_tarval_from_long(long l, ir_mode *mode) /* XXX C semantics ! */ return l ? tarval_b_true : tarval_b_false ; + case irms_reference: + /* same as integer modes */ case irms_int_number: case irms_character: sc_val_from_long(l, NULL); @@ -307,11 +329,8 @@ tarval *new_tarval_from_long(long l, ir_mode *mode) case irms_float_number: return new_tarval_from_double((long double)l, mode); - case irms_reference: - return l ? tarval_bad : get_tarval(NULL, 0, mode); /* null pointer or tarval_bad */ - default: - assert(0); + assert(0 && "unsupported mode sort"); } return NULL; } @@ -319,8 +338,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) { @@ -336,7 +357,7 @@ int tarval_is_long(tarval *tv) } /* this might overflow the machine's long, so use only with small values */ -long tarval_to_long(tarval* tv) +long get_tarval_long(tarval* tv) { ANNOUNCE(); assert(tarval_is_long(tv) && "tarval too big to fit in long"); @@ -372,7 +393,7 @@ int tarval_is_double(tarval *tv) return (get_mode_sort(tv->mode) == irms_float_number); } -long double tarval_to_double(tarval *tv) +long double get_tarval_double(tarval *tv) { ANNOUNCE(); assert(tarval_is_double(tv)); @@ -380,61 +401,14 @@ long double tarval_to_double(tarval *tv) return fc_val_to_float(tv->value); } -/* The tarval represents the address of the entity. As the address must - be constant the entity must have as owner the global type. */ -tarval *new_tarval_from_entity (entity *ent, ir_mode *mode) -{ - ANNOUNCE(); - assert(ent); - assert(mode && (get_mode_sort(mode) == irms_reference)); - - return get_tarval((void *)ent, 0, mode); -} -int tarval_is_entity(tarval *tv) -{ - ANNOUNCE(); - assert(tv); - /* tv->value == NULL means dereferencing a null pointer */ - return ((get_mode_sort(tv->mode) == irms_reference) && (tv->value != NULL) && (tv->length == 0) - && (tv != tarval_P_void)); -} - -entity *tarval_to_entity(tarval *tv) -{ - ANNOUNCE(); - assert(tv); - - if (tarval_is_entity(tv)) - return (entity *)tv->value; - else { - assert(0 && "tarval did not represent an entity"); - return NULL; - } -} - -void free_tarval_entity(entity *ent) { - /* There can be a tarval referencing this entity. Even if the - tarval is not used by the code any more, it can still reference - the entity as tarvals live indepently of the entity referenced. - Further the tarval is hashed into a set. If a hash function - evaluation happens to collide with this tarval, we will vrfy that - it contains a proper entity and we will crash if the entity is - freed. - - Unluckily, tarvals can neither be changed nor deleted, and to find - one, all existing reference modes have to be tried -> a facility - to retrieve all modes of a kind is needed. */ - ANNOUNCE(); -} /* * 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); } /* @@ -447,30 +421,20 @@ 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_undefined(void) -{ - ANNOUNCE(); - return tarval_undefined; +tarval *(get_tarval_bad)(void) { + return _get_tarval_bad(); } -tarval *get_tarval_b_false(void) -{ - ANNOUNCE(); - return tarval_b_false; + +tarval *(get_tarval_undefined)(void) { + return _get_tarval_undefined(); } -tarval *get_tarval_b_true(void) -{ - ANNOUNCE(); - return tarval_b_true; + +tarval *(get_tarval_b_false)(void) { + return _get_tarval_b_false(); } -tarval *get_tarval_P_void(void) -{ - ANNOUNCE(); - return tarval_P_void; + +tarval *(get_tarval_b_true)(void) { + return _get_tarval_b_true(); } tarval *get_tarval_max(ir_mode *mode) @@ -478,6 +442,11 @@ tarval *get_tarval_max(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_reference: @@ -518,6 +487,11 @@ tarval *get_tarval_min(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_reference: @@ -553,11 +527,18 @@ tarval *get_tarval_min(ir_mode *mode) return tarval_bad; } +static long _null_value; + tarval *get_tarval_null(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: @@ -575,7 +556,7 @@ tarval *get_tarval_null(ir_mode *mode) return new_tarval_from_long(0l, mode); case irms_reference: - return tarval_P_void; + return new_tarval_from_long(_null_value, mode); } return tarval_bad; } @@ -585,6 +566,11 @@ tarval *get_tarval_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: @@ -606,11 +592,46 @@ 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(); 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)) { @@ -632,11 +653,16 @@ 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); + 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)) { @@ -658,6 +684,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 ======================================== */ @@ -670,12 +727,18 @@ int tarval_is_negative(tarval *a) ANNOUNCE(); assert(a); + if (get_mode_n_vector_elems(a->mode) > 1) { + /* vector arithmetic not implemented yet */ + assert(0 && "tarval_is_negative is not allowed for vector modes"); + return 0; + } + switch (get_mode_sort(a->mode)) { case irms_int_number: if (!mode_is_signed(a->mode)) return 0; else - return sc_comp(a->value, get_mode_null(a->mode)->value) == -1 ? 1 : 0; + return sc_comp(a->value, get_mode_null(a->mode)->value) == -1 ? 1 : 0; case irms_float_number: return fc_comp(a->value, get_mode_null(a->mode)->value) == -1 ? 1 : 0; @@ -696,19 +759,40 @@ int tarval_is_null(tarval *a) return a == get_tarval_null(m); } +/* + * test if one, 1 means 'yes' + */ +int tarval_is_one(tarval *a) +{ + ir_mode *m = get_tarval_mode(a); + + return a == get_tarval_one(m); +} + /* * 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 (get_tarval_mode(a) != get_tarval_mode(b)) 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 */ + assert(0 && "cmp not implemented for vector modes"); + } /* Here the two tarvals are unequal and of the same mode */ switch (get_mode_sort(a->mode)) @@ -717,24 +801,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; } /* @@ -750,6 +844,11 @@ tarval *tarval_convert_to(tarval *src, ir_mode *m) if (src->mode == m) return src; + if (get_mode_n_vector_elems(src->mode) > 1) { + /* vector arithmetic not implemented yet */ + return tarval_bad; + } + switch (get_mode_sort(src->mode)) { case irms_control_flow: @@ -760,7 +859,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: @@ -776,7 +875,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()) @@ -788,14 +886,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 */ @@ -838,6 +936,12 @@ tarval *tarval_convert_to(tarval *src, ir_mode *m) } return get_tarval(fc_get_buffer(), fc_get_buffer_length(), m); + case irms_reference: + /* allow 0 to be casted */ + if (src == get_mode_null(src->mode)) + return get_mode_null(m); + break; + default: break; } @@ -865,7 +969,39 @@ tarval *tarval_convert_to(tarval *src, ir_mode *m) } /* - * negation + * bitwise negation + */ +tarval *tarval_not(tarval *a) +{ + char *buffer; + + ANNOUNCE(); + assert(a); + + /* works for vector mode without changes */ + + switch (get_mode_sort(a->mode)) + { + case irms_int_number: + buffer = alloca(sc_get_buffer_length()); + 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; + } +} + +/* + * arithmetic negation */ tarval *tarval_neg(tarval *a) { @@ -874,7 +1010,13 @@ 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 */ + return tarval_bad; + } switch (get_mode_sort(a->mode)) { @@ -902,7 +1044,12 @@ 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 */ + return tarval_bad; + } switch (get_mode_sort(a->mode)) { @@ -932,8 +1079,12 @@ 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 */ + return tarval_bad; + } switch (get_mode_sort(a->mode)) { case irms_character: @@ -962,7 +1113,12 @@ 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 */ + return tarval_bad; + } switch (get_mode_sort(a->mode)) { @@ -991,6 +1147,11 @@ tarval *tarval_quo(tarval *a, tarval *b) assert(b); assert((a->mode == b->mode) && mode_is_float(a->mode)); + if (get_mode_n_vector_elems(a->mode) > 1) { + /* vector arithmetic not implemented yet */ + return tarval_bad; + } + fc_div(a->value, b->value, NULL); return get_tarval_overflow(fc_get_buffer(), fc_get_buffer_length(), a->mode); } @@ -1006,6 +1167,11 @@ tarval *tarval_div(tarval *a, tarval *b) assert(b); assert((a->mode == b->mode) && mode_is_int(a->mode)); + if (get_mode_n_vector_elems(a->mode) > 1) { + /* vector arithmetic not implemented yet */ + return tarval_bad; + } + /* x/0 error */ if (b == get_mode_null(b->mode)) return tarval_bad; /* modes of a,b are equal */ @@ -1024,6 +1190,11 @@ tarval *tarval_mod(tarval *a, tarval *b) assert(b); assert((a->mode == b->mode) && mode_is_int(a->mode)); + if (get_mode_n_vector_elems(a->mode) > 1) { + /* vector arithmetic not implemented yet */ + return tarval_bad; + } + /* x/0 error */ if (b == get_mode_null(b->mode)) return tarval_bad; /* modes of a,b are equal */ @@ -1042,6 +1213,11 @@ tarval *tarval_abs(tarval *a) assert(a); assert(mode_is_num(a->mode)); + if (get_mode_n_vector_elems(a->mode) > 1) { + /* vector arithmetic not implemented yet */ + return tarval_bad; + } + switch (get_mode_sort(a->mode)) { case irms_int_number: @@ -1077,6 +1253,8 @@ tarval *tarval_and(tarval *a, tarval *b) assert(b); assert(a->mode == b->mode); + /* works even for vector modes */ + switch(get_mode_sort(a->mode)) { case irms_internal_boolean: @@ -1102,6 +1280,8 @@ tarval *tarval_or (tarval *a, tarval *b) assert(b); assert(a->mode == b->mode); + /* works even for vector modes */ + switch (get_mode_sort(a->mode)) { case irms_internal_boolean: @@ -1127,13 +1307,15 @@ tarval *tarval_eor(tarval *a, tarval *b) assert(b); assert((a->mode == b->mode)); + /* works even for vector modes */ + switch (get_mode_sort(a->mode)) { case irms_internal_boolean: return (a == b)? tarval_b_false : tarval_b_true; case irms_int_number: - sc_or(a->value, b->value, NULL); + sc_xor(a->value, b->value, NULL); return get_tarval(sc_get_buffer(), sc_get_buffer_length(), a->mode); default: @@ -1147,12 +1329,28 @@ tarval *tarval_eor(tarval *a, tarval *b) */ tarval *tarval_shl(tarval *a, tarval *b) { + char *temp_val = NULL; ANNOUNCE(); assert(a); assert(b); assert(mode_is_int(a->mode) && mode_is_int(b->mode)); - sc_shl(a->value, b->value, get_mode_size_bits(a->mode), mode_is_signed(a->mode), NULL); + if (get_mode_n_vector_elems(a->mode) > 1 || get_mode_n_vector_elems(a->mode) > 1) { + /* vector arithmetic not implemented yet */ + return tarval_bad; + } + + if (get_mode_modulo_shift(a->mode) != 0) + { + temp_val = alloca(sc_get_buffer_length()); + + sc_val_from_ulong(get_mode_modulo_shift(a->mode), temp_val); + sc_mod(b->value, temp_val, temp_val); + } + else + temp_val = (char*)b->value; + + sc_shl(a->value, temp_val, get_mode_size_bits(a->mode), mode_is_signed(a->mode), NULL); return get_tarval(sc_get_buffer(), sc_get_buffer_length(), a->mode); } @@ -1161,12 +1359,28 @@ tarval *tarval_shl(tarval *a, tarval *b) */ tarval *tarval_shr(tarval *a, tarval *b) { + char *temp_val = NULL; ANNOUNCE(); assert(a); assert(b); assert(mode_is_int(a->mode) && mode_is_int(b->mode)); - sc_shr(a->value, b->value, get_mode_size_bits(a->mode), mode_is_signed(a->mode), NULL); + if (get_mode_n_vector_elems(a->mode) > 1 || get_mode_n_vector_elems(a->mode) > 1) { + /* vector arithmetic not implemented yet */ + return tarval_bad; + } + + if (get_mode_modulo_shift(a->mode) != 0) + { + temp_val = alloca(sc_get_buffer_length()); + + sc_val_from_ulong(get_mode_modulo_shift(a->mode), temp_val); + sc_mod(b->value, temp_val, temp_val); + } + else + temp_val = (char*)b->value; + + sc_shr(a->value, temp_val, get_mode_size_bits(a->mode), mode_is_signed(a->mode), NULL); return get_tarval(sc_get_buffer(), sc_get_buffer_length(), a->mode); } @@ -1175,12 +1389,28 @@ tarval *tarval_shr(tarval *a, tarval *b) */ tarval *tarval_shrs(tarval *a, tarval *b) { + char *temp_val = NULL; ANNOUNCE(); assert(a); assert(b); assert(mode_is_int(a->mode) && mode_is_int(b->mode)); - sc_shrs(a->value, b->value, get_mode_size_bits(a->mode), mode_is_signed(a->mode), NULL); + if (get_mode_n_vector_elems(a->mode) > 1 || get_mode_n_vector_elems(a->mode) > 1) { + /* vector arithmetic not implemented yet */ + return tarval_bad; + } + + if (get_mode_modulo_shift(a->mode) != 0) + { + temp_val = alloca(sc_get_buffer_length()); + + sc_val_from_ulong(get_mode_modulo_shift(a->mode), temp_val); + sc_mod(b->value, temp_val, temp_val); + } + else + temp_val = (char*)b->value; + + sc_shrs(a->value, temp_val, get_mode_size_bits(a->mode), mode_is_signed(a->mode), NULL); return get_tarval(sc_get_buffer(), sc_get_buffer_length(), a->mode); } @@ -1189,15 +1419,38 @@ tarval *tarval_shrs(tarval *a, tarval *b) */ tarval *tarval_rot(tarval *a, tarval *b) { + char *temp_val = NULL; ANNOUNCE(); assert(a); assert(b); assert(mode_is_int(a->mode) && mode_is_int(b->mode)); - sc_rot(a->value, b->value, get_mode_size_bits(a->mode), mode_is_signed(a->mode), NULL); + if (get_mode_n_vector_elems(a->mode) > 1 || get_mode_n_vector_elems(a->mode) > 1) { + /* vector arithmetic not implemented yet */ + return tarval_bad; + } + + if (get_mode_modulo_shift(a->mode) != 0) + { + temp_val = alloca(sc_get_buffer_length()); + + sc_val_from_ulong(get_mode_modulo_shift(a->mode), temp_val); + sc_mod(b->value, temp_val, temp_val); + } + else + temp_val = (char*)b->value; + + sc_rot(a->value, temp_val, get_mode_size_bits(a->mode), mode_is_signed(a->mode), NULL); 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 @@ -1227,17 +1480,17 @@ int tarval_snprintf(char *buf, size_t len, tarval *tv) case TVO_DECIMAL: str = sc_print(tv->value, get_mode_size_bits(tv->mode), SC_DEC); - break; + break; case TVO_OCTAL: str = sc_print(tv->value, get_mode_size_bits(tv->mode), SC_OCT); - break; + break; case TVO_HEX: case TVO_NATIVE: default: str = sc_print(tv->value, get_mode_size_bits(tv->mode), SC_HEX); - break; + break; } return snprintf(buf, len, "%s%s%s", prefix, str, suffix); @@ -1257,30 +1510,19 @@ int tarval_snprintf(char *buf, size_t len, tarval *tv) break; case irms_reference: - if (tv==tarval_P_void) return snprintf(buf, len, "NULL"); - if (tv->value != NULL) - if (tarval_is_entity(tv)) { - if (get_entity_peculiarity((entity *)tv->value) == existent) - return snprintf(buf, len, "%s%s%s", prefix, get_entity_ld_name((entity *)tv->value), suffix); - else { - if (mode_info->mode_output == TVO_NATIVE) - return snprintf(buf, len, "NULL"); - else - return snprintf(buf, len, "0"); - } - } + if (tv == tv->mode->null) return snprintf(buf, len, "NULL"); + if (tv->value != NULL) { + if (len > tv->length) { + memcpy(buf, tv->value, tv->length); + buf[tv->length] = '\0'; + } else { - if (size > tv->length) { - memcpy(buf, tv->value, tv->length); - buf[tv->length] = '\0'; - } - else { - /* truncated */ - memcpy(buf, tv->value, size-1); - buf[size-1] = '\0'; - } - return tv->length; - } + /* truncated */ + memcpy(buf, tv->value, len-1); + buf[len-1] = '\0'; + } + return tv->length; + } else return snprintf(buf, len, "void"); @@ -1301,7 +1543,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; @@ -1322,15 +1564,30 @@ int tarval_printf(tarval *tv) { } -char *tarval_bitpattern(tarval *tv) +char *get_tarval_bitpattern(tarval *tv) { - return NULL; + int i, j, pos = 0; + int n = get_mode_size_bits(tv->mode); + int bytes = (n + 7) / 8; + char *res = xmalloc((n + 1) * sizeof(char)); + unsigned char byte; + + for(i = 0; i < bytes; i++) { + byte = get_tarval_sub_bits(tv, i); + for(j = 1; j < 256; j <<= 1) + if(pos < n) + res[pos++] = j & byte ? '1' : '0'; + } + + res[n] = '\0'; + + return res; } /* * access to the bitpattern */ -unsigned char tarval_sub_bits(tarval *tv, unsigned byte_ofs) +unsigned char get_tarval_sub_bits(tarval *tv, unsigned byte_ofs) { switch (get_mode_sort(tv->mode)) { case irms_int_number: @@ -1352,7 +1609,7 @@ unsigned char tarval_sub_bits(tarval *tv, unsigned byte_ofs) * * Returns zero on success. */ -int tarval_set_mode_output_option(ir_mode *mode, const tarval_mode_info *modeinfo) +int set_tarval_mode_output_option(ir_mode *mode, const tarval_mode_info *modeinfo) { assert(mode); @@ -1363,35 +1620,78 @@ int tarval_set_mode_output_option(ir_mode *mode, const tarval_mode_info *modeinf /* * 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 *tarval_get_mode_output_option(ir_mode *mode) +const tarval_mode_info *get_tarval_mode_output_option(ir_mode *mode) { assert(mode); return mode->tv_priv; } - -/* Identifying some tarvals ??? */ -/* Implemented in old tv.c as such: - * return 0 for additive neutral, - * 1 for multiplicative neutral, - * -1 for bitwise-and neutral - * 2 else +/* + * Identifying tarvals values for algebraic simplifications. * - * Implemented for compatibility */ -long tarval_classify(tarval *tv) + * Returns: + * - TV_CLASSIFY_NULL for additive neutral or the NULL tarval for reference modes, + * - TV_CLASSIFY_ONE for multiplicative neutral, + * - TV_CLASSIFY_ALL_ONE for bitwise-and neutral + * - TV_CLASSIFY_OTHER else + */ +tarval_classification_t classify_tarval(tarval *tv) { ANNOUNCE(); - if (!tv || tv == tarval_bad) return 2; + if (!tv || tv == tarval_bad) return TV_CLASSIFY_OTHER; - if (tv == get_mode_null(tv->mode)) return 0; - else if (tv == get_mode_one(tv->mode)) return 1; + if (tv == get_mode_null(tv->mode)) + return TV_CLASSIFY_NULL; + else if (tv == get_mode_one(tv->mode)) + return TV_CLASSIFY_ONE; else if ((get_mode_sort(tv->mode) == irms_int_number) - && (tv == new_tarval_from_long(-1, tv->mode))) return -1; + && (tv == new_tarval_from_long(-1, tv->mode))) + return TV_CLASSIFY_ALL_ONE; - return 2; + return TV_CLASSIFY_OTHER; +} + +/* + * Returns non-zero if a given (integer) tarval has only one single bit + * set. + */ +int is_single_bit_tarval(tarval *tv) { + int i, l; + int bits; + + if (!tv || tv == tarval_bad) return 0; + if (! mode_is_int(tv->mode)) return 0; + + l = get_mode_size_bytes(tv->mode); + for (bits = 0, i = l - 1; i >= 0; --i) { + unsigned char v = get_tarval_sub_bits(tv, (unsigned)i); + + /* check for more than one bit in these */ + if (v) { + if (v & (v-1)) + return 0; + if (++bits > 1) + return 0; + } + } + return bits; +} + +/* + * 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; } /** @@ -1412,27 +1712,22 @@ static const tarval_mode_info reference_output = { ")", }; - /* * Initialization of the tarval module: called before init_mode() */ -void init_tarval_1(void) +void init_tarval_1(long null_value) { ANNOUNCE(); + _null_value = null_value; + /* initialize the sets holding the tarvals with a comparison function and * an initial size, which is the expected number of constants */ - tarvals = new_set(memcmp, TUNE_NCONSTANTS); - values = new_set(memcmp, TUNE_NCONSTANTS); + tarvals = new_set(memcmp, N_CONSTANTS); + values = new_set(memcmp, N_CONSTANTS); /* init strcalc with precision of 68 to support floating point values with 64 * bit mantissa (needs extra bits for rounding and overflow) */ init_strcalc(68); init_fltcalc(0); - - tarval_bad = (tarval*)malloc(sizeof(tarval)); - tarval_undefined = (tarval*)malloc(sizeof(tarval)); - tarval_b_true = (tarval*)malloc(sizeof(tarval)); - tarval_b_false = (tarval*)malloc(sizeof(tarval)); - tarval_P_void = (tarval*)malloc(sizeof(tarval)); } /* @@ -1442,27 +1737,45 @@ void init_tarval_2(void) { ANNOUNCE(); - tarval_bad->mode = mode_BAD; - tarval_undefined->mode = mode_ANY; - tarval_b_true->mode = mode_b; - tarval_b_false->mode = mode_b; - tarval_P_void->mode = mode_P; + tarval_bad->kind = k_tarval; + tarval_bad->mode = mode_BAD; + tarval_bad->value = INT_TO_PTR(resid_tarval_bad); + + tarval_undefined->kind = k_tarval; + tarval_undefined->mode = mode_ANY; + tarval_undefined->value = INT_TO_PTR(resid_tarval_undefined); + + tarval_b_true->kind = k_tarval; + tarval_b_true->mode = mode_b; + tarval_b_true->value = INT_TO_PTR(resid_tarval_b_true); + + tarval_b_false->kind = k_tarval; + tarval_b_false->mode = mode_b; + tarval_b_false->value = INT_TO_PTR(resid_tarval_b_false); /* * assign output modes that are compatible with the * old implementation: Hex output */ - tarval_set_mode_output_option(mode_U, &hex_output); - tarval_set_mode_output_option(mode_C, &hex_output); - tarval_set_mode_output_option(mode_Bs, &hex_output); - tarval_set_mode_output_option(mode_Bu, &hex_output); - tarval_set_mode_output_option(mode_Hs, &hex_output); - tarval_set_mode_output_option(mode_Hu, &hex_output); - tarval_set_mode_output_option(mode_Is, &hex_output); - tarval_set_mode_output_option(mode_Iu, &hex_output); - tarval_set_mode_output_option(mode_Ls, &hex_output); - tarval_set_mode_output_option(mode_Lu, &hex_output); - tarval_set_mode_output_option(mode_P, &reference_output); + set_tarval_mode_output_option(mode_U, &hex_output); + set_tarval_mode_output_option(mode_C, &hex_output); + set_tarval_mode_output_option(mode_Bs, &hex_output); + set_tarval_mode_output_option(mode_Bu, &hex_output); + set_tarval_mode_output_option(mode_Hs, &hex_output); + set_tarval_mode_output_option(mode_Hu, &hex_output); + set_tarval_mode_output_option(mode_Is, &hex_output); + set_tarval_mode_output_option(mode_Iu, &hex_output); + set_tarval_mode_output_option(mode_Ls, &hex_output); + set_tarval_mode_output_option(mode_Lu, &hex_output); + set_tarval_mode_output_option(mode_P, &reference_output); +} + +/* free all memory occupied by tarval. */ +void finish_tarval(void) { + finish_strcalc (); + finish_fltcalc (); + del_set(tarvals); tarvals = NULL; + del_set(values); values = NULL; } /****************************************************************************