From patchwork Tue Oct 24 17:58:05 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Richard Sandiford X-Patchwork-Id: 157655 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:ce89:0:b0:403:3b70:6f57 with SMTP id p9csp2112201vqx; Tue, 24 Oct 2023 10:59:21 -0700 (PDT) X-Google-Smtp-Source: AGHT+IHJh3Yi+++3RZpYl6dcNeZlM6m9HV/Y5669cbLQkmf/B4XU2PWkFYMNd6ndBCCsz+v4K1Fn X-Received: by 2002:ac8:5801:0:b0:418:1ba6:2b37 with SMTP id g1-20020ac85801000000b004181ba62b37mr12434573qtg.63.1698170361290; Tue, 24 Oct 2023 10:59:21 -0700 (PDT) ARC-Seal: i=2; a=rsa-sha256; t=1698170361; cv=pass; d=google.com; s=arc-20160816; b=CDPedSYq+6myUfK2BSatygPCNw4/Z35LIwJMset7qVHYU26fphxz6QLSvNXp8U9Gs+ 2Cl8LpOlWmWcfkyfjgUaj4VVX/voi4bMh5xKpaQlZMTPHKSh6/H3/Z1I5y+rE2C4SbJC 2Lg35Q3z3RWZm/7ASQzqohznl3U6DInN86D4/5HlEGkTtU5XiVy2q43iB9CaOCOjL4d2 tW7t/XUnchZvuvXHImldhD9suub2gpCKM87nAf5KtoYpBSq3tNTnFefl/XmiSiYifllc bGt9GV671uDLdFxVXd/DbRgZHVOYm7ieXalxSpJpaxQlc9EEDSE2iTchNrArFRG6zKf9 W9JA== ARC-Message-Signature: i=2; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=errors-to:list-subscribe:list-help:list-post:list-archive :list-unsubscribe:list-id:precedence:content-transfer-encoding :mime-version:references:in-reply-to:message-id:date:subject:cc:to :from:arc-filter:dmarc-filter:delivered-to; bh=NHIMV7i1gKmPTEHf9qiN6MIBNw8aTcgZ9cHA3xUqQKE=; fh=WSfZ840Wi6BqtTz8VZjapJ1yCCJ9QRCfxSVxwOS9rLc=; b=vJs9/ArGbx1sc0pdGjmleZpUl69v3xaz1LqA5I6LjnNTHqdd/BbtZfo0aR3o0XXnfh +2s/jVNAgqeuDiLb1cqIjl2EzGu9X2MLtlAp04Jor/j4ey2A0GsXcFv6OIvSgUN7c7Qq lGTzN5/83VH39paBUKANBydC499Sd4MVFwwQ6HIF+zi9zQyuFIQkuC7qEByyzfht1/Ep 02xG4e9LOfQiK+Z6Pkyv70UQvd6epZXFHgQmrFzg6E3FFP3fiNnB84EwnqkVE4fjwB51 +JMsZ+COkcjfdC/2HQGALNQJandvXhHwjWPXt9SziKEIghpQGvLpiqgzMX8wud0dxaa5 0vVA== ARC-Authentication-Results: i=2; mx.google.com; arc=pass (i=1); spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org"; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=arm.com Received: from server2.sourceware.org (server2.sourceware.org. [2620:52:3:1:0:246e:9693:128c]) by mx.google.com with ESMTPS id l13-20020a05622a050d00b0041cbed097e4si7370039qtx.227.2023.10.24.10.59.21 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 24 Oct 2023 10:59:21 -0700 (PDT) Received-SPF: pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) client-ip=2620:52:3:1:0:246e:9693:128c; Authentication-Results: mx.google.com; arc=pass (i=1); spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org"; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=arm.com Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 2679A3858005 for ; Tue, 24 Oct 2023 17:59:15 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by sourceware.org (Postfix) with ESMTP id 55CDF3857730 for ; Tue, 24 Oct 2023 17:58:34 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 55CDF3857730 Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=arm.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=arm.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 55CDF3857730 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=217.140.110.172 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1698170316; cv=none; b=K+eCCDgyltHMXA4Cbr0PKZT/wORqk4G0kNyZHWfZ3tp0eCp8jbFOAkh5Ab6U4l+6GJ+J8LCpVG8uQdxMtdVDBgeyMAQh2jqckyJNKuzHahDf15SsL67r+YlWiU2sgGz06ptVQQgeQFSqYOScyOJdXAUmGWwJ+mIZXNPk0niwWME= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1698170316; c=relaxed/simple; bh=ieOqWF7LKxxkCgUXO/i78DSUb+rcUioQpJIW5epaAcM=; h=From:To:Subject:Date:Message-Id:MIME-Version; b=VH7mpK5ivlZB31E1kWCAkpYKpLSFQ7Zr7QtjUeFvqHHgYt25TrLZMpebG0juJykM8pfcLH73kt0A7E+g2S3hXHv+aW0CNWa57neQTKrqS8Qulrw5qY92qC+9XXFMAGRHWDYR7F8d/Mm9aiy18L+Xwi95JpbmSvjv5cKC3cvqBWQ= ARC-Authentication-Results: i=1; server2.sourceware.org Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 37D502F4; Tue, 24 Oct 2023 10:59:15 -0700 (PDT) Received: from e121540-lin.manchester.arm.com (e121540-lin.manchester.arm.com [10.32.110.72]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 7B2E73F64C; Tue, 24 Oct 2023 10:58:33 -0700 (PDT) From: Richard Sandiford To: jlaw@ventanamicro.com, gcc-patches@gcc.gnu.org Cc: Richard Sandiford Subject: [PATCH 3/3] rtl-ssa: Add new helper functions Date: Tue, 24 Oct 2023 18:58:05 +0100 Message-Id: <20231024175805.3359331-4-richard.sandiford@arm.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20231024175805.3359331-1-richard.sandiford@arm.com> References: <20231024175805.3359331-1-richard.sandiford@arm.com> MIME-Version: 1.0 X-Spam-Status: No, score=-23.9 required=5.0 tests=BAYES_00, GIT_PATCH_0, KAM_DMARC_NONE, KAM_DMARC_STATUS, KAM_LAZY_DOMAIN_SECURITY, KAM_SHORT, SPF_HELO_NONE, SPF_NONE, TXREP 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.30 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1780660684725106844 X-GMAIL-MSGID: 1780660684725106844 This patch adds some RTL-SSA helper functions. They will be used by the upcoming late-combine pass. The patch contains the first non-template out-of-line function declared in movement.h, so it adds a movement.cc. I realise it seems a bit over-the-top to have a file with just one function, but it might grow in future. :) gcc/ * Makefile.in (OBJS): Add rtl-ssa/movement.o. * rtl-ssa/access-utils.h (accesses_include_nonfixed_hard_registers) (single_set_info): New functions. (remove_uses_of_def, accesses_reference_same_resource): Declare. (insn_clobbers_resources): Likewise. * rtl-ssa/accesses.cc (rtl_ssa::remove_uses_of_def): New function. (rtl_ssa::accesses_reference_same_resource): Likewise. (rtl_ssa::insn_clobbers_resources): Likewise. * rtl-ssa/movement.h (can_move_insn_p): Declare. * rtl-ssa/movement.cc: New file. --- gcc/Makefile.in | 1 + gcc/rtl-ssa/access-utils.h | 41 +++++++++++++++++++++++++ gcc/rtl-ssa/accesses.cc | 63 ++++++++++++++++++++++++++++++++++++++ gcc/rtl-ssa/movement.cc | 40 ++++++++++++++++++++++++ gcc/rtl-ssa/movement.h | 4 +++ 5 files changed, 149 insertions(+) create mode 100644 gcc/rtl-ssa/movement.cc diff --git a/gcc/Makefile.in b/gcc/Makefile.in index 7b7a4ff789a..91d6bfbea4d 100644 --- a/gcc/Makefile.in +++ b/gcc/Makefile.in @@ -1635,6 +1635,7 @@ OBJS = \ rtl-ssa/changes.o \ rtl-ssa/functions.o \ rtl-ssa/insns.o \ + rtl-ssa/movement.o \ rtl-tests.o \ rtl.o \ rtlhash.o \ diff --git a/gcc/rtl-ssa/access-utils.h b/gcc/rtl-ssa/access-utils.h index 0d7a57f843c..f078625babf 100644 --- a/gcc/rtl-ssa/access-utils.h +++ b/gcc/rtl-ssa/access-utils.h @@ -33,6 +33,20 @@ accesses_include_hard_registers (const access_array &accesses) return accesses.size () && HARD_REGISTER_NUM_P (accesses.front ()->regno ()); } +// Return true if ACCESSES includes a reference to a non-fixed hard register. +inline bool +accesses_include_nonfixed_hard_registers (access_array accesses) +{ + for (access_info *access : accesses) + { + if (!HARD_REGISTER_NUM_P (access->regno ())) + break; + if (!fixed_regs[access->regno ()]) + return true; + } + return false; +} + // Return true if sorted array ACCESSES includes an access to memory. inline bool accesses_include_memory (const access_array &accesses) @@ -246,6 +260,22 @@ last_def (def_mux mux) return mux.last_def (); } +// If INSN's definitions contain a single set, return that set, otherwise +// return null. +inline set_info * +single_set_info (insn_info *insn) +{ + set_info *set = nullptr; + for (auto def : insn->defs ()) + if (auto this_set = dyn_cast (def)) + { + if (set) + return nullptr; + set = this_set; + } + return set; +} + int lookup_use (splay_tree &, insn_info *); int lookup_def (def_splay_tree &, insn_info *); int lookup_clobber (clobber_tree &, insn_info *); @@ -539,6 +569,10 @@ insert_access (obstack_watermark &watermark, return T (insert_access_base (watermark, access1, accesses2)); } +// Return a copy of USES that drops any use of DEF. +use_array remove_uses_of_def (obstack_watermark &, use_array uses, + def_info *def); + // The underlying non-template implementation of remove_note_accesses. access_array remove_note_accesses_base (obstack_watermark &, access_array); @@ -554,4 +588,11 @@ remove_note_accesses (obstack_watermark &watermark, T accesses) return T (remove_note_accesses_base (watermark, accesses)); } +// Return true if ACCESSES1 and ACCESSES2 have at least one resource in common. +bool accesses_reference_same_resource (access_array accesses1, + access_array accesses2); + +// Return true if INSN clobbers the value of any resources in ACCESSES. +bool insn_clobbers_resources (insn_info *insn, access_array accesses); + } diff --git a/gcc/rtl-ssa/accesses.cc b/gcc/rtl-ssa/accesses.cc index 1b25ecc3e23..510545a8bad 100644 --- a/gcc/rtl-ssa/accesses.cc +++ b/gcc/rtl-ssa/accesses.cc @@ -1569,6 +1569,19 @@ rtl_ssa::insert_access_base (obstack_watermark &watermark, return builder.finish (); } +// See the comment above the declaration. +use_array +rtl_ssa::remove_uses_of_def (obstack_watermark &watermark, use_array uses, + def_info *def) +{ + access_array_builder uses_builder (watermark); + uses_builder.reserve (uses.size ()); + for (use_info *use : uses) + if (use->def () != def) + uses_builder.quick_push (use); + return use_array (uses_builder.finish ()); +} + // See the comment above the declaration. access_array rtl_ssa::remove_note_accesses_base (obstack_watermark &watermark, @@ -1587,6 +1600,56 @@ rtl_ssa::remove_note_accesses_base (obstack_watermark &watermark, return accesses; } +// See the comment above the declaration. +bool +rtl_ssa::accesses_reference_same_resource (access_array accesses1, + access_array accesses2) +{ + auto i1 = accesses1.begin (); + auto end1 = accesses1.end (); + auto i2 = accesses2.begin (); + auto end2 = accesses2.end (); + + while (i1 != end1 && i2 != end2) + { + access_info *access1 = *i1; + access_info *access2 = *i2; + + unsigned int regno1 = access1->regno (); + unsigned int regno2 = access2->regno (); + if (regno1 == regno2) + return true; + + if (regno1 < regno2) + ++i1; + else + ++i2; + } + return false; +} + +// See the comment above the declaration. +bool +rtl_ssa::insn_clobbers_resources (insn_info *insn, access_array accesses) +{ + if (accesses_reference_same_resource (insn->defs (), accesses)) + return true; + + if (insn->is_call () && accesses_include_hard_registers (accesses)) + { + function_abi abi = insn_callee_abi (insn->rtl ()); + for (const access_info *access : accesses) + { + if (!HARD_REGISTER_NUM_P (access->regno ())) + break; + if (abi.clobbers_reg_p (access->mode (), access->regno ())) + return true; + } + } + + return false; +} + // Print RESOURCE to PP. void rtl_ssa::pp_resource (pretty_printer *pp, resource_info resource) diff --git a/gcc/rtl-ssa/movement.cc b/gcc/rtl-ssa/movement.cc new file mode 100644 index 00000000000..fcf5f8bc822 --- /dev/null +++ b/gcc/rtl-ssa/movement.cc @@ -0,0 +1,40 @@ +// RTL SSA routines for moving instructions +// Copyright (C) 2023 Free Software Foundation, Inc. +// +// This file is part of GCC. +// +// GCC is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 3, or (at your option) any later +// version. +// +// GCC is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License +// along with GCC; see the file COPYING3. If not see +// . + +#define INCLUDE_ALGORITHM +#define INCLUDE_FUNCTIONAL +#include "config.h" +#include "system.h" +#include "coretypes.h" +#include "backend.h" +#include "rtl.h" +#include "df.h" +#include "rtl-ssa.h" +#include "rtl-ssa/internals.h" +#include "rtl-ssa/internals.inl" + +using namespace rtl_ssa; + +// See the comment above the declaration. +bool +rtl_ssa::can_move_insn_p (insn_info *insn) +{ + return (!control_flow_insn_p (insn->rtl ()) + && !may_trap_p (PATTERN (insn->rtl ()))); +} diff --git a/gcc/rtl-ssa/movement.h b/gcc/rtl-ssa/movement.h index 67370947dbd..ec076db406f 100644 --- a/gcc/rtl-ssa/movement.h +++ b/gcc/rtl-ssa/movement.h @@ -19,6 +19,10 @@ namespace rtl_ssa { +// Return true if INSN can in principle be moved around, and if RTL-SSA +// has enough information to do that. +bool can_move_insn_p (insn_info *); + // Restrict movement range RANGE so that the instruction is placed later // than INSN. (The movement range is the range of instructions after which // an instruction can be placed.)