1 /* IEEE floating point support routines, for GDB, the GNU Debugger.
2    Copyright 1991, 1994, 1999, 2000, 2003, 2005, 2006, 2010
3    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 2 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, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
20 
21 /* This is needed to pick up the NAN macro on some systems.  */
22 #define _GNU_SOURCE
23 
24 #ifdef HAVE_CONFIG_H
25 #include "config.h"
26 #endif
27 
28 #include <math.h>
29 
30 #ifdef HAVE_STRING_H
31 #include <string.h>
32 #endif
33 
34 /* On some platforms, <float.h> provides DBL_QNAN.  */
35 #ifdef STDC_HEADERS
36 #include <float.h>
37 #endif
38 
39 #include "ansidecl.h"
40 #include "libiberty.h"
41 #include "floatformat.h"
42 
43 #ifndef INFINITY
44 #ifdef HUGE_VAL
45 #define INFINITY HUGE_VAL
46 #else
47 #define INFINITY (1.0 / 0.0)
48 #endif
49 #endif
50 
51 #ifndef NAN
52 #ifdef DBL_QNAN
53 #define NAN DBL_QNAN
54 #else
55 #define NAN (0.0 / 0.0)
56 #endif
57 #endif
58 
59 static int mant_bits_set (const struct floatformat *, const unsigned char *);
60 static unsigned long get_field (const unsigned char *,
61                                 enum floatformat_byteorders,
62                                 unsigned int,
63                                 unsigned int,
64                                 unsigned int);
65 static int floatformat_always_valid (const struct floatformat *fmt,
66                                      const void *from);
67 
68 static int
floatformat_always_valid(const struct floatformat * fmt ATTRIBUTE_UNUSED,const void * from ATTRIBUTE_UNUSED)69 floatformat_always_valid (const struct floatformat *fmt ATTRIBUTE_UNUSED,
70                           const void *from ATTRIBUTE_UNUSED)
71 {
72   return 1;
73 }
74 
75 /* The odds that CHAR_BIT will be anything but 8 are low enough that I'm not
76    going to bother with trying to muck around with whether it is defined in
77    a system header, what we do if not, etc.  */
78 #define FLOATFORMAT_CHAR_BIT 8
79 
80 /* floatformats for IEEE half, single and double, big and little endian.  */
81 const struct floatformat floatformat_ieee_half_big =
82 {
83   floatformat_big, 16, 0, 1, 5, 15, 31, 6, 10,
84   floatformat_intbit_no,
85   "floatformat_ieee_half_big",
86   floatformat_always_valid,
87   NULL
88 };
89 const struct floatformat floatformat_ieee_half_little =
90 {
91   floatformat_little, 16, 0, 1, 5, 15, 31, 6, 10,
92   floatformat_intbit_no,
93   "floatformat_ieee_half_little",
94   floatformat_always_valid,
95   NULL
96 };
97 const struct floatformat floatformat_ieee_single_big =
98 {
99   floatformat_big, 32, 0, 1, 8, 127, 255, 9, 23,
100   floatformat_intbit_no,
101   "floatformat_ieee_single_big",
102   floatformat_always_valid,
103   NULL
104 };
105 const struct floatformat floatformat_ieee_single_little =
106 {
107   floatformat_little, 32, 0, 1, 8, 127, 255, 9, 23,
108   floatformat_intbit_no,
109   "floatformat_ieee_single_little",
110   floatformat_always_valid,
111   NULL
112 };
113 const struct floatformat floatformat_ieee_double_big =
114 {
115   floatformat_big, 64, 0, 1, 11, 1023, 2047, 12, 52,
116   floatformat_intbit_no,
117   "floatformat_ieee_double_big",
118   floatformat_always_valid,
119   NULL
120 };
121 const struct floatformat floatformat_ieee_double_little =
122 {
123   floatformat_little, 64, 0, 1, 11, 1023, 2047, 12, 52,
124   floatformat_intbit_no,
125   "floatformat_ieee_double_little",
126   floatformat_always_valid,
127   NULL
128 };
129 
130 /* floatformat for IEEE double, little endian byte order, with big endian word
131    ordering, as on the ARM.  */
132 
133 const struct floatformat floatformat_ieee_double_littlebyte_bigword =
134 {
135   floatformat_littlebyte_bigword, 64, 0, 1, 11, 1023, 2047, 12, 52,
136   floatformat_intbit_no,
137   "floatformat_ieee_double_littlebyte_bigword",
138   floatformat_always_valid,
139   NULL
140 };
141 
142 /* floatformat for VAX.  Not quite IEEE, but close enough.  */
143 
144 const struct floatformat floatformat_vax_f =
145 {
146   floatformat_vax, 32, 0, 1, 8, 129, 0, 9, 23,
147   floatformat_intbit_no,
148   "floatformat_vax_f",
149   floatformat_always_valid,
150   NULL
151 };
152 const struct floatformat floatformat_vax_d =
153 {
154   floatformat_vax, 64, 0, 1, 8, 129, 0, 9, 55,
155   floatformat_intbit_no,
156   "floatformat_vax_d",
157   floatformat_always_valid,
158   NULL
159 };
160 const struct floatformat floatformat_vax_g =
161 {
162   floatformat_vax, 64, 0, 1, 11, 1025, 0, 12, 52,
163   floatformat_intbit_no,
164   "floatformat_vax_g",
165   floatformat_always_valid,
166   NULL
167 };
168 
169 static int floatformat_i387_ext_is_valid (const struct floatformat *fmt,
170 					  const void *from);
171 
172 static int
floatformat_i387_ext_is_valid(const struct floatformat * fmt,const void * from)173 floatformat_i387_ext_is_valid (const struct floatformat *fmt, const void *from)
174 {
175   /* In the i387 double-extended format, if the exponent is all ones,
176      then the integer bit must be set.  If the exponent is neither 0
177      nor ~0, the intbit must also be set.  Only if the exponent is
178      zero can it be zero, and then it must be zero.  */
179   unsigned long exponent, int_bit;
180   const unsigned char *ufrom = (const unsigned char *) from;
181 
182   exponent = get_field (ufrom, fmt->byteorder, fmt->totalsize,
183 			fmt->exp_start, fmt->exp_len);
184   int_bit = get_field (ufrom, fmt->byteorder, fmt->totalsize,
185 		       fmt->man_start, 1);
186 
187   if ((exponent == 0) != (int_bit == 0))
188     return 0;
189   else
190     return 1;
191 }
192 
193 const struct floatformat floatformat_i387_ext =
194 {
195   floatformat_little, 80, 0, 1, 15, 0x3fff, 0x7fff, 16, 64,
196   floatformat_intbit_yes,
197   "floatformat_i387_ext",
198   floatformat_i387_ext_is_valid,
199   NULL
200 };
201 const struct floatformat floatformat_m68881_ext =
202 {
203   /* Note that the bits from 16 to 31 are unused.  */
204   floatformat_big, 96, 0, 1, 15, 0x3fff, 0x7fff, 32, 64,
205   floatformat_intbit_yes,
206   "floatformat_m68881_ext",
207   floatformat_always_valid,
208   NULL
209 };
210 const struct floatformat floatformat_i960_ext =
211 {
212   /* Note that the bits from 0 to 15 are unused.  */
213   floatformat_little, 96, 16, 17, 15, 0x3fff, 0x7fff, 32, 64,
214   floatformat_intbit_yes,
215   "floatformat_i960_ext",
216   floatformat_always_valid,
217   NULL
218 };
219 const struct floatformat floatformat_m88110_ext =
220 {
221   floatformat_big, 80, 0, 1, 15, 0x3fff, 0x7fff, 16, 64,
222   floatformat_intbit_yes,
223   "floatformat_m88110_ext",
224   floatformat_always_valid,
225   NULL
226 };
227 const struct floatformat floatformat_m88110_harris_ext =
228 {
229   /* Harris uses raw format 128 bytes long, but the number is just an ieee
230      double, and the last 64 bits are wasted. */
231   floatformat_big,128, 0, 1, 11,  0x3ff,  0x7ff, 12, 52,
232   floatformat_intbit_no,
233   "floatformat_m88110_ext_harris",
234   floatformat_always_valid,
235   NULL
236 };
237 const struct floatformat floatformat_arm_ext_big =
238 {
239   /* Bits 1 to 16 are unused.  */
240   floatformat_big, 96, 0, 17, 15, 0x3fff, 0x7fff, 32, 64,
241   floatformat_intbit_yes,
242   "floatformat_arm_ext_big",
243   floatformat_always_valid,
244   NULL
245 };
246 const struct floatformat floatformat_arm_ext_littlebyte_bigword =
247 {
248   /* Bits 1 to 16 are unused.  */
249   floatformat_littlebyte_bigword, 96, 0, 17, 15, 0x3fff, 0x7fff, 32, 64,
250   floatformat_intbit_yes,
251   "floatformat_arm_ext_littlebyte_bigword",
252   floatformat_always_valid,
253   NULL
254 };
255 const struct floatformat floatformat_ia64_spill_big =
256 {
257   floatformat_big, 128, 0, 1, 17, 65535, 0x1ffff, 18, 64,
258   floatformat_intbit_yes,
259   "floatformat_ia64_spill_big",
260   floatformat_always_valid,
261   NULL
262 };
263 const struct floatformat floatformat_ia64_spill_little =
264 {
265   floatformat_little, 128, 0, 1, 17, 65535, 0x1ffff, 18, 64,
266   floatformat_intbit_yes,
267   "floatformat_ia64_spill_little",
268   floatformat_always_valid,
269   NULL
270 };
271 const struct floatformat floatformat_ia64_quad_big =
272 {
273   floatformat_big, 128, 0, 1, 15, 16383, 0x7fff, 16, 112,
274   floatformat_intbit_no,
275   "floatformat_ia64_quad_big",
276   floatformat_always_valid,
277   NULL
278 };
279 const struct floatformat floatformat_ia64_quad_little =
280 {
281   floatformat_little, 128, 0, 1, 15, 16383, 0x7fff, 16, 112,
282   floatformat_intbit_no,
283   "floatformat_ia64_quad_little",
284   floatformat_always_valid,
285   NULL
286 };
287 
288 static int
floatformat_ibm_long_double_is_valid(const struct floatformat * fmt,const void * from)289 floatformat_ibm_long_double_is_valid (const struct floatformat *fmt,
290 				      const void *from)
291 {
292   const unsigned char *ufrom = (const unsigned char *) from;
293   const struct floatformat *hfmt = fmt->split_half;
294   long top_exp, bot_exp;
295   int top_nan = 0;
296 
297   top_exp = get_field (ufrom, hfmt->byteorder, hfmt->totalsize,
298 		       hfmt->exp_start, hfmt->exp_len);
299   bot_exp = get_field (ufrom + 8, hfmt->byteorder, hfmt->totalsize,
300 		       hfmt->exp_start, hfmt->exp_len);
301 
302   if ((unsigned long) top_exp == hfmt->exp_nan)
303     top_nan = mant_bits_set (hfmt, ufrom);
304 
305   /* A NaN is valid with any low part.  */
306   if (top_nan)
307     return 1;
308 
309   /* An infinity, zero or denormal requires low part 0 (positive or
310      negative).  */
311   if ((unsigned long) top_exp == hfmt->exp_nan || top_exp == 0)
312     {
313       if (bot_exp != 0)
314 	return 0;
315 
316       return !mant_bits_set (hfmt, ufrom + 8);
317     }
318 
319   /* The top part is now a finite normal value.  The long double value
320      is the sum of the two parts, and the top part must equal the
321      result of rounding the long double value to nearest double.  Thus
322      the bottom part must be <= 0.5ulp of the top part in absolute
323      value, and if it is < 0.5ulp then the long double is definitely
324      valid.  */
325   if (bot_exp < top_exp - 53)
326     return 1;
327   if (bot_exp > top_exp - 53 && bot_exp != 0)
328     return 0;
329   if (bot_exp == 0)
330     {
331       /* The bottom part is 0 or denormal.  Determine which, and if
332 	 denormal the first two set bits.  */
333       int first_bit = -1, second_bit = -1, cur_bit;
334       for (cur_bit = 0; (unsigned int) cur_bit < hfmt->man_len; cur_bit++)
335 	if (get_field (ufrom + 8, hfmt->byteorder, hfmt->totalsize,
336 		       hfmt->man_start + cur_bit, 1))
337 	  {
338 	    if (first_bit == -1)
339 	      first_bit = cur_bit;
340 	    else
341 	      {
342 		second_bit = cur_bit;
343 		break;
344 	      }
345 	  }
346       /* Bottom part 0 is OK.  */
347       if (first_bit == -1)
348 	return 1;
349       /* The real exponent of the bottom part is -first_bit.  */
350       if (-first_bit < top_exp - 53)
351 	return 1;
352       if (-first_bit > top_exp - 53)
353 	return 0;
354       /* The bottom part is at least 0.5ulp of the top part.  For this
355 	 to be OK, the bottom part must be exactly 0.5ulp (i.e. no
356 	 more bits set) and the top part must have last bit 0.  */
357       if (second_bit != -1)
358 	return 0;
359       return !get_field (ufrom, hfmt->byteorder, hfmt->totalsize,
360 			 hfmt->man_start + hfmt->man_len - 1, 1);
361     }
362   else
363     {
364       /* The bottom part is at least 0.5ulp of the top part.  For this
365 	 to be OK, it must be exactly 0.5ulp (i.e. no explicit bits
366 	 set) and the top part must have last bit 0.  */
367       if (get_field (ufrom, hfmt->byteorder, hfmt->totalsize,
368 		     hfmt->man_start + hfmt->man_len - 1, 1))
369 	return 0;
370       return !mant_bits_set (hfmt, ufrom + 8);
371     }
372 }
373 
374 const struct floatformat floatformat_ibm_long_double =
375 {
376   floatformat_big, 128, 0, 1, 11, 1023, 2047, 12, 52,
377   floatformat_intbit_no,
378   "floatformat_ibm_long_double",
379   floatformat_ibm_long_double_is_valid,
380   &floatformat_ieee_double_big
381 };
382 
383 
384 #ifndef min
385 #define min(a, b) ((a) < (b) ? (a) : (b))
386 #endif
387 
388 /* Return 1 if any bits are explicitly set in the mantissa of UFROM,
389    format FMT, 0 otherwise.  */
390 static int
mant_bits_set(const struct floatformat * fmt,const unsigned char * ufrom)391 mant_bits_set (const struct floatformat *fmt, const unsigned char *ufrom)
392 {
393   unsigned int mant_bits, mant_off;
394   int mant_bits_left;
395 
396   mant_off = fmt->man_start;
397   mant_bits_left = fmt->man_len;
398   while (mant_bits_left > 0)
399     {
400       mant_bits = min (mant_bits_left, 32);
401 
402       if (get_field (ufrom, fmt->byteorder, fmt->totalsize,
403 		     mant_off, mant_bits) != 0)
404 	return 1;
405 
406       mant_off += mant_bits;
407       mant_bits_left -= mant_bits;
408     }
409   return 0;
410 }
411 
412 /* Extract a field which starts at START and is LEN bits long.  DATA and
413    TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER.  */
414 static unsigned long
get_field(const unsigned char * data,enum floatformat_byteorders order,unsigned int total_len,unsigned int start,unsigned int len)415 get_field (const unsigned char *data, enum floatformat_byteorders order,
416            unsigned int total_len, unsigned int start, unsigned int len)
417 {
418   unsigned long result = 0;
419   unsigned int cur_byte;
420   int lo_bit, hi_bit, cur_bitshift = 0;
421   int nextbyte = (order == floatformat_little) ? 1 : -1;
422 
423   /* Start is in big-endian bit order!  Fix that first.  */
424   start = total_len - (start + len);
425 
426   /* Start at the least significant part of the field.  */
427   if (order == floatformat_little)
428     cur_byte = start / FLOATFORMAT_CHAR_BIT;
429   else
430     cur_byte = (total_len - start - 1) / FLOATFORMAT_CHAR_BIT;
431 
432   lo_bit = start % FLOATFORMAT_CHAR_BIT;
433   hi_bit = min (lo_bit + len, FLOATFORMAT_CHAR_BIT);
434 
435   do
436     {
437       unsigned int shifted = *(data + cur_byte) >> lo_bit;
438       unsigned int bits = hi_bit - lo_bit;
439       unsigned int mask = (1 << bits) - 1;
440       result |= (shifted & mask) << cur_bitshift;
441       len -= bits;
442       cur_bitshift += bits;
443       cur_byte += nextbyte;
444       lo_bit = 0;
445       hi_bit = min (len, FLOATFORMAT_CHAR_BIT);
446     }
447   while (len != 0);
448 
449   return result;
450 }
451 
452 /* Convert from FMT to a double.
453    FROM is the address of the extended float.
454    Store the double in *TO.  */
455 
456 void
floatformat_to_double(const struct floatformat * fmt,const void * from,double * to)457 floatformat_to_double (const struct floatformat *fmt,
458                        const void *from, double *to)
459 {
460   const unsigned char *ufrom = (const unsigned char *) from;
461   double dto;
462   long exponent;
463   unsigned long mant;
464   unsigned int mant_bits, mant_off;
465   int mant_bits_left;
466   int special_exponent;		/* It's a NaN, denorm or zero */
467 
468   /* Split values are not handled specially, since the top half has
469      the correctly rounded double value (in the only supported case of
470      split values).  */
471 
472   exponent = get_field (ufrom, fmt->byteorder, fmt->totalsize,
473 			fmt->exp_start, fmt->exp_len);
474 
475   /* If the exponent indicates a NaN, we don't have information to
476      decide what to do.  So we handle it like IEEE, except that we
477      don't try to preserve the type of NaN.  FIXME.  */
478   if ((unsigned long) exponent == fmt->exp_nan)
479     {
480       int nan = mant_bits_set (fmt, ufrom);
481 
482       /* On certain systems (such as GNU/Linux), the use of the
483 	 INFINITY macro below may generate a warning that can not be
484 	 silenced due to a bug in GCC (PR preprocessor/11931).  The
485 	 preprocessor fails to recognise the __extension__ keyword in
486 	 conjunction with the GNU/C99 extension for hexadecimal
487 	 floating point constants and will issue a warning when
488 	 compiling with -pedantic.  */
489       if (nan)
490 	dto = NAN;
491       else
492 	dto = INFINITY;
493 
494       if (get_field (ufrom, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1))
495 	dto = -dto;
496 
497       *to = dto;
498 
499       return;
500     }
501 
502   mant_bits_left = fmt->man_len;
503   mant_off = fmt->man_start;
504   dto = 0.0;
505 
506   special_exponent = exponent == 0 || (unsigned long) exponent == fmt->exp_nan;
507 
508   /* Don't bias zero's, denorms or NaNs.  */
509   if (!special_exponent)
510     exponent -= fmt->exp_bias;
511 
512   /* Build the result algebraically.  Might go infinite, underflow, etc;
513      who cares. */
514 
515   /* If this format uses a hidden bit, explicitly add it in now.  Otherwise,
516      increment the exponent by one to account for the integer bit.  */
517 
518   if (!special_exponent)
519     {
520       if (fmt->intbit == floatformat_intbit_no)
521 	dto = ldexp (1.0, exponent);
522       else
523 	exponent++;
524     }
525 
526   while (mant_bits_left > 0)
527     {
528       mant_bits = min (mant_bits_left, 32);
529 
530       mant = get_field (ufrom, fmt->byteorder, fmt->totalsize,
531 			 mant_off, mant_bits);
532 
533       /* Handle denormalized numbers.  FIXME: What should we do for
534 	 non-IEEE formats?  */
535       if (special_exponent && exponent == 0 && mant != 0)
536 	dto += ldexp ((double)mant,
537 		      (- fmt->exp_bias
538 		       - mant_bits
539 		       - (mant_off - fmt->man_start)
540 		       + 1));
541       else
542 	dto += ldexp ((double)mant, exponent - mant_bits);
543       if (exponent != 0)
544 	exponent -= mant_bits;
545       mant_off += mant_bits;
546       mant_bits_left -= mant_bits;
547     }
548 
549   /* Negate it if negative.  */
550   if (get_field (ufrom, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1))
551     dto = -dto;
552   *to = dto;
553 }
554 
555 static void put_field (unsigned char *, enum floatformat_byteorders,
556                        unsigned int,
557                        unsigned int,
558                        unsigned int,
559                        unsigned long);
560 
561 /* Set a field which starts at START and is LEN bits long.  DATA and
562    TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER.  */
563 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)564 put_field (unsigned char *data, enum floatformat_byteorders order,
565            unsigned int total_len, unsigned int start, unsigned int len,
566            unsigned long stuff_to_put)
567 {
568   unsigned int cur_byte;
569   int lo_bit, hi_bit;
570   int nextbyte = (order == floatformat_little) ? 1 : -1;
571 
572   /* Start is in big-endian bit order!  Fix that first.  */
573   start = total_len - (start + len);
574 
575   /* Start at the least significant part of the field.  */
576   if (order == floatformat_little)
577     cur_byte = start / FLOATFORMAT_CHAR_BIT;
578   else
579     cur_byte = (total_len - start - 1) / FLOATFORMAT_CHAR_BIT;
580 
581   lo_bit = start % FLOATFORMAT_CHAR_BIT;
582   hi_bit = min (lo_bit + len, FLOATFORMAT_CHAR_BIT);
583 
584   do
585     {
586       unsigned char *byte_ptr = data + cur_byte;
587       unsigned int bits = hi_bit - lo_bit;
588       unsigned int mask = ((1 << bits) - 1) << lo_bit;
589       *byte_ptr = (*byte_ptr & ~mask) | ((stuff_to_put << lo_bit) & mask);
590       stuff_to_put >>= bits;
591       len -= bits;
592       cur_byte += nextbyte;
593       lo_bit = 0;
594       hi_bit = min (len, FLOATFORMAT_CHAR_BIT);
595     }
596   while (len != 0);
597 }
598 
599 /* The converse: convert the double *FROM to an extended float
600    and store where TO points.  Neither FROM nor TO have any alignment
601    restrictions.  */
602 
603 void
floatformat_from_double(const struct floatformat * fmt,const double * from,void * to)604 floatformat_from_double (const struct floatformat *fmt,
605                          const double *from, void *to)
606 {
607   double dfrom;
608   int exponent;
609   double mant;
610   unsigned int mant_bits, mant_off;
611   int mant_bits_left;
612   unsigned char *uto = (unsigned char *) to;
613 
614   dfrom = *from;
615   memset (uto, 0, fmt->totalsize / FLOATFORMAT_CHAR_BIT);
616 
617   /* Split values are not handled specially, since a bottom half of
618      zero is correct for any value representable as double (in the
619      only supported case of split values).  */
620 
621   /* If negative, set the sign bit.  */
622   if (dfrom < 0)
623     {
624       put_field (uto, fmt->byteorder, fmt->totalsize, fmt->sign_start, 1, 1);
625       dfrom = -dfrom;
626     }
627 
628   if (dfrom == 0)
629     {
630       /* 0.0.  */
631       return;
632     }
633 
634   if (dfrom != dfrom)
635     {
636       /* NaN.  */
637       put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
638 		 fmt->exp_len, fmt->exp_nan);
639       /* Be sure it's not infinity, but NaN value is irrelevant.  */
640       put_field (uto, fmt->byteorder, fmt->totalsize, fmt->man_start,
641 		 32, 1);
642       return;
643     }
644 
645   if (dfrom + dfrom == dfrom)
646     {
647       /* This can only happen for an infinite value (or zero, which we
648 	 already handled above).  */
649       put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
650 		 fmt->exp_len, fmt->exp_nan);
651       return;
652     }
653 
654   mant = frexp (dfrom, &exponent);
655   if (exponent + fmt->exp_bias - 1 > 0)
656     put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
657 	       fmt->exp_len, exponent + fmt->exp_bias - 1);
658   else
659     {
660       /* Handle a denormalized number.  FIXME: What should we do for
661 	 non-IEEE formats?  */
662       put_field (uto, fmt->byteorder, fmt->totalsize, fmt->exp_start,
663 		 fmt->exp_len, 0);
664       mant = ldexp (mant, exponent + fmt->exp_bias - 1);
665     }
666 
667   mant_bits_left = fmt->man_len;
668   mant_off = fmt->man_start;
669   while (mant_bits_left > 0)
670     {
671       unsigned long mant_long;
672       mant_bits = mant_bits_left < 32 ? mant_bits_left : 32;
673 
674       mant *= 4294967296.0;
675       mant_long = (unsigned long)mant;
676       mant -= mant_long;
677 
678       /* If the integer bit is implicit, and we are not creating a
679 	 denormalized number, then we need to discard it.  */
680       if ((unsigned int) mant_bits_left == fmt->man_len
681 	  && fmt->intbit == floatformat_intbit_no
682 	  && exponent + fmt->exp_bias - 1 > 0)
683 	{
684 	  mant_long &= 0x7fffffff;
685 	  mant_bits -= 1;
686 	}
687       else if (mant_bits < 32)
688 	{
689 	  /* The bits we want are in the most significant MANT_BITS bits of
690 	     mant_long.  Move them to the least significant.  */
691 	  mant_long >>= 32 - mant_bits;
692 	}
693 
694       put_field (uto, fmt->byteorder, fmt->totalsize,
695 		 mant_off, mant_bits, mant_long);
696       mant_off += mant_bits;
697       mant_bits_left -= mant_bits;
698     }
699 }
700 
701 /* Return non-zero iff the data at FROM is a valid number in format FMT.  */
702 
703 int
floatformat_is_valid(const struct floatformat * fmt,const void * from)704 floatformat_is_valid (const struct floatformat *fmt, const void *from)
705 {
706   return fmt->is_valid (fmt, from);
707 }
708 
709 
710 #ifdef IEEE_DEBUG
711 
712 #include <stdio.h>
713 
714 /* This is to be run on a host which uses IEEE floating point.  */
715 
716 void
ieee_test(double n)717 ieee_test (double n)
718 {
719   double result;
720 
721   floatformat_to_double (&floatformat_ieee_double_little, &n, &result);
722   if ((n != result && (! isnan (n) || ! isnan (result)))
723       || (n < 0 && result >= 0)
724       || (n >= 0 && result < 0))
725     printf ("Differ(to): %.20g -> %.20g\n", n, result);
726 
727   floatformat_from_double (&floatformat_ieee_double_little, &n, &result);
728   if ((n != result && (! isnan (n) || ! isnan (result)))
729       || (n < 0 && result >= 0)
730       || (n >= 0 && result < 0))
731     printf ("Differ(from): %.20g -> %.20g\n", n, result);
732 
733 #if 0
734   {
735     char exten[16];
736 
737     floatformat_from_double (&floatformat_m68881_ext, &n, exten);
738     floatformat_to_double (&floatformat_m68881_ext, exten, &result);
739     if (n != result)
740       printf ("Differ(to+from): %.20g -> %.20g\n", n, result);
741   }
742 #endif
743 
744 #if IEEE_DEBUG > 1
745   /* This is to be run on a host which uses 68881 format.  */
746   {
747     long double ex = *(long double *)exten;
748     if (ex != n)
749       printf ("Differ(from vs. extended): %.20g\n", n);
750   }
751 #endif
752 }
753 
754 int
main(void)755 main (void)
756 {
757   ieee_test (0.0);
758   ieee_test (0.5);
759   ieee_test (256.0);
760   ieee_test (0.12345);
761   ieee_test (234235.78907234);
762   ieee_test (-512.0);
763   ieee_test (-0.004321);
764   ieee_test (1.2E-70);
765   ieee_test (1.2E-316);
766   ieee_test (4.9406564584124654E-324);
767   ieee_test (- 4.9406564584124654E-324);
768   ieee_test (- 0.0);
769   ieee_test (- INFINITY);
770   ieee_test (- NAN);
771   ieee_test (INFINITY);
772   ieee_test (NAN);
773   return 0;
774 }
775 #endif
776