diff options
| -rw-r--r-- | gdb/ChangeLog | 14 | ||||
| -rw-r--r-- | gdb/doublest.c | 151 | ||||
| -rw-r--r-- | gdb/doublest.h | 4 |
3 files changed, 102 insertions, 67 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 20a208d..47fe784 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,5 +1,19 @@ 2001-08-11 Andrew Cagney <ac131313@redhat.com> + * doublest.c (convert_doublest_to_floatformat): Rename + floatformat_from_doublest. Make static. + (convert_floatformat_to_doublest): Rename floatformat_to_doublest. + Make static. + (floatformat_to_doublest): New function. + (floatformat_from_doublest): New function. + (host_float_format, host_double_format, host_long_double_format): + New static variables. + (store_floating, extract_floating): Always use + floatformat_to_doublest and floatformat_from_doublest. + * doublest.h (HOST_LONG_DOUBLE_FORMAT): Delete macro. + +2001-08-11 Andrew Cagney <ac131313@redhat.com> + * config/mn10300/tm-mn10300.h (INIT_FRAME_PC): Delete. * mn10300-tdep.c (mn10300_gdbarch_init): Initialize init_frame_pc. diff --git a/gdb/doublest.c b/gdb/doublest.c index af635f2..287c9ad 100644 --- a/gdb/doublest.c +++ b/gdb/doublest.c @@ -104,10 +104,10 @@ get_field (unsigned char *data, enum floatformat_byteorders order, FROM is the address of the extended float. Store the DOUBLEST in *TO. */ -void -floatformat_to_doublest (const struct floatformat *fmt, - const void *from, - DOUBLEST *to) +static void +convert_floatformat_to_doublest (const struct floatformat *fmt, + const void *from, + DOUBLEST *to) { unsigned char *ufrom = (unsigned char *) from; DOUBLEST dto; @@ -325,10 +325,10 @@ ldfrexp (long double value, int *eptr) and store where TO points. Neither FROM nor TO have any alignment restrictions. */ -void -floatformat_from_doublest (CONST struct floatformat *fmt, - const DOUBLEST *from, - void *to) +static void +convert_doublest_to_floatformat (CONST struct floatformat *fmt, + const DOUBLEST *from, + void *to) { DOUBLEST dfrom; int exponent; @@ -533,60 +533,102 @@ floatformat_mantissa (const struct floatformat *fmt, char *val) -/* Extract a floating-point number from a target-order byte-stream at ADDR. - Returns the value as type DOUBLEST. +/* Convert TO/FROM target to the hosts DOUBLEST floating-point format. + + If the host and target formats agree, we just copy the raw data + into the appropriate type of variable and return, letting the host + increase precision as necessary. Otherwise, we call the conversion + routine and let it do the dirty work. */ + +#ifndef HOST_FLOAT_FORMAT +#define HOST_FLOAT_FORMAT 0 +#endif +#ifndef HOST_DOUBLE_FORMAT +#define HOST_DOUBLE_FORMAT 0 +#endif +#ifndef HOST_LONG_DOUBLE_FORMAT +#define HOST_LONG_DOUBLE_FORMAT 0 +#endif + +static const struct floatformat *host_float_format = HOST_FLOAT_FORMAT; +static const struct floatformat *host_double_format = HOST_DOUBLE_FORMAT; +static const struct floatformat *host_long_double_format = HOST_LONG_DOUBLE_FORMAT; + +void +floatformat_to_doublest (const struct floatformat *fmt, + const void *in, DOUBLEST *out) +{ + gdb_assert (fmt != NULL); + if (fmt == host_float_format) + { + float val; + memcpy (&val, in, sizeof (val)); + *out = val; + } + else if (fmt == host_double_format) + { + double val; + memcpy (&val, in, sizeof (val)); + *out = val; + } + else if (fmt == host_long_double_format) + { + long double val; + memcpy (&val, in, sizeof (val)); + *out = val; + } + else + convert_floatformat_to_doublest (fmt, in, out); +} + +void +floatformat_from_doublest (const struct floatformat *fmt, + const DOUBLEST *in, void *out) +{ + gdb_assert (fmt != NULL); + if (fmt == host_float_format) + { + float val = *in; + memcpy (out, &val, sizeof (val)); + } + else if (fmt == host_double_format) + { + double val = *in; + memcpy (out, &val, sizeof (val)); + } + else if (fmt == host_long_double_format) + { + long double val = *in; + memcpy (out, &val, sizeof (val)); + } + else + convert_doublest_to_floatformat (fmt, in, out); +} - If the host and target formats agree, we just copy the raw data into the - appropriate type of variable and return, letting the host increase precision - as necessary. Otherwise, we call the conversion routine and let it do the - dirty work. */ + +/* Extract/store a floating-point number from a target-order + byte-stream at ADDR. Returns the value as type DOUBLEST. */ DOUBLEST extract_floating (const void *addr, int len) { DOUBLEST dretval; - if (len * TARGET_CHAR_BIT == TARGET_FLOAT_BIT) { - if (HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT) - { - float retval; - - memcpy (&retval, addr, sizeof (retval)); - return retval; - } - else - floatformat_to_doublest (TARGET_FLOAT_FORMAT, addr, &dretval); + floatformat_to_doublest (TARGET_FLOAT_FORMAT, addr, &dretval); } else if (len * TARGET_CHAR_BIT == TARGET_DOUBLE_BIT) { - if (HOST_DOUBLE_FORMAT == TARGET_DOUBLE_FORMAT) - { - double retval; - - memcpy (&retval, addr, sizeof (retval)); - return retval; - } - else - floatformat_to_doublest (TARGET_DOUBLE_FORMAT, addr, &dretval); + floatformat_to_doublest (TARGET_DOUBLE_FORMAT, addr, &dretval); } else if (len * TARGET_CHAR_BIT == TARGET_LONG_DOUBLE_BIT) { - if (HOST_LONG_DOUBLE_FORMAT == TARGET_LONG_DOUBLE_FORMAT) - { - DOUBLEST retval; - - memcpy (&retval, addr, sizeof (retval)); - return retval; - } - else - floatformat_to_doublest (TARGET_LONG_DOUBLE_FORMAT, addr, &dretval); + floatformat_to_doublest (TARGET_LONG_DOUBLE_FORMAT, addr, &dretval); } else { error ("Can't deal with a floating point number of %d bytes.", len); } - return dretval; } @@ -595,32 +637,15 @@ store_floating (void *addr, int len, DOUBLEST val) { if (len * TARGET_CHAR_BIT == TARGET_FLOAT_BIT) { - if (HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT) - { - float floatval = val; - - memcpy (addr, &floatval, sizeof (floatval)); - } - else - floatformat_from_doublest (TARGET_FLOAT_FORMAT, &val, addr); + floatformat_from_doublest (TARGET_FLOAT_FORMAT, &val, addr); } else if (len * TARGET_CHAR_BIT == TARGET_DOUBLE_BIT) { - if (HOST_DOUBLE_FORMAT == TARGET_DOUBLE_FORMAT) - { - double doubleval = val; - - memcpy (addr, &doubleval, sizeof (doubleval)); - } - else - floatformat_from_doublest (TARGET_DOUBLE_FORMAT, &val, addr); + floatformat_from_doublest (TARGET_DOUBLE_FORMAT, &val, addr); } else if (len * TARGET_CHAR_BIT == TARGET_LONG_DOUBLE_BIT) { - if (HOST_LONG_DOUBLE_FORMAT == TARGET_LONG_DOUBLE_FORMAT) - memcpy (addr, &val, sizeof (val)); - else - floatformat_from_doublest (TARGET_LONG_DOUBLE_FORMAT, &val, addr); + floatformat_from_doublest (TARGET_LONG_DOUBLE_FORMAT, &val, addr); } else { diff --git a/gdb/doublest.h b/gdb/doublest.h index 692280d..2380f16 100644 --- a/gdb/doublest.h +++ b/gdb/doublest.h @@ -53,10 +53,6 @@ extern const struct floatformat floatformat_unknown; #endif #endif -#ifndef HOST_LONG_DOUBLE_FORMAT -#define HOST_LONG_DOUBLE_FORMAT &floatformat_unknown -#endif - /* Use `long double' if the host compiler supports it. (Note that this is not necessarily any longer than `double'. On SunOS/gcc, it's the same as double.) This is necessary because GDB internally converts all floating |