On October 29, 2015 4:53:59 PM GMT+01:00, Richard Sandiford
<richard.sandif...@arm.com> wrote:
>Most real.h routines used machine modes to specify the format of
>an operation and converted that to a float_format * internally.
>Some also had alternative versions that accepted a float_format *.
>
>In an upcoming patch it seemed more convenient for the callers
>I was adding to use float_format directly, since the callers need
>to examine the format themselves for other reasons. This patch
>therefore replaces the machine_mode arguments with a new class that
>allows both machine modes and float_format pointers to be used.
>
>Tested on x86_64-linux-gnu, arm-linux-gnueabi and aarch64-linux-gnu.
>OK to install?
OK.
Richard.
>Thanks,
>Richard
>
>
>gcc/
> * real.h (format_helper): New.
> (real_convert, exact_real_truncate, real_from_string3, real_to_target)
> (real_from_target, real_nan, real_2expN, real_value_truncate)
> (significand_size, real_from_string2, exact_real_inverse)
> (exact_real_inverse, real_powi, real_trunc, real_floor, real_ceil)
> (real_round, real_isinteger, real_from_integer): Replace
> machine_mode arguments with format_helper arguments.
> * real.c (exact_real_inverse, real_from_string2, real_from_string3)
> (real_from_integer, real_nan, real_2expN, real_convert)
> (real_value_truncate, exact_real_truncate, real_to_target)
> (real_from_target, significand_size, real_powi, real_trunc)
> (real_floor, real_ceil, real_round, real_isinteger): Replace
> machine_mode arguments with format_helper arguments.
> (real_to_target_fmt, real_from_target_fmt): Delete.
> * dfp.h (decimal_real_convert): Replace mode argument with
>real_format.
> * dfp.c (decimal_to_binary, decimal_real_convert): Replace mode
> argument with real_format.
> * builtins.c (do_real_to_int_conversion): Update type of fn argument.
>
>gcc/java/
> * jcf-parse.c (get_constant): Use real_from_target rather than
> real_from_target_fmt.
>
>diff --git a/gcc/builtins.c b/gcc/builtins.c
>index 248c009..583a68e 100644
>--- a/gcc/builtins.c
>+++ b/gcc/builtins.c
>@@ -7275,7 +7275,7 @@ fold_builtin_strlen (location_t loc, tree type,
>tree arg)
>
> static tree
> do_real_to_int_conversion (tree itype, tree arg,
>- void (*fn) (REAL_VALUE_TYPE *, machine_mode,
>+ void (*fn) (REAL_VALUE_TYPE *, format_helper,
> const REAL_VALUE_TYPE *))
> {
> if (TREE_CODE (arg) != REAL_CST || TREE_OVERFLOW (arg))
>diff --git a/gcc/dfp.c b/gcc/dfp.c
>index ceb43d1..f3a3b6f 100644
>--- a/gcc/dfp.c
>+++ b/gcc/dfp.c
>@@ -343,13 +343,13 @@ decode_decimal128 (const struct real_format *fmt
>ATTRIBUTE_UNUSED,
>
> static void
> decimal_to_binary (REAL_VALUE_TYPE *to, const REAL_VALUE_TYPE *from,
>- machine_mode mode)
>+ const real_format *fmt)
> {
> char string[256];
> const decimal128 *const d128 = (const decimal128 *) from->sig;
>
> decimal128ToString (d128, string);
>- real_from_string3 (to, string, mode);
>+ real_from_string3 (to, string, fmt);
> }
>
>
>@@ -459,15 +459,13 @@ decimal_round_for_format (const struct
>real_format *fmt, REAL_VALUE_TYPE *r)
> binary and decimal types. */
>
> void
>-decimal_real_convert (REAL_VALUE_TYPE *r, machine_mode mode,
>+decimal_real_convert (REAL_VALUE_TYPE *r, const real_format *fmt,
> 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);
>+ decimal_to_binary (r, a, fmt);
> else
> decimal_from_binary (r, a);
> }
>diff --git a/gcc/dfp.h b/gcc/dfp.h
>index 013de8b..a3653c9 100644
>--- a/gcc/dfp.h
>+++ b/gcc/dfp.h
>@@ -34,7 +34,8 @@ void encode_decimal128 (const struct real_format
>*fmt, long *, const REAL_VALUE_
>int decimal_do_compare (const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE
>*, int);
> void decimal_real_from_string (REAL_VALUE_TYPE *, const char *);
>void decimal_round_for_format (const struct real_format *,
>REAL_VALUE_TYPE *);
>-void decimal_real_convert (REAL_VALUE_TYPE *, machine_mode, const
>REAL_VALUE_TYPE *);
>+void decimal_real_convert (REAL_VALUE_TYPE *, const real_format *,
>+ const REAL_VALUE_TYPE *);
>void decimal_real_to_decimal (char *, const REAL_VALUE_TYPE *, size_t,
>size_t, int);
>void decimal_do_fix_trunc (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
> void decimal_real_maxval (REAL_VALUE_TYPE *, int, machine_mode);
>diff --git a/gcc/java/jcf-parse.c b/gcc/java/jcf-parse.c
>index bb6e743..88f1a06 100644
>--- a/gcc/java/jcf-parse.c
>+++ b/gcc/java/jcf-parse.c
>@@ -1061,7 +1061,7 @@ get_constant (JCF *jcf, int index)
> long buf = num;
> REAL_VALUE_TYPE d;
>
>- real_from_target_fmt (&d, &buf, &ieee_single_format);
>+ real_from_target (&d, &buf, &ieee_single_format);
> value = build_real (float_type_node, d);
> break;
> }
>@@ -1079,7 +1079,7 @@ get_constant (JCF *jcf, int index)
> else
> buf[0] = lo, buf[1] = hi;
>
>- real_from_target_fmt (&d, buf, &ieee_double_format);
>+ real_from_target (&d, buf, &ieee_double_format);
> value = build_real (double_type_node, d);
> break;
> }
>diff --git a/gcc/real.c b/gcc/real.c
>index a292126..6d472be 100644
>--- a/gcc/real.c
>+++ b/gcc/real.c
>@@ -1267,11 +1267,11 @@ real_identical (const REAL_VALUE_TYPE *a, const
>REAL_VALUE_TYPE *b)
> return true;
> }
>
>-/* Try to change R into its exact multiplicative inverse in machine
>- mode MODE. Return true if successful. */
>+/* Try to change R into its exact multiplicative inverse in format
>FMT.
>+ Return true if successful. */
>
> bool
>-exact_real_inverse (machine_mode mode, REAL_VALUE_TYPE *r)
>+exact_real_inverse (format_helper fmt, REAL_VALUE_TYPE *r)
> {
> const REAL_VALUE_TYPE *one = real_digit (1);
> REAL_VALUE_TYPE u;
>@@ -1287,9 +1287,9 @@ exact_real_inverse (machine_mode mode,
>REAL_VALUE_TYPE *r)
> if (r->sig[SIGSZ-1] != SIG_MSB)
> return false;
>
>- /* Find the inverse and truncate to the required mode. */
>+ /* Find the inverse and truncate to the required format. */
> do_divide (&u, one, r);
>- real_convert (&u, mode, &u);
>+ real_convert (&u, fmt, &u);
>
> /* The rounding may have overflowed. */
> if (u.cl != rvc_normal)
>@@ -2105,35 +2105,36 @@ real_from_string (REAL_VALUE_TYPE *r, const
>char *str)
> /* Legacy. Similar, but return the result directly. */
>
> REAL_VALUE_TYPE
>-real_from_string2 (const char *s, machine_mode mode)
>+real_from_string2 (const char *s, format_helper fmt)
> {
> REAL_VALUE_TYPE r;
>
> real_from_string (&r, s);
>- if (mode != VOIDmode)
>- real_convert (&r, mode, &r);
>+ if (fmt)
>+ real_convert (&r, fmt, &r);
>
> return r;
> }
>
>-/* Initialize R from string S and desired MODE. */
>+/* Initialize R from string S and desired format FMT. */
>
> void
>-real_from_string3 (REAL_VALUE_TYPE *r, const char *s, machine_mode
>mode)
>+real_from_string3 (REAL_VALUE_TYPE *r, const char *s, format_helper
>fmt)
> {
>- if (DECIMAL_FLOAT_MODE_P (mode))
>+ if (fmt.decimal_p ())
> decimal_real_from_string (r, s);
> else
> real_from_string (r, s);
>
>- if (mode != VOIDmode)
>- real_convert (r, mode, r);
>+ if (fmt)
>+ real_convert (r, fmt, r);
> }
>
>-/* Initialize R from the wide_int VAL_IN. The MODE is not VOIDmode,*/
>+/* Initialize R from the wide_int VAL_IN. Round it to format FMT if
>+ FMT is nonnull. */
>
> void
>-real_from_integer (REAL_VALUE_TYPE *r, machine_mode mode,
>+real_from_integer (REAL_VALUE_TYPE *r, format_helper fmt,
> const wide_int_ref &val_in, signop sgn)
> {
> if (val_in == 0)
>@@ -2217,10 +2218,10 @@ real_from_integer (REAL_VALUE_TYPE *r,
>machine_mode mode,
> normalize (r);
> }
>
>- if (DECIMAL_FLOAT_MODE_P (mode))
>+ if (fmt.decimal_p ())
> decimal_from_integer (r);
>- else if (mode != VOIDmode)
>- real_convert (r, mode, r);
>+ else if (fmt)
>+ real_convert (r, fmt, r);
> }
>
> /* Render R, an integral value, as a floating point constant with no
>@@ -2449,13 +2450,8 @@ real_inf (REAL_VALUE_TYPE *r)
>
> bool
> real_nan (REAL_VALUE_TYPE *r, const char *str, int quiet,
>- machine_mode mode)
>+ format_helper fmt)
> {
>- const struct real_format *fmt;
>-
>- fmt = REAL_MODE_FORMAT (mode);
>- gcc_assert (fmt);
>-
> if (*str == 0)
> {
> if (quiet)
>@@ -2575,7 +2571,7 @@ real_maxval (REAL_VALUE_TYPE *r, int sign,
>machine_mode mode)
> /* Fills R with 2**N. */
>
> void
>-real_2expN (REAL_VALUE_TYPE *r, int n, machine_mode fmode)
>+real_2expN (REAL_VALUE_TYPE *r, int n, format_helper fmt)
> {
> memset (r, 0, sizeof (*r));
>
>@@ -2590,8 +2586,8 @@ real_2expN (REAL_VALUE_TYPE *r, int n,
>machine_mode fmode)
> SET_REAL_EXP (r, n);
> r->sig[SIGSZ-1] = SIG_MSB;
> }
>- if (DECIMAL_FLOAT_MODE_P (fmode))
>- decimal_real_convert (r, fmode, r);
>+ if (fmt.decimal_p ())
>+ decimal_real_convert (r, fmt, r);
> }
>
> >
>@@ -2613,7 +2609,7 @@ round_for_format (const struct real_format *fmt,
>REAL_VALUE_TYPE *r)
> (e.g. -O0 on '_Decimal32 x = 1.0 + 2.0dd'), but have not
> investigated whether this convert needs to be here, or
> something else is missing. */
>- decimal_real_convert (r, DFmode, r);
>+ decimal_real_convert (r, REAL_MODE_FORMAT (DFmode), r);
> }
>
> p2 = fmt->p;
>@@ -2719,21 +2715,16 @@ round_for_format (const struct real_format
>*fmt, REAL_VALUE_TYPE *r)
> clear_significand_below (r, np2);
> }
>
>-/* Extend or truncate to a new mode. */
>+/* Extend or truncate to a new format. */
>
> void
>-real_convert (REAL_VALUE_TYPE *r, machine_mode mode,
>+real_convert (REAL_VALUE_TYPE *r, format_helper fmt,
> const REAL_VALUE_TYPE *a)
> {
>- const struct real_format *fmt;
>-
>- fmt = REAL_MODE_FORMAT (mode);
>- gcc_assert (fmt);
>-
> *r = *a;
>
> if (a->decimal || fmt->b == 10)
>- decimal_real_convert (r, mode, a);
>+ decimal_real_convert (r, fmt, a);
>
> round_for_format (fmt, r);
>
>@@ -2745,32 +2736,28 @@ real_convert (REAL_VALUE_TYPE *r, machine_mode
>mode,
> /* Legacy. Likewise, except return the struct directly. */
>
> REAL_VALUE_TYPE
>-real_value_truncate (machine_mode mode, REAL_VALUE_TYPE a)
>+real_value_truncate (format_helper fmt, REAL_VALUE_TYPE a)
> {
> REAL_VALUE_TYPE r;
>- real_convert (&r, mode, &a);
>+ real_convert (&r, fmt, &a);
> return r;
> }
>
>-/* Return true if truncating to MODE is exact. */
>+/* Return true if truncating to FMT is exact. */
>
> bool
>-exact_real_truncate (machine_mode mode, const REAL_VALUE_TYPE *a)
>+exact_real_truncate (format_helper fmt, const REAL_VALUE_TYPE *a)
> {
>- const struct real_format *fmt;
> REAL_VALUE_TYPE t;
> int emin2m1;
>
>- fmt = REAL_MODE_FORMAT (mode);
>- gcc_assert (fmt);
>-
> /* Don't allow conversion to denormals. */
> emin2m1 = fmt->emin - 1;
> if (REAL_EXP (a) <= emin2m1)
> return false;
>
>- /* After conversion to the new mode, the value must be identical.
>*/
>- real_convert (&t, mode, a);
>+ /* After conversion to the new format, the value must be identical.
>*/
>+ real_convert (&t, fmt, a);
> return real_identical (&t, a);
> }
>
>@@ -2781,8 +2768,8 @@ exact_real_truncate (machine_mode mode, const
>REAL_VALUE_TYPE *a)
>Legacy: return word 0 for implementing REAL_VALUE_TO_TARGET_SINGLE. */
>
> long
>-real_to_target_fmt (long *buf, const REAL_VALUE_TYPE *r_orig,
>- const struct real_format *fmt)
>+real_to_target (long *buf, const REAL_VALUE_TYPE *r_orig,
>+ format_helper fmt)
> {
> REAL_VALUE_TYPE r;
> long buf1;
>@@ -2797,62 +2784,32 @@ real_to_target_fmt (long *buf, const
>REAL_VALUE_TYPE *r_orig,
> return *buf;
> }
>
>-/* Similar, but look up the format from MODE. */
>-
>-long
>-real_to_target (long *buf, const REAL_VALUE_TYPE *r, machine_mode
>mode)
>-{
>- const struct real_format *fmt;
>-
>- fmt = REAL_MODE_FORMAT (mode);
>- gcc_assert (fmt);
>-
>- return real_to_target_fmt (buf, r, fmt);
>-}
>-
> /* Read R from the given target format. Read the words of the result
> in target word order in BUF. There are always 32 bits in each
> long, no matter the size of the host long. */
>
> void
>-real_from_target_fmt (REAL_VALUE_TYPE *r, const long *buf,
>- const struct real_format *fmt)
>+real_from_target (REAL_VALUE_TYPE *r, const long *buf, format_helper
>fmt)
> {
> (*fmt->decode) (fmt, r, buf);
> }
>
>-/* Similar, but look up the format from MODE. */
>-
>-void
>-real_from_target (REAL_VALUE_TYPE *r, const long *buf, machine_mode
>mode)
>-{
>- const struct real_format *fmt;
>-
>- fmt = REAL_MODE_FORMAT (mode);
>- gcc_assert (fmt);
>-
>- (*fmt->decode) (fmt, r, buf);
>-}
>-
> /* Return the number of bits of the largest binary value that the
>- significand of MODE will hold. */
>+ significand of FMT will hold. */
> /* ??? Legacy. Should get access to real_format directly. */
>
> int
>-significand_size (machine_mode mode)
>+significand_size (format_helper fmt)
> {
>- const struct real_format *fmt;
>-
>- fmt = REAL_MODE_FORMAT (mode);
> if (fmt == NULL)
> return 0;
>
> if (fmt->b == 10)
> {
> /* Return the size in bits of the largest binary value that can be
>- held by the decimal coefficient for this mode. This is one more
>+ held by the decimal coefficient for this format. This is one more
> than the number of bits required to hold the largest coefficient
>- of this mode. */
>+ of this format. */
> double log2_10 = 3.3219281;
> return fmt->p * log2_10;
> }
>@@ -4862,14 +4819,14 @@ const struct real_format real_internal_format =
> "real_internal"
> };
> >
>-/* Calculate X raised to the integer exponent N in mode MODE and store
>+/* Calculate X raised to the integer exponent N in format FMT and
>store
> the result in R. Return true if the result may be inexact due to
> loss of precision. The algorithm is the classic "left-to-right binary
> method" described in section 4.6.3 of Donald Knuth's "Seminumerical
> Algorithms", "The Art of Computer Programming", Volume 2. */
>
> bool
>-real_powi (REAL_VALUE_TYPE *r, machine_mode mode,
>+real_powi (REAL_VALUE_TYPE *r, format_helper fmt,
> const REAL_VALUE_TYPE *x, HOST_WIDE_INT n)
> {
> unsigned HOST_WIDE_INT bit;
>@@ -4911,27 +4868,27 @@ real_powi (REAL_VALUE_TYPE *r, machine_mode
>mode,
> if (neg)
> inexact |= do_divide (&t, &dconst1, &t);
>
>- real_convert (r, mode, &t);
>+ real_convert (r, fmt, &t);
> return inexact;
> }
>
> /* Round X to the nearest integer not larger in absolute value, i.e.
>- towards zero, placing the result in R in mode MODE. */
>+ towards zero, placing the result in R in format FMT. */
>
> void
>-real_trunc (REAL_VALUE_TYPE *r, machine_mode mode,
>+real_trunc (REAL_VALUE_TYPE *r, format_helper fmt,
> const REAL_VALUE_TYPE *x)
> {
> do_fix_trunc (r, x);
>- if (mode != VOIDmode)
>- real_convert (r, mode, r);
>+ if (fmt)
>+ real_convert (r, fmt, r);
> }
>
> /* Round X to the largest integer not greater in value, i.e. round
>- down, placing the result in R in mode MODE. */
>+ down, placing the result in R in format FMT. */
>
> void
>-real_floor (REAL_VALUE_TYPE *r, machine_mode mode,
>+real_floor (REAL_VALUE_TYPE *r, format_helper fmt,
> const REAL_VALUE_TYPE *x)
> {
> REAL_VALUE_TYPE t;
>@@ -4939,17 +4896,17 @@ real_floor (REAL_VALUE_TYPE *r, machine_mode
>mode,
> do_fix_trunc (&t, x);
> if (! real_identical (&t, x) && x->sign)
> do_add (&t, &t, &dconstm1, 0);
>- if (mode != VOIDmode)
>- real_convert (r, mode, &t);
>+ if (fmt)
>+ real_convert (r, fmt, &t);
> else
> *r = t;
> }
>
> /* Round X to the smallest integer not less then argument, i.e. round
>- up, placing the result in R in mode MODE. */
>+ up, placing the result in R in format FMT. */
>
> void
>-real_ceil (REAL_VALUE_TYPE *r, machine_mode mode,
>+real_ceil (REAL_VALUE_TYPE *r, format_helper fmt,
> const REAL_VALUE_TYPE *x)
> {
> REAL_VALUE_TYPE t;
>@@ -4957,8 +4914,8 @@ real_ceil (REAL_VALUE_TYPE *r, machine_mode mode,
> do_fix_trunc (&t, x);
> if (! real_identical (&t, x) && ! x->sign)
> do_add (&t, &t, &dconst1, 0);
>- if (mode != VOIDmode)
>- real_convert (r, mode, &t);
>+ if (fmt)
>+ real_convert (r, fmt, &t);
> else
> *r = t;
> }
>@@ -4967,13 +4924,13 @@ real_ceil (REAL_VALUE_TYPE *r, machine_mode
>mode,
> zero. */
>
> void
>-real_round (REAL_VALUE_TYPE *r, machine_mode mode,
>+real_round (REAL_VALUE_TYPE *r, format_helper fmt,
> const REAL_VALUE_TYPE *x)
> {
> do_add (r, x, &dconsthalf, x->sign);
> do_fix_trunc (r, r);
>- if (mode != VOIDmode)
>- real_convert (r, mode, r);
>+ if (fmt)
>+ real_convert (r, fmt, r);
> }
>
> /* Set the sign of R to the sign of X. */
>@@ -4987,11 +4944,11 @@ real_copysign (REAL_VALUE_TYPE *r, const
>REAL_VALUE_TYPE *x)
> /* Check whether the real constant value given is an integer. */
>
> bool
>-real_isinteger (const REAL_VALUE_TYPE *c, machine_mode mode)
>+real_isinteger (const REAL_VALUE_TYPE *c, format_helper fmt)
> {
> REAL_VALUE_TYPE cint;
>
>- real_trunc (&cint, mode, c);
>+ real_trunc (&cint, fmt, c);
> return real_identical (c, &cint);
> }
>
>diff --git a/gcc/real.h b/gcc/real.h
>index d3b14e5..df5ccc9 100644
>--- a/gcc/real.h
>+++ b/gcc/real.h
>@@ -193,6 +193,28 @@ extern const struct real_format *
> (FLOAT_MODE_P (MODE) \
> && FLOAT_MODE_FORMAT (MODE)->has_sign_dependent_rounding)
>
>+/* This class allows functions in this file to accept a floating-point
>+ format as either a mode or an explicit real_format pointer. In the
>+ former case the mode must be VOIDmode (which means "no particular
>+ format") or must satisfy SCALAR_FLOAT_MODE_P. */
>+class format_helper
>+{
>+public:
>+ format_helper (const real_format *format) : m_format (format) {}
>+ format_helper (machine_mode m);
>+ const real_format *operator-> () const { return m_format; }
>+ operator const real_format *() const { return m_format; }
>+
>+ bool decimal_p () const { return m_format && m_format->b == 10; }
>+
>+private:
>+ const real_format *m_format;
>+};
>+
>+inline format_helper::format_helper (machine_mode m)
>+ : m_format (m == VOIDmode ? 0 : REAL_MODE_FORMAT (m))
>+{}
>+
> /* Declare functions in real.c. */
>
>/* True if the given mode has a NaN representation and the treatment of
>@@ -254,12 +276,12 @@ extern bool real_identical (const REAL_VALUE_TYPE
>*, const REAL_VALUE_TYPE *);
>extern bool real_equal (const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE
>*);
>extern bool real_less (const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE
>*);
>
>-/* Extend or truncate to a new mode. */
>-extern void real_convert (REAL_VALUE_TYPE *, machine_mode,
>+/* Extend or truncate to a new format. */
>+extern void real_convert (REAL_VALUE_TYPE *, format_helper,
> const REAL_VALUE_TYPE *);
>
> /* Return true if truncating to NEW is exact. */
>-extern bool exact_real_truncate (machine_mode, const REAL_VALUE_TYPE
>*);
>+extern bool exact_real_truncate (format_helper, const REAL_VALUE_TYPE
>*);
>
> /* Render R as a decimal floating point constant. */
> extern void real_to_decimal (char *, const REAL_VALUE_TYPE *, size_t,
>@@ -281,24 +303,20 @@ extern HOST_WIDE_INT real_to_integer (const
>REAL_VALUE_TYPE *);
> the value underflows, +1 if overflows, and 0 otherwise. */
> extern int real_from_string (REAL_VALUE_TYPE *, const char *);
>/* Wrapper to allow different internal representation for decimal
>floats. */
>-extern void real_from_string3 (REAL_VALUE_TYPE *, const char *,
>machine_mode);
>+extern void real_from_string3 (REAL_VALUE_TYPE *, const char *,
>format_helper);
>
>-extern long real_to_target_fmt (long *, const REAL_VALUE_TYPE *,
>- const struct real_format *);
>-extern long real_to_target (long *, const REAL_VALUE_TYPE *,
>machine_mode);
>+extern long real_to_target (long *, const REAL_VALUE_TYPE *,
>format_helper);
>
>-extern void real_from_target_fmt (REAL_VALUE_TYPE *, const long *,
>- const struct real_format *);
> extern void real_from_target (REAL_VALUE_TYPE *, const long *,
>- machine_mode);
>+ format_helper);
>
> extern void real_inf (REAL_VALUE_TYPE *);
>
>-extern bool real_nan (REAL_VALUE_TYPE *, const char *, int,
>machine_mode);
>+extern bool real_nan (REAL_VALUE_TYPE *, const char *, int,
>format_helper);
>
> extern void real_maxval (REAL_VALUE_TYPE *, int, machine_mode);
>
>-extern void real_2expN (REAL_VALUE_TYPE *, int, machine_mode);
>+extern void real_2expN (REAL_VALUE_TYPE *, int, format_helper);
>
> extern unsigned int real_hash (const REAL_VALUE_TYPE *);
>
>@@ -370,15 +388,14 @@ extern const struct real_format arm_half_format;
> #define REAL_VALUE_TO_TARGET_DECIMAL32(IN, OUT) \
>((OUT) = real_to_target (NULL, &(IN), mode_for_size (32,
>MODE_DECIMAL_FLOAT, 0)))
>
>-extern REAL_VALUE_TYPE real_value_truncate (machine_mode,
>- REAL_VALUE_TYPE);
>+extern REAL_VALUE_TYPE real_value_truncate (format_helper,
>REAL_VALUE_TYPE);
>
> extern REAL_VALUE_TYPE real_value_negate (const REAL_VALUE_TYPE *);
> extern REAL_VALUE_TYPE real_value_abs (const REAL_VALUE_TYPE *);
>
>-extern int significand_size (machine_mode);
>+extern int significand_size (format_helper);
>
>-extern REAL_VALUE_TYPE real_from_string2 (const char *, machine_mode);
>+extern REAL_VALUE_TYPE real_from_string2 (const char *,
>format_helper);
>
> #define REAL_VALUE_ATOF(s, m) \
> real_from_string2 (s, m)
>@@ -437,8 +454,8 @@ REAL_VALUE_TYPE real_value_from_int_cst
>(const_tree, const_tree);
> /* Return a CONST_DOUBLE with value R and mode M. */
>extern rtx const_double_from_real_value (REAL_VALUE_TYPE,
>machine_mode);
>
>-/* Replace R by 1/R in the given machine mode, if the result is exact.
> */
>-extern bool exact_real_inverse (machine_mode, REAL_VALUE_TYPE *);
>+/* Replace R by 1/R in the given format, if the result is exact. */
>+extern bool exact_real_inverse (format_helper, REAL_VALUE_TYPE *);
>
> /* Return true if arithmetic on values in IMODE that were promoted
> from values in TMODE is equivalent to direct arithmetic on values
>@@ -451,25 +468,25 @@ extern tree build_real (tree, REAL_VALUE_TYPE);
> /* Likewise, but first truncate the value to the type. */
> extern tree build_real_truncate (tree, REAL_VALUE_TYPE);
>
>-/* Calculate R as X raised to the integer exponent N in mode MODE. */
>-extern bool real_powi (REAL_VALUE_TYPE *, machine_mode,
>+/* Calculate R as X raised to the integer exponent N in format FMT.
>*/
>+extern bool real_powi (REAL_VALUE_TYPE *, format_helper,
> const REAL_VALUE_TYPE *, HOST_WIDE_INT);
>
> /* Standard round to integer value functions. */
>-extern void real_trunc (REAL_VALUE_TYPE *, machine_mode,
>+extern void real_trunc (REAL_VALUE_TYPE *, format_helper,
> const REAL_VALUE_TYPE *);
>-extern void real_floor (REAL_VALUE_TYPE *, machine_mode,
>+extern void real_floor (REAL_VALUE_TYPE *, format_helper,
> const REAL_VALUE_TYPE *);
>-extern void real_ceil (REAL_VALUE_TYPE *, machine_mode,
>+extern void real_ceil (REAL_VALUE_TYPE *, format_helper,
> const REAL_VALUE_TYPE *);
>-extern void real_round (REAL_VALUE_TYPE *, machine_mode,
>+extern void real_round (REAL_VALUE_TYPE *, format_helper,
> const REAL_VALUE_TYPE *);
>
> /* Set the sign of R to the sign of X. */
>extern void real_copysign (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
>
> /* Check whether the real constant value given is an integer. */
>-extern bool real_isinteger (const REAL_VALUE_TYPE *, machine_mode);
>+extern bool real_isinteger (const REAL_VALUE_TYPE *, format_helper);
> extern bool real_isinteger (const REAL_VALUE_TYPE *, HOST_WIDE_INT *);
>
> /* Write into BUF the maximum representable finite floating-point
>@@ -480,7 +497,7 @@ extern void get_max_float (const struct real_format
>*, char *, size_t);
> #ifndef GENERATOR_FILE
> /* real related routines. */
>extern wide_int real_to_integer (const REAL_VALUE_TYPE *, bool *, int);
>-extern void real_from_integer (REAL_VALUE_TYPE *, machine_mode,
>+extern void real_from_integer (REAL_VALUE_TYPE *, format_helper,
> const wide_int_ref &, signop);
> #endif
>
