From 0754a74753693f16cd043d3b57562a4735dcaaba Mon Sep 17 00:00:00 2001 From: hubicka Date: Tue, 3 May 2016 19:05:31 +0000 Subject: [PATCH] * 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 --- gcc/ChangeLog | 18 ++++++++++++++++++ gcc/cgraph.c | 22 ++++++++++++++++------ gcc/cgraphclones.c | 1 + gcc/cif-code.def | 8 ++++++-- gcc/ipa-inline-analysis.c | 26 +++++++++++--------------- gcc/ipa-inline.c | 15 +++++++++------ gcc/lto-cgraph.c | 2 ++ gcc/lto/ChangeLog | 4 ++++ gcc/lto/lto-symtab.c | 5 ++++- 9 files changed, 71 insertions(+), 30 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index b73543cd35d..12a292c17de 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 3105aec8255..782cb520eac 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 07ceb1a80d4..10f2d3417f4 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 97a285857f4..f112e962aad 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 4fbc2eddace..47b5b96ace4 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 d520c556d43..a5c5c9b382b 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 95c446d0696..14302138efa 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 b1421cbe733..80ffba329ad 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 94b919b53e6..ce9e1465e3c 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); -- 2.11.4.GIT