FreeChainXenon/binutils-gdb
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

* doublest.c (FLOATFORMAT_LARGEST_BYTES): New define.

Browse source 
(get_field, put_field): Assert that the format is one we can handle.
Simplify logic accordingly.
(floatformat_normalize_byteorder): New function.
(convert_floatformat_to_doublest): Use floatformat_normalize_byteorder
to normalize and select modified byte order. Pass modified byte order
to get_field.
(floatformat_is_negative, floatformat_is_nan, floatformat_mantissa):
Likewise.
(convert_doublest_to_floatformat): Select an appropriate intermediate
byte order if necessary.  Always convert to the final format before
returning.
This commit is contained in:
Richard Earnshaw 2004-12-05 15:17:34 +00:00
parent 0e1200e593
commit fcab3fb53b
2 changed files with 146 additions and 80 deletions
Download patch file Download diff file Expand all files Collapse all files

15
gdb/ChangeLog
View file

@ -1,3 +1,18 @@
2004-12-05 Richard Earnshaw <rearnsha@arm.com>
* doublest.c (FLOATFORMAT_LARGEST_BYTES): New define.
(get_field, put_field): Assert that the format is one we can handle.
Simplify logic accordingly.
(floatformat_normalize_byteorder): New function.
(convert_floatformat_to_doublest): Use floatformat_normalize_byteorder
to normalize and select modified byte order. Pass modified byte order
to get_field.
(floatformat_is_negative, floatformat_is_nan, floatformat_mantissa):
Likewise.
(convert_doublest_to_floatformat): Select an appropriate intermediate
byte order if necessary. Always convert to the final format before
returning.
2004-12-04 Daniel Jacobowitz <dan@debian.org> 2004-12-04 Daniel Jacobowitz <dan@debian.org>
PR tui/1703 PR tui/1703

205
gdb/doublest.c
View file

@ -40,6 +40,10 @@
a system header, what we do if not, etc. */ a system header, what we do if not, etc. */
#define FLOATFORMAT_CHAR_BIT 8 #define FLOATFORMAT_CHAR_BIT 8
/* The number of bytes that the largest floating-point type that we
can convert to doublest will need. */
#define FLOATFORMAT_LARGEST_BYTES 16
static unsigned long get_field (unsigned char *, static unsigned long get_field (unsigned char *,
enum floatformat_byteorders, enum floatformat_byteorders,
unsigned int, unsigned int, unsigned int); unsigned int, unsigned int, unsigned int);
@ -54,8 +58,11 @@ get_field (unsigned char *data, enum floatformat_byteorders order,
unsigned int cur_byte; unsigned int cur_byte;
int cur_bitshift; int cur_bitshift;
/* Caller must byte-swap words before calling this routine. */
gdb_assert (order == floatformat_little || order == floatformat_big);
/* Start at the least significant part of the field. */ /* Start at the least significant part of the field. */
if (order == floatformat_little || order == floatformat_littlebyte_bigword) if (order == floatformat_little)
{ {
/* We start counting from the other end (i.e, from the high bytes /* We start counting from the other end (i.e, from the high bytes
rather than the low bytes). As such, we need to be concerned rather than the low bytes). As such, we need to be concerned
@ -81,7 +88,7 @@ get_field (unsigned char *data, enum floatformat_byteorders order,
else else
result = 0; result = 0;
cur_bitshift += FLOATFORMAT_CHAR_BIT; cur_bitshift += FLOATFORMAT_CHAR_BIT;
if (order == floatformat_little || order == floatformat_littlebyte_bigword) if (order == floatformat_little)
++cur_byte; ++cur_byte;
else else
--cur_byte; --cur_byte;
@ -99,8 +106,6 @@ get_field (unsigned char *data, enum floatformat_byteorders order,
case floatformat_big: case floatformat_big:
--cur_byte; --cur_byte;
break; break;
case floatformat_littlebyte_bigword:
break;
} }
} }
if (len < sizeof(result) * FLOATFORMAT_CHAR_BIT) if (len < sizeof(result) * FLOATFORMAT_CHAR_BIT)
@ -109,6 +114,40 @@ get_field (unsigned char *data, enum floatformat_byteorders order,
return result; return result;
} }
/* Normalize the byte order of FROM into TO. If no normalization is needed
then FMT->byteorder is returned and TO is not changed; otherwise the format
of the normalized form in TO is returned. */
static enum floatformat_byteorders
floatformat_normalize_byteorder (const struct floatformat *fmt,
const void *from, void *to)
{
const unsigned char *swapin;
unsigned char *swapout;
int words;
if (fmt->byteorder == floatformat_little
|| fmt->byteorder == floatformat_big)
return fmt->byteorder;
gdb_assert (fmt->byteorder == floatformat_littlebyte_bigword);
words = fmt->totalsize / FLOATFORMAT_CHAR_BIT;
words >>= 2;
swapout = (unsigned char *)to;
swapin = (const unsigned char *)from;
while (words-- > 0)
{
*swapout++ = swapin[3];
*swapout++ = swapin[2];
*swapout++ = swapin[1];
*swapout++ = swapin[0];
swapin += 4;
}
return floatformat_big;
}
/* Convert from FMT to a DOUBLEST. /* Convert from FMT to a DOUBLEST.
FROM is the address of the extended float. FROM is the address of the extended float.
Store the DOUBLEST in *TO. */ Store the DOUBLEST in *TO. */
@ -125,51 +164,19 @@ convert_floatformat_to_doublest (const struct floatformat *fmt,
unsigned int mant_bits, mant_off; unsigned int mant_bits, mant_off;
int mant_bits_left; int mant_bits_left;
int special_exponent; /* It's a NaN, denorm or zero */ int special_exponent; /* It's a NaN, denorm or zero */
enum floatformat_byteorders order;
unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
/* If the mantissa bits are not contiguous from one end of the gdb_assert (fmt->totalsize
mantissa to the other, we need to make a private copy of the <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);
source bytes that is in the right order since the unpacking
algorithm assumes that the bits are contiguous.
Swap the bytes individually rather than accessing them through order = floatformat_normalize_byteorder (fmt, ufrom, newfrom);
"long *" since we have no guarantee that they start on a long
alignment, and also sizeof(long) for the host could be different
than sizeof(long) for the target. FIXME: Assumes sizeof(long)
for the target is 4. */
if (fmt->byteorder == floatformat_littlebyte_bigword) if (order != fmt->byteorder)
{
static unsigned char *newfrom;
unsigned char *swapin, *swapout;
int longswaps;
longswaps = fmt->totalsize / FLOATFORMAT_CHAR_BIT;
longswaps >>= 3;
if (newfrom == NULL)
{
newfrom = (unsigned char *) xmalloc (fmt->totalsize);
}
swapout = newfrom;
swapin = ufrom;
ufrom = newfrom; ufrom = newfrom;
while (longswaps-- > 0)
{
/* This is ugly, but efficient */
*swapout++ = swapin[4];
*swapout++ = swapin[5];
*swapout++ = swapin[6];
*swapout++ = swapin[7];
*swapout++ = swapin[0];
*swapout++ = swapin[1];
*swapout++ = swapin[2];
*swapout++ = swapin[3];
swapin += 8;
}
}
exponent = get_field (ufrom, fmt->byteorder, fmt->totalsize, exponent = get_field (ufrom, order, fmt->totalsize, fmt->exp_start,
fmt->exp_start, fmt->exp_len); fmt->exp_len);
/* Note that if exponent indicates a NaN, we can't really do anything useful /* 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 (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. */ end up as an infinity or something close; that is OK. */
@ -207,8 +214,7 @@ convert_floatformat_to_doublest (const struct floatformat *fmt,
{ {
mant_bits = min (mant_bits_left, 32); mant_bits = min (mant_bits_left, 32);
mant = get_field (ufrom, fmt->byteorder, fmt->totalsize, mant = get_field (ufrom, order, fmt->totalsize, mant_off, mant_bits);
mant_off, mant_bits);
dto += ldexp ((double) mant, exponent - mant_bits); dto += ldexp ((double) mant, exponent - mant_bits);
exponent -= mant_bits; exponent -= mant_bits;
@ -217,7 +223,7 @@ convert_floatformat_to_doublest (const struct floatformat *fmt,
} }
/* Negate it if negative. */ /* Negate it if negative. */
if (get_field (ufrom, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1)) if (get_field (ufrom, order, fmt->totalsize, fmt->sign_start, 1))
dto = -dto; dto = -dto;
*to = dto; *to = dto;
} }
@ -236,8 +242,11 @@ put_field (unsigned char *data, enum floatformat_byteorders order,
unsigned int cur_byte; unsigned int cur_byte;
int cur_bitshift; int cur_bitshift;
/* Caller must byte-swap words before calling this routine. */
gdb_assert (order == floatformat_little || order == floatformat_big);
/* Start at the least significant part of the field. */ /* Start at the least significant part of the field. */
if (order == floatformat_little || order == floatformat_littlebyte_bigword) if (order == floatformat_little)
{ {
int excess = FLOATFORMAT_CHAR_BIT - (total_len % FLOATFORMAT_CHAR_BIT); int excess = FLOATFORMAT_CHAR_BIT - (total_len % FLOATFORMAT_CHAR_BIT);
cur_byte = (total_len / FLOATFORMAT_CHAR_BIT) cur_byte = (total_len / FLOATFORMAT_CHAR_BIT)
@ -260,7 +269,7 @@ put_field (unsigned char *data, enum floatformat_byteorders order,
(stuff_to_put & ((1 << FLOATFORMAT_CHAR_BIT) - 1)) << (-cur_bitshift); (stuff_to_put & ((1 << FLOATFORMAT_CHAR_BIT) - 1)) << (-cur_bitshift);
} }
cur_bitshift += FLOATFORMAT_CHAR_BIT; cur_bitshift += FLOATFORMAT_CHAR_BIT;
if (order == floatformat_little || order == floatformat_littlebyte_bigword) if (order == floatformat_little)
++cur_byte; ++cur_byte;
else else
--cur_byte; --cur_byte;
@ -279,7 +288,7 @@ put_field (unsigned char *data, enum floatformat_byteorders order,
*(data + cur_byte) = ((stuff_to_put >> cur_bitshift) *(data + cur_byte) = ((stuff_to_put >> cur_bitshift)
& ((1 << FLOATFORMAT_CHAR_BIT) - 1)); & ((1 << FLOATFORMAT_CHAR_BIT) - 1));
cur_bitshift += FLOATFORMAT_CHAR_BIT; cur_bitshift += FLOATFORMAT_CHAR_BIT;
if (order == floatformat_little || order == floatformat_littlebyte_bigword) if (order == floatformat_little)
++cur_byte; ++cur_byte;
else else
--cur_byte; --cur_byte;
@ -347,6 +356,10 @@ convert_doublest_to_floatformat (CONST struct floatformat *fmt,
unsigned int mant_bits, mant_off; unsigned int mant_bits, mant_off;
int mant_bits_left; int mant_bits_left;
unsigned char *uto = (unsigned char *) to; unsigned char *uto = (unsigned char *) to;
enum floatformat_byteorders order = fmt->byteorder;
if (order == floatformat_littlebyte_bigword)
order = floatformat_big;
memcpy (&dfrom, from, sizeof (dfrom)); memcpy (&dfrom, from, sizeof (dfrom));
memset (uto, 0, (fmt->totalsize + FLOATFORMAT_CHAR_BIT - 1) memset (uto, 0, (fmt->totalsize + FLOATFORMAT_CHAR_BIT - 1)
@ -356,30 +369,30 @@ convert_doublest_to_floatformat (CONST struct floatformat *fmt,
if (dfrom != dfrom) /* Result is NaN */ if (dfrom != dfrom) /* Result is NaN */
{ {
/* From is NaN */ /* From is NaN */
put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start, put_field (uto, order, fmt->totalsize, fmt->exp_start,
fmt->exp_len, fmt->exp_nan); fmt->exp_len, fmt->exp_nan);
/* Be sure it's not infinity, but NaN value is irrel */ /* Be sure it's not infinity, but NaN value is irrel */
put_field (uto, fmt->byteorder, fmt->totalsize, fmt->man_start, put_field (uto, order, fmt->totalsize, fmt->man_start,
32, 1); 32, 1);
return; goto finalize_byteorder;
} }
/* If negative, set the sign bit. */ /* If negative, set the sign bit. */
if (dfrom < 0) if (dfrom < 0)
{ {
put_field (uto, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1, 1); put_field (uto, order, fmt->totalsize, fmt->sign_start, 1, 1);
dfrom = -dfrom; dfrom = -dfrom;
} }
if (dfrom + dfrom == dfrom && dfrom != 0.0) /* Result is Infinity */ if (dfrom + dfrom == dfrom && dfrom != 0.0) /* Result is Infinity */
{ {
/* Infinity exponent is same as NaN's. */ /* Infinity exponent is same as NaN's. */
put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start, put_field (uto, order, fmt->totalsize, fmt->exp_start,
fmt->exp_len, fmt->exp_nan); fmt->exp_len, fmt->exp_nan);
/* Infinity mantissa is all zeroes. */ /* Infinity mantissa is all zeroes. */
put_field (uto, fmt->byteorder, fmt->totalsize, fmt->man_start, put_field (uto, order, fmt->totalsize, fmt->man_start,
fmt->man_len, 0); fmt->man_len, 0);
return; goto finalize_byteorder;
} }
#ifdef HAVE_LONG_DOUBLE #ifdef HAVE_LONG_DOUBLE
@ -388,7 +401,7 @@ convert_doublest_to_floatformat (CONST struct floatformat *fmt,
mant = frexp (dfrom, &exponent); mant = frexp (dfrom, &exponent);
#endif #endif
put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start, fmt->exp_len, put_field (uto, order, fmt->totalsize, fmt->exp_start, fmt->exp_len,
exponent + fmt->exp_bias - 1); exponent + fmt->exp_bias - 1);
mant_bits_left = fmt->man_len; mant_bits_left = fmt->man_len;
@ -429,23 +442,31 @@ convert_doublest_to_floatformat (CONST struct floatformat *fmt,
mant_long >>= 32 - mant_bits; mant_long >>= 32 - mant_bits;
} }
put_field (uto, fmt->byteorder, fmt->totalsize, put_field (uto, order, fmt->totalsize,
mant_off, mant_bits, mant_long); mant_off, mant_bits, mant_long);
mant_off += mant_bits; mant_off += mant_bits;
mant_bits_left -= mant_bits; mant_bits_left -= mant_bits;
} }
if (fmt->byteorder == floatformat_littlebyte_bigword)
finalize_byteorder:
/* Do we need to byte-swap the words in the result? */
if (order != fmt->byteorder)
{ {
int count; int words;
unsigned char *swaplow = uto; unsigned char *curword = uto;
unsigned char *swaphigh = uto + 4;
unsigned char tmp; unsigned char tmp;
for (count = 0; count < 4; count++) words = fmt->totalsize / FLOATFORMAT_CHAR_BIT;
words >>= 2;
while (words-- > 0)
{ {
tmp = *swaplow; tmp = curword[0];
*swaplow++ = *swaphigh; curword[0] = curword[3];
*swaphigh++ = tmp; curword[3] = tmp;
tmp = curword[1];
curword[1] = curword[2];
curword[2] = tmp;
curword += 4;
} }
} }
} }
@ -457,8 +478,19 @@ int
floatformat_is_negative (const struct floatformat *fmt, char *val) floatformat_is_negative (const struct floatformat *fmt, char *val)
{ {
unsigned char *uval = (unsigned char *) val; unsigned char *uval = (unsigned char *) val;
enum floatformat_byteorders order;
unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
gdb_assert (fmt != NULL); gdb_assert (fmt != NULL);
return get_field (uval, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1); gdb_assert (fmt->totalsize
<= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);
order = floatformat_normalize_byteorder (fmt, uval, newfrom);
if (order != fmt->byteorder)
uval = newfrom;
return get_field (uval, order, fmt->totalsize, fmt->sign_start, 1);
} }
/* Check if VAL is "not a number" (NaN) for FMT. */ /* Check if VAL is "not a number" (NaN) for FMT. */
@ -471,14 +503,23 @@ floatformat_is_nan (const struct floatformat *fmt, char *val)
unsigned long mant; unsigned long mant;
unsigned int mant_bits, mant_off; unsigned int mant_bits, mant_off;
int mant_bits_left; int mant_bits_left;
enum floatformat_byteorders order;
unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
gdb_assert (fmt != NULL); gdb_assert (fmt != NULL);
gdb_assert (fmt->totalsize
<= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);
order = floatformat_normalize_byteorder (fmt, uval, newfrom);
if (order != fmt->byteorder)
uval = newfrom;
if (! fmt->exp_nan) if (! fmt->exp_nan)
return 0; return 0;
exponent = get_field (uval, fmt->byteorder, fmt->totalsize, exponent = get_field (uval, order, fmt->totalsize, fmt->exp_start,
fmt->exp_start, fmt->exp_len); fmt->exp_len);
if (exponent != fmt->exp_nan) if (exponent != fmt->exp_nan)
return 0; return 0;
@ -490,8 +531,7 @@ floatformat_is_nan (const struct floatformat *fmt, char *val)
{ {
mant_bits = min (mant_bits_left, 32); mant_bits = min (mant_bits_left, 32);
mant = get_field (uval, fmt->byteorder, fmt->totalsize, mant = get_field (uval, order, fmt->totalsize, mant_off, mant_bits);
mant_off, mant_bits);
/* If there is an explicit integer bit, mask it off. */ /* If there is an explicit integer bit, mask it off. */
if (mant_off == fmt->man_start if (mant_off == fmt->man_start
@ -521,17 +561,29 @@ floatformat_mantissa (const struct floatformat *fmt, char *val)
int mant_bits_left; int mant_bits_left;
static char res[50]; static char res[50];
char buf[9]; char buf[9];
enum floatformat_byteorders order;
unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
gdb_assert (fmt != NULL);
gdb_assert (fmt->totalsize
<= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);
order = floatformat_normalize_byteorder (fmt, uval, newfrom);
if (order != fmt->byteorder)
uval = newfrom;
if (! fmt->exp_nan)
return 0;
/* Make sure we have enough room to store the mantissa. */ /* Make sure we have enough room to store the mantissa. */
gdb_assert (fmt != NULL);
gdb_assert (sizeof res > ((fmt->man_len + 7) / 8) * 2); gdb_assert (sizeof res > ((fmt->man_len + 7) / 8) * 2);
mant_off = fmt->man_start; mant_off = fmt->man_start;
mant_bits_left = fmt->man_len; mant_bits_left = fmt->man_len;
mant_bits = (mant_bits_left % 32) > 0 ? mant_bits_left % 32 : 32; mant_bits = (mant_bits_left % 32) > 0 ? mant_bits_left % 32 : 32;
mant = get_field (uval, fmt->byteorder, fmt->totalsize, mant = get_field (uval, order, fmt->totalsize, mant_off, mant_bits);
mant_off, mant_bits);
sprintf (res, "%lx", mant); sprintf (res, "%lx", mant);
@ -540,8 +592,7 @@ floatformat_mantissa (const struct floatformat *fmt, char *val)
while (mant_bits_left > 0) while (mant_bits_left > 0)
{ {
mant = get_field (uval, fmt->byteorder, fmt->totalsize, mant = get_field (uval, order, fmt->totalsize, mant_off, 32);
mant_off, 32);
sprintf (buf, "%08lx", mant); sprintf (buf, "%08lx", mant);
strcat (res, buf); strcat (res, buf);