cgraph.c (symbol_table::create_edge): Set inline_failed.

	* 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.

From-SVN: r235839

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index b73543cd35db71500adce618442d5245fa5e900b..12a292c17deb91933491dde1efa18d3f637c7093 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,21 @@
+2016-05-03  Jan Hubicka  <hubicka@ucw.cz>
+
+       * 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  <ubizjak@gmail.com>
 
        * config/i386/predicates.md (x87nonimm_ssenomem_operand): Rename

diff --git a/gcc/cgraph.c b/gcc/cgraph.c
index 3105aec82556b94b372219c9dcbec952dfb31bff..782cb520eacf25ba547b06ece696d09e70c08f52 100644 (file)
--- 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 07ceb1a80d49dcf3c940f2b0f265996f7b072e00..10f2d3417f47e41528d50f8bc65bee5afc2d9c58 100644 (file)
--- 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 97a285857f4f17ad1fa37443e15825499b1ab0e2..f112e962aadfedd8fbe23b89582247a6758d56a6 100644 (file)
--- 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 4fbc2eddacede8c66c3da161353eccf7d809f3b1..47b5b96ace4db0121323c2b8bad78728f2d7d233 100644 (file)
--- 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 d520c556d435593a44ea9a759e709649acceba33..a5c5c9b382bac6dad8806d990e7316bba7f7a42a 100644 (file)
--- 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 95c446d0696e54c7bd8934e4682cdac4fdcdf0a9..14302138efa050a69bb9d1250715cd6947fb9ffe 100644 (file)
--- 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 b1421cbe733bb76772f90b23b86e43da7dcef5b7..80ffba329ad3b25d9058851b747854f55ef685a6 100644 (file)
--- a/gcc/lto/ChangeLog
+++ b/gcc/lto/ChangeLog
@@ -1,3 +1,7 @@
+2016-05-03  Jan Hubicka  <hubicka@ucw.cz>
+
+       * lto-symtab.c (lto_cgraph_replace_node): Initialize inline_failed.
+
 2016-04-27  Prathamesh Kulkarni  <prathamesh.kulkarni@linaro.org>
 
        * lto-partition.h (lto_balanced_map): New parameter.

diff --git a/gcc/lto/lto-symtab.c b/gcc/lto/lto-symtab.c
index 94b919b53e6ed18583e4212f71aac3637b933230..ce9e1465e3c186f9d55d815f9d0e8acbc5e53f7b 100644 (file)
--- 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);