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

[Kazu Hirata]

Hi,

Attached is a patch to fix comment typos.  Committed as obvious.

Kazu Hirata

2003-07-05  Kazu Hirata  <kazu@cs.umass.edu>

	* bt-load.c: Fix comment typos.
	* c-incpath.c: Likewise.
	* cfg.c: Likewise.
	* cfgcleanup.c: Likewise.
	* cfgloop.h: Likewise.
	* cfgloopmanip.c: Likewise.
	* cfgrtl.c: Likewise.
	* diagnostic.h: Likewise.
	* dwarfout.c: Likewise.
	* emit-rtl.c: Likewise.
	* et-forest.c: Likewise.
	* et-forest.h: Likewise.
	* expr.c: Likewise.
	* gcse.c: Likewise.
	* genattr.c: Likewise.
	* jump.c: Likewise.
	* langhooks.h: Likewise.
	* local-alloc.c: Likewise.
	* loop-unroll.c: Likewise.
	* loop-unswitch.c: Likewise.
	* ra-build.c: Likewise.
	* regclass.c: Likewise.
	* regmove.c: Likewise.
	* rtl.def: Likewise.
	* rtlanal.c: Likewise.
	* sched-ebb.c: Likewise.
	* sched-rgn.c: Likewise.
	* simplify-rtx.c: Likewise.
	* ssa.c: Likewise.
	* tracer.c: Likewise.
	* tree.c: Likewise.

Index: bt-load.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/bt-load.c,v
retrieving revision 2.7
diff -u -r2.7 bt-load.c
--- bt-load.c	29 Jun 2003 13:53:06 -0000	2.7
+++ bt-load.c	5 Jul 2003 15:08:44 -0000
@@ -1157,7 +1157,7 @@
    MIN_COST is the lower bound on the cost of the DEF after migration.
    If we migrate DEF so that its cost falls below MIN_COST,
    then we do not attempt to migrate further.  The idea is that
-   we migrate defintions in a priority order based on their cost,
+   we migrate definitions in a priority order based on their cost,
    when the cost of this definition falls below MIN_COST, then
    there is another definition with cost == MIN_COST which now
    has a higher priority than this definition.
Index: c-incpath.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/c-incpath.c,v
retrieving revision 1.6
diff -u -r1.6 c-incpath.c
--- c-incpath.c	19 Jun 2003 19:43:59 -0000	1.6
+++ c-incpath.c	5 Jul 2003 15:08:45 -0000
@@ -208,7 +208,7 @@
 
 	  if (!tmp)
 	    {
-	      /* Dupicate of something earlier in the same chain?  */
+	      /* Duplicate of something earlier in the same chain?  */
 	      reason = REASON_DUP;
 	      for (tmp = head; tmp != cur; tmp = tmp->next)
 		if (INO_T_EQ (cur->ino, tmp->ino) && cur->dev == tmp->dev)
Index: cfg.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cfg.c,v
retrieving revision 1.48
diff -u -r1.48 cfg.c
--- cfg.c	3 Jul 2003 18:40:24 -0000	1.48
+++ cfg.c	5 Jul 2003 15:08:45 -0000
@@ -20,7 +20,7 @@
 02111-1307, USA.  */
 
 /* This file contains low level functions to manipulate the CFG and
-   analyze it.  All other modules should not transform the datastructure
+   analyze it.  All other modules should not transform the data structure
    directly and use abstraction instead.  The file is supposed to be
    ordered bottom-up and should not contain any code dependent on a
    particular intermediate language (RTL or trees).
Index: cfgcleanup.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cfgcleanup.c,v
retrieving revision 1.87
diff -u -r1.87 cfgcleanup.c
--- cfgcleanup.c	3 Jul 2003 18:40:27 -0000	1.87
+++ cfgcleanup.c	5 Jul 2003 15:08:46 -0000
@@ -769,7 +769,7 @@
 
    It may be good idea to return basic block before C in the case
    C has been moved after B and originally appeared earlier in the
-   insn seqeunce, but we have no infromation available about the
+   insn sequence, but we have no information available about the
    relative ordering of these two.  Hopefully it is not too common.  */
 
 static basic_block
Index: cfgloop.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cfgloop.h,v
retrieving revision 1.9
diff -u -r1.9 cfgloop.h
--- cfgloop.h	3 Jul 2003 18:40:27 -0000	1.9
+++ cfgloop.h	5 Jul 2003 15:08:46 -0000
@@ -266,7 +266,7 @@
 extern void flow_loop_free (struct loop *);
 void mark_irreducible_loops (struct loops *);
 
-/* Loop datastructure manipulation/querying.  */
+/* Loop data structure manipulation/querying.  */
 extern void flow_loop_tree_node_add (struct loop *, struct loop *);
 extern void flow_loop_tree_node_remove (struct loop *);
 extern bool flow_loop_outside_edge_p (const struct loop *, edge);
Index: cfgloopmanip.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cfgloopmanip.c,v
retrieving revision 1.12
diff -u -r1.12 cfgloopmanip.c
--- cfgloopmanip.c	3 Jul 2003 23:50:05 -0000	1.12
+++ cfgloopmanip.c	5 Jul 2003 15:08:47 -0000
@@ -169,7 +169,7 @@
    his placement no longer has to be correct, and iteratively fix placement of
    its predecessors that may change if placement of FROM changed.  Also fix
    placement of subloops of FROM->loop_father, that might also be altered due
-   to this change; the condition for them is simmilar, except that instead of
+   to this change; the condition for them is similar, except that instead of
    successors we consider edges coming out of the loops.  */
 static void
 fix_bb_placements (struct loops *loops, basic_block from)
Index: cfgrtl.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cfgrtl.c,v
retrieving revision 1.91
diff -u -r1.91 cfgrtl.c
--- cfgrtl.c	3 Jul 2003 18:40:27 -0000	1.91
+++ cfgrtl.c	5 Jul 2003 15:08:48 -0000
@@ -1340,7 +1340,7 @@
 
   make_single_succ_edge (bb, edge_in->dest, EDGE_FALLTHRU);
 
-  /* For non-fallthry edges, we must adjust the predecessor's
+  /* For non-fallthru edges, we must adjust the predecessor's
      jump instruction to target our new block.  */
   if ((edge_in->flags & EDGE_FALLTHRU) == 0)
     {
Index: diagnostic.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/diagnostic.h,v
retrieving revision 1.62
diff -u -r1.62 diagnostic.h
--- diagnostic.h	4 Jul 2003 01:55:47 -0000	1.62
+++ diagnostic.h	5 Jul 2003 15:08:48 -0000
@@ -34,7 +34,7 @@
   int err_no;  /* for %m */
 } text_info;
 
-/* Contants used to discriminate diagnostics.  */
+/* Constants used to discriminate diagnostics.  */
 typedef enum
 {
 #define DEFINE_DIAGNOSTIC_KIND(K, M) K,  
Index: dwarfout.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/dwarfout.c,v
retrieving revision 1.128
diff -u -r1.128 dwarfout.c
--- dwarfout.c	29 Jun 2003 15:19:13 -0000	1.128
+++ dwarfout.c	5 Jul 2003 15:08:54 -0000
@@ -2182,7 +2182,7 @@
 
 /* Given a tree node describing an array bound (either lower or upper)
    output a representation for that bound.  DIM_NUM is used for
-   multi-dimensional arrays and U_OR_L disgnates upper or lower
+   multi-dimensional arrays and U_OR_L designates upper or lower
    bound.  */
 
 static void
Index: emit-rtl.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/emit-rtl.c,v
retrieving revision 1.339
diff -u -r1.339 emit-rtl.c
--- emit-rtl.c	3 Jul 2003 09:52:26 -0000	1.339
+++ emit-rtl.c	5 Jul 2003 15:08:54 -0000
@@ -912,7 +912,7 @@
 
   if (!x)
     return;
-  /* For register, we maitain the reverse information too.  */
+  /* For register, we maintain the reverse information too.  */
   if (GET_CODE (x) == REG)
     REG_ATTRS (x) = get_reg_attrs (t, 0);
   else if (GET_CODE (x) == SUBREG)
@@ -2241,7 +2241,7 @@
   new = simplify_gen_binary (PLUS, Pmode, addr, offset);
 
   /* At this point we don't know _why_ the address is invalid.  It
-     could have secondary memory refereces, multiplies or anything.
+     could have secondary memory references, multiplies or anything.
 
      However, if we did go and rearrange things, we can wind up not
      being able to recognize the magic around pic_offset_table_rtx.
Index: et-forest.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/et-forest.c,v
retrieving revision 1.7
diff -u -r1.7 et-forest.c
--- et-forest.c	29 Jun 2003 16:21:57 -0000	1.7
+++ et-forest.c	5 Jul 2003 15:08:54 -0000
@@ -1,4 +1,4 @@
-/* ET-trees datastructure implementation.
+/* ET-trees data structure implementation.
    Contributed by Pavel Nejedly
    Copyright (C) 2002, 2003 Free Software Foundation, Inc.
 
Index: et-forest.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/et-forest.h,v
retrieving revision 1.4
diff -u -r1.4 et-forest.h
--- et-forest.h	1 Jul 2003 12:17:52 -0000	1.4
+++ et-forest.h	5 Jul 2003 15:08:54 -0000
@@ -20,7 +20,7 @@
    for tree operations (insertion and removal of nodes and edges) and
    poly-logarithmic time for nearest common ancestor.
 
-   ET tree strores its structue as a sequence of symbols obtained
+   ET tree stores its structue as a sequence of symbols obtained
    by dfs(root)
 
    dfs (node)
Index: expr.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/expr.c,v
retrieving revision 1.562
diff -u -r1.562 expr.c
--- expr.c	4 Jul 2003 22:00:18 -0000	1.562
+++ expr.c	5 Jul 2003 15:08:59 -0000
@@ -4398,7 +4398,7 @@
     {
       /* C++ can generate ?: expressions with a throw expression in one
 	 branch and an rvalue in the other. Here, we resolve attempts to
-	 store the throw expression's nonexistant result.  */
+	 store the throw expression's nonexistent result.  */
       if (want_value)
 	abort ();
       expand_expr (exp, const0_rtx, VOIDmode, 0);
Index: gcse.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/gcse.c,v
retrieving revision 1.255
diff -u -r1.255 gcse.c
--- gcse.c	3 Jul 2003 05:26:30 -0000	1.255
+++ gcse.c	5 Jul 2003 15:09:03 -0000
@@ -5327,7 +5327,7 @@
     pat_end = NEXT_INSN (pat_end);
 
   /* If the last insn is a jump, insert EXPR in front [taking care to
-     handle cc0, etc. properly].  Similary we need to care trapping
+     handle cc0, etc. properly].  Similarly we need to care trapping
      instructions in presence of non-call exceptions.  */
 
   if (GET_CODE (insn) == JUMP_INSN
Index: genattr.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/genattr.c,v
retrieving revision 1.57
diff -u -r1.57 genattr.c
--- genattr.c	5 Jul 2003 05:27:22 -0000	1.57
+++ genattr.c	5 Jul 2003 15:09:03 -0000
@@ -165,7 +165,7 @@
   printf ("#define BLOCKAGE_BITS %d\n", i + 1);
 
   /* INSN_QUEUE_SIZE is a power of two larger than MAX_BLOCKAGE and
-     MAX_READY_COST.  This is the longest time an isnsn may be queued.  */
+     MAX_READY_COST.  This is the longest time an insn may be queued.  */
   i = MAX (blockage->max, ready_cost->max);
   for (q_size = 1; q_size <= i; q_size <<= 1)
     ;
Index: jump.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/jump.c,v
retrieving revision 1.232
diff -u -r1.232 jump.c
--- jump.c	4 Jul 2003 01:55:47 -0000	1.232
+++ jump.c	5 Jul 2003 15:09:04 -0000
@@ -681,7 +681,7 @@
     case NE:
     case EQ:
       /* It is always safe to reverse EQ and NE, even for the floating
-	 point.  Similary the unsigned comparisons are never used for
+	 point.  Similarly the unsigned comparisons are never used for
 	 floating point so we can reverse them in the default way.  */
       return reverse_condition (code);
     case ORDERED:
Index: langhooks.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/langhooks.h,v
retrieving revision 1.61
diff -u -r1.61 langhooks.h
--- langhooks.h	2 Jul 2003 20:15:37 -0000	1.61
+++ langhooks.h	5 Jul 2003 15:09:04 -0000
@@ -211,7 +211,7 @@
 
   /* Handle the switch CODE, which has real type enum opt_code from
      options.h.  If the switch takes an argument, it is passed in ARG
-     which points to permanent storage.  The handler is resonsible for
+     which points to permanent storage.  The handler is responsible for
      checking whether ARG is NULL, which indicates that no argument
      was in fact supplied.  For -f and -W switches, VALUE is 1 or 0
      for the positive and negative forms respectively.
Index: local-alloc.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/local-alloc.c,v
retrieving revision 1.118
diff -u -r1.118 local-alloc.c
--- local-alloc.c	16 Jun 2003 21:41:05 -0000	1.118
+++ local-alloc.c	5 Jul 2003 15:09:06 -0000
@@ -922,7 +922,7 @@
 	      || (CLASS_LIKELY_SPILLED_P (reg_preferred_class (regno))
 		  && GET_CODE (src) == MEM))
 	    {
-	      /* This might be seting a SUBREG of a pseudo, a pseudo that is
+	      /* This might be setting a SUBREG of a pseudo, a pseudo that is
 		 also set somewhere else to a constant.  */
 	      note_stores (set, no_equiv, NULL);
 	      continue;
@@ -1035,7 +1035,7 @@
      registers only used that once.  If so, see if we can replace the
      reference with the equivalent from.  If we can, delete the
      initializing reference and this register will go away.  If we
-     can't replace the reference, and the initialzing reference is
+     can't replace the reference, and the initializing reference is
      within the same loop (or in an inner loop), then move the register
      initialization just before the use, so that they are in the same
      basic block.  */
Index: loop-unroll.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/loop-unroll.c,v
retrieving revision 1.10
diff -u -r1.10 loop-unroll.c
--- loop-unroll.c	1 Jul 2003 12:17:54 -0000	1.10
+++ loop-unroll.c	5 Jul 2003 15:09:06 -0000
@@ -35,7 +35,7 @@
    optimizations on innermost loops (with single exception) because
    the impact on performance is greatest here, and we want to avoid
    unnecessary code size growth.  The gain is caused by greater sequentiality
-   of code, better code to optimize for futher passes and in some cases
+   of code, better code to optimize for further passes and in some cases
    by fewer testings of exit conditions.  The main problem is code growth,
    that impacts performance negatively due to effect of caches.
 
Index: loop-unswitch.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/loop-unswitch.c,v
retrieving revision 1.5
diff -u -r1.5 loop-unswitch.c
--- loop-unswitch.c	3 Jul 2003 18:40:28 -0000	1.5
+++ loop-unswitch.c	5 Jul 2003 15:09:06 -0000
@@ -410,7 +410,7 @@
   remove_path (loops, unswitch_on_alt->succ);
 
   /* One of created loops do not have to be subloop of the outer loop now,
-     so fix its placement in loop datastructure.  */
+     so fix its placement in loop data structure.  */
   fix_loop_placement (loop);
   fix_loop_placement (nloop);
 
Index: ra-build.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/ra-build.c,v
retrieving revision 1.19
diff -u -r1.19 ra-build.c
--- ra-build.c	1 Jul 2003 12:17:59 -0000	1.19
+++ ra-build.c	5 Jul 2003 15:09:08 -0000
@@ -667,7 +667,7 @@
 	     if they refer to the same word.  */
 	  if (SUBREG_BYTE (def) == SUBREG_BYTE (use->x))
 	    return 1;
-	/* Now the more difficult part: the same regno is refered, but the
+	/* Now the more difficult part: the same regno is referred, but the
 	   sizes of the references or the words differ.  E.g.
            (subreg:SI (reg:CDI a) 0) and (subreg:DI (reg:CDI a) 2) do not
 	   overlap, whereas the latter overlaps with (subreg:SI (reg:CDI a) 3).
Index: regclass.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/regclass.c,v
retrieving revision 1.172
diff -u -r1.172 regclass.c
--- regclass.c	27 Jun 2003 12:40:12 -0000	1.172
+++ regclass.c	5 Jul 2003 15:09:09 -0000
@@ -1828,7 +1828,7 @@
      we may want to adjust the cost of that register class to -1.
 
      Avoid the adjustment if the source does not die to avoid stressing of
-     register allocator by preferrencing two coliding registers into single
+     register allocator by preferrencing two colliding registers into single
      class.
 
      Also avoid the adjustment if a copy between registers of the class
Index: regmove.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/regmove.c,v
retrieving revision 1.143
diff -u -r1.143 regmove.c
--- regmove.c	1 Jul 2003 12:18:00 -0000	1.143
+++ regmove.c	5 Jul 2003 15:09:10 -0000
@@ -2070,7 +2070,7 @@
 }
 
 
-/* return nonzero if X is stable and mentions no regsiters but for
+/* return nonzero if X is stable and mentions no registers but for
    mentioning SRC or mentioning / changing DST .  If in doubt, presume
    it is unstable.
    The rationale is that we want to check if we can move an insn easily
Index: rtl.def
===================================================================
RCS file: /cvs/gcc/gcc/gcc/rtl.def,v
retrieving revision 1.70
diff -u -r1.70 rtl.def
--- rtl.def	8 Jun 2003 19:35:53 -0000	1.70
+++ rtl.def	5 Jul 2003 15:09:11 -0000
@@ -528,7 +528,7 @@
        first regular expression *and* the reservation described by the
        second regular expression *and* etc.
 
-       4. "*" is used for convinience and simply means sequence in
+       4. "*" is used for convenience and simply means sequence in
        which the regular expression are repeated NUMBER times with
        cycle advancing (see ",").
 
Index: rtlanal.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/rtlanal.c,v
retrieving revision 1.163
diff -u -r1.163 rtlanal.c
--- rtlanal.c	1 Jul 2003 12:18:00 -0000	1.163
+++ rtlanal.c	5 Jul 2003 15:09:13 -0000
@@ -3693,7 +3693,7 @@
 	      break;
 	    case USE:
 	      /* We need to fix callers to really ensure availability
-	         of all values inisn uses, but for now it is safe to prohibit
+	         of all values insn uses, but for now it is safe to prohibit
 		 hoisting of any insn having such a hidden uses.  */
 	      return false;
 	      break;
Index: sched-ebb.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/sched-ebb.c,v
retrieving revision 1.27
diff -u -r1.27 sched-ebb.c
--- sched-ebb.c	1 Jul 2003 12:18:01 -0000	1.27
+++ sched-ebb.c	5 Jul 2003 15:09:13 -0000
@@ -290,7 +290,7 @@
 	         it by splitting the edge and repositioning the block.
 	         This is somewhat hackish, but at least avoid cut&paste 
 
-	         Safter sollution can be to bring the code into sequence,
+	         A safer solution can be to bring the code into sequence,
 	         do the split and re-emit it back in case this will ever
 	         trigger problem.  */
 	      f = bb->prev_bb->succ;
@@ -410,7 +410,7 @@
   return earliest_block;
 }
 
-/* The following function adds dependecies between jumps and risky
+/* The following function adds dependencies between jumps and risky
    insns in given ebb.  */
 
 static void
Index: sched-rgn.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/sched-rgn.c,v
retrieving revision 1.58
diff -u -r1.58 sched-rgn.c
--- sched-rgn.c	25 Feb 2003 20:40:57 -0000	1.58
+++ sched-rgn.c	5 Jul 2003 15:09:14 -0000
@@ -142,7 +142,7 @@
 /* Topological order of blocks in the region (if b2 is reachable from
    b1, block_to_bb[b2] > block_to_bb[b1]).  Note: A basic block is
    always referred to by either block or b, while its topological
-   order name (in the region) is refered to by bb.  */
+   order name (in the region) is referred to by bb.  */
 static int *block_to_bb;
 
 /* The number of the region containing a block.  */
Index: simplify-rtx.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/simplify-rtx.c,v
retrieving revision 1.145
diff -u -r1.145 simplify-rtx.c
--- simplify-rtx.c	3 Jul 2003 07:30:00 -0000	1.145
+++ simplify-rtx.c	5 Jul 2003 15:09:16 -0000
@@ -2897,7 +2897,7 @@
 	    return NULL_RTX;
 	}
 
-      /* Recurse for futher possible simplifications.  */
+      /* Recurse for further possible simplifications.  */
       new = simplify_subreg (outermode, SUBREG_REG (op),
 			     GET_MODE (SUBREG_REG (op)),
 			     final_offset);
Index: ssa.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/ssa.c,v
retrieving revision 1.60
diff -u -r1.60 ssa.c
--- ssa.c	1 Jul 2003 12:18:01 -0000	1.60
+++ ssa.c	5 Jul 2003 15:09:17 -0000
@@ -142,7 +142,7 @@
 typedef int (*srf_trav) PARAMS ((int regno, rtx r, sbitmap canonical_elements, partition reg_partition));
 static void ssa_rename_from_traverse
   PARAMS ((htab_trav callback_function, sbitmap canonical_elements, partition reg_partition));
-/*static Avoid warnign message.  */ void ssa_rename_from_print
+/*static Avoid warning message.  */ void ssa_rename_from_print
   PARAMS ((void));
 static int ssa_rename_from_print_1
   PARAMS ((void **slot, void *data));
@@ -360,7 +360,7 @@
 }
 
 /* Print the contents of the hash table entry SLOT, passing the unused
-   sttribute DATA.  Used as a callback function with htab_traverse ().  */
+   attribute DATA.  Used as a callback function with htab_traverse ().  */
 
 static int
 ssa_rename_from_print_1 (slot, data)
@@ -1568,7 +1568,7 @@
 }
 
 /* Consider phi insns in basic block BB pairwise.  If the set target
-   of both isns are equivalent pseudos, make the corresponding phi
+   of both insns are equivalent pseudos, make the corresponding phi
    alternatives in each phi corresponding equivalent.
 
    Return nonzero if any new register classes were unioned.  */
Index: tracer.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tracer.c,v
retrieving revision 1.12
diff -u -r1.12 tracer.c
--- tracer.c	3 Jul 2003 18:40:29 -0000	1.12
+++ tracer.c	5 Jul 2003 15:09:17 -0000
@@ -316,7 +316,7 @@
   fibheap_delete (heap);
 }
 
-/* Connect the superblocks into linear seuqence.  At the moment we attempt to keep
+/* Connect the superblocks into linear sequence.  At the moment we attempt to keep
    the original order as much as possible, but the algorithm may be made smarter
    later if needed.  BB reordering pass should void most of the benefits of such
    change though.  */
Index: tree.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree.c,v
retrieving revision 1.310
diff -u -r1.310 tree.c
--- tree.c	29 Jun 2003 11:28:00 -0000	1.310
+++ tree.c	5 Jul 2003 15:09:19 -0000
@@ -5080,7 +5080,7 @@
     tree t;
     BUILD_VA_LIST_TYPE (t);
 
-    /* Many back-ends define record types without seting TYPE_NAME.
+    /* Many back-ends define record types without setting TYPE_NAME.
        If we copied the record type here, we'd keep the original
        record type without a name.  This breaks name mangling.  So,
        don't copy record types and let c_common_nodes_and_builtins()