1 /* Floating point routines for GDB, the GNU debugger.
2 Copyright 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
3 1997, 1998, 1999, 2000, 2001
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
23 /* Support for converting target fp numbers into host DOUBLEST format. */
25 /* XXX - This code should really be in libiberty/floatformat.c,
26 however configuration issues with libiberty made this very
27 difficult to do in the available time. */
31 #include "floatformat.h"
32 #include "gdb_assert.h"
33 #include "gdb_string.h"
35 #include <math.h> /* ldexp */
37 /* The odds that CHAR_BIT will be anything but 8 are low enough that I'm not
38 going to bother with trying to muck around with whether it is defined in
39 a system header, what we do if not, etc. */
40 #define FLOATFORMAT_CHAR_BIT 8
42 static unsigned long get_field (unsigned char *,
43 enum floatformat_byteorders
,
44 unsigned int, unsigned int, unsigned int);
46 /* Extract a field which starts at START and is LEN bytes long. DATA and
47 TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */
49 get_field (unsigned char *data
, enum floatformat_byteorders order
,
50 unsigned int total_len
, unsigned int start
, unsigned int len
)
53 unsigned int cur_byte
;
56 /* Start at the least significant part of the field. */
57 if (order
== floatformat_little
|| order
== floatformat_littlebyte_bigword
)
59 /* We start counting from the other end (i.e, from the high bytes
60 rather than the low bytes). As such, we need to be concerned
61 with what happens if bit 0 doesn't start on a byte boundary.
62 I.e, we need to properly handle the case where total_len is
63 not evenly divisible by 8. So we compute ``excess'' which
64 represents the number of bits from the end of our starting
65 byte needed to get to bit 0. */
66 int excess
= FLOATFORMAT_CHAR_BIT
- (total_len
% FLOATFORMAT_CHAR_BIT
);
67 cur_byte
= (total_len
/ FLOATFORMAT_CHAR_BIT
)
68 - ((start
+ len
+ excess
) / FLOATFORMAT_CHAR_BIT
);
69 cur_bitshift
= ((start
+ len
+ excess
) % FLOATFORMAT_CHAR_BIT
)
70 - FLOATFORMAT_CHAR_BIT
;
74 cur_byte
= (start
+ len
) / FLOATFORMAT_CHAR_BIT
;
76 ((start
+ len
) % FLOATFORMAT_CHAR_BIT
) - FLOATFORMAT_CHAR_BIT
;
78 if (cur_bitshift
> -FLOATFORMAT_CHAR_BIT
)
79 result
= *(data
+ cur_byte
) >> (-cur_bitshift
);
82 cur_bitshift
+= FLOATFORMAT_CHAR_BIT
;
83 if (order
== floatformat_little
|| order
== floatformat_littlebyte_bigword
)
88 /* Move towards the most significant part of the field. */
89 while (cur_bitshift
< len
)
91 result
|= (unsigned long)*(data
+ cur_byte
) << cur_bitshift
;
92 cur_bitshift
+= FLOATFORMAT_CHAR_BIT
;
93 if (order
== floatformat_little
|| order
== floatformat_littlebyte_bigword
)
98 if (len
< sizeof(result
) * FLOATFORMAT_CHAR_BIT
)
99 /* Mask out bits which are not part of the field */
100 result
&= ((1UL << len
) - 1);
104 /* Convert from FMT to a DOUBLEST.
105 FROM is the address of the extended float.
106 Store the DOUBLEST in *TO. */
109 convert_floatformat_to_doublest (const struct floatformat
*fmt
,
113 unsigned char *ufrom
= (unsigned char *) from
;
117 unsigned int mant_bits
, mant_off
;
119 int special_exponent
; /* It's a NaN, denorm or zero */
121 /* If the mantissa bits are not contiguous from one end of the
122 mantissa to the other, we need to make a private copy of the
123 source bytes that is in the right order since the unpacking
124 algorithm assumes that the bits are contiguous.
126 Swap the bytes individually rather than accessing them through
127 "long *" since we have no guarantee that they start on a long
128 alignment, and also sizeof(long) for the host could be different
129 than sizeof(long) for the target. FIXME: Assumes sizeof(long)
130 for the target is 4. */
132 if (fmt
->byteorder
== floatformat_littlebyte_bigword
)
134 static unsigned char *newfrom
;
135 unsigned char *swapin
, *swapout
;
138 longswaps
= fmt
->totalsize
/ FLOATFORMAT_CHAR_BIT
;
143 newfrom
= (unsigned char *) xmalloc (fmt
->totalsize
);
148 while (longswaps
-- > 0)
150 /* This is ugly, but efficient */
151 *swapout
++ = swapin
[4];
152 *swapout
++ = swapin
[5];
153 *swapout
++ = swapin
[6];
154 *swapout
++ = swapin
[7];
155 *swapout
++ = swapin
[0];
156 *swapout
++ = swapin
[1];
157 *swapout
++ = swapin
[2];
158 *swapout
++ = swapin
[3];
163 exponent
= get_field (ufrom
, fmt
->byteorder
, fmt
->totalsize
,
164 fmt
->exp_start
, fmt
->exp_len
);
165 /* Note that if exponent indicates a NaN, we can't really do anything useful
166 (not knowing if the host has NaN's, or how to build one). So it will
167 end up as an infinity or something close; that is OK. */
169 mant_bits_left
= fmt
->man_len
;
170 mant_off
= fmt
->man_start
;
173 special_exponent
= exponent
== 0 || exponent
== fmt
->exp_nan
;
175 /* Don't bias NaNs. Use minimum exponent for denorms. For simplicity,
176 we don't check for zero as the exponent doesn't matter. Note the cast
177 to int; exp_bias is unsigned, so it's important to make sure the
178 operation is done in signed arithmetic. */
179 if (!special_exponent
)
180 exponent
-= fmt
->exp_bias
;
181 else if (exponent
== 0)
182 exponent
= 1 - (int) fmt
->exp_bias
;
184 /* Build the result algebraically. Might go infinite, underflow, etc;
187 /* If this format uses a hidden bit, explicitly add it in now. Otherwise,
188 increment the exponent by one to account for the integer bit. */
190 if (!special_exponent
)
192 if (fmt
->intbit
== floatformat_intbit_no
)
193 dto
= ldexp (1.0, exponent
);
198 while (mant_bits_left
> 0)
200 mant_bits
= min (mant_bits_left
, 32);
202 mant
= get_field (ufrom
, fmt
->byteorder
, fmt
->totalsize
,
203 mant_off
, mant_bits
);
205 dto
+= ldexp ((double) mant
, exponent
- mant_bits
);
206 exponent
-= mant_bits
;
207 mant_off
+= mant_bits
;
208 mant_bits_left
-= mant_bits
;
211 /* Negate it if negative. */
212 if (get_field (ufrom
, fmt
->byteorder
, fmt
->totalsize
, fmt
->sign_start
, 1))
217 static void put_field (unsigned char *, enum floatformat_byteorders
,
219 unsigned int, unsigned int, unsigned long);
221 /* Set a field which starts at START and is LEN bytes long. DATA and
222 TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */
224 put_field (unsigned char *data
, enum floatformat_byteorders order
,
225 unsigned int total_len
, unsigned int start
, unsigned int len
,
226 unsigned long stuff_to_put
)
228 unsigned int cur_byte
;
231 /* Start at the least significant part of the field. */
232 if (order
== floatformat_little
|| order
== floatformat_littlebyte_bigword
)
234 int excess
= FLOATFORMAT_CHAR_BIT
- (total_len
% FLOATFORMAT_CHAR_BIT
);
235 cur_byte
= (total_len
/ FLOATFORMAT_CHAR_BIT
)
236 - ((start
+ len
+ excess
) / FLOATFORMAT_CHAR_BIT
);
237 cur_bitshift
= ((start
+ len
+ excess
) % FLOATFORMAT_CHAR_BIT
)
238 - FLOATFORMAT_CHAR_BIT
;
242 cur_byte
= (start
+ len
) / FLOATFORMAT_CHAR_BIT
;
244 ((start
+ len
) % FLOATFORMAT_CHAR_BIT
) - FLOATFORMAT_CHAR_BIT
;
246 if (cur_bitshift
> -FLOATFORMAT_CHAR_BIT
)
248 *(data
+ cur_byte
) &=
249 ~(((1 << ((start
+ len
) % FLOATFORMAT_CHAR_BIT
)) - 1)
251 *(data
+ cur_byte
) |=
252 (stuff_to_put
& ((1 << FLOATFORMAT_CHAR_BIT
) - 1)) << (-cur_bitshift
);
254 cur_bitshift
+= FLOATFORMAT_CHAR_BIT
;
255 if (order
== floatformat_little
|| order
== floatformat_littlebyte_bigword
)
260 /* Move towards the most significant part of the field. */
261 while (cur_bitshift
< len
)
263 if (len
- cur_bitshift
< FLOATFORMAT_CHAR_BIT
)
265 /* This is the last byte. */
266 *(data
+ cur_byte
) &=
267 ~((1 << (len
- cur_bitshift
)) - 1);
268 *(data
+ cur_byte
) |= (stuff_to_put
>> cur_bitshift
);
271 *(data
+ cur_byte
) = ((stuff_to_put
>> cur_bitshift
)
272 & ((1 << FLOATFORMAT_CHAR_BIT
) - 1));
273 cur_bitshift
+= FLOATFORMAT_CHAR_BIT
;
274 if (order
== floatformat_little
|| order
== floatformat_littlebyte_bigword
)
281 #ifdef HAVE_LONG_DOUBLE
282 /* Return the fractional part of VALUE, and put the exponent of VALUE in *EPTR.
283 The range of the returned value is >= 0.5 and < 1.0. This is equivalent to
284 frexp, but operates on the long double data type. */
286 static long double ldfrexp (long double value
, int *eptr
);
289 ldfrexp (long double value
, int *eptr
)
294 /* Unfortunately, there are no portable functions for extracting the exponent
295 of a long double, so we have to do it iteratively by multiplying or dividing
296 by two until the fraction is between 0.5 and 1.0. */
304 if (value
>= tmp
) /* Value >= 1.0 */
310 else if (value
!= 0.0l) /* Value < 1.0 and > 0.0 */
324 #endif /* HAVE_LONG_DOUBLE */
327 /* The converse: convert the DOUBLEST *FROM to an extended float
328 and store where TO points. Neither FROM nor TO have any alignment
332 convert_doublest_to_floatformat (CONST
struct floatformat
*fmt
,
333 const DOUBLEST
*from
,
339 unsigned int mant_bits
, mant_off
;
341 unsigned char *uto
= (unsigned char *) to
;
343 memcpy (&dfrom
, from
, sizeof (dfrom
));
344 memset (uto
, 0, (fmt
->totalsize
+ FLOATFORMAT_CHAR_BIT
- 1)
345 / FLOATFORMAT_CHAR_BIT
);
347 return; /* Result is zero */
348 if (dfrom
!= dfrom
) /* Result is NaN */
351 put_field (uto
, fmt
->byteorder
, fmt
->totalsize
, fmt
->exp_start
,
352 fmt
->exp_len
, fmt
->exp_nan
);
353 /* Be sure it's not infinity, but NaN value is irrel */
354 put_field (uto
, fmt
->byteorder
, fmt
->totalsize
, fmt
->man_start
,
359 /* If negative, set the sign bit. */
362 put_field (uto
, fmt
->byteorder
, fmt
->totalsize
, fmt
->sign_start
, 1, 1);
366 if (dfrom
+ dfrom
== dfrom
&& dfrom
!= 0.0) /* Result is Infinity */
368 /* Infinity exponent is same as NaN's. */
369 put_field (uto
, fmt
->byteorder
, fmt
->totalsize
, fmt
->exp_start
,
370 fmt
->exp_len
, fmt
->exp_nan
);
371 /* Infinity mantissa is all zeroes. */
372 put_field (uto
, fmt
->byteorder
, fmt
->totalsize
, fmt
->man_start
,
377 #ifdef HAVE_LONG_DOUBLE
378 mant
= ldfrexp (dfrom
, &exponent
);
380 mant
= frexp (dfrom
, &exponent
);
383 put_field (uto
, fmt
->byteorder
, fmt
->totalsize
, fmt
->exp_start
, fmt
->exp_len
,
384 exponent
+ fmt
->exp_bias
- 1);
386 mant_bits_left
= fmt
->man_len
;
387 mant_off
= fmt
->man_start
;
388 while (mant_bits_left
> 0)
390 unsigned long mant_long
;
391 mant_bits
= mant_bits_left
< 32 ? mant_bits_left
: 32;
393 mant
*= 4294967296.0;
394 mant_long
= ((unsigned long) mant
) & 0xffffffffL
;
397 /* If the integer bit is implicit, then we need to discard it.
398 If we are discarding a zero, we should be (but are not) creating
399 a denormalized number which means adjusting the exponent
401 if (mant_bits_left
== fmt
->man_len
402 && fmt
->intbit
== floatformat_intbit_no
)
405 mant_long
&= 0xffffffffL
;
411 /* The bits we want are in the most significant MANT_BITS bits of
412 mant_long. Move them to the least significant. */
413 mant_long
>>= 32 - mant_bits
;
416 put_field (uto
, fmt
->byteorder
, fmt
->totalsize
,
417 mant_off
, mant_bits
, mant_long
);
418 mant_off
+= mant_bits
;
419 mant_bits_left
-= mant_bits
;
421 if (fmt
->byteorder
== floatformat_littlebyte_bigword
)
424 unsigned char *swaplow
= uto
;
425 unsigned char *swaphigh
= uto
+ 4;
428 for (count
= 0; count
< 4; count
++)
431 *swaplow
++ = *swaphigh
;
437 /* Check if VAL (which is assumed to be a floating point number whose
438 format is described by FMT) is negative. */
441 floatformat_is_negative (const struct floatformat
*fmt
, char *val
)
443 unsigned char *uval
= (unsigned char *) val
;
444 gdb_assert (fmt
!= NULL
);
445 return get_field (uval
, fmt
->byteorder
, fmt
->totalsize
, fmt
->sign_start
, 1);
448 /* Check if VAL is "not a number" (NaN) for FMT. */
451 floatformat_is_nan (const struct floatformat
*fmt
, char *val
)
453 unsigned char *uval
= (unsigned char *) val
;
456 unsigned int mant_bits
, mant_off
;
459 gdb_assert (fmt
!= NULL
);
464 exponent
= get_field (uval
, fmt
->byteorder
, fmt
->totalsize
,
465 fmt
->exp_start
, fmt
->exp_len
);
467 if (exponent
!= fmt
->exp_nan
)
470 mant_bits_left
= fmt
->man_len
;
471 mant_off
= fmt
->man_start
;
473 while (mant_bits_left
> 0)
475 mant_bits
= min (mant_bits_left
, 32);
477 mant
= get_field (uval
, fmt
->byteorder
, fmt
->totalsize
,
478 mant_off
, mant_bits
);
480 /* If there is an explicit integer bit, mask it off. */
481 if (mant_off
== fmt
->man_start
482 && fmt
->intbit
== floatformat_intbit_yes
)
483 mant
&= ~(1 << (mant_bits
- 1));
488 mant_off
+= mant_bits
;
489 mant_bits_left
-= mant_bits
;
495 /* Convert the mantissa of VAL (which is assumed to be a floating
496 point number whose format is described by FMT) into a hexadecimal
497 and store it in a static string. Return a pointer to that string. */
500 floatformat_mantissa (const struct floatformat
*fmt
, char *val
)
502 unsigned char *uval
= (unsigned char *) val
;
504 unsigned int mant_bits
, mant_off
;
509 /* Make sure we have enough room to store the mantissa. */
510 gdb_assert (fmt
!= NULL
);
511 gdb_assert (sizeof res
> ((fmt
->man_len
+ 7) / 8) * 2);
513 mant_off
= fmt
->man_start
;
514 mant_bits_left
= fmt
->man_len
;
515 mant_bits
= (mant_bits_left
% 32) > 0 ? mant_bits_left
% 32 : 32;
517 mant
= get_field (uval
, fmt
->byteorder
, fmt
->totalsize
,
518 mant_off
, mant_bits
);
520 sprintf (res
, "%lx", mant
);
522 mant_off
+= mant_bits
;
523 mant_bits_left
-= mant_bits
;
525 while (mant_bits_left
> 0)
527 mant
= get_field (uval
, fmt
->byteorder
, fmt
->totalsize
,
530 sprintf (buf
, "%08lx", mant
);
534 mant_bits_left
-= 32;
541 /* Convert TO/FROM target to the hosts DOUBLEST floating-point format.
543 If the host and target formats agree, we just copy the raw data
544 into the appropriate type of variable and return, letting the host
545 increase precision as necessary. Otherwise, we call the conversion
546 routine and let it do the dirty work. */
548 #ifndef HOST_FLOAT_FORMAT
549 #define HOST_FLOAT_FORMAT 0
551 #ifndef HOST_DOUBLE_FORMAT
552 #define HOST_DOUBLE_FORMAT 0
554 #ifndef HOST_LONG_DOUBLE_FORMAT
555 #define HOST_LONG_DOUBLE_FORMAT 0
558 static const struct floatformat
*host_float_format
= HOST_FLOAT_FORMAT
;
559 static const struct floatformat
*host_double_format
= HOST_DOUBLE_FORMAT
;
560 static const struct floatformat
*host_long_double_format
= HOST_LONG_DOUBLE_FORMAT
;
563 floatformat_to_doublest (const struct floatformat
*fmt
,
564 const void *in
, DOUBLEST
*out
)
566 gdb_assert (fmt
!= NULL
);
567 if (fmt
== host_float_format
)
570 memcpy (&val
, in
, sizeof (val
));
573 else if (fmt
== host_double_format
)
576 memcpy (&val
, in
, sizeof (val
));
579 else if (fmt
== host_long_double_format
)
582 memcpy (&val
, in
, sizeof (val
));
586 convert_floatformat_to_doublest (fmt
, in
, out
);
590 floatformat_from_doublest (const struct floatformat
*fmt
,
591 const DOUBLEST
*in
, void *out
)
593 gdb_assert (fmt
!= NULL
);
594 if (fmt
== host_float_format
)
597 memcpy (out
, &val
, sizeof (val
));
599 else if (fmt
== host_double_format
)
602 memcpy (out
, &val
, sizeof (val
));
604 else if (fmt
== host_long_double_format
)
606 long double val
= *in
;
607 memcpy (out
, &val
, sizeof (val
));
610 convert_doublest_to_floatformat (fmt
, in
, out
);
614 /* Return a floating-point format for a floating-point variable of
615 length LEN. Return NULL, if no suitable floating-point format
618 We need this functionality since information about the
619 floating-point format of a type is not always available to GDB; the
620 debug information typically only tells us the size of a
623 FIXME: kettenis/2001-10-28: In many places, particularly in
624 target-dependent code, the format of floating-point types is known,
625 but not passed on by GDB. This should be fixed. */
627 const struct floatformat
*
628 floatformat_from_length (int len
)
630 if (len
* TARGET_CHAR_BIT
== TARGET_FLOAT_BIT
)
631 return TARGET_FLOAT_FORMAT
;
632 else if (len
* TARGET_CHAR_BIT
== TARGET_DOUBLE_BIT
)
633 return TARGET_DOUBLE_FORMAT
;
634 else if (len
* TARGET_CHAR_BIT
== TARGET_LONG_DOUBLE_BIT
)
635 return TARGET_LONG_DOUBLE_FORMAT
;
640 const struct floatformat
*
641 floatformat_from_type (const struct type
*type
)
643 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FLT
);
644 if (TYPE_FLOATFORMAT (type
) != NULL
)
645 return TYPE_FLOATFORMAT (type
);
647 return floatformat_from_length (TYPE_LENGTH (type
));
650 /* If the host doesn't define NAN, use zero instead. */
655 /* Extract a floating-point number of length LEN from a target-order
656 byte-stream at ADDR. Returns the value as type DOUBLEST. */
659 extract_floating (const void *addr
, int len
)
661 const struct floatformat
*fmt
= floatformat_from_length (len
);
666 warning ("Can't extract a floating-point number of %d bytes.", len
);
670 floatformat_to_doublest (fmt
, addr
, &val
);
674 /* Store VAL as a floating-point number of length LEN to a
675 target-order byte-stream at ADDR. */
678 store_floating (void *addr
, int len
, DOUBLEST val
)
680 const struct floatformat
*fmt
= floatformat_from_length (len
);
684 warning ("Can't store a floating-point number of %d bytes.", len
);
685 memset (addr
, 0, len
);
689 floatformat_from_doublest (fmt
, &val
, addr
);
692 /* Extract a floating-point number of type TYPE from a target-order
693 byte-stream at ADDR. Returns the value as type DOUBLEST. */
696 extract_typed_floating (const void *addr
, const struct type
*type
)
700 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FLT
);
702 if (TYPE_FLOATFORMAT (type
) == NULL
)
703 return extract_floating (addr
, TYPE_LENGTH (type
));
705 floatformat_to_doublest (TYPE_FLOATFORMAT (type
), addr
, &retval
);
709 /* Store VAL as a floating-point number of type TYPE to a target-order
710 byte-stream at ADDR. */
713 store_typed_floating (void *addr
, const struct type
*type
, DOUBLEST val
)
715 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FLT
);
717 /* FIXME: kettenis/2001-10-28: It is debatable whether we should
718 zero out any remaining bytes in the target buffer when TYPE is
719 longer than the actual underlying floating-point format. Perhaps
720 we should store a fixed bitpattern in those remaining bytes,
721 instead of zero, or perhaps we shouldn't touch those remaining
724 NOTE: cagney/2001-10-28: With the way things currently work, it
725 isn't a good idea to leave the end bits undefined. This is
726 because GDB writes out the entire sizeof(<floating>) bits of the
727 floating-point type even though the value might only be stored
728 in, and the target processor may only refer to, the first N <
729 TYPE_LENGTH (type) bits. If the end of the buffer wasn't
730 initialized, GDB would write undefined data to the target. An
731 errant program, refering to that undefined data, would then
732 become non-deterministic.
734 See also the function convert_typed_floating below. */
735 memset (addr
, 0, TYPE_LENGTH (type
));
737 if (TYPE_FLOATFORMAT (type
) == NULL
)
738 store_floating (addr
, TYPE_LENGTH (type
), val
);
740 floatformat_from_doublest (TYPE_FLOATFORMAT (type
), &val
, addr
);
743 /* Convert a floating-point number of type FROM_TYPE from a
744 target-order byte-stream at FROM to a floating-point number of type
745 TO_TYPE, and store it to a target-order byte-stream at TO. */
748 convert_typed_floating (const void *from
, const struct type
*from_type
,
749 void *to
, const struct type
*to_type
)
751 const struct floatformat
*from_fmt
= floatformat_from_type (from_type
);
752 const struct floatformat
*to_fmt
= floatformat_from_type (to_type
);
754 gdb_assert (TYPE_CODE (from_type
) == TYPE_CODE_FLT
);
755 gdb_assert (TYPE_CODE (to_type
) == TYPE_CODE_FLT
);
757 if (from_fmt
== NULL
|| to_fmt
== NULL
)
759 /* If we don't know the floating-point format of FROM_TYPE or
760 TO_TYPE, there's not much we can do. We might make the
761 assumption that if the length of FROM_TYPE and TO_TYPE match,
762 their floating-point format would match too, but that
763 assumption might be wrong on targets that support
764 floating-point types that only differ in endianness for
765 example. So we warn instead, and zero out the target buffer. */
766 warning ("Can't convert floating-point number to desired type.");
767 memset (to
, 0, TYPE_LENGTH (to_type
));
769 else if (from_fmt
== to_fmt
)
771 /* We're in business. The floating-point format of FROM_TYPE
772 and TO_TYPE match. However, even though the floating-point
773 format matches, the length of the type might still be
774 different. Make sure we don't overrun any buffers. See
775 comment in store_typed_floating for a discussion about
776 zeroing out remaining bytes in the target buffer. */
777 memset (to
, 0, TYPE_LENGTH (to_type
));
778 memcpy (to
, from
, min (TYPE_LENGTH (from_type
), TYPE_LENGTH (to_type
)));
782 /* The floating-point types don't match. The best we can do
783 (aport from simulating the target FPU) is converting to the
784 widest floating-point type supported by the host, and then
785 again to the desired type. */
788 floatformat_to_doublest (from_fmt
, from
, &d
);
789 floatformat_from_doublest (to_fmt
, &d
, to
);