Tests for validate symbol file using build-id.
[gdb/archer.git] / gdb / doublest.c
blob9ddc7a63f701580f097a8d9f75297a33fb0c0fb7
1 /* Floating point routines for GDB, the GNU debugger.
3 Copyright (C) 1986-2013 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. */
26 #include "defs.h"
27 #include "doublest.h"
28 #include "floatformat.h"
29 #include "gdb_assert.h"
30 #include "gdb_string.h"
31 #include "gdbtypes.h"
32 #include <math.h> /* ldexp */
34 /* The odds that CHAR_BIT will be anything but 8 are low enough that I'm not
35 going to bother with trying to muck around with whether it is defined in
36 a system header, what we do if not, etc. */
37 #define FLOATFORMAT_CHAR_BIT 8
39 /* The number of bytes that the largest floating-point type that we
40 can convert to doublest will need. */
41 #define FLOATFORMAT_LARGEST_BYTES 16
43 /* Extract a field which starts at START and is LEN bytes long. DATA and
44 TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */
45 static unsigned long
46 get_field (const bfd_byte *data, enum floatformat_byteorders order,
47 unsigned int total_len, unsigned int start, unsigned int len)
49 unsigned long result;
50 unsigned int cur_byte;
51 int cur_bitshift;
53 /* Caller must byte-swap words before calling this routine. */
54 gdb_assert (order == floatformat_little || order == floatformat_big);
56 /* Start at the least significant part of the field. */
57 if (order == floatformat_little)
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);
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;
73 else
75 cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT;
76 cur_bitshift =
77 ((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT;
79 if (cur_bitshift > -FLOATFORMAT_CHAR_BIT)
80 result = *(data + cur_byte) >> (-cur_bitshift);
81 else
82 result = 0;
83 cur_bitshift += FLOATFORMAT_CHAR_BIT;
84 if (order == floatformat_little)
85 ++cur_byte;
86 else
87 --cur_byte;
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 switch (order)
96 case floatformat_little:
97 ++cur_byte;
98 break;
99 case floatformat_big:
100 --cur_byte;
101 break;
104 if (len < sizeof(result) * FLOATFORMAT_CHAR_BIT)
105 /* Mask out bits which are not part of the field. */
106 result &= ((1UL << len) - 1);
107 return result;
110 /* Normalize the byte order of FROM into TO. If no normalization is
111 needed then FMT->byteorder is returned and TO is not changed;
112 otherwise the format of the normalized form in TO is returned. */
114 static enum floatformat_byteorders
115 floatformat_normalize_byteorder (const struct floatformat *fmt,
116 const void *from, void *to)
118 const unsigned char *swapin;
119 unsigned char *swapout;
120 int words;
122 if (fmt->byteorder == floatformat_little
123 || fmt->byteorder == floatformat_big)
124 return fmt->byteorder;
126 words = fmt->totalsize / FLOATFORMAT_CHAR_BIT;
127 words >>= 2;
129 swapout = (unsigned char *)to;
130 swapin = (const unsigned char *)from;
132 if (fmt->byteorder == floatformat_vax)
134 while (words-- > 0)
136 *swapout++ = swapin[1];
137 *swapout++ = swapin[0];
138 *swapout++ = swapin[3];
139 *swapout++ = swapin[2];
140 swapin += 4;
142 /* This may look weird, since VAX is little-endian, but it is
143 easier to translate to big-endian than to little-endian. */
144 return floatformat_big;
146 else
148 gdb_assert (fmt->byteorder == floatformat_littlebyte_bigword);
150 while (words-- > 0)
152 *swapout++ = swapin[3];
153 *swapout++ = swapin[2];
154 *swapout++ = swapin[1];
155 *swapout++ = swapin[0];
156 swapin += 4;
158 return floatformat_big;
162 /* Convert from FMT to a DOUBLEST.
163 FROM is the address of the extended float.
164 Store the DOUBLEST in *TO. */
166 static void
167 convert_floatformat_to_doublest (const struct floatformat *fmt,
168 const void *from,
169 DOUBLEST *to)
171 unsigned char *ufrom = (unsigned char *) from;
172 DOUBLEST dto;
173 long exponent;
174 unsigned long mant;
175 unsigned int mant_bits, mant_off;
176 int mant_bits_left;
177 int special_exponent; /* It's a NaN, denorm or zero. */
178 enum floatformat_byteorders order;
179 unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
180 enum float_kind kind;
182 gdb_assert (fmt->totalsize
183 <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);
185 /* For non-numbers, reuse libiberty's logic to find the correct
186 format. We do not lose any precision in this case by passing
187 through a double. */
188 kind = floatformat_classify (fmt, from);
189 if (kind == float_infinite || kind == float_nan)
191 double dto;
193 floatformat_to_double (fmt, from, &dto);
194 *to = (DOUBLEST) dto;
195 return;
198 order = floatformat_normalize_byteorder (fmt, ufrom, newfrom);
200 if (order != fmt->byteorder)
201 ufrom = newfrom;
203 if (fmt->split_half)
205 DOUBLEST dtop, dbot;
207 floatformat_to_doublest (fmt->split_half, ufrom, &dtop);
208 /* Preserve the sign of 0, which is the sign of the top
209 half. */
210 if (dtop == 0.0)
212 *to = dtop;
213 return;
215 floatformat_to_doublest (fmt->split_half,
216 ufrom + fmt->totalsize / FLOATFORMAT_CHAR_BIT / 2,
217 &dbot);
218 *to = dtop + dbot;
219 return;
222 exponent = get_field (ufrom, order, fmt->totalsize, fmt->exp_start,
223 fmt->exp_len);
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;
230 dto = 0.0;
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;
244 who cares. */
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);
253 else
254 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))
271 dto = -dto;
272 *to = dto;
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. */
277 static void
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;
283 int cur_bitshift;
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;
298 else
300 cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT;
301 cur_bitshift =
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)
308 << (-cur_bitshift));
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)
314 ++cur_byte;
315 else
316 --cur_byte;
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);
328 else
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)
333 ++cur_byte;
334 else
335 --cur_byte;
339 #ifdef HAVE_LONG_DOUBLE
340 /* Return the fractional part of VALUE, and put the exponent of VALUE in *EPTR.
341 The range of the returned value is >= 0.5 and < 1.0. This is equivalent to
342 frexp, but operates on the long double data type. */
344 static long double ldfrexp (long double value, int *eptr);
346 static long double
347 ldfrexp (long double value, int *eptr)
349 long double tmp;
350 int exp;
352 /* Unfortunately, there are no portable functions for extracting the
353 exponent of a long double, so we have to do it iteratively by
354 multiplying or dividing by two until the fraction is between 0.5
355 and 1.0. */
357 if (value < 0.0l)
358 value = -value;
360 tmp = 1.0l;
361 exp = 0;
363 if (value >= tmp) /* Value >= 1.0 */
364 while (value >= tmp)
366 tmp *= 2.0l;
367 exp++;
369 else if (value != 0.0l) /* Value < 1.0 and > 0.0 */
371 while (value < tmp)
373 tmp /= 2.0l;
374 exp--;
376 tmp *= 2.0l;
377 exp++;
380 *eptr = exp;
381 return value / tmp;
383 #endif /* HAVE_LONG_DOUBLE */
386 /* The converse: convert the DOUBLEST *FROM to an extended float and
387 store where TO points. Neither FROM nor TO have any alignment
388 restrictions. */
390 static void
391 convert_doublest_to_floatformat (CONST struct floatformat *fmt,
392 const DOUBLEST *from, void *to)
394 DOUBLEST dfrom;
395 int exponent;
396 DOUBLEST mant;
397 unsigned int mant_bits, mant_off;
398 int mant_bits_left;
399 unsigned char *uto = (unsigned char *) to;
400 enum floatformat_byteorders order = fmt->byteorder;
401 unsigned char newto[FLOATFORMAT_LARGEST_BYTES];
403 if (order != floatformat_little)
404 order = floatformat_big;
406 if (order != fmt->byteorder)
407 uto = newto;
409 memcpy (&dfrom, from, sizeof (dfrom));
410 memset (uto, 0, (fmt->totalsize + FLOATFORMAT_CHAR_BIT - 1)
411 / FLOATFORMAT_CHAR_BIT);
413 if (fmt->split_half)
415 /* Use static volatile to ensure that any excess precision is
416 removed via storing in memory, and so the top half really is
417 the result of converting to double. */
418 static volatile double dtop, dbot;
419 DOUBLEST dtopnv, dbotnv;
421 dtop = (double) dfrom;
422 /* If the rounded top half is Inf, the bottom must be 0 not NaN
423 or Inf. */
424 if (dtop + dtop == dtop && dtop != 0.0)
425 dbot = 0.0;
426 else
427 dbot = (double) (dfrom - (DOUBLEST) dtop);
428 dtopnv = dtop;
429 dbotnv = dbot;
430 floatformat_from_doublest (fmt->split_half, &dtopnv, uto);
431 floatformat_from_doublest (fmt->split_half, &dbotnv,
432 (uto
433 + fmt->totalsize / FLOATFORMAT_CHAR_BIT / 2));
434 return;
437 if (dfrom == 0)
438 return; /* Result is zero */
439 if (dfrom != dfrom) /* Result is NaN */
441 /* From is NaN */
442 put_field (uto, order, fmt->totalsize, fmt->exp_start,
443 fmt->exp_len, fmt->exp_nan);
444 /* Be sure it's not infinity, but NaN value is irrel. */
445 put_field (uto, order, fmt->totalsize, fmt->man_start,
446 fmt->man_len, 1);
447 goto finalize_byteorder;
450 /* If negative, set the sign bit. */
451 if (dfrom < 0)
453 put_field (uto, order, fmt->totalsize, fmt->sign_start, 1, 1);
454 dfrom = -dfrom;
457 if (dfrom + dfrom == dfrom && dfrom != 0.0) /* Result is Infinity. */
459 /* Infinity exponent is same as NaN's. */
460 put_field (uto, order, fmt->totalsize, fmt->exp_start,
461 fmt->exp_len, fmt->exp_nan);
462 /* Infinity mantissa is all zeroes. */
463 put_field (uto, order, fmt->totalsize, fmt->man_start,
464 fmt->man_len, 0);
465 goto finalize_byteorder;
468 #ifdef HAVE_LONG_DOUBLE
469 mant = ldfrexp (dfrom, &exponent);
470 #else
471 mant = frexp (dfrom, &exponent);
472 #endif
474 if (exponent + fmt->exp_bias <= 0)
476 /* The value is too small to be expressed in the destination
477 type (not enough bits in the exponent. Treat as 0. */
478 put_field (uto, order, fmt->totalsize, fmt->exp_start,
479 fmt->exp_len, 0);
480 put_field (uto, order, fmt->totalsize, fmt->man_start,
481 fmt->man_len, 0);
482 goto finalize_byteorder;
485 if (exponent + fmt->exp_bias >= (1 << fmt->exp_len))
487 /* The value is too large to fit into the destination.
488 Treat as infinity. */
489 put_field (uto, order, fmt->totalsize, fmt->exp_start,
490 fmt->exp_len, fmt->exp_nan);
491 put_field (uto, order, fmt->totalsize, fmt->man_start,
492 fmt->man_len, 0);
493 goto finalize_byteorder;
496 put_field (uto, order, fmt->totalsize, fmt->exp_start, fmt->exp_len,
497 exponent + fmt->exp_bias - 1);
499 mant_bits_left = fmt->man_len;
500 mant_off = fmt->man_start;
501 while (mant_bits_left > 0)
503 unsigned long mant_long;
505 mant_bits = mant_bits_left < 32 ? mant_bits_left : 32;
507 mant *= 4294967296.0;
508 mant_long = ((unsigned long) mant) & 0xffffffffL;
509 mant -= mant_long;
511 /* If the integer bit is implicit, then we need to discard it.
512 If we are discarding a zero, we should be (but are not) creating
513 a denormalized number which means adjusting the exponent
514 (I think). */
515 if (mant_bits_left == fmt->man_len
516 && fmt->intbit == floatformat_intbit_no)
518 mant_long <<= 1;
519 mant_long &= 0xffffffffL;
520 /* If we are processing the top 32 mantissa bits of a doublest
521 so as to convert to a float value with implied integer bit,
522 we will only be putting 31 of those 32 bits into the
523 final value due to the discarding of the top bit. In the
524 case of a small float value where the number of mantissa
525 bits is less than 32, discarding the top bit does not alter
526 the number of bits we will be adding to the result. */
527 if (mant_bits == 32)
528 mant_bits -= 1;
531 if (mant_bits < 32)
533 /* The bits we want are in the most significant MANT_BITS bits of
534 mant_long. Move them to the least significant. */
535 mant_long >>= 32 - mant_bits;
538 put_field (uto, order, fmt->totalsize,
539 mant_off, mant_bits, mant_long);
540 mant_off += mant_bits;
541 mant_bits_left -= mant_bits;
544 finalize_byteorder:
545 /* Do we need to byte-swap the words in the result? */
546 if (order != fmt->byteorder)
547 floatformat_normalize_byteorder (fmt, newto, to);
550 /* Check if VAL (which is assumed to be a floating point number whose
551 format is described by FMT) is negative. */
554 floatformat_is_negative (const struct floatformat *fmt,
555 const bfd_byte *uval)
557 enum floatformat_byteorders order;
558 unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
560 gdb_assert (fmt != NULL);
561 gdb_assert (fmt->totalsize
562 <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);
564 order = floatformat_normalize_byteorder (fmt, uval, newfrom);
566 if (order != fmt->byteorder)
567 uval = newfrom;
569 return get_field (uval, order, fmt->totalsize, fmt->sign_start, 1);
572 /* Check if VAL is "not a number" (NaN) for FMT. */
574 enum float_kind
575 floatformat_classify (const struct floatformat *fmt,
576 const bfd_byte *uval)
578 long exponent;
579 unsigned long mant;
580 unsigned int mant_bits, mant_off;
581 int mant_bits_left;
582 enum floatformat_byteorders order;
583 unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
584 int mant_zero;
586 gdb_assert (fmt != NULL);
587 gdb_assert (fmt->totalsize
588 <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);
590 order = floatformat_normalize_byteorder (fmt, uval, newfrom);
592 if (order != fmt->byteorder)
593 uval = newfrom;
595 exponent = get_field (uval, order, fmt->totalsize, fmt->exp_start,
596 fmt->exp_len);
598 mant_bits_left = fmt->man_len;
599 mant_off = fmt->man_start;
601 mant_zero = 1;
602 while (mant_bits_left > 0)
604 mant_bits = min (mant_bits_left, 32);
606 mant = get_field (uval, order, fmt->totalsize, mant_off, mant_bits);
608 /* If there is an explicit integer bit, mask it off. */
609 if (mant_off == fmt->man_start
610 && fmt->intbit == floatformat_intbit_yes)
611 mant &= ~(1 << (mant_bits - 1));
613 if (mant)
615 mant_zero = 0;
616 break;
619 mant_off += mant_bits;
620 mant_bits_left -= mant_bits;
623 /* If exp_nan is not set, assume that inf, NaN, and subnormals are not
624 supported. */
625 if (! fmt->exp_nan)
627 if (mant_zero)
628 return float_zero;
629 else
630 return float_normal;
633 if (exponent == 0 && !mant_zero)
634 return float_subnormal;
636 if (exponent == fmt->exp_nan)
638 if (mant_zero)
639 return float_infinite;
640 else
641 return float_nan;
644 if (mant_zero)
645 return float_zero;
647 return float_normal;
650 /* Convert the mantissa of VAL (which is assumed to be a floating
651 point number whose format is described by FMT) into a hexadecimal
652 and store it in a static string. Return a pointer to that string. */
654 const char *
655 floatformat_mantissa (const struct floatformat *fmt,
656 const bfd_byte *val)
658 unsigned char *uval = (unsigned char *) val;
659 unsigned long mant;
660 unsigned int mant_bits, mant_off;
661 int mant_bits_left;
662 static char res[50];
663 char buf[9];
664 int len;
665 enum floatformat_byteorders order;
666 unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
668 gdb_assert (fmt != NULL);
669 gdb_assert (fmt->totalsize
670 <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);
672 order = floatformat_normalize_byteorder (fmt, uval, newfrom);
674 if (order != fmt->byteorder)
675 uval = newfrom;
677 if (! fmt->exp_nan)
678 return 0;
680 /* Make sure we have enough room to store the mantissa. */
681 gdb_assert (sizeof res > ((fmt->man_len + 7) / 8) * 2);
683 mant_off = fmt->man_start;
684 mant_bits_left = fmt->man_len;
685 mant_bits = (mant_bits_left % 32) > 0 ? mant_bits_left % 32 : 32;
687 mant = get_field (uval, order, fmt->totalsize, mant_off, mant_bits);
689 len = xsnprintf (res, sizeof res, "%lx", mant);
691 mant_off += mant_bits;
692 mant_bits_left -= mant_bits;
694 while (mant_bits_left > 0)
696 mant = get_field (uval, order, fmt->totalsize, mant_off, 32);
698 xsnprintf (buf, sizeof buf, "%08lx", mant);
699 gdb_assert (len + strlen (buf) <= sizeof res);
700 strcat (res, buf);
702 mant_off += 32;
703 mant_bits_left -= 32;
706 return res;
710 /* Convert TO/FROM target to the hosts DOUBLEST floating-point format.
712 If the host and target formats agree, we just copy the raw data
713 into the appropriate type of variable and return, letting the host
714 increase precision as necessary. Otherwise, we call the conversion
715 routine and let it do the dirty work. */
717 static const struct floatformat *host_float_format = GDB_HOST_FLOAT_FORMAT;
718 static const struct floatformat *host_double_format = GDB_HOST_DOUBLE_FORMAT;
719 static const struct floatformat *host_long_double_format
720 = GDB_HOST_LONG_DOUBLE_FORMAT;
722 void
723 floatformat_to_doublest (const struct floatformat *fmt,
724 const void *in, DOUBLEST *out)
726 gdb_assert (fmt != NULL);
727 if (fmt == host_float_format)
729 float val;
731 memcpy (&val, in, sizeof (val));
732 *out = val;
734 else if (fmt == host_double_format)
736 double val;
738 memcpy (&val, in, sizeof (val));
739 *out = val;
741 else if (fmt == host_long_double_format)
743 long double val;
745 memcpy (&val, in, sizeof (val));
746 *out = val;
748 else
749 convert_floatformat_to_doublest (fmt, in, out);
752 void
753 floatformat_from_doublest (const struct floatformat *fmt,
754 const DOUBLEST *in, void *out)
756 gdb_assert (fmt != NULL);
757 if (fmt == host_float_format)
759 float val = *in;
761 memcpy (out, &val, sizeof (val));
763 else if (fmt == host_double_format)
765 double val = *in;
767 memcpy (out, &val, sizeof (val));
769 else if (fmt == host_long_double_format)
771 long double val = *in;
773 memcpy (out, &val, sizeof (val));
775 else
776 convert_doublest_to_floatformat (fmt, in, out);
780 /* Return a floating-point format for a floating-point variable of
781 length LEN. If no suitable floating-point format is found, an
782 error is thrown.
784 We need this functionality since information about the
785 floating-point format of a type is not always available to GDB; the
786 debug information typically only tells us the size of a
787 floating-point type.
789 FIXME: kettenis/2001-10-28: In many places, particularly in
790 target-dependent code, the format of floating-point types is known,
791 but not passed on by GDB. This should be fixed. */
793 static const struct floatformat *
794 floatformat_from_length (struct gdbarch *gdbarch, int len)
796 const struct floatformat *format;
798 if (len * TARGET_CHAR_BIT == gdbarch_half_bit (gdbarch))
799 format = gdbarch_half_format (gdbarch)
800 [gdbarch_byte_order (gdbarch)];
801 else if (len * TARGET_CHAR_BIT == gdbarch_float_bit (gdbarch))
802 format = gdbarch_float_format (gdbarch)
803 [gdbarch_byte_order (gdbarch)];
804 else if (len * TARGET_CHAR_BIT == gdbarch_double_bit (gdbarch))
805 format = gdbarch_double_format (gdbarch)
806 [gdbarch_byte_order (gdbarch)];
807 else if (len * TARGET_CHAR_BIT == gdbarch_long_double_bit (gdbarch))
808 format = gdbarch_long_double_format (gdbarch)
809 [gdbarch_byte_order (gdbarch)];
810 /* On i386 the 'long double' type takes 96 bits,
811 while the real number of used bits is only 80,
812 both in processor and in memory.
813 The code below accepts the real bit size. */
814 else if ((gdbarch_long_double_format (gdbarch) != NULL)
815 && (len * TARGET_CHAR_BIT
816 == gdbarch_long_double_format (gdbarch)[0]->totalsize))
817 format = gdbarch_long_double_format (gdbarch)
818 [gdbarch_byte_order (gdbarch)];
819 else
820 format = NULL;
821 if (format == NULL)
822 error (_("Unrecognized %d-bit floating-point type."),
823 len * TARGET_CHAR_BIT);
824 return format;
827 const struct floatformat *
828 floatformat_from_type (const struct type *type)
830 struct gdbarch *gdbarch = get_type_arch (type);
832 gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT);
833 if (TYPE_FLOATFORMAT (type) != NULL)
834 return TYPE_FLOATFORMAT (type)[gdbarch_byte_order (gdbarch)];
835 else
836 return floatformat_from_length (gdbarch, TYPE_LENGTH (type));
839 /* Extract a floating-point number of type TYPE from a target-order
840 byte-stream at ADDR. Returns the value as type DOUBLEST. */
842 DOUBLEST
843 extract_typed_floating (const void *addr, const struct type *type)
845 const struct floatformat *fmt = floatformat_from_type (type);
846 DOUBLEST retval;
848 floatformat_to_doublest (fmt, addr, &retval);
849 return retval;
852 /* Store VAL as a floating-point number of type TYPE to a target-order
853 byte-stream at ADDR. */
855 void
856 store_typed_floating (void *addr, const struct type *type, DOUBLEST val)
858 const struct floatformat *fmt = floatformat_from_type (type);
860 /* FIXME: kettenis/2001-10-28: It is debatable whether we should
861 zero out any remaining bytes in the target buffer when TYPE is
862 longer than the actual underlying floating-point format. Perhaps
863 we should store a fixed bitpattern in those remaining bytes,
864 instead of zero, or perhaps we shouldn't touch those remaining
865 bytes at all.
867 NOTE: cagney/2001-10-28: With the way things currently work, it
868 isn't a good idea to leave the end bits undefined. This is
869 because GDB writes out the entire sizeof(<floating>) bits of the
870 floating-point type even though the value might only be stored
871 in, and the target processor may only refer to, the first N <
872 TYPE_LENGTH (type) bits. If the end of the buffer wasn't
873 initialized, GDB would write undefined data to the target. An
874 errant program, refering to that undefined data, would then
875 become non-deterministic.
877 See also the function convert_typed_floating below. */
878 memset (addr, 0, TYPE_LENGTH (type));
880 floatformat_from_doublest (fmt, &val, addr);
883 /* Convert a floating-point number of type FROM_TYPE from a
884 target-order byte-stream at FROM to a floating-point number of type
885 TO_TYPE, and store it to a target-order byte-stream at TO. */
887 void
888 convert_typed_floating (const void *from, const struct type *from_type,
889 void *to, const struct type *to_type)
891 const struct floatformat *from_fmt = floatformat_from_type (from_type);
892 const struct floatformat *to_fmt = floatformat_from_type (to_type);
894 if (from_fmt == NULL || to_fmt == NULL)
896 /* If we don't know the floating-point format of FROM_TYPE or
897 TO_TYPE, there's not much we can do. We might make the
898 assumption that if the length of FROM_TYPE and TO_TYPE match,
899 their floating-point format would match too, but that
900 assumption might be wrong on targets that support
901 floating-point types that only differ in endianness for
902 example. So we warn instead, and zero out the target buffer. */
903 warning (_("Can't convert floating-point number to desired type."));
904 memset (to, 0, TYPE_LENGTH (to_type));
906 else if (from_fmt == to_fmt)
908 /* We're in business. The floating-point format of FROM_TYPE
909 and TO_TYPE match. However, even though the floating-point
910 format matches, the length of the type might still be
911 different. Make sure we don't overrun any buffers. See
912 comment in store_typed_floating for a discussion about
913 zeroing out remaining bytes in the target buffer. */
914 memset (to, 0, TYPE_LENGTH (to_type));
915 memcpy (to, from, min (TYPE_LENGTH (from_type), TYPE_LENGTH (to_type)));
917 else
919 /* The floating-point types don't match. The best we can do
920 (apart from simulating the target FPU) is converting to the
921 widest floating-point type supported by the host, and then
922 again to the desired type. */
923 DOUBLEST d;
925 floatformat_to_doublest (from_fmt, from, &d);
926 floatformat_from_doublest (to_fmt, &d, to);
930 const struct floatformat *floatformat_ieee_single[BFD_ENDIAN_UNKNOWN];
931 const struct floatformat *floatformat_ieee_double[BFD_ENDIAN_UNKNOWN];
932 const struct floatformat *floatformat_ieee_quad[BFD_ENDIAN_UNKNOWN];
933 const struct floatformat *floatformat_arm_ext[BFD_ENDIAN_UNKNOWN];
934 const struct floatformat *floatformat_ia64_spill[BFD_ENDIAN_UNKNOWN];
936 extern void _initialize_doublest (void);
938 extern void
939 _initialize_doublest (void)
941 floatformat_ieee_single[BFD_ENDIAN_LITTLE] = &floatformat_ieee_single_little;
942 floatformat_ieee_single[BFD_ENDIAN_BIG] = &floatformat_ieee_single_big;
943 floatformat_ieee_double[BFD_ENDIAN_LITTLE] = &floatformat_ieee_double_little;
944 floatformat_ieee_double[BFD_ENDIAN_BIG] = &floatformat_ieee_double_big;
945 floatformat_arm_ext[BFD_ENDIAN_LITTLE]
946 = &floatformat_arm_ext_littlebyte_bigword;
947 floatformat_arm_ext[BFD_ENDIAN_BIG] = &floatformat_arm_ext_big;
948 floatformat_ia64_spill[BFD_ENDIAN_LITTLE] = &floatformat_ia64_spill_little;
949 floatformat_ia64_spill[BFD_ENDIAN_BIG] = &floatformat_ia64_spill_big;
950 floatformat_ieee_quad[BFD_ENDIAN_LITTLE] = &floatformat_ia64_quad_little;
951 floatformat_ieee_quad[BFD_ENDIAN_BIG] = &floatformat_ia64_quad_big;