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
@@ -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.
@@ -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"};
@@ -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);
@@ -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"))
@@ -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
new file mode 100644
@@ -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" } */
+}
@@ -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