diff options
| -rw-r--r-- | gcc/ChangeLog | 50 | ||||
| -rw-r--r-- | gcc/Makefile.in | 6 | ||||
| -rw-r--r-- | gcc/cgraph.c | 30 | ||||
| -rw-r--r-- | gcc/cgraph.h | 22 | ||||
| -rw-r--r-- | gcc/cgraphbuild.c | 12 | ||||
| -rw-r--r-- | gcc/cgraphunit.c | 9 | ||||
| -rw-r--r-- | gcc/ipa-cp.c | 4 | ||||
| -rw-r--r-- | gcc/ipa-inline-analysis.c | 115 | ||||
| -rw-r--r-- | gcc/ipa-inline.c | 174 | ||||
| -rw-r--r-- | gcc/ipa-inline.h | 33 | ||||
| -rw-r--r-- | gcc/ipa-split.c | 5 | ||||
| -rw-r--r-- | gcc/ipa.c | 8 | ||||
| -rw-r--r-- | gcc/lto-cgraph.c | 6 | ||||
| -rw-r--r-- | gcc/lto/ChangeLog | 4 | ||||
| -rw-r--r-- | gcc/lto/lto.c | 4 | ||||
| -rw-r--r-- | gcc/tree-sra.c | 3 |
16 files changed, 288 insertions, 197 deletions
diff --git a/gcc/ChangeLog b/gcc/ChangeLog index e3a583a..237f2fd 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,53 @@ +2011-04-16 Jan Hubicka <jh@suse.cz> + + * cgraphbuild.c: Include ipa-inline.h. + (reset_inline_failed): Use initialize_inline_failed. + * cgraph.c: Include ipa-inline.h. + (cgraph_create_node_1): Do not initialize estimated_growth. + (initialize_inline_failed): More to ipa-inline-analysis.c + (dump_cgraph_node): Do not dump inline flags. + * cgraph.h (cgraph_local_info): Remove inlineable, versionable + and disregard_inline_limits flags. + (cgrpah_global_info): Remove estimated_stack_size, stack_frame_offset, + time, size, estimated_growth. + * ipa-cp.c (ipcp_versionable_function_p, ipcp_generate_summary): Update. + * cgraphunit.c (cgraph_decide_is_function_needed): Use + DECL_DISREGARD_INLINE_LIMITS. + (cgraph_analyze_function): Do not initialize + node->local.disregard_inline_limits. + * lto-cgraph.c (lto_output_node, input_overwrite_node): Do not stream + inlinable, versionable and disregard_inline_limits. + * ipa-inline.c (cgraph_clone_inlined_nodes, cgraph_mark_inline_edge, + cgraph_check_inline_limits, cgraph_default_inline_p, cgraph_edge_badness, + update_caller_keys, update_callee_keys, add_new_edges_to_heap): Update. + (cgraph_decide_inlining_of_small_function): Update; set CIF_FUNCTION_NOT_INLINABLE + for uninlinable functions. + (cgraph_decide_inlining, cgraph_edge_early_inlinable_p, + cgraph_decide_inlining_incrementally): Update. + * ipa-inline.h (inline_summary): Add inlinable, versionable, disregard_inline_limits, + estimated_stack_size, stack_frame_offset, time, size and estimated_growth + parameters. + (estimate_edge_growth): Update. + (initialize_inline_failed): Declare. + * ipa-split.c: Include ipa-inline.h + (execute_split_functions): Update. + * ipa.c (cgraph_postorder): Use DECL_DISREGARD_INLINE_LIMITS. + (cgraph_remove_unreachable_nodes): Do not clear inlinable flag. + (record_cdtor_fn): Use DECL_DISREGARD_INLINE_LIMITS. + * ipa-inline-analysis.c (inline_node_removal_hook): Update; set + estimated_growth to INT_MIN. + (inline_node_duplication_hook): Likewise. + (dump_inline_summary): Dump new fields. + (compute_inline_parameters): Update. + (estimate_edge_time, estimate_time_after_inlining, + estimate_size_after_inlining, estimate_growth, inline_read_summary, + inline_write_summary): + (initialize_inline_failed): Move here from cgraph.c. + * tree-sra.c: Include ipa-inline.h. + (ipa_sra_preliminary_function_checks): Update. + * Makefile.in: (cgraph.o, cgraphbuild.o): Add dependency on + ipa-inline.h + 2011-04-16 Uros Bizjak <ubizjak@gmail.com> * config/i386/sse.md (V16): New mode iterator. diff --git a/gcc/Makefile.in b/gcc/Makefile.in index 04b10cd..f88d61d 100644 --- a/gcc/Makefile.in +++ b/gcc/Makefile.in @@ -2983,7 +2983,8 @@ cgraph.o : cgraph.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(TREE_H) \ langhooks.h toplev.h $(DIAGNOSTIC_CORE_H) $(FLAGS_H) $(GGC_H) $(TARGET_H) $(CGRAPH_H) \ gt-cgraph.h output.h intl.h $(BASIC_BLOCK_H) debug.h $(HASHTAB_H) \ $(TREE_INLINE_H) $(TREE_DUMP_H) $(TREE_FLOW_H) cif-code.def \ - value-prof.h $(EXCEPT_H) $(IPA_UTILS_H) $(DIAGNOSTIC_CORE_H) + value-prof.h $(EXCEPT_H) $(IPA_UTILS_H) $(DIAGNOSTIC_CORE_H) \ + ipa-inline.h cgraphunit.o : cgraphunit.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \ $(TREE_H) langhooks.h $(TREE_INLINE_H) toplev.h $(DIAGNOSTIC_CORE_H) $(FLAGS_H) $(GGC_H) \ $(TARGET_H) $(CGRAPH_H) intl.h pointer-set.h $(FUNCTION_H) $(GIMPLE_H) \ @@ -2993,7 +2994,8 @@ cgraphunit.o : cgraphunit.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \ tree-pretty-print.h gimple-pretty-print.h cgraphbuild.o : cgraphbuild.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \ $(TREE_H) langhooks.h $(CGRAPH_H) intl.h pointer-set.h $(GIMPLE_H) \ - $(TREE_FLOW_H) $(TREE_PASS_H) $(IPA_UTILS_H) $(EXCEPT_H) + $(TREE_FLOW_H) $(TREE_PASS_H) $(IPA_UTILS_H) $(EXCEPT_H) \ + ipa-inline.h varpool.o : varpool.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \ $(TREE_H) $(CGRAPH_H) langhooks.h $(DIAGNOSTIC_CORE_H) $(HASHTAB_H) \ $(GGC_H) $(TIMEVAR_H) debug.h $(TARGET_H) output.h $(GIMPLE_H) \ diff --git a/gcc/cgraph.c b/gcc/cgraph.c index 09436c7..31c5b59 100644 --- a/gcc/cgraph.c +++ b/gcc/cgraph.c @@ -98,6 +98,7 @@ The callgraph: #include "rtl.h" #include "ipa-utils.h" #include "lto-streamer.h" +#include "ipa-inline.h" const char * const ld_plugin_symbol_resolution_names[]= { @@ -476,7 +477,6 @@ cgraph_create_node_1 (void) if (cgraph_nodes) cgraph_nodes->previous = node; node->previous = NULL; - node->global.estimated_growth = INT_MIN; node->frequency = NODE_FREQUENCY_NORMAL; node->count_materialization_scale = REG_BR_PROB_BASE; ipa_empty_ref_list (&node->ref_list); @@ -970,28 +970,6 @@ cgraph_create_edge_including_clones (struct cgraph_node *orig, } } -/* Give initial reasons why inlining would fail on EDGE. This gets either - nullified or usually overwritten by more precise reasons later. */ - -static void -initialize_inline_failed (struct cgraph_edge *e) -{ - struct cgraph_node *callee = e->callee; - - if (e->indirect_unknown_callee) - e->inline_failed = CIF_INDIRECT_UNKNOWN_CALL; - else if (!callee->analyzed) - e->inline_failed = CIF_BODY_NOT_AVAILABLE; - else if (callee->local.redefined_extern_inline) - e->inline_failed = CIF_REDEFINED_EXTERN_INLINE; - else if (!callee->local.inlinable) - e->inline_failed = CIF_FUNCTION_NOT_INLINABLE; - else if (e->call_stmt && gimple_call_cannot_inline_p (e->call_stmt)) - e->inline_failed = CIF_MISMATCHED_ARGUMENTS; - else - e->inline_failed = CIF_FUNCTION_NOT_CONSIDERED; -} - /* Allocate a cgraph_edge structure and fill it with data according to the parameters of which only CALLEE can be NULL (when creating an indirect call edge). */ @@ -1899,12 +1877,6 @@ dump_cgraph_node (FILE *f, struct cgraph_node *node) ld_plugin_symbol_resolution_names[(int)node->resolution]); if (node->local.finalized) fprintf (f, " finalized"); - if (node->local.disregard_inline_limits) - fprintf (f, " always_inline"); - else if (node->local.inlinable) - fprintf (f, " inlinable"); - else if (node->local.versionable) - fprintf (f, " versionable"); if (node->local.redefined_extern_inline) fprintf (f, " redefined_extern_inline"); if (TREE_ASM_WRITTEN (node->decl)) diff --git a/gcc/cgraph.h b/gcc/cgraph.h index eb51546..199349b 100644 --- a/gcc/cgraph.h +++ b/gcc/cgraph.h @@ -88,20 +88,10 @@ struct GTY(()) cgraph_local_info { /* Set once it has been finalized so we consider it to be output. */ unsigned finalized : 1; - /* False when there something makes inlining impossible (such as va_arg). */ - unsigned inlinable : 1; - - /* False when there something makes versioning impossible. - Currently computed and used only by ipa-cp. */ - unsigned versionable : 1; - /* False when function calling convention and signature can not be changed. This is the case when __builtin_apply_args is used. */ unsigned can_change_signature : 1; - /* True when function should be inlined independently on its size. */ - unsigned disregard_inline_limits : 1; - /* True when the function has been originally extern inline, but it is redefined now. */ unsigned redefined_extern_inline : 1; @@ -115,21 +105,9 @@ struct GTY(()) cgraph_local_info { once compilation is finished. Available only with -funit-at-a-time. */ struct GTY(()) cgraph_global_info { - /* Estimated stack frame consumption by the function. */ - HOST_WIDE_INT estimated_stack_size; - /* Expected offset of the stack frame of inlined function. */ - HOST_WIDE_INT stack_frame_offset; - /* For inline clones this points to the function they will be inlined into. */ struct cgraph_node *inlined_to; - - /* Estimated size of the function after inlining. */ - int time; - int size; - - /* Estimated growth after inlining. INT_MIN if not computed. */ - int estimated_growth; }; /* Information about the function that is propagated by the RTL backend. diff --git a/gcc/cgraphbuild.c b/gcc/cgraphbuild.c index 935462e..3a2cb67 100644 --- a/gcc/cgraphbuild.c +++ b/gcc/cgraphbuild.c @@ -33,6 +33,7 @@ along with GCC; see the file COPYING3. If not see #include "tree-pass.h" #include "ipa-utils.h" #include "except.h" +#include "ipa-inline.h" /* Context of record_reference. */ struct record_reference_ctx @@ -207,16 +208,7 @@ reset_inline_failed (struct cgraph_node *node) for (e = node->callers; e; e = e->next_caller) { e->callee->global.inlined_to = NULL; - if (!node->analyzed) - e->inline_failed = CIF_BODY_NOT_AVAILABLE; - else if (node->local.redefined_extern_inline) - e->inline_failed = CIF_REDEFINED_EXTERN_INLINE; - else if (!node->local.inlinable) - e->inline_failed = CIF_FUNCTION_NOT_INLINABLE; - else if (e->call_stmt_cannot_inline_p) - e->inline_failed = CIF_MISMATCHED_ARGUMENTS; - else - e->inline_failed = CIF_FUNCTION_NOT_CONSIDERED; + initialize_inline_failed (e); } } diff --git a/gcc/cgraphunit.c b/gcc/cgraphunit.c index 539dbf9..6b3ddb5 100644 --- a/gcc/cgraphunit.c +++ b/gcc/cgraphunit.c @@ -172,7 +172,7 @@ cgraph_decide_is_function_needed (struct cgraph_node *node, tree decl) if (flag_keep_inline_functions && DECL_DECLARED_INLINE_P (decl) && !DECL_EXTERNAL (decl) - && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (decl))) + && !DECL_DISREGARD_INLINE_LIMITS (decl)) return true; /* If we decided it was needed before, but at the time we didn't have @@ -191,7 +191,7 @@ cgraph_decide_is_function_needed (struct cgraph_node *node, tree decl) to change the behavior here. */ if (((TREE_PUBLIC (decl) || (!optimize - && !node->local.disregard_inline_limits + && !DECL_DISREGARD_INLINE_LIMITS (decl) && !DECL_DECLARED_INLINE_P (decl) && !(DECL_CONTEXT (decl) && TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL))) @@ -783,11 +783,6 @@ cgraph_analyze_function (struct cgraph_node *node) assign_assembler_name_if_neeeded (node->decl); - /* disregard_inline_limits affects topological order of the early optimization, - so we need to compute it ahead of rest of inline parameters. */ - node->local.disregard_inline_limits - = DECL_DISREGARD_INLINE_LIMITS (node->decl); - /* Make sure to gimplify bodies only once. During analyzing a function we lower it, which will require gimplified nested functions, so we can end up here with an already gimplified diff --git a/gcc/ipa-cp.c b/gcc/ipa-cp.c index 4cee1d4..5ec0b2c 100644 --- a/gcc/ipa-cp.c +++ b/gcc/ipa-cp.c @@ -424,7 +424,7 @@ ipcp_versionable_function_p (struct cgraph_node *node) /* There are a number of generic reasons functions cannot be versioned. We also cannot remove parameters if there are type attributes such as fnspec present. */ - if (!node->local.versionable + if (!inline_summary (node)->versionable || TYPE_ATTRIBUTES (TREE_TYPE (node->decl))) return false; @@ -1577,7 +1577,7 @@ ipcp_generate_summary (void) /* Unreachable nodes should have been eliminated before ipcp. */ gcc_assert (node->needed || node->reachable); - node->local.versionable = tree_versionable_function_p (node->decl); + inline_summary (node)->versionable = tree_versionable_function_p (node->decl); ipa_analyze_node (node); } } diff --git a/gcc/ipa-inline-analysis.c b/gcc/ipa-inline-analysis.c index 47bd2a8..6ab3e47 100644 --- a/gcc/ipa-inline-analysis.c +++ b/gcc/ipa-inline-analysis.c @@ -100,11 +100,13 @@ inline_summary_alloc (void) static void inline_node_removal_hook (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED) { + struct inline_summary *info; if (VEC_length (inline_summary_t, inline_summary_vec) <= (unsigned)node->uid) return; - memset (inline_summary (node), - 0, sizeof (inline_summary_t)); + info = inline_summary (node); + info->estimated_growth = INT_MIN; + memset (info, 0, sizeof (inline_summary_t)); } /* Hook that is called by cgraph.c when a node is duplicated. */ @@ -113,9 +115,12 @@ static void inline_node_duplication_hook (struct cgraph_node *src, struct cgraph_node *dst, ATTRIBUTE_UNUSED void *data) { + struct inline_summary *info; inline_summary_alloc (); - memcpy (inline_summary (dst), inline_summary (src), + info = inline_summary (dst); + memcpy (info, inline_summary (src), sizeof (struct inline_summary)); + info->estimated_growth = INT_MIN; } static void @@ -124,18 +129,24 @@ dump_inline_summary (FILE *f, struct cgraph_node *node) if (node->analyzed) { struct inline_summary *s = inline_summary (node); - fprintf (f, "Inline summary for %s/%i\n", cgraph_node_name (node), + fprintf (f, "Inline summary for %s/%i", cgraph_node_name (node), node->uid); - fprintf (f, " self time: %i, benefit: %i\n", + if (s->disregard_inline_limits) + fprintf (f, " always_inline"); + if (s->inlinable) + fprintf (f, " inlinable"); + if (s->versionable) + fprintf (f, " versionable"); + fprintf (f, "\n self time: %i, benefit: %i\n", s->self_time, s->time_inlining_benefit); - fprintf (f, " global time: %i\n", node->global.time); + fprintf (f, " global time: %i\n", s->time); fprintf (f, " self size: %i, benefit: %i\n", s->self_size, s->size_inlining_benefit); - fprintf (f, " global size: %i", node->global.size); + fprintf (f, " global size: %i", s->size); fprintf (f, " self stack: %i\n", (int)s->estimated_self_stack_size); fprintf (f, " global stack: %i\n\n", - (int)node->global.estimated_stack_size); + (int)s->estimated_stack_size); } } @@ -155,6 +166,26 @@ dump_inline_summaries (FILE *f) dump_inline_summary (f, node); } +/* Give initial reasons why inlining would fail on EDGE. This gets either + nullified or usually overwritten by more precise reasons later. */ + +void +initialize_inline_failed (struct cgraph_edge *e) +{ + struct cgraph_node *callee = e->callee; + + if (e->indirect_unknown_callee) + e->inline_failed = CIF_INDIRECT_UNKNOWN_CALL; + else if (!callee->analyzed) + e->inline_failed = CIF_BODY_NOT_AVAILABLE; + else if (callee->local.redefined_extern_inline) + e->inline_failed = CIF_REDEFINED_EXTERN_INLINE; + else if (e->call_stmt && gimple_call_cannot_inline_p (e->call_stmt)) + e->inline_failed = CIF_MISMATCHED_ARGUMENTS; + else + e->inline_failed = CIF_FUNCTION_NOT_CONSIDERED; +} + /* See if statement might disappear after inlining. 0 - means not eliminated 1 - half of statements goes away @@ -317,24 +348,27 @@ compute_inline_parameters (struct cgraph_node *node) { HOST_WIDE_INT self_stack_size; struct cgraph_edge *e; + struct inline_summary *info; gcc_assert (!node->global.inlined_to); inline_summary_alloc (); + info = inline_summary (node); + /* Estimate the stack size for the function if we're optimizing. */ self_stack_size = optimize ? estimated_stack_frame_size (node) : 0; - inline_summary (node)->estimated_self_stack_size = self_stack_size; - node->global.estimated_stack_size = self_stack_size; - node->global.stack_frame_offset = 0; + info->estimated_self_stack_size = self_stack_size; + info->estimated_stack_size = self_stack_size; + info->stack_frame_offset = 0; /* Can this function be inlined at all? */ - node->local.inlinable = tree_inlinable_function_p (node->decl); - if (!node->local.inlinable) - node->local.disregard_inline_limits = 0; + info->inlinable = tree_inlinable_function_p (node->decl); + if (!info->inlinable) + info->disregard_inline_limits = 0; /* Inlinable functions always can change signature. */ - if (node->local.inlinable) + if (info->inlinable) node->local.can_change_signature = true; else { @@ -349,8 +383,13 @@ compute_inline_parameters (struct cgraph_node *node) estimate_function_body_sizes (node); /* Inlining characteristics are maintained by the cgraph_mark_inline. */ - node->global.time = inline_summary (node)->self_time; - node->global.size = inline_summary (node)->self_size; + info->time = info->self_time; + info->size = info->self_size; + info->estimated_growth = INT_MIN; + info->stack_frame_offset = 0; + info->estimated_stack_size = info->estimated_self_stack_size; + info->disregard_inline_limits + = DECL_DISREGARD_INLINE_LIMITS (node->decl); } @@ -390,10 +429,12 @@ static inline int estimate_edge_time (struct cgraph_edge *edge) { int call_stmt_time; + struct inline_summary *info = inline_summary (edge->callee); + call_stmt_time = edge->call_stmt_time; gcc_checking_assert (call_stmt_time); - return (((gcov_type)edge->callee->global.time - - inline_summary (edge->callee)->time_inlining_benefit + return (((gcov_type)info->time + - info->time_inlining_benefit - call_stmt_time) * edge->frequency + CGRAPH_FREQ_BASE / 2) / CGRAPH_FREQ_BASE; } @@ -405,7 +446,7 @@ int estimate_time_after_inlining (struct cgraph_node *node, struct cgraph_edge *edge) { - gcov_type time = node->global.time + estimate_edge_time (edge); + gcov_type time = inline_summary (node)->time + estimate_edge_time (edge); if (time < 0) time = 0; if (time > MAX_TIME) @@ -421,7 +462,7 @@ int estimate_size_after_inlining (struct cgraph_node *node, struct cgraph_edge *edge) { - int size = node->global.size + estimate_edge_growth (edge); + int size = inline_summary (node)->size + estimate_edge_growth (edge); gcc_assert (size >= 0); return size; } @@ -435,9 +476,10 @@ estimate_growth (struct cgraph_node *node) int growth = 0; struct cgraph_edge *e; bool self_recursive = false; + struct inline_summary *info = inline_summary (node); - if (node->global.estimated_growth != INT_MIN) - return node->global.estimated_growth; + if (info->estimated_growth != INT_MIN) + return info->estimated_growth; for (e = node->callers; e; e = e->next_caller) { @@ -453,15 +495,15 @@ estimate_growth (struct cgraph_node *node) some inlining. */ if (cgraph_will_be_removed_from_program_if_no_direct_calls (node) && !DECL_EXTERNAL (node->decl) && !self_recursive) - growth -= node->global.size; + growth -= info->size; /* COMDAT functions are very often not shared across multiple units since they come from various template instantiations. Take this into account. */ else if (DECL_COMDAT (node->decl) && !self_recursive && cgraph_can_remove_if_no_direct_calls_p (node)) - growth -= (node->global.size + growth -= (info->size * (100 - PARAM_VALUE (PARAM_COMDAT_SHARING_PROBABILITY)) + 50) / 100; - node->global.estimated_growth = growth; + info->estimated_growth = growth; return growth; } @@ -561,19 +603,25 @@ inline_read_summary (void) struct cgraph_node *node; struct inline_summary *info; lto_cgraph_encoder_t encoder; + struct bitpack_d bp; index = lto_input_uleb128 (ib); encoder = file_data->cgraph_node_encoder; node = lto_cgraph_encoder_deref (encoder, index); info = inline_summary (node); - node->global.estimated_stack_size + info->estimated_stack_size = info->estimated_self_stack_size = lto_input_uleb128 (ib); - node->global.time = info->self_time = lto_input_uleb128 (ib); + info->time = info->self_time = lto_input_uleb128 (ib); info->time_inlining_benefit = lto_input_uleb128 (ib); - node->global.size = info->self_size = lto_input_uleb128 (ib); + info->size = info->self_size = lto_input_uleb128 (ib); info->size_inlining_benefit = lto_input_uleb128 (ib); - node->global.estimated_growth = INT_MIN; + info->estimated_growth = INT_MIN; + + bp = lto_input_bitpack (ib); + info->inlinable = bp_unpack_value (&bp, 1); + info->versionable = bp_unpack_value (&bp, 1); + info->disregard_inline_limits = bp_unpack_value (&bp, 1); } lto_destroy_simple_input_block (file_data, @@ -623,6 +671,8 @@ inline_write_summary (cgraph_node_set set, if (node->analyzed) { struct inline_summary *info = inline_summary (node); + struct bitpack_d bp; + lto_output_uleb128_stream (ob->main_stream, lto_cgraph_encoder_encode (encoder, node)); lto_output_sleb128_stream (ob->main_stream, @@ -635,6 +685,11 @@ inline_write_summary (cgraph_node_set set, info->self_time); lto_output_sleb128_stream (ob->main_stream, info->time_inlining_benefit); + bp = bitpack_create (ob->main_stream); + bp_pack_value (&bp, info->inlinable, 1); + bp_pack_value (&bp, info->versionable, 1); + bp_pack_value (&bp, info->disregard_inline_limits, 1); + lto_output_bitpack (&bp); } } lto_destroy_simple_output_block (ob); diff --git a/gcc/ipa-inline.c b/gcc/ipa-inline.c index 1dbb324..c605eae 100644 --- a/gcc/ipa-inline.c +++ b/gcc/ipa-inline.c @@ -156,6 +156,7 @@ cgraph_clone_inlined_nodes (struct cgraph_edge *e, bool duplicate, bool update_original) { HOST_WIDE_INT peak; + struct inline_summary *caller_info, *callee_info; if (duplicate) { @@ -184,7 +185,7 @@ cgraph_clone_inlined_nodes (struct cgraph_edge *e, bool duplicate, gcc_assert (!e->callee->global.inlined_to); if (e->callee->analyzed && !DECL_EXTERNAL (e->callee->decl)) { - overall_size -= e->callee->global.size; + overall_size -= inline_summary (e->callee)->size; nfunctions_inlined++; } duplicate = false; @@ -201,17 +202,20 @@ cgraph_clone_inlined_nodes (struct cgraph_edge *e, bool duplicate, } } + callee_info = inline_summary (e->callee); + caller_info = inline_summary (e->caller); + if (e->caller->global.inlined_to) e->callee->global.inlined_to = e->caller->global.inlined_to; else e->callee->global.inlined_to = e->caller; - e->callee->global.stack_frame_offset - = e->caller->global.stack_frame_offset - + inline_summary (e->caller)->estimated_self_stack_size; - peak = e->callee->global.stack_frame_offset - + inline_summary (e->callee)->estimated_self_stack_size; - if (e->callee->global.inlined_to->global.estimated_stack_size < peak) - e->callee->global.inlined_to->global.estimated_stack_size = peak; + callee_info->stack_frame_offset + = caller_info->stack_frame_offset + + caller_info->estimated_self_stack_size; + peak = callee_info->stack_frame_offset + + callee_info->estimated_self_stack_size; + if (inline_summary (e->callee->global.inlined_to)->estimated_stack_size < peak) + inline_summary (e->callee->global.inlined_to)->estimated_stack_size = peak; cgraph_propagate_frequency (e->callee); /* Recursively clone all bodies. */ @@ -233,6 +237,7 @@ cgraph_mark_inline_edge (struct cgraph_edge *e, bool update_original, int old_size = 0, new_size = 0; struct cgraph_node *to = NULL; struct cgraph_edge *curr = e; + struct inline_summary *info; /* Don't inline inlined edges. */ gcc_assert (e->inline_failed); @@ -248,10 +253,11 @@ cgraph_mark_inline_edge (struct cgraph_edge *e, bool update_original, for (;e && !e->inline_failed; e = e->caller->callers) { to = e->caller; - old_size = e->caller->global.size; + info = inline_summary (to); + old_size = info->size; new_size = estimate_size_after_inlining (to, curr); - to->global.size = new_size; - to->global.time = estimate_time_after_inlining (to, curr); + info->size = new_size; + info->time = estimate_time_after_inlining (to, curr); } gcc_assert (curr->callee->global.inlined_to == to); if (new_size > old_size) @@ -280,23 +286,27 @@ cgraph_check_inline_limits (struct cgraph_edge *e, int newsize; int limit; HOST_WIDE_INT stack_size_limit, inlined_stack; + struct inline_summary *info, *what_info; if (to->global.inlined_to) to = to->global.inlined_to; + info = inline_summary (to); + what_info = inline_summary (what); + /* When inlining large function body called once into small function, take the inlined function as base for limiting the growth. */ - if (inline_summary (to)->self_size > inline_summary(what)->self_size) - limit = inline_summary (to)->self_size; + if (info->self_size > what_info->self_size) + limit = info->self_size; else - limit = inline_summary (what)->self_size; + limit = what_info->self_size; limit += limit * PARAM_VALUE (PARAM_LARGE_FUNCTION_GROWTH) / 100; /* Check the size after inlining against the function limits. But allow the function to shrink if it went over the limits by forced inlining. */ newsize = estimate_size_after_inlining (to, e); - if (newsize >= to->global.size + if (newsize >= info->size && newsize > PARAM_VALUE (PARAM_LARGE_FUNCTION_INSNS) && newsize > limit) { @@ -305,13 +315,13 @@ cgraph_check_inline_limits (struct cgraph_edge *e, return false; } - stack_size_limit = inline_summary (to)->estimated_self_stack_size; + stack_size_limit = info->estimated_self_stack_size; stack_size_limit += stack_size_limit * PARAM_VALUE (PARAM_STACK_FRAME_GROWTH) / 100; - inlined_stack = (to->global.stack_frame_offset - + inline_summary (to)->estimated_self_stack_size - + what->global.estimated_stack_size); + inlined_stack = (info->stack_frame_offset + + info->estimated_self_stack_size + + what_info->estimated_stack_size); if (inlined_stack > stack_size_limit && inlined_stack > PARAM_VALUE (PARAM_LARGE_STACK_FRAME)) { @@ -328,8 +338,9 @@ static bool cgraph_default_inline_p (struct cgraph_node *n, cgraph_inline_failed_t *reason) { tree decl = n->decl; + struct inline_summary *info = inline_summary (n); - if (n->local.disregard_inline_limits) + if (info->disregard_inline_limits) return true; if (!flag_inline_small_functions && !DECL_DECLARED_INLINE_P (decl)) @@ -354,7 +365,7 @@ cgraph_default_inline_p (struct cgraph_node *n, cgraph_inline_failed_t *reason) if (DECL_DECLARED_INLINE_P (decl)) { - if (n->global.size >= MAX_INLINE_INSNS_SINGLE) + if (info->size >= MAX_INLINE_INSNS_SINGLE) { if (reason) *reason = CIF_MAX_INLINE_INSNS_SINGLE_LIMIT; @@ -363,7 +374,7 @@ cgraph_default_inline_p (struct cgraph_node *n, cgraph_inline_failed_t *reason) } else { - if (n->global.size >= MAX_INLINE_INSNS_AUTO) + if (info->size >= MAX_INLINE_INSNS_AUTO) { if (reason) *reason = CIF_MAX_INLINE_INSNS_AUTO_LIMIT; @@ -385,8 +396,9 @@ cgraph_edge_badness (struct cgraph_edge *edge, bool dump) { gcov_type badness; int growth; + struct inline_summary *callee_info = inline_summary (edge->callee); - if (edge->callee->local.disregard_inline_limits) + if (callee_info->disregard_inline_limits) return INT_MIN; growth = estimate_edge_growth (edge); @@ -398,11 +410,11 @@ cgraph_edge_badness (struct cgraph_edge *edge, bool dump) cgraph_node_name (edge->callee)); fprintf (dump_file, " growth %i, time %i-%i, size %i-%i\n", growth, - edge->callee->global.time, - inline_summary (edge->callee)->time_inlining_benefit + callee_info->time, + callee_info->time_inlining_benefit + edge->call_stmt_time, - edge->callee->global.size, - inline_summary (edge->callee)->size_inlining_benefit + callee_info->size, + callee_info->size_inlining_benefit + edge->call_stmt_size); } @@ -422,7 +434,7 @@ cgraph_edge_badness (struct cgraph_edge *edge, bool dump) badness = ((int) ((double) edge->count * INT_MIN / max_count / (max_benefit + 1)) * - (inline_summary (edge->callee)->time_inlining_benefit + (callee_info->time_inlining_benefit + edge->call_stmt_time + 1)) / growth; if (dump) { @@ -453,9 +465,9 @@ cgraph_edge_badness (struct cgraph_edge *edge, bool dump) int growth_for_all; badness = growth * 10000; benefitperc = - 100 * (inline_summary (edge->callee)->time_inlining_benefit + 100 * (callee_info->time_inlining_benefit + edge->call_stmt_time) - / (edge->callee->global.time + 1) + 1; + / (callee_info->time + 1) + 1; benefitperc = MIN (benefitperc, 100); div *= benefitperc; @@ -543,13 +555,13 @@ update_caller_keys (fibheap_t heap, struct cgraph_node *node, struct cgraph_edge *edge; cgraph_inline_failed_t failed_reason; - if (!node->local.inlinable + if (!inline_summary (node)->inlinable || cgraph_function_body_availability (node) <= AVAIL_OVERWRITABLE || node->global.inlined_to) return; if (!bitmap_set_bit (updated_nodes, node->uid)) return; - node->global.estimated_growth = INT_MIN; + inline_summary (node)->estimated_growth = INT_MIN; /* See if there is something to do. */ for (edge = node->callers; edge; edge = edge->next_caller) @@ -586,7 +598,7 @@ update_callee_keys (fibheap_t heap, struct cgraph_node *node, bitmap updated_nodes) { struct cgraph_edge *e = node->callees; - node->global.estimated_growth = INT_MIN; + inline_summary (node)->estimated_growth = INT_MIN; if (!e) return; @@ -596,11 +608,11 @@ update_callee_keys (fibheap_t heap, struct cgraph_node *node, else { if (e->inline_failed - && e->callee->local.inlinable + && inline_summary (e->callee)->inlinable && cgraph_function_body_availability (e->callee) >= AVAIL_AVAILABLE && !bitmap_bit_p (updated_nodes, e->callee->uid)) { - node->global.estimated_growth = INT_MIN; + inline_summary (node)->estimated_growth = INT_MIN; /* If function becomes uninlinable, we need to remove it from the heap. */ if (!cgraph_default_inline_p (e->callee, &e->inline_failed)) update_caller_keys (heap, e->callee, updated_nodes); @@ -632,7 +644,7 @@ update_all_callee_keys (fibheap_t heap, struct cgraph_node *node, bitmap updated_nodes) { struct cgraph_edge *e = node->callees; - node->global.estimated_growth = INT_MIN; + inline_summary (node)->estimated_growth = INT_MIN; if (!e) return; @@ -709,7 +721,7 @@ cgraph_decide_recursive_inlining (struct cgraph_edge *edge, /* It does not make sense to recursively inline always-inline functions as we are going to sorry() on the remaining calls anyway. */ - if (node->local.disregard_inline_limits + if (inline_summary (node)->disregard_inline_limits && lookup_attribute ("always_inline", DECL_ATTRIBUTES (node->decl))) return false; @@ -811,8 +823,8 @@ cgraph_decide_recursive_inlining (struct cgraph_edge *edge, if (dump_file) fprintf (dump_file, "\n Inlined %i times, body grown from size %i to %i, time %i to %i\n", n, - master_clone->global.size, node->global.size, - master_clone->global.time, node->global.time); + inline_summary (master_clone)->size, inline_summary (node)->size, + inline_summary (master_clone)->time, inline_summary (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 @@ -870,7 +882,7 @@ add_new_edges_to_heap (fibheap_t heap, VEC (cgraph_edge_p, heap) *new_edges) struct cgraph_edge *edge = VEC_pop (cgraph_edge_p, new_edges); gcc_assert (!edge->aux); - if (edge->callee->local.inlinable + if (inline_summary (edge->callee)->inlinable && edge->inline_failed && cgraph_default_inline_p (edge->callee, &edge->inline_failed)) edge->aux = fibheap_insert (heap, cgraph_edge_badness (edge, false), edge); @@ -905,26 +917,37 @@ cgraph_decide_inlining_of_small_functions (void) /* Put all inline candidates into the heap. */ for (node = cgraph_nodes; node; node = node->next) - { - if (!node->local.inlinable || !node->callers) - continue; - if (dump_file) - fprintf (dump_file, "Considering inline candidate %s.\n", cgraph_node_name (node)); + if (node->analyzed) + { + struct inline_summary *info = inline_summary (node); - node->global.estimated_growth = INT_MIN; - if (!cgraph_default_inline_p (node, &failed_reason)) - { - cgraph_set_inline_failed (node, failed_reason); - continue; - } + if (!info->inlinable || !node->callers) + { + struct cgraph_edge *e; + for (e = node->callers; e; e = e->next_caller) + { + gcc_assert (e->inline_failed); + e->inline_failed = CIF_FUNCTION_NOT_INLINABLE; + } + continue; + } + if (dump_file) + fprintf (dump_file, "Considering inline candidate %s.\n", cgraph_node_name (node)); - for (edge = node->callers; edge; edge = edge->next_caller) - if (edge->inline_failed) + info->estimated_growth = INT_MIN; + if (!cgraph_default_inline_p (node, &failed_reason)) { - gcc_assert (!edge->aux); - edge->aux = fibheap_insert (heap, cgraph_edge_badness (edge, false), edge); + cgraph_set_inline_failed (node, failed_reason); + continue; } - } + + for (edge = node->callers; edge; edge = edge->next_caller) + if (edge->inline_failed) + { + gcc_assert (!edge->aux); + edge->aux = fibheap_insert (heap, cgraph_edge_badness (edge, false), edge); + } + } max_size = compute_max_insns (overall_size); min_size = overall_size; @@ -963,7 +986,7 @@ cgraph_decide_inlining_of_small_functions (void) fprintf (dump_file, "\nConsidering %s with %i size\n", cgraph_node_name (edge->callee), - edge->callee->global.size); + inline_summary (edge->callee)->size); fprintf (dump_file, " to be inlined into %s in %s:%i\n" " Estimated growth after inlined into all callees is %+i insns.\n" @@ -1007,7 +1030,7 @@ cgraph_decide_inlining_of_small_functions (void) if (where->global.inlined_to) { edge->inline_failed - = (edge->callee->local.disregard_inline_limits + = (inline_summary (edge->callee)->disregard_inline_limits ? CIF_RECURSIVE_INLINING : CIF_UNSPECIFIED); if (dump_file) fprintf (dump_file, " inline_failed:Recursive inlining performed only for function itself.\n"); @@ -1015,7 +1038,7 @@ cgraph_decide_inlining_of_small_functions (void) } } - if (edge->callee->local.disregard_inline_limits) + if (inline_summary (edge->callee)->disregard_inline_limits) ; else if (!cgraph_maybe_hot_edge_p (edge)) not_good = CIF_UNLIKELY_CALL; @@ -1112,8 +1135,8 @@ cgraph_decide_inlining_of_small_functions (void) " Inlined into %s which now has time %i and size %i," "net change of %+i.\n", cgraph_node_name (edge->caller), - edge->caller->global.time, - edge->caller->global.size, + inline_summary (edge->caller)->time, + inline_summary (edge->caller)->size, overall_size - old_size); } if (min_size > overall_size) @@ -1142,7 +1165,7 @@ cgraph_decide_inlining_of_small_functions (void) fprintf (dump_file, "\nSkipping %s with %i size\n", cgraph_node_name (edge->callee), - edge->callee->global.size); + inline_summary (edge->callee)->size); fprintf (dump_file, " called by %s in %s:%i\n" " Estimated growth after inlined into all callees is %+i insns.\n" @@ -1159,7 +1182,7 @@ cgraph_decide_inlining_of_small_functions (void) if (dump_flags & TDF_DETAILS) cgraph_edge_badness (edge, true); } - if (!edge->callee->local.disregard_inline_limits && edge->inline_failed) + if (!inline_summary (edge->callee)->disregard_inline_limits && edge->inline_failed) edge->inline_failed = CIF_INLINE_UNIT_GROWTH_LIMIT; } @@ -1287,13 +1310,14 @@ cgraph_decide_inlining (void) if (node->analyzed) { struct cgraph_edge *e; + struct inline_summary *info = inline_summary (node); - gcc_assert (inline_summary (node)->self_size == node->global.size); + gcc_assert (info->self_size == info->size); if (!DECL_EXTERNAL (node->decl)) - initial_size += node->global.size; + initial_size += info->size; for (e = node->callees; e; e = e->next_callee) { - int benefit = (inline_summary (node)->time_inlining_benefit + int benefit = (info->time_inlining_benefit + e->call_stmt_time); if (max_count < e->count) max_count = e->count; @@ -1362,7 +1386,7 @@ cgraph_decide_inlining (void) && !node->callers->next_caller && !node->global.inlined_to && cgraph_will_be_removed_from_program_if_no_direct_calls (node) - && node->local.inlinable + && inline_summary (node)->inlinable && cgraph_function_body_availability (node) >= AVAIL_AVAILABLE && node->callers->inline_failed && node->callers->caller != node @@ -1377,11 +1401,11 @@ cgraph_decide_inlining (void) { fprintf (dump_file, "\nConsidering %s size %i.\n", - cgraph_node_name (node), node->global.size); + cgraph_node_name (node), inline_summary (node)->size); fprintf (dump_file, " Called once from %s %i insns.\n", cgraph_node_name (node->callers->caller), - node->callers->caller->global.size); + inline_summary (node->callers->caller)->size); } if (cgraph_check_inline_limits (node->callers, &reason)) @@ -1393,7 +1417,7 @@ cgraph_decide_inlining (void) " Inlined into %s which now has %i size" " for a net change of %+i size.\n", cgraph_node_name (caller), - caller->global.size, + inline_summary (caller)->size, overall_size - old_size); } else @@ -1442,7 +1466,7 @@ leaf_node_p (struct cgraph_node *n) static bool cgraph_edge_early_inlinable_p (struct cgraph_edge *e, FILE *file) { - if (!e->callee->local.inlinable) + if (!inline_summary (e->callee)->inlinable) { if (file) fprintf (file, "Not inlining: Function not inlinable.\n"); @@ -1482,7 +1506,7 @@ cgraph_perform_always_inlining (struct cgraph_node *node) for (e = node->callees; e; e = e->next_callee) { - if (!e->callee->local.disregard_inline_limits) + if (!inline_summary (e->callee)->disregard_inline_limits) continue; if (dump_file) @@ -1524,16 +1548,16 @@ cgraph_decide_inlining_incrementally (struct cgraph_node *node) /* Never inline regular functions into always-inline functions during incremental inlining. */ - if (node->local.disregard_inline_limits) + if (inline_summary (node)->disregard_inline_limits) return false; for (e = node->callees; e; e = e->next_callee) { int allowed_growth = 0; - if (!e->callee->local.inlinable + if (!inline_summary (e->callee)->inlinable || !e->inline_failed - || e->callee->local.disregard_inline_limits) + || inline_summary (e->callee)->disregard_inline_limits) continue; /* Do not consider functions not declared inline. */ diff --git a/gcc/ipa-inline.h b/gcc/ipa-inline.h index e9a7db2..58bcdd9 100644 --- a/gcc/ipa-inline.h +++ b/gcc/ipa-inline.h @@ -23,9 +23,10 @@ along with GCC; see the file COPYING3. If not see struct inline_summary { + /* Information about the function body itself. */ + /* Estimated stack frame consumption by the function. */ HOST_WIDE_INT estimated_self_stack_size; - /* Size of the function body. */ int self_size; /* How many instructions are likely going to disappear after inlining. */ @@ -34,6 +35,29 @@ struct inline_summary int self_time; /* How much time is going to be saved by inlining. */ int time_inlining_benefit; + + /* False when there something makes inlining impossible (such as va_arg). */ + unsigned inlinable : 1; + /* False when there something makes versioning impossible. + Currently computed and used only by ipa-cp. */ + unsigned versionable : 1; + /* True when function should be inlined independently on its size. */ + unsigned disregard_inline_limits : 1; + + /* Information about function that will result after applying all the + inline decisions present in the callgraph. Generally kept up to + date only for functions that are not inline clones. */ + + /* Estimated stack frame consumption by the function. */ + HOST_WIDE_INT estimated_stack_size; + /* Expected offset of the stack frame of inlined function. */ + HOST_WIDE_INT stack_frame_offset; + /* Estimated size of the function after inlining. */ + int time; + int size; + /* Cached estimated growth after inlining. + INT_MIN if not computed. */ + int estimated_growth; }; typedef struct inline_summary inline_summary_t; @@ -47,6 +71,7 @@ void inline_generate_summary (void); void inline_read_summary (void); void inline_write_summary (cgraph_node_set, varpool_node_set); void inline_free_summary (void); +void initialize_inline_failed (struct cgraph_edge *); int estimate_time_after_inlining (struct cgraph_node *, struct cgraph_edge *); int estimate_size_after_inlining (struct cgraph_node *, struct cgraph_edge *); int estimate_growth (struct cgraph_node *); @@ -63,10 +88,10 @@ static inline int estimate_edge_growth (struct cgraph_edge *edge) { int call_stmt_size; + struct inline_summary *info = inline_summary (edge->callee); call_stmt_size = edge->call_stmt_size; gcc_checking_assert (call_stmt_size); - return (edge->callee->global.size - - inline_summary (edge->callee)->size_inlining_benefit + return (info->size + - info->size_inlining_benefit - call_stmt_size); } - diff --git a/gcc/ipa-split.c b/gcc/ipa-split.c index 60102db..47109ab 100644 --- a/gcc/ipa-split.c +++ b/gcc/ipa-split.c @@ -92,6 +92,7 @@ along with GCC; see the file COPYING3. If not see #include "fibheap.h" #include "params.h" #include "gimple-pretty-print.h" +#include "ipa-inline.h" /* Per basic block info. */ @@ -1281,13 +1282,13 @@ execute_split_functions (void) } /* This can be relaxed; function might become inlinable after splitting away the uninlinable part. */ - if (!node->local.inlinable) + if (!inline_summary (node)->inlinable) { if (dump_file) fprintf (dump_file, "Not splitting: not inlinable.\n"); return 0; } - if (node->local.disregard_inline_limits) + if (DECL_DISREGARD_INLINE_LIMITS (node->decl)) { if (dump_file) fprintf (dump_file, "Not splitting: disregarding inline limits.\n"); @@ -78,8 +78,8 @@ cgraph_postorder (struct cgraph_node **order) /* Break possible cycles involving always-inline functions by ignoring edges from always-inline functions to non-always-inline functions. */ - if (edge->caller->local.disregard_inline_limits - && !edge->callee->local.disregard_inline_limits) + if (DECL_DISREGARD_INLINE_LIMITS (edge->caller->decl) + && !DECL_DISREGARD_INLINE_LIMITS (edge->callee->decl)) continue; if (!edge->caller->aux) { @@ -380,7 +380,6 @@ cgraph_remove_unreachable_nodes (bool before_inlining_p, FILE *file) cgraph_node_remove_callees (node); ipa_remove_all_references (&node->ref_list); node->analyzed = false; - node->local.inlinable = false; } if (!node->aux) { @@ -421,7 +420,6 @@ cgraph_remove_unreachable_nodes (bool before_inlining_p, FILE *file) if (!clone) { cgraph_release_function_body (node); - node->local.inlinable = false; if (node->prev_sibling_clone) node->prev_sibling_clone->next_sibling_clone = node->next_sibling_clone; else if (node->clone_of) @@ -1629,7 +1627,7 @@ record_cdtor_fn (struct cgraph_node *node) if (DECL_STATIC_DESTRUCTOR (node->decl)) VEC_safe_push (tree, heap, static_dtors, node->decl); node = cgraph_get_node (node->decl); - node->local.disregard_inline_limits = 1; + DECL_DISREGARD_INLINE_LIMITS (node->decl) = 1; } /* Define global constructors/destructor functions for the CDTORS, of diff --git a/gcc/lto-cgraph.c b/gcc/lto-cgraph.c index c154457..861a37b 100644 --- a/gcc/lto-cgraph.c +++ b/gcc/lto-cgraph.c @@ -489,10 +489,7 @@ lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node, bp_pack_value (&bp, node->local.local, 1); bp_pack_value (&bp, node->local.externally_visible, 1); bp_pack_value (&bp, node->local.finalized, 1); - bp_pack_value (&bp, node->local.inlinable, 1); - bp_pack_value (&bp, node->local.versionable, 1); bp_pack_value (&bp, node->local.can_change_signature, 1); - bp_pack_value (&bp, node->local.disregard_inline_limits, 1); bp_pack_value (&bp, node->local.redefined_extern_inline, 1); bp_pack_value (&bp, node->local.vtable_method, 1); bp_pack_value (&bp, node->needed, 1); @@ -928,10 +925,7 @@ input_overwrite_node (struct lto_file_decl_data *file_data, node->local.local = bp_unpack_value (bp, 1); node->local.externally_visible = bp_unpack_value (bp, 1); node->local.finalized = bp_unpack_value (bp, 1); - node->local.inlinable = bp_unpack_value (bp, 1); - node->local.versionable = bp_unpack_value (bp, 1); node->local.can_change_signature = bp_unpack_value (bp, 1); - node->local.disregard_inline_limits = bp_unpack_value (bp, 1); node->local.redefined_extern_inline = bp_unpack_value (bp, 1); node->local.vtable_method = bp_unpack_value (bp, 1); node->needed = bp_unpack_value (bp, 1); diff --git a/gcc/lto/ChangeLog b/gcc/lto/ChangeLog index 45dd300..6c87a38 100644 --- a/gcc/lto/ChangeLog +++ b/gcc/lto/ChangeLog @@ -1,3 +1,7 @@ +2011-04-16 Jan Hubicka <jh@suse.cz> + + * lto.c (lto_balanced_map): Update. + 2011-04-14 Jan Hubicka <jh@suse.cz> * lto.c: Include ipa-inline.h diff --git a/gcc/lto/lto.c b/gcc/lto/lto.c index 9103af4..f515aaa 100644 --- a/gcc/lto/lto.c +++ b/gcc/lto/lto.c @@ -1030,7 +1030,7 @@ lto_balanced_map (void) if (partition_cgraph_node_p (node)) { order[n_nodes++] = node; - total_size += node->global.size; + total_size += inline_summary (node)->size; } } free (postorder); @@ -1049,7 +1049,7 @@ lto_balanced_map (void) { if (!order[i]->aux) add_cgraph_node_to_partition (partition, order[i]); - total_size -= order[i]->global.size; + total_size -= inline_summary (order[i])->size; /* Once we added a new node to the partition, we also want to add all referenced variables unless they was already added into some diff --git a/gcc/tree-sra.c b/gcc/tree-sra.c index 95a9f1b..56a9346 100644 --- a/gcc/tree-sra.c +++ b/gcc/tree-sra.c @@ -91,6 +91,7 @@ along with GCC; see the file COPYING3. If not see #include "dbgcnt.h" #include "tree-inline.h" #include "gimple-pretty-print.h" +#include "ipa-inline.h" /* Enumeration of all aggregate reductions we can do. */ enum sra_mode { SRA_MODE_EARLY_IPA, /* early call regularization */ @@ -4469,7 +4470,7 @@ ipa_sra_preliminary_function_checks (struct cgraph_node *node) } if ((DECL_COMDAT (node->decl) || DECL_EXTERNAL (node->decl)) - && node->global.size >= MAX_INLINE_INSNS_AUTO) + && inline_summary(node)->size >= MAX_INLINE_INSNS_AUTO) { if (dump_file) fprintf (dump_file, "Function too big to be made truly local.\n"); |