From 1d9da71f4f1dcad2a5e2bd3a3e9fac6012a6049b Mon Sep 17 00:00:00 2001 From: Richard Sandiford Date: Tue, 17 Nov 2015 18:43:42 +0000 Subject: [PATCH] Make more use of combined_fn This patch generalises fold-const.[hc] routines to use combined_fn instead of built_in_function. It also updates gimple-ssa-backprop,c since the update is simple and it avoids churn on the call to negate_mathfn_p. Tested on x86_64-linux-gnu, aarch64-linux-gnu and arm-linux-gnueabi. gcc/ * fold-const.h (negate_mathfn_p): Take a combined_fn rather than a built_in_function. (tree_call_nonnegative_warnv_p): Take a combined_fn rather than a function decl. (integer_valued_real_call_p): Likewise. * fold-const.c: Include case-cfn-macros.h (negate_mathfn_p): Take a combined_fn rather than a built_in_function. (negate_expr_p): Update accordingly. (tree_call_nonnegative_warnv_p): Take a combined_fn rather than a function decl. (integer_valued_real_call_p): Likewise. (tree_invalid_nonnegative_warnv_p): Update accordingly. (integer_valued_real_p): Likewise. * gimple-fold.c (gimple_call_nonnegative_warnv_p): Update call to tree_call_nonnegative_warnv_p. (gimple_call_integer_valued_real_p): Likewise integer_valued_real_call_p. * gimple-ssa-backprop.c: Include case-cfn-macros.h. (backprop::process_builtin_call_use): Extend to combined_fn. (strip_sign_op_1): Likewise. (backprop::process_use): Don't check for built-in calls here. (backprop::execute): Likewise. (backprop::optimize_builtin_call): Update call to negate_mathfn_p. From-SVN: r230478 --- gcc/ChangeLog | 26 +++ gcc/fold-const.c | 321 +++++++++++++++++++------------------- gcc/fold-const.h | 8 +- gcc/gimple-fold.c | 4 +- gcc/gimple-ssa-backprop.c | 56 +++---- 5 files changed, 217 insertions(+), 198 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 93e3c520521..75ce9f8b1bf 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,29 @@ +2015-11-17 Richard Sandiford + + * fold-const.h (negate_mathfn_p): Take a combined_fn rather + than a built_in_function. + (tree_call_nonnegative_warnv_p): Take a combined_fn rather than + a function decl. + (integer_valued_real_call_p): Likewise. + * fold-const.c: Include case-cfn-macros.h + (negate_mathfn_p): Take a combined_fn rather than a built_in_function. + (negate_expr_p): Update accordingly. + (tree_call_nonnegative_warnv_p): Take a combined_fn rather than + a function decl. + (integer_valued_real_call_p): Likewise. + (tree_invalid_nonnegative_warnv_p): Update accordingly. + (integer_valued_real_p): Likewise. + * gimple-fold.c (gimple_call_nonnegative_warnv_p): Update call + to tree_call_nonnegative_warnv_p. + (gimple_call_integer_valued_real_p): Likewise + integer_valued_real_call_p. + * gimple-ssa-backprop.c: Include case-cfn-macros.h. + (backprop::process_builtin_call_use): Extend to combined_fn. + (strip_sign_op_1): Likewise. + (backprop::process_use): Don't check for built-in calls here. + (backprop::execute): Likewise. + (backprop::optimize_builtin_call): Update call to negate_mathfn_p. + 2015-11-17 Richard Sandiford * fold-const-call.h (fold_const_call): Replace built_in_function diff --git a/gcc/fold-const.c b/gcc/fold-const.c index ce59c488b7e..698062ee814 100644 --- a/gcc/fold-const.c +++ b/gcc/fold-const.c @@ -73,6 +73,7 @@ along with GCC; see the file COPYING3. If not see #include "params.h" #include "tree-into-ssa.h" #include "md5.h" +#include "case-cfn-macros.h" #ifndef LOAD_EXTEND_OP #define LOAD_EXTEND_OP(M) UNKNOWN @@ -313,39 +314,39 @@ fold_overflow_warning (const char* gmsgid, enum warn_strict_overflow_code wc) is odd, i.e. -f(x) == f(-x). */ bool -negate_mathfn_p (enum built_in_function code) -{ - switch (code) - { - CASE_FLT_FN (BUILT_IN_ASIN): - CASE_FLT_FN (BUILT_IN_ASINH): - CASE_FLT_FN (BUILT_IN_ATAN): - CASE_FLT_FN (BUILT_IN_ATANH): - CASE_FLT_FN (BUILT_IN_CASIN): - CASE_FLT_FN (BUILT_IN_CASINH): - CASE_FLT_FN (BUILT_IN_CATAN): - CASE_FLT_FN (BUILT_IN_CATANH): - CASE_FLT_FN (BUILT_IN_CBRT): - CASE_FLT_FN (BUILT_IN_CPROJ): - CASE_FLT_FN (BUILT_IN_CSIN): - CASE_FLT_FN (BUILT_IN_CSINH): - CASE_FLT_FN (BUILT_IN_CTAN): - CASE_FLT_FN (BUILT_IN_CTANH): - CASE_FLT_FN (BUILT_IN_ERF): - CASE_FLT_FN (BUILT_IN_LLROUND): - CASE_FLT_FN (BUILT_IN_LROUND): - CASE_FLT_FN (BUILT_IN_ROUND): - CASE_FLT_FN (BUILT_IN_SIN): - CASE_FLT_FN (BUILT_IN_SINH): - CASE_FLT_FN (BUILT_IN_TAN): - CASE_FLT_FN (BUILT_IN_TANH): - CASE_FLT_FN (BUILT_IN_TRUNC): +negate_mathfn_p (combined_fn fn) +{ + switch (fn) + { + CASE_CFN_ASIN: + CASE_CFN_ASINH: + CASE_CFN_ATAN: + CASE_CFN_ATANH: + CASE_CFN_CASIN: + CASE_CFN_CASINH: + CASE_CFN_CATAN: + CASE_CFN_CATANH: + CASE_CFN_CBRT: + CASE_CFN_CPROJ: + CASE_CFN_CSIN: + CASE_CFN_CSINH: + CASE_CFN_CTAN: + CASE_CFN_CTANH: + CASE_CFN_ERF: + CASE_CFN_LLROUND: + CASE_CFN_LROUND: + CASE_CFN_ROUND: + CASE_CFN_SIN: + CASE_CFN_SINH: + CASE_CFN_TAN: + CASE_CFN_TANH: + CASE_CFN_TRUNC: return true; - CASE_FLT_FN (BUILT_IN_LLRINT): - CASE_FLT_FN (BUILT_IN_LRINT): - CASE_FLT_FN (BUILT_IN_NEARBYINT): - CASE_FLT_FN (BUILT_IN_RINT): + CASE_CFN_LLRINT: + CASE_CFN_LRINT: + CASE_CFN_NEARBYINT: + CASE_CFN_RINT: return !flag_rounding_math; default: @@ -506,7 +507,7 @@ negate_expr_p (tree t) case CALL_EXPR: /* Negate -f(x) as f(-x). */ - if (negate_mathfn_p (builtin_mathfn_code (t))) + if (negate_mathfn_p (get_call_combined_fn (t))) return negate_expr_p (CALL_EXPR_ARG (t, 0)); break; @@ -693,7 +694,7 @@ fold_negate_expr (location_t loc, tree t) case CALL_EXPR: /* Negate -f(x) as f(-x). */ - if (negate_mathfn_p (builtin_mathfn_code (t)) + if (negate_mathfn_p (get_call_combined_fn (t)) && negate_expr_p (CALL_EXPR_ARG (t, 0))) { tree fndecl, arg; @@ -12910,121 +12911,120 @@ tree_single_nonnegative_warnv_p (tree t, bool *strict_overflow_p, int depth) *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */ bool -tree_call_nonnegative_warnv_p (tree type, tree fndecl, tree arg0, tree arg1, +tree_call_nonnegative_warnv_p (tree type, combined_fn fn, tree arg0, tree arg1, bool *strict_overflow_p, int depth) { - if (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL) - switch (DECL_FUNCTION_CODE (fndecl)) - { - CASE_FLT_FN (BUILT_IN_ACOS): - CASE_FLT_FN (BUILT_IN_ACOSH): - CASE_FLT_FN (BUILT_IN_CABS): - CASE_FLT_FN (BUILT_IN_COSH): - CASE_FLT_FN (BUILT_IN_ERFC): - CASE_FLT_FN (BUILT_IN_EXP): - CASE_FLT_FN (BUILT_IN_EXP10): - CASE_FLT_FN (BUILT_IN_EXP2): - CASE_FLT_FN (BUILT_IN_FABS): - CASE_FLT_FN (BUILT_IN_FDIM): - CASE_FLT_FN (BUILT_IN_HYPOT): - CASE_FLT_FN (BUILT_IN_POW10): - CASE_INT_FN (BUILT_IN_FFS): - CASE_INT_FN (BUILT_IN_PARITY): - CASE_INT_FN (BUILT_IN_POPCOUNT): - CASE_INT_FN (BUILT_IN_CLZ): - CASE_INT_FN (BUILT_IN_CLRSB): - case BUILT_IN_BSWAP32: - case BUILT_IN_BSWAP64: - /* Always true. */ - return true; + switch (fn) + { + CASE_CFN_ACOS: + CASE_CFN_ACOSH: + CASE_CFN_CABS: + CASE_CFN_COSH: + CASE_CFN_ERFC: + CASE_CFN_EXP: + CASE_CFN_EXP10: + CASE_CFN_EXP2: + CASE_CFN_FABS: + CASE_CFN_FDIM: + CASE_CFN_HYPOT: + CASE_CFN_POW10: + CASE_CFN_FFS: + CASE_CFN_PARITY: + CASE_CFN_POPCOUNT: + CASE_CFN_CLZ: + CASE_CFN_CLRSB: + case CFN_BUILT_IN_BSWAP32: + case CFN_BUILT_IN_BSWAP64: + /* Always true. */ + return true; - CASE_FLT_FN (BUILT_IN_SQRT): - /* sqrt(-0.0) is -0.0. */ - if (!HONOR_SIGNED_ZEROS (element_mode (type))) - return true; - return RECURSE (arg0); - - CASE_FLT_FN (BUILT_IN_ASINH): - CASE_FLT_FN (BUILT_IN_ATAN): - CASE_FLT_FN (BUILT_IN_ATANH): - CASE_FLT_FN (BUILT_IN_CBRT): - CASE_FLT_FN (BUILT_IN_CEIL): - CASE_FLT_FN (BUILT_IN_ERF): - CASE_FLT_FN (BUILT_IN_EXPM1): - CASE_FLT_FN (BUILT_IN_FLOOR): - CASE_FLT_FN (BUILT_IN_FMOD): - CASE_FLT_FN (BUILT_IN_FREXP): - CASE_FLT_FN (BUILT_IN_ICEIL): - CASE_FLT_FN (BUILT_IN_IFLOOR): - CASE_FLT_FN (BUILT_IN_IRINT): - CASE_FLT_FN (BUILT_IN_IROUND): - CASE_FLT_FN (BUILT_IN_LCEIL): - CASE_FLT_FN (BUILT_IN_LDEXP): - CASE_FLT_FN (BUILT_IN_LFLOOR): - CASE_FLT_FN (BUILT_IN_LLCEIL): - CASE_FLT_FN (BUILT_IN_LLFLOOR): - CASE_FLT_FN (BUILT_IN_LLRINT): - CASE_FLT_FN (BUILT_IN_LLROUND): - CASE_FLT_FN (BUILT_IN_LRINT): - CASE_FLT_FN (BUILT_IN_LROUND): - CASE_FLT_FN (BUILT_IN_MODF): - CASE_FLT_FN (BUILT_IN_NEARBYINT): - CASE_FLT_FN (BUILT_IN_RINT): - CASE_FLT_FN (BUILT_IN_ROUND): - CASE_FLT_FN (BUILT_IN_SCALB): - CASE_FLT_FN (BUILT_IN_SCALBLN): - CASE_FLT_FN (BUILT_IN_SCALBN): - CASE_FLT_FN (BUILT_IN_SIGNBIT): - CASE_FLT_FN (BUILT_IN_SIGNIFICAND): - CASE_FLT_FN (BUILT_IN_SINH): - CASE_FLT_FN (BUILT_IN_TANH): - CASE_FLT_FN (BUILT_IN_TRUNC): - /* True if the 1st argument is nonnegative. */ - return RECURSE (arg0); - - CASE_FLT_FN (BUILT_IN_FMAX): - /* True if the 1st OR 2nd arguments are nonnegative. */ - return RECURSE (arg0) || RECURSE (arg1); - - CASE_FLT_FN (BUILT_IN_FMIN): - /* True if the 1st AND 2nd arguments are nonnegative. */ - return RECURSE (arg0) && RECURSE (arg1); - - CASE_FLT_FN (BUILT_IN_COPYSIGN): - /* True if the 2nd argument is nonnegative. */ - return RECURSE (arg1); - - CASE_FLT_FN (BUILT_IN_POWI): - /* True if the 1st argument is nonnegative or the second - argument is an even integer. */ - if (TREE_CODE (arg1) == INTEGER_CST - && (TREE_INT_CST_LOW (arg1) & 1) == 0) - return true; - return RECURSE (arg0); + CASE_CFN_SQRT: + /* sqrt(-0.0) is -0.0. */ + if (!HONOR_SIGNED_ZEROS (element_mode (type))) + return true; + return RECURSE (arg0); + + CASE_CFN_ASINH: + CASE_CFN_ATAN: + CASE_CFN_ATANH: + CASE_CFN_CBRT: + CASE_CFN_CEIL: + CASE_CFN_ERF: + CASE_CFN_EXPM1: + CASE_CFN_FLOOR: + CASE_CFN_FMOD: + CASE_CFN_FREXP: + CASE_CFN_ICEIL: + CASE_CFN_IFLOOR: + CASE_CFN_IRINT: + CASE_CFN_IROUND: + CASE_CFN_LCEIL: + CASE_CFN_LDEXP: + CASE_CFN_LFLOOR: + CASE_CFN_LLCEIL: + CASE_CFN_LLFLOOR: + CASE_CFN_LLRINT: + CASE_CFN_LLROUND: + CASE_CFN_LRINT: + CASE_CFN_LROUND: + CASE_CFN_MODF: + CASE_CFN_NEARBYINT: + CASE_CFN_RINT: + CASE_CFN_ROUND: + CASE_CFN_SCALB: + CASE_CFN_SCALBLN: + CASE_CFN_SCALBN: + CASE_CFN_SIGNBIT: + CASE_CFN_SIGNIFICAND: + CASE_CFN_SINH: + CASE_CFN_TANH: + CASE_CFN_TRUNC: + /* True if the 1st argument is nonnegative. */ + return RECURSE (arg0); + + CASE_CFN_FMAX: + /* True if the 1st OR 2nd arguments are nonnegative. */ + return RECURSE (arg0) || RECURSE (arg1); + + CASE_CFN_FMIN: + /* True if the 1st AND 2nd arguments are nonnegative. */ + return RECURSE (arg0) && RECURSE (arg1); + + CASE_CFN_COPYSIGN: + /* True if the 2nd argument is nonnegative. */ + return RECURSE (arg1); + + CASE_CFN_POWI: + /* True if the 1st argument is nonnegative or the second + argument is an even integer. */ + if (TREE_CODE (arg1) == INTEGER_CST + && (TREE_INT_CST_LOW (arg1) & 1) == 0) + return true; + return RECURSE (arg0); - CASE_FLT_FN (BUILT_IN_POW): - /* True if the 1st argument is nonnegative or the second - argument is an even integer valued real. */ - if (TREE_CODE (arg1) == REAL_CST) - { - REAL_VALUE_TYPE c; - HOST_WIDE_INT n; + CASE_CFN_POW: + /* True if the 1st argument is nonnegative or the second + argument is an even integer valued real. */ + if (TREE_CODE (arg1) == REAL_CST) + { + REAL_VALUE_TYPE c; + HOST_WIDE_INT n; - c = TREE_REAL_CST (arg1); - n = real_to_integer (&c); - if ((n & 1) == 0) - { - REAL_VALUE_TYPE cint; - real_from_integer (&cint, VOIDmode, n, SIGNED); - if (real_identical (&c, &cint)) - return true; - } - } - return RECURSE (arg0); + c = TREE_REAL_CST (arg1); + n = real_to_integer (&c); + if ((n & 1) == 0) + { + REAL_VALUE_TYPE cint; + real_from_integer (&cint, VOIDmode, n, SIGNED); + if (real_identical (&c, &cint)) + return true; + } + } + return RECURSE (arg0); - default: - break; - } + default: + break; + } return tree_simple_nonnegative_warnv_p (CALL_EXPR, type); } @@ -13079,7 +13079,7 @@ tree_invalid_nonnegative_warnv_p (tree t, bool *strict_overflow_p, int depth) tree arg1 = call_expr_nargs (t) > 1 ? CALL_EXPR_ARG (t, 1) : NULL_TREE; return tree_call_nonnegative_warnv_p (TREE_TYPE (t), - get_callee_fndecl (t), + get_call_combined_fn (t), arg0, arg1, strict_overflow_p, depth); @@ -13482,26 +13482,25 @@ integer_valued_real_binary_p (tree_code code, tree op0, tree op1, int depth) DEPTH is the current nesting depth of the query. */ bool -integer_valued_real_call_p (tree fndecl, tree arg0, tree arg1, int depth) +integer_valued_real_call_p (combined_fn fn, tree arg0, tree arg1, int depth) { - if (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL) - switch (DECL_FUNCTION_CODE (fndecl)) - { - CASE_FLT_FN (BUILT_IN_CEIL): - CASE_FLT_FN (BUILT_IN_FLOOR): - CASE_FLT_FN (BUILT_IN_NEARBYINT): - CASE_FLT_FN (BUILT_IN_RINT): - CASE_FLT_FN (BUILT_IN_ROUND): - CASE_FLT_FN (BUILT_IN_TRUNC): - return true; + switch (fn) + { + CASE_CFN_CEIL: + CASE_CFN_FLOOR: + CASE_CFN_NEARBYINT: + CASE_CFN_RINT: + CASE_CFN_ROUND: + CASE_CFN_TRUNC: + return true; - CASE_FLT_FN (BUILT_IN_FMIN): - CASE_FLT_FN (BUILT_IN_FMAX): - return RECURSE (arg0) && RECURSE (arg1); + CASE_CFN_FMIN: + CASE_CFN_FMAX: + return RECURSE (arg0) && RECURSE (arg1); - default: - break; - } + default: + break; + } return false; } @@ -13612,7 +13611,7 @@ integer_valued_real_p (tree t, int depth) tree arg1 = (call_expr_nargs (t) > 1 ? CALL_EXPR_ARG (t, 1) : NULL_TREE); - return integer_valued_real_call_p (get_callee_fndecl (t), + return integer_valued_real_call_p (get_call_combined_fn (t), arg0, arg1, depth); } diff --git a/gcc/fold-const.h b/gcc/fold-const.h index 94a21b7652a..7741802981e 100644 --- a/gcc/fold-const.h +++ b/gcc/fold-const.h @@ -137,12 +137,12 @@ extern bool tree_unary_nonnegative_warnv_p (enum tree_code, tree, tree, extern bool tree_binary_nonnegative_warnv_p (enum tree_code, tree, tree, tree, bool *, int); extern bool tree_single_nonnegative_warnv_p (tree, bool *, int); -extern bool tree_call_nonnegative_warnv_p (tree, tree, tree, tree, bool *, - int); +extern bool tree_call_nonnegative_warnv_p (tree, combined_fn, tree, tree, + bool *, int); extern bool integer_valued_real_unary_p (tree_code, tree, int); extern bool integer_valued_real_binary_p (tree_code, tree, tree, int); -extern bool integer_valued_real_call_p (tree, tree, tree, int); +extern bool integer_valued_real_call_p (combined_fn, tree, tree, int); extern bool integer_valued_real_single_p (tree, int); extern bool integer_valued_real_p (tree, int = 0); @@ -179,7 +179,7 @@ extern tree sign_bit_p (tree, const_tree); extern tree exact_inverse (tree, tree); extern tree const_unop (enum tree_code, tree, tree); extern tree const_binop (enum tree_code, tree, tree, tree); -extern bool negate_mathfn_p (enum built_in_function); +extern bool negate_mathfn_p (combined_fn); extern const char *c_getstr (tree); /* Return OFF converted to a pointer offset type suitable as offset for diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c index fc095eb5bfc..436e29b37b7 100644 --- a/gcc/gimple-fold.c +++ b/gcc/gimple-fold.c @@ -6202,7 +6202,7 @@ gimple_call_nonnegative_warnv_p (gimple *stmt, bool *strict_overflow_p, gimple_call_arg (stmt, 1) : NULL_TREE; return tree_call_nonnegative_warnv_p (gimple_expr_type (stmt), - gimple_call_fndecl (stmt), + gimple_call_combined_fn (stmt), arg0, arg1, strict_overflow_p, depth); @@ -6295,7 +6295,7 @@ gimple_call_integer_valued_real_p (gimple *stmt, int depth) 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), + return integer_valued_real_call_p (gimple_call_combined_fn (stmt), arg0, arg1, depth); } diff --git a/gcc/gimple-ssa-backprop.c b/gcc/gimple-ssa-backprop.c index 91a3c79fb1c..d5736514dff 100644 --- a/gcc/gimple-ssa-backprop.c +++ b/gcc/gimple-ssa-backprop.c @@ -102,6 +102,7 @@ along with GCC; see the file COPYING3. If not see #include "gimple-fold.h" #include "alloc-pool.h" #include "tree-hash-traits.h" +#include "case-cfn-macros.h" namespace { @@ -337,26 +338,29 @@ backprop::pop_from_worklist () void backprop::process_builtin_call_use (gcall *call, tree rhs, usage_info *info) { - enum built_in_function fn = DECL_FUNCTION_CODE (gimple_call_fndecl (call)); + combined_fn fn = gimple_call_combined_fn (call); tree lhs = gimple_call_lhs (call); switch (fn) { - CASE_FLT_FN (BUILT_IN_COS): - CASE_FLT_FN (BUILT_IN_COSH): - CASE_FLT_FN (BUILT_IN_CCOS): - CASE_FLT_FN (BUILT_IN_CCOSH): - CASE_FLT_FN (BUILT_IN_HYPOT): + case CFN_LAST: + break; + + CASE_CFN_COS: + CASE_CFN_COSH: + CASE_CFN_CCOS: + CASE_CFN_CCOSH: + CASE_CFN_HYPOT: /* The signs of all inputs are ignored. */ info->flags.ignore_sign = true; break; - CASE_FLT_FN (BUILT_IN_COPYSIGN): + CASE_CFN_COPYSIGN: /* The sign of the first input is ignored. */ if (rhs != gimple_call_arg (call, 1)) info->flags.ignore_sign = true; break; - CASE_FLT_FN (BUILT_IN_POW): + CASE_CFN_POW: { /* The sign of the first input is ignored as long as the second input is an even real. */ @@ -369,7 +373,7 @@ backprop::process_builtin_call_use (gcall *call, tree rhs, usage_info *info) break; } - CASE_FLT_FN (BUILT_IN_FMA): + CASE_CFN_FMA: /* In X * X + Y, where Y is distinct from X, the sign of X doesn't matter. */ if (gimple_call_arg (call, 0) == rhs @@ -472,10 +476,7 @@ backprop::process_use (gimple *stmt, tree rhs, usage_info *info) } if (gcall *call = dyn_cast (stmt)) - { - if (gimple_call_builtin_p (call, BUILT_IN_NORMAL)) - process_builtin_call_use (call, rhs, info); - } + process_builtin_call_use (call, rhs, info); else if (gassign *assign = dyn_cast (stmt)) process_assign_use (assign, rhs, info); else if (gphi *phi = dyn_cast (stmt)) @@ -686,17 +687,14 @@ strip_sign_op_1 (tree rhs) break; } else if (gcall *call = dyn_cast (def_stmt)) - { - if (gimple_call_builtin_p (call, BUILT_IN_NORMAL)) - switch (DECL_FUNCTION_CODE (gimple_call_fndecl (call))) - { - CASE_FLT_FN (BUILT_IN_COPYSIGN): - return gimple_call_arg (call, 0); - - default: - break; - } - } + switch (gimple_call_combined_fn (call)) + { + CASE_CFN_COPYSIGN: + return gimple_call_arg (call, 0); + + default: + break; + } return NULL_TREE; } @@ -758,11 +756,10 @@ backprop::complete_change (gimple *stmt) void backprop::optimize_builtin_call (gcall *call, tree lhs, const usage_info *info) { - tree fndecl = gimple_call_fndecl (call); - enum built_in_function fn = DECL_FUNCTION_CODE (fndecl); /* If we have an f such that -f(x) = f(-x), and if the sign of the result doesn't matter, strip any sign operations from the input. */ - if (info->flags.ignore_sign && negate_mathfn_p (fn)) + if (info->flags.ignore_sign + && negate_mathfn_p (gimple_call_combined_fn (call))) { tree new_arg = strip_sign_op (gimple_call_arg (call, 0)); if (new_arg) @@ -889,10 +886,7 @@ backprop::execute () tree var = m_vars[i].first; gimple *stmt = SSA_NAME_DEF_STMT (var); if (gcall *call = dyn_cast (stmt)) - { - if (gimple_call_builtin_p (call, BUILT_IN_NORMAL)) - optimize_builtin_call (call, var, info); - } + optimize_builtin_call (call, var, info); else if (gassign *assign = dyn_cast (stmt)) optimize_assign (assign, var, info); else if (gphi *phi = dyn_cast (stmt)) -- 2.30.2