+2004-09-10 Kazu Hirata <kazu@cs.umass.edu>
+
+ * c-common.c, c-pch.c, defaults.h, lambda-code.c, passes.c,
+ tree-data-ref.c, tree-flow.h, tree-ssa-operands.c,
+ tree-ssa-threadupdate.c, tree-vectorizer.c, tree-vectorizer.h,
+ value-prof.c: Fix comment typos. Follow spelling conventions.
+
2004-09-10 Giovanni Bajo <giovannibajo@gcc.gnu.org>
* unroll.c (unroll_loop, calculate_giv_inc, initial_reg_note_copy,
bound of the case label, and CASE_HIGH_P is the upper bound or NULL
if the case is not a case range.
The caller has to make sure that we are not called with NULL for
- CASE_LOW_P (ie. the defualt case).
+ CASE_LOW_P (ie. the default case).
Returns true if the case label is in range of ORIG_TYPE (satured or
untouched) or false if the label is out of range. */
fclose (f);
/* Give the front end a chance to take action after a PCH file has
- been loadeded. */
+ been loaded. */
if (lang_post_pch_load)
(*lang_post_pch_load) ();
}
#define FLOAT_LIB_COMPARE_RETURNS_BOOL(MODE, COMPARISON) false
#endif
-/* True if the targets integer-comparision functions return { 0, 1, 2
+/* True if the targets integer-comparison functions return { 0, 1, 2
} to indicate { <, ==, > }. False if { -1, 0, 1 } is used
instead. The libgcc routines are biased. */
#ifndef TARGET_LIB_INT_CMP_BIASED
math.
A little terminology and a general sketch of the algorithm. See "A singular
- loop transformatrion framework based on non-singular matrices" by Wei Li and
+ loop transformation framework based on non-singular matrices" by Wei Li and
Keshav Pingali for formal proofs that the various statements below are
correct.
For a dense source space, we take the transformation matrix, decompose it
into a lower triangular part (H) and a unimodular part (U).
- We then compute the auxillary space from the unimodular part (source loop
- nest . U = auxillary space) , which has two important properties:
+ We then compute the auxiliary space from the unimodular part (source loop
+ nest . U = auxiliary space) , which has two important properties:
1. It traverses the iterations in the same lexicographic order as the source
space.
2. It is a dense space when the source is a dense space (even if the target
space is going to be sparse).
- Given the auxillary space, we use the lower triangular part to compute the
+ Given the auxiliary space, we use the lower triangular part to compute the
bounds in the target space by simple matrix multiplication.
The gaps in the target space (IE the new loop step sizes) will be the
diagonals of the H matrix.
Sparse source spaces require another step, because you can't directly compute
- the exact bounds of the auxillary and target space from the sparse space.
+ the exact bounds of the auxiliary and target space from the sparse space.
Rather than try to come up with a separate algorithm to handle sparse source
spaces directly, we just find a legal transformation matrix that gives you
the sparse source space, from a dense space, and then transform the dense
}
/* Compute the loop bounds for the target space, using the bounds of
- the auxillary nest AUXILLARY_NEST, and the triangular matrix H. This is
+ the auxiliary nest AUXILLARY_NEST, and the triangular matrix H. This is
done by matrix multiplication and then transformation of the new matrix
back into linear expression form.
Return the target loopnest. */
timevar_push (TV_JUMP);
open_dump_file (DFI_sibling, current_function_decl);
- /* ??? We may get caled either via tree_rest_of_compilation when the CFG
+ /* ??? We may get called either via tree_rest_of_compilation when the CFG
is already built or directly (for instance from coverage code).
The direct callers shall be updated. */
if (!basic_block_info)
/* at this point we know that base_a != base_b. However, pointer accesses
of the form x=(*p) and y=(*q), which bases are p and q, may still by pointing
to the same base. In SSAed GIMPLE p and q will be SSA_NAMES in this case.
- Therefore, here we check if it's really two diferent declarations. */
+ Therefore, here we check if it's really two different declarations. */
if (TREE_CODE (base_a) == VAR_DECL && TREE_CODE (base_b) == VAR_DECL)
{
*differ_p = true;
return opnd0;
}
-/* For a data reference REF contained in the statemet STMT, initialize
+/* For a data reference REF contained in the statement STMT, initialize
a DATA_REFERENCE structure, and return it. IS_READ flag has to be
set to true when REF is in the right hand side of an
assignment. */
return res;
}
-/* For a data reference REF contained in the statemet STMT, initialize
+/* For a data reference REF contained in the statement STMT, initialize
a DATA_REFERENCE structure, and return it. */
struct data_reference *
struct tree_niter_desc
{
- tree assumptions; /* The boolean expression. If this expression evalutes
+ tree assumptions; /* The boolean expression. If this expression evaluates
to false, then the other fields in this structure
should not be used; there is no guarantee that they
will be correct. */
#include "timevar.h"
-/* This file contains the code required to mnage the operands cache of the
+/* This file contains the code required to manage the operands cache of the
SSA optimizer. For every stmt, we maintain an operand cache in the stmt
- annotation. This cache contains operands that will be of interets to
+ annotation. This cache contains operands that will be of interest to
optimizers and other passes wishing to manipulate the IL.
The operand type are broken up into REAL and VIRTUAL operands. The real
will be destroyed. It is appropriate to call free_stmt_operands() on
the value returned in old_ops.
- The rationale for this: Certain optimizations wish to exmaine the difference
+ The rationale for this: Certain optimizations wish to examine the difference
between new_ops and old_ops after processing. If a set of operands don't
change, new_ops will simply assume the pointer in old_ops, and the old_ops
pointer will be set to NULL, indicating no memory needs to be cleared.
}
-/* Scan operands in the ASM_EXPR stmt refered to in INFO. */
+/* Scan operands in the ASM_EXPR stmt referred to in INFO. */
static void
get_asm_expr_operands (tree stmt)
and may expose new optimization opportunities. Note that we have
to update dominator tree and SSA graph after such changes.
- The key to keeping the SSA graph update managable is to duplicate
+ The key to keeping the SSA graph update manageable is to duplicate
the side effects occurring in BB so that those side effects still
occur on the paths which bypass BB after redirecting edges.
Returns whether a stmt with OPERAND can be vectorized.
Supportable operands are constants, loop invariants, and operands that are
- defined by the current iteration of the loop. Unsupportable opernads are
+ defined by the current iteration of the loop. Unsupportable operands are
those that are defined by a previous iteration of the loop (as is the case
in reduction/induction computations). */
/* The stmt to which this info struct refers to. */
tree stmt;
- /* The loop with resprct to which STMT is vectorized. */
+ /* The loop with respect to which STMT is vectorized. */
struct loop *loop;
/* Not all stmts in the loop need to be vectorized. e.g, the incrementation
following optimizations are implemented (for more detailed descriptions
see comments at value_profile_transformations):
- 1) Division/modulo specialisation. Provided that we can determine that the
+ 1) Division/modulo specialization. Provided that we can determine that the
operands of the division have some special properties, we may use it to
produce more effective code.
2) Speculative prefetching. If we are able to determine that the difference
projects / gcc.git / commitdiff