config/crx/crx.c, config/crx/crx.h, config/crx/crx.md: Update
FSF address.
+ * calls.c, fold-const.c, ipa-reference.c, ipa-type-escape.c,
+ tree-ssa-reassoc.c, tree-ssa-structalias.c, vec.h,
+ config/crx/crx.c, config/m32c/m32c.c, config/m32c/m32c.h: Fix
+ comment typos.
+ * doc/c-tree.texi, doc/tree-ssa.texi: Fix typos.
+
2005-07-26 Richard Guenther <rguenther@suse.de>
PR tree-optimization/22486
use = plus_constant (argblock,
argvec[argnum].locate.offset.constant);
else
- /* When arguemnts are pushed, trying to tell alias.c where
+ /* When arguments are pushed, trying to tell alias.c where
exactly this argument is won't work, because the
auto-increment causes confusion. So we merely indicate
that we access something with a known mode somewhere on
| | (alloca, variable deallocated
Stack | length arrays).
grows +-------------------- Fp(x)
- down| | Local vaiables of X
+ down| | Local variables of X
ward| +--------------------
| | Regs saved for X-1
| +==================== Sp(x-1)=Ap(x)
/* Output of Assembler Instructions */
-/* We use a lookup table because the addressing modes are non-orthagonal. */
+/* We use a lookup table because the addressing modes are non-orthogonal. */
static struct
{
#define BASE_REG_CLASS A_REGS
#define INDEX_REG_CLASS NO_REGS
-/* We primarily use the new "long" constraint names, with the intial
+/* We primarily use the new "long" constraint names, with the initial
letter classifying the constraint type and following letters
specifying which. The types are:
node structure type is required to have a unique enumerator value
specified with it.
For language specific @code{DECL} nodes, this new enumerator value
-should go in the approriate @file{.def} file.
+should go in the appropriate @file{.def} file.
For @code{DECL} nodes that are part of the middle-end, the enumerator
values are specified in @file{treestruct.def}.
In order to make your new structure type usable, it must be added to
@code{union tree_node}.
For language specific @code{DECL} nodes, a new entry should be added
-to the approriate @file{.h} file of the form
+to the appropriate @file{.h} file of the form
@smallexample
struct tree_foo_decl GTY ((tag ("TS_VAR_DECL"))) foo_decl;
@end smallexample
hierarchy, a simple lookup table is used.
This lookup table needs to be kept up to date with the tree structure
hierarchy, or else checking and containment macros will fail
-inapproriately.
+inappropriately.
For language specific @code{DECL} nodes, their is an @code{init_ts}
-function in an approriate @file{.c} file, which initializes the lookup
+function in an appropriate @file{.c} file, which initializes the lookup
table.
Code setting up the table for new @code{DECL} nodes should be added
there.
@item Add macros to access any new fields and flags
Each added field or flag should have a macro that is used to access
-it, that performs approriate checking to ensure only the right type of
+it, that performs appropriate checking to ensure only the right type of
@code{DECL} nodes access the field.
These macros generally take the following form
first sequence or not, so we assume that it doesn't).
After the second sequence is executed, if it completes normally by
-falling off the end, execution continues whereever the first sequence
+falling off the end, execution continues wherever the first sequence
would have continued, by falling off the end, or doing a goto, etc.
@code{TRY_FINALLY_EXPR} complicates the flow graph, since the cleanup
}
/* Handle (T *)&A.B.C for A being of type T and B and C
- living at offset zero. This occours frequently in
+ living at offset zero. This occurs frequently in
C++ upcasting and then accessing the base. */
if (TREE_CODE (op0) == ADDR_EXPR
&& POINTER_TYPE_P (type)
}
/* Lookup the tree node for the static variable that has UID and
- conver the name to a string for debugging. */
+ convert the name to a string for debugging. */
static const char *
get_static_name (int index)
bitmap_set_bit (map, uid);
if (escape_status == FULL_ESCAPE)
{
- /* Effeciency hack. When things are bad, do not mess around
+ /* Efficiency hack. When things are bad, do not mess around
with this type anymore. */
bitmap_set_bit (global_types_exposed_parameter, uid);
}
return;
bitmap_set_bit (been_there_done_that, uid);
- /* If we are doing a language with a type heirarchy, mark all of
+ /* If we are doing a language with a type hierarchy, mark all of
the superclasses. */
if (TYPE_BINFO (type))
for (binfo = TYPE_BINFO (type), i = 0;
subtype_map = subtype_map_for_uid (uid, false);
- /* If we are doing a language with a type heirarchy, mark all of
+ /* If we are doing a language with a type hierarchy, mark all of
the superclasses. */
if (TYPE_BINFO (type))
for (binfo = TYPE_BINFO (type), i = 0;
unsigned int lhsrank = get_rank (lhs);
unsigned int rhsrank = get_rank (rhs);
- /* If unsafe math optimizations we can do reassociation for non integal
+ /* If unsafe math optimizations we can do reassociation for non-integral
types. */
if ((!INTEGRAL_TYPE_P (TREE_TYPE (lhs))
|| !INTEGRAL_TYPE_P (TREE_TYPE (rhs)))
1- If the constraint for PTR is ADDRESSOF for a non-structure
variable, then we can use it directly because adding or
subtracting a constant may not alter the original ADDRESSOF
- constraing (i.e., pointer arithmetic may not legally go outside
+ constraint (i.e., pointer arithmetic may not legally go outside
an object's boundaries).
2- If the constraint for PTR is ADDRESSOF for a structure variable,
if (vi->is_artificial_var)
{
/* FIXME. READONLY should be handled better so that
- flow insensitive aliasing can disregard writeable
+ flow insensitive aliasing can disregard writable
aliases. */
if (vi->id == nothing_id)
pi->pt_null = 1;
VEC(T,A) *VEC_T_A_copy(VEC(T) *);
Copy the live elements of a vector into a new vector. The new and
- old vectors need not be allocated by the same mechanim. */
+ old vectors need not be allocated by the same mechanism. */
#define VEC_copy(T,A,V) (VEC_OP(T,A,copy)(VEC_BASE(V) MEM_STAT_INFO))
git://gcc.gnu.org / gcc.git / commitdiff