1 /* Floating point routines for GDB, the GNU debugger.
3 Copyright (C) 1986-2014 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 /* Support for converting target fp numbers into host DOUBLEST format. */
22 /* XXX - This code should really be in libiberty/floatformat.c,
23 however configuration issues with libiberty made this very
24 difficult to do in the available time. */
28 #include "floatformat.h"
31 #include <math.h> /* ldexp */
33 /* The odds that CHAR_BIT will be anything but 8 are low enough that I'm not
34 going to bother with trying to muck around with whether it is defined in
35 a system header, what we do if not, etc. */
36 #define FLOATFORMAT_CHAR_BIT 8
38 /* The number of bytes that the largest floating-point type that we
39 can convert to doublest will need. */
40 #define FLOATFORMAT_LARGEST_BYTES 16
42 /* Extract a field which starts at START and is LEN bytes long. DATA and
43 TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */
45 get_field (const bfd_byte *data, enum floatformat_byteorders order,
46 unsigned int total_len, unsigned int start, unsigned int len)
49 unsigned int cur_byte;
52 /* Caller must byte-swap words before calling this routine. */
53 gdb_assert (order == floatformat_little || order == floatformat_big);
55 /* Start at the least significant part of the field. */
56 if (order == floatformat_little)
58 /* We start counting from the other end (i.e, from the high bytes
59 rather than the low bytes). As such, we need to be concerned
60 with what happens if bit 0 doesn't start on a byte boundary.
61 I.e, we need to properly handle the case where total_len is
62 not evenly divisible by 8. So we compute ``excess'' which
63 represents the number of bits from the end of our starting
64 byte needed to get to bit 0. */
65 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)
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;
95 case floatformat_little:
103 if (len < sizeof(result) * FLOATFORMAT_CHAR_BIT)
104 /* Mask out bits which are not part of the field. */
105 result &= ((1UL << len) - 1);
109 /* Normalize the byte order of FROM into TO. If no normalization is
110 needed then FMT->byteorder is returned and TO is not changed;
111 otherwise the format of the normalized form in TO is returned. */
113 static enum floatformat_byteorders
114 floatformat_normalize_byteorder (const struct floatformat *fmt,
115 const void *from, void *to)
117 const unsigned char *swapin;
118 unsigned char *swapout;
121 if (fmt->byteorder == floatformat_little
122 || fmt->byteorder == floatformat_big)
123 return fmt->byteorder;
125 words = fmt->totalsize / FLOATFORMAT_CHAR_BIT;
128 swapout = (unsigned char *)to;
129 swapin = (const unsigned char *)from;
131 if (fmt->byteorder == floatformat_vax)
135 *swapout++ = swapin[1];
136 *swapout++ = swapin[0];
137 *swapout++ = swapin[3];
138 *swapout++ = swapin[2];
141 /* This may look weird, since VAX is little-endian, but it is
142 easier to translate to big-endian than to little-endian. */
143 return floatformat_big;
147 gdb_assert (fmt->byteorder == floatformat_littlebyte_bigword);
151 *swapout++ = swapin[3];
152 *swapout++ = swapin[2];
153 *swapout++ = swapin[1];
154 *swapout++ = swapin[0];
157 return floatformat_big;
161 /* Convert from FMT to a DOUBLEST.
162 FROM is the address of the extended float.
163 Store the DOUBLEST in *TO. */
166 convert_floatformat_to_doublest (const struct floatformat *fmt,
170 unsigned char *ufrom = (unsigned char *) from;
174 unsigned int mant_bits, mant_off;
176 int special_exponent; /* It's a NaN, denorm or zero. */
177 enum floatformat_byteorders order;
178 unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
179 enum float_kind kind;
181 gdb_assert (fmt->totalsize
182 <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);
184 /* For non-numbers, reuse libiberty's logic to find the correct
185 format. We do not lose any precision in this case by passing
187 kind = floatformat_classify (fmt, from);
188 if (kind == float_infinite || kind == float_nan)
192 floatformat_to_double (fmt->split_half ? fmt->split_half : fmt,
194 *to = (DOUBLEST) dto;
198 order = floatformat_normalize_byteorder (fmt, ufrom, newfrom);
200 if (order != fmt->byteorder)
207 floatformat_to_doublest (fmt->split_half, ufrom, &dtop);
208 /* Preserve the sign of 0, which is the sign of the top
215 floatformat_to_doublest (fmt->split_half,
216 ufrom + fmt->totalsize / FLOATFORMAT_CHAR_BIT / 2,
222 exponent = get_field (ufrom, order, fmt->totalsize, fmt->exp_start,
224 /* Note that if exponent indicates a NaN, we can't really do anything useful
225 (not knowing if the host has NaN's, or how to build one). So it will
226 end up as an infinity or something close; that is OK. */
228 mant_bits_left = fmt->man_len;
229 mant_off = fmt->man_start;
232 special_exponent = exponent == 0 || exponent == fmt->exp_nan;
234 /* Don't bias NaNs. Use minimum exponent for denorms. For
235 simplicity, we don't check for zero as the exponent doesn't matter.
236 Note the cast to int; exp_bias is unsigned, so it's important to
237 make sure the operation is done in signed arithmetic. */
238 if (!special_exponent)
239 exponent -= fmt->exp_bias;
240 else if (exponent == 0)
241 exponent = 1 - fmt->exp_bias;
243 /* Build the result algebraically. Might go infinite, underflow, etc;
246 /* If this format uses a hidden bit, explicitly add it in now. Otherwise,
247 increment the exponent by one to account for the integer bit. */
249 if (!special_exponent)
251 if (fmt->intbit == floatformat_intbit_no)
252 dto = ldexp (1.0, exponent);
257 while (mant_bits_left > 0)
259 mant_bits = min (mant_bits_left, 32);
261 mant = get_field (ufrom, order, fmt->totalsize, mant_off, mant_bits);
263 dto += ldexp ((double) mant, exponent - mant_bits);
264 exponent -= mant_bits;
265 mant_off += mant_bits;
266 mant_bits_left -= mant_bits;
269 /* Negate it if negative. */
270 if (get_field (ufrom, order, fmt->totalsize, fmt->sign_start, 1))
275 /* Set a field which starts at START and is LEN bytes long. DATA and
276 TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */
278 put_field (unsigned char *data, enum floatformat_byteorders order,
279 unsigned int total_len, unsigned int start, unsigned int len,
280 unsigned long stuff_to_put)
282 unsigned int cur_byte;
285 /* Caller must byte-swap words before calling this routine. */
286 gdb_assert (order == floatformat_little || order == floatformat_big);
288 /* Start at the least significant part of the field. */
289 if (order == floatformat_little)
291 int excess = FLOATFORMAT_CHAR_BIT - (total_len % FLOATFORMAT_CHAR_BIT);
293 cur_byte = (total_len / FLOATFORMAT_CHAR_BIT)
294 - ((start + len + excess) / FLOATFORMAT_CHAR_BIT);
295 cur_bitshift = ((start + len + excess) % FLOATFORMAT_CHAR_BIT)
296 - FLOATFORMAT_CHAR_BIT;
300 cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT;
302 ((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT;
304 if (cur_bitshift > -FLOATFORMAT_CHAR_BIT)
306 *(data + cur_byte) &=
307 ~(((1 << ((start + len) % FLOATFORMAT_CHAR_BIT)) - 1)
309 *(data + cur_byte) |=
310 (stuff_to_put & ((1 << FLOATFORMAT_CHAR_BIT) - 1)) << (-cur_bitshift);
312 cur_bitshift += FLOATFORMAT_CHAR_BIT;
313 if (order == floatformat_little)
318 /* Move towards the most significant part of the field. */
319 while (cur_bitshift < len)
321 if (len - cur_bitshift < FLOATFORMAT_CHAR_BIT)
323 /* This is the last byte. */
324 *(data + cur_byte) &=
325 ~((1 << (len - cur_bitshift)) - 1);
326 *(data + cur_byte) |= (stuff_to_put >> cur_bitshift);
329 *(data + cur_byte) = ((stuff_to_put >> cur_bitshift)
330 & ((1 << FLOATFORMAT_CHAR_BIT) - 1));
331 cur_bitshift += FLOATFORMAT_CHAR_BIT;
332 if (order == floatformat_little)
339 /* The converse: convert the DOUBLEST *FROM to an extended float and
340 store where TO points. Neither FROM nor TO have any alignment
344 convert_doublest_to_floatformat (const struct floatformat *fmt,
345 const DOUBLEST *from, void *to)
350 unsigned int mant_bits, mant_off;
352 unsigned char *uto = (unsigned char *) to;
353 enum floatformat_byteorders order = fmt->byteorder;
354 unsigned char newto[FLOATFORMAT_LARGEST_BYTES];
356 if (order != floatformat_little)
357 order = floatformat_big;
359 if (order != fmt->byteorder)
362 memcpy (&dfrom, from, sizeof (dfrom));
363 memset (uto, 0, (fmt->totalsize + FLOATFORMAT_CHAR_BIT - 1)
364 / FLOATFORMAT_CHAR_BIT);
368 /* Use static volatile to ensure that any excess precision is
369 removed via storing in memory, and so the top half really is
370 the result of converting to double. */
371 static volatile double dtop, dbot;
372 DOUBLEST dtopnv, dbotnv;
374 dtop = (double) dfrom;
375 /* If the rounded top half is Inf, the bottom must be 0 not NaN
377 if (dtop + dtop == dtop && dtop != 0.0)
380 dbot = (double) (dfrom - (DOUBLEST) dtop);
383 floatformat_from_doublest (fmt->split_half, &dtopnv, uto);
384 floatformat_from_doublest (fmt->split_half, &dbotnv,
386 + fmt->totalsize / FLOATFORMAT_CHAR_BIT / 2));
391 return; /* Result is zero */
392 if (dfrom != dfrom) /* Result is NaN */
395 put_field (uto, order, fmt->totalsize, fmt->exp_start,
396 fmt->exp_len, fmt->exp_nan);
397 /* Be sure it's not infinity, but NaN value is irrel. */
398 put_field (uto, order, fmt->totalsize, fmt->man_start,
400 goto finalize_byteorder;
403 /* If negative, set the sign bit. */
406 put_field (uto, order, fmt->totalsize, fmt->sign_start, 1, 1);
410 if (dfrom + dfrom == dfrom && dfrom != 0.0) /* Result is Infinity. */
412 /* Infinity exponent is same as NaN's. */
413 put_field (uto, order, fmt->totalsize, fmt->exp_start,
414 fmt->exp_len, fmt->exp_nan);
415 /* Infinity mantissa is all zeroes. */
416 put_field (uto, order, fmt->totalsize, fmt->man_start,
418 goto finalize_byteorder;
421 #ifdef HAVE_LONG_DOUBLE
422 mant = frexpl (dfrom, &exponent);
424 mant = frexp (dfrom, &exponent);
427 if (exponent + fmt->exp_bias <= 0)
429 /* The value is too small to be expressed in the destination
430 type (not enough bits in the exponent. Treat as 0. */
431 put_field (uto, order, fmt->totalsize, fmt->exp_start,
433 put_field (uto, order, fmt->totalsize, fmt->man_start,
435 goto finalize_byteorder;
438 if (exponent + fmt->exp_bias >= (1 << fmt->exp_len))
440 /* The value is too large to fit into the destination.
441 Treat as infinity. */
442 put_field (uto, order, fmt->totalsize, fmt->exp_start,
443 fmt->exp_len, fmt->exp_nan);
444 put_field (uto, order, fmt->totalsize, fmt->man_start,
446 goto finalize_byteorder;
449 put_field (uto, order, fmt->totalsize, fmt->exp_start, fmt->exp_len,
450 exponent + fmt->exp_bias - 1);
452 mant_bits_left = fmt->man_len;
453 mant_off = fmt->man_start;
454 while (mant_bits_left > 0)
456 unsigned long mant_long;
458 mant_bits = mant_bits_left < 32 ? mant_bits_left : 32;
460 mant *= 4294967296.0;
461 mant_long = ((unsigned long) mant) & 0xffffffffL;
464 /* If the integer bit is implicit, then we need to discard it.
465 If we are discarding a zero, we should be (but are not) creating
466 a denormalized number which means adjusting the exponent
468 if (mant_bits_left == fmt->man_len
469 && fmt->intbit == floatformat_intbit_no)
472 mant_long &= 0xffffffffL;
473 /* If we are processing the top 32 mantissa bits of a doublest
474 so as to convert to a float value with implied integer bit,
475 we will only be putting 31 of those 32 bits into the
476 final value due to the discarding of the top bit. In the
477 case of a small float value where the number of mantissa
478 bits is less than 32, discarding the top bit does not alter
479 the number of bits we will be adding to the result. */
486 /* The bits we want are in the most significant MANT_BITS bits of
487 mant_long. Move them to the least significant. */
488 mant_long >>= 32 - mant_bits;
491 put_field (uto, order, fmt->totalsize,
492 mant_off, mant_bits, mant_long);
493 mant_off += mant_bits;
494 mant_bits_left -= mant_bits;
498 /* Do we need to byte-swap the words in the result? */
499 if (order != fmt->byteorder)
500 floatformat_normalize_byteorder (fmt, newto, to);
503 /* Check if VAL (which is assumed to be a floating point number whose
504 format is described by FMT) is negative. */
507 floatformat_is_negative (const struct floatformat *fmt,
508 const bfd_byte *uval)
510 enum floatformat_byteorders order;
511 unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
513 gdb_assert (fmt != NULL);
514 gdb_assert (fmt->totalsize
515 <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);
517 /* An IBM long double (a two element array of double) always takes the
518 sign of the first double. */
520 fmt = fmt->split_half;
522 order = floatformat_normalize_byteorder (fmt, uval, newfrom);
524 if (order != fmt->byteorder)
527 return get_field (uval, order, fmt->totalsize, fmt->sign_start, 1);
530 /* Check if VAL is "not a number" (NaN) for FMT. */
533 floatformat_classify (const struct floatformat *fmt,
534 const bfd_byte *uval)
538 unsigned int mant_bits, mant_off;
540 enum floatformat_byteorders order;
541 unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
544 gdb_assert (fmt != NULL);
545 gdb_assert (fmt->totalsize
546 <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);
548 /* An IBM long double (a two element array of double) can be classified
549 by looking at the first double. inf and nan are specified as
550 ignoring the second double. zero and subnormal will always have
551 the second double 0.0 if the long double is correctly rounded. */
553 fmt = fmt->split_half;
555 order = floatformat_normalize_byteorder (fmt, uval, newfrom);
557 if (order != fmt->byteorder)
560 exponent = get_field (uval, order, fmt->totalsize, fmt->exp_start,
563 mant_bits_left = fmt->man_len;
564 mant_off = fmt->man_start;
567 while (mant_bits_left > 0)
569 mant_bits = min (mant_bits_left, 32);
571 mant = get_field (uval, order, fmt->totalsize, mant_off, mant_bits);
573 /* If there is an explicit integer bit, mask it off. */
574 if (mant_off == fmt->man_start
575 && fmt->intbit == floatformat_intbit_yes)
576 mant &= ~(1 << (mant_bits - 1));
584 mant_off += mant_bits;
585 mant_bits_left -= mant_bits;
588 /* If exp_nan is not set, assume that inf, NaN, and subnormals are not
598 if (exponent == 0 && !mant_zero)
599 return float_subnormal;
601 if (exponent == fmt->exp_nan)
604 return float_infinite;
615 /* Convert the mantissa of VAL (which is assumed to be a floating
616 point number whose format is described by FMT) into a hexadecimal
617 and store it in a static string. Return a pointer to that string. */
620 floatformat_mantissa (const struct floatformat *fmt,
623 unsigned char *uval = (unsigned char *) val;
625 unsigned int mant_bits, mant_off;
630 enum floatformat_byteorders order;
631 unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
633 gdb_assert (fmt != NULL);
634 gdb_assert (fmt->totalsize
635 <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);
637 /* For IBM long double (a two element array of double), return the
638 mantissa of the first double. The problem with returning the
639 actual mantissa from both doubles is that there can be an
640 arbitrary number of implied 0's or 1's between the mantissas
641 of the first and second double. In any case, this function
642 is only used for dumping out nans, and a nan is specified to
643 ignore the value in the second double. */
645 fmt = fmt->split_half;
647 order = floatformat_normalize_byteorder (fmt, uval, newfrom);
649 if (order != fmt->byteorder)
655 /* Make sure we have enough room to store the mantissa. */
656 gdb_assert (sizeof res > ((fmt->man_len + 7) / 8) * 2);
658 mant_off = fmt->man_start;
659 mant_bits_left = fmt->man_len;
660 mant_bits = (mant_bits_left % 32) > 0 ? mant_bits_left % 32 : 32;
662 mant = get_field (uval, order, fmt->totalsize, mant_off, mant_bits);
664 len = xsnprintf (res, sizeof res, "%lx", mant);
666 mant_off += mant_bits;
667 mant_bits_left -= mant_bits;
669 while (mant_bits_left > 0)
671 mant = get_field (uval, order, fmt->totalsize, mant_off, 32);
673 xsnprintf (buf, sizeof buf, "%08lx", mant);
674 gdb_assert (len + strlen (buf) <= sizeof res);
678 mant_bits_left -= 32;
685 /* Convert TO/FROM target to the hosts DOUBLEST floating-point format.
687 If the host and target formats agree, we just copy the raw data
688 into the appropriate type of variable and return, letting the host
689 increase precision as necessary. Otherwise, we call the conversion
690 routine and let it do the dirty work. */
692 static const struct floatformat *host_float_format = GDB_HOST_FLOAT_FORMAT;
693 static const struct floatformat *host_double_format = GDB_HOST_DOUBLE_FORMAT;
694 static const struct floatformat *host_long_double_format
695 = GDB_HOST_LONG_DOUBLE_FORMAT;
698 floatformat_to_doublest (const struct floatformat *fmt,
699 const void *in, DOUBLEST *out)
701 gdb_assert (fmt != NULL);
702 if (fmt == host_float_format)
706 memcpy (&val, in, sizeof (val));
709 else if (fmt == host_double_format)
713 memcpy (&val, in, sizeof (val));
716 else if (fmt == host_long_double_format)
720 memcpy (&val, in, sizeof (val));
724 convert_floatformat_to_doublest (fmt, in, out);
728 floatformat_from_doublest (const struct floatformat *fmt,
729 const DOUBLEST *in, void *out)
731 gdb_assert (fmt != NULL);
732 if (fmt == host_float_format)
736 memcpy (out, &val, sizeof (val));
738 else if (fmt == host_double_format)
742 memcpy (out, &val, sizeof (val));
744 else if (fmt == host_long_double_format)
746 long double val = *in;
748 memcpy (out, &val, sizeof (val));
751 convert_doublest_to_floatformat (fmt, in, out);
755 /* Return a floating-point format for a floating-point variable of
756 length LEN. If no suitable floating-point format is found, an
759 We need this functionality since information about the
760 floating-point format of a type is not always available to GDB; the
761 debug information typically only tells us the size of a
764 FIXME: kettenis/2001-10-28: In many places, particularly in
765 target-dependent code, the format of floating-point types is known,
766 but not passed on by GDB. This should be fixed. */
768 static const struct floatformat *
769 floatformat_from_length (struct gdbarch *gdbarch, int len)
771 const struct floatformat *format;
773 if (len * TARGET_CHAR_BIT == gdbarch_half_bit (gdbarch))
774 format = gdbarch_half_format (gdbarch)
775 [gdbarch_byte_order (gdbarch)];
776 else if (len * TARGET_CHAR_BIT == gdbarch_float_bit (gdbarch))
777 format = gdbarch_float_format (gdbarch)
778 [gdbarch_byte_order (gdbarch)];
779 else if (len * TARGET_CHAR_BIT == gdbarch_double_bit (gdbarch))
780 format = gdbarch_double_format (gdbarch)
781 [gdbarch_byte_order (gdbarch)];
782 else if (len * TARGET_CHAR_BIT == gdbarch_long_double_bit (gdbarch))
783 format = gdbarch_long_double_format (gdbarch)
784 [gdbarch_byte_order (gdbarch)];
785 /* On i386 the 'long double' type takes 96 bits,
786 while the real number of used bits is only 80,
787 both in processor and in memory.
788 The code below accepts the real bit size. */
789 else if ((gdbarch_long_double_format (gdbarch) != NULL)
790 && (len * TARGET_CHAR_BIT
791 == gdbarch_long_double_format (gdbarch)[0]->totalsize))
792 format = gdbarch_long_double_format (gdbarch)
793 [gdbarch_byte_order (gdbarch)];
797 error (_("Unrecognized %d-bit floating-point type."),
798 len * TARGET_CHAR_BIT);
802 const struct floatformat *
803 floatformat_from_type (const struct type *type)
805 struct gdbarch *gdbarch = get_type_arch (type);
807 gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT);
808 if (TYPE_FLOATFORMAT (type) != NULL)
809 return TYPE_FLOATFORMAT (type)[gdbarch_byte_order (gdbarch)];
811 return floatformat_from_length (gdbarch, TYPE_LENGTH (type));
814 /* Extract a floating-point number of type TYPE from a target-order
815 byte-stream at ADDR. Returns the value as type DOUBLEST. */
818 extract_typed_floating (const void *addr, const struct type *type)
820 const struct floatformat *fmt = floatformat_from_type (type);
823 floatformat_to_doublest (fmt, addr, &retval);
827 /* Store VAL as a floating-point number of type TYPE to a target-order
828 byte-stream at ADDR. */
831 store_typed_floating (void *addr, const struct type *type, DOUBLEST val)
833 const struct floatformat *fmt = floatformat_from_type (type);
835 /* FIXME: kettenis/2001-10-28: It is debatable whether we should
836 zero out any remaining bytes in the target buffer when TYPE is
837 longer than the actual underlying floating-point format. Perhaps
838 we should store a fixed bitpattern in those remaining bytes,
839 instead of zero, or perhaps we shouldn't touch those remaining
842 NOTE: cagney/2001-10-28: With the way things currently work, it
843 isn't a good idea to leave the end bits undefined. This is
844 because GDB writes out the entire sizeof(<floating>) bits of the
845 floating-point type even though the value might only be stored
846 in, and the target processor may only refer to, the first N <
847 TYPE_LENGTH (type) bits. If the end of the buffer wasn't
848 initialized, GDB would write undefined data to the target. An
849 errant program, refering to that undefined data, would then
850 become non-deterministic.
852 See also the function convert_typed_floating below. */
853 memset (addr, 0, TYPE_LENGTH (type));
855 floatformat_from_doublest (fmt, &val, addr);
858 /* Convert a floating-point number of type FROM_TYPE from a
859 target-order byte-stream at FROM to a floating-point number of type
860 TO_TYPE, and store it to a target-order byte-stream at TO. */
863 convert_typed_floating (const void *from, const struct type *from_type,
864 void *to, const struct type *to_type)
866 const struct floatformat *from_fmt = floatformat_from_type (from_type);
867 const struct floatformat *to_fmt = floatformat_from_type (to_type);
869 if (from_fmt == NULL || to_fmt == NULL)
871 /* If we don't know the floating-point format of FROM_TYPE or
872 TO_TYPE, there's not much we can do. We might make the
873 assumption that if the length of FROM_TYPE and TO_TYPE match,
874 their floating-point format would match too, but that
875 assumption might be wrong on targets that support
876 floating-point types that only differ in endianness for
877 example. So we warn instead, and zero out the target buffer. */
878 warning (_("Can't convert floating-point number to desired type."));
879 memset (to, 0, TYPE_LENGTH (to_type));
881 else if (from_fmt == to_fmt)
883 /* We're in business. The floating-point format of FROM_TYPE
884 and TO_TYPE match. However, even though the floating-point
885 format matches, the length of the type might still be
886 different. Make sure we don't overrun any buffers. See
887 comment in store_typed_floating for a discussion about
888 zeroing out remaining bytes in the target buffer. */
889 memset (to, 0, TYPE_LENGTH (to_type));
890 memcpy (to, from, min (TYPE_LENGTH (from_type), TYPE_LENGTH (to_type)));
894 /* The floating-point types don't match. The best we can do
895 (apart from simulating the target FPU) is converting to the
896 widest floating-point type supported by the host, and then
897 again to the desired type. */
900 floatformat_to_doublest (from_fmt, from, &d);
901 floatformat_from_doublest (to_fmt, &d, to);