diff options
Diffstat (limited to 'gcc/tree-inline.c')
| -rw-r--r-- | gcc/tree-inline.c | 2154 |
1 files changed, 1404 insertions, 750 deletions
diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c index c0f4c880f7f..511270bffb3 100644 --- a/gcc/tree-inline.c +++ b/gcc/tree-inline.c @@ -56,13 +56,13 @@ along with GCC; see the file COPYING3. If not see /* I'm not real happy about this, but we need to handle gimple and non-gimple trees. */ -#include "tree-gimple.h" +#include "gimple.h" /* Inlining, Cloning, Versioning, Parallelization Inlining: a function body is duplicated, but the PARM_DECLs are remapped into VAR_DECLs, and non-void RETURN_EXPRs become - GIMPLE_MODIFY_STMTs that store to a dedicated returned-value variable. + MODIFY_EXPRs that store to a dedicated returned-value variable. The duplicated eh_region info of the copy will later be appended to the info for the caller; the eh_region info in copied throwing statements and RESX_EXPRs is adjusted accordingly. @@ -88,14 +88,7 @@ along with GCC; see the file COPYING3. If not see updated to point into the new body. (Note that the original callgraph node and edge list will not be altered.) - See the CALL_EXPR handling case in copy_body_r (). */ - -/* 0 if we should not perform inlining. - 1 if we should expand functions calls inline at the tree level. - 2 if we should consider *all* functions to be inline - candidates. */ - -int flag_inline_trees = 0; + See the CALL_EXPR handling case in copy_tree_body_r (). */ /* To Do: @@ -140,6 +133,7 @@ static void add_lexical_block (tree current_block, tree new_block); static tree copy_decl_to_var (tree, copy_body_data *); static tree copy_result_decl_to_var (tree, copy_body_data *); static tree copy_decl_maybe_to_var (tree, copy_body_data *); +static gimple remap_gimple_stmt (gimple, copy_body_data *); /* Insert a tree->tree mapping for ID. Despite the name suggests that the trees should be variables, it is used for more than that. */ @@ -172,6 +166,7 @@ remap_ssa_name (tree name, copy_body_data *id) /* Do not set DEF_STMT yet as statement is not copied yet. We do that in copy_bb. */ new = remap_decl (SSA_NAME_VAR (name), id); + /* We might've substituted constant or another SSA_NAME for the variable. @@ -187,36 +182,37 @@ remap_ssa_name (tree name, copy_body_data *id) SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new) = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name); TREE_TYPE (new) = TREE_TYPE (SSA_NAME_VAR (new)); - if (IS_EMPTY_STMT (SSA_NAME_DEF_STMT (name))) + if (gimple_nop_p (SSA_NAME_DEF_STMT (name))) { /* By inlining function having uninitialized variable, we might extend the lifetime (variable might get reused). This cause ICE in the case we end up extending lifetime of SSA name across abnormal edge, but also increase register pressure. - We simply initialize all uninitialized vars by 0 except for case - we are inlining to very first BB. We can avoid this for all - BBs that are not withing strongly connected regions of the CFG, - but this is bit expensive to test. - */ - if (id->entry_bb && is_gimple_reg (SSA_NAME_VAR (name)) + We simply initialize all uninitialized vars by 0 except + for case we are inlining to very first BB. We can avoid + this for all BBs that are not inside strongly connected + regions of the CFG, but this is expensive to test. */ + if (id->entry_bb + && is_gimple_reg (SSA_NAME_VAR (name)) && TREE_CODE (SSA_NAME_VAR (name)) != PARM_DECL && (id->entry_bb != EDGE_SUCC (ENTRY_BLOCK_PTR, 0)->dest || EDGE_COUNT (id->entry_bb->preds) != 1)) { - block_stmt_iterator bsi = bsi_last (id->entry_bb); - tree init_stmt - = build_gimple_modify_stmt (new, - fold_convert (TREE_TYPE (new), + gimple_stmt_iterator gsi = gsi_last_bb (id->entry_bb); + gimple init_stmt; + + init_stmt = gimple_build_assign (new, + fold_convert (TREE_TYPE (new), integer_zero_node)); - bsi_insert_after (&bsi, init_stmt, BSI_NEW_STMT); - SSA_NAME_DEF_STMT (new) = init_stmt; + gsi_insert_after (&gsi, init_stmt, GSI_NEW_STMT); SSA_NAME_IS_DEFAULT_DEF (new) = 0; } else { - SSA_NAME_DEF_STMT (new) = build_empty_stmt (); - if (gimple_default_def (id->src_cfun, SSA_NAME_VAR (name)) == name) + SSA_NAME_DEF_STMT (new) = gimple_build_nop (); + if (gimple_default_def (id->src_cfun, SSA_NAME_VAR (name)) + == name) set_default_def (SSA_NAME_VAR (new), new); } } @@ -262,15 +258,15 @@ remap_decl (tree decl, copy_body_data *id) DECL_ORIGINAL_TYPE (t) = remap_type (DECL_ORIGINAL_TYPE (t), id); /* Remap sizes as necessary. */ - walk_tree (&DECL_SIZE (t), copy_body_r, id, NULL); - walk_tree (&DECL_SIZE_UNIT (t), copy_body_r, id, NULL); + walk_tree (&DECL_SIZE (t), copy_tree_body_r, id, NULL); + walk_tree (&DECL_SIZE_UNIT (t), copy_tree_body_r, id, NULL); /* If fields, do likewise for offset and qualifier. */ if (TREE_CODE (t) == FIELD_DECL) { - walk_tree (&DECL_FIELD_OFFSET (t), copy_body_r, id, NULL); + walk_tree (&DECL_FIELD_OFFSET (t), copy_tree_body_r, id, NULL); if (TREE_CODE (DECL_CONTEXT (t)) == QUAL_UNION_TYPE) - walk_tree (&DECL_QUALIFIER (t), copy_body_r, id, NULL); + walk_tree (&DECL_QUALIFIER (t), copy_tree_body_r, id, NULL); } if (cfun && gimple_in_ssa_p (cfun) @@ -285,7 +281,7 @@ remap_decl (tree decl, copy_body_data *id) /* Watch out RESULT_DECLs whose SSA names map directly to them. */ if (TREE_CODE (map) == SSA_NAME - && IS_EMPTY_STMT (SSA_NAME_DEF_STMT (map))) + && gimple_nop_p (SSA_NAME_DEF_STMT (map))) set_default_def (t, map); } add_referenced_var (t); @@ -357,16 +353,16 @@ remap_type_1 (tree type, copy_body_data *id) case BOOLEAN_TYPE: t = TYPE_MIN_VALUE (new); if (t && TREE_CODE (t) != INTEGER_CST) - walk_tree (&TYPE_MIN_VALUE (new), copy_body_r, id, NULL); + walk_tree (&TYPE_MIN_VALUE (new), copy_tree_body_r, id, NULL); t = TYPE_MAX_VALUE (new); if (t && TREE_CODE (t) != INTEGER_CST) - walk_tree (&TYPE_MAX_VALUE (new), copy_body_r, id, NULL); + walk_tree (&TYPE_MAX_VALUE (new), copy_tree_body_r, id, NULL); return new; case FUNCTION_TYPE: TREE_TYPE (new) = remap_type (TREE_TYPE (new), id); - walk_tree (&TYPE_ARG_TYPES (new), copy_body_r, id, NULL); + walk_tree (&TYPE_ARG_TYPES (new), copy_tree_body_r, id, NULL); return new; case ARRAY_TYPE: @@ -397,8 +393,8 @@ remap_type_1 (tree type, copy_body_data *id) gcc_unreachable (); } - walk_tree (&TYPE_SIZE (new), copy_body_r, id, NULL); - walk_tree (&TYPE_SIZE_UNIT (new), copy_body_r, id, NULL); + walk_tree (&TYPE_SIZE (new), copy_tree_body_r, id, NULL); + walk_tree (&TYPE_SIZE_UNIT (new), copy_tree_body_r, id, NULL); return new; } @@ -442,9 +438,10 @@ remap_decls (tree decls, copy_body_data *id) { tree new_var; - /* We can not chain the local static declarations into the local_decls - as we can't duplicate them or break one decl rule. Go ahead and link - them into local_decls. */ + /* We cannot chain the local static declarations into the local_decls + as we can't duplicate them or break one decl rule. Go ahead + and link them into local_decls. */ + if (!auto_var_in_fn_p (old_var, id->src_fn) && !DECL_EXTERNAL (old_var)) { @@ -456,7 +453,7 @@ remap_decls (tree decls, copy_body_data *id) /* Remap the variable. */ new_var = remap_decl (old_var, id); - /* If we didn't remap this variable, so we can't mess with its + /* If we didn't remap this variable, we can't mess with its TREE_CHAIN. If we remapped this variable to the return slot, it's already declared somewhere else, so don't declare it here. */ if (!new_var || new_var == id->retvar) @@ -552,11 +549,234 @@ copy_bind_expr (tree *tp, int *walk_subtrees, copy_body_data *id) BIND_EXPR_VARS (*tp) = remap_decls (BIND_EXPR_VARS (*tp), id); } -/* Called from copy_body_id via walk_tree. DATA is really an + +/* Create a new gimple_seq by remapping all the statements in BODY + using the inlining information in ID. */ + +gimple_seq +remap_gimple_seq (gimple_seq body, copy_body_data *id) +{ + gimple_stmt_iterator si; + gimple_seq new_body = NULL; + + for (si = gsi_start (body); !gsi_end_p (si); gsi_next (&si)) + { + gimple new_stmt = remap_gimple_stmt (gsi_stmt (si), id); + gimple_seq_add_stmt (&new_body, new_stmt); + } + + return new_body; +} + + +/* Copy a GIMPLE_BIND statement STMT, remapping all the symbols in its + block using the mapping information in ID. */ + +static gimple +copy_gimple_bind (gimple stmt, copy_body_data *id) +{ + gimple new_bind; + tree new_block, new_vars; + gimple_seq body, new_body; + + /* Copy the statement. Note that we purposely don't use copy_stmt + here because we need to remap statements as we copy. */ + body = gimple_bind_body (stmt); + new_body = remap_gimple_seq (body, id); + + new_block = gimple_bind_block (stmt); + if (new_block) + remap_block (&new_block, id); + + /* This will remap a lot of the same decls again, but this should be + harmless. */ + new_vars = gimple_bind_vars (stmt); + if (new_vars) + new_vars = remap_decls (new_vars, id); + + new_bind = gimple_build_bind (new_vars, new_body, new_block); + + return new_bind; +} + + +/* Remap the GIMPLE operand pointed to by *TP. DATA is really a + 'struct walk_stmt_info *'. DATA->INFO is a 'copy_body_data *'. + WALK_SUBTREES is used to indicate walk_gimple_op whether to keep + recursing into the children nodes of *TP. */ + +static tree +remap_gimple_op_r (tree *tp, int *walk_subtrees, void *data) +{ + struct walk_stmt_info *wi_p = (struct walk_stmt_info *) data; + copy_body_data *id = (copy_body_data *) wi_p->info; + tree fn = id->src_fn; + + if (TREE_CODE (*tp) == SSA_NAME) + { + *tp = remap_ssa_name (*tp, id); + *walk_subtrees = 0; + return NULL; + } + else if (auto_var_in_fn_p (*tp, fn)) + { + /* Local variables and labels need to be replaced by equivalent + variables. We don't want to copy static variables; there's + only one of those, no matter how many times we inline the + containing function. Similarly for globals from an outer + function. */ + tree new_decl; + + /* Remap the declaration. */ + new_decl = remap_decl (*tp, id); + gcc_assert (new_decl); + /* Replace this variable with the copy. */ + STRIP_TYPE_NOPS (new_decl); + *tp = new_decl; + *walk_subtrees = 0; + } + else if (TREE_CODE (*tp) == STATEMENT_LIST) + gcc_unreachable (); + else if (TREE_CODE (*tp) == SAVE_EXPR) + gcc_unreachable (); + else if (TREE_CODE (*tp) == LABEL_DECL + && (!DECL_CONTEXT (*tp) + || decl_function_context (*tp) == id->src_fn)) + /* These may need to be remapped for EH handling. */ + *tp = remap_decl (*tp, id); + else if (TYPE_P (*tp)) + /* Types may need remapping as well. */ + *tp = remap_type (*tp, id); + else if (CONSTANT_CLASS_P (*tp)) + { + /* If this is a constant, we have to copy the node iff the type + will be remapped. copy_tree_r will not copy a constant. */ + tree new_type = remap_type (TREE_TYPE (*tp), id); + + if (new_type == TREE_TYPE (*tp)) + *walk_subtrees = 0; + + else if (TREE_CODE (*tp) == INTEGER_CST) + *tp = build_int_cst_wide (new_type, TREE_INT_CST_LOW (*tp), + TREE_INT_CST_HIGH (*tp)); + else + { + *tp = copy_node (*tp); + TREE_TYPE (*tp) = new_type; + } + } + else + { + /* Otherwise, just copy the node. Note that copy_tree_r already + knows not to copy VAR_DECLs, etc., so this is safe. */ + if (TREE_CODE (*tp) == INDIRECT_REF) + { + /* Get rid of *& from inline substitutions that can happen when a + pointer argument is an ADDR_EXPR. */ + tree decl = TREE_OPERAND (*tp, 0); + tree *n; + + n = (tree *) pointer_map_contains (id->decl_map, decl); + if (n) + { + tree type, new, old; + + /* If we happen to get an ADDR_EXPR in n->value, strip + it manually here as we'll eventually get ADDR_EXPRs + which lie about their types pointed to. In this case + build_fold_indirect_ref wouldn't strip the + INDIRECT_REF, but we absolutely rely on that. As + fold_indirect_ref does other useful transformations, + try that first, though. */ + type = TREE_TYPE (TREE_TYPE (*n)); + new = unshare_expr (*n); + old = *tp; + *tp = gimple_fold_indirect_ref (new); + if (!*tp) + { + if (TREE_CODE (new) == ADDR_EXPR) + { + *tp = fold_indirect_ref_1 (type, new); + /* ??? We should either assert here or build + a VIEW_CONVERT_EXPR instead of blindly leaking + incompatible types to our IL. */ + if (! *tp) + *tp = TREE_OPERAND (new, 0); + } + else + { + *tp = build1 (INDIRECT_REF, type, new); + TREE_THIS_VOLATILE (*tp) = TREE_THIS_VOLATILE (old); + } + } + *walk_subtrees = 0; + return NULL; + } + } + + /* Here is the "usual case". Copy this tree node, and then + tweak some special cases. */ + copy_tree_r (tp, walk_subtrees, NULL); + + /* Global variables we haven't seen yet need to go into referenced + vars. If not referenced from types only. */ + if (gimple_in_ssa_p (cfun) + && TREE_CODE (*tp) == VAR_DECL + && id->remapping_type_depth == 0) + add_referenced_var (*tp); + + /* We should never have TREE_BLOCK set on non-statements. */ + if (EXPR_P (*tp)) + gcc_assert (!TREE_BLOCK (*tp)); + + if (TREE_CODE (*tp) != OMP_CLAUSE) + TREE_TYPE (*tp) = remap_type (TREE_TYPE (*tp), id); + + if (TREE_CODE (*tp) == TARGET_EXPR && TREE_OPERAND (*tp, 3)) + { + /* The copied TARGET_EXPR has never been expanded, even if the + original node was expanded already. */ + TREE_OPERAND (*tp, 1) = TREE_OPERAND (*tp, 3); + TREE_OPERAND (*tp, 3) = NULL_TREE; + } + else if (TREE_CODE (*tp) == ADDR_EXPR) + { + /* Variable substitution need not be simple. In particular, + the INDIRECT_REF substitution above. Make sure that + TREE_CONSTANT and friends are up-to-date. But make sure + to not improperly set TREE_BLOCK on some sub-expressions. */ + int invariant = is_gimple_min_invariant (*tp); + tree block = id->block; + id->block = NULL_TREE; + walk_tree (&TREE_OPERAND (*tp, 0), copy_tree_body_r, id, NULL); + id->block = block; + + /* Handle the case where we substituted an INDIRECT_REF + into the operand of the ADDR_EXPR. */ + if (TREE_CODE (TREE_OPERAND (*tp, 0)) == INDIRECT_REF) + *tp = TREE_OPERAND (TREE_OPERAND (*tp, 0), 0); + else + recompute_tree_invariant_for_addr_expr (*tp); + + /* If this used to be invariant, but is not any longer, + then regimplification is probably needed. */ + if (invariant && !is_gimple_min_invariant (*tp)) + id->regimplify = true; + + *walk_subtrees = 0; + } + } + + /* Keep iterating. */ + return NULL_TREE; +} + + +/* Called from copy_body_id via walk_tree. DATA is really a `copy_body_data *'. */ tree -copy_body_r (tree *tp, int *walk_subtrees, void *data) +copy_tree_body_r (tree *tp, int *walk_subtrees, void *data) { copy_body_data *id = (copy_body_data *) data; tree fn = id->src_fn; @@ -569,7 +789,7 @@ copy_body_r (tree *tp, int *walk_subtrees, void *data) duplicated and/or tweaked. */ /* When requested, RETURN_EXPRs should be transformed to just the - contained GIMPLE_MODIFY_STMT. The branch semantics of the return will + contained MODIFY_EXPR. The branch semantics of the return will be handled elsewhere by manipulating the CFG rather than a statement. */ if (TREE_CODE (*tp) == RETURN_EXPR && id->transform_return_to_modify) { @@ -580,10 +800,10 @@ copy_body_r (tree *tp, int *walk_subtrees, void *data) If the "assignment" is just the result decl, the result decl has already been set (e.g. a recent "foo (&result_decl, ...)"); just toss the entire RETURN_EXPR. */ - if (assignment && TREE_CODE (assignment) == GIMPLE_MODIFY_STMT) + if (assignment && TREE_CODE (assignment) == MODIFY_EXPR) { /* Replace the RETURN_EXPR with (a copy of) the - GIMPLE_MODIFY_STMT hanging underneath. */ + MODIFY_EXPR hanging underneath. */ *tp = copy_node (assignment); } else /* Else the RETURN_EXPR returns no value. */ @@ -656,14 +876,14 @@ copy_body_r (tree *tp, int *walk_subtrees, void *data) /* Here we handle trees that are not completely rewritten. First we detect some inlining-induced bogosities for discarding. */ - if (TREE_CODE (*tp) == GIMPLE_MODIFY_STMT - && GIMPLE_STMT_OPERAND (*tp, 0) == GIMPLE_STMT_OPERAND (*tp, 1) - && (auto_var_in_fn_p (GIMPLE_STMT_OPERAND (*tp, 0), fn))) + if (TREE_CODE (*tp) == MODIFY_EXPR + && TREE_OPERAND (*tp, 0) == TREE_OPERAND (*tp, 1) + && (auto_var_in_fn_p (TREE_OPERAND (*tp, 0), fn))) { /* Some assignments VAR = VAR; don't generate any rtl code and thus don't count as variable modification. Avoid keeping bogosities like 0 = 0. */ - tree decl = GIMPLE_STMT_OPERAND (*tp, 0), value; + tree decl = TREE_OPERAND (*tp, 0), value; tree *n; n = (tree *) pointer_map_contains (id->decl_map, decl); @@ -674,7 +894,7 @@ copy_body_r (tree *tp, int *walk_subtrees, void *data) if (TREE_CONSTANT (value) || TREE_READONLY (value)) { *tp = build_empty_stmt (); - return copy_body_r (tp, walk_subtrees, data); + return copy_tree_body_r (tp, walk_subtrees, data); } } } @@ -729,14 +949,15 @@ copy_body_r (tree *tp, int *walk_subtrees, void *data) /* Global variables we haven't seen yet needs to go into referenced vars. If not referenced from types only. */ - if (gimple_in_ssa_p (cfun) && TREE_CODE (*tp) == VAR_DECL + if (gimple_in_ssa_p (cfun) + && TREE_CODE (*tp) == VAR_DECL && id->remapping_type_depth == 0) add_referenced_var (*tp); /* If EXPR has block defined, map it to newly constructed block. When inlining we want EXPRs without block appear in the block of function call. */ - if (EXPR_P (*tp) || GIMPLE_STMT_P (*tp)) + if (EXPR_P (*tp)) { new_block = id->block; if (TREE_BLOCK (*tp)) @@ -752,11 +973,11 @@ copy_body_r (tree *tp, int *walk_subtrees, void *data) if (TREE_CODE (*tp) == RESX_EXPR && id->eh_region_offset) TREE_OPERAND (*tp, 0) = - build_int_cst - (NULL_TREE, - id->eh_region_offset + TREE_INT_CST_LOW (TREE_OPERAND (*tp, 0))); + build_int_cst (NULL_TREE, + id->eh_region_offset + + TREE_INT_CST_LOW (TREE_OPERAND (*tp, 0))); - if (!GIMPLE_TUPLE_P (*tp) && TREE_CODE (*tp) != OMP_CLAUSE) + if (TREE_CODE (*tp) != OMP_CLAUSE) TREE_TYPE (*tp) = remap_type (TREE_TYPE (*tp), id); /* The copied TARGET_EXPR has never been expanded, even if the @@ -773,17 +994,20 @@ copy_body_r (tree *tp, int *walk_subtrees, void *data) else if (TREE_CODE (*tp) == ADDR_EXPR) { int invariant = is_gimple_min_invariant (*tp); - walk_tree (&TREE_OPERAND (*tp, 0), copy_body_r, id, NULL); + walk_tree (&TREE_OPERAND (*tp, 0), copy_tree_body_r, id, NULL); + /* Handle the case where we substituted an INDIRECT_REF into the operand of the ADDR_EXPR. */ if (TREE_CODE (TREE_OPERAND (*tp, 0)) == INDIRECT_REF) *tp = TREE_OPERAND (TREE_OPERAND (*tp, 0), 0); else recompute_tree_invariant_for_addr_expr (*tp); + /* If this used to be invariant, but is not any longer, then regimplification is probably needed. */ if (invariant && !is_gimple_min_invariant (*tp)) id->regimplify = true; + *walk_subtrees = 0; } } @@ -792,6 +1016,209 @@ copy_body_r (tree *tp, int *walk_subtrees, void *data) return NULL_TREE; } + +/* Helper for copy_bb. Remap statement STMT using the inlining + information in ID. Return the new statement copy. */ + +static gimple +remap_gimple_stmt (gimple stmt, copy_body_data *id) +{ + gimple copy = NULL; + struct walk_stmt_info wi; + tree new_block; + + /* Begin by recognizing trees that we'll completely rewrite for the + inlining context. Our output for these trees is completely + different from out input (e.g. RETURN_EXPR is deleted, and morphs + into an edge). Further down, we'll handle trees that get + duplicated and/or tweaked. */ + + /* When requested, GIMPLE_RETURNs should be transformed to just the + contained GIMPLE_ASSIGN. The branch semantics of the return will + be handled elsewhere by manipulating the CFG rather than the + statement. */ + if (gimple_code (stmt) == GIMPLE_RETURN && id->transform_return_to_modify) + { + tree retval = gimple_return_retval (stmt); + + /* If we're returning something, just turn that into an + assignment into the equivalent of the original RESULT_DECL. + If RETVAL is just the result decl, the result decl has + already been set (e.g. a recent "foo (&result_decl, ...)"); + just toss the entire GIMPLE_RETURN. */ + if (retval && TREE_CODE (retval) != RESULT_DECL) + copy = gimple_build_assign (id->retvar, retval); + else + return gimple_build_nop (); + } + else if (gimple_has_substatements (stmt)) + { + gimple_seq s1, s2; + + /* When cloning bodies from the C++ front end, we will be handed bodies + in High GIMPLE form. Handle here all the High GIMPLE statements that + have embedded statements. */ + switch (gimple_code (stmt)) + { + case GIMPLE_BIND: + copy = copy_gimple_bind (stmt, id); + break; + + case GIMPLE_CATCH: + s1 = remap_gimple_seq (gimple_catch_handler (stmt), id); + copy = gimple_build_catch (gimple_catch_types (stmt), s1); + break; + + case GIMPLE_EH_FILTER: + s1 = remap_gimple_seq (gimple_eh_filter_failure (stmt), id); + copy = gimple_build_eh_filter (gimple_eh_filter_types (stmt), s1); + break; + + case GIMPLE_TRY: + s1 = remap_gimple_seq (gimple_try_eval (stmt), id); + s2 = remap_gimple_seq (gimple_try_cleanup (stmt), id); + copy = gimple_build_try (s1, s2, gimple_try_kind (stmt)); + break; + + case GIMPLE_WITH_CLEANUP_EXPR: + s1 = remap_gimple_seq (gimple_wce_cleanup (stmt), id); + copy = gimple_build_wce (s1); + break; + + case GIMPLE_OMP_PARALLEL: + s1 = remap_gimple_seq (gimple_omp_body (stmt), id); + copy = gimple_build_omp_parallel + (s1, + gimple_omp_parallel_clauses (stmt), + gimple_omp_parallel_child_fn (stmt), + gimple_omp_parallel_data_arg (stmt)); + break; + + case GIMPLE_OMP_TASK: + s1 = remap_gimple_seq (gimple_omp_body (stmt), id); + copy = gimple_build_omp_task + (s1, + gimple_omp_task_clauses (stmt), + gimple_omp_task_child_fn (stmt), + gimple_omp_task_data_arg (stmt), + gimple_omp_task_copy_fn (stmt), + gimple_omp_task_arg_size (stmt), + gimple_omp_task_arg_align (stmt)); + break; + + case GIMPLE_OMP_FOR: + s1 = remap_gimple_seq (gimple_omp_body (stmt), id); + s2 = remap_gimple_seq (gimple_omp_for_pre_body (stmt), id); + copy = gimple_build_omp_for (s1, gimple_omp_for_clauses (stmt), + gimple_omp_for_collapse (stmt), s2); + { + size_t i; + for (i = 0; i < gimple_omp_for_collapse (stmt); i++) + { + gimple_omp_for_set_index (copy, i, + gimple_omp_for_index (stmt, i)); + gimple_omp_for_set_initial (copy, i, + gimple_omp_for_initial (stmt, i)); + gimple_omp_for_set_final (copy, i, + gimple_omp_for_final (stmt, i)); + gimple_omp_for_set_incr (copy, i, + gimple_omp_for_incr (stmt, i)); + gimple_omp_for_set_cond (copy, i, + gimple_omp_for_cond (stmt, i)); + } + } + break; + + case GIMPLE_OMP_MASTER: + s1 = remap_gimple_seq (gimple_omp_body (stmt), id); + copy = gimple_build_omp_master (s1); + break; + + case GIMPLE_OMP_ORDERED: + s1 = remap_gimple_seq (gimple_omp_body (stmt), id); + copy = gimple_build_omp_ordered (s1); + break; + + case GIMPLE_OMP_SECTION: + s1 = remap_gimple_seq (gimple_omp_body (stmt), id); + copy = gimple_build_omp_section (s1); + break; + + case GIMPLE_OMP_SECTIONS: + s1 = remap_gimple_seq (gimple_omp_body (stmt), id); + copy = gimple_build_omp_sections + (s1, gimple_omp_sections_clauses (stmt)); + break; + + case GIMPLE_OMP_SINGLE: + s1 = remap_gimple_seq (gimple_omp_body (stmt), id); + copy = gimple_build_omp_single + (s1, gimple_omp_single_clauses (stmt)); + break; + + default: + gcc_unreachable (); + } + } + else + { + if (gimple_assign_copy_p (stmt) + && gimple_assign_lhs (stmt) == gimple_assign_rhs1 (stmt) + && auto_var_in_fn_p (gimple_assign_lhs (stmt), id->src_fn)) + { + /* Here we handle statements that are not completely rewritten. + First we detect some inlining-induced bogosities for + discarding. */ + + /* Some assignments VAR = VAR; don't generate any rtl code + and thus don't count as variable modification. Avoid + keeping bogosities like 0 = 0. */ + tree decl = gimple_assign_lhs (stmt), value; + tree *n; + + n = (tree *) pointer_map_contains (id->decl_map, decl); + if (n) + { + value = *n; + STRIP_TYPE_NOPS (value); + if (TREE_CONSTANT (value) || TREE_READONLY (value)) + return gimple_build_nop (); + } + } + + /* Create a new deep copy of the statement. */ + copy = gimple_copy (stmt); + } + + /* If STMT has a block defined, map it to the newly constructed + block. When inlining we want statements without a block to + appear in the block of the function call. */ + new_block = id->block; + if (gimple_block (copy)) + { + tree *n; + n = (tree *) pointer_map_contains (id->decl_map, gimple_block (copy)); + gcc_assert (n); + new_block = *n; + } + + gimple_set_block (copy, new_block); + + /* Remap all the operands in COPY. */ + memset (&wi, 0, sizeof (wi)); + wi.info = id; + walk_gimple_op (copy, remap_gimple_op_r, &wi); + + /* We have to handle EH region remapping of GIMPLE_RESX specially because + the region number is not an operand. */ + if (gimple_code (stmt) == GIMPLE_RESX && id->eh_region_offset) + { + gimple_resx_set_region (copy, gimple_resx_region (stmt) + id->eh_region_offset); + } + return copy; +} + + /* Copy basic block, scale profile accordingly. Edges will be taken care of later */ @@ -799,8 +1226,9 @@ static basic_block copy_bb (copy_body_data *id, basic_block bb, int frequency_scale, gcov_type count_scale) { - block_stmt_iterator bsi, copy_bsi; + gimple_stmt_iterator gsi, copy_gsi; basic_block copy_basic_block; + tree decl; /* create_basic_block() will append every new block to basic_block_info automatically. */ @@ -808,237 +1236,227 @@ copy_bb (copy_body_data *id, basic_block bb, int frequency_scale, (basic_block) bb->prev_bb->aux); copy_basic_block->count = bb->count * count_scale / REG_BR_PROB_BASE; - /* We are going to rebuild frequencies from scratch. These values have just - small importance to drive canonicalize_loop_headers. */ + /* We are going to rebuild frequencies from scratch. These values + have just small importance to drive canonicalize_loop_headers. */ copy_basic_block->frequency = ((gcov_type)bb->frequency - * frequency_scale / REG_BR_PROB_BASE); + * frequency_scale / REG_BR_PROB_BASE); + if (copy_basic_block->frequency > BB_FREQ_MAX) copy_basic_block->frequency = BB_FREQ_MAX; - copy_bsi = bsi_start (copy_basic_block); - for (bsi = bsi_start (bb); - !bsi_end_p (bsi); bsi_next (&bsi)) + copy_gsi = gsi_start_bb (copy_basic_block); + + for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) { - tree stmt = bsi_stmt (bsi); - tree orig_stmt = stmt; + gimple stmt = gsi_stmt (gsi); + gimple orig_stmt = stmt; id->regimplify = false; - walk_tree (&stmt, copy_body_r, id, NULL); - - /* RETURN_EXPR might be removed, - this is signalled by making stmt pointer NULL. */ - if (stmt) + stmt = remap_gimple_stmt (stmt, id); + if (gimple_nop_p (stmt)) + continue; + + gimple_duplicate_stmt_histograms (cfun, stmt, id->src_cfun, orig_stmt); + + /* With return slot optimization we can end up with + non-gimple (foo *)&this->m, fix that here. */ + if ((is_gimple_assign (stmt) + && gimple_assign_rhs_code (stmt) == NOP_EXPR + && !is_gimple_val (gimple_assign_rhs1 (stmt))) + || id->regimplify) { - tree call, decl; - - gimple_duplicate_stmt_histograms (cfun, stmt, id->src_cfun, orig_stmt); + tree new_rhs; + new_rhs = force_gimple_operand_gsi (©_gsi, + gimple_assign_rhs1 (stmt), + true, NULL, true, GSI_SAME_STMT); + gimple_assign_set_rhs1 (stmt, new_rhs); + } + else if (id->regimplify) + gimple_regimplify_operands (stmt, ©_gsi); - /* With return slot optimization we can end up with - non-gimple (foo *)&this->m, fix that here. */ - if ((TREE_CODE (stmt) == GIMPLE_MODIFY_STMT - && TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 1)) == NOP_EXPR - && !is_gimple_val (TREE_OPERAND (GIMPLE_STMT_OPERAND (stmt, 1), 0))) - || id->regimplify) - gimplify_stmt (&stmt); + gsi_insert_after (©_gsi, stmt, GSI_NEW_STMT); - bsi_insert_after (©_bsi, stmt, BSI_NEW_STMT); + /* Process the new statement. The call to gimple_regimplify_operands + possibly turned the statement into multiple statements, we + need to process all of them. */ + while (!gsi_end_p (copy_gsi)) + { + if (is_gimple_call (stmt) + && gimple_call_va_arg_pack_p (stmt) + && id->gimple_call) + { + /* __builtin_va_arg_pack () should be replaced by + all arguments corresponding to ... in the caller. */ + tree p; + gimple new_call; + VEC(tree, heap) *argarray; + size_t nargs = gimple_call_num_args (id->gimple_call); + size_t n; + + for (p = DECL_ARGUMENTS (id->src_fn); p; p = TREE_CHAIN (p)) + nargs--; + + /* Create the new array of arguments. */ + n = nargs + gimple_call_num_args (stmt); + argarray = VEC_alloc (tree, heap, n); + VEC_safe_grow (tree, heap, argarray, n); + + /* Copy all the arguments before '...' */ + memcpy (VEC_address (tree, argarray), + gimple_call_arg_ptr (stmt, 0), + gimple_call_num_args (stmt) * sizeof (tree)); + + /* Append the arguments passed in '...' */ + memcpy (VEC_address(tree, argarray) + gimple_call_num_args (stmt), + gimple_call_arg_ptr (id->gimple_call, 0) + + (gimple_call_num_args (id->gimple_call) - nargs), + nargs * sizeof (tree)); + + new_call = gimple_build_call_vec (gimple_call_fn (stmt), + argarray); + + VEC_free (tree, heap, argarray); + + /* Copy all GIMPLE_CALL flags, location and block, except + GF_CALL_VA_ARG_PACK. */ + gimple_call_copy_flags (new_call, stmt); + gimple_call_set_va_arg_pack (new_call, false); + gimple_set_location (new_call, gimple_location (stmt)); + gimple_set_block (new_call, gimple_block (stmt)); + gimple_call_set_lhs (new_call, gimple_call_lhs (stmt)); + + gsi_replace (©_gsi, new_call, false); + stmt = new_call; + } + else if (is_gimple_call (stmt) + && id->gimple_call + && (decl = gimple_call_fndecl (stmt)) + && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL + && DECL_FUNCTION_CODE (decl) == BUILT_IN_VA_ARG_PACK_LEN) + { + /* __builtin_va_arg_pack_len () should be replaced by + the number of anonymous arguments. */ + size_t nargs = gimple_call_num_args (id->gimple_call); + tree count, p; + gimple new_stmt; + + for (p = DECL_ARGUMENTS (id->src_fn); p; p = TREE_CHAIN (p)) + nargs--; + + count = build_int_cst (integer_type_node, nargs); + new_stmt = gimple_build_assign (gimple_call_lhs (stmt), count); + gsi_replace (©_gsi, new_stmt, false); + stmt = new_stmt; + } - /* Process new statement. gimplify_stmt possibly turned statement - into multiple statements, we need to process all of them. */ - while (!bsi_end_p (copy_bsi)) + /* Statements produced by inlining can be unfolded, especially + when we constant propagated some operands. We can't fold + them right now for two reasons: + 1) folding require SSA_NAME_DEF_STMTs to be correct + 2) we can't change function calls to builtins. + So we just mark statement for later folding. We mark + all new statements, instead just statements that has changed + by some nontrivial substitution so even statements made + foldable indirectly are updated. If this turns out to be + expensive, copy_body can be told to watch for nontrivial + changes. */ + if (id->statements_to_fold) + pointer_set_insert (id->statements_to_fold, stmt); + + /* We're duplicating a CALL_EXPR. Find any corresponding + callgraph edges and update or duplicate them. */ + if (is_gimple_call (stmt)) { - tree *stmtp = bsi_stmt_ptr (copy_bsi); - tree stmt = *stmtp; - call = get_call_expr_in (stmt); + struct cgraph_node *node; + struct cgraph_edge *edge; - if (call && CALL_EXPR_VA_ARG_PACK (call) && id->call_expr) + switch (id->transform_call_graph_edges) { - /* __builtin_va_arg_pack () should be replaced by - all arguments corresponding to ... in the caller. */ - tree p, *argarray, new_call, *call_ptr; - int nargs = call_expr_nargs (id->call_expr); - - for (p = DECL_ARGUMENTS (id->src_fn); p; p = TREE_CHAIN (p)) - nargs--; - - argarray = (tree *) alloca ((nargs + call_expr_nargs (call)) - * sizeof (tree)); - - memcpy (argarray, CALL_EXPR_ARGP (call), - call_expr_nargs (call) * sizeof (*argarray)); - memcpy (argarray + call_expr_nargs (call), - CALL_EXPR_ARGP (id->call_expr) - + (call_expr_nargs (id->call_expr) - nargs), - nargs * sizeof (*argarray)); - - new_call = build_call_array (TREE_TYPE (call), - CALL_EXPR_FN (call), - nargs + call_expr_nargs (call), - argarray); - /* Copy all CALL_EXPR flags, locus and block, except - CALL_EXPR_VA_ARG_PACK flag. */ - CALL_EXPR_STATIC_CHAIN (new_call) - = CALL_EXPR_STATIC_CHAIN (call); - CALL_EXPR_TAILCALL (new_call) = CALL_EXPR_TAILCALL (call); - CALL_EXPR_RETURN_SLOT_OPT (new_call) - = CALL_EXPR_RETURN_SLOT_OPT (call); - CALL_FROM_THUNK_P (new_call) = CALL_FROM_THUNK_P (call); - CALL_CANNOT_INLINE_P (new_call) - = CALL_CANNOT_INLINE_P (call); - TREE_NOTHROW (new_call) = TREE_NOTHROW (call); - SET_EXPR_LOCUS (new_call, EXPR_LOCUS (call)); - TREE_BLOCK (new_call) = TREE_BLOCK (call); - - call_ptr = stmtp; - if (TREE_CODE (*call_ptr) == GIMPLE_MODIFY_STMT) - call_ptr = &GIMPLE_STMT_OPERAND (*call_ptr, 1); - if (TREE_CODE (*call_ptr) == WITH_SIZE_EXPR) - call_ptr = &TREE_OPERAND (*call_ptr, 0); - gcc_assert (*call_ptr == call); - if (call_ptr == stmtp) - { - bsi_replace (©_bsi, new_call, true); - stmtp = bsi_stmt_ptr (copy_bsi); - stmt = *stmtp; - } - else - { - *call_ptr = new_call; - stmt = *stmtp; - update_stmt (stmt); - } - } - else if (call - && id->call_expr - && (decl = get_callee_fndecl (call)) - && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL - && DECL_FUNCTION_CODE (decl) - == BUILT_IN_VA_ARG_PACK_LEN) - { - /* __builtin_va_arg_pack_len () should be replaced by - the number of anonymous arguments. */ - int nargs = call_expr_nargs (id->call_expr); - tree count, *call_ptr, p; - - for (p = DECL_ARGUMENTS (id->src_fn); p; p = TREE_CHAIN (p)) - nargs--; - - count = build_int_cst (integer_type_node, nargs); - call_ptr = stmtp; - if (TREE_CODE (*call_ptr) == GIMPLE_MODIFY_STMT) - call_ptr = &GIMPLE_STMT_OPERAND (*call_ptr, 1); - if (TREE_CODE (*call_ptr) == WITH_SIZE_EXPR) - call_ptr = &TREE_OPERAND (*call_ptr, 0); - gcc_assert (*call_ptr == call && call_ptr != stmtp); - *call_ptr = count; - stmt = *stmtp; - update_stmt (stmt); - call = NULL_TREE; + case CB_CGE_DUPLICATE: + edge = cgraph_edge (id->src_node, orig_stmt); + if (edge) + cgraph_clone_edge (edge, id->dst_node, stmt, + REG_BR_PROB_BASE, 1, + edge->frequency, true); + break; + + case CB_CGE_MOVE_CLONES: + for (node = id->dst_node->next_clone; + node; + node = node->next_clone) + { + edge = cgraph_edge (node, orig_stmt); + if (edge) + cgraph_set_call_stmt (edge, stmt); + } + /* FALLTHRU */ + + case CB_CGE_MOVE: + edge = cgraph_edge (id->dst_node, orig_stmt); + if (edge) + cgraph_set_call_stmt (edge, stmt); + break; + + default: + gcc_unreachable (); } + } - /* Statements produced by inlining can be unfolded, especially - when we constant propagated some operands. We can't fold - them right now for two reasons: - 1) folding require SSA_NAME_DEF_STMTs to be correct - 2) we can't change function calls to builtins. - So we just mark statement for later folding. We mark - all new statements, instead just statements that has changed - by some nontrivial substitution so even statements made - foldable indirectly are updated. If this turns out to be - expensive, copy_body can be told to watch for nontrivial - changes. */ - if (id->statements_to_fold) - pointer_set_insert (id->statements_to_fold, stmt); - /* We're duplicating a CALL_EXPR. Find any corresponding - callgraph edges and update or duplicate them. */ - if (call && (decl = get_callee_fndecl (call))) - { - struct cgraph_node *node; - struct cgraph_edge *edge; - - switch (id->transform_call_graph_edges) - { - case CB_CGE_DUPLICATE: - edge = cgraph_edge (id->src_node, orig_stmt); - if (edge) - cgraph_clone_edge (edge, id->dst_node, stmt, - REG_BR_PROB_BASE, 1, edge->frequency, true); - break; - - case CB_CGE_MOVE_CLONES: - for (node = id->dst_node->next_clone; - node; - node = node->next_clone) - { - edge = cgraph_edge (node, orig_stmt); - gcc_assert (edge); - cgraph_set_call_stmt (edge, stmt); - } - /* FALLTHRU */ - - case CB_CGE_MOVE: - edge = cgraph_edge (id->dst_node, orig_stmt); - if (edge) - cgraph_set_call_stmt (edge, stmt); - break; - - default: - gcc_unreachable (); - } - } - /* If you think we can abort here, you are wrong. - There is no region 0 in tree land. */ - gcc_assert (lookup_stmt_eh_region_fn (id->src_cfun, orig_stmt) - != 0); - - if (tree_could_throw_p (stmt) - /* When we are cloning for inlining, we are supposed to - construct a clone that calls precisely the same functions - as original. However IPA optimizers might've proved - earlier some function calls as non-trapping that might - render some basic blocks dead that might become - unreachable. - - We can't update SSA with unreachable blocks in CFG and thus - we prevent the scenario by preserving even the "dead" eh - edges until the point they are later removed by - fixup_cfg pass. */ - || (id->transform_call_graph_edges == CB_CGE_MOVE_CLONES - && lookup_stmt_eh_region_fn (id->src_cfun, orig_stmt) > 0)) - { - int region = lookup_stmt_eh_region_fn (id->src_cfun, orig_stmt); - /* Add an entry for the copied tree in the EH hashtable. - When cloning or versioning, use the hashtable in - cfun, and just copy the EH number. When inlining, use the - hashtable in the caller, and adjust the region number. */ - if (region > 0) - add_stmt_to_eh_region (stmt, region + id->eh_region_offset); - - /* If this tree doesn't have a region associated with it, - and there is a "current region," - then associate this tree with the current region - and add edges associated with this region. */ - if ((lookup_stmt_eh_region_fn (id->src_cfun, - orig_stmt) <= 0 - && id->eh_region > 0) - && tree_could_throw_p (stmt)) - add_stmt_to_eh_region (stmt, id->eh_region); - } - if (gimple_in_ssa_p (cfun)) - { - ssa_op_iter i; - tree def; + /* If you think we can abort here, you are wrong. + There is no region 0 in gimple. */ + gcc_assert (lookup_stmt_eh_region_fn (id->src_cfun, orig_stmt) != 0); + + if (stmt_could_throw_p (stmt) + /* When we are cloning for inlining, we are supposed to + construct a clone that calls precisely the same functions + as original. However IPA optimizers might've proved + earlier some function calls as non-trapping that might + render some basic blocks dead that might become + unreachable. + + We can't update SSA with unreachable blocks in CFG and thus + we prevent the scenario by preserving even the "dead" eh + edges until the point they are later removed by + fixup_cfg pass. */ + || (id->transform_call_graph_edges == CB_CGE_MOVE_CLONES + && lookup_stmt_eh_region_fn (id->src_cfun, orig_stmt) > 0)) + { + int region = lookup_stmt_eh_region_fn (id->src_cfun, orig_stmt); + + /* Add an entry for the copied tree in the EH hashtable. + When cloning or versioning, use the hashtable in + cfun, and just copy the EH number. When inlining, use the + hashtable in the caller, and adjust the region number. */ + if (region > 0) + add_stmt_to_eh_region (stmt, region + id->eh_region_offset); + + /* If this tree doesn't have a region associated with it, + and there is a "current region," + then associate this tree with the current region + and add edges associated with this region. */ + if (lookup_stmt_eh_region_fn (id->src_cfun, orig_stmt) <= 0 + && id->eh_region > 0 + && stmt_could_throw_p (stmt)) + add_stmt_to_eh_region (stmt, id->eh_region); + } - find_new_referenced_vars (bsi_stmt_ptr (copy_bsi)); - FOR_EACH_SSA_TREE_OPERAND (def, stmt, i, SSA_OP_DEF) - if (TREE_CODE (def) == SSA_NAME) - SSA_NAME_DEF_STMT (def) = stmt; - } - bsi_next (©_bsi); + if (gimple_in_ssa_p (cfun)) + { + ssa_op_iter i; + tree def; + + find_new_referenced_vars (gsi_stmt (copy_gsi)); + FOR_EACH_SSA_TREE_OPERAND (def, stmt, i, SSA_OP_DEF) + if (TREE_CODE (def) == SSA_NAME) + SSA_NAME_DEF_STMT (def) = stmt; } - copy_bsi = bsi_last (copy_basic_block); + + gsi_next (©_gsi); } + + copy_gsi = gsi_last_bb (copy_basic_block); } + return copy_basic_block; } @@ -1071,27 +1489,31 @@ update_ssa_across_abnormal_edges (basic_block bb, basic_block ret_bb, if (!e->dest->aux || ((basic_block)e->dest->aux)->index == ENTRY_BLOCK) { - tree phi; + gimple phi; + gimple_stmt_iterator si; gcc_assert (e->flags & EDGE_ABNORMAL); + if (!nonlocal_goto) gcc_assert (e->flags & EDGE_EH); + if (!can_throw) gcc_assert (!(e->flags & EDGE_EH)); - for (phi = phi_nodes (e->dest); phi; phi = PHI_CHAIN (phi)) + + for (si = gsi_start_phis (e->dest); !gsi_end_p (si); gsi_next (&si)) { edge re; + phi = gsi_stmt (si); + /* There shouldn't be any PHI nodes in the ENTRY_BLOCK. */ gcc_assert (!e->dest->aux); - gcc_assert (SSA_NAME_OCCURS_IN_ABNORMAL_PHI - (PHI_RESULT (phi))); + gcc_assert (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (PHI_RESULT (phi))); if (!is_gimple_reg (PHI_RESULT (phi))) { - mark_sym_for_renaming - (SSA_NAME_VAR (PHI_RESULT (phi))); + mark_sym_for_renaming (SSA_NAME_VAR (PHI_RESULT (phi))); continue; } @@ -1106,16 +1528,18 @@ update_ssa_across_abnormal_edges (basic_block bb, basic_block ret_bb, } } + /* Copy edges from BB into its copy constructed earlier, scale profile accordingly. Edges will be taken care of later. Assume aux pointers to point to the copies of each BB. */ + static void copy_edges_for_bb (basic_block bb, gcov_type count_scale, basic_block ret_bb) { basic_block new_bb = (basic_block) bb->aux; edge_iterator ei; edge old_edge; - block_stmt_iterator bsi; + gimple_stmt_iterator si; int flags; /* Use the indices from the original blocks to create edges for the @@ -1139,17 +1563,18 @@ copy_edges_for_bb (basic_block bb, gcov_type count_scale, basic_block ret_bb) if (bb->index == ENTRY_BLOCK || bb->index == EXIT_BLOCK) return; - for (bsi = bsi_start (new_bb); !bsi_end_p (bsi);) + for (si = gsi_start_bb (new_bb); !gsi_end_p (si);) { - tree copy_stmt; + gimple copy_stmt; bool can_throw, nonlocal_goto; - copy_stmt = bsi_stmt (bsi); + copy_stmt = gsi_stmt (si); update_stmt (copy_stmt); if (gimple_in_ssa_p (cfun)) mark_symbols_for_renaming (copy_stmt); + /* Do this before the possible split_block. */ - bsi_next (&bsi); + gsi_next (&si); /* If this tree could throw an exception, there are two cases where we need to add abnormal edge(s): the @@ -1162,13 +1587,12 @@ copy_edges_for_bb (basic_block bb, gcov_type count_scale, basic_block ret_bb) propagation can change an INDIRECT_REF which throws into a COMPONENT_REF which doesn't. If the copy can throw, the original could also throw. */ - - can_throw = tree_can_throw_internal (copy_stmt); - nonlocal_goto = tree_can_make_abnormal_goto (copy_stmt); + can_throw = stmt_can_throw_internal (copy_stmt); + nonlocal_goto = stmt_can_make_abnormal_goto (copy_stmt); if (can_throw || nonlocal_goto) { - if (!bsi_end_p (bsi)) + if (!gsi_end_p (si)) /* Note that bb's predecessor edges aren't necessarily right at this point; split_block doesn't care. */ { @@ -1176,7 +1600,7 @@ copy_edges_for_bb (basic_block bb, gcov_type count_scale, basic_block ret_bb) new_bb = e->dest; new_bb->aux = e->src->aux; - bsi = bsi_start (new_bb); + si = gsi_start_bb (new_bb); } } @@ -1184,11 +1608,11 @@ copy_edges_for_bb (basic_block bb, gcov_type count_scale, basic_block ret_bb) make_eh_edges (copy_stmt); if (nonlocal_goto) - make_abnormal_goto_edges (bb_for_stmt (copy_stmt), true); + make_abnormal_goto_edges (gimple_bb (copy_stmt), true); if ((can_throw || nonlocal_goto) && gimple_in_ssa_p (cfun)) - update_ssa_across_abnormal_edges (bb_for_stmt (copy_stmt), ret_bb, + update_ssa_across_abnormal_edges (gimple_bb (copy_stmt), ret_bb, can_throw, nonlocal_goto); } } @@ -1203,27 +1627,33 @@ copy_phis_for_bb (basic_block bb, copy_body_data *id) { basic_block const new_bb = (basic_block) bb->aux; edge_iterator ei; - tree phi; + gimple phi; + gimple_stmt_iterator si; - for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi)) + for (si = gsi_start (phi_nodes (bb)); !gsi_end_p (si); gsi_next (&si)) { - tree res = PHI_RESULT (phi); - tree new_res = res; - tree new_phi; + tree res, new_res; + gimple new_phi; edge new_edge; + phi = gsi_stmt (si); + res = PHI_RESULT (phi); + new_res = res; if (is_gimple_reg (res)) { - walk_tree (&new_res, copy_body_r, id, NULL); + walk_tree (&new_res, copy_tree_body_r, id, NULL); SSA_NAME_DEF_STMT (new_res) = new_phi = create_phi_node (new_res, new_bb); FOR_EACH_EDGE (new_edge, ei, new_bb->preds) { - edge const old_edge = find_edge ((basic_block) new_edge->src->aux, bb); + edge const old_edge + = find_edge ((basic_block) new_edge->src->aux, bb); tree arg = PHI_ARG_DEF_FROM_EDGE (phi, old_edge); tree new_arg = arg; - - walk_tree (&new_arg, copy_body_r, id, NULL); + tree block = id->block; + id->block = NULL_TREE; + walk_tree (&new_arg, copy_tree_body_r, id, NULL); + id->block = block; gcc_assert (new_arg); /* With return slot optimization we can end up with non-gimple (foo *)&this->m, fix that here. */ @@ -1231,10 +1661,9 @@ copy_phis_for_bb (basic_block bb, copy_body_data *id) && TREE_CODE (new_arg) != FUNCTION_DECL && !is_gimple_val (new_arg)) { - tree stmts = NULL_TREE; - new_arg = force_gimple_operand (new_arg, &stmts, - true, NULL); - bsi_insert_on_edge_immediate (new_edge, stmts); + gimple_seq stmts = NULL; + new_arg = force_gimple_operand (new_arg, &stmts, true, NULL); + gsi_insert_seq_on_edge_immediate (new_edge, stmts); } add_phi_arg (new_phi, new_arg, new_edge); } @@ -1242,7 +1671,9 @@ copy_phis_for_bb (basic_block bb, copy_body_data *id) } } + /* Wrapper for remap_decl so it can be used as a callback. */ + static tree remap_decl_1 (tree decl, void *data) { @@ -1275,7 +1706,7 @@ initialize_cfun (tree new_fndecl, tree callee_fndecl, gcov_type count, frequency_scale = count_scale; /* Register specific tree functions. */ - tree_register_cfg_hooks (); + gimple_register_cfg_hooks (); *new_cfun = *DECL_STRUCT_FUNCTION (callee_fndecl); new_cfun->funcdef_no = get_next_funcdef_no (); VALUE_HISTOGRAMS (new_cfun) = NULL; @@ -1340,7 +1771,7 @@ copy_cfg_body (copy_body_data * id, gcov_type count, int frequency, frequency_scale = count_scale; /* Register specific tree functions. */ - tree_register_cfg_hooks (); + gimple_register_cfg_hooks (); /* Must have a CFG here at this point. */ gcc_assert (ENTRY_BLOCK_PTR_FOR_FUNCTION @@ -1348,7 +1779,6 @@ copy_cfg_body (copy_body_data * id, gcov_type count, int frequency, cfun_to_copy = id->src_cfun = DECL_STRUCT_FUNCTION (callee_fndecl); - ENTRY_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy)->aux = entry_block_map; EXIT_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy)->aux = exit_block_map; entry_block_map->aux = ENTRY_BLOCK_PTR_FOR_FUNCTION (cfun_to_copy); @@ -1361,6 +1791,7 @@ copy_cfg_body (copy_body_data * id, gcov_type count, int frequency, = duplicate_eh_regions (cfun_to_copy, remap_decl_1, id, 0, id->eh_region); } + /* Use aux pointers to map the original blocks to copy. */ FOR_EACH_BB_FN (bb, cfun_to_copy) { @@ -1370,17 +1801,21 @@ copy_cfg_body (copy_body_data * id, gcov_type count, int frequency, } last = last_basic_block; + /* Now that we've duplicated the blocks, duplicate their edges. */ FOR_ALL_BB_FN (bb, cfun_to_copy) copy_edges_for_bb (bb, count_scale, exit_block_map); + if (gimple_in_ssa_p (cfun)) FOR_ALL_BB_FN (bb, cfun_to_copy) copy_phis_for_bb (bb, id); + FOR_ALL_BB_FN (bb, cfun_to_copy) { ((basic_block)bb->aux)->aux = NULL; bb->aux = NULL; } + /* Zero out AUX fields of newly created block during EH edge insertion. */ for (; last < last_basic_block; last++) @@ -1391,21 +1826,6 @@ copy_cfg_body (copy_body_data * id, gcov_type count, int frequency, return new_fndecl; } -/* Make a copy of the body of FN so that it can be inserted inline in - another function. */ - -tree -copy_generic_body (copy_body_data *id) -{ - tree body; - tree fndecl = id->src_fn; - - body = DECL_SAVED_TREE (fndecl); - walk_tree (&body, copy_body_r, id, NULL); - - return body; -} - static tree copy_body (copy_body_data *id, gcov_type count, int frequency, basic_block entry_block_map, basic_block exit_block_map) @@ -1440,7 +1860,7 @@ static void setup_one_parameter (copy_body_data *id, tree p, tree value, tree fn, basic_block bb, tree *vars) { - tree init_stmt; + gimple init_stmt; tree var; tree rhs = value; tree def = (gimple_in_ssa_p (cfun) @@ -1556,7 +1976,7 @@ setup_one_parameter (copy_body_data *id, tree p, tree value, tree fn, the argument to the proper type in case it was promoted. */ if (value) { - block_stmt_iterator bsi = bsi_last (bb); + gimple_stmt_iterator si = gsi_last_bb (bb); if (rhs == error_mark_node) { @@ -1566,21 +1986,20 @@ setup_one_parameter (copy_body_data *id, tree p, tree value, tree fn, STRIP_USELESS_TYPE_CONVERSION (rhs); - /* We want to use GIMPLE_MODIFY_STMT, not INIT_EXPR here so that we + /* We want to use MODIFY_EXPR, not INIT_EXPR here so that we keep our trees in gimple form. */ if (def && gimple_in_ssa_p (cfun) && is_gimple_reg (p)) { def = remap_ssa_name (def, id); - init_stmt = build_gimple_modify_stmt (def, rhs); - SSA_NAME_DEF_STMT (def) = init_stmt; + init_stmt = gimple_build_assign (def, rhs); SSA_NAME_IS_DEFAULT_DEF (def) = 0; set_default_def (var, NULL); } else - init_stmt = build_gimple_modify_stmt (var, rhs); + init_stmt = gimple_build_assign (var, rhs); /* If we did not create a gimple value and we did not create a gimple - cast of a gimple value, then we will need to gimplify INIT_STMTS + cast of a gimple value, then we will need to gimplify INIT_STMT at the end. Note that is_gimple_cast only checks the outer tree code, not its operand. Thus the explicit check that its operand is a gimple value. */ @@ -1589,54 +2008,67 @@ setup_one_parameter (copy_body_data *id, tree p, tree value, tree fn, || !is_gimple_val (TREE_OPERAND (rhs, 0)))) || !is_gimple_reg (var)) { - tree_stmt_iterator i; + gimple_stmt_iterator i; + gimple_seq seq = gimple_seq_alloc (); struct gimplify_ctx gctx; push_gimplify_context (&gctx); - gimplify_stmt (&init_stmt); + + i = gsi_start (seq); + gimple_regimplify_operands (init_stmt, &i); + if (gimple_in_ssa_p (cfun) - && init_stmt && TREE_CODE (init_stmt) == STATEMENT_LIST) + && init_stmt + && !gimple_seq_empty_p (seq)) { /* The replacement can expose previously unreferenced variables. */ - for (i = tsi_start (init_stmt); !tsi_end_p (i); tsi_next (&i)) - find_new_referenced_vars (tsi_stmt_ptr (i)); + for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i)) + find_new_referenced_vars (gsi_stmt (i)); + + /* Insert the gimplified sequence needed for INIT_STMT + after SI. INIT_STMT will be inserted after SEQ. */ + gsi_insert_seq_after (&si, seq, GSI_NEW_STMT); } + pop_gimplify_context (NULL); } /* If VAR represents a zero-sized variable, it's possible that the assignment statement may result in no gimple statements. */ if (init_stmt) - bsi_insert_after (&bsi, init_stmt, BSI_NEW_STMT); + gsi_insert_after (&si, init_stmt, GSI_NEW_STMT); + if (gimple_in_ssa_p (cfun)) - for (;!bsi_end_p (bsi); bsi_next (&bsi)) - mark_symbols_for_renaming (bsi_stmt (bsi)); + for (;!gsi_end_p (si); gsi_next (&si)) + mark_symbols_for_renaming (gsi_stmt (si)); } } /* Generate code to initialize the parameters of the function at the - top of the stack in ID from the CALL_EXPR EXP. */ + top of the stack in ID from the GIMPLE_CALL STMT. */ static void -initialize_inlined_parameters (copy_body_data *id, tree exp, +initialize_inlined_parameters (copy_body_data *id, gimple stmt, tree fn, basic_block bb) { tree parms; - tree a; + size_t i; tree p; tree vars = NULL_TREE; - call_expr_arg_iterator iter; - tree static_chain = CALL_EXPR_STATIC_CHAIN (exp); + tree static_chain = gimple_call_chain (stmt); /* Figure out what the parameters are. */ parms = DECL_ARGUMENTS (fn); /* Loop through the parameter declarations, replacing each with an equivalent VAR_DECL, appropriately initialized. */ - for (p = parms, a = first_call_expr_arg (exp, &iter); p; - a = next_call_expr_arg (&iter), p = TREE_CHAIN (p)) - setup_one_parameter (id, p, a, fn, bb, &vars); + for (p = parms, i = 0; p; p = TREE_CHAIN (p), i++) + { + tree val; + val = i < gimple_call_num_args (stmt) ? gimple_call_arg (stmt, i) : NULL; + setup_one_parameter (id, p, val, fn, bb, &vars); + } /* Initialize the static chain. */ p = DECL_STRUCT_FUNCTION (fn)->static_chain_decl; @@ -1652,6 +2084,7 @@ initialize_inlined_parameters (copy_body_data *id, tree exp, declare_inline_vars (id->block, vars); } + /* Declare a return variable to replace the RESULT_DECL for the function we are calling. An appropriate DECL_STMT is returned. The USE_STMT is filled to contain a use of the declaration to @@ -1659,7 +2092,7 @@ initialize_inlined_parameters (copy_body_data *id, tree exp, RETURN_SLOT, if non-null is place where to store the result. It is set only for CALL_EXPR_RETURN_SLOT_OPT. MODIFY_DEST, if non-null, - was the LHS of the GIMPLE_MODIFY_STMT to which this call is the RHS. + was the LHS of the MODIFY_EXPR to which this call is the RHS. The return value is a (possibly null) value that is the result of the function as seen by the callee. *USE_P is a (possibly null) value that @@ -1839,37 +2272,89 @@ declare_return_variable (copy_body_data *id, tree return_slot, tree modify_dest, bool tree_inlinable_function_p (tree fn) { - return inlinable_function_p (fn); + bool ret = inlinable_function_p (fn); + + if (getenv ("TUPLES_INLINE")) + fprintf (stderr, "Function %s is %sinlinable\n", get_name (fn), + ret ? "" : "not "); + + return ret; } static const char *inline_forbidden_reason; +/* A callback for walk_gimple_seq to handle tree operands. Returns + NULL_TREE if a function can be inlined, otherwise sets the reason + why not and returns a tree representing the offending operand. */ + static tree -inline_forbidden_p_1 (tree *nodep, int *walk_subtrees ATTRIBUTE_UNUSED, - void *fnp) +inline_forbidden_p_op (tree *nodep, int *walk_subtrees ATTRIBUTE_UNUSED, + void *fnp ATTRIBUTE_UNUSED) { tree node = *nodep; - tree fn = (tree) fnp; tree t; - switch (TREE_CODE (node)) + if (TREE_CODE (node) == RECORD_TYPE || TREE_CODE (node) == UNION_TYPE) { - case CALL_EXPR: + /* We cannot inline a function of the form + + void F (int i) { struct S { int ar[i]; } s; } + + Attempting to do so produces a catch-22. + If walk_tree examines the TYPE_FIELDS chain of RECORD_TYPE/ + UNION_TYPE nodes, then it goes into infinite recursion on a + structure containing a pointer to its own type. If it doesn't, + then the type node for S doesn't get adjusted properly when + F is inlined. + + ??? This is likely no longer true, but it's too late in the 4.0 + cycle to try to find out. This should be checked for 4.1. */ + for (t = TYPE_FIELDS (node); t; t = TREE_CHAIN (t)) + if (variably_modified_type_p (TREE_TYPE (t), NULL)) + { + inline_forbidden_reason + = G_("function %q+F can never be inlined " + "because it uses variable sized variables"); + return node; + } + } + + return NULL_TREE; +} + + +/* A callback for walk_gimple_seq to handle statements. Returns + non-NULL iff a function can not be inlined. Also sets the reason + why. */ + +static tree +inline_forbidden_p_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p, + struct walk_stmt_info *wip) +{ + tree fn = (tree) wip->info; + tree t; + gimple stmt = gsi_stmt (*gsi); + + switch (gimple_code (stmt)) + { + case GIMPLE_CALL: /* Refuse to inline alloca call unless user explicitly forced so as this may change program's memory overhead drastically when the function using alloca is called in loop. In GCC present in SPEC2000 inlining into schedule_block cause it to require 2GB of RAM instead of 256MB. */ - if (alloca_call_p (node) + if (gimple_alloca_call_p (stmt) && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn))) { inline_forbidden_reason = G_("function %q+F can never be inlined because it uses " "alloca (override using the always_inline attribute)"); - return node; + *handled_ops_p = true; + return fn; } - t = get_callee_fndecl (node); - if (! t) + + t = gimple_call_fndecl (stmt); + if (t == NULL_TREE) break; /* We cannot inline functions that call setjmp. */ @@ -1877,7 +2362,8 @@ inline_forbidden_p_1 (tree *nodep, int *walk_subtrees ATTRIBUTE_UNUSED, { inline_forbidden_reason = G_("function %q+F can never be inlined because it uses setjmp"); - return node; + *handled_ops_p = true; + return t; } if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL) @@ -1891,7 +2377,8 @@ inline_forbidden_p_1 (tree *nodep, int *walk_subtrees ATTRIBUTE_UNUSED, inline_forbidden_reason = G_("function %q+F can never be inlined because it " "uses variable argument lists"); - return node; + *handled_ops_p = true; + return t; case BUILT_IN_LONGJMP: /* We can't inline functions that call __builtin_longjmp at @@ -1902,14 +2389,16 @@ inline_forbidden_p_1 (tree *nodep, int *walk_subtrees ATTRIBUTE_UNUSED, inline_forbidden_reason = G_("function %q+F can never be inlined because " "it uses setjmp-longjmp exception handling"); - return node; + *handled_ops_p = true; + return t; case BUILT_IN_NONLOCAL_GOTO: /* Similarly. */ inline_forbidden_reason = G_("function %q+F can never be inlined because " "it uses non-local goto"); - return node; + *handled_ops_p = true; + return t; case BUILT_IN_RETURN: case BUILT_IN_APPLY_ARGS: @@ -1920,15 +2409,16 @@ inline_forbidden_p_1 (tree *nodep, int *walk_subtrees ATTRIBUTE_UNUSED, inline_forbidden_reason = G_("function %q+F can never be inlined because " "it uses __builtin_return or __builtin_apply_args"); - return node; + *handled_ops_p = true; + return t; default: break; } break; - case GOTO_EXPR: - t = TREE_OPERAND (node, 0); + case GIMPLE_GOTO: + t = gimple_goto_dest (stmt); /* We will not inline a function which uses computed goto. The addresses of its local labels, which may be tucked into @@ -1939,12 +2429,13 @@ inline_forbidden_p_1 (tree *nodep, int *walk_subtrees ATTRIBUTE_UNUSED, inline_forbidden_reason = G_("function %q+F can never be inlined " "because it contains a computed goto"); - return node; + *handled_ops_p = true; + return t; } break; - case LABEL_EXPR: - t = TREE_OPERAND (node, 0); + case GIMPLE_LABEL: + t = gimple_label_label (stmt); if (DECL_NONLOCAL (t)) { /* We cannot inline a function that receives a non-local goto @@ -1953,41 +2444,20 @@ inline_forbidden_p_1 (tree *nodep, int *walk_subtrees ATTRIBUTE_UNUSED, inline_forbidden_reason = G_("function %q+F can never be inlined " "because it receives a non-local goto"); - return node; + *handled_ops_p = true; + return t; } break; - case RECORD_TYPE: - case UNION_TYPE: - /* We cannot inline a function of the form - - void F (int i) { struct S { int ar[i]; } s; } - - Attempting to do so produces a catch-22. - If walk_tree examines the TYPE_FIELDS chain of RECORD_TYPE/ - UNION_TYPE nodes, then it goes into infinite recursion on a - structure containing a pointer to its own type. If it doesn't, - then the type node for S doesn't get adjusted properly when - F is inlined. - - ??? This is likely no longer true, but it's too late in the 4.0 - cycle to try to find out. This should be checked for 4.1. */ - for (t = TYPE_FIELDS (node); t; t = TREE_CHAIN (t)) - if (variably_modified_type_p (TREE_TYPE (t), NULL)) - { - inline_forbidden_reason - = G_("function %q+F can never be inlined " - "because it uses variable sized variables"); - return node; - } - default: break; } + *handled_ops_p = false; return NULL_TREE; } + static tree inline_forbidden_p_2 (tree *nodep, int *walk_subtrees, void *fnp) @@ -2009,25 +2479,35 @@ inline_forbidden_p_2 (tree *nodep, int *walk_subtrees, return NULL_TREE; } -/* Return subexpression representing possible alloca call, if any. */ -static tree +/* Return true if FNDECL is a function that cannot be inlined into + another one. */ + +static bool inline_forbidden_p (tree fndecl) { location_t saved_loc = input_location; - block_stmt_iterator bsi; - basic_block bb; - tree ret = NULL_TREE; struct function *fun = DECL_STRUCT_FUNCTION (fndecl); tree step; + struct walk_stmt_info wi; + struct pointer_set_t *visited_nodes; + basic_block bb; + bool forbidden_p = false; + + visited_nodes = pointer_set_create (); + memset (&wi, 0, sizeof (wi)); + wi.info = (void *) fndecl; + wi.pset = visited_nodes; FOR_EACH_BB_FN (bb, fun) - for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi)) - { - ret = walk_tree_without_duplicates (bsi_stmt_ptr (bsi), - inline_forbidden_p_1, fndecl); - if (ret) - goto egress; - } + { + gimple ret; + gimple_seq seq = bb_seq (bb); + ret = walk_gimple_seq (seq, inline_forbidden_p_stmt, + inline_forbidden_p_op, &wi); + forbidden_p = (ret != NULL); + if (forbidden_p) + goto egress; + } for (step = fun->local_decls; step; step = TREE_CHAIN (step)) { @@ -2036,15 +2516,20 @@ inline_forbidden_p (tree fndecl) && TREE_STATIC (decl) && !DECL_EXTERNAL (decl) && DECL_INITIAL (decl)) - ret = walk_tree_without_duplicates (&DECL_INITIAL (decl), - inline_forbidden_p_2, fndecl); - if (ret) - goto egress; + { + tree ret; + ret = walk_tree_without_duplicates (&DECL_INITIAL (decl), + inline_forbidden_p_2, fndecl); + forbidden_p = (ret != NULL); + if (forbidden_p) + goto egress; + } } egress: + pointer_set_destroy (visited_nodes); input_location = saved_loc; - return ret; + return forbidden_p; } /* Returns nonzero if FN is a function that does not have any @@ -2064,7 +2549,6 @@ inlinable_function_p (tree fn) /* We only warn for functions declared `inline' by the user. */ do_warning = (warn_inline - && DECL_INLINE (fn) && DECL_DECLARED_INLINE_P (fn) && !DECL_IN_SYSTEM_HEADER (fn)); @@ -2096,27 +2580,9 @@ inlinable_function_p (tree fn) /* If we don't have the function body available, we can't inline it. However, this should not be recorded since we also get here for forward declared inline functions. Therefore, return at once. */ - if (!DECL_SAVED_TREE (fn)) + if (!gimple_body (fn)) return false; - /* If we're not inlining at all, then we cannot inline this function. */ - else if (!flag_inline_trees) - inlinable = false; - - /* Only try to inline functions if DECL_INLINE is set. This should be - true for all functions declared `inline', and for all other functions - as well with -finline-functions. - - Don't think of disregarding DECL_INLINE when flag_inline_trees == 2; - it's the front-end that must set DECL_INLINE in this case, because - dwarf2out loses if a function that does not have DECL_INLINE set is - inlined anyway. That is why we have both DECL_INLINE and - DECL_DECLARED_INLINE_P. */ - /* FIXME: When flag_inline_trees dies, the check for flag_unit_at_a_time - here should be redundant. */ - else if (!DECL_INLINE (fn) && !flag_unit_at_a_time) - inlinable = false; - else if (inline_forbidden_p (fn)) { /* See if we should warn about uninlinable functions. Previously, @@ -2157,151 +2623,21 @@ estimate_move_cost (tree type) return ((size + MOVE_MAX_PIECES - 1) / MOVE_MAX_PIECES); } -/* Arguments for estimate_num_insns_1. */ +/* Returns cost of operation CODE, according to WEIGHTS */ -struct eni_data +static int +estimate_operator_cost (enum tree_code code, eni_weights *weights) { - /* Used to return the number of insns. */ - int count; - - /* Weights of various constructs. */ - eni_weights *weights; -}; - -/* Used by estimate_num_insns. Estimate number of instructions seen - by given statement. */ - -static tree -estimate_num_insns_1 (tree *tp, int *walk_subtrees, void *data) -{ - struct eni_data *const d = (struct eni_data *) data; - tree x = *tp; - unsigned cost; - - if (IS_TYPE_OR_DECL_P (x)) + switch (code) { - *walk_subtrees = 0; - return NULL; - } - /* Assume that constants and references counts nothing. These should - be majorized by amount of operations among them we count later - and are common target of CSE and similar optimizations. */ - else if (CONSTANT_CLASS_P (x) || REFERENCE_CLASS_P (x)) - return NULL; - - switch (TREE_CODE (x)) - { - /* Containers have no cost. */ - case TREE_LIST: - case TREE_VEC: - case BLOCK: - case COMPONENT_REF: - case BIT_FIELD_REF: - case INDIRECT_REF: - case ALIGN_INDIRECT_REF: - case MISALIGNED_INDIRECT_REF: - case ARRAY_REF: - case ARRAY_RANGE_REF: - case OBJ_TYPE_REF: - case EXC_PTR_EXPR: /* ??? */ - case FILTER_EXPR: /* ??? */ - case COMPOUND_EXPR: - case BIND_EXPR: - case WITH_CLEANUP_EXPR: - case PAREN_EXPR: - CASE_CONVERT: - case VIEW_CONVERT_EXPR: - case SAVE_EXPR: - case ADDR_EXPR: - case COMPLEX_EXPR: + /* These are "free" conversions, or their presumed cost + is folded into other operations. */ case RANGE_EXPR: - case CASE_LABEL_EXPR: - case SSA_NAME: - case CATCH_EXPR: - case EH_FILTER_EXPR: - case STATEMENT_LIST: - case ERROR_MARK: - case FDESC_EXPR: - case VA_ARG_EXPR: - case TRY_CATCH_EXPR: - case TRY_FINALLY_EXPR: - case LABEL_EXPR: - case GOTO_EXPR: - case RETURN_EXPR: - case EXIT_EXPR: - case LOOP_EXPR: - case PHI_NODE: - case WITH_SIZE_EXPR: - case OMP_CLAUSE: - case OMP_RETURN: - case OMP_CONTINUE: - case OMP_SECTIONS_SWITCH: - case OMP_ATOMIC_STORE: - break; - - /* We don't account constants for now. Assume that the cost is amortized - by operations that do use them. We may re-consider this decision once - we are able to optimize the tree before estimating its size and break - out static initializers. */ - case IDENTIFIER_NODE: - case INTEGER_CST: - case REAL_CST: - case FIXED_CST: - case COMPLEX_CST: - case VECTOR_CST: - case STRING_CST: - case PREDICT_EXPR: - *walk_subtrees = 0; - return NULL; - - /* CHANGE_DYNAMIC_TYPE_EXPR explicitly expands to nothing. */ - case CHANGE_DYNAMIC_TYPE_EXPR: - *walk_subtrees = 0; - return NULL; - - /* Try to estimate the cost of assignments. We have three cases to - deal with: - 1) Simple assignments to registers; - 2) Stores to things that must live in memory. This includes - "normal" stores to scalars, but also assignments of large - structures, or constructors of big arrays; - 3) TARGET_EXPRs. - - Let us look at the first two cases, assuming we have "a = b + C": - <GIMPLE_MODIFY_STMT <var_decl "a"> - <plus_expr <var_decl "b"> <constant C>> - If "a" is a GIMPLE register, the assignment to it is free on almost - any target, because "a" usually ends up in a real register. Hence - the only cost of this expression comes from the PLUS_EXPR, and we - can ignore the GIMPLE_MODIFY_STMT. - If "a" is not a GIMPLE register, the assignment to "a" will most - likely be a real store, so the cost of the GIMPLE_MODIFY_STMT is the cost - of moving something into "a", which we compute using the function - estimate_move_cost. - - The third case deals with TARGET_EXPRs, for which the semantics are - that a temporary is assigned, unless the TARGET_EXPR itself is being - assigned to something else. In the latter case we do not need the - temporary. E.g. in: - <GIMPLE_MODIFY_STMT <var_decl "a"> <target_expr>>, the - GIMPLE_MODIFY_STMT is free. */ - case INIT_EXPR: - case GIMPLE_MODIFY_STMT: - /* Is the right and side a TARGET_EXPR? */ - if (TREE_CODE (GENERIC_TREE_OPERAND (x, 1)) == TARGET_EXPR) - break; - /* ... fall through ... */ - - case TARGET_EXPR: - x = GENERIC_TREE_OPERAND (x, 0); - /* Is this an assignments to a register? */ - if (is_gimple_reg (x)) - break; - /* Otherwise it's a store, so fall through to compute the move cost. */ - - case CONSTRUCTOR: - d->count += estimate_move_cost (TREE_TYPE (x)); - break; + case CONVERT_EXPR: + case COMPLEX_EXPR: + case PAREN_EXPR: + case NOP_EXPR: + return 0; /* Assign cost of 1 to usual operations. ??? We may consider mapping RTL costs to this. */ @@ -2364,15 +2700,15 @@ estimate_num_insns_1 (tree *tp, int *walk_subtrees, void *data) case POSTDECREMENT_EXPR: case POSTINCREMENT_EXPR: - case ASM_EXPR: - case REALIGN_LOAD_EXPR: case REDUC_MAX_EXPR: case REDUC_MIN_EXPR: case REDUC_PLUS_EXPR: case WIDEN_SUM_EXPR: - case DOT_PROD_EXPR: + case WIDEN_MULT_EXPR: + case DOT_PROD_EXPR: + case VEC_WIDEN_MULT_HI_EXPR: case VEC_WIDEN_MULT_LO_EXPR: case VEC_UNPACK_HI_EXPR: @@ -2382,26 +2718,12 @@ estimate_num_insns_1 (tree *tp, int *walk_subtrees, void *data) case VEC_PACK_TRUNC_EXPR: case VEC_PACK_SAT_EXPR: case VEC_PACK_FIX_TRUNC_EXPR: - - case WIDEN_MULT_EXPR: - case VEC_EXTRACT_EVEN_EXPR: case VEC_EXTRACT_ODD_EXPR: case VEC_INTERLEAVE_HIGH_EXPR: case VEC_INTERLEAVE_LOW_EXPR: - case RESX_EXPR: - d->count += 1; - break; - - case SWITCH_EXPR: - /* Take into account cost of the switch + guess 2 conditional jumps for - each case label. - - TODO: once the switch expansion logic is sufficiently separated, we can - do better job on estimating cost of the switch. */ - d->count += TREE_VEC_LENGTH (SWITCH_LABELS (x)) * 2; - break; + return 1; /* Few special cases of expensive operations. This is useful to avoid inlining on functions having too many of these. */ @@ -2415,34 +2737,115 @@ estimate_num_insns_1 (tree *tp, int *walk_subtrees, void *data) case FLOOR_MOD_EXPR: case ROUND_MOD_EXPR: case RDIV_EXPR: - d->count += d->weights->div_mod_cost; + return weights->div_mod_cost; + + default: + /* We expect a copy assignment with no operator. */ + gcc_assert (get_gimple_rhs_class (code) == GIMPLE_SINGLE_RHS); + return 0; + } +} + + +/* Estimate number of instructions that will be created by expanding + the statements in the statement sequence STMTS. + WEIGHTS contains weights attributed to various constructs. */ + +static +int estimate_num_insns_seq (gimple_seq stmts, eni_weights *weights) +{ + int cost; + gimple_stmt_iterator gsi; + + cost = 0; + for (gsi = gsi_start (stmts); !gsi_end_p (gsi); gsi_next (&gsi)) + cost += estimate_num_insns (gsi_stmt (gsi), weights); + + return cost; +} + + +/* Estimate number of instructions that will be created by expanding STMT. + WEIGHTS contains weights attributed to various constructs. */ + +int +estimate_num_insns (gimple stmt, eni_weights *weights) +{ + unsigned cost, i; + enum gimple_code code = gimple_code (stmt); + tree lhs; + + switch (code) + { + case GIMPLE_ASSIGN: + /* Try to estimate the cost of assignments. We have three cases to + deal with: + 1) Simple assignments to registers; + 2) Stores to things that must live in memory. This includes + "normal" stores to scalars, but also assignments of large + structures, or constructors of big arrays; + + Let us look at the first two cases, assuming we have "a = b + C": + <GIMPLE_ASSIGN <var_decl "a"> + <plus_expr <var_decl "b"> <constant C>> + If "a" is a GIMPLE register, the assignment to it is free on almost + any target, because "a" usually ends up in a real register. Hence + the only cost of this expression comes from the PLUS_EXPR, and we + can ignore the GIMPLE_ASSIGN. + If "a" is not a GIMPLE register, the assignment to "a" will most + likely be a real store, so the cost of the GIMPLE_ASSIGN is the cost + of moving something into "a", which we compute using the function + estimate_move_cost. */ + lhs = gimple_assign_lhs (stmt); + if (is_gimple_reg (lhs)) + cost = 0; + else + cost = estimate_move_cost (TREE_TYPE (lhs)); + + cost += estimate_operator_cost (gimple_assign_rhs_code (stmt), weights); + break; + + case GIMPLE_COND: + cost = 1 + estimate_operator_cost (gimple_cond_code (stmt), weights); + break; + + case GIMPLE_SWITCH: + /* Take into account cost of the switch + guess 2 conditional jumps for + each case label. + + TODO: once the switch expansion logic is sufficiently separated, we can + do better job on estimating cost of the switch. */ + cost = gimple_switch_num_labels (stmt) * 2; break; - case CALL_EXPR: + + case GIMPLE_CALL: { - tree decl = get_callee_fndecl (x); - tree addr = CALL_EXPR_FN (x); + tree decl = gimple_call_fndecl (stmt); + tree addr = gimple_call_fn (stmt); tree funtype = TREE_TYPE (addr); - gcc_assert (POINTER_TYPE_P (funtype)); - funtype = TREE_TYPE (funtype); + if (POINTER_TYPE_P (funtype)) + funtype = TREE_TYPE (funtype); if (decl && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_MD) - cost = d->weights->target_builtin_call_cost; + cost = weights->target_builtin_call_cost; else - cost = d->weights->call_cost; + cost = weights->call_cost; if (decl && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL) switch (DECL_FUNCTION_CODE (decl)) { case BUILT_IN_CONSTANT_P: - *walk_subtrees = 0; - return NULL_TREE; + return 0; case BUILT_IN_EXPECT: - return NULL_TREE; + cost = 0; + break; + /* Prefetch instruction is not expensive. */ case BUILT_IN_PREFETCH: - cost = 1; + cost = weights->target_builtin_call_cost; break; + default: break; } @@ -2450,96 +2853,117 @@ estimate_num_insns_1 (tree *tp, int *walk_subtrees, void *data) if (decl) funtype = TREE_TYPE (decl); - /* Our cost must be kept in sync with cgraph_estimate_size_after_inlining - that does use function declaration to figure out the arguments. - - When we deal with function with no body nor prototype, base estimates on - actual parameters of the call expression. Otherwise use either the actual - arguments types or function declaration for more precise answer. */ + /* Our cost must be kept in sync with + cgraph_estimate_size_after_inlining that does use function + declaration to figure out the arguments. */ if (decl && DECL_ARGUMENTS (decl)) { tree arg; for (arg = DECL_ARGUMENTS (decl); arg; arg = TREE_CHAIN (arg)) - d->count += estimate_move_cost (TREE_TYPE (arg)); + cost += estimate_move_cost (TREE_TYPE (arg)); } else if (funtype && prototype_p (funtype)) { tree t; for (t = TYPE_ARG_TYPES (funtype); t; t = TREE_CHAIN (t)) - d->count += estimate_move_cost (TREE_VALUE (t)); + cost += estimate_move_cost (TREE_VALUE (t)); } else { - tree a; - call_expr_arg_iterator iter; - FOR_EACH_CALL_EXPR_ARG (a, iter, x) - d->count += estimate_move_cost (TREE_TYPE (a)); + for (i = 0; i < gimple_call_num_args (stmt); i++) + { + tree arg = gimple_call_arg (stmt, i); + cost += estimate_move_cost (TREE_TYPE (arg)); + } } - d->count += cost; break; } - case OMP_PARALLEL: - case OMP_TASK: - case OMP_FOR: - case OMP_SECTIONS: - case OMP_SINGLE: - case OMP_SECTION: - case OMP_MASTER: - case OMP_ORDERED: - case OMP_CRITICAL: - case OMP_ATOMIC: - case OMP_ATOMIC_LOAD: - /* OpenMP directives are generally very expensive. */ - d->count += d->weights->omp_cost; - break; + case GIMPLE_GOTO: + case GIMPLE_LABEL: + case GIMPLE_NOP: + case GIMPLE_PHI: + case GIMPLE_RETURN: + case GIMPLE_CHANGE_DYNAMIC_TYPE: + case GIMPLE_PREDICT: + return 0; + + case GIMPLE_ASM: + case GIMPLE_RESX: + return 1; + + case GIMPLE_BIND: + return estimate_num_insns_seq (gimple_bind_body (stmt), weights); + + case GIMPLE_EH_FILTER: + return estimate_num_insns_seq (gimple_eh_filter_failure (stmt), weights); + + case GIMPLE_CATCH: + return estimate_num_insns_seq (gimple_catch_handler (stmt), weights); + + case GIMPLE_TRY: + return (estimate_num_insns_seq (gimple_try_eval (stmt), weights) + + estimate_num_insns_seq (gimple_try_cleanup (stmt), weights)); + + /* OpenMP directives are generally very expensive. */ + + case GIMPLE_OMP_RETURN: + case GIMPLE_OMP_SECTIONS_SWITCH: + case GIMPLE_OMP_ATOMIC_STORE: + case GIMPLE_OMP_CONTINUE: + /* ...except these, which are cheap. */ + return 0; + + case GIMPLE_OMP_ATOMIC_LOAD: + return weights->omp_cost; + + case GIMPLE_OMP_FOR: + return (weights->omp_cost + + estimate_num_insns_seq (gimple_omp_body (stmt), weights) + + estimate_num_insns_seq (gimple_omp_for_pre_body (stmt), weights)); + + case GIMPLE_OMP_PARALLEL: + case GIMPLE_OMP_TASK: + case GIMPLE_OMP_CRITICAL: + case GIMPLE_OMP_MASTER: + case GIMPLE_OMP_ORDERED: + case GIMPLE_OMP_SECTION: + case GIMPLE_OMP_SECTIONS: + case GIMPLE_OMP_SINGLE: + return (weights->omp_cost + + estimate_num_insns_seq (gimple_omp_body (stmt), weights)); default: gcc_unreachable (); } - return NULL; + + return cost; } -/* Estimate number of instructions that will be created by expanding EXPR. - WEIGHTS contains weights attributed to various constructs. */ +/* Estimate number of instructions that will be created by expanding + function FNDECL. WEIGHTS contains weights attributed to various + constructs. */ int -estimate_num_insns (tree expr, eni_weights *weights) +estimate_num_insns_fn (tree fndecl, eni_weights *weights) { - struct pointer_set_t *visited_nodes; + struct function *my_function = DECL_STRUCT_FUNCTION (fndecl); + gimple_stmt_iterator bsi; basic_block bb; - block_stmt_iterator bsi; - struct function *my_function; - struct eni_data data; - - data.count = 0; - data.weights = weights; + int n = 0; - /* If we're given an entire function, walk the CFG. */ - if (TREE_CODE (expr) == FUNCTION_DECL) + gcc_assert (my_function && my_function->cfg); + FOR_EACH_BB_FN (bb, my_function) { - my_function = DECL_STRUCT_FUNCTION (expr); - gcc_assert (my_function && my_function->cfg); - visited_nodes = pointer_set_create (); - FOR_EACH_BB_FN (bb, my_function) - { - for (bsi = bsi_start (bb); - !bsi_end_p (bsi); - bsi_next (&bsi)) - { - walk_tree (bsi_stmt_ptr (bsi), estimate_num_insns_1, - &data, visited_nodes); - } - } - pointer_set_destroy (visited_nodes); + for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi)) + n += estimate_num_insns (gsi_stmt (bsi), weights); } - else - walk_tree_without_duplicates (&expr, estimate_num_insns_1, &data); - return data.count; + return n; } + /* Initializes weights used by estimate_num_insns. */ void @@ -2565,7 +2989,22 @@ init_inline_once (void) eni_time_weights.omp_cost = 40; } +/* Estimate the number of instructions in a gimple_seq. */ + +int +count_insns_seq (gimple_seq seq, eni_weights *weights) +{ + gimple_stmt_iterator gsi; + int n = 0; + for (gsi = gsi_start (seq); !gsi_end_p (gsi); gsi_next (&gsi)) + n += estimate_num_insns (gsi_stmt (gsi), weights); + + return n; +} + + /* Install new lexical TREE_BLOCK underneath 'current_block'. */ + static void add_lexical_block (tree current_block, tree new_block) { @@ -2580,13 +3019,25 @@ add_lexical_block (tree current_block, tree new_block) BLOCK_SUPERCONTEXT (new_block) = current_block; } -/* If *TP is a CALL_EXPR, replace it with its inline expansion. */ +/* Fetch callee declaration from the call graph edge going from NODE and + associated with STMR call statement. Return NULL_TREE if not found. */ +static tree +get_indirect_callee_fndecl (struct cgraph_node *node, gimple stmt) +{ + struct cgraph_edge *cs; + + cs = cgraph_edge (node, stmt); + if (cs) + return cs->callee->decl; + + return NULL_TREE; +} + +/* If STMT is a GIMPLE_CALL, replace it with its inline expansion. */ static bool -expand_call_inline (basic_block bb, tree stmt, tree *tp, void *data) +expand_call_inline (basic_block bb, gimple stmt, copy_body_data *id) { - copy_body_data *id; - tree t; tree retvar, use_retvar; tree fn; struct pointer_map_t *st; @@ -2597,45 +3048,45 @@ expand_call_inline (basic_block bb, tree stmt, tree *tp, void *data) const char *reason; basic_block return_block; edge e; - block_stmt_iterator bsi, stmt_bsi; + gimple_stmt_iterator gsi, stmt_gsi; bool successfully_inlined = FALSE; bool purge_dead_abnormal_edges; tree t_step; tree var; - /* See what we've got. */ - id = (copy_body_data *) data; - t = *tp; - /* Set input_location here so we get the right instantiation context if we call instantiate_decl from inlinable_function_p. */ saved_location = input_location; - if (EXPR_HAS_LOCATION (t)) - input_location = EXPR_LOCATION (t); + if (gimple_has_location (stmt)) + input_location = gimple_location (stmt); /* From here on, we're only interested in CALL_EXPRs. */ - if (TREE_CODE (t) != CALL_EXPR) + if (gimple_code (stmt) != GIMPLE_CALL) goto egress; /* First, see if we can figure out what function is being called. If we cannot, then there is no hope of inlining the function. */ - fn = get_callee_fndecl (t); + fn = gimple_call_fndecl (stmt); if (!fn) - goto egress; + { + fn = get_indirect_callee_fndecl (id->dst_node, stmt); + if (!fn) + goto egress; + } /* Turn forward declarations into real ones. */ fn = cgraph_node (fn)->decl; - /* If fn is a declaration of a function in a nested scope that was + /* If FN is a declaration of a function in a nested scope that was globally declared inline, we don't set its DECL_INITIAL. However, we can't blindly follow DECL_ABSTRACT_ORIGIN because the C++ front-end uses it for cdtors to refer to their internal declarations, that are not real functions. Fortunately those don't have trees to be saved, so we can tell by checking their - DECL_SAVED_TREE. */ - if (! DECL_INITIAL (fn) + gimple_body. */ + if (!DECL_INITIAL (fn) && DECL_ABSTRACT_ORIGIN (fn) - && DECL_SAVED_TREE (DECL_ABSTRACT_ORIGIN (fn))) + && gimple_body (DECL_ABSTRACT_ORIGIN (fn))) fn = DECL_ABSTRACT_ORIGIN (fn); /* Objective C and fortran still calls tree_rest_of_compilation directly. @@ -2655,7 +3106,7 @@ expand_call_inline (basic_block bb, tree stmt, tree *tp, void *data) where previous inlining turned indirect call into direct call by constant propagating arguments. In all other cases we hit a bug (incorrect node sharing is most common reason for missing edges. */ - gcc_assert (dest->needed || !flag_unit_at_a_time); + gcc_assert (dest->needed); cgraph_create_edge (id->dst_node, dest, stmt, bb->count, CGRAPH_FREQ_BASE, bb->loop_depth)->inline_failed @@ -2672,9 +3123,15 @@ expand_call_inline (basic_block bb, tree stmt, tree *tp, void *data) inlining. */ if (!cgraph_inline_p (cg_edge, &reason)) { + /* If this call was originally indirect, we do not want to emit any + inlining related warnings or sorry messages because there are no + guarantees regarding those. */ + if (cg_edge->indirect_call) + goto egress; + if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) /* Avoid warnings during early inline pass. */ - && (!flag_unit_at_a_time || cgraph_global_info_ready)) + && cgraph_global_info_ready) { sorry ("inlining failed in call to %q+F: %s", fn, reason); sorry ("called from here"); @@ -2684,7 +3141,7 @@ expand_call_inline (basic_block bb, tree stmt, tree *tp, void *data) && strlen (reason) && !lookup_attribute ("noinline", DECL_ATTRIBUTES (fn)) /* Avoid warnings during early inline pass. */ - && (!flag_unit_at_a_time || cgraph_global_info_ready)) + && cgraph_global_info_ready) { warning (OPT_Winline, "inlining failed in call to %q+F: %s", fn, reason); @@ -2702,7 +3159,7 @@ expand_call_inline (basic_block bb, tree stmt, tree *tp, void *data) /* We will be inlining this callee. */ id->eh_region = lookup_stmt_eh_region (stmt); - /* Split the block holding the CALL_EXPR. */ + /* Split the block holding the GIMPLE_CALL. */ e = split_block (bb, stmt); bb = e->src; return_block = e->dest; @@ -2711,26 +3168,26 @@ expand_call_inline (basic_block bb, tree stmt, tree *tp, void *data) /* split_block splits after the statement; work around this by moving the call into the second block manually. Not pretty, but seems easier than doing the CFG manipulation by hand - when the CALL_EXPR is in the last statement of BB. */ - stmt_bsi = bsi_last (bb); - bsi_remove (&stmt_bsi, false); + when the GIMPLE_CALL is in the last statement of BB. */ + stmt_gsi = gsi_last_bb (bb); + gsi_remove (&stmt_gsi, false); - /* If the CALL_EXPR was in the last statement of BB, it may have + /* If the GIMPLE_CALL was in the last statement of BB, it may have been the source of abnormal edges. In this case, schedule the removal of dead abnormal edges. */ - bsi = bsi_start (return_block); - if (bsi_end_p (bsi)) + gsi = gsi_start_bb (return_block); + if (gsi_end_p (gsi)) { - bsi_insert_after (&bsi, stmt, BSI_NEW_STMT); + gsi_insert_after (&gsi, stmt, GSI_NEW_STMT); purge_dead_abnormal_edges = true; } else { - bsi_insert_before (&bsi, stmt, BSI_NEW_STMT); + gsi_insert_before (&gsi, stmt, GSI_NEW_STMT); purge_dead_abnormal_edges = false; } - stmt_bsi = bsi_start (return_block); + stmt_gsi = gsi_start_bb (return_block); /* Build a block containing code to initialize the arguments, the actual inline expansion of the body, and a label for the return @@ -2739,7 +3196,7 @@ expand_call_inline (basic_block bb, tree stmt, tree *tp, void *data) id->block = make_node (BLOCK); BLOCK_ABSTRACT_ORIGIN (id->block) = fn; BLOCK_SOURCE_LOCATION (id->block) = input_location; - add_lexical_block (TREE_BLOCK (stmt), id->block); + add_lexical_block (gimple_block (stmt), id->block); /* Local declarations will be replaced by their equivalents in this map. */ @@ -2750,27 +3207,26 @@ expand_call_inline (basic_block bb, tree stmt, tree *tp, void *data) id->src_fn = fn; id->src_node = cg_edge->callee; id->src_cfun = DECL_STRUCT_FUNCTION (fn); - id->call_expr = t; + id->gimple_call = stmt; gcc_assert (!id->src_cfun->after_inlining); id->entry_bb = bb; - initialize_inlined_parameters (id, t, fn, bb); + initialize_inlined_parameters (id, stmt, fn, bb); if (DECL_INITIAL (fn)) add_lexical_block (id->block, remap_blocks (DECL_INITIAL (fn), id)); /* Return statements in the function body will be replaced by jumps to the RET_LABEL. */ - gcc_assert (DECL_INITIAL (fn)); gcc_assert (TREE_CODE (DECL_INITIAL (fn)) == BLOCK); - /* Find the lhs to which the result of this call is assigned. */ + /* Find the LHS to which the result of this call is assigned. */ return_slot = NULL; - if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT) + if (gimple_call_lhs (stmt)) { - modify_dest = GIMPLE_STMT_OPERAND (stmt, 0); + modify_dest = gimple_call_lhs (stmt); /* The function which we are inlining might not return a value, in which case we should issue a warning that the function @@ -2780,7 +3236,8 @@ expand_call_inline (basic_block bb, tree stmt, tree *tp, void *data) uninitialized variable. */ if (DECL_P (modify_dest)) TREE_NO_WARNING (modify_dest) = 1; - if (CALL_EXPR_RETURN_SLOT_OPT (t)) + + if (gimple_call_return_slot_opt_p (stmt)) { return_slot = modify_dest; modify_dest = NULL; @@ -2801,8 +3258,7 @@ expand_call_inline (basic_block bb, tree stmt, tree *tp, void *data) } /* Declare the return variable for the function. */ - retvar = declare_return_variable (id, return_slot, - modify_dest, &use_retvar); + retvar = declare_return_variable (id, return_slot, modify_dest, &use_retvar); if (DECL_IS_OPERATOR_NEW (fn)) { @@ -2836,56 +3292,65 @@ expand_call_inline (basic_block bb, tree stmt, tree *tp, void *data) id->decl_map = st; /* If the inlined function returns a result that we care about, - clobber the CALL_EXPR with a reference to the return variable. */ - if (use_retvar && (TREE_CODE (bsi_stmt (stmt_bsi)) != CALL_EXPR)) + substitute the GIMPLE_CALL with an assignment of the return + variable to the LHS of the call. That is, if STMT was + 'a = foo (...)', substitute the call with 'a = USE_RETVAR'. */ + if (use_retvar && gimple_call_lhs (stmt)) { - *tp = use_retvar; + gimple old_stmt = stmt; + stmt = gimple_build_assign (gimple_call_lhs (stmt), use_retvar); + gsi_replace (&stmt_gsi, stmt, false); if (gimple_in_ssa_p (cfun)) { update_stmt (stmt); mark_symbols_for_renaming (stmt); } - maybe_clean_or_replace_eh_stmt (stmt, stmt); + maybe_clean_or_replace_eh_stmt (old_stmt, stmt); } else - /* We're modifying a TSI owned by gimple_expand_calls_inline(); - tsi_delink() will leave the iterator in a sane state. */ { - /* Handle case of inlining function that miss return statement so - return value becomes undefined. */ - if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT - && TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 0)) == SSA_NAME) + /* Handle the case of inlining a function with no return + statement, which causes the return value to become undefined. */ + if (gimple_call_lhs (stmt) + && TREE_CODE (gimple_call_lhs (stmt)) == SSA_NAME) { - tree name = GIMPLE_STMT_OPERAND (stmt, 0); - tree var = SSA_NAME_VAR (GIMPLE_STMT_OPERAND (stmt, 0)); + tree name = gimple_call_lhs (stmt); + tree var = SSA_NAME_VAR (name); tree def = gimple_default_def (cfun, var); - /* If the variable is used undefined, make this name undefined via - move. */ if (def) { - GIMPLE_STMT_OPERAND (stmt, 1) = def; + /* If the variable is used undefined, make this name + undefined via a move. */ + stmt = gimple_build_assign (gimple_call_lhs (stmt), def); + gsi_replace (&stmt_gsi, stmt, true); update_stmt (stmt); } - /* Otherwise make this variable undefined. */ else { - bsi_remove (&stmt_bsi, true); + /* Otherwise make this variable undefined. */ + gsi_remove (&stmt_gsi, true); set_default_def (var, name); - SSA_NAME_DEF_STMT (name) = build_empty_stmt (); + SSA_NAME_DEF_STMT (name) = gimple_build_nop (); } } else - bsi_remove (&stmt_bsi, true); + gsi_remove (&stmt_gsi, true); } if (purge_dead_abnormal_edges) - tree_purge_dead_abnormal_call_edges (return_block); + gimple_purge_dead_abnormal_call_edges (return_block); /* If the value of the new expression is ignored, that's OK. We don't warn about this for CALL_EXPRs, so we shouldn't warn about the equivalent inlined version either. */ - TREE_USED (*tp) = 1; + if (is_gimple_assign (stmt)) + { + gcc_assert (gimple_assign_single_p (stmt) + || gimple_assign_rhs_code (stmt) == NOP_EXPR + || gimple_assign_rhs_code (stmt) == CONVERT_EXPR); + TREE_USED (gimple_assign_rhs1 (stmt)) = 1; + } /* Output the inlining info for this abstract function, since it has been inlined. If we don't do this now, we can lose the information about the @@ -2906,58 +3371,58 @@ expand_call_inline (basic_block bb, tree stmt, tree *tp, void *data) /* Expand call statements reachable from STMT_P. We can only have CALL_EXPRs as the "toplevel" tree code or nested - in a GIMPLE_MODIFY_STMT. See tree-gimple.c:get_call_expr_in(). We can + in a MODIFY_EXPR. See tree-gimple.c:get_call_expr_in(). We can unfortunately not use that function here because we need a pointer to the CALL_EXPR, not the tree itself. */ static bool gimple_expand_calls_inline (basic_block bb, copy_body_data *id) { - block_stmt_iterator bsi; + gimple_stmt_iterator gsi; - /* Register specific tree functions. */ - tree_register_cfg_hooks (); - for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi)) + for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) { - tree *expr_p = bsi_stmt_ptr (bsi); - tree stmt = *expr_p; + gimple stmt = gsi_stmt (gsi); - if (TREE_CODE (*expr_p) == GIMPLE_MODIFY_STMT) - expr_p = &GIMPLE_STMT_OPERAND (*expr_p, 1); - if (TREE_CODE (*expr_p) == WITH_SIZE_EXPR) - expr_p = &TREE_OPERAND (*expr_p, 0); - if (TREE_CODE (*expr_p) == CALL_EXPR) - if (expand_call_inline (bb, stmt, expr_p, id)) - return true; + if (is_gimple_call (stmt) + && expand_call_inline (bb, stmt, id)) + return true; } + return false; } + /* Walk all basic blocks created after FIRST and try to fold every statement in the STATEMENTS pointer set. */ + static void fold_marked_statements (int first, struct pointer_set_t *statements) { - for (;first < n_basic_blocks;first++) + for (; first < n_basic_blocks; first++) if (BASIC_BLOCK (first)) { - block_stmt_iterator bsi; - for (bsi = bsi_start (BASIC_BLOCK (first)); - !bsi_end_p (bsi); bsi_next (&bsi)) - if (pointer_set_contains (statements, bsi_stmt (bsi))) + gimple_stmt_iterator gsi; + + for (gsi = gsi_start_bb (BASIC_BLOCK (first)); + !gsi_end_p (gsi); + gsi_next (&gsi)) + if (pointer_set_contains (statements, gsi_stmt (gsi))) { - tree old_stmt = bsi_stmt (bsi); - tree old_call = get_call_expr_in (old_stmt); + gimple old_stmt = gsi_stmt (gsi); - if (fold_stmt (bsi_stmt_ptr (bsi))) + if (fold_stmt (&gsi)) { - update_stmt (bsi_stmt (bsi)); - if (old_call) - cgraph_update_edges_for_call_stmt (old_stmt, old_call, - bsi_stmt (bsi)); - if (maybe_clean_or_replace_eh_stmt (old_stmt, - bsi_stmt (bsi))) - tree_purge_dead_eh_edges (BASIC_BLOCK (first)); + /* Re-read the statement from GSI as fold_stmt() may + have changed it. */ + gimple new_stmt = gsi_stmt (gsi); + update_stmt (new_stmt); + + if (is_gimple_call (old_stmt)) + cgraph_update_edges_for_call_stmt (old_stmt, new_stmt); + + if (maybe_clean_or_replace_eh_stmt (old_stmt, new_stmt)) + gimple_purge_dead_eh_edges (BASIC_BLOCK (first)); } } } @@ -3021,6 +3486,9 @@ optimize_inline_calls (tree fn) free_dominance_info (CDI_DOMINATORS); free_dominance_info (CDI_POST_DOMINATORS); + /* Register specific gimple functions. */ + gimple_register_cfg_hooks (); + /* Reach the trees by walking over the CFG, and note the enclosing basic-blocks in the call edges. */ /* We walk the blocks going forward, because inlined function bodies @@ -3058,11 +3526,13 @@ optimize_inline_calls (tree fn) cgraph_node_remove_callees (id.dst_node); fold_cond_expr_cond (); + /* It would be nice to check SSA/CFG/statement consistency here, but it is not possible yet - the IPA passes might make various functions to not throw and they don't care to proactively update local EH info. This is done later in fixup_cfg pass that also execute the verification. */ - return (TODO_update_ssa | TODO_cleanup_cfg + return (TODO_update_ssa + | TODO_cleanup_cfg | (gimple_in_ssa_p (cfun) ? TODO_remove_unused_locals : 0) | (profile_status != PROFILE_ABSENT ? TODO_rebuild_frequencies : 0)); } @@ -3077,7 +3547,6 @@ copy_tree_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED) /* We make copies of most nodes. */ if (IS_EXPR_CODE_CLASS (cl) - || IS_GIMPLE_STMT_CODE_CLASS (cl) || code == TREE_LIST || code == TREE_VEC || code == TYPE_DECL @@ -3087,8 +3556,7 @@ copy_tree_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED) here. */ tree chain = NULL_TREE, new; - if (!GIMPLE_TUPLE_P (*tp)) - chain = TREE_CHAIN (*tp); + chain = TREE_CHAIN (*tp); /* Copy the node. */ new = copy_node (*tp); @@ -3248,7 +3716,7 @@ unsave_r (tree *tp, int *walk_subtrees, void *data) } else if (TREE_CODE (*tp) == STATEMENT_LIST) - copy_statement_list (tp); + gcc_unreachable (); else if (TREE_CODE (*tp) == BIND_EXPR) copy_bind_expr (tp, walk_subtrees, id); else if (TREE_CODE (*tp) == SAVE_EXPR) @@ -3301,6 +3769,162 @@ unsave_expr_now (tree expr) return expr; } +/* Called via walk_gimple_seq. If *GSIP points to a GIMPLE_LABEL for a local + label, copies the declaration and enters it in the splay_tree in DATA (which + is really a 'copy_body_data *'. */ + +static tree +mark_local_labels_stmt (gimple_stmt_iterator *gsip, + bool *handled_ops_p ATTRIBUTE_UNUSED, + struct walk_stmt_info *wi) +{ + copy_body_data *id = (copy_body_data *) wi->info; + gimple stmt = gsi_stmt (*gsip); + + if (gimple_code (stmt) == GIMPLE_LABEL) + { + tree decl = gimple_label_label (stmt); + + /* Copy the decl and remember the copy. */ + insert_decl_map (id, decl, id->copy_decl (decl, id)); + } + + return NULL_TREE; +} + + +/* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local. + Using the splay_tree pointed to by ST (which is really a `splay_tree'), + remaps all local declarations to appropriate replacements in gimple + operands. */ + +static tree +replace_locals_op (tree *tp, int *walk_subtrees, void *data) +{ + struct walk_stmt_info *wi = (struct walk_stmt_info*) data; + copy_body_data *id = (copy_body_data *) wi->info; + struct pointer_map_t *st = id->decl_map; + tree *n; + tree expr = *tp; + + /* Only a local declaration (variable or label). */ + if ((TREE_CODE (expr) == VAR_DECL + && !TREE_STATIC (expr)) + || TREE_CODE (expr) == LABEL_DECL) + { + /* Lookup the declaration. */ + n = (tree *) pointer_map_contains (st, expr); + + /* If it's there, remap it. */ + if (n) + *tp = *n; + *walk_subtrees = 0; + } + else if (TREE_CODE (expr) == STATEMENT_LIST + || TREE_CODE (expr) == BIND_EXPR + || TREE_CODE (expr) == SAVE_EXPR) + gcc_unreachable (); + else if (TREE_CODE (expr) == TARGET_EXPR) + { + /* Don't mess with a TARGET_EXPR that hasn't been expanded. + It's OK for this to happen if it was part of a subtree that + isn't immediately expanded, such as operand 2 of another + TARGET_EXPR. */ + if (!TREE_OPERAND (expr, 1)) + { + TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 3); + TREE_OPERAND (expr, 3) = NULL_TREE; + } + } + + /* Keep iterating. */ + return NULL_TREE; +} + + +/* Called via walk_gimple_seq by copy_gimple_seq_and_replace_local. + Using the splay_tree pointed to by ST (which is really a `splay_tree'), + remaps all local declarations to appropriate replacements in gimple + statements. */ + +static tree +replace_locals_stmt (gimple_stmt_iterator *gsip, + bool *handled_ops_p ATTRIBUTE_UNUSED, + struct walk_stmt_info *wi) +{ + copy_body_data *id = (copy_body_data *) wi->info; + gimple stmt = gsi_stmt (*gsip); + + if (gimple_code (stmt) == GIMPLE_BIND) + { + tree block = gimple_bind_block (stmt); + + if (block) + { + remap_block (&block, id); + gimple_bind_set_block (stmt, block); + } + + /* This will remap a lot of the same decls again, but this should be + harmless. */ + if (gimple_bind_vars (stmt)) + gimple_bind_set_vars (stmt, remap_decls (gimple_bind_vars (stmt), id)); + } + + /* Keep iterating. */ + return NULL_TREE; +} + + +/* Copies everything in SEQ and replaces variables and labels local to + current_function_decl. */ + +gimple_seq +copy_gimple_seq_and_replace_locals (gimple_seq seq) +{ + copy_body_data id; + struct walk_stmt_info wi; + struct pointer_set_t *visited; + gimple_seq copy; + + /* There's nothing to do for NULL_TREE. */ + if (seq == NULL) + return seq; + + /* Set up ID. */ + memset (&id, 0, sizeof (id)); + id.src_fn = current_function_decl; + id.dst_fn = current_function_decl; + id.decl_map = pointer_map_create (); + + id.copy_decl = copy_decl_no_change; + id.transform_call_graph_edges = CB_CGE_DUPLICATE; + id.transform_new_cfg = false; + id.transform_return_to_modify = false; + id.transform_lang_insert_block = NULL; + + /* Walk the tree once to find local labels. */ + memset (&wi, 0, sizeof (wi)); + visited = pointer_set_create (); + wi.info = &id; + wi.pset = visited; + walk_gimple_seq (seq, mark_local_labels_stmt, NULL, &wi); + pointer_set_destroy (visited); + + copy = gimple_seq_copy (seq); + + /* Walk the copy, remapping decls. */ + memset (&wi, 0, sizeof (wi)); + wi.info = &id; + walk_gimple_seq (copy, replace_locals_stmt, replace_locals_op, &wi); + + /* Clean up. */ + pointer_map_destroy (id.decl_map); + + return copy; +} + + /* Allow someone to determine if SEARCH is a child of TOP from gdb. */ static tree @@ -3337,7 +3961,6 @@ declare_inline_vars (tree block, tree vars) BLOCK_VARS (block) = chainon (BLOCK_VARS (block), vars); } - /* Copy NODE (which must be a DECL). The DECL originally was in the FROM_FN, but now it will be in the TO_FN. PARM_TO_VAR means enable PARM_DECL to VAR_DECL translation. */ @@ -3430,7 +4053,6 @@ copy_result_decl_to_var (tree decl, copy_body_data *id) return copy_decl_for_dup_finish (id, decl, copy); } - tree copy_decl_no_change (tree decl, copy_body_data *id) { @@ -3592,7 +4214,8 @@ tree_function_versioning (tree old_decl, tree new_decl, varray_type tree_map, if (tree_map) for (i = 0; i < VARRAY_ACTIVE_SIZE (tree_map); i++) { - replace_info = (struct ipa_replace_map *) VARRAY_GENERIC_PTR (tree_map, i); + replace_info + = (struct ipa_replace_map *) VARRAY_GENERIC_PTR (tree_map, i); if (replace_info->replace_p) insert_decl_map (&id, replace_info->old_tree, replace_info->new_tree); @@ -3683,3 +4306,34 @@ build_duplicate_type (tree type) return type; } + +/* Return whether it is safe to inline a function because it used different + target specific options or different optimization options. */ +bool +tree_can_inline_p (tree caller, tree callee) +{ + /* Don't inline a function with a higher optimization level than the + caller, or with different space constraints (hot/cold functions). */ + tree caller_tree = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (caller); + tree callee_tree = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (callee); + + if (caller_tree != callee_tree) + { + struct cl_optimization *caller_opt + = TREE_OPTIMIZATION ((caller_tree) + ? caller_tree + : optimization_default_node); + + struct cl_optimization *callee_opt + = TREE_OPTIMIZATION ((callee_tree) + ? callee_tree + : optimization_default_node); + + if ((caller_opt->optimize > callee_opt->optimize) + || (caller_opt->optimize_size != callee_opt->optimize_size)) + return false; + } + + /* Allow the backend to decide if inlining is ok. */ + return targetm.target_option.can_inline_p (caller, callee); +} |