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

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

Hi,

Committed as obvious without a ChangeLog entry. (See
http://sources.redhat.com/ml/binutils/2003-10/msg00667.html.)

Kazu Hirata

Index: c-typeck.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/c-typeck.c,v
retrieving revision 1.264
diff -u -r1.264 c-typeck.c
--- c-typeck.c	12 Nov 2003 19:52:08 -0000	1.264
+++ c-typeck.c	13 Dec 2003 03:56:23 -0000
@@ -5642,7 +5642,7 @@
 
  retry:
 
-  /* Look thru the whole pending tree.
+  /* Look through the whole pending tree.
      If we find an element that should be output now,
      output it.  Otherwise, set NEXT to the element
      that comes first among those still pending.  */
Index: calls.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/calls.c,v
retrieving revision 1.308
diff -u -r1.308 calls.c
--- calls.c	8 Dec 2003 10:33:46 -0000	1.308
+++ calls.c	13 Dec 2003 03:56:25 -0000
@@ -290,7 +290,7 @@
     /* Get possible static chain value for nested function in C.  */
     static_chain_value = lookup_static_chain (fndecl);
 
-  /* Make a valid memory address and copy constants thru pseudo-regs,
+  /* Make a valid memory address and copy constants through pseudo-regs,
      but not for a constant address if -fno-function-cse.  */
   if (GET_CODE (funexp) != SYMBOL_REF)
     /* If we are using registers for parameters, force the
Index: cfgcleanup.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cfgcleanup.c,v
retrieving revision 1.96
diff -u -r1.96 cfgcleanup.c
--- cfgcleanup.c	11 Dec 2003 00:20:36 -0000	1.96
+++ cfgcleanup.c	13 Dec 2003 03:56:26 -0000
@@ -174,7 +174,7 @@
 
   end = BB_END (jump_block);
   /* Deleting a block may produce unreachable code warning even when we are
-     not deleting anything live.  Supress it by moving all the line number
+     not deleting anything live.  Suppress it by moving all the line number
      notes out of the block.  */
   for (insn = BB_HEAD (jump_block); insn != NEXT_INSN (BB_END (jump_block));
        insn = next)
Index: cgraph.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cgraph.h,v
retrieving revision 1.23
diff -u -r1.23 cgraph.h
--- cgraph.h	22 Oct 2003 11:58:09 -0000	1.23
+++ cgraph.h	13 Dec 2003 03:56:26 -0000
@@ -75,7 +75,7 @@
 };
 
 
-/* The cgraph data strutcture.
+/* The cgraph data structure.
    Each function decl has assigned cgraph_node listing callees and callers.  */
 
 struct cgraph_node GTY((chain_next ("%h.next"), chain_prev ("%h.previous")))
@@ -122,7 +122,7 @@
   bool inline_call;
 };
 
-/* The cgraph_varpool data strutcture.
+/* The cgraph_varpool data structure.
    Each static variable decl has assigned cgraph_varpool_node.  */
 
 struct cgraph_varpool_node GTY(())
Index: dwarfout.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/dwarfout.c,v
retrieving revision 1.138
diff -u -r1.138 dwarfout.c
--- dwarfout.c	13 Oct 2003 21:16:18 -0000	1.138
+++ dwarfout.c	13 Dec 2003 03:56:30 -0000
@@ -2074,7 +2074,7 @@
 	   which contains the given subreg.  */
 
 	rtl = SUBREG_REG (rtl);
-	/* Drop thru.  */
+	/* Drop through.  */
 
       case REG:
 
@@ -2157,7 +2157,7 @@
 	   which contains the given subreg.  */
 
 	rtl = SUBREG_REG (rtl);
-	/* Drop thru.  */
+	/* Drop through.  */
 
     case REG:
 	ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_REG);
Index: emit-rtl.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/emit-rtl.c,v
retrieving revision 1.357
diff -u -r1.357 emit-rtl.c
--- emit-rtl.c	11 Dec 2003 00:20:38 -0000	1.357
+++ emit-rtl.c	13 Dec 2003 03:56:33 -0000
@@ -2596,7 +2596,7 @@
   return;
 }
 
-/* Go through all the RTL insn bodies and chec that there is no inexpected
+/* Go through all the RTL insn bodies and check that there is no unexpected
    sharing in between the subexpressions.  */
 
 void
Index: explow.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/explow.c,v
retrieving revision 1.117
diff -u -r1.117 explow.c
--- explow.c	18 Sep 2003 20:43:04 -0000	1.117
+++ explow.c	13 Dec 2003 03:56:33 -0000
@@ -444,7 +444,7 @@
 
   x = convert_memory_address (Pmode, x);
 
-  /* By passing constant addresses thru registers
+  /* By passing constant addresses through registers
      we get a chance to cse them.  */
   if (! cse_not_expected && CONSTANT_P (x) && CONSTANT_ADDRESS_P (x))
     x = force_reg (Pmode, x);
Index: expr.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/expr.c,v
retrieving revision 1.606
diff -u -r1.606 expr.c
--- expr.c	3 Dec 2003 22:40:53 -0000	1.606
+++ expr.c	13 Dec 2003 03:56:38 -0000
@@ -9793,7 +9793,7 @@
   if (mode != Pmode)
     index = convert_to_mode (Pmode, index, 1);
 
-  /* Don't let a MEM slip thru, because then INDEX that comes
+  /* Don't let a MEM slip through, because then INDEX that comes
      out of PIC_CASE_VECTOR_ADDRESS won't be a valid address,
      and break_out_memory_refs will go to work on it and mess it up.  */
 #ifdef PIC_CASE_VECTOR_ADDRESS
Index: flow.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/flow.c,v
retrieving revision 1.569
diff -u -r1.569 flow.c
--- flow.c	11 Dec 2003 00:20:38 -0000	1.569
+++ flow.c	13 Dec 2003 03:56:40 -0000
@@ -2462,7 +2462,7 @@
     case SET:
       if (GET_CODE (XEXP (x, 1)) == ASM_OPERANDS)
 	flags |= PROP_ASM_SCAN;
-      /* Fall thru */
+      /* Fall through */
     case CLOBBER:
       mark_set_1 (pbi, code, SET_DEST (x), cond, insn, flags);
       return;
@@ -2497,7 +2497,7 @@
 	      mark_set:
 		if (GET_CODE (XEXP (sub, 1)) == ASM_OPERANDS)
 		  flags |= PROP_ASM_SCAN;
-		/* Fall thru */
+		/* Fall through */
 	      case CLOBBER:
 	      mark_clob:
 		mark_set_1 (pbi, code, SET_DEST (sub), cond, insn, flags);
Index: function.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/function.c,v
retrieving revision 1.476
diff -u -r1.476 function.c
--- function.c	11 Dec 2003 19:04:07 -0000	1.476
+++ function.c	13 Dec 2003 03:56:44 -0000
@@ -6733,7 +6733,7 @@
 	  tem = decl_function_context (tem);
 	  if (tem == 0)
 	    break;
-	  /* Chain thru stack frames, assuming pointer to next lexical frame
+	  /* Chain through stack frames, assuming pointer to next lexical frame
 	     is found at the place we always store it.  */
 #ifdef FRAME_GROWS_DOWNWARD
 	  last_ptr = plus_constant (last_ptr,
Index: gcc.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/gcc.c,v
retrieving revision 1.398
diff -u -r1.398 gcc.c
--- gcc.c	6 Dec 2003 03:47:55 -0000	1.398
+++ gcc.c	13 Dec 2003 03:56:48 -0000
@@ -2687,7 +2687,7 @@
         {
 	  /* verbose_only_flag should act as if the spec was
 	     executed, so increment execution_count before
-	     returning.  Theis prevent spurious warnings about
+	     returning.  This prevents spurious warnings about
 	     unused linker input files, etc.  */
 	  execution_count++;
 	  return 0;
Index: ggc-zone.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/ggc-zone.c,v
retrieving revision 2.7
diff -u -r2.7 ggc-zone.c
--- ggc-zone.c	13 Dec 2003 00:23:50 -0000	2.7
+++ ggc-zone.c	13 Dec 2003 03:56:48 -0000
@@ -89,7 +89,7 @@
    If we track inter-zone pointers, we can mark single zones at a
    time.
    If we have a zone where we guarantee no inter-zone pointers, we
-   could mark that zone seperately.
+   could mark that zone separately.
    The garbage zone should not be marked, and we should return 1 in
    ggc_set_mark for any object in the garbage zone, which cuts off
    marking quickly.  */
Index: ifcvt.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/ifcvt.c,v
retrieving revision 1.132
diff -u -r1.132 ifcvt.c
--- ifcvt.c	11 Dec 2003 00:20:44 -0000	1.132
+++ ifcvt.c	13 Dec 2003 03:56:50 -0000
@@ -2962,8 +2962,8 @@
   if (HAVE_conditional_execution)
     {
       /* In the conditional execution case, we have things easy.  We know
-	 the condition is reversible.  We don't have to check life info,
-	 becase we're going to conditionally execute the code anyway.
+	 the condition is reversible.  We don't have to check life info
+	 because we're going to conditionally execute the code anyway.
 	 All that's left is making sure the insns involved can actually
 	 be predicated.  */
 
Index: local-alloc.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/local-alloc.c,v
retrieving revision 1.123
diff -u -r1.123 local-alloc.c
--- local-alloc.c	11 Dec 2003 00:20:45 -0000	1.123
+++ local-alloc.c	13 Dec 2003 03:56:51 -0000
@@ -108,7 +108,7 @@
 
   /* Number of words needed to hold the data in given quantity.
      This depends on its machine mode.  It is used for these purposes:
-     1. It is used in computing the relative importances of qtys,
+     1. It is used in computing the relative importance of qtys,
 	which determines the order in which we look for regs for them.
      2. It is used in rules that prevent tying several registers of
 	different sizes in a way that is geometrically impossible
Index: predict.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/predict.c,v
retrieving revision 1.92
diff -u -r1.92 predict.c
--- predict.c	11 Dec 2003 00:20:45 -0000	1.92
+++ predict.c	13 Dec 2003 03:56:52 -0000
@@ -878,7 +878,7 @@
   /* To keep queue of basic blocks to process.  */
   basic_block next;
 
-  /* True if block needs to be visited in prop_freqency.  */
+  /* True if block needs to be visited in propagate_freq.  */
   int tovisit:1;
 
   /* Number of predecessors we need to visit first.  */
Index: pretty-print.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/pretty-print.c,v
retrieving revision 2.6
diff -u -r2.6 pretty-print.c
--- pretty-print.c	12 Sep 2003 23:47:01 -0000	2.6
+++ pretty-print.c	13 Dec 2003 03:56:52 -0000
@@ -472,7 +472,7 @@
 }
 
 /* Return the amount of characters PRETTY-PRINTER can accept to
-   make a full line.  Meaningfull only in line-wrapping mode.  */
+   make a full line.  Meaningful only in line-wrapping mode.  */
 int
 pp_base_remaining_character_count_for_line (pretty_printer *pp)
 {
Index: profile.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/profile.c,v
retrieving revision 1.128
diff -u -r1.128 profile.c
--- profile.c	11 Dec 2003 00:20:45 -0000	1.128
+++ profile.c	13 Dec 2003 03:56:53 -0000
@@ -502,7 +502,7 @@
 	}
       for (e = bb->succ; e; e = e->succ_next)
 	{
-	  /* Function may return twice in the cased the called fucntion is
+	  /* Function may return twice in the cased the called function is
 	     setjmp or calls fork, but we can't represent this by extra
 	     edge from the entry, since extra edge from the exit is
 	     already present.  We get negative frequency from the entry
Index: ra-colorize.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/ra-colorize.c,v
retrieving revision 1.14
diff -u -r1.14 ra-colorize.c
--- ra-colorize.c	14 Sep 2003 13:42:33 -0000	1.14
+++ ra-colorize.c	13 Dec 2003 03:56:54 -0000
@@ -618,7 +618,7 @@
 	{
 	  /* The main webs do _not_ conflict, only some parts of both.  This
 	     means, that 4 is possibly true, so we need to check this too.
-	     For this we go thru all sub conflicts between T and C, and see if
+	     For this we go through all sub conflicts between T and C, and see if
 	     the target part of C already conflicts with S.  When this is not
 	     the case we disallow coalescing.  */
 	  struct sub_conflict *sl;
@@ -1214,7 +1214,7 @@
 		}
 	    }
 	  /* The next if() only gets true, if there was no wl->sub at all, in
-	     which case we are only making one go thru this loop with W being
+	     which case we are only making one go through this loop with W being
 	     a whole web.  */
 	  if (!sl)
 	    break;
@@ -1433,7 +1433,7 @@
 	 even if we spill this one here, the situation won't become better
 	 in the next iteration.  It probably will have the same conflicts,
 	 those will have the same colors, and we would come here again, for
-	 all parts, in which this one gets splitted by the spill.  This
+	 all parts, in which this one gets split by the spill.  This
 	 can result in endless iteration spilling the same register again and
 	 again.  That's why we try to find a neighbor, which spans more
 	 instructions that ourself, and got a color, and try to spill _that_.
@@ -1826,7 +1826,7 @@
 		  else if (web2->type == SELECT)
 		    /* This means, that WEB2 once was a part of a coalesced
 		       web, which got spilled in the above colorize_one_web()
-		       call, and whose parts then got splitted and put back
+		       call, and whose parts then got split and put back
 		       onto the SELECT stack.  As the cause for that splitting
 		       (the coloring of WEB) was worthless, we should again
 		       coalesce the parts, as they were before.  For now we
Index: sched-vis.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/sched-vis.c,v
retrieving revision 1.28
diff -u -r1.28 sched-vis.c
--- sched-vis.c	19 Jul 2003 14:47:13 -0000	1.28
+++ sched-vis.c	13 Dec 2003 03:56:55 -0000
@@ -80,7 +80,7 @@
 }
 
 /* MAX_VISUAL_LINES is the maximum number of lines in visualization table
-   of a basic block.  If more lines are needed, table is splitted to two.
+   of a basic block.  If more lines are needed, table is split to two.
    n_visual_lines is the number of lines printed so far for a block.
    visual_tbl contains the block visualization info.
    vis_no_unit holds insns in a cycle that are not mapped to any unit.  */
Index: stor-layout.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/stor-layout.c,v
retrieving revision 1.173
diff -u -r1.173 stor-layout.c
--- stor-layout.c	6 Nov 2003 08:38:50 -0000	1.173
+++ stor-layout.c	13 Dec 2003 03:56:56 -0000
@@ -453,7 +453,7 @@
       else if (DECL_PACKED (decl) && DECL_USER_ALIGN (decl))
 	/* Don't touch DECL_ALIGN.  For other packed fields, go ahead and
 	   round up; we'll reduce it again below.  We want packing to
-	   supercede USER_ALIGN inherited from the type, but defer to
+	   supersede USER_ALIGN inherited from the type, but defer to
 	   alignment explicitly specified on the field decl.  */;
       else
 	do_type_align (type, decl);