From: hubicka Date: Tue, 3 May 2016 19:05:31 +0000 (+0000) Subject: * cgraph.c (symbol_table::create_edge): Set inline_failed. X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=0754a74753693f16cd043d3b57562a4735dcaaba;p=thirdparty%2Fgcc.git * cgraph.c (symbol_table::create_edge): Set inline_failed. (cgraph_edge::make_direct): Likewise. (cgraph_edge::dump_edge_flags): Dump call_stmt_cannot_inline_p. * cgraphclones.c (duplicate_thunk_for_node): Set inline_failed. * cif-code.def (CIF_LTO_MISMATCHED_DECLARATIONS): New code (CIF_THUNK): New code. * ipa-inline-analysis.c (initialize_inline_failed): Preserve CIF_FINAL_ERROR codes; do not deal with call_stmt_cannot_inline_p. (compute_inline_parameters): Set inline_failed for thunks. (inline_analyze_function): Cleanup. * ipa-inline.c (can_inline_edge_p): Do not deal with call_stmt_cannot_inline_p. (can_early_inline_edge_p): Likewise. (early_inliner): Initialize inline_failed. * lto-cgraph.c (lto_output_edge): Sanity check inline_failed. * lto-symtab.c (lto_cgraph_replace_node): Initialize inline_failed. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@235839 138bc75d-0d04-0410-961f-82ee72b054a4 --- diff --git a/gcc/ChangeLog b/gcc/ChangeLog index b73543cd35db..12a292c17deb 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,21 @@ +2016-05-03 Jan Hubicka + + * cgraph.c (symbol_table::create_edge): Set inline_failed. + (cgraph_edge::make_direct): Likewise. + (cgraph_edge::dump_edge_flags): Dump call_stmt_cannot_inline_p. + * cgraphclones.c (duplicate_thunk_for_node): Set inline_failed. + * cif-code.def (CIF_LTO_MISMATCHED_DECLARATIONS): New code + (CIF_THUNK): New code. + * ipa-inline-analysis.c (initialize_inline_failed): Preserve + CIF_FINAL_ERROR codes; do not deal with call_stmt_cannot_inline_p. + (compute_inline_parameters): Set inline_failed for thunks. + (inline_analyze_function): Cleanup. + * ipa-inline.c (can_inline_edge_p): Do not deal with + call_stmt_cannot_inline_p. + (can_early_inline_edge_p): Likewise. + (early_inliner): Initialize inline_failed. + * lto-cgraph.c (lto_output_edge): Sanity check inline_failed. + 2016-05-03 Uros Bizjak * config/i386/predicates.md (x87nonimm_ssenomem_operand): Rename diff --git a/gcc/cgraph.c b/gcc/cgraph.c index 3105aec82556..782cb520eacf 100644 --- a/gcc/cgraph.c +++ b/gcc/cgraph.c @@ -859,9 +859,15 @@ symbol_table::create_edge (cgraph_node *caller, cgraph_node *callee, && callee && callee->decl && !gimple_check_call_matching_types (call_stmt, callee->decl, false)) - edge->call_stmt_cannot_inline_p = true; + { + edge->inline_failed = CIF_MISMATCHED_ARGUMENTS; + edge->call_stmt_cannot_inline_p = true; + } else - edge->call_stmt_cannot_inline_p = false; + { + edge->inline_failed = CIF_FUNCTION_NOT_CONSIDERED; + edge->call_stmt_cannot_inline_p = false; + } edge->indirect_info = NULL; edge->indirect_inlining_edge = 0; @@ -1240,10 +1246,12 @@ cgraph_edge::make_direct (cgraph_node *callee) /* Insert to callers list of the new callee. */ edge->set_callee (callee); - if (call_stmt) - call_stmt_cannot_inline_p - = !gimple_check_call_matching_types (call_stmt, callee->decl, - false); + if (call_stmt + && !gimple_check_call_matching_types (call_stmt, callee->decl, false)) + { + call_stmt_cannot_inline_p = true; + inline_failed = CIF_MISMATCHED_ARGUMENTS; + } /* We need to re-determine the inlining status of the edge. */ initialize_inline_failed (edge); @@ -1996,6 +2004,8 @@ cgraph_edge::dump_edge_flags (FILE *f) fprintf (f, "(speculative) "); if (!inline_failed) fprintf (f, "(inlined) "); + if (call_stmt_cannot_inline_p) + fprintf (f, "(call_stmt_cannot_inline_p) "); if (indirect_inlining_edge) fprintf (f, "(indirect_inlining) "); if (count) diff --git a/gcc/cgraphclones.c b/gcc/cgraphclones.c index 07ceb1a80d49..10f2d3417f47 100644 --- a/gcc/cgraphclones.c +++ b/gcc/cgraphclones.c @@ -338,6 +338,7 @@ duplicate_thunk_for_node (cgraph_node *thunk, cgraph_node *node) cgraph_edge *e = new_thunk->create_edge (node, NULL, 0, CGRAPH_FREQ_BASE); e->call_stmt_cannot_inline_p = true; + e->inline_failed = CIF_THUNK; symtab->call_edge_duplication_hooks (thunk->callees, e); symtab->call_cgraph_duplication_hooks (thunk, new_thunk); return new_thunk; diff --git a/gcc/cif-code.def b/gcc/cif-code.def index 97a285857f4f..f112e962aadf 100644 --- a/gcc/cif-code.def +++ b/gcc/cif-code.def @@ -92,8 +92,12 @@ DEFCIFCODE(MISMATCHED_ARGUMENTS, CIF_FINAL_ERROR, N_("mismatched arguments")) /* Caller and callee disagree on the arguments. */ -DEFCIFCODE(THUNK, CIF_FINAL_ERROR, - N_("thunk call")) +DEFCIFCODE(LTO_MISMATCHED_DECLARATIONS, CIF_FINAL_ERROR, + N_("mismatched declarations during linktime optimization")) + +/* Caller is thunk. */ +DEFCIFCODE(THUNK, CIF_FINAL_ERROR, + N_("thunk call")) /* Call was originally indirect. */ DEFCIFCODE(ORIGINALLY_INDIRECT_CALL, CIF_FINAL_NORMAL, diff --git a/gcc/ipa-inline-analysis.c b/gcc/ipa-inline-analysis.c index 4fbc2eddaced..47b5b96ace4d 100644 --- a/gcc/ipa-inline-analysis.c +++ b/gcc/ipa-inline-analysis.c @@ -1490,19 +1490,23 @@ initialize_inline_failed (struct cgraph_edge *e) { struct cgraph_node *callee = e->callee; - if (e->indirect_unknown_callee) + if (e->inline_failed && e->inline_failed != CIF_BODY_NOT_AVAILABLE + && cgraph_inline_failed_type (e->inline_failed) == CIF_FINAL_ERROR) + ; + else if (e->indirect_unknown_callee) e->inline_failed = CIF_INDIRECT_UNKNOWN_CALL; else if (!callee->definition) 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_cannot_inline_p) - e->inline_failed = CIF_MISMATCHED_ARGUMENTS; else if (cfun && fn_contains_cilk_spawn_p (cfun)) /* We can't inline if the function is spawing a function. */ - e->inline_failed = CIF_FUNCTION_NOT_INLINABLE; + e->inline_failed = CIF_CILK_SPAWN; else e->inline_failed = CIF_FUNCTION_NOT_CONSIDERED; + gcc_checking_assert (!e->call_stmt_cannot_inline_p + || cgraph_inline_failed_type (e->inline_failed) + == CIF_FINAL_ERROR); } /* Callback of walk_aliased_vdefs. Flags that it has been invoked to the @@ -2925,7 +2929,7 @@ compute_inline_parameters (struct cgraph_node *node, bool early) struct predicate t = true_predicate (); info->inlinable = 0; - node->callees->call_stmt_cannot_inline_p = true; + node->callees->inline_failed = CIF_THUNK; node->local.can_change_signature = false; es->call_stmt_time = 1; es->call_stmt_size = 1; @@ -4107,17 +4111,9 @@ inline_analyze_function (struct cgraph_node *node) { struct cgraph_edge *e; for (e = node->callees; e; e = e->next_callee) - { - if (e->inline_failed == CIF_FUNCTION_NOT_CONSIDERED) - e->inline_failed = CIF_FUNCTION_NOT_OPTIMIZED; - e->call_stmt_cannot_inline_p = true; - } + e->inline_failed = CIF_FUNCTION_NOT_OPTIMIZED; for (e = node->indirect_calls; e; e = e->next_callee) - { - if (e->inline_failed == CIF_FUNCTION_NOT_CONSIDERED) - e->inline_failed = CIF_FUNCTION_NOT_OPTIMIZED; - e->call_stmt_cannot_inline_p = true; - } + e->inline_failed = CIF_FUNCTION_NOT_OPTIMIZED; } pop_cfun (); diff --git a/gcc/ipa-inline.c b/gcc/ipa-inline.c index d520c556d435..a5c5c9b382ba 100644 --- a/gcc/ipa-inline.c +++ b/gcc/ipa-inline.c @@ -335,12 +335,10 @@ can_inline_edge_p (struct cgraph_edge *e, bool report, e->inline_failed = CIF_OVERWRITABLE; inlinable = false; } + /* All edges with call_stmt_cannot_inline_p should have inline_failed + initialized to one of FINAL_ERROR reasons. */ else if (e->call_stmt_cannot_inline_p) - { - if (e->inline_failed != CIF_FUNCTION_NOT_OPTIMIZED) - e->inline_failed = e->caller->thunk.thunk_p ? CIF_THUNK : CIF_MISMATCHED_ARGUMENTS; - inlinable = false; - } + gcc_unreachable (); /* Don't inline if the functions have different EH personalities. */ else if (DECL_FUNCTION_PERSONALITY (caller->decl) && DECL_FUNCTION_PERSONALITY (callee->decl) @@ -529,6 +527,8 @@ can_early_inline_edge_p (struct cgraph_edge *e) /* Early inliner might get called at WPA stage when IPA pass adds new function. In this case we can not really do any of early inlining because function bodies are missing. */ + if (cgraph_inline_failed_type (e->inline_failed) == CIF_FINAL_ERROR) + return false; if (!gimple_has_body_p (callee->decl)) { e->inline_failed = CIF_BODY_NOT_AVAILABLE; @@ -2741,7 +2741,10 @@ early_inliner (function *fun) if (edge->callee->decl && !gimple_check_call_matching_types ( edge->call_stmt, edge->callee->decl, false)) - edge->call_stmt_cannot_inline_p = true; + { + edge->inline_failed = CIF_MISMATCHED_ARGUMENTS; + edge->call_stmt_cannot_inline_p = true; + } } if (iterations < PARAM_VALUE (PARAM_EARLY_INLINER_MAX_ITERATIONS) - 1) inline_update_overall_summary (node); diff --git a/gcc/lto-cgraph.c b/gcc/lto-cgraph.c index 95c446d0696e..14302138efa0 100644 --- a/gcc/lto-cgraph.c +++ b/gcc/lto-cgraph.c @@ -268,6 +268,8 @@ lto_output_edge (struct lto_simple_output_block *ob, struct cgraph_edge *edge, bp_pack_value (&bp, edge->indirect_inlining_edge, 1); bp_pack_value (&bp, edge->speculative, 1); bp_pack_value (&bp, edge->call_stmt_cannot_inline_p, 1); + gcc_assert (!edge->call_stmt_cannot_inline_p + || edge->inline_failed != CIF_BODY_NOT_AVAILABLE); bp_pack_value (&bp, edge->can_throw_external, 1); bp_pack_value (&bp, edge->in_polymorphic_cdtor, 1); if (edge->indirect_unknown_callee) diff --git a/gcc/lto/ChangeLog b/gcc/lto/ChangeLog index b1421cbe733b..80ffba329ad3 100644 --- a/gcc/lto/ChangeLog +++ b/gcc/lto/ChangeLog @@ -1,3 +1,7 @@ +2016-05-03 Jan Hubicka + + * lto-symtab.c (lto_cgraph_replace_node): Initialize inline_failed. + 2016-04-27 Prathamesh Kulkarni * lto-partition.h (lto_balanced_map): New parameter. diff --git a/gcc/lto/lto-symtab.c b/gcc/lto/lto-symtab.c index 94b919b53e6e..ce9e1465e3c1 100644 --- a/gcc/lto/lto-symtab.c +++ b/gcc/lto/lto-symtab.c @@ -81,7 +81,10 @@ lto_cgraph_replace_node (struct cgraph_node *node, ??? We really need a way to match function signatures for ABI compatibility and perform related promotions at inlining time. */ if (!compatible_p) - e->call_stmt_cannot_inline_p = 1; + { + e->inline_failed = CIF_LTO_MISMATCHED_DECLARATIONS; + e->call_stmt_cannot_inline_p = 1; + } } /* Redirect incomming references. */ prevailing_node->clone_referring (node);