ipa-inline-analysis.c (redirect_to_unreachable): New function.

	* ipa-inline-analysis.c (redirect_to_unreachable): New function.
	(edge_set_predicate): Use it to mark unreachable edges.
	(inline_summary_t::duplicate): Remove unnecesary code.
	(remap_edge_summaries): Likewise.
	(dump_inline_summary): Report contains_cilk_spawn.
	(compute_inline_parameters): Compute contains_cilk_spawn.
	(inline_read_section, inline_write_summary): Stream
	contains_cilk_spawn.
	* ipa-inline.c (can_inline_edge_p): Do not tuch 
	DECL_STRUCT_FUNCTION that may not be available;
	use CIF_CILK_SPAWN for cilk; fix optimization attribute checks;
	remove check for callee_fun->can_throw_non_call_exceptions and
	replace it by optimization attribute check; check for flag_exceptions.
	* ipa-inline-transform.c (inline_call): Maintain
	DECL_FUNCTION_PERSONALITY
	* ipa-inline.h (inline_summary): Add contains_cilk_spawn.

From-SVN: r221706

1 files changed, 37 insertions, 33 deletions

diff --git a/gcc/ipa-inline.c b/gcc/ipa-inline.c
index 851ef3f..49af4ce 100644
--- a/gcc/ipa-inline.c
+++ b/gcc/ipa-inline.c
@@ -142,7 +142,6 @@ along with GCC; see the file COPYING3.  If not see
 #include "ipa-utils.h"
 #include "sreal.h"
 #include "auto-profile.h"
-#include "cilk.h"
 #include "builtins.h"
 #include "fibonacci_heap.h"
 #include "lto-streamer.h"
@@ -329,8 +328,6 @@ can_inline_edge_p (struct cgraph_edge *e, bool report,
   tree caller_tree = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (caller->decl);
   tree callee_tree
     = callee ? DECL_FUNCTION_SPECIFIC_OPTIMIZATION (callee->decl) : NULL;
-  struct function *caller_fun = caller->get_fun ();
-  struct function *callee_fun = callee ? callee->get_fun () : NULL;
 
   if (!callee->definition)
     {
@@ -342,12 +339,6 @@ can_inline_edge_p (struct cgraph_edge *e, bool report,
       e->inline_failed = CIF_USES_COMDAT_LOCAL;
       inlinable = false;
     }
-  else if (!inline_summaries->get (callee)->inlinable
-	   || (caller_fun && fn_contains_cilk_spawn_p (caller_fun)))
-    {
-      e->inline_failed = CIF_FUNCTION_NOT_INLINABLE;
-      inlinable = false;
-    }
   else if (avail <= AVAIL_INTERPOSABLE)
     {
       e->inline_failed = CIF_OVERWRITABLE;
@@ -375,16 +366,6 @@ can_inline_edge_p (struct cgraph_edge *e, bool report,
       e->inline_failed = CIF_UNSPECIFIED;
       inlinable = false;
     }
-  /* Don't inline if the callee can throw non-call exceptions but the
-     caller cannot.
-     FIXME: this is obviously wrong for LTO where STRUCT_FUNCTION is missing.
-     Move the flag into cgraph node or mirror it in the inline summary.  */
-  else if (callee_fun && callee_fun->can_throw_non_call_exceptions
-	   && !(caller_fun && caller_fun->can_throw_non_call_exceptions))
-    {
-      e->inline_failed = CIF_NON_CALL_EXCEPTIONS;
-      inlinable = false;
-    }
   /* Check compatibility of target optimization options.  */
   else if (!targetm.target_option.can_inline_p (caller->decl,
 						callee->decl))
@@ -392,6 +373,16 @@ can_inline_edge_p (struct cgraph_edge *e, bool report,
       e->inline_failed = CIF_TARGET_OPTION_MISMATCH;
       inlinable = false;
     }
+  else if (!inline_summaries->get (callee)->inlinable)
+    {
+      e->inline_failed = CIF_FUNCTION_NOT_INLINABLE;
+      inlinable = false;
+    }
+  else if (inline_summaries->get (caller)->contains_cilk_spawn)
+    {
+      e->inline_failed = CIF_CILK_SPAWN;
+      inlinable = false;
+    }
   /* Don't inline a function with mismatched sanitization attributes. */
   else if (!sanitize_attrs_match_for_inline_p (caller->decl, callee->decl))
     {
@@ -416,38 +407,51 @@ can_inline_edge_p (struct cgraph_edge *e, bool report,
       /* Strictly speaking only when the callee contains signed integer
          math where overflow is undefined.  */
       if ((opt_for_fn (caller->decl, flag_strict_overflow)
-	   != opt_for_fn (caller->decl, flag_strict_overflow))
+	   != opt_for_fn (callee->decl, flag_strict_overflow))
 	  || (opt_for_fn (caller->decl, flag_wrapv)
-	      != opt_for_fn (caller->decl, flag_wrapv))
+	      != opt_for_fn (callee->decl, flag_wrapv))
 	  || (opt_for_fn (caller->decl, flag_trapv)
-	      != opt_for_fn (caller->decl, flag_trapv))
+	      != opt_for_fn (callee->decl, flag_trapv))
 	  /* Strictly speaking only when the callee contains memory
 	     accesses that are not using alias-set zero anyway.  */
 	  || (opt_for_fn (caller->decl, flag_strict_aliasing)
-	      != opt_for_fn (caller->decl, flag_strict_aliasing))
+	      != opt_for_fn (callee->decl, flag_strict_aliasing))
 	  /* Strictly speaking only when the callee uses FP math.  */
 	  || (opt_for_fn (caller->decl, flag_rounding_math)
-	      != opt_for_fn (caller->decl, flag_rounding_math))
+	      != opt_for_fn (callee->decl, flag_rounding_math))
 	  || (opt_for_fn (caller->decl, flag_trapping_math)
-	      != opt_for_fn (caller->decl, flag_trapping_math))
+	      != opt_for_fn (callee->decl, flag_trapping_math))
 	  || (opt_for_fn (caller->decl, flag_unsafe_math_optimizations)
-	      != opt_for_fn (caller->decl, flag_unsafe_math_optimizations))
+	      != opt_for_fn (callee->decl, flag_unsafe_math_optimizations))
 	  || (opt_for_fn (caller->decl, flag_finite_math_only)
-	      != opt_for_fn (caller->decl, flag_finite_math_only))
+	      != opt_for_fn (callee->decl, flag_finite_math_only))
 	  || (opt_for_fn (caller->decl, flag_signaling_nans)
-	      != opt_for_fn (caller->decl, flag_signaling_nans))
+	      != opt_for_fn (callee->decl, flag_signaling_nans))
 	  || (opt_for_fn (caller->decl, flag_cx_limited_range)
-	      != opt_for_fn (caller->decl, flag_cx_limited_range))
+	      != opt_for_fn (callee->decl, flag_cx_limited_range))
 	  || (opt_for_fn (caller->decl, flag_signed_zeros)
-	      != opt_for_fn (caller->decl, flag_signed_zeros))
+	      != opt_for_fn (callee->decl, flag_signed_zeros))
 	  || (opt_for_fn (caller->decl, flag_associative_math)
-	      != opt_for_fn (caller->decl, flag_associative_math))
+	      != opt_for_fn (callee->decl, flag_associative_math))
 	  || (opt_for_fn (caller->decl, flag_reciprocal_math)
-	      != opt_for_fn (caller->decl, flag_reciprocal_math))
+	      != opt_for_fn (callee->decl, flag_reciprocal_math))
+	  /* We do not want to make code compiled with exceptions to be brought
+	     into a non-EH function unless we know that the callee does not
+	     throw.  This is tracked by DECL_FUNCTION_PERSONALITY.  */
+	  || (opt_for_fn (caller->decl, flag_non_call_exceptions)
+	      != opt_for_fn (callee->decl, flag_non_call_exceptions)
+	      /* TODO: We also may allow bringing !flag_non_call_exceptions
+		 to flag_non_call_exceptions function, but that may need
+		 extra work in tree-inline to add the extra EH edges.  */
+	      && (!opt_for_fn (callee->decl, flag_non_call_exceptions)
+		  || DECL_FUNCTION_PERSONALITY (callee->decl)))
+	  || (!opt_for_fn (caller->decl, flag_exceptions)
+	      && opt_for_fn (callee->decl, flag_exceptions)
+	      && DECL_FUNCTION_PERSONALITY (callee->decl))
 	  /* Strictly speaking only when the callee contains function
 	     calls that may end up setting errno.  */
 	  || (opt_for_fn (caller->decl, flag_errno_math)
-	      != opt_for_fn (caller->decl, flag_errno_math))
+	      != opt_for_fn (callee->decl, flag_errno_math))
 	  /* When devirtualization is diabled for callee, it is not safe
 	     to inline it as we possibly mangled the type info.
 	     Allow early inlining of always inlines.  */