* c-common.c, cfgexpand.c, cgraphunit.c, defaults.h,

	et-forest.c, expr.c, gimplify.c, global.c, gthr-lynx.h,
	hard-reg-set.h, modulo-sched.c, optabs.c, postreload-gcse.c,
	tree-data-ref.c, tree-flow.h, tree-if-conv.c, tree-inline.c,
	tree-sra.c, tree-ssa-loop-im.c, tree-ssa-loop-ivopts.c,
	tree-ssa-loop-niter.c, tree-ssa-operands.c,
	tree-ssa-operands.h, tree-ssa-propagate.c,
	tree-ssa-propagate.h, tree-ssa-threadupdate.c, value-prof.c,
	vec.c, vec.h: Fix comment typos.  Follow spelling conventions.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@87104 138bc75d-0d04-0410-961f-82ee72b054a4

30 files changed, 56 insertions, 44 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 69afbcca0ae..6dab2e77b8a 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,15 @@
+2004-09-05  Kazu Hirata  <kazu@cs.umass.edu>
+
+	* c-common.c, cfgexpand.c, cgraphunit.c, defaults.h,
+	et-forest.c, expr.c, gimplify.c, global.c, gthr-lynx.h,
+	hard-reg-set.h, modulo-sched.c, optabs.c, postreload-gcse.c,
+	tree-data-ref.c, tree-flow.h, tree-if-conv.c, tree-inline.c,
+	tree-sra.c, tree-ssa-loop-im.c, tree-ssa-loop-ivopts.c,
+	tree-ssa-loop-niter.c, tree-ssa-operands.c,
+	tree-ssa-operands.h, tree-ssa-propagate.c,
+	tree-ssa-propagate.h, tree-ssa-threadupdate.c, value-prof.c,
+	vec.c, vec.h: Fix comment typos.  Follow spelling conventions.
+
 2004-09-05  Diego Novillo  <dnovillo@redhat.com>
 
 	* tree-if-conv.c (gate_tree_if_conversion): Enable only if the
diff --git a/gcc/c-common.c b/gcc/c-common.c
index 1a105701eb0..95116cd75ae 100644
--- a/gcc/c-common.c
+++ b/gcc/c-common.c
@@ -1444,7 +1444,7 @@ check_case_value (tree value)
    type (ie. before the default conversion to int) of the switch testing
    expression.
    TYPE is the promoted type of the testing expression, and ORIG_TYPE is
-   the type before promiting it.  CASE_LOW_P is a pointer to the lower
+   the type before promoting it.  CASE_LOW_P is a pointer to the lower
    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
diff --git a/gcc/cfgexpand.c b/gcc/cfgexpand.c
index 68fd109e718..d4456e3d525 100644
--- a/gcc/cfgexpand.c
+++ b/gcc/cfgexpand.c
@@ -606,7 +606,7 @@ defer_stack_allocation (tree var, bool toplevel)
 }
 
 /* A subroutine of expand_used_vars.  Expand one variable according to
-   its flavour.  Variables to be placed on the stack are not actually
+   its flavor.  Variables to be placed on the stack are not actually
    expanded yet, merely recorded.  */
 
 static void
diff --git a/gcc/cgraphunit.c b/gcc/cgraphunit.c
index 9e903e09b9d..48cb2398f72 100644
--- a/gcc/cgraphunit.c
+++ b/gcc/cgraphunit.c
@@ -1261,7 +1261,7 @@ cgraph_decide_recursive_inlining (struct cgraph_node *node)
       max_depth = PARAM_VALUE (PARAM_MAX_INLINE_RECURSIVE_DEPTH);
     }
 
-  /* Make sure that function is small enought to be considered for inlining.  */
+  /* Make sure that function is small enough to be considered for inlining.  */
   if (!max_depth
       || cgraph_estimate_size_after_inlining (1, node, node)  >= limit)
     return;
diff --git a/gcc/defaults.h b/gcc/defaults.h
index dd5c21fe2c1..4b9cf5db63c 100644
--- a/gcc/defaults.h
+++ b/gcc/defaults.h
@@ -627,7 +627,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 fucntions return { 0, 1, 2
+/* True if the targets integer-comparision 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
diff --git a/gcc/et-forest.c b/gcc/et-forest.c
index 9b0997188bd..1c5eb9ab5bd 100644
--- a/gcc/et-forest.c
+++ b/gcc/et-forest.c
@@ -137,7 +137,7 @@ et_recomp_min (struct et_occ *occ)
 }
 
 #ifdef DEBUG_ET
-/* Checks whether neighbourhood of OCC seems sane.  */
+/* Checks whether neighborhood of OCC seems sane.  */
 
 static void
 et_check_occ_sanity (struct et_occ *occ)
diff --git a/gcc/expr.c b/gcc/expr.c
index 7d8c1f7f568..4f4a9aa4002 100644
--- a/gcc/expr.c
+++ b/gcc/expr.c
@@ -3596,7 +3596,7 @@ expand_assignment (tree to, tree from, int want_value)
 	  if (bitsize >= GET_MODE_BITSIZE (GET_MODE (str_rtx)))
 	    break;
 
-	  /* We can't handle fields split accross multiple entities.  */
+	  /* We can't handle fields split across multiple entities.  */
 	  if (bitpos1 + bitsize > GET_MODE_BITSIZE (GET_MODE (str_rtx)))
 	    break;
 
@@ -6120,7 +6120,7 @@ expand_expr_addr_expr (tree exp, rtx target, enum machine_mode tmode,
 
     case IMAGPART_EXPR:
       /* The imaginary part of the complex number is always second.
-	 The expresion is therefore always offset by the size of the
+	 The expression is therefore always offset by the size of the
 	 scalar type.  */
       offset = 0;
       bitpos = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (exp)));
diff --git a/gcc/gimplify.c b/gcc/gimplify.c
index 2358d3525f9..87f922c295f 100644
--- a/gcc/gimplify.c
+++ b/gcc/gimplify.c
@@ -1008,7 +1008,7 @@ gimplify_decl_expr (tree *stmt_p)
 	  gimplify_one_sizepos (&DECL_SIZE (decl), stmt_p);
 	  gimplify_one_sizepos (&DECL_SIZE_UNIT (decl), stmt_p);
 
-	  /* All occurences of this decl in final gimplified code will be
+	  /* All occurrences of this decl in final gimplified code will be
 	     replaced by indirection.  Setting DECL_VALUE_EXPR does two
 	     things: First, it lets the rest of the gimplifier know what
 	     replacement to use.  Second, it lets the debug info know 
@@ -3677,7 +3677,7 @@ gimplify_expr (tree *expr_p, tree *pre_p, tree *post_p,
 
 	case CONST_DECL:
 	  /* If we require an lvalue, such as for ADDR_EXPR, retain the
-	     CONST_DECL node.  Otherwise the decl is replacable by its
+	     CONST_DECL node.  Otherwise the decl is replaceable by its
 	     value.  */
 	  /* ??? Should be == fb_lvalue, but ADDR_EXPR passes fb_either.  */
 	  if (fallback & fb_lvalue)
diff --git a/gcc/global.c b/gcc/global.c
index 9964d728d71..5478cd1ba8b 100644
--- a/gcc/global.c
+++ b/gcc/global.c
@@ -2176,7 +2176,7 @@ check_earlyclobber (rtx insn)
     }
 }
 
-/* The function returns true if register classes C1 and C2 inetrsect.  */
+/* The function returns true if register classes C1 and C2 intersect.  */
 
 static bool
 regclass_intersect (enum reg_class c1, enum reg_class c2)
diff --git a/gcc/gthr-lynx.h b/gcc/gthr-lynx.h
index 651d7198f11..1ff631d35c4 100644
--- a/gcc/gthr-lynx.h
+++ b/gcc/gthr-lynx.h
@@ -45,7 +45,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
    weak.  If the multi-threaded application includes iostream.h,
    gthr-posix.h is included and pthread_create will be defined weak.
    If pthead_create is weak its defining module in libc is not
-   necessarly included in the link and the symbol is resolved to zero.
+   necessarily included in the link and the symbol is resolved to zero.
    Therefore the first call to it will crash.
 
    Since -mthreads is a multilib switch on LynxOS we know that at this
diff --git a/gcc/hard-reg-set.h b/gcc/hard-reg-set.h
index 8f61cdf25b2..397660c0d07 100644
--- a/gcc/hard-reg-set.h
+++ b/gcc/hard-reg-set.h
@@ -35,7 +35,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
    the same format as a HARD_REG_SET.  To help make sure this is true,
    we only try the widest fast integer mode (HOST_WIDEST_FAST_INT)
    instead of all the smaller types.  This approach loses only if
-   there are avery few registers and then only in the few cases where
+   there are very few registers and then only in the few cases where
    we have an array of HARD_REG_SETs, so it needn't be as complex as
    it used to be.  */
 
diff --git a/gcc/modulo-sched.c b/gcc/modulo-sched.c
index c7606d84a57..1207c31aa4f 100644
--- a/gcc/modulo-sched.c
+++ b/gcc/modulo-sched.c
@@ -1938,7 +1938,7 @@ ps_insn_find_column (partial_schedule_ptr ps, ps_insn_ptr ps_i,
   row = SMODULO (ps_i->cycle, ps->ii);
 
   /* Find the first must follow and the last must precede
-     and insert the node immediatly after the must precede
+     and insert the node immediately after the must precede
      but make sure that it there is no must follow after it.   */
   for (next_ps_i = ps->rows[row];
        next_ps_i;
@@ -2007,7 +2007,7 @@ ps_insn_advance_column (partial_schedule_ptr ps, ps_insn_ptr ps_i,
   if (TEST_BIT (must_follow, next_node->cuid))
     return false;
 
-  /* Advace PS_I over its next_in_row in the doubly linked list.  */
+  /* Advance PS_I over its next_in_row in the doubly linked list.  */
   prev = ps_i->prev_in_row;
   next = ps_i->next_in_row;
 
diff --git a/gcc/optabs.c b/gcc/optabs.c
index 22c0b347946..cc48ab53949 100644
--- a/gcc/optabs.c
+++ b/gcc/optabs.c
@@ -532,7 +532,7 @@ expand_doubleword_shift_condmove (enum machine_mode op1_mode, optab binoptab,
    masked by it and shifts in the range [BITS_PER_WORD, SHIFT_MASK) will
    fill with zeros or sign bits as appropriate.
 
-   If SHIFT_MASK is BITS_PER_WORD - 1, this routine will synthesise
+   If SHIFT_MASK is BITS_PER_WORD - 1, this routine will synthesize
    a doubleword shift whose equivalent mask is BITS_PER_WORD * 2 - 1.
    Doing this preserves semantics required by SHIFT_COUNT_TRUNCATED.
    In all other cases, shifts by values outside [0, BITS_PER_UNIT * 2)
diff --git a/gcc/postreload-gcse.c b/gcc/postreload-gcse.c
index a9d03440573..93d81c48241 100644
--- a/gcc/postreload-gcse.c
+++ b/gcc/postreload-gcse.c
@@ -86,7 +86,7 @@ static struct
 
 /* We need to keep a hash table of expressions.  The table entries are of
    type 'struct expr', and for each expression there is a single linked
-   list of occurences.  */
+   list of occurrences.  */
 
 /* The table itself.  */
 static htab_t expr_table;
@@ -107,7 +107,7 @@ struct expr
 static struct obstack expr_obstack;
 
 /* Occurrence of an expression.
-   There is at most one occurence per basic block.  If a pattern appears
+   There is at most one occurrence per basic block.  If a pattern appears
    more than once, the last appearance is used.  */
 
 struct occr
@@ -422,7 +422,7 @@ lookup_expr_in_table (rtx pat)
 }
 
 
-/* Dump all expressions and occurences that are currently in the
+/* Dump all expressions and occurrences that are currently in the
    expression hash table to FILE.  */
 
 /* This helper is called via htab_traverse.  */
diff --git a/gcc/tree-data-ref.c b/gcc/tree-data-ref.c
index 401bac62626..57f20bb7307 100644
--- a/gcc/tree-data-ref.c
+++ b/gcc/tree-data-ref.c
@@ -44,7 +44,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
        - polyhedron dependence
      or with the chains of recurrences based representation,
      
-   - to define a knowledge base for storing the data dependeces 
+   - to define a knowledge base for storing the data dependences 
      information,
      
    - to define an interface to access this data.
diff --git a/gcc/tree-flow.h b/gcc/tree-flow.h
index 5edfae50bbb..1efbbbd930f 100644
--- a/gcc/tree-flow.h
+++ b/gcc/tree-flow.h
@@ -605,7 +605,7 @@ struct tree_niter_desc
 			   to false, then the other fields in this structure
 			   should not be used; there is no guarantee that they
 			   will be correct.  */
-  tree may_be_zero;	/* The booleand expression.  If it evaluates to true,
+  tree may_be_zero;	/* The boolean expression.  If it evaluates to true,
 			   the loop will exit in the first iteration (i.e.
 			   its latch will not be executed), even if the niter
 			   field says otherwise.  */
diff --git a/gcc/tree-if-conv.c b/gcc/tree-if-conv.c
index 5a24091dbbe..da75585c0e4 100644
--- a/gcc/tree-if-conv.c
+++ b/gcc/tree-if-conv.c
@@ -949,7 +949,7 @@ ifc_temp_var (tree type, tree exp)
   var = create_tmp_var (type, name);
   add_referenced_tmp_var (var);
 
-  /* Build new statement to assigne EXP to new variable.  */
+  /* Build new statement to assign EXP to new variable.  */
   stmt = build (MODIFY_EXPR, type, var, exp);
 
   /* Get SSA name for the new variable and set make new statement
diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c
index 6f65f0900a8..0200bfc5966 100644
--- a/gcc/tree-inline.c
+++ b/gcc/tree-inline.c
@@ -1922,7 +1922,7 @@ walk_type_fields (tree type, walk_tree_fn func, void *data, void *htab)
     case POINTER_TYPE:
     case REFERENCE_TYPE:
       /* We have to worry about mutually recursive pointers.  These can't
-	 be written in C.  They can in Ada.  It's pathlogical, but
+	 be written in C.  They can in Ada.  It's pathological, but
 	 there's an ACATS test (c38102a) that checks it.  Deal with this
 	 by checking if we're pointing to another pointer, that one
 	 points to another pointer, that one does too, and we have no htab.
diff --git a/gcc/tree-sra.c b/gcc/tree-sra.c
index 66980ff6956..dd5d9e500ed 100644
--- a/gcc/tree-sra.c
+++ b/gcc/tree-sra.c
@@ -398,7 +398,7 @@ sra_elt_hash (const void *x)
 
   /* Take into account everything back up the chain.  Given that chain
      lengths are rarely very long, this should be acceptable.  If we
-     truely identify this as a performance problem, it should work to
+     truly identify this as a performance problem, it should work to
      hash the pointer value "e->parent".  */
   for (p = e->parent; p ; p = p->parent)
     h = (h * 65521) ^ sra_hash_tree (p->element);
diff --git a/gcc/tree-ssa-loop-im.c b/gcc/tree-ssa-loop-im.c
index e80d8eeeded..d05617db09e 100644
--- a/gcc/tree-ssa-loop-im.c
+++ b/gcc/tree-ssa-loop-im.c
@@ -206,7 +206,7 @@ movement_possibility (tree stmt)
 }
 
 /* Suppose that operand DEF is used inside the LOOP.  Returns the outermost
-   loop to that we could move the expresion using DEF if it did not have
+   loop to that we could move the expression using DEF if it did not have
    other operands, i.e. the outermost loop enclosing LOOP in that the value
    of DEF is invariant.  */
 
@@ -587,7 +587,7 @@ loop_commit_inserts (void)
 }
 
 /* Hoist the statements in basic block BB out of the loops prescribed by
-   data stored in LIM_DATA structres associated with each statement.  Callback
+   data stored in LIM_DATA structures associated with each statement.  Callback
    for walk_dominator_tree.  */
 
 static void
@@ -641,7 +641,7 @@ move_computations_stmt (struct dom_walk_data *dw_data ATTRIBUTE_UNUSED,
 }
 
 /* Hoist the statements out of the loops prescribed by data stored in
-   LIM_DATA structres associated with each statement.*/
+   LIM_DATA structures associated with each statement.*/
 
 static void
 move_computations (void)
@@ -698,7 +698,7 @@ may_move_till (tree ref, tree *index, void *data)
   return true;
 }
 
-/* Forces statements definining (invariant) SSA names in expression EXPR to be
+/* Forces statements defining (invariant) SSA names in expression EXPR to be
    moved out of the LOOP.  ORIG_LOOP is the loop in that EXPR is used.  */
 
 static void
@@ -1023,7 +1023,7 @@ rewrite_mem_refs (tree tmp_var, struct mem_ref *mem_refs)
 }
 
 /* Records request for store motion of memory reference REF from LOOP.
-   MEM_REFS is the list of occurences of the reference REF inside LOOP;
+   MEM_REFS is the list of occurrences of the reference REF inside LOOP;
    these references are rewritten by a new temporary variable.
    Exits from the LOOP are stored in EXITS, there are N_EXITS of them.
    The initialization of the temporary variable is put to the preheader
diff --git a/gcc/tree-ssa-loop-ivopts.c b/gcc/tree-ssa-loop-ivopts.c
index aee09fe545e..ba588eb5104 100644
--- a/gcc/tree-ssa-loop-ivopts.c
+++ b/gcc/tree-ssa-loop-ivopts.c
@@ -228,7 +228,7 @@ struct ivopts_data
 #define CONSIDER_ALL_CANDIDATES_BOUND \
   ((unsigned) PARAM_VALUE (PARAM_IV_CONSIDER_ALL_CANDIDATES_BOUND))
 
-/* If there are more iv occurences, we just give up (it is quite unlikely that
+/* If there are more iv occurrences, we just give up (it is quite unlikely that
    optimizing such a loop would help, and it would take ages).  */
 
 #define MAX_CONSIDERED_USES \
diff --git a/gcc/tree-ssa-loop-niter.c b/gcc/tree-ssa-loop-niter.c
index 7135ceee226..dd5fad9adb5 100644
--- a/gcc/tree-ssa-loop-niter.c
+++ b/gcc/tree-ssa-loop-niter.c
@@ -190,7 +190,7 @@ number_of_iterations_cond (tree type, tree base0, tree step0,
       /* We want to take care only of <=; this is easy,
 	 as in cases the overflow would make the transformation unsafe the loop
 	 does not roll.  Seemingly it would make more sense to want to take
-	 care of <, as NE is more simmilar to it, but the problem is that here
+	 care of <, as NE is more similar to it, but the problem is that here
 	 the transformation would be more difficult due to possibly infinite
 	 loops.  */
       if (zero_p (step0))
@@ -266,7 +266,7 @@ number_of_iterations_cond (tree type, tree base0, tree step0,
 		 obviously if the test for overflow during that transformation
 		 passed, we cannot overflow here.  Most importantly any
 		 loop with sharp end condition and step 1 falls into this
-		 cathegory, so handling this case specially is definitely
+		 category, so handling this case specially is definitely
 		 worth the troubles.  */
 	      may_xform = boolean_true_node;
 	    }
diff --git a/gcc/tree-ssa-operands.c b/gcc/tree-ssa-operands.c
index 85b777fd9dc..cf46d8ebefd 100644
--- a/gcc/tree-ssa-operands.c
+++ b/gcc/tree-ssa-operands.c
@@ -51,7 +51,7 @@ Boston, MA 02111-1307, USA.  */
    get_stmt_operands() in the primary entry point. 
 
    The operand tree is the parsed by the various get_* routines which look 
-   through the stmt tree for the occurence of operands which may be of 
+   through the stmt tree for the occurrence of operands which may be of 
    interest, and calls are made to the append_* routines whenever one is 
    found.  There are 5 of these routines, each representing one of the 
    5 types of operands. Defs, Uses, Virtual Uses, Virtual May Defs, and 
@@ -1686,9 +1686,9 @@ copy_virtual_operands (tree dst, tree src)
 
 
 /* Specifically for use in DOM's expression analysis.  Given a store, we
-   create an artifical stmt which looks like a load from the store, this can
+   create an artificial stmt which looks like a load from the store, this can
    be used to eliminate redundant loads.  OLD_OPS are the operands from the 
-   store stmt, and NEW_STMT is the new load which reperesent a load of the
+   store stmt, and NEW_STMT is the new load which represents a load of the
    values stored.  */
 
 void
diff --git a/gcc/tree-ssa-operands.h b/gcc/tree-ssa-operands.h
index 50459e507f6..ad0a916f9ba 100644
--- a/gcc/tree-ssa-operands.h
+++ b/gcc/tree-ssa-operands.h
@@ -188,7 +188,7 @@ extern void create_ssa_artficial_load_stmt (stmt_operands_p, tree);
 
 
 /* This structure is used in the operand iterator loops.  It contains the 
-   items required to determine which operand is retreived next.  During
+   items required to determine which operand is retrieved next.  During
    optimization, this structure is scalarized, and any unused fields are 
    optimized away, resulting in little overhead.  */
 
@@ -217,7 +217,7 @@ typedef struct ssa_operand_iterator_d
 #define SSA_OP_VUSE		0x04	/* VUSE operands.  */
 #define SSA_OP_VMAYUSE		0x08	/* USE portion of V_MAY_DEFS.  */
 #define SSA_OP_VMAYDEF		0x10	/* DEF portion of V_MAY_DEFS.  */
-#define SSA_OP_VMUSTDEF		0x20	/* V_MUST_DEF defintions.  */
+#define SSA_OP_VMUSTDEF		0x20	/* V_MUST_DEF definitions.  */
 
 /* These are commonly grouped operand flags.  */
 #define SSA_OP_VIRTUAL_USES	(SSA_OP_VUSE | SSA_OP_VMAYUSE)
diff --git a/gcc/tree-ssa-propagate.c b/gcc/tree-ssa-propagate.c
index 0eeee606ab5..b72c789476e 100644
--- a/gcc/tree-ssa-propagate.c
+++ b/gcc/tree-ssa-propagate.c
@@ -68,7 +68,7 @@
 
 	SSA_PROP_INTERESTING: S produces a value that can be computed
 	    at compile time.  Its result can be propagated into the
-	    statements that feed from S.  Furhtermore, if S is a
+	    statements that feed from S.  Furthermore, if S is a
 	    conditional jump, only the edge known to be taken is added
 	    to the work list.  Edges that are known not to execute are
 	    never simulated.
diff --git a/gcc/tree-ssa-propagate.h b/gcc/tree-ssa-propagate.h
index d390176937a..6375f5bd6c6 100644
--- a/gcc/tree-ssa-propagate.h
+++ b/gcc/tree-ssa-propagate.h
@@ -40,7 +40,7 @@ enum ssa_prop_result {
        returned by SSA_PROP_VISIT_STMT should be added to
        INTERESTING_SSA_EDGES.  If the statement being visited is a
        conditional jump, SSA_PROP_VISIT_STMT should indicate which edge
-       out of the basic block should be marked exectuable.  */
+       out of the basic block should be marked executable.  */
     SSA_PROP_INTERESTING,
 
     /* The statement produces a varying (i.e., useless) value and
diff --git a/gcc/tree-ssa-threadupdate.c b/gcc/tree-ssa-threadupdate.c
index 43b6b88ac57..36b8f335a8e 100644
--- a/gcc/tree-ssa-threadupdate.c
+++ b/gcc/tree-ssa-threadupdate.c
@@ -208,7 +208,7 @@ create_block_for_threading (basic_block bb, struct redirection_data *rd)
    to update dominator tree and SSA graph after such changes.
 
    The key to keeping the SSA graph update managable is to duplicate
-   the side effects occuring in BB so that those side effects still
+   the side effects occurring in BB so that those side effects still
    occur on the paths which bypass BB after redirecting edges.
 
    We accomplish this by creating duplicates of BB and arranging for
diff --git a/gcc/value-prof.c b/gcc/value-prof.c
index a01c1c9b2da..3f9caeb223c 100644
--- a/gcc/value-prof.c
+++ b/gcc/value-prof.c
@@ -62,7 +62,7 @@ static struct value_prof_hooks *value_prof_hooks;
    -- list of counters starting from the first one.  */
 
 /* For speculative prefetching, the range in that we do not prefetch (because
-   we assume that it will be in cache anyway).  The assymetry between min and
+   we assume that it will be in cache anyway).  The asymmetry between min and
    max range is trying to reflect the fact that the sequential prefetching
    of the data is commonly done directly by hardware.  Nevertheless, these
    values are just a guess and should of course be target-specific.  */
@@ -971,7 +971,7 @@ speculative_prefetching_transform (rtx insn)
 
   /* We require that count is at least half of all; this means
      that for the transformation to fire the value must be constant
-     at least 50% of time (and 75% gives the garantee of usage).  */
+     at least 50% of time (and 75% gives the guarantee of usage).  */
   if (!rtx_equal_p (address, value) || 2 * count < all)
     return false;
 
diff --git a/gcc/vec.c b/gcc/vec.c
index a597db6dd86..1f9ac206282 100644
--- a/gcc/vec.c
+++ b/gcc/vec.c
@@ -49,7 +49,7 @@ vec_p_reserve (void *vec, int reserve MEM_STAT_DECL)
 /* Ensure there are at least RESERVE free slots in VEC, if RESERVE >=
    0.  If RESERVE < 0, increase the current allocation exponentially.
    VEC can be NULL, in which case a new vector is created.  The
-   vector's trailing array is at VEC_OFFSET offset and consistes of
+   vector's trailing array is at VEC_OFFSET offset and consists of
    ELT_SIZE sized elements.  */
 
 void *
diff --git a/gcc/vec.h b/gcc/vec.h
index a3eea311320..9708b4823bf 100644
--- a/gcc/vec.h
+++ b/gcc/vec.h
@@ -30,7 +30,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
    interoperate with the GTY machinery.
 
    Because of the different behaviour of objects and of pointers to
-   objects, there are two flavours.  One to deal with a vector of
+   objects, there are two flavors.  One to deal with a vector of
    pointers to objects, and one to deal with a vector of objects
    themselves.  Both of these pass pointers to objects around -- in
    the former case the pointers are stored into the vector and in the
@@ -277,7 +277,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
    void VEC_T_ordered_remove (VEC(T) *v, unsigned ix); // Object
    
    Remove an element from the IXth position of V. Ordering of
-   remaining elements is preserverd.  For pointer vectors returns the
+   remaining elements is preserved.  For pointer vectors returns the
    removed object.  This is an O(N) operation due to a memmove.  */
 
 #define VEC_ordered_remove(TDEF,V,I)	\