/* Number of IFN_ASAN_CHECK statements. */
int asan_num_accesses;
- /* True when the current functions constains an ASAN_MARK. */
+ /* True when the current functions contains an ASAN_MARK. */
bool contains_asan_mark;
};
a jump insn which usually generates MOVE_BARRIER preventing
to move insns containing registers or memories through the
barrier. It is also wrong with generated code performance
- point of view as prefetch withouth dependecies will have a
+ point of view as prefetch without dependencies will have a
tendency to be issued later instead of earlier. It is hard
to generate accurate dependencies for prefetch insns as
prefetch has only the start address but it is better to have
/* Init target context TC.
If CLEAN_P is true, then make TC as it is beginning of the scheduler.
- Overwise, copy current backend context to TC. */
+ Otherwise, copy current backend context to TC. */
static void
init_target_context (tc_t tc, bool clean_p)
{
av_set_iterator i;
av_set_t *to_tailp, in_both_set = NULL;
- /* Delete from TOP all expres, that present in FROMP. */
+ /* Delete from TOP all exprs, that present in FROMP. */
FOR_EACH_EXPR_1 (expr1, i, top)
{
expr_t expr2 = av_set_lookup_and_remove (fromp, EXPR_VINSN (expr1));
return true;
}
-/* Initalize data structures needed. */
+/* Initialize data structures needed. */
void
sel_init_pipelining (void)
{
/* The list we're iterating. */
_list_t *lp;
- /* True when this iterator supprts removing. */
+ /* True when this iterator supports removing. */
bool can_remove_p;
/* True when we've actually removed something. */
/* A structure returning all successor's information. */
struct succs_info
{
- /* Flags that these succcessors were computed with. */
+ /* Flags that these successors were computed with. */
short flags;
/* Successors that correspond to the flags. */
/* Include all successors. */
#define SUCCS_ALL (SUCCS_NORMAL | SUCCS_BACK | SUCCS_OUT)
-/* We need to return a succ_iterator to avoid 'unitialized' warning
+/* We need to return a succ_iterator to avoid 'uninitialized' warning
during bootstrap. */
inline succ_iterator
_succ_iter_start (insn_t *succp, insn_t insn, int flags)
An expression is a vinsn with additional data characterizing its properties
at some point in the control flow graph. The data may be its usefulness,
- priority, speculative status, whether it was renamed/subsituted, etc.
+ priority, speculative status, whether it was renamed/substituted, etc.
An expression is described by expr_t type.
Availability set (av_set) is a set of expressions at a given control flow
/* The number of bookkeeping copies created. */
static int stat_bookkeeping_copies;
-/* The number of insns that required bookkeeiping for their scheduling. */
+/* The number of insns that required bookkeeping for their scheduling. */
static int stat_insns_needed_bookkeeping;
/* The number of insns that got renamed. */
insn is pulled ahead of it. It's hard to figure out how to
introduce such a notion in sel-sched, but it already fails to
support debug insns in other ways, so we just go ahead and
- let the deug insns go corrupt for now. */
+ let the debug insns go corrupt for now. */
if (DEBUG_INSN_P (through_insn) && !DEBUG_INSN_P (insn))
return MOVEUP_EXPR_SAME;
basic blocks. */;
else if (try_bitmap_cache (expr, insn, inside_insn_group, &res))
/* When inside insn group, we do not want remove stores conflicting
- with previosly issued loads. */
+ with previously issued loads. */
got_answer = ! inside_insn_group || res != MOVEUP_EXPR_NULL;
else if (try_transformation_cache (expr, insn, &res))
got_answer = true;
return to_check_ds;
}
-/* Find the set of registers that are unavailable for storing expres
+/* Find the set of registers that are unavailable for storing exprs
while moving ORIG_OPS up on the path starting from INSN due to
liveness (USED_REGS) or hardware restrictions (REG_RENAME_P).
This function utilizes code_motion_path_driver (formerly find_used_regs_1)
to traverse the code motion paths. This helper function finds registers
- that are not available for storing expres while moving ORIG_OPS up on the
+ that are not available for storing exprs while moving ORIG_OPS up on the
path starting from INSN. A register considered as used on the moving path,
if one of the following conditions is not satisfied:
{
if (!FENCE_STARTS_CYCLE_P (fence)
&& INSN_ASM_P (insn))
- /* This is asm insn which is tryed to be issued on the
+ /* This is asm insn which is tried to be issued on the
cycle not first. Issue it on the next cycle. */
return 1;
else
return place_to_insert;
}
-/* Find a proper seqno for bookkeeing insn inserted at PLACE_TO_INSERT
+/* Find a proper seqno for bookkeeping insn inserted at PLACE_TO_INSERT
for JOIN_POINT. */
static int
find_seqno_for_bookkeeping (insn_t place_to_insert, insn_t join_point)
rtx_insn *bb_end = sel_bb_end (book_block);
/* First, get correct liveness in the bookkeeping block. The problem is
- the range between the bookeeping insn and the end of block. */
+ the range between the bookkeeping insn and the end of block. */
update_liveness_on_insn (bb_end);
if (control_flow_insn_p (bb_end))
update_liveness_on_insn (PREV_INSN (bb_end));
r1 := r2
Here, insn "r1 := r3" was scheduled at the current scheduling point
- and bookkeeping code was generated at the bookeeping block. This
+ and bookkeeping code was generated at the bookkeeping block. This
way insn "r1 := r2" is no longer available as a whole instruction
(but only as expr) ahead of insn "r1 := r3" in bookkeeping block.
This situation is handled by calling update_data_sets.
}
/* Update seqnos of insns given by PSCHEDULED_INSNS. MIN_SEQNO and MAX_SEQNO
- are the miminum and maximum seqnos of the group, HIGHEST_SEQNO_IN_USE is
+ are the minimum and maximum seqnos of the group, HIGHEST_SEQNO_IN_USE is
the highest seqno used in a region. Return the updated highest seqno. */
static int
update_seqnos_and_stage (int min_seqno, int max_seqno,
/* Try to move INSN from BB to a successor. Return true on success.
USES and DEFS are the set of registers that are used and defined
after INSN in BB. SPLIT_P indicates whether a live edge from BB
- is splitted or not. */
+ is split or not. */
static bool
move_insn_for_shrink_wrap (basic_block bb, rtx_insn *insn,
/* Now see if we can put the prologue at the start of PRO. Putting it
there might require duplicating a block that cannot be duplicated,
or in some cases we cannot insert the prologue there at all. If PRO
- wont't do, try again with the immediate dominator of PRO, and so on.
+ won't do, try again with the immediate dominator of PRO, and so on.
The blocks that need duplicating are those reachable from PRO but
not dominated by it. We keep in BB_WITH a bitmap of the blocks
handle_simple_exit (e);
/* Finally, we want a single edge to put the prologue on. Make a new
- block before the PRO block; the edge beteen them is the edge we want.
+ block before the PRO block; the edge between them is the edge we want.
Then redirect those edges into PRO that come from blocks without the
prologue, to point to the new block instead. The new prologue block
is put at the end of the insn chain. */
simplify down to IOR/XOR expression right now, but there may be other
simplifications we can do in the future.
- Return the simpified expression or NULL_RTX if no simpification was
+ Return the simplified expression or NULL_RTX if no simplification was
possible. */
rtx
simplify_context::simplify_ior_with_common_term (machine_mode mode, rtx op0, rtx op1)
(i386) extract scalar element from a vector using chain of
nested VEC_SELECT expressions. When input operand is a memory
operand, this operation can be simplified to a simple scalar
- load from an offseted memory address. */
+ load from an offsetted memory address. */
int n_elts;
if (GET_CODE (trueop0) == VEC_SELECT
&& (GET_MODE_NUNITS (GET_MODE (XEXP (trueop0, 0)))
if (!native_encode_rtx (innermode, x, buffer, first_byte, buffer_bytes))
return NULL_RTX;
- /* Reencode the bytes as OUTERMODE. */
+ /* Re-encode the bytes as OUTERMODE. */
return native_decode_vector_rtx (outermode, buffer, 0, out_npatterns,
nelts_per_pattern);
}
assert_not_suggested_for (SELFTEST_LOCATION, CANDIDATE, TARGET); \
SELFTEST_END_STMT
-/* Verify that we offer varous suggestions that are meaningful,
+/* Verify that we offer various suggestions that are meaningful,
and that we don't offer various other ones that aren't (PR c/82967). */
static void
-/* Declarations and definitons for stringpool.cc.
+/* Declarations and definitions for stringpool.cc.
Copyright (C) 2013-2026 Free Software Foundation, Inc.
This file is part of GCC.
/* Adds two bits and carry value.
- Resturn result and stores new carry bit in "carry". */
+ Returns result and stores new carry bit in "carry". */
value_bit *
state::full_adder (value_bit *var1, value_bit *var2, value_bit **carry)
node_to_parent.put (expr_root, nullptr);
/* Traversing expression tree:
- considering only comutative expression nodes. */
+ considering only commutative expression nodes. */
while (!nodes_to_consider.is_empty ())
{
bit_expression *cur_element = *nodes_to_consider.begin ();
}
-/* ANDs every bit of the vector with var_bit, stroes the result in var1. */
+/* ANDs every bit of the vector with var_bit, stores the result in var1. */
void
state::and_number_bit (value *var1, value_bit *var_bit)
}
/* When some of bits are constants and they differ by value,
- then we can evalate it to be false. */
+ then we can evaluate it to be false. */
for (size_t i = 0; i < arg1->length (); i++)
{
if (is_a<bit *> ((*arg1)[i]) && is_a<bit *> ((*arg2)[i])
}
/* When some of bits are constants and they differ by value,
- then we can evalate it to be true. */
+ then we can evaluate it to be true. */
for (size_t i = 0; i < arg1->length (); i++)
{
if (is_a<bit *> ((*arg1)[i]) && is_a<bit *> ((*arg2)[i])
/* Performs AND operation on two bits. */
static value_bit *and_two_bits (value_bit *arg1, value_bit *arg2);
- /* ANDs every bit of the value with var_bit, stroes the result in var1. */
+ /* ANDs every bit of the value with var_bit, stores the result in var1. */
void and_number_bit (value *var1, value_bit *var_bit);
/* Multiplies given values. The result is stored in dest. */
value *shift_left_by_const (const value *number, size_t shift_value);
/* Adds two bits and carry value.
- Resturn result and stores new carry bit in "carry". */
+ Returns result and stores new carry bit in "carry". */
static value_bit *full_adder (value_bit *var1, value_bit *var2,
value_bit **carry);
related to a callgraph node. Typical usage can be seen in IPA passes which
create a temporary pass-related structures. The summary class registers
hooks that are triggered when a new node is inserted, duplicated and deleted.
- A user of a summary class can ovewrite virtual methods than are triggered by
+ A user of a summary class can overwrite virtual methods than are triggered by
the summary if such hook is triggered. Apart from a callgraph node, the user
is given a data structure tied to the node.
return false;
}
-/* If node cannot be overwriten by static or dynamic linker to point to
+/* If node cannot be overwritten by static or dynamic linker to point to
different definition, return NODE. Otherwise look for alias with such
property and if none exists, introduce new one. */
We probably should be consistent and use this fact here, too, but for
the moment return false only when we are called from the alias oracle.
Return 0 in C constant initializers and C++ manifestly constant
- expressions, the likelyhood that different vars will be aliases is
+ expressions, the likelihood that different vars will be aliases is
small and returning -1 lets us reject too many initializers. */
if (memory_accessed || folding_initializer)
return 0;
- the character 'k', if the number is higher than 10 K (in base 2)
but strictly lower than 10 M (in base 2)
- the character 'M' if the number is higher than 10 M (in base2)
- - the charcter ' ' if the number is strictly lower than 10 K */
+ - the character ' ' if the number is strictly lower than 10 K */
#define SIZE_LABEL(x) ((x) < 10 * ONE_K ? ' ' : ((x) < 10 * ONE_M ? 'k' : 'M'))
/* Display an integer amount as multiple of 1K or 1M (in base 2).
under the GPL, but not under the GFDL, put it in a comment above the hook
definition. If the function declaration is available both under GPL and
GFDL, but the documentation is only available under the GFDL, put the
- documentaton in tm.texi.in, heading with @hook <hookname> and closing
+ documentation in tm.texi.in, heading with @hook <hookname> and closing
the paragraph with @end deftypefn / deftypevr as appropriate, and marking
the next autogenerated hook with @hook <hookname>.
In both these cases, leave the DOC string empty, i.e. "".
A documentation string of "*" means not to emit any documentation at all,
and is mainly used internally for DEFHOOK_UNDOC. It should generally not
be used otherwise, but it has its use for exceptional cases where automatic
- documentation is not wanted, and the real documentation is elsewere, like
+ documentation is not wanted, and the real documentation is elsewhere, like
for TARGET_ASM_{,UN}ALIGNED_INT_OP, which are hooks only for implementation
purposes; they refer to structs, the components of which are documented as
separate hooks TARGET_ASM_{,UN}ALIGNED_[HSDT]I_OP.
(expand_var_decl,
"This hook, if defined, is used by accelerator target back-ends to expand\n\
specially handled kinds of @code{VAR_DECL} expressions. A particular use is\n\
-to place variables with specific attributes inside special accelarator\n\
+to place variables with specific attributes inside special accelerator\n\
memories. A return value of @code{NULL} indicates that the target does not\n\
handle this @code{VAR_DECL}, and normal RTL expanding is resumed.\n\
\n\
\n\
The modes returned in @var{modes} should use the smallest element mode\n\
possible for the vectorization approach that they represent, preferring\n\
-integer modes over floating-poing modes in the event of a tie. The first\n\
+integer modes over floating-point modes in the event of a tie. The first\n\
mode should be the @code{TARGET_VECTORIZE_PREFERRED_SIMD_MODE} for its\n\
element mode.\n\
\n\
DEFHOOK
(gen_ccmp_first,
"This function prepares to emit a comparison insn for the first compare in a\n\
- sequence of conditional comparisions. It returns an appropriate comparison\n\
+ sequence of conditional comparisons. It returns an appropriate comparison\n\
with @code{CC} for passing to @code{gen_ccmp_next} or @code{cbranch_optab}.\n\
The insns to prepare the compare are saved in @var{prep_seq} and the compare\n\
insns are saved in @var{gen_seq}. They will be emitted when all the\n\
- compares in the conditional comparision are generated without error.\n\
+ compares in the conditional comparison are generated without error.\n\
@var{code} is the @code{rtx_code} of the compare for @var{op0} and @var{op1}.",
rtx, (rtx_insn **prep_seq, rtx_insn **gen_seq, rtx_code code, tree op0, tree op1),
NULL)
@code{CC} for passing to @code{gen_ccmp_next} or @code{cbranch_optab}.\n\
The insns to prepare the compare are saved in @var{prep_seq} and the compare\n\
insns are saved in @var{gen_seq}. They will be emitted when all the\n\
- compares in the conditional comparision are generated without error. The\n\
+ compares in the conditional comparison are generated without error. The\n\
@var{prev} expression is the result of a prior call to @code{gen_ccmp_first}\n\
or @code{gen_ccmp_next}. It may return @code{NULL} if the combination of\n\
@var{prev} and this comparison is not supported, otherwise the result must\n\
built-in function without the @code{__builtin_} prefix in addition to the\n\
normal built-in function with the @code{__builtin_} prefix. The default is\n\
to only enable built-in functions without the @code{__builtin_} prefix for\n\
-the GNU C langauge. In strict ANSI/ISO mode, the built-in function without\n\
+the GNU C language. In strict ANSI/ISO mode, the built-in function without\n\
the @code{__builtin_} prefix is not enabled. The argument @code{FUNC} is the\n\
@code{enum built_in_function} id of the function to be enabled.",
bool, (int func),
hook_bool_mode_false)
/* Register number for a flags register. Only needs to be defined if the
- target is constrainted to use post-reload comparison elimination. */
+ target is constrained to use post-reload comparison elimination. */
DEFHOOKPOD
(flags_regnum,
"If the target has a dedicated flags register, and it needs to use the\n\
compilation for the second case.\n\
\n\
For targets that have no processors that can execute instructions\n\
- speculatively an alternative implemenation of this hook is available:\n\
+ speculatively an alternative implementation of this hook is available:\n\
simply redefine this hook to @code{speculation_safe_value_not_needed}\n\
along with your other target hooks.",
bool, (bool active), default_have_speculation_safe_value)
move IV value from hardware count register to general purpose register\n\
while doloop IV candidate is used for address IV uses. It probably takes\n\
expensive penalty. This hook allows target owners to define the cost for\n\
-this escpecially for address IV uses.\n\
+this especially for address IV uses.\n\
The default value is zero.",
int64_t, 0)
@code{EXCESS_PRECISION_TYPE_STANDARD}, or\n\
@code{EXCESS_PRECISION_TYPE_FLOAT16}. For\n\
@code{EXCESS_PRECISION_TYPE_IMPLICIT}, the target should return which\n\
-precision and range operations will be implictly evaluated in regardless\n\
+precision and range operations will be implicitly evaluated in regardless\n\
of the excess precision explicitly added. For\n\
@code{EXCESS_PRECISION_TYPE_STANDARD}, \n\
@code{EXCESS_PRECISION_TYPE_FLOAT16}, and\n\
should implicitly enable the built-in function without the __builtin_ prefix
in addition to the normal built-in function with the __builtin_ prefix. The
default is to only enable built-in functions without the __builtin_ prefix
- for the GNU C langauge. The argument FUNC is the enum builtin_in_function
+ for the GNU C language. The argument FUNC is the enum builtin_in_function
id of the function to be enabled. */
bool
return c_or_objective_c;
}
-/* Make some target macros useable by target-independent code. */
+/* Make some target macros usable by target-independent code. */
bool
targhook_words_big_endian (void)
{
}
/* By default, assume that a target supports any factor of misalignment
- memory access if it supports movmisalign patten.
+ memory access if it supports movmisalign pattern.
is_packed is true if the memory access is defined in a packed struct. */
bool
default_builtin_support_vector_misalignment (machine_mode mode,
}
-/* The defualt implementation of TARGET_HARD_REGNO_NREGS. */
+/* The default implementation of TARGET_HARD_REGNO_NREGS. */
unsigned int
default_hard_regno_nregs (unsigned int, machine_mode mode)
/* Now walk backwards trying to place them vertically,
setting m_text_rect.m_top_left.y for each label,
consolidating the rows where possible.
- The y cooordinates are stored with respect to label_dir::BELOW. */
+ The y coordinates are stored with respect to label_dir::BELOW. */
int label_y = 2;
for (int idx = m_labels.size () - 1; idx >= 0; idx--)
{
# m_text_coord.x == 6
and m_text_coord is (2, 6).
- The y cooordinates are stored with respect to label_dir::BELOW;
+ The y coordinates are stored with respect to label_dir::BELOW;
for label_dir::ABOVE we flip them when painting the ruler. */
class label
{
DEFTIMEVAR (TV_TREE_SSA_DOMINATOR_OPTS , "dominator optimization")
DEFTIMEVAR (TV_TREE_SSA_THREAD_JUMPS , "backwards jump threading")
DEFTIMEVAR (TV_TREE_SRA , "tree SRA")
-DEFTIMEVAR (TV_ISOLATE_ERRONEOUS_PATHS , "isolate eroneous paths")
+DEFTIMEVAR (TV_ISOLATE_ERRONEOUS_PATHS , "isolate erroneous paths")
DEFTIMEVAR (TV_TREE_CCP , "tree CCP")
DEFTIMEVAR (TV_TREE_SPLIT_EDGES , "tree split crit edges")
DEFTIMEVAR (TV_TREE_REASSOC , "tree reassociation")
return false;
}
-/* For each of the blocks seeded witin PQUEUE, walk the CFG looking
+/* For each of the blocks seeded within PQUEUE, walk the CFG looking
for new irrevocable blocks, marking them in NEW_IRR. Don't bother
scanning past OLD_IRR or EXIT_BLOCKS. */
/* Iterate scans until no more work to be done. Prefer not to use
vec::pop because the worklist tends to follow a breadth-first
- search of the callgraph, which should allow convergance with a
+ search of the callgraph, which should allow convergence with a
minimum number of scans. But we also don't want the worklist
array to grow without bound, so we shift the array up periodically. */
for (i = 0; i < irr_worklist.length (); ++i)
/* The root of the tree. */
splay_tree_node root;
- /* The comparision function. */
+ /* The comparison function. */
compare_fn comp;
/* The deallocate-key function. NULL if no cleanup is necessary. */
}
/* Determine if we can propagate given LOCATION to ubsan_data descriptor to use
- new style handlers. Libubsan uses heuristics to destinguish between old and
+ new style handlers. Libubsan uses heuristics to distinguish between old and
new styles and relies on these properties for filename:
a) Location's filename must not be NULL.
compute_value_histograms() that translates the collected data to
histograms and attaches them to the profiled statements via
gimple_add_histogram_value(). Histograms are stored in a hash table
- that is attached to every intrumented function, see VALUE_HISTOGRAMS
+ that is attached to every instrumented function, see VALUE_HISTOGRAMS
in function.h.
The value-profile transformations driver is the function
bool
irange::union_append (const irange &r)
{
- // Check if the first range in R is an immmediate successor to the last
- // range, ths requiring a merge.
+ // Check if the first range in R is an immediate successor to the last
+ // range, thus requiring a merge.
signop sign = TYPE_SIGN (m_type);
wide_int lb = r.lower_bound ();
wide_int ub = upper_bound ();
}
// This method loops through the subranges in THIS, and adjusts any bounds
-// to satisfy the contraints of the BITMASK. If a subrange is invalid,
+// to satisfy the constraints of the BITMASK. If a subrange is invalid,
// it is removed. TRUE is returned if there were any changes.
bool
}
// If the bitmask has a range representation, intersect this range with
-// the bitmasks range. Then ensure all enpoints match the bitmask.
+// the bitmasks range. Then ensure all endpoints match the bitmask.
// Return TRUE if the range changes at all.
bool
irange_bitmask bm (type (), lower_bound (), upper_bound ());
if (!m_bitmask.unknown_p ())
{
- // If the new intersection is unknown, it means there are inconstent
+ // If the new intersection is unknown, it means there are inconsistent
// bits, so simply return the original bitmask.
if (!bm.intersect (m_bitmask))
return m_bitmask;
return m_mask.get_precision ();
}
-// The following two functions are meant for backwards compatability
+// The following two functions are meant for backwards compatibility
// with the nonzero bitmask. A cleared bit means the value must be 0.
// A set bit means we have no information for the bit.
};
// Given relation record PTR in block BB, return the next relation in the
-// list. If PTR is NULL, retreive the first relation in BB.
+// list. If PTR is NULL, retrieve the first relation in BB.
// If NAME is sprecified, return only relations which include NAME.
// Return NULL when there are no relations left.
tree name) const
{
relation_chain *p;
- // No value_relation pointer is used to intialize the iterator.
+ // No value_relation pointer is used to initialize the iterator.
if (!ptr)
{
int bbi = bb->index;
return p;
}
-// Instatiate a block relation iterator to iterate over the relations
+// Instantiate a block relation iterator to iterate over the relations
// on exit from block BB in ORACLE. Limit this to relations involving NAME
// if specified. Return the first such relation in VR if there is one.
m_done = true;
}
-// Retreive the next relation from the iterator and return it in VR.
+// Retrieve the next relation from the iterator and return it in VR.
void
block_relation_iterator::get_next_relation (value_relation &vr)
return shared_hash_find_1 (vars, dv, dv_htab_hash (dv));
}
-/* Return true if TVAL is better than CVAL as a canonival value. We
+/* Return true if TVAL is better than CVAL as a canonical value. We
choose lowest-numbered VALUEs, using the RTX address as a
tie-breaker. The idea is to arrange them into a star topology,
such that all of them are at most one step away from the canonical
mode = GET_MODE (var->var_part[i].cur_loc);
if (mode == VOIDmode && var->onepart)
mode = DECL_MODE (decl);
- /* We ony track subparts of constant-sized objects, since at present
+ /* We only track subparts of constant-sized objects, since at present
there's no representation for polynomial pieces. */
if (!GET_MODE_SIZE (mode).is_constant (&size))
{
unsigned HOST_WIDE_INT align,
unsigned int flags)
{
- /* If the mode is unknown (BLK or VOID), then return a non mergable section. */
+ /* If the mode is unknown (BLK or VOID), then return a non mergeable section. */
if (mode == BLKmode || mode == VOIDmode)
return readonly_data_section;
unsigned HOST_WIDE_INT size;
if (tm_clone_hash == NULL)
return;
- /* We need a determenistic order for the .tm_clone_table, otherwise
+ /* We need a deterministic order for the .tm_clone_table, otherwise
we will get bootstrap comparison failures, so dump the hash table
to a vector, sort it, and dump the vector. */
/* Weakrefs may not bind locally, even though the weakref itself is always
static and therefore local. Similarly, the resolver for ifunc functions
might resolve to a non-local function.
- FIXME: We can resolve the weakref case more curefuly by looking at the
+ FIXME: We can resolve the weakref case more carefully by looking at the
weakref alias. */
if (lookup_attribute ("weakref", DECL_ATTRIBUTES (exp))
|| (!targetm.ifunc_ref_local_ok ()
cmp_var = rhs1;
}
- /* If we could not find two-vals or the optimzation is invalid as
+ /* If we could not find two-vals or the optimization is invalid as
in divide by zero, new_rhs1 / new_rhs will be NULL_TREE. */
if (new_rhs1 && new_rhs2)
{
The vtable verification feature is controlled by the flag
'-fvtable-verify='. There are three flavors of this:
'-fvtable-verify=std', '-fvtable-verify=preinit', and
- '-fvtable-verify=none'. If the option '-fvtable-verfy=preinit' is
+ '-fvtable-verify=none'. If the option '-fvtable-verify=preinit' is
used, then our constructor initialization function gets put into the
preinit array. This is necessary if there are data sets that need
to be built very early in execution. If the constructor
return !RESERVED_LOCATION_P (loc) && get_no_warning_bit (t);
}
-/* Retrieve warning dispostion bitmap for tree streaming. */
+/* Retrieve warning disposition bitmap for tree streaming. */
unsigned
get_warning_spec (const_tree t)
/* Return the largest SGNed number that is representable in PRECISION bits.
- TODO: There is still code from the double_int era that trys to
+ TODO: There is still code from the double_int era that tries to
make up for the fact that double int's could not represent the
min and max values of all types. This code should be removed
because the min and max values can always be represented in
}
/* This function hides the fact that we cannot rely on the bits beyond
- the precision. This issue comes up in the relational comparisions
+ the precision. This issue comes up in the relational comparisons
where we do allow comparisons of values of different precisions. */
static inline HOST_WIDE_INT
selt (const HOST_WIDE_INT *a, unsigned int len,
overflow = true;
/* Handle the overflow cases. Viewed as unsigned value, the quotient of
- (signed min / -1) has the same representation as the orignal dividend.
+ (signed min / -1) has the same representation as the original dividend.
We have traditionally made division by zero act as division by one,
so there too we use the original dividend. */
if (overflow)
bits above the precision that has been specified. Because of
this, the default flavor has semantics that are simple to
understand and in general model the underlying hardware that the
- compiler is targetted for.
+ compiler is targeted for.
This flavor must be used at the RTL level of gcc because there
is, in general, not enough information in the RTL representation
The offset_int and the widest_int flavors are more expensive
than the default wide int, so in addition to the caveats with these
- two, the default is the prefered representation.
+ two, the default is the preferred representation.
All three flavors of wide_int are represented as a vector of
HOST_WIDE_INTs. The default and widest_int vectors contain enough elements
namespace wi
{
- /* ints_for<T>::zero (X) returns a zero that, when asssigned to a T,
+ /* ints_for<T>::zero (X) returns a zero that, when assigned to a T,
gives that T the same precision as X. */
template<typename T, precision_type = int_traits<T>::precision_type>
struct ints_for
return result;
}
-/* Return the mininum of X and Y, treating them both as having
+/* Return the minimum of X and Y, treating them both as having
signedness SGN. */
template <typename T1, typename T2>
inline WI_BINARY_RESULT (T1, T2)
return wi::min (x, y, UNSIGNED);
}
-/* Return the maxinum of X and Y, treating them both as having
+/* Return the maximum of X and Y, treating them both as having
signedness SGN. */
template <typename T1, typename T2>
inline WI_BINARY_RESULT (T1, T2)
return result;
}
-/* Return X / Y, rouding towards 0. Treat X and Y as having the
+/* Return X / Y, rounding towards 0. Treat X and Y as having the
signedness given by SGN. Indicate in *OVERFLOW if the result
overflows. */
template <typename T1, typename T2>
return quotient;
}
-/* Return X / Y, rouding towards 0. Treat X and Y as signed values. */
+/* Return X / Y, rounding towards 0. Treat X and Y as signed values. */
template <typename T1, typename T2>
inline WI_BINARY_RESULT (T1, T2)
wi::sdiv_trunc (const T1 &x, const T2 &y)
return div_trunc (x, y, SIGNED);
}
-/* Return X / Y, rouding towards 0. Treat X and Y as unsigned values. */
+/* Return X / Y, rounding towards 0. Treat X and Y as unsigned values. */
template <typename T1, typename T2>
inline WI_BINARY_RESULT (T1, T2)
wi::udiv_trunc (const T1 &x, const T2 &y)
return div_trunc (x, y, UNSIGNED);
}
-/* Return X / Y, rouding towards -inf. Treat X and Y as having the
+/* Return X / Y, rounding towards -inf. Treat X and Y as having the
signedness given by SGN. Indicate in *OVERFLOW if the result
overflows. */
template <typename T1, typename T2>
return quotient;
}
-/* Return X / Y, rouding towards -inf. Treat X and Y as signed values. */
+/* Return X / Y, rounding towards -inf. Treat X and Y as signed values. */
template <typename T1, typename T2>
inline WI_BINARY_RESULT (T1, T2)
wi::sdiv_floor (const T1 &x, const T2 &y)
return div_floor (x, y, SIGNED);
}
-/* Return X / Y, rouding towards -inf. Treat X and Y as unsigned values. */
+/* Return X / Y, rounding towards -inf. Treat X and Y as unsigned values. */
/* ??? Why do we have both this and udiv_trunc. Aren't they the same? */
template <typename T1, typename T2>
inline WI_BINARY_RESULT (T1, T2)
return div_floor (x, y, UNSIGNED);
}
-/* Return X / Y, rouding towards +inf. Treat X and Y as having the
+/* Return X / Y, rounding towards +inf. Treat X and Y as having the
signedness given by SGN. Indicate in *OVERFLOW if the result
overflows. */
template <typename T1, typename T2>
return quotient;
}
-/* Return X / Y, rouding towards +inf. Treat X and Y as unsigned values. */
+/* Return X / Y, rounding towards +inf. Treat X and Y as unsigned values. */
template <typename T1, typename T2>
inline WI_BINARY_RESULT (T1, T2)
wi::udiv_ceil (const T1 &x, const T2 &y)
return div_ceil (x, y, UNSIGNED);
}
-/* Return X / Y, rouding towards nearest with ties away from zero.
+/* Return X / Y, rounding towards nearest with ties away from zero.
Treat X and Y as having the signedness given by SGN. Indicate
in *OVERFLOW if the result overflows. */
template <typename T1, typename T2>
return quotient;
}
-/* Return X / Y, rouding towards 0. Treat X and Y as having the
+/* Return X / Y, rounding towards 0. Treat X and Y as having the
signedness given by SGN. Store the remainder in *REMAINDER_PTR. */
template <typename T1, typename T2>
inline WI_BINARY_RESULT (T1, T2)
return y;
}
-/* Compute X / Y, rouding towards 0, and return the remainder.
+/* Compute X / Y, rounding towards 0, and return the remainder.
Treat X and Y as having the signedness given by SGN. Indicate
in *OVERFLOW if the division overflows. */
template <typename T1, typename T2>
return remainder;
}
-/* Compute X / Y, rouding towards 0, and return the remainder.
+/* Compute X / Y, rounding towards 0, and return the remainder.
Treat X and Y as signed values. */
template <typename T1, typename T2>
inline WI_BINARY_RESULT (T1, T2)
return mod_trunc (x, y, SIGNED);
}
-/* Compute X / Y, rouding towards 0, and return the remainder.
+/* Compute X / Y, rounding towards 0, and return the remainder.
Treat X and Y as unsigned values. */
template <typename T1, typename T2>
inline WI_BINARY_RESULT (T1, T2)
return mod_trunc (x, y, UNSIGNED);
}
-/* Compute X / Y, rouding towards -inf, and return the remainder.
+/* Compute X / Y, rounding towards -inf, and return the remainder.
Treat X and Y as having the signedness given by SGN. Indicate
in *OVERFLOW if the division overflows. */
template <typename T1, typename T2>
return remainder;
}
-/* Compute X / Y, rouding towards -inf, and return the remainder.
+/* Compute X / Y, rounding towards -inf, and return the remainder.
Treat X and Y as unsigned values. */
/* ??? Why do we have both this and umod_trunc. Aren't they the same? */
template <typename T1, typename T2>
return mod_floor (x, y, UNSIGNED);
}
-/* Compute X / Y, rouding towards +inf, and return the remainder.
+/* Compute X / Y, rounding towards +inf, and return the remainder.
Treat X and Y as having the signedness given by SGN. Indicate
in *OVERFLOW if the division overflows. */
template <typename T1, typename T2>
return remainder;
}
-/* Compute X / Y, rouding towards nearest with ties away from zero,
+/* Compute X / Y, rounding towards nearest with ties away from zero,
and return the remainder. Treat X and Y as having the signedness
given by SGN. Indicate in *OVERFLOW if the division overflows. */
template <typename T1, typename T2>
projects / thirdparty / gcc.git / commitdiff
