https://gcc.gnu.org/g:d52d48ad351f9546da36d24b8a4313d408eb1f1b
commit r17-1016-gd52d48ad351f9546da36d24b8a4313d408eb1f1b Author: Dhruv Chawla <[email protected]> Date: Wed May 13 11:29:49 2026 +0000 ipa: Fix typos in various files 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. Diff: --- 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 b89eb596ef36..7a95fde23246 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 ce77acf8e0da..9e0b698b8cb0 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. */ @@ -4533,7 +4533,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) @@ -4718,7 +4718,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 @@ -4790,7 +4790,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 (); @@ -4950,7 +4950,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) @@ -6122,7 +6122,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 ff1811130785..a6ccdb1852af 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 de7b7f61cb1d..0503ec4c8d75 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 f32563fdd22d..3ff3f9638ff3 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 0a3508170d4d..a893a3faaa42 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, @@ -1007,7 +1007,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 40e9614c7364..44501ec760e3 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 c4df9d91425b..3f190ec2ad04 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 24d8974d5ca4..5a7615666cc1 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 e75458b8fb94..f7a875cd40c4 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 9372cc1d5948..7883a90bcdd0 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 024db825977a..e35f62235415 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 f31c6a6bd29a..307e351ba6e1 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 66b70e529669..b0a1edd96d85 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 8fd8fcc977ab..330c8a39e5bd 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 @@ -3348,7 +3348,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 () @@ -4023,7 +4023,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. @@ -4737,7 +4737,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 @@ -5134,7 +5134,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, @@ -5329,7 +5329,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) @@ -6117,7 +6117,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 173f5f466a2a..9099afaea304 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 c5699312c8f3..130cd4c1e666 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 b31235c99cf0..84a51fda1d7b 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 fd33e2028a0c..422bf367b97b 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 d0ebba0a2ff9..b0156fe46f66 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 f6ba07aef48b..ac052ad4b346 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 172ba401d3d8..d689d45c70c9 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 d0d6348d534c..4361d84adc97 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 d1a0bb8ce1d0..908fb301cd02 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)
