From: Dhruv Chawla <[email protected]>
Signed-off-by: Dhruv Chawla <[email protected]>
gcc/ChangeLog:
* ipa-comdats.cc: Fix typos.
* ipa-cp.cc (good_cloning_opportunity_p): Likewise.
(dump_profile_updates): Likewise.
(update_counts_for_self_gen_clones): Likewise.
(update_profiling_info): Likewise.
(adjust_refs_in_act_callers): Likewise.
(struct cloning_opportunity_ranking): Likewise.
* ipa-fnsummary.cc (evaluate_conditions_for_known_args): Likewise.
(unmodified_parm_or_parm_agg_item): Likewise.
(guards_builtin_unreachable): Likewise.
(analyze_function_body): Likewise.
(estimate_edge_devirt_benefit): Likewise.
* ipa-fnsummary.h (cross_module_call_p): Likewise.
* ipa-free-lang-data.cc (fld_simplified_type_name): Likewise.
(free_lang_data_in_decl): Likewise.
* ipa-icf-gimple.cc (func_checker::compare_decl): Likewise.
(func_checker::compatible_types_p): Likewise.
(func_checker::compare_gimple_asm): Likewise.
* ipa-icf.cc (sem_function::hash_stmt): Likewise.
(sem_item_optimizer::subdivide_classes_by_equality): Likewise.
(sem_item_optimizer::traverse_congruence_split): Likewise.
(sem_item_optimizer::process_cong_reduction): Likewise.
* ipa-inline-transform.cc (mark_all_inlined_calls_cdtor): Likewise.
(preserve_function_body_p): Likewise.
* ipa-inline.cc (enum can_inline_edge_by_limits_flags): Likewise.
(can_early_inline_edge_p): Likewise.
(early_inliner): Likewise.
* ipa-locality-cloning.cc (edge_redirectable_p): Likewise.
(clone_node_as_needed): Likewise.
(partition_callchain): Likewise.
* ipa-modref.cc (modref_eaf_analysis::merge_with_ssa_name): Likewise.
* ipa-param-manipulation.cc
(ipa_param_adjustments::get_surviving_params): Likewise.
(purge_all_uses): Likewise.
(ipa_param_body_adjustments::mark_dead_statements): Likewise.
(replace_with_mapped_expr): Likewise.
(ipa_param_body_adjustments::get_new_param_chain): Likewise.
(record_argument_state): Likewise.
(ipa_param_body_adjustments::perform_cfun_body_modifications): Likewise.
* ipa-param-manipulation.h (struct ipa_replace_map): Likewise.
* ipa-polymorphic-call.cc (ipa_polymorphic_call_context::combine_with):
Likewise.
* ipa-prop.cc (struct ipa_vr_ggc_hash_traits): Likewise.
(noted_fnptr_hasher::equal): Likewise.
(ipa_set_ancestor_jf): Likewise.
(check_stmt_for_type_change): Likewise.
(param_type_may_change_p): Likewise.
(find_dominating_aa_status): Likewise.
(parm_ref_data_pass_through_p): Likewise.
(build_agg_jump_func_from_list): Likewise.
(analyze_agg_content_value): Likewise.
(ipa_single_noted_fnptr_in_record): Likewise.
(ipa_make_edge_direct_to_target): Likewise.
(combine_controlled_uses_counters): Likewise.
(ipa_duplicate_jump_function): Likewise.
(ipa_write_jump_function): Likewise.
(useful_ipcp_transformation_info_p): Likewise.
* ipa-prop.h (struct GTY): Likewise.
* ipa-reference.cc (ipa_reference_var_uid): Likewise.
(ipa_reference_get_written_global): Likewise.
(union_static_var_sets): Likewise.
* ipa-split.cc (split_function): Likewise.
* ipa-sra.cc (isra_track_scalar_value_uses): Likewise.
(process_scan_results): Likewise.
(flip_all_hints_pessimistic): Likewise.
(flip_all_param_hints_pessimistic): Likewise.
* ipa-strub.cc (get_strub_mode_attr_parm): Likewise.
(compute_strub_mode): Likewise.
* ipa-utils.cc (ipa_merge_profiles): Likewise.
(recursive_call_p): Likewise.
(stmt_may_terminate_function_p): Likewise.
(find_always_executed_bbs): Likewise.
* ipa-utils.h (type_with_linkage_p): Likewise.
(lto_streaming_expected_p): Likewise.
* ipa-visibility.cc (varpool_node::externally_visible_p): Likewise.
* ipa.cc (update_inlined_to_pointer): Likewise.
(enqueue_node): Likewise.
(process_references): Likewise.
(set_readonly_bit): Likewise.
(clear_addressable_bit): Likewise.
(BOTTOM): Likewise.
(propagate_single_user): Likewise.
---
gcc/ipa-comdats.cc | 2 +-
gcc/ipa-cp.cc | 12 ++++++------
gcc/ipa-fnsummary.cc | 10 +++++-----
gcc/ipa-fnsummary.h | 6 +++---
gcc/ipa-free-lang-data.cc | 6 +++---
gcc/ipa-icf-gimple.cc | 6 +++---
gcc/ipa-icf.cc | 10 +++++-----
gcc/ipa-inline-transform.cc | 4 ++--
gcc/ipa-inline.cc | 6 +++---
gcc/ipa-locality-cloning.cc | 10 +++++-----
gcc/ipa-modref.cc | 2 +-
gcc/ipa-param-manipulation.cc | 16 ++++++++--------
gcc/ipa-param-manipulation.h | 6 +++---
gcc/ipa-polymorphic-call.cc | 2 +-
gcc/ipa-prop.cc | 34 +++++++++++++++++-----------------
gcc/ipa-prop.h | 10 +++++-----
gcc/ipa-reference.cc | 6 +++---
gcc/ipa-split.cc | 2 +-
gcc/ipa-sra.cc | 10 +++++-----
gcc/ipa-strub.cc | 6 +++---
gcc/ipa-utils.cc | 12 ++++++------
gcc/ipa-utils.h | 4 ++--
gcc/ipa-visibility.cc | 8 ++++----
gcc/ipa.cc | 14 +++++++-------
24 files changed, 102 insertions(+), 102 deletions(-)
diff --git a/gcc/ipa-comdats.cc b/gcc/ipa-comdats.cc
index b89eb596ef3..7a95fde2324 100644
--- a/gcc/ipa-comdats.cc
+++ b/gcc/ipa-comdats.cc
@@ -20,7 +20,7 @@ along with GCC; see the file COPYING3. If not see
/* This is very simple pass that looks for static symbols that are used
exclusively by symbol within one comdat group. In this case it makes
sense to bring the symbol itself into the group to avoid dead code
- that would arrise when the comdat group from current unit is replaced
+ that would arise when the comdat group from current unit is replaced
by a different copy. Consider for example:
static int q(void)
diff --git a/gcc/ipa-cp.cc b/gcc/ipa-cp.cc
index c1b1f6201fd..ec9aaaea4cc 100644
--- a/gcc/ipa-cp.cc
+++ b/gcc/ipa-cp.cc
@@ -3495,7 +3495,7 @@ good_cloning_opportunity_p (struct cgraph_node *node,
sreal time_benefit,
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, " not cloning: time saved is not hot\n");
}
- /* Evaulation approximately corresponds to time saved per instruction
+ /* Evaluation approximately corresponds to time saved per instruction
introduced. This is likely almost always going to be true, since we
already checked that time saved is large enough to be considered
hot. */
@@ -4537,7 +4537,7 @@ dump_profile_updates (cgraph_node *node, bool spec)
/* With partial train run we do not want to assume that original's count is
zero whenever we redurect all executed edges to clone. Simply drop profile
to local one in this case. In eany case, return the new value. ORIG_NODE
- is the original node and its count has not been updaed yet. */
+ is the original node and its count has not been updated yet. */
profile_count
lenient_count_portion_handling (profile_count remainder, cgraph_node
*orig_node)
@@ -4722,7 +4722,7 @@ update_counts_for_self_gen_clones (cgraph_node *orig_node,
}
}
- /* Edges from the seeds of the valus generated for arithmetic jump-functions
+ /* Edges from the seeds of the values generated for arithmetic jump-functions
along self-recursive edges are likely to have fairly low count and so
edges from them to nodes in the self_gen_clones do not correspond to the
artificially distributed count of the nodes, the total sum of incoming
@@ -4794,7 +4794,7 @@ update_profiling_info (struct cgraph_node *orig_node,
bool orig_edges_processed = false;
if (new_sum > orig_node_count)
{
- /* Profile has alreay gone astray, keep what we have but lower it
+ /* Profile has already gone astray, keep what we have but lower it
to global0adjusted or to local if we have partial training. */
if (opt_for_fn (orig_node->decl, flag_profile_partial_training))
orig_node->make_profile_local ();
@@ -4954,7 +4954,7 @@ adjust_refs_in_act_callers (struct cgraph_node *node,
void *data)
/* At INDEX of a function being called by CS there is an ADDR_EXPR of a
variable which is only dereferenced and which is represented by SYMBOL. See
- if we can remove ADDR reference in callers assosiated witht the call. */
+ if we can remove ADDR reference in callers associated with the call. */
static void
adjust_references_in_caller (cgraph_edge *cs, symtab_node *symbol, int index)
@@ -6127,7 +6127,7 @@ struct cloning_opportunity_ranking
int index;
};
-/* Helper function to qsort a vecotr of cloning opportunities. */
+/* Helper function to qsort a vector of cloning opportunities. */
static int
compare_cloning_opportunities (const void *a, const void *b)
diff --git a/gcc/ipa-fnsummary.cc b/gcc/ipa-fnsummary.cc
index ff181113078..a6ccdb1852a 100644
--- a/gcc/ipa-fnsummary.cc
+++ b/gcc/ipa-fnsummary.cc
@@ -566,7 +566,7 @@ evaluate_conditions_for_known_args (struct cgraph_node
*node,
*ret_nonspec_clause = nonspec_clause;
}
-/* Return true if VRP will be exectued on the function.
+/* Return true if VRP will be executed on the function.
We do not want to anticipate optimizations that will not happen.
FIXME: This can be confused with -fdisable and debug counters and thus
@@ -1323,7 +1323,7 @@ unmodified_parm_or_parm_agg_item (struct
ipa_func_body_info *fbi,
size_p, &aggpos->by_ref);
}
-/* If stmt is simple load or store of value pointed to by a function parmaeter,
+/* If stmt is simple load or store of value pointed to by a function parameter,
return its index. */
static int
@@ -2745,7 +2745,7 @@ guards_builtin_unreachable (basic_block bb, vec<unsigned
char> &cache)
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,
"BB %i ends with conditional guarding __builtin_unreachable;"
- " conditinal is unnecesary\n", bb->index);
+ " conditinal is unnecessary\n", bb->index);
return true;
}
return false;
@@ -3011,7 +3011,7 @@ analyze_function_body (struct cgraph_node *node, bool
early)
{
if (dump_file && (dump_flags & TDF_DETAILS))
{
- fprintf (dump_file, " skipping unnecesary stmt ");
+ fprintf (dump_file, " skipping unnecessary stmt ");
print_gimple_stmt (dump_file, stmt, 0);
}
/* TODO: const calls used only to produce values for
@@ -3610,7 +3610,7 @@ estimate_edge_devirt_benefit (struct cgraph_edge *ie,
/* Increase SIZE, MIN_SIZE (if non-NULL) and TIME for size and time needed to
handle edge E with probability PROB. Set HINTS accordingly if edge may be
devirtualized. AVALS, if non-NULL, describes the context of the call site
- as far as values of parameters are concerened. */
+ as far as values of parameters are concerned. */
static inline void
estimate_edge_size_and_time (struct cgraph_edge *e, int *size, int *min_size,
diff --git a/gcc/ipa-fnsummary.h b/gcc/ipa-fnsummary.h
index de7b7f61cb1..0503ec4c8d7 100644
--- a/gcc/ipa-fnsummary.h
+++ b/gcc/ipa-fnsummary.h
@@ -191,7 +191,7 @@ public:
auto_vec<size_time_entry> GTY((skip)) size_time_table;
/* Unlike size_time_table that is initialized for all summaries
call_size_time_table is allocated only for functions with
- many calls. Use effecient vl_ptr storage. */
+ many calls. Use efficient vl_ptr storage. */
vec<size_time_entry, va_heap, vl_ptr> GTY((skip)) call_size_time_table;
/* Predicates on when some loops in the function can have known bounds. */
@@ -440,11 +440,11 @@ void ipa_remove_from_growth_caches (struct cgraph_edge
*edge);
inline bool
cross_module_call_p (struct cgraph_edge *edge)
{
- /* Here we do not want to walk to alias target becuase ICF may create
+ /* Here we do not want to walk to alias target because ICF may create
cross-unit aliases. */
if (edge->caller->unit_id == edge->callee->unit_id)
return false;
- /* If the call is to a (former) comdat function or s symbol with mutiple
+ /* If the call is to a (former) comdat function or s symbol with multiple
extern inline definitions then treat is as in-module call. */
if (edge->callee->merged_extern_inline || edge->callee->merged_comdat
|| DECL_COMDAT (edge->callee->decl))
diff --git a/gcc/ipa-free-lang-data.cc b/gcc/ipa-free-lang-data.cc
index f32563fdd22..3ff3f9638ff 100644
--- a/gcc/ipa-free-lang-data.cc
+++ b/gcc/ipa-free-lang-data.cc
@@ -116,7 +116,7 @@ fld_simplified_type_name (tree type)
return TYPE_NAME (type);
}
-/* Do same comparsion as check_qualified_type skipping lang part of type
+/* Do same comparison as check_qualified_type skipping lang part of type
and be more permissive about type names: we only care that names are
same (for diagnostics) and that ODR names are the same.
If INNER_TYPE is non-NULL, be sure that TREE_TYPE match it. */
@@ -569,7 +569,7 @@ free_lang_data_in_decl (tree decl, class free_lang_data_d
*fld)
use for middle-end.
It would make more sense if frontends set TREE_ADDRESSABLE to 0 only
- for public objects that indeed cannot be adressed, but it is not
+ for public objects that indeed cannot be addressed, but it is not
the case. Set the flag to true so we do not get merge failures for
i.e. virtual tables between units that take address of it and
units that don't. */
@@ -683,7 +683,7 @@ free_lang_data_in_decl (tree decl, class free_lang_data_d
*fld)
these are needed by devirtualization.
C++ destructors are special because C++ frontends sometimes produces
virtual destructor as an alias of non-virtual destructor. In
- devirutalization code we always walk through aliases and we need
+ devirtualization code we always walk through aliases and we need
context to be preserved too. See PR89335 */
if (TREE_CODE (decl) != FIELD_DECL
&& ((TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != FUNCTION_DECL)
diff --git a/gcc/ipa-icf-gimple.cc b/gcc/ipa-icf-gimple.cc
index 4a95ae0bb9b..2bceb008bd8 100644
--- a/gcc/ipa-icf-gimple.cc
+++ b/gcc/ipa-icf-gimple.cc
@@ -166,7 +166,7 @@ func_checker::compare_decl (const_tree t1, const_tree t2)
/* We do not really need to check types of variables, since they are just
blocks of memory and we verify types of the accesses to them.
However do compare types of other kinds of decls
- (parm decls and result decl types may affect ABI convetions). */
+ (parm decls and result decl types may affect ABI conventions). */
if (t != VAR_DECL)
{
if (!compatible_types_p (TREE_TYPE (t1), TREE_TYPE (t2)))
@@ -238,7 +238,7 @@ func_checker::compatible_types_p (tree t1, tree t2)
}
/* Add hash of ARG to HSTATE. FLAGS have same meaning
- as for operand_equal_p. Works only if operand acces type is OP_NORMAL. */
+ as for operand_equal_p. Works only if operand access type is OP_NORMAL. */
void
func_checker::hash_operand (const_tree arg, inchash::hash &hstate,
@@ -1016,7 +1016,7 @@ func_checker::compare_gimple_asm (const gasm *g1, const
gasm *g2)
if (gimple_asm_noutputs (g1) != gimple_asm_noutputs (g2))
return false;
- /* We do not suppport goto ASM statement comparison. */
+ /* We do not support goto ASM statement comparison. */
if (gimple_asm_nlabels (g1) || gimple_asm_nlabels (g2))
return false;
diff --git a/gcc/ipa-icf.cc b/gcc/ipa-icf.cc
index 40e9614c736..44501ec760e 100644
--- a/gcc/ipa-icf.cc
+++ b/gcc/ipa-icf.cc
@@ -1473,7 +1473,7 @@ sem_function::hash_stmt (gimple *stmt, inchash::hash
&hstate)
(&map, gimple_op (stmt, i));
m_checker->hash_operand (gimple_op (stmt, i), hstate, 0,
access_type);
- /* For memory accesses when hasing for LTO stremaing record
+ /* For memory accesses when hashing for LTO streaming record
base and ref alias ptr types so we can compare them at WPA
time without having to read actual function body. */
if (access_type == func_checker::OP_MEMORY
@@ -2795,7 +2795,7 @@ sem_item_optimizer::subdivide_classes_by_equality (bool
in_wpa)
}
// We replace newly created new_vector for the class we've just
- // splitted.
+ // split.
c->members.release ();
c->members.create (new_vector.length ());
@@ -2963,7 +2963,7 @@ sem_item_optimizer::traverse_congruence_split
(congruence_class * const &cls,
const congruence_class *splitter_cls = pair->cls;
/* If counted bits are greater than zero and less than the number of members
- a group will be splitted. */
+ a group will be split. */
unsigned popcount = bitmap_count_bits (b);
if (popcount > 0 && popcount < cls->members.length ())
@@ -3031,7 +3031,7 @@ sem_item_optimizer::traverse_congruence_split
(congruence_class * const &cls,
if (dump_file && (dump_flags & TDF_DETAILS))
{
- fprintf (dump_file, " congruence class splitted:\n");
+ fprintf (dump_file, " congruence class split:\n");
cls->dump (dump_file, 4);
fprintf (dump_file, " newly created groups:\n");
@@ -3234,7 +3234,7 @@ sem_item_optimizer::process_cong_reduction (void)
"new classes.\n", new_classes);
}
-/* Debug function prints all informations about congruence classes. */
+/* Debug function prints all information about congruence classes. */
void
sem_item_optimizer::dump_cong_classes (void)
diff --git a/gcc/ipa-inline-transform.cc b/gcc/ipa-inline-transform.cc
index c4df9d91425..3f190ec2ad0 100644
--- a/gcc/ipa-inline-transform.cc
+++ b/gcc/ipa-inline-transform.cc
@@ -310,7 +310,7 @@ mark_all_inlined_calls_cdtor (cgraph_node *node)
/* Mark edge E as inlined and update callgraph accordingly. UPDATE_ORIGINAL
specify whether profile of original function should be updated and whether
- offline copy should be removed if unnecesary. If any new
+ offline copy should be removed if unnecessary. If any new
indirect edges are discovered in the process, add them to NEW_EDGES, unless
it is NULL. If UPDATE_OVERALL_SUMMARY is false, do not bother to recompute
overall
size of caller after inlining. Caller is required to eventually do it via
@@ -771,7 +771,7 @@ preserve_function_body_p (struct cgraph_node *node)
with param manipulation because IPA param manipulation attaches debug
statements to PARM_DECLs of called clone. Materialize them if needed.
- FIXME: This is somehwat broken by design because it does not play well
+ FIXME: This is somewhat broken by design because it does not play well
with partitioning. */
static void
diff --git a/gcc/ipa-inline.cc b/gcc/ipa-inline.cc
index 24d8974d5ca..5a7615666cc 100644
--- a/gcc/ipa-inline.cc
+++ b/gcc/ipa-inline.cc
@@ -511,7 +511,7 @@ enum can_inline_edge_by_limits_flags
/* Ignore size limits. */
CAN_INLINE_DISREGARD_LIMITS = 2,
/* Force size limits (ignore always_inline). This is used for
- recrusive inlining where always_inline may lead to inline bombs
+ recursive inlining where always_inline may lead to inline bombs
and technically it is non-sential anyway. */
CAN_INLINE_FORCE_LIMITS = 4,
/* Report decision to dump file. */
@@ -725,7 +725,7 @@ can_early_inline_edge_p (struct cgraph_edge *e)
|| !lookup_attribute ("always_inline", DECL_ATTRIBUTES
(callee->decl))))
{
/* If there are indirect calls, inlining may produce direct call.
- TODO: We may lift this restriction if we avoid errors on formely
+ TODO: We may lift this restriction if we avoid errors on formerly
indirect calls to always_inline functions. Taking address
of always_inline function is generally bad idea and should
have been declared as undefined, but sadly we allow this. */
@@ -3270,7 +3270,7 @@ early_inliner (function *fun)
statements that don't have inline parameters computed. */
for (edge = node->callees; edge; edge = edge->next_callee)
{
- /* We can enounter not-yet-analyzed function during
+ /* We can encounter not-yet-analyzed function during
early inlining on callgraphs with strongly
connected components. */
ipa_call_summary *es = ipa_call_summaries->get_create (edge);
diff --git a/gcc/ipa-locality-cloning.cc b/gcc/ipa-locality-cloning.cc
index e75458b8fb9..f7a875cd40c 100644
--- a/gcc/ipa-locality-cloning.cc
+++ b/gcc/ipa-locality-cloning.cc
@@ -44,13 +44,13 @@ along with GCC; see the file COPYING3. If not see
satisfied.
3. Redirect any new caller to a local clone if one exists.
- Another heuristics can be used in the absense of profile information. This
+ Another heuristics can be used in the absence of profile information. This
approach uses C++ template instantiation types to group functions together.
Entry functions are sorted in the beginning by most used template types, and
callees are sorted as part of partition_callchain (), again by template
types.
- For bothe schemes, partition size is param controlled to fine tune per
+ For both schemes, partition size is param controlled to fine tune per
program behavior. */
#include "config.h"
@@ -780,7 +780,7 @@ edge_redirectable_p (cgraph_edge *edge,
lto_locality_cloning_model cm)
/* Create a locality clone of CNODE and redirect all callers present in
PARTITION.
- Create a clone dpending on whether CNODE itself is a clone or not. */
+ Create a clone depending on whether CNODE itself is a clone or not. */
static cgraph_node *
create_locality_clone (cgraph_node *cnode,
@@ -1084,7 +1084,7 @@ clone_node_as_needed (cgraph_edge *edge,
locality_partition partition,
return cloned_node;
}
-/* Determine if EDGE->CALLEE is suitable for cloning. It is assummed that the
+/* Determine if EDGE->CALLEE is suitable for cloning. It is assumed that the
callee is not an inlined node. */
static bool
@@ -1232,7 +1232,7 @@ partition_callchain (cgraph_node *node,
locality_partition &partition,
In partition X, edge A->B was transformed to A->B_clone0.
In current partition, A was cloned to A_clone0 and now
B_clone0 is visited via edge A_clone0->B_clone0. If a
- B_clonei is present, redirect A_clone0 to it, otherise do
+ B_clonei is present, redirect A_clone0 to it, otherwise do
nothing.
3. N is not a locality clone and no clone of N is present in
PARTITION, check for suitability and clone. */
diff --git a/gcc/ipa-modref.cc b/gcc/ipa-modref.cc
index 9372cc1d594..7883a90bcdd 100644
--- a/gcc/ipa-modref.cc
+++ b/gcc/ipa-modref.cc
@@ -2744,7 +2744,7 @@ modref_eaf_analysis::merge_with_ssa_name (tree dest, tree
src, bool deref)
m_lattice[src_index].do_dataflow = true;
if (dump_file)
fprintf (dump_file,
- "%*sWill propgate from ssa_name %i to %i%s\n",
+ "%*sWill propagate from ssa_name %i to %i%s\n",
m_depth * 4 + 4,
"", src_index, index, deref ? " (deref)" : "");
}
diff --git a/gcc/ipa-param-manipulation.cc b/gcc/ipa-param-manipulation.cc
index 024db825977..e35f6223541 100644
--- a/gcc/ipa-param-manipulation.cc
+++ b/gcc/ipa-param-manipulation.cc
@@ -52,7 +52,7 @@ along with GCC; see the file COPYING3. If not see
#include "ipa-prop.h"
#include "attr-callback.h"
-/* Actual prefixes of different newly synthetized parameters. Keep in sync
+/* Actual prefixes of different newly synthesized parameters. Keep in sync
with IPA_PARAM_PREFIX_* defines. */
static const char *ipa_param_prefixes[IPA_PARAM_PREFIX_COUNT]
@@ -439,7 +439,7 @@ ipa_param_adjustments::get_surviving_params (vec<bool>
*surviving_params)
}
/* Fill NEW_INDICES with new indices of each surviving parameter or -1 for
- those which do not survive. Any parameter outside of lenght of the vector
+ those which do not survive. Any parameter outside of length of the vector
does not survive. There is currently no support for a parameter to be
copied to two distinct new parameters. */
@@ -646,7 +646,7 @@ purge_all_uses (tree name, hash_set <tree> *killed_ssas)
{
if (gimple_debug_bind_p (stmt))
{
- /* When runing within tree-inline, we will never end up here but
+ /* When running within tree-inline, we will never end up here but
adding the SSAs to killed_ssas will do the trick in this case
and the respective debug statements will get reset. */
gimple_debug_bind_reset_value (stmt);
@@ -1185,7 +1185,7 @@ ipa_param_body_adjustments::mark_dead_statements (tree
dead_param,
{
/* Current IPA analyses which remove unused parameters never remove a
non-gimple register ones which have any use except as parameters in other
- calls, so we can safely leve them as they are. */
+ calls, so we can safely leave them as they are. */
tree parm_ddef = get_ddef_if_exists_and_is_used (dead_param);
if (!parm_ddef)
return;
@@ -1324,7 +1324,7 @@ replace_with_mapped_expr (tree *remap, int
*walk_subtrees, void *data)
return 0;
}
-/* Replace all occurances of SSAs in m_dead_ssa_debug_equiv in t with what they
+/* Replace all occurrences of SSAs in m_dead_ssa_debug_equiv in t with what
they
are mapped to. */
void
@@ -1751,7 +1751,7 @@ ipa_param_body_adjustments::get_new_param_chain ()
/* Modify the function parameters FNDECL and its type according to the plan in
ADJUSTMENTS. This function needs to be called when the decl has not already
been processed with ipa_param_adjustments::adjust_decl, otherwise just
- seting DECL_ARGUMENTS to whatever get_new_param_chain will do is enough. */
+ setting DECL_ARGUMENTS to whatever get_new_param_chain will do is enough.
*/
void
ipa_param_body_adjustments::modify_formal_parameters ()
@@ -2205,7 +2205,7 @@ record_argument_state (copy_body_data *id, gimple
*orig_stmt,
up call_graph edges.
If the method is invoked as a part of IPA clone materialization and if any
- parameter split is pass-through, i.e. it applies to the functin that is
+ parameter split is pass-through, i.e. it applies to the function that is
being modified and also to the callee of the statement, replace the
parameter passed to old callee with all of the replacement a callee might
possibly want and record the performed argument modifications in
@@ -2635,7 +2635,7 @@
ipa_param_body_adjustments::perform_cfun_body_modifications ()
/* If there are any initialization statements that need to be emitted into
- the basic block BB right at ther start of the new function, do so. */
+ the basic block BB right at the start of the new function, do so. */
void
ipa_param_body_adjustments::append_init_stmts (basic_block bb)
{
diff --git a/gcc/ipa-param-manipulation.h b/gcc/ipa-param-manipulation.h
index f31c6a6bd29..307e351ba6e 100644
--- a/gcc/ipa-param-manipulation.h
+++ b/gcc/ipa-param-manipulation.h
@@ -290,7 +290,7 @@ struct ipa_replace_map;
part of tree-inine.c's tree_function_versioning machinery to clone functions
(when M_ID is not NULL) and in s standalone fashion, modifying an existing
function in place (when M_ID is NULL). While a lot of stuff handled in a
- unified way in both modes, there are many aspects of the processs that
+ unified way in both modes, there are many aspects of the process that
requires distinct paths. */
class ipa_param_body_adjustments
@@ -337,12 +337,12 @@ public:
gimple *orig_stmt);
/* Return the new chain of parameters. */
tree get_new_param_chain ();
- /* Replace all occurances of SSAs in m_dead_ssa_debug_equiv in t with what
+ /* Replace all occurrences of SSAs in m_dead_ssa_debug_equiv in t with what
they are mapped to. */
void remap_with_debug_expressions (tree *t);
/* If there are any initialization statements that need to be emitted into
- the basic block BB right at ther start of the new function, do so. */
+ the basic block BB right at the start of the new function, do so. */
void append_init_stmts (basic_block bb);
/* Pointers to data structures defining how the function should be
diff --git a/gcc/ipa-polymorphic-call.cc b/gcc/ipa-polymorphic-call.cc
index 66b70e52966..b0a1edd96d8 100644
--- a/gcc/ipa-polymorphic-call.cc
+++ b/gcc/ipa-polymorphic-call.cc
@@ -2227,7 +2227,7 @@ ipa_polymorphic_call_context::combine_with
(ipa_polymorphic_call_context ctx,
}
/* If we do not know how the context is being used, we cannot
- clear MAYBE_IN_CONSTRUCTION because it may be offseted
+ clear MAYBE_IN_CONSTRUCTION because it may be offsetted
to other component of OUTER_TYPE later and we know nothing
about it. */
if (otr_type && maybe_in_construction
diff --git a/gcc/ipa-prop.cc b/gcc/ipa-prop.cc
index 6675c2191fc..80b24a815cb 100644
--- a/gcc/ipa-prop.cc
+++ b/gcc/ipa-prop.cc
@@ -83,7 +83,7 @@ struct ipa_vr_ggc_hash_traits : public ggc_cache_remove
<ipa_vr *>
{
// This never get called, except in the verification code, as
// ipa_get_value_range() calculates the hash itself. This
- // function is mostly here for completness' sake.
+ // function is mostly here for completeness' sake.
value_range vr;
p->get_vrange (vr);
inchash::hash hstate;
@@ -320,7 +320,7 @@ noted_fnptr_hasher::equal (noted_fnptr_store *v1,
}
-/* Structore holding the information that all stores to OFFSET of a particular
+/* Structure holding the information that all stores to OFFSET of a particular
record type RECTYPE was storing a pointer to specific function or that there
were multiple such functions. */
@@ -806,7 +806,7 @@ ipa_set_ancestor_jf (struct ipa_jump_func *jfunc,
HOST_WIDE_INT offset,
jfunc->value.ancestor.keep_null = keep_null;
}
-/* Get IPA BB information about the given BB. FBI is the context of analyzis
+/* Get IPA BB information about the given BB. FBI is the context of analysis
of this function body. */
static struct ipa_bb_info *
@@ -918,7 +918,7 @@ check_stmt_for_type_change (ao_ref *ao ATTRIBUTE_UNUSED,
tree vdef, void *data)
/* See if ARG is PARAM_DECl describing instance passed by pointer
or reference in FUNCTION. Return false if the dynamic type may change
- in between beggining of the function until CALL is invoked.
+ in between beginning of the function until CALL is invoked.
Generally functions are not allowed to change type of such instances,
but they call destructors. We assume that methods cannot destroy the THIS
@@ -932,7 +932,7 @@ param_type_may_change_p (tree function, tree arg, gimple
*call)
that require writing to memory. */
if (flags_from_decl_or_type (function) & (ECF_PURE | ECF_CONST))
return false;
- /* We need to check if we are within inlined consturctor
+ /* We need to check if we are within inlined constructor
or destructor (ideally we would have way to check that the
inline cdtor is actually working on ARG, but we don't have
easy tie on this, so punt on all non-pure cdtors.
@@ -977,7 +977,7 @@ param_type_may_change_p (tree function, tree arg, gimple
*call)
returned by get_ref_base_and_extent, as is the offset.
This is helper function for detect_type_change and detect_type_change_ssa
- that does the heavy work which is usually unnecesary. */
+ that does the heavy work which is usually unnecessary. */
static bool
detect_type_change_from_memory_writes (ipa_func_body_info *fbi, tree arg,
@@ -1107,7 +1107,7 @@ find_dominating_aa_status (struct ipa_func_body_info
*fbi, basic_block bb,
}
/* Get AA status structure for the given BB and parameter with INDEX. Allocate
- structures and/or intialize the result with a dominating description as
+ structures and/or initialize the result with a dominating description as
necessary. */
static struct ipa_param_aa_status *
@@ -1247,8 +1247,8 @@ parm_ref_data_pass_through_p (struct ipa_func_body_info
*fbi, int index,
bool modified = false;
ao_ref refd;
- /* It's unnecessary to calculate anything about memory contnets for a const
- function because it is not goin to use it. But do not cache the result
+ /* It's unnecessary to calculate anything about memory contents for a const
+ function because it is not going to use it. But do not cache the result
either. Also, no such calculations for non-pointers. */
if (!gimple_vuse (call)
|| !POINTER_TYPE_P (TREE_TYPE (parm)))
@@ -1908,7 +1908,7 @@ build_agg_jump_func_from_list (struct
ipa_known_agg_contents_list *list,
if (list->value.pass_through.formal_id >= 0)
{
- /* Content value is derived from some formal paramerter. */
+ /* Content value is derived from some formal parameter. */
if (list->value.offset >= 0)
item.jftype = IPA_JF_LOAD_AGG;
else
@@ -2012,7 +2012,7 @@ analyze_agg_content_value (struct ipa_func_body_info *fbi,
__x_MOD_foo (&parm.6, b_31(D));
The aggregate function describing parm.6.dim[0].stride is encoded as a
- PASS-THROUGH jump function with ASSERT_EXPR operation whith operand 1
+ PASS-THROUGH jump function with ASSERT_EXPR operation with operand 1
(the constant from the PHI node). */
if (gimple_phi_num_args (phi) != 2
@@ -3349,7 +3349,7 @@ ipa_single_noted_fnptr_in_record (tree rec_type, unsigned
fld_offset)
}
/* Free the hash table storing the information about function pointers stored
- to a particular position in record typed strucutres. */
+ to a particular position in record typed structures. */
void
ipa_free_noted_fnptr_calls ()
@@ -4024,7 +4024,7 @@ ipa_make_edge_direct_to_target (struct cgraph_edge *ie,
tree target,
/* Member pointer call that goes through a VMT lookup. */
if ((sii && sii->member_ptr)
/* Or if target is not an invariant expression and we do not
- know if it will evaulate to function at runtime.
+ know if it will evaluate to function at runtime.
This can happen when folding through &VAR, where &VAR
is IP invariant, but VAR itself is not.
@@ -4738,7 +4738,7 @@ combine_controlled_uses_counters (int c, int d)
return c + d - 1;
}
-/* Propagate number of controlled users from CS->caleee to the new root of the
+/* Propagate number of controlled users from CS->callee to the new root of the
tree of inlined nodes. */
static void
@@ -5135,7 +5135,7 @@ ipa_duplicate_jump_function (cgraph_edge *src,
cgraph_edge *dst,
}
/* Method invoked when an edge is duplicated. Copy ipa_edge_args and adjust
- reference count data strucutres accordingly. */
+ reference count data structures accordingly. */
void
ipa_edge_args_sum_t::duplicate (cgraph_edge *src, cgraph_edge *dst,
@@ -5330,7 +5330,7 @@ ipa_write_jump_function (struct output_block *ob,
int i, count;
int flag = 0;
- /* ADDR_EXPRs are very comon IP invariants; save some streamer data
+ /* ADDR_EXPRs are very common IP invariants; save some streamer data
as well as WPA memory by handling them specially. */
if (jump_func->type == IPA_JF_CONST
&& TREE_CODE (jump_func->value.constant.value) == ADDR_EXPR)
@@ -6118,7 +6118,7 @@ useful_ipcp_transformation_info_p (ipcp_transformation
*ts)
return false;
}
-/* Write into OB IPA-CP transfromation summary TS describing NODE. */
+/* Write into OB IPA-CP transformation summary TS describing NODE. */
void
write_ipcp_transformation_info (output_block *ob, cgraph_node *node,
diff --git a/gcc/ipa-prop.h b/gcc/ipa-prop.h
index 173f5f466a2..9099afaea30 100644
--- a/gcc/ipa-prop.h
+++ b/gcc/ipa-prop.h
@@ -339,7 +339,7 @@ struct GTY (()) ipa_jump_func
struct ipa_agg_jump_function agg;
/* Information about value range, containing valid data only when vr_known is
- true. The pointed to structure is shared betweed different jump
+ true. The pointed to structure is shared between different jump
functions. Use ipa_set_jfunc_vr to set this field. */
ipa_vr *m_vr;
@@ -356,7 +356,7 @@ struct GTY (()) ipa_jump_func
};
-/* Return the constant stored in a constant jump functin JFUNC. */
+/* Return the constant stored in a constant jump function JFUNC. */
inline tree
ipa_get_jf_constant (struct ipa_jump_func *jfunc)
@@ -517,7 +517,7 @@ ipa_get_jf_ancestor_keep_null (struct ipa_jump_func *jfunc)
class ipa_auto_call_arg_values
{
public:
- /* If m_known_vals (vector of known "scalar" values) is sufficiantly long,
+ /* If m_known_vals (vector of known "scalar" values) is sufficiently long,
return its element at INDEX, otherwise return NULL. */
tree safe_sval_at (int index)
{
@@ -569,7 +569,7 @@ public:
m_known_value_ranges (aavals->m_known_value_ranges.to_vec_legacy ())
{}
- /* If m_known_vals (vector of known "scalar" values) is sufficiantly long,
+ /* If m_known_vals (vector of known "scalar" values) is sufficiently long,
return its element at INDEX, otherwise return NULL. */
tree safe_sval_at (int index)
{
@@ -1092,7 +1092,7 @@ public:
ipa_node_params *data2) final override;
};
-/* Summary to manange ipa_edge_args structures. */
+/* Summary to manage ipa_edge_args structures. */
class GTY((user)) ipa_edge_args_sum_t : public call_summary <ipa_edge_args *>
{
diff --git a/gcc/ipa-reference.cc b/gcc/ipa-reference.cc
index c5699312c8f..130cd4c1e66 100644
--- a/gcc/ipa-reference.cc
+++ b/gcc/ipa-reference.cc
@@ -156,7 +156,7 @@ ipa_reference_var_uid (tree t)
}
/* Return ID used by ipa-reference bitmaps. Create new entry if
- T is not in map. Set EXISTED accordinly */
+ T is not in map. Set EXISTED accordingly */
int
ipa_reference_var_get_or_insert_uid (tree t, bool *existed)
{
@@ -249,7 +249,7 @@ ipa_reference_get_written_global (struct cgraph_node *fn)
}
-/* Hepler for is_proper_for_analysis. */
+/* Helper for is_proper_for_analysis. */
static bool
is_improper (symtab_node *n, void *v ATTRIBUTE_UNUSED)
{
@@ -347,7 +347,7 @@ union_static_var_sets (bitmap &x, bitmap y)
In that case, we want to make that visible explicitly.
Even though bitmap_equal_p can be very expensive, it
turns out to be an overall win to check this here for
- an LTO bootstrap of GCC itself. Liberally extrapoliate
+ an LTO bootstrap of GCC itself. Liberally extrapolate
that result to be applicable to all cases. */
if (bitmap_equal_p (x, all_module_statics))
{
diff --git a/gcc/ipa-split.cc b/gcc/ipa-split.cc
index b31235c99cf..84a51fda1d7 100644
--- a/gcc/ipa-split.cc
+++ b/gcc/ipa-split.cc
@@ -1390,7 +1390,7 @@ split_function (basic_block return_bb, class split_point
*split_point,
}
- /* Let's take a time profile for splitted function. */
+ /* Let's take a time profile for split function. */
if (cur_node->tp_first_run)
node->tp_first_run = cur_node->tp_first_run + 1;
diff --git a/gcc/ipa-sra.cc b/gcc/ipa-sra.cc
index fd33e2028a0..422bf367b97 100644
--- a/gcc/ipa-sra.cc
+++ b/gcc/ipa-sra.cc
@@ -411,7 +411,7 @@ public:
/* Set when any of the call arguments are not byte-aligned. */
unsigned m_bit_aligned_arg : 1;
- /* Set to true if the call happend before any (other) store to memory in the
+ /* Set to true if the call happened before any (other) store to memory in the
caller. */
unsigned m_before_any_store : 1;
};
@@ -1028,7 +1028,7 @@ isra_track_scalar_value_uses (function *fun, cgraph_node
*node, tree name,
statement. If there are no such uses, return true and store the number of
actual arguments that this parameter eventually feeds to (or zero if there
is none) to DESC->call_uses and set DESC->remove_only_when_retval_removed if
- there are any uses in return statemens. For any such parameter, mark
+ there are any uses in return statements. For any such parameter, mark
PARM_NUM as one of its sources.
This function is similar to ptr_parm_has_nonarg_uses but its results are
@@ -2633,7 +2633,7 @@ process_scan_results (cgraph_node *node, struct function
*fun,
}
/* Walk basic block and see if its execution can terminate earlier.
- Keep the info for later re-use to avoid quadratic behavoiur
here. */
+ Keep the info for later re-use to avoid quadratic behaviour
here. */
gimple_stmt_iterator gsi = gsi_for_stmt (call_stmt);
bool safe = true;
int n = 0;
@@ -3469,7 +3469,7 @@ flip_all_hints_pessimistic (isra_param_desc *desc)
}
/* Because we have not analyzed or otherwise problematic caller, go over all
- parameter int flags of IFS describing a call graph node of a calllee and
+ parameter int flags of IFS describing a call graph node of a callee and
turn them pessimistic. Return true if any hints that need to potentially
trigger further propagation have changed. */
@@ -3488,7 +3488,7 @@ flip_all_param_hints_pessimistic (isra_func_summary *ifs)
return ret;
}
-/* Propagate hints accross edge CS which ultimately leads to a node described
+/* Propagate hints across edge CS which ultimately leads to a node described
by TO_IFS. Return true if any hints of the callee which should potentially
trigger further propagation have changed. */
diff --git a/gcc/ipa-strub.cc b/gcc/ipa-strub.cc
index d0ebba0a2ff..b0156fe46f6 100644
--- a/gcc/ipa-strub.cc
+++ b/gcc/ipa-strub.cc
@@ -370,7 +370,7 @@ get_strub_mode_attr_parm (enum strub_mode mode)
}
}
-/* Return the parmeters (TREE_VALUE) for a strub attribute of MODE.
+/* Return the parameters (TREE_VALUE) for a strub attribute of MODE.
We know we use a single parameter, so we bypass the creation of a
tree list. */
@@ -1068,7 +1068,7 @@ compute_strub_mode (cgraph_node *node, tree strub_attr)
const bool strub_flag_at_calls = flag_strub == 1;
/* On top of default, also enable strub implicitly for functions that can
safely undergo internal strubbing. At-calls mode will still be used in
- functions that requiest it explicitly with attribute strub() or strub(1),
+ functions that request it explicitly with attribute strub() or strub(1),
or when the function body requires strubbing and internal strubbing is not
viable. */
const bool strub_flag_internal = flag_strub == 2;
@@ -1747,7 +1747,7 @@ public:
virtual bool gate (function *) {
/* In relaxed (-3) and strict (-4) settings, that only enable strub at a
function or variable attribute's request, the attribute handler changes
- flag_strub to -1 or -2, respectively, if any strub-enabling occurence of
+ flag_strub to -1 or -2, respectively, if any strub-enabling occurrence
of
the attribute is found. Therefore, if it remains at -3 or -4, nothing
that would enable strub was found, so we can disable it and avoid the
overhead. */
diff --git a/gcc/ipa-utils.cc b/gcc/ipa-utils.cc
index f6ba07aef48..ac052ad4b34 100644
--- a/gcc/ipa-utils.cc
+++ b/gcc/ipa-utils.cc
@@ -760,7 +760,7 @@ ipa_merge_profiles (struct cgraph_node *dst,
src->decl = oldsrcdecl;
}
-/* Return true if call to DEST is known to be self-recusive
+/* Return true if call to DEST is known to be self-recursive
call withing FUNC. */
bool
@@ -778,7 +778,7 @@ recursive_call_p (tree func, tree dest)
return true;
if (!dest_node->semantically_equivalent_p (cnode))
return false;
- /* If there is only one way to call the fuction or we know all of them
+ /* If there is only one way to call the function or we know all of them
are semantically equivalent, we still can consider call recursive. */
FOR_EACH_ALIAS (cnode, alias)
if (!dest_node->semantically_equivalent_p (alias->referring))
@@ -788,7 +788,7 @@ recursive_call_p (tree func, tree dest)
/* Return true if stmt may terminate execution of function.
If assume_return_or_eh we can further assume that the function ends
- either by retrn statement or EH (no trapping or infinite loops). */
+ either by return statement or EH (no trapping or infinite loops). */
bool
stmt_may_terminate_function_p (function *fun, gimple *stmt, bool
assume_return_or_eh)
@@ -819,8 +819,8 @@ stmt_may_terminate_function_p (function *fun, gimple *stmt,
bool assume_return_o
execute on every invocation of the function.
If assume_return_or_eh we can further assume that the function ends
- either by retrn statement or EH (no trapping or infinite loops).
- This is useful when sumarizing function in passes like ipa-modref.
+ either by return statement or EH (no trapping or infinite loops).
+ This is useful when summarizing function in passes like ipa-modref.
Seeing assume_return_or_eh to false is used to prove that given
statmeent will be executed even if the function gets into infinite
@@ -868,7 +868,7 @@ find_always_executed_bbs (function *fun, bool
assume_return_or_eh)
TODO: with C++ forced progression we can still walk the
irreducible region and see if it contains any side effects.
Similarly for loops. -ffinite-loops does not really imply
- this since we allow inlining across -ffinite-loops bondary
+ this since we allow inlining across -ffinite-loops boundary
and thus it can be used only as a loop flag. */
if (e->dest->loop_father->header != e->dest
|| !dominated_by_p (CDI_DOMINATORS, bb, e->dest))
diff --git a/gcc/ipa-utils.h b/gcc/ipa-utils.h
index 172ba401d3d..d689d45c70c 100644
--- a/gcc/ipa-utils.h
+++ b/gcc/ipa-utils.h
@@ -220,7 +220,7 @@ type_with_linkage_p (const_tree t)
if (!TYPE_NAME (t) || TREE_CODE (TYPE_NAME (t)) != TYPE_DECL)
return false;
- /* After free_lang_data was run we can recongize
+ /* After free_lang_data was run we can recognize
types with linkage by presence of mangled name. */
if (DECL_ASSEMBLER_NAME_SET_P (TYPE_NAME (t)))
return true;
@@ -295,7 +295,7 @@ get_odr_name_for_type (tree type)
inline bool
lto_streaming_expected_p ()
{
- /* Compilation before LTO stremaing. */
+ /* Compilation before LTO streaming. */
if (flag_lto && !in_lto_p && symtab->state < IPA_SSA_AFTER_INLINING)
return true;
/* WPA or incremental link. */
diff --git a/gcc/ipa-visibility.cc b/gcc/ipa-visibility.cc
index d0d6348d534..4361d84adc9 100644
--- a/gcc/ipa-visibility.cc
+++ b/gcc/ipa-visibility.cc
@@ -51,14 +51,14 @@ along with GCC; see the file COPYING3. If not see
Comdat group represent a section that may be replaced by linker by
a different copy of the same section from other unit.
If we have resolution information (from linker plugin) and we know that
- a given comdat gorup is prevailing, we can dismantle it and turn symbols
+ a given comdat group is prevailing, we can dismantle it and turn symbols
into normal symbols. If the resolution information says that the
section was previaled by copy from non-LTO code, we can also dismantle
it and turn all symbols into external.
- Local aliases:
- Some symbols can be interposed by dynamic linker. Refering to these
+ Some symbols can be interposed by dynamic linker. Referring to these
symbols is expensive, since it needs to be overwritable by the dynamic
linker. In some cases we know that the interposition does not change
semantic and we can always refer to a local copy (as in the case of
@@ -310,7 +310,7 @@ varpool_node::externally_visible_p (void)
/* As a special case, the COMDAT virtual tables can be unshared.
In LTO mode turn vtables into static variables. The variable is readonly,
so this does not enable more optimization, but referring static var
- is faster for dynamic linking. Also this match logic hidding vtables
+ is faster for dynamic linking. Also this match logic hides vtables
from LTO symbol tables. */
if (((in_lto_p || flag_whole_program) && !flag_incremental_link)
&& DECL_COMDAT (decl)
@@ -333,7 +333,7 @@ varpool_node::externally_visible_p (void)
inline definitions.
FIXME: We can do so for readonly vars with no address taken and
- possibly also for vtables since no direct pointer comparsion is done.
+ possibly also for vtables since no direct pointer comparison is done.
It might be interesting to do so to reduce linking overhead. */
if (DECL_COMDAT (decl) || DECL_WEAK (decl))
return true;
diff --git a/gcc/ipa.cc b/gcc/ipa.cc
index d1a0bb8ce1d..908fb301cd0 100644
--- a/gcc/ipa.cc
+++ b/gcc/ipa.cc
@@ -84,7 +84,7 @@ update_inlined_to_pointer (struct cgraph_node *node, struct
cgraph_node *inlined
The queue is linked via AUX pointers and terminated by pointer to 1.
We enqueue nodes at two occasions: when we find them reachable or when we
find
- their bodies needed for further clonning. In the second case we mark them
+ their bodies needed for further cloning. In the second case we mark them
by pointer to 2 after processing so they are re-queue when they become
reachable. */
@@ -105,7 +105,7 @@ enqueue_node (symtab_node *node, symtab_node **first,
/* Return true if NODE may get inlined later.
This is used to keep DECL_EXTERNAL function bodies around long enough
- so inliner can proces them. */
+ so inliner can process them. */
static bool
possible_inline_candidate_p (symtab_node *node)
@@ -168,7 +168,7 @@ process_references (symtab_node *snode,
devirtualization happens. After inlining still keep their declarations
around, so we can devirtualize to a direct call.
- Also try to make trivial devirutalization when no or only one target is
+ Also try to make trivial devirtualization when no or only one target is
possible. */
static void
@@ -747,7 +747,7 @@ set_readonly_bit (varpool_node *vnode, void *data
ATTRIBUTE_UNUSED)
return false;
}
-/* Set writeonly bit and clear the initalizer, since it will not be needed. */
+/* Set writeonly bit and clear the initializer, since it will not be needed.
*/
bool
set_writeonly_bit (varpool_node *vnode, void *data)
@@ -784,7 +784,7 @@ clear_addressable_bit (varpool_node *vnode, void *data
ATTRIBUTE_UNUSED)
FIXME: This cannot be done in between gimplify and omp_expand since
readonly flag plays role on what is shared and what is not. Currently we do
this transformation as part of whole program visibility and re-do at
- ipa-reference pass (to take into account clonning), but it would
+ ipa-reference pass (to take into account cloning), but it would
make sense to do it before early optimizations. */
bool
@@ -1387,7 +1387,7 @@ make_pass_ipa_cdtor_merge (gcc::context *ctxt)
#define BOTTOM ((cgraph_node *)(size_t) 2)
/* Meet operation for single user dataflow.
- Here we want to associate variables with sigle function that may access it.
+ Here we want to associate variables with single function that may access it.
FUNCTION is current single user of a variable, VAR is variable that uses it.
Latttice is stored in SINGLE_USER_MAP.
@@ -1458,7 +1458,7 @@ propagate_single_user (varpool_node *vnode, cgraph_node
*function,
/* Pass setting used_by_single_function flag.
This flag is set on variable when there is only one function that may
- possibly referr to it. */
+ possibly refer to it. */
static unsigned int
ipa_single_use (void)
--
2.43.0
