* bt-load.c: Fix comment typos.
* c-incpath.c: Likewise.
* cfg.c: Likewise.
* cfgcleanup.c: Likewise.
* cfgloop.h: Likewise.
* cfgloopmanip.c: Likewise.
* cfgrtl.c: Likewise.
* diagnostic.h: Likewise.
* dwarfout.c: Likewise.
* emit-rtl.c: Likewise.
* et-forest.c: Likewise.
* et-forest.h: Likewise.
* expr.c: Likewise.
* gcse.c: Likewise.
* genattr.c: Likewise.
* jump.c: Likewise.
* langhooks.h: Likewise.
* local-alloc.c: Likewise.
* loop-unroll.c: Likewise.
* loop-unswitch.c: Likewise.
* ra-build.c: Likewise.
* regclass.c: Likewise.
* regmove.c: Likewise.
* rtl.def: Likewise.
* rtlanal.c: Likewise.
* sched-ebb.c: Likewise.
* sched-rgn.c: Likewise.
* simplify-rtx.c: Likewise.
* ssa.c: Likewise.
* tracer.c: Likewise.
* tree.c: Likewise.
From-SVN: r68975
+2003-07-05 Kazu Hirata <kazu@cs.umass.edu>
+
+ * bt-load.c: Fix comment typos.
+ * c-incpath.c: Likewise.
+ * cfg.c: Likewise.
+ * cfgcleanup.c: Likewise.
+ * cfgloop.h: Likewise.
+ * cfgloopmanip.c: Likewise.
+ * cfgrtl.c: Likewise.
+ * diagnostic.h: Likewise.
+ * dwarfout.c: Likewise.
+ * emit-rtl.c: Likewise.
+ * et-forest.c: Likewise.
+ * et-forest.h: Likewise.
+ * expr.c: Likewise.
+ * gcse.c: Likewise.
+ * genattr.c: Likewise.
+ * jump.c: Likewise.
+ * langhooks.h: Likewise.
+ * local-alloc.c: Likewise.
+ * loop-unroll.c: Likewise.
+ * loop-unswitch.c: Likewise.
+ * ra-build.c: Likewise.
+ * regclass.c: Likewise.
+ * regmove.c: Likewise.
+ * rtl.def: Likewise.
+ * rtlanal.c: Likewise.
+ * sched-ebb.c: Likewise.
+ * sched-rgn.c: Likewise.
+ * simplify-rtx.c: Likewise.
+ * ssa.c: Likewise.
+ * tracer.c: Likewise.
+ * tree.c: Likewise.
+
2003-07-05 Zack Weinberg <zack@codesourcery.com>
* cppcharset.c: Use the correct return type for the fallback iconv
MIN_COST is the lower bound on the cost of the DEF after migration.
If we migrate DEF so that its cost falls below MIN_COST,
then we do not attempt to migrate further. The idea is that
- we migrate defintions in a priority order based on their cost,
+ we migrate definitions in a priority order based on their cost,
when the cost of this definition falls below MIN_COST, then
there is another definition with cost == MIN_COST which now
has a higher priority than this definition.
if (!tmp)
{
- /* Dupicate of something earlier in the same chain? */
+ /* Duplicate of something earlier in the same chain? */
reason = REASON_DUP;
for (tmp = head; tmp != cur; tmp = tmp->next)
if (INO_T_EQ (cur->ino, tmp->ino) && cur->dev == tmp->dev)
02111-1307, USA. */
/* This file contains low level functions to manipulate the CFG and
- analyze it. All other modules should not transform the datastructure
+ analyze it. All other modules should not transform the data structure
directly and use abstraction instead. The file is supposed to be
ordered bottom-up and should not contain any code dependent on a
particular intermediate language (RTL or trees).
It may be good idea to return basic block before C in the case
C has been moved after B and originally appeared earlier in the
- insn seqeunce, but we have no infromation available about the
+ insn sequence, but we have no information available about the
relative ordering of these two. Hopefully it is not too common. */
static basic_block
extern void flow_loop_free (struct loop *);
void mark_irreducible_loops (struct loops *);
-/* Loop datastructure manipulation/querying. */
+/* Loop data structure manipulation/querying. */
extern void flow_loop_tree_node_add (struct loop *, struct loop *);
extern void flow_loop_tree_node_remove (struct loop *);
extern bool flow_loop_outside_edge_p (const struct loop *, edge);
his placement no longer has to be correct, and iteratively fix placement of
its predecessors that may change if placement of FROM changed. Also fix
placement of subloops of FROM->loop_father, that might also be altered due
- to this change; the condition for them is simmilar, except that instead of
+ to this change; the condition for them is similar, except that instead of
successors we consider edges coming out of the loops. */
static void
fix_bb_placements (struct loops *loops, basic_block from)
make_single_succ_edge (bb, edge_in->dest, EDGE_FALLTHRU);
- /* For non-fallthry edges, we must adjust the predecessor's
+ /* For non-fallthru edges, we must adjust the predecessor's
jump instruction to target our new block. */
if ((edge_in->flags & EDGE_FALLTHRU) == 0)
{
int err_no; /* for %m */
} text_info;
-/* Contants used to discriminate diagnostics. */
+/* Constants used to discriminate diagnostics. */
typedef enum
{
#define DEFINE_DIAGNOSTIC_KIND(K, M) K,
/* Given a tree node describing an array bound (either lower or upper)
output a representation for that bound. DIM_NUM is used for
- multi-dimensional arrays and U_OR_L disgnates upper or lower
+ multi-dimensional arrays and U_OR_L designates upper or lower
bound. */
static void
if (!x)
return;
- /* For register, we maitain the reverse information too. */
+ /* For register, we maintain the reverse information too. */
if (GET_CODE (x) == REG)
REG_ATTRS (x) = get_reg_attrs (t, 0);
else if (GET_CODE (x) == SUBREG)
new = simplify_gen_binary (PLUS, Pmode, addr, offset);
/* At this point we don't know _why_ the address is invalid. It
- could have secondary memory refereces, multiplies or anything.
+ could have secondary memory references, multiplies or anything.
However, if we did go and rearrange things, we can wind up not
being able to recognize the magic around pic_offset_table_rtx.
-/* ET-trees datastructure implementation.
+/* ET-trees data structure implementation.
Contributed by Pavel Nejedly
Copyright (C) 2002, 2003 Free Software Foundation, Inc.
for tree operations (insertion and removal of nodes and edges) and
poly-logarithmic time for nearest common ancestor.
- ET tree strores its structue as a sequence of symbols obtained
+ ET tree stores its structue as a sequence of symbols obtained
by dfs(root)
dfs (node)
{
/* C++ can generate ?: expressions with a throw expression in one
branch and an rvalue in the other. Here, we resolve attempts to
- store the throw expression's nonexistant result. */
+ store the throw expression's nonexistent result. */
if (want_value)
abort ();
expand_expr (exp, const0_rtx, VOIDmode, 0);
pat_end = NEXT_INSN (pat_end);
/* If the last insn is a jump, insert EXPR in front [taking care to
- handle cc0, etc. properly]. Similary we need to care trapping
+ handle cc0, etc. properly]. Similarly we need to care trapping
instructions in presence of non-call exceptions. */
if (GET_CODE (insn) == JUMP_INSN
printf ("#define BLOCKAGE_BITS %d\n", i + 1);
/* INSN_QUEUE_SIZE is a power of two larger than MAX_BLOCKAGE and
- MAX_READY_COST. This is the longest time an isnsn may be queued. */
+ MAX_READY_COST. This is the longest time an insn may be queued. */
i = MAX (blockage->max, ready_cost->max);
for (q_size = 1; q_size <= i; q_size <<= 1)
;
case NE:
case EQ:
/* It is always safe to reverse EQ and NE, even for the floating
- point. Similary the unsigned comparisons are never used for
+ point. Similarly the unsigned comparisons are never used for
floating point so we can reverse them in the default way. */
return reverse_condition (code);
case ORDERED:
/* Handle the switch CODE, which has real type enum opt_code from
options.h. If the switch takes an argument, it is passed in ARG
- which points to permanent storage. The handler is resonsible for
+ which points to permanent storage. The handler is responsible for
checking whether ARG is NULL, which indicates that no argument
was in fact supplied. For -f and -W switches, VALUE is 1 or 0
for the positive and negative forms respectively.
|| (CLASS_LIKELY_SPILLED_P (reg_preferred_class (regno))
&& GET_CODE (src) == MEM))
{
- /* This might be seting a SUBREG of a pseudo, a pseudo that is
+ /* This might be setting a SUBREG of a pseudo, a pseudo that is
also set somewhere else to a constant. */
note_stores (set, no_equiv, NULL);
continue;
registers only used that once. If so, see if we can replace the
reference with the equivalent from. If we can, delete the
initializing reference and this register will go away. If we
- can't replace the reference, and the initialzing reference is
+ can't replace the reference, and the initializing reference is
within the same loop (or in an inner loop), then move the register
initialization just before the use, so that they are in the same
basic block. */
optimizations on innermost loops (with single exception) because
the impact on performance is greatest here, and we want to avoid
unnecessary code size growth. The gain is caused by greater sequentiality
- of code, better code to optimize for futher passes and in some cases
+ of code, better code to optimize for further passes and in some cases
by fewer testings of exit conditions. The main problem is code growth,
that impacts performance negatively due to effect of caches.
remove_path (loops, unswitch_on_alt->succ);
/* One of created loops do not have to be subloop of the outer loop now,
- so fix its placement in loop datastructure. */
+ so fix its placement in loop data structure. */
fix_loop_placement (loop);
fix_loop_placement (nloop);
if they refer to the same word. */
if (SUBREG_BYTE (def) == SUBREG_BYTE (use->x))
return 1;
- /* Now the more difficult part: the same regno is refered, but the
+ /* Now the more difficult part: the same regno is referred, but the
sizes of the references or the words differ. E.g.
(subreg:SI (reg:CDI a) 0) and (subreg:DI (reg:CDI a) 2) do not
overlap, whereas the latter overlaps with (subreg:SI (reg:CDI a) 3).
we may want to adjust the cost of that register class to -1.
Avoid the adjustment if the source does not die to avoid stressing of
- register allocator by preferrencing two coliding registers into single
+ register allocator by preferrencing two colliding registers into single
class.
Also avoid the adjustment if a copy between registers of the class
}
-/* return nonzero if X is stable and mentions no regsiters but for
+/* return nonzero if X is stable and mentions no registers but for
mentioning SRC or mentioning / changing DST . If in doubt, presume
it is unstable.
The rationale is that we want to check if we can move an insn easily
first regular expression *and* the reservation described by the
second regular expression *and* etc.
- 4. "*" is used for convinience and simply means sequence in
+ 4. "*" is used for convenience and simply means sequence in
which the regular expression are repeated NUMBER times with
cycle advancing (see ",").
break;
case USE:
/* We need to fix callers to really ensure availability
- of all values inisn uses, but for now it is safe to prohibit
+ of all values insn uses, but for now it is safe to prohibit
hoisting of any insn having such a hidden uses. */
return false;
break;
it by splitting the edge and repositioning the block.
This is somewhat hackish, but at least avoid cut&paste
- Safter sollution can be to bring the code into sequence,
+ A safer solution can be to bring the code into sequence,
do the split and re-emit it back in case this will ever
trigger problem. */
f = bb->prev_bb->succ;
return earliest_block;
}
-/* The following function adds dependecies between jumps and risky
+/* The following function adds dependencies between jumps and risky
insns in given ebb. */
static void
/* Topological order of blocks in the region (if b2 is reachable from
b1, block_to_bb[b2] > block_to_bb[b1]). Note: A basic block is
always referred to by either block or b, while its topological
- order name (in the region) is refered to by bb. */
+ order name (in the region) is referred to by bb. */
static int *block_to_bb;
/* The number of the region containing a block. */
return NULL_RTX;
}
- /* Recurse for futher possible simplifications. */
+ /* Recurse for further possible simplifications. */
new = simplify_subreg (outermode, SUBREG_REG (op),
GET_MODE (SUBREG_REG (op)),
final_offset);
typedef int (*srf_trav) PARAMS ((int regno, rtx r, sbitmap canonical_elements, partition reg_partition));
static void ssa_rename_from_traverse
PARAMS ((htab_trav callback_function, sbitmap canonical_elements, partition reg_partition));
-/*static Avoid warnign message. */ void ssa_rename_from_print
+/*static Avoid warning message. */ void ssa_rename_from_print
PARAMS ((void));
static int ssa_rename_from_print_1
PARAMS ((void **slot, void *data));
}
/* Print the contents of the hash table entry SLOT, passing the unused
- sttribute DATA. Used as a callback function with htab_traverse (). */
+ attribute DATA. Used as a callback function with htab_traverse (). */
static int
ssa_rename_from_print_1 (slot, data)
}
/* Consider phi insns in basic block BB pairwise. If the set target
- of both isns are equivalent pseudos, make the corresponding phi
+ of both insns are equivalent pseudos, make the corresponding phi
alternatives in each phi corresponding equivalent.
Return nonzero if any new register classes were unioned. */
fibheap_delete (heap);
}
-/* Connect the superblocks into linear seuqence. At the moment we attempt to keep
+/* Connect the superblocks into linear sequence. At the moment we attempt to keep
the original order as much as possible, but the algorithm may be made smarter
later if needed. BB reordering pass should void most of the benefits of such
change though. */
tree t;
BUILD_VA_LIST_TYPE (t);
- /* Many back-ends define record types without seting TYPE_NAME.
+ /* Many back-ends define record types without setting TYPE_NAME.
If we copied the record type here, we'd keep the original
record type without a name. This breaks name mangling. So,
don't copy record types and let c_common_nodes_and_builtins()
projects / thirdparty / gcc.git / commitdiff
