if (TREE_CHAIN (list) == 0)
{
-#if 0 /* If something inside inhibited lvalueness, we shoukd not override. */
+#if 0 /* If something inside inhibited lvalueness, we should not override. */
/* Consider (x, y+0), which is not an lvalue since y+0 is not. */
/* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
into the message.
If OFWHAT is null, the component name is stored on the spelling stack.
- If the compoment name is a null string, then LOCAL is omitted entirely. */
+ If the component name is a null string, then LOCAL is omitted entirely. */
void
error_init (format, local, ofwhat)
into the message.
If OFWHAT is null, the component name is stored on the spelling stack.
- If the compoment name is a null string, then LOCAL is omitted entirely. */
+ If the component name is a null string, then LOCAL is omitted entirely. */
void
pedwarn_init (format, local, ofwhat)
return \"subq%.w %2,%0\";
}
/* On everything except the 68000 it is faster to use two
- addqw insttuctions to add a small integer (8 < N <= 16)
+ addqw instructions to add a small integer (8 < N <= 16)
to an address register. Likewise for subqw. */
if (INTVAL (operands[2]) > 8
&& INTVAL (operands[2]) <= 16
return \"subq%.w %1,%0\";
}
/* On everything except the 68000 it is faster to use two
- addqw instuctions to add a small integer (8 < N <= 16)
+ addqw instructions to add a small integer (8 < N <= 16)
to an address register. Likewise for subqw. */
if (INTVAL (operands[1]) > 8
&& INTVAL (operands[1]) <= 16
return \"subq%.w %1,%0\";
}
/* On everything except the 68000 it is faster to use two
- addqw instuctions to add a small integer (8 < N <= 16)
+ addqw instructions to add a small integer (8 < N <= 16)
to an address register. Likewise for subqw. */
if (INTVAL (operands[1]) > 8
&& INTVAL (operands[1]) <= 16
}
/* Achieve greatest use of double memory ops. Either we end up saving
- r30 or we use that slot to align the regsters we do save. */
+ r30 or we use that slot to align the registers we do save. */
if (nregs >= 2 && save_regs[1] && !save_regs[FRAME_POINTER_REGNUM])
sp_size += 4;
goto copy_with_loop;
/* Read and store using two registers, and hide latency
- by defering the stores until three instructions after
+ by deferring the stores until three instructions after
the corresponding load. The last load insn will read
the entire word were the last bytes are, possibly past
the end of the source block, but since loads are aligned,
output_asm_insn ("addib,<,n -4,%2,.+16", operands);
}
- /* Copying loop. Note that the first load is in the anulled delay slot
+ /* Copying loop. Note that the first load is in the annulled delay slot
of addib. Is it OK on PA to have a load in a delay slot, i.e. is a
possible page fault stopped in time? */
output_asm_insn ("ldws,ma 4(0,%1),%3", operands);
output_asm_insn ("addib,=,n 4,%2,.+16", operands);
/* Read the entire word of the source block tail. (Also this
- load is in an anulled delay slot.) */
+ load is in an annulled delay slot.) */
output_asm_insn ("ldw 0(0,%1),%3", operands);
/* Make %0 point at the first byte after the destination block. */
{
rtx op2 = operands[2];
- /* If constant is postive, upper bits zeroed, otherwise unchanged.
+ /* If constant is positive, upper bits zeroed, otherwise unchanged.
Give the assembler a chance to pick the move instruction. */
if (GET_CODE (op2) == CONST_INT)
{
current_sym_nchars = 0;
}
\f
-/* Subtroutine of `dbxout_type'. Output the type fields of TYPE.
+/* Subroutine of `dbxout_type'. Output the type fields of TYPE.
This must be a separate function because anonymous unions require
recursive calls. */
}
}
\f
-/* Subtroutine of `dbxout_type_methods'. Output debug info about the
+/* Subroutine of `dbxout_type_methods'. Output debug info about the
method described DECL. DEBUG_NAME is an encoding of the method's
type signature. ??? We may be able to do without DEBUG_NAME altogether
now. */
#define PENDING_SIBLINGS_INCREMENT 64
/* Non-zero if we are performing our file-scope finalization pass and if
- we should force out Dwarf decsriptions of any and all file-scope
+ we should force out Dwarf descriptions of any and all file-scope
tagged types which are still incomplete types. */
static int finalizing = 0;
#define PENDING_TYPES_INCREMENT 64
-/* Pointer to an artifical RECORD_TYPE which we create in dwarfout_init.
+/* Pointer to an artificial RECORD_TYPE which we create in dwarfout_init.
This is used in a hack to help us get the DIEs describing types of
formal parameters to come *after* all of the DIEs describing the formal
parameters themselves. That's necessary in order to be compatible
- with what the brain-dammaged svr4 SDB debugger requires. */
+ with what the brain-damaged svr4 SDB debugger requires. */
static tree fake_containing_scope;
does. It always makes the TYPE_NAME for each tagged type be either
NULL (signifying an anonymous tagged type) or else a pointer to an
IDENTIFIER_NODE. Obviously, we would like to generate correct Dwarf
- for both C and C++, but given this inconsistancy in the TREE
+ for both C and C++, but given this inconsistency in the TREE
representation of tagged types for C and C++ in the GNU front-ends,
we cannot support both languages correctly unless we introduce some
front-end specific code here, and rms objects to that, so we can
case FILE_TYPE:
output_type (TREE_TYPE (type), containing_scope);
- abort (); /* No way to reprsent these in Dwarf yet! */
+ abort (); /* No way to represent these in Dwarf yet! */
break;
case STRING_TYPE:
if (TREE_EXTERNAL (decl) && !TREE_USED (decl))
return;
- if (TREE_PUBLIC (decl) && ! TREE_EXTERNAL (decl))
+ if (TREE_PUBLIC (decl)
+ && ! TREE_EXTERNAL (decl)
+ && GET_CODE (DECL_RTL (decl)) == MEM)
{
char label[MAX_ARTIFICIAL_LABEL_BYTES];
if (DECL_INITIAL (decl) == NULL)
{
/* Output a .debug_aranges entry for a public variable
- which is tenatively defined in this compilation unit. */
+ which is tentatively defined in this compilation unit. */
fputc ('\n', asm_out_file);
ASM_OUTPUT_PUSH_SECTION (asm_out_file, ARANGES_SECTION);
In order to force the label `..D2' to get aligned to a 4 byte boundary,
the trick used is to insert extra (otherwise useless) padding bytes
- into the (null) DIE that we know must preceed the ..D2 label in the
+ into the (null) DIE that we know must precede the ..D2 label in the
.debug section. The amount of padding required can be anywhere between
0 and 3 bytes. The length word at the start of this DIE (i.e. the one
with the padding) would normally contain the value 4, but now it will
#include <setjmp.h>
#endif
-/* Kludge around the possiblity that <stdio.h> includes <limits.h> */
+/* Kludge around the possibility that <stdio.h> includes <limits.h> */
#ifdef CHAR_BIT
#undef CHAR_BIT
#undef CHAR_MAX
REG must be a hard register in this case.
EXTRA is the amount in bytes of extra space to leave next to this arg.
- This is ignored if an argument block has already been allocted.
+ This is ignored if an argument block has already been allocated.
On a machine that lacks real push insns, ARGS_ADDR is the address of
the bottom of the argument block for this call. We use indexing off there
EXPAND_INITIALIZER is much like EXPAND_SUM except that
it also marks a label as absolutely required (it can't be dead).
- This is used for outputting expressions used in intializers. */
+ This is used for outputting expressions used in initializers. */
rtx
expand_expr (exp, target, tmode, modifier)
target = allocate_dynamic_stack_space (op0, target, BITS_PER_UNIT);
/* Record the new stack level for nonlocal gotos. */
- if (nonlocal_goto_stack_level != 0)
- emit_move_insn (nonlocal_goto_stack_level, stack_pointer_rtx);
+ if (nonlocal_goto_handler_slot != 0)
+ emit_stack_save (SAVE_NONLOCAL, &nonlocal_goto_stack_level, 0);
return target;
case BUILT_IN_FFS:
/* Emit one rtl insn to compare two rtx's. */
extern void emit_cmp_insn ();
-/* Generate rtl to compate two rtx's, will call emit_cmp_insn. */
+/* Generate rtl to compare two rtx's, will call emit_cmp_insn. */
extern rtx compare_from_rtx ();
/* Emit some rtl insns to move data between rtx's, converting machine modes.
fi
fi
-# Fix this Sun file to avoid intefering with stddef.h.
+# Fix this Sun file to avoid interfering with stddef.h.
file=sys/stdtypes.h
if [ -r $file ] && [ ! -r ${LIB}/$file ]; then
cp $file ${LIB}/$file >/dev/null 2>&1 || echo "Can't copy $file"
fi
fi
-# Fix this file to avoid intefering with stddef.h.
+# Fix this file to avoid interfering with stddef.h.
file=sys/types.h
if [ -r $file ] && [ ! -r ${LIB}/$file ]; then
cp $file ${LIB}/$file >/dev/null 2>&1 || echo "Can't copy $file"
BLOCK_NUM (insn) = i;
- /* Don't separare a CALL_INSN from following CLOBBER insns. This is
+ /* Don't separate a CALL_INSN from following CLOBBER insns. This is
a kludge that will go away when each CALL_INSN records its
USE and CLOBBERs. */
/*@@ Fix lossage on folding division of big integers. */
-/*@@ This file should be rewritten to use an arbitary precision
+/*@@ This file should be rewritten to use an arbitrary precision
@@ representation for "struct tree_int_cst" and "struct tree_real_cst".
@@ Perhaps the routines could also be used for bc/dc, and made a lib.
@@ The routines that translate from the ap rep should
}
else { /* full double precision,
with thanks to Don Knuth's
- "Semi-Numericial Algorithms". */
+ "Seminumerical Algorithms". */
#define BASE 256
int quo_est, scale, num_hi_sig, den_hi_sig, quo_hi_sig;
/* Main loop */
for (i = quo_hi_sig; i > 0; i--) {
- /* quess the next quotient digit, quo_est, by dividing the first
+ /* guess the next quotient digit, quo_est, by dividing the first
two remaining dividend digits by the high order quotient digit.
quo_est is never low and is at most 2 high. */
COMPARE_TYPE is the type of the comparison, and LHS and RHS
are the left and right operands of the comparison, respectively.
- If the optimization described above can be done, we return the resuling
+ If the optimization described above can be done, we return the resulting
tree. Otherwise we return zero. */
static tree
return inner;
}
-/* Return non-zero if MASK respresents a mask of SIZE ones in the low-order
+/* Return non-zero if MASK represents a mask of SIZE ones in the low-order
bit positions. */
static int
/* Save the current context for compilation of a nested function.
This is called from language-specific code.
The caller is responsible for saving any language-specific status,
- since this function knows only about language-indepedent variables. */
+ since this function knows only about language-independent variables. */
void
push_function_context ()
if (GET_CODE (x) == SIGN_EXTRACT)
wanted_mode = insn_operand_mode[(int) CODE_FOR_extv][1];
#endif
- /* If we have a narrower mode, we can do someting. */
+ /* If we have a narrower mode, we can do something. */
if (wanted_mode != VOIDmode
&& GET_MODE_SIZE (wanted_mode) < GET_MODE_SIZE (is_mode))
{
int width = INTVAL (XEXP (outerdest, 1));
int pos = INTVAL (XEXP (outerdest, 2));
- /* If we have a narrower mode, we can do someting. */
+ /* If we have a narrower mode, we can do something. */
if (GET_MODE_SIZE (wanted_mode) < GET_MODE_SIZE (is_mode))
{
int offset = pos / BITS_PER_UNIT;
static struct obstack obstack;
/* This is the obstack to build an environment variable to pass to
- collect2 that describes all of the relavant switches of what to
+ collect2 that describes all of the relevant switches of what to
pass the compiler in building the list of pointers to constructors
and destructors. */
%{S*:X} substitutes X if one or more switches whose names with -S are
specified to CC. Note that the tail part of the -S option
(i.e. the part matched by the `*') will be substituted for each
- occurance of %* within X.
+ occurrence of %* within X.
%{S:X} substitutes X, but only if the -S switch was given to CC.
%{!S:X} substitutes X, but only if the -S switch was NOT given to CC.
%{|S:X} like %{S:X}, but if no S switch, substitute `-'.
#endif
/* A vector of options to give to the linker.
- These options are accumlated by %x
+ These options are accumulated by %x
and substituted into the linker command with %X. */
static int n_linker_options;
static char **linker_options;
along with GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
-/* This program handles insn attribues and the DEFINE_DELAY and
+/* This program handles insn attributes and the DEFINE_DELAY and
DEFINE_FUNCTION_UNIT definitions.
It produces a series of functions named `get_attr_...', one for each insn
Finally, for each [DEFINE_DELAY, slot #] pair, we compute an attribute that
tells whether a given insn can be in that delay slot.
- Normal attrbute filling and optimization expands these to contain the
+ Normal attribute filling and optimization expands these to contain the
information needed to handle delay slots. */
static void
make_internal_attr ("*delay_type", condexp, 1);
}
- /* For each delay possibility and delay slot, compute an eligability
- attribute for non-anulled insns and for each type of annulled (annul
+ /* For each delay possibility and delay slot, compute an eligibility
+ attribute for non-annulled insns and for each type of annulled (annul
if true and annul if false). */
for (delay = delays; delay; delay = delay->next)
{
return exp;
}
\f
-/* Similiar to `simplify_and_tree', but for IOR trees. */
+/* Similar to `simplify_and_tree', but for IOR trees. */
static rtx
simplify_or_tree (exp, pterm, insn_code, insn_index)
struct function_unit_op *op;
/* See if we have already seen this function unit. If so, check that
- the multipicity and simultaneity values are the same. If not, make
+ the multiplicity and simultaneity values are the same. If not, make
a structure for this function unit. */
for (unit = units; unit; unit = unit->next)
if (! strcmp (unit->name, XSTR (def, 0)))
the specified insn can be annulled if the branch is true, and likewise
for `eligible_for_annul_false'.
- KIND is a string distingushing these three cases ("delay", "annul_true",
+ KIND is a string distinguishing these three cases ("delay", "annul_true",
or "annul_false"). */
static void
}
/* Now that all functions have been written, write the table describing
- the function units. The name is included for documenation purposes
+ the function units. The name is included for documentation purposes
only. */
printf ("struct function_unit_desc function_units[] = {\n");
We would like to list nodes testing for specific codes before those
that test predicates to avoid unnecessary function calls. Similarly,
- tests for specific modes should preceed nodes that allow any mode.
+ tests for specific modes should precede nodes that allow any mode.
This function returns the merit (with 0 being the best) of inserting
a test involving the specified MODE and CODE after node P. If P is
of the same mode, we also group tests with the same code, followed by a
group that does not test a code.
- Occasionally, we cannot arbitarily reorder the tests so that multiple
+ Occasionally, we cannot arbitrarily reorder the tests so that multiple
sequence of groups as described above are present.
We generate two nested switch statements, the outer statement for
* a way that is compatible with code compiled by the Pyramid Technology
* C compiler.
* As such, it depends strongly on the Pyramid conventions for
- * parameter passing.ct and indepenent implementation.
+ * parameter passing.ct and independent implementation.
* These (somewhat bizarre) parameter-passing conventions are described
* in the ``OSx Operating System Porting Guide''.
*
/* This is just like the default gvarargs.h
- except for differences decribed below. */
+ except for differences described below. */
/* Make this a macro rather than a typedef, so we can undef any other defn. */
#define va_list __va___list
static int *allocno_size;
/* Indexed by (pseudo) reg number, gives the number of another
- lower-numbered pseudo reg which can share a hard reg with this peudo
+ lower-numbered pseudo reg which can share a hard reg with this pseudo
*even if the two pseudos would otherwise appear to conflict*. */
static int *reg_may_share;
try to set a preference. If one of the two is a hard register and the other
is a pseudo-register, mark the preference.
- Note that we are not as agressive as local-alloc in trying to tie a
+ Note that we are not as aggressive as local-alloc in trying to tie a
pseudo-register to a hard register. */
static void
INSN is the conditional branch around the arithmetic. We set:
TEMP is the arithmetic insn.
- TEMP1 is the SET doing the arthmetic.
+ TEMP1 is the SET doing the arithmetic.
TEMP2 is the operand being incremented or decremented.
TEMP3 to the condition being tested.
TEMP4 to the earliest insn used to find the condition. */
It is questionable whether we want this optimization anyways,
since if the user wrote code like this because he/she knew that
- the jump to label1 is taken most of the time, then rewritting
+ the jump to label1 is taken most of the time, then rewriting
this gives slower code. */
/* @@ This should call get_condition to find the values being
compared, instead of looking for a COMPARE insn when HAVE_cc0
{
rtx prev = PREV_INSN (insn);
- /* Don't put a label between a CALL_INSN and USE insns that preceed
+ /* Don't put a label between a CALL_INSN and USE insns that precede
it. */
if (GET_CODE (insn) == CALL_INSN
If the old jump target label (before the dispatch table) becomes unused,
it and the dispatch table may be deleted. In that case, find the insn
- before the jump references that label and delete it and logical sucessors
+ before the jump references that label and delete it and logical successors
too. */
void
break;
case MEM:
- /* If memory modified or either volatile, not eqivalent.
+ /* If memory modified or either volatile, not equivalent.
Else, check address. */
if (modified_mem || MEM_VOLATILE_P (x) || MEM_VOLATILE_P (y))
return 0;
/* This sets the maximum number of quantities we can have. Quantity
numbers start at zero and we can have one for each pseudo plus the
- number of SCRATCHs in the largest block, in the worst case. */
+ number of SCRATCHes in the largest block, in the worst case. */
max_qty = (max_regno - FIRST_PSEUDO_REGISTER) + max_scratch;
/* Allocate vectors of temporary data.
if (GET_CODE (r0) == REG || GET_CODE (r0) == SUBREG)
{
- /* We have two priorities for hard register preferrences.
+ /* We have two priorities for hard register preferences.
If we have a move insn or an insn whose first input can
only be in the same register as the output, give
priority to an equivalence found from that insn. */
\f
/* Compare two quantities' priority for getting real registers.
We give shorter-lived quantities higher priority.
- Quantities with more references are also preferred, as are quanties that
- require multiple registers. This is the identical prioritorization as
+ Quantities with more references are also preferred, as are quantities that
+ require multiple registers. This is the identical prioritization as
done by global-alloc.
We used to give preference to registers with *longer* lives, but using
register int sqty;
/* Determine the numbers and sizes of registers being used. If a subreg
- is present that does not change the entire register, don't conside
+ is present that does not change the entire register, don't consider
this a copy insn. */
while (GET_CODE (usedreg) == SUBREG)
rtx initial_value; /* Value of reg at loop start */
rtx initial_test; /* Test performed on BIV before loop */
struct iv_class *next; /* Links all class structures together */
- rtx init_insn; /* insn which intializes biv, 0 if none. */
+ rtx init_insn; /* insn which initializes biv, 0 if none. */
rtx init_set; /* SET of INIT_INSN, if any. */
unsigned incremented : 1; /* 1 if somewhere incremented/decremented */
unsigned eliminable : 1; /* 1 if plausible candidate for elimination. */
one plus the highest signed number, convert, and add it back.
We only need to check all real modes, since we know we didn't find
- anything with a wider inetger mode. */
+ anything with a wider integer mode. */
if (unsignedp && GET_MODE_BITSIZE (GET_MODE (to)) <= HOST_BITS_PER_INT)
for (fmode = GET_MODE (from); fmode != VOIDmode;
#ifndef UNPROTOIZE
const f_list_chain_item * f_list_chain; /* -> chain of formals lists */
const def_dec_info * definition; /* -> def/dec containing related def */
- char is_static; /* = 0 means visiblilty is "extern" */
+ char is_static; /* = 0 means visibility is "extern" */
char is_implicit; /* != 0 for implicit func decl's */
char written; /* != 0 means written for implicit */
#else /* !defined (UNPROTOIZE) */
const char * formal_names; /* -> to list of names of formals */
- const char * formal_decls; /* -> to string of formal declartions */
+ const char * formal_decls; /* -> to string of formal declarations */
#endif /* !defined (UNPROTOIZE) */
};
return ret_val;
}
-/* Return a pointer to the first occurance of s2 within s1 or NULL if s2
+/* Return a pointer to the first occurrence of s2 within s1 or NULL if s2
does not occur within s1. Assume neither s1 nor s2 are null pointers. */
static const char *
convert and for which we don't issue the usual warnings. */
static int
-file_normally_convertable (const char *path)
+file_normally_convertible (const char *path)
{
char *const dir_name = alloca (strlen (path) + 1);
identifier we just found. We ignore whitespace while hunting. If
the next non-whitespace byte we see is *not* an open left paren,
then we must assume that we have been fooled and we start over
- again accordingly. Note that there is no guarrantee, that even if
+ again accordingly. Note that there is no guarantee, that even if
we do see the open paren, that we are in the right place.
Programmers do the strangest things sometimes! */
#endif /* !defined (UNPROTOIZE) */
/* When we first read in all of the information from the aux_info files
- we saved in it decending line number order, because that was likely to
+ we saved in it descending line number order, because that was likely to
be faster. Now however, we want the chains of def & dec records to
appear in ascending line number order as we get further away from the
file_info record that they hang from. The following line causes all of
of the operand. If we are replacing the operand with a VOIDmode
constant, we lose the information. So try to simplify the operation
in that case. If it fails, substitute in something that we know
- won't be recogized. */
+ won't be recognized. */
if (GET_MODE (to) == VOIDmode
&& (XEXP (x, 0) == from
|| (GET_CODE (XEXP (x, 0)) == REG && GET_CODE (from) == REG
wanted_mode = insn_operand_mode[(int) CODE_FOR_extv][1];
#endif
- /* If we have a narrower mode, we can do someting. */
+ /* If we have a narrower mode, we can do something. */
if (wanted_mode != VOIDmode
&& GET_MODE_SIZE (wanted_mode) < GET_MODE_SIZE (is_mode))
{
The main use of this function is as a predicate in match_operand
expressions in the machine description.
- For an explaination of this function's behavior for registers of
+ For an explanation of this function's behavior for registers of
class NO_REGS, see the comment for `register_operand'. */
int
if (block + 1 != blocks)
abort ();
- /* generate all label references to the correspondending jump insn */
+ /* generate all label references to the corresponding jump insn */
for (block = 0; block < blocks; block++)
{
insn = block_end[block];
\f
/* Substitute hard regnums for any stack regs in INSN, which has
N_INPUTS inputs and N_OUTPUTS outputs. REGSTACK is the stack info
- before the insn, and is updated with changes made here. CONSTAINTS is
+ before the insn, and is updated with changes made here. CONSTRAINTS is
an array of the constraint strings used in the asm statement.
OPERANDS is an array of the operands, and OPERANDS_LOC is a
parallel array of where the operands were found. The output operands
- all preceed the input operands.
+ all precede the input operands.
There are several requirements and assumptions about the use of
stack-like regs in asm statements. These rules are enforced by
static char *prefclass;
/* preferred_or_nothing[R] is nonzero if we should put pseudo number R
- in memory if we can't get its perferred class.
+ in memory if we can't get its preferred class.
This is available after `regclass' is run. */
static char *preferred_or_nothing;
if (reload_in[output_reload] != 0)
return;
- /* If this reload is for an earlyclobber operand, we can't do anyting. */
+ /* If this reload is for an earlyclobber operand, we can't do anything. */
for (i = 0; i < n_earlyclobbers; i++)
if (reload_out[output_reload] == reload_earlyclobbers[i])
RTX_UNCHANGING_P (recog_operand[i])
= RTX_UNCHANGING_P (regno_reg_rtx[regno]);
find_reloads_address (GET_MODE (recog_operand[i]),
- recog_operand_loc[i],
+ /* This is no longer a pseudo register. To prevent later code
XEXP (recog_operand[i], 0),
&XEXP (recog_operand[i], 0),
recog_operand[i], ind_levels);
/* Scan X for memory references and scan the addresses for reloading.
Also checks for references to "constant" regs that we want to eliminate
and replaces them with the values they stand for.
- We may alter X descructively if it contains a reference to such.
+ We may alter X destructively if it contains a reference to such.
If X is just a constant reg, we return the equivalent value
instead of X.
if (ep->to_rtx == SET_DEST (x)
&& SET_DEST (x) != frame_pointer_rtx)
{
- /* If it is being incrememented, adjust the offset. Otherwise,
+ /* If it is being incremented, adjust the offset. Otherwise,
this elimination can't be done. */
rtx src = SET_SRC (x);
optimization. It should be the last pass to run before peephole.
It serves primarily to fill delay slots of insns, typically branch
and call insns. Other insns typically involve more complicated
- interractions of data dependencies and resource constraints, and
+ interactions of data dependencies and resource constraints, and
are better handled by scheduling before register allocation (by the
function `schedule_insns').
/* Points to the label before the end of the function. */
static rtx end_of_function_label;
-/* This structure is used to record livness information at the targets or
+/* This structure is used to record liveness information at the targets or
fallthrough insns of branches. We will most likely need the information
at targets again, so save them in a hash table rather than recomputing them
each time. */
}
}
- /* ... fall through to other INSN procesing ... */
+ /* ... fall through to other INSN processing ... */
case INSN:
case JUMP_INSN:
We never mark the insn as modifying the condition code unless it explicitly
SETs CC0 even though this is not totally correct. The reason for this is
- that we require a SET of CC0 to immediately preceed the reference to CC0.
+ that we require a SET of CC0 to immediately precede the reference to CC0.
So if some other insn sets CC0 as a side-effect, we know it cannot affect
our computation and thus may be placed in a delay slot. */
1. When a conditional branch skips over only one instruction,
use an annulling branch and put that insn in the delay slot.
- Use either a branch that annulls when the condition if true or
- invert the test with a branch that annulls when the condition is
+ Use either a branch that annuls when the condition if true or
+ invert the test with a branch that annuls when the condition is
false. This saves insns, since otherwise we must copy an insn
from the L1 target.
/* If the last insn in the delay slot sets CC0 for some insn,
various code assumes that it is in a delay slot. We could
put it back where it belonged and delete the register notes,
- but it doesn't seem worhwhile in this uncommon case. */
+ but it doesn't seem worthwhile in this uncommon case. */
&& ! find_reg_note (XVECEXP (pat, 0, XVECLEN (pat, 0) - 1),
REG_CC_USER, 0)
#endif
/* Indexed by rtx code, gives a sequence of operand-types for
rtx's of that code. The sequence is a C string in which
- each charcter describes one operand. */
+ each character describes one operand. */
char *rtx_format[] = {
/* "*" undefined.
DEF_RTL_EXPR(INSN_LIST, "insn_list", "ue", 'x')
/* ----------------------------------------------------------------------
- Expression types for machine descripions.
+ Expression types for machine descriptions.
These do not appear in actual rtl code in the compiler.
---------------------------------------------------------------------- */
or inside an expression. */
DEF_RTL_EXPR(UNSPEC, "unspec", "Ei", 'x')
-/* Similiar, but a volatile operation and one which may trap. */
+/* Similar, but a volatile operation and one which may trap. */
DEF_RTL_EXPR(UNSPEC_VOLATILE, "unspec_volatile", "Ei", 'x')
/* Vector of addresses, stored as full words. */
#include "rtl.def" /* rtl expressions are documented here */
#undef DEF_RTL_EXPR
- LAST_AND_UNUSED_RTX_CODE}; /* A convienent way to get a value for
+ LAST_AND_UNUSED_RTX_CODE}; /* A convenient way to get a value for
NUM_RTX_CODE.
- Assumes default enum value assignement. */
+ Assumes default enum value assignment. */
#define NUM_RTX_CODE ((int)LAST_AND_UNUSED_RTX_CODE)
/* The cast here, saves many elsewhere. */
#define INSN_ANNULLED_BRANCH_P(INSN) ((INSN)->unchanging)
/* 1 if insn is in a delay slot and is from the target of the branch. If
- the branch insn has INSN_ANULLED_BRANCH_P set, this insn should only be
+ the branch insn has INSN_ANNULLED_BRANCH_P set, this insn should only be
executed if the branch is taken. For annulled branches with this bit
clear, the insn should be executed only if the branch is not taken. */
#define INSN_FROM_TARGET_P(INSN) ((INSN)->in_struct)
/* Regset telling whether a given register is live after the insn currently
being scheduled. Before processing an insn, this is equal to bb_live_regs
- above. This is used so that we can find regsiters that are newly born/dead
+ above. This is used so that we can find registers that are newly born/dead
after processing an insn. */
static regset old_live_regs;
with addresses involving static variables.
(2) static variables with different addresses cannot conflict.
- Nice to notice that varying addresses cannot confict with fp if no
+ Nice to notice that varying addresses cannot conflict with fp if no
local variables had their addresses taken, but that's too hard now. */
static int
if (GET_CODE (x) == PLUS)
{
- /* The fact that X is canonnicallized means that this
- PLUS rtx is canonnicallized. */
+ /* The fact that X is canonicalized means that this
+ PLUS rtx is canonicalized. */
rtx x0 = XEXP (x, 0);
rtx x1 = XEXP (x, 1);
if (GET_CODE (y) == PLUS)
{
- /* The fact that Y is canonnicallized means that this
- PLUS rtx is canonnicallized. */
+ /* The fact that Y is canonicalized means that this
+ PLUS rtx is canonicalized. */
rtx y0 = XEXP (y, 0);
rtx y1 = XEXP (y, 1);
}
else if (GET_CODE (y) == PLUS)
{
- /* The fact that Y is canonnicallized means that this
- PLUS rtx is canonnicallized. */
+ /* The fact that Y is canonicalized means that this
+ PLUS rtx is canonicalized. */
rtx y0 = XEXP (y, 0);
rtx y1 = XEXP (y, 1);
/* Flush all pending reads and writes to prevent the pending lists
from getting any larger. Insn scheduling runs too slowly when
these lists get long. The number 32 was chosen because it
- seems like a resonable number. When compiling GCC with itself,
+ seems like a reasonable number. When compiling GCC with itself,
this flush occurs 8 times for sparc, and 10 times for m88k using
the number 32. */
flush_pending_lists (insn);
prev = PREV_INSN (insn);
if (LINE_NOTE (note))
{
- /* Re-use the orignal line-number note. */
+ /* Re-use the original line-number note. */
LINE_NOTE (note) = 0;
PREV_INSN (note) = prev;
NEXT_INSN (prev) = note;
/* Sometimes need to convert REG_UNUSED notes to REG_DEAD
notes. */
- /* ??? This won't handle mutiple word registers correctly,
+ /* ??? This won't handle multiple word registers correctly,
but should be good enough for now. */
if (REG_NOTE_KIND (note) == REG_UNUSED
&& ! dead_or_set_p (insn, XEXP (note, 0)))
4. All structure .defs are emitted before the typedefs that refer to them.
5. All top level static and external variable definitions are moved to the
- end of file with all top level statics occuring first before externs.
+ end of file with all top level statics occurring first before externs.
6. All undefined references are at the end of the file.
*/
/* Take an ordered list of case nodes
and transform them into a near optimal binary tree,
- on the assumtion that any target code selection value is as
+ on the assumption that any target code selection value is as
likely as any other.
The transformation is performed by splitting the ordered
TIMEVAR (symout_time, sdbout_toplevel_data (decl));
#endif /* SDB_DEBUGGING_INFO */
#ifdef DWARF_DEBUGGING_INFO
- /* Output DWARF information for file-scope tenative data object
+ /* Output DWARF information for file-scope tentative data object
declarations, file-scope (extern) function declarations (which
had no corresponding body) and file-scope tagged type declarations
and definitions which have not yet been forced out. */
enum tree_code {
#include "tree.def"
- LAST_AND_UNUSED_TREE_CODE /* A convienent way to get a value for
+ LAST_AND_UNUSED_TREE_CODE /* A convenient way to get a value for
NUM_TREE_CODE. */
};
/* In a VAR_DECL or FUNCTION_DECL,
nonzero means name is to be accessible from outside this module.
In an identifier node, nonzero means a external declaration
- accesible from outside this module was previously seen
+ accessible from outside this module was previously seen
for this name in an inner scope. */
#define TREE_PUBLIC(NODE) ((NODE)->common.public_flag)
- On traditional architectures, unrolling a non-constant bound loop
is a win if there is a giv whose only use is in memory addresses, the
- memory addresses can be split, and hence giv incremenets can be
+ memory addresses can be split, and hence giv increments can be
eliminated.
- It is also a win if the loop is executed many times, and preconditioning
can be performed for the loop.
/* Try to unroll one loop and split induction variables in the loop.
The loop is described by the arguments LOOP_END, INSN_COUNT, and
- LOOP_START. END_INSERT_BEDFORE indicates where insns should be added
+ LOOP_START. END_INSERT_BEFORE indicates where insns should be added
which need to be executed when the loop falls through. STRENGTH_REDUCTION_P
indicates whether information generated in the strength reduction pass
is available.
It is safe to do this here, since the extra registers created by the
preconditioning code and find_splittable_regs will never be used
- to accees the splittable_regs[] and addr_combined_regs[] arrays. */
+ to access the splittable_regs[] and addr_combined_regs[] arrays. */
splittable_regs = (rtx *) alloca (maxregnum * sizeof (rtx));
bzero (splittable_regs, maxregnum * sizeof (rtx));
if (exit_label)
emit_label_after (exit_label, loop_end);
- /* If debugging, we must replicate the tree nodes corresponsing to the blocks
+ /* If debugging, we must replicate the tree nodes corresponding to the blocks
inside the loop, so that the original one to one mapping will remain. */
if (write_symbols != NO_DEBUG)
/* Must ensure that final_value is invariant, so call invariant_p to
check. Before doing so, must check regno against max_reg_before_loop
- to make sure that the register is in the range convered by invariant_p.
+ to make sure that the register is in the range covered by invariant_p.
If it isn't, then it is most likely a biv/giv which by definition are
not invariant. */
if ((GET_CODE (loop_final_value) == REG
is a backward branch in that range that branches to somewhere between
LOOP_START and INSN. Returns 0 otherwise. */
-/* ??? This is quadratic algorithm. Could be rewriten to be linear.
+/* ??? This is quadratic algorithm. Could be rewritten to be linear.
In practice, this is not a problem, because this function is seldom called,
and uses a negligible amount of CPU time on average. */
/* Calculate the number of loop iterations. Returns the exact number of loop
- iterations if it can be calculated, otherwise retusns zero. */
+ iterations if it can be calculated, otherwise returns zero. */
unsigned long
loop_iterations (loop_start, loop_end)
be addresses with the same base but different constant offsets.
Final value must be invariant for this to work.
- To do this, need someway to find the values of registers which are
+ To do this, need some way to find the values of registers which are
invariant. */
/* Final_larger is 1 if final larger, 0 if they are equal, otherwise -1. */
declaration. When something like ".stabx "aa:S-2",aa,133,0" is emitted
and `aa' hasn't been output yet, the assembler generates a stab entry with
a value of zero, in addition to creating an unnecessary external entry
- for `aa'. Hence, we must pospone dbxout_symbol to here at the end. */
+ for `aa'. Hence, we must postpone dbxout_symbol to here at the end. */
/* File-scope global variables are output here. */
if (write_symbols == XCOFF_DEBUG && top_level)
/* We need to pass the correct function size to .function, otherwise,
the xas assembler can't figure out the correct size for the function
aux entry. So, we emit a label after the last instruction which can
- be used by the .function psuedo op to calculate the function size. */
+ be used by the .function pseudo op to calculate the function size. */
char *fname = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
if (*fname == '*')
git://gcc.gnu.org / gcc.git / commitdiff