c-common.c, [...]: Fix comment typos.

* 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.

From-SVN: r87288

gcc/ChangeLog

@@ -1,3 +1,10 @@
+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,

gcc/c-common.c

@@ -1448,7 +1448,7 @@ check_case_value (tree value)
    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.  */
 

gcc/c-pch.c

@@ -448,7 +448,7 @@ c_common_read_pch (cpp_reader *pfile, const char *name,
   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) ();
 }

gcc/defaults.h

@@ -632,7 +632,7 @@ do { fputs (integer_asm_op (POINTER_SIZE / BITS_PER_UNIT, TRUE), FILE); \
 #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

gcc/lambda-code.c

@@ -47,7 +47,7 @@
    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. 
 
@@ -74,20 +74,20 @@
 
  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
@@ -749,7 +749,7 @@ lambda_compute_auxillary_space (lambda_loopnest nest,
 }
 
 /* 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.  */

gcc/passes.c

@@ -1287,7 +1287,7 @@ rest_of_handle_jump (void)
   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)

gcc/tree-data-ref.c

@@ -146,7 +146,7 @@ array_base_name_differ_p (struct data_reference *a,
   /* 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;
@@ -525,7 +525,7 @@ analyze_array_indexes (struct loop *loop,
     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.  */
@@ -558,7 +558,7 @@ analyze_array (tree stmt, tree ref, bool is_read)
   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 *

gcc/tree-flow.h

@@ -601,7 +601,7 @@ extern bool may_propagate_copy (tree, tree);
 
 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.  */

gcc/tree-ssa-operands.c

@@ -34,9 +34,9 @@ Boston, MA 02111-1307, USA.  */
 #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 
@@ -795,7 +795,7 @@ append_v_must_def (tree var)
    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.  
@@ -1187,7 +1187,7 @@ get_expr_operands (tree stmt, tree *expr_p, int flags)
 }
 
 
-/* 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)

gcc/tree-ssa-threadupdate.c

@@ -204,7 +204,7 @@ create_block_for_threading (basic_block bb, struct redirection_data *rd)
    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.
 

gcc/tree-vectorizer.c

@@ -1525,7 +1525,7 @@ vect_transform_loop (loop_vec_info loop_vinfo,
 
    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).  */
 

gcc/tree-vectorizer.h

@@ -52,7 +52,7 @@ typedef struct _stmt_vec_info {
   /* 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

gcc/value-prof.c

@@ -41,7 +41,7 @@ static struct value_prof_hooks *value_prof_hooks;
    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