diff options
author | Richard Sandiford <richard.sandiford@arm.com> | 2015-10-23 10:01:47 +0000 |
---|---|---|
committer | Richard Sandiford <rsandifo@gcc.gnu.org> | 2015-10-23 10:01:47 +0000 |
commit | 67dbe5829e2f9cac9deb756762cdaf5a8829cb31 (patch) | |
tree | 2104e5a46faba7156714cceac0b8be8dce7c9b63 /gcc/gimple-fold.c | |
parent | 735a559c68e208b9dd5b5a4bb7e109289743fbeb (diff) | |
download | gcc-67dbe5829e2f9cac9deb756762cdaf5a8829cb31.zip gcc-67dbe5829e2f9cac9deb756762cdaf5a8829cb31.tar.gz gcc-67dbe5829e2f9cac9deb756762cdaf5a8829cb31.tar.bz2 |
Move fold_trunc_transparent_mathfn to match.pd
This moves the fold rules for trunc, floor, ceil, round, nearbyint and
rint in one go, since they're tested as a group. Most of the code is
supporting the f(x)->x fold when x is known to be integer-valued.
Like with the non-negative test, this is probably more elegantly handled
by tracking range information for reals, but until that happens, I think
we should handle it analogously to tree_expr_nonnegative_p.
I've incorporated the fix for PR68031 in the new version of
integer_valued_real_p. However, it seemed confusing to test for an
SSA name at the head of the function rather than the case statement,
and not fall through to tree_simple_nonnegative_warnv_p (which
conceptually shouldn't care whether an update is in progress).
But tree_simple_nonnegative_warnv_p is a no-op for SSA names,
so I simply changed it to:
return (!name_registered_for_update_p (t)
&& depth < PARAM_VALUE (PARAM_MAX_SSA_NAME_QUERY_DEPTH)
&& gimple_stmt_nonnegative_warnv_p (SSA_NAME_DEF_STMT (t),
strict_overflow_p, depth));
and used that in the new code too.
Doing these folds later meant that IPA would start to use information
about the aborting sinf and floor in 20030125-1.c before the folds
kicked in. I changed them from noinline to weak to stop that.
Tested on x86_64-linux-gnu, aarch64-linux-gnu and arm-linux-gnueabi.
gcc/
* builtins.c (integer_valued_real_p): Move to fold-const.c.
(fold_trunc_transparent_mathfn, fold_builtin_trunc, fold_builtin_floor)
(fold_builtin_ceil, fold_builtin_round): Delete.
(fold_builtin_1): Handle constant trunc, floor, ceil and round
arguments here.
* convert.c (convert_to_real): Remove narrowing of rounding
functions.
* fold-const.h (integer_valued_real_unary_p)
(integer_valued_real_binary_p, integer_valued_real_call_p)
(integer_valued_real_single_p, integer_valued_real_p): Declare.
* fold-const.c (tree_single_nonnegative_warnv_p): Move
name_registered_for_update_p check to SSA_NAME case statement.
Don't call tree_simple_nonnegative_warnv_p for SSA names.
(integer_valued_real_unary_p, integer_valued_real_binary_p)
(integer_valued_real_call_p, integer_valued_real_single_p)
(integer_valued_real_invalid_p): New functions.
(integer_valued_real_p): Move from fold-const.c and rework
to call the functions above. Handle SSA names.
* gimple-fold.h (gimple_stmt_integer_valued_real_p): Declare.
* gimple-fold.c (gimple_assign_integer_valued_real_p)
(gimple_call_integer_valued_real_p, gimple_phi_integer_valued_real_p)
(gimple_stmt_integer_valued_real_p): New functions.
* match.pd: Fold f(f(x))->f(x) for fp->fp rounding functions f.
Fold f(x)->x for the same f if x is known to be integer-valued.
Fold f(extend(x))->extend(f'(x)) if doing so doesn't affect
the result. Canonicalize floor(x) as trunc(x) if x is
nonnegative.
gcc/testsuite/
* gcc.c-torture/execute/20030125-1.c (floor, floorf, sin, sinf):
Make weak rather than noinline.
* gcc.dg/builtins-57.c: Compile with -O.
* gcc.dg/torture/builtin-integral-1.c: Skip for -O0.
From-SVN: r229221
Diffstat (limited to 'gcc/gimple-fold.c')
-rw-r--r-- | gcc/gimple-fold.c | 88 |
1 files changed, 88 insertions, 0 deletions
diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c index 85ff018..1869c09 100644 --- a/gcc/gimple-fold.c +++ b/gcc/gimple-fold.c @@ -6266,3 +6266,91 @@ gimple_stmt_nonnegative_warnv_p (gimple *stmt, bool *strict_overflow_p, return false; } } + +/* Return true if the floating-point value computed by assignment STMT + is known to have an integer value. We also allow +Inf, -Inf and NaN + to be considered integer values. + + DEPTH is the current nesting depth of the query. */ + +static bool +gimple_assign_integer_valued_real_p (gimple *stmt, int depth) +{ + enum tree_code code = gimple_assign_rhs_code (stmt); + switch (get_gimple_rhs_class (code)) + { + case GIMPLE_UNARY_RHS: + return integer_valued_real_unary_p (gimple_assign_rhs_code (stmt), + gimple_assign_rhs1 (stmt), depth); + case GIMPLE_BINARY_RHS: + return integer_valued_real_binary_p (gimple_assign_rhs_code (stmt), + gimple_assign_rhs1 (stmt), + gimple_assign_rhs2 (stmt), depth); + case GIMPLE_TERNARY_RHS: + return false; + case GIMPLE_SINGLE_RHS: + return integer_valued_real_single_p (gimple_assign_rhs1 (stmt), depth); + case GIMPLE_INVALID_RHS: + break; + } + gcc_unreachable (); +} + +/* Return true if the floating-point value computed by call STMT is known + to have an integer value. We also allow +Inf, -Inf and NaN to be + considered integer values. + + DEPTH is the current nesting depth of the query. */ + +static bool +gimple_call_integer_valued_real_p (gimple *stmt, int depth) +{ + tree arg0 = (gimple_call_num_args (stmt) > 0 + ? gimple_call_arg (stmt, 0) + : NULL_TREE); + tree arg1 = (gimple_call_num_args (stmt) > 1 + ? gimple_call_arg (stmt, 1) + : NULL_TREE); + return integer_valued_real_call_p (gimple_call_fndecl (stmt), + arg0, arg1, depth); +} + +/* Return true if the floating-point result of phi STMT is known to have + an integer value. We also allow +Inf, -Inf and NaN to be considered + integer values. + + DEPTH is the current nesting depth of the query. */ + +static bool +gimple_phi_integer_valued_real_p (gimple *stmt, int depth) +{ + for (unsigned i = 0; i < gimple_phi_num_args (stmt); ++i) + { + tree arg = gimple_phi_arg_def (stmt, i); + if (!integer_valued_real_single_p (arg, depth + 1)) + return false; + } + return true; +} + +/* Return true if the floating-point value computed by STMT is known + to have an integer value. We also allow +Inf, -Inf and NaN to be + considered integer values. + + DEPTH is the current nesting depth of the query. */ + +bool +gimple_stmt_integer_valued_real_p (gimple *stmt, int depth) +{ + switch (gimple_code (stmt)) + { + case GIMPLE_ASSIGN: + return gimple_assign_integer_valued_real_p (stmt, depth); + case GIMPLE_CALL: + return gimple_call_integer_valued_real_p (stmt, depth); + case GIMPLE_PHI: + return gimple_phi_integer_valued_real_p (stmt, depth); + default: + return false; + } +} |