1 /* Floating point routines for GDB, the GNU debugger.
3 Copyright 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2003 Free Software Foundation,
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
24 /* Support for converting target fp numbers into host DOUBLEST format. */
26 /* XXX - This code should really be in libiberty/floatformat.c,
27 however configuration issues with libiberty made this very
28 difficult to do in the available time. */
32 #include "floatformat.h"
33 #include "gdb_assert.h"
34 #include "gdb_string.h"
36 #include <math.h> /* ldexp */
38 /* The odds that CHAR_BIT will be anything but 8 are low enough that I'm not
39 going to bother with trying to muck around with whether it is defined in
40 a system header, what we do if not, etc. */
41 #define FLOATFORMAT_CHAR_BIT 8
43 static unsigned long get_field (unsigned char *,
44 enum floatformat_byteorders
,
45 unsigned int, unsigned int, unsigned int);
47 /* Extract a field which starts at START and is LEN bytes long. DATA and
48 TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */
50 get_field (unsigned char *data
, enum floatformat_byteorders order
,
51 unsigned int total_len
, unsigned int start
, unsigned int len
)
54 unsigned int cur_byte
;
57 /* Start at the least significant part of the field. */
58 if (order
== floatformat_little
|| order
== floatformat_littlebyte_bigword
)
60 /* We start counting from the other end (i.e, from the high bytes
61 rather than the low bytes). As such, we need to be concerned
62 with what happens if bit 0 doesn't start on a byte boundary.
63 I.e, we need to properly handle the case where total_len is
64 not evenly divisible by 8. So we compute ``excess'' which
65 represents the number of bits from the end of our starting
66 byte needed to get to bit 0. */
67 int excess
= FLOATFORMAT_CHAR_BIT
- (total_len
% FLOATFORMAT_CHAR_BIT
);
68 cur_byte
= (total_len
/ FLOATFORMAT_CHAR_BIT
)
69 - ((start
+ len
+ excess
) / FLOATFORMAT_CHAR_BIT
);
70 cur_bitshift
= ((start
+ len
+ excess
) % FLOATFORMAT_CHAR_BIT
)
71 - FLOATFORMAT_CHAR_BIT
;
75 cur_byte
= (start
+ len
) / FLOATFORMAT_CHAR_BIT
;
77 ((start
+ len
) % FLOATFORMAT_CHAR_BIT
) - FLOATFORMAT_CHAR_BIT
;
79 if (cur_bitshift
> -FLOATFORMAT_CHAR_BIT
)
80 result
= *(data
+ cur_byte
) >> (-cur_bitshift
);
83 cur_bitshift
+= FLOATFORMAT_CHAR_BIT
;
84 if (order
== floatformat_little
|| order
== floatformat_littlebyte_bigword
)
89 /* Move towards the most significant part of the field. */
90 while (cur_bitshift
< len
)
92 result
|= (unsigned long)*(data
+ cur_byte
) << cur_bitshift
;
93 cur_bitshift
+= FLOATFORMAT_CHAR_BIT
;
94 if (order
== floatformat_little
|| order
== floatformat_littlebyte_bigword
)
99 if (len
< sizeof(result
) * FLOATFORMAT_CHAR_BIT
)
100 /* Mask out bits which are not part of the field */
101 result
&= ((1UL << len
) - 1);
105 /* Convert from FMT to a DOUBLEST.
106 FROM is the address of the extended float.
107 Store the DOUBLEST in *TO. */
110 convert_floatformat_to_doublest (const struct floatformat
*fmt
,
114 unsigned char *ufrom
= (unsigned char *) from
;
118 unsigned int mant_bits
, mant_off
;
120 int special_exponent
; /* It's a NaN, denorm or zero */
122 /* If the mantissa bits are not contiguous from one end of the
123 mantissa to the other, we need to make a private copy of the
124 source bytes that is in the right order since the unpacking
125 algorithm assumes that the bits are contiguous.
127 Swap the bytes individually rather than accessing them through
128 "long *" since we have no guarantee that they start on a long
129 alignment, and also sizeof(long) for the host could be different
130 than sizeof(long) for the target. FIXME: Assumes sizeof(long)
131 for the target is 4. */
133 if (fmt
->byteorder
== floatformat_littlebyte_bigword
)
135 static unsigned char *newfrom
;
136 unsigned char *swapin
, *swapout
;
139 longswaps
= fmt
->totalsize
/ FLOATFORMAT_CHAR_BIT
;
144 newfrom
= (unsigned char *) xmalloc (fmt
->totalsize
);
149 while (longswaps
-- > 0)
151 /* This is ugly, but efficient */
152 *swapout
++ = swapin
[4];
153 *swapout
++ = swapin
[5];
154 *swapout
++ = swapin
[6];
155 *swapout
++ = swapin
[7];
156 *swapout
++ = swapin
[0];
157 *swapout
++ = swapin
[1];
158 *swapout
++ = swapin
[2];
159 *swapout
++ = swapin
[3];
164 exponent
= get_field (ufrom
, fmt
->byteorder
, fmt
->totalsize
,
165 fmt
->exp_start
, fmt
->exp_len
);
166 /* Note that if exponent indicates a NaN, we can't really do anything useful
167 (not knowing if the host has NaN's, or how to build one). So it will
168 end up as an infinity or something close; that is OK. */
170 mant_bits_left
= fmt
->man_len
;
171 mant_off
= fmt
->man_start
;
174 special_exponent
= exponent
== 0 || exponent
== fmt
->exp_nan
;
176 /* Don't bias NaNs. Use minimum exponent for denorms. For simplicity,
177 we don't check for zero as the exponent doesn't matter. Note the cast
178 to int; exp_bias is unsigned, so it's important to make sure the
179 operation is done in signed arithmetic. */
180 if (!special_exponent
)
181 exponent
-= fmt
->exp_bias
;
182 else if (exponent
== 0)
183 exponent
= 1 - (int) fmt
->exp_bias
;
185 /* Build the result algebraically. Might go infinite, underflow, etc;
188 /* If this format uses a hidden bit, explicitly add it in now. Otherwise,
189 increment the exponent by one to account for the integer bit. */
191 if (!special_exponent
)
193 if (fmt
->intbit
== floatformat_intbit_no
)
194 dto
= ldexp (1.0, exponent
);
199 while (mant_bits_left
> 0)
201 mant_bits
= min (mant_bits_left
, 32);
203 mant
= get_field (ufrom
, fmt
->byteorder
, fmt
->totalsize
,
204 mant_off
, mant_bits
);
206 dto
+= ldexp ((double) mant
, exponent
- mant_bits
);
207 exponent
-= mant_bits
;
208 mant_off
+= mant_bits
;
209 mant_bits_left
-= mant_bits
;
212 /* Negate it if negative. */
213 if (get_field (ufrom
, fmt
->byteorder
, fmt
->totalsize
, fmt
->sign_start
, 1))
218 static void put_field (unsigned char *, enum floatformat_byteorders
,
220 unsigned int, unsigned int, unsigned long);
222 /* Set a field which starts at START and is LEN bytes long. DATA and
223 TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */
225 put_field (unsigned char *data
, enum floatformat_byteorders order
,
226 unsigned int total_len
, unsigned int start
, unsigned int len
,
227 unsigned long stuff_to_put
)
229 unsigned int cur_byte
;
232 /* Start at the least significant part of the field. */
233 if (order
== floatformat_little
|| order
== floatformat_littlebyte_bigword
)
235 int excess
= FLOATFORMAT_CHAR_BIT
- (total_len
% FLOATFORMAT_CHAR_BIT
);
236 cur_byte
= (total_len
/ FLOATFORMAT_CHAR_BIT
)
237 - ((start
+ len
+ excess
) / FLOATFORMAT_CHAR_BIT
);
238 cur_bitshift
= ((start
+ len
+ excess
) % FLOATFORMAT_CHAR_BIT
)
239 - FLOATFORMAT_CHAR_BIT
;
243 cur_byte
= (start
+ len
) / FLOATFORMAT_CHAR_BIT
;
245 ((start
+ len
) % FLOATFORMAT_CHAR_BIT
) - FLOATFORMAT_CHAR_BIT
;
247 if (cur_bitshift
> -FLOATFORMAT_CHAR_BIT
)
249 *(data
+ cur_byte
) &=
250 ~(((1 << ((start
+ len
) % FLOATFORMAT_CHAR_BIT
)) - 1)
252 *(data
+ cur_byte
) |=
253 (stuff_to_put
& ((1 << FLOATFORMAT_CHAR_BIT
) - 1)) << (-cur_bitshift
);
255 cur_bitshift
+= FLOATFORMAT_CHAR_BIT
;
256 if (order
== floatformat_little
|| order
== floatformat_littlebyte_bigword
)
261 /* Move towards the most significant part of the field. */
262 while (cur_bitshift
< len
)
264 if (len
- cur_bitshift
< FLOATFORMAT_CHAR_BIT
)
266 /* This is the last byte. */
267 *(data
+ cur_byte
) &=
268 ~((1 << (len
- cur_bitshift
)) - 1);
269 *(data
+ cur_byte
) |= (stuff_to_put
>> cur_bitshift
);
272 *(data
+ cur_byte
) = ((stuff_to_put
>> cur_bitshift
)
273 & ((1 << FLOATFORMAT_CHAR_BIT
) - 1));
274 cur_bitshift
+= FLOATFORMAT_CHAR_BIT
;
275 if (order
== floatformat_little
|| order
== floatformat_littlebyte_bigword
)
282 #ifdef HAVE_LONG_DOUBLE
283 /* Return the fractional part of VALUE, and put the exponent of VALUE in *EPTR.
284 The range of the returned value is >= 0.5 and < 1.0. This is equivalent to
285 frexp, but operates on the long double data type. */
287 static long double ldfrexp (long double value
, int *eptr
);
290 ldfrexp (long double value
, int *eptr
)
295 /* Unfortunately, there are no portable functions for extracting the exponent
296 of a long double, so we have to do it iteratively by multiplying or dividing
297 by two until the fraction is between 0.5 and 1.0. */
305 if (value
>= tmp
) /* Value >= 1.0 */
311 else if (value
!= 0.0l) /* Value < 1.0 and > 0.0 */
325 #endif /* HAVE_LONG_DOUBLE */
328 /* The converse: convert the DOUBLEST *FROM to an extended float
329 and store where TO points. Neither FROM nor TO have any alignment
333 convert_doublest_to_floatformat (CONST
struct floatformat
*fmt
,
334 const DOUBLEST
*from
,
340 unsigned int mant_bits
, mant_off
;
342 unsigned char *uto
= (unsigned char *) to
;
344 memcpy (&dfrom
, from
, sizeof (dfrom
));
345 memset (uto
, 0, (fmt
->totalsize
+ FLOATFORMAT_CHAR_BIT
- 1)
346 / FLOATFORMAT_CHAR_BIT
);
348 return; /* Result is zero */
349 if (dfrom
!= dfrom
) /* Result is NaN */
352 put_field (uto
, fmt
->byteorder
, fmt
->totalsize
, fmt
->exp_start
,
353 fmt
->exp_len
, fmt
->exp_nan
);
354 /* Be sure it's not infinity, but NaN value is irrel */
355 put_field (uto
, fmt
->byteorder
, fmt
->totalsize
, fmt
->man_start
,
360 /* If negative, set the sign bit. */
363 put_field (uto
, fmt
->byteorder
, fmt
->totalsize
, fmt
->sign_start
, 1, 1);
367 if (dfrom
+ dfrom
== dfrom
&& dfrom
!= 0.0) /* Result is Infinity */
369 /* Infinity exponent is same as NaN's. */
370 put_field (uto
, fmt
->byteorder
, fmt
->totalsize
, fmt
->exp_start
,
371 fmt
->exp_len
, fmt
->exp_nan
);
372 /* Infinity mantissa is all zeroes. */
373 put_field (uto
, fmt
->byteorder
, fmt
->totalsize
, fmt
->man_start
,
378 #ifdef HAVE_LONG_DOUBLE
379 mant
= ldfrexp (dfrom
, &exponent
);
381 mant
= frexp (dfrom
, &exponent
);
384 put_field (uto
, fmt
->byteorder
, fmt
->totalsize
, fmt
->exp_start
, fmt
->exp_len
,
385 exponent
+ fmt
->exp_bias
- 1);
387 mant_bits_left
= fmt
->man_len
;
388 mant_off
= fmt
->man_start
;
389 while (mant_bits_left
> 0)
391 unsigned long mant_long
;
392 mant_bits
= mant_bits_left
< 32 ? mant_bits_left
: 32;
394 mant
*= 4294967296.0;
395 mant_long
= ((unsigned long) mant
) & 0xffffffffL
;
398 /* If the integer bit is implicit, then we need to discard it.
399 If we are discarding a zero, we should be (but are not) creating
400 a denormalized number which means adjusting the exponent
402 if (mant_bits_left
== fmt
->man_len
403 && fmt
->intbit
== floatformat_intbit_no
)
406 mant_long
&= 0xffffffffL
;
412 /* The bits we want are in the most significant MANT_BITS bits of
413 mant_long. Move them to the least significant. */
414 mant_long
>>= 32 - mant_bits
;
417 put_field (uto
, fmt
->byteorder
, fmt
->totalsize
,
418 mant_off
, mant_bits
, mant_long
);
419 mant_off
+= mant_bits
;
420 mant_bits_left
-= mant_bits
;
422 if (fmt
->byteorder
== floatformat_littlebyte_bigword
)
425 unsigned char *swaplow
= uto
;
426 unsigned char *swaphigh
= uto
+ 4;
429 for (count
= 0; count
< 4; count
++)
432 *swaplow
++ = *swaphigh
;
438 /* Check if VAL (which is assumed to be a floating point number whose
439 format is described by FMT) is negative. */
442 floatformat_is_negative (const struct floatformat
*fmt
, char *val
)
444 unsigned char *uval
= (unsigned char *) val
;
445 gdb_assert (fmt
!= NULL
);
446 return get_field (uval
, fmt
->byteorder
, fmt
->totalsize
, fmt
->sign_start
, 1);
449 /* Check if VAL is "not a number" (NaN) for FMT. */
452 floatformat_is_nan (const struct floatformat
*fmt
, char *val
)
454 unsigned char *uval
= (unsigned char *) val
;
457 unsigned int mant_bits
, mant_off
;
460 gdb_assert (fmt
!= NULL
);
465 exponent
= get_field (uval
, fmt
->byteorder
, fmt
->totalsize
,
466 fmt
->exp_start
, fmt
->exp_len
);
468 if (exponent
!= fmt
->exp_nan
)
471 mant_bits_left
= fmt
->man_len
;
472 mant_off
= fmt
->man_start
;
474 while (mant_bits_left
> 0)
476 mant_bits
= min (mant_bits_left
, 32);
478 mant
= get_field (uval
, fmt
->byteorder
, fmt
->totalsize
,
479 mant_off
, mant_bits
);
481 /* If there is an explicit integer bit, mask it off. */
482 if (mant_off
== fmt
->man_start
483 && fmt
->intbit
== floatformat_intbit_yes
)
484 mant
&= ~(1 << (mant_bits
- 1));
489 mant_off
+= mant_bits
;
490 mant_bits_left
-= mant_bits
;
496 /* Convert the mantissa of VAL (which is assumed to be a floating
497 point number whose format is described by FMT) into a hexadecimal
498 and store it in a static string. Return a pointer to that string. */
501 floatformat_mantissa (const struct floatformat
*fmt
, char *val
)
503 unsigned char *uval
= (unsigned char *) val
;
505 unsigned int mant_bits
, mant_off
;
510 /* Make sure we have enough room to store the mantissa. */
511 gdb_assert (fmt
!= NULL
);
512 gdb_assert (sizeof res
> ((fmt
->man_len
+ 7) / 8) * 2);
514 mant_off
= fmt
->man_start
;
515 mant_bits_left
= fmt
->man_len
;
516 mant_bits
= (mant_bits_left
% 32) > 0 ? mant_bits_left
% 32 : 32;
518 mant
= get_field (uval
, fmt
->byteorder
, fmt
->totalsize
,
519 mant_off
, mant_bits
);
521 sprintf (res
, "%lx", mant
);
523 mant_off
+= mant_bits
;
524 mant_bits_left
-= mant_bits
;
526 while (mant_bits_left
> 0)
528 mant
= get_field (uval
, fmt
->byteorder
, fmt
->totalsize
,
531 sprintf (buf
, "%08lx", mant
);
535 mant_bits_left
-= 32;
542 /* Convert TO/FROM target to the hosts DOUBLEST floating-point format.
544 If the host and target formats agree, we just copy the raw data
545 into the appropriate type of variable and return, letting the host
546 increase precision as necessary. Otherwise, we call the conversion
547 routine and let it do the dirty work. */
549 #ifndef HOST_FLOAT_FORMAT
550 #define HOST_FLOAT_FORMAT 0
552 #ifndef HOST_DOUBLE_FORMAT
553 #define HOST_DOUBLE_FORMAT 0
555 #ifndef HOST_LONG_DOUBLE_FORMAT
556 #define HOST_LONG_DOUBLE_FORMAT 0
559 static const struct floatformat
*host_float_format
= HOST_FLOAT_FORMAT
;
560 static const struct floatformat
*host_double_format
= HOST_DOUBLE_FORMAT
;
561 static const struct floatformat
*host_long_double_format
= HOST_LONG_DOUBLE_FORMAT
;
564 floatformat_to_doublest (const struct floatformat
*fmt
,
565 const void *in
, DOUBLEST
*out
)
567 gdb_assert (fmt
!= NULL
);
568 if (fmt
== host_float_format
)
571 memcpy (&val
, in
, sizeof (val
));
574 else if (fmt
== host_double_format
)
577 memcpy (&val
, in
, sizeof (val
));
580 else if (fmt
== host_long_double_format
)
583 memcpy (&val
, in
, sizeof (val
));
587 convert_floatformat_to_doublest (fmt
, in
, out
);
591 floatformat_from_doublest (const struct floatformat
*fmt
,
592 const DOUBLEST
*in
, void *out
)
594 gdb_assert (fmt
!= NULL
);
595 if (fmt
== host_float_format
)
598 memcpy (out
, &val
, sizeof (val
));
600 else if (fmt
== host_double_format
)
603 memcpy (out
, &val
, sizeof (val
));
605 else if (fmt
== host_long_double_format
)
607 long double val
= *in
;
608 memcpy (out
, &val
, sizeof (val
));
611 convert_doublest_to_floatformat (fmt
, in
, out
);
615 /* Return a floating-point format for a floating-point variable of
616 length LEN. Return NULL, if no suitable floating-point format
619 We need this functionality since information about the
620 floating-point format of a type is not always available to GDB; the
621 debug information typically only tells us the size of a
624 FIXME: kettenis/2001-10-28: In many places, particularly in
625 target-dependent code, the format of floating-point types is known,
626 but not passed on by GDB. This should be fixed. */
628 const struct floatformat
*
629 floatformat_from_length (int len
)
631 if (len
* TARGET_CHAR_BIT
== TARGET_FLOAT_BIT
)
632 return TARGET_FLOAT_FORMAT
;
633 else if (len
* TARGET_CHAR_BIT
== TARGET_DOUBLE_BIT
)
634 return TARGET_DOUBLE_FORMAT
;
635 else if (len
* TARGET_CHAR_BIT
== TARGET_LONG_DOUBLE_BIT
)
636 return TARGET_LONG_DOUBLE_FORMAT
;
637 /* On i386 the 'long double' type takes 96 bits,
638 while the real number of used bits is only 80,
639 both in processor and in memory.
640 The code below accepts the real bit size. */
641 else if ((TARGET_LONG_DOUBLE_FORMAT
!= NULL
)
642 && (len
* TARGET_CHAR_BIT
==
643 TARGET_LONG_DOUBLE_FORMAT
->totalsize
))
644 return TARGET_LONG_DOUBLE_FORMAT
;
649 const struct floatformat
*
650 floatformat_from_type (const struct type
*type
)
652 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FLT
);
653 if (TYPE_FLOATFORMAT (type
) != NULL
)
654 return TYPE_FLOATFORMAT (type
);
656 return floatformat_from_length (TYPE_LENGTH (type
));
659 /* If the host doesn't define NAN, use zero instead. */
664 /* Extract a floating-point number of length LEN from a target-order
665 byte-stream at ADDR. Returns the value as type DOUBLEST. */
668 extract_floating_by_length (const void *addr
, int len
)
670 const struct floatformat
*fmt
= floatformat_from_length (len
);
675 warning ("Can't extract a floating-point number of %d bytes.", len
);
679 floatformat_to_doublest (fmt
, addr
, &val
);
684 deprecated_extract_floating (const void *addr
, int len
)
686 return extract_floating_by_length (addr
, len
);
689 /* Store VAL as a floating-point number of length LEN to a
690 target-order byte-stream at ADDR. */
693 store_floating_by_length (void *addr
, int len
, DOUBLEST val
)
695 const struct floatformat
*fmt
= floatformat_from_length (len
);
699 warning ("Can't store a floating-point number of %d bytes.", len
);
700 memset (addr
, 0, len
);
704 floatformat_from_doublest (fmt
, &val
, addr
);
708 deprecated_store_floating (void *addr
, int len
, DOUBLEST val
)
710 store_floating_by_length (addr
, len
, val
);
713 /* Extract a floating-point number of type TYPE from a target-order
714 byte-stream at ADDR. Returns the value as type DOUBLEST. */
717 extract_typed_floating (const void *addr
, const struct type
*type
)
721 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FLT
);
723 if (TYPE_FLOATFORMAT (type
) == NULL
)
724 /* Not all code remembers to set the FLOATFORMAT (language
725 specific code? stabs?) so handle that here as a special case. */
726 return extract_floating_by_length (addr
, TYPE_LENGTH (type
));
728 floatformat_to_doublest (TYPE_FLOATFORMAT (type
), addr
, &retval
);
732 /* Store VAL as a floating-point number of type TYPE to a target-order
733 byte-stream at ADDR. */
736 store_typed_floating (void *addr
, const struct type
*type
, DOUBLEST val
)
738 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_FLT
);
740 /* FIXME: kettenis/2001-10-28: It is debatable whether we should
741 zero out any remaining bytes in the target buffer when TYPE is
742 longer than the actual underlying floating-point format. Perhaps
743 we should store a fixed bitpattern in those remaining bytes,
744 instead of zero, or perhaps we shouldn't touch those remaining
747 NOTE: cagney/2001-10-28: With the way things currently work, it
748 isn't a good idea to leave the end bits undefined. This is
749 because GDB writes out the entire sizeof(<floating>) bits of the
750 floating-point type even though the value might only be stored
751 in, and the target processor may only refer to, the first N <
752 TYPE_LENGTH (type) bits. If the end of the buffer wasn't
753 initialized, GDB would write undefined data to the target. An
754 errant program, refering to that undefined data, would then
755 become non-deterministic.
757 See also the function convert_typed_floating below. */
758 memset (addr
, 0, TYPE_LENGTH (type
));
760 if (TYPE_FLOATFORMAT (type
) == NULL
)
761 /* Not all code remembers to set the FLOATFORMAT (language
762 specific code? stabs?) so handle that here as a special case. */
763 store_floating_by_length (addr
, TYPE_LENGTH (type
), val
);
765 floatformat_from_doublest (TYPE_FLOATFORMAT (type
), &val
, addr
);
768 /* Convert a floating-point number of type FROM_TYPE from a
769 target-order byte-stream at FROM to a floating-point number of type
770 TO_TYPE, and store it to a target-order byte-stream at TO. */
773 convert_typed_floating (const void *from
, const struct type
*from_type
,
774 void *to
, const struct type
*to_type
)
776 const struct floatformat
*from_fmt
= floatformat_from_type (from_type
);
777 const struct floatformat
*to_fmt
= floatformat_from_type (to_type
);
779 gdb_assert (TYPE_CODE (from_type
) == TYPE_CODE_FLT
);
780 gdb_assert (TYPE_CODE (to_type
) == TYPE_CODE_FLT
);
782 if (from_fmt
== NULL
|| to_fmt
== NULL
)
784 /* If we don't know the floating-point format of FROM_TYPE or
785 TO_TYPE, there's not much we can do. We might make the
786 assumption that if the length of FROM_TYPE and TO_TYPE match,
787 their floating-point format would match too, but that
788 assumption might be wrong on targets that support
789 floating-point types that only differ in endianness for
790 example. So we warn instead, and zero out the target buffer. */
791 warning ("Can't convert floating-point number to desired type.");
792 memset (to
, 0, TYPE_LENGTH (to_type
));
794 else if (from_fmt
== to_fmt
)
796 /* We're in business. The floating-point format of FROM_TYPE
797 and TO_TYPE match. However, even though the floating-point
798 format matches, the length of the type might still be
799 different. Make sure we don't overrun any buffers. See
800 comment in store_typed_floating for a discussion about
801 zeroing out remaining bytes in the target buffer. */
802 memset (to
, 0, TYPE_LENGTH (to_type
));
803 memcpy (to
, from
, min (TYPE_LENGTH (from_type
), TYPE_LENGTH (to_type
)));
807 /* The floating-point types don't match. The best we can do
808 (aport from simulating the target FPU) is converting to the
809 widest floating-point type supported by the host, and then
810 again to the desired type. */
813 floatformat_to_doublest (from_fmt
, from
, &d
);
814 floatformat_from_doublest (to_fmt
, &d
, to
);