OSDN Git Service

23285892d9bc4eb919edd94595d07ba62ef8976f
[pf3gnuchains/gcc-fork.git] / gcc / dfp.c
1 /* Decimal floating point support.
2    Copyright (C) 2005, 2006, 2007 Free Software Foundation, Inc.
3
4 This file is part of GCC.
5
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
9 version.
10
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14 for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3.  If not see
18 <http://www.gnu.org/licenses/>.  */
19
20 #include "config.h"
21 #include "system.h"
22 #include "coretypes.h"
23 #include "tm.h"
24 #include "tree.h"
25 #include "toplev.h"
26 #include "real.h"
27 #include "tm_p.h"
28 #include "dfp.h"
29
30 /* The order of the following headers is important for making sure
31    decNumber structure is large enough to hold decimal128 digits.  */
32
33 #include "decimal128.h"
34 #include "decimal64.h"
35 #include "decimal32.h"
36 #include "decNumber.h"
37
38 static uint32_t
39 dfp_byte_swap (uint32_t in)
40 {
41   uint32_t out = 0;
42   unsigned char *p = (unsigned char *) &out;
43   union {
44     uint32_t i;
45     unsigned char b[4];
46   } u;
47
48   u.i = in;
49   p[0] = u.b[3];
50   p[1] = u.b[2];
51   p[2] = u.b[1];
52   p[3] = u.b[0];
53
54   return out;
55 }
56
57 /* Initialize R (a real with the decimal flag set) from DN.  Can
58    utilize status passed in via CONTEXT, if a previous operation had
59    interesting status.  */
60
61 static void
62 decimal_from_decnumber (REAL_VALUE_TYPE *r, decNumber *dn, decContext *context)
63 {
64   memset (r, 0, sizeof (REAL_VALUE_TYPE));
65
66   r->cl = rvc_normal;
67   if (decNumberIsZero (dn))
68     r->cl = rvc_zero;
69   if (decNumberIsNaN (dn))
70     r->cl = rvc_nan;
71   if (decNumberIsInfinite (dn))
72     r->cl = rvc_inf;
73   if (context->status & DEC_Overflow)
74     r->cl = rvc_inf;
75   if (decNumberIsNegative (dn))
76     r->sign = 1;
77   r->decimal = 1;
78
79   if (r->cl != rvc_normal)
80     return;
81
82   decContextDefault (context, DEC_INIT_DECIMAL128);
83   context->traps = 0;
84
85   decimal128FromNumber ((decimal128 *) r->sig, dn, context);
86 }
87
88 /* Create decimal encoded R from string S.  */
89
90 void
91 decimal_real_from_string (REAL_VALUE_TYPE *r, const char *s)
92 {
93   decNumber dn;
94   decContext set;
95   decContextDefault (&set, DEC_INIT_DECIMAL128);
96   set.traps = 0;
97
98   decNumberFromString (&dn, s, &set);
99
100   /* It would be more efficient to store directly in decNumber format,
101      but that is impractical from current data structure size.
102      Encoding as a decimal128 is much more compact.  */
103   decimal_from_decnumber (r, &dn, &set);
104 }
105
106 /* Initialize a decNumber from a REAL_VALUE_TYPE.  */
107
108 static void
109 decimal_to_decnumber (const REAL_VALUE_TYPE *r, decNumber *dn)
110 {
111   decContext set;
112   decContextDefault (&set, DEC_INIT_DECIMAL128);
113   set.traps = 0;
114
115   switch (r->cl)
116     {
117     case rvc_zero:
118       decNumberZero (dn);
119       break;
120     case rvc_inf:
121       decNumberFromString (dn, "Infinity", &set);
122       break;
123     case rvc_nan:
124       if (r->signalling)
125         decNumberFromString (dn, "snan", &set);
126       else
127         decNumberFromString (dn, "nan", &set);
128       break;
129     case rvc_normal:
130       gcc_assert (r->decimal);
131       decimal128ToNumber ((const decimal128 *) r->sig, dn);
132       break;
133     default:
134       gcc_unreachable ();
135     }
136
137   /* Fix up sign bit.  */
138   if (r->sign != decNumberIsNegative (dn))
139     dn->bits ^= DECNEG;
140 }
141
142 /* Encode a real into an IEEE 754R decimal32 type.  */
143
144 void
145 encode_decimal32 (const struct real_format *fmt ATTRIBUTE_UNUSED,
146                   long *buf, const REAL_VALUE_TYPE *r)
147 {
148   decNumber dn;
149   decimal32 d32;
150   decContext set;
151
152   decContextDefault (&set, DEC_INIT_DECIMAL128);
153   set.traps = 0;
154
155   decimal_to_decnumber (r, &dn); 
156   decimal32FromNumber (&d32, &dn, &set);
157
158   if (FLOAT_WORDS_BIG_ENDIAN)
159     buf[0] = *(uint32_t *) d32.bytes;
160   else
161     buf[0] = dfp_byte_swap (*(uint32_t *) d32.bytes);
162 }
163
164 /* Decode an IEEE 754R decimal32 type into a real.  */
165
166 void
167 decode_decimal32 (const struct real_format *fmt ATTRIBUTE_UNUSED,
168                   REAL_VALUE_TYPE *r, const long *buf)
169 {
170   decNumber dn;
171   decimal32 d32;
172   decContext set;
173
174   decContextDefault (&set, DEC_INIT_DECIMAL128);
175   set.traps = 0;
176
177   if (FLOAT_WORDS_BIG_ENDIAN)
178     *((uint32_t *) d32.bytes) = (uint32_t) buf[0];
179   else
180     *((uint32_t *) d32.bytes) = dfp_byte_swap ((uint32_t) buf[0]);
181
182   decimal32ToNumber (&d32, &dn);
183   decimal_from_decnumber (r, &dn, &set); 
184 }
185
186 /* Encode a real into an IEEE 754R decimal64 type.  */
187
188 void
189 encode_decimal64 (const struct real_format *fmt ATTRIBUTE_UNUSED,
190                   long *buf, const REAL_VALUE_TYPE *r)
191 {
192   decNumber dn;
193   decimal64 d64;
194   decContext set;
195
196   decContextDefault (&set, DEC_INIT_DECIMAL128);
197   set.traps = 0;
198
199   decimal_to_decnumber (r, &dn);
200   decimal64FromNumber (&d64, &dn, &set);
201
202   if (FLOAT_WORDS_BIG_ENDIAN)
203     {
204       buf[0] = *(uint32_t *) &d64.bytes[0];
205       buf[1] = *(uint32_t *) &d64.bytes[4];
206     }
207   else
208     {
209       buf[1] = dfp_byte_swap (*(uint32_t *) &d64.bytes[0]);
210       buf[0] = dfp_byte_swap (*(uint32_t *) &d64.bytes[4]);
211     }
212 }
213
214 /* Decode an IEEE 754R decimal64 type into a real.  */
215
216 void
217 decode_decimal64 (const struct real_format *fmt ATTRIBUTE_UNUSED,
218                   REAL_VALUE_TYPE *r, const long *buf)
219
220   decNumber dn;
221   decimal64 d64;
222   decContext set;
223
224   decContextDefault (&set, DEC_INIT_DECIMAL128);
225   set.traps = 0;
226
227   if (FLOAT_WORDS_BIG_ENDIAN)
228     {
229       *((uint32_t *) &d64.bytes[0]) = (uint32_t) buf[0];
230       *((uint32_t *) &d64.bytes[4]) = (uint32_t) buf[1];
231     }
232   else
233     {
234       *((uint32_t *) &d64.bytes[0]) = dfp_byte_swap ((uint32_t) buf[1]);
235       *((uint32_t *) &d64.bytes[4]) = dfp_byte_swap ((uint32_t) buf[0]); 
236     }
237
238   decimal64ToNumber (&d64, &dn);
239   decimal_from_decnumber (r, &dn, &set); 
240 }
241
242 /* Encode a real into an IEEE 754R decimal128 type.  */
243
244 void
245 encode_decimal128 (const struct real_format *fmt ATTRIBUTE_UNUSED,
246                    long *buf, const REAL_VALUE_TYPE *r)
247 {
248   decNumber dn;
249   decContext set;
250   decimal128 d128;
251
252   decContextDefault (&set, DEC_INIT_DECIMAL128);
253   set.traps = 0;
254
255   decimal_to_decnumber (r, &dn);
256   decimal128FromNumber (&d128, &dn, &set);
257
258   if (FLOAT_WORDS_BIG_ENDIAN)
259     {
260       buf[0] = *(uint32_t *) &d128.bytes[0];
261       buf[1] = *(uint32_t *) &d128.bytes[4];
262       buf[2] = *(uint32_t *) &d128.bytes[8];
263       buf[3] = *(uint32_t *) &d128.bytes[12];
264     }
265   else
266     {
267       buf[0] = dfp_byte_swap (*(uint32_t *) &d128.bytes[12]);
268       buf[1] = dfp_byte_swap (*(uint32_t *) &d128.bytes[8]);
269       buf[2] = dfp_byte_swap (*(uint32_t *) &d128.bytes[4]);
270       buf[3] = dfp_byte_swap (*(uint32_t *) &d128.bytes[0]);
271     }
272 }
273
274 /* Decode an IEEE 754R decimal128 type into a real.  */
275
276 void
277 decode_decimal128 (const struct real_format *fmt ATTRIBUTE_UNUSED,
278                    REAL_VALUE_TYPE *r, const long *buf)
279 {
280   decNumber dn;
281   decimal128 d128;
282   decContext set;
283
284   decContextDefault (&set, DEC_INIT_DECIMAL128);
285   set.traps = 0;
286
287   if (FLOAT_WORDS_BIG_ENDIAN)
288     {
289       *((uint32_t *) &d128.bytes[0])  = (uint32_t) buf[0];
290       *((uint32_t *) &d128.bytes[4])  = (uint32_t) buf[1];
291       *((uint32_t *) &d128.bytes[8])  = (uint32_t) buf[2];
292       *((uint32_t *) &d128.bytes[12]) = (uint32_t) buf[3];
293     }
294   else
295     {
296       *((uint32_t *) &d128.bytes[0])  = dfp_byte_swap ((uint32_t) buf[3]);
297       *((uint32_t *) &d128.bytes[4])  = dfp_byte_swap ((uint32_t) buf[2]);
298       *((uint32_t *) &d128.bytes[8])  = dfp_byte_swap ((uint32_t) buf[1]);
299       *((uint32_t *) &d128.bytes[12]) = dfp_byte_swap ((uint32_t) buf[0]);
300     }
301
302   decimal128ToNumber (&d128, &dn);
303   decimal_from_decnumber (r, &dn, &set); 
304 }
305
306 /* Helper function to convert from a binary real internal
307    representation.  */
308
309 static void
310 decimal_to_binary (REAL_VALUE_TYPE *to, const REAL_VALUE_TYPE *from,
311                    enum machine_mode mode)
312 {
313   char string[256];
314   const decimal128 *const d128 = (const decimal128 *) from->sig;
315
316   decimal128ToString (d128, string);
317   real_from_string3 (to, string, mode);
318 }
319
320
321 /* Helper function to convert from a binary real internal
322    representation.  */
323
324 static void
325 decimal_from_binary (REAL_VALUE_TYPE *to, const REAL_VALUE_TYPE *from)
326 {
327   char string[256];
328
329   /* We convert to string, then to decNumber then to decimal128.  */
330   real_to_decimal (string, from, sizeof (string), 0, 1);
331   decimal_real_from_string (to, string);
332 }
333
334 /* Helper function to real.c:do_compare() to handle decimal internal
335    representation including when one of the operands is still in the
336    binary internal representation.  */
337
338 int
339 decimal_do_compare (const REAL_VALUE_TYPE *a, const REAL_VALUE_TYPE *b,
340                     int nan_result)
341 {
342   decContext set;
343   decNumber dn, dn2, dn3;
344   REAL_VALUE_TYPE a1, b1;
345
346   /* If either operand is non-decimal, create temporary versions.  */
347   if (!a->decimal)
348     {
349       decimal_from_binary (&a1, a);
350       a = &a1;
351     }
352   if (!b->decimal)
353     {
354       decimal_from_binary (&b1, b);
355       b = &b1;
356     }
357     
358   /* Convert into decNumber form for comparison operation.  */
359   decContextDefault (&set, DEC_INIT_DECIMAL128);
360   set.traps = 0;  
361   decimal128ToNumber ((const decimal128 *) a->sig, &dn2);
362   decimal128ToNumber ((const decimal128 *) b->sig, &dn3);
363
364   /* Finally, do the comparison.  */
365   decNumberCompare (&dn, &dn2, &dn3, &set);
366
367   /* Return the comparison result.  */
368   if (decNumberIsNaN (&dn))
369     return nan_result;
370   else if (decNumberIsZero (&dn))
371     return 0;
372   else if (decNumberIsNegative (&dn))
373     return -1;
374   else 
375     return 1;
376 }
377
378 /* Helper to round_for_format, handling decimal float types.  */
379
380 void
381 decimal_round_for_format (const struct real_format *fmt, REAL_VALUE_TYPE *r)
382 {
383   decNumber dn;
384   decContext set;
385
386   /* Real encoding occurs later.  */
387   if (r->cl != rvc_normal)
388     return;
389
390   decContextDefault (&set, DEC_INIT_DECIMAL128);
391   set.traps = 0;
392   decimal128ToNumber ((decimal128 *) r->sig, &dn);
393
394   if (fmt == &decimal_quad_format)
395     {
396       /* The internal format is already in this format.  */
397       return;
398     }
399   else if (fmt == &decimal_single_format)
400     {
401       decimal32 d32;
402       decContextDefault (&set, DEC_INIT_DECIMAL32);
403       set.traps = 0;
404
405       decimal32FromNumber (&d32, &dn, &set);
406       decimal32ToNumber (&d32, &dn);
407     }
408   else if (fmt == &decimal_double_format)
409     {
410       decimal64 d64;
411       decContextDefault (&set, DEC_INIT_DECIMAL64);
412       set.traps = 0;
413
414       decimal64FromNumber (&d64, &dn, &set);
415       decimal64ToNumber (&d64, &dn);
416     }
417   else
418     gcc_unreachable ();
419
420   decimal_from_decnumber (r, &dn, &set);
421 }
422
423 /* Extend or truncate to a new mode.  Handles conversions between
424    binary and decimal types.  */
425
426 void
427 decimal_real_convert (REAL_VALUE_TYPE *r, enum machine_mode mode, 
428                       const REAL_VALUE_TYPE *a)
429 {
430   const struct real_format *fmt = REAL_MODE_FORMAT (mode);
431
432   if (a->decimal && fmt->b == 10)
433     return;
434   if (a->decimal)
435       decimal_to_binary (r, a, mode);
436   else
437       decimal_from_binary (r, a);
438 }
439
440 /* Render R_ORIG as a decimal floating point constant.  Emit DIGITS
441    significant digits in the result, bounded by BUF_SIZE.  If DIGITS
442    is 0, choose the maximum for the representation.  If
443    CROP_TRAILING_ZEROS, strip trailing zeros.  Currently, not honoring
444    DIGITS or CROP_TRAILING_ZEROS.  */
445
446 void
447 decimal_real_to_decimal (char *str, const REAL_VALUE_TYPE *r_orig,
448                          size_t buf_size,
449                          size_t digits ATTRIBUTE_UNUSED,
450                          int crop_trailing_zeros ATTRIBUTE_UNUSED)
451 {
452   const decimal128 *const d128 = (const decimal128*) r_orig->sig;
453
454   /* decimal128ToString requires space for at least 24 characters;
455      Require two more for suffix.  */
456   gcc_assert (buf_size >= 24);
457   decimal128ToString (d128, str);
458 }
459
460 static bool
461 decimal_do_add (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *op0,
462                 const REAL_VALUE_TYPE *op1, int subtract_p)
463 {
464   decNumber dn;
465   decContext set;
466   decNumber dn2, dn3;
467
468   decimal_to_decnumber (op0, &dn2);
469   decimal_to_decnumber (op1, &dn3);
470
471   decContextDefault (&set, DEC_INIT_DECIMAL128);
472   set.traps = 0;
473
474   if (subtract_p)
475     decNumberSubtract (&dn, &dn2, &dn3, &set);
476   else 
477     decNumberAdd (&dn, &dn2, &dn3, &set);
478
479   decimal_from_decnumber (r, &dn, &set);
480
481   /* Return true, if inexact.  */
482   return (set.status & DEC_Inexact);
483 }
484
485 /* Compute R = OP0 * OP1.  */
486
487 static bool
488 decimal_do_multiply (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *op0,
489                      const REAL_VALUE_TYPE *op1)
490 {
491   decContext set;
492   decNumber dn, dn2, dn3;
493
494   decimal_to_decnumber (op0, &dn2);
495   decimal_to_decnumber (op1, &dn3);
496
497   decContextDefault (&set, DEC_INIT_DECIMAL128);
498   set.traps = 0;
499
500   decNumberMultiply (&dn, &dn2, &dn3, &set);
501   decimal_from_decnumber (r, &dn, &set);
502
503   /* Return true, if inexact.  */
504   return (set.status & DEC_Inexact);
505 }
506
507 /* Compute R = OP0 / OP1.  */
508
509 static bool
510 decimal_do_divide (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *op0,
511                    const REAL_VALUE_TYPE *op1)
512 {
513   decContext set;
514   decNumber dn, dn2, dn3;
515
516   decimal_to_decnumber (op0, &dn2);
517   decimal_to_decnumber (op1, &dn3);
518
519   decContextDefault (&set, DEC_INIT_DECIMAL128);
520   set.traps = 0;
521
522   decNumberDivide (&dn, &dn2, &dn3, &set);
523   decimal_from_decnumber (r, &dn, &set);
524
525   /* Return true, if inexact.  */
526   return (set.status & DEC_Inexact);
527 }
528
529 /* Set R to A truncated to an integral value toward zero (decimal
530    floating point).  */
531
532 void
533 decimal_do_fix_trunc (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a)
534 {
535   decNumber dn, dn2;
536   decContext set;
537
538   decContextDefault (&set, DEC_INIT_DECIMAL128);
539   set.traps = 0;
540   set.round = DEC_ROUND_DOWN;
541   decimal128ToNumber ((const decimal128 *) a->sig, &dn2);
542
543   decNumberToIntegralValue (&dn, &dn2, &set);
544   decimal_from_decnumber (r, &dn, &set);
545 }
546
547 /* Render decimal float value R as an integer.  */
548
549 HOST_WIDE_INT
550 decimal_real_to_integer (const REAL_VALUE_TYPE *r)
551 {
552   decContext set;
553   decNumber dn, dn2, dn3;
554   REAL_VALUE_TYPE to;
555   char string[256];
556
557   decContextDefault (&set, DEC_INIT_DECIMAL128);
558   set.traps = 0;
559   set.round = DEC_ROUND_DOWN;
560   decimal128ToNumber ((const decimal128 *) r->sig, &dn);
561
562   decNumberToIntegralValue (&dn2, &dn, &set);
563   decNumberZero (&dn3);
564   decNumberRescale (&dn, &dn2, &dn3, &set);
565
566   /* Convert to REAL_VALUE_TYPE and call appropriate conversion
567      function.  */
568   decNumberToString (&dn, string);
569   real_from_string (&to, string);
570   return real_to_integer (&to);
571 }
572
573 /* Likewise, but to an integer pair, HI+LOW.  */
574
575 void
576 decimal_real_to_integer2 (HOST_WIDE_INT *plow, HOST_WIDE_INT *phigh,
577                           const REAL_VALUE_TYPE *r)
578 {
579   decContext set;
580   decNumber dn, dn2, dn3;
581   REAL_VALUE_TYPE to;
582   char string[256];
583
584   decContextDefault (&set, DEC_INIT_DECIMAL128);
585   set.traps = 0;
586   set.round = DEC_ROUND_DOWN;
587   decimal128ToNumber ((const decimal128 *) r->sig, &dn);
588
589   decNumberToIntegralValue (&dn2, &dn, &set);
590   decNumberZero (&dn3);
591   decNumberRescale (&dn, &dn2, &dn3, &set);
592
593   /* Conver to REAL_VALUE_TYPE and call appropriate conversion
594      function.  */
595   decNumberToString (&dn, string);
596   real_from_string (&to, string);
597   real_to_integer2 (plow, phigh, &to);
598 }
599
600 /* Perform the decimal floating point operation described by CODE.
601    For a unary operation, OP1 will be NULL.  This function returns
602    true if the result may be inexact due to loss of precision.  */
603
604 bool
605 decimal_real_arithmetic (REAL_VALUE_TYPE *r, enum tree_code code,
606                          const REAL_VALUE_TYPE *op0,
607                          const REAL_VALUE_TYPE *op1)
608 {
609   REAL_VALUE_TYPE a, b;
610
611   /* If either operand is non-decimal, create temporaries.  */
612   if (!op0->decimal)
613     {
614       decimal_from_binary (&a, op0);
615       op0 = &a;
616     }
617   if (op1 && !op1->decimal)
618     {
619       decimal_from_binary (&b, op1);
620       op1 = &b;
621     }
622
623   switch (code)
624     {
625     case PLUS_EXPR:
626       return decimal_do_add (r, op0, op1, 0);
627
628     case MINUS_EXPR:
629       return decimal_do_add (r, op0, op1, 1);
630
631     case MULT_EXPR:
632       return decimal_do_multiply (r, op0, op1);
633
634     case RDIV_EXPR:
635       return decimal_do_divide (r, op0, op1);
636
637     case MIN_EXPR:
638       if (op1->cl == rvc_nan)
639         *r = *op1;
640       else if (real_compare (UNLT_EXPR, op0, op1))
641         *r = *op0;
642       else
643         *r = *op1;
644       return false;
645
646     case MAX_EXPR:
647       if (op1->cl == rvc_nan)
648         *r = *op1;
649       else if (real_compare (LT_EXPR, op0, op1))
650         *r = *op1;
651       else
652         *r = *op0;
653       return false;
654
655     case NEGATE_EXPR:
656       {
657         *r = *op0;
658         /* Flip sign bit.  */
659         decimal128FlipSign ((decimal128 *) r->sig);
660         /* Keep sign field in sync.  */
661         r->sign ^= 1;
662       }
663       return false;
664
665     case ABS_EXPR:
666       {
667         *r = *op0;
668         /* Clear sign bit.  */
669         decimal128ClearSign ((decimal128 *) r->sig);
670         /* Keep sign field in sync.  */
671         r->sign = 0;
672       }
673       return false;
674
675     case FIX_TRUNC_EXPR:
676       decimal_do_fix_trunc (r, op0);
677       return false;
678
679     default:
680       gcc_unreachable ();
681     }
682 }
683
684 /* Fills R with the largest finite value representable in mode MODE.
685    If SIGN is nonzero, R is set to the most negative finite value.  */
686
687 void
688 decimal_real_maxval (REAL_VALUE_TYPE *r, int sign, enum machine_mode mode)
689
690   const char *max;
691
692   switch (mode)
693     {
694     case SDmode:
695       max = "9.999999E96";
696       break;
697     case DDmode:
698       max = "9.999999999999999E384";
699       break;
700     case TDmode:
701       max = "9.999999999999999999999999999999999E6144";
702       break;
703     default:
704       gcc_unreachable ();
705     }
706
707   decimal_real_from_string (r, max);
708   if (sign)
709     decimal128SetSign ((decimal128 *) r->sig, 1);
710 }