This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
Re: Replace REAL_VALUES_EQUAL with real_equal
- From: Richard Biener <richard dot guenther at gmail dot com>
- To: GCC Patches <gcc-patches at gcc dot gnu dot org>, richard dot sandiford at arm dot com
- Date: Mon, 5 Oct 2015 12:59:42 +0200
- Subject: Re: Replace REAL_VALUES_EQUAL with real_equal
- Authentication-results: sourceware.org; auth=none
- References: <87oagdd2bu dot fsf at e105548-lin dot cambridge dot arm dot com>
On Mon, Oct 5, 2015 at 12:41 PM, Richard Sandiford
<richard.sandiford@arm.com> wrote:
> Richard B suggested we should replace dconsthalf etc. with
> dconst<1, 2> (). When I tried that, the extra comma caused problems
> with some lingering uses of the old target macros for handling reals
> (e.g. REAL_ARITHMETIC instead of real_arithmetic), since the constant
> was then treated as two macro parameters. It would have been possible
> to add an extra level of brackets to avoid this, but I thought I might
> as well take the opportunity to remove the macros instead. (Note that
> I'm only removing macros that caused a problem directly, or are closely
> related to ones that did.)
>
> This first patch replaces REAL_VALUES_EQUAL with a real_equal function.
> The prototype is the same as for real_identical, which has already
> undergone a half-transition in this direction.
>
> Bootstrapped & regression-tested on x86_64-linux-gnu. Also tested by
> building one target per CPU directory and checking that there were
> no new warnings and no changes in testsuite output at -O2.
> OK to install?
Ok.
Thanks,
Richard.
> Thanks,
> Richard
>
> PS. It might be good to make real_value more "C++-like" in future,
> but I think it should be done with care, especially with the potential
> confusion between operator== being real_identical or real_equal.
> This patch should at least be a strict improvement over the status quo.
>
>
> gcc/c-family/
> * c-lex.c (interpret_float): Use real_equal instead of
> REAL_VALUES_EQUAL.
>
> gcc/c/
> * c-typeck.c (c_tree_equal): Use real_equal instead of
> REAL_VALUES_EQUAL.
>
> gcc/cp/
> * tree.c (cp_tree_equal): Use real_equal instead of
> REAL_VALUES_EQUAL.
>
> gcc/
> * real.h (real_equal): Declare.
> (REAL_VALUES_EQUAL): Delete.
> * real.c (real_equal): New function.
> (real_compare): Use it.
> * doc/tm.texi.in (REAL_VALUES_EQUAL): Delete.
> * doc/tm.texi: Regenerate.
> * builtins.c (fold_builtin_pow, fold_builtin_load_exponent): Use
> real_equal instead of REAL_VALUES_EQUAL.
> * config/aarch64/aarch64.c (aarch64_float_const_zero_rtx_p): Likewise.
> * config/arm/arm.c (arm_const_double_rtx, neon_valid_immediate)
> (fp_const_from_val): Likewise.
> * config/fr30/fr30.c (fr30_const_double_is_zero): Likewise.
> * config/m68k/m68k.c (standard_68881_constant_p): Likewise.
> (floating_exact_log2): Likewise.
> * config/sh/sh.c (fp_zero_operand, fp_one_operand): Likewise.
> * config/vax/vax.c (vax_float_literal): Likewise.
> * config/xtensa/predicates.md (const_float_1_operand): Likewise.
> * cprop.c (implicit_set_cond_p): Likewise.
> * expmed.c (expand_mult): Likewise.
> * fold-const.c (const_binop): Likewise.
> * simplify-rtx.c (simplify_binary_operation_1): Likewise.
> (simplify_const_binary_operation): Likewise.
> (simplify_const_relational_operation): Likewise.
> * tree-call-cdce.c (check_pow): Likewise.
> (gen_conditions_for_pow_cst_base): Likewise.
> * tree-inline.c (estimate_num_insns): Likewise.
> * tree-ssa-dom.c (record_equality): Likewise.
> * tree-ssa-math-opts.c (representable_as_half_series_p): Likewise.
> (gimple_expand_builtin_pow): Likewise.
> (pass_optimize_widening_mul::execute): Likewise.
> * tree-ssa-uncprop.c (associate_equivalences_with_edges): Likewise.
> * tree-vect-patterns.c (vect_recog_pow_pattern): Likewise.
> * tree.c (real_zerop, real_onep, real_minus_onep): Likewise.
>
> diff --git a/gcc/builtins.c b/gcc/builtins.c
> index 956cf43..89bea60 100644
> --- a/gcc/builtins.c
> +++ b/gcc/builtins.c
> @@ -8419,22 +8419,22 @@ fold_builtin_pow (location_t loc, tree fndecl, tree arg0, tree arg1, tree type)
> c = TREE_REAL_CST (arg1);
>
> /* Optimize pow(x,0.0) = 1.0. */
> - if (REAL_VALUES_EQUAL (c, dconst0))
> + if (real_equal (&c, &dconst0))
> return omit_one_operand_loc (loc, type, build_real (type, dconst1),
> arg0);
>
> /* Optimize pow(x,1.0) = x. */
> - if (REAL_VALUES_EQUAL (c, dconst1))
> + if (real_equal (&c, &dconst1))
> return arg0;
>
> /* Optimize pow(x,-1.0) = 1.0/x. */
> - if (REAL_VALUES_EQUAL (c, dconstm1))
> + if (real_equal (&c, &dconstm1))
> return fold_build2_loc (loc, RDIV_EXPR, type,
> build_real (type, dconst1), arg0);
>
> /* Optimize pow(x,0.5) = sqrt(x). */
> if (flag_unsafe_math_optimizations
> - && REAL_VALUES_EQUAL (c, dconsthalf))
> + && real_equal (&c, &dconsthalf))
> {
> tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
>
> @@ -8448,7 +8448,7 @@ fold_builtin_pow (location_t loc, tree fndecl, tree arg0, tree arg1, tree type)
> const REAL_VALUE_TYPE dconstroot
> = real_value_truncate (TYPE_MODE (type), dconst_third ());
>
> - if (REAL_VALUES_EQUAL (c, dconstroot))
> + if (real_equal (&c, &dconstroot))
> {
> tree cbrtfn = mathfn_built_in (type, BUILT_IN_CBRT);
> if (cbrtfn != NULL_TREE)
> @@ -8467,7 +8467,7 @@ fold_builtin_pow (location_t loc, tree fndecl, tree arg0, tree arg1, tree type)
> && !TREE_OVERFLOW (arg0)
> && (n > 0
> || (!flag_trapping_math && !flag_errno_math)
> - || !REAL_VALUES_EQUAL (TREE_REAL_CST (arg0), dconst0)))
> + || !real_equal (&TREE_REAL_CST (arg0), &dconst0)))
> {
> REAL_VALUE_TYPE x;
> bool inexact;
> @@ -9358,7 +9358,7 @@ fold_builtin_load_exponent (location_t loc, tree arg0, tree arg1,
>
> /* Only proceed if the target mode can hold the
> resulting value. */
> - if (REAL_VALUES_EQUAL (initial_result, trunc_result))
> + if (real_equal (&initial_result, &trunc_result))
> return build_real (type, trunc_result);
> }
> }
> diff --git a/gcc/c-family/c-lex.c b/gcc/c-family/c-lex.c
> index 55ceb20..c69f4a6 100644
> --- a/gcc/c-family/c-lex.c
> +++ b/gcc/c-family/c-lex.c
> @@ -914,9 +914,9 @@ interpret_float (const cpp_token *token, unsigned int flags,
> }
> }
> /* We also give a warning if the value underflows. */
> - else if (REAL_VALUES_EQUAL (real, dconst0)
> + else if (real_equal (&real, &dconst0)
> || (const_type != type
> - && REAL_VALUES_EQUAL (real_trunc, dconst0)))
> + && real_equal (&real_trunc, &dconst0)))
> {
> REAL_VALUE_TYPE realvoidmode;
> int oflow = real_from_string (&realvoidmode, copy);
> @@ -924,7 +924,7 @@ interpret_float (const cpp_token *token, unsigned int flags,
> : (oflow < 0 ? OT_UNDERFLOW : OT_OVERFLOW));
> if (!(flags & CPP_N_USERDEF))
> {
> - if (oflow < 0 || !REAL_VALUES_EQUAL (realvoidmode, dconst0))
> + if (oflow < 0 || !real_equal (&realvoidmode, &dconst0))
> warning (OPT_Woverflow, "floating constant truncated to zero");
> }
> }
> diff --git a/gcc/c/c-typeck.c b/gcc/c/c-typeck.c
> index ad02d6c..10cad36 100644
> --- a/gcc/c/c-typeck.c
> +++ b/gcc/c/c-typeck.c
> @@ -12758,7 +12758,7 @@ c_tree_equal (tree t1, tree t2)
> return wi::eq_p (t1, t2);
>
> case REAL_CST:
> - return REAL_VALUES_EQUAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
> + return real_equal (&TREE_REAL_CST (t1), &TREE_REAL_CST (t2));
>
> case STRING_CST:
> return TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
> diff --git a/gcc/config/aarch64/aarch64.c b/gcc/config/aarch64/aarch64.c
> index d4c5665..a1057c9 100644
> --- a/gcc/config/aarch64/aarch64.c
> +++ b/gcc/config/aarch64/aarch64.c
> @@ -3771,7 +3771,7 @@ aarch64_float_const_zero_rtx_p (rtx x)
> REAL_VALUE_FROM_CONST_DOUBLE (r, x);
> if (REAL_VALUE_MINUS_ZERO (r))
> return !HONOR_SIGNED_ZEROS (GET_MODE (x));
> - return REAL_VALUES_EQUAL (r, dconst0);
> + return real_equal (&r, &dconst0);
> }
>
> /* Return the fixed registers used for condition codes. */
> diff --git a/gcc/config/arm/arm.c b/gcc/config/arm/arm.c
> index 02f5dc3..184ce50 100644
> --- a/gcc/config/arm/arm.c
> +++ b/gcc/config/arm/arm.c
> @@ -12107,7 +12107,7 @@ arm_const_double_rtx (rtx x)
> if (REAL_VALUE_MINUS_ZERO (r))
> return 0;
>
> - if (REAL_VALUES_EQUAL (r, value_fp0))
> + if (real_equal (&r, &value_fp0))
> return 1;
>
> return 0;
> @@ -12319,7 +12319,7 @@ neon_valid_immediate (rtx op, machine_mode mode, int inverse,
>
> REAL_VALUE_FROM_CONST_DOUBLE (re, elt);
>
> - if (!REAL_VALUES_EQUAL (r0, re))
> + if (!real_equal (&r0, &re))
> return -1;
> }
>
> @@ -17594,7 +17594,7 @@ fp_const_from_val (REAL_VALUE_TYPE *r)
> if (!fp_consts_inited)
> init_fp_table ();
>
> - gcc_assert (REAL_VALUES_EQUAL (*r, value_fp0));
> + gcc_assert (real_equal (r, &value_fp0));
> return "0";
> }
>
> diff --git a/gcc/config/fr30/fr30.c b/gcc/config/fr30/fr30.c
> index 3308b55..0cac6ce 100644
> --- a/gcc/config/fr30/fr30.c
> +++ b/gcc/config/fr30/fr30.c
> @@ -895,7 +895,7 @@ fr30_const_double_is_zero (rtx operand)
>
> REAL_VALUE_FROM_CONST_DOUBLE (d, operand);
>
> - return REAL_VALUES_EQUAL (d, dconst0);
> + return real_equal (&d, &dconst0);
> }
>
> /*}}}*/
> diff --git a/gcc/config/m68k/m68k.c b/gcc/config/m68k/m68k.c
> index c26f37b..b7d96a5 100644
> --- a/gcc/config/m68k/m68k.c
> +++ b/gcc/config/m68k/m68k.c
> @@ -4336,7 +4336,7 @@ standard_68881_constant_p (rtx x)
>
> REAL_VALUE_FROM_CONST_DOUBLE (r, x);
>
> - /* Use REAL_VALUES_IDENTICAL instead of REAL_VALUES_EQUAL so that -0.0
> + /* Use REAL_VALUES_IDENTICAL instead of real_equal so that -0.0
> is rejected. */
> for (i = 0; i < 6; i++)
> {
> @@ -4347,7 +4347,7 @@ standard_68881_constant_p (rtx x)
> if (GET_MODE (x) == SFmode)
> return 0;
>
> - if (REAL_VALUES_EQUAL (r, values_68881[6]))
> + if (real_equal (&r, &values_68881[6]))
> return (codes_68881[6]);
>
> /* larger powers of ten in the constants ram are not used
> @@ -4371,7 +4371,7 @@ floating_exact_log2 (rtx x)
>
> exp = real_exponent (&r);
> real_2expN (&r1, exp, DFmode);
> - if (REAL_VALUES_EQUAL (r1, r))
> + if (real_equal (&r1, &r))
> return exp;
>
> return 0;
> diff --git a/gcc/config/sh/sh.c b/gcc/config/sh/sh.c
> index 904201b..a0d2e16 100644
> --- a/gcc/config/sh/sh.c
> +++ b/gcc/config/sh/sh.c
> @@ -10006,7 +10006,7 @@ fp_zero_operand (rtx op)
> return false;
>
> REAL_VALUE_FROM_CONST_DOUBLE (r, op);
> - return REAL_VALUES_EQUAL (r, dconst0) && ! REAL_VALUE_MINUS_ZERO (r);
> + return real_equal (&r, &dconst0) && ! REAL_VALUE_MINUS_ZERO (r);
> }
>
> /* Returns true if OP is a floating point value with value 1.0. */
> @@ -10019,7 +10019,7 @@ fp_one_operand (rtx op)
> return false;
>
> REAL_VALUE_FROM_CONST_DOUBLE (r, op);
> - return REAL_VALUES_EQUAL (r, dconst1);
> + return real_equal (&r, &dconst1);
> }
>
> /* Return the TLS type for TLS symbols. */
> diff --git a/gcc/config/vax/vax.c b/gcc/config/vax/vax.c
> index 7e0a2c2..2ad0e0ad 100644
> --- a/gcc/config/vax/vax.c
> +++ b/gcc/config/vax/vax.c
> @@ -661,11 +661,11 @@ vax_float_literal (rtx c)
> bool ok;
> real_from_integer (&s, mode, x, SIGNED);
>
> - if (REAL_VALUES_EQUAL (r, s))
> + if (real_equal (&r, &s))
> return true;
> ok = exact_real_inverse (mode, &s);
> gcc_assert (ok);
> - if (REAL_VALUES_EQUAL (r, s))
> + if (real_equal (&r, &s))
> return true;
> }
> return false;
> diff --git a/gcc/config/xtensa/predicates.md b/gcc/config/xtensa/predicates.md
> index d7dfa11..e297b82 100644
> --- a/gcc/config/xtensa/predicates.md
> +++ b/gcc/config/xtensa/predicates.md
> @@ -152,7 +152,7 @@
> {
> REAL_VALUE_TYPE d;
> REAL_VALUE_FROM_CONST_DOUBLE (d, op);
> - return REAL_VALUES_EQUAL (d, dconst1);
> + return real_equal (&d, &dconst1);
> })
>
> (define_predicate "fpmem_offset_operand"
> diff --git a/gcc/cp/tree.c b/gcc/cp/tree.c
> index 987ebe8..b9b801f 100644
> --- a/gcc/cp/tree.c
> +++ b/gcc/cp/tree.c
> @@ -2852,7 +2852,7 @@ cp_tree_equal (tree t1, tree t2)
> return tree_int_cst_equal (t1, t2);
>
> case REAL_CST:
> - return REAL_VALUES_EQUAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
> + return real_equal (&TREE_REAL_CST (t1), &TREE_REAL_CST (t2));
>
> case STRING_CST:
> return TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
> diff --git a/gcc/cprop.c b/gcc/cprop.c
> index 28e9e54..aa23a07 100644
> --- a/gcc/cprop.c
> +++ b/gcc/cprop.c
> @@ -1355,7 +1355,7 @@ implicit_set_cond_p (const_rtx cond)
> {
> REAL_VALUE_TYPE d;
> REAL_VALUE_FROM_CONST_DOUBLE (d, cst);
> - if (REAL_VALUES_EQUAL (d, dconst0))
> + if (real_equal (&d, &dconst0))
> return 0;
> }
> else
> diff --git a/gcc/doc/tm.texi b/gcc/doc/tm.texi
> index 610d6c1..fdd49d9 100644
> --- a/gcc/doc/tm.texi
> +++ b/gcc/doc/tm.texi
> @@ -9708,13 +9708,6 @@ array of @code{HOST_WIDE_INT}, but all code should treat it as an opaque
> quantity.
> @end defmac
>
> -@deftypefn Macro int REAL_VALUES_EQUAL (REAL_VALUE_TYPE @var{x}, REAL_VALUE_TYPE @var{y})
> -Compares for equality the two values, @var{x} and @var{y}. If the target
> -floating point format supports negative zeroes and/or NaNs,
> -@samp{REAL_VALUES_EQUAL (-0.0, 0.0)} is true, and
> -@samp{REAL_VALUES_EQUAL (NaN, NaN)} is false.
> -@end deftypefn
> -
> @deftypefn Macro int REAL_VALUES_LESS (REAL_VALUE_TYPE @var{x}, REAL_VALUE_TYPE @var{y})
> Tests whether @var{x} is less than @var{y}.
> @end deftypefn
> diff --git a/gcc/doc/tm.texi.in b/gcc/doc/tm.texi.in
> index 2ee0294..ab75ad9 100644
> --- a/gcc/doc/tm.texi.in
> +++ b/gcc/doc/tm.texi.in
> @@ -7131,13 +7131,6 @@ array of @code{HOST_WIDE_INT}, but all code should treat it as an opaque
> quantity.
> @end defmac
>
> -@deftypefn Macro int REAL_VALUES_EQUAL (REAL_VALUE_TYPE @var{x}, REAL_VALUE_TYPE @var{y})
> -Compares for equality the two values, @var{x} and @var{y}. If the target
> -floating point format supports negative zeroes and/or NaNs,
> -@samp{REAL_VALUES_EQUAL (-0.0, 0.0)} is true, and
> -@samp{REAL_VALUES_EQUAL (NaN, NaN)} is false.
> -@end deftypefn
> -
> @deftypefn Macro int REAL_VALUES_LESS (REAL_VALUE_TYPE @var{x}, REAL_VALUE_TYPE @var{y})
> Tests whether @var{x} is less than @var{y}.
> @end deftypefn
> diff --git a/gcc/expmed.c b/gcc/expmed.c
> index 604a957..07578e7 100644
> --- a/gcc/expmed.c
> +++ b/gcc/expmed.c
> @@ -3239,7 +3239,7 @@ expand_mult (machine_mode mode, rtx op0, rtx op1, rtx target,
> REAL_VALUE_TYPE d;
> REAL_VALUE_FROM_CONST_DOUBLE (d, scalar_op1);
>
> - if (REAL_VALUES_EQUAL (d, dconst2))
> + if (real_equal (&d, &dconst2))
> {
> op0 = force_reg (GET_MODE (op0), op0);
> return expand_binop (mode, add_optab, op0, op0,
> diff --git a/gcc/fold-const.c b/gcc/fold-const.c
> index 7231fd6..768b39b 100644
> --- a/gcc/fold-const.c
> +++ b/gcc/fold-const.c
> @@ -1176,7 +1176,7 @@ const_binop (enum tree_code code, tree arg1, tree arg2)
> /* Don't perform operation if it would raise a division
> by zero exception. */
> if (code == RDIV_EXPR
> - && REAL_VALUES_EQUAL (d2, dconst0)
> + && real_equal (&d2, &dconst0)
> && (flag_trapping_math || ! MODE_HAS_INFINITIES (mode)))
> return NULL_TREE;
>
> diff --git a/gcc/real.c b/gcc/real.c
> index c1ff78d..d47f32a 100644
> --- a/gcc/real.c
> +++ b/gcc/real.c
> @@ -1078,6 +1078,14 @@ real_value_abs (const REAL_VALUE_TYPE *op0)
> return r;
> }
>
> +/* Return whether OP0 == OP1. */
> +
> +bool
> +real_equal (const REAL_VALUE_TYPE *op0, const REAL_VALUE_TYPE *op1)
> +{
> + return do_compare (op0, op1, -1) == 0;
> +}
> +
> bool
> real_compare (int icode, const REAL_VALUE_TYPE *op0,
> const REAL_VALUE_TYPE *op1)
> @@ -1095,7 +1103,7 @@ real_compare (int icode, const REAL_VALUE_TYPE *op0,
> case GE_EXPR:
> return do_compare (op0, op1, -1) >= 0;
> case EQ_EXPR:
> - return do_compare (op0, op1, -1) == 0;
> + return real_equal (op0, op1);
> case NE_EXPR:
> return do_compare (op0, op1, -1) != 0;
> case UNORDERED_EXPR:
> diff --git a/gcc/real.h b/gcc/real.h
> index 455d853..2ffc0d2 100644
> --- a/gcc/real.h
> +++ b/gcc/real.h
> @@ -247,8 +247,9 @@ extern bool real_isneg (const REAL_VALUE_TYPE *);
> /* Determine whether a floating-point value X is minus zero. */
> extern bool real_isnegzero (const REAL_VALUE_TYPE *);
>
> -/* Compare two floating-point objects for bitwise identity. */
> +/* Test relationships between reals. */
> extern bool real_identical (const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
> +extern bool real_equal (const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
>
> /* Extend or truncate to a new mode. */
> extern void real_convert (REAL_VALUE_TYPE *, machine_mode,
> @@ -333,7 +334,6 @@ extern const struct real_format arm_half_format;
> real_arithmetic (&(value), code, &(d1), &(d2))
>
> #define REAL_VALUES_IDENTICAL(x, y) real_identical (&(x), &(y))
> -#define REAL_VALUES_EQUAL(x, y) real_compare (EQ_EXPR, &(x), &(y))
> #define REAL_VALUES_LESS(x, y) real_compare (LT_EXPR, &(x), &(y))
>
> /* Determine whether a floating-point value X is infinite. */
> diff --git a/gcc/simplify-rtx.c b/gcc/simplify-rtx.c
> index 8d86e57..b4d95a2 100644
> --- a/gcc/simplify-rtx.c
> +++ b/gcc/simplify-rtx.c
> @@ -2472,11 +2472,11 @@ simplify_binary_operation_1 (enum rtx_code code, machine_mode mode,
> REAL_VALUE_TYPE d;
> REAL_VALUE_FROM_CONST_DOUBLE (d, trueop1);
>
> - if (REAL_VALUES_EQUAL (d, dconst2))
> + if (real_equal (&d, &dconst2))
> return simplify_gen_binary (PLUS, mode, op0, copy_rtx (op0));
>
> if (!HONOR_SNANS (mode)
> - && REAL_VALUES_EQUAL (d, dconstm1))
> + && real_equal (&d, &dconstm1))
> return simplify_gen_unary (NEG, mode, op0, mode);
> }
>
> @@ -3102,14 +3102,14 @@ simplify_binary_operation_1 (enum rtx_code code, machine_mode mode,
> REAL_VALUE_FROM_CONST_DOUBLE (d, trueop1);
>
> /* x/-1.0 is -x. */
> - if (REAL_VALUES_EQUAL (d, dconstm1)
> + if (real_equal (&d, &dconstm1)
> && !HONOR_SNANS (mode))
> return simplify_gen_unary (NEG, mode, op0, mode);
>
> /* Change FP division by a constant into multiplication.
> Only do this with -freciprocal-math. */
> if (flag_reciprocal_math
> - && !REAL_VALUES_EQUAL (d, dconst0))
> + && !real_equal (&d, &dconst0))
> {
> REAL_ARITHMETIC (d, RDIV_EXPR, dconst1, d);
> tem = CONST_DOUBLE_FROM_REAL_VALUE (d, mode);
> @@ -3872,7 +3872,7 @@ simplify_const_binary_operation (enum rtx_code code, machine_mode mode,
> return 0;
>
> if (code == DIV
> - && REAL_VALUES_EQUAL (f1, dconst0)
> + && real_equal (&f1, &dconst0)
> && (flag_trapping_math || ! MODE_HAS_INFINITIES (mode)))
> return 0;
>
> @@ -3905,9 +3905,9 @@ simplify_const_binary_operation (enum rtx_code code, machine_mode mode,
>
> if (code == MULT && MODE_HAS_INFINITIES (mode) && HONOR_NANS (mode)
> && flag_trapping_math
> - && ((REAL_VALUE_ISINF (f0) && REAL_VALUES_EQUAL (f1, dconst0))
> + && ((REAL_VALUE_ISINF (f0) && real_equal (&f1, &dconst0))
> || (REAL_VALUE_ISINF (f1)
> - && REAL_VALUES_EQUAL (f0, dconst0))))
> + && real_equal (&f0, &dconst0))))
> /* Inf * 0 = NaN plus exception. */
> return 0;
>
> @@ -4942,7 +4942,7 @@ simplify_const_relational_operation (enum rtx_code code,
> }
>
> return comparison_result (code,
> - (REAL_VALUES_EQUAL (d0, d1) ? CMP_EQ :
> + (real_equal (&d0, &d1) ? CMP_EQ :
> REAL_VALUES_LESS (d0, d1) ? CMP_LT : CMP_GT));
> }
>
> diff --git a/gcc/tree-call-cdce.c b/gcc/tree-call-cdce.c
> index e872eda..7a0275a 100644
> --- a/gcc/tree-call-cdce.c
> +++ b/gcc/tree-call-cdce.c
> @@ -199,7 +199,7 @@ check_pow (gcall *pow_call)
> /* Only handle a fixed range of constant. */
> REAL_VALUE_TYPE mv;
> REAL_VALUE_TYPE bcv = TREE_REAL_CST (base);
> - if (REAL_VALUES_EQUAL (bcv, dconst1))
> + if (real_equal (&bcv, &dconst1))
> return false;
> if (REAL_VALUES_LESS (bcv, dconst1))
> return false;
> @@ -420,7 +420,7 @@ gen_conditions_for_pow_cst_base (tree base, tree expn,
> sure it is consistent with check_pow. */
> REAL_VALUE_TYPE mv;
> REAL_VALUE_TYPE bcv = TREE_REAL_CST (base);
> - gcc_assert (!REAL_VALUES_EQUAL (bcv, dconst1)
> + gcc_assert (!real_equal (&bcv, &dconst1)
> && !REAL_VALUES_LESS (bcv, dconst1));
> real_from_integer (&mv, TYPE_MODE (TREE_TYPE (base)), 256, UNSIGNED);
> gcc_assert (!REAL_VALUES_LESS (mv, bcv));
> diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c
> index ac9586e..9b525f3 100644
> --- a/gcc/tree-inline.c
> +++ b/gcc/tree-inline.c
> @@ -4092,8 +4092,9 @@ estimate_num_insns (gimple *stmt, eni_weights *weights)
> case BUILT_IN_POWF:
> case BUILT_IN_POWL:
> if (TREE_CODE (gimple_call_arg (stmt, 1)) == REAL_CST
> - && REAL_VALUES_EQUAL
> - (TREE_REAL_CST (gimple_call_arg (stmt, 1)), dconst2))
> + && (real_equal
> + (&TREE_REAL_CST (gimple_call_arg (stmt, 1)),
> + &dconst2)))
> return estimate_operator_cost
> (MULT_EXPR, weights, gimple_call_arg (stmt, 0),
> gimple_call_arg (stmt, 0));
> diff --git a/gcc/tree-ssa-dom.c b/gcc/tree-ssa-dom.c
> index d940816..c226da5 100644
> --- a/gcc/tree-ssa-dom.c
> +++ b/gcc/tree-ssa-dom.c
> @@ -1158,7 +1158,7 @@ record_equality (tree x, tree y, class const_and_copies *const_and_copies)
> nonzero. */
> if (HONOR_SIGNED_ZEROS (x)
> && (TREE_CODE (y) != REAL_CST
> - || REAL_VALUES_EQUAL (dconst0, TREE_REAL_CST (y))))
> + || real_equal (&dconst0, &TREE_REAL_CST (y))))
> return;
>
> const_and_copies->record_const_or_copy (x, y, prev_x);
> diff --git a/gcc/tree-ssa-math-opts.c b/gcc/tree-ssa-math-opts.c
> index 9747739..63245fc 100644
> --- a/gcc/tree-ssa-math-opts.c
> +++ b/gcc/tree-ssa-math-opts.c
> @@ -1145,7 +1145,7 @@ representable_as_half_series_p (REAL_VALUE_TYPE c, unsigned n,
>
> /* We have hit zero. The number is representable as a sum
> of powers of 0.5. */
> - if (REAL_VALUES_EQUAL (res, dconst0))
> + if (real_equal (&res, &dconst0))
> {
> info->factors[i] = true;
> info->deepest = i + 1;
> @@ -1509,7 +1509,7 @@ gimple_expand_builtin_pow (gimple_stmt_iterator *gsi, location_t loc,
> unless signed zeros must be maintained. pow(-0,0.5) = +0, while
> sqrt(-0) = -0. */
> if (sqrtfn
> - && REAL_VALUES_EQUAL (c, dconsthalf)
> + && real_equal (&c, &dconsthalf)
> && !HONOR_SIGNED_ZEROS (mode))
> return build_and_insert_call (gsi, loc, sqrtfn, arg0);
>
> @@ -1527,7 +1527,7 @@ gimple_expand_builtin_pow (gimple_stmt_iterator *gsi, location_t loc,
> if (flag_unsafe_math_optimizations
> && cbrtfn
> && (gimple_val_nonnegative_real_p (arg0) || !HONOR_NANS (mode))
> - && REAL_VALUES_EQUAL (c, dconst1_3))
> + && real_equal (&c, &dconst1_3))
> return build_and_insert_call (gsi, loc, cbrtfn, arg0);
>
> /* Optimize pow(x,1./6.) = cbrt(sqrt(x)). Don't do this optimization
> @@ -1541,7 +1541,7 @@ gimple_expand_builtin_pow (gimple_stmt_iterator *gsi, location_t loc,
> && (gimple_val_nonnegative_real_p (arg0) || !HONOR_NANS (mode))
> && speed_p
> && hw_sqrt_exists
> - && REAL_VALUES_EQUAL (c, dconst1_6))
> + && real_equal (&c, &dconst1_6))
> {
> /* sqrt(x) */
> sqrt_arg0 = build_and_insert_call (gsi, loc, sqrtfn, arg0);
> @@ -1556,7 +1556,7 @@ gimple_expand_builtin_pow (gimple_stmt_iterator *gsi, location_t loc,
> if (flag_unsafe_math_optimizations
> && sqrtfn
> && hw_sqrt_exists
> - && (speed_p || REAL_VALUES_EQUAL (c, dconst1_4))
> + && (speed_p || real_equal (&c, &dconst1_4))
> && !HONOR_SIGNED_ZEROS (mode))
> {
> unsigned int max_depth = speed_p
> @@ -3589,9 +3589,9 @@ pass_optimize_widening_mul::execute (function *fun)
> case BUILT_IN_POW:
> case BUILT_IN_POWL:
> if (TREE_CODE (gimple_call_arg (stmt, 1)) == REAL_CST
> - && REAL_VALUES_EQUAL
> - (TREE_REAL_CST (gimple_call_arg (stmt, 1)),
> - dconst2)
> + && real_equal
> + (&TREE_REAL_CST (gimple_call_arg (stmt, 1)),
> + &dconst2)
> && convert_mult_to_fma (stmt,
> gimple_call_arg (stmt, 0),
> gimple_call_arg (stmt, 0)))
> diff --git a/gcc/tree-ssa-uncprop.c b/gcc/tree-ssa-uncprop.c
> index d045341..0f16c50 100644
> --- a/gcc/tree-ssa-uncprop.c
> +++ b/gcc/tree-ssa-uncprop.c
> @@ -153,7 +153,7 @@ associate_equivalences_with_edges (void)
> this value unless we know that the value is nonzero. */
> if (HONOR_SIGNED_ZEROS (op0)
> && (TREE_CODE (op1) != REAL_CST
> - || REAL_VALUES_EQUAL (dconst0, TREE_REAL_CST (op1))))
> + || real_equal (&dconst0, &TREE_REAL_CST (op1))))
> continue;
>
> equivalency = XNEW (struct edge_equivalency);
> diff --git a/gcc/tree-vect-patterns.c b/gcc/tree-vect-patterns.c
> index 830801a..48b5298 100644
> --- a/gcc/tree-vect-patterns.c
> +++ b/gcc/tree-vect-patterns.c
> @@ -1084,7 +1084,7 @@ vect_recog_pow_pattern (vec<gimple *> *stmts, tree *type_in,
> if ((tree_fits_shwi_p (exp)
> && tree_to_shwi (exp) == 2)
> || (TREE_CODE (exp) == REAL_CST
> - && REAL_VALUES_EQUAL (TREE_REAL_CST (exp), dconst2)))
> + && real_equal (&TREE_REAL_CST (exp), &dconst2)))
> {
> *type_in = TREE_TYPE (base);
>
> @@ -1095,7 +1095,7 @@ vect_recog_pow_pattern (vec<gimple *> *stmts, tree *type_in,
>
> /* Catch square root. */
> if (TREE_CODE (exp) == REAL_CST
> - && REAL_VALUES_EQUAL (TREE_REAL_CST (exp), dconsthalf))
> + && real_equal (&TREE_REAL_CST (exp), &dconsthalf))
> {
> tree newfn = mathfn_built_in (TREE_TYPE (base), BUILT_IN_SQRT);
> *type_in = get_vectype_for_scalar_type (TREE_TYPE (base));
> diff --git a/gcc/tree.c b/gcc/tree.c
> index 3249a95..b432997 100644
> --- a/gcc/tree.c
> +++ b/gcc/tree.c
> @@ -2554,7 +2554,7 @@ real_zerop (const_tree expr)
> switch (TREE_CODE (expr))
> {
> case REAL_CST:
> - return REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst0)
> + return real_equal (&TREE_REAL_CST (expr), &dconst0)
> && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr))));
> case COMPLEX_CST:
> return real_zerop (TREE_REALPART (expr))
> @@ -2584,7 +2584,7 @@ real_onep (const_tree expr)
> switch (TREE_CODE (expr))
> {
> case REAL_CST:
> - return REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst1)
> + return real_equal (&TREE_REAL_CST (expr), &dconst1)
> && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr))));
> case COMPLEX_CST:
> return real_onep (TREE_REALPART (expr))
> @@ -2613,7 +2613,7 @@ real_minus_onep (const_tree expr)
> switch (TREE_CODE (expr))
> {
> case REAL_CST:
> - return REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconstm1)
> + return real_equal (&TREE_REAL_CST (expr), &dconstm1)
> && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr))));
> case COMPLEX_CST:
> return real_minus_onep (TREE_REALPART (expr))
>