Patchwork PATCH: PR middle-end/59789: [4.9 Regression] ICE in in convert_move, at expr.c:333

login
register
mail settings
Submitter H.J. Lu
Date Jan. 17, 2014, 5:59 p.m.
Message ID <CAMe9rOoHVjj4x6r=zGbhK18uBe5HO9-KNveWsA1An+U2oUnqcA@mail.gmail.com>
Download mbox | patch
Permalink /patch/312161/
State New
Headers show

Comments

H.J. Lu - Jan. 17, 2014, 5:59 p.m.
On Fri, Jan 17, 2014 at 8:42 AM, Jan Hubicka <hubicka@ucw.cz> wrote:
>> For this testcase, we get CIF_TARGET_OPTION_MISMATCH.
>> Do you want to add a new flag so that inliner can use for
>> other errors?
>
> Just add flags parameter to DEFCIFCODE in cif-code.def
> and flag those that are final and should be output already
> in early inlining.
> This way we will not forget to include new codes as we introduce them.
>

Like this?  OK for trunk?

Thanks.
Jan Hubicka - Jan. 20, 2014, 8:09 p.m.
> +enum cgraph_inline_failed_flag_t
> +{
> +  CIF_FINAL_NORMAL = 0,
> +  CIF_FINAL_ERROR

The difference is that some errors will never go away, while others are "temporary"
and inliner may revisit them later and inline (such as when indirect call becomes direct).
So perhaps CIF_FINAL/CIF_NORMAL?
> +};
> +
>  /* Structure containing additional information about an indirect call.  */
>  
>  struct GTY(()) cgraph_indirect_call_info
> @@ -774,6 +780,7 @@ void cgraph_unnest_node (struct cgraph_node *);
>  enum availability cgraph_function_body_availability (struct cgraph_node *);
>  void cgraph_add_new_function (tree, bool);
>  const char* cgraph_inline_failed_string (cgraph_inline_failed_t);
> +cgraph_inline_failed_flag_t cgraph_inline_failed_flag (cgraph_inline_failed_t);

When you made them enum rather than flags, lets call it cgraph_inline_failed_type

OK with these changes,
thanks!
Honza
>  
>  void cgraph_set_nothrow_flag (struct cgraph_node *, bool);
>  void cgraph_set_const_flag (struct cgraph_node *, bool, bool);
> diff --git a/gcc/cif-code.def b/gcc/cif-code.def
> index f1df5a0..5591f9a 100644
> --- a/gcc/cif-code.def
> +++ b/gcc/cif-code.def
> @@ -28,84 +28,98 @@ along with GCC see the file COPYING3.  If not see
>     which is a NULL pointer.  */
>  
>  /* Inlining successful.  This must be the first code.  */
> -DEFCIFCODE(OK , NULL)
> +DEFCIFCODE(OK, CIF_FINAL_NORMAL, NULL)
>  
>  /* Inlining failed for an unspecified reason.  */
> -DEFCIFCODE(UNSPECIFIED , "")
> +DEFCIFCODE(UNSPECIFIED, CIF_FINAL_ERROR, "")
>  
>  /* Function has not be considered for inlining.  This is the code for
>     functions that have not been rejected for inlining yet.  */
> -DEFCIFCODE(FUNCTION_NOT_CONSIDERED, N_("function not considered for inlining"))
> +DEFCIFCODE(FUNCTION_NOT_CONSIDERED, CIF_FINAL_NORMAL,
> +	   N_("function not considered for inlining"))
>  
>  /* Caller is compiled with optimizations disabled.  */
> -DEFCIFCODE(FUNCTION_NOT_OPTIMIZED, N_("caller is not optimized"))
> +DEFCIFCODE(FUNCTION_NOT_OPTIMIZED, CIF_FINAL_NORMAL,
> +	   N_("caller is not optimized"))
>  
>  /* Inlining failed owing to unavailable function body.  */
> -DEFCIFCODE(BODY_NOT_AVAILABLE, N_("function body not available"))
> +DEFCIFCODE(BODY_NOT_AVAILABLE, CIF_FINAL_ERROR,
> +	   N_("function body not available"))
>  
>  /* Extern inline function that has been redefined.  */
> -DEFCIFCODE(REDEFINED_EXTERN_INLINE,
> +DEFCIFCODE(REDEFINED_EXTERN_INLINE, CIF_FINAL_NORMAL,
>  	   N_("redefined extern inline functions are not considered for "
>  	      "inlining"))
>  
>  /* Function is not inlinable.  */
> -DEFCIFCODE(FUNCTION_NOT_INLINABLE, N_("function not inlinable"))
> +DEFCIFCODE(FUNCTION_NOT_INLINABLE, CIF_FINAL_ERROR,
> +	   N_("function not inlinable"))
>  
>  /* Function is overwritable.  */
> -DEFCIFCODE(OVERWRITABLE, N_("function body can be overwritten at link time"))
> +DEFCIFCODE(OVERWRITABLE, CIF_FINAL_ERROR,
> +	   N_("function body can be overwritten at link time"))
>  
>  /* Function is not an inlining candidate.  */
> -DEFCIFCODE(FUNCTION_NOT_INLINE_CANDIDATE, N_("function not inline candidate"))
> +DEFCIFCODE(FUNCTION_NOT_INLINE_CANDIDATE, CIF_FINAL_NORMAL,
> +	   N_("function not inline candidate"))
>  
>  /* Inlining failed because of various limit parameters.  */
> -DEFCIFCODE(LARGE_FUNCTION_GROWTH_LIMIT,
> +DEFCIFCODE(LARGE_FUNCTION_GROWTH_LIMIT, CIF_FINAL_NORMAL,
>  	   N_("--param large-function-growth limit reached"))
> -DEFCIFCODE(LARGE_STACK_FRAME_GROWTH_LIMIT,
> +DEFCIFCODE(LARGE_STACK_FRAME_GROWTH_LIMIT, CIF_FINAL_NORMAL,
>  	   N_("--param large-stack-frame-growth limit reached"))
> -DEFCIFCODE(MAX_INLINE_INSNS_SINGLE_LIMIT,
> +DEFCIFCODE(MAX_INLINE_INSNS_SINGLE_LIMIT, CIF_FINAL_NORMAL,
>  	   N_("--param max-inline-insns-single limit reached"))
> -DEFCIFCODE(MAX_INLINE_INSNS_AUTO_LIMIT,
> +DEFCIFCODE(MAX_INLINE_INSNS_AUTO_LIMIT, CIF_FINAL_NORMAL,
>  	   N_("--param max-inline-insns-auto limit reached"))
> -DEFCIFCODE(INLINE_UNIT_GROWTH_LIMIT,
> +DEFCIFCODE(INLINE_UNIT_GROWTH_LIMIT, CIF_FINAL_NORMAL,
>  	   N_("--param inline-unit-growth limit reached"))
>  
>  /* Recursive inlining.  */
> -DEFCIFCODE(RECURSIVE_INLINING, N_("recursive inlining"))
> +DEFCIFCODE(RECURSIVE_INLINING, CIF_FINAL_NORMAL,
> +	   N_("recursive inlining"))
>  
>  /* Call is unlikely.  */
> -DEFCIFCODE(UNLIKELY_CALL, N_("call is unlikely and code size would grow"))
> +DEFCIFCODE(UNLIKELY_CALL, CIF_FINAL_NORMAL,
> +	   N_("call is unlikely and code size would grow"))
>  
>  /* Function is not declared as inline.  */
> -DEFCIFCODE(NOT_DECLARED_INLINED,
> +DEFCIFCODE(NOT_DECLARED_INLINED, CIF_FINAL_NORMAL,
>  	   N_("function not declared inline and code size would grow"))
>  
>  /* Inlining suppressed due to size optimization.  */
> -DEFCIFCODE(OPTIMIZING_FOR_SIZE,
> +DEFCIFCODE(OPTIMIZING_FOR_SIZE, CIF_FINAL_NORMAL,
>  	   N_("optimizing for size and code size would grow"))
>  
>  /* Caller and callee disagree on the arguments.  */
> -DEFCIFCODE(MISMATCHED_ARGUMENTS, N_("mismatched arguments"))
> +DEFCIFCODE(MISMATCHED_ARGUMENTS, CIF_FINAL_ERROR,
> +	   N_("mismatched arguments"))
>  
>  /* Call was originally indirect.  */
> -DEFCIFCODE(ORIGINALLY_INDIRECT_CALL,
> +DEFCIFCODE(ORIGINALLY_INDIRECT_CALL, CIF_FINAL_NORMAL,
>  	   N_("originally indirect function call not considered for inlining"))
>  
>  /* Ths edge represents an indirect edge with a yet-undetermined callee .  */
> -DEFCIFCODE(INDIRECT_UNKNOWN_CALL,
> +DEFCIFCODE(INDIRECT_UNKNOWN_CALL, CIF_FINAL_NORMAL,
>  	   N_("indirect function call with a yet undetermined callee"))
>  
>  /* We can't inline different EH personalities together.  */
> -DEFCIFCODE(EH_PERSONALITY, N_("exception handling personality mismatch"))
> +DEFCIFCODE(EH_PERSONALITY, CIF_FINAL_ERROR,
> +	   N_("exception handling personality mismatch"))
>  
>  /* We can't inline if the callee can throw non-call exceptions but the
>     caller cannot.  */
> -DEFCIFCODE(NON_CALL_EXCEPTIONS, N_("non-call exception handling mismatch"))
> +DEFCIFCODE(NON_CALL_EXCEPTIONS, CIF_FINAL_ERROR,
> +	   N_("non-call exception handling mismatch"))
>  
>  /* We can't inline because of mismatched target specific options.  */
> -DEFCIFCODE(TARGET_OPTION_MISMATCH, N_("target specific option mismatch"))
> +DEFCIFCODE(TARGET_OPTION_MISMATCH, CIF_FINAL_ERROR,
> +	   N_("target specific option mismatch"))
>  
>  /* We can't inline because of mismatched optimization levels.  */
> -DEFCIFCODE(OPTIMIZATION_MISMATCH, N_("optimization level attribute mismatch"))
> +DEFCIFCODE(OPTIMIZATION_MISMATCH, CIF_FINAL_ERROR,
> +	   N_("optimization level attribute mismatch"))
>  
>  /* We can't inline because the callee refers to comdat-local symbols.  */
> -DEFCIFCODE(USES_COMDAT_LOCAL, N_("callee refers to comdat-local symbols"))
> +DEFCIFCODE(USES_COMDAT_LOCAL, CIF_FINAL_NORMAL,
> +	   N_("callee refers to comdat-local symbols"))
> diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
> index 98bc528..b11ff17 100644
> --- a/gcc/testsuite/ChangeLog
> +++ b/gcc/testsuite/ChangeLog
> @@ -1,3 +1,8 @@
> +2014-01-17  H.J. Lu  <hongjiu.lu@intel.com>
> +
> +	PR middle-end/59789
> +	* gcc.target/i386/pr59789.c: New testcase.
> +
>  2014-01-17  Paolo Carlini  <paolo.carlini@oracle.com>
>  
>  	PR c++/59269
> diff --git a/gcc/testsuite/gcc.target/i386/pr59789.c b/gcc/testsuite/gcc.target/i386/pr59789.c
> new file mode 100644
> index 0000000..b144025
> --- /dev/null
> +++ b/gcc/testsuite/gcc.target/i386/pr59789.c
> @@ -0,0 +1,22 @@
> +/* { dg-do compile } */
> +/* { dg-require-effective-target ia32 } */
> +/* { dg-options "-O -march=i686" } */
> +
> +#pragma GCC push_options
> +#pragma GCC target("sse2")
> +typedef int __v4si __attribute__ ((__vector_size__ (16)));
> +typedef long long __m128i __attribute__ ((__vector_size__ (16), __may_alias__));
> +
> +extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
> +_mm_set_epi32 (int __q3, int __q2, int __q1, int __q0) /* { dg-error "target specific option mismatch" } */
> +{
> +  return __extension__ (__m128i)(__v4si){ __q0, __q1, __q2, __q3 };
> +}
> +#pragma GCC pop_options
> +
> +
> +__m128i
> +f1(void)
> +{ /* { dg-message "warning: SSE vector return without SSE enabled changes the ABI" } */
> +  return _mm_set_epi32 (0, 0, 0, 0); /* { dg-error "called from here" } */
> +}
> diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c
> index 22521b1..0c6835c 100644
> --- a/gcc/tree-inline.c
> +++ b/gcc/tree-inline.c
> @@ -4116,7 +4116,8 @@ expand_call_inline (basic_block bb, gimple stmt, copy_body_data *id)
>  	  /* During early inline pass, report only when optimization is
>  	     not turned on.  */
>  	  && (cgraph_global_info_ready
> -	      || !optimize)
> +	      || !optimize
> +	      || cgraph_inline_failed_flag (reason) == CIF_FINAL_ERROR)
>  	  /* PR 20090218-1_0.c. Body can be provided by another module. */
>  	  && (reason != CIF_BODY_NOT_AVAILABLE || !flag_generate_lto))
>  	{
> -- 
> 1.8.3.1
>

Patch

From abb55ed09f4d493046b3dd6a27e7df0d1587fa72 Mon Sep 17 00:00:00 2001
From: "H.J. Lu" <hjl.tools@gmail.com>
Date: Mon, 13 Jan 2014 11:54:36 -0800
Subject: [PATCH] Update error handling during early_inlining

---
 gcc/ChangeLog                           | 24 ++++++++++++
 gcc/cgraph.c                            | 20 +++++++++-
 gcc/cgraph.h                            |  9 ++++-
 gcc/cif-code.def                        | 66 ++++++++++++++++++++-------------
 gcc/testsuite/ChangeLog                 |  5 +++
 gcc/testsuite/gcc.target/i386/pr59789.c | 22 +++++++++++
 gcc/tree-inline.c                       |  3 +-
 7 files changed, 120 insertions(+), 29 deletions(-)
 create mode 100644 gcc/testsuite/gcc.target/i386/pr59789.c

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index df6e491..eb55a89 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,5 +1,29 @@ 
 2014-01-17  H.J. Lu  <hongjiu.lu@intel.com>
 
+	PR middle-end/59789
+	* cgraph.c (cgraph_inline_failed_string): Add flag to DEFCIFCODE.
+	(cgraph_inline_failed_flag): New function.
+	* cgraph.h (DEFCIFCODE): Add flag.
+	(cgraph_inline_failed_flag_t): New enum.
+	(cgraph_inline_failed_flag): New prototype.
+	* cif-code.def: Add CIF_FINAL_NORMAL to OK, FUNCTION_NOT_CONSIDERED,
+	FUNCTION_NOT_OPTIMIZED, REDEFINED_EXTERN_INLINE,
+	FUNCTION_NOT_INLINE_CANDIDATE, LARGE_FUNCTION_GROWTH_LIMIT,
+	LARGE_STACK_FRAME_GROWTH_LIMIT, MAX_INLINE_INSNS_SINGLE_LIMIT,
+	MAX_INLINE_INSNS_AUTO_LIMIT, INLINE_UNIT_GROWTH_LIMIT,
+	RECURSIVE_INLINING, UNLIKELY_CALL, NOT_DECLARED_INLINED,
+	OPTIMIZING_FOR_SIZE, ORIGINALLY_INDIRECT_CALL,
+	INDIRECT_UNKNOWN_CALL, USES_COMDAT_LOCAL. 
+	Add CIF_FINAL_ERROR to UNSPECIFIED, BODY_NOT_AVAILABLE,
+	FUNCTION_NOT_INLINABLE, OVERWRITABLE, MISMATCHED_ARGUMENTS,
+	EH_PERSONALITY, NON_CALL_EXCEPTIONS, TARGET_OPTION_MISMATCH,
+	OPTIMIZATION_MISMATCH.
+	* tree-inline.c (expand_call_inline): Emit errors during
+	early_inlining if cgraph_inline_failed_flag returns
+	CIF_FINAL_ERROR.
+
+2014-01-17  H.J. Lu  <hongjiu.lu@intel.com>
+
 	* config/i386/i386-c.c (ix86_target_macros_internal): Handle
 	PROCESSOR_INTEL.  Treat like PROCESSOR_GENERIC.
 	* config/i386/i386.c (intel_memcpy): New.  Duplicate slm_memcpy.
diff --git a/gcc/cgraph.c b/gcc/cgraph.c
index 92b31b9..156b6ee 100644
--- a/gcc/cgraph.c
+++ b/gcc/cgraph.c
@@ -1877,7 +1877,7 @@  const char*
 cgraph_inline_failed_string (cgraph_inline_failed_t reason)
 {
 #undef DEFCIFCODE
-#define DEFCIFCODE(code, string)	string,
+#define DEFCIFCODE(code, flag, string)	string,
 
   static const char *cif_string_table[CIF_N_REASONS] = {
 #include "cif-code.def"
@@ -1889,6 +1889,24 @@  cgraph_inline_failed_string (cgraph_inline_failed_t reason)
   return cif_string_table[reason];
 }
 
+/* Return a flag describing the failure REASON.  */
+
+cgraph_inline_failed_flag_t
+cgraph_inline_failed_flag (cgraph_inline_failed_t reason)
+{
+#undef DEFCIFCODE
+#define DEFCIFCODE(code, flag, string)	flag,
+
+  static cgraph_inline_failed_flag_t cif_flag_table[CIF_N_REASONS] = {
+#include "cif-code.def"
+  };
+
+  /* Signedness of an enum type is implementation defined, so cast it
+     to unsigned before testing. */
+  gcc_assert ((unsigned) reason < CIF_N_REASONS);
+  return cif_flag_table[reason];
+}
+
 /* Names used to print out the availability enum.  */
 const char * const cgraph_availability_names[] =
   {"unset", "not_available", "overwritable", "available", "local"};
diff --git a/gcc/cgraph.h b/gcc/cgraph.h
index 7ce5401..6b5ae8e 100644
--- a/gcc/cgraph.h
+++ b/gcc/cgraph.h
@@ -518,13 +518,19 @@  struct varpool_node_set_iterator
   unsigned index;
 };
 
-#define DEFCIFCODE(code, string)	CIF_ ## code,
+#define DEFCIFCODE(code, flag, string)	CIF_ ## code,
 /* Reasons for inlining failures.  */
 enum cgraph_inline_failed_t {
 #include "cif-code.def"
   CIF_N_REASONS
 };
 
+enum cgraph_inline_failed_flag_t
+{
+  CIF_FINAL_NORMAL = 0,
+  CIF_FINAL_ERROR
+};
+
 /* Structure containing additional information about an indirect call.  */
 
 struct GTY(()) cgraph_indirect_call_info
@@ -774,6 +780,7 @@  void cgraph_unnest_node (struct cgraph_node *);
 enum availability cgraph_function_body_availability (struct cgraph_node *);
 void cgraph_add_new_function (tree, bool);
 const char* cgraph_inline_failed_string (cgraph_inline_failed_t);
+cgraph_inline_failed_flag_t cgraph_inline_failed_flag (cgraph_inline_failed_t);
 
 void cgraph_set_nothrow_flag (struct cgraph_node *, bool);
 void cgraph_set_const_flag (struct cgraph_node *, bool, bool);
diff --git a/gcc/cif-code.def b/gcc/cif-code.def
index f1df5a0..5591f9a 100644
--- a/gcc/cif-code.def
+++ b/gcc/cif-code.def
@@ -28,84 +28,98 @@  along with GCC see the file COPYING3.  If not see
    which is a NULL pointer.  */
 
 /* Inlining successful.  This must be the first code.  */
-DEFCIFCODE(OK , NULL)
+DEFCIFCODE(OK, CIF_FINAL_NORMAL, NULL)
 
 /* Inlining failed for an unspecified reason.  */
-DEFCIFCODE(UNSPECIFIED , "")
+DEFCIFCODE(UNSPECIFIED, CIF_FINAL_ERROR, "")
 
 /* Function has not be considered for inlining.  This is the code for
    functions that have not been rejected for inlining yet.  */
-DEFCIFCODE(FUNCTION_NOT_CONSIDERED, N_("function not considered for inlining"))
+DEFCIFCODE(FUNCTION_NOT_CONSIDERED, CIF_FINAL_NORMAL,
+	   N_("function not considered for inlining"))
 
 /* Caller is compiled with optimizations disabled.  */
-DEFCIFCODE(FUNCTION_NOT_OPTIMIZED, N_("caller is not optimized"))
+DEFCIFCODE(FUNCTION_NOT_OPTIMIZED, CIF_FINAL_NORMAL,
+	   N_("caller is not optimized"))
 
 /* Inlining failed owing to unavailable function body.  */
-DEFCIFCODE(BODY_NOT_AVAILABLE, N_("function body not available"))
+DEFCIFCODE(BODY_NOT_AVAILABLE, CIF_FINAL_ERROR,
+	   N_("function body not available"))
 
 /* Extern inline function that has been redefined.  */
-DEFCIFCODE(REDEFINED_EXTERN_INLINE,
+DEFCIFCODE(REDEFINED_EXTERN_INLINE, CIF_FINAL_NORMAL,
 	   N_("redefined extern inline functions are not considered for "
 	      "inlining"))
 
 /* Function is not inlinable.  */
-DEFCIFCODE(FUNCTION_NOT_INLINABLE, N_("function not inlinable"))
+DEFCIFCODE(FUNCTION_NOT_INLINABLE, CIF_FINAL_ERROR,
+	   N_("function not inlinable"))
 
 /* Function is overwritable.  */
-DEFCIFCODE(OVERWRITABLE, N_("function body can be overwritten at link time"))
+DEFCIFCODE(OVERWRITABLE, CIF_FINAL_ERROR,
+	   N_("function body can be overwritten at link time"))
 
 /* Function is not an inlining candidate.  */
-DEFCIFCODE(FUNCTION_NOT_INLINE_CANDIDATE, N_("function not inline candidate"))
+DEFCIFCODE(FUNCTION_NOT_INLINE_CANDIDATE, CIF_FINAL_NORMAL,
+	   N_("function not inline candidate"))
 
 /* Inlining failed because of various limit parameters.  */
-DEFCIFCODE(LARGE_FUNCTION_GROWTH_LIMIT,
+DEFCIFCODE(LARGE_FUNCTION_GROWTH_LIMIT, CIF_FINAL_NORMAL,
 	   N_("--param large-function-growth limit reached"))
-DEFCIFCODE(LARGE_STACK_FRAME_GROWTH_LIMIT,
+DEFCIFCODE(LARGE_STACK_FRAME_GROWTH_LIMIT, CIF_FINAL_NORMAL,
 	   N_("--param large-stack-frame-growth limit reached"))
-DEFCIFCODE(MAX_INLINE_INSNS_SINGLE_LIMIT,
+DEFCIFCODE(MAX_INLINE_INSNS_SINGLE_LIMIT, CIF_FINAL_NORMAL,
 	   N_("--param max-inline-insns-single limit reached"))
-DEFCIFCODE(MAX_INLINE_INSNS_AUTO_LIMIT,
+DEFCIFCODE(MAX_INLINE_INSNS_AUTO_LIMIT, CIF_FINAL_NORMAL,
 	   N_("--param max-inline-insns-auto limit reached"))
-DEFCIFCODE(INLINE_UNIT_GROWTH_LIMIT,
+DEFCIFCODE(INLINE_UNIT_GROWTH_LIMIT, CIF_FINAL_NORMAL,
 	   N_("--param inline-unit-growth limit reached"))
 
 /* Recursive inlining.  */
-DEFCIFCODE(RECURSIVE_INLINING, N_("recursive inlining"))
+DEFCIFCODE(RECURSIVE_INLINING, CIF_FINAL_NORMAL,
+	   N_("recursive inlining"))
 
 /* Call is unlikely.  */
-DEFCIFCODE(UNLIKELY_CALL, N_("call is unlikely and code size would grow"))
+DEFCIFCODE(UNLIKELY_CALL, CIF_FINAL_NORMAL,
+	   N_("call is unlikely and code size would grow"))
 
 /* Function is not declared as inline.  */
-DEFCIFCODE(NOT_DECLARED_INLINED,
+DEFCIFCODE(NOT_DECLARED_INLINED, CIF_FINAL_NORMAL,
 	   N_("function not declared inline and code size would grow"))
 
 /* Inlining suppressed due to size optimization.  */
-DEFCIFCODE(OPTIMIZING_FOR_SIZE,
+DEFCIFCODE(OPTIMIZING_FOR_SIZE, CIF_FINAL_NORMAL,
 	   N_("optimizing for size and code size would grow"))
 
 /* Caller and callee disagree on the arguments.  */
-DEFCIFCODE(MISMATCHED_ARGUMENTS, N_("mismatched arguments"))
+DEFCIFCODE(MISMATCHED_ARGUMENTS, CIF_FINAL_ERROR,
+	   N_("mismatched arguments"))
 
 /* Call was originally indirect.  */
-DEFCIFCODE(ORIGINALLY_INDIRECT_CALL,
+DEFCIFCODE(ORIGINALLY_INDIRECT_CALL, CIF_FINAL_NORMAL,
 	   N_("originally indirect function call not considered for inlining"))
 
 /* Ths edge represents an indirect edge with a yet-undetermined callee .  */
-DEFCIFCODE(INDIRECT_UNKNOWN_CALL,
+DEFCIFCODE(INDIRECT_UNKNOWN_CALL, CIF_FINAL_NORMAL,
 	   N_("indirect function call with a yet undetermined callee"))
 
 /* We can't inline different EH personalities together.  */
-DEFCIFCODE(EH_PERSONALITY, N_("exception handling personality mismatch"))
+DEFCIFCODE(EH_PERSONALITY, CIF_FINAL_ERROR,
+	   N_("exception handling personality mismatch"))
 
 /* We can't inline if the callee can throw non-call exceptions but the
    caller cannot.  */
-DEFCIFCODE(NON_CALL_EXCEPTIONS, N_("non-call exception handling mismatch"))
+DEFCIFCODE(NON_CALL_EXCEPTIONS, CIF_FINAL_ERROR,
+	   N_("non-call exception handling mismatch"))
 
 /* We can't inline because of mismatched target specific options.  */
-DEFCIFCODE(TARGET_OPTION_MISMATCH, N_("target specific option mismatch"))
+DEFCIFCODE(TARGET_OPTION_MISMATCH, CIF_FINAL_ERROR,
+	   N_("target specific option mismatch"))
 
 /* We can't inline because of mismatched optimization levels.  */
-DEFCIFCODE(OPTIMIZATION_MISMATCH, N_("optimization level attribute mismatch"))
+DEFCIFCODE(OPTIMIZATION_MISMATCH, CIF_FINAL_ERROR,
+	   N_("optimization level attribute mismatch"))
 
 /* We can't inline because the callee refers to comdat-local symbols.  */
-DEFCIFCODE(USES_COMDAT_LOCAL, N_("callee refers to comdat-local symbols"))
+DEFCIFCODE(USES_COMDAT_LOCAL, CIF_FINAL_NORMAL,
+	   N_("callee refers to comdat-local symbols"))
diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index 98bc528..b11ff17 100644
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,8 @@ 
+2014-01-17  H.J. Lu  <hongjiu.lu@intel.com>
+
+	PR middle-end/59789
+	* gcc.target/i386/pr59789.c: New testcase.
+
 2014-01-17  Paolo Carlini  <paolo.carlini@oracle.com>
 
 	PR c++/59269
diff --git a/gcc/testsuite/gcc.target/i386/pr59789.c b/gcc/testsuite/gcc.target/i386/pr59789.c
new file mode 100644
index 0000000..b144025
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr59789.c
@@ -0,0 +1,22 @@ 
+/* { dg-do compile } */
+/* { dg-require-effective-target ia32 } */
+/* { dg-options "-O -march=i686" } */
+
+#pragma GCC push_options
+#pragma GCC target("sse2")
+typedef int __v4si __attribute__ ((__vector_size__ (16)));
+typedef long long __m128i __attribute__ ((__vector_size__ (16), __may_alias__));
+
+extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_set_epi32 (int __q3, int __q2, int __q1, int __q0) /* { dg-error "target specific option mismatch" } */
+{
+  return __extension__ (__m128i)(__v4si){ __q0, __q1, __q2, __q3 };
+}
+#pragma GCC pop_options
+
+
+__m128i
+f1(void)
+{ /* { dg-message "warning: SSE vector return without SSE enabled changes the ABI" } */
+  return _mm_set_epi32 (0, 0, 0, 0); /* { dg-error "called from here" } */
+}
diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c
index 22521b1..0c6835c 100644
--- a/gcc/tree-inline.c
+++ b/gcc/tree-inline.c
@@ -4116,7 +4116,8 @@  expand_call_inline (basic_block bb, gimple stmt, copy_body_data *id)
 	  /* During early inline pass, report only when optimization is
 	     not turned on.  */
 	  && (cgraph_global_info_ready
-	      || !optimize)
+	      || !optimize
+	      || cgraph_inline_failed_flag (reason) == CIF_FINAL_ERROR)
 	  /* PR 20090218-1_0.c. Body can be provided by another module. */
 	  && (reason != CIF_BODY_NOT_AVAILABLE || !flag_generate_lto))
 	{
-- 
1.8.3.1