X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Ftv%2Ftv.c;h=969e2fea57a494df647d193729148ec6fc1c8699;hb=cbe8608ae6f9a523d007919691104b444c92d004;hp=b6f4b66775b82a9df0092adae04beb0c268afe45;hpb=2fc3fe45a4abc32707b1028203317f423e17e8fb;p=libfirm diff --git a/ir/tv/tv.c b/ir/tv/tv.c index b6f4b6677..969e2fea5 100644 --- a/ir/tv/tv.c +++ b/ir/tv/tv.c @@ -24,34 +24,29 @@ * @date 2003 * @author Mathias Heil * @version $Id$ - * @summary + * @brief * * 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 "config.h" -#include /* assertions */ -#include /* atoi() */ -#ifdef HAVE_STRING_H -# include /* nice things for strings */ -#endif +#include +#include +#include #ifdef HAVE_STRINGS_H -#include /* strings.h also includes bsd only function strcasecmp */ -#endif -#ifdef HAVE_STDLIB_H -# include +#include #endif +#include +#include "bitfiddle.h" #include "tv_t.h" -#include "set.h" /* to store tarvals in */ -#include "entity_t.h" /* needed to store pointers to entities */ +#include "set.h" +#include "entity_t.h" #include "irmode_t.h" -#include "irnode.h" /* defines boolean return values (pnc_number)*/ +#include "irnode.h" #include "strcalc.h" #include "fltcalc.h" #include "irtools.h" @@ -63,16 +58,13 @@ target values */ #define N_CONSTANTS 2048 -/* get the integer overflow mode */ -#define GET_OVERFLOW_MODE() int_overflow_mode - /* unused, float to int doesn't work yet */ -enum float_to_int_mode { +typedef enum float_to_int_mode { TRUNCATE, ROUND -}; +} float_to_int_mode; -#define GET_FLOAT_TO_INT_MODE() TRUNCATE +static float_to_int_mode current_float_to_int_mode = TRUNCATE; #define SWITCH_NOINFINITY 0 #define SWITCH_NODENORMALS 0 @@ -99,6 +91,9 @@ static struct set *tarvals = NULL; /** A set containing all existing values. */ static struct set *values = NULL; +/** The carry flag for SOME operations. -1 means UNDEFINED here */ +static int carry_flag = -1; + /** The integer overflow mode. */ static tarval_int_overflow_mode_t int_overflow_mode = TV_OVERFLOW_WRAP; @@ -127,16 +122,15 @@ static void _fail_verify(tarval *tv, const char* file, int line) { /* print a memory image of the tarval and throw an assertion */ if (tv) - printf("%s:%d: Invalid tarval:\n mode: %s\n value: [%p]\n", file, line, get_mode_name(tv->mode), tv->value); + panic("%s:%d: Invalid tarval: mode: %F\n value: [%p]", file, line, tv->mode, tv->value); else - printf("%s:%d: Invalid tarval (null)", file, line); - assert(0); + panic("%s:%d: Invalid tarval (null)", file, line); } #ifdef __GNUC__ -INLINE static void tarval_verify(tarval *tv) __attribute__ ((unused)); +inline static void tarval_verify(tarval *tv) __attribute__ ((unused)); #endif -INLINE static void tarval_verify(tarval *tv) +inline static void tarval_verify(tarval *tv) { assert(tv); assert(tv->mode); @@ -151,12 +145,14 @@ INLINE static void tarval_verify(tarval *tv) #endif /* NDEBUG */ /** Hash a tarval. */ -static int hash_tv(tarval *tv) { +static int hash_tv(tarval *tv) +{ return (PTR_TO_INT(tv->value) ^ PTR_TO_INT(tv->mode)) + tv->length; } /** Hash a value. Treat it as a byte array. */ -static int hash_val(const void *value, unsigned int length) { +static int hash_val(const void *value, unsigned int length) +{ unsigned int i; unsigned int hash = 0; @@ -169,7 +165,8 @@ static int hash_val(const void *value, unsigned int length) { return hash; } -static int cmp_tv(const void *p1, const void *p2, size_t n) { +static int cmp_tv(const void *p1, const void *p2, size_t n) +{ const tarval *tv1 = p1; const tarval *tv2 = p2; (void) n; @@ -193,7 +190,8 @@ static int cmp_tv(const void *p1, const void *p2, size_t n) { } /** finds tarval with value/mode or creates new tarval */ -static tarval *get_tarval(const void *value, int length, ir_mode *mode) { +static tarval *get_tarval(const void *value, int length, ir_mode *mode) +{ tarval tv; tv.kind = k_tarval; @@ -235,7 +233,7 @@ 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()) { + switch (tarval_get_integer_overflow_mode()) { case TV_OVERFLOW_SATURATE: return get_mode_max(mode); case TV_OVERFLOW_WRAP: @@ -252,7 +250,7 @@ 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()) { + switch (tarval_get_integer_overflow_mode()) { case TV_OVERFLOW_SATURATE: return get_mode_min(mode); case TV_OVERFLOW_WRAP: { @@ -270,15 +268,19 @@ static tarval *get_tarval_overflow(const void *value, int length, ir_mode *mode) break; case irms_float_number: - if (SWITCH_NOINFINITY && fc_is_inf(value)) { +#ifdef SWITCH_NOINFINITY + if (fc_is_inf(value)) { /* clip infinity to maximum value */ return fc_is_negative(value) ? get_mode_min(mode) : get_mode_max(mode); } +#endif - if (SWITCH_NODENORMALS && fc_is_subnormal(value)) { +#ifdef SWITCH_NODENORMALS + if (fc_is_subnormal(value)) { /* clip denormals to zero */ return get_mode_null(mode); } +#endif break; default: @@ -302,23 +304,88 @@ tarval *tarval_unreachable = &reserved_tv[5]; /** * get the float descriptor for given mode. */ -static const ieee_descriptor_t *get_descriptor(const ir_mode *mode) { +static const ieee_descriptor_t *get_descriptor(const ir_mode *mode) +{ switch (get_mode_size_bits(mode)) { case 16: return &half_desc; case 32: return &single_desc; case 64: return &double_desc; case 80: - case 96: return &extended_desc; - case 128: return &quad_desc; + case 96: + case 128: return &extended_desc; /* FIXME: HACK for x86 where we have + sizeof(long double)==16 with 10 byte + real payload */ + /* case 128: return &quad_desc; */ default: panic("Unsupported mode in get_descriptor()"); - return NULL; } } -/* - * public functions declared in tv.h - */ +tarval *new_integer_tarval_from_str(const char *str, size_t len, char sign, + unsigned char base, ir_mode *mode) +{ + void *buffer; + int ok; + + buffer = alloca(sc_get_buffer_length()); + + ok = sc_val_from_str(sign, base, str, len, buffer); + if (!ok) + return tarval_bad; + + return get_tarval_overflow(buffer, sc_get_buffer_length(), mode); +} + +static tarval *new_tarval_from_str_int(const char *str, size_t len, + ir_mode *mode) +{ + void *buffer; + unsigned base = 10; + char sign = 1; + int ok; + + /* skip leading spaces */ + while (len > 0 && str[0] == ' ') { + ++str; + --len; + } + if (len == 0) + return tarval_bad; + + /* 1 sign character allowed */ + if (str[0] == '-') { + sign = -1; + ++str; + --len; + } else if (str[0] == '+') { + ++str; + --len; + } + + /* a number starting with '0x' is hexadeciaml, + * a number starting with '0' (and at least 1 more char) is octal */ + if (len >= 2 && str[0] == '0') { + if (str[1] == 'x' || str[1] == 'X') { + str += 2; + len -= 2; + base = 16; + } else { + ++str; + --len; + base = 8; + } + } + if (len == 0) + return tarval_bad; + + buffer = alloca(sc_get_buffer_length()); + + ok = sc_val_from_str(sign, base, str, len, buffer); + if (!ok) + return tarval_bad; + + return get_tarval_overflow(buffer, sc_get_buffer_length(), mode); +} /* * Constructors ============================================================= @@ -335,15 +402,14 @@ tarval *new_tarval_from_str(const char *str, size_t len, ir_mode *mode) case irms_control_flow: case irms_memory: case irms_auxiliary: - assert(0); - break; + panic("Unsupported tarval creation with mode %F", mode); case irms_internal_boolean: /* match [tT][rR][uU][eE]|[fF][aA][lL][sS][eE] */ - if (strcasecmp(str, "true")) - return tarval_b_true; - else if (strcasecmp(str, "false")) + if (!strcasecmp(str, "true")) return tarval_b_true; + else if (!strcasecmp(str, "false")) + return tarval_b_false; else /* XXX This is C semantics */ return atoi(str) ? tarval_b_true : tarval_b_false; @@ -354,20 +420,20 @@ 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 */ + if (!strcasecmp(str, "null")) + return get_tarval_null(mode); + /* FALLTHROUGH */ case irms_int_number: - sc_val_from_str(str, len, NULL, mode); - return get_tarval(sc_get_buffer(), sc_get_buffer_length(), mode); + return new_tarval_from_str_int(str, len, mode); } - - assert(0); /* can't be reached, can it? */ - return NULL; + panic("Unsupported tarval creation with mode %F", mode); } /* * helper function, create a tarval from long */ -tarval *new_tarval_from_long(long l, ir_mode *mode) { +tarval *new_tarval_from_long(long l, ir_mode *mode) +{ assert(mode); switch (get_mode_sort(mode)) { @@ -385,13 +451,13 @@ tarval *new_tarval_from_long(long l, ir_mode *mode) { return new_tarval_from_double((long double)l, mode); default: - assert(0 && "unsupported mode sort"); + panic("unsupported mode sort"); } - return NULL; } /* returns non-zero if can be converted to long */ -int tarval_is_long(tarval *tv) { +int tarval_is_long(tarval *tv) +{ if (!mode_is_int(tv->mode) && !mode_is_reference(tv->mode)) return 0; @@ -407,13 +473,15 @@ int tarval_is_long(tarval *tv) { } /* this might overflow the machine's long, so use only with small values */ -long get_tarval_long(tarval* tv) { +long get_tarval_long(tarval* tv) +{ assert(tarval_is_long(tv) && "tarval too big to fit in long"); return sc_val_to_long(tv->value); } -tarval *new_tarval_from_double(long double d, ir_mode *mode) { +tarval *new_tarval_from_double(long double d, ir_mode *mode) +{ const ieee_descriptor_t *desc; assert(mode && (get_mode_sort(mode) == irms_float_number)); @@ -423,13 +491,15 @@ tarval *new_tarval_from_double(long double d, ir_mode *mode) { } /* returns non-zero if can be converted to double */ -int tarval_is_double(tarval *tv) { +int tarval_is_double(tarval *tv) +{ assert(tv); return (get_mode_sort(tv->mode) == irms_float_number); } -long double get_tarval_double(tarval *tv) { +long double get_tarval_double(tarval *tv) +{ assert(tarval_is_double(tv)); return fc_val_to_ieee754(tv->value); @@ -441,7 +511,8 @@ long double get_tarval_double(tarval *tv) { */ /* get the mode of the tarval */ -ir_mode *(get_tarval_mode)(const tarval *tv) { +ir_mode *(get_tarval_mode)(const tarval *tv) +{ return _get_tarval_mode(tv); } @@ -455,31 +526,38 @@ ir_mode *(get_tarval_mode)(const tarval *tv) { * therefore the irmode functions should be preferred to the functions below. */ -tarval *(get_tarval_bad)(void) { +tarval *(get_tarval_bad)(void) +{ return _get_tarval_bad(); } -tarval *(get_tarval_undefined)(void) { +tarval *(get_tarval_undefined)(void) +{ return _get_tarval_undefined(); } -tarval *(get_tarval_b_false)(void) { +tarval *(get_tarval_b_false)(void) +{ return _get_tarval_b_false(); } -tarval *(get_tarval_b_true)(void) { +tarval *(get_tarval_b_true)(void) +{ return _get_tarval_b_true(); } -tarval *(get_tarval_reachable)(void) { +tarval *(get_tarval_reachable)(void) +{ return _get_tarval_reachable(); } -tarval *(get_tarval_unreachable)(void) { +tarval *(get_tarval_unreachable)(void) +{ return _get_tarval_unreachable(); } -tarval *get_tarval_max(ir_mode *mode) { +tarval *get_tarval_max(ir_mode *mode) +{ const ieee_descriptor_t *desc; assert(mode); @@ -492,8 +570,7 @@ tarval *get_tarval_max(ir_mode *mode) { case irms_control_flow: case irms_memory: case irms_auxiliary: - assert(0); - break; + panic("mode %F does not support maximum value", mode); case irms_internal_boolean: return tarval_b_true; @@ -511,7 +588,8 @@ tarval *get_tarval_max(ir_mode *mode) { return tarval_bad; } -tarval *get_tarval_min(ir_mode *mode) { +tarval *get_tarval_min(ir_mode *mode) +{ const ieee_descriptor_t *desc; assert(mode); @@ -524,8 +602,7 @@ tarval *get_tarval_min(ir_mode *mode) { case irms_control_flow: case irms_memory: case irms_auxiliary: - assert(0); - break; + panic("mode %F does not support minimum value", mode); case irms_internal_boolean: return tarval_b_false; @@ -546,7 +623,8 @@ tarval *get_tarval_min(ir_mode *mode) { /** The bit pattern for the pointer NULL */ static long _null_value = 0; -tarval *get_tarval_null(ir_mode *mode) { +tarval *get_tarval_null(ir_mode *mode) +{ assert(mode); if (get_mode_n_vector_elems(mode) > 1) { @@ -558,8 +636,7 @@ tarval *get_tarval_null(ir_mode *mode) { case irms_control_flow: case irms_memory: case irms_auxiliary: - assert(0); - break; + panic("mode %F does not support null value", mode); case irms_float_number: return new_tarval_from_double(0.0, mode); @@ -574,21 +651,18 @@ tarval *get_tarval_null(ir_mode *mode) { return tarval_bad; } -tarval *get_tarval_one(ir_mode *mode) { +tarval *get_tarval_one(ir_mode *mode) +{ assert(mode); - if (get_mode_n_vector_elems(mode) > 1) { - /* vector arithmetic not implemented yet */ - assert(0); - return tarval_bad; - } + if (get_mode_n_vector_elems(mode) > 1) + panic("vector arithmetic not implemented yet"); switch (get_mode_sort(mode)) { case irms_control_flow: case irms_memory: case irms_auxiliary: - assert(0); - break; + panic("mode %F does not support one value", mode); case irms_internal_boolean: return tarval_b_true; @@ -603,21 +677,18 @@ tarval *get_tarval_one(ir_mode *mode) { return tarval_bad; } -tarval *get_tarval_all_one(ir_mode *mode) { +tarval *get_tarval_all_one(ir_mode *mode) +{ assert(mode); - if (get_mode_n_vector_elems(mode) > 1) { - /* vector arithmetic not implemented yet */ - assert(0); - return tarval_bad; - } + if (get_mode_n_vector_elems(mode) > 1) + panic("vector arithmetic not implemented yet"); switch (get_mode_sort(mode)) { case irms_control_flow: case irms_memory: case irms_auxiliary: - assert(0); - return tarval_bad; + panic("mode %F does not support all-one value", mode); case irms_int_number: case irms_internal_boolean: @@ -631,7 +702,8 @@ tarval *get_tarval_all_one(ir_mode *mode) { return tarval_bad; } -int tarval_is_constant(tarval *tv) { +int tarval_is_constant(tarval *tv) +{ int num_res = sizeof(reserved_tv) / sizeof(reserved_tv[0]); /* reserved tarvals are NOT constants. Note that although @@ -639,21 +711,19 @@ int tarval_is_constant(tarval *tv) { return (tv < &reserved_tv[2] || tv > &reserved_tv[num_res - 1]); } -tarval *get_tarval_minus_one(ir_mode *mode) { +tarval *get_tarval_minus_one(ir_mode *mode) +{ assert(mode); - if (get_mode_n_vector_elems(mode) > 1) { - /* vector arithmetic not implemented yet */ - return tarval_bad; - } + if (get_mode_n_vector_elems(mode) > 1) + panic("vector arithmetic not implemented yet"); switch (get_mode_sort(mode)) { case irms_control_flow: case irms_memory: case irms_auxiliary: case irms_internal_boolean: - assert(0); - break; + panic("mode %F does not support minus one value", mode); case irms_reference: return tarval_bad; @@ -667,75 +737,62 @@ tarval *get_tarval_minus_one(ir_mode *mode) { return tarval_bad; } -tarval *get_tarval_nan(ir_mode *mode) { +tarval *get_tarval_nan(ir_mode *mode) +{ const ieee_descriptor_t *desc; assert(mode); - if (get_mode_n_vector_elems(mode) > 1) { - /* vector arithmetic not implemented yet */ - return tarval_bad; - } + if (get_mode_n_vector_elems(mode) > 1) + panic("vector arithmetic not implemented yet"); if (get_mode_sort(mode) == irms_float_number) { desc = get_descriptor(mode); fc_get_qnan(desc, NULL); return get_tarval(fc_get_buffer(), fc_get_buffer_length(), mode); - } else { - assert(0 && "tarval is not floating point"); - return tarval_bad; - } + } else + panic("mode %F does not support NaN value", mode); } -tarval *get_tarval_plus_inf(ir_mode *mode) { +tarval *get_tarval_plus_inf(ir_mode *mode) +{ assert(mode); - if (get_mode_n_vector_elems(mode) > 1) { - /* vector arithmetic not implemented yet */ - return tarval_bad; - } + if (get_mode_n_vector_elems(mode) > 1) + panic("vector arithmetic not implemented yet"); if (get_mode_sort(mode) == irms_float_number) { const ieee_descriptor_t *desc = get_descriptor(mode); fc_get_plusinf(desc, NULL); return get_tarval(fc_get_buffer(), fc_get_buffer_length(), mode); - } else { - assert(0 && "tarval is not floating point"); - return tarval_bad; - } + } else + panic("mode %F does not support +inf value", mode); } -tarval *get_tarval_minus_inf(ir_mode *mode) { +tarval *get_tarval_minus_inf(ir_mode *mode) +{ assert(mode); - if (get_mode_n_vector_elems(mode) > 1) { - /* vector arithmetic not implemented yet */ - return tarval_bad; - } + if (get_mode_n_vector_elems(mode) > 1) + panic("vector arithmetic not implemented yet"); if (get_mode_sort(mode) == irms_float_number) { const ieee_descriptor_t *desc = get_descriptor(mode); fc_get_minusinf(desc, NULL); return get_tarval(fc_get_buffer(), fc_get_buffer_length(), mode); - } else { - assert(0 && "tarval is not floating point"); - return tarval_bad; - } + } else + panic("mode %F does not support -inf value", mode); } /* - * Arithmethic operations on tarvals ======================================== + * Arithmetic operations on tarvals ======================================== */ /* * test if negative number, 1 means 'yes' */ -int tarval_is_negative(tarval *a) { - 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; - } +int tarval_is_negative(tarval *a) +{ + if (get_mode_n_vector_elems(a->mode) > 1) + panic("vector arithmetic not implemented yet"); switch (get_mode_sort(a->mode)) { case irms_int_number: @@ -747,15 +804,15 @@ int tarval_is_negative(tarval *a) { return fc_is_negative(a->value); default: - assert(0 && "not implemented"); - return 0; + panic("mode %F does not support negation value", a->mode); } } /* * test if null, 1 means 'yes' */ -int tarval_is_null(tarval *a) { +int tarval_is_null(tarval *a) +{ return a != tarval_bad && a == get_mode_null(get_tarval_mode(a)); @@ -764,13 +821,15 @@ int tarval_is_null(tarval *a) { /* * test if one, 1 means 'yes' */ -int tarval_is_one(tarval *a) { +int tarval_is_one(tarval *a) +{ return a != tarval_bad && a == get_mode_one(get_tarval_mode(a)); } -int tarval_is_all_one(tarval *tv) { +int tarval_is_all_one(tarval *tv) +{ return tv != tarval_bad && tv == get_mode_all_one(get_tarval_mode(tv)); @@ -779,7 +838,8 @@ int tarval_is_all_one(tarval *tv) { /* * test if one, 1 means 'yes' */ -int tarval_is_minus_one(tarval *a) { +int tarval_is_minus_one(tarval *a) +{ return a != tarval_bad && a == get_mode_minus_one(get_tarval_mode(a)); @@ -788,13 +848,12 @@ int tarval_is_minus_one(tarval *a) { /* * comparison */ -pn_Cmp tarval_cmp(tarval *a, tarval *b) { - assert(a); - assert(b); +pn_Cmp tarval_cmp(tarval *a, tarval *b) +{ + carry_flag = -1; if (a == tarval_bad || b == tarval_bad) { - assert(0 && "Comparison with tarval_bad"); - return pn_Cmp_False; + panic("Comparison with tarval_bad"); } if (a == tarval_undefined || b == tarval_undefined) @@ -805,7 +864,7 @@ pn_Cmp tarval_cmp(tarval *a, tarval *b) { if (get_mode_n_vector_elems(a->mode) > 1) { /* vector arithmetic not implemented yet */ - assert(0 && "cmp not implemented for vector modes"); + panic("cmp not implemented for vector modes"); } /* Here the two tarvals are unequal and of the same mode */ @@ -849,10 +908,14 @@ pn_Cmp tarval_cmp(tarval *a, tarval *b) { /* * convert to other mode */ -tarval *tarval_convert_to(tarval *src, ir_mode *dst_mode) { +tarval *tarval_convert_to(tarval *src, ir_mode *dst_mode) +{ char *buffer; fp_value *res; const ieee_descriptor_t *desc; + int len; + + carry_flag = -1; assert(src); assert(dst_mode); @@ -880,16 +943,13 @@ tarval *tarval_convert_to(tarval *src, ir_mode *dst_mode) { return get_tarval(fc_get_buffer(), fc_get_buffer_length(), dst_mode); case irms_int_number: - switch (GET_FLOAT_TO_INT_MODE()) { + switch (current_float_to_int_mode) { case TRUNCATE: res = fc_int(src->value, NULL); break; case ROUND: res = fc_rnd(src->value, NULL); break; - default: - panic("Unsupported float to int conversion mode in tarval_convert_to()"); - break; } buffer = alloca(sc_get_buffer_length()); if (! fc_flt2int(res, buffer, dst_mode)) @@ -925,11 +985,11 @@ tarval *tarval_convert_to(tarval *src, ir_mode *dst_mode) { buffer = alloca(100); /* decimal string representation because hexadecimal output is * interpreted unsigned by fc_val_from_str, so this is a HACK */ - snprintf(buffer, 100, "%s", + len = snprintf(buffer, 100, "%s", sc_print(src->value, get_mode_size_bits(src->mode), SC_DEC, mode_is_signed(src->mode))); buffer[100 - 1] = '\0'; desc = get_descriptor(dst_mode); - fc_val_from_str(buffer, 0, desc, NULL); + fc_val_from_str(buffer, len, desc, NULL); return get_tarval(fc_get_buffer(), fc_get_buffer_length(), dst_mode); default: @@ -959,10 +1019,11 @@ tarval *tarval_convert_to(tarval *src, ir_mode *dst_mode) { /* * bitwise negation */ -tarval *tarval_not(tarval *a) { +tarval *tarval_not(tarval *a) +{ char *buffer; - assert(a); + carry_flag = -1; /* works for vector mode without changes */ @@ -981,20 +1042,21 @@ tarval *tarval_not(tarval *a) { return tarval_bad; default: - assert(0 && "bitwise negation is only allowed for integer and boolean"); - return tarval_bad; + panic("bitwise negation is only allowed for integer and boolean"); } } /* * arithmetic negation */ -tarval *tarval_neg(tarval *a) { +tarval *tarval_neg(tarval *a) +{ char *buffer; - assert(a); assert(mode_is_num(a->mode)); /* negation only for numerical values */ + carry_flag = -1; + /* note: negation is allowed even for unsigned modes. */ if (get_mode_n_vector_elems(a->mode) > 1) { @@ -1024,74 +1086,54 @@ tarval *tarval_neg(tarval *a) { /* * addition */ -tarval *tarval_add(tarval *a, tarval *b) { - tarval *res; - char *buffer; - ir_mode *imm_mode, *dst_mode = NULL; +tarval *tarval_add(tarval *a, tarval *b) +{ + char *buffer; - assert(a); - assert(b); + carry_flag = -1; 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; } - if (mode_is_reference(a->mode)) { - dst_mode = a->mode; - imm_mode = find_unsigned_mode(a->mode); - - if (imm_mode == NULL) - return tarval_bad; - - a = tarval_convert_to(a, imm_mode); - b = tarval_convert_to(b, imm_mode); - } - if (mode_is_reference(b->mode)) { - dst_mode = b->mode; - imm_mode = find_unsigned_mode(b->mode); - - if (imm_mode == 0) - return tarval_bad; - - a = tarval_convert_to(a, imm_mode); - b = tarval_convert_to(b, imm_mode); + if (mode_is_reference(a->mode) && a->mode != b->mode) { + b = tarval_convert_to(b, a->mode); + } else if (mode_is_reference(b->mode) && b->mode != a->mode) { + a = tarval_convert_to(a, b->mode); } assert(a->mode == b->mode); switch (get_mode_sort(a->mode)) { + case irms_reference: case irms_int_number: /* modes of a,b are equal, so result has mode of a as this might be the character */ buffer = alloca(sc_get_buffer_length()); sc_add(a->value, b->value, buffer); - res = get_tarval_overflow(buffer, a->length, a->mode); - break; + carry_flag = sc_get_bit_at(buffer, get_mode_size_bits(a->mode)); + return get_tarval_overflow(buffer, a->length, a->mode); case irms_float_number: if (no_float) return tarval_bad; fc_add(a->value, b->value, NULL); - res = get_tarval_overflow(fc_get_buffer(), fc_get_buffer_length(), a->mode); - break; + return get_tarval_overflow(fc_get_buffer(), fc_get_buffer_length(), a->mode); default: return tarval_bad; } - if (dst_mode != NULL) - return tarval_convert_to(res, dst_mode); - return res; } /* * subtraction */ -tarval *tarval_sub(tarval *a, tarval *b, ir_mode *dst_mode) { +tarval *tarval_sub(tarval *a, tarval *b, ir_mode *dst_mode) +{ char *buffer; - assert(a); - assert(b); + carry_flag = -1; if (get_mode_n_vector_elems(a->mode) > 1 || get_mode_n_vector_elems(b->mode) > 1) { /* vector arithmetic not implemented yet */ @@ -1099,21 +1141,20 @@ tarval *tarval_sub(tarval *a, tarval *b, ir_mode *dst_mode) { } if (dst_mode != NULL) { - if (mode_is_reference(a->mode)) { + if (a->mode != dst_mode) a = tarval_convert_to(a, dst_mode); - } - if (mode_is_reference(b->mode)) { + if (b->mode != dst_mode) b = tarval_convert_to(b, dst_mode); - } - assert(a->mode == dst_mode); } assert(a->mode == b->mode); switch (get_mode_sort(a->mode)) { + case irms_reference: case irms_int_number: /* modes of a,b are equal, so result has mode of a as this might be the character */ buffer = alloca(sc_get_buffer_length()); sc_sub(a->value, b->value, buffer); + carry_flag = sc_get_bit_at(buffer, get_mode_size_bits(a->mode)); return get_tarval_overflow(buffer, a->length, a->mode); case irms_float_number: @@ -1131,13 +1172,14 @@ tarval *tarval_sub(tarval *a, tarval *b, ir_mode *dst_mode) { /* * multiplication */ -tarval *tarval_mul(tarval *a, tarval *b) { +tarval *tarval_mul(tarval *a, tarval *b) +{ char *buffer; - assert(a); - assert(b); assert(a->mode == b->mode); + carry_flag = -1; + if (get_mode_n_vector_elems(a->mode) > 1) { /* vector arithmetic not implemented yet */ return tarval_bad; @@ -1165,11 +1207,12 @@ tarval *tarval_mul(tarval *a, tarval *b) { /* * floating point division */ -tarval *tarval_quo(tarval *a, tarval *b) { - assert(a); - assert(b); +tarval *tarval_quo(tarval *a, tarval *b) +{ assert((a->mode == b->mode) && mode_is_float(a->mode)); + carry_flag = -1; + if (no_float) return tarval_bad; @@ -1186,11 +1229,12 @@ tarval *tarval_quo(tarval *a, tarval *b) { * integer division * overflow is impossible, but look out for division by zero */ -tarval *tarval_div(tarval *a, tarval *b) { - assert(a); - assert(b); +tarval *tarval_div(tarval *a, tarval *b) +{ assert((a->mode == b->mode) && mode_is_int(a->mode)); + carry_flag = -1; + if (get_mode_n_vector_elems(a->mode) > 1) { /* vector arithmetic not implemented yet */ return tarval_bad; @@ -1207,11 +1251,12 @@ tarval *tarval_div(tarval *a, tarval *b) { * remainder * overflow is impossible, but look out for division by zero */ -tarval *tarval_mod(tarval *a, tarval *b) { - assert(a); - assert(b); +tarval *tarval_mod(tarval *a, tarval *b) +{ assert((a->mode == b->mode) && mode_is_int(a->mode)); + carry_flag = -1; + if (get_mode_n_vector_elems(a->mode) > 1) { /* vector arithmetic not implemented yet */ return tarval_bad; @@ -1228,15 +1273,16 @@ tarval *tarval_mod(tarval *a, tarval *b) { * integer division AND remainder * overflow is impossible, but look out for division by zero */ -tarval *tarval_divmod(tarval *a, tarval *b, tarval **mod) { +tarval *tarval_divmod(tarval *a, tarval *b, tarval **mod) +{ int len = sc_get_buffer_length(); char *div_res = alloca(len); char *mod_res = alloca(len); - assert(a); - assert(b); assert((a->mode == b->mode) && mode_is_int(a->mode)); + carry_flag = -1; + if (get_mode_n_vector_elems(a->mode) > 1) { /* vector arithmetic not implemented yet */ return tarval_bad; @@ -1254,10 +1300,11 @@ tarval *tarval_divmod(tarval *a, tarval *b, tarval **mod) { /* * absolute value */ -tarval *tarval_abs(tarval *a) { +tarval *tarval_abs(tarval *a) +{ char *buffer; - assert(a); + carry_flag = -1; assert(mode_is_num(a->mode)); if (get_mode_n_vector_elems(a->mode) > 1) { @@ -1286,7 +1333,7 @@ tarval *tarval_abs(tarval *a) { return a; default: - return tarval_bad; + break; } return tarval_bad; } @@ -1294,12 +1341,12 @@ tarval *tarval_abs(tarval *a) { /* * bitwise and */ -tarval *tarval_and(tarval *a, tarval *b) { - assert(a); - assert(b); +tarval *tarval_and(tarval *a, tarval *b) +{ assert(a->mode == b->mode); /* works even for vector modes */ + carry_flag = 0; switch (get_mode_sort(a->mode)) { case irms_internal_boolean: @@ -1310,20 +1357,39 @@ tarval *tarval_and(tarval *a, tarval *b) { return get_tarval(sc_get_buffer(), sc_get_buffer_length(), a->mode); default: - assert(0 && "operation not defined on mode"); - return tarval_bad; + panic("operation not defined on mode"); + } +} + +tarval *tarval_andnot(tarval *a, tarval *b) +{ + assert(a->mode == b->mode); + + /* works even for vector modes */ + carry_flag = 0; + + switch (get_mode_sort(a->mode)) { + case irms_internal_boolean: + return a == tarval_b_true && b == tarval_b_false ? tarval_b_true : tarval_b_false; + + case irms_int_number: + sc_andnot(a->value, b->value, NULL); + return get_tarval(sc_get_buffer(), sc_get_buffer_length(), a->mode); + + default: + panic("operation not defined on mode"); } } /* * bitwise or */ -tarval *tarval_or(tarval *a, tarval *b) { - assert(a); - assert(b); +tarval *tarval_or(tarval *a, tarval *b) +{ assert(a->mode == b->mode); /* works even for vector modes */ + carry_flag = 0; switch (get_mode_sort(a->mode)) { case irms_internal_boolean: @@ -1334,20 +1400,19 @@ tarval *tarval_or(tarval *a, tarval *b) { return get_tarval(sc_get_buffer(), sc_get_buffer_length(), a->mode); default: - assert(0 && "operation not defined on mode"); - return tarval_bad; + panic("operation not defined on mode"); } } /* * bitwise exclusive or (xor) */ -tarval *tarval_eor(tarval *a, tarval *b) { - assert(a); - assert(b); +tarval *tarval_eor(tarval *a, tarval *b) +{ assert((a->mode == b->mode)); /* works even for vector modes */ + carry_flag = 0; switch (get_mode_sort(a->mode)) { case irms_internal_boolean: @@ -1358,21 +1423,21 @@ tarval *tarval_eor(tarval *a, tarval *b) { return get_tarval(sc_get_buffer(), sc_get_buffer_length(), a->mode); default: - assert(0 && "operation not defined on mode"); - return tarval_bad;; + panic("operation not defined on mode"); } } /* * bitwise left shift */ -tarval *tarval_shl(tarval *a, tarval *b) { +tarval *tarval_shl(tarval *a, tarval *b) +{ char *temp_val = NULL; - assert(a); - assert(b); assert(mode_is_int(a->mode) && mode_is_int(b->mode)); + carry_flag = -1; + 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; @@ -1393,13 +1458,14 @@ tarval *tarval_shl(tarval *a, tarval *b) { /* * bitwise unsigned right shift */ -tarval *tarval_shr(tarval *a, tarval *b) { +tarval *tarval_shr(tarval *a, tarval *b) +{ char *temp_val = NULL; - assert(a); - assert(b); assert(mode_is_int(a->mode) && mode_is_int(b->mode)); + carry_flag = -1; + 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; @@ -1420,13 +1486,14 @@ tarval *tarval_shr(tarval *a, tarval *b) { /* * bitwise signed right shift */ -tarval *tarval_shrs(tarval *a, tarval *b) { +tarval *tarval_shrs(tarval *a, tarval *b) +{ char *temp_val = NULL; - assert(a); - assert(b); assert(mode_is_int(a->mode) && mode_is_int(b->mode)); + carry_flag = -1; + 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; @@ -1447,13 +1514,14 @@ tarval *tarval_shrs(tarval *a, tarval *b) { /* * bitwise rotation to left */ -tarval *tarval_rotl(tarval *a, tarval *b) { +tarval *tarval_rotl(tarval *a, tarval *b) +{ char *temp_val = NULL; - assert(a); - assert(b); assert(mode_is_int(a->mode) && mode_is_int(b->mode)); + carry_flag = -1; + 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; @@ -1474,15 +1542,18 @@ tarval *tarval_rotl(tarval *a, tarval *b) { /* * carry flag of the last operation */ -int tarval_carry(void) { - panic("tarval_carry() requetsed: not implemented on all operations"); - return sc_had_carry(); +int tarval_carry(void) +{ + if (carry_flag == -1) + panic("Carry undefined for the last operation"); + return carry_flag; } /* * Output of tarvals */ -int tarval_snprintf(char *buf, size_t len, tarval *tv) { +int tarval_snprintf(char *buf, size_t len, tarval *tv) +{ static const tarval_mode_info default_info = { TVO_NATIVE, NULL, NULL }; const char *str; @@ -1499,7 +1570,7 @@ int tarval_snprintf(char *buf, size_t len, tarval *tv) { switch (get_mode_sort(tv->mode)) { case irms_reference: if (tv == tv->mode->null) return snprintf(buf, len, "NULL"); - /* fall through */ + /* FALLTHROUGH */ case irms_int_number: switch (mode_info->mode_output) { @@ -1511,8 +1582,9 @@ int tarval_snprintf(char *buf, size_t len, tarval *tv) { str = sc_print(tv->value, get_mode_size_bits(tv->mode), SC_OCT, 0); break; - case TVO_HEX: case TVO_NATIVE: + prefix = "0x"; + case TVO_HEX: default: str = sc_print(tv->value, get_mode_size_bits(tv->mode), SC_HEX, 0); break; @@ -1568,27 +1640,29 @@ int tarval_snprintf(char *buf, size_t len, tarval *tv) { /** * Output of tarvals to stdio. */ -int tarval_printf(tarval *tv) { +int tarval_printf(tarval *tv) +{ char buf[1024]; int res; res = tarval_snprintf(buf, sizeof(buf), tv); assert(res < (int) sizeof(buf) && "buffer to small for tarval_snprintf"); - printf(buf); + printf("%s", buf); return res; } -char *get_tarval_bitpattern(tarval *tv) { +char *get_tarval_bitpattern(tarval *tv) +{ 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)); + char *res = XMALLOCN(char, n + 1); unsigned char byte; - for(i = 0; i < bytes; i++) { + for (i = 0; i < bytes; i++) { byte = get_tarval_sub_bits(tv, i); - for(j = 1; j < 256; j <<= 1) - if(pos < n) + for (j = 1; j < 256; j <<= 1) + if (pos < n) res[pos++] = j & byte ? '1' : '0'; } @@ -1600,7 +1674,8 @@ char *get_tarval_bitpattern(tarval *tv) { /* * access to the bitpattern */ -unsigned char get_tarval_sub_bits(tarval *tv, unsigned byte_ofs) { +unsigned char get_tarval_sub_bits(tarval *tv, unsigned byte_ofs) +{ switch (get_mode_arithmetic(tv->mode)) { case irma_twos_complement: return sc_sub_bits(tv->value, get_mode_size_bits(tv->mode), byte_ofs); @@ -1618,7 +1693,8 @@ unsigned char get_tarval_sub_bits(tarval *tv, unsigned byte_ofs) { * * Returns zero on success. */ -int set_tarval_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); mode->tv_priv = modeinfo; @@ -1630,7 +1706,8 @@ int set_tarval_mode_output_option(ir_mode *mode, const tarval_mode_info *modein * * This functions returns the mode info of a given mode. */ -const tarval_mode_info *get_tarval_mode_output_option(ir_mode *mode) { +const tarval_mode_info *get_tarval_mode_output_option(ir_mode *mode) +{ assert(mode); return mode->tv_priv; @@ -1640,7 +1717,8 @@ const tarval_mode_info *get_tarval_mode_output_option(ir_mode *mode) { * Returns non-zero if a given (integer) tarval has only one single bit * set. */ -int tarval_is_single_bit(tarval *tv) { +int tarval_is_single_bit(tarval *tv) +{ int i, l; int bits; @@ -1662,17 +1740,63 @@ int tarval_is_single_bit(tarval *tv) { return bits; } +/* + * Return the number of set bits in a given (integer) tarval. + */ +int get_tarval_popcount(tarval *tv) +{ + int i, l; + int bits; + + if (!tv || tv == tarval_bad) return -1; + if (! mode_is_int(tv->mode)) return -1; + + 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); + + bits += popcount(v); + } + return bits; +} + +/** + * Return the number of the lowest set bit in a given (integer) tarval. + * + * @param tv the tarval + * + * @return number of lowest set bit or -1 on error + */ +int get_tarval_lowest_bit(tarval *tv) +{ + int i, l; + + if (!tv || tv == tarval_bad) return -1; + if (! mode_is_int(tv->mode)) return -1; + + l = get_mode_size_bytes(tv->mode); + for (i = 0; i < l; ++i) { + unsigned char v = get_tarval_sub_bits(tv, (unsigned)i); + + if (v) + return ntz(v) + i * 8; + } + return -1; +} + /* * Returns non-zero if the mantissa of a floating point IEEE-754 * tarval is zero (i.e. 1.0Exxx) */ -int tarval_ieee754_zero_mantissa(tarval *tv) { +int tarval_ieee754_zero_mantissa(tarval *tv) +{ assert(get_mode_arithmetic(tv->mode) == irma_ieee754); return fc_zero_mantissa(tv->value); } /* Returns the exponent of a floating point IEEE-754 tarval. */ -int tarval_ieee754_get_exponent(tarval *tv) { +int tarval_ieee754_get_exponent(tarval *tv) +{ assert(get_mode_arithmetic(tv->mode) == irma_ieee754); return fc_get_exponent(tv->value); } @@ -1681,24 +1805,28 @@ int tarval_ieee754_get_exponent(tarval *tv) { * Check if the tarval can be converted to the given mode without * precision loss. */ -int tarval_ieee754_can_conv_lossless(tarval *tv, ir_mode *mode) { +int tarval_ieee754_can_conv_lossless(tarval *tv, ir_mode *mode) +{ const ieee_descriptor_t *desc = get_descriptor(mode); return fc_can_lossless_conv_to(tv->value, desc); } /* Set the immediate precision for IEEE-754 results. */ -unsigned tarval_ieee754_set_immediate_precision(unsigned bits) { +unsigned tarval_ieee754_set_immediate_precision(unsigned bits) +{ return fc_set_immediate_precision(bits); } /* Returns non-zero if the result of the last IEEE-754 operation was exact. */ -unsigned tarval_ieee754_get_exact(void) { +unsigned tarval_ieee754_get_exact(void) +{ return fc_is_exact(); } /* Return the size of the mantissa in bits (including possible implicit bits) for the given mode. */ -unsigned tarval_ieee754_get_mantissa_size(const ir_mode *mode) { +unsigned tarval_ieee754_get_mantissa_size(const ir_mode *mode) +{ const ieee_descriptor_t *desc; assert(get_mode_arithmetic(mode) == irma_ieee754); @@ -1708,28 +1836,32 @@ unsigned tarval_ieee754_get_mantissa_size(const ir_mode *mode) { } /* check if its the a floating point NaN */ -int tarval_is_NaN(tarval *tv) { +int tarval_is_NaN(tarval *tv) +{ if (! mode_is_float(tv->mode)) return 0; return fc_is_nan(tv->value); } /* check if its the a floating point +inf */ -int tarval_is_plus_inf(tarval *tv) { +int tarval_is_plus_inf(tarval *tv) +{ if (! mode_is_float(tv->mode)) return 0; return fc_is_inf(tv->value) && !fc_is_negative(tv->value); } /* check if its the a floating point -inf */ -int tarval_is_minus_inf(tarval *tv) { +int tarval_is_minus_inf(tarval *tv) +{ if (! mode_is_float(tv->mode)) return 0; return fc_is_inf(tv->value) && fc_is_negative(tv->value); } /* check if the tarval represents a finite value */ -int tarval_is_finite(tarval *tv) { +int tarval_is_finite(tarval *tv) +{ if (mode_is_float(tv->mode)) return !fc_is_nan(tv->value) && !fc_is_inf(tv->value); return 1; @@ -1738,21 +1870,26 @@ int tarval_is_finite(tarval *tv) { /* * Sets the overflow mode for integer operations. */ -void tarval_set_integer_overflow_mode(tarval_int_overflow_mode_t ov_mode) { +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) { +tarval_int_overflow_mode_t tarval_get_integer_overflow_mode(void) +{ return int_overflow_mode; } /* Enable/Disable floating point constant folding. */ -int tarval_enable_fp_ops(int enable) { - int old = !no_float; - +void tarval_enable_fp_ops(int enable) +{ no_float = !enable; - return old; +} + +int tarval_fp_ops_enabled(void) +{ + return !no_float; } /** @@ -1767,7 +1904,8 @@ static const tarval_mode_info hex_output = { /* * Initialization of the tarval module: called before init_mode() */ -void init_tarval_1(long null_value, int support_quad_precision) { +void init_tarval_1(long null_value, int support_quad_precision) +{ /* if these assertion fail, tarval_is_constant() will follow ... */ assert(tarval_b_false == &reserved_tv[0] && "b_false MUST be the first reserved tarval!"); assert(tarval_b_true == &reserved_tv[1] && "b_true MUST be the second reserved tarval!"); @@ -1785,7 +1923,8 @@ void init_tarval_1(long null_value, int support_quad_precision) { /* * Initialization of the tarval module: called after init_mode() */ -void init_tarval_2(void) { +void init_tarval_2(void) +{ tarval_bad->kind = k_tarval; tarval_bad->mode = mode_BAD; tarval_bad->value = INT_TO_PTR(resid_tarval_bad); @@ -1826,14 +1965,16 @@ void init_tarval_2(void) { } /* free all memory occupied by tarval. */ -void finish_tarval(void) { +void finish_tarval(void) +{ finish_strcalc(); finish_fltcalc(); del_set(tarvals); tarvals = NULL; del_set(values); values = NULL; } -int (is_tarval)(const void *thing) { +int (is_tarval)(const void *thing) +{ return _is_tarval(thing); }