From: Dhruv Chawla <[email protected]>
Signed-off-by: Dhruv Chawla <[email protected]>
gcc/ChangeLog:
* tree-vect-data-refs.cc (vect_get_smallest_scalar_type): Fix typos.
(vect_preserves_scalar_order_p): Likewise.
(vect_slp_analyze_instance_dependence): Likewise.
(vect_enhance_data_refs_alignment): Likewise.
(vect_check_gather_scatter): Likewise.
(vect_grouped_store_supported): Likewise.
* tree-vect-generic.cc (type_for_widest_vector_mode): Likewise.
* tree-vect-loop-manip.cc
(vect_set_loop_condition_partial_vectors_avx512): Likewise.
(get_live_virtual_operand_on_edge): Likewise.
(vect_can_peel_nonlinear_iv_p): Likewise.
(vect_do_peeling): Likewise.
* tree-vect-loop.cc (vec_init_loop_exit_info): Likewise.
(vect_verify_full_masking_avx512): Likewise.
(vect_verify_loop_lens): Likewise.
(vect_analyze_loop_costing): Likewise.
(vect_analyze_loop_2): Likewise.
(vect_analyze_loop): Likewise.
(vect_is_simple_reduction): Likewise.
(vect_create_epilog_for_reduction): Likewise.
(vectorizable_lane_reducing): Likewise.
(vectorizable_reduction): Likewise.
(vectorizable_live_operation): Likewise.
(vect_record_loop_len): Likewise.
(scale_profile_for_vect_loop): Likewise.
(vect_update_ivs_after_vectorizer_for_early_breaks): Likewise.
* tree-vect-patterns.cc (vect_recog_widen_minus_pattern): Likewise.
(vect_recog_bit_insert_pattern): Likewise.
(vect_recog_build_binary_gimple_stmt): Likewise.
(vect_recog_sat_sub_pattern_transform): Likewise.
(vect_recog_sat_sub_pattern): Likewise.
(add_code_for_floorceilround_divmod): Likewise.
(vect_recog_bool_pattern): Likewise.
(struct vect_recog_func): Likewise.
* tree-vect-slp-patterns.cc (class complex_pattern): Likewise.
(compatible_complex_nodes_p): Likewise.
* tree-vect-slp.cc (vect_slp_tree_uniform_p): Likewise.
(vect_def_types_match): Likewise.
(vect_record_max_nunits): Likewise.
(vect_analyze_slp_instance): Likewise.
(vect_lower_load_permutations): Likewise.
(vect_optimize_slp_pass::is_compatible_layout): Likewise.
* tree-vect-stmts.cc (vect_get_strided_load_store_ops): Likewise.
(vectorizable_simd_clone_call): Likewise.
(vectorizable_store): Likewise.
(vectorizable_load): Likewise.
(vectorizable_condition): Likewise.
(vectorizable_early_exit): Likewise.
* tree-vectorizer.cc (vector_costs::compare_inside_loop_cost): Likewise.
* tree-vectorizer.h (enum vect_reduction_type): Likewise.
---
gcc/tree-vect-data-refs.cc | 12 ++++++------
gcc/tree-vect-generic.cc | 2 +-
gcc/tree-vect-loop-manip.cc | 14 +++++++-------
gcc/tree-vect-loop.cc | 32 ++++++++++++++++----------------
gcc/tree-vect-patterns.cc | 18 +++++++++---------
gcc/tree-vect-slp-patterns.cc | 8 ++++----
gcc/tree-vect-slp.cc | 12 ++++++------
gcc/tree-vect-stmts.cc | 14 +++++++-------
gcc/tree-vectorizer.cc | 2 +-
gcc/tree-vectorizer.h | 8 ++++----
10 files changed, 61 insertions(+), 61 deletions(-)
diff --git a/gcc/tree-vect-data-refs.cc b/gcc/tree-vect-data-refs.cc
index da65f1d652c..65d5ef9ae34 100644
--- a/gcc/tree-vect-data-refs.cc
+++ b/gcc/tree-vect-data-refs.cc
@@ -218,7 +218,7 @@ vect_get_smallest_scalar_type (stmt_vec_info stmt_info,
tree scalar_type)
i = ~0U;
else if (internal_store_fn_p (ifn))
{
- /* For stores use the tyep of the stored value. */
+ /* For stores use the type of the stored value. */
i = internal_fn_stored_value_index (ifn);
scalar_type = TREE_TYPE (gimple_call_arg (call, i));
i = ~0U;
@@ -300,7 +300,7 @@ vect_preserves_scalar_order_p (dr_vec_info *dr_info_a,
dr_vec_info *dr_info_b)
return true;
/* If there is a loop invariant read involved we might vectorize it in
- the prologue, breaking scalar oder with respect to the in-loop store. */
+ the prologue, breaking scalar order with respect to the in-loop store. */
if ((DR_IS_READ (dr_info_a->dr) && integer_zerop (DR_STEP (dr_info_a->dr)))
|| (DR_IS_READ (dr_info_b->dr) && integer_zerop (DR_STEP
(dr_info_b->dr))))
return false;
@@ -1261,7 +1261,7 @@ vect_slp_analyze_instance_dependence (vec_info *vinfo,
slp_instance instance)
/* For now concern ourselves with write-after-read as we also
only look for re-use of the store within the same SLP instance.
- We can still get a RAW here when the instance contais a PHI
+ We can still get a RAW here when the instance contains a PHI
with a backedge though, thus this test. */
if (! vect_stmt_dominates_stmt_p (STMT_VINFO_STMT (load_info),
STMT_VINFO_STMT (store_info)))
@@ -2614,7 +2614,7 @@ vect_enhance_data_refs_alignment (loop_vec_info
loop_vinfo)
|| !slpeel_can_duplicate_loop_p (loop, LOOP_VINFO_MAIN_EXIT (loop_vinfo),
loop_preheader_edge (loop))
|| loop->inner
- /* We don't currently maintaing the LCSSA for prologue peeled inversed
+ /* We don't currently maintain the LCSSA for prologue peeled inversed
loops. */
|| (LOOP_VINFO_EARLY_BREAKS_VECT_PEELED (loop_vinfo)
&& !LOOP_VINFO_NITERS_UNCOUNTED_P (loop_vinfo)))
@@ -4817,7 +4817,7 @@ vect_check_gather_scatter (stmt_vec_info stmt_info, tree
vectype,
/* In pattern recog we simply used a ZERO else value that
we need to correct here. To that end just re-use the
- (already succesful) check if we support a gather IFN
+ (already successful) check if we support a gather IFN
and have it populate the else values. */
if (DR_IS_READ (dr) && internal_fn_mask_index (ifn) >= 0 && elsvals)
supports_vec_gather_load_p (TYPE_MODE (vectype), elsvals);
@@ -6180,7 +6180,7 @@ vect_grouped_store_supported (tree vectype, unsigned
HOST_WIDE_INT count)
if (dump_enabled_p ())
dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
"the size of the group of accesses"
- " is not a power of 2 or not eqaul to 3\n");
+ " is not a power of 2 or not equal to 3\n");
return false;
}
diff --git a/gcc/tree-vect-generic.cc b/gcc/tree-vect-generic.cc
index 77066bbb2e1..fddb44bfe86 100644
--- a/gcc/tree-vect-generic.cc
+++ b/gcc/tree-vect-generic.cc
@@ -1509,7 +1509,7 @@ type_for_widest_vector_mode (tree original_vector_type,
optab op)
ARRAY_REF expression.
GSI is required to insert temporary variables while building a
- refernece to the element of the vector VECT.
+ reference to the element of the vector VECT.
PTMPVEC is a pointer to the temporary variable for caching
purposes. In case when PTMPVEC is NULL new temporary variable
diff --git a/gcc/tree-vect-loop-manip.cc b/gcc/tree-vect-loop-manip.cc
index cd1ea746ae4..88bf8ab18be 100644
--- a/gcc/tree-vect-loop-manip.cc
+++ b/gcc/tree-vect-loop-manip.cc
@@ -1010,7 +1010,7 @@ vect_set_loop_condition_partial_vectors_avx512 (class
loop *loop,
continue;
Where the constant is built with elements at most VF - 1 and
- repetitions according to max_nscalars_per_iter which is guarnateed
+ repetitions according to max_nscalars_per_iter which is guaranteed
to be the same within a group. */
/* Convert NITERS to the determined IV type. */
@@ -1473,7 +1473,7 @@ get_live_virtual_operand_on_edge (edge e)
where the contents of the loop body are split but the iteration space of
both
copies remains the same.
- If UPDATED_DOMS is not NULL it is update with the list of basic blocks whoms
+ If UPDATED_DOMS is not NULL it is update with the list of basic blocks whose
dominators were updated during the peeling. When doing early break
vectorization
then LOOP_VINFO needs to be provided and is used to keep track of any newly
created
memory references that need to be updated should we decide to vectorize. */
@@ -2201,7 +2201,7 @@ vect_can_peel_nonlinear_iv_p (loop_vec_info loop_vinfo,
= STMT_VINFO_LOOP_PHI_EVOLUTION_TYPE (stmt_info);
tree niters_skip;
/* Init_expr will be update by vect_update_ivs_after_vectorizer,
- if niters or vf is unkown:
+ if niters or vf is unknown:
For shift, when shift mount >= precision, there would be UD.
For mult, don't known how to generate
init_expr * pow (step, niters) for variable niters.
@@ -2251,7 +2251,7 @@ vect_can_peel_nonlinear_iv_p (loop_vec_info loop_vinfo,
}
}
- /* Also doens't support peel for neg when niter is variable.
+ /* Also doesn't support peel for neg when niter is variable.
??? generate something like niter_expr & 1 ? init_expr : -init_expr? */
niters_skip = LOOP_VINFO_MASK_SKIP_NITERS (loop_vinfo);
if ((niters_skip != NULL_TREE
@@ -2262,7 +2262,7 @@ vect_can_peel_nonlinear_iv_p (loop_vec_info loop_vinfo,
{
if (dump_enabled_p ())
dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
- "Peeling for alignement is not supported"
+ "Peeling for alignment is not supported"
" for nonlinear induction when niters_skip"
" is not constant.\n");
return false;
@@ -3327,7 +3327,7 @@ vect_do_peeling (loop_vec_info loop_vinfo, tree niters,
tree nitersm1,
introduces clobbers of the temporary vector array, which in turn
needs new vdefs. If the scalar loop doesn't write to memory, these
new vdefs will be the only ones in the vector loop.
- We are currently defering updating virtual SSA form and creating
+ We are currently deferring updating virtual SSA form and creating
of a virtual PHI for this case so we do not have to make sure the
newly introduced virtual def is in LCSSA form. */
@@ -3675,7 +3675,7 @@ vect_do_peeling (loop_vec_info loop_vinfo, tree niters,
tree nitersm1,
niters_no_overflow);
if (!integer_onep (*step_vector))
{
- /* On exit from the loop we will have an easy way of calcalating
+ /* On exit from the loop we will have an easy way of calculating
NITERS_VECTOR / STEP * STEP. Install a dummy definition
until then. */
niters_vector_mult_vf
diff --git a/gcc/tree-vect-loop.cc b/gcc/tree-vect-loop.cc
index ac7e08cf205..116a28635c6 100644
--- a/gcc/tree-vect-loop.cc
+++ b/gcc/tree-vect-loop.cc
@@ -656,7 +656,7 @@ edge
vec_init_loop_exit_info (class loop *loop)
{
/* Before we begin we must first determine which exit is the main one and
- which are auxilary exits. */
+ which are auxiliary exits. */
auto_vec<edge> exits = get_loop_exit_edges (loop);
if (exits.length () == 0)
return NULL;
@@ -1244,7 +1244,7 @@ vect_verify_full_masking_avx512 (loop_vec_info loop_vinfo)
return true;
}
-/* Check whether we can use vector access with length based on precison
+/* Check whether we can use vector access with length based on precision
comparison. So far, to keep it simple, we only allow the case that the
precision of the target supported length is larger than the precision
required by loop niters. */
@@ -1307,7 +1307,7 @@ vect_verify_loop_lens (loop_vec_info loop_vinfo)
- the Pmode precision
If min_ni_prec is less than the precision of the current niters,
- we perfer to still use the niters type. Prefer to use Pmode and
+ we prefer to still use the niters type. Prefer to use Pmode and
wider IV to avoid narrow conversions. */
unsigned int ni_prec
@@ -1767,7 +1767,7 @@ vect_analyze_loop_costing (loop_vec_info loop_vinfo,
/* If we know the number of iterations we can do better, for the
epilogue we can also decide whether the main loop leaves us
- with enough iterations, prefering a smaller vector epilog then
+ with enough iterations, preferring a smaller vector epilog then
also possibly used for the case we skip the vector loop. */
if (LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo))
{
@@ -2159,7 +2159,7 @@ vect_analyze_loop_2 (loop_vec_info loop_vinfo, int
masked_p, bool &fatal,
orig_loop_vinfo = loop_vinfo;
gcc_assert (orig_loop_vinfo);
- /* We can't mask on niters for uncounted loops due to unkown upper bound. */
+ /* We can't mask on niters for uncounted loops due to unknown upper bound.
*/
if (LOOP_VINFO_NITERS_UNCOUNTED_P (loop_vinfo))
LOOP_VINFO_CAN_USE_PARTIAL_VECTORS_P (loop_vinfo) = false;
@@ -2302,7 +2302,7 @@ start_over:
gcc_assert (LOOP_VINFO_MASKS (loop_vinfo).is_empty ());
/* Apply the suggested unrolling factor, this was determined by the backend
- during finish_cost the first time we ran the analyzis for this
+ during finish_cost the first time we ran the analysis for this
vector mode. */
if (applying_suggested_uf)
LOOP_VINFO_VECT_FACTOR (loop_vinfo) *= loop_vinfo->suggested_unroll_factor;
@@ -2998,7 +2998,7 @@ vect_analyze_loop (class loop *loop, gimple
*loop_vectorized_call,
if (loop_vinfo)
{
- /* Analyzis has been successful so update the VF value. The
+ /* Analysis has been successful so update the VF value. The
VF should always be a multiple of unroll_factor and we want to
capture the original VF here. */
cached_vf_per_mode[last_mode_i]
@@ -3175,7 +3175,7 @@ vect_analyze_loop (class loop *loop, gimple
*loop_vectorized_call,
break;
}
- /* Revert back to the default from the suggested prefered
+ /* Revert back to the default from the suggested preferred
epilogue vectorization mode. */
masked_p = -1;
if (mode_i == vector_modes.length ())
@@ -3801,7 +3801,7 @@ vect_is_simple_reduction (loop_vec_info loop_info,
stmt_vec_info phi_info,
}
/* If this isn't a nested cycle or if the nested cycle reduction value
- is used ouside of the inner loop we cannot handle uses of the reduction
+ is used outside of the inner loop we cannot handle uses of the reduction
value. */
if (nlatch_def_loop_uses > 1 || nphi_def_loop_uses > 1)
{
@@ -5905,7 +5905,7 @@ vect_create_epilog_for_reduction (loop_vec_info
loop_vinfo,
neutral_op);
for (unsigned int i = 0; i < group_size; ++i)
{
- /* If there's no univeral neutral value, we can use the
+ /* If there's no universal neutral value, we can use the
initial scalar value from the original PHI. This is used
for MIN and MAX reduction, for example. */
if (!neutral_op)
@@ -6806,7 +6806,7 @@ vectorizable_lane_reducing (loop_vec_info loop_vinfo,
stmt_vec_info stmt_info,
return false;
/* Lane-reducing pattern inside any inner loop of LOOP_VINFO is not
- recoginized. */
+ recognized. */
gcc_assert (!nested_in_vect_loop_p (LOOP_VINFO_LOOP (loop_vinfo),
stmt_info));
gcc_assert (VECT_REDUC_INFO_TYPE (reduc_info) == TREE_CODE_REDUCTION);
@@ -7438,7 +7438,7 @@ vectorizable_reduction (loop_vec_info loop_vinfo,
else if (needs_fold_left_reduction_p (op.type, orig_code))
{
/* When vectorizing a reduction chain w/o SLP the reduction PHI
- is not directy used in stmt. */
+ is not directly used in stmt. */
if (reduc_chain_length != 1)
{
if (dump_enabled_p ())
@@ -10433,7 +10433,7 @@ vectorizable_live_operation (vec_info *vinfo,
stmt_vec_info stmt_info,
if (dump_enabled_p ())
dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
"Using original scalar computation for "
- "live lane because use preceeds vector "
+ "live lane because use precedes vector "
"def\n");
continue;
}
@@ -10705,7 +10705,7 @@ vect_record_loop_len (loop_vec_info loop_vinfo,
vec_loop_lens *lens,
/* Given a complete set of lengths LENS, extract length number INDEX
for an rgroup that operates on NVECTORS vectors of type VECTYPE,
where 0 <= INDEX < NVECTORS. Return a value that contains FACTOR
- multipled by the number of elements that should be processed.
+ multiplied by the number of elements that should be processed.
Insert any set-up statements before GSI. */
tree
@@ -10860,7 +10860,7 @@ scale_profile_for_vect_loop (class loop *loop, edge
exit_e, unsigned vf, bool fl
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file,
"Vectorization factor %i seems too large for profile "
- "prevoiusly believed to be consistent; reducing.\n", vf);
+ "previously believed to be consistent; reducing.\n", vf);
vf /= 2;
}
@@ -11144,7 +11144,7 @@ vect_update_ivs_after_vectorizer_for_early_breaks
(loop_vec_info loop_vinfo)
/* Write the init_stmts in the loop-preheader block. */
auto psi = gsi_last_nondebug_bb (pe->src);
gsi_insert_seq_after (&psi, init_stmts, GSI_LAST_NEW_STMT);
- /* Wite the adjustments in the header block. */
+ /* Write the adjustments in the header block. */
basic_block bb = loop->header;
auto si = gsi_after_labels (bb);
gsi_insert_seq_before (&si, stmts, GSI_SAME_STMT);
diff --git a/gcc/tree-vect-patterns.cc b/gcc/tree-vect-patterns.cc
index 259626a1e7b..b059ae3be65 100644
--- a/gcc/tree-vect-patterns.cc
+++ b/gcc/tree-vect-patterns.cc
@@ -1730,7 +1730,7 @@ vect_recog_widen_minus_pattern (vec_info *vinfo,
stmt_vec_info last_stmt_info,
false, "vect_recog_widen_minus_pattern");
}
-/* Try to detect abd on widened inputs, converting IFN_ABD
+/* Try to detect and on widened inputs, converting IFN_ABD
to IFN_VEC_WIDEN_ABD. */
static gimple *
vect_recog_widen_abd_pattern (vec_info *vinfo, stmt_vec_info stmt_vinfo,
@@ -3002,7 +3002,7 @@ vect_recog_bit_insert_pattern (vec_info *vinfo,
stmt_vec_info stmt_info,
needed to maintain the type correctness of the IR.
vect_determine_precisions has already determined the minimum
- precison of the operation and the minimum precision required
+ precision of the operation and the minimum precision required
by users of the result. */
static gimple *
@@ -4625,7 +4625,7 @@ vect_recog_build_binary_gimple_stmt (vec_info *vinfo,
stmt_vec_info stmt_info,
* _10 = -_9;
* _12 = _7 | _10;
*
- * And then simplied to
+ * And then simplified to
* _12 = .SAT_ADD (_4, _6);
*/
@@ -4732,7 +4732,7 @@ vect_recog_sat_sub_pattern_transform (vec_info *vinfo,
* _10 = (long unsigned int) _7;
* _9 = _8 * _10;
*
- * And then simplied to
+ * And then simplified to
* _9 = .SAT_SUB (_1, _2);
*
* Signed:
@@ -4753,7 +4753,7 @@ vect_recog_sat_sub_pattern_transform (vec_info *vinfo,
* _41 = _42 & _44;
* iftmp.2_11 = _41 ? _26 : minus_19;
*
- * And then simplied to
+ * And then simplified to
* iftmp.2_11 = .SAT_SUB (x_16, y_18);
*/
@@ -4794,7 +4794,7 @@ vect_recog_sat_sub_pattern (vec_info *vinfo,
stmt_vec_info stmt_vinfo,
* _3 = -_2;
* _6 = _1 | _3;
*
- * And then simplied to
+ * And then simplified to
* _6 = .SAT_TRUNC (x_4(D));
*/
@@ -5064,7 +5064,7 @@ add_code_for_floorceilround_divmod (tree vectype,
vec_info *vinfo,
unsigned HOST_WIDE_INT mid_d = (abs_d - 1) >> 1;
if (!unsigned_p)
{
- // check availibility of abs expression for vector
+ // check availability of abs expression for vector
if (!target_has_vecop_for_code (ABS_EXPR, vectype))
return NULL;
// abs (r)
@@ -6247,7 +6247,7 @@ vect_recog_bool_pattern (vec_info *vinfo,
/* Function vect_recog_mask_conversion_pattern
Try to find statements which require boolean type
- converison. Additional conversion statements are
+ conversion. Additional conversion statements are
added to handle such cases. For example:
bool m_1, m_2, m_3;
@@ -7436,7 +7436,7 @@ struct vect_recog_func
};
/* Note that ordering matters - the first pattern matching on a stmt is
- taken which means usually the more complex one needs to preceed the
+ taken which means usually the more complex one needs to precede the
less comples onex (widen_sum only after dot_prod or sad for example). */
static vect_recog_func vect_vect_recog_func_ptrs[] = {
{ vect_recog_bitfield_ref_pattern, "bitfield_ref" },
diff --git a/gcc/tree-vect-slp-patterns.cc b/gcc/tree-vect-slp-patterns.cc
index 5e765e23847..c0031a129a4 100644
--- a/gcc/tree-vect-slp-patterns.cc
+++ b/gcc/tree-vect-slp-patterns.cc
@@ -69,7 +69,7 @@ along with GCC; see the file COPYING3. If not see
******************************************************************************/
/* Default implementation of recognize that performs matching, validation and
- replacement of nodes but that can be overriden if required. */
+ replacement of nodes but that can be overridden if required. */
static bool
vect_pattern_validate_optab (internal_fn ifn, slp_tree node)
@@ -517,7 +517,7 @@ class complex_pattern : public vect_pattern
statement is created as call to internal function IFN with m_num_args
arguments.
- Futhermore the new pattern is also added to the vectorization information
+ Furthermore the new pattern is also added to the vectorization information
structure VINFO and the old statement STMT_INFO is marked as unused while
the new statement is marked as used and the number of SLP uses of the new
statement is incremented.
@@ -850,11 +850,11 @@ compatible_complex_nodes_p (slp_compat_nodes_map_t
*compat_cache,
}
-/* Check to see if the oprands to two multiplies, 2 each in LEFT_OP and
+/* Check to see if the operands to two multiplies, 2 each in LEFT_OP and
RIGHT_OP match a complex multiplication or complex multiply-and-accumulate
or complex multiply-and-subtract pattern. Do this using the permute cache
PERM_CACHE and the combination compatibility list COMPAT_CACHE. If
- the operation is successful the macthing operands are returned in OPS and
+ the operation is successful the matching operands are returned in OPS and
_STATUS indicates if the operation matched includes a conjugate of one of
the
operands. If the operation succeeds True is returned, otherwise False and
the values in ops are meaningless. */
diff --git a/gcc/tree-vect-slp.cc b/gcc/tree-vect-slp.cc
index ea49c32b780..4ab0dab4cef 100644
--- a/gcc/tree-vect-slp.cc
+++ b/gcc/tree-vect-slp.cc
@@ -374,7 +374,7 @@ vect_slp_tree_uniform_p (slp_tree node)
gcc_assert (SLP_TREE_DEF_TYPE (node) == vect_constant_def
|| SLP_TREE_DEF_TYPE (node) == vect_external_def);
- /* Pre-exsting vectors. */
+ /* Pre-existing vectors. */
if (SLP_TREE_SCALAR_OPS (node).is_empty ())
return false;
@@ -518,7 +518,7 @@ vect_def_types_match (enum vect_def_type dta, enum
vect_def_type dtb)
- for each child node, the index of the argument associated with that node.
The special index -1 is the first operand of an embedded comparison and
the special index -2 is the second operand of an embedded comparison.
- The special indes -3 is the offset of a gather as analyzed by
+ The special index -3 is the offset of a gather as analyzed by
vect_check_gather_scatter.
SWAP is as for vect_get_and_check_slp_defs. */
@@ -1142,7 +1142,7 @@ vect_record_max_nunits (vec_info *vinfo, stmt_vec_info
stmt_info,
operands. Set SWAP[i] to 1 if stmt I is COND_EXPR and isomorphic to
the first stmt by swapping the two operands of comparison; set SWAP[i]
to 2 if stmt I is isormorphic to the first stmt by inverting the code
- of comparison. Take A1 >= B1 ? X1 : Y1 as an exmple, it can be swapped
+ of comparison. Take A1 >= B1 ? X1 : Y1 as an example, it can be swapped
to (B1 <= A1 ? X1 : Y1); or be inverted to (A1 < B1) ? Y1 : X1. */
static bool
@@ -5261,7 +5261,7 @@ vect_analyze_slp_instance (vec_info *vinfo,
substmts.release ();
if (end - start == 1)
{
- /* Single-lane discovery failed. Free ressources. */
+ /* Single-lane discovery failed. Free resources. */
for (auto node : rhs_nodes)
vect_free_slp_tree (node);
scalar_stmts.release ();
@@ -5637,7 +5637,7 @@ vect_lower_load_permutations (loop_vec_info loop_vinfo,
interleaving scheme. For this try to compute whether all
elements needed for this load are in even or odd elements of
an even/odd decomposition with N consecutive elements.
- Thus { e, e, o, o, e, e, o, o } woud be an even/odd decomposition
+ Thus { e, e, o, o, e, e, o, o } would be an even/odd decomposition
with N == 2. */
/* ??? Only an even number of lanes can be handed this way, but the
fallback below could work for any number. We have to make sure
@@ -6968,7 +6968,7 @@ vect_optimize_slp_pass::is_compatible_layout (const
slpg_partition_info
return true;
}
-/* Return the cost (in arbtirary units) of going from layout FROM_LAYOUT_I
+/* Return the cost (in arbitrary units) of going from layout FROM_LAYOUT_I
to layout TO_LAYOUT_I for a node like NODE. Return -1 if either of the
layouts is incompatible with NODE or if the change is not possible for
some other reason.
diff --git a/gcc/tree-vect-stmts.cc b/gcc/tree-vect-stmts.cc
index da87b329715..a6cf6635929 100644
--- a/gcc/tree-vect-stmts.cc
+++ b/gcc/tree-vect-stmts.cc
@@ -3235,7 +3235,7 @@ vect_get_strided_load_store_ops (stmt_vec_info stmt_info,
slp_tree node,
/* Prepare the pointer IVs which needs to be updated by a variable amount.
Such variable amount is the outcome of .SELECT_VL. In this case, we can
allow each iteration process the flexible number of elements as long as
- the number <= vf elments.
+ the number <= vf elements.
Return data reference according to SELECT_VL.
If new statements are needed, insert them before GSI. */
@@ -4270,7 +4270,7 @@ vectorizable_simd_clone_call (vec_info *vinfo,
stmt_vec_info stmt_info,
unsigned int num_calls;
/* The number of arguments in the call and the number of parameters in
the simdclone should match. However, when the simdclone is
- 'inbranch', it could have one more paramater than nargs when using
+ 'inbranch', it could have one more parameter than nargs when using
an inbranch simdclone to call a non-inbranch call, either in a
non-masked loop using a all true constant mask, or inside a masked
loop using it's mask. */
@@ -8685,7 +8685,7 @@ vectorizable_store (vec_info *vinfo,
during transform but it is allowed during analysis.
Shouldn't go with length-based approach if fully masked. */
if (cost_vec == NULL)
- /* The cost_vec is NULL during transfrom. */
+ /* The cost_vec is NULL during transform. */
gcc_assert ((!loop_lens || !loop_masks));
/* Targets with store-lane instructions must not require explicit
@@ -10576,7 +10576,7 @@ vectorizable_load (vec_info *vinfo,
during transform but it is allowed during analysis.
Shouldn't go with length-based approach if fully masked. */
if (cost_vec == NULL)
- /* The cost_vec is NULL during transfrom. */
+ /* The cost_vec is NULL during transform. */
gcc_assert ((!loop_lens || !loop_masks));
/* Targets with store-lane instructions must not require explicit
@@ -12493,7 +12493,7 @@ vectorizable_condition (vec_info *vinfo,
/* If we decided to apply a loop mask to the result of the vector
comparison, AND the comparison with the mask now. Later passes
- should then be able to reuse the AND results between mulitple
+ should then be able to reuse the AND results between multiple
vector statements.
For example:
@@ -13080,7 +13080,7 @@ vectorizable_early_exit (loop_vec_info loop_vinfo,
stmt_vec_info stmt_info,
return true;
}
- /* Tranform. */
+ /* Transform. */
tree new_temp = NULL_TREE;
gimple *new_stmt = NULL;
@@ -13102,7 +13102,7 @@ vectorizable_early_exit (loop_vec_info loop_vinfo,
stmt_vec_info stmt_info,
auto_vec<tree> stmts;
stmts.safe_splice (SLP_TREE_VEC_DEFS (slp_node));
- /* If we're comparing against a previous forall we need to negate the
resullts
+ /* If we're comparing against a previous forall we need to negate the results
before we do the final comparison or reduction. */
if (flipped)
{
diff --git a/gcc/tree-vectorizer.cc b/gcc/tree-vectorizer.cc
index 205a07b0be5..ab455c08349 100644
--- a/gcc/tree-vectorizer.cc
+++ b/gcc/tree-vectorizer.cc
@@ -2046,7 +2046,7 @@ vector_costs::compare_inside_loop_cost (const
vector_costs *other) const
HOST_WIDE_INT est_rel_other_max
= estimated_poly_value (rel_other, POLY_VALUE_MAX);
- /* Check first if we can make out an unambigous total order from the minimum
+ /* Check first if we can make out an unambiguous total order from the minimum
and maximum estimates. */
if (est_rel_this_min < est_rel_other_min
&& est_rel_this_max < est_rel_other_max)
diff --git a/gcc/tree-vectorizer.h b/gcc/tree-vectorizer.h
index 3a01e1be0f1..cd74f942d4b 100644
--- a/gcc/tree-vectorizer.h
+++ b/gcc/tree-vectorizer.h
@@ -107,7 +107,7 @@ enum vect_reduction_type {
for (int i = 0; i < VF; ++i)
res = res OP val[i];
- (with no reassocation). */
+ (with no reassociation). */
FOLD_LEFT_REDUCTION
};
@@ -1218,7 +1218,7 @@ public:
_loop_vec_info *main_loop_info;
/* For loops being epilogues of already vectorized loops
- this points to the preceeding vectorized (possibly epilogue) loop.
+ this points to the preceding vectorized (possibly epilogue) loop.
Otherwise NULL. */
_loop_vec_info *orig_loop_info;
@@ -1256,7 +1256,7 @@ public:
auto_vec<gimple*> early_break_vuses;
/* The IV adjustment value for inductions that needs to be materialized
- inside the relavent exit blocks in order to adjust for early break. */
+ inside the relevant exit blocks in order to adjust for early break. */
tree early_break_niters_var;
/* The type of the variable to be used to create the scalar IV for early
break
@@ -2894,7 +2894,7 @@ extern size_t num__slp_patterns;
The following routines are provided to simplify costing decisions in
target code. Please add more as needed. */
-/* Return true if an operaton of kind KIND for STMT_INFO represents
+/* Return true if an operation of kind KIND for STMT_INFO represents
the extraction of an element from a vector in preparation for
storing the element to memory. */
inline bool
--
2.43.0
