* et-forest.c: Fix comment typos.
* et-forest.h: Likewise.
* except.c: Likewise.
* expr.c: Likewise.
* flags.h: Likewise.
* flow.c: Likewise.
* gcc.c: Likewise.
* gcse.c: Likewise.
* genattrtab.c: Likewise.
* genautomata.c: Likewise.
* gengtype.c: Likewise.
* genrecog.c: Likewise.
* global.c: Likewise.
* gthr-rtems.h: Likewise.
From-SVN: r61443
+2003-01-17 Kazu Hirata <kazu@cs.umass.edu>
+
+ * et-forest.c: Fix comment typos.
+ * et-forest.h: Likewise.
+ * except.c: Likewise.
+ * expr.c: Likewise.
+ * flags.h: Likewise.
+ * flow.c: Likewise.
+ * gcc.c: Likewise.
+ * gcse.c: Likewise.
+ * genattrtab.c: Likewise.
+ * genautomata.c: Likewise.
+ * gengtype.c: Likewise.
+ * genrecog.c: Likewise.
+ * global.c: Likewise.
+ * gthr-rtems.h: Likewise.
+
2003-01-17 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
* i386.c (x86_function_profiler): Fix format specifier.
}
-/* Operation splay for splay tree structure representing ocuurences. */
+/* Operation splay for splay tree structure representing occurrences. */
static et_forest_occurrence_t
splay (node)
et_forest_occurrence_t node;
return node;
}
-/* Remove all occurences of the given node before destroying the node. */
+/* Remove all occurrences of the given node before destroying the node. */
static void
remove_all_occurrences (forest, forest_node)
et_forest_t forest;
prev_node = splay (find_rightmost_node (first->left));
next_node = splay (find_leftmost_node (last->right));
- /* prev_node and next_node are consecutive occurencies
+ /* prev_node and next_node are consecutive occurrences
of the same node. */
if (prev_node->next != next_node)
abort ();
return node;
}
-/* Add new edge to the tree, return 1 if succesfull.
+/* Add new edge to the tree, return 1 if successful.
0 indicates that creation of the edge will close the cycle in graph. */
int
et_forest_add_edge (forest, parent_node, child_node)
pool_free (forest->node_pool, node);
}
-/* Remove edge from the tree, return 1 if sucesfull,
+/* Remove edge from the tree, return 1 if successful,
0 indicates nonexisting edge. */
int
et_forest_remove_edge (forest, parent_node, child_node)
et_forest_occurrence_t occ = node->first, stop = node->last, occ1;
/* Parent is the rightmost node of the left successor.
- Look for all occurences having no right succesor
+ Look for all occurrences having no right successor
and lookup the sons. */
while (occ != stop)
{
/* This package implements ET forest data structure. Each tree in
the structure maintains a tree structure and offers logarithmic time
for tree operations (insertion and removal of nodes and edges) and
- poly-logarithmic time for nearest common ancesto.
+ poly-logarithmic time for nearest common ancestor.
ET tree strores its structue as a sequence of symbols obtained
by dfs(root)
return RNL_MAYBE_CAUGHT;
case ERT_CATCH:
- /* Catch regions are handled by their controling try region. */
+ /* Catch regions are handled by their controlling try region. */
return RNL_NOT_CAUGHT;
case ERT_MUST_NOT_THROW:
#ifdef MAX_INTEGER_COMPUTATION_MODE
/* Only check stuff here if the mode we want is different from the mode
- of the expression; if it's the same, check_max_integer_computiation_mode
+ of the expression; if it's the same, check_max_integer_computation_mode
will handle it. Do we really need to check this stuff at all? */
if (target
/* Perform a peephole pass before sched2. */
extern int flag_peephole2;
-/* Try to guess branch probablities. */
+/* Try to guess branch probabilities. */
extern int flag_guess_branch_prob;
/* -fcheck-bounds causes gcc to generate array bounds checks.
(MODE_HAS_INFINITIES (MODE) && !flag_finite_math_only)
/* Like HONOR_NANS, but true if the given mode distinguishes between
- postive and negative zero, and the sign of zero is important. */
+ positive and negative zero, and the sign of zero is important. */
#define HONOR_SIGNED_ZEROS(MODE) \
(MODE_HAS_SIGNED_ZEROS (MODE) && !flag_unsafe_math_optimizations)
/* Nonzero if the value of CC0 is live. */
int cc0_live;
- /* Flags controling the set of information propagate_block collects. */
+ /* Flags controlling the set of information propagate_block collects. */
int flags;
};
}
/* Similarly if INSN contains a LIBCALL note, remove the
- dnagling REG_RETVAL note. */
+ dangling REG_RETVAL note. */
note = find_reg_note (insn, REG_LIBCALL, NULL_RTX);
if (note)
{
});
}
-/* Print a human-reaable representation of R on the standard error
+/* Print a human-readable representation of R on the standard error
stream. This function is designed to be used from within the
debugger. */
PREFIX_PRIORITY_LAST
};
-/* Add an entry for PREFIX in PLIST. The PLIST is kept in assending
+/* Add an entry for PREFIX in PLIST. The PLIST is kept in ascending
order according to PRIORITY. Within each PRIORITY, new entries are
appended.
}
#ifdef ENABLE_VALGRIND_CHECKING
- /* Run the each command through valgrind. To simplifiy prepending the
+ /* Run the each command through valgrind. To simplify prepending the
path to valgrind and the option "-q" (for quiet operation unless
something triggers), we allocate a separate argv array. */
/* Scan the function and record each set of each pseudo-register.
This is called once, at the start of the gcse pass. See the comments for
- `reg_set_table' for further documenation. */
+ `reg_set_table' for further documentation. */
static void
compute_sets (f)
const char *fmt;
/* Used to turn recursion into iteration. We can't rely on GCC's
- tail-recursion eliminatio since we need to keep accumulating values
+ tail-recursion elimination since we need to keep accumulating values
in HASH. */
if (x == 0)
/* REG_EQUAL may get simplified into register.
We don't allow that. Remove that note. This code ought
- not to hapen, because previous code ought to syntetize
+ not to happen, because previous code ought to synthesize
reg-reg move, but be on the safe side. */
if (note && REG_P (XEXP (note, 0)))
remove_note (insn, note);
/* Subroutine of cprop_insn that tries to propagate constants into
JUMP_INSNS. JUMP must be a conditional jump. If SETCC is non-NULL
- it is the instruction that immediately preceeds JUMP, and must be a
+ it is the instruction that immediately precedes JUMP, and must be a
single SET of a register. FROM is what we will try to replace,
SRC is the constant we will try to substitute for it. Returns nonzero
if a change was made. */
if (newcnst && constprop_register (insn, x, newcnst, alter_jumps))
{
/* If we find a case where we can't fix the retval REG_EQUAL notes
- match the new register, we either have to abandom this replacement
+ match the new register, we either have to abandon this replacement
or fix delete_trivially_dead_insns to preserve the setting insn,
or make it delete the REG_EUAQL note, and fix up all passes that
require the REG_EQUAL note there. */
}
/* If we bypassed any register setting insns, we inserted a
- copy on the redirected edge. These need to be commited. */
+ copy on the redirected edge. These need to be committed. */
if (changed)
commit_edge_insertions();
/* Keeping in mind SMALL_REGISTER_CLASSES and parameters in registers,
we search backward and place the instructions before the first
parameter is loaded. Do this for everyone for consistency and a
- presumtion that we'll get better code elsewhere as well.
+ presumption that we'll get better code elsewhere as well.
It should always be the case that we can put these instructions
anywhere in the basic block with performing PRE optimizations.
}
/* Now compute global properties based on the local properties. This
- is a classic global availablity algorithm. */
+ is a classic global availability algorithm. */
compute_available (nonnull_local, nonnull_killed,
nonnull_avout, nonnull_avin);
reference of that form, then we know the register can not have the value
zero at the conditional branch.
- So we merely need to compute the local properies and propagate that data
+ So we merely need to compute the local properties and propagate that data
around the cfg, then optimize where possible.
We run this pass two times. Once before CSE, then again after CSE. This
Note that if registers are changed ANYWHERE in the block, we'll
decide we can't move it, regardless of whether it changed above
or below the store. This could be improved by checking the register
- operands while lookinng for aliasing in each insn. */
+ operands while looking for aliasing in each insn. */
if (!store_ops_ok (XEXP (x, 0), bb))
return 1;
Note that if registers are changed ANYWHERE in the block, we'll
decide we can't move it, regardless of whether it changed above
or below the store. This could be improved by checking the register
- operands while lookinng for aliasing in each insn. */
+ operands while looking for aliasing in each insn. */
if (!store_ops_ok (XEXP (x, 0), bb))
return 1;
if (!store_killed_after (ptr->pattern, insn, bb))
{
- /* If we've already seen an availale expression in this block,
+ /* If we've already seen an available expression in this block,
we can delete the one we saw already (It occurs earlier in
the block), and replace it with this one). We'll copy the
old SRC expression to an unused register in case there
Load in the middle here if we push the store down. It happens in
gcc.c-torture/execute/960311-1.c with -O3
If we always kill it in this case, we'll sometimes do
- uneccessary work, but it shouldn't actually hurt anything.
+ unnecessary work, but it shouldn't actually hurt anything.
if (!TEST_BIT (ae_gen[b], ptr->index)). */
SET_BIT (ae_kill[b->index], ptr->index);
}
}
}
-/* Insert an instruction at the begining of a basic block, and update
+/* Insert an instruction at the beginning of a basic block, and update
the BLOCK_HEAD if needed. */
static void
every possible C.
The issue delay function for C is op->issue_exp and is used to
- write the `<name>_unit_conflict_cost' function. Symbolicly
+ write the `<name>_unit_conflict_cost' function. Symbolically
this is "ISSUE-DELAY (E,C)".
The pipeline delay results form the FIFO constraint on the
\f
/* Simplify test expression and use temporary obstack in order to avoid
- memory bloat. Use ATTR_IND_SIMPLIFIED to avoid unnecesary simplifications
- and avoid unnecesary copying if possible. */
+ memory bloat. Use ATTR_IND_SIMPLIFIED to avoid unnecessary simplifications
+ and avoid unnecessary copying if possible. */
static rtx
simplify_test_exp_in_temp (exp, insn_code, insn_index)
following:
1. New operator `|' (alternative) is permitted in functional unit
- reservation which can be treated deterministicly and
- non-deterministicly.
+ reservation which can be treated deterministically and
+ non-deterministically.
2. Possibility of usage of nondeterministic automata too.
of automaton insn or which is part of NDFA. */
struct alt_state
{
- /* The following field is a determinist state which characterizes
+ /* The following field is a deterministic state which characterizes
unit reservations of the instruction. */
state_t state;
/* The following field refers to the next state which characterizes
int important_p;
};
-/* The folowing describes an automaton for PHR. */
+/* The following describes an automaton for PHR. */
struct automaton
{
/* The following field value is the list of insn declarations for
/* Given a string and a separator, return the number of separated
elements in it, taking parentheses into account if PAR_FLAG has
- nonzero value. Return 0 for the null string, -1 if parantheses is
+ nonzero value. Return 0 for the null string, -1 if parentheses is
not balanced. */
static int
n_sep_els (s, sep, par_flag)
/* The function sets up RESULT bits by bits of OPERAND shifted on one
cpu cycle. The remaining bits of OPERAND (representing the last
- cycle unit reservations) are not chenged. */
+ cycle unit reservations) are not changed. */
static void
reserv_sets_shift (result, operand)
reserv_sets_t result;
return regexp;
}
-/* The function applys all transformations for reservations of all
+/* The function applies all transformations for reservations of all
insn declarations. */
static void
transform_insn_regexps ()
advance' arcs -- see comment below. */
abort ();
else if (state->longest_path_length != UNDEFINED_LONGEST_PATH_LENGTH)
- /* We alreday visited the state. */
+ /* We already visited the state. */
return state->longest_path_length;
result = 0;
}
-/* The function outputs switch cases for insn reseravtions using
+/* The function outputs switch cases for insn reservations using
function *output_automata_list_code. */
static void
output_insn_code_cases (output_automata_list_code)
}
/* Create a union for YYSTYPE, as yacc would do it, given a fieldlist FIELDS
- and information about the correspondance between token types and fields
+ and information about the correspondence between token types and fields
in TYPEINFO. POS is used for error messages. */
void
static int insn_name_ptr_size = 0;
/* A listhead of decision trees. The alternatives to a node are kept
- in a doublely-linked list so we can easily add nodes to the proper
+ in a doubly-linked list so we can easily add nodes to the proper
place when merging. */
struct decision_head
}
else
{
- /* None of the other tests are ameanable. */
+ /* None of the other tests are amenable. */
return p;
}
}
2. Y is live at some instruction on the path that
evaluates X.
- 3. Either X or Y is not evaluted on the path to P
+ 3. Either X or Y is not evaluated on the path to P
(ie it is used uninitialized) and thus the
conflict can be ignored.
-/* RTEMS threads compatibily routines for libgcc2 and libobjc.
+/* RTEMS threads compatibility routines for libgcc2 and libobjc.
by: Rosimildo da Silva( rdasilva@connecttel.com ) */
/* Compile this one with gcc. */
/* Copyright (C) 1997, 1999, 2000, 2002 Free Software Foundation, Inc.
#define __GTHREAD_ONCE_INIT 0
#define __GTHREAD_MUTEX_INIT_FUNCTION rtems_gxx_mutex_init
-/* avoid depedency on rtems specific headers */
+/* Avoid dependency on rtems specific headers. */
typedef void *__gthread_key_t;
typedef int __gthread_once_t;
typedef void *__gthread_mutex_t;
projects / gcc.git / commitdiff