2003-08-19 Kazu Hirata <kazu@cs.umass.edu>
+ * builtins.c: Fix comment typos.
+ * c-common.c: Likewise.
+ * c-decl.c: Likewise.
+ * c-pretty-print.c: Likewise.
+ * cfgbuild.c: Likewise.
+ * cfglayout.c: Likewise.
+ * cfgloopanal.c: Likewise.
+ * cgraphunit.c: Likewise.
+ * cppfiles.c: Likewise.
+ * dwarfout.c: Likewise.
+ * expr.c: Likewise.
+ * fold-const.c: Likewise.
+ * gcse.c: Likewise.
+ * ggc-page.c: Likewise.
+ * haifa-sched.c: Likewise.
+ * pretty-print.c: Likewise.
+ * tree.c: Likewise.
+ * tree.h: Likewise.
+ * value-prof.c: Likewise.
+
+2003-08-19 Kazu Hirata <kazu@cs.umass.edu>
+
* c-decl.c: Follow spelling conventions.
* cppfiles.c: Likewise.
size_t len = strlen (fmt_str);
if (fmt_str[len - 1] == '\n')
{
- /* Create a NUL-terminalted string that's one char shorter
+ /* Create a NUL-terminated string that's one char shorter
than the original, stripping off the trailing '\n'. */
char *newstr = (char *) alloca (len);
memcpy (newstr, fmt_str, len - 1);
return NULL;
}
/* Assume that constants and references counts nothing. These should
- be majorized by amount of operations amoung them we count later
+ be majorized by amount of operations among them we count later
and are common target of CSE and similar optimizations. */
if (TREE_CODE_CLASS (TREE_CODE (x)) == 'c'
|| TREE_CODE_CLASS (TREE_CODE (x)) == 'r')
/* A wrapper around lhd_set_decl_assembler_name that gives static
variables their C names if they are at file scope and only one
translation unit is being compiled, for backwards compatibility
- with certain bizzare assembler hacks (like crtstuff.c). */
+ with certain bizarre assembler hacks (like crtstuff.c). */
void
c_static_assembler_name (tree decl)
/* The pretty-printer code is primarily designed to closely follow
(GNU) C and C++ grammars. That is to be contrasted with spaghetti
codes we used to have in the past. Following a structured
- approach (preferaably the official grammars) is believed to make it
- much easier o add extensions and nifty pretty-printing effects that
- takes expresssion or declaration contexts into account. */
+ approach (preferably the official grammars) is believed to make it
+ much easier to add extensions and nifty pretty-printing effects that
+ takes expression or declaration contexts into account. */
#define pp_c_whitespace(PP) \
Implementation note: Because of the non-linearities in array or
- function declarations, this routinie prints not just the
+ function declarations, this routine prints not just the
specifier-qualifier-list of such entities or types of such entities,
but also the 'pointer' production part of their declarators. The
remaining part is done by pp_declarator or pp_c_abstract_declarator. */
return (flag_non_call_exceptions && can_throw_internal (insn));
case BARRIER:
- /* It is nonsence to reach barrier when looking for the
+ /* It is nonsense to reach barrier when looking for the
end of basic block, but before dead code is eliminated
this may happen. */
return false;
prev_bb->next_bb = EXIT_BLOCK_PTR;
EXIT_BLOCK_PTR->prev_bb = prev_bb;
- /* Anoying special case - jump around dead jumptables left in the code. */
+ /* Annoying special case - jump around dead jumptables left in the code. */
FOR_EACH_BB (bb)
{
edge e;
abort ();
}
- /* If this is const_true_rtx and we did not take a conservative aproximation
+ /* If this is const_true_rtx and we did not take a conservative approximation
of after_wrap above, we might iterate the calculation (but of course we
would have to take care about infinite cases). Ignore this for now. */
rqmt = simplify_gen_relational (cond, SImode, mode, after_wrap, lim);
|| !cgraph_default_inline_p (node))
continue;
- /* Rule out always_inline functions we dealt with earler. */
+ /* Rule out always_inline functions we dealt with earlier. */
for (e = node->callers; e; e = e->next_caller)
if (e->inline_call)
break;
if (e->callee == callee)
return e->inline_call;
/* We do not record builtins in the callgraph. Perhaps it would make more
- sense to do so and then prune out those not overwriten by explicit
+ sense to do so and then prune out those not overwritten by explicit
function body. */
return false;
}
Attempt to topologically sort the nodes so function is output when
all called functions are already assembled to allow data to be
- propagated accross the callgraph. Use a stack to get smaller distance
+ propagated across the callgraph. Use a stack to get smaller distance
between a function and it's callees (later we may choose to use a more
sophisticated algorithm for function reordering; we will likely want
to use subsections to make the output functions appear in top-down
/* Mark all local functions.
- Local function is function whose calls can occur only in the
- current compilation unit so we change it's calling convetion.
+ A local function is one whose calls can occur only in the
+ current compilation unit, so we change its calling convention.
We simply mark all static functions whose address is not taken
as local. */
/* A singly-linked list for all searches for a given file name, with
its head pointed to by a slot in FILE_HASH. The file name is what
appeared between the quotes in a #include directive; it can be
- determined implicity from the hash table location or explicitly
+ determined implicitly from the hash table location or explicitly
from FILE->name.
FILE is a structure containing details about the file that was
}
/* Convenience wrapper around read_file_guts that opens the file if
- necessary and closes the file desciptor after reading. FILE must
+ necessary and closes the file descriptor after reading. FILE must
have been passed through find_file() at some stage. */
static bool
read_file (cpp_reader *pfile, _cpp_file *file)
#endif
/* Pseudo-ops for pushing the current section onto the section stack (and
- simultaneously changing to a new section) and for poping back to the
+ simultaneously changing to a new section) and for popping back to the
section we were in immediately before this one. Note that most svr4
assemblers only maintain a one level stack... you can push all the
sections you want, but you can only pop out one level. (The sparc
/* We can find the lowest bit that's a one. If the low
HOST_BITS_PER_WIDE_INT bits are zero, return BIGGEST_ALIGNMENT.
We need to handle this case since we can find it in a COND_EXPR,
- a MIN_EXPR, or a MAX_EXPR. If the constant overlows, we have an
+ a MIN_EXPR, or a MAX_EXPR. If the constant overflows, we have an
erroneous program, so return BIGGEST_ALIGNMENT to avoid any
later ICE. */
if (TREE_CONSTANT_OVERFLOW (exp))
#endif
-/* Perform constant folding and related simplification of intializer
+/* Perform constant folding and related simplification of initializer
expression EXPR. This behaves identically to "fold" but ignores
potential run-time traps and exceptions that fold must preserve. */
count = 0;
FOR_EACH_BB (bb)
- /* Check for more than one sucessor. */
+ /* Check for more than one successor. */
if (bb->succ && bb->succ->succ_next)
{
cond = fis_get_condition (bb->end);
/* This routine will take an expression which we are replacing with
a reaching register, and update any stores that are needed if
that expression is in the ld_motion list. Stores are updated by
- copying their SRC to the reaching register, and then storeing
+ copying their SRC to the reaching register, and then storing
the reaching register into the store location. These keeps the
correct value in the reaching register for the loads. */
G.context_depth_allocations &= omask - 1;
G.context_depth_collections &= omask - 1;
- /* The G.depth array is shortend so that the last index is the
+ /* The G.depth array is shortened so that the last index is the
context_depth of the top element of by_depth. */
if (depth+1 < G.depth_in_use)
e = G.depth[depth+1];
moved speculatively, by examining it's patterns, returning:
TRAP_RISKY: store, or risky non-load insn (e.g. division by variable).
TRAP_FREE: non-load insn.
- IFREE: load from a globaly safe location.
+ IFREE: load from a globally safe location.
IRISKY: volatile load.
PFREE_CANDIDATE, PRISKY_CANDIDATE: load that need to be checked for
being either PFREE or PRISKY. */
default:
break;
}
- /* We don't support precision behond that of "long long". */
+ /* We don't support precision beyond that of "long long". */
if (precision > 2)
abort();
return t;
}
-/* Build a function type. The RETURN_TYPE is the type retured by the
+/* Build a function type. The RETURN_TYPE is the type returned by the
function. If additional arguments are provided, they are
additional argument types. The list of argument types must always
be terminated by NULL_TREE. */
USIZETYPE, /* Unsigned representation of sizes in bytes. */
BITSIZETYPE, /* Normal representation of sizes in bits. */
SBITSIZETYPE, /* Signed representation of sizes in bits. */
- UBITSIZETYPE, /* Unsifgned representation of sizes in bits. */
+ UBITSIZETYPE, /* Unsigned representation of sizes in bits. */
TYPE_KIND_LAST};
extern GTY(()) tree sizetype_tab[(int) TYPE_KIND_LAST];
insn_values_to_profile function. This function is called from branch_prob
in profile.c and the requested values are instrumented by it in the first
compilation with -fprofile-arcs. The optimization may then read the
- gathered data in the second compilation with -fbranch-probablities.
+ gathered data in the second compilation with -fbranch-probabilities.
The measured data is appended as REG_VALUE_PROFILE note to the instrumented
insn. The argument to the note consists of an EXPR_LIST where its
members have the following meaning (from the first to the last):
projects / platform / upstream / linaro-gcc.git / commitdiff