/* Floating point routines for GDB, the GNU debugger.
- Copyright 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
- 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004 Free Software
- Foundation, Inc.
+ Copyright (C) 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
+ 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2007
+ 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
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
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. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
/* Support for converting target fp numbers into host DOUBLEST format. */
can convert to doublest will need. */
#define FLOATFORMAT_LARGEST_BYTES 16
-static unsigned long get_field (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 (unsigned char *data, enum floatformat_byteorders order,
+get_field (const bfd_byte *data, enum floatformat_byteorders order,
unsigned int total_len, unsigned int start, unsigned int len)
{
unsigned long 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. */
+/* 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)
|| 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)
+ if (fmt->byteorder == floatformat_vax)
+ {
+ while (words-- > 0)
+ {
+ *swapout++ = swapin[1];
+ *swapout++ = swapin[0];
+ *swapout++ = swapin[3];
+ *swapout++ = swapin[2];
+ swapin += 4;
+ }
+ /* This may look weird, since VAX is little-endian, but it is
+ easier to translate to big-endian than to little-endian. */
+ return floatformat_big;
+ }
+ else
{
- *swapout++ = swapin[3];
- *swapout++ = swapin[2];
- *swapout++ = swapin[1];
- *swapout++ = swapin[0];
- swapin += 4;
+ gdb_assert (fmt->byteorder == floatformat_littlebyte_bigword);
+
+ while (words-- > 0)
+ {
+ *swapout++ = swapin[3];
+ *swapout++ = swapin[2];
+ *swapout++ = swapin[1];
+ *swapout++ = swapin[0];
+ swapin += 4;
+ }
+ return floatformat_big;
}
- return floatformat_big;
}
/* Convert from FMT to a DOUBLEST.
int special_exponent; /* It's a NaN, denorm or zero */
enum floatformat_byteorders order;
unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
+ enum float_kind kind;
gdb_assert (fmt->totalsize
<= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);
+ /* For non-numbers, reuse libiberty's logic to find the correct
+ format. We do not lose any precision in this case by passing
+ through a double. */
+ kind = floatformat_classify (fmt, from);
+ if (kind == float_infinite || kind == float_nan)
+ {
+ double dto;
+ floatformat_to_double (fmt, from, &dto);
+ *to = (DOUBLEST) dto;
+ return;
+ }
+
order = floatformat_normalize_byteorder (fmt, ufrom, newfrom);
if (order != fmt->byteorder)
#endif /* HAVE_LONG_DOUBLE */
-/* The converse: convert the DOUBLEST *FROM to an extended float
- and store where TO points. Neither FROM nor TO have any alignment
+/* The converse: convert the DOUBLEST *FROM to an extended float and
+ store where TO points. Neither FROM nor TO have any alignment
restrictions. */
static void
convert_doublest_to_floatformat (CONST struct floatformat *fmt,
- const DOUBLEST *from,
- void *to)
+ const DOUBLEST *from, void *to)
{
DOUBLEST dfrom;
int exponent;
int mant_bits_left;
unsigned char *uto = (unsigned char *) to;
enum floatformat_byteorders order = fmt->byteorder;
+ unsigned char newto[FLOATFORMAT_LARGEST_BYTES];
- if (order == floatformat_littlebyte_bigword)
+ if (order != floatformat_little)
order = floatformat_big;
+ if (order != fmt->byteorder)
+ uto = newto;
+
memcpy (&dfrom, from, sizeof (dfrom));
memset (uto, 0, (fmt->totalsize + FLOATFORMAT_CHAR_BIT - 1)
/ FLOATFORMAT_CHAR_BIT);
finalize_byteorder:
/* Do we need to byte-swap the words in the result? */
if (order != fmt->byteorder)
- {
- int words;
- unsigned char *curword = uto;
- unsigned char tmp;
-
- words = fmt->totalsize / FLOATFORMAT_CHAR_BIT;
- words >>= 2;
- while (words-- > 0)
- {
- tmp = curword[0];
- curword[0] = curword[3];
- curword[3] = tmp;
- tmp = curword[1];
- curword[1] = curword[2];
- curword[2] = tmp;
- curword += 4;
- }
- }
+ floatformat_normalize_byteorder (fmt, newto, to);
}
/* Check if VAL (which is assumed to be a floating point number whose
format is described by FMT) is negative. */
int
-floatformat_is_negative (const struct floatformat *fmt, char *val)
+floatformat_is_negative (const struct floatformat *fmt,
+ const bfd_byte *uval)
{
- unsigned char *uval = (unsigned char *) val;
enum floatformat_byteorders order;
unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
/* Check if VAL is "not a number" (NaN) for FMT. */
-int
-floatformat_is_nan (const struct floatformat *fmt, char *val)
+enum float_kind
+floatformat_classify (const struct floatformat *fmt,
+ const bfd_byte *uval)
{
- unsigned char *uval = (unsigned char *) val;
long exponent;
unsigned long mant;
unsigned int mant_bits, mant_off;
int mant_bits_left;
enum floatformat_byteorders order;
unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
+ int mant_zero;
gdb_assert (fmt != NULL);
gdb_assert (fmt->totalsize
if (order != fmt->byteorder)
uval = newfrom;
- if (! fmt->exp_nan)
- return 0;
-
exponent = get_field (uval, order, fmt->totalsize, fmt->exp_start,
fmt->exp_len);
- if (exponent != fmt->exp_nan)
- return 0;
-
mant_bits_left = fmt->man_len;
mant_off = fmt->man_start;
+ mant_zero = 1;
while (mant_bits_left > 0)
{
mant_bits = min (mant_bits_left, 32);
mant &= ~(1 << (mant_bits - 1));
if (mant)
- return 1;
+ {
+ mant_zero = 0;
+ break;
+ }
mant_off += mant_bits;
mant_bits_left -= mant_bits;
}
- return 0;
+ /* If exp_nan is not set, assume that inf, NaN, and subnormals are not
+ supported. */
+ if (! fmt->exp_nan)
+ {
+ if (mant_zero)
+ return float_zero;
+ else
+ return float_normal;
+ }
+
+ if (exponent == 0 && !mant_zero)
+ return float_subnormal;
+
+ if (exponent == fmt->exp_nan)
+ {
+ if (mant_zero)
+ return float_infinite;
+ else
+ return float_nan;
+ }
+
+ if (mant_zero)
+ return float_zero;
+
+ return float_normal;
}
/* Convert the mantissa of VAL (which is assumed to be a floating
point number whose format is described by FMT) into a hexadecimal
and store it in a static string. Return a pointer to that string. */
-char *
-floatformat_mantissa (const struct floatformat *fmt, char *val)
+const char *
+floatformat_mantissa (const struct floatformat *fmt,
+ const bfd_byte *val)
{
unsigned char *uval = (unsigned char *) val;
unsigned long mant;
int mant_bits_left;
static char res[50];
char buf[9];
+ int len;
enum floatformat_byteorders order;
unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
mant = get_field (uval, order, fmt->totalsize, mant_off, mant_bits);
- sprintf (res, "%lx", mant);
+ len = xsnprintf (res, sizeof res, "%lx", mant);
mant_off += mant_bits;
mant_bits_left -= mant_bits;
-
+
while (mant_bits_left > 0)
{
mant = get_field (uval, order, fmt->totalsize, mant_off, 32);
- sprintf (buf, "%08lx", mant);
+ xsnprintf (buf, sizeof buf, "%08lx", mant);
+ gdb_assert (len + strlen (buf) <= sizeof res);
strcat (res, buf);
mant_off += 32;
floatformat_from_length (int len)
{
const struct floatformat *format;
- if (len * TARGET_CHAR_BIT == TARGET_FLOAT_BIT)
- format = TARGET_FLOAT_FORMAT;
- else if (len * TARGET_CHAR_BIT == TARGET_DOUBLE_BIT)
- format = TARGET_DOUBLE_FORMAT;
- else if (len * TARGET_CHAR_BIT == TARGET_LONG_DOUBLE_BIT)
- format = TARGET_LONG_DOUBLE_FORMAT;
+ if (len * TARGET_CHAR_BIT == gdbarch_float_bit (current_gdbarch))
+ format = gdbarch_float_format (current_gdbarch)
+ [gdbarch_byte_order (current_gdbarch)];
+ else if (len * TARGET_CHAR_BIT == gdbarch_double_bit (current_gdbarch))
+ format = gdbarch_double_format (current_gdbarch)
+ [gdbarch_byte_order (current_gdbarch)];
+ else if (len * TARGET_CHAR_BIT == gdbarch_long_double_bit (current_gdbarch))
+ format = gdbarch_long_double_format (current_gdbarch)
+ [gdbarch_byte_order (current_gdbarch)];
/* On i386 the 'long double' type takes 96 bits,
while the real number of used bits is only 80,
both in processor and in memory.
The code below accepts the real bit size. */
- else if ((TARGET_LONG_DOUBLE_FORMAT != NULL)
+ else if ((gdbarch_long_double_format (current_gdbarch) != NULL)
&& (len * TARGET_CHAR_BIT ==
- TARGET_LONG_DOUBLE_FORMAT->totalsize))
- format = TARGET_LONG_DOUBLE_FORMAT;
+ gdbarch_long_double_format (current_gdbarch)[0]->totalsize))
+ format = gdbarch_long_double_format (current_gdbarch)
+ [gdbarch_byte_order (current_gdbarch)];
else
format = NULL;
if (format == NULL)
- error ("Unrecognized %d-bit floating-point type.",
+ error (_("Unrecognized %d-bit floating-point type."),
len * TARGET_CHAR_BIT);
return format;
}
{
gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT);
if (TYPE_FLOATFORMAT (type) != NULL)
- return TYPE_FLOATFORMAT (type);
+ return TYPE_FLOATFORMAT (type)[gdbarch_byte_order (current_gdbarch)];
else
return floatformat_from_length (TYPE_LENGTH (type));
}
specific code? stabs?) so handle that here as a special case. */
return extract_floating_by_length (addr, TYPE_LENGTH (type));
- floatformat_to_doublest (TYPE_FLOATFORMAT (type), addr, &retval);
+ floatformat_to_doublest
+ (TYPE_FLOATFORMAT (type)[gdbarch_byte_order (current_gdbarch)],
+ addr, &retval);
return retval;
}
specific code? stabs?) so handle that here as a special case. */
store_floating_by_length (addr, TYPE_LENGTH (type), val);
else
- floatformat_from_doublest (TYPE_FLOATFORMAT (type), &val, addr);
+ floatformat_from_doublest
+ (TYPE_FLOATFORMAT (type)[gdbarch_byte_order (current_gdbarch)],
+ &val, addr);
}
/* Convert a floating-point number of type FROM_TYPE from a
assumption might be wrong on targets that support
floating-point types that only differ in endianness for
example. So we warn instead, and zero out the target buffer. */
- warning ("Can't convert floating-point number to desired type.");
+ warning (_("Can't convert floating-point number to desired type."));
memset (to, 0, TYPE_LENGTH (to_type));
}
else if (from_fmt == to_fmt)
projects / thirdparty / binutils-gdb.git / blobdiff