From patchwork Mon Jun 17 11:19:20 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Aldy Hernandez X-Patchwork-Id: 1948600 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@legolas.ozlabs.org Authentication-Results: legolas.ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=redhat.com header.i=@redhat.com header.a=rsa-sha256 header.s=mimecast20190719 header.b=Sma9uJB0; dkim-atps=neutral Authentication-Results: legolas.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=2620:52:3:1:0:246e:9693:128c; helo=server2.sourceware.org; envelope-from=gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=patchwork.ozlabs.org) Received: from server2.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 ECDSA (secp384r1) server-digest SHA384) (No client certificate requested) by legolas.ozlabs.org (Postfix) with ESMTPS id 4W2nVP1c28z20Ws for ; Mon, 17 Jun 2024 21:20:11 +1000 (AEST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 19B9C3858C32 for ; Mon, 17 Jun 2024 11:20:09 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from us-smtp-delivery-44.mimecast.com (us-smtp-delivery-44.mimecast.com [207.211.30.44]) by sourceware.org (Postfix) with ESMTPS id 600A73858C31 for ; Mon, 17 Jun 2024 11:19:39 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 600A73858C31 Authentication-Results: sourceware.org; dmarc=fail (p=none dis=none) header.from=redhat.com Authentication-Results: sourceware.org; spf=none smtp.mailfrom=localhost.redhat.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 600A73858C31 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=207.211.30.44 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1718623185; cv=none; b=uDRe+OZGQJ1mJQJiJbpuPkdnsA4JOjRiaU56HzkwsANuXne0O+MyAuAffCNut0C/KqpeRQyzDVNheKbffYkr2baj+aCmNZT6jO2P81w+BGGxs8kV8lggrz13DYg4TqTHAeib0iCGpldVzcZTU3Wy334l/wZtg4DIznxdYtAZSeE= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1718623185; c=relaxed/simple; bh=kor3iEV9DZhjMNT5Vb3yUGWGoDILcnGCjukvQtz1oHU=; h=DKIM-Signature:From:To:Subject:Date:Message-ID:MIME-Version; b=dzIw07mSvipb+Q8Rkv4LSz6zOpqiudMHrLGcPVz5OMwKkSL2XOZXHcfUxQ0HNqyr6y/8MzzR6F92LHGlNNdvzF7s2Foyx2LiShg0L8YMfs3S8v09s7d7N2NOC8B+vUx2aD7/m4GHTfg4vMqvbSkU8oXZAN/Y36bA+xLTDconePg= ARC-Authentication-Results: i=1; server2.sourceware.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1718623178; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding; bh=7RzbFiUpKTR9DOiIiGwtqqnTpKgaV6LoQBHVdhgKQIY=; b=Sma9uJB0M8zPNv51Lkwv2FE9MNTHe/glFLXMd50Tl0PDxNtKUMOc3tmWCQ8JS9hzGcS6vv U1Uhsonim9RE/1q1xfSSnga4f5dn9Szy59tfp8MYp16R1i+D6V+7QLfEi708jJ2Ukhfh5H NWCbMhUM+k3RT/F/TDjn/rMjQIBCZWM= Received: from mx-prod-mc-03.mail-002.prod.us-west-2.aws.redhat.com (ec2-54-186-198-63.us-west-2.compute.amazonaws.com [54.186.198.63]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-621-e_oXlSGMP0CZ6MqVsCE45Q-1; Mon, 17 Jun 2024 07:19:35 -0400 X-MC-Unique: e_oXlSGMP0CZ6MqVsCE45Q-1 Received: from mx-prod-int-01.mail-002.prod.us-west-2.aws.redhat.com (mx-prod-int-01.mail-002.prod.us-west-2.aws.redhat.com [10.30.177.4]) (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 mx-prod-mc-03.mail-002.prod.us-west-2.aws.redhat.com (Postfix) with ESMTPS id DC20C19560B2 for ; Mon, 17 Jun 2024 11:19:33 +0000 (UTC) Received: from abulafia.quesejoda.com (unknown [10.39.195.18]) by mx-prod-int-01.mail-002.prod.us-west-2.aws.redhat.com (Postfix) with ESMTPS id CB8853000218; Mon, 17 Jun 2024 11:19:31 +0000 (UTC) Received: from abulafia.quesejoda.com (localhost [127.0.0.1]) by abulafia.quesejoda.com (8.18.1/8.17.1) with ESMTPS id 45HBJSiT1739593 (version=TLSv1.3 cipher=TLS_AES_256_GCM_SHA384 bits=256 verify=NOT); Mon, 17 Jun 2024 13:19:28 +0200 Received: (from aldyh@localhost) by abulafia.quesejoda.com (8.18.1/8.18.1/Submit) id 45HBJSpc1739592; Mon, 17 Jun 2024 13:19:28 +0200 From: Aldy Hernandez To: GCC patches Cc: Andrew MacLeod , Aldy Hernandez Subject: [COMMITTED] Rename Value_Range to value_range. Date: Mon, 17 Jun 2024 13:19:20 +0200 Message-ID: <20240617111926.1739567-1-aldyh@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 3.4.1 on 10.30.177.4 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com X-Spam-Status: No, score=-11.0 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, NO_DNS_FOR_FROM, RCVD_IN_DNSWL_LOW, RCVD_IN_SBL_CSS, 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.30 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org Now that all remaining users of value_range have been renamed to int_range<>, we can reclaim value_range as a temporary, thus removing the annoying CamelCase. gcc/ChangeLog: * data-streamer-in.cc (streamer_read_value_range): Rename Value_Range to value_range. * data-streamer.h (streamer_read_value_range): Same. * gimple-pretty-print.cc (dump_ssaname_info): Same. * gimple-range-cache.cc (ssa_block_ranges::dump): Same. (ssa_lazy_cache::merge): Same. (block_range_cache::dump): Same. (ssa_cache::merge_range): Same. (ssa_cache::dump): Same. (ranger_cache::edge_range): Same. (ranger_cache::propagate_cache): Same. (ranger_cache::fill_block_cache): Same. (ranger_cache::resolve_dom): Same. (ranger_cache::range_from_dom): Same. (ranger_cache::register_inferred_value): Same. * gimple-range-fold.cc (op1_range): Same. (op2_range): Same. (fold_relations): Same. (fold_using_range::range_of_range_op): Same. (fold_using_range::range_of_phi): Same. (fold_using_range::range_of_call): Same. (fold_using_range::condexpr_adjust): Same. (fold_using_range::range_of_cond_expr): Same. (fur_source::register_outgoing_edges): Same. * gimple-range-fold.h (gimple_range_type): Same. (gimple_range_ssa_p): Same. * gimple-range-gori.cc (gori_compute::compute_operand_range): Same. (gori_compute::logical_combine): Same. (gori_compute::refine_using_relation): Same. (gori_compute::compute_operand1_range): Same. (gori_compute::compute_operand2_range): Same. (gori_compute::compute_operand1_and_operand2_range): Same. (gori_calc_operands): Same. (gori_name_helper): Same. * gimple-range-infer.cc (gimple_infer_range::check_assume_func): Same. (gimple_infer_range::gimple_infer_range): Same. (infer_range_manager::maybe_adjust_range): Same. (infer_range_manager::add_range): Same. * gimple-range-infer.h: Same. * gimple-range-op.cc (gimple_range_op_handler::gimple_range_op_handler): Same. (gimple_range_op_handler::calc_op1): Same. (gimple_range_op_handler::calc_op2): Same. (gimple_range_op_handler::maybe_builtin_call): Same. * gimple-range-path.cc (path_range_query::internal_range_of_expr): Same. (path_range_query::ssa_range_in_phi): Same. (path_range_query::compute_ranges_in_phis): Same. (path_range_query::compute_ranges_in_block): Same. (path_range_query::add_to_exit_dependencies): Same. * gimple-range-trace.cc (debug_seed_ranger): Same. * gimple-range.cc (gimple_ranger::range_of_expr): Same. (gimple_ranger::range_on_entry): Same. (gimple_ranger::range_on_edge): Same. (gimple_ranger::range_of_stmt): Same. (gimple_ranger::prefill_stmt_dependencies): Same. (gimple_ranger::register_inferred_ranges): Same. (gimple_ranger::register_transitive_inferred_ranges): Same. (gimple_ranger::export_global_ranges): Same. (gimple_ranger::dump_bb): Same. (assume_query::calculate_op): Same. (assume_query::calculate_phi): Same. (assume_query::dump): Same. (dom_ranger::range_of_stmt): Same. * ipa-cp.cc (ipcp_vr_lattice::meet_with_1): Same. (ipa_vr_operation_and_type_effects): Same. (ipa_value_range_from_jfunc): Same. (propagate_bits_across_jump_function): Same. (propagate_vr_across_jump_function): Same. (ipcp_store_vr_results): Same. * ipa-cp.h: Same. * ipa-fnsummary.cc (evaluate_conditions_for_known_args): Same. (evaluate_properties_for_edge): Same. * ipa-prop.cc (struct ipa_vr_ggc_hash_traits): Same. (ipa_vr::get_vrange): Same. (ipa_vr::streamer_read): Same. (ipa_vr::streamer_write): Same. (ipa_vr::dump): Same. (ipa_set_jfunc_vr): Same. (ipa_compute_jump_functions_for_edge): Same. (ipcp_get_parm_bits): Same. (ipcp_update_vr): Same. (ipa_record_return_value_range): Same. (ipa_return_value_range): Same. * ipa-prop.h (ipa_return_value_range): Same. (ipa_record_return_value_range): Same. * range-op.h (range_cast): Same. * tree-ssa-dom.cc (dom_opt_dom_walker::set_global_ranges_from_unreachable_edges): Same. (cprop_operand): Same. * tree-ssa-loop-ch.cc (loop_static_stmt_p): Same. * tree-ssa-loop-niter.cc (record_nonwrapping_iv): Same. * tree-ssa-loop-split.cc (split_at_bb_p): Same. * tree-ssa-phiopt.cc (value_replacement): Same. * tree-ssa-strlen.cc (get_range): Same. * tree-ssa-threadedge.cc (hybrid_jt_simplifier::simplify): Same. (hybrid_jt_simplifier::compute_exit_dependencies): Same. * tree-ssanames.cc (set_range_info): Same. (duplicate_ssa_name_range_info): Same. * tree-vrp.cc (remove_unreachable::handle_early): Same. (remove_unreachable::remove_and_update_globals): Same. (execute_ranger_vrp): Same. * value-query.cc (range_query::value_of_expr): Same. (range_query::value_on_edge): Same. (range_query::value_of_stmt): Same. (range_query::value_on_entry): Same. (range_query::value_on_exit): Same. (range_query::get_tree_range): Same. * value-range-storage.cc (vrange_storage::set_vrange): Same. * value-range.cc (Value_Range::dump): Same. (value_range::dump): Same. (debug): Same. * value-range.h (enum value_range_discriminator): Same. (class vrange): Same. (class Value_Range): Same. (class value_range): Same. (Value_Range::Value_Range): Same. (value_range::value_range): Same. (Value_Range::~Value_Range): Same. (value_range::~value_range): Same. (Value_Range::set_type): Same. (value_range::set_type): Same. (Value_Range::init): Same. (value_range::init): Same. (Value_Range::operator=): Same. (value_range::operator=): Same. (Value_Range::operator==): Same. (value_range::operator==): Same. (Value_Range::operator!=): Same. (value_range::operator!=): Same. (Value_Range::supports_type_p): Same. (value_range::supports_type_p): Same. * vr-values.cc (simplify_using_ranges::fold_cond_with_ops): Same. (simplify_using_ranges::legacy_fold_cond): Same. --- gcc/data-streamer-in.cc | 4 +-- gcc/data-streamer.h | 2 +- gcc/gimple-pretty-print.cc | 2 +- gcc/gimple-range-cache.cc | 36 +++++++++++------------ gcc/gimple-range-fold.cc | 48 +++++++++++++++---------------- gcc/gimple-range-fold.h | 4 +-- gcc/gimple-range-gori.cc | 50 ++++++++++++++++---------------- gcc/gimple-range-infer.cc | 12 ++++---- gcc/gimple-range-infer.h | 2 +- gcc/gimple-range-op.cc | 12 ++++---- gcc/gimple-range-path.cc | 16 +++++------ gcc/gimple-range-trace.cc | 2 +- gcc/gimple-range.cc | 42 +++++++++++++-------------- gcc/ipa-cp.cc | 34 +++++++++++----------- gcc/ipa-cp.h | 2 +- gcc/ipa-fnsummary.cc | 12 ++++---- gcc/ipa-prop.cc | 26 ++++++++--------- gcc/ipa-prop.h | 10 +++---- gcc/range-op.h | 10 +++---- gcc/tree-ssa-dom.cc | 4 +-- gcc/tree-ssa-loop-ch.cc | 4 +-- gcc/tree-ssa-loop-niter.cc | 4 +-- gcc/tree-ssa-loop-split.cc | 2 +- gcc/tree-ssa-phiopt.cc | 4 +-- gcc/tree-ssa-strlen.cc | 2 +- gcc/tree-ssa-threadedge.cc | 4 +-- gcc/tree-ssanames.cc | 4 +-- gcc/tree-vrp.cc | 24 ++++++++-------- gcc/value-query.cc | 34 +++++++++++----------- gcc/value-range-storage.cc | 2 +- gcc/value-range.cc | 4 +-- gcc/value-range.h | 58 +++++++++++++++++++------------------- gcc/vr-values.cc | 6 ++-- 33 files changed, 241 insertions(+), 241 deletions(-) diff --git a/gcc/data-streamer-in.cc b/gcc/data-streamer-in.cc index 12cb10e42c0..7dce2928ef0 100644 --- a/gcc/data-streamer-in.cc +++ b/gcc/data-streamer-in.cc @@ -219,14 +219,14 @@ streamer_read_real_value (class lto_input_block *ib, REAL_VALUE_TYPE *r) void streamer_read_value_range (class lto_input_block *ib, data_in *data_in, - Value_Range &vr) + 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. + // Initialize the value_range to the correct type. vr.set_type (type); if (is_a (vr)) diff --git a/gcc/data-streamer.h b/gcc/data-streamer.h index 88f8ed5231d..6a2596134ce 100644 --- a/gcc/data-streamer.h +++ b/gcc/data-streamer.h @@ -93,7 +93,7 @@ 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 &); + class value_range &); /* Returns a new bit-packing context for bit-packing into S. */ inline struct bitpack_d diff --git a/gcc/gimple-pretty-print.cc b/gcc/gimple-pretty-print.cc index 8294465fd9f..08b823c84ef 100644 --- a/gcc/gimple-pretty-print.cc +++ b/gcc/gimple-pretty-print.cc @@ -2362,7 +2362,7 @@ dump_ssaname_info (pretty_printer *pp, tree node, int spc) if (!POINTER_TYPE_P (TREE_TYPE (node)) && SSA_NAME_RANGE_INFO (node)) { - Value_Range r (TREE_TYPE (node)); + value_range r (TREE_TYPE (node)); get_global_range_query ()->range_of_expr (r, node); pp_string (pp, "# RANGE "); pp_vrange (pp, &r); diff --git a/gcc/gimple-range-cache.cc b/gcc/gimple-range-cache.cc index efaae2ed928..d84fd1ca0e8 100644 --- a/gcc/gimple-range-cache.cc +++ b/gcc/gimple-range-cache.cc @@ -61,7 +61,7 @@ void ssa_block_ranges::dump (FILE *f) { basic_block bb; - Value_Range r (m_type); + value_range r (m_type); FOR_EACH_BB_FN (bb, cfun) if (get_bb_range (r, bb)) @@ -493,7 +493,7 @@ block_range_cache::dump (FILE *f, basic_block bb, bool print_varying) if (!gimple_range_ssa_p (ssa_name (x))) continue; - Value_Range r (TREE_TYPE (ssa_name (x))); + value_range r (TREE_TYPE (ssa_name (x))); if (m_ssa_ranges[x]->get_bb_range (r, bb)) { if (!print_varying && r.varying_p ()) @@ -519,7 +519,7 @@ block_range_cache::dump (FILE *f, basic_block bb, bool print_varying) if (!gimple_range_ssa_p (ssa_name (x))) continue; - Value_Range r (TREE_TYPE (ssa_name (x))); + value_range r (TREE_TYPE (ssa_name (x))); if (m_ssa_ranges[x]->get_bb_range (r, bb)) { if (r.varying_p ()) @@ -627,7 +627,7 @@ ssa_cache::merge_range (tree name, const vrange &r) m_tab[v] = m_range_allocator->clone (r); else { - Value_Range curr (TREE_TYPE (name)); + value_range curr (TREE_TYPE (name)); m->get_vrange (curr, TREE_TYPE (name)); // If there is no change, return false. if (!curr.intersect (r)) @@ -670,7 +670,7 @@ ssa_cache::dump (FILE *f) { if (!gimple_range_ssa_p (ssa_name (x))) continue; - Value_Range r (TREE_TYPE (ssa_name (x))); + value_range r (TREE_TYPE (ssa_name (x))); // Dump all non-varying ranges. if (get_range (r, ssa_name (x)) && !r.varying_p ()) { @@ -741,7 +741,7 @@ ssa_lazy_cache::merge (const ssa_lazy_cache &cache) EXECUTE_IF_SET_IN_BITMAP (cache.active_p, 0, x, bi) { tree name = ssa_name (x); - Value_Range r(TREE_TYPE (name)); + value_range r(TREE_TYPE (name)); cache.get_range (r, name); merge_range (ssa_name (x), r); } @@ -1195,7 +1195,7 @@ ranger_cache::edge_range (vrange &r, edge e, tree name, enum rfd_mode mode) // If this is not an abnormal edge, check for inferred ranges on exit. if ((e->flags & (EDGE_EH | EDGE_ABNORMAL)) == 0) infer_oracle ().maybe_adjust_range (r, name, e->src); - Value_Range er (TREE_TYPE (name)); + value_range er (TREE_TYPE (name)); if (gori ().edge_range_p (er, e, name, *this)) r.intersect (er); return true; @@ -1287,9 +1287,9 @@ ranger_cache::propagate_cache (tree name) edge_iterator ei; edge e; tree type = TREE_TYPE (name); - Value_Range new_range (type); - Value_Range current_range (type); - Value_Range e_range (type); + value_range new_range (type); + value_range current_range (type); + value_range e_range (type); // Process each block by seeing if its calculated range on entry is // the same as its cached value. If there is a difference, update @@ -1425,8 +1425,8 @@ ranger_cache::fill_block_cache (tree name, basic_block bb, basic_block def_bb) edge_iterator ei; edge e; tree type = TREE_TYPE (name); - Value_Range block_result (type); - Value_Range undefined (type); + value_range block_result (type); + value_range undefined (type); // At this point we shouldn't be looking at the def, entry block. gcc_checking_assert (bb != def_bb && bb != ENTRY_BLOCK_PTR_FOR_FN (cfun)); @@ -1486,7 +1486,7 @@ ranger_cache::fill_block_cache (tree name, basic_block bb, basic_block def_bb) print_generic_expr (dump_file, equiv_name, TDF_SLIM); fprintf (dump_file, "\n"); } - Value_Range equiv_range (TREE_TYPE (equiv_name)); + value_range equiv_range (TREE_TYPE (equiv_name)); if (range_from_dom (equiv_range, equiv_name, bb, RFD_READ_ONLY)) { if (rel != VREL_EQ) @@ -1539,7 +1539,7 @@ ranger_cache::fill_block_cache (tree name, basic_block bb, basic_block def_bb) FOR_EACH_EDGE (e, ei, node->preds) { basic_block pred = e->src; - Value_Range r (TREE_TYPE (name)); + value_range r (TREE_TYPE (name)); if (DEBUG_RANGE_CACHE) fprintf (dump_file, " %d->%d ",e->src->index, e->dest->index); @@ -1631,7 +1631,7 @@ ranger_cache::resolve_dom (vrange &r, tree name, basic_block bb) r.set_undefined (); edge e; edge_iterator ei; - Value_Range er (TREE_TYPE (name)); + value_range er (TREE_TYPE (name)); FOR_EACH_EDGE (e, ei, bb->preds) { // If the predecessor is dominated by this block, then there is a back @@ -1665,7 +1665,7 @@ ranger_cache::range_from_dom (vrange &r, tree name, basic_block start_bb, basic_block prev_bb = start_bb; // Track any inferred ranges seen. - Value_Range infer (TREE_TYPE (name)); + value_range infer (TREE_TYPE (name)); infer.set_varying (TREE_TYPE (name)); // Range on entry to the DEF block should not be queried. @@ -1740,7 +1740,7 @@ ranger_cache::range_from_dom (vrange &r, tree name, basic_block start_bb, // Now process any blocks wit incoming edges that nay have adjustments. while (m_workback.length () > start_limit) { - Value_Range er (TREE_TYPE (name)); + value_range er (TREE_TYPE (name)); prev_bb = m_workback.pop (); if (!single_pred_p (prev_bb)) { @@ -1793,7 +1793,7 @@ void ranger_cache::register_inferred_value (const vrange &ir, tree name, basic_block bb) { - Value_Range r (TREE_TYPE (name)); + value_range r (TREE_TYPE (name)); if (!m_on_entry.get_bb_range (r, name, bb)) exit_range (r, name, bb, RFD_READ_ONLY); if (r.intersect (ir)) diff --git a/gcc/gimple-range-fold.cc b/gcc/gimple-range-fold.cc index 52fc3f2cb04..65d31adde54 100644 --- a/gcc/gimple-range-fold.cc +++ b/gcc/gimple-range-fold.cc @@ -343,7 +343,7 @@ op1_range (vrange &r, gimple *s, const vrange &lhs, range_query *q) if (!op2_expr) return handler.calc_op1 (r, lhs); - Value_Range op2 (TREE_TYPE (op2_expr)); + value_range op2 (TREE_TYPE (op2_expr)); if (!src.get_operand (op2, op2_expr)) return false; @@ -359,7 +359,7 @@ op1_range (vrange &r, gimple *s, range_query *q) tree lhs_type = gimple_range_type (s); if (!lhs_type) return false; - Value_Range lhs_range; + value_range lhs_range; lhs_range.set_varying (lhs_type); return op1_range (r, s, lhs_range, q); } @@ -377,7 +377,7 @@ op2_range (vrange &r, gimple *s, const vrange &lhs, range_query *q) fur_stmt src (s, q); - Value_Range op1 (TREE_TYPE (handler.operand1 ())); + value_range op1 (TREE_TYPE (handler.operand1 ())); if (!src.get_operand (op1, handler.operand1 ())) return false; @@ -393,7 +393,7 @@ op2_range (vrange &r, gimple *s, range_query *q) tree lhs_type = gimple_range_type (s); if (!lhs_type) return false; - Value_Range lhs_range; + value_range lhs_range; lhs_range.set_varying (lhs_type); return op2_range (r, s, lhs_range, q); } @@ -493,7 +493,7 @@ fold_relations (gimple *s, range_query *q) tree lhs = gimple_range_ssa_p (gimple_get_lhs (s)); if (lhs) { - Value_Range vr(TREE_TYPE (lhs)); + value_range vr(TREE_TYPE (lhs)); if (f.fold_stmt (vr, s, src)) return src.trio (); } @@ -725,21 +725,21 @@ fold_using_range::range_of_range_op (vrange &r, // Certain types of builtin functions may have no arguments. if (!op1) { - Value_Range r1 (type); + value_range r1 (type); if (!handler.fold_range (r, type, r1, r1)) r.set_varying (type); return true; } - Value_Range range1 (TREE_TYPE (op1)); - Value_Range range2 (op2 ? TREE_TYPE (op2) : TREE_TYPE (op1)); + value_range range1 (TREE_TYPE (op1)); + value_range range2 (op2 ? TREE_TYPE (op2) : TREE_TYPE (op1)); if (src.get_operand (range1, op1)) { if (!op2) { // Fold range, and register any dependency if available. - Value_Range r2 (type); + value_range r2 (type); r2.set_varying (type); if (!handler.fold_range (r, type, range1, r2)) r.set_varying (type); @@ -913,8 +913,8 @@ fold_using_range::range_of_phi (vrange &r, gphi *phi, fur_source &src) { tree phi_def = gimple_phi_result (phi); tree type = gimple_range_type (phi); - Value_Range arg_range (type); - Value_Range equiv_range (type); + value_range arg_range (type); + value_range equiv_range (type); unsigned x; if (!type) @@ -1042,7 +1042,7 @@ fold_using_range::range_of_phi (vrange &r, gphi *phi, fur_source &src) class loop *l = loop_containing_stmt (phi); if (l && loop_outer (l)) { - Value_Range loop_range (type); + value_range loop_range (type); range_of_ssa_name_with_loop_info (loop_range, phi_def, l, phi, src); if (!loop_range.varying_p ()) { @@ -1089,7 +1089,7 @@ fold_using_range::range_of_call (vrange &r, gcall *call, fur_source &) if (callee && useless_type_conversion_p (TREE_TYPE (TREE_TYPE (callee)), type)) { - Value_Range val; + value_range val; if (ipa_return_value_range (val, callee)) { r.intersect (val); @@ -1107,7 +1107,7 @@ fold_using_range::range_of_call (vrange &r, gcall *call, fur_source &) // If there is an LHS, intersect that with what is known. if (gimple_range_ssa_p (lhs)) { - Value_Range def (TREE_TYPE (lhs)); + value_range def (TREE_TYPE (lhs)); gimple_range_global (def, lhs); r.intersect (def); } @@ -1155,8 +1155,8 @@ fold_using_range::condexpr_adjust (vrange &r1, vrange &r2, gimple *, tree cond, // Pick up the current values of each part of the condition. tree rhs1 = gimple_assign_rhs1 (cond_def); tree rhs2 = gimple_assign_rhs2 (cond_def); - Value_Range cl (TREE_TYPE (rhs1)); - Value_Range cr (TREE_TYPE (rhs2)); + value_range cl (TREE_TYPE (rhs1)); + value_range cr (TREE_TYPE (rhs2)); src.get_operand (cl, rhs1); src.get_operand (cr, rhs2); @@ -1165,7 +1165,7 @@ fold_using_range::condexpr_adjust (vrange &r1, vrange &r2, gimple *, tree cond, // Evaluate the value of COND_NAME on the true and false edges, using either // the op1 or op2 routines based on its location. - Value_Range cond_true (type), cond_false (type); + value_range cond_true (type), cond_false (type); if (c1) { if (!hand.op1_range (cond_false, type, range_false (), cr)) @@ -1188,14 +1188,14 @@ fold_using_range::condexpr_adjust (vrange &r1, vrange &r2, gimple *, tree cond, // Now solve for SSA1 or SSA2 if they are in the dependency chain. if (ssa1 && src.gori_ssa()->in_chain_p (ssa1, cond_name)) { - Value_Range tmp1 (TREE_TYPE (ssa1)); + value_range tmp1 (TREE_TYPE (ssa1)); if (src.gori ()->compute_operand_range (tmp1, def_stmt, cond_true, ssa1, src)) r1.intersect (tmp1); } if (ssa2 && src.gori_ssa ()->in_chain_p (ssa2, cond_name)) { - Value_Range tmp2 (TREE_TYPE (ssa2)); + value_range tmp2 (TREE_TYPE (ssa2)); if (src.gori ()->compute_operand_range (tmp2, def_stmt, cond_false, ssa2, src)) r2.intersect (tmp2); @@ -1217,9 +1217,9 @@ fold_using_range::range_of_cond_expr (vrange &r, gassign *s, fur_source &src) if (!type) return false; - Value_Range range1 (TREE_TYPE (op1)); - Value_Range range2 (TREE_TYPE (op2)); - Value_Range cond_range (TREE_TYPE (cond)); + value_range range1 (TREE_TYPE (op1)); + value_range range2 (TREE_TYPE (op2)); + value_range cond_range (TREE_TYPE (cond)); gcc_checking_assert (gimple_assign_rhs_code (s) == COND_EXPR); gcc_checking_assert (range_compatible_p (TREE_TYPE (op1), TREE_TYPE (op2))); src.get_operand (cond_range, cond); @@ -1426,7 +1426,7 @@ fur_source::register_outgoing_edges (gcond *s, irange &lhs_range, // if (a_2 < b_5) tree ssa1 = gimple_range_ssa_p (handler.operand1 ()); tree ssa2 = gimple_range_ssa_p (handler.operand2 ()); - Value_Range r1,r2; + value_range r1,r2; if (ssa1 && ssa2) { r1.set_varying (TREE_TYPE (ssa1)); @@ -1463,7 +1463,7 @@ fur_source::register_outgoing_edges (gcond *s, irange &lhs_range, continue; tree ssa1 = gimple_range_ssa_p (handler.operand1 ()); tree ssa2 = gimple_range_ssa_p (handler.operand2 ()); - Value_Range r (TREE_TYPE (name)); + value_range r (TREE_TYPE (name)); if (ssa1 && ssa2) { r1.set_varying (TREE_TYPE (ssa1)); diff --git a/gcc/gimple-range-fold.h b/gcc/gimple-range-fold.h index 491d57386f3..37c49596c33 100644 --- a/gcc/gimple-range-fold.h +++ b/gcc/gimple-range-fold.h @@ -78,7 +78,7 @@ gimple_range_type (const gimple *s) type = TREE_TYPE (type); } } - if (type && Value_Range::supports_type_p (type)) + if (type && value_range::supports_type_p (type)) return type; return NULL_TREE; } @@ -91,7 +91,7 @@ gimple_range_ssa_p (tree exp) if (exp && TREE_CODE (exp) == SSA_NAME && !SSA_NAME_IS_VIRTUAL_OPERAND (exp) && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (exp) && - Value_Range::supports_type_p (TREE_TYPE (exp))) + value_range::supports_type_p (TREE_TYPE (exp))) return exp; return NULL_TREE; } diff --git a/gcc/gimple-range-gori.cc b/gcc/gimple-range-gori.cc index 4f6073c715a..275283a424f 100644 --- a/gcc/gimple-range-gori.cc +++ b/gcc/gimple-range-gori.cc @@ -632,7 +632,7 @@ gori_compute::compute_operand_range (vrange &r, gimple *stmt, // likely to be more applicable. if (op1 && op2) { - Value_Range r1, r2; + value_range r1, r2; r1.set_varying (TREE_TYPE (op1)); r2.set_varying (TREE_TYPE (op2)); relation_kind k = handler.op1_op2_relation (lhs, r1, r2); @@ -719,8 +719,8 @@ gori_compute::compute_operand_range (vrange &r, gimple *stmt, } tree type = TREE_TYPE (name); - Value_Range op1_trange (type), op1_frange (type); - Value_Range op2_trange (type), op2_frange (type); + value_range op1_trange (type), op1_frange (type); + value_range op2_trange (type), op2_frange (type); compute_logical_operands (op1_trange, op1_frange, handler, as_a (lhs), name, src, op1, op1_in_chain); @@ -739,7 +739,7 @@ gori_compute::compute_operand_range (vrange &r, gimple *stmt, if (op1_in_chain && op2_in_chain) return compute_operand1_and_operand2_range (r, handler, lhs, name, src, vrel_ptr); - Value_Range vr; + value_range vr; gimple *src_stmt; if (op1_in_chain) { @@ -864,7 +864,7 @@ gori_compute::logical_combine (vrange &r, enum tree_code code, if (!range_is_either_true_or_false (lhs)) { bool res; - Value_Range r1 (r); + value_range r1 (r); if (logical_combine (r1, code, m_bool_zero, op1_true, op1_false, op2_true, op2_false) && logical_combine (r, code, m_bool_one, op1_true, op1_false, @@ -899,11 +899,11 @@ gori_compute::logical_combine (vrange &r, enum tree_code code, else { // The FALSE side is the union of the other 3 cases. - Value_Range ff (op1_false); + value_range ff (op1_false); ff.intersect (op2_false); - Value_Range tf (op1_true); + value_range tf (op1_true); tf.intersect (op2_false); - Value_Range ft (op1_false); + value_range ft (op1_false); ft.intersect (op2_true); r = ff; r.union_ (tf); @@ -926,11 +926,11 @@ gori_compute::logical_combine (vrange &r, enum tree_code code, { // The TRUE side of an OR operation will be the union of // the other three combinations. - Value_Range tt (op1_true); + value_range tt (op1_true); tt.intersect (op2_true); - Value_Range tf (op1_true); + value_range tf (op1_true); tf.intersect (op2_false); - Value_Range ft (op1_false); + value_range ft (op1_false); ft.intersect (op2_true); r = tt; r.union_ (tf); @@ -1051,12 +1051,12 @@ gori_compute::refine_using_relation (tree op1, vrange &op1_range, if (def_op1 == use_op) { // def_stmt has op1 in the 1st operand position. - Value_Range other_op (TREE_TYPE (def_op2)); + value_range other_op (TREE_TYPE (def_op2)); src.get_operand (other_op, def_op2); // Using op1_range as the LHS, and relation REL, evaluate op2. tree type = TREE_TYPE (def_op1); - Value_Range new_result (type); + value_range new_result (type); if (!op_handler.op1_range (new_result, type, op1_def_p ? op1_range : op2_range, other_op, relation_trio::lhs_op1 (k))) @@ -1083,12 +1083,12 @@ gori_compute::refine_using_relation (tree op1, vrange &op1_range, else if (def_op2 == use_op) { // def_stmt has op1 in the 1st operand position. - Value_Range other_op (TREE_TYPE (def_op1)); + value_range other_op (TREE_TYPE (def_op1)); src.get_operand (other_op, def_op1); // Using op1_range as the LHS, and relation REL, evaluate op2. tree type = TREE_TYPE (def_op2); - Value_Range new_result (type); + value_range new_result (type); if (!op_handler.op2_range (new_result, type, op1_def_p ? op1_range : op2_range, other_op, relation_trio::lhs_op2 (k))) @@ -1134,8 +1134,8 @@ gori_compute::compute_operand1_range (vrange &r, if (rel) trio = rel->create_trio (lhs_name, op1, op2); - Value_Range op1_range (TREE_TYPE (op1)); - Value_Range op2_range (op2 ? TREE_TYPE (op2) : TREE_TYPE (op1)); + value_range op1_range (TREE_TYPE (op1)); + value_range op2_range (op2 ? TREE_TYPE (op2) : TREE_TYPE (op1)); // Fetch the known range for op1 in this block. src.get_operand (op1_range, op1); @@ -1211,8 +1211,8 @@ gori_compute::compute_operand2_range (vrange &r, tree op2 = handler.operand2 (); tree lhs_name = gimple_get_lhs (stmt); - Value_Range op1_range (TREE_TYPE (op1)); - Value_Range op2_range (TREE_TYPE (op2)); + value_range op1_range (TREE_TYPE (op1)); + value_range op2_range (TREE_TYPE (op2)); src.get_operand (op1_range, op1); src.get_operand (op2_range, op2); @@ -1276,9 +1276,9 @@ gori_compute::compute_operand1_and_operand2_range (vrange &r, fur_source &src, value_relation *rel) { - Value_Range op_range (TREE_TYPE (name)); + value_range op_range (TREE_TYPE (name)); - Value_Range vr (TREE_TYPE (handler.operand2 ())); + value_range vr (TREE_TYPE (handler.operand2 ())); // Calculate a good a range through op2. if (!compute_operand2_range (vr, handler, lhs, src, rel)) return false; @@ -1509,8 +1509,8 @@ class gori_stmt_info : public gimple_range_op_handler { public: gori_stmt_info (vrange &lhs, gimple *stmt, range_query *q); - Value_Range op1_range; - Value_Range op2_range; + value_range op1_range; + value_range op2_range; tree ssa1; tree ssa2; }; @@ -1597,7 +1597,7 @@ gori_calc_operands (vrange &lhs, gimple *stmt, ssa_cache &r, range_query *q) if (!si) return; - Value_Range tmp; + value_range tmp; // Now evaluate operand ranges, and set them in the edge cache. // If there was already a range, leave it and do no further evaluation. if (si.ssa1 && !r.has_range (si.ssa1)) @@ -1669,7 +1669,7 @@ gori_name_helper (vrange &r, tree name, vrange &lhs, gimple *stmt, if (si.ssa2 == name) return si.calc_op2 (r, lhs, si.op1_range); - Value_Range tmp; + value_range tmp; // Now evaluate operand ranges, and set them in the edge cache. // If there was already a range, leave it and do no further evaluation. if (si.ssa1) diff --git a/gcc/gimple-range-infer.cc b/gcc/gimple-range-infer.cc index 2571a4d127f..98642e2438f 100644 --- a/gcc/gimple-range-infer.cc +++ b/gcc/gimple-range-infer.cc @@ -96,13 +96,13 @@ gimple_infer_range::check_assume_func (gcall *call) { tree op = gimple_call_arg (call, i); tree type = TREE_TYPE (op); - if (gimple_range_ssa_p (op) && Value_Range::supports_type_p (type)) + if (gimple_range_ssa_p (op) && value_range::supports_type_p (type)) { tree default_def = ssa_default_def (fun, arg); if (!default_def || type != TREE_TYPE (default_def)) continue; // Query the global range of the default def in the assume function. - Value_Range assume_range (type); + value_range assume_range (type); gimple_range_global (assume_range, default_def, fun); // If there is a non-varying result, add it as an inferred range. if (!assume_range.varying_p ()) @@ -218,14 +218,14 @@ gimple_infer_range::gimple_infer_range (gimple *s, bool use_rangeops) // query to pick up any other values. if (ssa1) { - Value_Range op1 (TREE_TYPE (ssa1)); + value_range op1 (TREE_TYPE (ssa1)); if (op1_range (op1, s, get_global_range_query ()) && !op1.varying_p ()) add_range (ssa1, op1); } else { gcc_checking_assert (ssa2); - Value_Range op2 (TREE_TYPE (ssa2)); + value_range op2 (TREE_TYPE (ssa2)); if (op2_range (op2, s, get_global_range_query ()) && !op2.varying_p ()) add_range (ssa2, op2); } @@ -355,7 +355,7 @@ infer_range_manager::maybe_adjust_range (vrange &r, tree name, basic_block bb) gcc_checking_assert (ptr); // Return true if this exit range changes R, otherwise false. tree type = TREE_TYPE (name); - Value_Range tmp (type); + value_range tmp (type); ptr->range->get_vrange (tmp, type); return r.intersect (tmp); } @@ -398,7 +398,7 @@ infer_range_manager::add_range (tree name, gimple *s, const vrange &r) if (ptr) { tree type = TREE_TYPE (name); - Value_Range cur (r), name_range (type); + value_range cur (r), name_range (type); ptr->range->get_vrange (name_range, type); // If no new info is added, just return. if (!cur.intersect (name_range)) diff --git a/gcc/gimple-range-infer.h b/gcc/gimple-range-infer.h index d2c151c4b9d..b11d28352ad 100644 --- a/gcc/gimple-range-infer.h +++ b/gcc/gimple-range-infer.h @@ -45,7 +45,7 @@ private: unsigned num_args; static const int size_limit = 10; tree m_names[size_limit]; - Value_Range m_ranges[size_limit]; + value_range m_ranges[size_limit]; inline void bump_index () { if (num_args < size_limit - 1) num_args++; } friend class non_null_wrapper; }; diff --git a/gcc/gimple-range-op.cc b/gcc/gimple-range-op.cc index 1b9a84708b9..a80b93cf063 100644 --- a/gcc/gimple-range-op.cc +++ b/gcc/gimple-range-op.cc @@ -133,7 +133,7 @@ gimple_range_op_handler::gimple_range_op_handler (gimple *s) m_op1 = gimple_cond_lhs (m_stmt); m_op2 = gimple_cond_rhs (m_stmt); // Check that operands are supported types. One check is enough. - if (Value_Range::supports_type_p (TREE_TYPE (m_op1))) + if (value_range::supports_type_p (TREE_TYPE (m_op1))) m_operator = oper.range_op (); gcc_checking_assert (m_operator); return; @@ -153,7 +153,7 @@ gimple_range_op_handler::gimple_range_op_handler (gimple *s) if (gimple_num_ops (m_stmt) >= 3) m_op2 = gimple_assign_rhs2 (m_stmt); // Check that operands are supported types. One check is enough. - if ((m_op1 && !Value_Range::supports_type_p (TREE_TYPE (m_op1)))) + if ((m_op1 && !value_range::supports_type_p (TREE_TYPE (m_op1)))) return; m_operator = oper.range_op (); gcc_checking_assert (m_operator); @@ -185,7 +185,7 @@ gimple_range_op_handler::calc_op1 (vrange &r, const vrange &lhs_range) // Unary operations require the type of the first operand in the // second range position. tree type = TREE_TYPE (operand1 ()); - Value_Range type_range (type); + value_range type_range (type); type_range.set_varying (type); return op1_range (r, type, lhs_range, type_range); } @@ -218,7 +218,7 @@ gimple_range_op_handler::calc_op1 (vrange &r, const vrange &lhs_range, op2_type = TREE_TYPE (operand2 ()); else op2_type = TREE_TYPE (operand1 ()); - Value_Range trange (op2_type); + value_range trange (op2_type); trange.set_varying (op2_type); return op1_range (r, type, lhs_range, trange, k); } @@ -243,7 +243,7 @@ gimple_range_op_handler::calc_op2 (vrange &r, const vrange &lhs_range, if (op1_range.undefined_p ()) { tree op1_type = TREE_TYPE (operand1 ()); - Value_Range trange (op1_type); + value_range trange (op1_type); trange.set_varying (op1_type); return op2_range (r, type, lhs_range, trange, k); } @@ -1228,7 +1228,7 @@ gimple_range_op_handler::maybe_builtin_call () tree type = gimple_range_type (call); if (!type) return; - if (!Value_Range::supports_type_p (type)) + if (!value_range::supports_type_p (type)) return; switch (func) diff --git a/gcc/gimple-range-path.cc b/gcc/gimple-range-path.cc index ef125a90882..f64a7a5e8ca 100644 --- a/gcc/gimple-range-path.cc +++ b/gcc/gimple-range-path.cc @@ -161,7 +161,7 @@ path_range_query::internal_range_of_expr (vrange &r, tree name, gimple *stmt) { if (TREE_CODE (name) == SSA_NAME) { - Value_Range glob (TREE_TYPE (name)); + value_range glob (TREE_TYPE (name)); gimple_range_global (glob, name); r.intersect (glob); } @@ -237,7 +237,7 @@ path_range_query::ssa_range_in_phi (vrange &r, gphi *phi) // This will get things like PHI <5(99), 6(88)>. We do this by // calling range_of_expr with no context. unsigned nargs = gimple_phi_num_args (phi); - Value_Range arg_range (TREE_TYPE (name)); + value_range arg_range (TREE_TYPE (name)); r.set_undefined (); for (size_t i = 0; i < nargs; ++i) { @@ -263,7 +263,7 @@ path_range_query::ssa_range_in_phi (vrange &r, gphi *phi) { if (m_resolve) { - Value_Range tmp (TREE_TYPE (name)); + value_range tmp (TREE_TYPE (name)); // Using both the range on entry to the path, and the // range on this edge yields significantly better // results. @@ -339,7 +339,7 @@ path_range_query::compute_ranges_in_phis (basic_block bb) if (!exit_dependency_p (name)) continue; - Value_Range r (TREE_TYPE (name)); + value_range r (TREE_TYPE (name)); if (range_defined_in_block (r, name, bb)) m_cache.set_range (name, r); } @@ -385,7 +385,7 @@ path_range_query::compute_ranges_in_block (basic_block bb) EXECUTE_IF_SET_IN_BITMAP (m_exit_dependencies, 0, i, bi) { tree name = ssa_name (i); - Value_Range r (TREE_TYPE (name)); + value_range r (TREE_TYPE (name)); if (gimple_code (SSA_NAME_DEF_STMT (name)) != GIMPLE_PHI && range_defined_in_block (r, name, bb)) @@ -417,10 +417,10 @@ path_range_query::compute_ranges_in_block (basic_block bb) EXECUTE_IF_AND_IN_BITMAP (m_exit_dependencies, exports, 0, i, bi) { tree name = ssa_name (i); - Value_Range r (TREE_TYPE (name)); + value_range r (TREE_TYPE (name)); if (gori ().edge_range_p (r, e, name, *this)) { - Value_Range cached_range (TREE_TYPE (name)); + value_range cached_range (TREE_TYPE (name)); if (get_cache (cached_range, name)) r.intersect (cached_range); @@ -477,7 +477,7 @@ bool path_range_query::add_to_exit_dependencies (tree name, bitmap dependencies) { if (TREE_CODE (name) == SSA_NAME - && Value_Range::supports_type_p (TREE_TYPE (name))) + && value_range::supports_type_p (TREE_TYPE (name))) return bitmap_set_bit (dependencies, SSA_NAME_VERSION (name)); return false; } diff --git a/gcc/gimple-range-trace.cc b/gcc/gimple-range-trace.cc index 4c3d79c5448..e1679a1bfc9 100644 --- a/gcc/gimple-range-trace.cc +++ b/gcc/gimple-range-trace.cc @@ -152,7 +152,7 @@ debug_seed_ranger (gimple_ranger &ranger) if (tree type = gimple_range_type (stmt)) { - Value_Range r (type); + value_range r (type); ranger.range_of_stmt (r, stmt); } } diff --git a/gcc/gimple-range.cc b/gcc/gimple-range.cc index be22bb4aa18..f3e4ec2d249 100644 --- a/gcc/gimple-range.cc +++ b/gcc/gimple-range.cc @@ -101,7 +101,7 @@ gimple_ranger::range_of_expr (vrange &r, tree expr, gimple *stmt) // If there is no statement, just get the global value. if (!stmt) { - Value_Range tmp (TREE_TYPE (expr)); + value_range tmp (TREE_TYPE (expr)); // If there is no global range for EXPR yet, try to evaluate it. // This call sets R to a global range regardless. if (!m_cache.get_global_range (r, expr)) @@ -158,7 +158,7 @@ gimple_ranger::range_on_entry (vrange &r, basic_block bb, tree name) if (!gimple_range_ssa_p (name)) return get_tree_range (r, name, NULL, bb, NULL); - Value_Range entry_range (TREE_TYPE (name)); + value_range entry_range (TREE_TYPE (name)); unsigned idx; if ((idx = tracer.header ("range_on_entry ("))) @@ -219,7 +219,7 @@ gimple_ranger::range_on_exit (vrange &r, basic_block bb, tree name) bool gimple_ranger::range_on_edge (vrange &r, edge e, tree name) { - Value_Range edge_range (TREE_TYPE (name)); + value_range edge_range (TREE_TYPE (name)); if (!r.supports_type_p (TREE_TYPE (name))) return false; @@ -334,7 +334,7 @@ gimple_ranger::range_of_stmt (vrange &r, gimple *s, tree name) prefill_stmt_dependencies (name); // Calculate a new value. - Value_Range tmp (TREE_TYPE (name)); + value_range tmp (TREE_TYPE (name)); fold_range_internal (tmp, s, name); // Combine the new value with the old value. This is required because @@ -412,10 +412,10 @@ gimple_ranger::prefill_stmt_dependencies (tree ssa) { // Fold and save the value for NAME. stmt = SSA_NAME_DEF_STMT (name); - Value_Range r (TREE_TYPE (name)); + value_range r (TREE_TYPE (name)); fold_range_internal (r, stmt, name); // Make sure we don't lose any current global info. - Value_Range tmp (TREE_TYPE (name)); + value_range tmp (TREE_TYPE (name)); m_cache.get_global_range (tmp, name); bool changed = tmp.intersect (r); m_cache.set_global_range (name, tmp, changed); @@ -439,7 +439,7 @@ gimple_ranger::prefill_stmt_dependencies (tree ssa) gphi *phi = dyn_cast (stmt); if (phi) { - Value_Range r (TREE_TYPE (gimple_phi_result (phi))); + value_range r (TREE_TYPE (gimple_phi_result (phi))); for (unsigned x = 0; x < gimple_phi_num_args (phi); x++) prefill_name (r, gimple_phi_arg_def (phi, x)); } @@ -451,13 +451,13 @@ gimple_ranger::prefill_stmt_dependencies (tree ssa) tree op = handler.operand2 (); if (op) { - Value_Range r (TREE_TYPE (op)); + value_range r (TREE_TYPE (op)); prefill_name (r, op); } op = handler.operand1 (); if (op) { - Value_Range r (TREE_TYPE (op)); + value_range r (TREE_TYPE (op)); prefill_name (r, op); } } @@ -494,7 +494,7 @@ gimple_ranger::register_inferred_ranges (gimple *s) tree lhs = gimple_get_lhs (s); if (lhs) { - Value_Range tmp (TREE_TYPE (lhs)); + value_range tmp (TREE_TYPE (lhs)); if (range_of_stmt (tmp, s, lhs) && !tmp.varying_p () && set_range_info (lhs, tmp) && dump_file) { @@ -532,13 +532,13 @@ gimple_ranger::register_transitive_inferred_ranges (basic_block bb) if (!gimple_range_ssa_p (lhs) || infer_oracle ().has_range_p (bb, lhs)) continue; // Pick up global value. - Value_Range g (TREE_TYPE (lhs)); + value_range g (TREE_TYPE (lhs)); range_of_expr (g, lhs); // If either dependency has an inferred range, check if recalculating // the LHS is different than the global value. If so, register it as // an inferred range as well. - Value_Range r (TREE_TYPE (lhs)); + value_range r (TREE_TYPE (lhs)); r.set_undefined (); tree name1 = gori_ssa ()->depend1 (lhs); tree name2 = gori_ssa ()->depend2 (lhs); @@ -569,7 +569,7 @@ gimple_ranger::export_global_ranges () tree name = ssa_name (x); if (!name) continue; - Value_Range r (TREE_TYPE (name)); + value_range r (TREE_TYPE (name)); if (name && !SSA_NAME_IN_FREE_LIST (name) && gimple_range_ssa_p (name) && m_cache.get_global_range (r, name) @@ -615,7 +615,7 @@ gimple_ranger::dump_bb (FILE *f, basic_block bb) tree name = ssa_name (x); if (!gimple_range_ssa_p (name) || !SSA_NAME_DEF_STMT (name)) continue; - Value_Range range (TREE_TYPE (name)); + value_range range (TREE_TYPE (name)); if (gimple_bb (SSA_NAME_DEF_STMT (name)) == bb && m_cache.get_global_range (range, name)) { @@ -639,11 +639,11 @@ gimple_ranger::dump_bb (FILE *f, basic_block bb) if (!name || !gori ().has_edge_range_p (name, e)) continue; - Value_Range range (TREE_TYPE (name)); + value_range range (TREE_TYPE (name)); if (m_cache.range_on_edge (range, e, name)) { gimple *s = SSA_NAME_DEF_STMT (name); - Value_Range tmp_range (TREE_TYPE (name)); + value_range tmp_range (TREE_TYPE (name)); // Only print the range if this is the def block, or // the on entry cache for either end of the edge is // set. @@ -797,7 +797,7 @@ assume_query::~assume_query () void assume_query::calculate_op (tree op, gimple *s, vrange &lhs, fur_source &src) { - Value_Range op_range (TREE_TYPE (op)); + value_range op_range (TREE_TYPE (op)); if (gori ().compute_operand_range (op_range, s, lhs, op, src) && !op_range.varying_p ()) { @@ -819,7 +819,7 @@ assume_query::calculate_phi (gphi *phi, vrange &lhs_range, fur_source &src) for (unsigned x= 0; x < gimple_phi_num_args (phi); x++) { tree arg = gimple_phi_arg_def (phi, x); - Value_Range arg_range (TREE_TYPE (arg)); + value_range arg_range (TREE_TYPE (arg)); if (gimple_range_ssa_p (arg)) { // A symbol arg will be the LHS value. @@ -902,10 +902,10 @@ assume_query::dump (FILE *f) if (!name || !gimple_range_ssa_p (name)) continue; tree type = TREE_TYPE (name); - if (!Value_Range::supports_type_p (type)) + if (!value_range::supports_type_p (type)) continue; - Value_Range assume_range (type); + value_range assume_range (type); if (assume_range_p (assume_range, name)) { print_generic_expr (f, name, TDF_SLIM); @@ -1106,7 +1106,7 @@ dom_ranger::range_of_stmt (vrange &r, gimple *s, tree name) } basic_block bb = gimple_bb (s); unsigned bbi = bb->index; - Value_Range vr (TREE_TYPE (name)); + value_range vr (TREE_TYPE (name)); // If there is a range on edge 0, update it. if (m_e0[bbi] && m_e0[bbi]->has_range (name)) { diff --git a/gcc/ipa-cp.cc b/gcc/ipa-cp.cc index 408166b8044..56468dc40ee 100644 --- a/gcc/ipa-cp.cc +++ b/gcc/ipa-cp.cc @@ -775,7 +775,7 @@ ipcp_vr_lattice::meet_with_1 (const vrange &other_vr) bool res; if (flag_checking) { - Value_Range save (m_vr); + value_range save (m_vr); res = m_vr.union_ (other_vr); gcc_assert (res == (m_vr != save)); } @@ -1656,7 +1656,7 @@ ipa_vr_operation_and_type_effects (vrange &dst_vr, if (!handler) return false; - Value_Range varying (dst_type); + value_range varying (dst_type); varying.set_varying (dst_type); return (handler.operand_check_p (dst_type, src_type, dst_type) @@ -1674,7 +1674,7 @@ ipa_vr_operation_and_type_effects (vrange &dst_vr, enum tree_code operation, tree dst_type, tree src_type) { - Value_Range tmp; + value_range tmp; src_vr.get_vrange (tmp); return ipa_vr_operation_and_type_effects (dst_vr, tmp, operation, dst_type, src_type); @@ -1713,14 +1713,14 @@ ipa_value_range_from_jfunc (vrange &vr, if (!(*sum->m_vr)[idx].known_p ()) return; tree vr_type = ipa_get_type (info, idx); - Value_Range srcvr; + value_range srcvr; (*sum->m_vr)[idx].get_vrange (srcvr); enum tree_code operation = ipa_get_jf_pass_through_operation (jfunc); if (TREE_CODE_CLASS (operation) == tcc_unary) { - Value_Range res (parm_type); + value_range res (parm_type); if (ipa_vr_operation_and_type_effects (res, srcvr, @@ -1730,10 +1730,10 @@ ipa_value_range_from_jfunc (vrange &vr, } else { - Value_Range op_res (vr_type); - Value_Range res (vr_type); + value_range op_res (vr_type); + value_range res (vr_type); tree op = ipa_get_jf_pass_through_operand (jfunc); - Value_Range op_vr (TREE_TYPE (op)); + value_range op_vr (TREE_TYPE (op)); range_op_handler handler (operation); ipa_range_set_and_normalize (op_vr, op); @@ -2486,7 +2486,7 @@ propagate_bits_across_jump_function (cgraph_edge *cs, int idx, } } - Value_Range vr (parm_type); + value_range vr (parm_type); if (jfunc->m_vr) { jfunc->m_vr->get_vrange (vr); @@ -2534,7 +2534,7 @@ propagate_vr_across_jump_function (cgraph_edge *cs, ipa_jump_func *jfunc, if (src_lats->m_value_range.bottom_p ()) return dest_lat->set_to_bottom (); - Value_Range vr (param_type); + value_range vr (param_type); if (TREE_CODE_CLASS (operation) == tcc_unary) ipa_vr_operation_and_type_effects (vr, src_lats->m_value_range.m_vr, @@ -2546,8 +2546,8 @@ propagate_vr_across_jump_function (cgraph_edge *cs, ipa_jump_func *jfunc, else if (!ipa_edge_within_scc (cs)) { tree op = ipa_get_jf_pass_through_operand (jfunc); - Value_Range op_vr (TREE_TYPE (op)); - Value_Range op_res (param_type); + value_range op_vr (TREE_TYPE (op)); + value_range op_res (param_type); range_op_handler handler (operation); ipa_range_set_and_normalize (op_vr, op); @@ -2576,7 +2576,7 @@ propagate_vr_across_jump_function (cgraph_edge *cs, ipa_jump_func *jfunc, { if (jfunc->m_vr) { - Value_Range jvr (param_type); + value_range jvr (param_type); if (ipa_vr_operation_and_type_effects (jvr, *jfunc->m_vr, NOP_EXPR, param_type, @@ -2595,12 +2595,12 @@ propagate_vr_across_jump_function (cgraph_edge *cs, ipa_jump_func *jfunc, if (TREE_OVERFLOW_P (val)) val = drop_tree_overflow (val); - Value_Range tmpvr (val, val); + value_range tmpvr (val, val); return dest_lat->meet_with (tmpvr); } } - Value_Range vr (param_type); + value_range vr (param_type); if (jfunc->m_vr && ipa_vr_operation_and_type_effects (vr, *jfunc->m_vr, NOP_EXPR, param_type, @@ -6359,7 +6359,7 @@ ipcp_store_vr_results (void) { if (bits) { - Value_Range tmp = plats->m_value_range.m_vr; + value_range tmp = plats->m_value_range.m_vr; tree type = ipa_get_type (info, i); irange_bitmask bm (wide_int::from (bits->get_value (), TYPE_PRECISION (type), @@ -6380,7 +6380,7 @@ ipcp_store_vr_results (void) else if (bits) { tree type = ipa_get_type (info, i); - Value_Range tmp; + value_range tmp; tmp.set_varying (type); irange_bitmask bm (wide_int::from (bits->get_value (), TYPE_PRECISION (type), diff --git a/gcc/ipa-cp.h b/gcc/ipa-cp.h index e62a09f38af..4616c61625a 100644 --- a/gcc/ipa-cp.h +++ b/gcc/ipa-cp.h @@ -230,7 +230,7 @@ private: class ipcp_vr_lattice { public: - Value_Range m_vr; + value_range m_vr; inline bool bottom_p () const; inline bool top_p () const; diff --git a/gcc/ipa-fnsummary.cc b/gcc/ipa-fnsummary.cc index 2faf2389297..b3824783406 100644 --- a/gcc/ipa-fnsummary.cc +++ b/gcc/ipa-fnsummary.cc @@ -489,7 +489,7 @@ evaluate_conditions_for_known_args (struct cgraph_node *node, && !c->agg_contents && (!val || TREE_CODE (val) != INTEGER_CST)) { - Value_Range vr (avals->m_known_value_ranges[c->operand_num]); + value_range vr (avals->m_known_value_ranges[c->operand_num]); if (!vr.undefined_p () && !vr.varying_p () && (TYPE_SIZE (c->type) == TYPE_SIZE (vr.type ()))) @@ -502,10 +502,10 @@ evaluate_conditions_for_known_args (struct cgraph_node *node, if (vr.varying_p () || vr.undefined_p ()) break; - Value_Range res (op->type); + value_range res (op->type); if (!op->val[0]) { - Value_Range varying (op->type); + value_range varying (op->type); varying.set_varying (op->type); range_op_handler handler (op->code); if (!handler @@ -515,7 +515,7 @@ evaluate_conditions_for_known_args (struct cgraph_node *node, } else if (!op->val[1]) { - Value_Range op0 (TREE_TYPE (op->val[0])); + value_range op0 (TREE_TYPE (op->val[0])); range_op_handler handler (op->code); ipa_range_set_and_normalize (op0, op->val[0]); @@ -534,7 +534,7 @@ evaluate_conditions_for_known_args (struct cgraph_node *node, if (!vr.varying_p () && !vr.undefined_p ()) { int_range<2> res; - Value_Range val_vr (TREE_TYPE (c->val)); + value_range val_vr (TREE_TYPE (c->val)); range_op_handler handler (c->code); ipa_range_set_and_normalize (val_vr, c->val); @@ -675,7 +675,7 @@ evaluate_properties_for_edge (struct cgraph_edge *e, bool inline_p, && vrp_will_run_p (caller) && ipa_is_param_used_by_ipa_predicates (callee_pi, i)) { - Value_Range vr (type); + value_range vr (type); ipa_value_range_from_jfunc (vr, caller_parms_info, e, jf, type); if (!vr.undefined_p () && !vr.varying_p ()) diff --git a/gcc/ipa-prop.cc b/gcc/ipa-prop.cc index 2d5c51298f2..7d7cb3835d2 100644 --- a/gcc/ipa-prop.cc +++ b/gcc/ipa-prop.cc @@ -80,7 +80,7 @@ struct ipa_vr_ggc_hash_traits : public ggc_cache_remove // This never get called, except in the verification code, as // ipa_get_value_range() calculates the hash itself. This // function is mostly here for completness' sake. - Value_Range vr; + value_range vr; p->get_vrange (vr); inchash::hash hstate; add_vrange (vr, hstate); @@ -165,13 +165,13 @@ ipa_vr::equal_p (const ipa_vr &o) const if (!types_compatible_p (m_type, o.m_type)) return false; - Value_Range r; + value_range r; o.get_vrange (r); return m_storage->equal_p (r); } void -ipa_vr::get_vrange (Value_Range &r) const +ipa_vr::get_vrange (value_range &r) const { r.set_type (m_type); m_storage->get_vrange (r, m_type); @@ -193,7 +193,7 @@ ipa_vr::streamer_read (lto_input_block *ib, data_in *data_in) bool known = bp_unpack_value (&bp, 1); if (known) { - Value_Range vr; + value_range vr; streamer_read_value_range (ib, data_in, vr); if (!m_storage || !m_storage->fits_p (vr)) { @@ -219,7 +219,7 @@ ipa_vr::streamer_write (output_block *ob) const streamer_write_bitpack (&bp); if (m_storage) { - Value_Range vr (m_type); + value_range vr (m_type); m_storage->get_vrange (vr, m_type); streamer_write_vrange (ob, vr); } @@ -230,7 +230,7 @@ ipa_vr::dump (FILE *out) const { if (known_p ()) { - Value_Range vr (m_type); + value_range vr (m_type); m_storage->get_vrange (vr, m_type); vr.dump (out); } @@ -2299,7 +2299,7 @@ ipa_set_jfunc_vr (ipa_jump_func *jf, const vrange &tmp) static void ipa_set_jfunc_vr (ipa_jump_func *jf, const ipa_vr &vr) { - Value_Range tmp; + value_range tmp; vr.get_vrange (tmp); ipa_set_jfunc_vr (jf, tmp); } @@ -2347,7 +2347,7 @@ ipa_compute_jump_functions_for_edge (struct ipa_func_body_info *fbi, useful_context = true; } - Value_Range vr (TREE_TYPE (arg)); + value_range vr (TREE_TYPE (arg)); if (POINTER_TYPE_P (TREE_TYPE (arg))) { bool addr_nonzero = false; @@ -2397,7 +2397,7 @@ ipa_compute_jump_functions_for_edge (struct ipa_func_body_info *fbi, && get_range_query (cfun)->range_of_expr (vr, arg, cs->call_stmt) && !vr.undefined_p ()) { - Value_Range resvr (vr); + value_range resvr (vr); range_cast (resvr, param_type); if (!resvr.undefined_p () && !resvr.varying_p ()) ipa_set_jfunc_vr (jfunc, resvr); @@ -5778,7 +5778,7 @@ ipcp_get_parm_bits (tree parm, tree *value, widest_int *mask) vec &vr = *ts->m_vr; if (!vr[i].known_p ()) return false; - Value_Range tmp; + value_range tmp; vr[i].get_vrange (tmp); if (tmp.undefined_p () || tmp.varying_p ()) return false; @@ -5837,7 +5837,7 @@ ipcp_update_vr (struct cgraph_node *node, ipcp_transformation *ts) if (vr[i].known_p ()) { - Value_Range tmp; + value_range tmp; vr[i].get_vrange (tmp); if (!tmp.undefined_p () && !tmp.varying_p ()) @@ -6007,7 +6007,7 @@ ipcp_transform_function (struct cgraph_node *node) /* Record that current function return value range is VAL. */ void -ipa_record_return_value_range (Value_Range val) +ipa_record_return_value_range (value_range val) { cgraph_node *n = cgraph_node::get (current_function_decl); if (!ipa_return_value_sum) @@ -6030,7 +6030,7 @@ ipa_record_return_value_range (Value_Range val) /* Return true if value range of DECL is known and if so initialize RANGE. */ bool -ipa_return_value_range (Value_Range &range, tree decl) +ipa_return_value_range (value_range &range, tree decl) { cgraph_node *n = cgraph_node::get (decl); if (!n || !ipa_return_value_sum) diff --git a/gcc/ipa-prop.h b/gcc/ipa-prop.h index 93d1b87b1f7..7a05c169c42 100644 --- a/gcc/ipa-prop.h +++ b/gcc/ipa-prop.h @@ -306,7 +306,7 @@ public: void set_unknown (); bool known_p () const { return m_storage != NULL; } tree type () const { return m_type; } - void get_vrange (Value_Range &) const; + void get_vrange (value_range &) const; bool equal_p (const vrange &) const; bool equal_p (const ipa_vr &) const; const vrange_storage *storage () const { return m_storage; } @@ -521,7 +521,7 @@ public: auto_vec m_known_aggs; /* Vector describing known value ranges of arguments. */ - auto_vec m_known_value_ranges; + auto_vec m_known_value_ranges; }; inline @@ -573,7 +573,7 @@ public: vec m_known_aggs = vNULL; /* Vector describing known value ranges of arguments. */ - vec m_known_value_ranges = vNULL; + vec m_known_value_ranges = vNULL; }; inline @@ -1277,8 +1277,8 @@ ipa_range_set_and_normalize (vrange &r, tree val) r.set (val, val); } -bool ipa_return_value_range (Value_Range &range, tree decl); -void ipa_record_return_value_range (Value_Range val); +bool ipa_return_value_range (value_range &range, tree decl); +void ipa_record_return_value_range (value_range val); bool ipa_jump_functions_equivalent_p (ipa_jump_func *jf1, ipa_jump_func *jf2); diff --git a/gcc/range-op.h b/gcc/range-op.h index 7fd7f0d5ce6..e415f87d7e6 100644 --- a/gcc/range-op.h +++ b/gcc/range-op.h @@ -336,8 +336,8 @@ inline bool range_cast (vrange &r, tree type) { gcc_checking_assert (r.supports_type_p (type)); - Value_Range tmp (r); - Value_Range varying (type); + value_range tmp (r); + value_range varying (type); varying.set_varying (type); // Call op_convert, if it fails, the result is varying. if (!range_op_handler (CONVERT_EXPR).fold_range (r, type, tmp, varying)) @@ -352,10 +352,10 @@ range_cast (vrange &r, tree type) // ie for float to int. inline bool -range_cast (Value_Range &r, tree type) +range_cast (value_range &r, tree type) { - Value_Range tmp (r); - Value_Range varying (type); + value_range tmp (r); + value_range varying (type); varying.set_varying (type); // Ensure we are in the correct mode for the call to fold. diff --git a/gcc/tree-ssa-dom.cc b/gcc/tree-ssa-dom.cc index 800bc5a4117..221fe6db321 100644 --- a/gcc/tree-ssa-dom.cc +++ b/gcc/tree-ssa-dom.cc @@ -1437,7 +1437,7 @@ dom_opt_dom_walker::set_global_ranges_from_unreachable_edges (basic_block bb) || (gimple_bb (SSA_NAME_DEF_STMT (name)) == pred_e->src))) { - Value_Range r (TREE_TYPE (name)); + value_range r (TREE_TYPE (name)); if (m_ranger->range_on_edge (r, pred_e, name) && !r.varying_p () @@ -2032,7 +2032,7 @@ cprop_operand (gimple *stmt, use_operand_p op_p, range_query *query) val = SSA_NAME_VALUE (op); if (!val) { - Value_Range r (TREE_TYPE (op)); + value_range r (TREE_TYPE (op)); tree single; if (query->range_of_expr (r, op, stmt) && r.singleton_p (&single)) val = single; diff --git a/gcc/tree-ssa-loop-ch.cc b/gcc/tree-ssa-loop-ch.cc index d7dd3e5459d..525eb357858 100644 --- a/gcc/tree-ssa-loop-ch.cc +++ b/gcc/tree-ssa-loop-ch.cc @@ -115,13 +115,13 @@ loop_static_stmt_p (class loop *loop, gimple *stmt) { tree type = gimple_range_type (stmt); - if (!type || !Value_Range::supports_type_p (type)) + if (!type || !value_range::supports_type_p (type)) return false; if (!query) query = get_range_query (loop, gimple_bb (stmt), ranger); - Value_Range r (gimple_range_type (stmt)); + value_range r (gimple_range_type (stmt)); if (!query->range_of_stmt (r, stmt)) return false; return r.singleton_p (); diff --git a/gcc/tree-ssa-loop-niter.cc b/gcc/tree-ssa-loop-niter.cc index 92db9c72ee4..f87731ef892 100644 --- a/gcc/tree-ssa-loop-niter.cc +++ b/gcc/tree-ssa-loop-niter.cc @@ -4092,7 +4092,7 @@ record_nonwrapping_iv (class loop *loop, tree base, tree step, gimple *stmt, if (tree_int_cst_sign_bit (step)) { wide_int max; - Value_Range base_range (TREE_TYPE (orig_base)); + value_range base_range (TREE_TYPE (orig_base)); if (get_range_query (cfun)->range_of_expr (base_range, orig_base) && !base_range.undefined_p ()) max = wi::to_wide (base_range.ubound ()); @@ -4115,7 +4115,7 @@ record_nonwrapping_iv (class loop *loop, tree base, tree step, gimple *stmt, else { wide_int min; - Value_Range base_range (TREE_TYPE (orig_base)); + value_range base_range (TREE_TYPE (orig_base)); if (get_range_query (cfun)->range_of_expr (base_range, orig_base) && !base_range.undefined_p ()) min = wi::to_wide (base_range.lbound ()); diff --git a/gcc/tree-ssa-loop-split.cc b/gcc/tree-ssa-loop-split.cc index a6be0cef7b0..68435485b79 100644 --- a/gcc/tree-ssa-loop-split.cc +++ b/gcc/tree-ssa-loop-split.cc @@ -144,7 +144,7 @@ split_at_bb_p (class loop *loop, basic_block bb, tree *border, affine_iv *iv, value range. */ else { - Value_Range r (TREE_TYPE (op0)); + value_range r (TREE_TYPE (op0)); get_global_range_query ()->range_of_expr (r, op0, stmt); if (!r.varying_p () && !r.undefined_p () && TREE_CODE (op1) == INTEGER_CST) diff --git a/gcc/tree-ssa-phiopt.cc b/gcc/tree-ssa-phiopt.cc index 65f63eb0652..0ef42a1031a 100644 --- a/gcc/tree-ssa-phiopt.cc +++ b/gcc/tree-ssa-phiopt.cc @@ -1326,11 +1326,11 @@ value_replacement (basic_block cond_bb, basic_block middle_bb, { /* After the optimization PHI result can have value which it couldn't have previously. */ - Value_Range r (TREE_TYPE (phires)); + value_range r (TREE_TYPE (phires)); if (get_global_range_query ()->range_of_expr (r, phires, phi)) { - Value_Range tmp (carg, carg); + value_range tmp (carg, carg); r.union_ (tmp); reset_flow_sensitive_info (phires); set_range_info (phires, r); diff --git a/gcc/tree-ssa-strlen.cc b/gcc/tree-ssa-strlen.cc index d3c7dc3a80f..ee60909aa21 100644 --- a/gcc/tree-ssa-strlen.cc +++ b/gcc/tree-ssa-strlen.cc @@ -215,7 +215,7 @@ get_range (tree val, gimple *stmt, wide_int minmax[2], rvals = get_range_query (cfun); } - Value_Range vr (TREE_TYPE (val)); + value_range vr (TREE_TYPE (val)); if (!rvals->range_of_expr (vr, val, stmt)) return NULL_TREE; diff --git a/gcc/tree-ssa-threadedge.cc b/gcc/tree-ssa-threadedge.cc index 70f269e29fb..7f82639b8ec 100644 --- a/gcc/tree-ssa-threadedge.cc +++ b/gcc/tree-ssa-threadedge.cc @@ -1418,7 +1418,7 @@ hybrid_jt_simplifier::simplify (gimple *stmt, gimple *, basic_block, if (gimple_code (stmt) == GIMPLE_COND || gimple_code (stmt) == GIMPLE_ASSIGN) { - Value_Range r (gimple_range_type (stmt)); + value_range r (gimple_range_type (stmt)); tree ret; if (m_query->range_of_stmt (r, stmt) && r.singleton_p (&ret)) return ret; @@ -1457,7 +1457,7 @@ hybrid_jt_simplifier::compute_exit_dependencies (bitmap dependencies, tree op = gimple_op (stmt, i); if (op && TREE_CODE (op) == SSA_NAME - && Value_Range::supports_type_p (TREE_TYPE (op))) + && value_range::supports_type_p (TREE_TYPE (op))) bitmap_set_bit (dependencies, SSA_NAME_VERSION (op)); } } diff --git a/gcc/tree-ssanames.cc b/gcc/tree-ssanames.cc index 1753a421a0b..615d522d0b1 100644 --- a/gcc/tree-ssanames.cc +++ b/gcc/tree-ssanames.cc @@ -432,7 +432,7 @@ set_range_info (tree name, const vrange &r) return false; } - Value_Range tmp (type); + value_range tmp (type); if (range_info_p (name)) range_info_get_range (name, tmp); else @@ -751,7 +751,7 @@ duplicate_ssa_name_range_info (tree name, tree src) if (range_info_p (src)) { - Value_Range src_range (TREE_TYPE (src)); + value_range src_range (TREE_TYPE (src)); range_info_get_range (src, src_range); range_info_set_range (name, src_range); } diff --git a/gcc/tree-vrp.cc b/gcc/tree-vrp.cc index 1f6b578f253..5f5eb9b57e9 100644 --- a/gcc/tree-vrp.cc +++ b/gcc/tree-vrp.cc @@ -223,7 +223,7 @@ remove_unreachable::handle_early (gimple *s, edge e) // Set the global value for each. FOR_EACH_GORI_EXPORT_NAME (m_ranger.gori_ssa (), e->src, name) { - Value_Range r (TREE_TYPE (name)); + value_range r (TREE_TYPE (name)); m_ranger.range_on_entry (r, e->dest, name); // Nothing at this late stage we can do if the write fails. if (!set_range_info (name, r)) @@ -333,8 +333,8 @@ remove_unreachable::remove_and_update_globals () FOR_EACH_GORI_EXPORT_NAME (m_ranger.gori_ssa (), e->src, name) { // Ensure the cache is set for NAME in the succ block. - Value_Range r(TREE_TYPE (name)); - Value_Range ex(TREE_TYPE (name)); + value_range r(TREE_TYPE (name)); + value_range ex(TREE_TYPE (name)); m_ranger.range_on_entry (r, e->dest, name); m_ranger.range_on_entry (ex, EXIT_BLOCK_PTR_FOR_FN (cfun), name); // If the range produced by this __builtin_unreachacble expression @@ -381,8 +381,8 @@ remove_unreachable::remove_and_update_globals () name = ssa_name (i); if (!name || SSA_NAME_IN_FREE_LIST (name)) continue; - Value_Range r (TREE_TYPE (name)); - Value_Range exp_range (TREE_TYPE (name)); + value_range r (TREE_TYPE (name)); + value_range exp_range (TREE_TYPE (name)); r.set_undefined (); FOR_EACH_IMM_USE_FAST (use_p, iter, name) { @@ -1112,7 +1112,7 @@ execute_ranger_vrp (struct function *fun, bool final_p) if (dump_file && (dump_flags & TDF_DETAILS)) ranger->dump (dump_file); - if (Value_Range::supports_type_p (TREE_TYPE + if (value_range::supports_type_p (TREE_TYPE (TREE_TYPE (current_function_decl))) && flag_ipa_vrp && !lookup_attribute ("noipa", DECL_ATTRIBUTES (current_function_decl))) @@ -1120,7 +1120,7 @@ execute_ranger_vrp (struct function *fun, bool final_p) edge e; edge_iterator ei; bool found = false; - Value_Range return_range (TREE_TYPE (TREE_TYPE (current_function_decl))); + value_range return_range (TREE_TYPE (TREE_TYPE (current_function_decl))); FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR_FOR_FN (cfun)->preds) if (greturn *ret = dyn_cast (*gsi_last_bb (e->src))) { @@ -1131,7 +1131,7 @@ execute_ranger_vrp (struct function *fun, bool final_p) found = true; continue; } - Value_Range r (TREE_TYPE (retval)); + value_range r (TREE_TYPE (retval)); if (ranger->range_of_expr (r, retval, ret) && !r.undefined_p () && !r.varying_p ()) @@ -1208,7 +1208,7 @@ public: tree name = gimple_range_ssa_p (PHI_RESULT (psi.phi ())); if (name) { - Value_Range vr(TREE_TYPE (name)); + value_range vr(TREE_TYPE (name)); m_dom_ranger->range_of_stmt (vr, psi.phi (), name); } } @@ -1225,7 +1225,7 @@ public: tree type = gimple_range_type (s); if (type) { - Value_Range vr(type); + value_range vr(type); m_dom_ranger->range_of_stmt (vr, s); } } @@ -1369,9 +1369,9 @@ public: if (!name || !gimple_range_ssa_p (name)) continue; tree type = TREE_TYPE (name); - if (!Value_Range::supports_type_p (type)) + if (!value_range::supports_type_p (type)) continue; - Value_Range assume_range (type); + value_range assume_range (type); if (query.assume_range_p (assume_range, name)) { // Set the global range of NAME to anything calculated. diff --git a/gcc/value-query.cc b/gcc/value-query.cc index 556a0f39b09..0a280be580b 100644 --- a/gcc/value-query.cc +++ b/gcc/value-query.cc @@ -74,10 +74,10 @@ range_query::value_of_expr (tree expr, gimple *stmt) { tree t; - if (!Value_Range::supports_type_p (TREE_TYPE (expr))) + if (!value_range::supports_type_p (TREE_TYPE (expr))) return NULL_TREE; - Value_Range r (TREE_TYPE (expr)); + value_range r (TREE_TYPE (expr)); if (range_of_expr (r, expr, stmt)) { @@ -99,9 +99,9 @@ range_query::value_on_edge (edge e, tree expr) { tree t; - if (!Value_Range::supports_type_p (TREE_TYPE (expr))) + if (!value_range::supports_type_p (TREE_TYPE (expr))) return NULL_TREE; - Value_Range r (TREE_TYPE (expr)); + value_range r (TREE_TYPE (expr)); if (range_on_edge (r, e, expr)) { // A constant used in an unreachable block often returns as UNDEFINED. @@ -127,9 +127,9 @@ range_query::value_of_stmt (gimple *stmt, tree name) gcc_checking_assert (!name || name == gimple_get_lhs (stmt)); - if (!name || !Value_Range::supports_type_p (TREE_TYPE (name))) + if (!name || !value_range::supports_type_p (TREE_TYPE (name))) return NULL_TREE; - Value_Range r (TREE_TYPE (name)); + value_range r (TREE_TYPE (name)); if (range_of_stmt (r, stmt, name) && r.singleton_p (&t)) return t; return NULL_TREE; @@ -144,10 +144,10 @@ range_query::value_on_entry (basic_block bb, tree expr) tree t; gcc_checking_assert (bb); - if (!Value_Range::supports_type_p (TREE_TYPE (expr))) + if (!value_range::supports_type_p (TREE_TYPE (expr))) return NULL_TREE; - Value_Range r (TREE_TYPE (expr)); + value_range r (TREE_TYPE (expr)); if (range_on_entry (r, bb, expr) && r.singleton_p (&t)) return t; @@ -163,10 +163,10 @@ range_query::value_on_exit (basic_block bb, tree expr) tree t; gcc_checking_assert (bb); - if (!Value_Range::supports_type_p (TREE_TYPE (expr))) + if (!value_range::supports_type_p (TREE_TYPE (expr))) return NULL_TREE; - Value_Range r (TREE_TYPE (expr)); + value_range r (TREE_TYPE (expr)); if (range_on_exit (r, bb, expr) && r.singleton_p (&t)) return t; @@ -317,7 +317,7 @@ range_query::get_tree_range (vrange &r, tree expr, gimple *stmt, else type = TREE_TYPE (expr); - if (!Value_Range::supports_type_p (type)) + if (!value_range::supports_type_p (type)) { r.set_undefined (); return false; @@ -381,13 +381,13 @@ range_query::get_tree_range (vrange &r, tree expr, gimple *stmt, tree op0 = TREE_OPERAND (expr, 0); tree op1 = TREE_OPERAND (expr, 1); if (COMPARISON_CLASS_P (expr) - && !Value_Range::supports_type_p (TREE_TYPE (op0))) + && !value_range::supports_type_p (TREE_TYPE (op0))) return false; range_op_handler op (TREE_CODE (expr)); if (op) { - Value_Range r0 (TREE_TYPE (op0)); - Value_Range r1 (TREE_TYPE (op1)); + value_range r0 (TREE_TYPE (op0)); + value_range r1 (TREE_TYPE (op1)); invoke_range_of_expr (r0, op0, stmt, bbentry, bbexit); invoke_range_of_expr (r1, op1, stmt, bbentry, bbexit); if (!op.fold_range (r, type, r0, r1)) @@ -401,10 +401,10 @@ range_query::get_tree_range (vrange &r, tree expr, gimple *stmt, { range_op_handler op (TREE_CODE (expr)); tree op0_type = TREE_TYPE (TREE_OPERAND (expr, 0)); - if (op && Value_Range::supports_type_p (op0_type)) + if (op && value_range::supports_type_p (op0_type)) { - Value_Range r0 (TREE_TYPE (TREE_OPERAND (expr, 0))); - Value_Range r1 (type); + value_range r0 (TREE_TYPE (TREE_OPERAND (expr, 0))); + value_range r1 (type); r1.set_varying (type); invoke_range_of_expr (r0, TREE_OPERAND (expr, 0), stmt, bbentry, bbexit); diff --git a/gcc/value-range-storage.cc b/gcc/value-range-storage.cc index 8e8d61d5935..d3d98f98d7b 100644 --- a/gcc/value-range-storage.cc +++ b/gcc/value-range-storage.cc @@ -186,7 +186,7 @@ vrange_storage::set_vrange (const vrange &r) && !is_a (r) && !r.undefined_p ()) { - Value_Range tmp (r); + value_range tmp (r); get_vrange (tmp, r.type ()); gcc_checking_assert (tmp == r); } diff --git a/gcc/value-range.cc b/gcc/value-range.cc index 05cb308e682..9c3eb78459d 100644 --- a/gcc/value-range.cc +++ b/gcc/value-range.cc @@ -62,7 +62,7 @@ irange::accept (const vrange_visitor &v) const } void -Value_Range::dump (FILE *out) const +value_range::dump (FILE *out) const { if (m_vrange) m_vrange->dump (out); @@ -71,7 +71,7 @@ Value_Range::dump (FILE *out) const } DEBUG_FUNCTION void -debug (const Value_Range &r) +debug (const value_range &r) { r.dump (stderr); fprintf (stderr, "\n"); diff --git a/gcc/value-range.h b/gcc/value-range.h index 3cc15d51516..4a8d69f3408 100644 --- a/gcc/value-range.h +++ b/gcc/value-range.h @@ -58,7 +58,7 @@ enum value_range_discriminator // Abstract class for ranges of any of the supported types. // // To query what types ranger and the entire ecosystem can support, -// use Value_Range::supports_type_p(tree type). This is a static +// use value_range::supports_type_p(tree type). This is a static // method available independently of any vrange object. // // To query what a given vrange variant can support, use: @@ -77,7 +77,7 @@ enum value_range_discriminator class vrange { template friend bool is_a (vrange &); - friend class Value_Range; + friend class value_range; friend void streamer_write_vrange (struct output_block *, const vrange &); friend class range_op_handler; public: @@ -753,20 +753,20 @@ public: // object to a function accepting a vrange, the correct type must be // set. If it isn't, you can do so with set_type(). -class Value_Range +class value_range { public: - Value_Range (); - Value_Range (const vrange &r); - Value_Range (tree type); - Value_Range (tree, tree, value_range_kind kind = VR_RANGE); - Value_Range (const Value_Range &); - ~Value_Range (); + value_range (); + value_range (const vrange &r); + value_range (tree type); + value_range (tree, tree, value_range_kind kind = VR_RANGE); + value_range (const value_range &); + ~value_range (); void set_type (tree type); vrange& operator= (const vrange &); - Value_Range& operator= (const Value_Range &); - bool operator== (const Value_Range &r) const; - bool operator!= (const Value_Range &r) const; + value_range& operator= (const value_range &); + bool operator== (const value_range &r) const; + bool operator!= (const value_range &r) const; operator vrange &(); operator const vrange &() const; void dump (FILE *) const; @@ -812,7 +812,7 @@ private: // with either set_type() or with an assignment into it. inline -Value_Range::Value_Range () +value_range::value_range () : m_buffer () { m_vrange = NULL; @@ -821,7 +821,7 @@ Value_Range::Value_Range () // Copy constructor. inline -Value_Range::Value_Range (const Value_Range &r) +value_range::value_range (const value_range &r) { init (*r.m_vrange); } @@ -829,7 +829,7 @@ Value_Range::Value_Range (const Value_Range &r) // Copy constructor from a vrange. inline -Value_Range::Value_Range (const vrange &r) +value_range::value_range (const vrange &r) { init (r); } @@ -838,7 +838,7 @@ Value_Range::Value_Range (const vrange &r) // is not supported, default to unsupported_range. inline -Value_Range::Value_Range (tree type) +value_range::value_range (tree type) { init (type); } @@ -847,14 +847,14 @@ Value_Range::Value_Range (tree type) // and MAX are trees. inline -Value_Range::Value_Range (tree min, tree max, value_range_kind kind) +value_range::value_range (tree min, tree max, value_range_kind kind) { init (TREE_TYPE (min)); m_vrange->set (min, max, kind); } inline -Value_Range::~Value_Range () +value_range::~value_range () { if (m_vrange) m_vrange->~vrange (); @@ -864,7 +864,7 @@ Value_Range::~Value_Range () // TYPE. Clean-up memory if there was a previous object. inline void -Value_Range::set_type (tree type) +value_range::set_type (tree type) { if (m_vrange) m_vrange->~vrange (); @@ -875,7 +875,7 @@ Value_Range::set_type (tree type) // TYPE. inline void -Value_Range::init (tree type) +value_range::init (tree type) { gcc_checking_assert (TYPE_P (type)); @@ -892,7 +892,7 @@ Value_Range::init (tree type) // Initialize object with a copy of R. inline void -Value_Range::init (const vrange &r) +value_range::init (const vrange &r) { if (is_a (r)) m_vrange = new (&m_buffer.ints) int_range_max (as_a (r)); @@ -910,7 +910,7 @@ Value_Range::init (const vrange &r) // right thing. inline vrange & -Value_Range::operator= (const vrange &r) +value_range::operator= (const vrange &r) { if (m_vrange) m_vrange->~vrange (); @@ -918,8 +918,8 @@ Value_Range::operator= (const vrange &r) return *m_vrange; } -inline Value_Range & -Value_Range::operator= (const Value_Range &r) +inline value_range & +value_range::operator= (const value_range &r) { // No need to call the m_vrange destructor here, as we will do so in // the assignment below. @@ -928,25 +928,25 @@ Value_Range::operator= (const Value_Range &r) } inline bool -Value_Range::operator== (const Value_Range &r) const +value_range::operator== (const value_range &r) const { return *m_vrange == *r.m_vrange; } inline bool -Value_Range::operator!= (const Value_Range &r) const +value_range::operator!= (const value_range &r) const { return *m_vrange != *r.m_vrange; } inline -Value_Range::operator vrange &() +value_range::operator vrange &() { return *m_vrange; } inline -Value_Range::operator const vrange &() const +value_range::operator const vrange &() const { return *m_vrange; } @@ -954,7 +954,7 @@ Value_Range::operator const vrange &() const // Return TRUE if TYPE is supported by the vrange infrastructure. inline bool -Value_Range::supports_type_p (const_tree type) +value_range::supports_type_p (const_tree type) { return irange::supports_p (type) || prange::supports_p (type) diff --git a/gcc/vr-values.cc b/gcc/vr-values.cc index 470e3145787..cf273a3fc62 100644 --- a/gcc/vr-values.cc +++ b/gcc/vr-values.cc @@ -310,8 +310,8 @@ tree simplify_using_ranges::fold_cond_with_ops (enum tree_code code, tree op0, tree op1, gimple *s) { - Value_Range r0 (TREE_TYPE (op0)); - Value_Range r1 (TREE_TYPE (op1)); + value_range r0 (TREE_TYPE (op0)); + value_range r1 (TREE_TYPE (op1)); if (!query->range_of_expr (r0, op0, s) || !query->range_of_expr (r1, op1, s)) return NULL_TREE; @@ -451,7 +451,7 @@ simplify_using_ranges::legacy_fold_cond (gcond *stmt, edge *taken_edge_p) fprintf (dump_file, "\t"); print_generic_expr (dump_file, use); fprintf (dump_file, ": "); - Value_Range r (TREE_TYPE (use)); + value_range r (TREE_TYPE (use)); query->range_of_expr (r, use, stmt); r.dump (dump_file); }