===================================================================
@@ -26,7 +26,6 @@
#include "defs.h"
#include "doublest.h"
#include "floatformat.h"
-#include "gdbtypes.h"
#include <math.h> /* ldexp */
#include <algorithm>
@@ -892,95 +891,3 @@ floatformat_from_string (const struct fl
floatformat_from_doublest (fmt, &doub, out);
return true;
}
-
-/* Extract a floating-point number of type TYPE from a target-order
- byte-stream at ADDR. Returns the value as type DOUBLEST. */
-
-DOUBLEST
-extract_typed_floating (const void *addr, const struct type *type)
-{
- const struct floatformat *fmt = floatformat_from_type (type);
- DOUBLEST retval;
-
- floatformat_to_doublest (fmt, addr, &retval);
- return retval;
-}
-
-/* Store VAL as a floating-point number of type TYPE to a target-order
- byte-stream at ADDR. */
-
-void
-store_typed_floating (void *addr, const struct type *type, DOUBLEST val)
-{
- const struct floatformat *fmt = floatformat_from_type (type);
-
- /* FIXME: kettenis/2001-10-28: It is debatable whether we should
- zero out any remaining bytes in the target buffer when TYPE is
- longer than the actual underlying floating-point format. Perhaps
- we should store a fixed bitpattern in those remaining bytes,
- instead of zero, or perhaps we shouldn't touch those remaining
- bytes at all.
-
- NOTE: cagney/2001-10-28: With the way things currently work, it
- isn't a good idea to leave the end bits undefined. This is
- because GDB writes out the entire sizeof(<floating>) bits of the
- floating-point type even though the value might only be stored
- in, and the target processor may only refer to, the first N <
- TYPE_LENGTH (type) bits. If the end of the buffer wasn't
- initialized, GDB would write undefined data to the target. An
- errant program, refering to that undefined data, would then
- become non-deterministic.
-
- See also the function convert_typed_floating below. */
- memset (addr, 0, TYPE_LENGTH (type));
-
- floatformat_from_doublest (fmt, &val, addr);
-}
-
-/* Convert a floating-point number of type FROM_TYPE from a
- target-order byte-stream at FROM to a floating-point number of type
- TO_TYPE, and store it to a target-order byte-stream at TO. */
-
-void
-convert_typed_floating (const void *from, const struct type *from_type,
- void *to, const struct type *to_type)
-{
- const struct floatformat *from_fmt = floatformat_from_type (from_type);
- const struct floatformat *to_fmt = floatformat_from_type (to_type);
-
- if (from_fmt == NULL || to_fmt == NULL)
- {
- /* If we don't know the floating-point format of FROM_TYPE or
- TO_TYPE, there's not much we can do. We might make the
- assumption that if the length of FROM_TYPE and TO_TYPE match,
- their floating-point format would match too, but that
- 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."));
- memset (to, 0, TYPE_LENGTH (to_type));
- }
- else if (from_fmt == to_fmt)
- {
- /* We're in business. The floating-point format of FROM_TYPE
- and TO_TYPE match. However, even though the floating-point
- format matches, the length of the type might still be
- different. Make sure we don't overrun any buffers. See
- comment in store_typed_floating for a discussion about
- zeroing out remaining bytes in the target buffer. */
- memset (to, 0, TYPE_LENGTH (to_type));
- memcpy (to, from, std::min (TYPE_LENGTH (from_type),
- TYPE_LENGTH (to_type)));
- }
- else
- {
- /* The floating-point types don't match. The best we can do
- (apart from simulating the target FPU) is converting to the
- widest floating-point type supported by the host, and then
- again to the desired type. */
- DOUBLEST d;
-
- floatformat_to_doublest (from_fmt, from, &d);
- floatformat_from_doublest (to_fmt, &d, to);
- }
-}
===================================================================
@@ -20,7 +20,6 @@
#ifndef DOUBLEST_H
#define DOUBLEST_H
-struct type;
struct floatformat;
/* Use `long double' if the host compiler supports it. (Note that this is not
@@ -35,12 +34,8 @@ struct floatformat;
#if (defined HAVE_LONG_DOUBLE && defined PRINTF_HAS_LONG_DOUBLE \
&& defined SCANF_HAS_LONG_DOUBLE)
typedef long double DOUBLEST;
-# define DOUBLEST_PRINT_FORMAT "Lg"
-# define DOUBLEST_SCAN_FORMAT "Lg"
#else
typedef double DOUBLEST;
-# define DOUBLEST_PRINT_FORMAT "g"
-# define DOUBLEST_SCAN_FORMAT "lg"
/* If we can't scan or print long double, we don't want to use it
anywhere. */
# undef HAVE_LONG_DOUBLE
@@ -81,12 +76,4 @@ extern bool floatformat_from_string (con
extern size_t floatformat_totalsize_bytes (const struct floatformat *fmt);
-extern DOUBLEST extract_typed_floating (const void *addr,
- const struct type *type);
-extern void store_typed_floating (void *addr, const struct type *type,
- DOUBLEST val);
-extern void convert_typed_floating (const void *from,
- const struct type *from_type,
- void *to, const struct type *to_type);
-
#endif
===================================================================
@@ -268,29 +268,6 @@ decimal_to_longest (const gdb_byte *from
return strtoll (str.c_str (), NULL, 10);
}
-/* Converts a value of a float type to a decimal float of
- specified LEN bytes.
-
- This is an ugly way to do the conversion, but libdecnumber does
- not offer a direct way to do it. */
-void
-decimal_from_doublest (DOUBLEST from,
- gdb_byte *to, int len, enum bfd_endian byte_order)
-{
- std::string str = string_printf ("%.30" DOUBLEST_PRINT_FORMAT, from);
- decimal_from_string (to, len, byte_order, str);
-}
-
-/* Converts a decimal float of LEN bytes to a double value. */
-DOUBLEST
-decimal_to_doublest (const gdb_byte *from, int len, enum bfd_endian byte_order)
-{
- /* This is an ugly way to do the conversion, but libdecnumber does
- not offer a direct way to do it. */
- std::string str = decimal_to_string (from, len, byte_order);
- return strtod (str.c_str (), NULL);
-}
-
/* Perform operation OP with operands X and Y with sizes LEN_X and LEN_Y
and byte orders BYTE_ORDER_X and BYTE_ORDER_Y, and store value in
RESULT with size LEN_RESULT and byte order BYTE_ORDER_RESULT. */
===================================================================
@@ -25,7 +25,6 @@
#ifndef DFP_H
#define DFP_H
-#include "doublest.h" /* For DOUBLEST. */
#include "expression.h" /* For enum exp_opcode. */
extern std::string decimal_to_string (const gdb_byte *, int, enum bfd_endian,
@@ -38,10 +37,6 @@ extern void decimal_from_ulongest (ULONG
int len, enum bfd_endian byte_order);
extern LONGEST decimal_to_longest (const gdb_byte *from, int len,
enum bfd_endian byte_order);
-extern void decimal_from_doublest (DOUBLEST from, gdb_byte *to,
- int len, enum bfd_endian byte_order);
-extern DOUBLEST decimal_to_doublest (const gdb_byte *from, int len,
- enum bfd_endian byte_order);
extern void decimal_binop (enum exp_opcode,
const gdb_byte *, int, enum bfd_endian,
const gdb_byte *, int, enum bfd_endian,
===================================================================
@@ -28,10 +28,8 @@
#include "target.h"
#include "language.h"
#include "demangle.h"
-#include "doublest.h"
#include "regcache.h"
#include "block.h"
-#include "dfp.h"
#include "target-float.h"
#include "objfiles.h"
#include "valprint.h"
@@ -2770,18 +2768,6 @@ value_as_long (struct value *val)
return unpack_long (value_type (val), value_contents (val));
}
-DOUBLEST
-value_as_double (struct value *val)
-{
- DOUBLEST foo;
- int inv;
-
- foo = unpack_double (value_type (val), value_contents (val), &inv);
- if (inv)
- error (_("Invalid floating value found in program."));
- return foo;
-}
-
/* Extract a value as a C pointer. Does not deallocate the value.
Note that val's type may not actually be a pointer; value_as_long
handles all the cases. */
@@ -2944,49 +2930,6 @@ unpack_long (struct type *type, const gd
return 0; /* Placate lint. */
}
-/* Return a double value from the specified type and address.
- INVP points to an int which is set to 0 for valid value,
- 1 for invalid value (bad float format). In either case,
- the returned double is OK to use. Argument is in target
- format, result is in host format. */
-
-DOUBLEST
-unpack_double (struct type *type, const gdb_byte *valaddr, int *invp)
-{
- enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
- enum type_code code;
- int len;
- int nosign;
-
- *invp = 0; /* Assume valid. */
- type = check_typedef (type);
- code = TYPE_CODE (type);
- len = TYPE_LENGTH (type);
- nosign = TYPE_UNSIGNED (type);
- if (code == TYPE_CODE_FLT)
- {
- if (!target_float_is_valid (valaddr, type))
- {
- *invp = 1;
- return 0.0;
- }
-
- return extract_typed_floating (valaddr, type);
- }
- else if (code == TYPE_CODE_DECFLOAT)
- return decimal_to_doublest (valaddr, len, byte_order);
- else if (nosign)
- {
- /* Unsigned -- be sure we compensate for signed LONGEST. */
- return (ULONGEST) unpack_long (type, valaddr);
- }
- else
- {
- /* Signed -- we are OK with unpack_long. */
- return unpack_long (type, valaddr);
- }
-}
-
/* Unpack raw data (copied from debugee, target byte order) at VALADDR
as a CORE_ADDR, assuming the raw data is described by type TYPE.
We don't assume any alignment for the raw data. Return value is in
@@ -3699,32 +3642,6 @@ value_from_contents (struct type *type,
return result;
}
-struct value *
-value_from_double (struct type *type, DOUBLEST num)
-{
- struct value *val = allocate_value (type);
- struct type *base_type = check_typedef (type);
- enum type_code code = TYPE_CODE (base_type);
-
- if (code == TYPE_CODE_FLT)
- {
- store_typed_floating (value_contents_raw (val), base_type, num);
- }
- else
- error (_("Unexpected type encountered for floating constant."));
-
- return val;
-}
-
-struct value *
-value_from_decfloat (struct type *type, const gdb_byte *dec)
-{
- struct value *val = allocate_value (type);
-
- memcpy (value_contents_raw (val), dec, TYPE_LENGTH (type));
- return val;
-}
-
/* Extract a value from the history file. Input will be of the form
$digits or $$digits. See block comment above 'write_dollar_variable'
for details. */
===================================================================
@@ -20,7 +20,6 @@
#if !defined (VALUE_H)
#define VALUE_H 1
-#include "doublest.h"
#include "frame.h" /* For struct frame_id. */
struct block;
@@ -613,12 +612,9 @@ extern int print_address_demangle (const
extern bool is_floating_value (struct value *val);
extern LONGEST value_as_long (struct value *val);
-extern DOUBLEST value_as_double (struct value *val);
extern CORE_ADDR value_as_address (struct value *val);
extern LONGEST unpack_long (struct type *type, const gdb_byte *valaddr);
-extern DOUBLEST unpack_double (struct type *type, const gdb_byte *valaddr,
- int *invp);
extern CORE_ADDR unpack_pointer (struct type *type, const gdb_byte *valaddr);
extern LONGEST unpack_field_as_long (struct type *type,
@@ -644,9 +640,6 @@ extern void pack_long (gdb_byte *buf, st
extern struct value *value_from_longest (struct type *type, LONGEST num);
extern struct value *value_from_ulongest (struct type *type, ULONGEST num);
extern struct value *value_from_pointer (struct type *type, CORE_ADDR addr);
-extern struct value *value_from_double (struct type *type, DOUBLEST num);
-extern struct value *value_from_decfloat (struct type *type,
- const gdb_byte *decbytes);
extern struct value *value_from_history_ref (const char *, const char **);
extern struct value *value_from_component (struct value *, struct type *,
LONGEST);