X-Git-Url: http://git.sourceforge.jp/view?p=pf3gnuchains%2Fgcc-fork.git;a=blobdiff_plain;f=gcc%2Ftree-inline.c;h=383cc86f24371d21916e31dc5e67e6f170497c3f;hp=e38da6d5bde75b34cfc9dd7ea35375c97f38d2c2;hb=ed5527ca4c73f9e2604ab5fe57834584c96b0aae;hpb=7bfefa9d2c82e804ef4e59772f4060ac325bf99a diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c index e38da6d5bde..383cc86f243 100644 --- a/gcc/tree-inline.c +++ b/gcc/tree-inline.c @@ -1,5 +1,5 @@ /* Tree inlining. - Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 + Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. Contributed by Alexandre Oliva @@ -41,7 +41,6 @@ along with GCC; see the file COPYING3. If not see #include "tree-mudflap.h" #include "tree-flow.h" #include "function.h" -#include "ggc.h" #include "tree-flow.h" #include "diagnostic.h" #include "except.h" @@ -102,10 +101,6 @@ along with GCC; see the file COPYING3. If not see calls? */ -/* Weights that estimate_num_insns uses for heuristics in inlining. */ - -eni_weights eni_inlining_weights; - /* Weights that estimate_num_insns uses to estimate the size of the produced code. */ @@ -118,7 +113,7 @@ eni_weights eni_time_weights; /* Prototypes. */ -static tree declare_return_variable (copy_body_data *, tree, tree, tree *); +static tree declare_return_variable (copy_body_data *, tree, tree); static void remap_block (tree *, copy_body_data *); static void copy_bind_expr (tree *, int *, copy_body_data *); static tree mark_local_for_remap_r (tree *, int *, void *); @@ -171,6 +166,12 @@ insert_debug_decl_map (copy_body_data *id, tree key, tree value) *pointer_map_insert (id->debug_map, key) = value; } +/* If nonzero, we're remapping the contents of inlined debug + statements. If negative, an error has occurred, such as a + reference to a variable that isn't available in the inlined + context. */ +static int processing_debug_stmt = 0; + /* Construct new SSA name for old NAME. ID is the inline context. */ static tree @@ -185,12 +186,18 @@ remap_ssa_name (tree name, copy_body_data *id) if (n) return unshare_expr (*n); + if (processing_debug_stmt) + { + processing_debug_stmt = -1; + return name; + } + /* Do not set DEF_STMT yet as statement is not copied yet. We do that in copy_bb. */ new_tree = remap_decl (SSA_NAME_VAR (name), id); /* We might've substituted constant or another SSA_NAME for - the variable. + the variable. Replace the SSA name representing RESULT_DECL by variable during inlining: this saves us from need to introduce PHI node in a case @@ -199,11 +206,21 @@ remap_ssa_name (tree name, copy_body_data *id) && (TREE_CODE (SSA_NAME_VAR (name)) != RESULT_DECL || !id->transform_return_to_modify)) { + struct ptr_info_def *pi; new_tree = make_ssa_name (new_tree, NULL); insert_decl_map (id, name, new_tree); SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_tree) = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name); TREE_TYPE (new_tree) = TREE_TYPE (SSA_NAME_VAR (new_tree)); + /* At least IPA points-to info can be directly transferred. */ + if (id->src_cfun->gimple_df + && id->src_cfun->gimple_df->ipa_pta + && (pi = SSA_NAME_PTR_INFO (name)) + && !pi->pt.anything) + { + struct ptr_info_def *new_pi = get_ptr_info (new_tree); + new_pi->pt = pi->pt; + } if (gimple_nop_p (SSA_NAME_DEF_STMT (name))) { /* By inlining function having uninitialized variable, we might @@ -223,7 +240,7 @@ remap_ssa_name (tree name, copy_body_data *id) { gimple_stmt_iterator gsi = gsi_last_bb (id->entry_bb); gimple init_stmt; - + init_stmt = gimple_build_assign (new_tree, fold_convert (TREE_TYPE (new_tree), integer_zero_node)); @@ -244,22 +261,14 @@ remap_ssa_name (tree name, copy_body_data *id) return new_tree; } -/* If nonzero, we're remapping the contents of inlined debug - statements. If negative, an error has occurred, such as a - reference to a variable that isn't available in the inlined - context. */ -int processing_debug_stmt = 0; - /* Remap DECL during the copying of the BLOCK tree for the function. */ tree remap_decl (tree decl, copy_body_data *id) { tree *n; - tree fn; /* We only remap local variables in the current function. */ - fn = id->src_fn; /* See if we have remapped this declaration. */ @@ -277,7 +286,7 @@ remap_decl (tree decl, copy_body_data *id) { /* Make a copy of the variable or label. */ tree t = id->copy_decl (decl, id); - + /* Remember it, so that if we encounter this local entity again we can reuse this copy. Do this early because remap_type may need this decl for TYPE_STUB_DECL. */ @@ -307,17 +316,7 @@ remap_decl (tree decl, copy_body_data *id) && (TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == RESULT_DECL || TREE_CODE (t) == PARM_DECL)) { - tree def = gimple_default_def (id->src_cfun, decl); get_var_ann (t); - if (TREE_CODE (decl) != PARM_DECL && def) - { - tree map = remap_ssa_name (def, id); - /* Watch out RESULT_DECLs whose SSA names map directly - to them. */ - if (TREE_CODE (map) == SSA_NAME - && gimple_nop_p (SSA_NAME_DEF_STMT (map))) - set_default_def (t, map); - } add_referenced_var (t); } return t; @@ -493,7 +492,7 @@ remapped_type (tree type, copy_body_data *id) /* The type only needs remapping if it's variably modified. */ /* Decide if DECL can be put into BLOCK_NONLOCAL_VARs. */ - + static bool can_be_nonlocal (tree decl, copy_body_data *id) { @@ -539,7 +538,6 @@ remap_decls (tree decls, VEC(tree,gc) **nonlocalized_list, copy_body_data *id) for (old_var = decls; old_var; old_var = TREE_CHAIN (old_var)) { tree new_var; - tree origin_var = DECL_ORIGIN (old_var); if (can_be_nonlocal (old_var, id)) { @@ -551,7 +549,7 @@ remap_decls (tree decls, VEC(tree,gc) **nonlocalized_list, copy_body_data *id) if ((!optimize || debug_info_level > DINFO_LEVEL_TERSE) && !DECL_IGNORED_P (old_var) && nonlocalized_list) - VEC_safe_push (tree, gc, *nonlocalized_list, origin_var); + VEC_safe_push (tree, gc, *nonlocalized_list, old_var); continue; } @@ -561,7 +559,7 @@ remap_decls (tree decls, VEC(tree,gc) **nonlocalized_list, copy_body_data *id) /* 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 == id->retvar) ; else if (!new_var) @@ -569,7 +567,7 @@ remap_decls (tree decls, VEC(tree,gc) **nonlocalized_list, copy_body_data *id) if ((!optimize || debug_info_level > DINFO_LEVEL_TERSE) && !DECL_IGNORED_P (old_var) && nonlocalized_list) - VEC_safe_push (tree, gc, *nonlocalized_list, origin_var); + VEC_safe_push (tree, gc, *nonlocalized_list, old_var); } else { @@ -590,7 +588,6 @@ remap_block (tree *block, copy_body_data *id) { tree old_block; tree new_block; - tree fn; /* Make the new block. */ old_block = *block; @@ -607,8 +604,6 @@ remap_block (tree *block, copy_body_data *id) &BLOCK_NONLOCALIZED_VARS (new_block), id); - fn = id->dst_fn; - if (id->transform_lang_insert_block) id->transform_lang_insert_block (new_block); @@ -670,9 +665,23 @@ copy_bind_expr (tree *tp, int *walk_subtrees, copy_body_data *id) } if (BIND_EXPR_VARS (*tp)) - /* This will remap a lot of the same decls again, but this should be - harmless. */ - BIND_EXPR_VARS (*tp) = remap_decls (BIND_EXPR_VARS (*tp), NULL, id); + { + tree t; + + /* This will remap a lot of the same decls again, but this should be + harmless. */ + BIND_EXPR_VARS (*tp) = remap_decls (BIND_EXPR_VARS (*tp), NULL, id); + + /* Also copy value-expressions. */ + for (t = BIND_EXPR_VARS (*tp); t; t = TREE_CHAIN (t)) + if (TREE_CODE (t) == VAR_DECL + && DECL_HAS_VALUE_EXPR_P (t)) + { + tree tem = DECL_VALUE_EXPR (t); + walk_tree (&tem, copy_tree_body_r, id, NULL); + SET_DECL_VALUE_EXPR (t, tem); + } + } } @@ -1095,13 +1104,13 @@ copy_tree_body_r (tree *tp, int *walk_subtrees, void *data) && id->remapping_type_depth == 0 && !processing_debug_stmt) 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. */ + of function call if we are not remapping a type. */ if (EXPR_P (*tp)) { - new_block = id->block; + new_block = id->remapping_type_depth == 0 ? id->block : NULL; if (TREE_BLOCK (*tp)) { tree *n; @@ -1247,7 +1256,7 @@ remap_gimple_stmt (gimple stmt, copy_body_data *id) 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)); + copy = gimple_build_try (s1, s2, gimple_try_kind (stmt)); break; case GIMPLE_WITH_CLEANUP_EXPR: @@ -1401,6 +1410,12 @@ remap_gimple_stmt (gimple stmt, copy_body_data *id) default: break; } + + /* Reset alias info if we didn't apply measures to + keep it valid over inlining by setting DECL_PT_UID. */ + if (!id->src_cfun->gimple_df + || !id->src_cfun->gimple_df->ipa_pta) + gimple_call_reset_alias_info (copy); } break; @@ -1448,7 +1463,7 @@ remap_gimple_stmt (gimple stmt, copy_body_data *id) if (skip_first) walk_tree (gimple_op_ptr (copy, 1), remap_gimple_op_r, &wi, NULL); else - walk_gimple_op (copy, remap_gimple_op_r, &wi); + walk_gimple_op (copy, remap_gimple_op_r, &wi); /* Clear the copied virtual operands. We are not remapping them here but are going to recreate them from scratch. */ @@ -1472,6 +1487,7 @@ copy_bb (copy_body_data *id, basic_block bb, int frequency_scale, gimple_stmt_iterator gsi, copy_gsi, seq_gsi; basic_block copy_basic_block; tree decl; + gcov_type freq; /* create_basic_block() will append every new block to basic_block_info automatically. */ @@ -1481,11 +1497,12 @@ copy_bb (copy_body_data *id, basic_block bb, int frequency_scale, /* 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); + freq = ((gcov_type)bb->frequency * frequency_scale / REG_BR_PROB_BASE); - if (copy_basic_block->frequency > BB_FREQ_MAX) - copy_basic_block->frequency = BB_FREQ_MAX; + /* We recompute frequencies after inlining, so this is quite safe. */ + if (freq > BB_FREQ_MAX) + freq = BB_FREQ_MAX; + copy_basic_block->frequency = freq; copy_gsi = gsi_start_bb (copy_basic_block); @@ -1631,10 +1648,35 @@ copy_bb (copy_body_data *id, basic_block bb, int frequency_scale, case CB_CGE_DUPLICATE: edge = cgraph_edge (id->src_node, orig_stmt); if (edge) - edge = cgraph_clone_edge (edge, id->dst_node, stmt, - gimple_uid (stmt), - REG_BR_PROB_BASE, 1, - edge->frequency, true); + { + int edge_freq = edge->frequency; + edge = cgraph_clone_edge (edge, id->dst_node, stmt, + gimple_uid (stmt), + REG_BR_PROB_BASE, CGRAPH_FREQ_BASE, + edge->frequency, true); + /* We could also just rescale the frequency, but + doing so would introduce roundoff errors and make + verifier unhappy. */ + edge->frequency + = compute_call_stmt_bb_frequency (id->dst_node->decl, + copy_basic_block); + if (dump_file + && profile_status_for_function (cfun) != PROFILE_ABSENT + && (edge_freq > edge->frequency + 10 + || edge_freq < edge->frequency - 10)) + { + fprintf (dump_file, "Edge frequency estimated by " + "cgraph %i diverge from inliner's estimate %i\n", + edge_freq, + edge->frequency); + fprintf (dump_file, + "Orig bb: %i, orig bb freq %i, new bb freq %i\n", + bb->index, + bb->frequency, + copy_basic_block->frequency); + } + stmt = cgraph_redirect_edge_call_stmt_to_callee (edge); + } break; case CB_CGE_MOVE_CLONES: @@ -1655,28 +1697,32 @@ copy_bb (copy_body_data *id, basic_block bb, int frequency_scale, /* Constant propagation on argument done during inlining may create new direct call. Produce an edge for it. */ - if ((!edge - || (edge->indirect_call + if ((!edge + || (edge->indirect_inlining_edge && id->transform_call_graph_edges == CB_CGE_MOVE_CLONES)) - && is_gimple_call (stmt) && (fn = gimple_call_fndecl (stmt)) != NULL) { struct cgraph_node *dest = cgraph_node (fn); /* We have missing edge in the callgraph. This can happen when previous inlining turned an indirect call into a - direct call by constant propagating arguments. In all + direct call by constant propagating arguments or we are + producing dead clone (for further clonning). In all other cases we hit a bug (incorrect node sharing is the most common reason for missing edges). */ - gcc_assert (dest->needed || !dest->analyzed); + gcc_assert (dest->needed || !dest->analyzed + || !id->src_node->analyzed); if (id->transform_call_graph_edges == CB_CGE_MOVE_CLONES) cgraph_create_edge_including_clones - (id->dst_node, dest, stmt, bb->count, - compute_call_stmt_bb_frequency (id->dst_node->decl, bb), + (id->dst_node, dest, orig_stmt, stmt, bb->count, + compute_call_stmt_bb_frequency (id->dst_node->decl, + copy_basic_block), bb->loop_depth, CIF_ORIGINALLY_INDIRECT_CALL); else cgraph_create_edge (id->dst_node, dest, stmt, - bb->count, CGRAPH_FREQ_BASE, + bb->count, + compute_call_stmt_bb_frequency + (id->dst_node->decl, copy_basic_block), bb->loop_depth)->inline_failed = CIF_ORIGINALLY_INDIRECT_CALL; if (dump_file) @@ -1926,7 +1972,7 @@ copy_phis_for_bb (basic_block bb, copy_body_data *id) 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, + add_phi_arg (new_phi, new_arg, new_edge, gimple_phi_arg_location_from_edge (phi, old_edge)); } } @@ -1946,24 +1992,16 @@ remap_decl_1 (tree decl, void *data) NEW_FNDECL to be build. CALLEE_FNDECL is the original */ static void -initialize_cfun (tree new_fndecl, tree callee_fndecl, gcov_type count, - int frequency) +initialize_cfun (tree new_fndecl, tree callee_fndecl, gcov_type count) { struct function *src_cfun = DECL_STRUCT_FUNCTION (callee_fndecl); - gcov_type count_scale, frequency_scale; + gcov_type count_scale; if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count) count_scale = (REG_BR_PROB_BASE * count / ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count); else - count_scale = 1; - - if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency) - frequency_scale = (REG_BR_PROB_BASE * frequency - / - ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency); - else - frequency_scale = count_scale; + count_scale = REG_BR_PROB_BASE; /* Register specific tree functions. */ gimple_register_cfg_hooks (); @@ -1983,12 +2021,8 @@ initialize_cfun (tree new_fndecl, tree callee_fndecl, gcov_type count, cfun->function_end_locus = src_cfun->function_end_locus; cfun->curr_properties = src_cfun->curr_properties; cfun->last_verified = src_cfun->last_verified; - if (src_cfun->ipa_transforms_to_apply) - cfun->ipa_transforms_to_apply = VEC_copy (ipa_opt_pass, heap, - src_cfun->ipa_transforms_to_apply); cfun->va_list_gpr_size = src_cfun->va_list_gpr_size; cfun->va_list_fpr_size = src_cfun->va_list_fpr_size; - cfun->function_frequency = src_cfun->function_frequency; cfun->has_nonlocal_label = src_cfun->has_nonlocal_label; cfun->stdarg = src_cfun->stdarg; cfun->dont_save_pending_sizes_p = src_cfun->dont_save_pending_sizes_p; @@ -1999,18 +2033,17 @@ initialize_cfun (tree new_fndecl, tree callee_fndecl, gcov_type count, init_empty_tree_cfg (); + profile_status_for_function (cfun) = profile_status_for_function (src_cfun); ENTRY_BLOCK_PTR->count = (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count * count_scale / REG_BR_PROB_BASE); - ENTRY_BLOCK_PTR->frequency = - (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency * - frequency_scale / REG_BR_PROB_BASE); + ENTRY_BLOCK_PTR->frequency + = ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency; EXIT_BLOCK_PTR->count = (EXIT_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count * count_scale / REG_BR_PROB_BASE); EXIT_BLOCK_PTR->frequency = - (EXIT_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency * - frequency_scale / REG_BR_PROB_BASE); + EXIT_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency; if (src_cfun->eh) init_eh_for_function (); @@ -2027,7 +2060,7 @@ initialize_cfun (tree new_fndecl, tree callee_fndecl, gcov_type count, another function. Walks FN via CFG, returns new fndecl. */ static tree -copy_cfg_body (copy_body_data * id, gcov_type count, int frequency, +copy_cfg_body (copy_body_data * id, gcov_type count, int frequency_scale, basic_block entry_block_map, basic_block exit_block_map) { tree callee_fndecl = id->src_fn; @@ -2036,21 +2069,14 @@ copy_cfg_body (copy_body_data * id, gcov_type count, int frequency, struct function *cfun_to_copy; basic_block bb; tree new_fndecl = NULL; - gcov_type count_scale, frequency_scale; + gcov_type count_scale; int last; if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count) count_scale = (REG_BR_PROB_BASE * count / ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->count); else - count_scale = 1; - - if (ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency) - frequency_scale = (REG_BR_PROB_BASE * frequency - / - ENTRY_BLOCK_PTR_FOR_FUNCTION (src_cfun)->frequency); - else - frequency_scale = count_scale; + count_scale = REG_BR_PROB_BASE; /* Register specific tree functions. */ gimple_register_cfg_hooks (); @@ -2147,6 +2173,12 @@ copy_debug_stmt (gimple stmt, copy_body_data *id) gcc_assert (TREE_CODE (*n) == VAR_DECL); t = *n; } + else if (TREE_CODE (t) == VAR_DECL + && !TREE_STATIC (t) + && gimple_in_ssa_p (cfun) + && !pointer_map_contains (id->decl_map, t) + && !var_ann (t)) + /* T is a non-localized variable. */; else walk_tree (&t, remap_gimple_op_r, &wi, NULL); @@ -2205,7 +2237,7 @@ copy_tree_body (copy_body_data *id) another function. */ static tree -copy_body (copy_body_data *id, gcov_type count, int frequency, +copy_body (copy_body_data *id, gcov_type count, int frequency_scale, basic_block entry_block_map, basic_block exit_block_map) { tree fndecl = id->src_fn; @@ -2213,7 +2245,7 @@ copy_body (copy_body_data *id, gcov_type count, int frequency, /* If this body has a CFG, walk CFG and copy. */ gcc_assert (ENTRY_BLOCK_PTR_FOR_FUNCTION (DECL_STRUCT_FUNCTION (fndecl))); - body = copy_cfg_body (id, count, frequency, entry_block_map, exit_block_map); + body = copy_cfg_body (id, count, frequency_scale, entry_block_map, exit_block_map); copy_debug_stmts (id); return body; @@ -2523,28 +2555,30 @@ initialize_inlined_parameters (copy_body_data *id, gimple stmt, is set only for CALL_EXPR_RETURN_SLOT_OPT. MODIFY_DEST, if non-null, 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 - holds the result as seen by the caller. */ + The return value is a (possibly null) value that holds the result + as seen by the caller. */ static tree -declare_return_variable (copy_body_data *id, tree return_slot, tree modify_dest, - tree *use_p) +declare_return_variable (copy_body_data *id, tree return_slot, tree modify_dest) { tree callee = id->src_fn; tree caller = id->dst_fn; tree result = DECL_RESULT (callee); tree callee_type = TREE_TYPE (result); - tree caller_type = TREE_TYPE (TREE_TYPE (callee)); + tree caller_type; tree var, use; + /* Handle type-mismatches in the function declaration return type + vs. the call expression. */ + if (modify_dest) + caller_type = TREE_TYPE (modify_dest); + else + caller_type = TREE_TYPE (TREE_TYPE (callee)); + /* We don't need to do anything for functions that don't return anything. */ if (!result || VOID_TYPE_P (callee_type)) - { - *use_p = NULL_TREE; - return NULL_TREE; - } + return NULL_TREE; /* If there was a return slot, then the return value is the dereferenced address of that object. */ @@ -2559,7 +2593,7 @@ declare_return_variable (copy_body_data *id, tree return_slot, tree modify_dest, STRIP_USELESS_TYPE_CONVERSION (return_slot_addr); /* We are going to construct *&return_slot and we can't do that - for variables believed to be not addressable. + for variables believed to be not addressable. FIXME: This check possibly can match, because values returned via return slot optimization are not believed to have address @@ -2677,7 +2711,7 @@ declare_return_variable (copy_body_data *id, tree return_slot, tree modify_dest, use = var; if (!useless_type_conversion_p (caller_type, TREE_TYPE (var))) use = fold_convert (caller_type, var); - + STRIP_USELESS_TYPE_CONVERSION (use); if (DECL_BY_REFERENCE (result)) @@ -2695,8 +2729,7 @@ declare_return_variable (copy_body_data *id, tree return_slot, tree modify_dest, /* Remember this so we can ignore it in remap_decls. */ id->retvar = var; - *use_p = use; - return var; + return use; } /* Callback through walk_tree. Determine if a DECL_INITIAL makes reference @@ -2717,39 +2750,6 @@ has_label_address_in_static_1 (tree *nodep, int *walk_subtrees, void *fnp) return NULL_TREE; } -/* Callback through walk_tree. Determine if we've got an aggregate - type that we can't support; return non-null if so. */ - -static tree -cannot_copy_type_1 (tree *nodep, int *walk_subtrees ATTRIBUTE_UNUSED, - void *data ATTRIBUTE_UNUSED) -{ - tree t, node = *nodep; - - if (TREE_CODE (node) == RECORD_TYPE || TREE_CODE (node) == 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)) - return node; - } - - return NULL_TREE; -} - - /* Determine if the function can be copied. If so return NULL. If not return a string describng the reason for failure. */ @@ -2792,16 +2792,6 @@ copy_forbidden (struct function *fun, tree fndecl) "address of local label in a static variable"); goto fail; } - - if (!TREE_STATIC (decl) && !DECL_EXTERNAL (decl) - && variably_modified_type_p (TREE_TYPE (decl), NULL) - && walk_tree_without_duplicates (&TREE_TYPE (decl), - cannot_copy_type_1, NULL)) - { - reason = G_("function %q+F can never be copied " - "because it uses variable sized variables"); - goto fail; - } } fail: @@ -3083,6 +3073,7 @@ estimate_operator_cost (enum tree_code code, eni_weights *weights, case MINUS_EXPR: case MULT_EXPR: + case ADDR_SPACE_CONVERT_EXPR: case FIXED_CONVERT_EXPR: case FIX_TRUNC_EXPR: @@ -3259,7 +3250,7 @@ estimate_num_insns (gimple stmt, eni_weights *weights) case GIMPLE_SWITCH: /* Take into account cost of the switch + guess 2 conditional jumps for - each case label. + each case label. TODO: once the switch expansion logic is sufficiently separated, we can do better job on estimating cost of the switch. */ @@ -3282,16 +3273,93 @@ estimate_num_insns (gimple stmt, eni_weights *weights) cost = weights->target_builtin_call_cost; else cost = weights->call_cost; - + if (decl && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL) switch (DECL_FUNCTION_CODE (decl)) { + /* Builtins that expand to constants. */ case BUILT_IN_CONSTANT_P: - return 0; case BUILT_IN_EXPECT: + case BUILT_IN_OBJECT_SIZE: + case BUILT_IN_UNREACHABLE: + /* Simple register moves or loads from stack. */ + case BUILT_IN_RETURN_ADDRESS: + case BUILT_IN_EXTRACT_RETURN_ADDR: + case BUILT_IN_FROB_RETURN_ADDR: + case BUILT_IN_RETURN: + case BUILT_IN_AGGREGATE_INCOMING_ADDRESS: + case BUILT_IN_FRAME_ADDRESS: + case BUILT_IN_VA_END: + case BUILT_IN_STACK_SAVE: + case BUILT_IN_STACK_RESTORE: + /* Exception state returns or moves registers around. */ + case BUILT_IN_EH_FILTER: + case BUILT_IN_EH_POINTER: + case BUILT_IN_EH_COPY_VALUES: return 0; - /* Prefetch instruction is not expensive. */ + /* builtins that are not expensive (that is they are most probably + expanded inline into resonably simple code). */ + case BUILT_IN_ABS: + case BUILT_IN_ALLOCA: + case BUILT_IN_BSWAP32: + case BUILT_IN_BSWAP64: + case BUILT_IN_CLZ: + case BUILT_IN_CLZIMAX: + case BUILT_IN_CLZL: + case BUILT_IN_CLZLL: + case BUILT_IN_CTZ: + case BUILT_IN_CTZIMAX: + case BUILT_IN_CTZL: + case BUILT_IN_CTZLL: + case BUILT_IN_FFS: + case BUILT_IN_FFSIMAX: + case BUILT_IN_FFSL: + case BUILT_IN_FFSLL: + case BUILT_IN_IMAXABS: + case BUILT_IN_FINITE: + case BUILT_IN_FINITEF: + case BUILT_IN_FINITEL: + case BUILT_IN_FINITED32: + case BUILT_IN_FINITED64: + case BUILT_IN_FINITED128: + case BUILT_IN_FPCLASSIFY: + case BUILT_IN_ISFINITE: + case BUILT_IN_ISINF_SIGN: + case BUILT_IN_ISINF: + case BUILT_IN_ISINFF: + case BUILT_IN_ISINFL: + case BUILT_IN_ISINFD32: + case BUILT_IN_ISINFD64: + case BUILT_IN_ISINFD128: + case BUILT_IN_ISNAN: + case BUILT_IN_ISNANF: + case BUILT_IN_ISNANL: + case BUILT_IN_ISNAND32: + case BUILT_IN_ISNAND64: + case BUILT_IN_ISNAND128: + case BUILT_IN_ISNORMAL: + case BUILT_IN_ISGREATER: + case BUILT_IN_ISGREATEREQUAL: + case BUILT_IN_ISLESS: + case BUILT_IN_ISLESSEQUAL: + case BUILT_IN_ISLESSGREATER: + case BUILT_IN_ISUNORDERED: + case BUILT_IN_VA_ARG_PACK: + case BUILT_IN_VA_ARG_PACK_LEN: + case BUILT_IN_VA_COPY: + case BUILT_IN_TRAP: + case BUILT_IN_SAVEREGS: + case BUILT_IN_POPCOUNTL: + case BUILT_IN_POPCOUNTLL: + case BUILT_IN_POPCOUNTIMAX: + case BUILT_IN_POPCOUNT: + case BUILT_IN_PARITYL: + case BUILT_IN_PARITYLL: + case BUILT_IN_PARITYIMAX: + case BUILT_IN_PARITY: + case BUILT_IN_LABS: + case BUILT_IN_LLABS: case BUILT_IN_PREFETCH: cost = weights->target_builtin_call_cost; break; @@ -3346,7 +3414,7 @@ estimate_num_insns (gimple stmt, eni_weights *weights) return 0; case GIMPLE_ASM: - return 1; + return asm_str_count (gimple_asm_string (stmt)); case GIMPLE_RESX: /* This is either going to be an external function call with one @@ -3484,7 +3552,7 @@ get_indirect_callee_fndecl (struct cgraph_node *node, gimple stmt) struct cgraph_edge *cs; cs = cgraph_edge (node, stmt); - if (cs) + if (cs && !cs->indirect_unknown_callee) return cs->callee->decl; return NULL_TREE; @@ -3495,7 +3563,7 @@ get_indirect_callee_fndecl (struct cgraph_node *node, gimple stmt) static bool expand_call_inline (basic_block bb, gimple stmt, copy_body_data *id) { - tree retvar, use_retvar; + tree use_retvar; tree fn; struct pointer_map_t *st, *dst; tree return_slot; @@ -3567,7 +3635,7 @@ expand_call_inline (basic_block bb, gimple stmt, copy_body_data *id) /* 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) + if (cg_edge->indirect_inlining_edge) goto egress; if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) @@ -3714,7 +3782,7 @@ expand_call_inline (basic_block bb, gimple stmt, copy_body_data *id) } /* Declare the return variable for the function. */ - retvar = declare_return_variable (id, return_slot, modify_dest, &use_retvar); + use_retvar = declare_return_variable (id, return_slot, modify_dest); /* Add local vars in this inlined callee to caller. */ t_step = id->src_cfun->local_decls; @@ -3732,19 +3800,27 @@ expand_call_inline (basic_block bb, gimple stmt, copy_body_data *id) cfun->local_decls); } + if (dump_file && (dump_flags & TDF_DETAILS)) + { + fprintf (dump_file, "Inlining "); + print_generic_expr (dump_file, id->src_fn, 0); + fprintf (dump_file, " to "); + print_generic_expr (dump_file, id->dst_fn, 0); + fprintf (dump_file, " with frequency %i\n", cg_edge->frequency); + } + /* This is it. Duplicate the callee body. Assume callee is pre-gimplified. Note that we must not alter the caller function in any way before this point, as this CALL_EXPR may be a self-referential call; if we're calling ourselves, we need to duplicate our body before altering anything. */ - copy_body (id, bb->count, bb->frequency, bb, return_block); + copy_body (id, bb->count, + cg_edge->frequency * REG_BR_PROB_BASE / CGRAPH_FREQ_BASE, + bb, return_block); - /* Reset the escaped and callused solutions. */ + /* Reset the escaped solution. */ if (cfun->gimple_df) - { - pt_solution_reset (&cfun->gimple_df->escaped); - pt_solution_reset (&cfun->gimple_df->callused); - } + pt_solution_reset (&cfun->gimple_df->escaped); /* Clean up. */ if (id->debug_map) @@ -3955,7 +4031,6 @@ unsigned int optimize_inline_calls (tree fn) { copy_body_data id; - tree prev_fn; basic_block bb; int last = n_basic_blocks; struct gimplify_ctx gctx; @@ -3972,12 +4047,8 @@ optimize_inline_calls (tree fn) id.src_node = id.dst_node = cgraph_node (fn); id.dst_fn = fn; /* Or any functions that aren't finished yet. */ - prev_fn = NULL_TREE; if (current_function_decl) - { - id.dst_fn = current_function_decl; - prev_fn = current_function_decl; - } + id.dst_fn = current_function_decl; id.copy_decl = copy_decl_maybe_to_var; id.transform_call_graph_edges = CB_CGE_DUPLICATE; @@ -4017,11 +4088,11 @@ optimize_inline_calls (tree fn) gcc_assert (e->inline_failed); } #endif - + /* Fold the statements before compacting/renumbering the basic blocks. */ fold_marked_statements (last, id.statements_to_fold); pointer_set_destroy (id.statements_to_fold); - + gcc_assert (!id.debug_stmts); /* Renumber the (code) basic_blocks consecutively. */ @@ -4489,14 +4560,14 @@ copy_decl_for_dup_finish (copy_body_data *id, tree decl, tree copy) DECL_IGNORED_P (copy) = DECL_IGNORED_P (decl); /* Set the DECL_ABSTRACT_ORIGIN so the debugging routines know what - declaration inspired this copy. */ + declaration inspired this copy. */ DECL_ABSTRACT_ORIGIN (copy) = DECL_ORIGIN (decl); /* The new variable/label has no RTL, yet. */ if (CODE_CONTAINS_STRUCT (TREE_CODE (copy), TS_DECL_WRTL) && !TREE_STATIC (copy) && !DECL_EXTERNAL (copy)) SET_DECL_RTL (copy, NULL_RTX); - + /* These args would always appear unused, if not for this. */ TREE_USED (copy) = 1; @@ -4532,6 +4603,8 @@ copy_decl_to_var (tree decl, copy_body_data *id) copy = build_decl (DECL_SOURCE_LOCATION (id->dst_fn), VAR_DECL, DECL_NAME (decl), type); + if (DECL_PT_UID_SET_P (decl)) + SET_DECL_PT_UID (copy, DECL_PT_UID (decl)); TREE_ADDRESSABLE (copy) = TREE_ADDRESSABLE (decl); TREE_READONLY (copy) = TREE_READONLY (decl); TREE_THIS_VOLATILE (copy) = TREE_THIS_VOLATILE (decl); @@ -4557,6 +4630,8 @@ copy_result_decl_to_var (tree decl, copy_body_data *id) copy = build_decl (DECL_SOURCE_LOCATION (id->dst_fn), VAR_DECL, DECL_NAME (decl), type); + if (DECL_PT_UID_SET_P (decl)) + SET_DECL_PT_UID (copy, DECL_PT_UID (decl)); TREE_READONLY (copy) = TREE_READONLY (decl); TREE_THIS_VOLATILE (copy) = TREE_THIS_VOLATILE (decl); if (!DECL_BY_REFERENCE (decl)) @@ -4707,7 +4782,7 @@ delete_unreachable_blocks_update_callgraph (copy_body_data *id) else cgraph_remove_edge (e); } - + if (node->clones) node = node->clones; else if (node->next_sibling_clone) @@ -4728,30 +4803,6 @@ delete_unreachable_blocks_update_callgraph (copy_body_data *id) if (changed) tidy_fallthru_edges (); -#ifdef ENABLE_CHECKING0 - verify_cgraph_node (id->dst_node); - if (id->transform_call_graph_edges == CB_CGE_MOVE_CLONES - && id->dst_node->clones) - { - struct cgraph_node *node; - for (node = id->dst_node->clones; node != id->dst_node;) - { - verify_cgraph_node (node); - - if (node->clones) - node = node->clones; - else if (node->next_sibling_clone) - node = node->next_sibling_clone; - else - { - while (node != id->dst_node && !node->next_sibling_clone) - node = node->clone_of; - if (node != id->dst_node) - node = node->next_sibling_clone; - } - } - } -#endif return changed; } @@ -4794,9 +4845,9 @@ update_clone_info (copy_body_data * id) /* Create a copy of a function's tree. OLD_DECL and NEW_DECL are FUNCTION_DECL tree nodes of the original function and the new copied function - respectively. In case we want to replace a DECL - tree with another tree while duplicating the function's - body, TREE_MAP represents the mapping between these + respectively. In case we want to replace a DECL + tree with another tree while duplicating the function's + body, TREE_MAP represents the mapping between these trees. If UPDATE_CLONES is set, the call_stmt fields of edges of clones of the function will be updated. */ void @@ -4847,7 +4898,20 @@ tree_function_versioning (tree old_decl, tree new_decl, id.src_node = old_version_node; id.dst_node = new_version_node; id.src_cfun = DECL_STRUCT_FUNCTION (old_decl); - + if (id.src_node->ipa_transforms_to_apply) + { + VEC(ipa_opt_pass,heap) * old_transforms_to_apply = id.dst_node->ipa_transforms_to_apply; + unsigned int i; + + id.dst_node->ipa_transforms_to_apply = VEC_copy (ipa_opt_pass, heap, + id.src_node->ipa_transforms_to_apply); + for (i = 0; i < VEC_length (ipa_opt_pass, old_transforms_to_apply); i++) + VEC_safe_push (ipa_opt_pass, heap, id.dst_node->ipa_transforms_to_apply, + VEC_index (ipa_opt_pass, + old_transforms_to_apply, + i)); + } + id.copy_decl = copy_decl_no_change; id.transform_call_graph_edges = update_clones ? CB_CGE_MOVE_CLONES : CB_CGE_MOVE; @@ -4859,17 +4923,16 @@ tree_function_versioning (tree old_decl, tree new_decl, old_entry_block = ENTRY_BLOCK_PTR_FOR_FUNCTION (DECL_STRUCT_FUNCTION (old_decl)); initialize_cfun (new_decl, old_decl, - old_entry_block->count, - old_entry_block->frequency); + old_entry_block->count); push_cfun (DECL_STRUCT_FUNCTION (new_decl)); - + /* Copy the function's static chain. */ p = DECL_STRUCT_FUNCTION (old_decl)->static_chain_decl; if (p) DECL_STRUCT_FUNCTION (new_decl)->static_chain_decl = copy_static_chain (DECL_STRUCT_FUNCTION (old_decl)->static_chain_decl, &id); - + /* If there's a tree_map, prepare for substitution. */ if (tree_map) for (i = 0; i < VEC_length (ipa_replace_map_p, tree_map); i++) @@ -4884,7 +4947,7 @@ tree_function_versioning (tree old_decl, tree new_decl, if (TREE_CODE (op) == VIEW_CONVERT_EXPR) op = TREE_OPERAND (op, 0); - + if (TREE_CODE (op) == ADDR_EXPR) { op = TREE_OPERAND (op, 0); @@ -4907,12 +4970,12 @@ tree_function_versioning (tree old_decl, tree new_decl, DECL_ARGUMENTS (new_decl) = copy_arguments_for_versioning (DECL_ARGUMENTS (old_decl), &id, args_to_skip, &vars); - + DECL_INITIAL (new_decl) = remap_blocks (DECL_INITIAL (id.src_fn), &id); - + /* Renumber the lexical scoping (non-code) blocks consecutively. */ number_blocks (id.dst_fn); - + declare_inline_vars (DECL_INITIAL (new_decl), vars); if (DECL_STRUCT_FUNCTION (old_decl)->local_decls != NULL_TREE) @@ -4928,18 +4991,18 @@ tree_function_versioning (tree old_decl, tree new_decl, tree_cons (NULL_TREE, remap_decl (var, &id), cfun->local_decls); } - + /* Copy the Function's body. */ - copy_body (&id, old_entry_block->count, old_entry_block->frequency, + copy_body (&id, old_entry_block->count, REG_BR_PROB_BASE, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR); - + if (DECL_RESULT (old_decl) != NULL_TREE) { tree *res_decl = &DECL_RESULT (old_decl); DECL_RESULT (new_decl) = remap_decl (*res_decl, &id); lang_hooks.dup_lang_specific_decl (DECL_RESULT (new_decl)); } - + /* Renumber the lexical scoping (non-code) blocks consecutively. */ number_blocks (new_decl); @@ -5098,7 +5161,7 @@ tree_can_inline_p (struct cgraph_edge *e) return false; } #endif - tree caller, callee; + tree caller, callee, lhs; caller = e->caller->decl; callee = e->callee->decl; @@ -5124,8 +5187,16 @@ tree_can_inline_p (struct cgraph_edge *e) return false; } + /* Do not inline calls where we cannot triviall work around mismatches + in argument or return types. */ if (e->call_stmt - && !gimple_check_call_args (e->call_stmt)) + && ((DECL_RESULT (callee) + && !DECL_BY_REFERENCE (DECL_RESULT (callee)) + && (lhs = gimple_call_lhs (e->call_stmt)) != NULL_TREE + && !useless_type_conversion_p (TREE_TYPE (DECL_RESULT (callee)), + TREE_TYPE (lhs)) + && !fold_convertible_p (TREE_TYPE (DECL_RESULT (callee)), lhs)) + || !gimple_check_call_args (e->call_stmt))) { e->inline_failed = CIF_MISMATCHED_ARGUMENTS; gimple_call_set_cannot_inline (e->call_stmt, true);