diff options
| -rw-r--r-- | gcc/ChangeLog | 57 | ||||
| -rw-r--r-- | gcc/cgraphunit.c | 2 | ||||
| -rw-r--r-- | gcc/ipa-cp.c | 8 | ||||
| -rw-r--r-- | gcc/ipa-inline-analysis.c | 155 | ||||
| -rw-r--r-- | gcc/ipa-inline-transform.c | 6 | ||||
| -rw-r--r-- | gcc/ipa-inline.c | 50 | ||||
| -rw-r--r-- | gcc/ipa-inline.h | 32 | ||||
| -rw-r--r-- | gcc/ipa-prop.h | 2 | ||||
| -rw-r--r-- | gcc/ipa-split.c | 2 | ||||
| -rw-r--r-- | gcc/ipa.c | 2 | ||||
| -rw-r--r-- | gcc/lto/ChangeLog | 7 | ||||
| -rw-r--r-- | gcc/lto/lto-partition.c | 10 | ||||
| -rw-r--r-- | gcc/tree-sra.c | 2 |
13 files changed, 193 insertions, 142 deletions
diff --git a/gcc/ChangeLog b/gcc/ChangeLog index abe1785955f..c5e878b883a 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,5 +1,62 @@ 2014-12-22 Martin Liska <mliska@suse.cz> + * cgraphunit.c (symbol_table::process_new_functions): New inline_summaries + is used. + * ipa-cp.c (ipcp_cloning_candidate_p): Likewise. + (devirtualization_time_bonus): Likewise. + (estimate_local_effects): Likewise. + (ipcp_propagate_stage): Likewise. + * ipa-inline-analysis.c (evaluate_conditions_for_known_args): Likewise. + (evaluate_properties_for_edge): Likewise. + (inline_summary_alloc): Likewise. + (reset_inline_summary): New inline_summary argument is introduced. + (inline_summary_t::remove): New function. + (inline_summary_t::duplicate): Likewise. + (dump_inline_edge_summary): New inline_summaries is used. + (dump_inline_summary): Likewise. + (estimate_function_body_sizes): Likewise. + (compute_inline_parameters): Likewise. + (estimate_edge_devirt_benefit): Likewise. + (estimate_node_size_and_time): Likewise. + (inline_update_callee_summaries): Likewise. + (inline_merge_summary): Likewise. + (inline_update_overall_summary): Likewise. + (simple_edge_hints): Likewise. + (do_estimate_edge_time): Likewise. + (estimate_time_after_inlining): Likewise. + (estimate_size_after_inlining): Likewise. + (do_estimate_growth): Likewise. + (growth_likely_positive): Likewise. + (inline_generate_summary): Likewise. + (inline_read_section): Likewise. + (inline_read_summary): Likewise. + (inline_write_summary): Likewise. + (inline_free_summary): Likewise. + * ipa-inline-transform.c (clone_inlined_nodes): Likewise. + (inline_call): Likewise. + * ipa-inline.c (caller_growth_limits): Likewise. + (can_inline_edge_p): Likewise. + (want_early_inline_function_p): Likewise. + (compute_uninlined_call_time): Likewise. + (compute_inlined_call_time): Likewise. + (big_speedup_p): Likewise. + (want_inline_small_function_p): Likewise. + (edge_badness): Likewise. + (update_caller_keys): Likewise. + (update_callee_keys): Likewise. + (recursive_inlining): Likewise. + (inline_small_functions): Likewise. + (inline_to_all_callers): Likewise. + (dump_overall_stats): Likewise. + (early_inline_small_functions): Likewise. + * ipa-inline.h: New class inline_summary_t replaces + vec<inline_summary_t>. + * ipa-split.c (execute_split_functions): New inline_summaries is used. + * ipa.c (walk_polymorphic_call_targets): Likewise. + * tree-sra.c (ipa_sra_preliminary_function_checks): Likewise. + +2014-12-22 Martin Liska <mliska@suse.cz> + * auto-profile.c: Include of symbol-summary.h is added. * cgraph.c: Likewise. * cgraphbuild.c: Likewise. diff --git a/gcc/cgraphunit.c b/gcc/cgraphunit.c index 41b284c466b..a1295d1f4fe 100644 --- a/gcc/cgraphunit.c +++ b/gcc/cgraphunit.c @@ -341,7 +341,7 @@ symbol_table::process_new_functions (void) if ((state == IPA_SSA || state == IPA_SSA_AFTER_INLINING) && !gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl))) g->get_passes ()->execute_early_local_passes (); - else if (inline_summary_vec != NULL) + else if (inline_summaries != NULL) compute_inline_parameters (node, true); free_dominance_info (CDI_POST_DOMINATORS); free_dominance_info (CDI_DOMINATORS); diff --git a/gcc/ipa-cp.c b/gcc/ipa-cp.c index ba86f0e8583..ba434ba16ad 100644 --- a/gcc/ipa-cp.c +++ b/gcc/ipa-cp.c @@ -598,7 +598,7 @@ ipcp_cloning_candidate_p (struct cgraph_node *node) init_caller_stats (&stats); node->call_for_symbol_thunks_and_aliases (gather_caller_stats, &stats, false); - if (inline_summary (node)->self_size < stats.n_calls) + if (inline_summaries->get (node)->self_size < stats.n_calls) { if (dump_file) fprintf (dump_file, "Considering %s for cloning; code might shrink.\n", @@ -2064,7 +2064,7 @@ devirtualization_time_bonus (struct cgraph_node *node, callee = callee->function_symbol (&avail); if (avail < AVAIL_AVAILABLE) continue; - isummary = inline_summary (callee); + isummary = inline_summaries->get (callee); if (!isummary->inlinable) continue; @@ -2311,7 +2311,7 @@ estimate_local_effects (struct cgraph_node *node) vec<ipa_agg_jump_function> known_aggs; vec<ipa_agg_jump_function_p> known_aggs_ptrs; bool always_const; - int base_time = inline_summary (node)->time; + int base_time = inline_summaries->get (node)->time; int removable_params_cost; if (!count || !ipcp_versionable_function_p (node)) @@ -2728,7 +2728,7 @@ ipcp_propagate_stage (struct ipa_topo_info *topo) initialize_node_lattices (node); } if (node->definition && !node->alias) - overall_size += inline_summary (node)->self_size; + overall_size += inline_summaries->get (node)->self_size; if (node->count > max_count) max_count = node->count; } diff --git a/gcc/ipa-inline-analysis.c b/gcc/ipa-inline-analysis.c index 888d6e35f85..7da373ec3b6 100644 --- a/gcc/ipa-inline-analysis.c +++ b/gcc/ipa-inline-analysis.c @@ -148,21 +148,15 @@ enum predicate_conditions #define CHANGED IDENTIFIER_NODE /* Holders of ipa cgraph hooks: */ -static struct cgraph_node_hook_list *function_insertion_hook_holder; -static struct cgraph_node_hook_list *node_removal_hook_holder; -static struct cgraph_2node_hook_list *node_duplication_hook_holder; static struct cgraph_2edge_hook_list *edge_duplication_hook_holder; static struct cgraph_edge_hook_list *edge_removal_hook_holder; -static void inline_node_removal_hook (struct cgraph_node *, void *); -static void inline_node_duplication_hook (struct cgraph_node *, - struct cgraph_node *, void *); static void inline_edge_removal_hook (struct cgraph_edge *, void *); static void inline_edge_duplication_hook (struct cgraph_edge *, struct cgraph_edge *, void *); /* VECtor holding inline summaries. In GGC memory because conditions might point to constant trees. */ -vec<inline_summary_t, va_gc> *inline_summary_vec; +function_summary <inline_summary *> *inline_summaries; vec<inline_edge_summary_t> inline_edge_summary_vec; /* Cached node/edge growths. */ @@ -828,7 +822,7 @@ evaluate_conditions_for_known_args (struct cgraph_node *node, known_aggs) { clause_t clause = inline_p ? 0 : 1 << predicate_not_inlined_condition; - struct inline_summary *info = inline_summary (node); + struct inline_summary *info = inline_summaries->get (node); int i; struct condition *c; @@ -910,7 +904,7 @@ evaluate_properties_for_edge (struct cgraph_edge *e, bool inline_p, vec<ipa_agg_jump_function_p> *known_aggs_ptr) { struct cgraph_node *callee = e->callee->ultimate_alias_target (); - struct inline_summary *info = inline_summary (callee); + struct inline_summary *info = inline_summaries->get (callee); vec<tree> known_vals = vNULL; vec<ipa_agg_jump_function_p> known_aggs = vNULL; @@ -986,21 +980,16 @@ evaluate_properties_for_edge (struct cgraph_edge *e, bool inline_p, static void inline_summary_alloc (void) { - if (!node_removal_hook_holder) - node_removal_hook_holder = - symtab->add_cgraph_removal_hook (&inline_node_removal_hook, NULL); if (!edge_removal_hook_holder) edge_removal_hook_holder = symtab->add_edge_removal_hook (&inline_edge_removal_hook, NULL); - if (!node_duplication_hook_holder) - node_duplication_hook_holder = - symtab->add_cgraph_duplication_hook (&inline_node_duplication_hook, NULL); if (!edge_duplication_hook_holder) edge_duplication_hook_holder = symtab->add_edge_duplication_hook (&inline_edge_duplication_hook, NULL); - if (vec_safe_length (inline_summary_vec) <= (unsigned) symtab->cgraph_max_uid) - vec_safe_grow_cleared (inline_summary_vec, symtab->cgraph_max_uid + 1); + if (!inline_summaries) + inline_summaries = (inline_summary_t*) inline_summary_t::create_ggc (symtab); + if (inline_edge_summary_vec.length () <= (unsigned) symtab->edges_max_uid) inline_edge_summary_vec.safe_grow_cleared (symtab->edges_max_uid + 1); if (!edge_predicate_pool) @@ -1030,9 +1019,9 @@ reset_inline_edge_summary (struct cgraph_edge *e) data from previous run so they are not cumulated. */ static void -reset_inline_summary (struct cgraph_node *node) +reset_inline_summary (struct cgraph_node *node, + inline_summary *info) { - struct inline_summary *info = inline_summary (node); struct cgraph_edge *e; info->self_size = info->self_time = 0; @@ -1068,16 +1057,10 @@ reset_inline_summary (struct cgraph_node *node) /* Hook that is called by cgraph.c when a node is removed. */ -static void -inline_node_removal_hook (struct cgraph_node *node, - void *data ATTRIBUTE_UNUSED) +void +inline_summary_t::remove (cgraph_node *node, inline_summary *info) { - struct inline_summary *info; - if (vec_safe_length (inline_summary_vec) <= (unsigned) node->uid) - return; - info = inline_summary (node); - reset_inline_summary (node); - memset (info, 0, sizeof (inline_summary_t)); + reset_inline_summary (node, info); } /* Remap predicate P of former function to be predicate of duplicated function. @@ -1127,16 +1110,14 @@ remap_hint_predicate_after_duplication (struct predicate **p, /* Hook that is called by cgraph.c when a node is duplicated. */ - -static void -inline_node_duplication_hook (struct cgraph_node *src, - struct cgraph_node *dst, - ATTRIBUTE_UNUSED void *data) +void +inline_summary_t::duplicate (cgraph_node *src, + cgraph_node *dst, + inline_summary *, + inline_summary *info) { - struct inline_summary *info; inline_summary_alloc (); - info = inline_summary (dst); - memcpy (info, inline_summary (src), sizeof (struct inline_summary)); + memcpy (info, inline_summaries->get (src), sizeof (inline_summary)); /* TODO: as an optimization, we may avoid copying conditions that are known to be false or true. */ info->conds = vec_safe_copy (info->conds); @@ -1357,8 +1338,8 @@ dump_inline_edge_summary (FILE *f, int indent, struct cgraph_node *node, ? "inlined" : cgraph_inline_failed_string (edge-> inline_failed), indent, "", es->loop_depth, edge->frequency, es->call_stmt_size, es->call_stmt_time, - (int) inline_summary (callee)->size / INLINE_SIZE_SCALE, - (int) inline_summary (callee)->estimated_stack_size); + (int) inline_summaries->get (callee)->size / INLINE_SIZE_SCALE, + (int) inline_summaries->get (callee)->estimated_stack_size); if (es->predicate) { @@ -1384,9 +1365,9 @@ dump_inline_edge_summary (FILE *f, int indent, struct cgraph_node *node, fprintf (f, "%*sStack frame offset %i, callee self size %i," " callee size %i\n", indent + 2, "", - (int) inline_summary (callee)->stack_frame_offset, - (int) inline_summary (callee)->estimated_self_stack_size, - (int) inline_summary (callee)->estimated_stack_size); + (int) inline_summaries->get (callee)->stack_frame_offset, + (int) inline_summaries->get (callee)->estimated_self_stack_size, + (int) inline_summaries->get (callee)->estimated_stack_size); dump_inline_edge_summary (f, indent + 2, callee, info); } } @@ -1414,7 +1395,7 @@ dump_inline_summary (FILE *f, struct cgraph_node *node) { if (node->definition) { - struct inline_summary *s = inline_summary (node); + struct inline_summary *s = inline_summaries->get (node); size_time_entry *e; int i; fprintf (f, "Inline summary for %s/%i", node->name (), @@ -2227,7 +2208,7 @@ param_change_prob (gimple stmt, int i) static bool phi_result_unknown_predicate (struct ipa_node_params *info, - struct inline_summary *summary, basic_block bb, + inline_summary *summary, basic_block bb, struct predicate *p, vec<predicate_t> nonconstant_names) { @@ -2316,7 +2297,7 @@ predicate_for_phi_result (struct inline_summary *summary, gphi *phi, /* Return predicate specifying when array index in access OP becomes non-constant. */ static struct predicate -array_index_predicate (struct inline_summary *info, +array_index_predicate (inline_summary *info, vec< predicate_t> nonconstant_names, tree op) { struct predicate p = false_predicate (); @@ -2471,7 +2452,7 @@ estimate_function_body_sizes (struct cgraph_node *node, bool early) basic_block bb; struct function *my_function = DECL_STRUCT_FUNCTION (node->decl); int freq; - struct inline_summary *info = inline_summary (node); + struct inline_summary *info = inline_summaries->get (node); struct predicate bb_predicate; struct ipa_node_params *parms_info = NULL; vec<predicate_t> nonconstant_names = vNULL; @@ -2717,7 +2698,7 @@ estimate_function_body_sizes (struct cgraph_node *node, bool early) } } } - set_hint_predicate (&inline_summary (node)->array_index, array_index); + set_hint_predicate (&inline_summaries->get (node)->array_index, array_index); time = (time + CGRAPH_FREQ_BASE / 2) / CGRAPH_FREQ_BASE; if (time > MAX_TIME) time = MAX_TIME; @@ -2805,9 +2786,9 @@ estimate_function_body_sizes (struct cgraph_node *node, bool early) } free (body); } - set_hint_predicate (&inline_summary (node)->loop_iterations, + set_hint_predicate (&inline_summaries->get (node)->loop_iterations, loop_iterations); - set_hint_predicate (&inline_summary (node)->loop_stride, loop_stride); + set_hint_predicate (&inline_summaries->get (node)->loop_stride, loop_stride); scev_finalize (); } FOR_ALL_BB_FN (bb, my_function) @@ -2825,8 +2806,8 @@ estimate_function_body_sizes (struct cgraph_node *node, bool early) e->aux = NULL; } } - inline_summary (node)->self_time = time; - inline_summary (node)->self_size = size; + inline_summaries->get (node)->self_time = time; + inline_summaries->get (node)->self_size = size; nonconstant_names.release (); if (opt_for_fn (node->decl, optimize) && !early) { @@ -2855,8 +2836,8 @@ compute_inline_parameters (struct cgraph_node *node, bool early) inline_summary_alloc (); - info = inline_summary (node); - reset_inline_summary (node); + info = inline_summaries->get (node); + reset_inline_summary (node, info); /* FIXME: Thunks are inlinable, but tree-inline don't know how to do that. Once this happen, we will need to more curefully predict call @@ -3024,7 +3005,7 @@ estimate_edge_devirt_benefit (struct cgraph_edge *ie, callee = callee->function_symbol (&avail); if (avail < AVAIL_AVAILABLE) return false; - isummary = inline_summary (callee); + isummary = inline_summaries->get (callee); return isummary->inlinable; } @@ -3136,7 +3117,7 @@ estimate_node_size_and_time (struct cgraph_node *node, vec<inline_param_summary> inline_param_summary) { - struct inline_summary *info = inline_summary (node); + struct inline_summary *info = inline_summaries->get (node); size_time_entry *e; int size = 0; int time = 0; @@ -3353,8 +3334,8 @@ static void inline_update_callee_summaries (struct cgraph_node *node, int depth) { struct cgraph_edge *e; - struct inline_summary *callee_info = inline_summary (node); - struct inline_summary *caller_info = inline_summary (node->callers->caller); + struct inline_summary *callee_info = inline_summaries->get (node); + struct inline_summary *caller_info = inline_summaries->get (node->callers->caller); HOST_WIDE_INT peak; callee_info->stack_frame_offset @@ -3362,8 +3343,8 @@ inline_update_callee_summaries (struct cgraph_node *node, int depth) + caller_info->estimated_self_stack_size; peak = callee_info->stack_frame_offset + callee_info->estimated_self_stack_size; - if (inline_summary (node->global.inlined_to)->estimated_stack_size < peak) - inline_summary (node->global.inlined_to)->estimated_stack_size = peak; + if (inline_summaries->get (node->global.inlined_to)->estimated_stack_size < peak) + inline_summaries->get (node->global.inlined_to)->estimated_stack_size = peak; ipa_propagate_frequency (node); for (e = node->callees; e; e = e->next_callee) { @@ -3523,10 +3504,10 @@ remap_hint_predicate (struct inline_summary *info, void inline_merge_summary (struct cgraph_edge *edge) { - struct inline_summary *callee_info = inline_summary (edge->callee); + struct inline_summary *callee_info = inline_summaries->get (edge->callee); struct cgraph_node *to = (edge->caller->global.inlined_to ? edge->caller->global.inlined_to : edge->caller); - struct inline_summary *info = inline_summary (to); + struct inline_summary *info = inline_summaries->get (to); clause_t clause = 0; /* not_inline is known to be false. */ size_time_entry *e; vec<int> operand_map = vNULL; @@ -3635,7 +3616,7 @@ inline_merge_summary (struct cgraph_edge *edge) void inline_update_overall_summary (struct cgraph_node *node) { - struct inline_summary *info = inline_summary (node); + struct inline_summary *info = inline_summaries->get (node); size_time_entry *e; int i; @@ -3662,8 +3643,8 @@ simple_edge_hints (struct cgraph_edge *edge) int hints = 0; struct cgraph_node *to = (edge->caller->global.inlined_to ? edge->caller->global.inlined_to : edge->caller); - if (inline_summary (to)->scc_no - && inline_summary (to)->scc_no == inline_summary (edge->callee)->scc_no + if (inline_summaries->get (to)->scc_no + && inline_summaries->get (to)->scc_no == inline_summaries->get (edge->callee)->scc_no && !edge->recursive_p ()) hints |= INLINE_HINT_same_scc; @@ -3723,7 +3704,7 @@ do_estimate_edge_time (struct cgraph_edge *edge) /* When caching, update the cache entry. */ if (edge_growth_cache.exists ()) { - inline_summary (edge->callee)->min_size = min_size; + inline_summaries->get (edge->callee)->min_size = min_size; if ((int) edge_growth_cache.length () <= edge->uid) edge_growth_cache.safe_grow_cleared (symtab->edges_max_uid); edge_growth_cache[edge->uid].time = time + (time >= 0); @@ -3825,14 +3806,14 @@ estimate_time_after_inlining (struct cgraph_node *node, if (!es->predicate || !false_predicate_p (es->predicate)) { gcov_type time = - inline_summary (node)->time + estimate_edge_time (edge); + inline_summaries->get (node)->time + estimate_edge_time (edge); if (time < 0) time = 0; if (time > MAX_TIME) time = MAX_TIME; return time; } - return inline_summary (node)->time; + return inline_summaries->get (node)->time; } @@ -3846,11 +3827,11 @@ estimate_size_after_inlining (struct cgraph_node *node, struct inline_edge_summary *es = inline_edge_summary (edge); if (!es->predicate || !false_predicate_p (es->predicate)) { - int size = inline_summary (node)->size + estimate_edge_growth (edge); + int size = inline_summaries->get (node)->size + estimate_edge_growth (edge); gcc_assert (size >= 0); return size; } - return inline_summary (node)->size; + return inline_summaries->get (node)->size; } @@ -3890,7 +3871,7 @@ int do_estimate_growth (struct cgraph_node *node) { struct growth_data d = { node, 0, false }; - struct inline_summary *info = inline_summary (node); + struct inline_summary *info = inline_summaries->get (node); node->call_for_symbol_thunks_and_aliases (do_estimate_growth_1, &d, true); @@ -3963,7 +3944,7 @@ growth_likely_positive (struct cgraph_node *node, int edge_growth ATTRIBUTE_UNUS && (!DECL_COMDAT (node->decl) || !node->can_remove_if_no_direct_calls_p ())) return true; - max_callers = inline_summary (node)->size * 4 / edge_growth + 2; + max_callers = inline_summaries->get (node)->size * 4 / edge_growth + 2; for (e = node->callers; e; e = e->next_caller) { @@ -4026,13 +4007,12 @@ inline_analyze_function (struct cgraph_node *node) /* Called when new function is inserted to callgraph late. */ -static void -add_new_function (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED) +void +inline_summary_t::insert (struct cgraph_node *node, inline_summary *) { inline_analyze_function (node); } - /* Note function body size. */ void @@ -4045,8 +4025,10 @@ inline_generate_summary (void) if (!optimize && !flag_generate_lto && !flag_generate_offload && !flag_wpa) return; - function_insertion_hook_holder = - symtab->add_cgraph_insertion_hook (&add_new_function, NULL); + if (!inline_summaries) + inline_summaries = (inline_summary_t*) inline_summary_t::create_ggc (symtab); + + inline_summaries->enable_insertion_hook (); ipa_register_cgraph_hooks (); inline_free_summary (); @@ -4140,7 +4122,7 @@ inline_read_section (struct lto_file_decl_data *file_data, const char *data, encoder = file_data->symtab_node_encoder; node = dyn_cast<cgraph_node *> (lto_symtab_encoder_deref (encoder, index)); - info = inline_summary (node); + info = inline_summaries->get (node); info->estimated_stack_size = info->estimated_self_stack_size = streamer_read_uhwi (&ib); @@ -4229,8 +4211,9 @@ inline_read_summary (void) if (!flag_ipa_cp) ipa_prop_read_jump_functions (); } - function_insertion_hook_holder = - symtab->add_cgraph_insertion_hook (&add_new_function, NULL); + + gcc_assert (inline_summaries); + inline_summaries->enable_insertion_hook (); } @@ -4296,7 +4279,7 @@ inline_write_summary (void) cgraph_node *cnode = dyn_cast <cgraph_node *> (snode); if (cnode && (node = cnode)->definition && !node->alias) { - struct inline_summary *info = inline_summary (node); + struct inline_summary *info = inline_summaries->get (node); struct bitpack_d bp; struct cgraph_edge *edge; int i; @@ -4357,18 +4340,9 @@ void inline_free_summary (void) { struct cgraph_node *node; - if (function_insertion_hook_holder) - symtab->remove_cgraph_insertion_hook (function_insertion_hook_holder); - function_insertion_hook_holder = NULL; - if (node_removal_hook_holder) - symtab->remove_cgraph_removal_hook (node_removal_hook_holder); - node_removal_hook_holder = NULL; if (edge_removal_hook_holder) symtab->remove_edge_removal_hook (edge_removal_hook_holder); edge_removal_hook_holder = NULL; - if (node_duplication_hook_holder) - symtab->remove_cgraph_duplication_hook (node_duplication_hook_holder); - node_duplication_hook_holder = NULL; if (edge_duplication_hook_holder) symtab->remove_edge_duplication_hook (edge_duplication_hook_holder); edge_duplication_hook_holder = NULL; @@ -4376,8 +4350,9 @@ inline_free_summary (void) return; FOR_EACH_DEFINED_FUNCTION (node) if (!node->alias) - reset_inline_summary (node); - vec_free (inline_summary_vec); + reset_inline_summary (node, inline_summaries->get (node)); + inline_summaries->release (); + inline_summaries = NULL; inline_edge_summary_vec.release (); if (edge_predicate_pool) free_alloc_pool (edge_predicate_pool); diff --git a/gcc/ipa-inline-transform.c b/gcc/ipa-inline-transform.c index 62f68f09972..c521f642147 100644 --- a/gcc/ipa-inline-transform.c +++ b/gcc/ipa-inline-transform.c @@ -212,7 +212,7 @@ clone_inlined_nodes (struct cgraph_edge *e, bool duplicate, if (e->callee->definition && !DECL_EXTERNAL (e->callee->decl)) { if (overall_size) - *overall_size -= inline_summary (e->callee)->size; + *overall_size -= inline_summaries->get (e->callee)->size; nfunctions_inlined++; } duplicate = false; @@ -322,13 +322,13 @@ inline_call (struct cgraph_edge *e, bool update_original, gcc_assert (curr->callee->global.inlined_to == to); - old_size = inline_summary (to)->size; + old_size = inline_summaries->get (to)->size; inline_merge_summary (e); if (optimize) new_edges_found = ipa_propagate_indirect_call_infos (curr, new_edges); if (update_overall_summary) inline_update_overall_summary (to); - new_size = inline_summary (to)->size; + new_size = inline_summaries->get (to)->size; if (callee->calls_comdat_local) to->calls_comdat_local = true; diff --git a/gcc/ipa-inline.c b/gcc/ipa-inline.c index dc017c6ff46..24ca66e0b38 100644 --- a/gcc/ipa-inline.c +++ b/gcc/ipa-inline.c @@ -170,7 +170,7 @@ caller_growth_limits (struct cgraph_edge *e) int newsize; int limit = 0; HOST_WIDE_INT stack_size_limit = 0, inlined_stack; - struct inline_summary *info, *what_info, *outer_info = inline_summary (to); + inline_summary *info, *what_info, *outer_info = inline_summaries->get (to); /* Look for function e->caller is inlined to. While doing so work out the largest function body on the way. As @@ -182,7 +182,7 @@ caller_growth_limits (struct cgraph_edge *e) too much in order to prevent compiler from exploding". */ while (true) { - info = inline_summary (to); + info = inline_summaries->get (to); if (limit < info->self_size) limit = info->self_size; if (stack_size_limit < info->estimated_self_stack_size) @@ -193,7 +193,7 @@ caller_growth_limits (struct cgraph_edge *e) break; } - what_info = inline_summary (what); + what_info = inline_summaries->get (what); if (limit < what_info->self_size) limit = what_info->self_size; @@ -307,7 +307,7 @@ can_inline_edge_p (struct cgraph_edge *e, bool report, e->inline_failed = CIF_USES_COMDAT_LOCAL; inlinable = false; } - else if (!inline_summary (callee)->inlinable + else if (!inline_summaries->get (callee)->inlinable || (caller_fun && fn_contains_cilk_spawn_p (caller_fun))) { e->inline_failed = CIF_FUNCTION_NOT_INLINABLE; @@ -453,7 +453,7 @@ want_early_inline_function_p (struct cgraph_edge *e) if (DECL_DISREGARD_INLINE_LIMITS (callee->decl)) ; - /* For AutoFDO, we need to make sure that before profile annotation, all + /* For AutoFDO, we need to make sure that before profile summary, all hot paths' IR look exactly the same as profiled binary. As a result, in einliner, we will disregard size limit and inline those callsites that are: @@ -525,7 +525,7 @@ compute_uninlined_call_time (struct inline_summary *callee_info, gcov_type uninlined_call_time = RDIV ((gcov_type)callee_info->time * MAX (edge->frequency, 1), CGRAPH_FREQ_BASE); - gcov_type caller_time = inline_summary (edge->caller->global.inlined_to + gcov_type caller_time = inline_summaries->get (edge->caller->global.inlined_to ? edge->caller->global.inlined_to : edge->caller)->time; return uninlined_call_time + caller_time; @@ -538,7 +538,7 @@ inline gcov_type compute_inlined_call_time (struct cgraph_edge *edge, int edge_time) { - gcov_type caller_time = inline_summary (edge->caller->global.inlined_to + gcov_type caller_time = inline_summaries->get (edge->caller->global.inlined_to ? edge->caller->global.inlined_to : edge->caller)->time; gcov_type time = (caller_time @@ -558,7 +558,7 @@ compute_inlined_call_time (struct cgraph_edge *edge, static bool big_speedup_p (struct cgraph_edge *e) { - gcov_type time = compute_uninlined_call_time (inline_summary (e->callee), + gcov_type time = compute_uninlined_call_time (inline_summaries->get (e->callee), e); gcov_type inlined_time = compute_inlined_call_time (e, estimate_edge_time (e)); @@ -591,7 +591,7 @@ want_inline_small_function_p (struct cgraph_edge *e, bool report) MAX_INLINE_INSNS_SINGLE 16-fold for inline functions. */ else if ((!DECL_DECLARED_INLINE_P (callee->decl) && (!e->count || !e->maybe_hot_p ())) - && inline_summary (callee)->min_size + && inline_summaries->get (callee)->min_size - inline_edge_summary (e)->call_stmt_size > MAX (MAX_INLINE_INSNS_SINGLE, MAX_INLINE_INSNS_AUTO)) { @@ -599,7 +599,7 @@ want_inline_small_function_p (struct cgraph_edge *e, bool report) want_inline = false; } else if ((DECL_DECLARED_INLINE_P (callee->decl) || e->count) - && inline_summary (callee)->min_size + && inline_summaries->get (callee)->min_size - inline_edge_summary (e)->call_stmt_size > 16 * MAX_INLINE_INSNS_SINGLE) { @@ -910,7 +910,7 @@ edge_badness (struct cgraph_edge *edge, bool dump) sreal badness; int growth, edge_time; struct cgraph_node *callee = edge->callee->ultimate_alias_target (); - struct inline_summary *callee_info = inline_summary (callee); + struct inline_summary *callee_info = inline_summaries->get (callee); inline_hints hints; if (DECL_DISREGARD_INLINE_LIMITS (callee->decl)) @@ -1188,7 +1188,7 @@ update_caller_keys (edge_heap_t *heap, struct cgraph_node *node, struct cgraph_edge *edge; struct ipa_ref *ref; - if ((!node->alias && !inline_summary (node)->inlinable) + if ((!node->alias && !inline_summaries->get (node)->inlinable) || node->global.inlined_to) return; if (!bitmap_set_bit (updated_nodes, node->uid)) @@ -1246,7 +1246,7 @@ update_callee_keys (edge_heap_t *heap, struct cgraph_node *node, don't need updating. */ if (e->inline_failed && (callee = e->callee->ultimate_alias_target (&avail)) - && inline_summary (callee)->inlinable + && inline_summaries->get (callee)->inlinable && avail >= AVAIL_AVAILABLE && !bitmap_bit_p (updated_nodes, callee->uid)) { @@ -1417,8 +1417,8 @@ recursive_inlining (struct cgraph_edge *edge, fprintf (dump_file, "\n Inlined %i times, " "body grown from size %i to %i, time %i to %i\n", n, - inline_summary (master_clone)->size, inline_summary (node)->size, - inline_summary (master_clone)->time, inline_summary (node)->time); + inline_summaries->get (master_clone)->size, inline_summaries->get (node)->size, + inline_summaries->get (master_clone)->time, inline_summaries->get (node)->time); /* Remove master clone we used for inlining. We rely that clones inlined into master clone gets queued just before master clone so we don't @@ -1591,7 +1591,7 @@ inline_small_functions (void) if (node->has_gimple_body_p () || node->thunk.thunk_p) { - struct inline_summary *info = inline_summary (node); + struct inline_summary *info = inline_summaries->get (node); struct ipa_dfs_info *dfs = (struct ipa_dfs_info *) node->aux; /* Do not account external functions, they will be optimized out @@ -1607,7 +1607,7 @@ inline_small_functions (void) for (n2 = node; n2; n2 = ((struct ipa_dfs_info *) node->aux)->next_cycle) { - struct inline_summary *info2 = inline_summary (n2); + struct inline_summary *info2 = inline_summaries->get (n2); if (info2->scc_no) break; info2->scc_no = id; @@ -1727,7 +1727,7 @@ inline_small_functions (void) fprintf (dump_file, "\nConsidering %s/%i with %i size\n", callee->name (), callee->order, - inline_summary (callee)->size); + inline_summaries->get (callee)->size); fprintf (dump_file, " to be inlined into %s/%i in %s:%i\n" " Estimated badness is %"PRId64", frequency %.2f.\n", @@ -1845,8 +1845,8 @@ inline_small_functions (void) " Inlined into %s which now has time %i and size %i," "net change of %+i.\n", edge->caller->name (), - inline_summary (edge->caller)->time, - inline_summary (edge->caller)->size, + inline_summaries->get (edge->caller)->time, + inline_summaries->get (edge->caller)->size, overall_size - old_size); } if (min_size > overall_size) @@ -1983,11 +1983,11 @@ inline_to_all_callers (struct cgraph_node *node, void *data) fprintf (dump_file, "\nInlining %s size %i.\n", node->name (), - inline_summary (node)->size); + inline_summaries->get (node)->size); fprintf (dump_file, " Called once from %s %i insns.\n", node->callers->caller->name (), - inline_summary (node->callers->caller)->size); + inline_summaries->get (node->callers->caller)->size); } inline_call (node->callers, true, NULL, NULL, true, &callee_removed); @@ -1995,7 +1995,7 @@ inline_to_all_callers (struct cgraph_node *node, void *data) fprintf (dump_file, " Inlined into %s which now has %i size\n", caller->name (), - inline_summary (caller)->size); + inline_summaries->get (caller)->size); if (!(*num_calls)--) { if (dump_file) @@ -2019,7 +2019,7 @@ dump_overall_stats (void) if (!node->global.inlined_to && !node->alias) { - int time = inline_summary (node)->time; + int time = inline_summaries->get (node)->time; sum += time; sum_weighted += time * node->count; } @@ -2339,7 +2339,7 @@ early_inline_small_functions (struct cgraph_node *node) for (e = node->callees; e; e = e->next_callee) { struct cgraph_node *callee = e->callee->ultimate_alias_target (); - if (!inline_summary (callee)->inlinable + if (!inline_summaries->get (callee)->inlinable || !e->inline_failed) continue; diff --git a/gcc/ipa-inline.h b/gcc/ipa-inline.h index 4ba626441a2..8d33c3c18d7 100644 --- a/gcc/ipa-inline.h +++ b/gcc/ipa-inline.h @@ -162,10 +162,28 @@ struct GTY(()) inline_summary int scc_no; }; -/* Need a typedef for inline_summary because of inline function - 'inline_summary' below. */ -typedef struct inline_summary inline_summary_t; -extern GTY(()) vec<inline_summary_t, va_gc> *inline_summary_vec; +class GTY((user)) inline_summary_t: public function_summary <inline_summary *> +{ +public: + inline_summary_t (symbol_table *symtab, bool ggc): + function_summary <inline_summary *> (symtab, ggc) {} + + static inline_summary_t *create_ggc (symbol_table *symtab) + { + struct inline_summary_t *summary = new (ggc_cleared_alloc <inline_summary_t> ()) + inline_summary_t(symtab, true); + summary->disable_insertion_hook (); + return summary; + } + + + virtual void insert (cgraph_node *, inline_summary *); + virtual void remove (cgraph_node *node, inline_summary *); + virtual void duplicate (cgraph_node *src, cgraph_node *dst, + inline_summary *src_data, inline_summary *dst_data); +}; + +extern GTY(()) function_summary <inline_summary *> *inline_summaries; /* Information kept about parameter of call site. */ struct inline_param_summary @@ -250,12 +268,6 @@ void clone_inlined_nodes (struct cgraph_edge *e, bool, bool, int *, extern int ncalls_inlined; extern int nfunctions_inlined; -static inline struct inline_summary * -inline_summary (struct cgraph_node *node) -{ - return &(*inline_summary_vec)[node->uid]; -} - static inline struct inline_edge_summary * inline_edge_summary (struct cgraph_edge *edge) { diff --git a/gcc/ipa-prop.h b/gcc/ipa-prop.h index 16ab1d08e89..b16b151ed46 100644 --- a/gcc/ipa-prop.h +++ b/gcc/ipa-prop.h @@ -471,7 +471,7 @@ ipa_get_ith_polymorhic_call_context (struct ipa_edge_args *args, int i) return &(*args->polymorphic_call_contexts)[i]; } -/* Callgraph summary for ipa_node_params. */ +/* Function summary for ipa_node_params. */ class ipa_node_params_t: public function_summary <ipa_node_params *> { public: diff --git a/gcc/ipa-split.c b/gcc/ipa-split.c index 2670643f06b..f03ceaada64 100644 --- a/gcc/ipa-split.c +++ b/gcc/ipa-split.c @@ -1678,7 +1678,7 @@ execute_split_functions (void) /* This can be relaxed; function might become inlinable after splitting away the uninlinable part. */ if (inline_edge_summary_vec.exists () - && !inline_summary (node)->inlinable) + && !inline_summaries->get (node)->inlinable) { if (dump_file) fprintf (dump_file, "Not splitting: not inlinable.\n"); diff --git a/gcc/ipa.c b/gcc/ipa.c index aca9498b7ad..49a3d82c85b 100644 --- a/gcc/ipa.c +++ b/gcc/ipa.c @@ -246,7 +246,7 @@ walk_polymorphic_call_targets (hash_set<void *> *reachable_call_targets, target->order); } edge = edge->make_direct (target); - if (inline_summary_vec) + if (inline_summaries) inline_update_overall_summary (node); else if (edge->call_stmt) { diff --git a/gcc/lto/ChangeLog b/gcc/lto/ChangeLog index 8e158bedef9..40cdb4ef206 100644 --- a/gcc/lto/ChangeLog +++ b/gcc/lto/ChangeLog @@ -1,5 +1,12 @@ 2014-12-22 Martin Liska <mliska@suse.cz> + * lto-partition.c (add_symbol_to_partition_1): New inline_summaries + is used. + (undo_partition): Likewise. + (lto_balanced_map): Likewise. + +2014-12-22 Martin Liska <mliska@suse.cz> + * lto-partition.c: Include of symbol-summary.h is added. * lto-symtab.c: Likewise. * lto.c: Likewise. diff --git a/gcc/lto/lto-partition.c b/gcc/lto/lto-partition.c index 13beafbdb2a..160b910c31a 100644 --- a/gcc/lto/lto-partition.c +++ b/gcc/lto/lto-partition.c @@ -165,7 +165,7 @@ add_symbol_to_partition_1 (ltrans_partition part, symtab_node *node) { struct cgraph_edge *e; if (!node->alias) - part->insns += inline_summary (cnode)->self_size; + part->insns += inline_summaries->get (cnode)->self_size; /* Add all inline clones and callees that are duplicated. */ for (e = cnode->callees; e; e = e->next_callee) @@ -274,7 +274,7 @@ undo_partition (ltrans_partition partition, unsigned int n_nodes) partition->initializers_visited = NULL; if (!node->alias && (cnode = dyn_cast <cgraph_node *> (node))) - partition->insns -= inline_summary (cnode)->self_size; + partition->insns -= inline_summaries->get (cnode)->self_size; lto_symtab_encoder_delete_node (partition->encoder, node); node->aux = (void *)((size_t)node->aux - 1); } @@ -477,7 +477,7 @@ lto_balanced_map (int n_lto_partitions) else order[n_nodes++] = node; if (!node->alias) - total_size += inline_summary (node)->size; + total_size += inline_summaries->get (node)->size; } /* Streaming works best when the source units do not cross partition @@ -534,14 +534,14 @@ lto_balanced_map (int n_lto_partitions) && noreorder[noreorder_pos]->order < current_order) { if (!noreorder[noreorder_pos]->alias) - total_size -= inline_summary (noreorder[noreorder_pos])->size; + total_size -= inline_summaries->get (noreorder[noreorder_pos])->size; next_nodes.safe_push (noreorder[noreorder_pos++]); } add_sorted_nodes (next_nodes, partition); add_symbol_to_partition (partition, order[i]); if (!order[i]->alias) - total_size -= inline_summary (order[i])->size; + total_size -= inline_summaries->get (order[i])->size; /* Once we added a new node to the partition, we also want to add diff --git a/gcc/tree-sra.c b/gcc/tree-sra.c index 4c0aa15bab9..f80a8c43a7d 100644 --- a/gcc/tree-sra.c +++ b/gcc/tree-sra.c @@ -5032,7 +5032,7 @@ ipa_sra_preliminary_function_checks (struct cgraph_node *node) } if ((DECL_COMDAT (node->decl) || DECL_EXTERNAL (node->decl)) - && inline_summary (node)->size >= MAX_INLINE_INSNS_AUTO) + && inline_summaries->get (node)->size >= MAX_INLINE_INSNS_AUTO) { if (dump_file) fprintf (dump_file, "Function too big to be made truly local.\n"); |