URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [dfp.c] - Blame information for rev 801

Go to most recent revision | Details | Compare with Previous | View Log


/* Decimal floating point support.
   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
   Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.
 
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.  */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "tree.h"
#include "tm_p.h"
#include "dfp.h"
 
/* The order of the following headers is important for making sure
   decNumber structure is large enough to hold decimal128 digits.  */
 
#include "decimal128.h"
#include "decimal128Local.h"
#include "decimal64.h"
#include "decimal32.h"
#include "decNumber.h"
 
#ifndef WORDS_BIGENDIAN
#define WORDS_BIGENDIAN 0
#endif
 
/* Initialize R (a real with the decimal flag set) from DN.  Can
   utilize status passed in via CONTEXT, if a previous operation had
   interesting status.  */
 
static void
decimal_from_decnumber (REAL_VALUE_TYPE *r, decNumber *dn, decContext *context)
{
  memset (r, 0, sizeof (REAL_VALUE_TYPE));
 
  r->cl = rvc_normal;
  if (decNumberIsNaN (dn))
    r->cl = rvc_nan;
  if (decNumberIsInfinite (dn))
    r->cl = rvc_inf;
  if (context->status & DEC_Overflow)
    r->cl = rvc_inf;
  if (decNumberIsNegative (dn))
    r->sign = 1;
  r->decimal = 1;
 
  if (r->cl != rvc_normal)
    return;
 
  decContextDefault (context, DEC_INIT_DECIMAL128);
  context->traps = 0;
 
  decimal128FromNumber ((decimal128 *) r->sig, dn, context);
}
 
/* Create decimal encoded R from string S.  */
 
void
decimal_real_from_string (REAL_VALUE_TYPE *r, const char *s)
{
  decNumber dn;
  decContext set;
  decContextDefault (&set, DEC_INIT_DECIMAL128);
  set.traps = 0;
 
  decNumberFromString (&dn, s, &set);
 
  /* It would be more efficient to store directly in decNumber format,
     but that is impractical from current data structure size.
     Encoding as a decimal128 is much more compact.  */
  decimal_from_decnumber (r, &dn, &set);
}
 
/* Initialize a decNumber from a REAL_VALUE_TYPE.  */
 
static void
decimal_to_decnumber (const REAL_VALUE_TYPE *r, decNumber *dn)
{
  decContext set;
  decContextDefault (&set, DEC_INIT_DECIMAL128);
  set.traps = 0;
 
  switch (r->cl)
    {
    case rvc_zero:
      decNumberZero (dn);
      break;
    case rvc_inf:
      decNumberFromString (dn, "Infinity", &set);
      break;
    case rvc_nan:
      if (r->signalling)
        decNumberFromString (dn, "snan", &set);
      else
        decNumberFromString (dn, "nan", &set);
      break;
    case rvc_normal:
      if (!r->decimal)
        {
          /* dconst{1,2,m1,half} are used in various places in
             the middle-end and optimizers, allow them here
             as an exception by converting them to decimal.  */
          if (memcmp (r, &dconst1, sizeof (*r)) == 0)
            {
              decNumberFromString (dn, "1", &set);
              break;
            }
          if (memcmp (r, &dconst2, sizeof (*r)) == 0)
            {
              decNumberFromString (dn, "2", &set);
              break;
            }
          if (memcmp (r, &dconstm1, sizeof (*r)) == 0)
            {
              decNumberFromString (dn, "-1", &set);
              break;
            }
          if (memcmp (r, &dconsthalf, sizeof (*r)) == 0)
            {
              decNumberFromString (dn, "0.5", &set);
              break;
            }
          gcc_unreachable ();
        }
      decimal128ToNumber ((const decimal128 *) r->sig, dn);
      break;
    default:
      gcc_unreachable ();
    }
 
  /* Fix up sign bit.  */
  if (r->sign != decNumberIsNegative (dn))
    dn->bits ^= DECNEG;
}
 
/* Encode a real into an IEEE 754 decimal32 type.  */
 
void
encode_decimal32 (const struct real_format *fmt ATTRIBUTE_UNUSED,
                  long *buf, const REAL_VALUE_TYPE *r)
{
  decNumber dn;
  decimal32 d32;
  decContext set;
  int32_t image;
 
  decContextDefault (&set, DEC_INIT_DECIMAL128);
  set.traps = 0;
 
  decimal_to_decnumber (r, &dn);
  decimal32FromNumber (&d32, &dn, &set);
 
  memcpy (&image, d32.bytes, sizeof (int32_t));
  buf[0] = image;
}
 
/* Decode an IEEE 754 decimal32 type into a real.  */
 
void
decode_decimal32 (const struct real_format *fmt ATTRIBUTE_UNUSED,
                  REAL_VALUE_TYPE *r, const long *buf)
{
  decNumber dn;
  decimal32 d32;
  decContext set;
  int32_t image;
 
  decContextDefault (&set, DEC_INIT_DECIMAL128);
  set.traps = 0;
 
  image = buf[0];
  memcpy (&d32.bytes, &image, sizeof (int32_t));
 
  decimal32ToNumber (&d32, &dn);
  decimal_from_decnumber (r, &dn, &set);
}
 
/* Encode a real into an IEEE 754 decimal64 type.  */
 
void
encode_decimal64 (const struct real_format *fmt ATTRIBUTE_UNUSED,
                  long *buf, const REAL_VALUE_TYPE *r)
{
  decNumber dn;
  decimal64 d64;
  decContext set;
  int32_t image;
 
  decContextDefault (&set, DEC_INIT_DECIMAL128);
  set.traps = 0;
 
  decimal_to_decnumber (r, &dn);
  decimal64FromNumber (&d64, &dn, &set);
 
  if (WORDS_BIGENDIAN == FLOAT_WORDS_BIG_ENDIAN)
    {
      memcpy (&image, &d64.bytes[0], sizeof (int32_t));
      buf[0] = image;
      memcpy (&image, &d64.bytes[4], sizeof (int32_t));
      buf[1] = image;
    }
  else
    {
      memcpy (&image, &d64.bytes[4], sizeof (int32_t));
      buf[0] = image;
      memcpy (&image, &d64.bytes[0], sizeof (int32_t));
      buf[1] = image;
    }
}
 
/* Decode an IEEE 754 decimal64 type into a real.  */
 
void
decode_decimal64 (const struct real_format *fmt ATTRIBUTE_UNUSED,
                  REAL_VALUE_TYPE *r, const long *buf)
{
  decNumber dn;
  decimal64 d64;
  decContext set;
  int32_t image;
 
  decContextDefault (&set, DEC_INIT_DECIMAL128);
  set.traps = 0;
 
  if (WORDS_BIGENDIAN == FLOAT_WORDS_BIG_ENDIAN)
    {
      image = buf[0];
      memcpy (&d64.bytes[0], &image, sizeof (int32_t));
      image = buf[1];
      memcpy (&d64.bytes[4], &image, sizeof (int32_t));
    }
  else
    {
      image = buf[1];
      memcpy (&d64.bytes[0], &image, sizeof (int32_t));
      image = buf[0];
      memcpy (&d64.bytes[4], &image, sizeof (int32_t));
    }
 
  decimal64ToNumber (&d64, &dn);
  decimal_from_decnumber (r, &dn, &set);
}
 
/* Encode a real into an IEEE 754 decimal128 type.  */
 
void
encode_decimal128 (const struct real_format *fmt ATTRIBUTE_UNUSED,
                   long *buf, const REAL_VALUE_TYPE *r)
{
  decNumber dn;
  decContext set;
  decimal128 d128;
  int32_t image;
 
  decContextDefault (&set, DEC_INIT_DECIMAL128);
  set.traps = 0;
 
  decimal_to_decnumber (r, &dn);
  decimal128FromNumber (&d128, &dn, &set);
 
  if (WORDS_BIGENDIAN == FLOAT_WORDS_BIG_ENDIAN)
    {
      memcpy (&image, &d128.bytes[0], sizeof (int32_t));
      buf[0] = image;
      memcpy (&image, &d128.bytes[4], sizeof (int32_t));
      buf[1] = image;
      memcpy (&image, &d128.bytes[8], sizeof (int32_t));
      buf[2] = image;
      memcpy (&image, &d128.bytes[12], sizeof (int32_t));
      buf[3] = image;
    }
  else
    {
      memcpy (&image, &d128.bytes[12], sizeof (int32_t));
      buf[0] = image;
      memcpy (&image, &d128.bytes[8], sizeof (int32_t));
      buf[1] = image;
      memcpy (&image, &d128.bytes[4], sizeof (int32_t));
      buf[2] = image;
      memcpy (&image, &d128.bytes[0], sizeof (int32_t));
      buf[3] = image;
    }
}
 
/* Decode an IEEE 754 decimal128 type into a real.  */
 
void
decode_decimal128 (const struct real_format *fmt ATTRIBUTE_UNUSED,
                   REAL_VALUE_TYPE *r, const long *buf)
{
  decNumber dn;
  decimal128 d128;
  decContext set;
  int32_t image;
 
  decContextDefault (&set, DEC_INIT_DECIMAL128);
  set.traps = 0;
 
  if (WORDS_BIGENDIAN == FLOAT_WORDS_BIG_ENDIAN)
    {
      image = buf[0];
      memcpy (&d128.bytes[0],  &image, sizeof (int32_t));
      image = buf[1];
      memcpy (&d128.bytes[4],  &image, sizeof (int32_t));
      image = buf[2];
      memcpy (&d128.bytes[8],  &image, sizeof (int32_t));
      image = buf[3];
      memcpy (&d128.bytes[12], &image, sizeof (int32_t));
    }
  else
    {
      image = buf[3];
      memcpy (&d128.bytes[0],  &image, sizeof (int32_t));
      image = buf[2];
      memcpy (&d128.bytes[4],  &image, sizeof (int32_t));
      image = buf[1];
      memcpy (&d128.bytes[8],  &image, sizeof (int32_t));
      image = buf[0];
      memcpy (&d128.bytes[12], &image, sizeof (int32_t));
    }
 
  decimal128ToNumber (&d128, &dn);
  decimal_from_decnumber (r, &dn, &set);
}
 
/* Helper function to convert from a binary real internal
   representation.  */
 
static void
decimal_to_binary (REAL_VALUE_TYPE *to, const REAL_VALUE_TYPE *from,
                   enum machine_mode mode)
{
  char string[256];
  const decimal128 *const d128 = (const decimal128 *) from->sig;
 
  decimal128ToString (d128, string);
  real_from_string3 (to, string, mode);
}
 
 
/* Helper function to convert from a binary real internal
   representation.  */
 
static void
decimal_from_binary (REAL_VALUE_TYPE *to, const REAL_VALUE_TYPE *from)
{
  char string[256];
 
  /* We convert to string, then to decNumber then to decimal128.  */
  real_to_decimal (string, from, sizeof (string), 0, 1);
  decimal_real_from_string (to, string);
}
 
/* Helper function to real.c:do_compare() to handle decimal internal
   representation including when one of the operands is still in the
   binary internal representation.  */
 
int
decimal_do_compare (const REAL_VALUE_TYPE *a, const REAL_VALUE_TYPE *b,
                    int nan_result)
{
  decContext set;
  decNumber dn, dn2, dn3;
  REAL_VALUE_TYPE a1, b1;
 
  /* If either operand is non-decimal, create temporary versions.  */
  if (!a->decimal)
    {
      decimal_from_binary (&a1, a);
      a = &a1;
    }
  if (!b->decimal)
    {
      decimal_from_binary (&b1, b);
      b = &b1;
    }
 
  /* Convert into decNumber form for comparison operation.  */
  decContextDefault (&set, DEC_INIT_DECIMAL128);
  set.traps = 0;
  decimal128ToNumber ((const decimal128 *) a->sig, &dn2);
  decimal128ToNumber ((const decimal128 *) b->sig, &dn3);
 
  /* Finally, do the comparison.  */
  decNumberCompare (&dn, &dn2, &dn3, &set);
 
  /* Return the comparison result.  */
  if (decNumberIsNaN (&dn))
    return nan_result;
  else if (decNumberIsZero (&dn))
    return 0;
  else if (decNumberIsNegative (&dn))
    return -1;
  else
    return 1;
}
 
/* Helper to round_for_format, handling decimal float types.  */
 
void
decimal_round_for_format (const struct real_format *fmt, REAL_VALUE_TYPE *r)
{
  decNumber dn;
  decContext set;
 
  /* Real encoding occurs later.  */
  if (r->cl != rvc_normal)
    return;
 
  decContextDefault (&set, DEC_INIT_DECIMAL128);
  set.traps = 0;
  decimal128ToNumber ((decimal128 *) r->sig, &dn);
 
  if (fmt == &decimal_quad_format)
    {
      /* The internal format is already in this format.  */
      return;
    }
  else if (fmt == &decimal_single_format)
    {
      decimal32 d32;
      decContextDefault (&set, DEC_INIT_DECIMAL32);
      set.traps = 0;
 
      decimal32FromNumber (&d32, &dn, &set);
      decimal32ToNumber (&d32, &dn);
    }
  else if (fmt == &decimal_double_format)
    {
      decimal64 d64;
      decContextDefault (&set, DEC_INIT_DECIMAL64);
      set.traps = 0;
 
      decimal64FromNumber (&d64, &dn, &set);
      decimal64ToNumber (&d64, &dn);
    }
  else
    gcc_unreachable ();
 
  decimal_from_decnumber (r, &dn, &set);
}
 
/* Extend or truncate to a new mode.  Handles conversions between
   binary and decimal types.  */
 
void
decimal_real_convert (REAL_VALUE_TYPE *r, enum machine_mode mode,
                      const REAL_VALUE_TYPE *a)
{
  const struct real_format *fmt = REAL_MODE_FORMAT (mode);
 
  if (a->decimal && fmt->b == 10)
    return;
  if (a->decimal)
      decimal_to_binary (r, a, mode);
  else
      decimal_from_binary (r, a);
}
 
/* Render R_ORIG as a decimal floating point constant.  Emit DIGITS
   significant digits in the result, bounded by BUF_SIZE.  If DIGITS
   is 0, choose the maximum for the representation.  If
   CROP_TRAILING_ZEROS, strip trailing zeros.  Currently, not honoring
   DIGITS or CROP_TRAILING_ZEROS.  */
 
void
decimal_real_to_decimal (char *str, const REAL_VALUE_TYPE *r_orig,
                         size_t buf_size,
                         size_t digits ATTRIBUTE_UNUSED,
                         int crop_trailing_zeros ATTRIBUTE_UNUSED)
{
  const decimal128 *const d128 = (const decimal128*) r_orig->sig;
 
  /* decimal128ToString requires space for at least 24 characters;
     Require two more for suffix.  */
  gcc_assert (buf_size >= 24);
  decimal128ToString (d128, str);
}
 
static bool
decimal_do_add (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *op0,
                const REAL_VALUE_TYPE *op1, int subtract_p)
{
  decNumber dn;
  decContext set;
  decNumber dn2, dn3;
 
  decimal_to_decnumber (op0, &dn2);
  decimal_to_decnumber (op1, &dn3);
 
  decContextDefault (&set, DEC_INIT_DECIMAL128);
  set.traps = 0;
 
  if (subtract_p)
    decNumberSubtract (&dn, &dn2, &dn3, &set);
  else
    decNumberAdd (&dn, &dn2, &dn3, &set);
 
  decimal_from_decnumber (r, &dn, &set);
 
  /* Return true, if inexact.  */
  return (set.status & DEC_Inexact);
}
 
/* Compute R = OP0 * OP1.  */
 
static bool
decimal_do_multiply (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *op0,
                     const REAL_VALUE_TYPE *op1)
{
  decContext set;
  decNumber dn, dn2, dn3;
 
  decimal_to_decnumber (op0, &dn2);
  decimal_to_decnumber (op1, &dn3);
 
  decContextDefault (&set, DEC_INIT_DECIMAL128);
  set.traps = 0;
 
  decNumberMultiply (&dn, &dn2, &dn3, &set);
  decimal_from_decnumber (r, &dn, &set);
 
  /* Return true, if inexact.  */
  return (set.status & DEC_Inexact);
}
 
/* Compute R = OP0 / OP1.  */
 
static bool
decimal_do_divide (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *op0,
                   const REAL_VALUE_TYPE *op1)
{
  decContext set;
  decNumber dn, dn2, dn3;
 
  decimal_to_decnumber (op0, &dn2);
  decimal_to_decnumber (op1, &dn3);
 
  decContextDefault (&set, DEC_INIT_DECIMAL128);
  set.traps = 0;
 
  decNumberDivide (&dn, &dn2, &dn3, &set);
  decimal_from_decnumber (r, &dn, &set);
 
  /* Return true, if inexact.  */
  return (set.status & DEC_Inexact);
}
 
/* Set R to A truncated to an integral value toward zero (decimal
   floating point).  */
 
void
decimal_do_fix_trunc (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a)
{
  decNumber dn, dn2;
  decContext set;
 
  decContextDefault (&set, DEC_INIT_DECIMAL128);
  set.traps = 0;
  set.round = DEC_ROUND_DOWN;
  decimal128ToNumber ((const decimal128 *) a->sig, &dn2);
 
  decNumberToIntegralValue (&dn, &dn2, &set);
  decimal_from_decnumber (r, &dn, &set);
}
 
/* Render decimal float value R as an integer.  */
 
HOST_WIDE_INT
decimal_real_to_integer (const REAL_VALUE_TYPE *r)
{
  decContext set;
  decNumber dn, dn2, dn3;
  REAL_VALUE_TYPE to;
  char string[256];
 
  decContextDefault (&set, DEC_INIT_DECIMAL128);
  set.traps = 0;
  set.round = DEC_ROUND_DOWN;
  decimal128ToNumber ((const decimal128 *) r->sig, &dn);
 
  decNumberToIntegralValue (&dn2, &dn, &set);
  decNumberZero (&dn3);
  decNumberRescale (&dn, &dn2, &dn3, &set);
 
  /* Convert to REAL_VALUE_TYPE and call appropriate conversion
     function.  */
  decNumberToString (&dn, string);
  real_from_string (&to, string);
  return real_to_integer (&to);
}
 
/* Likewise, but to an integer pair, HI+LOW.  */
 
void
decimal_real_to_integer2 (HOST_WIDE_INT *plow, HOST_WIDE_INT *phigh,
                          const REAL_VALUE_TYPE *r)
{
  decContext set;
  decNumber dn, dn2, dn3;
  REAL_VALUE_TYPE to;
  char string[256];
 
  decContextDefault (&set, DEC_INIT_DECIMAL128);
  set.traps = 0;
  set.round = DEC_ROUND_DOWN;
  decimal128ToNumber ((const decimal128 *) r->sig, &dn);
 
  decNumberToIntegralValue (&dn2, &dn, &set);
  decNumberZero (&dn3);
  decNumberRescale (&dn, &dn2, &dn3, &set);
 
  /* Convert to REAL_VALUE_TYPE and call appropriate conversion
     function.  */
  decNumberToString (&dn, string);
  real_from_string (&to, string);
  real_to_integer2 (plow, phigh, &to);
}
 
/* Perform the decimal floating point operation described by CODE.
   For a unary operation, OP1 will be NULL.  This function returns
   true if the result may be inexact due to loss of precision.  */
 
bool
decimal_real_arithmetic (REAL_VALUE_TYPE *r, enum tree_code code,
                         const REAL_VALUE_TYPE *op0,
                         const REAL_VALUE_TYPE *op1)
{
  REAL_VALUE_TYPE a, b;
 
  /* If either operand is non-decimal, create temporaries.  */
  if (!op0->decimal)
    {
      decimal_from_binary (&a, op0);
      op0 = &a;
    }
  if (op1 && !op1->decimal)
    {
      decimal_from_binary (&b, op1);
      op1 = &b;
    }
 
  switch (code)
    {
    case PLUS_EXPR:
      return decimal_do_add (r, op0, op1, 0);
 
    case MINUS_EXPR:
      return decimal_do_add (r, op0, op1, 1);
 
    case MULT_EXPR:
      return decimal_do_multiply (r, op0, op1);
 
    case RDIV_EXPR:
      return decimal_do_divide (r, op0, op1);
 
    case MIN_EXPR:
      if (op1->cl == rvc_nan)
        *r = *op1;
      else if (real_compare (UNLT_EXPR, op0, op1))
        *r = *op0;
      else
        *r = *op1;
      return false;
 
    case MAX_EXPR:
      if (op1->cl == rvc_nan)
        *r = *op1;
      else if (real_compare (LT_EXPR, op0, op1))
        *r = *op1;
      else
        *r = *op0;
      return false;
 
    case NEGATE_EXPR:
      {
        *r = *op0;
        /* Flip sign bit.  */
        decimal128FlipSign ((decimal128 *) r->sig);
        /* Keep sign field in sync.  */
        r->sign ^= 1;
      }
      return false;
 
    case ABS_EXPR:
      {
        *r = *op0;
        /* Clear sign bit.  */
        decimal128ClearSign ((decimal128 *) r->sig);
        /* Keep sign field in sync.  */
        r->sign = 0;
      }
      return false;
 
    case FIX_TRUNC_EXPR:
      decimal_do_fix_trunc (r, op0);
      return false;
 
    default:
      gcc_unreachable ();
    }
}
 
/* Fills R with the largest finite value representable in mode MODE.
   If SIGN is nonzero, R is set to the most negative finite value.  */
 
void
decimal_real_maxval (REAL_VALUE_TYPE *r, int sign, enum machine_mode mode)
{
  const char *max;
 
  switch (mode)
    {
    case SDmode:
      max = "9.999999E96";
      break;
    case DDmode:
      max = "9.999999999999999E384";
      break;
    case TDmode:
      max = "9.999999999999999999999999999999999E6144";
      break;
    default:
      gcc_unreachable ();
    }
 
  decimal_real_from_string (r, max);
  if (sign)
    decimal128SetSign ((decimal128 *) r->sig, 1);
}

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [dfp.c] - Blame information for rev 801

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