#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
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:
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;
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;
*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);
}
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);
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;
}
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);
}
#include "gimple-fold.h"
#include "alloc-pool.h"
#include "tree-hash-traits.h"
+#include "case-cfn-macros.h"
namespace {
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. */
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
}
if (gcall *call = dyn_cast <gcall *> (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 <gassign *> (stmt))
process_assign_use (assign, rhs, info);
else if (gphi *phi = dyn_cast <gphi *> (stmt))
break;
}
else if (gcall *call = dyn_cast <gcall *> (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;
}
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)
tree var = m_vars[i].first;
gimple *stmt = SSA_NAME_DEF_STMT (var);
if (gcall *call = dyn_cast <gcall *> (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 <gassign *> (stmt))
optimize_assign (assign, var, info);
else if (gphi *phi = dyn_cast <gphi *> (stmt))
projects / gcc.git / commitdiff