GDB (xrefs)
/tmp/gdb-7.10/gdb/doublest.c
Go to the documentation of this file.
1 /* Floating point routines for GDB, the GNU debugger.
2 
3  Copyright (C) 1986-2015 Free Software Foundation, Inc.
4 
5  This file is part of GDB.
6 
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.
11 
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.
16 
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/>. */
19 
20 /* Support for converting target fp numbers into host DOUBLEST format. */
21 
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. */
25 
26 #include "defs.h"
27 #include "doublest.h"
28 #include "floatformat.h"
29 #include "gdbtypes.h"
30 #include <math.h> /* ldexp */
31 
32 /* The odds that CHAR_BIT will be anything but 8 are low enough that I'm not
33  going to bother with trying to muck around with whether it is defined in
34  a system header, what we do if not, etc. */
35 #define FLOATFORMAT_CHAR_BIT 8
36 
37 /* The number of bytes that the largest floating-point type that we
38  can convert to doublest will need. */
39 #define FLOATFORMAT_LARGEST_BYTES 16
40 
41 /* Extract a field which starts at START and is LEN bytes long. DATA and
42  TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */
43 static unsigned long
44 get_field (const bfd_byte *data, enum floatformat_byteorders order,
45  unsigned int total_len, unsigned int start, unsigned int len)
46 {
47  unsigned long result;
48  unsigned int cur_byte;
49  int cur_bitshift;
50 
51  /* Caller must byte-swap words before calling this routine. */
52  gdb_assert (order == floatformat_little || order == floatformat_big);
53 
54  /* Start at the least significant part of the field. */
55  if (order == floatformat_little)
56  {
57  /* We start counting from the other end (i.e, from the high bytes
58  rather than the low bytes). As such, we need to be concerned
59  with what happens if bit 0 doesn't start on a byte boundary.
60  I.e, we need to properly handle the case where total_len is
61  not evenly divisible by 8. So we compute ``excess'' which
62  represents the number of bits from the end of our starting
63  byte needed to get to bit 0. */
64  int excess = FLOATFORMAT_CHAR_BIT - (total_len % FLOATFORMAT_CHAR_BIT);
65 
66  cur_byte = (total_len / FLOATFORMAT_CHAR_BIT)
67  - ((start + len + excess) / FLOATFORMAT_CHAR_BIT);
68  cur_bitshift = ((start + len + excess) % FLOATFORMAT_CHAR_BIT)
70  }
71  else
72  {
73  cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT;
74  cur_bitshift =
76  }
77  if (cur_bitshift > -FLOATFORMAT_CHAR_BIT)
78  result = *(data + cur_byte) >> (-cur_bitshift);
79  else
80  result = 0;
81  cur_bitshift += FLOATFORMAT_CHAR_BIT;
82  if (order == floatformat_little)
83  ++cur_byte;
84  else
85  --cur_byte;
86 
87  /* Move towards the most significant part of the field. */
88  while (cur_bitshift < len)
89  {
90  result |= (unsigned long)*(data + cur_byte) << cur_bitshift;
91  cur_bitshift += FLOATFORMAT_CHAR_BIT;
92  switch (order)
93  {
94  case floatformat_little:
95  ++cur_byte;
96  break;
97  case floatformat_big:
98  --cur_byte;
99  break;
100  }
101  }
102  if (len < sizeof(result) * FLOATFORMAT_CHAR_BIT)
103  /* Mask out bits which are not part of the field. */
104  result &= ((1UL << len) - 1);
105  return result;
106 }
107 
108 /* Normalize the byte order of FROM into TO. If no normalization is
109  needed then FMT->byteorder is returned and TO is not changed;
110  otherwise the format of the normalized form in TO is returned. */
111 
112 static enum floatformat_byteorders
113 floatformat_normalize_byteorder (const struct floatformat *fmt,
114  const void *from, void *to)
115 {
116  const unsigned char *swapin;
117  unsigned char *swapout;
118  int words;
119 
120  if (fmt->byteorder == floatformat_little
121  || fmt->byteorder == floatformat_big)
122  return fmt->byteorder;
123 
124  words = fmt->totalsize / FLOATFORMAT_CHAR_BIT;
125  words >>= 2;
126 
127  swapout = (unsigned char *)to;
128  swapin = (const unsigned char *)from;
129 
130  if (fmt->byteorder == floatformat_vax)
131  {
132  while (words-- > 0)
133  {
134  *swapout++ = swapin[1];
135  *swapout++ = swapin[0];
136  *swapout++ = swapin[3];
137  *swapout++ = swapin[2];
138  swapin += 4;
139  }
140  /* This may look weird, since VAX is little-endian, but it is
141  easier to translate to big-endian than to little-endian. */
142  return floatformat_big;
143  }
144  else
145  {
146  gdb_assert (fmt->byteorder == floatformat_littlebyte_bigword);
147 
148  while (words-- > 0)
149  {
150  *swapout++ = swapin[3];
151  *swapout++ = swapin[2];
152  *swapout++ = swapin[1];
153  *swapout++ = swapin[0];
154  swapin += 4;
155  }
156  return floatformat_big;
157  }
158 }
159 
160 /* Convert from FMT to a DOUBLEST.
161  FROM is the address of the extended float.
162  Store the DOUBLEST in *TO. */
163 
164 static void
165 convert_floatformat_to_doublest (const struct floatformat *fmt,
166  const void *from,
167  DOUBLEST *to)
168 {
169  unsigned char *ufrom = (unsigned char *) from;
170  DOUBLEST dto;
171  long exponent;
172  unsigned long mant;
173  unsigned int mant_bits, mant_off;
174  int mant_bits_left;
175  int special_exponent; /* It's a NaN, denorm or zero. */
176  enum floatformat_byteorders order;
177  unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
178  enum float_kind kind;
179 
180  gdb_assert (fmt->totalsize
182 
183  /* For non-numbers, reuse libiberty's logic to find the correct
184  format. We do not lose any precision in this case by passing
185  through a double. */
186  kind = floatformat_classify (fmt, from);
187  if (kind == float_infinite || kind == float_nan)
188  {
189  double dto;
190 
191  floatformat_to_double (fmt->split_half ? fmt->split_half : fmt,
192  from, &dto);
193  *to = (DOUBLEST) dto;
194  return;
195  }
196 
197  order = floatformat_normalize_byteorder (fmt, ufrom, newfrom);
198 
199  if (order != fmt->byteorder)
200  ufrom = newfrom;
201 
202  if (fmt->split_half)
203  {
204  DOUBLEST dtop, dbot;
205 
206  floatformat_to_doublest (fmt->split_half, ufrom, &dtop);
207  /* Preserve the sign of 0, which is the sign of the top
208  half. */
209  if (dtop == 0.0)
210  {
211  *to = dtop;
212  return;
213  }
214  floatformat_to_doublest (fmt->split_half,
215  ufrom + fmt->totalsize / FLOATFORMAT_CHAR_BIT / 2,
216  &dbot);
217  *to = dtop + dbot;
218  return;
219  }
220 
221  exponent = get_field (ufrom, order, fmt->totalsize, fmt->exp_start,
222  fmt->exp_len);
223  /* Note that if exponent indicates a NaN, we can't really do anything useful
224  (not knowing if the host has NaN's, or how to build one). So it will
225  end up as an infinity or something close; that is OK. */
226 
227  mant_bits_left = fmt->man_len;
228  mant_off = fmt->man_start;
229  dto = 0.0;
230 
231  special_exponent = exponent == 0 || exponent == fmt->exp_nan;
232 
233  /* Don't bias NaNs. Use minimum exponent for denorms. For
234  simplicity, we don't check for zero as the exponent doesn't matter.
235  Note the cast to int; exp_bias is unsigned, so it's important to
236  make sure the operation is done in signed arithmetic. */
237  if (!special_exponent)
238  exponent -= fmt->exp_bias;
239  else if (exponent == 0)
240  exponent = 1 - fmt->exp_bias;
241 
242  /* Build the result algebraically. Might go infinite, underflow, etc;
243  who cares. */
244 
245 /* If this format uses a hidden bit, explicitly add it in now. Otherwise,
246  increment the exponent by one to account for the integer bit. */
247 
248  if (!special_exponent)
249  {
250  if (fmt->intbit == floatformat_intbit_no)
251  dto = ldexp (1.0, exponent);
252  else
253  exponent++;
254  }
255 
256  while (mant_bits_left > 0)
257  {
258  mant_bits = min (mant_bits_left, 32);
259 
260  mant = get_field (ufrom, order, fmt->totalsize, mant_off, mant_bits);
261 
262  dto += ldexp ((double) mant, exponent - mant_bits);
263  exponent -= mant_bits;
264  mant_off += mant_bits;
265  mant_bits_left -= mant_bits;
266  }
267 
268  /* Negate it if negative. */
269  if (get_field (ufrom, order, fmt->totalsize, fmt->sign_start, 1))
270  dto = -dto;
271  *to = dto;
272 }
273 
274 /* Set a field which starts at START and is LEN bytes long. DATA and
275  TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */
276 static void
277 put_field (unsigned char *data, enum floatformat_byteorders order,
278  unsigned int total_len, unsigned int start, unsigned int len,
279  unsigned long stuff_to_put)
280 {
281  unsigned int cur_byte;
282  int cur_bitshift;
283 
284  /* Caller must byte-swap words before calling this routine. */
285  gdb_assert (order == floatformat_little || order == floatformat_big);
286 
287  /* Start at the least significant part of the field. */
288  if (order == floatformat_little)
289  {
290  int excess = FLOATFORMAT_CHAR_BIT - (total_len % FLOATFORMAT_CHAR_BIT);
291 
292  cur_byte = (total_len / FLOATFORMAT_CHAR_BIT)
293  - ((start + len + excess) / FLOATFORMAT_CHAR_BIT);
294  cur_bitshift = ((start + len + excess) % FLOATFORMAT_CHAR_BIT)
296  }
297  else
298  {
299  cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT;
300  cur_bitshift =
302  }
303  if (cur_bitshift > -FLOATFORMAT_CHAR_BIT)
304  {
305  *(data + cur_byte) &=
306  ~(((1 << ((start + len) % FLOATFORMAT_CHAR_BIT)) - 1)
307  << (-cur_bitshift));
308  *(data + cur_byte) |=
309  (stuff_to_put & ((1 << FLOATFORMAT_CHAR_BIT) - 1)) << (-cur_bitshift);
310  }
311  cur_bitshift += FLOATFORMAT_CHAR_BIT;
312  if (order == floatformat_little)
313  ++cur_byte;
314  else
315  --cur_byte;
316 
317  /* Move towards the most significant part of the field. */
318  while (cur_bitshift < len)
319  {
320  if (len - cur_bitshift < FLOATFORMAT_CHAR_BIT)
321  {
322  /* This is the last byte. */
323  *(data + cur_byte) &=
324  ~((1 << (len - cur_bitshift)) - 1);
325  *(data + cur_byte) |= (stuff_to_put >> cur_bitshift);
326  }
327  else
328  *(data + cur_byte) = ((stuff_to_put >> cur_bitshift)
329  & ((1 << FLOATFORMAT_CHAR_BIT) - 1));
330  cur_bitshift += FLOATFORMAT_CHAR_BIT;
331  if (order == floatformat_little)
332  ++cur_byte;
333  else
334  --cur_byte;
335  }
336 }
337 
338 /* The converse: convert the DOUBLEST *FROM to an extended float and
339  store where TO points. Neither FROM nor TO have any alignment
340  restrictions. */
341 
342 static void
343 convert_doublest_to_floatformat (const struct floatformat *fmt,
344  const DOUBLEST *from, void *to)
345 {
346  DOUBLEST dfrom;
347  int exponent;
348  DOUBLEST mant;
349  unsigned int mant_bits, mant_off;
350  int mant_bits_left;
351  unsigned char *uto = (unsigned char *) to;
352  enum floatformat_byteorders order = fmt->byteorder;
353  unsigned char newto[FLOATFORMAT_LARGEST_BYTES];
354 
355  if (order != floatformat_little)
356  order = floatformat_big;
357 
358  if (order != fmt->byteorder)
359  uto = newto;
360 
361  memcpy (&dfrom, from, sizeof (dfrom));
362  memset (uto, 0, (fmt->totalsize + FLOATFORMAT_CHAR_BIT - 1)
364 
365  if (fmt->split_half)
366  {
367  /* Use static volatile to ensure that any excess precision is
368  removed via storing in memory, and so the top half really is
369  the result of converting to double. */
370  static volatile double dtop, dbot;
371  DOUBLEST dtopnv, dbotnv;
372 
373  dtop = (double) dfrom;
374  /* If the rounded top half is Inf, the bottom must be 0 not NaN
375  or Inf. */
376  if (dtop + dtop == dtop && dtop != 0.0)
377  dbot = 0.0;
378  else
379  dbot = (double) (dfrom - (DOUBLEST) dtop);
380  dtopnv = dtop;
381  dbotnv = dbot;
382  floatformat_from_doublest (fmt->split_half, &dtopnv, uto);
383  floatformat_from_doublest (fmt->split_half, &dbotnv,
384  (uto
385  + fmt->totalsize / FLOATFORMAT_CHAR_BIT / 2));
386  return;
387  }
388 
389  if (dfrom == 0)
390  return; /* Result is zero */
391  if (dfrom != dfrom) /* Result is NaN */
392  {
393  /* From is NaN */
394  put_field (uto, order, fmt->totalsize, fmt->exp_start,
395  fmt->exp_len, fmt->exp_nan);
396  /* Be sure it's not infinity, but NaN value is irrel. */
397  put_field (uto, order, fmt->totalsize, fmt->man_start,
398  fmt->man_len, 1);
399  goto finalize_byteorder;
400  }
401 
402  /* If negative, set the sign bit. */
403  if (dfrom < 0)
404  {
405  put_field (uto, order, fmt->totalsize, fmt->sign_start, 1, 1);
406  dfrom = -dfrom;
407  }
408 
409  if (dfrom + dfrom == dfrom && dfrom != 0.0) /* Result is Infinity. */
410  {
411  /* Infinity exponent is same as NaN's. */
412  put_field (uto, order, fmt->totalsize, fmt->exp_start,
413  fmt->exp_len, fmt->exp_nan);
414  /* Infinity mantissa is all zeroes. */
415  put_field (uto, order, fmt->totalsize, fmt->man_start,
416  fmt->man_len, 0);
417  goto finalize_byteorder;
418  }
419 
420 #ifdef HAVE_LONG_DOUBLE
421  mant = frexpl (dfrom, &exponent);
422 #else
423  mant = frexp (dfrom, &exponent);
424 #endif
425 
426  if (exponent + fmt->exp_bias <= 0)
427  {
428  /* The value is too small to be expressed in the destination
429  type (not enough bits in the exponent. Treat as 0. */
430  put_field (uto, order, fmt->totalsize, fmt->exp_start,
431  fmt->exp_len, 0);
432  put_field (uto, order, fmt->totalsize, fmt->man_start,
433  fmt->man_len, 0);
434  goto finalize_byteorder;
435  }
436 
437  if (exponent + fmt->exp_bias >= (1 << fmt->exp_len))
438  {
439  /* The value is too large to fit into the destination.
440  Treat as infinity. */
441  put_field (uto, order, fmt->totalsize, fmt->exp_start,
442  fmt->exp_len, fmt->exp_nan);
443  put_field (uto, order, fmt->totalsize, fmt->man_start,
444  fmt->man_len, 0);
445  goto finalize_byteorder;
446  }
447 
448  put_field (uto, order, fmt->totalsize, fmt->exp_start, fmt->exp_len,
449  exponent + fmt->exp_bias - 1);
450 
451  mant_bits_left = fmt->man_len;
452  mant_off = fmt->man_start;
453  while (mant_bits_left > 0)
454  {
455  unsigned long mant_long;
456 
457  mant_bits = mant_bits_left < 32 ? mant_bits_left : 32;
458 
459  mant *= 4294967296.0;
460  mant_long = ((unsigned long) mant) & 0xffffffffL;
461  mant -= mant_long;
462 
463  /* If the integer bit is implicit, then we need to discard it.
464  If we are discarding a zero, we should be (but are not) creating
465  a denormalized number which means adjusting the exponent
466  (I think). */
467  if (mant_bits_left == fmt->man_len
468  && fmt->intbit == floatformat_intbit_no)
469  {
470  mant_long <<= 1;
471  mant_long &= 0xffffffffL;
472  /* If we are processing the top 32 mantissa bits of a doublest
473  so as to convert to a float value with implied integer bit,
474  we will only be putting 31 of those 32 bits into the
475  final value due to the discarding of the top bit. In the
476  case of a small float value where the number of mantissa
477  bits is less than 32, discarding the top bit does not alter
478  the number of bits we will be adding to the result. */
479  if (mant_bits == 32)
480  mant_bits -= 1;
481  }
482 
483  if (mant_bits < 32)
484  {
485  /* The bits we want are in the most significant MANT_BITS bits of
486  mant_long. Move them to the least significant. */
487  mant_long >>= 32 - mant_bits;
488  }
489 
490  put_field (uto, order, fmt->totalsize,
491  mant_off, mant_bits, mant_long);
492  mant_off += mant_bits;
493  mant_bits_left -= mant_bits;
494  }
495 
496  finalize_byteorder:
497  /* Do we need to byte-swap the words in the result? */
498  if (order != fmt->byteorder)
499  floatformat_normalize_byteorder (fmt, newto, to);
500 }
501 
502 /* Check if VAL (which is assumed to be a floating point number whose
503  format is described by FMT) is negative. */
504 
505 int
506 floatformat_is_negative (const struct floatformat *fmt,
507  const bfd_byte *uval)
508 {
509  enum floatformat_byteorders order;
510  unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
511 
512  gdb_assert (fmt != NULL);
513  gdb_assert (fmt->totalsize
515 
516  /* An IBM long double (a two element array of double) always takes the
517  sign of the first double. */
518  if (fmt->split_half)
519  fmt = fmt->split_half;
520 
521  order = floatformat_normalize_byteorder (fmt, uval, newfrom);
522 
523  if (order != fmt->byteorder)
524  uval = newfrom;
525 
526  return get_field (uval, order, fmt->totalsize, fmt->sign_start, 1);
527 }
528 
529 /* Check if VAL is "not a number" (NaN) for FMT. */
530 
531 enum float_kind
532 floatformat_classify (const struct floatformat *fmt,
533  const bfd_byte *uval)
534 {
535  long exponent;
536  unsigned long mant;
537  unsigned int mant_bits, mant_off;
538  int mant_bits_left;
539  enum floatformat_byteorders order;
540  unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
541  int mant_zero;
542 
543  gdb_assert (fmt != NULL);
544  gdb_assert (fmt->totalsize
546 
547  /* An IBM long double (a two element array of double) can be classified
548  by looking at the first double. inf and nan are specified as
549  ignoring the second double. zero and subnormal will always have
550  the second double 0.0 if the long double is correctly rounded. */
551  if (fmt->split_half)
552  fmt = fmt->split_half;
553 
554  order = floatformat_normalize_byteorder (fmt, uval, newfrom);
555 
556  if (order != fmt->byteorder)
557  uval = newfrom;
558 
559  exponent = get_field (uval, order, fmt->totalsize, fmt->exp_start,
560  fmt->exp_len);
561 
562  mant_bits_left = fmt->man_len;
563  mant_off = fmt->man_start;
564 
565  mant_zero = 1;
566  while (mant_bits_left > 0)
567  {
568  mant_bits = min (mant_bits_left, 32);
569 
570  mant = get_field (uval, order, fmt->totalsize, mant_off, mant_bits);
571 
572  /* If there is an explicit integer bit, mask it off. */
573  if (mant_off == fmt->man_start
574  && fmt->intbit == floatformat_intbit_yes)
575  mant &= ~(1 << (mant_bits - 1));
576 
577  if (mant)
578  {
579  mant_zero = 0;
580  break;
581  }
582 
583  mant_off += mant_bits;
584  mant_bits_left -= mant_bits;
585  }
586 
587  /* If exp_nan is not set, assume that inf, NaN, and subnormals are not
588  supported. */
589  if (! fmt->exp_nan)
590  {
591  if (mant_zero)
592  return float_zero;
593  else
594  return float_normal;
595  }
596 
597  if (exponent == 0 && !mant_zero)
598  return float_subnormal;
599 
600  if (exponent == fmt->exp_nan)
601  {
602  if (mant_zero)
603  return float_infinite;
604  else
605  return float_nan;
606  }
607 
608  if (mant_zero)
609  return float_zero;
610 
611  return float_normal;
612 }
613 
614 /* Convert the mantissa of VAL (which is assumed to be a floating
615  point number whose format is described by FMT) into a hexadecimal
616  and store it in a static string. Return a pointer to that string. */
617 
618 const char *
619 floatformat_mantissa (const struct floatformat *fmt,
620  const bfd_byte *val)
621 {
622  unsigned char *uval = (unsigned char *) val;
623  unsigned long mant;
624  unsigned int mant_bits, mant_off;
625  int mant_bits_left;
626  static char res[50];
627  char buf[9];
628  int len;
629  enum floatformat_byteorders order;
630  unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
631 
632  gdb_assert (fmt != NULL);
633  gdb_assert (fmt->totalsize
635 
636  /* For IBM long double (a two element array of double), return the
637  mantissa of the first double. The problem with returning the
638  actual mantissa from both doubles is that there can be an
639  arbitrary number of implied 0's or 1's between the mantissas
640  of the first and second double. In any case, this function
641  is only used for dumping out nans, and a nan is specified to
642  ignore the value in the second double. */
643  if (fmt->split_half)
644  fmt = fmt->split_half;
645 
646  order = floatformat_normalize_byteorder (fmt, uval, newfrom);
647 
648  if (order != fmt->byteorder)
649  uval = newfrom;
650 
651  if (! fmt->exp_nan)
652  return 0;
653 
654  /* Make sure we have enough room to store the mantissa. */
655  gdb_assert (sizeof res > ((fmt->man_len + 7) / 8) * 2);
656 
657  mant_off = fmt->man_start;
658  mant_bits_left = fmt->man_len;
659  mant_bits = (mant_bits_left % 32) > 0 ? mant_bits_left % 32 : 32;
660 
661  mant = get_field (uval, order, fmt->totalsize, mant_off, mant_bits);
662 
663  len = xsnprintf (res, sizeof res, "%lx", mant);
664 
665  mant_off += mant_bits;
666  mant_bits_left -= mant_bits;
667 
668  while (mant_bits_left > 0)
669  {
670  mant = get_field (uval, order, fmt->totalsize, mant_off, 32);
671 
672  xsnprintf (buf, sizeof buf, "%08lx", mant);
673  gdb_assert (len + strlen (buf) <= sizeof res);
674  strcat (res, buf);
675 
676  mant_off += 32;
677  mant_bits_left -= 32;
678  }
679 
680  return res;
681 }
682 
683 
684 /* Convert TO/FROM target to the hosts DOUBLEST floating-point format.
685 
686  If the host and target formats agree, we just copy the raw data
687  into the appropriate type of variable and return, letting the host
688  increase precision as necessary. Otherwise, we call the conversion
689  routine and let it do the dirty work. */
690 
691 static const struct floatformat *host_float_format = GDB_HOST_FLOAT_FORMAT;
692 static const struct floatformat *host_double_format = GDB_HOST_DOUBLE_FORMAT;
693 static const struct floatformat *host_long_double_format
695 
696 void
697 floatformat_to_doublest (const struct floatformat *fmt,
698  const void *in, DOUBLEST *out)
699 {
700  gdb_assert (fmt != NULL);
701  if (fmt == host_float_format)
702  {
703  float val;
704 
705  memcpy (&val, in, sizeof (val));
706  *out = val;
707  }
708  else if (fmt == host_double_format)
709  {
710  double val;
711 
712  memcpy (&val, in, sizeof (val));
713  *out = val;
714  }
715  else if (fmt == host_long_double_format)
716  {
717  long double val;
718 
719  memcpy (&val, in, sizeof (val));
720  *out = val;
721  }
722  else
723  convert_floatformat_to_doublest (fmt, in, out);
724 }
725 
726 void
727 floatformat_from_doublest (const struct floatformat *fmt,
728  const DOUBLEST *in, void *out)
729 {
730  gdb_assert (fmt != NULL);
731  if (fmt == host_float_format)
732  {
733  float val = *in;
734 
735  memcpy (out, &val, sizeof (val));
736  }
737  else if (fmt == host_double_format)
738  {
739  double val = *in;
740 
741  memcpy (out, &val, sizeof (val));
742  }
743  else if (fmt == host_long_double_format)
744  {
745  long double val = *in;
746 
747  memcpy (out, &val, sizeof (val));
748  }
749  else
750  convert_doublest_to_floatformat (fmt, in, out);
751 }
752 
753 
754 /* Return a floating-point format for a floating-point variable of
755  length LEN. If no suitable floating-point format is found, an
756  error is thrown.
757 
758  We need this functionality since information about the
759  floating-point format of a type is not always available to GDB; the
760  debug information typically only tells us the size of a
761  floating-point type.
762 
763  FIXME: kettenis/2001-10-28: In many places, particularly in
764  target-dependent code, the format of floating-point types is known,
765  but not passed on by GDB. This should be fixed. */
766 
767 static const struct floatformat *
769 {
770  const struct floatformat *format;
771 
772  if (len * TARGET_CHAR_BIT == gdbarch_half_bit (gdbarch))
773  format = gdbarch_half_format (gdbarch)
774  [gdbarch_byte_order (gdbarch)];
775  else if (len * TARGET_CHAR_BIT == gdbarch_float_bit (gdbarch))
776  format = gdbarch_float_format (gdbarch)
777  [gdbarch_byte_order (gdbarch)];
778  else if (len * TARGET_CHAR_BIT == gdbarch_double_bit (gdbarch))
779  format = gdbarch_double_format (gdbarch)
780  [gdbarch_byte_order (gdbarch)];
781  else if (len * TARGET_CHAR_BIT == gdbarch_long_double_bit (gdbarch))
782  format = gdbarch_long_double_format (gdbarch)
783  [gdbarch_byte_order (gdbarch)];
784  /* On i386 the 'long double' type takes 96 bits,
785  while the real number of used bits is only 80,
786  both in processor and in memory.
787  The code below accepts the real bit size. */
788  else if ((gdbarch_long_double_format (gdbarch) != NULL)
789  && (len * TARGET_CHAR_BIT
790  == gdbarch_long_double_format (gdbarch)[0]->totalsize))
791  format = gdbarch_long_double_format (gdbarch)
792  [gdbarch_byte_order (gdbarch)];
793  else
794  format = NULL;
795  if (format == NULL)
796  error (_("Unrecognized %d-bit floating-point type."),
797  len * TARGET_CHAR_BIT);
798  return format;
799 }
800 
801 const struct floatformat *
803 {
804  struct gdbarch *gdbarch = get_type_arch (type);
805 
806  gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT);
807  if (TYPE_FLOATFORMAT (type) != NULL)
808  return TYPE_FLOATFORMAT (type)[gdbarch_byte_order (gdbarch)];
809  else
810  return floatformat_from_length (gdbarch, TYPE_LENGTH (type));
811 }
812 
813 /* Extract a floating-point number of type TYPE from a target-order
814  byte-stream at ADDR. Returns the value as type DOUBLEST. */
815 
816 DOUBLEST
817 extract_typed_floating (const void *addr, const struct type *type)
818 {
819  const struct floatformat *fmt = floatformat_from_type (type);
820  DOUBLEST retval;
821 
822  floatformat_to_doublest (fmt, addr, &retval);
823  return retval;
824 }
825 
826 /* Store VAL as a floating-point number of type TYPE to a target-order
827  byte-stream at ADDR. */
828 
829 void
830 store_typed_floating (void *addr, const struct type *type, DOUBLEST val)
831 {
832  const struct floatformat *fmt = floatformat_from_type (type);
833 
834  /* FIXME: kettenis/2001-10-28: It is debatable whether we should
835  zero out any remaining bytes in the target buffer when TYPE is
836  longer than the actual underlying floating-point format. Perhaps
837  we should store a fixed bitpattern in those remaining bytes,
838  instead of zero, or perhaps we shouldn't touch those remaining
839  bytes at all.
840 
841  NOTE: cagney/2001-10-28: With the way things currently work, it
842  isn't a good idea to leave the end bits undefined. This is
843  because GDB writes out the entire sizeof(<floating>) bits of the
844  floating-point type even though the value might only be stored
845  in, and the target processor may only refer to, the first N <
846  TYPE_LENGTH (type) bits. If the end of the buffer wasn't
847  initialized, GDB would write undefined data to the target. An
848  errant program, refering to that undefined data, would then
849  become non-deterministic.
850 
851  See also the function convert_typed_floating below. */
852  memset (addr, 0, TYPE_LENGTH (type));
853 
854  floatformat_from_doublest (fmt, &val, addr);
855 }
856 
857 /* Convert a floating-point number of type FROM_TYPE from a
858  target-order byte-stream at FROM to a floating-point number of type
859  TO_TYPE, and store it to a target-order byte-stream at TO. */
860 
861 void
862 convert_typed_floating (const void *from, const struct type *from_type,
863  void *to, const struct type *to_type)
864 {
865  const struct floatformat *from_fmt = floatformat_from_type (from_type);
866  const struct floatformat *to_fmt = floatformat_from_type (to_type);
867 
868  if (from_fmt == NULL || to_fmt == NULL)
869  {
870  /* If we don't know the floating-point format of FROM_TYPE or
871  TO_TYPE, there's not much we can do. We might make the
872  assumption that if the length of FROM_TYPE and TO_TYPE match,
873  their floating-point format would match too, but that
874  assumption might be wrong on targets that support
875  floating-point types that only differ in endianness for
876  example. So we warn instead, and zero out the target buffer. */
877  warning (_("Can't convert floating-point number to desired type."));
878  memset (to, 0, TYPE_LENGTH (to_type));
879  }
880  else if (from_fmt == to_fmt)
881  {
882  /* We're in business. The floating-point format of FROM_TYPE
883  and TO_TYPE match. However, even though the floating-point
884  format matches, the length of the type might still be
885  different. Make sure we don't overrun any buffers. See
886  comment in store_typed_floating for a discussion about
887  zeroing out remaining bytes in the target buffer. */
888  memset (to, 0, TYPE_LENGTH (to_type));
889  memcpy (to, from, min (TYPE_LENGTH (from_type), TYPE_LENGTH (to_type)));
890  }
891  else
892  {
893  /* The floating-point types don't match. The best we can do
894  (apart from simulating the target FPU) is converting to the
895  widest floating-point type supported by the host, and then
896  again to the desired type. */
897  DOUBLEST d;
898 
899  floatformat_to_doublest (from_fmt, from, &d);
900  floatformat_from_doublest (to_fmt, &d, to);
901  }
902 }
const struct floatformat ** gdbarch_double_format(struct gdbarch *gdbarch)
Definition: gdbarch.c:1641
void floatformat_from_doublest(const struct floatformat *fmt, const DOUBLEST *in, void *out)
Definition: doublest.c:727
int floatformat_is_negative(const struct floatformat *fmt, const bfd_byte *uval)
Definition: doublest.c:506
void warning(const char *fmt,...)
Definition: errors.c:26
const struct floatformat ** gdbarch_long_double_format(struct gdbarch *gdbarch)
Definition: gdbarch.c:1674
void convert_typed_floating(const void *from, const struct type *from_type, void *to, const struct type *to_type)
Definition: doublest.c:862
float_kind
Definition: doublest.h:66
#define TYPE_FLOATFORMAT(thistype)
Definition: gdbtypes.h:1320
static unsigned long get_field(const bfd_byte *data, enum floatformat_byteorders order, unsigned int total_len, unsigned int start, unsigned int len)
Definition: doublest.c:44
#define GDB_HOST_DOUBLE_FORMAT
Definition: config.h:55
#define _(String)
Definition: gdb_locale.h:40
DOUBLEST extract_typed_floating(const void *addr, const struct type *type)
Definition: doublest.c:817
void floatformat_to_doublest(const struct floatformat *fmt, const void *in, DOUBLEST *out)
Definition: doublest.c:697
static const struct floatformat * host_long_double_format
Definition: doublest.c:694
#define FLOATFORMAT_CHAR_BIT
Definition: doublest.c:35
int * from
Definition: varobj.h:282
static void put_field(unsigned char *data, enum floatformat_byteorders order, unsigned int total_len, unsigned int start, unsigned int len, unsigned long stuff_to_put)
Definition: doublest.c:277
static const struct floatformat * host_double_format
Definition: doublest.c:692
const char * floatformat_mantissa(const struct floatformat *fmt, const bfd_byte *val)
Definition: doublest.c:619
#define FLOATFORMAT_LARGEST_BYTES
Definition: doublest.c:39
double DOUBLEST
Definition: doublest.h:24
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
#define TARGET_CHAR_BIT
Definition: host-defs.h:29
static enum floatformat_byteorders floatformat_normalize_byteorder(const struct floatformat *fmt, const void *from, void *to)
Definition: doublest.c:113
static void convert_doublest_to_floatformat(const struct floatformat *fmt, const DOUBLEST *from, void *to)
Definition: doublest.c:343
Definition: gdbtypes.h:749
static const struct floatformat * floatformat_from_length(struct gdbarch *gdbarch, int len)
Definition: doublest.c:768
struct gdbarch * get_type_arch(const struct type *type)
Definition: gdbtypes.c:232
#define gdb_assert(expr)
Definition: gdb_assert.h:33
int gdbarch_double_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1624
#define min(a, b)
Definition: defs.h:106
const struct floatformat ** gdbarch_half_format(struct gdbarch *gdbarch)
Definition: gdbarch.c:1575
#define GDB_HOST_FLOAT_FORMAT
Definition: config.h:58
static const struct floatformat * host_float_format
Definition: doublest.c:691
int xsnprintf(char *str, size_t size, const char *format,...)
Definition: common-utils.c:134
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1240
static void convert_floatformat_to_doublest(const struct floatformat *fmt, const void *from, DOUBLEST *to)
Definition: doublest.c:165
enum float_kind floatformat_classify(const struct floatformat *fmt, const bfd_byte *uval)
Definition: doublest.c:532
int gdbarch_float_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1591
#define GDB_HOST_LONG_DOUBLE_FORMAT
Definition: config.h:61
int gdbarch_half_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1558
Definition: ia64-tdep.c:84
const struct floatformat ** gdbarch_float_format(struct gdbarch *gdbarch)
Definition: gdbarch.c:1608
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1237
int int * to
Definition: varobj.h:282
int gdbarch_long_double_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1657
void error(const char *fmt,...)
Definition: errors.c:38
void store_typed_floating(void *addr, const struct type *type, DOUBLEST val)
Definition: doublest.c:830
const ULONGEST const LONGEST len
Definition: target.h:309
const struct floatformat * floatformat_from_type(const struct type *type)
Definition: doublest.c:802