X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Ftv%2Ffltcalc.c;h=3371eddf013c7cd142a3b8ca4111b21c17cfa6fc;hb=8010ed3d640a15ac18138d8a96ea61f318aae2cb;hp=eb21309509f5e8cb8c2fbf11e9443d4052cf10cb;hpb=a1e9069afa4fa1e16e2d176bcd7905d6a1ed4677;p=libfirm diff --git a/ir/tv/fltcalc.c b/ir/tv/fltcalc.c index eb2130950..3371eddf0 100644 --- a/ir/tv/fltcalc.c +++ b/ir/tv/fltcalc.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 1995-2010 University of Karlsruhe. All right reserved. + * Copyright (C) 1995-2011 University of Karlsruhe. All right reserved. * * This file is part of libFirm. * @@ -44,54 +44,38 @@ #include "xmalloc.h" -#ifndef HAVE_STRTOLD +#ifdef _MSC_VER +#include +#define isnan(x) _isnan(x) +static inline int isinf(double x) +{ + return !_finite(x) && !_isnan(x); +} #define strtold(s, e) strtod(s, e) +#define SIZEOF_LONG_DOUBLE_8 #endif /** The number of extra precision rounding bits */ #define ROUNDING_BITS 2 -typedef uint32_t UINT32; - -#ifdef HAVE_LONG_DOUBLE -#ifdef WORDS_BIGENDIAN typedef union { struct { - UINT32 high; - UINT32 mid; - UINT32 low; - } val; - volatile long double d; -} value_t; +#ifdef WORDS_BIGENDIAN + uint32_t high; #else -typedef union { - struct { - UINT32 low; - UINT32 mid; - UINT32 high; - } val; - volatile long double d; -} value_t; + uint32_t low; +#endif +#ifndef SIZEOF_LONG_DOUBLE_8 + uint32_t mid; #endif -#else #ifdef WORDS_BIGENDIAN -typedef union { - struct { - UINT32 high; - UINT32 low; - } val; - volatile double d; -} value_t; + uint32_t low; #else -typedef union { - struct { - UINT32 low; - UINT32 high; + uint32_t high; +#endif } val; - volatile double d; + volatile long double d; } value_t; -#endif -#endif #define CLEAR_BUFFER(buffer) memset(buffer, 0, calc_buffer_size) @@ -138,20 +122,6 @@ static int max_precision; /** Exact flag. */ static int fc_exact = 1; -#if 0 -static void fail_char(const char *str, unsigned int len, int pos) -{ - if (*(str+pos)) - printf("ERROR: Unexpected character '%c'\n", *(str + pos)); - else - printf("ERROR: Unexpected end of string\n"); - while (len-- && *str) printf("%c", *str++); printf("\n"); - while (pos--) printf(" "); printf("^\n"); - /* the front end has to to check constant strings */ - exit(-1); -} -#endif - /** pack machine-like */ static void *pack(const fp_value *int_float, void *packed) { @@ -160,18 +130,18 @@ static void *pack(const fp_value *int_float, void *packed) fp_value *val_buffer; int pos; - temp = alloca(value_size); - shift_val = alloca(value_size); + temp = (char*) alloca(value_size); + shift_val = (char*) alloca(value_size); switch ((value_class_t)int_float->desc.clss) { case NAN: - val_buffer = alloca(calc_buffer_size); + val_buffer = (fp_value*) alloca(calc_buffer_size); fc_get_qnan(&int_float->desc, val_buffer); int_float = val_buffer; break; case INF: - val_buffer = alloca(calc_buffer_size); + val_buffer = (fp_value*) alloca(calc_buffer_size); fc_get_plusinf(&int_float->desc, val_buffer); val_buffer->sign = int_float->sign; int_float = val_buffer; @@ -222,7 +192,7 @@ static int normalize(const fp_value *in_val, fp_value *out_val, int sticky) int exact = 1; int hsb; char lsb, guard, round, round_dir = 0; - char *temp = alloca(value_size); + char *temp = (char*) alloca(value_size); /* save rounding bits at the end */ hsb = ROUNDING_BITS + in_val->desc.mantissa_size - sc_get_highest_set_bit(_mant(in_val)) - 1; @@ -445,8 +415,8 @@ static void _fadd(const fp_value *a, const fp_value *b, fp_value *result) return; } - temp = alloca(value_size); - exp_diff = alloca(value_size); + temp = (char*) alloca(value_size); + exp_diff = (char*) alloca(value_size); /* get exponent difference */ sc_sub(_exp(a), _exp(b), exp_diff); @@ -508,7 +478,7 @@ static void _fadd(const fp_value *a, const fp_value *b, fp_value *result) /* if subtracting a little more than the represented value or adding a little * more than the represented value to a negative value this, in addition to the * still set sticky bit, takes account of the 'little more' */ - char *temp1 = alloca(calc_buffer_size); + char *temp1 = (char*) alloca(calc_buffer_size); sc_val_from_ulong(1, temp1); sc_add(temp, temp1, temp); } @@ -548,7 +518,7 @@ static void _fmul(const fp_value *a, const fp_value *b, fp_value *result) handle_NAN(a, b, result); - temp = alloca(value_size); + temp = (char*) alloca(value_size); if (result != a && result != b) result->desc = a->desc; @@ -635,8 +605,8 @@ static void _fdiv(const fp_value *a, const fp_value *b, fp_value *result) handle_NAN(a, b, result); - temp = alloca(value_size); - dividend = alloca(value_size); + temp = (char*) alloca(value_size); + dividend = (char*) alloca(value_size); if (result != a && result != b) result->desc = a->desc; @@ -713,7 +683,7 @@ static void _fdiv(const fp_value *a, const fp_value *b, fp_value *result) _shift_left(_mant(a), temp, dividend); { - char *divisor = alloca(calc_buffer_size); + char *divisor = (char*) alloca(calc_buffer_size); sc_val_from_ulong(1, divisor); _shift_right(_mant(b), divisor, divisor); sc_div(dividend, divisor, _mant(result)); @@ -788,7 +758,7 @@ static void _trunc(const fp_value *a, fp_value *result) /* fixme: can be exact */ fc_exact = 0; - temp = alloca(value_size); + temp = (char*) alloca(value_size); if (a != result) result->desc = a->desc; @@ -840,16 +810,16 @@ int fc_get_buffer_length(void) return calc_buffer_size; } -void *fc_val_from_str(const char *str, unsigned int len, const ieee_descriptor_t *desc, void *result) +void *fc_val_from_str(const char *str, size_t len, const ieee_descriptor_t *desc, void *result) { char *buffer; /* XXX excuse of an implementation to make things work */ - LLDBL val; - fp_value *tmp = alloca(calc_buffer_size); + long double val; + fp_value *tmp = (fp_value*) alloca(calc_buffer_size); ieee_descriptor_t tmp_desc; - buffer = alloca(len+1); + buffer = (char*) alloca(len+1); memcpy(buffer, str, len); buffer[len] = '\0'; val = strtold(buffer, NULL); @@ -861,46 +831,38 @@ void *fc_val_from_str(const char *str, unsigned int len, const ieee_descriptor_t tmp_desc.clss = NORMAL; fc_val_from_ieee754(val, &tmp_desc, tmp); - return fc_cast(tmp, desc, result); + return fc_cast(tmp, desc, (fp_value*) result); } -fp_value *fc_val_from_ieee754(LLDBL l, const ieee_descriptor_t *desc, fp_value *result) +fp_value *fc_val_from_ieee754(long double l, const ieee_descriptor_t *desc, fp_value *result) { char *temp; - int bias_res, bias_val, mant_val; - value_t srcval; - char sign; - UINT32 exponent, mantissa0, mantissa1; + int bias_res, bias_val, mant_val; + value_t srcval; + char sign; + uint32_t exponent, mantissa0, mantissa1; srcval.d = l; bias_res = ((1 << (desc->exponent_size - 1)) - 1); -#ifdef HAVE_LONG_DOUBLE - mant_val = 63; - bias_val = 0x3fff; - sign = (srcval.val.high & 0x00008000) != 0; - exponent = (srcval.val.high & 0x00007FFF) ; - mantissa0 = srcval.val.mid; - mantissa1 = srcval.val.low; -#else /* no long double */ +#ifdef SIZEOF_LONG_DOUBLE_8 mant_val = 52; bias_val = 0x3ff; sign = (srcval.val.high & 0x80000000) != 0; exponent = (srcval.val.high & 0x7FF00000) >> 20; mantissa0 = srcval.val.high & 0x000FFFFF; mantissa1 = srcval.val.low; -#endif - -#ifdef HAVE_LONG_DOUBLE - TRACEPRINTF(("val_from_float(%.8X%.8X%.8X)\n", ((int*)&l)[2], ((int*)&l)[1], ((int*)&l)[0]));/* srcval.val.high, srcval.val.mid, srcval.val.low)); */ - DEBUGPRINTF(("(%d-%.4X-%.8X%.8X)\n", sign, exponent, mantissa0, mantissa1)); #else - TRACEPRINTF(("val_from_float(%.8X%.8X)\n", srcval.val.high, srcval.val.low)); - DEBUGPRINTF(("(%d-%.3X-%.5X%.8X)\n", sign, exponent, mantissa0, mantissa1)); + mant_val = 63; + bias_val = 0x3fff; + sign = (srcval.val.high & 0x00008000) != 0; + exponent = (srcval.val.high & 0x00007FFF) ; + mantissa0 = srcval.val.mid; + mantissa1 = srcval.val.low; #endif if (result == NULL) result = calc_buffer; - temp = alloca(value_size); + temp = (char*) alloca(value_size); /* CLEAR the buffer, else some bits might be uninitialized */ memset(result, 0, fc_get_buffer_length()); @@ -918,8 +880,7 @@ fp_value *fc_val_from_ieee754(LLDBL l, const ieee_descriptor_t *desc, fp_value * result->desc.clss = NAN; TRACEPRINTF(("val_from_float resulted in NAN\n")); return result; - } - else if (isinf(l)) { + } else if (isinf(l)) { result->desc.clss = INF; TRACEPRINTF(("val_from_float resulted in %sINF\n", (result->sign == 1) ? "-" : "")); return result; @@ -970,36 +931,36 @@ fp_value *fc_val_from_ieee754(LLDBL l, const ieee_descriptor_t *desc, fp_value * return result; } -LLDBL fc_val_to_ieee754(const fp_value *val) +long double fc_val_to_ieee754(const fp_value *val) { fp_value *value; fp_value *temp = NULL; int byte_offset; - UINT32 sign; - UINT32 exponent; - UINT32 mantissa0; - UINT32 mantissa1; + uint32_t sign; + uint32_t exponent; + uint32_t mantissa0; + uint32_t mantissa1; value_t buildval; ieee_descriptor_t desc; unsigned mantissa_size; -#ifdef HAVE_LONG_DOUBLE - desc.exponent_size = 15; - desc.mantissa_size = 63; - desc.explicit_one = 1; - desc.clss = NORMAL; -#else +#ifdef SIZEOF_LONG_DOUBLE_8 desc.exponent_size = 11; desc.mantissa_size = 52; desc.explicit_one = 0; desc.clss = NORMAL; +#else + desc.exponent_size = 15; + desc.mantissa_size = 63; + desc.explicit_one = 1; + desc.clss = NORMAL; #endif mantissa_size = desc.mantissa_size + desc.explicit_one; - temp = alloca(calc_buffer_size); + temp = (fp_value*) alloca(calc_buffer_size); value = fc_cast(val, &desc, temp); sign = value->sign; @@ -1020,17 +981,17 @@ LLDBL fc_val_to_ieee754(const fp_value *val) for (; (byte_offset<<3) < desc.mantissa_size; byte_offset++) mantissa0 |= sc_sub_bits(_mant(value), mantissa_size, byte_offset) << ((byte_offset - 4) << 3); -#ifdef HAVE_LONG_DOUBLE - buildval.val.high = sign << 15; - buildval.val.high |= exponent; - buildval.val.mid = mantissa0; - buildval.val.low = mantissa1; -#else /* no long double */ +#ifdef SIZEOF_LONG_DOUBLE_8 mantissa0 &= 0x000FFFFF; /* get rid of garbage */ buildval.val.high = sign << 31; buildval.val.high |= exponent << 20; buildval.val.high |= mantissa0; buildval.val.low = mantissa1; +#else + buildval.val.high = sign << 15; + buildval.val.high |= exponent; + buildval.val.mid = mantissa0; + buildval.val.low = mantissa1; #endif TRACEPRINTF(("val_to_float: %d-%x-%x%x\n", sign, exponent, mantissa0, mantissa1)); @@ -1043,7 +1004,7 @@ fp_value *fc_cast(const fp_value *value, const ieee_descriptor_t *desc, fp_value int exp_offset, val_bias, res_bias; if (result == NULL) result = calc_buffer; - temp = alloca(value_size); + temp = (char*) alloca(value_size); if (value->desc.exponent_size == desc->exponent_size && value->desc.mantissa_size == desc->mantissa_size && @@ -1280,9 +1241,9 @@ int fc_is_subnormal(const fp_value *a) char *fc_print(const fp_value *val, char *buf, int buflen, unsigned base) { char *mul_1; - LLDBL flt_val; + long double flt_val; - mul_1 = alloca(calc_buffer_size); + mul_1 = (char*) alloca(calc_buffer_size); switch (base) { case FC_DEC: @@ -1298,12 +1259,8 @@ char *fc_print(const fp_value *val, char *buf, int buflen, unsigned base) break; default: flt_val = fc_val_to_ieee754(val); -#ifdef HAVE_LONG_DOUBLE /* XXX 30 is arbitrary */ snprintf(buf, buflen, "%.30LE", flt_val); -#else - snprintf(buf, buflen, "%.18E", flt_val); -#endif } break; @@ -1320,11 +1277,7 @@ char *fc_print(const fp_value *val, char *buf, int buflen, unsigned base) break; default: flt_val = fc_val_to_ieee754(val); -#ifdef HAVE_LONG_DOUBLE snprintf(buf, buflen, "%LA", flt_val); -#else - snprintf(buf, buflen, "%A", flt_val); -#endif } break; @@ -1422,19 +1375,9 @@ void init_fltcalc(int precision) value_size = sc_get_buffer_length(); calc_buffer_size = sizeof(fp_value) + 2*value_size - 1; - calc_buffer = xmalloc(calc_buffer_size); + calc_buffer = (fp_value*) xmalloc(calc_buffer_size); memset(calc_buffer, 0, calc_buffer_size); DEBUGPRINTF(("init fltcalc:\n\tVALUE_SIZE = %d\ntCALC_BUFFER_SIZE = %d\n\tcalc_buffer = %p\n\n", value_size, calc_buffer_size, calc_buffer)); -#ifdef HAVE_LONG_DOUBLE - DEBUGPRINTF(("\tUsing long double (1-15-64) interface\n")); -#else - DEBUGPRINTF(("\tUsing double (1-11-52) interface\n")); -#endif -#ifdef WORDS_BIGENDIAN - DEBUGPRINTF(("\tWord order is big endian\n\n")); -#else - DEBUGPRINTF(("\tWord order is little endian\n\n")); -#endif } } @@ -1474,7 +1417,7 @@ fp_value *fc_sub(const fp_value *a, const fp_value *b, fp_value *result) TRACEPRINTF(("%s ", fc_print(a, buffer, sizeof(buffer), FC_PACKED))); TRACEPRINTF(("- %s ", fc_print(b, buffer, sizeof(buffer), FC_PACKED))); - temp = alloca(calc_buffer_size); + temp = (fp_value*) alloca(calc_buffer_size); memcpy(temp, b, calc_buffer_size); temp->sign = !b->sign; if (sc_comp(_exp(a), _exp(temp)) == -1)