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 <irange> (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 <irange> (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 <gphi *> (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
<ipa_vr *>
// 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<ipa_vr, va_gc> &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<ipa_argagg_value, 32> m_known_aggs;
/* Vector describing known value ranges of arguments. */
- auto_vec<Value_Range, 32> m_known_value_ranges;
+ auto_vec<value_range, 32> m_known_value_ranges;
};
inline
@@ -573,7 +573,7 @@ public:
vec<ipa_argagg_value> m_known_aggs = vNULL;
/* Vector describing known value ranges of arguments. */
- vec<Value_Range> m_known_value_ranges = vNULL;
+ vec<value_range> 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 <greturn *> (*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 <frange> (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 <typename T> 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 <irange> (r))
m_vrange = new (&m_buffer.ints) int_range_max (as_a <irange> (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);
}
--
2.45.0
