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, 2004 Free Software
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;
96 case floatformat_little:
102 case floatformat_littlebyte_bigword:
106 if (len < sizeof(result) * FLOATFORMAT_CHAR_BIT)
107 /* Mask out bits which are not part of the field */
108 result &= ((1UL << len) - 1);
112 /* Convert from FMT to a DOUBLEST.
113 FROM is the address of the extended float.
114 Store the DOUBLEST in *TO. */
117 convert_floatformat_to_doublest (const struct floatformat *fmt,
121 unsigned char *ufrom = (unsigned char *) from;
125 unsigned int mant_bits, mant_off;
127 int special_exponent; /* It's a NaN, denorm or zero */
129 /* If the mantissa bits are not contiguous from one end of the
130 mantissa to the other, we need to make a private copy of the
131 source bytes that is in the right order since the unpacking
132 algorithm assumes that the bits are contiguous.
134 Swap the bytes individually rather than accessing them through
135 "long *" since we have no guarantee that they start on a long
136 alignment, and also sizeof(long) for the host could be different
137 than sizeof(long) for the target. FIXME: Assumes sizeof(long)
138 for the target is 4. */
140 if (fmt->byteorder == floatformat_littlebyte_bigword)
142 static unsigned char *newfrom;
143 unsigned char *swapin, *swapout;
146 longswaps = fmt->totalsize / FLOATFORMAT_CHAR_BIT;
151 newfrom = (unsigned char *) xmalloc (fmt->totalsize);
156 while (longswaps-- > 0)
158 /* This is ugly, but efficient */
159 *swapout++ = swapin[4];
160 *swapout++ = swapin[5];
161 *swapout++ = swapin[6];
162 *swapout++ = swapin[7];
163 *swapout++ = swapin[0];
164 *swapout++ = swapin[1];
165 *swapout++ = swapin[2];
166 *swapout++ = swapin[3];
171 exponent = get_field (ufrom, fmt->byteorder, fmt->totalsize,
172 fmt->exp_start, fmt->exp_len);
173 /* Note that if exponent indicates a NaN, we can't really do anything useful
174 (not knowing if the host has NaN's, or how to build one). So it will
175 end up as an infinity or something close; that is OK. */
177 mant_bits_left = fmt->man_len;
178 mant_off = fmt->man_start;
181 special_exponent = exponent == 0 || exponent == fmt->exp_nan;
183 /* Don't bias NaNs. Use minimum exponent for denorms. For simplicity,
184 we don't check for zero as the exponent doesn't matter. Note the cast
185 to int; exp_bias is unsigned, so it's important to make sure the
186 operation is done in signed arithmetic. */
187 if (!special_exponent)
188 exponent -= fmt->exp_bias;
189 else if (exponent == 0)
190 exponent = 1 - fmt->exp_bias;
192 /* Build the result algebraically. Might go infinite, underflow, etc;
195 /* If this format uses a hidden bit, explicitly add it in now. Otherwise,
196 increment the exponent by one to account for the integer bit. */
198 if (!special_exponent)
200 if (fmt->intbit == floatformat_intbit_no)
201 dto = ldexp (1.0, exponent);
206 while (mant_bits_left > 0)
208 mant_bits = min (mant_bits_left, 32);
210 mant = get_field (ufrom, fmt->byteorder, fmt->totalsize,
211 mant_off, mant_bits);
213 dto += ldexp ((double) mant, exponent - mant_bits);
214 exponent -= mant_bits;
215 mant_off += mant_bits;
216 mant_bits_left -= mant_bits;
219 /* Negate it if negative. */
220 if (get_field (ufrom, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1))
225 static void put_field (unsigned char *, enum floatformat_byteorders,
227 unsigned int, unsigned int, unsigned long);
229 /* Set a field which starts at START and is LEN bytes long. DATA and
230 TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */
232 put_field (unsigned char *data, enum floatformat_byteorders order,
233 unsigned int total_len, unsigned int start, unsigned int len,
234 unsigned long stuff_to_put)
236 unsigned int cur_byte;
239 /* Start at the least significant part of the field. */
240 if (order == floatformat_little || order == floatformat_littlebyte_bigword)
242 int excess = FLOATFORMAT_CHAR_BIT - (total_len % FLOATFORMAT_CHAR_BIT);
243 cur_byte = (total_len / FLOATFORMAT_CHAR_BIT)
244 - ((start + len + excess) / FLOATFORMAT_CHAR_BIT);
245 cur_bitshift = ((start + len + excess) % FLOATFORMAT_CHAR_BIT)
246 - FLOATFORMAT_CHAR_BIT;
250 cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT;
252 ((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT;
254 if (cur_bitshift > -FLOATFORMAT_CHAR_BIT)
256 *(data + cur_byte) &=
257 ~(((1 << ((start + len) % FLOATFORMAT_CHAR_BIT)) - 1)
259 *(data + cur_byte) |=
260 (stuff_to_put & ((1 << FLOATFORMAT_CHAR_BIT) - 1)) << (-cur_bitshift);
262 cur_bitshift += FLOATFORMAT_CHAR_BIT;
263 if (order == floatformat_little || order == floatformat_littlebyte_bigword)
268 /* Move towards the most significant part of the field. */
269 while (cur_bitshift < len)
271 if (len - cur_bitshift < FLOATFORMAT_CHAR_BIT)
273 /* This is the last byte. */
274 *(data + cur_byte) &=
275 ~((1 << (len - cur_bitshift)) - 1);
276 *(data + cur_byte) |= (stuff_to_put >> cur_bitshift);
279 *(data + cur_byte) = ((stuff_to_put >> cur_bitshift)
280 & ((1 << FLOATFORMAT_CHAR_BIT) - 1));
281 cur_bitshift += FLOATFORMAT_CHAR_BIT;
282 if (order == floatformat_little || order == floatformat_littlebyte_bigword)
289 #ifdef HAVE_LONG_DOUBLE
290 /* Return the fractional part of VALUE, and put the exponent of VALUE in *EPTR.
291 The range of the returned value is >= 0.5 and < 1.0. This is equivalent to
292 frexp, but operates on the long double data type. */
294 static long double ldfrexp (long double value, int *eptr);
297 ldfrexp (long double value, int *eptr)
302 /* Unfortunately, there are no portable functions for extracting the exponent
303 of a long double, so we have to do it iteratively by multiplying or dividing
304 by two until the fraction is between 0.5 and 1.0. */
312 if (value >= tmp) /* Value >= 1.0 */
318 else if (value != 0.0l) /* Value < 1.0 and > 0.0 */
332 #endif /* HAVE_LONG_DOUBLE */
335 /* The converse: convert the DOUBLEST *FROM to an extended float
336 and store where TO points. Neither FROM nor TO have any alignment
340 convert_doublest_to_floatformat (CONST struct floatformat *fmt,
341 const DOUBLEST *from,
347 unsigned int mant_bits, mant_off;
349 unsigned char *uto = (unsigned char *) to;
351 memcpy (&dfrom, from, sizeof (dfrom));
352 memset (uto, 0, (fmt->totalsize + FLOATFORMAT_CHAR_BIT - 1)
353 / FLOATFORMAT_CHAR_BIT);
355 return; /* Result is zero */
356 if (dfrom != dfrom) /* Result is NaN */
359 put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
360 fmt->exp_len, fmt->exp_nan);
361 /* Be sure it's not infinity, but NaN value is irrel */
362 put_field (uto, fmt->byteorder, fmt->totalsize, fmt->man_start,
367 /* If negative, set the sign bit. */
370 put_field (uto, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1, 1);
374 if (dfrom + dfrom == dfrom && dfrom != 0.0) /* Result is Infinity */
376 /* Infinity exponent is same as NaN's. */
377 put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
378 fmt->exp_len, fmt->exp_nan);
379 /* Infinity mantissa is all zeroes. */
380 put_field (uto, fmt->byteorder, fmt->totalsize, fmt->man_start,
385 #ifdef HAVE_LONG_DOUBLE
386 mant = ldfrexp (dfrom, &exponent);
388 mant = frexp (dfrom, &exponent);
391 put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start, fmt->exp_len,
392 exponent + fmt->exp_bias - 1);
394 mant_bits_left = fmt->man_len;
395 mant_off = fmt->man_start;
396 while (mant_bits_left > 0)
398 unsigned long mant_long;
399 mant_bits = mant_bits_left < 32 ? mant_bits_left : 32;
401 mant *= 4294967296.0;
402 mant_long = ((unsigned long) mant) & 0xffffffffL;
405 /* If the integer bit is implicit, then we need to discard it.
406 If we are discarding a zero, we should be (but are not) creating
407 a denormalized number which means adjusting the exponent
409 if (mant_bits_left == fmt->man_len
410 && fmt->intbit == floatformat_intbit_no)
413 mant_long &= 0xffffffffL;
414 /* If we are processing the top 32 mantissa bits of a doublest
415 so as to convert to a float value with implied integer bit,
416 we will only be putting 31 of those 32 bits into the
417 final value due to the discarding of the top bit. In the
418 case of a small float value where the number of mantissa
419 bits is less than 32, discarding the top bit does not alter
420 the number of bits we will be adding to the result. */
427 /* The bits we want are in the most significant MANT_BITS bits of
428 mant_long. Move them to the least significant. */
429 mant_long >>= 32 - mant_bits;
432 put_field (uto, fmt->byteorder, fmt->totalsize,
433 mant_off, mant_bits, mant_long);
434 mant_off += mant_bits;
435 mant_bits_left -= mant_bits;
437 if (fmt->byteorder == floatformat_littlebyte_bigword)
440 unsigned char *swaplow = uto;
441 unsigned char *swaphigh = uto + 4;
444 for (count = 0; count < 4; count++)
447 *swaplow++ = *swaphigh;
453 /* Check if VAL (which is assumed to be a floating point number whose
454 format is described by FMT) is negative. */
457 floatformat_is_negative (const struct floatformat *fmt, char *val)
459 unsigned char *uval = (unsigned char *) val;
460 gdb_assert (fmt != NULL);
461 return get_field (uval, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1);
464 /* Check if VAL is "not a number" (NaN) for FMT. */
467 floatformat_is_nan (const struct floatformat *fmt, char *val)
469 unsigned char *uval = (unsigned char *) val;
472 unsigned int mant_bits, mant_off;
475 gdb_assert (fmt != NULL);
480 exponent = get_field (uval, fmt->byteorder, fmt->totalsize,
481 fmt->exp_start, fmt->exp_len);
483 if (exponent != fmt->exp_nan)
486 mant_bits_left = fmt->man_len;
487 mant_off = fmt->man_start;
489 while (mant_bits_left > 0)
491 mant_bits = min (mant_bits_left, 32);
493 mant = get_field (uval, fmt->byteorder, fmt->totalsize,
494 mant_off, mant_bits);
496 /* If there is an explicit integer bit, mask it off. */
497 if (mant_off == fmt->man_start
498 && fmt->intbit == floatformat_intbit_yes)
499 mant &= ~(1 << (mant_bits - 1));
504 mant_off += mant_bits;
505 mant_bits_left -= mant_bits;
511 /* Convert the mantissa of VAL (which is assumed to be a floating
512 point number whose format is described by FMT) into a hexadecimal
513 and store it in a static string. Return a pointer to that string. */
516 floatformat_mantissa (const struct floatformat *fmt, char *val)
518 unsigned char *uval = (unsigned char *) val;
520 unsigned int mant_bits, mant_off;
525 /* Make sure we have enough room to store the mantissa. */
526 gdb_assert (fmt != NULL);
527 gdb_assert (sizeof res > ((fmt->man_len + 7) / 8) * 2);
529 mant_off = fmt->man_start;
530 mant_bits_left = fmt->man_len;
531 mant_bits = (mant_bits_left % 32) > 0 ? mant_bits_left % 32 : 32;
533 mant = get_field (uval, fmt->byteorder, fmt->totalsize,
534 mant_off, mant_bits);
536 sprintf (res, "%lx", mant);
538 mant_off += mant_bits;
539 mant_bits_left -= mant_bits;
541 while (mant_bits_left > 0)
543 mant = get_field (uval, fmt->byteorder, fmt->totalsize,
546 sprintf (buf, "%08lx", mant);
550 mant_bits_left -= 32;
557 /* Convert TO/FROM target to the hosts DOUBLEST floating-point format.
559 If the host and target formats agree, we just copy the raw data
560 into the appropriate type of variable and return, letting the host
561 increase precision as necessary. Otherwise, we call the conversion
562 routine and let it do the dirty work. */
564 static const struct floatformat *host_float_format = GDB_HOST_FLOAT_FORMAT;
565 static const struct floatformat *host_double_format = GDB_HOST_DOUBLE_FORMAT;
566 static const struct floatformat *host_long_double_format = GDB_HOST_LONG_DOUBLE_FORMAT;
569 floatformat_to_doublest (const struct floatformat *fmt,
570 const void *in, DOUBLEST *out)
572 gdb_assert (fmt != NULL);
573 if (fmt == host_float_format)
576 memcpy (&val, in, sizeof (val));
579 else if (fmt == host_double_format)
582 memcpy (&val, in, sizeof (val));
585 else if (fmt == host_long_double_format)
588 memcpy (&val, in, sizeof (val));
592 convert_floatformat_to_doublest (fmt, in, out);
596 floatformat_from_doublest (const struct floatformat *fmt,
597 const DOUBLEST *in, void *out)
599 gdb_assert (fmt != NULL);
600 if (fmt == host_float_format)
603 memcpy (out, &val, sizeof (val));
605 else if (fmt == host_double_format)
608 memcpy (out, &val, sizeof (val));
610 else if (fmt == host_long_double_format)
612 long double val = *in;
613 memcpy (out, &val, sizeof (val));
616 convert_doublest_to_floatformat (fmt, in, out);
620 /* Return a floating-point format for a floating-point variable of
621 length LEN. If no suitable floating-point format is found, an
624 We need this functionality since information about the
625 floating-point format of a type is not always available to GDB; the
626 debug information typically only tells us the size of a
629 FIXME: kettenis/2001-10-28: In many places, particularly in
630 target-dependent code, the format of floating-point types is known,
631 but not passed on by GDB. This should be fixed. */
633 static const struct floatformat *
634 floatformat_from_length (int len)
636 const struct floatformat *format;
637 if (len * TARGET_CHAR_BIT == TARGET_FLOAT_BIT)
638 format = TARGET_FLOAT_FORMAT;
639 else if (len * TARGET_CHAR_BIT == TARGET_DOUBLE_BIT)
640 format = TARGET_DOUBLE_FORMAT;
641 else if (len * TARGET_CHAR_BIT == TARGET_LONG_DOUBLE_BIT)
642 format = TARGET_LONG_DOUBLE_FORMAT;
643 /* On i386 the 'long double' type takes 96 bits,
644 while the real number of used bits is only 80,
645 both in processor and in memory.
646 The code below accepts the real bit size. */
647 else if ((TARGET_LONG_DOUBLE_FORMAT != NULL)
648 && (len * TARGET_CHAR_BIT ==
649 TARGET_LONG_DOUBLE_FORMAT->totalsize))
650 format = TARGET_LONG_DOUBLE_FORMAT;
654 error ("Unrecognized %d-bit floating-point type.",
655 len * TARGET_CHAR_BIT);
659 const struct floatformat *
660 floatformat_from_type (const struct type *type)
662 gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT);
663 if (TYPE_FLOATFORMAT (type) != NULL)
664 return TYPE_FLOATFORMAT (type);
666 return floatformat_from_length (TYPE_LENGTH (type));
669 /* If the host doesn't define NAN, use zero instead. */
674 /* Extract a floating-point number of length LEN from a target-order
675 byte-stream at ADDR. Returns the value as type DOUBLEST. */
678 extract_floating_by_length (const void *addr, int len)
680 const struct floatformat *fmt = floatformat_from_length (len);
683 floatformat_to_doublest (fmt, addr, &val);
688 deprecated_extract_floating (const void *addr, int len)
690 return extract_floating_by_length (addr, len);
693 /* Store VAL as a floating-point number of length LEN to a
694 target-order byte-stream at ADDR. */
697 store_floating_by_length (void *addr, int len, DOUBLEST val)
699 const struct floatformat *fmt = floatformat_from_length (len);
701 floatformat_from_doublest (fmt, &val, addr);
705 deprecated_store_floating (void *addr, int len, DOUBLEST val)
707 store_floating_by_length (addr, len, val);
710 /* Extract a floating-point number of type TYPE from a target-order
711 byte-stream at ADDR. Returns the value as type DOUBLEST. */
714 extract_typed_floating (const void *addr, const struct type *type)
718 gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT);
720 if (TYPE_FLOATFORMAT (type) == NULL)
721 /* Not all code remembers to set the FLOATFORMAT (language
722 specific code? stabs?) so handle that here as a special case. */
723 return extract_floating_by_length (addr, TYPE_LENGTH (type));
725 floatformat_to_doublest (TYPE_FLOATFORMAT (type), addr, &retval);
729 /* Store VAL as a floating-point number of type TYPE to a target-order
730 byte-stream at ADDR. */
733 store_typed_floating (void *addr, const struct type *type, DOUBLEST val)
735 gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT);
737 /* FIXME: kettenis/2001-10-28: It is debatable whether we should
738 zero out any remaining bytes in the target buffer when TYPE is
739 longer than the actual underlying floating-point format. Perhaps
740 we should store a fixed bitpattern in those remaining bytes,
741 instead of zero, or perhaps we shouldn't touch those remaining
744 NOTE: cagney/2001-10-28: With the way things currently work, it
745 isn't a good idea to leave the end bits undefined. This is
746 because GDB writes out the entire sizeof(<floating>) bits of the
747 floating-point type even though the value might only be stored
748 in, and the target processor may only refer to, the first N <
749 TYPE_LENGTH (type) bits. If the end of the buffer wasn't
750 initialized, GDB would write undefined data to the target. An
751 errant program, refering to that undefined data, would then
752 become non-deterministic.
754 See also the function convert_typed_floating below. */
755 memset (addr, 0, TYPE_LENGTH (type));
757 if (TYPE_FLOATFORMAT (type) == NULL)
758 /* Not all code remembers to set the FLOATFORMAT (language
759 specific code? stabs?) so handle that here as a special case. */
760 store_floating_by_length (addr, TYPE_LENGTH (type), val);
762 floatformat_from_doublest (TYPE_FLOATFORMAT (type), &val, addr);
765 /* Convert a floating-point number of type FROM_TYPE from a
766 target-order byte-stream at FROM to a floating-point number of type
767 TO_TYPE, and store it to a target-order byte-stream at TO. */
770 convert_typed_floating (const void *from, const struct type *from_type,
771 void *to, const struct type *to_type)
773 const struct floatformat *from_fmt = floatformat_from_type (from_type);
774 const struct floatformat *to_fmt = floatformat_from_type (to_type);
776 gdb_assert (TYPE_CODE (from_type) == TYPE_CODE_FLT);
777 gdb_assert (TYPE_CODE (to_type) == TYPE_CODE_FLT);
779 if (from_fmt == NULL || to_fmt == NULL)
781 /* If we don't know the floating-point format of FROM_TYPE or
782 TO_TYPE, there's not much we can do. We might make the
783 assumption that if the length of FROM_TYPE and TO_TYPE match,
784 their floating-point format would match too, but that
785 assumption might be wrong on targets that support
786 floating-point types that only differ in endianness for
787 example. So we warn instead, and zero out the target buffer. */
788 warning ("Can't convert floating-point number to desired type.");
789 memset (to, 0, TYPE_LENGTH (to_type));
791 else if (from_fmt == to_fmt)
793 /* We're in business. The floating-point format of FROM_TYPE
794 and TO_TYPE match. However, even though the floating-point
795 format matches, the length of the type might still be
796 different. Make sure we don't overrun any buffers. See
797 comment in store_typed_floating for a discussion about
798 zeroing out remaining bytes in the target buffer. */
799 memset (to, 0, TYPE_LENGTH (to_type));
800 memcpy (to, from, min (TYPE_LENGTH (from_type), TYPE_LENGTH (to_type)));
804 /* The floating-point types don't match. The best we can do
805 (aport from simulating the target FPU) is converting to the
806 widest floating-point type supported by the host, and then
807 again to the desired type. */
810 floatformat_to_doublest (from_fmt, from, &d);
811 floatformat_from_doublest (to_fmt, &d, to);