X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Ftv%2Ffltcalc.c;h=fe6862e66e5a8d2098daeb374d655abe60ac807a;hb=0481fff9d8163639a6cac25b6db008f745658d32;hp=564b28c0c795e6d7a6ebc8be62ccbd3b010fccbd;hpb=a999e1baedb84dc9b83059708699dac1c7fdb9a2;p=libfirm diff --git a/ir/tv/fltcalc.c b/ir/tv/fltcalc.c index 564b28c0c..fe6862e66 100644 --- a/ir/tv/fltcalc.c +++ b/ir/tv/fltcalc.c @@ -52,6 +52,9 @@ #include "xmalloc.h" +/** The number of extra precesion rounding bits */ +#define ROUNDING_BITS 2 + typedef uint32_t UINT32; #ifdef HAVE_LONG_DOUBLE @@ -210,8 +213,8 @@ static void *pack(const fp_value *int_float, void *packed) { sc_or(temp, packed, packed); /* extract mantissa */ - /* remove 2 rounding bits */ - sc_val_from_ulong(2, shift_val); + /* remove rounding bits */ + sc_val_from_ulong(ROUNDING_BITS, shift_val); _shift_right(_mant(int_float), shift_val, temp); /* remove leading 1 (or 0 if denormalized) */ @@ -235,8 +238,8 @@ static int normalize(const fp_value *in_val, fp_value *out_val, int sticky) { char lsb, guard, round, round_dir = 0; char *temp = alloca(value_size); - /* +2: save two rounding bits at the end */ - hsb = 2 + in_val->desc.mantissa_size - sc_get_highest_set_bit(_mant(in_val)) - 1; + /* save rounding bits at the end */ + hsb = ROUNDING_BITS + in_val->desc.mantissa_size - sc_get_highest_set_bit(_mant(in_val)) - 1; if (in_val != out_val) { out_val->sign = in_val->sign; @@ -246,7 +249,7 @@ static int normalize(const fp_value *in_val, fp_value *out_val, int sticky) { out_val->desc.clss = NORMAL; /* mantissa all zeros, so zero exponent (because of explicit one) */ - if (hsb == 2 + in_val->desc.mantissa_size) { + if (hsb == ROUNDING_BITS + in_val->desc.mantissa_size) { sc_val_from_ulong(0, _exp(out_val)); hsb = -1; } @@ -295,7 +298,7 @@ static int normalize(const fp_value *in_val, fp_value *out_val, int sticky) { /* perform rounding by adding a value that clears the guard bit and the round bit * and either causes a carry to round up or not */ /* get the last 3 bits of the value */ - lsb = sc_sub_bits(_mant(out_val), out_val->desc.mantissa_size + 2, 0) & 0x7; + lsb = sc_sub_bits(_mant(out_val), out_val->desc.mantissa_size + ROUNDING_BITS, 0) & 0x7; guard = (lsb&0x2)>>1; round = lsb&0x1; @@ -339,7 +342,7 @@ static int normalize(const fp_value *in_val, fp_value *out_val, int sticky) { out_val->desc.clss = ZERO; /* check for rounding overflow */ - hsb = 2 + out_val->desc.mantissa_size - sc_get_highest_set_bit(_mant(out_val)) - 1; + hsb = ROUNDING_BITS + out_val->desc.mantissa_size - sc_get_highest_set_bit(_mant(out_val)) - 1; if ((out_val->desc.clss != SUBNORMAL) && (hsb < -1)) { sc_val_from_ulong(1, temp); _shift_right(_mant(out_val), temp, _mant(out_val)); @@ -440,7 +443,7 @@ static void _fadd(const fp_value *a, const fp_value *b, fp_value *result) { /* make sure result has a descriptor */ if (result != a && result != b) - memcpy(&result->desc, &a->desc, sizeof(descriptor_t)); + result->desc = a->desc; /* determine if this is an addition or subtraction */ sign = a->sign ^ b->sign; @@ -554,7 +557,7 @@ static void _fmul(const fp_value *a, const fp_value *b, fp_value *result) { temp = alloca(value_size); if (result != a && result != b) - memcpy(&result->desc, &a->desc, sizeof(descriptor_t)); + result->desc = a->desc; result->sign = res_sign = a->sign ^ b->sign; @@ -611,8 +614,8 @@ static void _fmul(const fp_value *a, const fp_value *b, fp_value *result) { * point are the sum of the factors' digits after the radix point. As all * values are normalized they both have the same amount of these digits, * which has to be restored by proper shifting - * +2 because of the two rounding bits */ - sc_val_from_ulong(2 + result->desc.mantissa_size, temp); + * because of the rounding bits */ + sc_val_from_ulong(ROUNDING_BITS + result->desc.mantissa_size, temp); _shift_right(_mant(result), temp, _mant(result)); sticky = sc_had_carry(); @@ -637,7 +640,7 @@ static void _fdiv(const fp_value *a, const fp_value *b, fp_value *result) { dividend = alloca(value_size); if (result != a && result != b) - memcpy(&result->desc, &a->desc, sizeof(descriptor_t)); + result->desc = a->desc; result->sign = res_sign = a->sign ^ b->sign; @@ -702,7 +705,7 @@ static void _fdiv(const fp_value *a, const fp_value *b, fp_value *result) { * fit into the integer precision, but due to the rounding bits (which * are always zero because the values are all normalized) the divisor * can be shifted right instead to achieve the same result */ - sc_val_from_ulong(2 + result->desc.mantissa_size, temp); + sc_val_from_ulong(ROUNDING_BITS + result->desc.mantissa_size, temp); _shift_left(_mant(a), temp, dividend); @@ -728,12 +731,12 @@ static void _power_of_ten(int exp, descriptor_t *desc, char *result) { /* set new descriptor (else result is supposed to already have one) */ if (desc != NULL) - memcpy(&result->desc, desc, sizeof(descriptor_t)); + result->desc = *desc; build = alloca(value_size); temp = alloca(value_size); - sc_val_from_ulong((1 << result->desc.exponent_size)/2-1, _exp(result)); + sc_val_from_ulong((1 << (result->desc.exponent_size - 1)) - 1, _exp(result)); if (exp > 0) { /* temp is value of ten now */ @@ -747,7 +750,7 @@ static void _power_of_ten(int exp, descriptor_t *desc, char *result) { _save_result(build); /* temp is amount of left shift needed to put the value left of the radix point */ - sc_val_from_ulong(result->desc.mantissa_size + 2, temp); + sc_val_from_ulong(result->desc.mantissa_size + ROUNDING_BITS, temp); _shift_left(build, temp, _mant(result)); @@ -783,7 +786,7 @@ static void _trunc(const fp_value *a, fp_value *result) { temp = alloca(value_size); if (a != result) - memcpy(&result->desc, &a->desc, sizeof(descriptor_t)); + result->desc = a->desc; exp_bias = (1 << (a->desc.exponent_size - 1)) - 1; exp_val = sc_val_to_long(_exp(a)) - exp_bias; @@ -814,8 +817,6 @@ static void _trunc(const fp_value *a, fp_value *result) { sc_and(_mant(a), temp, _mant(result)); if (a != result) memcpy(_exp(result), _exp(a), value_size); - - return; } /******** @@ -991,11 +992,11 @@ done: sc_val_from_str(mant_str, strlen(mant_str), _mant(result)); /* shift to put value left of radix point */ - sc_val_from_ulong(mant_size + 2, exp_val); + sc_val_from_ulong(mant_size + ROUNDING_BITS, exp_val); _shift_left(_mant(result), exp_val, _mant(result)); - sc_val_from_ulong((1 << exp_size)/2-1, _exp(result)); + sc_val_from_ulong((1 << (exp_size - 1)) - 1, _exp(result)); _normalize(result, result, 0); @@ -1034,7 +1035,7 @@ fp_value *fc_val_from_ieee754(LLDBL l, char exp_size, char mant_size, fp_value * UINT32 sign, exponent, mantissa0, mantissa1; srcval.d = l; - bias_res = ((1<desc.exponent_size = exp_size; @@ -1100,7 +1101,7 @@ fp_value *fc_val_from_ieee754(LLDBL l, char exp_size, char mant_size, fp_value * if (exponent != 0) { /* insert the hidden bit */ sc_val_from_ulong(1, temp); - sc_val_from_ulong(mant_val + 2, NULL); + sc_val_from_ulong(mant_val + ROUNDING_BITS, NULL); _shift_left(temp, sc_get_buffer(), NULL); } else @@ -1119,7 +1120,7 @@ fp_value *fc_val_from_ieee754(LLDBL l, char exp_size, char mant_size, fp_value * /* bits from the lower word */ sc_val_from_ulong(mantissa1, temp); - sc_val_from_ulong(2, NULL); + sc_val_from_ulong(ROUNDING_BITS, NULL); _shift_left(temp, sc_get_buffer(), temp); sc_or(_mant(result), temp, _mant(result)); @@ -1171,7 +1172,7 @@ LLDBL fc_val_to_ieee754(const fp_value *val) { * lead to wrong results */ exponent = sc_val_to_long(_exp(value)) ; - sc_val_from_ulong(2, NULL); + sc_val_from_ulong(ROUNDING_BITS, NULL); _shift_right(_mant(value), sc_get_buffer(), _mant(value)); mantissa0 = 0; @@ -1264,7 +1265,7 @@ fp_value *fc_get_max(unsigned int exponent_size, unsigned int mantissa_size, fp_ sc_val_from_ulong((1<desc.mantissa_size; + return sc_get_lowest_set_bit(_mant(value)) == ROUNDING_BITS + value->desc.mantissa_size; } +/* Returns the exponent of a value. */ int fc_get_exponent(const fp_value *value) { int exp_bias = (1 << (value->desc.exponent_size - 1)) - 1; return sc_val_to_long(_exp(value)) - exp_bias; } +/* Return non-zero if a given value can be converted lossless into another precision */ +int fc_can_lossless_conv_to(const fp_value *value, char exp_size, char mant_size) { + int v; + int exp_bias; + + /* handle some special cases first */ + switch (value->desc.clss) { + case ZERO: + case INF: + case NAN: + return 1; + default: + break; + } + + /* check if the exponent can be encoded: note, 0 and all ones are reserved for the exponent */ + exp_bias = (1 << (exp_size - 1)) - 1; + v = fc_get_exponent(value) + exp_bias; + if (0 < v && v < (1 << exp_size) - 1) { + /* check the mantissa */ + v = value->desc.mantissa_size + ROUNDING_BITS - sc_get_lowest_set_bit(_mant(value)); + return v < mant_size; + } + return 0; +} + fc_rounding_mode_t fc_set_rounding_mode(fc_rounding_mode_t mode) { if (mode == FC_TONEAREST || mode == FC_TOPOSITIVE || mode == FC_TONEGATIVE || mode == FC_TOZERO) @@ -1655,7 +1684,7 @@ int fc_flt2int(const fp_value *a, void *result, ir_mode *dst_mode) { } assert(exp_val >= 0 && "floating point value not integral before fc_flt2int() call"); - shift = exp_val - a->desc.mantissa_size - 2; + shift = exp_val - (a->desc.mantissa_size + ROUNDING_BITS); if (shift > 0) { sc_shlI(_mant(a), shift, 64, 0, result);