From patchwork Tue Apr 18 09:06:36 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Aldy Hernandez X-Patchwork-Id: 67888 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 C92CC3857738 for ; Tue, 18 Apr 2023 09:07:18 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org C92CC3857738 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1681808838; bh=XHCwG9Mmg1niJyrnebE6ax2roYnQwE3mmx4RS5eVHNA=; h=To:Cc:Subject:Date:List-Id:List-Unsubscribe:List-Archive: List-Post:List-Help:List-Subscribe:From:Reply-To:From; b=YBHmy47u87P/f4VIAPftwlDmrolVWCaRCvTPIKDRnubxjyRvGNk+BBysFPkhsnDOl 56jSDLWGM/mjyiCwRXp6QhY0X+gY3Ckj/QnWnCFWSFeifp6ugLPYJEHNa64hVVzMSn +Y4LhSRikniU5CE5NZV7ZyuL2Uhc6C5fE3TyiNSA= 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.129.124]) by sourceware.org (Postfix) with ESMTPS id 3C6C3385802F for ; Tue, 18 Apr 2023 09:06:50 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 3C6C3385802F 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-601-pzta7g22NWiA69AFlRJ1Dw-1; Tue, 18 Apr 2023 05:06:46 -0400 X-MC-Unique: pzta7g22NWiA69AFlRJ1Dw-1 Received: from smtp.corp.redhat.com (int-mx01.intmail.prod.int.rdu2.redhat.com [10.11.54.1]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id 9438C2805586; Tue, 18 Apr 2023 09:06:46 +0000 (UTC) Received: from abulafia.quesejoda.com (unknown [10.39.194.164]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 2C21440C83A9; Tue, 18 Apr 2023 09:06:45 +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 33I96hJA253163 (version=TLSv1.3 cipher=TLS_AES_256_GCM_SHA384 bits=256 verify=NOT); Tue, 18 Apr 2023 11:06:43 +0200 Received: (from aldyh@localhost) by abulafia.quesejoda.com (8.17.1/8.17.1/Submit) id 33I96hWo253162; Tue, 18 Apr 2023 11:06:43 +0200 To: GCC patches Cc: Andrew MacLeod , Richard Biener , Aldy Hernandez Subject: [PATCH] Add support for vrange streaming. Date: Tue, 18 Apr 2023 11:06:36 +0200 Message-Id: <20230418090637.253140-1-aldyh@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 3.1 on 10.11.54.1 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com X-Spam-Status: No, score=-11.6 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, RCVD_IN_MSPIKE_H2, 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+patchwork=sourceware.org@gcc.gnu.org Sender: "Gcc-patches" I think it's time for the ranger folk to start owning range streaming instead of passes (IPA, etc) doing their own thing. I have plans for overhauling the IPA code later this cycle to support generic ranges, and I'd like to start cleaning up the streaming and hashing interface. This patch adds generic streaming support for vrange. I'd appreciate another set of eyes. Thoughts? gcc/ChangeLog: * data-streamer-in.cc (streamer_read_real_value): New. (streamer_read_value_range): New. * data-streamer-out.cc (streamer_write_real_value): New. (streamer_write_vrange): New. * data-streamer.h (streamer_write_vrange): New. (streamer_read_value_range): New. * value-range.h (class frange): Mark streamer_write_vrange and streamer_read_value_range as friends. --- gcc/data-streamer-in.cc | 56 ++++++++++++++++++++++++++++++++++++++++ gcc/data-streamer-out.cc | 48 ++++++++++++++++++++++++++++++++++ gcc/data-streamer.h | 3 +++ gcc/value-range.h | 4 +++ 4 files changed, 111 insertions(+) diff --git a/gcc/data-streamer-in.cc b/gcc/data-streamer-in.cc index 8ebcac43479..76954b12c95 100644 --- a/gcc/data-streamer-in.cc +++ b/gcc/data-streamer-in.cc @@ -28,6 +28,8 @@ along with GCC; see the file COPYING3. If not see #include "gimple.h" #include "cgraph.h" #include "data-streamer.h" +#include "value-range.h" +#include "streamer-hooks.h" /* Read a string from the string table in DATA_IN using input block IB. Write the length to RLEN. */ @@ -206,6 +208,60 @@ streamer_read_gcov_count (class lto_input_block *ib) return ret; } +/* Read REAL_VALUE_TYPE from IB. */ + +void +streamer_read_real_value (class lto_input_block *ib, REAL_VALUE_TYPE *r) +{ + struct bitpack_d bp = streamer_read_bitpack (ib); + bp_unpack_real_value (&bp, r); +} + +void +streamer_read_value_range (class lto_input_block *ib, data_in *data_in, + Value_Range &vr) +{ + // Read the common fields to all vranges. + value_range_kind kind = streamer_read_enum (ib, value_range_kind, VR_LAST); + gcc_checking_assert (kind != VR_UNDEFINED); + tree type = stream_read_tree (ib, data_in); + + // Initialize the Value_Range to the correct type. + vr.set_type (type); + + if (is_a (vr)) + { + irange &r = as_a (vr); + r.set_undefined (); + unsigned HOST_WIDE_INT num_pairs = streamer_read_uhwi (ib); + for (unsigned i = 0; i < num_pairs; ++i) + { + wide_int lb = streamer_read_wide_int (ib); + wide_int ub = streamer_read_wide_int (ib); + int_range<2> tmp (type, lb, ub); + r.union_ (tmp); + } + wide_int nz = streamer_read_wide_int (ib); + r.set_nonzero_bits (nz); + return; + } + if (is_a (vr)) + { + frange &r = as_a (vr); + + r.m_type = type; + streamer_read_real_value (ib, &r.m_min); + streamer_read_real_value (ib, &r.m_max); + struct bitpack_d bp = streamer_read_bitpack (ib); + r.m_pos_nan = (bool) bp_unpack_value (&bp, 1); + r.m_neg_nan = (bool) bp_unpack_value (&bp, 1); + if (flag_checking) + r.verify_range (); + return; + } + gcc_unreachable (); +} + /* Read the physical representation of a wide_int val from input block IB. */ diff --git a/gcc/data-streamer-out.cc b/gcc/data-streamer-out.cc index cd25745b8dc..888fc395d0d 100644 --- a/gcc/data-streamer-out.cc +++ b/gcc/data-streamer-out.cc @@ -28,6 +28,8 @@ along with GCC; see the file COPYING3. If not see #include "gimple.h" #include "cgraph.h" #include "data-streamer.h" +#include "value-range.h" +#include "streamer-hooks.h" /* Adds a new block to output stream OBS. */ @@ -392,6 +394,52 @@ streamer_write_data_stream (struct lto_output_stream *obs, const void *data, } } +/* Write REAL_VALUE_TYPE into OB. */ + +void +streamer_write_real_value (struct output_block *ob, const REAL_VALUE_TYPE *r) +{ + bitpack_d bp = bitpack_create (ob->main_stream); + bp_pack_real_value (&bp, r); + streamer_write_bitpack (&bp); +} + +void +streamer_write_vrange (struct output_block *ob, const vrange &v) +{ + gcc_checking_assert (!v.undefined_p ()); + + // Write the common fields to all vranges. + value_range_kind kind = v.varying_p () ? VR_VARYING : VR_RANGE; + streamer_write_enum (ob->main_stream, value_range_kind, VR_LAST, kind); + stream_write_tree (ob, v.type (), true); + + if (is_a (v)) + { + const irange &r = as_a (v); + streamer_write_uhwi (ob, r.num_pairs ()); + for (unsigned i = 0; i < r.num_pairs (); ++i) + { + streamer_write_wide_int (ob, r.lower_bound (i)); + streamer_write_wide_int (ob, r.upper_bound (i)); + } + streamer_write_wide_int (ob, r.get_nonzero_bits ()); + return; + } + if (is_a (v)) + { + const frange &r = as_a (v); + streamer_write_real_value (ob, &r.m_min); + streamer_write_real_value (ob, &r.m_max); + bitpack_d bp = bitpack_create (ob->main_stream); + bp_pack_value (&bp, r.m_pos_nan, 1); + bp_pack_value (&bp, r.m_neg_nan, 1); + streamer_write_bitpack (&bp); + return; + } + gcc_unreachable (); +} + /* Emit the physical representation of wide_int VAL to output block OB. */ void diff --git a/gcc/data-streamer.h b/gcc/data-streamer.h index 19c9d6ea606..7e69eb9992b 100644 --- a/gcc/data-streamer.h +++ b/gcc/data-streamer.h @@ -75,6 +75,7 @@ void streamer_write_data_stream (struct lto_output_stream *, const void *, size_t); void streamer_write_wide_int (struct output_block *, const wide_int &); void streamer_write_widest_int (struct output_block *, const widest_int &); +void streamer_write_vrange (struct output_block *, const class vrange &); /* In data-streamer-in.cc */ const char *streamer_read_string (class data_in *, class lto_input_block *); @@ -91,6 +92,8 @@ poly_int64 streamer_read_poly_int64 (class lto_input_block *); gcov_type streamer_read_gcov_count (class lto_input_block *); wide_int streamer_read_wide_int (class lto_input_block *); widest_int streamer_read_widest_int (class lto_input_block *); +void streamer_read_value_range (class lto_input_block *, class data_in *, + class Value_Range &); /* Returns a new bit-packing context for bit-packing into S. */ inline struct bitpack_d diff --git a/gcc/value-range.h b/gcc/value-range.h index f8aa0ca7bec..e56df9db901 100644 --- a/gcc/value-range.h +++ b/gcc/value-range.h @@ -328,6 +328,10 @@ class frange : public vrange { friend class frange_storage_slot; friend class vrange_printer; + friend void streamer_write_vrange (struct output_block *, const vrange &); + friend void streamer_read_value_range (class lto_input_block *, + class data_in *, + class Value_Range &); public: frange (); frange (const frange &);