From patchwork Wed Apr 20 13:52:33 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Richard Biener X-Patchwork-Id: 53073 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 99087385782D for ; Wed, 20 Apr 2022 13:53:05 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 99087385782D DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1650462785; bh=5CJK+Cgw1CEGmczoUYy4IN03FOuGnw2gm9I78Y+xu3M=; h=Date:To:Subject:List-Id:List-Unsubscribe:List-Archive:List-Post: List-Help:List-Subscribe:From:Reply-To:Cc:From; b=vupdco4tGHVhUuGUQNVYatMwr3si7sp/11HKwSpQ6RYOJz5qCHU7UFk7LjTO9ZpwN oRz5T4JoWQuvFvR4/9oW4fRIBr1l/rbNd8dUhPElrv+D/RzPwWZKpREWLoJ0rkFpss ui0fQJ3/bSI3I74VFBw742v+aBGeSBYI561kBgcg= X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from smtp-out2.suse.de (smtp-out2.suse.de [195.135.220.29]) by sourceware.org (Postfix) with ESMTPS id 9D79A3858C53; Wed, 20 Apr 2022 13:52:35 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 9D79A3858C53 Received: from imap2.suse-dmz.suse.de (imap2.suse-dmz.suse.de [192.168.254.74]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (P-521) server-digest SHA512) (No client certificate requested) by smtp-out2.suse.de (Postfix) with ESMTPS id 785521F385; Wed, 20 Apr 2022 13:52:34 +0000 (UTC) Received: from imap2.suse-dmz.suse.de (imap2.suse-dmz.suse.de [192.168.254.74]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (P-521) server-digest SHA512) (No client certificate requested) by imap2.suse-dmz.suse.de (Postfix) with ESMTPS id 57BF413A30; Wed, 20 Apr 2022 13:52:34 +0000 (UTC) Received: from dovecot-director2.suse.de ([192.168.254.65]) by imap2.suse-dmz.suse.de with ESMTPSA id 1c1BFCIQYGL5CgAAMHmgww (envelope-from ); Wed, 20 Apr 2022 13:52:34 +0000 Date: Wed, 20 Apr 2022 15:52:33 +0200 (CEST) To: gcc-patches@gcc.gnu.org Subject: [PATCH][v3] rtl-optimization/105231 - distribute_notes and REG_EH_REGION MIME-Version: 1.0 Message-Id: <20220420135234.57BF413A30@imap2.suse-dmz.suse.de> X-Spam-Status: No, score=-11.7 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, SPF_HELO_NONE, SPF_PASS, TXREP, T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.4 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Richard Biener via Gcc-patches From: Richard Biener Reply-To: Richard Biener Cc: ebotcazou@adacore.com, segher@kernel.crashing.org Errors-To: gcc-patches-bounces+patchwork=sourceware.org@gcc.gnu.org Sender: "Gcc-patches" The following mitigates a problem in combine distribute_notes which places an original REG_EH_REGION based on only may_trap_p which is good to test whether a non-call insn can possibly throw but not if actually it does or we care. That's something we decided at RTL expansion time where we possibly still know the insn evaluates to a constant. In fact, the REG_EH_REGION note with lp > 0 can only come from the original i3 and an assert is added to that effect. That means we only need to retain the note on i3 or, if that cannot trap, drop it but we should never move it to i2. For REG_EH_REGION corresponding to must-not-throw regions or nothrow marking try_combine gets new code ensuring we can merge and distribute notes which means placing must-not-throw notes on all result insns, and dropping nothrow notes or preserve them on i3 for calls. Bootstrapped and tested on x86_64-unknown-linux-gnu. WDYT? Thanks, Richard. 2022-04-19 Richard Biener PR rtl-optimization/105231 * combine.cc (distribute_notes): Assert that a REG_EH_REGION with landing pad > 0 is from i3 and only keep it there or drop it if the insn can not trap. Throw away REG_EH_REGION with landing pad = 0 or INT_MIN if it does not originate from a call i3. Distribute must-not-throw REG_EH_REGION to all resulting instructions. (try_combine): Ensure that we can merge REG_EH_REGION notes. * gcc.dg/torture/pr105231.c: New testcase. --- gcc/combine.cc | 106 ++++++++++++++++++++---- gcc/testsuite/gcc.dg/torture/pr105231.c | 15 ++++ 2 files changed, 104 insertions(+), 17 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/torture/pr105231.c diff --git a/gcc/combine.cc b/gcc/combine.cc index 53dcac92abc..ba234e3af5f 100644 --- a/gcc/combine.cc +++ b/gcc/combine.cc @@ -2951,6 +2951,45 @@ try_combine (rtx_insn *i3, rtx_insn *i2, rtx_insn *i1, rtx_insn *i0, return 0; } + /* When i3 transfers to an EH handler we cannot combine if any of the + sources are within a must-not-throw region. Else we can throw away + any nothrow, pick a random must-not-throw region or preserve the EH + transfer on i3. Since we want to preserve nothrow notes on calls + we have to avoid combining from must-not-throw stmts there as well. + This has to be kept in sync with distribute_note. */ + if (rtx i3_eh = find_reg_note (i3, REG_EH_REGION, NULL_RTX)) + { + int i3_lp_nr = INTVAL (XEXP (i3_eh, 0)); + if (i3_lp_nr > 0 + || ((i3_lp_nr == 0 || i3_lp_nr == INT_MIN) && CALL_P (i3))) + { + rtx eh; + int eh_lp; + if (((eh = find_reg_note (i2, REG_EH_REGION, NULL_RTX)) + && (eh_lp = INTVAL (XEXP (eh, 0))) < 0 + && eh_lp != INT_MIN) + || (i2 + && (eh = find_reg_note (i2, REG_EH_REGION, NULL_RTX)) + && (eh_lp = INTVAL (XEXP (eh, 0))) < 0 + && eh_lp != INT_MIN) + || (i1 + && (eh = find_reg_note (i1, REG_EH_REGION, NULL_RTX)) + && (eh_lp = INTVAL (XEXP (eh, 0))) < 0 + && eh_lp != INT_MIN) + || (i0 + && (eh = find_reg_note (i0, REG_EH_REGION, NULL_RTX)) + && (eh_lp = INTVAL (XEXP (eh, 0))) < 0 + && eh_lp != INT_MIN)) + { + if (dump_file && (dump_flags & TDF_DETAILS)) + fprintf (dump_file, "Can't combine insn in must-not-throw " + "EH region into i3 which can throws\n"); + undo_all (); + return 0; + } + } + } + /* Record whether i2 and i3 are trivial moves. */ i2_was_move = is_just_move (i2); i3_was_move = is_just_move (i3); @@ -14175,23 +14214,56 @@ distribute_notes (rtx notes, rtx_insn *from_insn, rtx_insn *i3, rtx_insn *i2, break; case REG_EH_REGION: - /* These notes must remain with the call or trapping instruction. */ - if (CALL_P (i3)) - place = i3; - else if (i2 && CALL_P (i2)) - place = i2; - else - { - gcc_assert (cfun->can_throw_non_call_exceptions); - if (may_trap_p (i3)) - place = i3; - else if (i2 && may_trap_p (i2)) - place = i2; - /* ??? Otherwise assume we've combined things such that we - can now prove that the instructions can't trap. Drop the - note in this case. */ - } - break; + { + /* This handling needs to be kept in sync with the + prerequesite checking in try_combine. */ + int lp_nr = INTVAL (XEXP (note, 0)); + /* A REG_EH_REGION note transfering control can only ever come + from i3 and it has to stay there. */ + if (lp_nr > 0) + { + gcc_assert (from_insn == i3); + if (CALL_P (i3)) + place = i3; + else + { + gcc_assert (cfun->can_throw_non_call_exceptions); + /* If i3 can still trap preserve the note, otherwise we've + combined things such that we can now prove that the + instructions can't trap. Drop the note in this case. */ + if (may_trap_p (i3)) + place = i3; + } + } + else if (lp_nr == 0 || lp_nr == INT_MIN) + { + /* nothrow notes can be dropped but we preserve + those on calls. */ + if (from_insn == i3 && CALL_P (i3)) + place = i3; + } + else + { + /* Distribute must-not-throw notes to all resulting + insns and just pick the first. */ + if (!find_reg_note (i3, REG_EH_REGION, NULL_RTX) + && (CALL_P (i3) + || (cfun->can_throw_non_call_exceptions + && may_trap_p (i3)))) + place = i3; + if (i2 + && !find_reg_note (i2, REG_EH_REGION, NULL_RTX) + && cfun->can_throw_non_call_exceptions + && may_trap_p (i2)) + { + if (place) + place2 = i2; + else + place = i2; + } + } + break; + } case REG_ARGS_SIZE: /* ??? How to distribute between i3-i1. Assume i3 contains the diff --git a/gcc/testsuite/gcc.dg/torture/pr105231.c b/gcc/testsuite/gcc.dg/torture/pr105231.c new file mode 100644 index 00000000000..50459219c08 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/pr105231.c @@ -0,0 +1,15 @@ +/* { dg-do compile } */ +/* { dg-require-effective-target int32plus } */ +/* { dg-require-effective-target dfp } */ +/* { dg-additional-options "-fsanitize-coverage=trace-pc -fnon-call-exceptions --param=max-cse-insns=1 -frounding-math" } */ +/* { dg-additional-options "-mstack-arg-probe" { target x86_64-*-* i?86-*-* } } */ + +void baz (int *); +void bar (double, double, _Decimal64); + +void +foo (void) +{ + int s __attribute__((cleanup (baz))); + bar (0xfffffffffffffffe, 0xebf3fff2fbebaf7f, 0xffffffffffffff); +}