From patchwork Fri Jan 17 17:59:02 2014 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "H.J. Lu" X-Patchwork-Id: 312161 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 566C92C0079 for ; Sat, 18 Jan 2014 04:59:13 +1100 (EST) DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender :mime-version:in-reply-to:references:date:message-id:subject :from:to:cc:content-type; q=dns; s=default; b=ioGl8xVDpSUL88bpea jXYYemmY+qu06/XzyAxinTKb9xy+dKFFcpMRTx4N+P6jDvyMFSYaS77cmRxLz2d4 SfGvbygBgImGDmIAAJ4rGg5EOkIJEzeQ6WidydRSSw5IJDvE+gl836JmL55sZS1F 6CRFKL0A9OpxeSbUql0XIaB9M= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender :mime-version:in-reply-to:references:date:message-id:subject :from:to:cc:content-type; s=default; bh=Ow9fxdomxtyVxc7SZ7MBQeTC Abk=; b=XBMFRfdQg8eGsoepkKWKuJei6Jauruv6MZok6ZwvR17YQN8SGUlRB/G/ kfF8dPXDbS25e8Pt3k8+ZQ8vft4NxQSLi6ct2ZMqk/qrnreQYaKCLNy90chSgrZr vR+025o4VICRm1kW2f/G20425NnNSeAvf5fO3xVth1cv62CgbAc= Received: (qmail 14654 invoked by alias); 17 Jan 2014 17:59:06 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Received: (qmail 14643 invoked by uid 89); 17 Jan 2014 17:59:06 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-1.3 required=5.0 tests=AWL, BAYES_00, FREEMAIL_FROM, RCVD_IN_DNSWL_LOW, SPF_PASS autolearn=ham version=3.3.2 X-HELO: mail-oa0-f54.google.com Received: from mail-oa0-f54.google.com (HELO mail-oa0-f54.google.com) (209.85.219.54) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES128-SHA encrypted) ESMTPS; Fri, 17 Jan 2014 17:59:04 +0000 Received: by mail-oa0-f54.google.com with SMTP id o6so4999591oag.27 for ; Fri, 17 Jan 2014 09:59:02 -0800 (PST) MIME-Version: 1.0 X-Received: by 10.60.119.70 with SMTP id ks6mr2631447oeb.45.1389981542729; Fri, 17 Jan 2014 09:59:02 -0800 (PST) Received: by 10.76.105.174 with HTTP; Fri, 17 Jan 2014 09:59:02 -0800 (PST) In-Reply-To: <20140117164258.GD11468@kam.mff.cuni.cz> References: <20140113201116.GA23030@intel.com> <20140117153521.GC11468@kam.mff.cuni.cz> <20140117164258.GD11468@kam.mff.cuni.cz> Date: Fri, 17 Jan 2014 09:59:02 -0800 Message-ID: Subject: Re: PATCH: PR middle-end/59789: [4.9 Regression] ICE in in convert_move, at expr.c:333 From: "H.J. Lu" To: Jan Hubicka Cc: GCC Patches X-IsSubscribed: yes On Fri, Jan 17, 2014 at 8:42 AM, Jan Hubicka 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. From abb55ed09f4d493046b3dd6a27e7df0d1587fa72 Mon Sep 17 00:00:00 2001 From: "H.J. Lu" 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 + 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 + * 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 + + PR middle-end/59789 + * gcc.target/i386/pr59789.c: New testcase. + 2014-01-17 Paolo Carlini 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