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