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
;
636 /* On i386 the 'long double' type takes 96 bits,
637 while the real number of used bits is only 80,
638 both in processor and in memory.
639 The code below accepts the real bit size. */
640 else if ((TARGET_LONG_DOUBLE_FORMAT
!= NULL
)
641 && (len
* TARGET_CHAR_BIT
==
642 TARGET_LONG_DOUBLE_FORMAT
->totalsize
))
643 return TARGET_LONG_DOUBLE_FORMAT
;
648 const struct floatformat
*
649 floatformat_from_type (const struct type
*type
)
651 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FLT
);
652 if (TYPE_FLOATFORMAT (type
) != NULL
)
653 return TYPE_FLOATFORMAT (type
);
655 return floatformat_from_length (TYPE_LENGTH (type
));
658 /* If the host doesn't define NAN, use zero instead. */
663 /* Extract a floating-point number of length LEN from a target-order
664 byte-stream at ADDR. Returns the value as type DOUBLEST. */
667 extract_floating (const void *addr
, int len
)
669 const struct floatformat
*fmt
= floatformat_from_length (len
);
674 warning ("Can't extract a floating-point number of %d bytes.", len
);
678 floatformat_to_doublest (fmt
, addr
, &val
);
682 /* Store VAL as a floating-point number of length LEN to a
683 target-order byte-stream at ADDR. */
686 store_floating (void *addr
, int len
, DOUBLEST val
)
688 const struct floatformat
*fmt
= floatformat_from_length (len
);
692 warning ("Can't store a floating-point number of %d bytes.", len
);
693 memset (addr
, 0, len
);
697 floatformat_from_doublest (fmt
, &val
, addr
);
700 /* Extract a floating-point number of type TYPE from a target-order
701 byte-stream at ADDR. Returns the value as type DOUBLEST. */
704 extract_typed_floating (const void *addr
, const struct type
*type
)
708 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FLT
);
710 if (TYPE_FLOATFORMAT (type
) == NULL
)
711 return extract_floating (addr
, TYPE_LENGTH (type
));
713 floatformat_to_doublest (TYPE_FLOATFORMAT (type
), addr
, &retval
);
717 /* Store VAL as a floating-point number of type TYPE to a target-order
718 byte-stream at ADDR. */
721 store_typed_floating (void *addr
, const struct type
*type
, DOUBLEST val
)
723 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FLT
);
725 /* FIXME: kettenis/2001-10-28: It is debatable whether we should
726 zero out any remaining bytes in the target buffer when TYPE is
727 longer than the actual underlying floating-point format. Perhaps
728 we should store a fixed bitpattern in those remaining bytes,
729 instead of zero, or perhaps we shouldn't touch those remaining
732 NOTE: cagney/2001-10-28: With the way things currently work, it
733 isn't a good idea to leave the end bits undefined. This is
734 because GDB writes out the entire sizeof(<floating>) bits of the
735 floating-point type even though the value might only be stored
736 in, and the target processor may only refer to, the first N <
737 TYPE_LENGTH (type) bits. If the end of the buffer wasn't
738 initialized, GDB would write undefined data to the target. An
739 errant program, refering to that undefined data, would then
740 become non-deterministic.
742 See also the function convert_typed_floating below. */
743 memset (addr
, 0, TYPE_LENGTH (type
));
745 if (TYPE_FLOATFORMAT (type
) == NULL
)
746 store_floating (addr
, TYPE_LENGTH (type
), val
);
748 floatformat_from_doublest (TYPE_FLOATFORMAT (type
), &val
, addr
);
751 /* Convert a floating-point number of type FROM_TYPE from a
752 target-order byte-stream at FROM to a floating-point number of type
753 TO_TYPE, and store it to a target-order byte-stream at TO. */
756 convert_typed_floating (const void *from
, const struct type
*from_type
,
757 void *to
, const struct type
*to_type
)
759 const struct floatformat
*from_fmt
= floatformat_from_type (from_type
);
760 const struct floatformat
*to_fmt
= floatformat_from_type (to_type
);
762 gdb_assert (TYPE_CODE (from_type
) == TYPE_CODE_FLT
);
763 gdb_assert (TYPE_CODE (to_type
) == TYPE_CODE_FLT
);
765 if (from_fmt
== NULL
|| to_fmt
== NULL
)
767 /* If we don't know the floating-point format of FROM_TYPE or
768 TO_TYPE, there's not much we can do. We might make the
769 assumption that if the length of FROM_TYPE and TO_TYPE match,
770 their floating-point format would match too, but that
771 assumption might be wrong on targets that support
772 floating-point types that only differ in endianness for
773 example. So we warn instead, and zero out the target buffer. */
774 warning ("Can't convert floating-point number to desired type.");
775 memset (to
, 0, TYPE_LENGTH (to_type
));
777 else if (from_fmt
== to_fmt
)
779 /* We're in business. The floating-point format of FROM_TYPE
780 and TO_TYPE match. However, even though the floating-point
781 format matches, the length of the type might still be
782 different. Make sure we don't overrun any buffers. See
783 comment in store_typed_floating for a discussion about
784 zeroing out remaining bytes in the target buffer. */
785 memset (to
, 0, TYPE_LENGTH (to_type
));
786 memcpy (to
, from
, min (TYPE_LENGTH (from_type
), TYPE_LENGTH (to_type
)));
790 /* The floating-point types don't match. The best we can do
791 (aport from simulating the target FPU) is converting to the
792 widest floating-point type supported by the host, and then
793 again to the desired type. */
796 floatformat_to_doublest (from_fmt
, from
, &d
);
797 floatformat_from_doublest (to_fmt
, &d
, to
);