Mercurial > hg > CbC > CbC_gcc

comparison gcc/dfp.c @ 0:a06113de4d67

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