X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Ftv%2Fstrcalc.c;h=b012b7479694ae7b1460d1bc604b68212786d884;hb=2d09549421b49587d4680a94dab277646e9fef44;hp=20d0cbd2f8fdf10e31497ca7b29923542724c237;hpb=486c118ff659beeafd759c6331f95c2e269a455a;p=libfirm diff --git a/ir/tv/strcalc.c b/ir/tv/strcalc.c index 20d0cbd2f..b012b7479 100644 --- a/ir/tv/strcalc.c +++ b/ir/tv/strcalc.c @@ -1,14 +1,30 @@ -/****i* strcalc/implementation - * - * AUTHORS - * Matthias Heil - * - * NOTES - ******/ +/* + * Project: libFIRM + * File name: ir/tv/strcalc.c + * Purpose: + * 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. + */ + + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + #include "strcalc.h" #include +#ifdef HAVE_ALLOCA_H +# include +#endif +#ifdef HAVE_MALLOC_H +# include +#endif #include /* assertions */ #include /* memset/memcmp */ #include /* output for error messages */ @@ -17,14 +33,20 @@ /* * local definitions and macros */ -#define CLEAR_CALC_BUFFER() assert(calc_buffer); memset(calc_buffer, SC_0, CALC_BUFFER_SIZE) +#define CLEAR_BUFFER(b) assert(b); memset(b, SC_0, CALC_BUFFER_SIZE) #define _val(a) ((a)-SC_0) #define _digit(a) ((a)+SC_0) #define _bitisset(digit, pos) (and_table[_val(digit)][_val(shift_table[pos])] != SC_0) #define fail_char(a, b, c, d) _fail_char((a), (b), (c), (d), __FILE__, __LINE__) -#ifdef STRCALC_DEBUG_COMPUTATION +/* shortcut output for debugging */ +# define sc_print_hex(a) sc_print((a), 0, SC_HEX) +# define sc_print_dec(a) sc_print((a), 0, SC_DEC) +# define sc_print_oct(a) sc_print((a), 0, SC_OCT) +# define sc_print_bin(a) sc_print((a), 0, SC_BIN) + +#ifdef STRCALC_DEBUG_PRINTCOMP # define DEBUGPRINTF_COMPUTATION(x) printf x #else # define DEBUGPRINTF_COMPUTATION(x) ((void)0) @@ -498,19 +520,24 @@ static void _add(const char *val1, const char *val2, char *buffer) buffer[counter] = add2[0]; carry = add_table[_val(add1[1])][_val(add2[1])][0]; } + carry_flag = carry != SC_0; } static void _mul(const char *val1, const char *val2, char *buffer) { - char temp_buffer[CALC_BUFFER_SIZE]; /* result buffer */ - char neg_val1[CALC_BUFFER_SIZE]; /* abs of val1 */ - char neg_val2[CALC_BUFFER_SIZE]; /* abs of val2 */ + char* temp_buffer; /* result buffer */ + char* neg_val1; /* abs of val1 */ + char* neg_val2; /* abs of val2 */ const char *mul, *add1, *add2; /* intermediate result containers */ char carry = SC_0; /* container for carries */ char sign = 0; /* marks result sign */ int c_inner, c_outer; /* loop counters */ + temp_buffer = alloca(CALC_BUFFER_SIZE); + neg_val1 = alloca(CALC_BUFFER_SIZE); + neg_val2 = alloca(CALC_BUFFER_SIZE); + /* init result buffer to zeroes */ memset(temp_buffer, SC_0, CALC_BUFFER_SIZE); @@ -575,7 +602,8 @@ static void _mul(const char *val1, const char *val2, char *buffer) static void _sub(const char *val1, const char *val2, char *buffer) { - char temp_buffer[CALC_BUFFER_SIZE]; /* intermediate buffer to hold -val2 */ + char *temp_buffer; /* intermediate buffer to hold -val2 */ + temp_buffer = alloca(CALC_BUFFER_SIZE); _negate(val2, temp_buffer); _add(val1, temp_buffer, buffer); @@ -596,13 +624,16 @@ static void _push(const char digit, char *buffer) static void _divmod(const char *dividend, const char *divisor, char *quot, char *rem) { const char *minus_divisor; - char neg_val1[CALC_BUFFER_SIZE]; - char neg_val2[CALC_BUFFER_SIZE]; + char *neg_val1; + char *neg_val2; char sign = 0; /* remember result sign */ int c_dividend; /* loop counters */ + neg_val1 = alloca(CALC_BUFFER_SIZE); + neg_val2 = alloca(CALC_BUFFER_SIZE); + /* clear result buffer */ memset(quot, SC_0, CALC_BUFFER_SIZE); memset(rem, SC_0, CALC_BUFFER_SIZE); @@ -768,6 +799,9 @@ static void _shr(const char *val1, char *buffer, long offset, int radius, unsign /* if shifting far enough the result is either 0 or -1 */ if (offset >= radius) { + if (!sc_is_zero(val1)) { + carry_flag = 1; + } memset(buffer, sign, CALC_BUFFER_SIZE); return; } @@ -775,18 +809,19 @@ static void _shr(const char *val1, char *buffer, long offset, int radius, unsign shift = offset % 4; offset = offset / 4; - /* check if any bits are lost, and set carry_flag is so */ + /* check if any bits are lost, and set carry_flag if so */ for (counter = 0; counter < offset; counter++) { - if (val1[counter] != carry_flag) + if (val1[counter] != 0) { carry_flag = 1; break; } } - if ((carry_flag == 0) && (_val(val1[counter]) & shift) != 0) + if ((_val(val1[counter]) & ((1< 0) { @@ -830,8 +865,9 @@ static void _shr(const char *val1, char *buffer, long offset, int radius, unsign /* positive: low-order -> high order, negative other direction */ static void _rot(const char *val1, char *buffer, long offset, int radius, unsigned is_signed) { - char temp1[CALC_BUFFER_SIZE]; - char temp2[CALC_BUFFER_SIZE]; + char *temp1, *temp2; + temp1 = alloca(CALC_BUFFER_SIZE); + temp2 = alloca(CALC_BUFFER_SIZE); offset = offset % radius; @@ -861,21 +897,25 @@ const int sc_get_buffer_length(void) } /* XXX doesn't check for overflows */ -void sc_val_from_str(const char *str, unsigned int len) +void sc_val_from_str(const char *str, unsigned int len, void *buffer) { const char *orig_str = str; unsigned int orig_len = len; char sign = 0; - char base[CALC_BUFFER_SIZE]; - char val[CALC_BUFFER_SIZE]; + char *base, *val; + + base = alloca(CALC_BUFFER_SIZE); + val = alloca(CALC_BUFFER_SIZE); /* verify valid pointers (not null) */ assert(str); /* a string no characters long is an error */ assert(len); - CLEAR_CALC_BUFFER(); + if (buffer == NULL) buffer = calc_buffer; + + CLEAR_BUFFER(buffer); memset(base, SC_0, CALC_BUFFER_SIZE); memset(val, SC_0, CALC_BUFFER_SIZE); @@ -1005,12 +1045,14 @@ void sc_val_from_str(const char *str, unsigned int len) } } -void sc_val_from_long(long value) +void sc_val_from_long(long value, void *buffer) { char *pos; char sign, is_minlong; - pos = calc_buffer; + if (buffer == NULL) buffer = calc_buffer; + pos = buffer; + sign = (value < 0); is_minlong = value == LONG_MIN; @@ -1022,18 +1064,34 @@ void sc_val_from_long(long value) value = -value; } - CLEAR_CALC_BUFFER(); + CLEAR_BUFFER(buffer); - while ((value != 0) && (pos < calc_buffer + CALC_BUFFER_SIZE)) + while ((value != 0) && (pos < (char*)buffer + CALC_BUFFER_SIZE)) { - *pos++ = _digit(value % 16); - value /= 16; + *pos++ = _digit(value & 0xf); + value >>= 4; } if (sign) { - if (is_minlong) _inc(calc_buffer, calc_buffer); - _negate(calc_buffer, calc_buffer); + if (is_minlong) + _inc(buffer, buffer); + + _negate(buffer, buffer); + } +} + +void sc_val_from_ulong(unsigned long value, void *buffer) +{ + char *pos; + + if (buffer == NULL) buffer = calc_buffer; + pos = buffer; + + while (pos < (char*)buffer + CALC_BUFFER_SIZE) + { + *pos++ = _digit(value & 0xf); + value >>= 4; } } @@ -1049,15 +1107,17 @@ long sc_val_to_long(const void *val) return l; } -void sc_min_from_bits(unsigned int num_bits, unsigned int sign) +void sc_min_from_bits(unsigned int num_bits, unsigned int sign, void *buffer) { char* pos; int i, bits; - CLEAR_CALC_BUFFER(); + if (buffer == NULL) buffer = calc_buffer; + CLEAR_BUFFER(buffer); + if (!sign) return; /* unsigned means minimum is 0(zero) */ - pos = calc_buffer; + pos = buffer; bits = num_bits - 1; for (i = 0; i < bits/4; i++) @@ -1069,13 +1129,14 @@ void sc_min_from_bits(unsigned int num_bits, unsigned int sign) *pos++ = SC_F; } -void sc_max_from_bits(unsigned int num_bits, unsigned int sign) +void sc_max_from_bits(unsigned int num_bits, unsigned int sign, void *buffer) { char* pos; int i, bits; - CLEAR_CALC_BUFFER(); - pos = calc_buffer; + if (buffer == NULL) buffer = calc_buffer; + CLEAR_BUFFER(buffer); + pos = buffer; bits = num_bits - sign; for (i = 0; i < bits/4; i++) @@ -1087,13 +1148,15 @@ void sc_max_from_bits(unsigned int num_bits, unsigned int sign) *pos++ = SC_0; } -void sc_calc(const void* value1, const void* value2, unsigned op) +void sc_calc(const void* value1, const void* value2, unsigned op, void *buffer) { - char unused_res[CALC_BUFFER_SIZE]; /* temp buffer holding unused result of divmod */ + char *unused_res; /* temp buffer holding unused result of divmod */ const char *val1 = (const char *)value1; const char *val2 = (const char *)value2; - CLEAR_CALC_BUFFER(); + + unused_res = alloca(CALC_BUFFER_SIZE); + CLEAR_BUFFER(calc_buffer); carry_flag = 0; DEBUGPRINTF_COMPUTATION(("%s ", sc_print_hex(value1))); @@ -1103,7 +1166,7 @@ void sc_calc(const void* value1, const void* value2, unsigned op) case SC_NEG: _negate(val1, calc_buffer); DEBUGPRINTF_COMPUTATION(("negated: %s\n", sc_print_hex(calc_buffer))); - return; + break; case SC_OR: DEBUGPRINTF_COMPUTATION(("| ")); _bitor(val1, val2, calc_buffer); @@ -1119,7 +1182,7 @@ void sc_calc(const void* value1, const void* value2, unsigned op) case SC_NOT: _bitnot(val1, calc_buffer); DEBUGPRINTF_COMPUTATION(("bit-negated: %s\n", sc_print_hex(calc_buffer))); - return; + break; case SC_ADD: DEBUGPRINTF_COMPUTATION(("+ ")); _add(val1, val2, calc_buffer); @@ -1145,9 +1208,14 @@ void sc_calc(const void* value1, const void* value2, unsigned op) } DEBUGPRINTF_COMPUTATION(("%s -> ", sc_print_hex(value2))); DEBUGPRINTF_COMPUTATION(("%s\n", sc_print_hex(calc_buffer))); + + if ((buffer != NULL) && (buffer != calc_buffer)) + { + memcpy(buffer, calc_buffer, CALC_BUFFER_SIZE); + } } -void sc_bitcalc(const void* value1, const void* value2, int radius, int sign, unsigned op) +void sc_bitcalc(const void* value1, const void* value2, int radius, int sign, unsigned op, void* buffer) { const char *val1 = (const char *)value1; const char *val2 = (const char *)value2; @@ -1160,25 +1228,30 @@ void sc_bitcalc(const void* value1, const void* value2, int radius, int sign, un switch (op) { case SC_SHL: - DEBUGPRINTF_COMPUTATION(("<< %d ", offset)); + DEBUGPRINTF_COMPUTATION(("<< %ld ", offset)); _shl(val1, calc_buffer, offset, radius, sign); break; case SC_SHR: - DEBUGPRINTF_COMPUTATION((">> %d ", offset)); + DEBUGPRINTF_COMPUTATION((">> %ld ", offset)); _shr(val1, calc_buffer, offset, radius, sign, 0); break; case SC_SHRS: - DEBUGPRINTF_COMPUTATION((">>> %d ", offset)); + DEBUGPRINTF_COMPUTATION((">>> %ld ", offset)); _shr(val1, calc_buffer, offset, radius, sign, 1); break; case SC_ROT: - DEBUGPRINTF_COMPUTATION(("<<>> %d ", offset)); + DEBUGPRINTF_COMPUTATION(("<<>> %ld ", offset)); _rot(val1, calc_buffer, offset, radius, sign); break; default: assert(0); } DEBUGPRINTF_COMPUTATION(("-> %s\n", sc_print_hex(calc_buffer))); + + if ((buffer != NULL) && (buffer != calc_buffer)) + { + memmove(buffer, calc_buffer, CALC_BUFFER_SIZE); + } } int sc_comp(const void* value1, const void* value2) @@ -1210,7 +1283,7 @@ int sc_get_highest_set_bit(const void *value) const char *val = (const char*)value; int high, counter; - high = CALC_BUFFER_SIZE * 4; + high = CALC_BUFFER_SIZE * 4 - 1; for (counter = CALC_BUFFER_SIZE-1; counter >= 0; counter--) { if (val[counter] == SC_0) high -= 4; @@ -1242,7 +1315,7 @@ int sc_get_lowest_set_bit(const void *value) else return low + 3; } } - return low; + return -1; } int sc_is_zero(const void *value) @@ -1285,16 +1358,14 @@ unsigned char sc_sub_bits(const void *value, int len, unsigned byte_ofs) /* * convert to a string + * XXX Doesn't check buffer bounds */ const char *sc_print(const void *value, unsigned bits, enum base_t base) { static const char big_digits[] = "0123456789ABCDEF"; static const char small_digits[] = "0123456789abcdef"; - char base_val[CALC_BUFFER_SIZE]; - char div1_res[CALC_BUFFER_SIZE]; - char div2_res[CALC_BUFFER_SIZE]; - char rem_res[CALC_BUFFER_SIZE]; + char *base_val, *div1_res, *div2_res, *rem_res; int counter, nibbles, i, sign; char x; @@ -1304,8 +1375,13 @@ const char *sc_print(const void *value, unsigned bits, enum base_t base) char *pos; const char *digits = small_digits; - pos = output_buffer + BIT_PATTERN_SIZE ; - *pos = '\0'; + base_val = alloca(CALC_BUFFER_SIZE); + div1_res = alloca(CALC_BUFFER_SIZE); + div2_res = alloca(CALC_BUFFER_SIZE); + rem_res = alloca(CALC_BUFFER_SIZE); + + pos = output_buffer + BIT_PATTERN_SIZE; + *(--pos) = '\0'; /* special case */ if (bits == 0) { @@ -1421,34 +1497,44 @@ const char *sc_print(const void *value, unsigned bits, enum base_t base) break; default: + printf("%i\n", base); assert(0); return NULL; } return pos; } -void init_strcalc(int precision_in_bytes) +void init_strcalc(int precision) { if (calc_buffer == NULL) { - if (precision_in_bytes <= 0) precision_in_bytes = DEFAULT_PRECISION_IN_BYTES; + if (precision <= 0) precision = SC_DEFAULT_PRECISION; - BIT_PATTERN_SIZE = (8 * precision_in_bytes); - CALC_BUFFER_SIZE = (4 * precision_in_bytes); - MAX_VALUE_SIZE = (2 * precision_in_bytes); + /* round up to multiple of 4 */ + precision = (precision + 3) & ~3; - calc_buffer = malloc(CALC_BUFFER_SIZE+1 * sizeof(char)); + BIT_PATTERN_SIZE = (precision); + CALC_BUFFER_SIZE = (precision / 2); + MAX_VALUE_SIZE = (precision / 4); + + calc_buffer = malloc(CALC_BUFFER_SIZE+1 * sizeof(char)); output_buffer = malloc(BIT_PATTERN_SIZE+1 * sizeof(char)); - if (calc_buffer == NULL || output_buffer == NULL) - { + if (calc_buffer == NULL || output_buffer == NULL) { assert(0 && "malloc failed"); exit(-1); } - DEBUGPRINTF(("init strcalc: \n\tPRECISION: %d\n\tCALC_BUFFER_SIZE = %d\n\tMAX_VALUE_SIZE = %d\n\tbuffer pointer: %p\n", precision_in_bytes, CALC_BUFFER_SIZE, MAX_VALUE_SIZE, calc_buffer)); + DEBUGPRINTF(("init strcalc: \n\tPRECISION: %d\n\tCALC_BUFFER_SIZE = %d\n\tMAX_VALUE_SIZE = %d\n\tbuffer pointer: %p\n", precision, CALC_BUFFER_SIZE, MAX_VALUE_SIZE, calc_buffer)); } } -int get_precision() + + +void finish_strcalc() { + free(calc_buffer); calc_buffer = NULL; + free(output_buffer); output_buffer = NULL; +} + +int sc_get_precision(void) { - return CALC_BUFFER_SIZE/4; + return BIT_PATTERN_SIZE; }