Include gdb_assert.h in common-defs.h
[platform/upstream/binutils.git] / gdb / doublest.c
1 /* Floating point routines for GDB, the GNU debugger.
2
3    Copyright (C) 1986-2014 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 <string.h>
30 #include "gdbtypes.h"
31 #include <math.h>               /* ldexp */
32
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
37
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
41
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.  */
44 static unsigned long
45 get_field (const bfd_byte *data, enum floatformat_byteorders order,
46            unsigned int total_len, unsigned int start, unsigned int len)
47 {
48   unsigned long result;
49   unsigned int cur_byte;
50   int cur_bitshift;
51
52   /* Caller must byte-swap words before calling this routine.  */
53   gdb_assert (order == floatformat_little || order == floatformat_big);
54
55   /* Start at the least significant part of the field.  */
56   if (order == floatformat_little)
57     {
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);
66
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;
71     }
72   else
73     {
74       cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT;
75       cur_bitshift =
76         ((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT;
77     }
78   if (cur_bitshift > -FLOATFORMAT_CHAR_BIT)
79     result = *(data + cur_byte) >> (-cur_bitshift);
80   else
81     result = 0;
82   cur_bitshift += FLOATFORMAT_CHAR_BIT;
83   if (order == floatformat_little)
84     ++cur_byte;
85   else
86     --cur_byte;
87
88   /* Move towards the most significant part of the field.  */
89   while (cur_bitshift < len)
90     {
91       result |= (unsigned long)*(data + cur_byte) << cur_bitshift;
92       cur_bitshift += FLOATFORMAT_CHAR_BIT;
93       switch (order)
94         {
95         case floatformat_little:
96           ++cur_byte;
97           break;
98         case floatformat_big:
99           --cur_byte;
100           break;
101         }
102     }
103   if (len < sizeof(result) * FLOATFORMAT_CHAR_BIT)
104     /* Mask out bits which are not part of the field.  */
105     result &= ((1UL << len) - 1);
106   return result;
107 }
108
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.  */
112
113 static enum floatformat_byteorders
114 floatformat_normalize_byteorder (const struct floatformat *fmt,
115                                  const void *from, void *to)
116 {
117   const unsigned char *swapin;
118   unsigned char *swapout;
119   int words;
120   
121   if (fmt->byteorder == floatformat_little
122       || fmt->byteorder == floatformat_big)
123     return fmt->byteorder;
124
125   words = fmt->totalsize / FLOATFORMAT_CHAR_BIT;
126   words >>= 2;
127
128   swapout = (unsigned char *)to;
129   swapin = (const unsigned char *)from;
130
131   if (fmt->byteorder == floatformat_vax)
132     {
133       while (words-- > 0)
134         {
135           *swapout++ = swapin[1];
136           *swapout++ = swapin[0];
137           *swapout++ = swapin[3];
138           *swapout++ = swapin[2];
139           swapin += 4;
140         }
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;
144     }
145   else
146     {
147       gdb_assert (fmt->byteorder == floatformat_littlebyte_bigword);
148
149       while (words-- > 0)
150         {
151           *swapout++ = swapin[3];
152           *swapout++ = swapin[2];
153           *swapout++ = swapin[1];
154           *swapout++ = swapin[0];
155           swapin += 4;
156         }
157       return floatformat_big;
158     }
159 }
160   
161 /* Convert from FMT to a DOUBLEST.
162    FROM is the address of the extended float.
163    Store the DOUBLEST in *TO.  */
164
165 static void
166 convert_floatformat_to_doublest (const struct floatformat *fmt,
167                                  const void *from,
168                                  DOUBLEST *to)
169 {
170   unsigned char *ufrom = (unsigned char *) from;
171   DOUBLEST dto;
172   long exponent;
173   unsigned long mant;
174   unsigned int mant_bits, mant_off;
175   int mant_bits_left;
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;
180   
181   gdb_assert (fmt->totalsize
182               <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);
183
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
186      through a double.  */
187   kind = floatformat_classify (fmt, from);
188   if (kind == float_infinite || kind == float_nan)
189     {
190       double dto;
191
192       floatformat_to_double (fmt->split_half ? fmt->split_half : fmt,
193                              from, &dto);
194       *to = (DOUBLEST) dto;
195       return;
196     }
197
198   order = floatformat_normalize_byteorder (fmt, ufrom, newfrom);
199
200   if (order != fmt->byteorder)
201     ufrom = newfrom;
202
203   if (fmt->split_half)
204     {
205       DOUBLEST dtop, dbot;
206
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)
211         {
212           *to = dtop;
213           return;
214         }
215       floatformat_to_doublest (fmt->split_half,
216                              ufrom + fmt->totalsize / FLOATFORMAT_CHAR_BIT / 2,
217                              &dbot);
218       *to = dtop + dbot;
219       return;
220     }
221
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.  */
227
228   mant_bits_left = fmt->man_len;
229   mant_off = fmt->man_start;
230   dto = 0.0;
231
232   special_exponent = exponent == 0 || exponent == fmt->exp_nan;
233
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;
242
243   /* Build the result algebraically.  Might go infinite, underflow, etc;
244      who cares.  */
245
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.  */
248
249   if (!special_exponent)
250     {
251       if (fmt->intbit == floatformat_intbit_no)
252         dto = ldexp (1.0, exponent);
253       else
254         exponent++;
255     }
256
257   while (mant_bits_left > 0)
258     {
259       mant_bits = min (mant_bits_left, 32);
260
261       mant = get_field (ufrom, order, fmt->totalsize, mant_off, mant_bits);
262
263       dto += ldexp ((double) mant, exponent - mant_bits);
264       exponent -= mant_bits;
265       mant_off += mant_bits;
266       mant_bits_left -= mant_bits;
267     }
268
269   /* Negate it if negative.  */
270   if (get_field (ufrom, order, fmt->totalsize, fmt->sign_start, 1))
271     dto = -dto;
272   *to = dto;
273 }
274 \f
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)
281 {
282   unsigned int cur_byte;
283   int cur_bitshift;
284
285   /* Caller must byte-swap words before calling this routine.  */
286   gdb_assert (order == floatformat_little || order == floatformat_big);
287
288   /* Start at the least significant part of the field.  */
289   if (order == floatformat_little)
290     {
291       int excess = FLOATFORMAT_CHAR_BIT - (total_len % FLOATFORMAT_CHAR_BIT);
292
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;
297     }
298   else
299     {
300       cur_byte = (start + len) / FLOATFORMAT_CHAR_BIT;
301       cur_bitshift =
302         ((start + len) % FLOATFORMAT_CHAR_BIT) - FLOATFORMAT_CHAR_BIT;
303     }
304   if (cur_bitshift > -FLOATFORMAT_CHAR_BIT)
305     {
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);
311     }
312   cur_bitshift += FLOATFORMAT_CHAR_BIT;
313   if (order == floatformat_little)
314     ++cur_byte;
315   else
316     --cur_byte;
317
318   /* Move towards the most significant part of the field.  */
319   while (cur_bitshift < len)
320     {
321       if (len - cur_bitshift < FLOATFORMAT_CHAR_BIT)
322         {
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);
327         }
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;
336     }
337 }
338
339 /* The converse: convert the DOUBLEST *FROM to an extended float and
340    store where TO points.  Neither FROM nor TO have any alignment
341    restrictions.  */
342
343 static void
344 convert_doublest_to_floatformat (const struct floatformat *fmt,
345                                  const DOUBLEST *from, void *to)
346 {
347   DOUBLEST dfrom;
348   int exponent;
349   DOUBLEST mant;
350   unsigned int mant_bits, mant_off;
351   int mant_bits_left;
352   unsigned char *uto = (unsigned char *) to;
353   enum floatformat_byteorders order = fmt->byteorder;
354   unsigned char newto[FLOATFORMAT_LARGEST_BYTES];
355
356   if (order != floatformat_little)
357     order = floatformat_big;
358
359   if (order != fmt->byteorder)
360     uto = newto;
361
362   memcpy (&dfrom, from, sizeof (dfrom));
363   memset (uto, 0, (fmt->totalsize + FLOATFORMAT_CHAR_BIT - 1) 
364                     / FLOATFORMAT_CHAR_BIT);
365
366   if (fmt->split_half)
367     {
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;
373
374       dtop = (double) dfrom;
375       /* If the rounded top half is Inf, the bottom must be 0 not NaN
376          or Inf.  */
377       if (dtop + dtop == dtop && dtop != 0.0)
378         dbot = 0.0;
379       else
380         dbot = (double) (dfrom - (DOUBLEST) dtop);
381       dtopnv = dtop;
382       dbotnv = dbot;
383       floatformat_from_doublest (fmt->split_half, &dtopnv, uto);
384       floatformat_from_doublest (fmt->split_half, &dbotnv,
385                                (uto
386                                 + fmt->totalsize / FLOATFORMAT_CHAR_BIT / 2));
387       return;
388     }
389
390   if (dfrom == 0)
391     return;                     /* Result is zero */
392   if (dfrom != dfrom)           /* Result is NaN */
393     {
394       /* From 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,
399                  fmt->man_len, 1);
400       goto finalize_byteorder;
401     }
402
403   /* If negative, set the sign bit.  */
404   if (dfrom < 0)
405     {
406       put_field (uto, order, fmt->totalsize, fmt->sign_start, 1, 1);
407       dfrom = -dfrom;
408     }
409
410   if (dfrom + dfrom == dfrom && dfrom != 0.0)   /* Result is Infinity.  */
411     {
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,
417                  fmt->man_len, 0);
418       goto finalize_byteorder;
419     }
420
421 #ifdef HAVE_LONG_DOUBLE
422   mant = frexpl (dfrom, &exponent);
423 #else
424   mant = frexp (dfrom, &exponent);
425 #endif
426
427   if (exponent + fmt->exp_bias <= 0)
428     {
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,
432                  fmt->exp_len, 0);
433       put_field (uto, order, fmt->totalsize, fmt->man_start,
434                  fmt->man_len, 0);
435       goto finalize_byteorder;
436     }
437
438   if (exponent + fmt->exp_bias >= (1 << fmt->exp_len))
439     {
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,
445                  fmt->man_len, 0);
446       goto finalize_byteorder;
447     }
448
449   put_field (uto, order, fmt->totalsize, fmt->exp_start, fmt->exp_len,
450              exponent + fmt->exp_bias - 1);
451
452   mant_bits_left = fmt->man_len;
453   mant_off = fmt->man_start;
454   while (mant_bits_left > 0)
455     {
456       unsigned long mant_long;
457
458       mant_bits = mant_bits_left < 32 ? mant_bits_left : 32;
459
460       mant *= 4294967296.0;
461       mant_long = ((unsigned long) mant) & 0xffffffffL;
462       mant -= mant_long;
463
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
467          (I think).  */
468       if (mant_bits_left == fmt->man_len
469           && fmt->intbit == floatformat_intbit_no)
470         {
471           mant_long <<= 1;
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.  */
480           if (mant_bits == 32)
481             mant_bits -= 1;
482         }
483
484       if (mant_bits < 32)
485         {
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;
489         }
490
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;
495     }
496
497  finalize_byteorder:
498   /* Do we need to byte-swap the words in the result?  */
499   if (order != fmt->byteorder)
500     floatformat_normalize_byteorder (fmt, newto, to);
501 }
502
503 /* Check if VAL (which is assumed to be a floating point number whose
504    format is described by FMT) is negative.  */
505
506 int
507 floatformat_is_negative (const struct floatformat *fmt,
508                          const bfd_byte *uval)
509 {
510   enum floatformat_byteorders order;
511   unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
512   
513   gdb_assert (fmt != NULL);
514   gdb_assert (fmt->totalsize
515               <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);
516
517   /* An IBM long double (a two element array of double) always takes the
518      sign of the first double.  */
519   if (fmt->split_half)
520     fmt = fmt->split_half;
521
522   order = floatformat_normalize_byteorder (fmt, uval, newfrom);
523
524   if (order != fmt->byteorder)
525     uval = newfrom;
526
527   return get_field (uval, order, fmt->totalsize, fmt->sign_start, 1);
528 }
529
530 /* Check if VAL is "not a number" (NaN) for FMT.  */
531
532 enum float_kind
533 floatformat_classify (const struct floatformat *fmt,
534                       const bfd_byte *uval)
535 {
536   long exponent;
537   unsigned long mant;
538   unsigned int mant_bits, mant_off;
539   int mant_bits_left;
540   enum floatformat_byteorders order;
541   unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
542   int mant_zero;
543   
544   gdb_assert (fmt != NULL);
545   gdb_assert (fmt->totalsize
546               <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);
547
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.  */
552   if (fmt->split_half)
553     fmt = fmt->split_half;
554
555   order = floatformat_normalize_byteorder (fmt, uval, newfrom);
556
557   if (order != fmt->byteorder)
558     uval = newfrom;
559
560   exponent = get_field (uval, order, fmt->totalsize, fmt->exp_start,
561                         fmt->exp_len);
562
563   mant_bits_left = fmt->man_len;
564   mant_off = fmt->man_start;
565
566   mant_zero = 1;
567   while (mant_bits_left > 0)
568     {
569       mant_bits = min (mant_bits_left, 32);
570
571       mant = get_field (uval, order, fmt->totalsize, mant_off, mant_bits);
572
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));
577
578       if (mant)
579         {
580           mant_zero = 0;
581           break;
582         }
583
584       mant_off += mant_bits;
585       mant_bits_left -= mant_bits;
586     }
587
588   /* If exp_nan is not set, assume that inf, NaN, and subnormals are not
589      supported.  */
590   if (! fmt->exp_nan)
591     {
592       if (mant_zero)
593         return float_zero;
594       else
595         return float_normal;
596     }
597
598   if (exponent == 0 && !mant_zero)
599     return float_subnormal;
600
601   if (exponent == fmt->exp_nan)
602     {
603       if (mant_zero)
604         return float_infinite;
605       else
606         return float_nan;
607     }
608
609   if (mant_zero)
610     return float_zero;
611
612   return float_normal;
613 }
614
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.  */
618
619 const char *
620 floatformat_mantissa (const struct floatformat *fmt,
621                       const bfd_byte *val)
622 {
623   unsigned char *uval = (unsigned char *) val;
624   unsigned long mant;
625   unsigned int mant_bits, mant_off;
626   int mant_bits_left;
627   static char res[50];
628   char buf[9];
629   int len;
630   enum floatformat_byteorders order;
631   unsigned char newfrom[FLOATFORMAT_LARGEST_BYTES];
632   
633   gdb_assert (fmt != NULL);
634   gdb_assert (fmt->totalsize
635               <= FLOATFORMAT_LARGEST_BYTES * FLOATFORMAT_CHAR_BIT);
636
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.  */
644   if (fmt->split_half)
645     fmt = fmt->split_half;
646
647   order = floatformat_normalize_byteorder (fmt, uval, newfrom);
648
649   if (order != fmt->byteorder)
650     uval = newfrom;
651
652   if (! fmt->exp_nan)
653     return 0;
654
655   /* Make sure we have enough room to store the mantissa.  */
656   gdb_assert (sizeof res > ((fmt->man_len + 7) / 8) * 2);
657
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;
661
662   mant = get_field (uval, order, fmt->totalsize, mant_off, mant_bits);
663
664   len = xsnprintf (res, sizeof res, "%lx", mant);
665
666   mant_off += mant_bits;
667   mant_bits_left -= mant_bits;
668
669   while (mant_bits_left > 0)
670     {
671       mant = get_field (uval, order, fmt->totalsize, mant_off, 32);
672
673       xsnprintf (buf, sizeof buf, "%08lx", mant);
674       gdb_assert (len + strlen (buf) <= sizeof res);
675       strcat (res, buf);
676
677       mant_off += 32;
678       mant_bits_left -= 32;
679     }
680
681   return res;
682 }
683
684 \f
685 /* Convert TO/FROM target to the hosts DOUBLEST floating-point format.
686
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.  */
691
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;
696
697 void
698 floatformat_to_doublest (const struct floatformat *fmt,
699                          const void *in, DOUBLEST *out)
700 {
701   gdb_assert (fmt != NULL);
702   if (fmt == host_float_format)
703     {
704       float val;
705
706       memcpy (&val, in, sizeof (val));
707       *out = val;
708     }
709   else if (fmt == host_double_format)
710     {
711       double val;
712
713       memcpy (&val, in, sizeof (val));
714       *out = val;
715     }
716   else if (fmt == host_long_double_format)
717     {
718       long double val;
719
720       memcpy (&val, in, sizeof (val));
721       *out = val;
722     }
723   else
724     convert_floatformat_to_doublest (fmt, in, out);
725 }
726
727 void
728 floatformat_from_doublest (const struct floatformat *fmt,
729                            const DOUBLEST *in, void *out)
730 {
731   gdb_assert (fmt != NULL);
732   if (fmt == host_float_format)
733     {
734       float val = *in;
735
736       memcpy (out, &val, sizeof (val));
737     }
738   else if (fmt == host_double_format)
739     {
740       double val = *in;
741
742       memcpy (out, &val, sizeof (val));
743     }
744   else if (fmt == host_long_double_format)
745     {
746       long double val = *in;
747
748       memcpy (out, &val, sizeof (val));
749     }
750   else
751     convert_doublest_to_floatformat (fmt, in, out);
752 }
753
754 \f
755 /* Return a floating-point format for a floating-point variable of
756    length LEN.  If no suitable floating-point format is found, an
757    error is thrown.
758
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
762    floating-point type.
763
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.  */
767
768 static const struct floatformat *
769 floatformat_from_length (struct gdbarch *gdbarch, int len)
770 {
771   const struct floatformat *format;
772
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)];
794   else
795     format = NULL;
796   if (format == NULL)
797     error (_("Unrecognized %d-bit floating-point type."),
798            len * TARGET_CHAR_BIT);
799   return format;
800 }
801
802 const struct floatformat *
803 floatformat_from_type (const struct type *type)
804 {
805   struct gdbarch *gdbarch = get_type_arch (type);
806
807   gdb_assert (TYPE_CODE (type) == TYPE_CODE_FLT);
808   if (TYPE_FLOATFORMAT (type) != NULL)
809     return TYPE_FLOATFORMAT (type)[gdbarch_byte_order (gdbarch)];
810   else
811     return floatformat_from_length (gdbarch, TYPE_LENGTH (type));
812 }
813
814 /* Extract a floating-point number of type TYPE from a target-order
815    byte-stream at ADDR.  Returns the value as type DOUBLEST.  */
816
817 DOUBLEST
818 extract_typed_floating (const void *addr, const struct type *type)
819 {
820   const struct floatformat *fmt = floatformat_from_type (type);
821   DOUBLEST retval;
822
823   floatformat_to_doublest (fmt, addr, &retval);
824   return retval;
825 }
826
827 /* Store VAL as a floating-point number of type TYPE to a target-order
828    byte-stream at ADDR.  */
829
830 void
831 store_typed_floating (void *addr, const struct type *type, DOUBLEST val)
832 {
833   const struct floatformat *fmt = floatformat_from_type (type);
834
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
840      bytes at all.
841
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.
851
852      See also the function convert_typed_floating below.  */
853   memset (addr, 0, TYPE_LENGTH (type));
854
855   floatformat_from_doublest (fmt, &val, addr);
856 }
857
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.  */
861
862 void
863 convert_typed_floating (const void *from, const struct type *from_type,
864                         void *to, const struct type *to_type)
865 {
866   const struct floatformat *from_fmt = floatformat_from_type (from_type);
867   const struct floatformat *to_fmt = floatformat_from_type (to_type);
868
869   if (from_fmt == NULL || to_fmt == NULL)
870     {
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));
880     }
881   else if (from_fmt == to_fmt)
882     {
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)));
891     }
892   else
893     {
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.  */
898       DOUBLEST d;
899
900       floatformat_to_doublest (from_fmt, from, &d);
901       floatformat_from_doublest (to_fmt, &d, to);
902     }
903 }