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

9 files changed, 71 insertions, 30 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index b73543c..12a292c 100644
--- 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 3105aec..782cb52 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 07ceb1a..10f2d34 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 97a2858..f112e96 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 4fbc2ed..47b5b96 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 d520c55..a5c5c9b 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 95c446d..1430213 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 b1421cb..80ffba3 100644
--- 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 94b919b..ce9e146 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);