URL
https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k
[/] [or1k/] [tags/] [VER_5_3/] [gdb-5.3/] [libiberty/] [floatformat.c] - Rev 1765
Compare with Previous | Blame | View Log
/* IEEE floating point support routines, for GDB, the GNU Debugger. Copyright (C) 1991, 1994, 1999, 2000 Free Software Foundation, Inc. This file is part of GDB. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "floatformat.h" #include <math.h> /* ldexp */ #ifdef __STDC__ #include <stddef.h> extern void *memcpy (void *s1, const void *s2, size_t n); extern void *memset (void *s, int c, size_t n); #else extern char *memcpy (); extern char *memset (); #endif /* The odds that CHAR_BIT will be anything but 8 are low enough that I'm not going to bother with trying to muck around with whether it is defined in a system header, what we do if not, etc. */ #define FLOATFORMAT_CHAR_BIT 8 /* floatformats for IEEE single and double, big and little endian. */ const struct floatformat floatformat_ieee_single_big = { floatformat_big, 32, 0, 1, 8, 127, 255, 9, 23, floatformat_intbit_no, "floatformat_ieee_single_big" }; const struct floatformat floatformat_ieee_single_little = { floatformat_little, 32, 0, 1, 8, 127, 255, 9, 23, floatformat_intbit_no, "floatformat_ieee_single_little" }; const struct floatformat floatformat_ieee_double_big = { floatformat_big, 64, 0, 1, 11, 1023, 2047, 12, 52, floatformat_intbit_no, "floatformat_ieee_double_big" }; const struct floatformat floatformat_ieee_double_little = { floatformat_little, 64, 0, 1, 11, 1023, 2047, 12, 52, floatformat_intbit_no, "floatformat_ieee_double_little" }; /* floatformat for IEEE double, little endian byte order, with big endian word ordering, as on the ARM. */ const struct floatformat floatformat_ieee_double_littlebyte_bigword = { floatformat_littlebyte_bigword, 64, 0, 1, 11, 1023, 2047, 12, 52, floatformat_intbit_no, "floatformat_ieee_double_littlebyte_bigword" }; const struct floatformat floatformat_i387_ext = { floatformat_little, 80, 0, 1, 15, 0x3fff, 0x7fff, 16, 64, floatformat_intbit_yes, "floatformat_i387_ext" }; const struct floatformat floatformat_m68881_ext = { /* Note that the bits from 16 to 31 are unused. */ floatformat_big, 96, 0, 1, 15, 0x3fff, 0x7fff, 32, 64, floatformat_intbit_yes, "floatformat_m68881_ext" }; const struct floatformat floatformat_i960_ext = { /* Note that the bits from 0 to 15 are unused. */ floatformat_little, 96, 16, 17, 15, 0x3fff, 0x7fff, 32, 64, floatformat_intbit_yes, "floatformat_i960_ext" }; const struct floatformat floatformat_m88110_ext = { floatformat_big, 80, 0, 1, 15, 0x3fff, 0x7fff, 16, 64, floatformat_intbit_yes, "floatformat_m88110_ext" }; const struct floatformat floatformat_m88110_harris_ext = { /* Harris uses raw format 128 bytes long, but the number is just an ieee double, and the last 64 bits are wasted. */ floatformat_big,128, 0, 1, 11, 0x3ff, 0x7ff, 12, 52, floatformat_intbit_no, "floatformat_m88110_ext_harris" }; const struct floatformat floatformat_arm_ext_big = { /* Bits 1 to 16 are unused. */ floatformat_big, 96, 0, 17, 15, 0x3fff, 0x7fff, 32, 64, floatformat_intbit_yes, "floatformat_arm_ext_big" }; const struct floatformat floatformat_arm_ext_littlebyte_bigword = { /* Bits 1 to 16 are unused. */ floatformat_littlebyte_bigword, 96, 0, 17, 15, 0x3fff, 0x7fff, 32, 64, floatformat_intbit_yes, "floatformat_arm_ext_littlebyte_bigword" }; const struct floatformat floatformat_ia64_spill_big = { floatformat_big, 128, 0, 1, 17, 65535, 0x1ffff, 18, 64, floatformat_intbit_yes, "floatformat_ia64_spill_big" }; const struct floatformat floatformat_ia64_spill_little = { floatformat_little, 128, 0, 1, 17, 65535, 0x1ffff, 18, 64, floatformat_intbit_yes, "floatformat_ia64_spill_little" }; const struct floatformat floatformat_ia64_quad_big = { floatformat_big, 128, 0, 1, 15, 16383, 0x7fff, 16, 112, floatformat_intbit_no, "floatformat_ia64_quad_big" }; const struct floatformat floatformat_ia64_quad_little = { floatformat_little, 128, 0, 1, 15, 16383, 0x7fff, 16, 112, floatformat_intbit_no, "floatformat_ia64_quad_little" }; static unsigned long get_field PARAMS ((unsigned char *, enum floatformat_byteorders, unsigned int, unsigned int, unsigned int)); /* Extract a field which starts at START and is LEN bytes long. DATA and TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */ static unsigned long get_field (data, order, total_len, start, len) unsigned char *data; enum floatformat_byteorders order; unsigned int total_len; unsigned int start; unsigned int len; { unsigned long result; unsigned int cur_byte; int cur_bitshift; /* Start at the least significant part of the field. */ cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT; if (order == floatformat_little) cur_byte = (total_len / FLOATFORMAT_CHAR_BIT) - cur_byte - 1; cur_bitshift = ((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT; result = *(data + cur_byte) >> (-cur_bitshift); cur_bitshift += FLOATFORMAT_CHAR_BIT; if (order == floatformat_little) ++cur_byte; else --cur_byte; /* Move towards the most significant part of the field. */ while ((unsigned int) cur_bitshift < len) { if (len - cur_bitshift < FLOATFORMAT_CHAR_BIT) /* This is the last byte; zero out the bits which are not part of this field. */ result |= (*(data + cur_byte) & ((1 << (len - cur_bitshift)) - 1)) << cur_bitshift; else result |= *(data + cur_byte) << cur_bitshift; cur_bitshift += FLOATFORMAT_CHAR_BIT; if (order == floatformat_little) ++cur_byte; else --cur_byte; } return result; } #ifndef min #define min(a, b) ((a) < (b) ? (a) : (b)) #endif /* Convert from FMT to a double. FROM is the address of the extended float. Store the double in *TO. */ void floatformat_to_double (fmt, from, to) const struct floatformat *fmt; char *from; double *to; { unsigned char *ufrom = (unsigned char *)from; double dto; long exponent; unsigned long mant; unsigned int mant_bits, mant_off; int mant_bits_left; int special_exponent; /* It's a NaN, denorm or zero */ exponent = get_field (ufrom, fmt->byteorder, fmt->totalsize, fmt->exp_start, fmt->exp_len); /* Note that if exponent indicates a NaN, we can't really do anything useful (not knowing if the host has NaN's, or how to build one). So it will end up as an infinity or something close; that is OK. */ mant_bits_left = fmt->man_len; mant_off = fmt->man_start; dto = 0.0; special_exponent = exponent == 0 || (unsigned long) exponent == fmt->exp_nan; /* Don't bias zero's, denorms or NaNs. */ if (!special_exponent) exponent -= fmt->exp_bias; /* Build the result algebraically. Might go infinite, underflow, etc; who cares. */ /* If this format uses a hidden bit, explicitly add it in now. Otherwise, increment the exponent by one to account for the integer bit. */ if (!special_exponent) { if (fmt->intbit == floatformat_intbit_no) dto = ldexp (1.0, exponent); else exponent++; } while (mant_bits_left > 0) { mant_bits = min (mant_bits_left, 32); mant = get_field (ufrom, fmt->byteorder, fmt->totalsize, mant_off, mant_bits); dto += ldexp ((double)mant, exponent - mant_bits); exponent -= mant_bits; mant_off += mant_bits; mant_bits_left -= mant_bits; } /* Negate it if negative. */ if (get_field (ufrom, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1)) dto = -dto; *to = dto; } static void put_field PARAMS ((unsigned char *, enum floatformat_byteorders, unsigned int, unsigned int, unsigned int, unsigned long)); /* Set a field which starts at START and is LEN bytes long. DATA and TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */ static void put_field (data, order, total_len, start, len, stuff_to_put) unsigned char *data; enum floatformat_byteorders order; unsigned int total_len; unsigned int start; unsigned int len; unsigned long stuff_to_put; { unsigned int cur_byte; int cur_bitshift; /* Start at the least significant part of the field. */ cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT; if (order == floatformat_little) cur_byte = (total_len / FLOATFORMAT_CHAR_BIT) - cur_byte - 1; cur_bitshift = ((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT; *(data + cur_byte) &= ~(((1 << ((start + len) % FLOATFORMAT_CHAR_BIT)) - 1) << (-cur_bitshift)); *(data + cur_byte) |= (stuff_to_put & ((1 << FLOATFORMAT_CHAR_BIT) - 1)) << (-cur_bitshift); cur_bitshift += FLOATFORMAT_CHAR_BIT; if (order == floatformat_little) ++cur_byte; else --cur_byte; /* Move towards the most significant part of the field. */ while ((unsigned int) cur_bitshift < len) { if (len - cur_bitshift < FLOATFORMAT_CHAR_BIT) { /* This is the last byte. */ *(data + cur_byte) &= ~((1 << (len - cur_bitshift)) - 1); *(data + cur_byte) |= (stuff_to_put >> cur_bitshift); } else *(data + cur_byte) = ((stuff_to_put >> cur_bitshift) & ((1 << FLOATFORMAT_CHAR_BIT) - 1)); cur_bitshift += FLOATFORMAT_CHAR_BIT; if (order == floatformat_little) ++cur_byte; else --cur_byte; } } /* The converse: convert the double *FROM to an extended float and store where TO points. Neither FROM nor TO have any alignment restrictions. */ void floatformat_from_double (fmt, from, to) const struct floatformat *fmt; double *from; char *to; { double dfrom; int exponent; double mant; unsigned int mant_bits, mant_off; int mant_bits_left; unsigned char *uto = (unsigned char *)to; memcpy (&dfrom, from, sizeof (dfrom)); memset (uto, 0, fmt->totalsize / FLOATFORMAT_CHAR_BIT); if (dfrom == 0) return; /* Result is zero */ if (dfrom != dfrom) { /* From is NaN */ put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start, fmt->exp_len, fmt->exp_nan); /* Be sure it's not infinity, but NaN value is irrel */ put_field (uto, fmt->byteorder, fmt->totalsize, fmt->man_start, 32, 1); return; } /* If negative, set the sign bit. */ if (dfrom < 0) { put_field (uto, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1, 1); dfrom = -dfrom; } /* How to tell an infinity from an ordinary number? FIXME-someday */ mant = frexp (dfrom, &exponent); put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start, fmt->exp_len, exponent + fmt->exp_bias - 1); mant_bits_left = fmt->man_len; mant_off = fmt->man_start; while (mant_bits_left > 0) { unsigned long mant_long; mant_bits = mant_bits_left < 32 ? mant_bits_left : 32; mant *= 4294967296.0; mant_long = (unsigned long)mant; mant -= mant_long; /* If the integer bit is implicit, then we need to discard it. If we are discarding a zero, we should be (but are not) creating a denormalized number which means adjusting the exponent (I think). */ if ((unsigned int) mant_bits_left == fmt->man_len && fmt->intbit == floatformat_intbit_no) { mant_long &= 0x7fffffff; mant_bits -= 1; } else if (mant_bits < 32) { /* The bits we want are in the most significant MANT_BITS bits of mant_long. Move them to the least significant. */ mant_long >>= 32 - mant_bits; } put_field (uto, fmt->byteorder, fmt->totalsize, mant_off, mant_bits, mant_long); mant_off += mant_bits; mant_bits_left -= mant_bits; } } #ifdef IEEE_DEBUG /* This is to be run on a host which uses IEEE floating point. */ void ieee_test (n) double n; { double result; char exten[16]; floatformat_to_double (&floatformat_ieee_double_big, &n, &result); if (n != result) printf ("Differ(to): %.20g -> %.20g\n", n, result); floatformat_from_double (&floatformat_ieee_double_big, &n, &result); if (n != result) printf ("Differ(from): %.20g -> %.20g\n", n, result); floatformat_from_double (&floatformat_m68881_ext, &n, exten); floatformat_to_double (&floatformat_m68881_ext, exten, &result); if (n != result) printf ("Differ(to+from): %.20g -> %.20g\n", n, result); #if IEEE_DEBUG > 1 /* This is to be run on a host which uses 68881 format. */ { long double ex = *(long double *)exten; if (ex != n) printf ("Differ(from vs. extended): %.20g\n", n); } #endif } int main () { ieee_test (0.5); ieee_test (256.0); ieee_test (0.12345); ieee_test (234235.78907234); ieee_test (-512.0); ieee_test (-0.004321); return 0; } #endif