From patchwork Fri Jun 3 07:32:17 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Aldy Hernandez X-Patchwork-Id: 1638618 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: bilbo.ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.a=rsa-sha256 header.s=default header.b=bHlycPFM; dkim-atps=neutral Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=2620:52:3:1:0:246e:9693:128c; helo=sourceware.org; envelope-from=gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=) Received: from sourceware.org (server2.sourceware.org [IPv6:2620:52:3:1:0:246e:9693:128c]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits) server-digest SHA256) (No client certificate requested) by bilbo.ozlabs.org (Postfix) with ESMTPS id 4LDvkz13ztz9s0w for ; Fri, 3 Jun 2022 17:33:47 +1000 (AEST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id DE53A38391AE for ; Fri, 3 Jun 2022 07:33:44 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org DE53A38391AE DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1654241624; bh=DiGrbHjw5wsWEnrTWJHKXVuzI7ueOgbNAFu8LZAABOc=; h=To:Subject:Date:List-Id:List-Unsubscribe:List-Archive:List-Post: List-Help:List-Subscribe:From:Reply-To:From; b=bHlycPFM4q+/eWFT4qPUed/5Tcrwrv7ywyFbSHfBDGKVeiwYK9rlSlPvJ0fXqzwJg kh1Srrx6BZycxFX0EjYPzC6cs2OHoEmZsov3MP3ZDWe9tZFwUQq7bJYENVvj9vngft X8VavQkpS+ZYnTOP3oxzbgRrD6z4XlH6zH0Vj0+k= X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by sourceware.org (Postfix) with ESMTPS id ED9893839197 for ; Fri, 3 Jun 2022 07:32:27 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org ED9893839197 Received: from mimecast-mx02.redhat.com (mx3-rdu2.redhat.com [66.187.233.73]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-638-QFW8tXUsOWS_5cKO3o0UZA-1; Fri, 03 Jun 2022 03:32:26 -0400 X-MC-Unique: QFW8tXUsOWS_5cKO3o0UZA-1 Received: from smtp.corp.redhat.com (int-mx08.intmail.prod.int.rdu2.redhat.com [10.11.54.8]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id 31CFE3C025AC for ; Fri, 3 Jun 2022 07:32:26 +0000 (UTC) Received: from abulafia.quesejoda.com (unknown [10.39.192.79]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 7FCC0C15E72; Fri, 3 Jun 2022 07:32:25 +0000 (UTC) Received: from abulafia.quesejoda.com (localhost [127.0.0.1]) by abulafia.quesejoda.com (8.17.1/8.17.1) with ESMTPS id 2537WMB02683104 (version=TLSv1.3 cipher=TLS_AES_256_GCM_SHA384 bits=256 verify=NOT); Fri, 3 Jun 2022 09:32:22 +0200 Received: (from aldyh@localhost) by abulafia.quesejoda.com (8.17.1/8.17.1/Submit) id 2537WMEr2683103; Fri, 3 Jun 2022 09:32:22 +0200 To: GCC patches Subject: [COMMITTED] Flesh out unsupported_range. Date: Fri, 3 Jun 2022 09:32:17 +0200 Message-Id: <20220603073219.2683070-1-aldyh@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.85 on 10.11.54.8 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com X-Spam-Status: No, score=-12.2 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_NONE, 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: Aldy Hernandez via Gcc-patches From: Aldy Hernandez Reply-To: Aldy Hernandez Errors-To: gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org Sender: "Gcc-patches" It's cleaner to have the unsupported_range fully fleshed out, instead of trapping on every operation. It can also serve as the basis for the default vrange methods that frange and prange will inherit. This patch implements most methods, including union and intersect, to handle an UNDEFINED and a VARYING range. Since this can serve as the basis for other classes, I have moved everything into the vrange class, making the unsupported_range trivial. Note that vrange is still an abstract class, as I have purposely left the dump() method abstract. Also, I have made the unsupported range in the temporary class (Value_Range) a method field, instead of a static member. This way the temporary can set UNDEFINED and VARYING as needed. Tested on x86-64 Linux. gcc/ChangeLog: * value-range.cc (vrange::contains_p): Implement. (vrange::type): Return void. (vrange::supports_type_p): Implement. (irange::fits_p): Same. (vrange::set_undefined): Same. (irange::set_nonnegative): Same. (vrange::set_varying): Same. (vrange::union_): Same. (unsupported_range::set): Move to vrange. (unsupported_range::type): Move to vrange. (vrange::intersect): Implement for varying and undefined. (vrange::zero_p): Implement. (unsupported_range::supports_type_p): Move to vrange. (vrange::nonzero_p): Implement. (unsupported_range::set_undefined): Move to vrange. (unsupported_range::set_varying): Same. (unsupported_range::dump): Same. (unsupported_range::union_): Same. Implement for varying and undefined. (unsupported_range::intersect): Move to vrange. (unsupported_range::zero_p): Same. (unsupported_range::nonzero_p): Same. (unsupported_range::set_nonzero): Same. (unsupported_range::set_zero): Same. (unsupported_range::set_nonnegative): Same. (unsupported_range::fits_p): Same. * value-range.h (class vrange): Remove abstract markers for most methods. (class unsupported_range): Remove most methods as they will now be inherited from vrange. --- gcc/value-range.cc | 175 +++++++++++++++++++++++---------------------- gcc/value-range.h | 44 ++++-------- 2 files changed, 106 insertions(+), 113 deletions(-) diff --git a/gcc/value-range.cc b/gcc/value-range.cc index c4bcb970094..815cb783abc 100644 --- a/gcc/value-range.cc +++ b/gcc/value-range.cc @@ -66,176 +66,183 @@ debug (const Value_Range &r) fprintf (stderr, "\n"); } -// Default implementation when none has been defined. +// Default vrange definitions. bool vrange::contains_p (tree) const { - return false; + return varying_p (); } -// Default implementation when none has been defined. - bool vrange::singleton_p (tree *) const { return false; } -// Assignment operator for generic ranges. Copying incompatible types -// is not allowed. - -vrange & -vrange::operator= (const vrange &src) +void +vrange::set (tree, tree, value_range_kind) { - if (is_a (src)) - { - as_a (*this) = as_a (src); - return *this; - } - else - gcc_unreachable (); } -// Equality operator for generic ranges. - -bool -vrange::operator== (const vrange &src) const +tree +vrange::type () const { - if (is_a (src)) - return as_a (*this) == as_a (src); - gcc_unreachable (); + return void_type_node; } bool -irange::supports_type_p (tree type) const +vrange::supports_type_p (tree) const { - return supports_p (type); + return false; } -// Return TRUE if R fits in THIS. - -bool -irange::fits_p (const vrange &r) const +void +vrange::set_undefined () { - return m_max_ranges >= as_a (r).num_pairs (); + m_kind = VR_UNDEFINED; } void -irange::set_nonnegative (tree type) +vrange::set_varying (tree) { - set (build_int_cst (type, 0), TYPE_MAX_VALUE (type)); + m_kind = VR_VARYING; } -unsupported_range::unsupported_range () +bool +vrange::union_ (const vrange &r) { - m_discriminator = VR_UNKNOWN; - set_undefined (); + if (r.undefined_p () || varying_p ()) + return false; + if (undefined_p () || r.varying_p ()) + { + operator= (r); + return true; + } + gcc_unreachable (); + return false; } -void -unsupported_range::set (tree, tree, value_range_kind) +bool +vrange::intersect (const vrange &r) { + if (undefined_p () || r.varying_p ()) + return false; + if (r.undefined_p ()) + { + set_undefined (); + return true; + } + if (varying_p ()) + { + operator= (r); + return true; + } gcc_unreachable (); + return false; } -tree -unsupported_range::type () const +bool +vrange::zero_p () const { - gcc_unreachable (); - return nullptr; + return false; } bool -unsupported_range::supports_type_p (tree) const +vrange::nonzero_p () const { return false; } void -unsupported_range::set_undefined () +vrange::set_nonzero (tree) { - m_kind = VR_UNDEFINED; } void -unsupported_range::set_varying (tree) +vrange::set_zero (tree) { - gcc_unreachable (); } void -unsupported_range::dump (FILE *file) const +vrange::set_nonnegative (tree) { - fprintf (file, "[unsupported_range] "); - if (undefined_p ()) - { - fprintf (file, "UNDEFINED"); - return; - } - if (varying_p ()) - { - fprintf (file, "VARYING"); - return; - } - gcc_unreachable (); } bool -unsupported_range::union_ (const vrange &) +vrange::fits_p (const vrange &) const { - gcc_unreachable (); - return false; + return true; } -bool -unsupported_range::intersect (const vrange &) +// Assignment operator for generic ranges. Copying incompatible types +// is not allowed. + +vrange & +vrange::operator= (const vrange &src) { - gcc_unreachable (); - return false; + if (is_a (src)) + { + as_a (*this) = as_a (src); + return *this; + } + else + gcc_unreachable (); } +// Equality operator for generic ranges. + bool -unsupported_range::zero_p () const +vrange::operator== (const vrange &src) const { + if (is_a (src)) + return as_a (*this) == as_a (src); gcc_unreachable (); - return false; } bool -unsupported_range::nonzero_p () const +irange::supports_type_p (tree type) const { - gcc_unreachable (); - return false; + return supports_p (type); } -void -unsupported_range::set_nonzero (tree) +// Return TRUE if R fits in THIS. + +bool +irange::fits_p (const vrange &r) const { - gcc_unreachable (); + return m_max_ranges >= as_a (r).num_pairs (); } void -unsupported_range::set_zero (tree) +irange::set_nonnegative (tree type) { - gcc_unreachable (); + set (build_int_cst (type, 0), TYPE_MAX_VALUE (type)); } -void -unsupported_range::set_nonnegative (tree) +unsupported_range::unsupported_range () { - gcc_unreachable (); + m_discriminator = VR_UNKNOWN; + set_undefined (); } -bool -unsupported_range::fits_p (const vrange &) const +void +unsupported_range::dump (FILE *file) const { + fprintf (file, "[unsupported_range] "); + if (undefined_p ()) + { + fprintf (file, "UNDEFINED"); + return; + } + if (varying_p ()) + { + fprintf (file, "VARYING"); + return; + } gcc_unreachable (); - return false; } -unsupported_range Value_Range::m_unsupported; - // Here we copy between any two irange's. The ranges can be legacy or // multi-ranges, and copying between any combination works correctly. diff --git a/gcc/value-range.h b/gcc/value-range.h index 69cf6c304d6..61e6a1887d5 100644 --- a/gcc/value-range.h +++ b/gcc/value-range.h @@ -73,22 +73,22 @@ class vrange template friend bool is_a (vrange &); friend class Value_Range; public: - virtual void set (tree, tree, value_range_kind = VR_RANGE) = 0; - virtual tree type () const = 0; - virtual bool supports_type_p (tree type) const = 0; - virtual void set_varying (tree type) = 0; - virtual void set_undefined () = 0; + virtual void set (tree, tree, value_range_kind = VR_RANGE); + virtual tree type () const; + virtual bool supports_type_p (tree type) const; + virtual void set_varying (tree type); + virtual void set_undefined (); virtual void dump (FILE * = stderr) const = 0; - virtual bool union_ (const vrange &) = 0; - virtual bool intersect (const vrange &) = 0; + virtual bool union_ (const vrange &); + virtual bool intersect (const vrange &); virtual bool singleton_p (tree *result = NULL) const; virtual bool contains_p (tree cst) const; - virtual bool zero_p () const = 0; - virtual bool nonzero_p () const = 0; - virtual void set_nonzero (tree type) = 0; - virtual void set_zero (tree type) = 0; - virtual void set_nonnegative (tree type) = 0; - virtual bool fits_p (const vrange &r) const = 0; + virtual bool zero_p () const; + virtual bool nonzero_p () const; + virtual void set_nonzero (tree type); + virtual void set_zero (tree type); + virtual void set_nonnegative (tree type); + virtual bool fits_p (const vrange &r) const; bool varying_p () const; bool undefined_p () const; @@ -236,27 +236,13 @@ private: }; // Unsupported temporaries may be created by ranger before it's known -// they're unsupported, or by vr_values::get_value_range. All -// operations except construction cause a trap. +// they're unsupported, or by vr_values::get_value_range. class unsupported_range : public vrange { public: unsupported_range (); - virtual void set (tree, tree, value_range_kind) override; - virtual tree type () const override; - virtual bool supports_type_p (tree type) const override; - virtual void set_varying (tree type) override; - virtual void set_undefined () override; virtual void dump (FILE *) const override; - virtual bool union_ (const vrange &) override; - virtual bool intersect (const vrange &) override; - virtual bool zero_p () const override; - virtual bool nonzero_p () const override; - virtual void set_nonzero (tree) override; - virtual void set_zero (tree) override; - virtual void set_nonnegative (tree) override; - virtual bool fits_p (const vrange &) const override; }; // Traits to implement vrange is_a<> and as_a<>. @@ -369,7 +355,7 @@ public: wide_int upper_bound () const; // For irange/prange compatability. private: void init (tree type); - static unsupported_range m_unsupported; + unsupported_range m_unsupported; vrange *m_vrange; int_range_max m_irange; DISABLE_COPY_AND_ASSIGN (Value_Range);