From: Dhruv Chawla <[email protected]>
Signed-off-by: Dhruv Chawla <[email protected]>
gcc/ChangeLog:
* tree-assume.cc (assume_query::calculate_phi): Fix typos.
* tree-cfg.cc (assign_discriminators): Likewise.
(stmt_starts_bb_p): Likewise.
(move_stmt_op): Likewise.
(ifconvertable_edge): Likewise.
* tree-cfgcleanup.cc (maybe_remove_forwarder_block): Likewise.
(cleanup_tree_cfg_noloop): Likewise.
* tree-chrec.cc (scev_is_linear_expression): Likewise.
* tree-complex.cc (expand_complex_div_wide): Likewise.
* tree-core.h (enum built_in_class): Likewise.
* tree-data-ref.cc (dump_alias_pair): Likewise.
(create_ifn_alias_checks): Likewise.
* tree-data-ref.h (struct data_dependence_relation): Likewise.
* tree-eh.cc (lower_try_finally_fallthru_label): Likewise.
(lower_eh_dispatch): Likewise.
* tree-if-conv.cc (idx_within_array_bound): Likewise.
(base_object_writable): Likewise.
(ifcvt_memrefs_wont_trap): Likewise.
(get_loop_body_in_if_conv_order): Likewise.
(predicate_scalar_phi): Likewise.
* tree-inline.cc (remap_type_1): Likewise.
(declare_return_variable): Likewise.
(inline_forbidden_p): Likewise.
(estimate_num_insns): Likewise.
(copy_decl_for_dup_finish): Likewise.
* tree-into-ssa.cc (get_ssa_name_ann): Likewise.
(clear_ssa_name_info): Likewise.
(insert_updated_phi_nodes_compare_uids): Likewise.
(update_ssa): Likewise.
* tree-loop-distribution.cc (enum partition_kind): Likewise.
(struct partition): Likewise.
(class loop_distribution): Likewise.
(loop_distribution::classify_partition): Likewise.
(loop_distribution::pg_add_dependence_edges): Likewise.
(add_partition_graph_edge): Likewise.
(free_partition_graph_vdata): Likewise.
(pg_unmark_merged_alias_ddrs): Likewise.
(version_loop_by_alias_check): Likewise.
* tree-object-size.cc (gimplify_size_expressions): Likewise.
(object_sizes_execute): Likewise.
* tree-parloops.cc (parloops_is_simple_reduction): Likewise.
(transform_to_exit_first_loop_alt): Likewise.
* tree-predcom.cc (pcom_worker::suitable_component_p): Likewise.
(pcom_worker::determine_roots_comp): Likewise.
(prepare_initializers_chain_store_elim): Likewise.
(pcom_worker::tree_predictive_commoning_loop): Likewise.
* tree-profile.cc (condition_uid): Likewise.
(cov_length): Likewise.
(tree_profiling): Likewise.
* tree-scalar-evolution.cc (scev_dfs::add_to_evolution_1): Likewise.
(scev_reset): Likewise.
(expression_expensive_p): Likewise.
* tree-sra.cc (struct access): Likewise.
(build_access_from_call_arg): Likewise.
(path_comparable_for_same_access): Likewise.
(child_would_conflict_in_acc): Likewise.
(sra_modify_call_arg): Likewise.
* tree-switch-conversion.cc (can_log2): Likewise.
(switch_conversion::exp_index_transform): Likewise.
* tree-switch-conversion.h (enum cluster_type): Likewise.
* tree-vrp.cc (remove_unreachable::handle_early): Likewise.
* tree.cc (build5): Likewise.
(get_file_function_name): Likewise.
(build_opaque_vector_type): Likewise.
(array_ref_flexible_size_p): Likewise.
(verify_type_variant): Likewise.
(gimple_canonical_types_compatible_p): Likewise.
* tree.h (decl_debug_args_insert): Likewise.
(strip_pointer_types): Likewise.
---
gcc/tree-assume.cc | 6 +++---
gcc/tree-cfg.cc | 8 ++++----
gcc/tree-cfgcleanup.cc | 4 ++--
gcc/tree-chrec.cc | 2 +-
gcc/tree-complex.cc | 2 +-
gcc/tree-core.h | 2 +-
gcc/tree-data-ref.cc | 4 ++--
gcc/tree-data-ref.h | 2 +-
gcc/tree-eh.cc | 4 ++--
gcc/tree-if-conv.cc | 22 +++++++++++-----------
gcc/tree-inline.cc | 10 +++++-----
gcc/tree-into-ssa.cc | 10 +++++-----
gcc/tree-loop-distribution.cc | 28 ++++++++++++++--------------
gcc/tree-object-size.cc | 4 ++--
gcc/tree-parloops.cc | 4 ++--
gcc/tree-predcom.cc | 12 ++++++------
gcc/tree-profile.cc | 8 ++++----
gcc/tree-scalar-evolution.cc | 6 +++---
gcc/tree-sra.cc | 12 ++++++------
gcc/tree-switch-conversion.cc | 4 ++--
gcc/tree-switch-conversion.h | 4 ++--
gcc/tree-vrp.cc | 2 +-
gcc/tree.cc | 14 +++++++-------
gcc/tree.h | 4 ++--
24 files changed, 89 insertions(+), 89 deletions(-)
diff --git a/gcc/tree-assume.cc b/gcc/tree-assume.cc
index ec6246989b0..4067807936a 100644
--- a/gcc/tree-assume.cc
+++ b/gcc/tree-assume.cc
@@ -1,4 +1,4 @@
-/* Support for C++23 ASSUME keyword functionailty.
+/* Support for C++23 ASSUME keyword functionality.
Copyright (C) 2023-2026 Free Software Foundation, Inc.
Contributed by Andrew MacLeod <[email protected]>.
@@ -295,7 +295,7 @@ assume_query::calculate_phi (gphi *phi, vrange &lhs_range)
continue;
}
- // If the def is in the immediate preceeding block, process it
+ // If the def is in the immediate preceding block, process it
// with GORI to determine what values can produce this
// argument value. Otherwise there is more CFG flow, so query
// the edge for parm ranges. This is conservative.
@@ -312,7 +312,7 @@ assume_query::calculate_phi (gphi *phi, vrange &lhs_range)
{
// If this is a constant value that differs from LHS, this
// edge cannot be taken and we can ignore it. Otherwise fall
- // thorugh and process the parameters on the edge.
+ // through and process the parameters on the edge.
edge_range.intersect (lhs_range);
if (edge_range.undefined_p ())
{
diff --git a/gcc/tree-cfg.cc b/gcc/tree-cfg.cc
index 5f751e15d9d..8fb80b8121e 100644
--- a/gcc/tree-cfg.cc
+++ b/gcc/tree-cfg.cc
@@ -1160,7 +1160,7 @@ assign_discriminators (void)
bb_id++;
}
}
- /* If basic block has multiple sucessors, consdier every edge as a
+ /* If basic block has multiple successors, consider every edge as a
separate block. */
if (!single_succ_p (bb))
bb_id++;
@@ -2744,7 +2744,7 @@ stmt_starts_bb_p (gimple *stmt, gimple *prev_stmt)
&& gimple_code (prev_stmt) != GIMPLE_LABEL
&& (gimple_code (prev_stmt) != GIMPLE_CALL
|| ! gimple_call_internal_p (prev_stmt, IFN_PHI)))
- /* PHI nodes start a new block unless preceeded by a label
+ /* PHI nodes start a new block unless preceded by a label
or another PHI. */
return true;
}
@@ -7152,7 +7152,7 @@ move_stmt_op (tree *tp, int *walk_subtrees, void *data)
}
/* Helper for move_stmt_r. Given an EH region number for the source
- function, map that to the duplicate EH regio number in the dest. */
+ function, map that to the duplicate EH region number in the dest. */
static int
move_stmt_eh_region_nr (int old_nr, struct move_stmt_d *p)
@@ -10188,7 +10188,7 @@ ifconvertable_edge (edge e)
return false;
}
- /* If convertables are only for conditionals. */
+ /* If convertibles are only for conditionals. */
if (!is_a<gcond*>(*gsi_last_nondebug_bb (bb0)))
return false;
diff --git a/gcc/tree-cfgcleanup.cc b/gcc/tree-cfgcleanup.cc
index 85b9a3cedaa..3aa750ee5ae 100644
--- a/gcc/tree-cfgcleanup.cc
+++ b/gcc/tree-cfgcleanup.cc
@@ -771,7 +771,7 @@ maybe_remove_forwarder_block (basic_block bb, bool
can_split = false)
set_immediate_dominator (CDI_DOMINATORS, dest, dom);
- /* Adjust latch infomation of BB's parent loop as otherwise
+ /* Adjust latch information of BB's parent loop as otherwise
the cfg hook has a hard time not to kill the loop. */
if (current_loops && bb->loop_father->latch == bb)
bb->loop_father->latch = pred;
@@ -1190,7 +1190,7 @@ cleanup_tree_cfg_noloop (unsigned ssa_update_flags)
/* Start by iterating over all basic blocks in PRE order looking for
edge removal opportunities. Do this first because incoming SSA form
may be invalid and we want to avoid performing SSA related tasks such
- as propgating out a PHI node during BB merging in that state. This
+ as propagating out a PHI node during BB merging in that state. This
also gets rid of unreachable blocks. */
bool changed = cleanup_control_flow_pre ();
diff --git a/gcc/tree-chrec.cc b/gcc/tree-chrec.cc
index bad0396d040..f02314aa570 100644
--- a/gcc/tree-chrec.cc
+++ b/gcc/tree-chrec.cc
@@ -1889,7 +1889,7 @@ scev_is_linear_expression (tree scev)
}
}
-/* Determines whether the expression CHREC contains only interger consts
+/* Determines whether the expression CHREC contains only integer consts
in the right parts. */
bool
diff --git a/gcc/tree-complex.cc b/gcc/tree-complex.cc
index 0937cb442bf..e99abbab7f0 100644
--- a/gcc/tree-complex.cc
+++ b/gcc/tree-complex.cc
@@ -1387,7 +1387,7 @@ expand_complex_div_wide (gimple_stmt_iterator *gsi, tree
inner_type,
/* Wire the blocks together. */
e->flags = EDGE_TRUE_VALUE;
- /* TODO: With value profile we could add an historgram to determine real
+ /* TODO: With value profile we could add an histogram to determine real
branch outcome. */
e->probability = profile_probability::even ();
redirect_edge_succ (e, bb_true);
diff --git a/gcc/tree-core.h b/gcc/tree-core.h
index 07e9318f5e8..a70e60e3290 100644
--- a/gcc/tree-core.h
+++ b/gcc/tree-core.h
@@ -176,7 +176,7 @@ enum built_in_class {
BUILT_IN_NORMAL
};
-/* Last marker used for LTO stremaing of built_in_class. We cannot add it
+/* Last marker used for LTO streaming of built_in_class. We cannot add it
to the enum since we need the enumb to fit in 2 bits. */
#define BUILT_IN_LAST (BUILT_IN_NORMAL + 1)
diff --git a/gcc/tree-data-ref.cc b/gcc/tree-data-ref.cc
index e60039b4776..11b3b826315 100644
--- a/gcc/tree-data-ref.cc
+++ b/gcc/tree-data-ref.cc
@@ -1795,7 +1795,7 @@ dump_alias_pair (dr_with_seg_len_pair_t *alias_pair,
const char *indent)
memory of store_ptr_0 cannot be between the memory of load_ptr_0 and
load_ptr_1.)
- we then can use only the following expression to finish the alising checks
+ we then can use only the following expression to finish the aliasing checks
between store_ptr_0 & load_ptr_0 and store_ptr_0 & load_ptr_1:
((store_ptr_0 + store_segment_length_0) <= load_ptr_0)
@@ -2037,7 +2037,7 @@ create_ifn_alias_checks (tree *cond_expr,
tree addr_a = DR_BASE_ADDRESS (dr_a.dr);
tree addr_b = DR_BASE_ADDRESS (dr_b.dr);
- /* See whether the target suports what we want to do. WAW checks are
+ /* See whether the target supports what we want to do. WAW checks are
equivalent to WAR checks here. */
internal_fn ifn = (alias_pair.flags & DR_ALIAS_RAW
? IFN_CHECK_RAW_PTRS
diff --git a/gcc/tree-data-ref.h b/gcc/tree-data-ref.h
index 79d55682264..e25f98d2966 100644
--- a/gcc/tree-data-ref.h
+++ b/gcc/tree-data-ref.h
@@ -475,7 +475,7 @@ struct data_dependence_relation
for (int i = 0; i < n; ++i)
a[0].f[i] += b[i].f[i];
- conservatively have a distance vector of (0), but they are indepenent
+ conservatively have a distance vector of (0), but they are independent
when a != b + i. In contrast, the references in:
struct s *a;
diff --git a/gcc/tree-eh.cc b/gcc/tree-eh.cc
index 512dca807a7..2980da22998 100644
--- a/gcc/tree-eh.cc
+++ b/gcc/tree-eh.cc
@@ -1002,7 +1002,7 @@ lower_try_finally_fallthru_label (struct leh_tf_state *tf)
return label;
}
-/* A subroutine of lower_try_finally. If FINALLY consits of a
+/* A subroutine of lower_try_finally. If FINALLY consists of a
GIMPLE_EH_ELSE node, return it. */
static inline geh_else *
@@ -3927,7 +3927,7 @@ lower_eh_dispatch (basic_block src, geh_dispatch *stmt)
hash_set<tree> seen_values;
/* Collect the labels for a switch. Zero the post_landing_pad
- field becase we'll no longer have anything keeping these labels
+ field because we'll no longer have anything keeping these labels
in existence and the optimizer will be free to merge these
blocks at will. */
for (c = r->u.eh_try.first_catch; c ; c = c->next_catch)
diff --git a/gcc/tree-if-conv.cc b/gcc/tree-if-conv.cc
index d728f7c5221..46b247417f6 100644
--- a/gcc/tree-if-conv.cc
+++ b/gcc/tree-if-conv.cc
@@ -815,7 +815,7 @@ idx_within_array_bound (tree ref, tree *idx, void *dta)
|| !high || TREE_CODE (high) != INTEGER_CST)
return false;
- /* Check if the intial idx is within bound. */
+ /* Check if the initial idx is within bound. */
if (wi::to_widest (init) < wi::to_widest (low)
|| wi::to_widest (init) > wi::to_widest (high))
return false;
@@ -893,9 +893,9 @@ base_object_writable (tree ref)
iteration unconditionally.
Returns true for the memory reference in STMT, same memory reference
- is read or written unconditionally atleast once and the base memory
+ is read or written unconditionally at least once and the base memory
reference is written unconditionally once. This is to check reference
- will not write fault. Also retuns true if the memory reference is
+ will not write fault. Also returns true if the memory reference is
unconditionally read once then we are conditionally writing to memory
which is defined as read and write and is bound to the definition
we are seeing. */
@@ -938,7 +938,7 @@ ifcvt_memrefs_wont_trap (gimple *stmt,
vec<data_reference_p> drs)
if (DR_IS_READ (a))
return true;
- /* an unconditionaly write won't trap if the base is written
+ /* an unconditionally write won't trap if the base is written
to unconditionally. */
if ((base_master_dr
&& DR_BASE_W_UNCONDITIONALLY (*base_master_dr))
@@ -1379,7 +1379,7 @@ get_loop_body_in_if_conv_order (const class loop *loop)
/* Go through loop and reject if-conversion or lowering of bitfields if we
encounter statements we do not believe the vectorizer will be able to
handle. If adding a new type of statement here, make sure
- 'ifcvt_local_dce' is also able to handle it propertly. */
+ 'ifcvt_local_dce' is also able to handle it properly. */
for (index = 0; index < loop->num_nodes; index++)
{
basic_block bb = blocks[index];
@@ -2277,14 +2277,14 @@ again:
if (!gimple_extract_op (arg0_def_stmt, &arg0_op))
return;
- /* At this point there should be no ssa names occuring in abnormals. */
+ /* At this point there should be no ssa names occurring in abnormals. */
gcc_assert (!arg0_op.operands_occurs_in_abnormal_phi ());
gimple *arg1_def_stmt = SSA_NAME_DEF_STMT (*arg1);
if (!gimple_extract_op (arg1_def_stmt, &arg1_op))
return;
- /* At this point there should be no ssa names occuring in abnormals. */
+ /* At this point there should be no ssa names occurring in abnormals. */
gcc_assert (!arg1_op.operands_occurs_in_abnormal_phi ());
/* No factoring can happen if the codes are different
@@ -2309,10 +2309,10 @@ again:
constant masks (operand 2). The target might not support it
and that might be invalid to do as such. Also with constants
masks, the number of elements of the mask type does not need
- to match tne number of elements of other operands and can be
+ to match the number of elements of other operands and can be
arbitrary integral vector type so factoring that out can't work.
Note in the case where one mask is a constant and the other is not,
- the next check for compatiable types will reject the case the
+ the next check for compatible types will reject the case the
constant mask has the incompatible type. */
if (arg1_op.code == VEC_PERM_EXPR && opnum == 2
&& TREE_CODE (new_arg0) == VECTOR_CST
@@ -2540,7 +2540,7 @@ predicate_scalar_phi (gphi *phi, gimple_stmt_iterator
*gsi, bool loop_versioned)
else
cond = bb_predicate (first_edge->src);
- /* Gimplify the condition to a valid cond-expr conditonal operand. */
+ /* Gimplify the condition to a valid cond-expr conditional operand. */
cond = gen_simplified_condition (cond, cond_set);
cond = force_gimple_operand_gsi (gsi, unshare_expr (cond), true,
NULL_TREE, true, GSI_SAME_STMT);
@@ -2654,7 +2654,7 @@ predicate_scalar_phi (gphi *phi, gimple_stmt_iterator
*gsi, bool loop_versioned)
swap = true;
cond = TREE_OPERAND (cond, 0);
}
- /* Gimplify the condition to a valid cond-expr conditonal operand. */
+ /* Gimplify the condition to a valid cond-expr conditional operand. */
cond = force_gimple_operand_gsi (gsi, unshare_expr (cond), true,
NULL_TREE, true, GSI_SAME_STMT);
if (!(is_cond_scalar_reduction (phi, &reduc, arg0 , arg1,
diff --git a/gcc/tree-inline.cc b/gcc/tree-inline.cc
index df5597ef30d..302ab8d6b7c 100644
--- a/gcc/tree-inline.cc
+++ b/gcc/tree-inline.cc
@@ -575,7 +575,7 @@ remap_type_1 (tree type, copy_body_data *id)
gcc_unreachable ();
}
- /* All variants of type share the same size, so use the already remaped
data. */
+ /* All variants of type share the same size, so use the already remapped
data. */
if (TYPE_MAIN_VARIANT (new_tree) != new_tree)
{
tree s = TYPE_SIZE (type);
@@ -3972,7 +3972,7 @@ declare_return_variable (copy_body_data *id, tree
return_slot, tree modify_dest,
}
/* Determine if the function can be copied. If so return NULL. If
- not return a string describng the reason for failure. */
+ not return a string describing the reason for failure. */
const char *
copy_forbidden (struct function *fun)
@@ -4150,7 +4150,7 @@ inline_forbidden_p (tree fndecl)
return true;
/* Next, walk the statements of the function looking for
- constraucts we can't handle, or are non-optimal for inlining. */
+ constructs we can't handle, or are non-optimal for inlining. */
hash_set<tree> visited_nodes;
memset (&wi, 0, sizeof (wi));
wi.info = (void *) fndecl;
@@ -4545,7 +4545,7 @@ estimate_num_insns (gimple *stmt, eni_weights *weights)
if ((node = cgraph_node::get (decl))
&& node->definition)
;
- /* For buitins that are likely expanded to nothing or
+ /* For builtins that are likely expanded to nothing or
inlined do not account operand costs. */
else if (is_simple_builtin (decl))
return 0;
@@ -6133,7 +6133,7 @@ copy_decl_for_dup_finish (copy_body_data *id, tree decl,
tree copy)
return copy;
}
-/* Create a new VAR_DECL that is indentical in all respect to DECL except that
+/* Create a new VAR_DECL that is identical in all respect to DECL except that
DECL can be either a VAR_DECL, a PARM_DECL or RESULT_DECL. The original
DECL must come from ID->src_fn and the copy will be part of ID->dst_fn. */
diff --git a/gcc/tree-into-ssa.cc b/gcc/tree-into-ssa.cc
index 5a0e9f2a842..dd128592d3d 100644
--- a/gcc/tree-into-ssa.cc
+++ b/gcc/tree-into-ssa.cc
@@ -346,7 +346,7 @@ get_ssa_name_ann (tree name)
return info;
}
-/* Return and allocate the auxiliar information for DECL. */
+/* Return and allocate the auxiliary information for DECL. */
static inline var_info *
get_var_info (tree decl)
@@ -374,12 +374,12 @@ clear_ssa_name_info (void)
current_info_for_ssa_name_age++;
/* If current_info_for_ssa_name_age wraps we use stale information.
- Asser that this does not happen. */
+ Assert that this does not happen. */
gcc_assert (current_info_for_ssa_name_age != 0);
}
-/* Get access to the auxiliar information stored per SSA name or decl. */
+/* Get access to the auxiliary information stored per SSA name or decl. */
static inline common_info *
get_common_info (tree var)
@@ -3315,7 +3315,7 @@ insert_updated_phi_nodes_compare_uids (const void *a,
const void *b)
calling create_new_def_for to create new defs for names that the
caller wants to replace.
- The caller cretaes the new names to be inserted and the names that need
+ The caller creates the new names to be inserted and the names that need
to be replaced by calling create_new_def_for for each old definition
to be replaced. Note that the function assumes that the
new defining statement has already been inserted in the IL.
@@ -3477,7 +3477,7 @@ update_ssa (unsigned update_flags)
statistics_counter_event (cfun, "Symbol to SSA rewrite", 1);
/* If we rename bare symbols initialize the mapping to
- auxiliar info we need to keep track of. */
+ auxiliary info we need to keep track of. */
var_infos = new hash_table<var_info_hasher> (47);
/* If we have to rename some symbols from scratch, we need to
diff --git a/gcc/tree-loop-distribution.cc b/gcc/tree-loop-distribution.cc
index 5de0383137f..dff8b72e40b 100644
--- a/gcc/tree-loop-distribution.cc
+++ b/gcc/tree-loop-distribution.cc
@@ -213,9 +213,9 @@ struct rdg_edge
/* Kind of distributed loop. */
enum partition_kind {
PKIND_NORMAL,
- /* Partial memset stands for a paritition can be distributed into a loop
+ /* Partial memset stands for a partition can be distributed into a loop
of memset calls, rather than a single memset call. It's handled just
- like a normal parition, i.e, distributed as separate loop, no memset
+ like a normal partition, i.e, distributed as separate loop, no memset
call is generated.
Note: This is a hacking fix trying to distribute ZERO-ing stmt in a
@@ -264,7 +264,7 @@ struct partition
enum partition_type type;
/* Data references in the partition. */
bitmap datarefs;
- /* Information of builtin parition. */
+ /* Information of builtin partition. */
struct builtin_info *builtin;
};
@@ -622,7 +622,7 @@ class loop_distribution
/* Build and return partition dependence graph for PARTITIONS. RDG is
reduced dependence graph for the loop to be distributed. If
IGNORE_ALIAS_P
is true, data dependence caused by possible alias between references
- is ignored, as if it doesn't exist at all; otherwise all depdendences
+ is ignored, as if it doesn't exist at all; otherwise all dependences
are considered. */
struct graph *build_partition_graph (struct graph *rdg,
vec<struct partition *> *partitions,
@@ -631,12 +631,12 @@ class loop_distribution
/* Given reduced dependence graph RDG merge strong connected components
of PARTITIONS. If IGNORE_ALIAS_P is true, data dependence caused by
possible alias between references is ignored, as if it doesn't exist
- at all; otherwise all depdendences are considered. */
+ at all; otherwise all dependences are considered. */
void merge_dep_scc_partitions (struct graph *rdg, vec<struct partition *>
*partitions, bool ignore_alias_p);
-/* This is the main function breaking strong conected components in
- PARTITIONS giving reduced depdendence graph RDG. Store data dependence
+/* This is the main function breaking strong connected components in
+ PARTITIONS giving reduced dependence graph RDG. Store data dependence
relations for runtime alias check in ALIAS_DDRS. */
void break_alias_scc_partitions (struct graph *rdg, vec<struct partition *>
*partitions, vec<ddr_p> *alias_ddrs);
@@ -1902,7 +1902,7 @@ loop_distribution::classify_partition (loop_p loop,
reduction partitions. As a result, this could cancel valid
loop distribution especially for loop that induction variable
is used outside of loop. To workaround this issue, we skip
- marking partition as reudction if the reduction stmt belongs
+ marking partition as reduction if the reduction stmt belongs
to all partitions. In such case, reduction will be computed
correctly no matter how partitions are fused/distributed. */
if (!bitmap_bit_p (stmt_in_all_partitions, i))
@@ -2174,7 +2174,7 @@ loop_distribution::pg_add_dependence_edges (struct graph
*rdg, int dir,
}
else if (DDR_ARE_DEPENDENT (ddr) == NULL_TREE)
{
- /* Known dependences can still be unordered througout the
+ /* Known dependences can still be unordered throughout the
iteration space, see gcc.dg/tree-ssa/ldist-16.c and
gcc.dg/tree-ssa/pr94969.c. */
if (DDR_NUM_DIST_VECTS (ddr) != 1)
@@ -2306,7 +2306,7 @@ add_partition_graph_edge (struct graph *pg, int i, int j,
vec<ddr_p> *ddrs)
}
}
-/* Callback function for graph travesal algorithm. It returns true
+/* Callback function for graph traversal algorithm. It returns true
if edge E should skipped when traversing the graph. */
static bool
@@ -2347,7 +2347,7 @@ free_partition_graph_vdata (struct graph *pg)
/* Build and return partition dependence graph for PARTITIONS. RDG is
reduced dependence graph for the loop to be distributed. If IGNORE_ALIAS_P
is true, data dependence caused by possible alias between references
- is ignored, as if it doesn't exist at all; otherwise all depdendences
+ is ignored, as if it doesn't exist at all; otherwise all dependences
are considered. */
struct graph *
@@ -2536,8 +2536,8 @@ pg_unmark_merged_alias_ddrs (struct graph *, struct
graph_edge *e, void *data)
}
}
-/* This is the main function breaking strong conected components in
- PARTITIONS giving reduced depdendence graph RDG. Store data dependence
+/* This is the main function breaking strong connected components in
+ PARTITIONS giving reduced dependence graph RDG. Store data dependence
relations for runtime alias check in ALIAS_DDRS. */
void
loop_distribution::break_alias_scc_partitions (struct graph *rdg,
@@ -2855,7 +2855,7 @@ version_loop_by_alias_check (vec<struct partition *>
*partitions,
update_ssa (TODO_update_ssa_no_phi);
}
-/* Return true if loop versioning is needed to distrubute PARTITIONS.
+/* Return true if loop versioning is needed to distribute PARTITIONS.
ALIAS_DDRS are data dependence relations for runtime alias check. */
static inline bool
diff --git a/gcc/tree-object-size.cc b/gcc/tree-object-size.cc
index ab2ba4abb85..54c320d36d0 100644
--- a/gcc/tree-object-size.cc
+++ b/gcc/tree-object-size.cc
@@ -1197,7 +1197,7 @@ gimplify_size_expressions (object_size_info *osi)
object_size_type))
{
/* Record the SSAs we're overwriting to propagate the
- unknwons. */
+ unknowns. */
tree oldval = object_sizes_get (osi, i);
tree old_wholeval = object_sizes_get (osi, i, true);
@@ -2379,7 +2379,7 @@ object_sizes_execute (function *fun, bool early)
if (!SSA_NAME_OCCURS_IN_ABNORMAL_PHI (lhs))
{
replace_uses_by (lhs, result);
- /* Mark lhs as being possiblely DCEd. */
+ /* Mark lhs as being possibly DCEd. */
bitmap_set_bit (sdce_worklist, SSA_NAME_VERSION (lhs));
}
else
diff --git a/gcc/tree-parloops.cc b/gcc/tree-parloops.cc
index 7c87f6c7cec..1da23f8d3c8 100644
--- a/gcc/tree-parloops.cc
+++ b/gcc/tree-parloops.cc
@@ -392,7 +392,7 @@ parloops_is_simple_reduction (loop_vec_info loop_info,
stmt_vec_info phi_info,
}
/* If this isn't a nested cycle or if the nested cycle reduction value
- is used ouside of the inner loop we cannot handle uses of the reduction
+ is used outside of the inner loop we cannot handle uses of the reduction
value. */
if ((!nested_in_vect_loop || inner_loop_of_double_reduc)
&& (nlatch_def_loop_uses > 1 || nphi_def_loop_uses > 1))
@@ -2270,7 +2270,7 @@ transform_to_exit_first_loop_alt (class loop *loop,
basic_block new_exit_block = NULL;
if (!single_pred_p (exit->dest))
{
- /* Create a new empty exit block, inbetween the new loop header and the
+ /* Create a new empty exit block, in between the new loop header and the
old exit block. The function separate_decls_in_region needs this block
to insert code that is active on loop exit, but not any other path. */
new_exit_block = split_edge (exit);
diff --git a/gcc/tree-predcom.cc b/gcc/tree-predcom.cc
index b8160ad486e..8e2894d46a0 100644
--- a/gcc/tree-predcom.cc
+++ b/gcc/tree-predcom.cc
@@ -327,7 +327,7 @@ typedef struct chain
/* Finalizers for the eliminated stores. */
auto_vec<tree> finis;
- /* gimple stmts intializing the initial variables of the chain. */
+ /* gimple stmts initializing the initial variables of the chain. */
gimple_seq init_seq;
/* gimple stmts finalizing the eliminated stores of the chain. */
@@ -1114,7 +1114,7 @@ pcom_worker::suitable_component_p (struct component *comp)
in some later iteration. There might be more latent issues
about this in predcom or data reference analysis. If the
reference is a COMPONENT_REF, also check if step isn't a
- multiple of the containg aggregate size. See PR111683. */
+ multiple of the containing aggregate size. See PR111683. */
tree ref = DR_REF (a->ref);
tree step = DR_STEP (a->ref);
if (TREE_CODE (ref) == COMPONENT_REF
@@ -1610,7 +1610,7 @@ pcom_worker::determine_roots_comp (struct component *comp)
release_chain (chain);
/* Determine type of the chain. If the root reference is a load,
- this can only be a CT_LOAD chain; other chains are intialized
+ this can only be a CT_LOAD chain; other chains are initialized
to CT_STORE_LOAD and might be promoted to CT_STORE_STORE when
new reference is added. */
type = DR_IS_READ (a->ref) ? CT_LOAD : CT_STORE_LOAD;
@@ -3132,7 +3132,7 @@ prepare_initializers_chain_store_elim (class loop *loop,
chain_p chain)
if (!chain->all_always_accessed)
return false;
- /* Nothing to intialize for intra-iteration store elimination. */
+ /* Nothing to initialize for intra-iteration store elimination. */
if (n == 0 && chain->type == CT_STORE_STORE)
return true;
@@ -3148,7 +3148,7 @@ prepare_initializers_chain_store_elim (class loop *loop,
chain_p chain)
chain->inits.create (n);
chain->inits.safe_grow_cleared (n, true);
- /* For store eliminatin chain like below:
+ /* For store eliminating chain like below:
for (i = 0; i < len; i++)
{
@@ -3384,7 +3384,7 @@ pcom_worker::tree_predictive_commoning_loop (bool
allow_unroll_p)
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "Processing loop %d\n", m_loop->num);
- /* Nothing for predicitive commoning if loop only iterates 1 time. */
+ /* Nothing for predictive commoning if loop only iterates 1 time. */
if (get_max_loop_iterations_int (m_loop) == 0)
{
if (dump_file && (dump_flags & TDF_DETAILS))
diff --git a/gcc/tree-profile.cc b/gcc/tree-profile.cc
index 7569dbb2f91..a03f1f3704f 100644
--- a/gcc/tree-profile.cc
+++ b/gcc/tree-profile.cc
@@ -392,7 +392,7 @@ condition_uid (struct function *fn, basic_block b)
Masking and short circuiting are deeply connected - masking occurs when
control flow reaches a state that is also reachable with short circuiting.
In fact, masking corresponds to short circuiting for the reversed
- expression. This means we can find the limits, the last term in preceeding
+ expression. This means we can find the limits, the last term in preceding
subexpressions, by following the edges that short circuit to the same
outcome. The algorithm treats the CFG as a reduced order binary decision
diagram (see Randall E. Bryant's Graph Based Algorithms for Boolean
@@ -455,7 +455,7 @@ condition_uid (struct function *fn, basic_block b)
We only have to consider the pairs of top, bot where top is the the closest
(highest-index'd) candidate that still satisfies top < bot in the
topological order, as this will be the immediate left operand. The nodes of
- the other left operands will also be found when going through the righmost
+ the other left operands will also be found when going through the rightmost
term, and a lower-index'd top would just find subsets. This has a
significant performance impact, 15-20x faster for the worst cases of (x && y
&& ..) with no nesting.
@@ -818,7 +818,7 @@ cov_length (const struct condcov *cov)
return cov->m_index.length () - 1;
}
-/* The subgraph, exluding intermediates, for the nth Boolean expression. */
+/* The subgraph, excluding intermediates, for the nth Boolean expression. */
array_slice<basic_block>
cov_blocks (struct condcov *cov, size_t n)
{
@@ -1932,7 +1932,7 @@ tree_profiling (void)
continue;
/* Do not instrument extern inline functions when testing coverage.
While this is not perfectly consistent (early inlined extern inlines
- will get acocunted), testsuite expects that. */
+ will get accounted), testsuite expects that. */
if (DECL_EXTERNAL (node->decl)
&& flag_test_coverage)
continue;
diff --git a/gcc/tree-scalar-evolution.cc b/gcc/tree-scalar-evolution.cc
index b27037cb02f..d8315177ff3 100644
--- a/gcc/tree-scalar-evolution.cc
+++ b/gcc/tree-scalar-evolution.cc
@@ -706,7 +706,7 @@ scev_dfs::add_to_evolution_1 (tree chrec_before, tree
to_add, gimple *at_stmt)
/* When we add the first evolution we need to replace the symbolic
evolution we've put in when the DFS reached the loop PHI node
with the initial value. There's only a limited cases of
- extra operations ontop of that symbol allowed, namely
+ extra operations on top of that symbol allowed, namely
sign-conversions we can look through. For other cases we leave
the symbolic initial condition which causes build_polynomial_chrec
to return chrec_dont_know. See PR42512, PR66375 and PR107176 for
@@ -3128,7 +3128,7 @@ scev_reset (void)
We do not use information whether TYPE can overflow so it is safe to
use this test even for derived IVs not computed every iteration or
- hypotetical IVs to be inserted into code. */
+ hypothetical IVs to be inserted into code. */
bool
iv_can_overflow_p (class loop *loop, tree type, tree base, tree step)
@@ -3638,7 +3638,7 @@ expression_expensive_p (tree expr, bool *cond_overflow_p)
/* ??? Both the explicit unsharing and gimplification of expr will
expand shared trees to multiple copies.
Guard against exponential growth by counting the visits and
- comparing againt the number of original nodes. Allow a tiny
+ comparing against the number of original nodes. Allow a tiny
bit of duplication to catch some additional optimizations. */
|| expanded_size > (cache.elements () + 1));
}
diff --git a/gcc/tree-sra.cc b/gcc/tree-sra.cc
index fde4d558f0e..d9ae740e054 100644
--- a/gcc/tree-sra.cc
+++ b/gcc/tree-sra.cc
@@ -262,7 +262,7 @@ struct access
/* Should TREE_NO_WARNING of a replacement be set? */
unsigned grp_no_warning : 1;
- /* Result of propagation accross link from LHS to RHS. */
+ /* Result of propagation across link from LHS to RHS. */
unsigned grp_result_of_prop_from_lhs : 1;
};
@@ -389,7 +389,7 @@ static struct
components. */
int aggregate_params_reduced;
- /* Numbber of components created when splitting aggregate parameters. */
+ /* Number of components created when splitting aggregate parameters. */
int param_reductions_created;
/* Number of deferred_init calls that are modified. */
@@ -1413,7 +1413,7 @@ build_access_from_call_arg (tree expr, gimple *stmt, bool
can_be_returned,
if (can_be_returned)
{
disqualify_base_of_expr (base, "Address possibly returned, "
- "leading to an alis SRA may not know.");
+ "leading to an alias SRA may not know.");
return false;
}
if (abnormal_edge_after_stmt_p (stmt, oe_check))
@@ -2312,7 +2312,7 @@ path_comparable_for_same_access (tree expr)
{
if (TREE_CODE (expr) == ARRAY_REF)
{
- /* SSA name indices can occur here too when the array is of sie one.
+ /* SSA name indices can occur here too when the array is of size one.
But we cannot just re-use array_refs with SSA names elsewhere in
the function, so disallow non-constant indices. TODO: Remove this
limitation after teaching build_reconstructed_reference to replace
@@ -3056,7 +3056,7 @@ child_would_conflict_in_acc (struct access *acc,
HOST_WIDE_INT norm_offset,
Return the new access or NULL if it cannot be created. Note that this
access is created long after all splicing and sorting, it's not located in
any access vector and is automatically a representative of its group. Set
- the gpr_write flag of the new accesss if SET_GRP_WRITE is true. */
+ the gpr_write flag of the new access if SET_GRP_WRITE is true. */
static struct access *
create_artificial_child_access (struct access *parent, struct access *model,
@@ -4345,7 +4345,7 @@ sra_modify_call_arg (tree *expr, gimple_stmt_iterator
*call_gsi,
}
/* Where scalar replacements of the RHS have been written to when a replacement
- of a LHS of an assigments cannot be direclty loaded from a replacement of
+ of a LHS of an assignments cannot be directly loaded from a replacement of
the RHS. */
enum unscalarized_data_handling { SRA_UDH_NONE, /* Nothing done so far. */
SRA_UDH_RIGHT, /* Data flushed to the RHS. */
diff --git a/gcc/tree-switch-conversion.cc b/gcc/tree-switch-conversion.cc
index 5027ab559c0..fef71c0bae0 100644
--- a/gcc/tree-switch-conversion.cc
+++ b/gcc/tree-switch-conversion.cc
@@ -105,7 +105,7 @@ can_log2 (tree type, optimization_type opt_type)
/* Assume that OP is a power of two. Build a sequence of gimple statements
efficiently computing the base two logarithm of OP using special optabs.
- Return the ssa name represeting the result of the logarithm through RESULT.
+ Return the ssa name representing the result of the logarithm through RESULT.
Before computing the logarithm, OP may have to be converted to another type.
This should be specified in TYPE. Use can_log2 to decide what this type
@@ -431,7 +431,7 @@ switch_conversion::exp_index_transform (gswitch *swtch)
gsi_insert_after (&gsi, stmt_cond, GSI_NEW_STMT);
/* We just added an edge going to default bb so fix PHI nodes in that bb:
- For each PHI add new PHI arg. It will be the same arg as when comming to
+ For each PHI add new PHI arg. It will be the same arg as when coming to
the default bb from the switch bb. */
edge default_edge = find_edge (swtch_bb, default_bb);
for (gphi_iterator gsi = gsi_start_phis (default_bb);
diff --git a/gcc/tree-switch-conversion.h b/gcc/tree-switch-conversion.h
index 7fbcc573eb1..b874937be4d 100644
--- a/gcc/tree-switch-conversion.h
+++ b/gcc/tree-switch-conversion.h
@@ -35,7 +35,7 @@ enum cluster_type
/* Abstract base class for representing a cluster of cases.
- Here is the inheritance hierarachy, and the enum_cluster_type
+ Here is the inheritance hierarchy, and the enum_cluster_type
values for the concrete subclasses:
cluster
@@ -312,7 +312,7 @@ as a single bit test:
if ((1<<x) & ((1<<4)|(1<<6)|(1<<9)|(1<<11)))
This transformation is only applied if the number of case targets is small,
-if CST constains at least 3 bits, and "1 << x" is cheap. The bit tests are
+if CST contains at least 3 bits, and "1 << x" is cheap. The bit tests are
performed in "word_mode".
The following example shows the code the transformation generates:
diff --git a/gcc/tree-vrp.cc b/gcc/tree-vrp.cc
index e080af5fcaa..47cbe769dd4 100644
--- a/gcc/tree-vrp.cc
+++ b/gcc/tree-vrp.cc
@@ -199,7 +199,7 @@ remove_unreachable::fully_replaceable (tree name,
basic_block bb)
void
remove_unreachable::handle_early (gimple *s, edge e)
{
- // If there is no gori_ssa, there is no early processsing.
+ // If there is no gori_ssa, there is no early processing.
if (!m_ranger.gori_ssa ())
return ;
bool lhs_p = TREE_CODE (gimple_cond_lhs (s)) == SSA_NAME;
diff --git a/gcc/tree.cc b/gcc/tree.cc
index 8479ffab584..57bd9344a31 100644
--- a/gcc/tree.cc
+++ b/gcc/tree.cc
@@ -5455,7 +5455,7 @@ build5 (enum tree_code code, tree tt, tree arg0, tree
arg1,
return t;
}
-/* Build a simple MEM_REF tree with the sematics of a plain INDIRECT_REF
+/* Build a simple MEM_REF tree with the semantics of a plain INDIRECT_REF
on the pointer PTR. */
tree
@@ -9123,7 +9123,7 @@ get_file_function_name (const char *type)
/* If the target is handling the constructors/destructors, they
will be local to this file and the name is only necessary for
debugging purposes.
- We also assign sub_I and sub_D sufixes to constructors called from
+ We also assign sub_I and sub_D suffixes to constructors called from
the global static constructors. These are always local.
OpenMP "declare target" offloaded constructors/destructors use "off_I" and
"off_D" for the same purpose. */
@@ -10559,7 +10559,7 @@ build_opaque_vector_type (tree innertype, poly_int64
nunits)
&& TYPE_VECTOR_OPAQUE (cand)
&& check_qualified_type (cand, t, TYPE_QUALS (t)))
return cand;
- /* Othewise build a variant type and make sure to queue it after
+ /* Otherwise build a variant type and make sure to queue it after
the non-opaque type. */
cand = build_distinct_type_copy (t);
TYPE_VECTOR_OPAQUE (cand) = true;
@@ -13231,7 +13231,7 @@ array_ref_up_bound (tree exp)
bool
array_ref_flexible_size_p (tree ref, bool *is_trailing_array /* = NULL */)
{
- /* The TYPE for this array referece. */
+ /* The TYPE for this array reference. */
tree atype = NULL_TREE;
/* The FIELD_DECL for the array field in the containing structure. */
tree afield_decl = NULL_TREE;
@@ -13795,7 +13795,7 @@ verify_type_variant (const_tree t, tree tv)
- main variant may be TYPE_COMPLETE_P and variant types !TYPE_COMPLETE_P
in this case some values may not be set in the variant types
(see TYPE_COMPLETE_P checks).
- - it is possible to have TYPE_ARTIFICIAL variant of non-artifical type
+ - it is possible to have TYPE_ARTIFICIAL variant of non-artificial type
- by TYPE_NAME and attributes (i.e. when variant originate by typedef)
- TYPE_CANONICAL (TYPE_ALIAS_SET is the same among variants)
- by the alignment: TYPE_ALIGN and TYPE_USER_ALIGN
@@ -13873,7 +13873,7 @@ verify_type_variant (const_tree t, tree tv)
verify_variant_match (TYPE_TRANSPARENT_AGGR);
else if (TREE_CODE (t) == ARRAY_TYPE)
verify_variant_match (TYPE_NONALIASED_COMPONENT);
- /* During LTO we merge variant lists from diferent translation units
+ /* During LTO we merge variant lists from different translation units
that may differ BY TYPE_CONTEXT that in turn may point
to TRANSLATION_UNIT_DECL.
Ada also builds variants of types with different TYPE_CONTEXT. */
@@ -14084,7 +14084,7 @@ gimple_canonical_types_compatible_p (const_tree t1,
const_tree t2,
need to ensure that we are never called on it.
FIXME: For more correctness the function probably should have three modes
- 1) mode assuming that types are complete mathcing their structure
+ 1) mode assuming that types are complete matching their structure
2) mode allowing incomplete types but producing equivalence classes
and thus ignoring all info from complete types
3) mode allowing incomplete types to match complete but checking
diff --git a/gcc/tree.h b/gcc/tree.h
index 3b012d0fd6a..55512ce5894 100644
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -3689,7 +3689,7 @@ extern vec<tree, va_gc> **decl_debug_args_insert (tree);
(FUNCTION_DECL_CHECK (NODE)->function_decl.versioned_function)
/* In FUNCTION_DECL, this is set if this function is a C++ constructor.
- Devirtualization machinery uses this knowledge for determing type of the
+ Devirtualization machinery uses this knowledge for determining type of the
object constructed. Also we assume that constructor address is not
important. */
#define DECL_CXX_CONSTRUCTOR_P(NODE)\
@@ -5178,7 +5178,7 @@ strip_pointer_types (const_tree type)
return type;
}
-/* Desription of the reason why the argument of valid_constant_size_p
+/* Description of the reason why the argument of valid_constant_size_p
is not a valid size. */
enum cst_size_error {
cst_size_ok,
--
2.43.0
