From: Dhruv Chawla <[email protected]>
Signed-off-by: Dhruv Chawla <[email protected]>
gcc/ChangeLog:
* tree-ssa-alias-compare.h: Fix typos.
* tree-ssa-alias.cc (ptr_deref_may_alias_decl_p): Likewise.
(ao_ref_alignment): Likewise.
(component_ref_to_zero_sized_trailing_array_p): Likewise.
(access_path_may_continue_p): Likewise.
(nonoverlapping_component_refs_p_1): Likewise.
(nonoverlapping_array_refs_p): Likewise.
(refs_may_alias_p_2): Likewise.
(ref_maybe_used_by_call_p_1): Likewise.
(stmt_kills_ref_p): Likewise.
* tree-ssa-ccp.cc: Likewise.
* tree-ssa-dce.cc (mark_all_reaching_defs_necessary_1): Likewise.
(propagate_necessity): Likewise.
(propagate_counts): Likewise.
(eliminate_unnecessary_stmts): Likewise.
* tree-ssa-dom.cc (pass_dominator::execute): Likewise.
* tree-ssa-dse.cc: Likewise.
* tree-ssa-forwprop.cc (new_src_based_on_copy): Likewise.
(optimize_agr_copyprop_1): Likewise.
(pass_forwprop::execute): Likewise.
* tree-ssa-ifcombine.cc (tree_ssa_ifcombine_bb_1): Likewise.
(pass_tree_ifcombine::execute): Likewise.
* tree-ssa-live.cc (remove_unused_scope_block_p): Likewise.
* tree-ssa-loop-ch.cc (loop_combined_static_and_iv_p): Likewise.
(should_duplicate_loop_header_p): Likewise.
* tree-ssa-loop-im.cc (get_coldest_out_loop): Likewise.
(determine_max_movement): Likewise.
(execute_sm_exit): Likewise.
(hoist_memory_references): Likewise.
* tree-ssa-loop-ivcanon.cc (constant_after_peeling): Likewise.
(loop_edge_to_cancel): Likewise.
(unloop_loops): Likewise.
(try_unroll_loop_completely): Likewise.
(adjust_loop_info_after_peeling): Likewise.
(tree_unroll_loops_completely_1): Likewise.
* tree-ssa-loop-ivopts.cc (struct iv_inv_expr_ent): Likewise.
(dump_cand): Likewise.
(group_compare_offset): Likewise.
(split_address_groups): Likewise.
(get_computation_aff_1): Likewise.
(iv_ca_dump): Likewise.
* tree-ssa-loop-niter.cc (number_of_iterations_ne): Likewise.
(number_of_iterations_popcount): Likewise.
(idx_infer_loop_bounds): Likewise.
(infer_loop_bounds_from_signedness): Likewise.
(discover_iteration_bound_by_body_walk): Likewise.
(loop_exits_before_overflow): Likewise.
* tree-ssa-loop-niter.h: Likewise.
* tree-ssa-loop-prefetch.cc (should_issue_prefetch_p): Likewise.
(schedule_prefetches): Likewise.
* tree-ssa-loop-split.cc (fix_loop_bb_probability): Likewise.
(split_loop): Likewise.
(find_vdef_in_loop): Likewise.
(get_cond_branch_to_split_loop): Likewise.
* tree-ssa-math-opts.cc (powi_as_mults): Likewise.
(expand_pow_as_sqrts): Likewise.
(gimple_expand_builtin_pow): Likewise.
(convert_mult_to_widen): Likewise.
(convert_plusminus_to_widen): Likewise.
* tree-ssa-phiopt.cc (replace_phi_edge_with_variable): Likewise.
(factor_out_conditional_operation): Likewise.
(cond_if_else_store_replacement_1): Likewise.
(execute_over_cond_phis): Likewise.
* tree-ssa-phiprop.cc (propagate_with_phi): Likewise.
* tree-ssa-pre.cc (get_or_alloc_expr_for_nary): Likewise.
(sorted_array_from_bitmap_set): Likewise.
(value_dies_in_block_x): Likewise.
(compute_antic_aux): Likewise.
* tree-ssa-propagate.cc
(substitute_and_fold_engine::substitute_and_fold): Likewise.
* tree-ssa-reassoc.cc (get_rank): Likewise.
(remove_visited_stmt_chain): Likewise.
* tree-ssa-sccvn.cc (vn_reference_eq): Likewise.
(vn_reference_lookup_call): Likewise.
(vn_nary_op_eq): Likewise.
(vn_nary_op_insert_into): Likewise.
(visit_reference_op_call): Likewise.
(visit_phi): Likewise.
(eliminate_dom_walker::eliminate_stmt): Likewise.
(eliminate_dom_walker::eliminate_cleanup): Likewise.
(process_bb): Likewise.
* tree-ssa-scopedtables.cc (hashable_expr_equal_p): Likewise.
* tree-ssa-structalias.cc (determine_global_memory_access): Likewise.
(clear_dependence_clique): Likewise.
* tree-ssa-threadbackward.cc
(back_threader_profitability::profitable_path_p): Likewise.
* tree-ssa-threadedge.cc (propagate_threaded_block_debug_into):
Likewise.
* tree-ssa-uninit.cc (warn_uninit): Likewise.
(execute_late_warn_uninitialized): Likewise.
* tree-ssanames.cc (range_info_get_range): Likewise.
---
gcc/tree-ssa-alias-compare.h | 2 +-
gcc/tree-ssa-alias.cc | 18 +++++++++---------
gcc/tree-ssa-ccp.cc | 2 +-
gcc/tree-ssa-dce.cc | 14 +++++++-------
gcc/tree-ssa-dom.cc | 4 ++--
gcc/tree-ssa-dse.cc | 2 +-
gcc/tree-ssa-forwprop.cc | 10 +++++-----
gcc/tree-ssa-ifcombine.cc | 4 ++--
gcc/tree-ssa-live.cc | 6 +++---
gcc/tree-ssa-loop-ch.cc | 20 ++++++++++----------
gcc/tree-ssa-loop-im.cc | 12 ++++++------
gcc/tree-ssa-loop-ivcanon.cc | 14 +++++++-------
gcc/tree-ssa-loop-ivopts.cc | 12 ++++++------
gcc/tree-ssa-loop-niter.cc | 14 +++++++-------
gcc/tree-ssa-loop-niter.h | 2 +-
gcc/tree-ssa-loop-prefetch.cc | 6 +++---
gcc/tree-ssa-loop-split.cc | 10 +++++-----
gcc/tree-ssa-math-opts.cc | 12 ++++++------
gcc/tree-ssa-phiopt.cc | 10 +++++-----
gcc/tree-ssa-phiprop.cc | 4 ++--
gcc/tree-ssa-pre.cc | 8 ++++----
gcc/tree-ssa-propagate.cc | 4 ++--
gcc/tree-ssa-reassoc.cc | 6 +++---
gcc/tree-ssa-sccvn.cc | 18 +++++++++---------
gcc/tree-ssa-scopedtables.cc | 2 +-
gcc/tree-ssa-structalias.cc | 4 ++--
gcc/tree-ssa-threadbackward.cc | 4 ++--
gcc/tree-ssa-threadedge.cc | 2 +-
gcc/tree-ssa-uninit.cc | 4 ++--
gcc/tree-ssanames.cc | 2 +-
30 files changed, 116 insertions(+), 116 deletions(-)
diff --git a/gcc/tree-ssa-alias-compare.h b/gcc/tree-ssa-alias-compare.h
index bbc5d5d751c..2ced2d67c66 100644
--- a/gcc/tree-ssa-alias-compare.h
+++ b/gcc/tree-ssa-alias-compare.h
@@ -1,4 +1,4 @@
-/* Comparsion of AO ref.
+/* Comparison of AO ref.
Copyright (C) 2020-2026 Free Software Foundation, Inc.
This file is part of GCC.
diff --git a/gcc/tree-ssa-alias.cc b/gcc/tree-ssa-alias.cc
index f662924b07f..9f3dd2adac0 100644
--- a/gcc/tree-ssa-alias.cc
+++ b/gcc/tree-ssa-alias.cc
@@ -251,7 +251,7 @@ ptr_deref_may_alias_decl_p (tree ptr, tree decl)
data-dependence analysis can feed us those. */
STRIP_NOPS (ptr);
- /* Anything we do not explicilty handle aliases. */
+ /* Anything we do not explicitly handle aliases. */
if ((TREE_CODE (ptr) != SSA_NAME
&& TREE_CODE (ptr) != ADDR_EXPR
&& TREE_CODE (ptr) != POINTER_PLUS_EXPR)
@@ -854,7 +854,7 @@ ao_ref_alignment (ao_ref *ref, unsigned int *align,
return get_object_alignment_1 (ref->ref, align, bitpos);
/* When we just have ref->base we cannot use get_object_alignment since
- that will eventually use the type of the appearant access while for
+ that will eventually use the type of the apparent access while for
example ao_ref_init_from_ptr_and_range is not careful to adjust that. */
*align = BITS_PER_UNIT;
HOST_WIDE_INT offset;
@@ -1124,7 +1124,7 @@ component_ref_to_zero_sized_trailing_array_p (tree ref)
(which is a start of possibly aliasing access path REF1).
If match is found, try to disambiguate.
- Return 0 for sucessful disambiguation.
+ Return 0 for successful disambiguation.
Return 1 if match was found but disambiguation failed
Return -1 if there is no match.
In this case MAYBE_MATCH is set to 0 if there is no type matching TYPE1
@@ -1232,7 +1232,7 @@ access_path_may_continue_p (tree ref_type1, bool
end_struct_past_end1,
{
if (compare_type_sizes (ref_type1, base_type2) < 0)
return false;
- /* If the path2 contains trailing array access we can strenghten the
check
+ /* If the path2 contains trailing array access we can strengthen the
check
to verify that also the size of element of the trailing array fits.
In fact we could check for offset + type_size, but we do not track
offsets and this is quite side case. */
@@ -1462,7 +1462,7 @@ nonoverlapping_component_refs_p_1 (const_tree field1,
const_tree field2)
/* In common case the offsets and bit offsets will be the same.
However if frontends do not agree on the alignment, they may be
different even if they actually represent same address.
- Try the common case first and if that fails calcualte the
+ Try the common case first and if that fails calculate the
actual bit offset. */
if (tree_int_cst_equal (DECL_FIELD_OFFSET (field1),
DECL_FIELD_OFFSET (field2))
@@ -1546,7 +1546,7 @@ nonoverlapping_array_refs_p (tree ref1, tree ref2)
/* If type sizes are different, give up.
Avoid expensive array_ref_element_size.
- If operand 3 is present it denotes size in the alignmnet units.
+ If operand 3 is present it denotes size in the alignment units.
Otherwise size is TYPE_SIZE of the element type.
Handle only common cases where types are of the same "kind". */
if ((TREE_OPERAND (ref1, 3) == NULL) != (TREE_OPERAND (ref2, 3) == NULL))
@@ -2458,7 +2458,7 @@ refs_may_alias_p_2 (ao_ref *ref1, ao_ref *ref2, bool
tbaa_p)
ref2ref = TREE_OPERAND (ref2ref, 0);
/* Defer to simple offset based disambiguation if we have
- references based on two decls. Do this before defering to
+ references based on two decls. Do this before deferring to
TBAA to handle must-alias cases in conformance with the
GCC extension of allowing type-punning through unions. */
var1_p = DECL_P (base1);
@@ -2891,7 +2891,7 @@ ref_maybe_used_by_call_p_1 (gcall *call, ao_ref *ref,
bool tbaa_p)
if (callee != NULL_TREE)
{
struct cgraph_node *node = cgraph_node::get (callee);
- /* We can not safely optimize based on summary of calle if it does
+ /* We can not safely optimize based on summary of callee if it does
not always bind to current def: it is possible that memory load
was optimized out earlier and the interposed variant may not be
optimized this way. */
@@ -3554,7 +3554,7 @@ stmt_kills_ref_p (gimple *stmt, ao_ref *ref)
&& node->binds_to_current_def_p ()
&& (summary = get_modref_function_summary (node)) != NULL
&& summary->kills.length ()
- /* Check that we can not trap while evaulating function
+ /* Check that we can not trap while evaluating function
parameters. This check is overly conservative. */
&& (!cfun->can_throw_non_call_exceptions
|| (!stmt_can_throw_internal (cfun, stmt)
diff --git a/gcc/tree-ssa-ccp.cc b/gcc/tree-ssa-ccp.cc
index d9a41c2e135..425784be5ba 100644
--- a/gcc/tree-ssa-ccp.cc
+++ b/gcc/tree-ssa-ccp.cc
@@ -104,7 +104,7 @@ along with GCC; see the file COPYING3. If not see
precision of the type of the variable are always zero. The
uninteresting case is a variable of UNSIGNED type that has the
maximum precision of the target. Such variables can go to VARYING,
- but this causes no loss of infomation since these variables will
+ but this causes no loss of information since these variables will
never be extended.
References:
diff --git a/gcc/tree-ssa-dce.cc b/gcc/tree-ssa-dce.cc
index bc8ae6d10f9..548d5d4bd66 100644
--- a/gcc/tree-ssa-dce.cc
+++ b/gcc/tree-ssa-dce.cc
@@ -781,7 +781,7 @@ mark_all_reaching_defs_necessary_1 (ao_ref *ref
ATTRIBUTE_UNUSED,
return false;
}
- /* We want to skip statments that do not constitute stores but have
+ /* We want to skip statements that do not constitute stores but have
a virtual definition. */
if (gcall *call = dyn_cast <gcall *> (def_stmt))
{
@@ -949,7 +949,7 @@ propagate_necessity (bool aggressive)
Consider the modified CFG created from current CFG by splitting
edge B->C. In the postdominance tree of modified CFG, C' is
- always child of C. There are two cases how chlids of C' can look
+ always child of C. There are two cases how children of C' can look
like:
1) C' is leaf
@@ -968,12 +968,12 @@ propagate_necessity (bool aggressive)
case 2 happens iff there is no other way from B to C except
the edge B->C.
- There is other way from B to C iff there is succesor of B
that
+ There is other way from B to C iff there is successor of B
that
is not postdominated by B. Testing this condition is
somewhat
- expensive, because we need to iterate all succesors of B.
+ expensive, because we need to iterate all successors of B.
We are safe to assume that this does not happen: we will
mark B
as needed when processing the other path from B to C that is
- conrol dependent on B and marking control dependencies of B
+ control dependent on B and marking control dependencies of B
itself is harmless because they will be processed anyway
after
processing control statement in B.
@@ -1516,7 +1516,7 @@ propagate_counts ()
sum += e->count ();
gcc_checking_assert (!cnt.get (e->src));
}
- /* If we have partial profile and some counts of incomming edges are
+ /* If we have partial profile and some counts of incoming edges are
unknown, it is probably better to keep the existing count.
We could also propagate bi-directionally. */
if (sum.initialized_p () && !(sum == bb->count))
@@ -1626,7 +1626,7 @@ eliminate_unnecessary_stmts (bool aggressive)
}
/* Conditional checking that return value of allocation is non-NULL
can be turned to constant if the allocation itself
- is unnecesary. */
+ is unnecessary. */
if (gimple_plf (stmt, STMT_NECESSARY)
&& gimple_code (stmt) == GIMPLE_COND
&& TREE_CODE (gimple_cond_lhs (stmt)) == SSA_NAME)
diff --git a/gcc/tree-ssa-dom.cc b/gcc/tree-ssa-dom.cc
index 10a1c3f0b21..84e2f7e77cd 100644
--- a/gcc/tree-ssa-dom.cc
+++ b/gcc/tree-ssa-dom.cc
@@ -817,7 +817,7 @@ private:
gcond *m_dummy_cond;
/* Optimize a single statement within a basic block using the
- various tables mantained by DOM. Returns the taken edge if
+ various tables maintained by DOM. Returns the taken edge if
the statement is a conditional with a statically determined
value. */
edge optimize_stmt (basic_block, gimple_stmt_iterator *, bool *);
@@ -1030,7 +1030,7 @@ pass_dominator::execute (function *fun)
/* Fixup stmts that became noreturn calls. This may require splitting
blocks and thus isn't possible during the dominator walk or before
jump threading finished. Do this in reverse order so we don't
- inadvertedly remove a stmt we want to fixup by visiting a dominating
+ inadvertently remove a stmt we want to fixup by visiting a dominating
now noreturn call first. */
while (!need_noreturn_fixup.is_empty ())
{
diff --git a/gcc/tree-ssa-dse.cc b/gcc/tree-ssa-dse.cc
index 58cfa9ec129..7b42bfd9b06 100644
--- a/gcc/tree-ssa-dse.cc
+++ b/gcc/tree-ssa-dse.cc
@@ -103,7 +103,7 @@ static bitmap need_ab_cleanup;
Return TRUE if the statement was analyzed, FALSE otherwise.
- It is always safe to return FALSE. But typically better optimziation
+ It is always safe to return FALSE. But typically better optimization
can be achieved by analyzing more statements. */
static bool
diff --git a/gcc/tree-ssa-forwprop.cc b/gcc/tree-ssa-forwprop.cc
index 06eb81b9a28..412c10c1cb5 100644
--- a/gcc/tree-ssa-forwprop.cc
+++ b/gcc/tree-ssa-forwprop.cc
@@ -1464,7 +1464,7 @@ static tree
new_src_based_on_copy (tree src2, tree dest, tree src)
{
/* If the second src is not exactly the same as dest,
- try to handle it seperately; see it is address/size equivalent.
+ try to handle it separately; see it is address/size equivalent.
Handles `a` and `a.b` and `MEM<char[N]>(&a)` which all have
the same size and offsets as address/size equivalent.
This allows copying over a memcpy and also one for copying
@@ -1605,7 +1605,7 @@ optimize_agr_copyprop_1 (gimple *stmt, gimple *use_stmt,
src = new_src_based_on_copy (src2, dest, src);
if (!src)
return;
- /* For 2 memory refences and using a temporary to do the copy,
+ /* For 2 memory references and using a temporary to do the copy,
don't remove the temporary as the 2 memory references might overlap.
Note t does not need to be decl as it could be field.
See PR 22237 for full details.
@@ -5227,7 +5227,7 @@ public:
bool m_full_walk = false;
}; // class pass_forwprop
-/* Attemp to make the BB block of __builtin_unreachable unreachable by changing
+/* Attempt to make the BB block of __builtin_unreachable unreachable by
changing
the incoming jumps. Return true if at least one jump was changed. */
static bool
@@ -5943,7 +5943,7 @@ pass_forwprop::execute (function *fun)
propagate_value (use_p, val);
}
- /* Mark outgoing exectuable edges. */
+ /* Mark outgoing executable edges. */
if (edge e = find_taken_edge (bb, NULL))
{
e->flags |= EDGE_EXECUTABLE;
@@ -6005,7 +6005,7 @@ pass_forwprop::execute (function *fun)
/* Fixup stmts that became noreturn calls. This may require splitting
blocks and thus isn't possible during the walk. Do this
- in reverse order so we don't inadvertedly remove a stmt we want to
+ in reverse order so we don't inadvertently remove a stmt we want to
fixup by visiting a dominating now noreturn call first. */
while (!to_fixup.is_empty ())
{
diff --git a/gcc/tree-ssa-ifcombine.cc b/gcc/tree-ssa-ifcombine.cc
index a60e6914e68..6489abf3a06 100644
--- a/gcc/tree-ssa-ifcombine.cc
+++ b/gcc/tree-ssa-ifcombine.cc
@@ -1064,7 +1064,7 @@ tree_ssa_ifcombine_bb_1 (basic_block inner_cond_bb,
basic_block outer_cond_bb,
basic_block phi_pred_bb, basic_block outer_succ_bb)
{
/* The && form is characterized by a common else_bb with
- the two edges leading to it mergable. The latter is
+ the two edges leading to it mergeable. The latter is
guaranteed by matching PHI arguments in the else_bb and
the inner cond_bb having no side-effects. */
if (phi_pred_bb != else_bb
@@ -1400,7 +1400,7 @@ pass_tree_ifcombine::execute (function *fun)
We walk the blocks in order that guarantees that a block with
a single predecessor is processed after the predecessor.
- This ensures that we collapse outter ifs before visiting the
+ This ensures that we collapse outer ifs before visiting the
inner ones, and also that we do not try to visit a removed
block. This is opposite of PHI-OPT, because we cascade the
combining rather than cascading PHIs. */
diff --git a/gcc/tree-ssa-live.cc b/gcc/tree-ssa-live.cc
index af58bf1c289..0bf8ace1bc0 100644
--- a/gcc/tree-ssa-live.cc
+++ b/gcc/tree-ssa-live.cc
@@ -446,8 +446,8 @@ remove_unused_scope_block_p (tree scope, bool
in_ctor_dtor_block)
next = &DECL_CHAIN (*t);
/* Debug info of nested function refers to the block of the
- function. We might stil call it even if all statements
- of function it was nested into was elliminated.
+ function. We might still call it even if all statements
+ of function it was nested into was eliminated.
TODO: We can actually look into cgraph to see if function
will be output to file. */
@@ -582,7 +582,7 @@ remove_unused_scope_block_p (tree scope, bool
in_ctor_dtor_block)
else if (inlined_function_outer_scope_p (scope))
unused = false;
else
- /* Verfify that only blocks with source location set
+ /* Verify that only blocks with source location set
are entry points to the inlined functions. */
gcc_assert (LOCATION_LOCUS (BLOCK_SOURCE_LOCATION (scope))
== UNKNOWN_LOCATION);
diff --git a/gcc/tree-ssa-loop-ch.cc b/gcc/tree-ssa-loop-ch.cc
index 5fdb9a009c9..3e85f36681d 100644
--- a/gcc/tree-ssa-loop-ch.cc
+++ b/gcc/tree-ssa-loop-ch.cc
@@ -44,7 +44,7 @@ along with GCC; see the file COPYING3. If not see
#include "tree-ssa-loop-niter.h"
#include "tree-scalar-evolution.h"
-/* Return path query insteance for testing ranges of statements
+/* Return path query instance for testing ranges of statements
in headers of LOOP contained in basic block BB.
Use RANGER instance. */
@@ -171,7 +171,7 @@ loop_combined_static_and_iv_p (class loop *loop,
return gimple_uid (SSA_NAME_DEF_STMT (op)) & 4;
}
-/* Decision about posibility of copying a given header. */
+/* Decision about possibility of copying a given header. */
enum ch_decision
{
@@ -233,7 +233,7 @@ should_duplicate_loop_header_p (basic_block header, class
loop *loop,
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,
- " Not duplicating bb %i: it has mutiple predecestors.\n",
+ " Not duplicating bb %i: it has multiple predecestors.\n",
header->index);
return ch_impossible;
}
@@ -327,12 +327,12 @@ should_duplicate_loop_header_p (basic_block header, class
loop *loop,
size costs.
Similarly static computations will be optimized out in the
- duplicatd header. */
+ duplicated header. */
if (inv || static_p)
continue;
/* Match the following:
- _1 = i_1 < 10 <- static condtion
+ _1 = i_1 < 10 <- static condition
_2 = n != 0 <- loop invariant condition
_3 = _1 & _2 <- combined static and iv statement. */
tree_code code;
@@ -372,7 +372,7 @@ should_duplicate_loop_header_p (basic_block header, class
loop *loop,
code_size_cost = true;
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,
- " Acconting stmt as %i insns\n", insns);
+ " Accounting stmt as %i insns\n", insns);
if (*limit < 0)
{
if (dump_file && (dump_flags & TDF_DETAILS))
@@ -400,7 +400,7 @@ should_duplicate_loop_header_p (basic_block header, class
loop *loop,
/* Combined conditional is a result of if combining:
- _1 = i_1 < 10 <- static condtion
+ _1 = i_1 < 10 <- static condition
_2 = n != 0 <- loop invariant condition
_3 = _1 & _2 <- combined static and iv statement
if (_3 != 0) <- combined conditional
@@ -457,7 +457,7 @@ should_duplicate_loop_header_p (basic_block header, class
loop *loop,
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,
- " Will elliminate invariant exit %i->%i\n",
+ " Will eliminate invariant exit %i->%i\n",
e->src->index, e->dest->index);
invariant_exits->add (e);
}
@@ -500,7 +500,7 @@ should_duplicate_loop_header_p (basic_block header, class
loop *loop,
*limit -= insns;
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,
- " Acconting stmt as %i insns\n", insns);
+ " Accounting stmt as %i insns\n", insns);
if (*limit < 0)
{
if (dump_file && (dump_flags & TDF_DETAILS))
@@ -737,7 +737,7 @@ public:
/* opt_pass methods: */
bool gate (function *) final override { return flag_tree_ch != 0; }
- /* Initialize and finalize loop structures, copying headers inbetween. */
+ /* Initialize and finalize loop structures, copying headers in between. */
unsigned int execute (function *) final override;
opt_pass * clone () final override { return new pass_ch (m_ctxt); }
diff --git a/gcc/tree-ssa-loop-im.cc b/gcc/tree-ssa-loop-im.cc
index 4f7401e2d5d..20ed3d3afab 100644
--- a/gcc/tree-ssa-loop-im.cc
+++ b/gcc/tree-ssa-loop-im.cc
@@ -494,7 +494,7 @@ get_coldest_out_loop (class loop *outermost_loop, class
loop *loop,
|| flow_loop_nested_p (outermost_loop, loop));
/* If bb_colder_than_loop_preheader returns false due to three-state
- comparision, OUTERMOST_LOOP is returned finally to preserve the behavior.
+ comparison, OUTERMOST_LOOP is returned finally to preserve the behavior.
Otherwise, return the coldest loop between OUTERMOST_LOOP and LOOP. */
if (curr_bb && bb_colder_than_loop_preheader (curr_bb, loop))
return NULL;
@@ -856,7 +856,7 @@ determine_max_movement (gimple *stmt, bool
must_preserve_exec)
if (!extract_true_false_args_from_phi (dom, phi, NULL, NULL))
return false;
- /* Check if one of the depedent statement is a vector compare whether
+ /* Check if one of the dependent statement is a vector compare whether
the target supports it, otherwise it's invalid to hoist it out of
the gcond it belonged to. */
if (VECTOR_TYPE_P (TREE_TYPE (gimple_cond_lhs (cond))))
@@ -2417,7 +2417,7 @@ execute_sm_exit (class loop *loop, edge ex,
vec<seq_entry> &seq,
tree lhs = gimple_assign_lhs (ref->accesses_in_loop[0].stmt);
if (dump_file && (dump_flags & TDF_DETAILS))
{
- fprintf (dump_file, "Re-issueing dependent ");
+ fprintf (dump_file, "Re-issuing dependent ");
print_generic_expr (dump_file, unshare_expr (seq[i-1].from));
fprintf (dump_file, " of ");
print_generic_expr (dump_file, lhs);
@@ -2432,7 +2432,7 @@ execute_sm_exit (class loop *loop, edge ex,
vec<seq_entry> &seq,
{
if (dump_file && (dump_flags & TDF_DETAILS))
{
- fprintf (dump_file, "Re-issueing dependent store of ");
+ fprintf (dump_file, "Re-issuing dependent store of ");
print_generic_expr (dump_file, ref->mem.ref);
fprintf (dump_file, " from loop %d on exit %d -> %d\n",
loop->num, ex->src->index, ex->dest->index);
@@ -2463,7 +2463,7 @@ execute_sm_exit (class loop *loop, edge ex,
vec<seq_entry> &seq,
/* Push the SM candidate at index PTR in the sequence SEQ down until
we hit the next SM candidate. Return true if that went OK and
- false if we could not disambiguate agains another unrelated ref.
+ false if we could not disambiguate against another unrelated ref.
Update *AT to the index where the candidate now resides. */
static bool
@@ -2779,7 +2779,7 @@ hoist_memory_references (class loop *loop, bitmap
mem_refs,
bitmap_iterator bi;
/* There's a special case we can use ordered re-materialization for
- conditionally excuted stores which is when all stores in the loop
+ conditionally executed stores which is when all stores in the loop
happen in the same basic-block. In that case we know we'll reach
all stores and thus can simply process that BB and emit a single
conditional block of ordered materializations. See PR102436. */
diff --git a/gcc/tree-ssa-loop-ivcanon.cc b/gcc/tree-ssa-loop-ivcanon.cc
index fb2ef44a3d3..c35a49189a1 100644
--- a/gcc/tree-ssa-loop-ivcanon.cc
+++ b/gcc/tree-ssa-loop-ivcanon.cc
@@ -254,7 +254,7 @@ constant_after_peeling (tree op, gimple *stmt, class loop
*loop)
}
/* Computes an estimated number of insns in LOOP.
- EXIT (if non-NULL) is an exite edge that will be eliminated in all but last
+ EXIT (if non-NULL) is an exit edge that will be eliminated in all but last
iteration of the loop.
EDGE_TO_CANCEL (if non-NULL) is an non-exit edge eliminated in the last
iteration
of loop.
@@ -514,7 +514,7 @@ loop_edge_to_cancel (class loop *loop)
FOR_EACH_VEC_ELT (exits, i, edge_to_cancel)
{
/* Find the other edge than the loop exit
- leaving the conditoinal. */
+ leaving the conditional. */
if (EDGE_COUNT (edge_to_cancel->src->succs) != 2)
continue;
if (EDGE_SUCC (edge_to_cancel->src, 0) == edge_to_cancel)
@@ -674,7 +674,7 @@ static bitmap peeled_loops;
IRRED_INVALIDATED is used to bookkeep if information about
irreducible regions may become invalid as a result
of the transformation.
- LOOP_CLOSED_SSA_INVALIDATED is used to bookkepp the case
+ LOOP_CLOSED_SSA_INVALIDATED is used to bookkeep the case
when we need to go into loop closed SSA form. */
void
@@ -737,7 +737,7 @@ unloop_loops (vec<class loop *> &loops_to_unloop,
/* Tries to unroll LOOP completely, i.e. NITER times.
UL determines which loops we are allowed to unroll.
EXIT is the exit of the loop that should be eliminated.
- MAXITER specfy bound on number of iterations, -1 if it is
+ MAXITER specify bound on number of iterations, -1 if it is
not known or too large for HOST_WIDE_INT. The location
LOCUS corresponding to the loop is used when emitting
a summary of the unroll to the dump file. */
@@ -871,7 +871,7 @@ try_unroll_loop_completely (class loop *loop,
<= ninsns + (size.constant_iv != false))
;
/* We unroll only inner loops, because we do not consider it
- profitable otheriwse. We still can cancel loopback edge
+ profitable otherwise. We still can cancel loopback edge
of not rolling loop; this is always a good idea. */
else if (ul == UL_NO_GROWTH)
{
@@ -1067,7 +1067,7 @@ adjust_loop_info_after_peeling (class loop *loop, int
npeel, bool precise)
iterations are special, it is not quite correct to
assume that the remaining iterations will behave
the same way. However we do not have better info
- so update the esitmate, since it is likely better
+ so update the estimate, since it is likely better
than keeping it as it is.
Remove it if it looks wrong.
@@ -1528,7 +1528,7 @@ tree_unroll_loops_completely_1 (bool may_increase_size,
bool unroll_outer,
/* Unroll LOOPS completely if they iterate just few times. Unless
MAY_INCREASE_SIZE is true, perform the unrolling only if the
size of the code does not increase.
- cunrolli is true when passs is cunrolli. */
+ cunrolli is true when pass is cunrolli. */
static unsigned int
tree_unroll_loops_completely (bool may_increase_size, bool unroll_outer, bool
cunrolli)
diff --git a/gcc/tree-ssa-loop-ivopts.cc b/gcc/tree-ssa-loop-ivopts.cc
index 776487d0f8b..4ca55325188 100644
--- a/gcc/tree-ssa-loop-ivopts.cc
+++ b/gcc/tree-ssa-loop-ivopts.cc
@@ -524,7 +524,7 @@ struct iv_inv_expr_ent
{
/* Tree expression of the entry. */
tree expr;
- /* Unique indentifier. */
+ /* Unique identifier. */
int id;
/* Hash value. */
hashval_t hash;
@@ -869,7 +869,7 @@ dump_cand (FILE *file, struct iv_cand *cand)
if (cand->var_before)
{
- fprintf (file, " Var befor: ");
+ fprintf (file, " Var before: ");
print_generic_expr (file, cand->var_before, TDF_SLIM);
fprintf (file, "\n");
}
@@ -2578,7 +2578,7 @@ group_compare_offset (const void *a, const void *b)
contains more than two uses with distinct addr_offsets. Return
false otherwise. We want to split such groups because:
- 1) Small groups don't have much benefit and may interfer with
+ 1) Small groups don't have much benefit and may interfere with
general candidate selection.
2) Size for problem with only small groups is usually small and
general algorithm can handle it well.
@@ -2658,7 +2658,7 @@ split_address_groups (struct ivopts_data *data)
struct iv_use *next = group->vuses[j];
poly_int64 offset = next->addr_offset - use->addr_offset;
- /* Split group if aksed to, or the offset against the first
+ /* Split group if asked to, or the offset against the first
use can't fit in offset part of addressing mode. IV uses
having the same offset are still kept in one group. */
if (maybe_ne (offset, 0)
@@ -3997,7 +3997,7 @@ get_computation_aff_1 (struct ivopts_data *data, gimple
*at, struct iv_use *use,
inner_type = TREE_TYPE (inner_base);
/* If candidate is added from a biv whose type is smaller than
ctype, we know both candidate and the biv won't overflow.
- In this case, it's safe to skip the convertion in candidate.
+ In this case, it's safe to skip the conversion in candidate.
As an example, (unsigned short)((unsigned long)A) equals to
(unsigned short)A, if A has a type no larger than short. */
if (TYPE_PRECISION (inner_type) <= TYPE_PRECISION (uutype))
@@ -6626,7 +6626,7 @@ iv_ca_dump (struct ivopts_data *data, FILE *file, class
iv_ca *ivs)
/* Try changing candidate in IVS to CAND for each use. Return cost of the
new set, and store differences in DELTA. Number of induction variables
in the new set is stored to N_IVS. MIN_NCAND is a flag. When it is true
- the function will try to find a solution with mimimal iv candidates. */
+ the function will try to find a solution with minimal iv candidates. */
static comp_cost
iv_ca_extend (struct ivopts_data *data, class iv_ca *ivs,
diff --git a/gcc/tree-ssa-loop-niter.cc b/gcc/tree-ssa-loop-niter.cc
index c39401147ae..87807e49f52 100644
--- a/gcc/tree-ssa-loop-niter.cc
+++ b/gcc/tree-ssa-loop-niter.cc
@@ -1031,7 +1031,7 @@ number_of_iterations_ne (class loop *loop, tree type,
affine_iv *iv,
Note, for NE_EXPR, base equals to FINAL is a special case, in
which the loop exits immediately, and the iv does not overflow.
- Also note, we prove condition 2) by checking base and final seperately
+ Also note, we prove condition 2) by checking base and final separately
along with condition 1) or 1'). Since we ensure the difference
computation of c does not wrap with cond below and the adjusted s
will fit a signed type as well as an unsigned we can safely do
@@ -2130,7 +2130,7 @@ number_of_iterations_popcount (loop_p loop, edge exit,
/* Check that _1 is defined by (_1 = iv_1 + -1).
Also make sure that _1 is the same in and_stmt and _1 defining stmt.
- Also canonicalize if _1 and _b11 are revrsed. */
+ Also canonicalize if _1 and _b11 are reversed. */
if (ssa_defined_by_minus_one_stmt_p (iv_1, _1))
std::swap (iv_1, _1);
else if (ssa_defined_by_minus_one_stmt_p (_1, iv_1))
@@ -4362,7 +4362,7 @@ idx_infer_loop_bounds (tree base, tree *idx, void *dta)
&& tree_int_cst_compare (next, high) <= 0)
return true;
- /* If access is not executed on every iteration, we must ensure that overlow
+ /* If access is not executed on every iteration, we must ensure that overflow
may not make the access valid later. */
if (!dominated_by_p (CDI_DOMINATORS, loop->latch, gimple_bb (data->stmt)))
{
@@ -4538,7 +4538,7 @@ infer_loop_bounds_from_signedness (class loop *loop,
gimple *stmt)
record_nonwrapping_iv (loop, base, step, stmt, low, high, false, true);
}
-/* The following analyzers are extracting informations on the bounds
+/* The following analyzers are extracting information on the bounds
of LOOP from the following undefined behaviors:
- data references should not access elements over the statically
@@ -4737,7 +4737,7 @@ discover_iteration_bound_by_body_walk (class loop *loop)
if (entry && *entry < bound_index)
bound_index = *entry;
- /* Insert succesors into the queue, watch for latch edge
+ /* Insert successors into the queue, watch for latch edge
and record greatest index we saw. */
FOR_EACH_EDGE (e, ei, bb->succs)
{
@@ -4785,7 +4785,7 @@ discover_iteration_bound_by_body_walk (class loop *loop)
}
/* See if every path cross the loop goes through a statement that is known
- to not execute at the last iteration. In that case we can decrese iteration
+ to not execute at the last iteration. In that case we can decrease iteration
count by 1. */
static void
@@ -5573,7 +5573,7 @@ loop_exits_before_overflow (tree base, tree step,
}
VAR _6 doesn't overflow only with pre-condition (i_21 != 0), here we
- can't use _6 to prove no-overlfow for _7. In fact, var _7 takes value
+ can't use _6 to prove no-overflow for _7. In fact, var _7 takes value
sequence (4294967295, 0, 1, ..., 65533) in loop life time, rather than
(4294967295, 4294967296, ...). */
diff --git a/gcc/tree-ssa-loop-niter.h b/gcc/tree-ssa-loop-niter.h
index d2e7b5e4be1..643ac1d7f7f 100644
--- a/gcc/tree-ssa-loop-niter.h
+++ b/gcc/tree-ssa-loop-niter.h
@@ -1,4 +1,4 @@
-/* Header file for loop interation estimates.
+/* Header file for loop iteration estimates.
Copyright (C) 2013-2026 Free Software Foundation, Inc.
This file is part of GCC.
diff --git a/gcc/tree-ssa-loop-prefetch.cc b/gcc/tree-ssa-loop-prefetch.cc
index c1a1ff31fc0..c5437cfdc84 100644
--- a/gcc/tree-ssa-loop-prefetch.cc
+++ b/gcc/tree-ssa-loop-prefetch.cc
@@ -131,7 +131,7 @@ along with GCC; see the file COPYING3. If not see
heuristic that disables prefetching in a loop if the prefetching
cost is above a certain limit. The relative prefetching cost is
estimated by taking the ratio between the prefetch count and the
- total intruction count (this models the I-cache cost).
+ total instruction count (this models the I-cache cost).
The limits used in these heuristics are defined as parameters with
reasonable default values. Machine-specific default values will be
@@ -1015,7 +1015,7 @@ should_issue_prefetch_p (struct mem_ref *ref)
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,
"Step for reference %u:%u (" HOST_WIDE_INT_PRINT_DEC
- ") is less than the mininum required stride of %d\n",
+ ") is less than the minimum required stride of %d\n",
ref->group->uid, ref->uid, int_cst_value (ref->group->step),
param_prefetch_minimum_stride);
return false;
@@ -1081,7 +1081,7 @@ schedule_prefetches (struct mem_ref_group *groups,
unsigned unroll_factor,
continue;
/* The loop is far from being sufficiently unrolled for this
- prefetch. Do not generate prefetch to avoid many redudant
+ prefetch. Do not generate prefetch to avoid many redundant
prefetches. */
if (ref->prefetch_mod / unroll_factor >
PREFETCH_MOD_TO_UNROLL_FACTOR_RATIO)
continue;
diff --git a/gcc/tree-ssa-loop-split.cc b/gcc/tree-ssa-loop-split.cc
index 722383a420a..ea2d8152999 100644
--- a/gcc/tree-ssa-loop-split.cc
+++ b/gcc/tree-ssa-loop-split.cc
@@ -547,7 +547,7 @@ fix_loop_bb_probability (class loop *loop1, class loop
*loop2, edge true_edge,
bbs2 = get_loop_body (loop2);
for (j = 0; j < loop2->num_nodes; j++)
if (bbs2[j] == loop2->latch
- /* Watch for case where the flase conditional is empty. */
+ /* Watch for case where the false conditional is empty. */
|| !single_pred_p (bbi_copy)
|| !dominated_by_p (CDI_DOMINATORS, bbs2[j], bbi_copy))
bbs2[j]->count
@@ -718,7 +718,7 @@ split_loop (class loop *loop1)
they increase expected loop count, so account this accordingly.
If we do not know the probability of split conditional, avoid
reudcing loop estimates, since we do not really know how they are
- split between of the two new loops. Keep orignal estimate since
+ split between of the two new loops. Keep original estimate since
it is likely better then completely dropping it.
TODO: If we know that one of the new loops has constant
@@ -733,7 +733,7 @@ split_loop (class loop *loop1)
? false_edge->probability.to_sreal () : (sreal)1;
sreal div1 = loop1_prob.initialized_p ()
? loop1_prob.to_sreal () : (sreal)1/(sreal)2;
- /* +1 to get header interations rather than latch iterations and
then
+ /* +1 to get header iterations rather than latch iterations and then
-1 to convert back. */
if (div1 != 0)
loop1->nb_iterations_estimate
@@ -944,7 +944,7 @@ find_vdef_in_loop (struct loop *loop)
/* Two basic blocks have equivalent control dependency if one dominates to
the other, and it is post-dominated by the latter. Given a basic block
- BB in LOOP, find farest equivalent dominating basic block. For BB, there
+ BB in LOOP, find farthest equivalent dominating basic block. For BB, there
is a constraint that BB does not post-dominate loop header of LOOP, this
means BB is control-dependent on at least one basic block in LOOP. */
@@ -1620,7 +1620,7 @@ get_cond_branch_to_split_loop (struct loop *loop, gcond
*cond)
In the graph, loop1 represents the part derived from original one, and
loop2 is duplicated using loop_version (), which corresponds to the part
- of original one being splitted out. In original latch edge of loop1, we
+ of original one being split out. In original latch edge of loop1, we
insert a new conditional statement duplicated from the semi-invariant cond,
and one of its branch goes back to loop1 header as a latch edge, and the
other branch goes to loop2 pre-header as an entry edge. And also in loop2,
diff --git a/gcc/tree-ssa-math-opts.cc b/gcc/tree-ssa-math-opts.cc
index cd3fd2fc8fb..abb1e251883 100644
--- a/gcc/tree-ssa-math-opts.cc
+++ b/gcc/tree-ssa-math-opts.cc
@@ -1582,7 +1582,7 @@ powi_as_mults (gimple_stmt_iterator *gsi, location_t loc,
/* ARG0 and N are the two arguments to a powi builtin in GSI with
location info LOC. If the arguments are appropriate, create an
equivalent sequence of statements prior to GSI using an optimal
- number of multiplications, and return an expession holding the
+ number of multiplications, and return an expression holding the
result. */
static tree
@@ -1999,7 +1999,7 @@ expand_pow_as_sqrts (gimple_stmt_iterator *gsi,
location_t loc,
/* ARG0 and ARG1 are the two arguments to a pow builtin call in GSI
with location info LOC. If possible, create an equivalent and
less expensive sequence of statements prior to GSI, and return an
- expession holding the result. */
+ expression holding the result. */
static tree
gimple_expand_builtin_pow (gimple_stmt_iterator *gsi, location_t loc,
@@ -2098,7 +2098,7 @@ gimple_expand_builtin_pow (gimple_stmt_iterator *gsi,
location_t loc,
/* Attempt to expand the POW as a product of square root chains.
- Expand the 0.25 case even when otpimising for size. */
+ Expand the 0.25 case even when optimising for size. */
if (flag_unsafe_math_optimizations
&& sqrtfn
&& hw_sqrt_exists
@@ -2739,7 +2739,7 @@ convert_mult_to_widen (gimple *stmt, gimple_stmt_iterator
*gsi)
return false;
/* if any one of rhs1 and rhs2 is subject to abnormal coalescing,
- avoid the tranform. */
+ avoid the transform. */
if ((TREE_CODE (rhs1) == SSA_NAME
&& SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rhs1))
|| (TREE_CODE (rhs2) == SSA_NAME
@@ -2804,7 +2804,7 @@ convert_mult_to_widen (gimple *stmt, gimple_stmt_iterator
*gsi)
}
}
- /* Ensure that the inputs to the handler are in the correct precison
+ /* Ensure that the inputs to the handler are in the correct precision
for the opcode. This will be the full mode size. */
actual_precision = GET_MODE_PRECISION (actual_mode);
if (2 * actual_precision > TYPE_PRECISION (type))
@@ -3052,7 +3052,7 @@ convert_plusminus_to_widen (gimple_stmt_iterator *gsi,
gimple *stmt,
if (handler == CODE_FOR_nothing)
return false;
- /* Ensure that the inputs to the handler are in the correct precison
+ /* Ensure that the inputs to the handler are in the correct precision
for the opcode. This will be the full mode size. */
actual_precision = GET_MODE_PRECISION (actual_mode);
if (actual_precision != TYPE_PRECISION (type1)
diff --git a/gcc/tree-ssa-phiopt.cc b/gcc/tree-ssa-phiopt.cc
index e654e823636..6c2f15e5c60 100644
--- a/gcc/tree-ssa-phiopt.cc
+++ b/gcc/tree-ssa-phiopt.cc
@@ -102,7 +102,7 @@ replace_phi_edge_with_variable (basic_block cond_block,
/* Duplicate range info if they are the only things setting the target PHI.
This is needed as later on, the new_tree will be replacing
- The assignement of the PHI.
+ The assignment of the PHI.
For an example:
bb1:
_4 = min<a_1, 255>
@@ -333,7 +333,7 @@ factor_out_conditional_operation (edge e0, edge e1,
basic_block merge,
gcc_assert (arg0 != NULL_TREE && arg1 != NULL_TREE);
- /* Arugments that are the same don't have anything to be
+ /* Arguments that are the same don't have anything to be
done to them. */
if (operand_equal_for_phi_arg_p (arg0, arg1))
return false;
@@ -491,7 +491,7 @@ factor_out_conditional_operation (edge e0, edge e1,
basic_block merge,
}
new_arg1 = fold_convert (TREE_TYPE (new_arg0), arg1);
- /* Drop the overlow that fold_convert might add. */
+ /* Drop the overflow that fold_convert might add. */
if (TREE_OVERFLOW (new_arg1))
new_arg1 = drop_tree_overflow (new_arg1);
@@ -3171,7 +3171,7 @@ cond_if_else_store_replacement_1 (basic_block then_bb,
basic_block else_bb,
if (!is_gimple_reg_type (TREE_TYPE (lhs)))
{
- /* Handle clobbers seperately as operand_equal_p does not check
+ /* Handle clobbers separately as operand_equal_p does not check
the kind of the clobbers being the same. */
if (TREE_CLOBBER_P (then_rhs) && TREE_CLOBBER_P (else_rhs))
{
@@ -3876,7 +3876,7 @@ execute_over_cond_phis (func_type func)
This fully replaces the old "Conditional Replacement",
"ABS Replacement" and "MIN/MAX Replacement" transformations as they are now
- implmeneted in match.pd.
+ implemented in match.pd.
Value Replacement
-----------------
diff --git a/gcc/tree-ssa-phiprop.cc b/gcc/tree-ssa-phiprop.cc
index 54f3ad8d9f8..07fe70b75fe 100644
--- a/gcc/tree-ssa-phiprop.cc
+++ b/gcc/tree-ssa-phiprop.cc
@@ -560,7 +560,7 @@ propagate_with_phi (basic_block bb, gphi *vphi, gphi *phi,
phiprop_insert_phi (bb, phi, use_stmt, phivn, n,
dce_ssa_names, other_vuse);
- /* Remove old stmt. The phi and all of maybe its depedencies
+ /* Remove old stmt. The phi and all of maybe its dependencies
will be removed later via simple_dce_from_worklist. */
gsi = gsi_for_stmt (use_stmt);
/* Unlinking the VDEF here is fine as we are sure that we process
@@ -599,7 +599,7 @@ propagate_with_phi (basic_block bb, gphi *vphi, gphi *phi,
phivn[SSA_NAME_VERSION (ptr)].value = res;
phivn[SSA_NAME_VERSION (ptr)].vuse = vuse;
- /* Remove old stmt. The phi and all of maybe its depedencies
+ /* Remove old stmt. The phi and all of maybe its dependencies
will be removed later via simple_dce_from_worklist. */
gsi = gsi_for_stmt (use_stmt);
gsi_remove (&gsi, true);
diff --git a/gcc/tree-ssa-pre.cc b/gcc/tree-ssa-pre.cc
index 0e5eaf86bc7..4d414d05c6d 100644
--- a/gcc/tree-ssa-pre.cc
+++ b/gcc/tree-ssa-pre.cc
@@ -455,7 +455,7 @@ get_or_alloc_expr_for_nary (vn_nary_op_t nary, unsigned
value_id,
/* Given an REFERENCE, get or create a pre_expr to represent it. Assign
VALUE_ID to it or allocate a new value-id if it is zero. Record
LOC as the original location of the expression. If MOVE_OPERANDS
- is true then ownership of REFERENCE->operands is transfered, otherwise
+ is true then ownership of REFERENCE->operands is transferred, otherwise
a copy is made if necessary. */
static pre_expr
@@ -1053,7 +1053,7 @@ sorted_array_from_bitmap_set (bitmap_set_t set, bool
for_insertion)
}
else
{
- /* If neither works for pairwise chosing a conservative
+ /* If neither works for pairwise choosing a conservative
alternative, drop all REFERENCE expressions for this value.
REFERENCE are always toplevel, so no chain should be
interrupted by pruning them. */
@@ -2020,7 +2020,7 @@ value_dies_in_block_x (pre_expr expr, basic_block block)
/* A memory expression {e, VUSE} dies in the block if there is a
statement that may clobber e. If, starting statement walk from the
top of the basic block, a statement uses VUSE there can be no kill
- inbetween that use and the original statement that loaded {e, VUSE},
+ in between that use and the original statement that loaded {e, VUSE},
so we can stop walking. */
ref.base = NULL_TREE;
for (gsi = gsi_start_bb (block); !gsi_end_p (gsi); gsi_next (&gsi))
@@ -2410,7 +2410,7 @@ compute_antic_aux (basic_block block, bool
block_has_abnormal_pred_edge)
bitmap_ior_into (&ANTIC_IN (block)->values, &S->values);
bitmap_ior_into (&ANTIC_IN (block)->expressions, &S->expressions);
- /* clean (ANTIC_IN (block)) is defered to after the iteration converged
+ /* clean (ANTIC_IN (block)) is deferred to after the iteration converged
because it can cause non-convergence, see for example PR81181. */
if (was_visited
diff --git a/gcc/tree-ssa-propagate.cc b/gcc/tree-ssa-propagate.cc
index a87c45d3a12..ab265c5b57a 100644
--- a/gcc/tree-ssa-propagate.cc
+++ b/gcc/tree-ssa-propagate.cc
@@ -699,7 +699,7 @@ private:
/* Call post_new_stmt for each new statement that has been added
to the current BB. OLD_GSI is the statement iterator before the BB
- changes ocurred. NEW_GSI is the iterator which may contain new
+ changes occurred. NEW_GSI is the iterator which may contain new
statements. */
void
@@ -1011,7 +1011,7 @@ substitute_and_fold_engine::substitute_and_fold
(basic_block block)
/* Fixup stmts that became noreturn calls. This may require splitting
blocks and thus isn't possible during the dominator walk. Do this
- in reverse order so we don't inadvertedly remove a stmt we want to
+ in reverse order so we don't inadvertently remove a stmt we want to
fixup by visiting a dominating now noreturn call first. */
while (!walker.stmts_to_fixup.is_empty ())
{
diff --git a/gcc/tree-ssa-reassoc.cc b/gcc/tree-ssa-reassoc.cc
index 7abbf195520..3117b77ef95 100644
--- a/gcc/tree-ssa-reassoc.cc
+++ b/gcc/tree-ssa-reassoc.cc
@@ -481,7 +481,7 @@ get_rank (tree e)
/* Otherwise, find the maximum rank for the operands. As an
exception, remove the bias from loop-carried phis when propagating
the rank so that dependent operations are not also biased. */
- /* Simply walk over all SSA uses - this takes advatage of the
+ /* Simply walk over all SSA uses - this takes advantage of the
fact that non-SSA operands are is_gimple_min_invariant and
thus have rank 0. */
rank = 0;
@@ -5169,10 +5169,10 @@ remove_visited_stmt_chain (tree var)
}
}
-/* This function checks three consequtive operands in
+/* This function checks three consecutive operands in
passed operands vector OPS starting from OPINDEX and
swaps two operands if it is profitable for binary operation
- consuming OPINDEX + 1 abnd OPINDEX + 2 operands.
+ consuming OPINDEX + 1 and OPINDEX + 2 operands.
We pair ops with the same rank if possible. */
diff --git a/gcc/tree-ssa-sccvn.cc b/gcc/tree-ssa-sccvn.cc
index e19beb439d2..c99303ce500 100644
--- a/gcc/tree-ssa-sccvn.cc
+++ b/gcc/tree-ssa-sccvn.cc
@@ -840,7 +840,7 @@ vn_reference_eq (const_vn_reference_t const vr1,
const_vn_reference_t const vr2,
/* Vector boolean types can have padding, verify we are dealing with
the same number of elements, aka the precision of the types.
For example, In most architecture the precision_size of vbool*_t
- types are caculated like below:
+ types are calculated like below:
precision_size = type_size * 8
Unfortunately, the RISC-V will adjust the precision_size for the
@@ -4357,7 +4357,7 @@ vn_reference_lookup_call (gcall *call, vn_reference_t
*vnresult,
vr->vuse = vuse ? SSA_VAL (vuse) : NULL_TREE;
vr->operands = valueize_shared_reference_ops_from_call (call);
tree lhs = gimple_call_lhs (call);
- /* For non-SSA return values the referece ops contain the LHS. */
+ /* For non-SSA return values the reference ops contain the LHS. */
vr->type = ((lhs && TREE_CODE (lhs) == SSA_NAME)
? TREE_TYPE (lhs) : NULL_TREE);
vr->punned = false;
@@ -4545,7 +4545,7 @@ vn_nary_op_eq (const_vn_nary_op_t const vno1,
const_vn_nary_op_t const vno2)
if (!expressions_equal_p (vno1->op[i], vno2->op[i]))
return false;
- /* BIT_INSERT_EXPR has an implict operand as the type precision
+ /* BIT_INSERT_EXPR has an implicit operand as the type precision
of op1. Need to check to make sure they are the same. */
if (vno1->opcode == BIT_INSERT_EXPR
&& TREE_CODE (vno1->op[1]) == INTEGER_CST
@@ -4852,7 +4852,7 @@ vn_nary_op_insert_into (vn_nary_op_t vno,
vn_nary_op_table_type *table)
return *slot;
}
- /* ??? There's also optimistic vs. previous commited state merging
+ /* ??? There's also optimistic vs. previous committed state merging
that is problematic for the case of unwinding. */
/* ??? We should return NULL if we do not use 'vno' and have the
@@ -5929,7 +5929,7 @@ visit_reference_op_call (tree lhs, gcall *stmt)
&& summary->load_accesses < accesses_limit)
|| gimple_call_flags (stmt) & ECF_CONST))
{
- /* First search if we can do someting useful and build a
+ /* First search if we can do something useful and build a
vector of all loads we have to check. */
bool unknown_memory_access = false;
auto_vec<ao_ref, accesses_limit> accesses;
@@ -6476,7 +6476,7 @@ visit_phi (gimple *phi, bool *inserted, bool
backedges_varying_p)
the hashes. */
result = PHI_RESULT (phi);
/* If none of the edges was executable keep the value-number at VN_TOP,
- if only a single edge is exectuable use its value. */
+ if only a single edge is executable use its value. */
else if (n_executable <= 1)
result = seen_undef ? seen_undef : sameval;
/* If we saw only undefined values and VN_TOP use one of the
@@ -7559,7 +7559,7 @@ eliminate_dom_walker::eliminate_stmt (basic_block b,
gimple_stmt_iterator *gsi)
gsi_prev (&prev);
if (fold_stmt (gsi, follow_all_ssa_edges))
{
- /* fold_stmt may have created new stmts inbetween
+ /* fold_stmt may have created new stmts in between
the previous stmt and the folded stmt. Mark
all defs created there as varying to not confuse
the SCCVN machinery as we're using that even during
@@ -7916,7 +7916,7 @@ eliminate_dom_walker::eliminate_cleanup (bool region_p)
/* Fixup stmts that became noreturn calls. This may require splitting
blocks and thus isn't possible during the dominator walk. Do this
- in reverse order so we don't inadvertedly remove a stmt we want to
+ in reverse order so we don't inadvertently remove a stmt we want to
fixup by visiting a dominating now noreturn call first. */
while (!to_fixup.is_empty ())
{
@@ -8530,7 +8530,7 @@ process_bb (rpo_elim &avail, basic_block bb,
tree val = gimple_simplify (cmpcode,
boolean_type_node, lhs, rhs,
NULL, vn_valueize);
- /* If the condition didn't simplfy see if we have recorded
+ /* If the condition didn't simplify see if we have recorded
an expression from sofar taken edges. */
if (! val || TREE_CODE (val) != INTEGER_CST)
{
diff --git a/gcc/tree-ssa-scopedtables.cc b/gcc/tree-ssa-scopedtables.cc
index 828f214c7cb..242d3f0e7cc 100644
--- a/gcc/tree-ssa-scopedtables.cc
+++ b/gcc/tree-ssa-scopedtables.cc
@@ -664,7 +664,7 @@ hashable_expr_equal_p (const struct hashable_expr *expr0,
expr1->ops.ternary.opnd2, 0))
return false;
- /* BIT_INSERT_EXPR has an implict operand as the type precision
+ /* BIT_INSERT_EXPR has an implicit operand as the type precision
of op1. Need to check to make sure they are the same. */
if (expr0->ops.ternary.op == BIT_INSERT_EXPR
&& TREE_CODE (expr0->ops.ternary.opnd1) == INTEGER_CST
diff --git a/gcc/tree-ssa-structalias.cc b/gcc/tree-ssa-structalias.cc
index e4a185d0f84..ab6658a0981 100644
--- a/gcc/tree-ssa-structalias.cc
+++ b/gcc/tree-ssa-structalias.cc
@@ -313,7 +313,7 @@ determine_global_memory_access (gcall *stmt,
cgraph_node *node;
modref_summary *summary;
- /* We need to detrmine reads to set uses. */
+ /* We need to determine reads to set uses. */
gcc_assert (!uses_global_memory || reads_global_memory);
if ((callee = gimple_call_fndecl (stmt)) != NULL_TREE
@@ -1555,7 +1555,7 @@ clear_dependence_clique (gimple *, tree base, tree, void
*data)
return false;
}
-/* Compute the set of independend memory references based on restrict
+/* Compute the set of independent memory references based on restrict
tags and their conservative propagation to the points-to sets. */
static void
diff --git a/gcc/tree-ssa-threadbackward.cc b/gcc/tree-ssa-threadbackward.cc
index d4b3734304d..895b2fa8164 100644
--- a/gcc/tree-ssa-threadbackward.cc
+++ b/gcc/tree-ssa-threadbackward.cc
@@ -701,7 +701,7 @@ back_threader_profitability::possibly_profitable_path_p
/* Threading is profitable if the path duplicated is hot but also
in a case we separate cold path from hot path and permit optimization
- of the hot path later. Be on the agressive side here. In some testcases,
+ of the hot path later. Be on the aggressive side here. In some testcases,
as in PR 78407 this leads to noticeable improvements. */
if (m_speed_p)
{
@@ -794,7 +794,7 @@ back_threader_profitability::profitable_path_p (const
vec<basic_block> &m_path,
/* Threading is profitable if the path duplicated is hot but also
in a case we separate cold path from hot path and permit optimization
- of the hot path later. Be on the agressive side here. In some testcases,
+ of the hot path later. Be on the aggressive side here. In some testcases,
as in PR 78407 this leads to noticeable improvements. */
if (m_speed_p
&& (optimize_edge_for_speed_p (taken_edge) || m_contains_hot_bb))
diff --git a/gcc/tree-ssa-threadedge.cc b/gcc/tree-ssa-threadedge.cc
index 9fc0c5ed2a2..69e01c83e67 100644
--- a/gcc/tree-ssa-threadedge.cc
+++ b/gcc/tree-ssa-threadedge.cc
@@ -658,7 +658,7 @@ propagate_threaded_block_debug_into (basic_block dest,
basic_block src)
fewvars.release ();
}
-/* See if TAKEN_EDGE->dest is a threadable block with no side effecs (ie, it
+/* See if TAKEN_EDGE->dest is a threadable block with no side effects (ie, it
need not be duplicated as part of the CFG/SSA updating process).
If it is threadable, add it to PATH and VISITED and recurse, ultimately
diff --git a/gcc/tree-ssa-uninit.cc b/gcc/tree-ssa-uninit.cc
index 284445b20f8..dbd187e21d7 100644
--- a/gcc/tree-ssa-uninit.cc
+++ b/gcc/tree-ssa-uninit.cc
@@ -193,7 +193,7 @@ warn_uninit (opt_code opt, tree t, tree var, gimple
*context,
Or
2. A call to .DEFERRED_INIT internal function. Since the original variable
- has been eliminated by optimziation, we need to get the variable name,
+ has been eliminated by optimization, we need to get the variable name,
and variable declaration location from this call. We recorded variable
name into VAR_NAME_STR, and will get location info and record warning
suppressed info to VAR_DEF_STMT, which is the .DEFERRED_INIT call. */
@@ -1454,7 +1454,7 @@ execute_late_warn_uninitialized (function *fun)
timevar_push (TV_TREE_UNINIT);
- /* Avoid quadratic beahvior when looking up case labels for edges. */
+ /* Avoid quadratic behavior when looking up case labels for edges. */
start_recording_case_labels ();
possibly_undefined_names = new hash_set<tree>;
diff --git a/gcc/tree-ssanames.cc b/gcc/tree-ssanames.cc
index 9d7269c05a4..d2ebb49909f 100644
--- a/gcc/tree-ssanames.cc
+++ b/gcc/tree-ssanames.cc
@@ -119,7 +119,7 @@ range_info_get_range (const_tree name, vrange &r)
SSA_NAME_RANGE_INFO (name)->get_vrange (r, TREE_TYPE (name));
}
-/* Set the global range for NAME from R. Return TRUE if successfull,
+/* Set the global range for NAME from R. Return TRUE if successful,
or FALSE if we can't set a range of NAME's type. */
inline bool
--
2.43.0
