From: Jan Hubicka Date: Tue, 7 Jun 2016 11:22:26 +0000 (+0200) Subject: gimple.c: Include builtins.h X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=ce120587f3810484e8b939b7df69320d9f39420c;p=gcc.git gimple.c: Include builtins.h * gimple.c: Include builtins.h (gimple_inexpensive_call_p): New function. * gimple.h (gimple_inexpensive_call_p): Declare. * tree-ssa-loop-ch.c (should_duplicate_loop_header_p): Use it. * tree-ssa-loop-ivcanon.c (tree_estimate_loop_size): Likewise; fix formatting. From-SVN: r237172 --- diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 3c2825c99c7..16f8b60afaf 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,12 @@ +2016-06-07 Jan Hubicka + + * gimple.c: Include builtins.h + (gimple_inexpensive_call_p): New function. + * gimple.h (gimple_inexpensive_call_p): Declare. + * tree-ssa-loop-ch.c (should_duplicate_loop_header_p): Use it. + * tree-ssa-loop-ivcanon.c (tree_estimate_loop_size): Likewise; + fix formatting. + 2016-06-07 Paolo Carlini * diagnostic.c (diagnostic_impl, diagnostic_n_impl): New. diff --git a/gcc/gimple.c b/gcc/gimple.c index 178c1d3a517..677c5607090 100644 --- a/gcc/gimple.c +++ b/gcc/gimple.c @@ -38,6 +38,7 @@ along with GCC; see the file COPYING3. If not see #include "gimple-walk.h" #include "gimplify.h" #include "target.h" +#include "builtins.h" #include "selftest.h" #include "gimple-pretty-print.h" @@ -3025,6 +3026,19 @@ maybe_remove_unused_call_args (struct function *fn, gimple *stmt) } } +/* Return false if STMT will likely expand to real function call. */ + +bool +gimple_inexpensive_call_p (gcall *stmt) +{ + if (gimple_call_internal_p (stmt)) + return true; + tree decl = gimple_call_fndecl (stmt); + if (decl && is_inexpensive_builtin (decl)) + return true; + return false; +} + #if CHECKING_P namespace selftest { diff --git a/gcc/gimple.h b/gcc/gimple.h index 063e29d7897..1da719c52e0 100644 --- a/gcc/gimple.h +++ b/gcc/gimple.h @@ -1525,6 +1525,7 @@ extern void preprocess_case_label_vec_for_gimple (vec, tree, tree *); extern void gimple_seq_set_location (gimple_seq, location_t); extern void gimple_seq_discard (gimple_seq); extern void maybe_remove_unused_call_args (struct function *, gimple *); +extern bool gimple_inexpensive_call_p (gcall *); /* Formal (expression) temporary table handling: multiple occurrences of the same scalar expression are evaluated into the same temporary. */ diff --git a/gcc/tree-ssa-loop-ch.c b/gcc/tree-ssa-loop-ch.c index 3af09ece39e..0ddbda6da7e 100644 --- a/gcc/tree-ssa-loop-ch.c +++ b/gcc/tree-ssa-loop-ch.c @@ -118,7 +118,8 @@ should_duplicate_loop_header_p (basic_block header, struct loop *loop, if (is_gimple_debug (last)) continue; - if (is_gimple_call (last)) + if (gimple_code (last) == GIMPLE_CALL + && !gimple_inexpensive_call_p (as_a (last))) { if (dump_file && (dump_flags & TDF_DETAILS)) fprintf (dump_file, diff --git a/gcc/tree-ssa-loop-ivcanon.c b/gcc/tree-ssa-loop-ivcanon.c index 5a7c378a975..fff28ee8712 100644 --- a/gcc/tree-ssa-loop-ivcanon.c +++ b/gcc/tree-ssa-loop-ivcanon.c @@ -207,8 +207,8 @@ constant_after_peeling (tree op, gimple *stmt, struct loop *loop) Stop estimating after UPPER_BOUND is met. Return true in this case. */ static bool -tree_estimate_loop_size (struct loop *loop, edge exit, edge edge_to_cancel, struct loop_size *size, - int upper_bound) +tree_estimate_loop_size (struct loop *loop, edge exit, edge edge_to_cancel, + struct loop_size *size, int upper_bound) { basic_block *body = get_loop_body (loop); gimple_stmt_iterator gsi; @@ -236,7 +236,8 @@ tree_estimate_loop_size (struct loop *loop, edge exit, edge edge_to_cancel, stru else after_exit = false; if (dump_file && (dump_flags & TDF_DETAILS)) - fprintf (dump_file, " BB: %i, after_exit: %i\n", body[i]->index, after_exit); + fprintf (dump_file, " BB: %i, after_exit: %i\n", body[i]->index, + after_exit); for (gsi = gsi_start_bb (body[i]); !gsi_end_p (gsi); gsi_next (&gsi)) { @@ -285,20 +286,24 @@ tree_estimate_loop_size (struct loop *loop, edge exit, edge edge_to_cancel, stru /* Assignments of IV variables. */ else if (gimple_code (stmt) == GIMPLE_ASSIGN && TREE_CODE (gimple_assign_lhs (stmt)) == SSA_NAME - && constant_after_peeling (gimple_assign_rhs1 (stmt), stmt, loop) + && constant_after_peeling (gimple_assign_rhs1 (stmt), stmt, + loop) && (gimple_assign_rhs_class (stmt) != GIMPLE_BINARY_RHS || constant_after_peeling (gimple_assign_rhs2 (stmt), stmt, loop))) { size->constant_iv = true; if (dump_file && (dump_flags & TDF_DETAILS)) - fprintf (dump_file, " Constant expression will be folded away.\n"); + fprintf (dump_file, + " Constant expression will be folded away.\n"); likely_eliminated = true; } /* Conditionals. */ else if ((gimple_code (stmt) == GIMPLE_COND - && constant_after_peeling (gimple_cond_lhs (stmt), stmt, loop) - && constant_after_peeling (gimple_cond_rhs (stmt), stmt, loop) + && constant_after_peeling (gimple_cond_lhs (stmt), stmt, + loop) + && constant_after_peeling (gimple_cond_rhs (stmt), stmt, + loop) /* We don't simplify all constant compares so make sure they are not both constant already. See PR70288. */ && (! is_gimple_min_invariant (gimple_cond_lhs (stmt)) @@ -307,8 +312,8 @@ tree_estimate_loop_size (struct loop *loop, edge exit, edge edge_to_cancel, stru && constant_after_peeling (gimple_switch_index ( as_a (stmt)), stmt, loop) - && ! is_gimple_min_invariant (gimple_switch_index ( - as_a (stmt))))) + && ! is_gimple_min_invariant + (gimple_switch_index (as_a (stmt))))) { if (dump_file && (dump_flags & TDF_DETAILS)) fprintf (dump_file, " Constant conditional.\n"); @@ -339,26 +344,24 @@ tree_estimate_loop_size (struct loop *loop, edge exit, edge edge_to_cancel, stru for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) { gimple *stmt = gsi_stmt (gsi); - if (gimple_code (stmt) == GIMPLE_CALL) + if (gimple_code (stmt) == GIMPLE_CALL + && !gimple_inexpensive_call_p (as_a (stmt))) { int flags = gimple_call_flags (stmt); - tree decl = gimple_call_fndecl (stmt); - - if (decl && DECL_IS_BUILTIN (decl) - && is_inexpensive_builtin (decl)) - ; - else if (flags & (ECF_PURE | ECF_CONST)) + if (flags & (ECF_PURE | ECF_CONST)) size->num_pure_calls_on_hot_path++; else size->num_non_pure_calls_on_hot_path++; size->num_branches_on_hot_path ++; } - else if (gimple_code (stmt) != GIMPLE_CALL - && gimple_code (stmt) != GIMPLE_DEBUG) + /* Count inexpensive calls as non-calls, because they will likely + expand inline. */ + else if (gimple_code (stmt) != GIMPLE_DEBUG) size->non_call_stmts_on_hot_path++; if (((gimple_code (stmt) == GIMPLE_COND && (!constant_after_peeling (gimple_cond_lhs (stmt), stmt, loop) - || constant_after_peeling (gimple_cond_rhs (stmt), stmt, loop))) + || constant_after_peeling (gimple_cond_rhs (stmt), stmt, + loop))) || (gimple_code (stmt) == GIMPLE_SWITCH && !constant_after_peeling (gimple_switch_index ( as_a (stmt)),