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

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

Hi,

Committed as obvious.

Kazu Hirata

2004-09-18  Kazu Hirata  <kazu@cs.umass.edu>

	* alias.c, crtstuff.c, dbxout.c, domwalk.c, domwalk.h, gcc.c,
	gcse.c, global.c, lambda-code.c, loop.c, mips-tdump.c,
	optabs.h, predict.c, reg-stack.c, regclass.c, sched-rgn.c,
	tree-optimize.c, tree-ssa-dom.c, tree-ssa-forwprop.c,
	tree-ssa-operands.c, tree-ssa-phiopt.c,
	tree-ssa-threadupdate.c: Fix comment typos.

Index: alias.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/alias.c,v
retrieving revision 1.241
diff -u -r1.241 alias.c
--- alias.c	17 Sep 2004 21:54:20 -0000	1.241
+++ alias.c	18 Sep 2004 19:37:00 -0000
@@ -2698,7 +2698,7 @@
 
 
 /* Return true when INSN possibly modify memory contents of MEM
-   (ie address can be modified).  */
+   (i.e. address can be modified).  */
 bool
 memory_modified_in_insn_p (rtx mem, rtx insn)
 {
Index: crtstuff.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/crtstuff.c,v
retrieving revision 1.67
diff -u -r1.67 crtstuff.c
--- crtstuff.c	21 Jan 2004 20:39:53 -0000	1.67
+++ crtstuff.c	18 Sep 2004 19:37:05 -0000
@@ -109,7 +109,7 @@
    but not its definition.
 
    Making TARGET_WEAK_ATTRIBUTE conditional seems like a good solution until
-   one thinks about scaling to larger problems -- ie, the condition under
+   one thinks about scaling to larger problems -- i.e., the condition under
    which TARGET_WEAK_ATTRIBUTE is active will eventually get far too
    complicated.
 
Index: dbxout.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/dbxout.c,v
retrieving revision 1.201
diff -u -r1.201 dbxout.c
--- dbxout.c	17 Sep 2004 21:54:27 -0000	1.201
+++ dbxout.c	18 Sep 2004 19:37:06 -0000
@@ -1431,7 +1431,7 @@
     {
     case VOID_TYPE:
     case LANG_TYPE:
-      /* For a void type, just define it as itself; ie, "5=5".
+      /* For a void type, just define it as itself; i.e., "5=5".
 	 This makes us consider it defined
 	 without saying what it is.  The debugger will make it
 	 a void type when the reference is seen, and nothing will
Index: domwalk.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/domwalk.c,v
retrieving revision 2.1
diff -u -r2.1 domwalk.c
--- domwalk.c	13 May 2004 06:39:37 -0000	2.1
+++ domwalk.c	18 Sep 2004 19:37:07 -0000
@@ -52,7 +52,7 @@
 
 
   [ Note this walker can also walk the post-dominator tree, which is
-    defined in a similar manner.  ie, block B1 is said to post-dominate
+    defined in a similar manner.  i.e., block B1 is said to post-dominate
     block B2 if all paths from B2 to the exit block must pass through
     B1.  ]
 
Index: domwalk.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/domwalk.h,v
retrieving revision 2.2
diff -u -r2.2 domwalk.h
--- domwalk.h	12 Jun 2004 05:53:51 -0000	2.2
+++ domwalk.h	18 Sep 2004 19:37:07 -0000
@@ -25,7 +25,7 @@
 
 struct dom_walk_data
 {
-  /* This is the direction of the dominator tree we want to walk.  ie,
+  /* This is the direction of the dominator tree we want to walk.  i.e.,
      if it is set to CDI_DOMINATORS, then we walk the dominator tree,
      if it is set to CDI_POST_DOMINATORS, then we walk the post
      dominator tree.  */
Index: gcc.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/gcc.c,v
retrieving revision 1.433
diff -u -r1.433 gcc.c
--- gcc.c	16 Sep 2004 06:49:56 -0000	1.433
+++ gcc.c	18 Sep 2004 19:37:21 -0000
@@ -5169,7 +5169,7 @@
 	      }
 	    else
 	      /* Catch the case where a spec string contains something like
-		 '%{foo:%*}'.  ie there is no * in the pattern on the left
+		 '%{foo:%*}'.  i.e. there is no * in the pattern on the left
 		 hand side of the :.  */
 	      error ("spec failure: '%%*' has not been initialized by pattern match");
 	    break;
Index: gcse.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/gcse.c,v
retrieving revision 1.315
diff -u -r1.315 gcse.c
--- gcse.c	15 Sep 2004 21:45:28 -0000	1.315
+++ gcse.c	18 Sep 2004 19:37:24 -0000
@@ -453,7 +453,7 @@
 /* This is a list of expressions which are MEMs and will be used by load
    or store motion.
    Load motion tracks MEMs which aren't killed by
-   anything except itself. (ie, loads and stores to a single location).
+   anything except itself. (i.e., loads and stores to a single location).
    We can then allow movement of these MEM refs with a little special
    allowance. (all stores copy the same value to the reaching reg used
    for the loads).  This means all values used to store into memory must have
@@ -2768,7 +2768,7 @@
   struct expr *set1 = 0;
 
   /* Loops are not possible here.  To get a loop we would need two sets
-     available at the start of the block containing INSN.  ie we would
+     available at the start of the block containing INSN.  i.e. we would
      need two sets like this available at the start of the block:
 
        (set (reg X) (reg Y))
@@ -2814,7 +2814,7 @@
       if (! REG_P (src))
 	break;
 
-      /* Follow the copy chain, ie start another iteration of the loop
+      /* Follow the copy chain, i.e. start another iteration of the loop
 	 and see if we have an available copy into SRC.  */
       regno = REGNO (src);
     }
Index: global.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/global.c,v
retrieving revision 1.108
diff -u -r1.108 global.c
--- global.c	9 Sep 2004 13:54:06 -0000	1.108
+++ global.c	18 Sep 2004 19:37:25 -0000
@@ -734,7 +734,7 @@
 		   evaluates X.
 
 		3. Either X or Y is not evaluated on the path to P
-		   (ie it is used uninitialized) and thus the
+		   (i.e. it is used uninitialized) and thus the
 		   conflict can be ignored.
 
 	    In cases #1 and #2 the conflict will be recorded when we
Index: lambda-code.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/lambda-code.c,v
retrieving revision 2.9
diff -u -r2.9 lambda-code.c
--- lambda-code.c	17 Sep 2004 21:54:35 -0000	2.9
+++ lambda-code.c	18 Sep 2004 19:37:27 -0000
@@ -2033,7 +2033,7 @@
    innermost loop body.
    If S is a program statement, then
 
-   ie 
+   i.e. 
    DO I = 1, 20
        S1
        DO J = 1, 20
@@ -2395,7 +2395,7 @@
    matrix T is legal when applied to a loop nest with a set of
    lexicographically non-negative distance vectors RDG if and only if
    for each vector d in RDG, (T.d >= 0) is lexicographically positive.
-   ie.: if and only if it transforms the lexicographically positive
+   i.e.: if and only if it transforms the lexicographically positive
    distance vectors to lexicographically positive vectors.  Note that
    a unimodular matrix must transform the zero vector (and only it) to
    the zero vector." S.Muchnick.  */
Index: loop.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/loop.c,v
retrieving revision 1.512
diff -u -r1.512 loop.c
--- loop.c	14 Sep 2004 07:43:02 -0000	1.512
+++ loop.c	18 Sep 2004 19:37:33 -0000
@@ -3558,7 +3558,7 @@
 }
 
 /* X is a value modified by an INSN that references a biv inside a loop
-   exit test (ie, X is somehow related to the value of the biv).  If X
+   exit test (i.e., X is somehow related to the value of the biv).  If X
    is a pseudo that is used more than once, then the biv is (effectively)
    used more than once.  DATA is a pointer to a loop_regs structure.  */
 
Index: mips-tdump.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/mips-tdump.c,v
retrieving revision 1.30
diff -u -r1.30 mips-tdump.c
--- mips-tdump.c	10 Sep 2004 15:09:38 -0000	1.30
+++ mips-tdump.c	18 Sep 2004 19:37:34 -0000
@@ -631,7 +631,7 @@
       /*
        * Snarf up any array bounds in the correct order.  Arrays
        * store 5 successive words in the aux. table:
-       *	word 0	RNDXR to type of the bounds (ie, int)
+       *	word 0	RNDXR to type of the bounds (i.e., int)
        *	word 1	Current file descriptor index
        *	word 2	low bound
        *	word 3	high bound (or -1 if [])
@@ -689,7 +689,7 @@
 		int first_array = i;
 		int j;
 
-		/* Print array bounds reversed (ie, in the order the C
+		/* Print array bounds reversed (i.e., in the order the C
 		   programmer writes them).  C is such a fun language....  */
 
 		while (i < 5 && qualifiers[i+1].type == tq_Array)
Index: optabs.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/optabs.h,v
retrieving revision 1.35
diff -u -r1.35 optabs.h
--- optabs.h	4 Sep 2004 07:55:04 -0000	1.35
+++ optabs.h	18 Sep 2004 19:37:35 -0000
@@ -374,12 +374,12 @@
 
 typedef rtx (*rtxfun) (rtx);
 
-/* Indexed by the rtx-code for a conditional (eg. EQ, LT,...)
+/* Indexed by the rtx-code for a conditional (e.g. EQ, LT,...)
    gives the gen_function to make a branch to test that condition.  */
 
 extern rtxfun bcc_gen_fctn[NUM_RTX_CODE];
 
-/* Indexed by the rtx-code for a conditional (eg. EQ, LT,...)
+/* Indexed by the rtx-code for a conditional (e.g. EQ, LT,...)
    gives the insn code to make a store-condition insn
    to test that condition.  */
 
Index: predict.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/predict.c,v
retrieving revision 1.121
diff -u -r1.121 predict.c
--- predict.c	17 Sep 2004 21:54:35 -0000	1.121
+++ predict.c	18 Sep 2004 19:37:35 -0000
@@ -823,7 +823,7 @@
 	       && !last_basic_block_p (e->dest))
 	    predict_edge_def (e, PRED_EARLY_RETURN, TAKEN);
 
-	  /* Look for block we are guarding (ie we dominate it,
+	  /* Look for block we are guarding (i.e. we dominate it,
 	     but it doesn't postdominate us).  */
 	  if (e->dest != EXIT_BLOCK_PTR && e->dest != bb
 	      && dominated_by_p (CDI_DOMINATORS, e->dest, e->src)
@@ -1183,7 +1183,7 @@
 	       && !last_basic_block_p (e->dest))
 	    predict_edge_def (e, PRED_EARLY_RETURN, TAKEN);
 
-	  /* Look for block we are guarding (ie we dominate it,
+	  /* Look for block we are guarding (i.e. we dominate it,
 	     but it doesn't postdominate us).  */
 	  if (e->dest != EXIT_BLOCK_PTR && e->dest != bb
 	      && dominated_by_p (CDI_DOMINATORS, e->dest, e->src)
Index: reg-stack.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/reg-stack.c,v
retrieving revision 1.163
diff -u -r1.163 reg-stack.c
--- reg-stack.c	9 Sep 2004 17:19:12 -0000	1.163
+++ reg-stack.c	18 Sep 2004 19:37:37 -0000
@@ -105,7 +105,7 @@
 		asm ("foo" : "=t" (a) : "f" (b));
 
       This asm says that input B is not popped by the asm, and that
-      the asm pushes a result onto the reg-stack, ie, the stack is one
+      the asm pushes a result onto the reg-stack, i.e., the stack is one
       deeper after the asm than it was before.  But, it is possible that
       reload will think that it can use the same reg for both the input and
       the output, if input B dies in this insn.
@@ -2393,7 +2393,7 @@
 
    Insert any needed insns before or after INSN, as indicated by
    WHERE.  OLD is the original stack layout, and NEW is the desired
-   form.  OLD is updated to reflect the code emitted, ie, it will be
+   form.  OLD is updated to reflect the code emitted, i.e., it will be
    the same as NEW upon return.
 
    This function will not preserve block_end[].  But that information
Index: regclass.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/regclass.c,v
retrieving revision 1.196
diff -u -r1.196 regclass.c
--- regclass.c	14 Sep 2004 22:52:38 -0000	1.196
+++ regclass.c	18 Sep 2004 19:37:38 -0000
@@ -1582,7 +1582,7 @@
 		  win = address_operand (op, GET_MODE (op));
 		  /* We know this operand is an address, so we want it to be
 		     allocated to a register that can be the base of an
-		     address, ie BASE_REG_CLASS.  */
+		     address, i.e. BASE_REG_CLASS.  */
 		  classes[i]
 		    = reg_class_subunion[(int) classes[i]]
 		      [(int) MODE_BASE_REG_CLASS (VOIDmode)];
@@ -1696,7 +1696,7 @@
 			win = 1;
 		      /* We know this operand is an address, so we want it to
 			 be allocated to a register that can be the base of an
-			 address, ie BASE_REG_CLASS.  */
+			 address, i.e. BASE_REG_CLASS.  */
 		      classes[i]
 			= reg_class_subunion[(int) classes[i]]
 			  [(int) MODE_BASE_REG_CLASS (VOIDmode)];
Index: sched-rgn.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/sched-rgn.c,v
retrieving revision 1.81
diff -u -r1.81 sched-rgn.c
--- sched-rgn.c	9 Sep 2004 17:19:13 -0000	1.81
+++ sched-rgn.c	18 Sep 2004 19:37:39 -0000
@@ -912,7 +912,7 @@
 		 d	  b
 
 	     The algorithm in the DFS traversal may not mark B & D as part
-	     of the loop (ie they will not have max_hdr set to A).
+	     of the loop (i.e. they will not have max_hdr set to A).
 
 	     We know they can not be loop latches (else they would have
 	     had max_hdr set since they'd have a backedge to a dominator
Index: tree-optimize.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree-optimize.c,v
retrieving revision 2.47
diff -u -r2.47 tree-optimize.c
--- tree-optimize.c	17 Sep 2004 21:04:56 -0000	2.47
+++ tree-optimize.c	18 Sep 2004 19:37:41 -0000
@@ -541,7 +541,7 @@
 }
 
 
-/* update recursivly all inlined_to pointers of functions
+/* Update recursively all inlined_to pointers of functions
    inlined into NODE to INLINED_TO.  */
 static void
 update_inlined_to_pointers (struct cgraph_node *node,
Index: tree-ssa-dom.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree-ssa-dom.c,v
retrieving revision 2.44
diff -u -r2.44 tree-ssa-dom.c
--- tree-ssa-dom.c	17 Sep 2004 21:54:42 -0000	2.44
+++ tree-ssa-dom.c	18 Sep 2004 19:37:43 -0000
@@ -170,7 +170,7 @@
    optimizations are not performed.
 
    Note carefully we do not propagate information through each statement
-   in the block.  ie, if we know variable X has a value defined of
+   in the block.  i.e., if we know variable X has a value defined of
    [0, 25] and we encounter Y = X + 1, we do not track a value range
    for Y (which would be [1, 26] if we cared).  Similarly we do not
    constrain values as we encounter narrowing typecasts, etc.  */
@@ -1988,7 +1988,7 @@
 
 	  /* We really want to avoid unnecessary computations of range
 	     info.  So all ranges are computed lazily; this avoids a
-	     lot of unnecessary work.  ie, we record the conditional,
+	     lot of unnecessary work.  i.e., we record the conditional,
 	     but do not process how it constrains the variable's 
 	     potential values until we know that processing the condition
 	     could be helpful.
@@ -3095,7 +3095,7 @@
       tree op1 = TREE_OPERAND (cond, 1);
 
       /* Special case comparing booleans against a constant as we know
-	 the value of OP0 on both arms of the branch.  ie, we can record
+	 the value of OP0 on both arms of the branch.  i.e., we can record
 	 an equivalence for OP0 rather than COND.  */
       if ((TREE_CODE (cond) == EQ_EXPR || TREE_CODE (cond) == NE_EXPR)
 	  && TREE_CODE (op0) == SSA_NAME
Index: tree-ssa-forwprop.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree-ssa-forwprop.c,v
retrieving revision 2.6
diff -u -r2.6 tree-ssa-forwprop.c
--- tree-ssa-forwprop.c	17 Sep 2004 21:54:42 -0000	2.6
+++ tree-ssa-forwprop.c	18 Sep 2004 19:37:43 -0000
@@ -39,7 +39,7 @@
 
    Right now we only bother forward propagating into COND_EXPRs since those
    are relatively common cases where forward propagation creates valid
-   gimple code without the expression needing to fold.  ie
+   gimple code without the expression needing to fold.  i.e.
 
      bb0:
        x = a COND b;
Index: tree-ssa-operands.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree-ssa-operands.c,v
retrieving revision 2.44
diff -u -r2.44 tree-ssa-operands.c
--- tree-ssa-operands.c	17 Sep 2004 21:54:43 -0000	2.44
+++ tree-ssa-operands.c	18 Sep 2004 19:37:44 -0000
@@ -75,7 +75,7 @@
    variable, and that same variable occurs in the same operands cache, then 
    the new cache vector will also get the same SSA_NAME.
 
-  ie, if a stmt had a VUSE of 'a_5', and 'a' occurs in the new operand 
+  i.e., if a stmt had a VUSE of 'a_5', and 'a' occurs in the new operand 
   vector for VUSE, then the new vector will also be modified such that 
   it contains 'a_5' rather than 'a'.
 
Index: tree-ssa-phiopt.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree-ssa-phiopt.c,v
retrieving revision 2.13
diff -u -r2.13 tree-ssa-phiopt.c
--- tree-ssa-phiopt.c	17 Sep 2004 21:54:43 -0000	2.13
+++ tree-ssa-phiopt.c	18 Sep 2004 19:37:44 -0000
@@ -47,7 +47,7 @@
 					       basic_block *);
 
 /* This pass eliminates PHI nodes which can be trivially implemented as
-   an assignment from a conditional expression.  ie if we have something
+   an assignment from a conditional expression.  i.e. if we have something
    like:
 
      bb0:
Index: tree-ssa-threadupdate.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree-ssa-threadupdate.c,v
retrieving revision 2.5
diff -u -r2.5 tree-ssa-threadupdate.c
--- tree-ssa-threadupdate.c	10 Sep 2004 10:44:47 -0000	2.5
+++ tree-ssa-threadupdate.c	18 Sep 2004 19:37:46 -0000
@@ -41,7 +41,7 @@
    one or more in-edges to B to instead reach the destination of an
    out-edge from B while preserving any side effects in B.
 
-   ie, given A->B and B->C, change A->B to be A->C yet still preserve the
+   i.e., given A->B and B->C, change A->B to be A->C yet still preserve the
    side effects of executing B.
 
      1. Make a copy of B (including its outgoing edges and statements).  Call