From patchwork Wed May 25 14:35:31 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Andrew MacLeod X-Patchwork-Id: 54375 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 6BF673856DC7 for ; Wed, 25 May 2022 14:36:08 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 6BF673856DC7 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1653489368; bh=RY7NXZWz8+VsehVW9+EC/Sd9qNPgxQ87j79FtAaBsJ0=; h=Date:Subject:To:References:In-Reply-To:List-Id:List-Unsubscribe: List-Archive:List-Post:List-Help:List-Subscribe:From:Reply-To:Cc: From; b=t/cuK9DHVBkhXZgJXV1leK1A6Aw8fO0GFY8dnkIkGM/wWDt5qpasT6dI5hrKC5Q9t DEioR7U03+JZqLTDDMgUB0LeFMHo4LOY8YWJDFaNPnUQtbdaHe1euxG01anPIwcamL BQS46KnqaNNR+S5qBglI9kR1cFP5ox/0BOemcxgo= 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 E0C77382F0B5 for ; Wed, 25 May 2022 14:35:36 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org E0C77382F0B5 Received: from mail-qk1-f197.google.com (mail-qk1-f197.google.com [209.85.222.197]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-199-3-nTFqv2OdSLajo2swQLYQ-1; Wed, 25 May 2022 10:35:34 -0400 X-MC-Unique: 3-nTFqv2OdSLajo2swQLYQ-1 Received: by mail-qk1-f197.google.com with SMTP id z13-20020a05620a100d00b006a3870a404bso6541421qkj.17 for ; Wed, 25 May 2022 07:35:34 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:message-id:date:mime-version:user-agent:subject :content-language:to:cc:references:from:in-reply-to; bh=Ievzm/SbRzaKf7ID4/anqM3j+SQwviQDRPBI0toys3A=; b=lCBZb+HbvT+qYdW982HHGUCp0McupOPvDf8em1y70+ymfGcGaVZavvF2DFpgewLOOW 2sevGlwoXYq2jkGBZ3W08SqbhITqdBCbEhddHhlX7tBWGu6brfzafU1BWH2UUZLjrH9R ENcUebVcqK85EN9to5p1FzbbtwWLoFz0c5tnU3MMiL+/+k5lr26J7CbGef7I1tkeYoSb WRvne0yDmyeZlL/gy0EVp0lThL4M71gHKd21zH2Kzqpiu4/Qf/v96qZz7pG/kF3B9/8O UZ3NRfDxYyfHBt3ko3arwrhqdjHsTaaswWi5rhB85mfpkrFemEpg3HcxqxaRTvRLmR93 tJvg== X-Gm-Message-State: AOAM532UU8hEFpA7KD3ojW5yjS7K3e1PFw4isHnqcwHKk5kyMzYrQvY2 Xi+6VSf74IJahMdZl9H53jb79x9zwXH1gQTEDyTwj8XHWN3n/t+aY13jDPREhSXyR1Fn41ytYdY CMvSOGAQsIu+/9ZsavA== X-Received: by 2002:ae9:f712:0:b0:6a3:4797:1d23 with SMTP id s18-20020ae9f712000000b006a347971d23mr18627543qkg.300.1653489334200; Wed, 25 May 2022 07:35:34 -0700 (PDT) X-Google-Smtp-Source: ABdhPJy4ktKk0lKkOogKSiU9N8SSJ1awyY84xHw5T8F9cqzk6EdJpE+UH7TD9EqOgXWVmT153hD0Fw== X-Received: by 2002:ae9:f712:0:b0:6a3:4797:1d23 with SMTP id s18-20020ae9f712000000b006a347971d23mr18627517qkg.300.1653489333808; Wed, 25 May 2022 07:35:33 -0700 (PDT) Received: from ?IPV6:2607:fea8:a261:5e00::616d? ([2607:fea8:a261:5e00::616d]) by smtp.gmail.com with ESMTPSA id k5-20020a37ba05000000b006a39da89f32sm1308282qkf.68.2022.05.25.07.35.32 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Wed, 25 May 2022 07:35:32 -0700 (PDT) Message-ID: <42194086-c1e5-2817-c14b-e5247f324ca3@redhat.com> Date: Wed, 25 May 2022 10:35:31 -0400 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:91.0) Gecko/20100101 Thunderbird/91.9.1 Subject: [COMMITTED] Use infer instead of side-effect for ranges. To: Bernhard Reutner-Fischer , gcc-patches@gcc.gnu.org, Segher Boessenkool , Eric Botcazou References: <18d5bea-e46c-e2f5-1495-ab55ddff6c47@ispras.ru> <11982059.O9o76ZdvQC@fomalhaut> <20220520143920.GF25951@gate.crashing.org> <4D02CEE1-16B3-49A2-8027-90B48EB9534D@gmail.com> In-Reply-To: <4D02CEE1-16B3-49A2-8027-90B48EB9534D@gmail.com> X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Language: en-CA X-Spam-Status: No, score=-13.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_LOW, 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: Andrew MacLeod via Gcc-patches From: Andrew MacLeod Reply-To: Andrew MacLeod Cc: Alexander Monakov Errors-To: gcc-patches-bounces+patchwork=sourceware.org@gcc.gnu.org Sender: "Gcc-patches" On 5/20/22 15:18, Bernhard Reutner-Fischer via Gcc-patches wrote: > On 20 May 2022 16:39:20 CEST, Segher Boessenkool wrote: >> On Fri, May 20, 2022 at 10:11:32AM +0200, Eric Botcazou wrote: >>>> I suggest 'deduce', 'deduction', 'deducing a range'. What the code is >>>> actually doing is deducing that 'b' in 'a / b' cannot be zero. Function in >>>> GCC might be called like 'deduce_ranges_from_stmt'. >>> Or "infer", "inference", "inferring a range". >> "Infer" is great here, yes! >> >> infer (verb): >> deduce or conclude (something) from evidence and reasoning rather than >> from explicit statements >> >> It has exactly the connotation wanted here, I would say. > Infer, deduct, refine > Sound all plausible, a native speaker should probably help decide the bikeshed :-) > thanks, > Executive decision made. gimple-range-side-effect.{h,cc}   -> gimple-range-infer.{h,cc} class stmt_side_effects  -->  class gimple_infer_range class side_effect_manager  -->  class infer_range_manager various APIs/comments with the term "side effect"  renamed to "infer range" or some variation of tense. Bootstraps from scratch on x86_64-pc-linux-gnu with no regressions.  pushed. Andrew commit 156d7d8dbc8d65d3958486bc4112a7279935e47d Author: Andrew MacLeod Date: Tue May 24 11:32:42 2022 -0400 Use infer instead of side-effect for ranges. Rename the files and classes to reflect the term infer rather than side-effect. * Makefile.in (OBJS): Use gimple-range-infer.o. * gimple-range-cache.cc (ranger_cache::fill_block_cache): Change msg. (ranger_cache::range_from_dom): Rename var side_effect to infer. (ranger_cache::apply_inferred_ranges): Rename from apply_side_effects. * gimple-range-cache.h: Include gimple-range-infer.h. (class ranger_cache): Adjust prototypes, use infer_range_manager. * gimple-range-infer.cc: Rename from gimple-range-side-effects.cc. (gimple_infer_range::*): Rename from stmt_side_effects. (infer_range_manager::*): Rename from side_effect_manager. * gimple-range-side-effect.cc: Rename. * gimple-range-side-effect.h: Rename. * gimple-range-infer.h: Rename from gimple-range-side-effects.h. (class gimple_infer_range): Rename from stmt_side_effects. (class infer_range_manager): Rename from side_effect_manager. * gimple-range.cc (gimple_ranger::register_inferred_ranges): Rename from register_side_effects. * gimple-range.h (register_inferred_ranges): Adjust prototype. * range-op.h: Adjust comment. * tree-vrp.cc (rvrp_folder::pre_fold_bb): Use register_inferred_ranges. (rvrp_folder::post_fold_bb): Use register_inferred_ranges. diff --git a/gcc/Makefile.in b/gcc/Makefile.in index 97e5450ecb5..731d8dd2a69 100644 --- a/gcc/Makefile.in +++ b/gcc/Makefile.in @@ -1410,7 +1410,7 @@ OBJS = \ gimple-range-edge.o \ gimple-range-fold.o \ gimple-range-gori.o \ - gimple-range-side-effect.o \ + gimple-range-infer.o \ gimple-range-trace.o \ gimple-ssa-backprop.o \ gimple-ssa-evrp.o \ diff --git a/gcc/gimple-range-cache.cc b/gcc/gimple-range-cache.cc index c726393b380..5d5e2bfd0c3 100644 --- a/gcc/gimple-range-cache.cc +++ b/gcc/gimple-range-cache.cc @@ -944,7 +944,7 @@ bool ranger_cache::edge_range (irange &r, edge e, tree name, enum rfd_mode mode) { exit_range (r, name, e->src, mode); - // If this is not an abnormal edge, check for side effects on exit. + // If this is not an abnormal edge, check for inferred ranges on exit. if ((e->flags & (EDGE_EH | EDGE_ABNORMAL)) == 0) m_exit.maybe_adjust_range (r, name, e->src); int_range_max er; @@ -1251,12 +1251,12 @@ ranger_cache::fill_block_cache (tree name, basic_block bb, basic_block def_bb) } // Regardless of whether we have visited pred or not, if the - // pred has side_effects, revisit this block. + // pred has inferred ranges, revisit this block. // Don't search the DOM tree. if (m_exit.has_range_p (name, pred)) { if (DEBUG_RANGE_CACHE) - fprintf (dump_file, "side effect: update "); + fprintf (dump_file, "Inferred range: update "); m_update->add (node); } @@ -1317,8 +1317,8 @@ ranger_cache::range_from_dom (irange &r, tree name, basic_block start_bb, basic_block bb; basic_block prev_bb = start_bb; - // Track any side effects seen - int_range_max side_effect (TREE_TYPE (name)); + // Track any inferred ranges seen. + int_range_max infer (TREE_TYPE (name)); // Range on entry to the DEF block should not be queried. gcc_checking_assert (start_bb != def_bb); @@ -1332,8 +1332,8 @@ ranger_cache::range_from_dom (irange &r, tree name, basic_block start_bb, bb; prev_bb = bb, bb = get_immediate_dominator (CDI_DOMINATORS, bb)) { - // Accumulate any block exit side effects. - m_exit.maybe_adjust_range (side_effect, name, bb); + // Accumulate any block exit inferred ranges. + m_exit.maybe_adjust_range (infer, name, bb); // This block has an outgoing range. if (m_gori.has_edge_range_p (name, bb)) @@ -1399,7 +1399,7 @@ ranger_cache::range_from_dom (irange &r, tree name, basic_block start_bb, if (m_gori.outgoing_edge_range_p (er, e, name, *this)) { r.intersect (er); - // If this is a normal edge, apply any side effects. + // If this is a normal edge, apply any inferred ranges. if ((e->flags & (EDGE_EH | EDGE_ABNORMAL)) == 0) m_exit.maybe_adjust_range (r, name, bb); @@ -1415,7 +1415,7 @@ ranger_cache::range_from_dom (irange &r, tree name, basic_block start_bb, // Apply non-null if appropriate. if (!has_abnormal_call_or_eh_pred_edge_p (start_bb)) - r.intersect (side_effect); + r.intersect (infer); if (DEBUG_RANGE_CACHE) { @@ -1430,14 +1430,14 @@ ranger_cache::range_from_dom (irange &r, tree name, basic_block start_bb, // any operands on stmt S to nonnull. void -ranger_cache::apply_side_effects (gimple *s) +ranger_cache::apply_inferred_ranges (gimple *s) { int_range_max r; bool update = true; basic_block bb = gimple_bb (s); - stmt_side_effects se(s); - if (se.num () == 0) + gimple_infer_range infer(s); + if (infer.num () == 0) return; // Do not update the on-netry cache for block ending stmts. @@ -1452,15 +1452,15 @@ ranger_cache::apply_side_effects (gimple *s) update = false; } - for (unsigned x = 0; x < se.num (); x++) + for (unsigned x = 0; x < infer.num (); x++) { - tree name = se.name (x); - m_exit.add_range (name, bb, se.range (x)); + tree name = infer.name (x); + m_exit.add_range (name, bb, infer.range (x)); if (update) { if (!m_on_entry.get_bb_range (r, name, bb)) exit_range (r, name, bb, RFD_READ_ONLY); - if (r.intersect (se.range (x))) + if (r.intersect (infer.range (x))) m_on_entry.set_bb_range (name, bb, r); } } diff --git a/gcc/gimple-range-cache.h b/gcc/gimple-range-cache.h index 555fe32513f..d56e56c201c 100644 --- a/gcc/gimple-range-cache.h +++ b/gcc/gimple-range-cache.h @@ -22,7 +22,7 @@ along with GCC; see the file COPYING3. If not see #define GCC_SSA_RANGE_CACHE_H #include "gimple-range-gori.h" -#include "gimple-range-side-effect.h" +#include "gimple-range-infer.h" // This class manages a vector of pointers to ssa_block ranges. It // provides the basis for the "range on entry" cache for all @@ -87,9 +87,9 @@ public: void propagate_updated_value (tree name, basic_block bb); - void apply_side_effects (gimple *s); + void apply_inferred_ranges (gimple *s); gori_compute m_gori; - side_effect_manager m_exit; + infer_range_manager m_exit; void dump_bb (FILE *f, basic_block bb); virtual void dump (FILE *f) override; diff --git a/gcc/gimple-range-side-effect.cc b/gcc/gimple-range-infer.cc similarity index 79% rename from gcc/gimple-range-side-effect.cc rename to gcc/gimple-range-infer.cc index 2c8c77dc569..8e25830849f 100644 --- a/gcc/gimple-range-side-effect.cc +++ b/gcc/gimple-range-infer.cc @@ -1,4 +1,4 @@ -/* Gimple range side effect implementation. +/* Gimple range inference implementation. Copyright (C) 2022 Free Software Foundation, Inc. Contributed by Andrew MacLeod . @@ -37,7 +37,7 @@ along with GCC; see the file COPYING3. If not see // Adapted from infer_nonnull_range_by_dereference and check_loadstore // to process nonnull ssa_name OP in S. DATA contains a pointer to a -// stmt side effects instance. +// stmt range inference instance. static bool non_null_loadstore (gimple *, tree op, tree, void *data) @@ -49,16 +49,16 @@ non_null_loadstore (gimple *, tree op, tree, void *data) if (!targetm.addr_space.zero_address_valid (as)) { tree ssa = TREE_OPERAND (op, 0); - ((stmt_side_effects *)data)->add_nonzero (ssa); + ((gimple_infer_range *)data)->add_nonzero (ssa); } } return false; } -// Add NAME and RANGE to the the side effect summary. +// Add NAME and RANGE to the the range inference summary. void -stmt_side_effects::add_range (tree name, irange &range) +gimple_infer_range::add_range (tree name, irange &range) { m_names[num_args] = name; m_ranges[num_args] = range; @@ -66,10 +66,10 @@ stmt_side_effects::add_range (tree name, irange &range) num_args++; } -// Add a nonzero range for NAME to the side effect summary. +// Add a nonzero range for NAME to the range inference summary. void -stmt_side_effects::add_nonzero (tree name) +gimple_infer_range::add_nonzero (tree name) { if (!gimple_range_ssa_p (name)) return; @@ -78,10 +78,10 @@ stmt_side_effects::add_nonzero (tree name) add_range (name, nz); } -// Process S for side effects and fill in the summary list. -// This is the routine where new side effects should be added. +// Process S for range inference and fill in the summary list. +// This is the routine where new inferred ranges should be added. -stmt_side_effects::stmt_side_effects (gimple *s) +gimple_infer_range::gimple_infer_range (gimple *s) { num_args = 0; @@ -120,7 +120,7 @@ stmt_side_effects::stmt_side_effects (gimple *s) // ------------------------------------------------------------------------- -// This class is an element in list of side effect ranges. +// This class is an element in list of infered ranges. class exit_range { @@ -134,7 +134,7 @@ public: // Otherwise return NULL. exit_range * -side_effect_manager::exit_range_head::find_ptr (tree ssa) +infer_range_manager::exit_range_head::find_ptr (tree ssa) { // Return NULL if SSA is not in this list. if (!m_names || !bitmap_bit_p (m_names, SSA_NAME_VERSION (ssa))) @@ -147,11 +147,11 @@ side_effect_manager::exit_range_head::find_ptr (tree ssa) return NULL; } -// Construct a side effects manager. DO_SEARCH indicates whether an immediate +// Construct a range infer manager. DO_SEARCH indicates whether an immediate // use scan should be made the first time a name is processed. This is for // on-demand clients who may not visit every statement and may miss uses. -side_effect_manager::side_effect_manager (bool do_search) +infer_range_manager::infer_range_manager (bool do_search) { bitmap_obstack_initialize (&m_bitmaps); m_on_exit.create (0); @@ -168,9 +168,9 @@ side_effect_manager::side_effect_manager (bool do_search) m_nonzero.safe_grow_cleared (num_ssa_names + 1); } -// Destruct a side effects manager. +// Destruct a range infer manager. -side_effect_manager::~side_effect_manager () +infer_range_manager::~infer_range_manager () { m_nonzero.release (); obstack_free (&m_list_obstack, NULL); @@ -182,7 +182,7 @@ side_effect_manager::~side_effect_manager () // the cache, creating it if necessary. const irange& -side_effect_manager::get_nonzero (tree name) +infer_range_manager::get_nonzero (tree name) { unsigned v = SSA_NAME_VERSION (name); if (v >= m_nonzero.length ()) @@ -195,10 +195,10 @@ side_effect_manager::get_nonzero (tree name) return *(m_nonzero[v]); } -// Return TRUE if NAME has a side effect range in block BB. +// Return TRUE if NAME has a range inference in block BB. bool -side_effect_manager::has_range_p (tree name, basic_block bb) +infer_range_manager::has_range_p (tree name, basic_block bb) { // Check if this is an immediate use search model. if (m_seen && !bitmap_bit_p (m_seen, SSA_NAME_VERSION (name))) @@ -213,11 +213,11 @@ side_effect_manager::has_range_p (tree name, basic_block bb) return true; } -// Return TRUE if NAME has a side effect range in block BB, and adjust range R +// Return TRUE if NAME has a range inference in block BB, and adjust range R // to include it. bool -side_effect_manager::maybe_adjust_range (irange &r, tree name, basic_block bb) +infer_range_manager::maybe_adjust_range (irange &r, tree name, basic_block bb) { if (!has_range_p (name, bb)) return false; @@ -227,10 +227,10 @@ side_effect_manager::maybe_adjust_range (irange &r, tree name, basic_block bb) return r.intersect (*(ptr->range)); } -// Add range R as a side effect for NAME in block BB. +// Add range R as an inferred range for NAME in block BB. void -side_effect_manager::add_range (tree name, basic_block bb, const irange &r) +infer_range_manager::add_range (tree name, basic_block bb, const irange &r) { if (bb->index >= (int)m_on_exit.length ()) m_on_exit.safe_grow_cleared (last_basic_block_for_fn (cfun) + 1); @@ -272,18 +272,18 @@ side_effect_manager::add_range (tree name, basic_block bb, const irange &r) m_on_exit[bb->index].head = ptr; } -// Add a non-zero side effect for NAME in block BB. +// Add a non-zero inferred range for NAME in block BB. void -side_effect_manager::add_nonzero (tree name, basic_block bb) +infer_range_manager::add_nonzero (tree name, basic_block bb) { add_range (name, bb, get_nonzero (name)); } -// Follow immediate use chains and find all side effects for NAME. +// Follow immediate use chains and find all inferred ranges for NAME. void -side_effect_manager::register_all_uses (tree name) +infer_range_manager::register_all_uses (tree name) { gcc_checking_assert (m_seen); @@ -296,15 +296,15 @@ side_effect_manager::register_all_uses (tree name) use_operand_p use_p; imm_use_iterator iter; - // Loop over each immediate use and see if it has a side effect. + // Loop over each immediate use and see if it has an inferred range. FOR_EACH_IMM_USE_FAST (use_p, iter, name) { gimple *s = USE_STMT (use_p); - stmt_side_effects se (s); - for (unsigned x = 0; x < se.num (); x++) + gimple_infer_range infer (s); + for (unsigned x = 0; x < infer.num (); x++) { - if (name == se.name (x)) - add_range (name, gimple_bb (s), se.range (x)); + if (name == infer.name (x)) + add_range (name, gimple_bb (s), infer.range (x)); } } } diff --git a/gcc/gimple-range-side-effect.h b/gcc/gimple-range-infer.h similarity index 76% rename from gcc/gimple-range-side-effect.h rename to gcc/gimple-range-infer.h index 848d94ba6d7..629436753e9 100644 --- a/gcc/gimple-range-side-effect.h +++ b/gcc/gimple-range-infer.h @@ -1,4 +1,4 @@ -/* Header file for gimple range side effects. +/* Header file for gimple range inference. Copyright (C) 2022 Free Software Foundation, Inc. Contributed by Andrew MacLeod . @@ -21,15 +21,17 @@ along with GCC; see the file COPYING3. If not see #ifndef GCC_GIMPLE_RANGE_SIDE_H #define GCC_GIMPLE_RANGE_SIDE_H -// This class manages an on-demand summary of side effects for a statement. -// It can be instantiated as required and provides a list of side effects. +// Inferred ranges are ranges which are applied to use operands as a by product +// of executing an operation. -// New side effects should added in the constructor of this class. +// This class manages an on-demand summary of inferred ranges for a statement. +// It can be instantiated as required and provides a list of inferred ranges. +// New inferred ranges should added in the constructor of this class. -class stmt_side_effects +class gimple_infer_range { public: - stmt_side_effects (gimple *s); + gimple_infer_range (gimple *s); inline unsigned num () const { return num_args; } inline tree name (unsigned index) const { gcc_checking_assert (index < num_args); return m_names[index]; } @@ -45,17 +47,17 @@ private: inline void bump_index () { if (num_args < size_limit - 1) num_args++; } }; -// This class manages a list of side effect ranges for each basic block. -// As side effects are seen, they can be registered to a block and later +// This class manages a list of inferred ranges for each basic block. +// As inferences are made, they can be registered to a block and later // queried. WHen constructed with a TRUE flag, immediate uses chains are // followed the first time a name is referenced and block populated if -// thre are any side effects. +// there are any inferred ranges. -class side_effect_manager +class infer_range_manager { public: - side_effect_manager (bool do_search); - ~side_effect_manager (); + infer_range_manager (bool do_search); + ~infer_range_manager (); void add_range (tree name, basic_block bb, const irange &r); void add_nonzero (tree name, basic_block bb); bool has_range_p (tree name, basic_block bb); diff --git a/gcc/gimple-range.cc b/gcc/gimple-range.cc index f5e9e77bc71..08a9c01e91a 100644 --- a/gcc/gimple-range.cc +++ b/gcc/gimple-range.cc @@ -446,12 +446,11 @@ gimple_ranger::fold_stmt (gimple_stmt_iterator *gsi, tree (*valueize) (tree)) return ret; } -// Called during dominator walks to register any side effects that take effect -// from this point forward. Current release is only for tracking non-null -// within a block. +// Called during dominator walks to register any inferred ranges that take +// effect from this point forward. void -gimple_ranger::register_side_effects (gimple *s) +gimple_ranger::register_inferred_ranges (gimple *s) { // First, export the LHS if it is a new global range. tree lhs = gimple_get_lhs (s); @@ -475,7 +474,7 @@ gimple_ranger::register_side_effects (gimple *s) fputc ('\n', dump_file); } } - m_cache.apply_side_effects (s); + m_cache.apply_inferred_ranges (s); } // This routine will export whatever global ranges are known to GCC diff --git a/gcc/gimple-range.h b/gcc/gimple-range.h index 13d4c77883e..c67280dc1d2 100644 --- a/gcc/gimple-range.h +++ b/gcc/gimple-range.h @@ -60,7 +60,7 @@ public: void dump_bb (FILE *f, basic_block bb); auto_edge_flag non_executable_edge_flag; bool fold_stmt (gimple_stmt_iterator *gsi, tree (*) (tree)); - void register_side_effects (gimple *s); + void register_inferred_ranges (gimple *s); protected: bool fold_range_internal (irange &r, gimple *s, tree name); void prefill_name (irange &r, tree name); diff --git a/gcc/range-op.h b/gcc/range-op.h index 5fdda326d4b..300974fbb78 100644 --- a/gcc/range-op.h +++ b/gcc/range-op.h @@ -95,7 +95,7 @@ protected: const wide_int &lh_ub, const wide_int &rh_lb, const wide_int &rh_ub) const; - // Side effect of relation for generic fold_range clients. + // Effect of relation for generic fold_range clients. virtual bool op1_op2_relation_effect (irange &lhs_range, tree type, const irange &op1_range, const irange &op2_range, diff --git a/gcc/tree-vrp.cc b/gcc/tree-vrp.cc index 0784d658567..62ae5a967f3 100644 --- a/gcc/tree-vrp.cc +++ b/gcc/tree-vrp.cc @@ -4304,7 +4304,7 @@ public: m_pta->enter (bb); for (gphi_iterator gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi)) - m_ranger->register_side_effects (gsi.phi ()); + m_ranger->register_inferred_ranges (gsi.phi ()); } void post_fold_bb (basic_block bb) override @@ -4322,7 +4322,7 @@ public: bool ret = m_simplifier.simplify (gsi); if (!ret) ret = m_ranger->fold_stmt (gsi, follow_single_use_edges); - m_ranger->register_side_effects (gsi_stmt (*gsi)); + m_ranger->register_inferred_ranges (gsi_stmt (*gsi)); return ret; }