[patch] gcc/*.[ch]: Fix comment typos.

[Kazu Hirata <kazu at cs dot umass dot edu>]

Hi,

Committed as obvious.

Kazu Hirata

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.

Index: c-common.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/c-common.c,v
retrieving revision 1.570
diff -u -r1.570 c-common.c
--- c-common.c	7 Sep 2004 10:18:53 -0000	1.570
+++ c-common.c	10 Sep 2004 10:36:09 -0000
@@ -1448,7 +1448,7 @@
    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.  */
 
Index: c-pch.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/c-pch.c,v
retrieving revision 1.26
diff -u -r1.26 c-pch.c
--- c-pch.c	7 Sep 2004 10:18:59 -0000	1.26
+++ c-pch.c	10 Sep 2004 10:36:09 -0000
@@ -448,7 +448,7 @@
   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) ();
 }
Index: defaults.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/defaults.h,v
retrieving revision 1.155
diff -u -r1.155 defaults.h
--- defaults.h	9 Sep 2004 17:11:15 -0000	1.155
+++ defaults.h	10 Sep 2004 10:36:10 -0000
@@ -632,7 +632,7 @@
 #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
Index: lambda-code.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/lambda-code.c,v
retrieving revision 2.4
diff -u -r2.4 lambda-code.c
--- lambda-code.c	8 Sep 2004 15:28:55 -0000	2.4
+++ lambda-code.c	10 Sep 2004 10:36:11 -0000
@@ -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 @@
 }
 
 /* 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.  */
Index: passes.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/passes.c,v
retrieving revision 2.46
diff -u -r2.46 passes.c
--- passes.c	10 Sep 2004 09:22:27 -0000	2.46
+++ passes.c	10 Sep 2004 10:36:13 -0000
@@ -1287,7 +1287,7 @@
   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)
Index: tree-data-ref.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree-data-ref.c,v
retrieving revision 2.5
diff -u -r2.5 tree-data-ref.c
--- tree-data-ref.c	9 Sep 2004 07:54:07 -0000	2.5
+++ tree-data-ref.c	10 Sep 2004 10:36:14 -0000
@@ -146,7 +146,7 @@
   /* 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 @@
     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 @@
   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 *
Index: tree-flow.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree-flow.h,v
retrieving revision 2.42
diff -u -r2.42 tree-flow.h
--- tree-flow.h	8 Sep 2004 15:28:55 -0000	2.42
+++ tree-flow.h	10 Sep 2004 10:36:14 -0000
@@ -601,7 +601,7 @@
 
 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.  */
Index: tree-ssa-operands.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree-ssa-operands.c,v
retrieving revision 2.38
diff -u -r2.38 tree-ssa-operands.c
--- tree-ssa-operands.c	9 Sep 2004 07:54:12 -0000	2.38
+++ tree-ssa-operands.c	10 Sep 2004 10:36:15 -0000
@@ -34,9 +34,9 @@
 #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 @@
    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 @@
 }
 
 
-/* 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)
Index: tree-ssa-threadupdate.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree-ssa-threadupdate.c,v
retrieving revision 2.4
diff -u -r2.4 tree-ssa-threadupdate.c
--- tree-ssa-threadupdate.c	9 Sep 2004 07:54:12 -0000	2.4
+++ tree-ssa-threadupdate.c	10 Sep 2004 10:36:15 -0000
@@ -204,7 +204,7 @@
    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.
 
Index: tree-vectorizer.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree-vectorizer.c,v
retrieving revision 2.7
diff -u -r2.7 tree-vectorizer.c
--- tree-vectorizer.c	9 Sep 2004 07:54:12 -0000	2.7
+++ tree-vectorizer.c	10 Sep 2004 10:36:18 -0000
@@ -1525,7 +1525,7 @@
 
    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).  */
 
Index: tree-vectorizer.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree-vectorizer.h,v
retrieving revision 2.2
diff -u -r2.2 tree-vectorizer.h
--- tree-vectorizer.h	5 Sep 2004 16:05:05 -0000	2.2
+++ tree-vectorizer.h	10 Sep 2004 10:36:18 -0000
@@ -52,7 +52,7 @@
   /* 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
Index: value-prof.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/value-prof.c,v
retrieving revision 1.14
diff -u -r1.14 value-prof.c
--- value-prof.c	5 Sep 2004 15:24:15 -0000	1.14
+++ value-prof.c	10 Sep 2004 10:36:18 -0000
@@ -41,7 +41,7 @@
    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