ranger: Ranger meets aspell

I've noticed a comment typo in tree-vrp.cc and decided to quickly
skim aspell -c on the ranger sources (with quick I on everything that
looked ok or roughly ok).
But not being a native English speaker, I could get stuff wrong.

2023-03-23  Jakub Jelinek  <jakub@redhat.com>

	* value-range.cc (irange::irange_union, irange::intersect): Fix
	comment spelling bugs.
	* gimple-range-trace.cc (range_tracer::do_header): Likewise.
	* gimple-range-trace.h: Likewise.
	* gimple-range-edge.cc: Likewise.
	(gimple_outgoing_range_stmt_p,
	gimple_outgoing_range::switch_edge_range,
	gimple_outgoing_range::edge_range_p): Likewise.
	* gimple-range.cc (gimple_ranger::prefill_stmt_dependencies,
	gimple_ranger::fold_stmt, gimple_ranger::register_transitive_infer,
	assume_query::assume_query, assume_query::calculate_phi): Likewise.
	* gimple-range-edge.h: Likewise.
	* value-range.h (Value_Range::set, Value_Range::lower_bound,
	Value_Range::upper_bound, frange::set_undefined): Likewise.
	* gimple-range-gori.h (range_def_chain::depend, gori_map::m_outgoing,
	gori_compute): Likewise.
	* gimple-range-fold.h (fold_using_range): Likewise.
	* gimple-range-path.cc (path_range_query::compute_ranges_in_phis):
	Likewise.
	* gimple-range-gori.cc (range_def_chain::in_chain_p,
	range_def_chain::dump, gori_map::calculate_gori,
	gori_compute::compute_operand_range_switch,
	gori_compute::logical_combine, gori_compute::refine_using_relation,
	gori_compute::compute_operand1_range, gori_compute::may_recompute_p):
	Likewise.
	* gimple-range.h: Likewise.
	(enable_ranger): Likewise.
	* range-op.h (empty_range_varying): Likewise.
	* value-query.h (value_query): Likewise.
	* gimple-range-cache.cc (block_range_cache::set_bb_range,
	block_range_cache::dump, ssa_global_cache::clear_global_range,
	temporal_cache::temporal_value, temporal_cache::current_p,
	ranger_cache::range_of_def, ranger_cache::propagate_updated_value,
	ranger_cache::range_from_dom, ranger_cache::register_inferred_value):
	Likewise.
	* gimple-range-fold.cc (fur_edge::get_phi_operand,
	fur_stmt::get_operand, gimple_range_adjustment,
	fold_using_range::range_of_phi,
	fold_using_range::relation_fold_and_or): Likewise.
	* value-range-storage.h (irange_storage_slot::MAX_INTS): Likewise.
	* value-query.cc (range_query::value_of_expr,
	range_query::value_on_edge, range_query::query_relation): Likewise.
	* tree-vrp.cc (remove_unreachable::remove_and_update_globals,
	intersect_range_with_nonzero_bits): Likewise.
	* gimple-range-infer.cc (gimple_infer_range::check_assume_func,
	exit_range): Likewise.
	* value-relation.h: Likewise.
	(equiv_oracle, relation_trio::relation_trio, value_relation,
	value_relation::value_relation, pe_min): Likewise.
	* range-op-float.cc (range_operator_float::rv_fold,
	frange_arithmetic, foperator_unordered_equal::op1_range,
	foperator_div::rv_fold): Likewise.
	* gimple-range-op.cc (cfn_clz::fold_range): Likewise.
	* value-relation.cc (equiv_oracle::query_relation,
	equiv_oracle::register_equiv, equiv_oracle::add_equiv_to_block,
	value_relation::apply_transitive, relation_chain_head::find_relation,
	dom_oracle::query_relation, dom_oracle::find_relation_block,
	dom_oracle::find_relation_dom, path_oracle::register_equiv): Likewise.
	* range-op.cc (range_operator::wi_fold_in_parts_equiv,
	create_possibly_reversed_range, adjust_op1_for_overflow,
	operator_mult::wi_fold, operator_exact_divide::op1_range,
	operator_cast::lhs_op1_relation, operator_cast::fold_pair,
	operator_cast::fold_range, operator_abs::wi_fold, range_op_cast_tests,
	range_op_lshift_tests): Likewise.

1 files changed, 9 insertions, 9 deletions

diff --git a/gcc/value-relation.h b/gcc/value-relation.h
index 897cf46..36a7586 100644
--- a/gcc/value-relation.h
+++ b/gcc/value-relation.h
@@ -27,7 +27,7 @@ along with GCC; see the file COPYING3.  If not see
 //
 // The general range_query object provided in value-query.h provides
 // access to an oracle, if one is available, via the oracle() method.
-// Thre are also a couple of access routines provided, which even if there is
+// There are also a couple of access routines provided, which even if there is
 // no oracle, will return the default VREL_VARYING no relation.
 //
 // Typically, when a ranger object is active, there will be an oracle, and
@@ -36,7 +36,7 @@ along with GCC; see the file COPYING3.  If not see
 // is totally transparent to the client, and they are free to make queries.
 //
 // relation_kind is a new enum which represents the different relations,
-// often with a direct mapping to treee codes. ie VREL_EQ is equivalent to
+// often with a direct mapping to tree codes. ie VREL_EQ is equivalent to
 // EQ_EXPR.
 //
 // A query is made requesting the relation between SSA1 and SSA@ in a basic
@@ -48,10 +48,10 @@ along with GCC; see the file COPYING3.  If not see
 //
 // The oracle maintains VREL_EQ relations with equivalency sets, so if a
 // relation comes back VREL_EQ, it is also possible to query the set of
-// equivlaencies.  These are basically bitmaps over ssa_names.  An iterator is
+// equivalencies.  These are basically bitmaps over ssa_names.  An iterator is
 // provided later for this activity.
 //
-// Relations are maintained via the dominace trees and are optimized assuming
+// Relations are maintained via the dominance trees and are optimized assuming
 // they are registered in dominance order.   When a new relation is added, it
 // is intersected with whatever existing relation exists in the dominance tree
 // and registered at the specified block.
@@ -148,7 +148,7 @@ public:
 // The equivalency oracle maintains equivalencies using the dominator tree.
 // Equivalencies apply to an entire basic block.  Equivalencies on edges
 // can be represented only on edges whose destination is a single-pred block,
-// and the equivalence is simply applied to that succesor block.
+// and the equivalence is simply applied to that successor block.
 
 class equiv_oracle : public relation_oracle
 {
@@ -350,7 +350,7 @@ protected:
 
 // These 3 classes are shortcuts for when a caller has a single relation to
 // pass as a trio, it can simply construct the appropriate one.  The other
-// unspecified realtions will be VREL_VARYING.
+// unspecified relations will be VREL_VARYING.
 
 inline relation_trio::relation_trio ()
 {
@@ -411,7 +411,7 @@ relation_trio::swap_op1_op2 ()
 
 // -----------------------------------------------------------------------
 
-// The value-relation class is used to encapsulate the represention of an
+// The value-relation class is used to encapsulate the representation of an
 // individual relation between 2 ssa-names, and to facilitate operating on
 // the relation.
 
@@ -467,7 +467,7 @@ value_relation::value_relation ()
   name2 = NULL_TREE;
 }
 
-// Constructor for relation R between SSA version N1 nd N2.
+// Constructor for relation R between SSA version N1 and N2.
 
 inline
 value_relation::value_relation (relation_kind kind, tree n1, tree n2)
@@ -517,7 +517,7 @@ bits_to_pe (int bits)
   }
 }
 
-// Given partial equivalencies T1 and T2, return the snmallest kind.
+// Given partial equivalencies T1 and T2, return the smallest kind.
 
 inline relation_kind
 pe_min (relation_kind t1, relation_kind t2)