From patchwork Tue May 24 06:20:36 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Richard Biener X-Patchwork-Id: 54328 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 96C96385624B for ; Tue, 24 May 2022 06:21:15 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 96C96385624B DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1653373275; bh=jPApxKmNLhW/XXQU0rhmDfoQ3bGLnGazcjaiwAV0TkE=; h=Date:To:Subject:List-Id:List-Unsubscribe:List-Archive:List-Post: List-Help:List-Subscribe:From:Reply-To:From; b=U8S0+VGOFiQ2XiNodm7xOMqspEG7xFTXQ0KOn91TVjMhZxEkpVybZ7zw8J817Fb22 vjzhZgJGVkFzuYGNd6Nn/aR0vnGOfwtgv15lwetS3PPleYo8AoEBwerK23Yz9no4TQ ShMKGjQVweZxELQfZ0xuU7Cuin2CMNt3zBz4I1KY= 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 3BB0C385625F for ; Tue, 24 May 2022 06:20:38 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 3BB0C385625F 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 1AF741F91C for ; Tue, 24 May 2022 06:20:37 +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 0792813AE3 for ; Tue, 24 May 2022 06:20:37 +0000 (UTC) Received: from dovecot-director2.suse.de ([192.168.254.65]) by imap2.suse-dmz.suse.de with ESMTPSA id RRawADV5jGIhLQAAMHmgww (envelope-from ) for ; Tue, 24 May 2022 06:20:37 +0000 Date: Tue, 24 May 2022 08:20:36 +0200 (CEST) To: gcc-patches@gcc.gnu.org Subject: [PATCH] tree-optimization/100221 - improve DSE a bit MIME-Version: 1.0 Message-Id: <20220524062037.0792813AE3@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.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) 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 Errors-To: gcc-patches-bounces+patchwork=sourceware.org@gcc.gnu.org Sender: "Gcc-patches" When facing multiple PHI defs and one feeding the other we can postpone processing uses of one and thus can proceed. Bootstrapped and tested on x86_64-unknown-linux-gnu, pushed. 2022-05-20 Richard Biener PR tree-optimization/100221 * tree-ssa-dse.cc (contains_phi_arg): New function. (dse_classify_store): Postpone PHI defs that feed another PHI in defs. * gcc.dg/tree-ssa/ssa-dse-44.c: New testcase. * gcc.dg/tree-ssa/ssa-dse-45.c: Likewise. --- gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-44.c | 19 +++++++++ gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-45.c | 24 +++++++++++ gcc/tree-ssa-dse.cc | 46 +++++++++++++++++++--- 3 files changed, 84 insertions(+), 5 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-44.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-45.c diff --git a/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-44.c b/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-44.c new file mode 100644 index 00000000000..aaec41d7bdf --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-44.c @@ -0,0 +1,19 @@ +/* { dg-do link } */ +/* { dg-options "-O -fdump-tree-dse1-details" } */ + +extern void foo(void); +int a, b; +static int c; +int main() +{ + if (c) + foo (); + int *g = &c; + int **h = &g; + int ***h1 = &h; + if (a) + while (b) + b = 0; +} + +/* { dg-final { scan-tree-dump "Deleted dead store: g = &c;" "dse1" } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-45.c b/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-45.c new file mode 100644 index 00000000000..fd92d7b599a --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-45.c @@ -0,0 +1,24 @@ +/* { dg-do link } */ +/* { dg-options "-O" } */ + +extern void foo(void); +int a, b; +static int c; +static void f() { + while (a) + for (; b; b--) + ; +} +void i() { + if (c) + foo(); + int *g = &c; + { + int **h[1] = {&g}; + f(); + } +} +int main() { + i(); + return 0; +} diff --git a/gcc/tree-ssa-dse.cc b/gcc/tree-ssa-dse.cc index 881a2d0f98d..ea50de789b1 100644 --- a/gcc/tree-ssa-dse.cc +++ b/gcc/tree-ssa-dse.cc @@ -898,6 +898,17 @@ dse_optimize_redundant_stores (gimple *stmt) } } +/* Return whether PHI contains ARG as an argument. */ + +static bool +contains_phi_arg (gphi *phi, tree arg) +{ + for (unsigned i = 0; i < gimple_phi_num_args (phi); ++i) + if (gimple_phi_arg_def (phi, i) == arg) + return true; + return false; +} + /* A helper of dse_optimize_stmt. Given a GIMPLE_ASSIGN in STMT that writes to REF, classify it according to downstream uses and defs. Sets *BY_CLOBBER_P to true @@ -949,8 +960,8 @@ dse_classify_store (ao_ref *ref, gimple *stmt, return DSE_STORE_LIVE; auto_vec defs; - gimple *first_phi_def = NULL; - gimple *last_phi_def = NULL; + gphi *first_phi_def = NULL; + gphi *last_phi_def = NULL; FOR_EACH_IMM_USE_STMT (use_stmt, ui, defvar) { /* Limit stmt walking. */ @@ -973,8 +984,8 @@ dse_classify_store (ao_ref *ref, gimple *stmt, { defs.safe_push (use_stmt); if (!first_phi_def) - first_phi_def = use_stmt; - last_phi_def = use_stmt; + first_phi_def = as_a (use_stmt); + last_phi_def = as_a (use_stmt); } } /* If the statement is a use the store is not dead. */ @@ -1046,6 +1057,7 @@ dse_classify_store (ao_ref *ref, gimple *stmt, use_operand_p use_p; tree vdef = (gimple_code (def) == GIMPLE_PHI ? gimple_phi_result (def) : gimple_vdef (def)); + gphi *phi_def; /* If the path to check starts with a kill we do not need to process it further. ??? With byte tracking we need only kill the bytes currently @@ -1079,7 +1091,31 @@ dse_classify_store (ao_ref *ref, gimple *stmt, && bitmap_bit_p (visited, SSA_NAME_VERSION (PHI_RESULT (use_stmt)))))) - defs.unordered_remove (i); + { + defs.unordered_remove (i); + if (def == first_phi_def) + first_phi_def = NULL; + else if (def == last_phi_def) + last_phi_def = NULL; + } + /* If def is a PHI and one of its arguments is another PHI node still + in consideration we can defer processing it. */ + else if ((phi_def = dyn_cast (def)) + && ((last_phi_def + && phi_def != last_phi_def + && contains_phi_arg (phi_def, + gimple_phi_result (last_phi_def))) + || (first_phi_def + && phi_def != first_phi_def + && contains_phi_arg + (phi_def, gimple_phi_result (first_phi_def))))) + { + defs.unordered_remove (i); + if (phi_def == first_phi_def) + first_phi_def = NULL; + else if (phi_def == last_phi_def) + last_phi_def = NULL; + } else ++i; }