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);
 	}
