ltyp = function_args_iter_cond (&liter);
rtyp = function_args_iter_cond (&riter);
- /* If we've exhaused both lists simulateously, we're done. */
+ /* If we've exhausted both lists simulateously, we're done. */
if (ltyp == NULL_TREE && rtyp == NULL_TREE)
break;
{
/* We need to fixup all the argument indexes by adding 2
for the two hidden arguments of an Objective-C method
- invocation, similat to what we do above for the
+ invocation, similar to what we do above for the
"format" attribute. */
/* FIXME: This works great in terms of implementing the
functionality, but the warnings that are produced by
next_object:
if (__objc_foreach_mutation_pointer != *__objc_foreach_enum_state.mutationsPtr) objc_enumeration_mutation (<collection expression>);
<object expression> = enumState.itemsPtr[__objc_foreach_index];
- <statements> [PS: inside <statments>, 'break' jumps to break_label and 'continue' jumps to continue_label]
+ <statements> [PS: inside <statements>, 'break' jumps to break_label and 'continue' jumps to continue_label]
continue_label:
__objc_foreach_index++;
SET_EXPR_LOCATION (t, location);
append_to_statement_list (t, &BIND_EXPR_BODY (next_batch_bind));
- /* <statements> [PS: in <statments>, 'break' jumps to break_label and 'continue' jumps to continue_label] */
+ /* <statements> [PS: in <statements>, 'break' jumps to break_label and 'continue' jumps to continue_label] */
append_to_statement_list (for_body, &BIND_EXPR_BODY (next_batch_bind));
/* continue_label: */
(INSTANCE_METHOD_OR_CLASS_METHOD_DECL_CHECK (DECL)->decl_common.size_unit)
-/* PROPERTY_DECL. A PROPERTY_DECL repesents a @property declaration
+/* PROPERTY_DECL. A PROPERTY_DECL represents a @property declaration
(when attached to the list of properties of an interface) or a
@synthesize or @dynamic declaration (when attached to the list of
properties of an implementation). */
/* Check for or otherwise handle a request to check that the constant
string class reference is set-up & OK. */
bool (*setup_const_string_class_decl) (void);
- /* Return the tree reprenting a const string constructor for the arg.
+ /* Return the tree representing a const string constructor for the arg.
Most of the data are in global trees. */
tree (*build_const_string_constructor) (location_t, tree, int);
store number of iterations of the loops from fd->first_nonrect
to fd->last_nonrect inclusive, i.e. the above COUNT multiplied
by the counts of rectangular loops not referenced in any non-rectangular
- loops sandwitched in between those. */
+ loops sandwiched in between those. */
/* NOTE: It *could* be better to moosh all of the BBs together,
creating one larger BB with all the computation and the unexpected
}
/* Fallback implementation. Evaluate the loops in between
(inclusive) fd->first_nonrect and fd->last_nonrect at
- runtime unsing temporaries instead of the original iteration
+ runtime using temporaries instead of the original iteration
variables, in the body just bump the counter and compare
with the desired value. */
gimple_stmt_iterator gsi2 = *gsi;
FALLTHRU_EDGE (region->cont)->flags &= ~EDGE_ABNORMAL;
}
else
- /* If there isn't a continue then this is a degerate case where
+ /* If there isn't a continue then this is a degenerate case where
the introduction of abnormal edges during lowering will prevent
original loops from being detected. Fix that up. */
loops_state_set (LOOPS_NEED_FIXUP);
/* We could test all of the various optabs involved, but the fact of the
matter is that (with the exception of i486 vs i586 and xadd) all targets
- that support any atomic operaton optab also implements compare-and-swap.
+ that support any atomic operation optab also implements compare-and-swap.
Let optabs.cc take care of expanding any compare-and-swap loop. */
if (!can_compare_and_swap_p (imode, true) || !can_atomic_load_p (imode))
return false;
region = NULL;
else if (code == GIMPLE_OMP_TASKGROUP)
/* #pragma omp taskgroup isn't a stand-alone directive, but
- gimplifier put the end API call into try finall block
+ gimplifier put the end API call into try finally block
for it, so omp expansion can treat it as such. */
region = NULL;
/* ..., this directive becomes the parent for a new region. */
/* Check whether this DECL belongs to a Fortran optional argument.
With 'for_present_check' set to false, decls which are optional parameters
- themselve are returned as tree - or a NULL_TREE otherwise. Those decls are
+ themselves are returned as tree - or a NULL_TREE otherwise. Those decls are
always pointers. With 'for_present_check' set to true, the decl for checking
whether an argument is present is returned; for arguments with value
attribute this is the hidden argument and of BOOLEAN_TYPE. If the decl is
{
/* For reduction in SIMD loop, defer adding the
initialization of the reference, because if we decide
- to use SIMD array for it, the initilization could cause
+ to use SIMD array for it, the initialization could cause
expansion ICE. Ditto for other privatization clauses. */
if (is_simd)
x = NULL_TREE;
gimple_stmt_iterator gsi;
for (gsi = gsi_start (*body); !gsi_end_p (gsi); gsi_next (&gsi))
lower_omp_1 (&gsi, ctx);
- /* During gimplification, we haven't folded statments inside offloading
+ /* During gimplification, we haven't folded statements inside offloading
or taskreg regions (gimplify.cc:maybe_fold_stmt); do that now. */
if (target_nesting_level || taskreg_nesting_level)
for (gsi = gsi_start (*body); !gsi_end_p (gsi); gsi_next (&gsi))
e_mask = 0;
#endif
if (!e_mask)
- /* Not paritioning. */
+ /* Not partitioning. */
span = integer_one_node;
else if (!integer_zerop (tile_size))
/* User explicitly specified size. */
span = tile_size;
else
{
- /* Pick a size based on the paritioning of the element loop and
+ /* Pick a size based on the partitioning of the element loop and
the number of loop nests. */
tree first_size = NULL_TREE;
tree second_size = NULL_TREE;
same wording and logic applies to num_workers and
vector_length, however the worker- or vector- single
execution doesn't have the same impact as gang-redundant
- execution. (If the minimum gang-level partioning is not 1,
+ execution. (If the minimum gang-level partitioning is not 1,
the target is probably too confusing.) */
dims[ix] = (used & GOMP_DIM_MASK (ix)
? oacc_default_dims[ix] : oacc_min_dims[ix]);
"gang reduction on an orphan loop");
}
-/* Walk the OpenACC loop heirarchy checking and assigning the
+/* Walk the OpenACC loop hierarchy checking and assigning the
programmer-specified partitionings. OUTER_MASK is the partitioning
this loop is contained within. Return mask of partitioning
encountered. If any auto loops are discovered, set GOMP_DIM_MAX
return mask_all;
}
-/* Walk the OpenACC loop heirarchy to assign auto-partitioned loops.
+/* Walk the OpenACC loop hierarchy to assign auto-partitioned loops.
OUTER_MASK is the partitioning this loop is contained within.
OUTER_ASSIGN is true if an outer loop is being auto-partitioned.
Return the cumulative partitioning used by this loop, siblings and
return inner_mask;
}
-/* Walk the OpenACC loop heirarchy to check and assign partitioning
+/* Walk the OpenACC loop hierarchy to check and assign partitioning
axes. Return mask of partitioning. */
static unsigned
2. The address of the variable in the new address space can be taken,
converted to the default (original) address space, and the result of
- that conversion subsituted in place of the original ADDR_EXPR node.
+ that conversion substituted in place of the original ADDR_EXPR node.
Which of these is done depends on the gimple statement being processed.
At present atomic operations and inline asms use (1), and everything else
}
/* Given a SIMD clone in NODE, calculate the characteristic data
- type and return the coresponding type. The characteristic data
+ type and return the corresponding type. The characteristic data
type is computed as described in the Intel Vector ABI. */
static tree
offset into the corresponding simd_array.
This function will replace all function argument uses with their
- corresponding simd array elements, and ajust the return values
+ corresponding simd array elements, and adjust the return values
accordingly. */
static void
static bool init[2] = { false, false };
static bool cheap[2] = { true, true };
- /* If the targer has no lshift in word_mode, the operation will most
+ /* If the target has no lshift in word_mode, the operation will most
probably not be cheap. ??? Does GCC even work for such targets? */
if (optab_handler (ashl_optab, word_mode) == CODE_FOR_nothing)
return false;
}
/* Return insn code for a comparison operator with VMODE
- resultin MASK_MODE, unsigned if UNS is true. */
+ result in MASK_MODE, unsigned if UNS is true. */
inline enum insn_code
get_vec_cmp_icode (machine_mode vmode, machine_mode mask_mode, bool uns)
}
/* Return insn code for a comparison operator with VMODE
- resultin MASK_MODE (only for EQ/NE). */
+ result in MASK_MODE (only for EQ/NE). */
inline enum insn_code
get_vec_cmp_eq_icode (machine_mode vmode, machine_mode mask_mode)
}
}
- /* Attempt to synthetize double word modulo by constant divisor. */
+ /* Attempt to synthesize double word modulo by constant divisor. */
if ((binoptab == umod_optab
|| binoptab == smod_optab
|| binoptab == udiv_optab
gcc_assert (sel != NULL);
/* Add the byte offset to each byte element. */
- /* Note that the definition of the indicies here is memory ordering,
+ /* Note that the definition of the indices here is memory ordering,
so there should be no difference between big and little endian. */
rtx_vector_builder byte_indices (qimode, u, 1);
for (i = 0; i < u; ++i)
}
-/* This function tries to emit an atomic_exchange intruction. VAL is written
+/* This function tries to emit an atomic_exchange instruction. VAL is written
to *MEM using memory model MODEL. The previous contents of *MEM are returned,
using TARGET if possible. */
then we assume that a load will not be atomic. We could try to
emulate a load with a compare-and-swap operation, but the store that
doing this could result in would be incorrect if this is a volatile
- atomic load or targetting read-only-mapped memory. */
+ atomic load or targeting read-only-mapped memory. */
if (maybe_gt (GET_MODE_PRECISION (mode), BITS_PER_WORD))
/* If there is no atomic load, leave the library call. */
return NULL_RTX;
return NULL_RTX;
}
-/* Try to emit an instruction for a specific operation varaition.
+/* Try to emit an instruction for a specific operation variation.
OPTAB contains the OP functions.
TARGET is an optional place to return the result. const0_rtx means unused.
MEM is the memory location to operate on.
{
case EXPAND_OUTPUT:
case EXPAND_UNDEFINED_INPUT:
- /* Outputs and undefined intputs must remain distinct. */
+ /* Outputs and undefined inputs must remain distinct. */
return false;
case EXPAND_FIXED:
/* ??? Ideally, we should do this earlier and the FEs will override
it if desired (none do it so far). However, the way the FEs
construct their pretty-printers means that all previous settings
- are overriden. */
+ are overridden. */
global_dc->set_show_highlight_colors (show_highlight_colors);
diagnostic_color_init (global_dc);
/* Option length, not including initial '-'. */
unsigned char opt_len;
/* Next option in a sequence marked with Negative, or -1 if none.
- For a single option with both a negative and a positve form
+ For a single option with both a negative and a positive form
(such as -Wall and -Wno-all), NEG_IDX is equal to the option's
own index (i.e., cl_options[IDX].neg_idx == IDX holds). */
int neg_index;
// are deleting both original insns and inserting a new insn for the stp.
insn_info *m_repurpose;
- // Destionation of the stp, it will be placed immediately after m_dest.
+ // Destination of the stp, it will be placed immediately after m_dest.
insn_info *m_dest;
// Current nondebug use that needs updating due to stp insertion.
{
if (dump_file)
fprintf (dump_file,
- "punting on load pair due to reg conflcits (%d,%d)\n",
+ "punting on load pair due to reg conflicts (%d,%d)\n",
insns[0]->uid (), insns[1]->uid ());
return false;
}
// Pass to fuse adjacent loads/stores into paired memory accesses.
//
// This file contains the definition of the virtual base class which is
-// overriden by targets that make use of the pass.
+// overridden by targets that make use of the pass.
//
// Copyright (C) 2023-2026 Free Software Foundation, Inc.
//
ALL
};
-// This class can be overriden by targets to give a pass that fuses
+// This class can be overridden by targets to give a pass that fuses
// adjacent loads and stores into load/store pair instructions.
//
// The target can override the various virtual functions to customize
need to implement cloning, but passes that support multiple instances
*must* provide their own implementation of the clone method.
- Handle this by providing a default implemenation, but make it a fatal
+ Handle this by providing a default implementation, but make it a fatal
error to call it. */
opt_pass *
pop_cfun ();
}
-/* Account profile chnages to all passes in list starting in SUB. */
+/* Account profile changes to all passes in list starting in SUB. */
static void
account_profile_in_list (opt_pass *sub)
else if (all_bits_set_p (*bitmask, bucketsize) && phi)
{
/* This reduces to a no-op (x & ~0). Reusing the SSA and not
- emitting an unecessary AND is a big improvement for large
+ emitting an unnecessary AND is a big improvement for large
programs. */
tree *prev = SSAex.get ({e->src, bucket});
if (prev)
/* Retrieve the default plugin directory. The gcc driver should have passed
- it as -iplugindir <dir> to the cc1 program, and it is queriable through the
+ it as -iplugindir <dir> to the cc1 program, and it is queryable through the
-print-file-name=plugin option to gcc. */
const char*
default_plugin_dir_name (void)
{
/* If the object referenced by both arguments has been determined
set *PREF to the one with more or less space remainng, whichever
- is appopriate for CODE.
+ is appropriate for CODE.
TODO: Indicate when the objects are distinct so it can be
diagnosed. */
i0 = code == MAX_EXPR;
tree arefop = TREE_OPERAND (aref, 0);
tree reftype = TREE_TYPE (arefop);
if (!addr && TREE_CODE (TREE_TYPE (reftype)) == POINTER_TYPE)
- /* Avoid arrays of pointers. FIXME: Hande pointers to arrays
+ /* Avoid arrays of pointers. FIXME: Handle pointers to arrays
of known bound. */
return false;
qry->max_depth = qry->depth;
if (const access_ref *cache_ref = qry->get_ref (ptr, ostype))
{
- /* Add the number of DEREFerences accummulated so far. */
+ /* Add the number of DEREFerences accumulated so far. */
const int deref = pref->deref;
*pref = *cache_ref;
pref->deref += deref;
- poly_int_traits<T>::num_coeffs gives the number of coefficients in T
if T is a poly_int and 1 otherwise.
- - poly_int_traits<T>::coeff_type gives the coefficent type of T if T
+ - poly_int_traits<T>::coeff_type gives the coefficient type of T if T
is a poly_int and T itself otherwise
- poly_int_traits<T>::int_type is a shorthand for
second of which has coefficients of type C2. */
#define POLY_POLY_COEFF(C1, C2) typename poly_result<C1, C2>::type
-/* Enforce that T2 is non-polynomial and provide the cofficient type of
+/* Enforce that T2 is non-polynomial and provide the coefficient type of
the result of a binary operation in which the first operand is a
poly_int with coefficients of type C1 and the second operand is
a constant of type T2. */
if (!expr_table->is_empty ())
{
- /* Knowing which MEMs are transparent through a block can signifiantly
+ /* Knowing which MEMs are transparent through a block can significantly
increase the number of redundant loads found. So compute transparency
information for each memory expression in the hash table. */
df_analyze ();
if (*predictor == predictor2 && p1 == p2)
continue;
/* The general case has no precise solution, since we do not
- know probabilities of incomming edges, yet.
- Still if value is predicted over all incomming edges, we
+ know probabilities of incoming edges, yet.
+ Still if value is predicted over all incoming edges, we
can hope it will be indeed the case. Conservatively
downgrade prediction quality (so first match merging is not
performed) and take least successful prediction. */
example:
op0 * op1
If op0 is 0 with probability p, then we will ignore the
- posibility that op0 != 0 and op1 == 0. It does not seem to be
- worthwhile to downgrade prediciton quality for this. */
+ possibility that op0 != 0 and op1 == 0. It does not seem to be
+ worthwhile to downgrade prediction quality for this. */
return res;
if (!nop0)
nop0 = op0;
&& !gimple_call_builtin_p (stmt, BUILT_IN__EXIT2))
return false;
- /* Argument is an interger zero. */
+ /* Argument is an integer zero. */
return integer_zerop (gimple_call_arg (stmt, 0));
}
using predictor. Otherwise we need to look for paths
leading to e->src.
- The second may lead to infinite loop in the case we are predicitng
+ The second may lead to infinite loop in the case we are predicting
regions that are only reachable by abnormal edges. We simply
prevent visiting given BB twice. */
if (found)
/* Scaling frequencies up to maximal profile count may result in
frequent overflows especially when inlining loops.
- Small scaling results in unnecesary precision loss. Stay in
+ Small scaling results in unnecessary precision loss. Stay in
the half of the (exponential) range. */
freq_max = (sreal (1) << (profile_count::n_bits / 2)) / freq_max;
if (freq_max < 16)
bb->count);
if (bb->count.nonzero_p () && bb->count.quality () >= AFDO)
feedback_found = true;
- /* Uninitialized count may be result of inlining or an omision in an
+ /* Uninitialized count may be result of inlining or an omission in an
optimization pass. */
if (!bb->count.initialized_p ())
{
{
sum += e->count ();
/* Uninitialized probability may be result of inlining or an
- omision in an optimization pass. */
+ omission in an optimization pass. */
if (!e->probability.initialized_p ())
{
if (dump_file)
{
if (dump_file)
fprintf (dump_file,
- "BB %i has invalid sum of incomming counts\n",
+ "BB %i has invalid sum of incoming counts\n",
bb->index);
inconsistency_found = true;
}
return;
}
/* Do not re-propagate if we have profile feedback. Even if the profile is
- inconsistent from previous transofrmations, it is probably more realistic
+ inconsistent from previous transformations, it is probably more realistic
for hot part of the program than result of repropagating.
Consider example where we previously has
important copy is not the one we look on.
Propagating from probabilities would make profile look consistent, but
- because probablities after code duplication may not be representative
+ because probabilities after code duplication may not be representative
for a given run, we would only propagate the error further. */
if (feedback_found && !uninitialized_count_found)
{
return new pass_rebuild_frequencies (ctxt);
}
-/* Perform a dry run of the branch prediction pass and report comparsion of
+/* Perform a dry run of the branch prediction pass and report comparison of
the predicted and real profile into the dump file. */
void
BEGIN_URL("http://example.com"), TEXT("-foption"), END_URL, END_QUOTE]
(5) emits all tokens in sequence with appropriate line-wrapping. This
- can be overridded via the pretty_printer's token_printer, allowing for
+ can be overridden via the pretty_printer's token_printer, allowing for
output formats to e.g. override how URLs are handled, or to handle
custom_data that wasn't lowered in (2) above, e.g. for handling JSON
output of optimization records. */
/* If non-NULL, this is called by pp_format once after all format codes
have been processed, to allow for client-specific postprocessing.
This is used by the C++ frontend for handling the %H and %I
- format codes (which interract with each other). */
+ format codes (which interact with each other). */
std::unique_ptr<format_postprocessor> m_format_postprocessor;
/* This is used by pp_output_formatted_text after it has converted all
The union of near/far is essentially a short-vector optimization, switching
to a heap-allocated vector when necessary. This happens relatively rarely
- (usually maxes out at 1-2%), and the vertices that have more than 2 sucessors
+ (usually maxes out at 1-2%), and the vertices that have more than 2 successors
also tend to have more than 4. The root vertex tends to use the dynamic
vector because the subpaths are recorded as the successors of the root.
Conceptually, this is a small map from vertex-id -> index and the API is
modelled as such. The insert and search functions are unrolled by hand when
- using the small vector. This has a noticable performance impact on insert in
+ using the small vector. This has a noticeable performance impact on insert in
particular, and is not too complex since we know we are limited to 2
elements.
in [2 4 6] is cleared when the suffixes of [9 7 2 4 6] are inserted.
The node will be inserted into a vec, and should be trivial. Instances
- should be value-initialized to zero-intialized state. */
+ should be value-initialized to zero-initialized state. */
struct trie_node
{
unsigned length () const
The algorithm is based on Fazli & Afsharchi's "A Time and Space-Efficient
Compositional Method for Prime and Test Paths Generation" (2019), combined
- with a suffix trie for removing duplicate or redundant paths. An auxillary
+ with a suffix trie for removing duplicate or redundant paths. An auxiliary
graph of the strongly connected components (SCCs) is built. Then, the prime
paths of the SCCs composes the prime paths of each SCC with the prime paths
- of this auxillary graph. This can drastically cut the number of redundant
+ of this auxiliary graph. This can drastically cut the number of redundant
paths generated compared to a naive algorithm.
This does not work for all graphs. Some structures, e.g. when most of the
/* This test checks some basic assumptions on finding the strongly connected
components and disconnecting the graph by removing all edges between SCCs.
- Creating a single auxillary graph simplifies the bookkeeping. */
+ Creating a single auxiliary graph simplifies the bookkeeping. */
static void
test_split_components ()
{
else if (m_compact)
{
/* In compact mode, print pseudos with '< and '>' wrapping the regno,
- offseting it by (LAST_VIRTUAL_REGISTER + 1), so that the
+ offsetting it by (LAST_VIRTUAL_REGISTER + 1), so that the
first non-virtual pseudo is dumped as "<0>". */
gcc_assert (regno > LAST_VIRTUAL_REGISTER);
fprintf (m_outfile, " <%d>", regno - (LAST_VIRTUAL_REGISTER + 1));
static const uint32_t uninitialized_probability
= ((uint32_t) 1 << (n_bits - 1)) - 1;
/* For probibilityes quality is either UNINITIALIZED (0)
- or greated then GUESSED. To save bits we store it in
+ or greater then GUESSED. To save bits we store it in
adjusted form which skips the invalid values. */
static const int min_quality = GUESSED;
{
/* This is common case of AFDO scaling when we upgrade
GLOBAL0_AFDO function to AFDO. Be sure that result
- is AFDO and not GUESSED (which is unnecesarily low). */
+ is AFDO and not GUESSED (which is unnecessarily low). */
if (num.m_quality == AFDO
&& (ret.m_quality != GUESSED
&& ret.m_quality != GUESSED_LOCAL))
FOR_EACH_VEC_ELT (graph->complex[from], i, c)
{
/* In complex constraints for node FROM, we may have either
- a = *FROM, and *FROM = a, or an offseted constraint which are
+ a = *FROM, and *FROM = a, or an offsetted constraint which are
always added to the rhs node's constraints. */
if (c->rhs.type == DEREF)
adding the direct edge FROM -> TO when we have FROM -> ESCAPED
and TO contains ESCAPED.
??? Note this is only a heuristic, it does not prevent the
- situation from occuring. The heuristic helps PR38474 and
+ situation from occurring. The heuristic helps PR38474 and
PR99912 significantly. */
if (to < FIRST_REF_NODE
&& bitmap_bit_p (graph->succs[from], find (escaped_id))
return m_operator != &default_operator;
}
-// Return a pointer to the range operator assocaited with this handler.
+// Return a pointer to the range operator associated with this handler.
// If it is a default operator, return nullptr.
// This is the equivalent of indexing the range table.
wide_int value = wide_int::from (bm.value (), TYPE_PRECISION (type),
UNSIGNED);
- // Set then additonal unknown bits in mask.
+ // Set then additional unknown bits in mask.
wide_int lim = wi::mask (TYPE_PRECISION (lhs_type), true,
TYPE_PRECISION (type));
mask = mask | lim;
const wide_int &rh_ub) const
{
// The AND algorithm does not handle complex signed operations well.
- // If a signed range crosses the boundry between signed and unsigned
- // proces sit as 2 ranges and union the results.
+ // If a signed range crosses the boundary between signed and unsigned
+ // process it as 2 ranges and union the results.
if (TYPE_SIGN (type) == SIGNED
&& wi::neg_p (lh_lb, SIGNED) != wi::neg_p (lh_ub, SIGNED))
{
op1_mask |= lhs_bm.mask ();
// The resulting zeros correspond to known bits in the LHS mask, and
// the LHS value should tell us what they are. Mask off any
- // extraneous values thats are not convered by the mask.
+ // extraneous values that are not covered by the mask.
wide_int op1_value = lhs_bm.value () & ~op1_mask;
irange_bitmask op1_bm (op1_value, op1_mask);
// Intersect this mask with anything already known about the value.
virtual bool overflow_free_p (const irange &lh, const irange &rh,
relation_trio = TRIO_VARYING) const;
- // Compatability check for operands.
+ // Compatibility check for operands.
virtual bool operand_check_p (tree, tree, tree) const;
protected:
htab_t m_overloads_htab;
};
-/* Global singleton; constrast with rtx_reader_ptr below. */
+/* Global singleton; contrast with rtx_reader_ptr below. */
extern md_reader *md_reader_ptr;
/* An md_reader subclass which skips unknown directives, for
#endif
};
-/* Global singleton; constrast with md_reader_ptr above. */
+/* Global singleton; contrast with md_reader_ptr above. */
extern rtx_reader *rtx_reader_ptr;
extern void (*include_callback) (const char *);
/* TODO: handle "virtual-reg-%d". */
/* In compact mode, pseudos are printed with '< and '>' wrapping the regno,
- offseting it by (LAST_VIRTUAL_REGISTER + 1), so that the
+ offsetting it by (LAST_VIRTUAL_REGISTER + 1), so that the
first non-virtual pseudo is dumped as "<0>". */
if (name[0] == '<' && name[strlen (name) - 1] == '>')
{
- Denormals can be represented, but are treated as +0.0 when
used as an operand and are never generated as a result.
- -0.0 can be represented, but a zero result is always +0.0.
- - the only supported rounding mode is trunction (towards zero). */
+ - the only supported rounding mode is truncation (towards zero). */
const struct real_format spu_single_format =
{
encode_ieee_single,
rtx /*mem*/) { return true; }
/* Note that we've simplified OLD_RTX into NEW_RTX. When substituting,
- this only happens if a substitution occured within OLD_RTX.
+ this only happens if a substitution occurred within OLD_RTX.
Undoing OLD_NUM_CHANGES and up will restore the old form of OLD_RTX.
OLD_RESULT_FLAGS is the value that RESULT_FLAGS had before processing
OLD_RTX. */
It may first appear that the arguments for the copy are reversed.
Remember that the memory reference will be changed to refer to the
- destination of the extention. So we're actually emitting a copy
+ destination of the extension. So we're actually emitting a copy
from the new destination to the old destination. */
for (unsigned int i = 0; i < reinsn_copy_list.length (); i += 2)
{
REG_CFA_NOTE (CFA_NO_RESTORE)
/* Attached to insns that are RTX_FRAME_RELATED_P, marks insn that sets
- vDRAP from DRAP. If vDRAP is a register, vdrap_reg is initalized
+ vDRAP from DRAP. If vDRAP is a register, vdrap_reg is initialized
to the argument, if it is a MEM, it is ignored. */
REG_CFA_NOTE (CFA_SET_VDRAP)
\f
-/* Allocate space for reg info and initilize it. */
+/* Allocate space for reg info and initialize it. */
static void
allocate_reg_info (void)
{
so any pseudo reg that is spilled must go to the stack.
Return value is TRUE if reload likely left dead insns in the
- stream and a DCE pass should be run to elimiante them. Else the
+ stream and a DCE pass should be run to eliminate them. Else the
return value is FALSE. */
bool
}
/* The following if-statement was #if 0'd in 1.34 (or before...).
- It's reenabled in 1.35 because supposedly nothing else
+ It's re-enabled in 1.35 because supposedly nothing else
deals with this problem. */
/* If a register gets output-reloaded from a non-spill register,
/* In addition to the usual references, also consider all outputs
as referenced, to compensate for mark_set_resources treating
them as killed. This is similar to ZERO_EXTRACT / STRICT_LOW_PART
- handling, execpt that we got a partial incidence instead of a partial
+ handling, except that we got a partial incidence instead of a partial
width. */
mark_set_resources (x, res, 0,
include_delayed_effects
if (CALL_P (real_insn))
{
/* Values in call-clobbered registers survive a COND_EXEC CALL
- if that is not executed; this matters for resoure use because
+ if that is not executed; this matters for resource use because
they may be used by a complementarily (or more strictly)
predicated instruction, or if the CALL is NORETURN. */
if (GET_CODE (PATTERN (real_insn)) != COND_EXEC)
2: A docstring for this constraint, in Texinfo syntax; not currently
used, in future will be incorporated into the manual's list of
machine-specific operand constraints.
- 3: A C expression that evalutes to true if "regno" is a valid
+ 3: A C expression that evaluates to true if "regno" is a valid
start register. */
DEF_RTL_EXPR(DEFINE_REGISTER_CONSTRAINT, "define_register_constraint", "sssS", RTX_EXTRA)
that match the substitution pattern.
Operand:
- 0: The name of the substitition template.
+ 0: The name of the substitution template.
1: Input template to match to see if a substitution is applicable.
2: A C expression giving an additional condition for the generated
new define_expand or define_insn.
name, for the case that the DEFINE_SUBST is not applied (i.e. the
unmodified version of the pattern).
3: String to substitute for the subst-attribute name in the pattern
- name, for the case that the DEFINE_SUBST is applied to the patten.
+ name, for the case that the DEFINE_SUBST is applied to the pattern.
The use of DEFINE_SUBST and DEFINE_SUBST_ATTR is explained in the
GCC internals manual, under "RTL Templates Transformations". */
{ B, B + S, B + 2 * S, B + 3 * S, ... }
- for a nonzero S. Store B and S in *BASE_OUT and *STEP_OUT on sucess. */
+ for a nonzero S. Store B and S in *BASE_OUT and *STEP_OUT on success. */
inline bool
const_vec_series_p (const_rtx x, rtx *base_out, rtx *step_out)
{ B, B + S, B + 2 * S, B + 3 * S, ... }
where B and S are constant or nonconstant. Store B and S in
- *BASE_OUT and *STEP_OUT on sucess. */
+ *BASE_OUT and *STEP_OUT on success. */
inline bool
vec_series_p (const_rtx x, rtx *base_out, rtx *step_out)
projects / thirdparty / gcc.git / commitdiff
