OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [dfp.c] - Blame information for rev 280

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.