From c0bf89054a2bdaddccfe9a0794018f2b3f91ad40 Mon Sep 17 00:00:00 2001
From: David Malcolm <dmalcolm@redhat.com>
Date: Mon, 12 Jun 2017 16:43:06 -0400
Subject: [PATCH 1/3] FIXME: spelling corrections (found via
 -Wspellcheck-comments)

---
 gcc/alias.c                          | 22 +++++++-------
 gcc/alloc-pool.h                     |  2 +-
 gcc/asan.c                           |  4 +--
 gcc/auto-profile.c                   |  4 +--
 gcc/bb-reorder.c                     |  2 +-
 gcc/bitmap.h                         |  2 +-
 gcc/builtins.c                       | 10 +++----
 gcc/c-family/array-notation-common.c |  2 +-
 gcc/c-family/c-common.c              |  6 ++--
 gcc/c-family/c-common.h              |  2 +-
 gcc/c-family/c-cppbuiltin.c          |  2 +-
 gcc/c-family/c-opts.c                |  2 +-
 gcc/c-family/c-pretty-print.c        |  2 +-
 gcc/c-family/c-warn.c                |  2 +-
 gcc/c-family/cilk.c                  |  4 +--
 gcc/c/c-array-notation.c             |  2 +-
 gcc/c/c-parser.c                     |  6 ++--
 gcc/c/c-tree.h                       |  2 +-
 gcc/c/gimple-parser.c                |  2 +-
 gcc/calls.c                          |  2 +-
 gcc/ccmp.c                           |  8 +++---
 gcc/ccmp.h                           |  2 +-
 gcc/cfganal.c                        |  2 +-
 gcc/cfgexpand.c                      | 14 ++++-----
 gcc/cfgloop.c                        |  2 +-
 gcc/cgraph.c                         |  2 +-
 gcc/cgraph.h                         | 44 ++++++++++++++--------------
 gcc/cgraphclones.c                   |  4 +--
 gcc/cgraphunit.c                     | 28 +++++++++---------
 gcc/config.in                        |  2 +-
 gcc/config/i386/i386-c.c             |  2 +-
 gcc/config/i386/i386.c               | 56 ++++++++++++++++++------------------
 gcc/config/i386/i386.h               | 10 +++----
 gcc/config/i386/x86-tune.def         | 16 +++++------
 gcc/configure.ac                     |  2 +-
 gcc/coverage.c                       |  2 +-
 gcc/cp/call.c                        |  2 +-
 gcc/cp/class.c                       | 10 +++----
 gcc/cp/constexpr.c                   | 10 +++----
 gcc/cp/constraint.cc                 |  6 ++--
 gcc/cp/cp-array-notation.c           |  2 +-
 gcc/cp/cp-gimplify.c                 |  2 +-
 gcc/cp/cp-tree.h                     | 12 ++++----
 gcc/cp/cvt.c                         |  2 +-
 gcc/cp/decl.c                        |  4 +--
 gcc/cp/decl2.c                       |  2 +-
 gcc/cp/init.c                        |  6 ++--
 gcc/cp/lex.c                         |  2 +-
 gcc/cp/mangle.c                      |  2 +-
 gcc/cp/name-lookup.c                 | 10 +++----
 gcc/cp/name-lookup.h                 |  2 +-
 gcc/cp/parser.c                      |  2 +-
 gcc/cp/pt.c                          |  8 +++---
 gcc/cp/tree.c                        |  2 +-
 gcc/cp/vtable-class-hierarchy.c      | 12 ++++----
 gcc/cse.c                            |  4 +--
 gcc/cselib.c                         |  4 +--
 gcc/dce.c                            |  2 +-
 gcc/df-problems.c                    |  2 +-
 gcc/double-int.h                     |  4 +--
 gcc/dwarf2cfi.c                      |  2 +-
 gcc/dwarf2out.c                      | 34 +++++++++++-----------
 gcc/dwarf2out.h                      |  2 +-
 gcc/edit-context.c                   |  2 +-
 gcc/emit-rtl.h                       |  4 +--
 gcc/except.h                         |  2 +-
 gcc/expmed.c                         |  2 +-
 gcc/expr.c                           | 10 +++----
 gcc/fibonacci_heap.h                 |  4 +--
 gcc/fold-const.c                     |  8 +++---
 gcc/fortran/check.c                  |  4 +--
 gcc/fortran/class.c                  |  4 +--
 gcc/fortran/decl.c                   |  6 ++--
 gcc/fortran/expr.c                   |  2 +-
 gcc/fortran/frontend-passes.c        | 10 +++----
 gcc/fortran/gfortran.h               |  6 ++--
 gcc/fortran/intrinsic.c              |  2 +-
 gcc/fortran/primary.c                |  4 +--
 gcc/fortran/resolve.c                |  4 +--
 gcc/fortran/trans-array.c            |  4 +--
 gcc/fortran/trans-expr.c             |  4 +--
 gcc/fortran/trans-stmt.c             | 10 +++----
 gcc/fortran/trans.c                  |  2 +-
 gcc/function.c                       |  6 ++--
 gcc/gcc.c                            | 10 +++----
 gcc/gcov-dump.c                      |  2 +-
 gcc/gcov-io.c                        |  2 +-
 gcc/gcov.c                           |  2 +-
 gcc/genattrtab.c                     |  6 ++--
 gcc/genautomata.c                    |  2 +-
 gcc/gengtype-state.c                 |  6 ++--
 gcc/gengtype.c                       | 10 +++----
 gcc/gengtype.h                       |  2 +-
 gcc/genhooks.c                       |  4 +--
 gcc/genmatch.c                       |  8 +++---
 gcc/genopinit.c                      |  2 +-
 gcc/genoutput.c                      |  2 +-
 gcc/genrecog.c                       |  8 +++---
 gcc/gensupport.c                     |  2 +-
 gcc/ggc-page.c                       |  2 +-
 gcc/gimple-fold.c                    | 14 ++++-----
 gcc/gimple-ssa-split-paths.c         |  2 +-
 gcc/gimple-ssa-sprintf.c             | 14 ++++-----
 gcc/gimple-ssa-store-merging.c       |  2 +-
 gcc/gimple-ssa-strength-reduction.c  |  2 +-
 gcc/gimple.c                         |  2 +-
 gcc/gimple.def                       |  2 +-
 gcc/gimple.h                         | 10 +++----
 gcc/gimplify.c                       |  8 +++---
 gcc/graph.c                          |  2 +-
 gcc/haifa-sched.c                    |  8 +++---
 gcc/hash-table.h                     |  4 +--
 gcc/hsa-brig.c                       |  4 +--
 gcc/hsa-common.h                     |  4 +--
 gcc/hsa-gen.c                        |  6 ++--
 gcc/inchash.h                        |  8 +++---
 gcc/input.c                          |  4 +--
 gcc/internal-fn.h                    |  2 +-
 gcc/ipa-chkp.c                       |  2 +-
 gcc/ipa-cp.c                         | 18 ++++++------
 gcc/ipa-devirt.c                     | 16 +++++------
 gcc/ipa-fnsummary.c                  | 56 ++++++++++++++++++------------------
 gcc/ipa-fnsummary.h                  |  6 ++--
 gcc/ipa-icf-gimple.c                 |  6 ++--
 gcc/ipa-icf-gimple.h                 |  8 +++---
 gcc/ipa-icf.c                        | 10 +++----
 gcc/ipa-icf.h                        | 10 +++----
 gcc/ipa-inline-transform.c           |  2 +-
 gcc/ipa-inline.c                     | 20 ++++++-------
 gcc/ipa-polymorphic-call.c           | 36 +++++++++++------------
 gcc/ipa-predicate.c                  |  4 +--
 gcc/ipa-predicate.h                  |  2 +-
 gcc/ipa-profile.c                    |  2 +-
 gcc/ipa-prop.c                       | 26 ++++++++---------
 gcc/ipa-prop.h                       | 24 ++++++++--------
 gcc/ipa-ref.h                        |  2 +-
 gcc/ipa-reference.c                  |  2 +-
 gcc/ipa-split.c                      |  2 +-
 gcc/ipa-utils.c                      |  5 ++--
 gcc/ipa-utils.h                      |  2 +-
 gcc/ipa-visibility.c                 |  8 +++---
 gcc/ipa.c                            | 16 +++++------
 gcc/jit/jit-playback.c               |  6 ++--
 gcc/jit/jit-recording.c              |  6 ++--
 gcc/jit/libgccjit.c                  |  4 +--
 gcc/jit/libgccjit.h                  |  2 +-
 gcc/loop-invariant.c                 |  6 ++--
 gcc/loop-unroll.c                    |  2 +-
 gcc/lra-assigns.c                    |  2 +-
 gcc/lra-coalesce.c                   |  2 +-
 gcc/lra-constraints.c                | 22 +++++++-------
 gcc/lra-eliminations.c               |  4 +--
 gcc/lra-int.h                        |  2 +-
 gcc/lra-remat.c                      |  6 ++--
 gcc/lra.c                            |  4 +--
 gcc/lto-cgraph.c                     | 16 +++++------
 gcc/lto-opts.c                       |  2 +-
 gcc/lto-section-in.c                 |  2 +-
 gcc/lto-streamer-in.c                | 12 ++++----
 gcc/lto-streamer-out.c               | 10 +++----
 gcc/lto-streamer.h                   |  9 +++---
 gcc/lto-wrapper.c                    |  2 +-
 gcc/lto/lto-lang.c                   |  2 +-
 gcc/lto/lto-partition.c              |  8 +++---
 gcc/lto/lto-symtab.c                 | 19 ++++++------
 gcc/lto/lto.c                        | 10 +++----
 gcc/machmode.def                     |  2 +-
 gcc/machmode.h                       |  4 +--
 gcc/mem-stats.h                      | 14 ++++-----
 gcc/mode-switching.c                 |  4 +--
 gcc/modulo-sched.c                   |  4 +--
 gcc/omp-expand.c                     | 10 +++----
 gcc/omp-general.c                    |  6 ++--
 gcc/omp-general.h                    |  4 +--
 gcc/omp-grid.c                       |  6 ++--
 gcc/omp-low.c                        |  8 +++---
 gcc/omp-offload.c                    | 10 +++----
 gcc/omp-simd-clone.c                 |  4 +--
 gcc/optabs-query.c                   |  4 +--
 gcc/optabs.c                         | 12 ++++----
 gcc/opts.c                           |  2 +-
 gcc/params.def                       |  4 +--
 gcc/passes.c                         |  4 +--
 gcc/postreload-gcse.c                |  2 +-
 gcc/predict.c                        | 16 +++++------
 gcc/predict.def                      |  2 +-
 gcc/pretty-print.c                   |  2 +-
 gcc/print-rtl.c                      |  4 +--
 gcc/print-rtl.h                      |  2 +-
 gcc/profile.c                        |  2 +-
 gcc/read-md.h                        |  4 +--
 gcc/real.c                           |  2 +-
 gcc/reg-notes.def                    |  2 +-
 gcc/reginfo.c                        |  2 +-
 gcc/reload.c                         |  2 +-
 gcc/reload1.c                        |  2 +-
 gcc/resource.c                       |  4 +--
 gcc/rtl.def                          |  6 ++--
 gcc/sanopt.c                         |  2 +-
 gcc/sched-deps.c                     |  4 +--
 gcc/sel-sched-dump.c                 |  4 +--
 gcc/sel-sched-ir.h                   |  6 ++--
 gcc/sel-sched.c                      | 20 ++++++-------
 gcc/shrink-wrap.c                    |  4 +--
 gcc/simplify-rtx.c                   |  4 +--
 gcc/stringpool.h                     |  2 +-
 gcc/symbol-summary.h                 |  4 +--
 gcc/symtab.c                         | 18 ++++++------
 gcc/target-hooks-macros.h            |  4 +--
 gcc/target.def                       |  6 ++--
 gcc/targhooks.c                      |  4 +--
 gcc/trans-mem.c                      |  2 +-
 gcc/tree-cfg.c                       |  4 +--
 gcc/tree-cfgcleanup.c                |  6 ++--
 gcc/tree-chkp-opt.c                  |  4 +--
 gcc/tree-chkp.c                      | 44 ++++++++++++++--------------
 gcc/tree-chrec.c                     |  2 +-
 gcc/tree-core.h                      |  4 +--
 gcc/tree-data-ref.c                  |  6 ++--
 gcc/tree-eh.c                        |  4 +--
 gcc/tree-if-conv.c                   | 18 ++++++------
 gcc/tree-inline.c                    |  4 +--
 gcc/tree-into-ssa.c                  | 10 +++----
 gcc/tree-loop-distribution.c         |  5 ++--
 gcc/tree-predcom.c                   |  2 +-
 gcc/tree-profile.c                   |  4 +--
 gcc/tree-scalar-evolution.c          |  4 +--
 gcc/tree-sra.c                       |  8 +++---
 gcc/tree-ssa-address.c               |  2 +-
 gcc/tree-ssa-alias.c                 |  4 +--
 gcc/tree-ssa-ccp.c                   |  2 +-
 gcc/tree-ssa-coalesce.c              |  4 +--
 gcc/tree-ssa-dce.c                   | 14 ++++-----
 gcc/tree-ssa-dom.c                   |  4 +--
 gcc/tree-ssa-dse.c                   |  2 +-
 gcc/tree-ssa-forwprop.c              |  2 +-
 gcc/tree-ssa-ifcombine.c             |  2 +-
 gcc/tree-ssa-live.c                  |  2 +-
 gcc/tree-ssa-loop-im.c               |  4 +--
 gcc/tree-ssa-loop-ivcanon.c          | 12 ++++----
 gcc/tree-ssa-loop-ivopts.c           | 12 ++++----
 gcc/tree-ssa-loop-niter.c            | 14 ++++-----
 gcc/tree-ssa-loop-niter.h            |  2 +-
 gcc/tree-ssa-loop-prefetch.c         | 12 ++++----
 gcc/tree-ssa-math-opts.c             | 16 +++++------
 gcc/tree-ssa-pre.c                   |  6 ++--
 gcc/tree-ssa-propagate.c             |  2 +-
 gcc/tree-ssa-reassoc.c               |  8 +++---
 gcc/tree-ssa-sccvn.c                 |  2 +-
 gcc/tree-ssa-sink.c                  |  4 +--
 gcc/tree-ssa-strlen.c                |  2 +-
 gcc/tree-ssa-structalias.c           |  6 ++--
 gcc/tree-ssa-threadbackward.c        |  2 +-
 gcc/tree-ssa-threadedge.c            |  2 +-
 gcc/tree-ssa-threadupdate.c          |  2 +-
 gcc/tree-ssa-uninit.c                | 10 +++----
 gcc/tree-ssanames.h                  |  2 +-
 gcc/tree-streamer-out.c              |  2 +-
 gcc/tree-vect-data-refs.c            |  4 +--
 gcc/tree-vect-generic.c              |  2 +-
 gcc/tree-vect-loop-manip.c           |  4 +--
 gcc/tree-vect-loop.c                 |  6 ++--
 gcc/tree-vect-patterns.c             | 14 ++++-----
 gcc/tree-vect-slp.c                  | 10 +++----
 gcc/tree-vect-stmts.c                |  6 ++--
 gcc/tree-vectorizer.h                |  2 +-
 gcc/tree-vrp.c                       | 16 +++++------
 gcc/tree.c                           | 18 ++++++------
 gcc/tree.h                           |  8 +++---
 gcc/ubsan.c                          |  2 +-
 gcc/value-prof.c                     |  2 +-
 gcc/var-tracking.c                   |  2 +-
 gcc/varasm.c                         |  2 +-
 gcc/varpool.c                        | 12 ++++----
 gcc/wide-int.cc                      |  2 +-
 gcc/wide-int.h                       | 48 +++++++++++++++----------------
 include/ansidecl.h                   |  2 +-
 include/demangle.h                   |  4 +--
 include/gomp-constants.h             |  2 +-
 include/libiberty.h                  |  4 +--
 include/plugin-api.h                 |  2 +-
 include/safe-ctype.h                 |  2 +-
 include/splay-tree.h                 |  2 +-
 libcpp/include/cpplib.h              |  2 +-
 libcpp/include/line-map.h            |  4 +--
 libcpp/internal.h                    |  2 +-
 libgcc/libgcov-util.c                |  2 +-
 zlib/zlib.h                          |  6 ++--
 288 files changed, 935 insertions(+), 931 deletions(-)

diff --git a/gcc/alias.c b/gcc/alias.c
index cff4fac..656e0fe 100644
--- a/gcc/alias.c
+++ b/gcc/alias.c
@@ -130,11 +130,11 @@ struct GTY(()) alias_set_entry {
      alias set the same as alias set zero.  */
   bool has_zero_child;
   /* Nonzero if alias set corresponds to pointer type itself (i.e. not to
-     aggregate contaiing pointer.
+     aggregate containing pointer.
      This is used for a special case where we need an universal pointer type
      compatible with all other pointer types.  */
   bool is_pointer;
-  /* Nonzero if is_pointer or if one of childs have has_pointer set.  */
+  /* Nonzero if is_pointer or if one of children have has_pointer set.  */
   bool has_pointer;
 
   /* The children of the alias set.  These are not just the immediate
@@ -433,7 +433,7 @@ alias_set_subset_of (alias_set_type set1, alias_set_type set2)
      *ptr2 = ...
 
      Additionally if a set contains universal pointer, we consider every pointer
-     to be a subset of it, but we do not represent this explicitely - doing so
+     to be a subset of it, but we do not represent this explicitly - doing so
      would require us to update transitive closure each time we introduce new
      pointer type.  This makes aliasing_component_refs_p to return true
      on the following testcase:
@@ -455,7 +455,7 @@ alias_set_subset_of (alias_set_type set1, alias_set_type set2)
  	     them subset of each other.  */
 	  if (set1 == voidptr_set || set2 == voidptr_set)
 	    return true;
-	  /* If SET2 contains universal pointer's alias set, then we consdier
+	  /* If SET2 contains universal pointer's alias set, then we consider
  	     every (non-universal) pointer.  */
 	  if (ase2->children && set1 != voidptr_set
 	      && ase2->children->get (voidptr_set))
@@ -818,7 +818,7 @@ alias_ptr_types_compatible_p (tree t1, tree t2)
 	  == TYPE_MAIN_VARIANT (TREE_TYPE (t2)));
 }
 
-/* Create emptry alias set entry.  */
+/* Create empty alias set entry.  */
 
 alias_set_entry *
 init_alias_set_entry (alias_set_type set)
@@ -904,7 +904,7 @@ get_alias_set (tree t)
       /* Handle structure type equality for pointer types, arrays and vectors.
 	 This is easy to do, because the code bellow ignore canonical types on
 	 these anyway.  This is important for LTO, where TYPE_CANONICAL for
-	 pointers can not be meaningfuly computed by the frotnend.  */
+	 pointers can not be meaningfully computed by the frontend.  */
       if (canonical_type_used_p (t))
 	{
 	  /* In LTO we set canonical types for all types where it makes
@@ -992,9 +992,9 @@ get_alias_set (tree t)
      the pointed-to types.  This issue has been reported to the
      C++ committee.
 
-     For this reason go to canonical type of the unqalified pointer type.
+     For this reason go to canonical type of the unqualified pointer type.
      Until GCC 6 this code set all pointers sets to have alias set of
-     ptr_type_node but that is a bad idea, because it prevents disabiguations
+     ptr_type_node but that is a bad idea, because it prevents disambiguations
      in between pointers.  For Firefox this accounts about 20% of all
      disambiguations in the program.  */
   else if (POINTER_TYPE_P (t) && t != ptr_type_node)
@@ -1013,7 +1013,7 @@ get_alias_set (tree t)
 	   || TREE_CODE (p) == VECTOR_TYPE;
 	   p = TREE_TYPE (p))
 	{
-	  /* Ada supports recusive pointers.  Instead of doing recrusion check
+	  /* Ada supports recursive pointers.  Instead of doing recursion check
 	     just give up once the preallocated space of 8 elements is up.
 	     In this case just punt to void * alias set.  */
 	  if (reference.length () == 8)
@@ -1070,7 +1070,7 @@ get_alias_set (tree t)
 	  /* Assign the alias set to both p and t.
 	     We can not call get_alias_set (p) here as that would trigger
 	     infinite recursion when p == t.  In other cases it would just
-	     trigger unnecesary legwork of rebuilding the pointer again.  */
+	     trigger unnecessary legwork of rebuilding the pointer again.  */
 	  gcc_checking_assert (p == TYPE_MAIN_VARIANT (p));
 	  if (TYPE_ALIAS_SET_KNOWN_P (p))
 	    set = TYPE_ALIAS_SET (p);
@@ -2180,7 +2180,7 @@ base_alias_check (rtx x, rtx x_base, rtx y, rtx y_base,
      alias one another, though "char a; long b;" cannot.  AND addresses may
      implicitly alias surrounding objects; i.e. unaligned access in DImode
      via AND address can alias all surrounding object types except those
-     with aligment 8 or higher.  */
+     with alignment 8 or higher.  */
   if (GET_CODE (x) == AND && GET_CODE (y) == AND)
     return 1;
   if (GET_CODE (x) == AND
diff --git a/gcc/alloc-pool.h b/gcc/alloc-pool.h
index a5236db..a6a48d1 100644
--- a/gcc/alloc-pool.h
+++ b/gcc/alloc-pool.h
@@ -36,7 +36,7 @@ extern ALLOC_POOL_ID_TYPE last_id;
 /* Pool allocator memory usage.  */
 struct pool_usage: public mem_usage
 {
-  /* Default contructor.  */
+  /* Default constructor.  */
   pool_usage (): m_element_size (0), m_pool_name ("") {}
   /* Constructor.  */
   pool_usage (size_t allocated, size_t times, size_t peak,
diff --git a/gcc/asan.c b/gcc/asan.c
index bf564a4..64fd81c 100644
--- a/gcc/asan.c
+++ b/gcc/asan.c
@@ -1650,7 +1650,7 @@ insert_if_then_before_iter (gcond *cond,
 }
 
 /* Build (base_addr >> ASAN_SHADOW_SHIFT) + asan_shadow_offset ().
-   If RETURN_ADDRESS is set to true, return memory location instread
+   If RETURN_ADDRESS is set to true, return memory location instead
    of a value in the shadow memory.  */
 
 static tree
@@ -2930,7 +2930,7 @@ asan_expand_check_ifn (gimple_stmt_iterator *iter, bool use_calls)
 	   {
 	     //asan instrumentation code goes here.
 	   }
-	 // falltrough instructions, starting with *ITER.  */
+	 // fallthrough instructions, starting with *ITER.  */
 
       g = gimple_build_cond (NE_EXPR,
 			    len,
diff --git a/gcc/auto-profile.c b/gcc/auto-profile.c
index 0de1040..a550bb7 100644
--- a/gcc/auto-profile.c
+++ b/gcc/auto-profile.c
@@ -1159,7 +1159,7 @@ afdo_set_bb_count (basic_block bb, const stmt_set &promoted)
    3. BB1 and BB2 are in the same loop nest.
    This function finds the equivalent class for each basic block, and
    stores a pointer to the first BB in its equivalent class. Meanwhile,
-   set bb counts for the same equivalent class to be idenical. Update
+   set bb counts for the same equivalent class to be identical. Update
    ANNOTATED_BB for the first BB in its equivalent class.  */
 
 static void
@@ -1598,7 +1598,7 @@ early_inline ()
     update_ssa (TODO_update_ssa);
 }
 
-/* Use AutoFDO profile to annoate the control flow graph.
+/* Use AutoFDO profile to annotate the control flow graph.
    Return the todo flag.  */
 
 static unsigned int
diff --git a/gcc/bb-reorder.c b/gcc/bb-reorder.c
index a8d4256..88a45ca 100644
--- a/gcc/bb-reorder.c
+++ b/gcc/bb-reorder.c
@@ -590,7 +590,7 @@ find_traces_1_round (int branch_th, int exec_th, gcov_type count_th,
 	  /* If the best destination has multiple successors or predecessors,
 	     don't allow it to be added when optimizing for size.  This makes
 	     sure predecessors with smaller index are handled before the best
-	     destinarion.  It breaks long trace and reduces long jumps.
+	     destination.  It breaks long trace and reduces long jumps.
 
 	     Take if-then-else as an example.
 		A
diff --git a/gcc/bitmap.h b/gcc/bitmap.h
index ad53984..879f473 100644
--- a/gcc/bitmap.h
+++ b/gcc/bitmap.h
@@ -132,7 +132,7 @@ along with GCC; see the file COPYING3.  If not see
 /* Bitmap memory usage.  */
 struct bitmap_usage: public mem_usage
 {
-  /* Default contructor.  */
+  /* Default constructor.  */
   bitmap_usage (): m_nsearches (0), m_search_iter (0) {}
   /* Constructor.  */
   bitmap_usage (size_t allocated, size_t times, size_t peak,
diff --git a/gcc/builtins.c b/gcc/builtins.c
index 30462ad..36c3b96 100644
--- a/gcc/builtins.c
+++ b/gcc/builtins.c
@@ -299,7 +299,7 @@ get_object_alignment_2 (tree exp, unsigned int *alignp,
       unsigned HOST_WIDE_INT ptr_bitpos;
       unsigned HOST_WIDE_INT ptr_bitmask = ~0;
 
-      /* If the address is explicitely aligned, handle that.  */
+      /* If the address is explicitly aligned, handle that.  */
       if (TREE_CODE (addr) == BIT_AND_EXPR
 	  && TREE_CODE (TREE_OPERAND (addr, 1)) == INTEGER_CST)
 	{
@@ -867,7 +867,7 @@ expand_builtin_setjmp_setup (rtx buf_addr, rtx receiver_label)
 
 /* Construct the trailing part of a __builtin_setjmp call.  This is
    also called directly by the SJLJ exception handling code.
-   If RECEIVER_LABEL is NULL, instead contruct a nonlocal goto handler.  */
+   If RECEIVER_LABEL is NULL, instead construct a nonlocal goto handler.  */
 
 void
 expand_builtin_setjmp_receiver (rtx receiver_label)
@@ -1943,7 +1943,7 @@ mathfn_built_in_2 (tree type, combined_fn fn)
     return END_BUILTINS;
 }
 
-/* Return mathematic function equivalent to FN but operating directly on TYPE,
+/* Return mathematical function equivalent to FN but operating directly on TYPE,
    if available.  If IMPLICIT_P is true use the implicit builtin declaration,
    otherwise use the explicit declaration.  If we can't do the conversion,
    return null.  */
@@ -5830,7 +5830,7 @@ expand_builtin_atomic_compare_exchange (machine_mode mode, tree exp,
   if (target == const0_rtx)
     target = NULL;
 
-  /* Lest the rtl backend create a race condition with an imporoper store
+  /* Lest the rtl backend create a race condition with an improper store
      to memory, always create a new pseudo for OLDVAL.  */
   oldval = NULL;
 
@@ -6420,7 +6420,7 @@ expand_builtin_thread_pointer (tree exp, rtx target)
   if (icode != CODE_FOR_nothing)
     {
       struct expand_operand op;
-      /* If the target is not sutitable then create a new target. */
+      /* If the target is not suitable then create a new target. */
       if (target == NULL_RTX
 	  || !REG_P (target)
 	  || GET_MODE (target) != Pmode)
diff --git a/gcc/c-family/array-notation-common.c b/gcc/c-family/array-notation-common.c
index 3b95332..28e8726 100644
--- a/gcc/c-family/array-notation-common.c
+++ b/gcc/c-family/array-notation-common.c
@@ -76,7 +76,7 @@ extract_sec_implicit_index_arg (location_t location, tree fn)
   return return_int;
 }
 
-/* Returns true if there is a length mismatch among exprssions that are at the
+/* Returns true if there is a length mismatch among expressions that are at the
    same dimension and one the same side of the equal sign.  The Array notation
    lengths (LIST->LENGTH) is passed in as a 2D vector of trees.  */
 
diff --git a/gcc/c-family/c-common.c b/gcc/c-family/c-common.c
index 4395e51..93a1916 100644
--- a/gcc/c-family/c-common.c
+++ b/gcc/c-family/c-common.c
@@ -844,7 +844,7 @@ get_cpp_ttype_from_string_type (tree string_type)
   return CPP_OTHER;
 }
 
-/* The global record of string concatentations, for use in
+/* The global record of string concatenations, for use in
    extracting locations within string literals.  */
 
 GTY(()) string_concat_db *g_string_concat_db;
@@ -4451,7 +4451,7 @@ build_va_arg (location_t loc, tree expr, tree type)
       if (canon_va_type == NULL_TREE)
 	error_at (loc, "first argument to %<va_arg%> not of type %<va_list%>");
 
-      /* Let's handle things neutrallly, if expr:
+      /* Let's handle things neutrally, if expr:
 	 - has undeclared type, or
 	 - is not an va_list type.  */
       return build_va_arg_1 (loc, type, error_mark_node);
@@ -7914,7 +7914,7 @@ cb_get_suggestion (cpp_reader *, const char *goal,
   return bm.get_best_meaningful_candidate ();
 }
 
-/* Return the latice point which is the wider of the two FLT_EVAL_METHOD
+/* Return the lattice point which is the wider of the two FLT_EVAL_METHOD
    modes X, Y.  This isn't just  >, as the FLT_EVAL_METHOD values added
    by C TS 18661-3 for interchange  types that are computed in their
    native precision are larger than the C11 values for evaluating in the
diff --git a/gcc/c-family/c-common.h b/gcc/c-family/c-common.h
index 79072e6..a4cb584 100644
--- a/gcc/c-family/c-common.h
+++ b/gcc/c-family/c-common.h
@@ -1400,7 +1400,7 @@ extern bool c_check_cilk_loop (location_t, tree);
   TREE_OPERAND (ARRAY_NOTATION_CHECK (NODE), 3)
 
 /* This structure holds all the scalar values and its appropriate variable 
-   replacment.  It is mainly used by the function that pulls all the invariant
+   replacement.  It is mainly used by the function that pulls all the invariant
    parts that should be executed only once, which comes with array notation 
    expressions.  */
 struct inv_list
diff --git a/gcc/c-family/c-cppbuiltin.c b/gcc/c-family/c-cppbuiltin.c
index 083d5fd..e0227db 100644
--- a/gcc/c-family/c-cppbuiltin.c
+++ b/gcc/c-family/c-cppbuiltin.c
@@ -1727,7 +1727,7 @@ builtin_define_type_max (const char *macro, tree type)
   builtin_define_type_minmax (NULL, macro, type);
 }
 
-/* Given a value with COUNT LSBs set, fill BUF with a hexidecimal
+/* Given a value with COUNT LSBs set, fill BUF with a hexadecimal
    representation of that value.  For example, a COUNT of 10 would
    return "0x3ff".  */
 
diff --git a/gcc/c-family/c-opts.c b/gcc/c-family/c-opts.c
index be4478f..c32c554 100644
--- a/gcc/c-family/c-opts.c
+++ b/gcc/c-family/c-opts.c
@@ -1602,7 +1602,7 @@ set_std_cxx1z (int iso)
   flag_isoc99 = 1;
   flag_isoc11 = 1;
   cxx_dialect = cxx1z;
-  lang_hooks.name = "GNU C++14"; /* Pretend C++14 till standarization.  */
+  lang_hooks.name = "GNU C++14"; /* Pretend C++14 till standardization.  */
 }
 
 /* Args to -d specify what to dump.  Silently ignore
diff --git a/gcc/c-family/c-pretty-print.c b/gcc/c-family/c-pretty-print.c
index fdb7b41..e6fbb11 100644
--- a/gcc/c-family/c-pretty-print.c
+++ b/gcc/c-family/c-pretty-print.c
@@ -783,7 +783,7 @@ pp_c_attributes (c_pretty_printer *pp, tree attributes)
 }
 
 /* Pretty-print ATTRIBUTES using GNU C extension syntax for attributes
-   marked to be displayed on disgnostic.  */
+   marked to be displayed on diagnostic.  */
 
 void
 pp_c_attributes_display (c_pretty_printer *pp, tree a)
diff --git a/gcc/c-family/c-warn.c b/gcc/c-family/c-warn.c
index 012675b..d0a5843 100644
--- a/gcc/c-family/c-warn.c
+++ b/gcc/c-family/c-warn.c
@@ -1972,7 +1972,7 @@ do_warn_double_promotion (tree result_type, tree type1, tree type2,
      warn about it.  */
   if (c_inhibit_evaluation_warnings)
     return;
-  /* If an invalid conversion has occured, don't warn.  */
+  /* If an invalid conversion has occurred, don't warn.  */
   if (result_type == error_mark_node)
     return;
   if (TYPE_MAIN_VARIANT (result_type) != double_type_node
diff --git a/gcc/c-family/cilk.c b/gcc/c-family/cilk.c
index e6df498..430d295 100644
--- a/gcc/c-family/cilk.c
+++ b/gcc/c-family/cilk.c
@@ -47,7 +47,7 @@ enum add_variable_type {
 };
 
 enum cilk_block_type {
-    /* Indicates a _Cilk_spawn block.  30 was an arbitary number picked for 
+    /* Indicates a _Cilk_spawn block.  30 was an arbitrary number picked for
        ease of debugging.  */
     CILK_BLOCK_SPAWN = 30,
     /* Indicates _Cilk_for statement block.  */
@@ -922,7 +922,7 @@ add_variable (struct wrapper_data *wd, tree var, enum add_variable_type how)
 	  break;
 	  /* ADD_READ means
 	     1. For cilk_for, refer to the outer scope definition as-is
-	     2. For a spawned block, take a scalar in an rgument
+	     2. For a spawned block, take a scalar in an argument
 	     and otherwise refer to the outer scope definition as-is.
 	     3. For a spawned call, take a scalar in an argument.  */
 	case ADD_READ:
diff --git a/gcc/c/c-array-notation.c b/gcc/c/c-array-notation.c
index e430f5c..8daadc9 100644
--- a/gcc/c/c-array-notation.c
+++ b/gcc/c/c-array-notation.c
@@ -917,7 +917,7 @@ fix_conditional_array_notations_1 (tree stmt)
   else if (truth_value_p (TREE_CODE (stmt)))
     cond = TREE_OPERAND (stmt, 0);
   else
-    /* Otherwise dont even touch the statement.  */
+    /* Otherwise don't even touch the statement.  */
     return stmt;
 
   if (!find_rank (location, cond, cond, false, &rank))
diff --git a/gcc/c/c-parser.c b/gcc/c/c-parser.c
index 6f954f2..f5f1b45 100644
--- a/gcc/c/c-parser.c
+++ b/gcc/c/c-parser.c
@@ -69,7 +69,7 @@ along with GCC; see the file COPYING3.  If not see
 /* We need to walk over decls with incomplete struct/union/enum types
    after parsing the whole translation unit.
    In finish_decl(), if the decl is static, has incomplete
-   struct/union/enum type, it is appeneded to incomplete_record_decls.
+   struct/union/enum type, it is appended to incomplete_record_decls.
    In c_parser_translation_unit(), we iterate over incomplete_record_decls
    and report error if any of the decls are still incomplete.  */ 
 
@@ -5859,7 +5859,7 @@ c_parser_do_statement (c_parser *parser, bool ivdep)
    In Objective-C, there are two additional variants:
 
    foreach-statement:
-     for ( expression in expresssion ) statement
+     for ( expression in expression ) statement
      for ( declaration in expression ) statement
 
    This is inconsistent with C, because the second variant is allowed
@@ -5884,7 +5884,7 @@ c_parser_do_statement (c_parser *parser, bool ivdep)
       id object;
       for (object in array) { do something with object }
     }
-   Note that initizializing 'object' in some way (eg, "for ((object =
+   Note that initializing 'object' in some way (eg, "for ((object =
    xxx) in array) { do something with object }") is possibly
    technically valid, but completely pointless as 'object' will be
    assigned to something else as soon as the loop starts.  We should
diff --git a/gcc/c/c-tree.h b/gcc/c/c-tree.h
index ce25fae..cad8c75 100644
--- a/gcc/c/c-tree.h
+++ b/gcc/c/c-tree.h
@@ -350,7 +350,7 @@ struct c_declspecs {
   BOOL_BITFIELD complex_p : 1;
   /* Whether "inline" was specified.  */
   BOOL_BITFIELD inline_p : 1;
-  /* Whether "_Noreturn" was speciied.  */
+  /* Whether "_Noreturn" was specified.  */
   BOOL_BITFIELD noreturn_p : 1;
   /* Whether "__thread" or "_Thread_local" was specified.  */
   BOOL_BITFIELD thread_p : 1;
diff --git a/gcc/c/gimple-parser.c b/gcc/c/gimple-parser.c
index fb9a543..3638a67 100644
--- a/gcc/c/gimple-parser.c
+++ b/gcc/c/gimple-parser.c
@@ -141,7 +141,7 @@ c_parser_gimple_compound_statement (c_parser *parser, gimple_seq *seq)
   if (! c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
     return false;
 
-  /* A compund statement starts with optional declarations.  */
+  /* A compound statement starts with optional declarations.  */
   while (c_parser_next_tokens_start_declaration (parser))
     {
       c_parser_gimple_declaration (parser);
diff --git a/gcc/calls.c b/gcc/calls.c
index 91a4466..bd63b34 100644
--- a/gcc/calls.c
+++ b/gcc/calls.c
@@ -1342,7 +1342,7 @@ get_size_range (tree exp, tree range[2])
 
 /* Diagnose a call EXP to function FN decorated with attribute alloc_size
    whose argument numbers given by IDX with values given by ARGS exceed
-   the maximum object size or cause an unsigned oveflow (wrapping) when
+   the maximum object size or cause an unsigned overflow (wrapping) when
    multiplied.  When ARGS[0] is null the function does nothing.  ARGS[1]
    may be null for functions like malloc, and non-null for those like
    calloc that are decorated with a two-argument attribute alloc_size.  */
diff --git a/gcc/ccmp.c b/gcc/ccmp.c
index 92ca133..633d682 100644
--- a/gcc/ccmp.c
+++ b/gcc/ccmp.c
@@ -92,8 +92,8 @@ ccmp_candidate_p (gimple *g)
   gs1 = get_gimple_for_ssa_name (op1);
   if (!gs0 || !gs1 || !is_gimple_assign (gs0) || !is_gimple_assign (gs1)
       /* g, gs0 and gs1 must be in the same basic block, since current stage
-	 is out-of-ssa.  We can not guarantee the correctness when forwording
-	 the gs0 and gs1 into g whithout DATAFLOW analysis.  */
+	 is out-of-ssa.  We can not guarantee the correctness when forwarding
+	 the gs0 and gs1 into g without DATAFLOW analysis.  */
       || gimple_bb (gs0) != gimple_bb (gs1)
       || gimple_bb (gs0) != gimple_bb (g))
     return false;
@@ -118,7 +118,7 @@ ccmp_candidate_p (gimple *g)
    result of the previous CMP or CCMP.  The function expands the
    next compare based on G which is ANDed/ORed with the previous
    compare depending on CODE.
-   PREP_SEQ returns all insns to prepare opearands for compare.
+   PREP_SEQ returns all insns to prepare operands for compare.
    GEN_SEQ returns all compare insns.  */
 static rtx
 expand_ccmp_next (gimple *g, tree_code code, rtx prev,
@@ -146,7 +146,7 @@ expand_ccmp_next (gimple *g, tree_code code, rtx prev,
 
    hook gen_ccmp_first is used to expand the first compare.
    hook gen_ccmp_next is used to expand the following CCMP.
-   PREP_SEQ returns all insns to prepare opearand.
+   PREP_SEQ returns all insns to prepare operand.
    GEN_SEQ returns all compare insns.  */
 static rtx
 expand_ccmp_expr_1 (gimple *g, rtx_insn **prep_seq, rtx_insn **gen_seq)
diff --git a/gcc/ccmp.h b/gcc/ccmp.h
index bc1aafb..73364f3 100644
--- a/gcc/ccmp.h
+++ b/gcc/ccmp.h
@@ -1,4 +1,4 @@
-/* Conditional comapre related functions.
+/* Conditional compare related functions.
    Copyright (C) 2014-2017 Free Software Foundation, Inc.
 
 This file is part of GCC.
diff --git a/gcc/cfganal.c b/gcc/cfganal.c
index a3a6ea8..72ba76c 100644
--- a/gcc/cfganal.c
+++ b/gcc/cfganal.c
@@ -711,7 +711,7 @@ post_order_compute (int *post_order, bool include_entry_exit,
 
 /* Helper routine for inverted_post_order_compute
    flow_dfs_compute_reverse_execute, and the reverse-CFG
-   deapth first search in dominance.c.
+   depth first search in dominance.c.
    BB has to belong to a region of CFG
    unreachable by inverted traversal from the exit.
    i.e. there's no control flow path from ENTRY to EXIT
diff --git a/gcc/cfgexpand.c b/gcc/cfgexpand.c
index 698d43b..3817127 100644
--- a/gcc/cfgexpand.c
+++ b/gcc/cfgexpand.c
@@ -88,7 +88,7 @@ along with GCC; see the file COPYING3.  If not see
 struct ssaexpand SA;
 
 /* This variable holds the currently expanded gimple statement for purposes
-   of comminucating the profile info to the builtin expanders.  */
+   of communicating the profile info to the builtin expanders.  */
 gimple *currently_expanding_gimple_stmt;
 
 static rtx expand_debug_expr (tree);
@@ -1248,7 +1248,7 @@ set_parm_rtl (tree parm, rtx x)
 					      TYPE_MODE (TREE_TYPE (parm)),
 					      TYPE_ALIGN (TREE_TYPE (parm)));
 
-      /* If the variable alignment is very large we'll dynamicaly
+      /* If the variable alignment is very large we'll dynamically
 	 allocate it, which means that in-frame portion is just a
 	 pointer.  ??? We've got a pseudo for sure here, do we
 	 actually dynamically allocate its spilling area if needed?
@@ -1372,7 +1372,7 @@ expand_one_ssa_partition (tree var)
 					  TYPE_MODE (TREE_TYPE (var)),
 					  TYPE_ALIGN (TREE_TYPE (var)));
 
-  /* If the variable alignment is very large we'll dynamicaly allocate
+  /* If the variable alignment is very large we'll dynamically allocate
      it, which means that in-frame portion is just a pointer.  */
   if (align > MAX_SUPPORTED_STACK_ALIGNMENT)
     align = POINTER_SIZE;
@@ -1589,7 +1589,7 @@ expand_one_var (tree var, bool toplevel, bool really_expand)
       else
 	align = MINIMUM_ALIGNMENT (var, DECL_MODE (var), DECL_ALIGN (var));
 
-      /* If the variable alignment is very large we'll dynamicaly allocate
+      /* If the variable alignment is very large we'll dynamically allocate
 	 it, which means that in-frame portion is just a pointer.  */
       if (align > MAX_SUPPORTED_STACK_ALIGNMENT)
 	align = POINTER_SIZE;
@@ -2826,7 +2826,7 @@ expand_asm_stmt (gasm *stmt)
     }
 
   /* There are some legacy diagnostics in here, and also avoids a
-     sixth parameger to targetm.md_asm_adjust.  */
+     sixth parameter to targetm.md_asm_adjust.  */
   save_input_location s_i_l(locus);
 
   unsigned noutputs = gimple_asm_noutputs (stmt);
@@ -6223,7 +6223,7 @@ pass_expand::execute (function *fun)
   fun->cfg->max_jumptable_ents = 0;
 
   /* Resovle the function section.  Some targets, like ARM EABI rely on knowledge
-     of the function section at exapnsion time to predict distance of calls.  */
+     of the function section at expansion time to predict distance of calls.  */
   resolve_unique_section (current_function_decl, 0, flag_function_sections);
 
   /* Expand the variables recorded during gimple lowering.  */
@@ -6260,7 +6260,7 @@ pass_expand::execute (function *fun)
       emit_insn_before (var_seq, parm_birth_insn);
 
       /* In expand_function_end we'll insert the alloca save/restore
-	 before parm_birth_insn.  We've just insertted an alloca call.
+	 before parm_birth_insn.  We've just inserted an alloca call.
 	 Adjust the pointer to match.  */
       parm_birth_insn = var_seq;
     }
diff --git a/gcc/cfgloop.c b/gcc/cfgloop.c
index 654d188..ee5fe90 100644
--- a/gcc/cfgloop.c
+++ b/gcc/cfgloop.c
@@ -1895,7 +1895,7 @@ likely_max_stmt_executions_int (struct loop *loop)
 bool
 get_estimated_loop_iterations (struct loop *loop, widest_int *nit)
 {
-  /* Even if the bound is not recorded, possibly we can derrive one from
+  /* Even if the bound is not recorded, possibly we can derive one from
      profile.  */
   if (!loop->any_estimate)
     {
diff --git a/gcc/cgraph.c b/gcc/cgraph.c
index 3932006..ac8db64 100644
--- a/gcc/cgraph.c
+++ b/gcc/cgraph.c
@@ -2580,7 +2580,7 @@ set_const_flag_1 (cgraph_node *node, bool set_const, bool looping,
    If SET_CONST if false, clear the flag.
 
    When setting the flag be careful about possible interposition and
-   do not set the flag for functions that can be interposet and set pure
+   do not set the flag for functions that can be interposed and set pure
    flag for functions that can bind to other definition. 
 
    Return true if any change was done. */
diff --git a/gcc/cgraph.h b/gcc/cgraph.h
index 72f9702..0dcd6f4 100644
--- a/gcc/cgraph.h
+++ b/gcc/cgraph.h
@@ -82,7 +82,7 @@ enum symbol_partitioning_class
    /* External declarations are ignored by partitioning algorithms and they are
       added into the boundary later via compute_ltrans_boundary.  */
    SYMBOL_EXTERNAL,
-   /* Partitioned symbols are pur into one of partitions.  */
+   /* Partitioned symbols are put into one of partitions.  */
    SYMBOL_PARTITION,
    /* Duplicated symbols (such as comdat or constant pool references) are
       copied into every node needing them via add_symbol_to_partition.  */
@@ -145,7 +145,7 @@ public:
   void clone_references (symtab_node *node);
 
   /* Remove all stmt references in non-speculative references.
-     Those are not maintained during inlining & clonning.
+     Those are not maintained during inlining & cloning.
      The exception are speculative references that are updated along
      with callgraph edges associated with them.  */
   void clone_referring (symtab_node *node);
@@ -162,7 +162,7 @@ public:
   void remove_stmt_references (gimple *stmt);
 
   /* Remove all stmt references in non-speculative references.
-     Those are not maintained during inlining & clonning.
+     Those are not maintained during inlining & cloning.
      The exception are speculative references that are updated along
      with callgraph edges associated with them.  */
   void clear_stmts_in_references (void);
@@ -449,7 +449,7 @@ public:
 	 by varasm.c. For those DECL_ASSEMBLER_NAME have
 	 IDENTIFIER_TRANSPARENT_ALIAS set and thus also their assembler
 	 name must be unique.
-	 Weakrefs belong to this cateogry when we target assembler without
+	 Weakrefs belong to this category when we target assembler without
 	 .weakref directive.
        - weakrefs that are renamed by assembler via .weakref directive.
 	 In this case the alias may or may not be definition (depending if
@@ -935,7 +935,7 @@ public:
      version node.
 
      If non-NULL BLOCK_TO_COPY determine what basic blocks
-     was copied to prevent duplications of calls that are dead
+     was copied to prevent duplication of calls that are dead
      in the clone.
 
      SUFFIX is string that is appended to the original name.  */
@@ -1070,7 +1070,7 @@ public:
   /* Likewise indicate that a node is having address taken.  */
   void mark_address_taken (void);
 
-  /* Set fialization priority to PRIORITY.  */
+  /* Set finalization priority to PRIORITY.  */
   void set_fini_priority (priority_type priority);
 
   /* Return the finalization priority.  */
@@ -1123,7 +1123,7 @@ public:
     If SET_CONST if false, clear the flag.
 
     When setting the flag be careful about possible interposition and
-    do not set the flag for functions that can be interposet and set pure
+    do not set the flag for functions that can be interposed and set pure
     flag for functions that can bind to other definition. 
 
     Return true if any change was done. */
@@ -1486,7 +1486,7 @@ public:
   ipa_polymorphic_call_context (cgraph_edge *e);
   /* Build polymorphic call context for IP invariant CST.
      If specified, OTR_TYPE specify the type of polymorphic call
-     that takes CST+OFFSET as a prameter.  */
+     that takes CST+OFFSET as a parameter.  */
   ipa_polymorphic_call_context (tree cst, tree otr_type = NULL,
 				HOST_WIDE_INT offset = 0);
   /* Build context for pointer REF contained in FNDECL at statement STMT.
@@ -1502,7 +1502,7 @@ public:
   /* Make context non-speculative.  */
   void clear_speculation ();
 
-  /* Produce context specifying all derrived types of OTR_TYPE.  If OTR_TYPE is
+  /* Produce context specifying all derived types of OTR_TYPE.  If OTR_TYPE is
      NULL, the context is set to dummy "I know nothing" setting.  */
   void clear_outer_type (tree otr_type = NULL);
 
@@ -1525,8 +1525,8 @@ public:
   /* Use when we can not track dynamic type change.  This speculatively assume
      type change is not happening.  */
   void possible_dynamic_type_change (bool, tree otr_type = NULL);
-  /* Assume that both THIS and a given context is valid and strenghten THIS
-     if possible.  Return true if any strenghtening was made.
+  /* Assume that both THIS and a given context is valid and strengthen THIS
+     if possible.  Return true if any strengthening was made.
      If actual type the context is being used in is known, OTR_TYPE should be
      set accordingly. This improves quality of combined result.  */
   bool combine_with (ipa_polymorphic_call_context, tree otr_type = NULL);
@@ -1572,7 +1572,7 @@ struct GTY(()) cgraph_indirect_call_info
   int param_index;
   /* ECF flags determined from the caller.  */
   int ecf_flags;
-  /* Profile_id of common target obtrained from profile.  */
+  /* Profile_id of common target obtained from profile.  */
   int common_target_id;
   /* Probability that call will land in function with COMMON_TARGET_ID.  */
   int common_target_probability;
@@ -1720,10 +1720,10 @@ struct GTY((chain_next ("%h.next_caller"), chain_prev ("%h.prev_caller"),
      to a same call statement:
      1) a direct call (to expected_fn)
      2) an indirect call (to call_target)
-     3) a IPA_REF_ADDR refrence to expected_fn.
+     3) a IPA_REF_ADDR reference to expected_fn.
 
      Optimizers may later redirect direct call to clone, so 1) and 3)
-     do not need to necesarily agree with destination.  */
+     do not need to necessarily agree with destination.  */
   unsigned int speculative : 1;
   /* Set to true when caller is a constructor or destructor of polymorphic
      type.  */
@@ -1865,7 +1865,7 @@ public:
   unsigned output : 1;
 
   /* Set when variable has statically initialized pointer
-     or is a static bounds variable and needs initalization.  */
+     or is a static bounds variable and needs initialization.  */
   unsigned need_bounds_init : 1;
 
   /* Set if the variable is dynamically initialized, except for
@@ -1913,7 +1913,7 @@ is_a_helper <cgraph_node *>::test (symtab_node *p)
   return p && p->type == SYMTAB_FUNCTION;
 }
 
-/* Report whether or not THIS symtab node is a vriable, aka varpool_node.  */
+/* Report whether or not THIS symtab node is a variable, aka varpool_node.  */
 
 template <>
 template <>
@@ -1999,8 +1999,8 @@ public:
   /* C++ frontend produce same body aliases all over the place, even before PCH
      gets streamed out. It relies on us linking the aliases with their function
      in order to do the fixups, but ipa-ref is not PCH safe.  Consequentely we
-     first produce aliases without links, but once C++ FE is sure he won't sream
-     PCH we build the links via this function.  */
+     first produce aliases without links, but once C++ FE is sure it won't
+     stream PCH we build the links via this function.  */
   void process_same_body_aliases (void);
 
   /* Perform simple optimizations based on callgraph.  */
@@ -2224,7 +2224,7 @@ public:
 
   bool cpp_implicit_aliases_done;
 
-  /* Hash table used to hold sectoons.  */
+  /* Hash table used to hold sections.  */
   hash_table<section_name_hasher> *GTY(()) section_hash;
 
   /* Hash table used to convert assembler names into nodes.  */
@@ -2376,7 +2376,7 @@ symtab_node::real_symbol_p (void)
 }
 
 /* Return true if DECL should have entry in symbol table if used.
-   Those are functions and static & external veriables*/
+   Those are functions and static & external variables.  */
 
 static inline bool
 decl_in_symtab_p (const_tree decl)
@@ -3192,7 +3192,7 @@ varpool_node::call_for_symbol_and_aliases (bool (*callback) (varpool_node *,
   return false;
 }
 
-/* Return true if refernece may be used in address compare.  */
+/* Return true if reference may be used in address compare.  */
 
 inline bool
 ipa_ref::address_matters_p ()
@@ -3235,7 +3235,7 @@ ipa_polymorphic_call_context::clear_speculation ()
   speculative_maybe_derived_type = false;
 }
 
-/* Produce context specifying all derrived types of OTR_TYPE.  If OTR_TYPE is
+/* Produce context specifying all derived types of OTR_TYPE.  If OTR_TYPE is
    NULL, the context is set to dummy "I know nothing" setting.  */
 
 inline void
diff --git a/gcc/cgraphclones.c b/gcc/cgraphclones.c
index ec90066..39f6083 100644
--- a/gcc/cgraphclones.c
+++ b/gcc/cgraphclones.c
@@ -18,7 +18,7 @@ You should have received a copy of the GNU General Public License
 along with GCC; see the file COPYING3.  If not see
 <http://www.gnu.org/licenses/>.  */
 
-/* This module provide facilities for clonning functions. I.e. creating
+/* This module provide facilities for cloning functions. I.e. creating
    new functions based on existing functions with simple modifications,
    such as replacement of parameters.
 
@@ -496,7 +496,7 @@ cgraph_node::create_clone (tree new_decl, gcov_type gcov_count, int freq,
     {
       /* Redirect calls to the old version node to point to its new
 	 version.  The only exception is when the edge was proved to
-	 be unreachable during the clonning procedure.  */
+	 be unreachable during the cloning procedure.  */
       if (!e->callee
 	  || DECL_BUILT_IN_CLASS (e->callee->decl) != BUILT_IN_NORMAL
 	  || DECL_FUNCTION_CODE (e->callee->decl) != BUILT_IN_UNREACHABLE)
diff --git a/gcc/cgraphunit.c b/gcc/cgraphunit.c
index 7b4f47e..eaa0d51 100644
--- a/gcc/cgraphunit.c
+++ b/gcc/cgraphunit.c
@@ -75,7 +75,7 @@ along with GCC; see the file COPYING3.  If not see
 	   a) early optimizations. These are local passes executed in
 	      the topological order on the callgraph.
 
-	      The purpose of early optimiations is to optimize away simple
+	      The purpose of early optimizations is to optimize away simple
 	      things that may otherwise confuse IP analysis. Very simple
 	      propagation across the callgraph is done i.e. to discover
 	      functions without side effects and simple inlining is performed.
@@ -83,7 +83,7 @@ along with GCC; see the file COPYING3.  If not see
 	   b) early small interprocedural passes.
 
 	      Those are interprocedural passes executed only at compilation
-	      time.  These include, for example, transational memory lowering,
+	      time.  These include, for example, transactional memory lowering,
 	      unreachable code removal and other simple transformations.
 
 	   c) IP analysis stage.  All interprocedural passes do their
@@ -95,7 +95,7 @@ along with GCC; see the file COPYING3.  If not see
 	      both reduce linking times and linktime memory usage by	
 	      not having to represent whole program in memory.
 
-	   d) LTO sreaming.  When doing LTO, everything important gets
+	   d) LTO streaming.  When doing LTO, everything important gets
 	      streamed into the object file.
 
        Compile time and or linktime analysis stage (WPA):
@@ -107,7 +107,7 @@ along with GCC; see the file COPYING3.  If not see
 	      IP propagation. This is done based on the earlier analysis
 	      without having function bodies at hand.
 	   f) Ltrans streaming.  When doing WHOPR LTO, the program
-	      is partitioned and streamed into multple object files.
+	      is partitioned and streamed into multiple object files.
 
        Compile time and/or parallel linktime stage (ltrans)
 
@@ -118,7 +118,7 @@ along with GCC; see the file COPYING3.  If not see
 	 2) Virtual clone materialization
 	    (cgraph_materialize_clone)
 
-	    IP passes can produce copies of existing functoins (such
+	    IP passes can produce copies of existing functions (such
 	    as versioned clones or inline clones) without actually
 	    manipulating their bodies by creating virtual clones in
 	    the callgraph. At this time the virtual clones are
@@ -335,7 +335,7 @@ symbol_table::process_new_functions (void)
 	    {
 	      bool summaried_computed = ipa_fn_summaries != NULL;
 	      g->get_passes ()->execute_early_local_passes ();
-	      /* Early passes compure inline parameters to do inlining
+	      /* Early passes compute inline parameters to do inlining
 		 and splitting.  This is redundant for functions added late.
 		 Just throw away whatever it did.  */
 	      if (!summaried_computed)
@@ -691,7 +691,7 @@ cgraph_node::analyze (void)
 /* C++ frontend produce same body aliases all over the place, even before PCH
    gets streamed out. It relies on us linking the aliases with their function
    in order to do the fixups, but ipa-ref is not PCH safe.  Consequentely we
-   first produce aliases without links, but once C++ FE is sure he won't sream
+   first produce aliases without links, but once C++ FE is sure he won't stream
    PCH we build the links via this function.  */
 
 void
@@ -842,7 +842,7 @@ varpool_node::finalize_decl (tree decl)
   notice_global_symbol (decl);
   if (TREE_THIS_VOLATILE (decl) || DECL_PRESERVE_P (decl)
       /* Traditionally we do not eliminate static variables when not
-	 optimizing and when not doing toplevel reoder.  */
+	 optimizing and when not doing toplevel reorder.  */
       || node->no_reorder
       || ((!flag_toplevel_reorder
           && !DECL_COMDAT (node->decl)
@@ -868,7 +868,7 @@ varpool_node::finalize_decl (tree decl)
 /* EDGE is an polymorphic call.  Mark all possible targets as reachable
    and if there is only one target, perform trivial devirtualization. 
    REACHABLE_CALL_TARGETS collects target lists we already walked to
-   avoid udplicate work.  */
+   avoid duplicate work.  */
 
 static void
 walk_polymorphic_call_targets (hash_set<void *> *reachable_call_targets,
@@ -1133,7 +1133,7 @@ analyze_functions (bool first_time)
 			|| opt_for_fn (edge->callee->decl, optimize)
 			/* Weakrefs needs to be preserved.  */
 			|| edge->callee->alias
-			/* always_inline functions are inlined aven at -O0.  */
+			/* always_inline functions are inlined even at -O0.  */
 		        || lookup_attribute
 				 ("always_inline",
 			          DECL_ATTRIBUTES (edge->callee->decl))
@@ -1728,7 +1728,7 @@ cgraph_node::expand_thunk (bool output_asm_thunks, bool force_gimple_thunk)
       greturn *ret;
       bool alias_is_noreturn = TREE_THIS_VOLATILE (alias);
 
-      /* We may be called from expand_thunk that releses body except for
+      /* We may be called from expand_thunk that releases body except for
 	 DECL_ARGUMENTS.  In this case force_gimple_thunk is true.  */
       if (in_lto_p && !force_gimple_thunk)
 	get_untransformed_body ();
@@ -1832,7 +1832,7 @@ cgraph_node::expand_thunk (bool output_asm_thunks, bool force_gimple_thunk)
       gimple_call_set_from_thunk (call, true);
       gimple_call_set_with_bounds (call, instrumentation_clone);
 
-      /* Return slot optimization is always possible and in fact requred to
+      /* Return slot optimization is always possible and in fact required to
          return values with DECL_BY_REFERENCE.  */
       if (aggregate_value_p (resdecl, TREE_TYPE (thunk_fndecl))
 	  && (!is_gimple_reg_type (TREE_TYPE (resdecl))
@@ -2507,14 +2507,14 @@ symbol_table::compile (void)
 
   /* When weakref support is missing, we automatically translate all
      references to NODE to references to its ultimate alias target.
-     The renaming mechanizm uses flag IDENTIFIER_TRANSPARENT_ALIAS and
+     The renaming mechanism uses flag IDENTIFIER_TRANSPARENT_ALIAS and
      TREE_CHAIN.
 
      Set up this mapping before we output any assembler but once we are sure
      that all symbol renaming is done.
 
      FIXME: All this uglyness can go away if we just do renaming at gimple
-     level by physically rewritting the IL.  At the moment we can only redirect
+     level by physically rewriting the IL.  At the moment we can only redirect
      calls, so we need infrastructure for renaming references as well.  */
 #ifndef ASM_OUTPUT_WEAKREF
   symtab_node *node;
diff --git a/gcc/config.in b/gcc/config.in
index bf2aa7b..e7ebed5 100644
--- a/gcc/config.in
+++ b/gcc/config.in
@@ -220,7 +220,7 @@
 #endif
 
 
-/* Define if you want all gimple types to be verified after gimplifiation.
+/* Define if you want all gimple types to be verified after gimplification.
    This is cheap. */
 #ifndef USED_FOR_TARGET
 #undef ENABLE_TYPES_CHECKING
diff --git a/gcc/config/i386/i386-c.c b/gcc/config/i386/i386-c.c
index 9a79a21..b838cdd 100644
--- a/gcc/config/i386/i386-c.c
+++ b/gcc/config/i386/i386-c.c
@@ -42,7 +42,7 @@ ix86_target_macros_internal (HOST_WIDE_INT isa_flag,
 			     void (*def_or_undef) (cpp_reader *,
 						   const char *))
 {
-  /* For some of the k6/pentium varients there weren't separate ISA bits to
+  /* For some of the k6/pentium variants there weren't separate ISA bits to
      identify which tune/arch flag was passed, so figure it out here.  */
   size_t arch_len = strlen (ix86_arch_string);
   size_t tune_len = strlen (ix86_tune_string);
diff --git a/gcc/config/i386/i386.c b/gcc/config/i386/i386.c
index 94a84b3..b47d747 100644
--- a/gcc/config/i386/i386.c
+++ b/gcc/config/i386/i386.c
@@ -2078,7 +2078,7 @@ struct processor_costs generic_cost = {
   1,					/* cond_not_taken_branch_cost.  */
 };
 
-/* core_cost should produce code tuned for Core familly of CPUs.  */
+/* core_cost should produce code tuned for Core family of CPUs.  */
 static stringop_algs core_memcpy[2] = {
   {libcall, {{1024, rep_prefix_4_byte, true}, {-1, libcall, false}}},
   {libcall, {{24, loop, true}, {128, rep_prefix_8_byte, true},
@@ -3614,7 +3614,7 @@ scalar_chain::build (bitmap candidates, unsigned insn_uid)
   BITMAP_FREE (queue);
 }
 
-/* Return a cost of building a vector costant
+/* Return a cost of building a vector constant
    instead of using a scalar one.  */
 
 int
@@ -8365,8 +8365,8 @@ ix86_function_regparm (const_tree type, const_tree decl)
    DFmode (2) arguments in SSE registers for a function with the
    indicated TYPE and DECL.  DECL may be NULL when calling function
    indirectly or considering a libcall.  Return -1 if any FP parameter
-   should be rejected by error.  This is used in siutation we imply SSE
-   calling convetion but the function is called from another function with
+   should be rejected by error.  This is used in situation we imply SSE
+   calling convention but the function is called from another function with
    SSE disabled. Otherwise return 0.  */
 
 static int
@@ -9002,7 +9002,7 @@ init_cumulative_args (CUMULATIVE_ARGS *cum,  /* Argument info to initialize */
    select the proper ABI location for the operand and not depend on whatever
    the middle-end decides to do with these vector types.
 
-   The midde-end can't deal with the vector types > 16 bytes.  In this
+   The middle-end can't deal with the vector types > 16 bytes.  In this
    case, we return the original mode and warn ABI change if CUM isn't
    NULL. 
 
@@ -10943,7 +10943,7 @@ ix86_function_value (const_tree valtype, const_tree fntype_or_decl, bool)
 }
 
 /*  Return an RTX representing a place where a function returns
-    or recieves pointer bounds or NULL if no bounds are returned.
+    or receives pointer bounds or NULL if no bounds are returned.
 
     VALTYPE is a data type of a value returned by the function.
 
@@ -11091,7 +11091,7 @@ ix86_return_in_memory (const_tree type, const_tree fntype ATTRIBUTE_UNUSED)
 	  if (size < 8)
 	    return false;
 
-	  /* Unless ABI prescibes otherwise,
+	  /* Unless ABI prescribes otherwise,
 	     MMX/3dNow values are returned in MM0 if available.  */
 	     
 	  if (size == 8)
@@ -12688,7 +12688,7 @@ ix86_save_reg (unsigned int regno, bool maybe_eh_return, bool ignore_outlined)
 	  && (regno != HARD_FRAME_POINTER_REGNUM || !frame_pointer_needed));
 }
 
-/* Return number of saved general prupose registers.  */
+/* Return number of saved general purpose registers.  */
 
 static int
 ix86_nsaved_regs (void)
@@ -12842,7 +12842,7 @@ ix86_compute_frame_layout (void)
   m->call_ms2sysv_pad_out = 0;
 
   /* 64-bit MS ABI seem to require stack alignment to be always 16,
-     except for function prologues, leaf functions and when the defult
+     except for function prologues, leaf functions and when the default
      incoming stack boundary is overriden at command line or via
      force_align_arg_pointer attribute.  */
   if ((TARGET_64BIT_MS_ABI && crtl->preferred_stack_boundary < 128)
@@ -13216,7 +13216,7 @@ choose_basereg (HOST_WIDE_INT cfa_offset, rtx &base_reg,
 /* Return an RTX that points to CFA_OFFSET within the stack frame and
    the alignment of address.  If align is non-null, it should point to
    an alignment value (in bits) that is preferred or zero and will
-   recieve the alignment of the base register that was selected.  The
+   receive the alignment of the base register that was selected.  The
    valid base registers are taken from CFUN->MACHINE->FS.  */
 
 static rtx
@@ -13267,7 +13267,7 @@ ix86_emit_save_reg_using_mov (machine_mode mode, unsigned int regno,
   addr = choose_baseaddr (cfa_offset, &align);
   mem = gen_frame_mem (mode, addr);
 
-  /* The location aligment depends upon the base register.  */
+  /* The location alignment depends upon the base register.  */
   align = MIN (GET_MODE_ALIGNMENT (mode), align);
   gcc_assert (! (cfa_offset & (align / BITS_PER_UNIT - 1)));
   set_mem_align (mem, align);
@@ -14764,7 +14764,7 @@ ix86_expand_prologue (void)
     }
   gcc_assert (m->fs.sp_offset == frame.stack_pointer_offset);
 
-  /* If we havn't already set up the frame pointer, do so now.  */
+  /* If we haven't already set up the frame pointer, do so now.  */
   if (frame_pointer_needed && !m->fs.fp_valid)
     {
       insn = ix86_gen_add3 (hard_frame_pointer_rtx, stack_pointer_rtx,
@@ -14794,7 +14794,7 @@ ix86_expand_prologue (void)
       RTX_FRAME_RELATED_P (insn) = 1;
       add_reg_note (insn, REG_CFA_FLUSH_QUEUE, NULL_RTX);
       emit_insn (gen_prologue_use (pic));
-      /* Deleting already emmitted SET_GOT if exist and allocated to
+      /* Deleting already emitted SET_GOT if exist and allocated to
 	 REAL_PIC_OFFSET_TABLE_REGNUM.  */
       ix86_elim_entry_set_got (pic);
     }
@@ -14985,7 +14985,7 @@ ix86_emit_restore_sse_regs_using_mov (HOST_WIDE_INT cfa_offset,
 	mem = choose_baseaddr (cfa_offset, &align);
 	mem = gen_rtx_MEM (V4SFmode, mem);
 
-	/* The location aligment depends upon the base register.  */
+	/* The location alignment depends upon the base register.  */
 	align = MIN (GET_MODE_ALIGNMENT (V4SFmode), align);
 	gcc_assert (! (cfa_offset & (align / BITS_PER_UNIT - 1)));
 	set_mem_align (mem, align);
@@ -15289,7 +15289,7 @@ ix86_expand_epilogue (int style)
   /* If using out-of-line stub that is a tail-call, then...*/
   if (m->call_ms2sysv && restore_stub_is_tail)
     {
-      /* TODO: parinoid tests. (remove eventually)  */
+      /* TODO: paranoid tests. (remove eventually)  */
       gcc_assert (m->fs.sp_valid);
       gcc_assert (!m->fs.sp_realigned);
       gcc_assert (!m->fs.fp_valid);
@@ -18571,7 +18571,7 @@ print_reg (rtx x, int code, FILE *file)
    F,f -- likewise, but for floating-point.
    O -- if HAVE_AS_IX86_CMOV_SUN_SYNTAX, expand to "w.", "l." or "q.",
 	otherwise nothing
-   R -- print embeded rounding and sae.
+   R -- print embedded rounding and sae.
    r -- print only sae.
    z -- print the opcode suffix for the size of the current operand.
    Z -- likewise, with special suffixes for x87 instructions.
@@ -21554,7 +21554,7 @@ ix86_split_idivmod (machine_mode mode, rtx operands[],
 /* Increase given DISTANCE in half-cycles according to
    dependencies between PREV and NEXT instructions.
    Add 1 half-cycle if there is no dependency and
-   go to next cycle if there is some dependecy.  */
+   go to next cycle if there is some dependency.  */
 
 static unsigned int
 increase_distance (rtx_insn *prev, rtx_insn *next, unsigned int distance)
@@ -21919,7 +21919,7 @@ ix86_lea_outperforms (rtx_insn *insn, unsigned int regno0, unsigned int regno1,
      lea priority.  */
   dist_define += split_cost + IX86_LEA_PRIORITY;
 
-  /* If there is no use in memory addess then we just check
+  /* If there is no use in memory address then we just check
      that split cost exceeds AGU stall.  */
   if (dist_use < 0)
     return dist_define > LEA_MAX_STALL;
@@ -22068,7 +22068,7 @@ ix86_avoid_lea_for_addr (rtx_insn *insn, rtx operands[])
      if split lea into a sequence of instructions.  */
   if (parts.base || parts.index)
     {
-      /* Have to use mov instruction if non desctructive
+      /* Have to use mov instruction if non destructive
 	 destination form is used.  */
       if (regno1 != regno0 && regno2 != regno0)
 	split_cost += 1;
@@ -23650,7 +23650,7 @@ ix86_expand_branch (enum rtx_code code, rtx op0, rtx op1, rtx label)
   machine_mode mode = GET_MODE (op0);
   rtx tmp;
 
-  /* Handle special case - vector comparsion with boolean result, transform
+  /* Handle special case - vector comparison with boolean result, transform
      it using ptest instruction.  */
   if (GET_MODE_CLASS (mode) == MODE_VECTOR_INT)
     {
@@ -27683,8 +27683,8 @@ expand_small_movmem_or_setmem (rtx destmem, rtx srcmem,
 }
 
 /* Handle small memcpy (up to SIZE that is supposed to be small power of 2.
-   and get ready for the main memcpy loop by copying iniital DESIRED_ALIGN-ALIGN
-   bytes and last SIZE bytes adjusitng DESTPTR/SRCPTR/COUNT in a way we can
+   and get ready for the main memcpy loop by copying initial DESIRED_ALIGN-ALIGN
+   bytes and last SIZE bytes adjusting DESTPTR/SRCPTR/COUNT in a way we can
    proceed with an loop copying SIZE bytes at once. Do moves in MODE.
    DONE_LABEL is a label after the whole copying sequence. The label is created
    on demand if *DONE_LABEL is NULL.
@@ -30589,7 +30589,7 @@ swap_top_of_ready_list (rtx_insn **ready, int n_ready)
   #undef INSN_TICK
 }
 
-/* Perform possible reodering of ready list for Atom/Silvermont only.
+/* Perform possible reordering of ready list for Atom/Silvermont only.
    Return issue rate.  */
 static int
 ix86_sched_reorder (FILE *dump, int sched_verbose, rtx_insn **ready,
@@ -30604,7 +30604,7 @@ ix86_sched_reorder (FILE *dump, int sched_verbose, rtx_insn **ready,
   /* Set up issue rate.  */
   issue_rate = ix86_issue_rate ();
 
-  /* Do reodering for BONNELL/SILVERMONT only.  */
+  /* Do reordering for BONNELL/SILVERMONT only.  */
   if (!TARGET_BONNELL && !TARGET_SILVERMONT && !TARGET_INTEL)
     return issue_rate;
 
@@ -33567,7 +33567,7 @@ dispatch_function_versions (tree dispatch_decl,
 
   gseq = bb_seq (*empty_bb);
   /* Function version dispatch is via IFUNC.  IFUNC resolvers fire before
-     constructors, so explicity call __builtin_cpu_init here.  */
+     constructors, so explicitly call __builtin_cpu_init here.  */
   ifunc_cpu_init_stmt = gimple_build_call_vec (
                      ix86_builtins [(int) IX86_BUILTIN_CPU_INIT], vNULL);
   gimple_seq_add_stmt (&gseq, ifunc_cpu_init_stmt);
@@ -36486,7 +36486,7 @@ ix86_erase_embedded_rounding (rtx pat)
 	    res [j++] = elem;
 	}
 
-      /*  No more than 1 occurence was removed.  */
+      /*  No more than 1 occurrence was removed.  */
       gcc_assert (j >= XVECLEN (pat, 0) - 1);
 
       return gen_rtx_PARALLEL (GET_MODE (pat), gen_rtvec_v (j, res));
@@ -43975,7 +43975,7 @@ ix86_expand_vector_init_interleave (machine_mode mode,
 
   for (i = 0; i < n; i++)
     {
-      /* Extend the odd elment to SImode using a paradoxical SUBREG.  */
+      /* Extend the odd element to SImode using a paradoxical SUBREG.  */
       op0 = gen_reg_rtx (SImode);
       emit_move_insn (op0, gen_lowpart (SImode, ops [i + i]));
 
@@ -52073,7 +52073,7 @@ ix86_optab_supported_p (int op, machine_mode mode1, machine_mode,
    to use %fs and %gs segment prefixes.  Therefore:
 
     (a) All address spaces have the same modes,
-    (b) All address spaces have the same addresss forms,
+    (b) All address spaces have the same address forms,
     (c) While %fs and %gs are technically subsets of the generic
         address space, they are probably not subsets of each other.
     (d) Since we have no access to the segment base register values
diff --git a/gcc/config/i386/i386.h b/gcc/config/i386/i386.h
index 08243c1..7311e87 100644
--- a/gcc/config/i386/i386.h
+++ b/gcc/config/i386/i386.h
@@ -191,7 +191,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
    known at compile time or estimated via feedback, the SIZE array
    is walked in order until MAX is greater then the estimate (or -1
    means infinity).  Corresponding ALG is used then.
-   When NOALIGN is true the code guaranting the alignment of the memory
+   When NOALIGN is true the code guaranteeing the alignment of the memory
    block is skipped.
 
    For example initializer:
@@ -778,7 +778,7 @@ extern const char *host_detect_local_cpu (int argc, const char **argv);
 
 /* 1 if -mstackrealign should be turned on by default.  It will
    generate an alternate prologue and epilogue that realigns the
-   runtime stack if nessary.  This supports mixing codes that keep a
+   runtime stack if necessary.  This supports mixing codes that keep a
    4-byte aligned stack, as specified by i386 psABI, with codes that
    need a 16-byte aligned stack, as required by SSE instructions.  */
 #define STACK_REALIGN_DEFAULT 0
@@ -789,7 +789,7 @@ extern const char *host_detect_local_cpu (int argc, const char **argv);
 /* According to Windows x64 software convention, the maximum stack allocatable
    in the prologue is 4G - 8 bytes.  Furthermore, there is a limited set of
    instructions allowed to adjust the stack pointer in the epilog, forcing the
-   use of frame pointer for frames larger than 2 GB.  This theorical limit
+   use of frame pointer for frames larger than 2 GB.  This theoretical limit
    is reduced by 256, an over-estimated upper bound for the stack use by the
    prologue.
    We define only one threshold for both the prolog and the epilog.  When the
@@ -1619,7 +1619,7 @@ enum reg_class
 
    FIXME: Unlike earlier implementations, the size of unwind info seems to
    actually grow with accumulation.  Is that because accumulated args
-   unwind info became unnecesarily bloated?
+   unwind info became unnecessarily bloated?
 
    With the 64-bit MS ABI, we can generate correct code with or without
    accumulated args, but because of OUTGOING_REG_PARM_STACK_SPACE the code
@@ -1704,7 +1704,7 @@ typedef struct ix86_args {
   int mmx_words;		/* # mmx words passed so far */
   int mmx_nregs;		/* # mmx registers available for passing */
   int mmx_regno;		/* next available mmx register number */
-  int maybe_vaarg;		/* true for calls to possibly vardic fncts.  */
+  int maybe_vaarg;		/* true for calls to possibly variadic fncts.  */
   int caller;			/* true if it is caller.  */
   int float_in_sse;		/* Set to 1 or 2 for 32bit targets if
 				   SFmode/DFmode arguments should be passed
diff --git a/gcc/config/i386/x86-tune.def b/gcc/config/i386/x86-tune.def
index c642f45..338353f 100644
--- a/gcc/config/i386/x86-tune.def
+++ b/gcc/config/i386/x86-tune.def
@@ -44,8 +44,8 @@ DEF_TUNE (X86_TUNE_SCHEDULE, "schedule",
 	  | m_INTEL | m_KNL | m_K6_GEODE | m_AMD_MULTIPLE | m_GENERIC)
 
 /* X86_TUNE_PARTIAL_REG_DEPENDENCY: Enable more register renaming
-   on modern chips.  Preffer stores affecting whole integer register
-   over partial stores.  For example preffer MOVZBL or MOVQ to load 8bit
+   on modern chips.  Prefer stores affecting whole integer register
+   over partial stores.  For example prefer MOVZBL or MOVQ to load 8bit
    value over movb.  */
 DEF_TUNE (X86_TUNE_PARTIAL_REG_DEPENDENCY, "partial_reg_dependency",
           m_P4_NOCONA | m_CORE_ALL | m_BONNELL | m_SILVERMONT | m_INTEL
@@ -137,12 +137,12 @@ DEF_TUNE (X86_TUNE_REASSOC_FP_TO_PARALLEL, "reassoc_fp_to_parallel",
    by push/pop instructions.
    This increase code size by about 5% in 32bit mode, less so in 64bit mode
    because parameters are passed in registers.  It is considerable
-   win for targets without stack engine that prevents multple push operations
+   win for targets without stack engine that prevents multiple push operations
    to happen in parallel.
 
    FIXME: the flags is incorrectly enabled for amdfam10, Bulldozer,
    Bobcat and Generic.  This is because disabling it causes large
-   regression on mgrid due to IRA limitation leading to unecessary
+   regression on mgrid due to IRA limitation leading to unnecessary
    use of the frame pointer in 32bit mode.  */
 DEF_TUNE (X86_TUNE_ACCUMULATE_OUTGOING_ARGS, "accumulate_outgoing_args",
 	  m_PPRO | m_P4_NOCONA | m_BONNELL | m_SILVERMONT | m_KNL | m_INTEL
@@ -273,7 +273,7 @@ DEF_TUNE (X86_TUNE_SINGLE_STRINGOP, "single_stringop", m_386 | m_P4_NOCONA)
    compact prologues and epilogues by issuing a misaligned moves.  This
    requires target to handle misaligned moves and partial memory stalls
    reasonably well.
-   FIXME: This may actualy be a win on more targets than listed here.  */
+   FIXME: This may actually be a win on more targets than listed here.  */
 DEF_TUNE (X86_TUNE_MISALIGNED_MOVE_STRING_PRO_EPILOGUES,
 	  "misaligned_move_string_pro_epilogues",
 	  m_386 | m_486 | m_CORE_ALL | m_AMD_MULTIPLE | m_GENERIC)
@@ -339,7 +339,7 @@ DEF_TUNE (X86_TUNE_SSE_UNALIGNED_STORE_OPTIMAL, "sse_unaligned_store_optimal",
 	  m_NEHALEM | m_SANDYBRIDGE | m_HASWELL | m_SILVERMONT | m_KNL
 	  | m_INTEL | m_BDVER | m_ZNVER1 | m_GENERIC)
 
-/* Use packed single precision instructions where posisble.  I.e. movups instead
+/* Use packed single precision instructions where possible.  I.e. movups instead
    of movupd.  */
 DEF_TUNE (X86_TUNE_SSE_PACKED_SINGLE_INSN_OPTIMAL, "sse_packed_single_insn_optimal",
 	  m_BDVER | m_ZNVER1)
@@ -429,7 +429,7 @@ DEF_TUNE (X86_TUNE_DOUBLE_WITH_ADD, "double_with_add", ~m_386)
 
 /* X86_TUNE_ALWAYS_FANCY_MATH_387: controls use of fancy 387 operations,
    such as fsqrt, fprem, fsin, fcos, fsincos etc.
-   Should be enabled for all targets that always has coprocesor.  */
+   Should be enabled for all targets that always has coprocessor.  */
 DEF_TUNE (X86_TUNE_ALWAYS_FANCY_MATH_387, "always_fancy_math_387",
           ~(m_386 | m_486 | m_LAKEMONT))
 
@@ -489,7 +489,7 @@ DEF_TUNE (X86_TUNE_PARTIAL_REG_STALL, "partial_reg_stall", m_PPRO)
 DEF_TUNE (X86_TUNE_PROMOTE_QIMODE, "promote_qimode",
 	  ~m_PPRO)
 
-/* X86_TUNE_PROMOTE_HI_REGS: Same, but for 16bit artihmetic.  Again we avoid
+/* X86_TUNE_PROMOTE_HI_REGS: Same, but for 16bit arithmetic.  Again we avoid
    partial register stalls on PentiumPro targets. */
 DEF_TUNE (X86_TUNE_PROMOTE_HI_REGS, "promote_hi_regs", m_PPRO)
 
diff --git a/gcc/configure.ac b/gcc/configure.ac
index acfe979..055be56 100644
--- a/gcc/configure.ac
+++ b/gcc/configure.ac
@@ -630,7 +630,7 @@ if test x$ac_tree_checking != x ; then
 fi
 if test x$ac_types_checking != x ; then
   AC_DEFINE(ENABLE_TYPES_CHECKING, 1,
-[Define if you want all gimple types to be verified after gimplifiation.
+[Define if you want all gimple types to be verified after gimplification.
    This is cheap.
    ])
 fi
diff --git a/gcc/coverage.c b/gcc/coverage.c
index 53e379b..1b2f71c 100644
--- a/gcc/coverage.c
+++ b/gcc/coverage.c
@@ -606,7 +606,7 @@ coverage_compute_profile_id (struct cgraph_node *n)
    The checksum is calculated carefully so that
    source code changes that doesn't affect the control flow graph
    won't change the checksum.
-   This is to make the profile data useable across source code change.
+   This is to make the profile data usable across source code change.
    The downside of this is that the compiler may use potentially
    wrong profile data - that the source code change has non-trivial impact
    on the validity of profile data (e.g. the reversed condition)
diff --git a/gcc/cp/call.c b/gcc/cp/call.c
index 51260f0..bc1f723 100644
--- a/gcc/cp/call.c
+++ b/gcc/cp/call.c
@@ -8358,7 +8358,7 @@ build_special_member_call (tree instance, tree name, vec<tree, va_gc> **args,
 
       /* FIXME P0135 doesn't say how to handle direct initialization from a
 	 type with a suitable conversion operator.  Let's handle it like
-	 copy-initialization, but allowing explict conversions.  */
+	 copy-initialization, but allowing explicit conversions.  */
       tsubst_flags_t sub_complain = tf_warning;
       if (!is_dummy_object (instance))
 	/* If we're using this to initialize a non-temporary object, don't
diff --git a/gcc/cp/class.c b/gcc/cp/class.c
index eddc118..9c8beb9 100644
--- a/gcc/cp/class.c
+++ b/gcc/cp/class.c
@@ -1703,7 +1703,7 @@ inherit_targ_abi_tags (tree t)
 }
 
 /* Return true, iff class T has a non-virtual destructor that is
-   accessible from outside the class heirarchy (i.e. is public, or
+   accessible from outside the class hierarchy (i.e. is public, or
    there's a suitable friend.  */
 
 static bool
@@ -3226,9 +3226,9 @@ maybe_add_class_template_decl_list (tree type, tree t, int friend_p)
 /* This function is called from declare_virt_assop_and_dtor via
    dfs_walk_all.
 
-   DATA is a type that direcly or indirectly inherits the base
+   DATA is a type that directly or indirectly inherits the base
    represented by BINFO.  If BINFO contains a virtual assignment [copy
-   assignment or move assigment] operator or a virtual constructor,
+   assignment or move assignment] operator or a virtual constructor,
    declare that function in DATA if it hasn't been already declared.  */
 
 static tree
@@ -8687,7 +8687,7 @@ note_name_declared_in_class (tree name, tree decl)
     return;
   /* The C language allows members to be declared with a type of the same
      name, and the C++ standard says this diagnostic is not required.  So
-     allow it in extern "C" blocks unless predantic is specified.
+     allow it in extern "C" blocks unless pedantic is specified.
      Allow it in all cases if -ms-extensions is specified.  */
   if ((!pedantic && current_lang_name == lang_name_c)
       || flag_ms_extensions)
@@ -9539,7 +9539,7 @@ dfs_accumulate_vtbl_inits (tree binfo,
        straighten this out.  */
     BINFO_VTABLE (binfo) = tree_cons (rtti_binfo, vtbl, BINFO_VTABLE (binfo));
   else if (BINFO_PRIMARY_P (binfo) && BINFO_VIRTUAL_P (binfo))
-    /* Throw away any unneeded intializers.  */
+    /* Throw away any unneeded initializers.  */
     (*l)->truncate (n_inits);
   else
      /* For an ordinary vtable, set BINFO_VTABLE.  */
diff --git a/gcc/cp/constexpr.c b/gcc/cp/constexpr.c
index 157b20d..44cb677 100644
--- a/gcc/cp/constexpr.c
+++ b/gcc/cp/constexpr.c
@@ -755,7 +755,7 @@ cx_check_missing_mem_inits (tree ctype, tree body, bool complain)
 	    continue;
 	  if (ANON_AGGR_TYPE_P (TREE_TYPE (field)))
 	    {
-	      /* Recurse to check the anonummous aggregate member.  */
+	      /* Recurse to check the anonymous aggregate member.  */
 	      bad |= cx_check_missing_mem_inits
 		(TREE_TYPE (field), NULL_TREE, complain);
 	      if (bad && !complain)
@@ -797,7 +797,7 @@ cx_check_missing_mem_inits (tree ctype, tree body, bool complain)
 }
 
 /* We are processing the definition of the constexpr function FUN.
-   Check that its BODY fulfills the propriate requirements and
+   Check that its BODY fulfills the appropriate requirements and
    enter it in the constexpr function definition table.
    For constructor BODY is actually the TREE_LIST of the
    member-initializer list.  */
@@ -912,7 +912,7 @@ struct GTY((for_user)) constexpr_call {
   /* Result of the call.
        NULL means the call is being evaluated.
        error_mark_node means that the evaluation was erroneous;
-       otherwise, the actuall value of the call.  */
+       otherwise, the actual value of the call.  */
   tree result;
   /* The hash of this call; we remember it here to avoid having to
      recalculate it when expanding the hash table.  */
@@ -1092,7 +1092,7 @@ save_fundef_copy (tree fun, tree copy)
 
 /* We have an expression tree T that represents a call, either CALL_EXPR
    or AGGR_INIT_EXPR.  If the call is lexically to a named function,
-   retrun the _DECL for that function.  */
+   return the _DECL for that function.  */
 
 static tree
 get_function_named_in_call (tree t)
@@ -5863,7 +5863,7 @@ potential_nondependent_static_init_expression (tree t)
 void
 fini_constexpr (void)
 {
-  /* The contexpr call and fundef copies tables are no longer needed.  */
+  /* The constexpr call and fundef copies tables are no longer needed.  */
   constexpr_call_table = NULL;
   fundef_copies_table = NULL;
 }
diff --git a/gcc/cp/constraint.cc b/gcc/cp/constraint.cc
index 6fd4bde..c797bb1 100644
--- a/gcc/cp/constraint.cc
+++ b/gcc/cp/constraint.cc
@@ -453,7 +453,7 @@ learn_implications (tree parent, tree constr, implication_context cxt)
 void
 learn_implications (tree tmpl, tree args, tree constr)
 {
-  /* Don't memoize relations between non-dependent arguemnts. It's not
+  /* Don't memoize relations between non-dependent arguments. It's not
      helpful. */
   if (!uses_template_parms (args))
     return;
@@ -461,7 +461,7 @@ learn_implications (tree tmpl, tree args, tree constr)
   /* Build a check constraint for the purpose of caching. */
   tree parent = build_nt (CHECK_CONSTR, tmpl, args);
 
-  /* Start learning based on the kind of the top-level contraint. */
+  /* Start learning based on the kind of the top-level constraint. */
   if (TREE_CODE (constr) == CONJ_CONSTR)
     return learn_logical_operation (parent, constr, conjunction_cxt);
   else if (TREE_CODE (constr) == DISJ_CONSTR)
@@ -2956,7 +2956,7 @@ diagnose_argument_deduction_constraint (location_t loc, tree orig, tree cur,
 
   /* The expression and type will previously have been substituted into,
      and therefore may already be an error. Also, we will have already
-     diagnosed substution failures into an expression since this must be
+     diagnosed substitution failures into an expression since this must be
      part of a compound requirement.  */
   tree expr = DEDUCT_CONSTR_EXPR (cur);
   if (error_operand_p (expr))
diff --git a/gcc/cp/cp-array-notation.c b/gcc/cp/cp-array-notation.c
index 36d6624..d08563d 100644
--- a/gcc/cp/cp-array-notation.c
+++ b/gcc/cp/cp-array-notation.c
@@ -313,7 +313,7 @@ expand_sec_reduce_builtin (tree an_builtin_fn, tree *new_var)
 
       /* In this place, we are using get_temp_regvar instead of 
 	 create_temporary_var if an_type is SEC_REDUCE_MAX/MIN_IND because
-	 the array_ind_value depends on this value being initalized to 0.  */
+	 the array_ind_value depends on this value being initialized to 0.  */
       if (an_type == BUILT_IN_CILKPLUS_SEC_REDUCE_MAX_IND
 	  || an_type == BUILT_IN_CILKPLUS_SEC_REDUCE_MIN_IND) 
 	an_loop_info[ii].var = get_temp_regvar (typ, build_zero_cst (typ));
diff --git a/gcc/cp/cp-gimplify.c b/gcc/cp/cp-gimplify.c
index 898a5ae..0922c4f 100644
--- a/gcc/cp/cp-gimplify.c
+++ b/gcc/cp/cp-gimplify.c
@@ -1287,7 +1287,7 @@ cp_genericize_r (tree *stmt_p, int *walk_subtrees, void *data)
     {
       tree block = NULL_TREE;
 
-      /* Get the innermost inclosing GIMPLE_BIND that has a non NULL
+      /* Get the innermost enclosing GIMPLE_BIND that has a non NULL
          BLOCK, and append an IMPORTED_DECL to its
 	 BLOCK_VARS chained list.  */
       if (wtd->bind_expr_stack.exists ())
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index 1c3cce8..c6fb5e0 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -666,7 +666,7 @@ typedef struct ptrmem_cst * ptrmem_cst_t;
 #define OVL_NESTED_P(NODE)	TREE_LANG_FLAG_3 (OVERLOAD_CHECK (NODE))
 /* If set, this overload was constructed during lookup.  */
 #define OVL_LOOKUP_P(NODE)	TREE_LANG_FLAG_4 (OVERLOAD_CHECK (NODE))
-/* If set, this is a persistant lookup. */
+/* If set, this is a persistent lookup. */
 #define OVL_USED_P(NODE)	TREE_USED (OVERLOAD_CHECK (NODE))
 
 /* The first decl of an overload.  */
@@ -3149,7 +3149,7 @@ struct GTY(()) lang_decl {
 #define SCOPE_DEPTH(NODE) \
   (NAMESPACE_DECL_CHECK (NODE)->base.u.bits.address_space)
 
-/* Whether the namepace is an inline namespace.  */
+/* Whether the namespace is an inline namespace.  */
 #define DECL_NAMESPACE_INLINE_P(NODE) \
   TREE_LANG_FLAG_0 (NAMESPACE_DECL_CHECK (NODE))
 
@@ -4064,7 +4064,7 @@ more_aggr_init_expr_args_p (const aggr_init_expr_arg_iterator *iter)
          enum E1 : char { ... } // underlying type is char
 
      - In a C++0x scoped enumeration, the underlying type is int
-       unless otherwises specified:
+       unless otherwise specified:
 
          enum class E2 { ... } // underlying type is int
 
@@ -4469,7 +4469,7 @@ more_aggr_init_expr_args_p (const aggr_init_expr_arg_iterator *iter)
    TYPE_DECL). 
 
    FIXME: CONST_CAST_TREE is a hack that hopefully will go away after
-   tree is converted to C++ class hiearchy.  */
+   tree is converted to C++ class hierarchy.  */
 #define DECL_TEMPLATE_PARMS(NODE)       \
    ((struct tree_template_decl *)CONST_CAST_TREE (TEMPLATE_DECL_CHECK (NODE)))->arguments
 #define DECL_INNERMOST_TEMPLATE_PARMS(NODE) \
@@ -4479,7 +4479,7 @@ more_aggr_init_expr_args_p (const aggr_init_expr_arg_iterator *iter)
 /* For function, method, class-data templates.
 
    FIXME: CONST_CAST_TREE is a hack that hopefully will go away after
-   tree is converted to C++ class hiearchy.  */
+   tree is converted to C++ class hierarchy.  */
 #define DECL_TEMPLATE_RESULT(NODE)      \
    ((struct tree_template_decl *)CONST_CAST_TREE(TEMPLATE_DECL_CHECK (NODE)))->result
 /* For a function template at namespace scope, DECL_TEMPLATE_INSTANTIATIONS
@@ -5631,7 +5631,7 @@ enum cp_decl_spec {
 /* A decl-specifier-seq.  */
 
 struct cp_decl_specifier_seq {
-  /* An array of locations for the declaration sepecifiers, indexed by
+  /* An array of locations for the declaration specifiers, indexed by
      enum cp_decl_spec_word.  */
   source_location locations[ds_last];
   /* The primary type, if any, given by the decl-specifier-seq.
diff --git a/gcc/cp/cvt.c b/gcc/cp/cvt.c
index 6b28ef6..e8857f0 100644
--- a/gcc/cp/cvt.c
+++ b/gcc/cp/cvt.c
@@ -1064,7 +1064,7 @@ convert_to_void (tree expr, impl_conv_void implicit, tsubst_flags_t complain)
       if (DECL_P (exprv)
 	  || handled_component_p (exprv)
 	  || INDIRECT_REF_P (exprv))
-	/* Expr is not being 'used' here, otherwise we whould have
+	/* Expr is not being 'used' here, otherwise we would have
 	   called mark_{rl}value_use use here, which would have in turn
 	   called mark_exp_read.  Rather, we call mark_exp_read directly
 	   to avoid some warnings when
diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
index e895fa7..cc25e95 100644
--- a/gcc/cp/decl.c
+++ b/gcc/cp/decl.c
@@ -13953,7 +13953,7 @@ copy_type_enum (tree dst, tree src)
 /* Begin compiling the definition of an enumeration type.
    NAME is its name, 
 
-   if ENUMTYPE is not NULL_TREE then the type has alredy been found.
+   if ENUMTYPE is not NULL_TREE then the type has already been found.
 
    UNDERLYING_TYPE is the type that will be used as the storage for
    the enumeration type. This should be NULL_TREE if no storage type
@@ -14345,7 +14345,7 @@ finish_enum_value_list (tree enumtype)
 }
 
 /* Finishes the enum type. This is called only the first time an
-   enumeration is seen, be it opaque or odinary.
+   enumeration is seen, be it opaque or ordinary.
    ENUMTYPE is the type object.  */
 
 void
diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c
index 1645437..3adddef 100644
--- a/gcc/cp/decl2.c
+++ b/gcc/cp/decl2.c
@@ -2235,7 +2235,7 @@ determine_visibility (tree decl)
   enum symbol_visibility orig_visibility = DECL_VISIBILITY (decl);
 
   /* The decl may be a template instantiation, which could influence
-     visibilty.  */
+     visibility.  */
   tree template_decl = NULL_TREE;
   if (TREE_CODE (decl) == TYPE_DECL)
     {
diff --git a/gcc/cp/init.c b/gcc/cp/init.c
index 4ad2cae..32982cc 100644
--- a/gcc/cp/init.c
+++ b/gcc/cp/init.c
@@ -2197,7 +2197,7 @@ constant_value_1 (tree decl, bool strict_p, bool return_aggregate_cst_ok_p)
 	init = TREE_VALUE (init);
       /* Instantiate a non-dependent initializer for user variables.  We
 	 mustn't do this for the temporary for an array compound literal;
-	 trying to instatiate the initializer will keep creating new
+	 trying to instantiate the initializer will keep creating new
 	 temporaries until we crash.  Probably it's not useful to do it for
 	 other artificial variables, either.  */
       if (!DECL_ARTIFICIAL (decl))
@@ -2488,7 +2488,7 @@ warn_placement_new_too_small (tree type, tree nelts, tree size, tree oper)
      is a constant.  */
   if (TREE_CODE (oper) == POINTER_PLUS_EXPR)
     {
-      /* If the offset is comple-time constant, use it to compute a more
+      /* If the offset is compile-time constant, use it to compute a more
 	 accurate estimate of the size of the buffer.  Since the operand
 	 of POINTER_PLUS_EXPR is represented as an unsigned type, convert
 	 it to signed first.
@@ -3601,7 +3601,7 @@ build_new (vec<tree, va_gc> **placement, tree type, tree nelts,
       /* The expression in a noptr-new-declarator is erroneous if it's of
 	 non-class type and its value before converting to std::size_t is
 	 less than zero. ... If the expression is a constant expression,
-	 the program is ill-fomed.  */
+	 the program is ill-formed.  */
       if (INTEGER_CST == TREE_CODE (cst_nelts)
 	  && tree_int_cst_sgn (cst_nelts) == -1)
 	{
diff --git a/gcc/cp/lex.c b/gcc/cp/lex.c
index 5dc9eee..6261c8f 100644
--- a/gcc/cp/lex.c
+++ b/gcc/cp/lex.c
@@ -479,7 +479,7 @@ unqualified_fn_lookup_error (cp_expr name_expr)
 
 	 Note that we have the exact wording of the following message in
 	 the manual (trouble.texi, node "Name lookup"), so they need to
-	 be kept in synch.  */
+	 be kept in sync.  */
       permerror (loc, "there are no arguments to %qD that depend on a template "
 		 "parameter, so a declaration of %qD must be available",
 		 name, name);
diff --git a/gcc/cp/mangle.c b/gcc/cp/mangle.c
index 42290fe..0320925 100644
--- a/gcc/cp/mangle.c
+++ b/gcc/cp/mangle.c
@@ -1422,7 +1422,7 @@ write_unqualified_name (tree decl)
 	    decl = res;
 	  else if (flag_abi_version == 10)
 	    {
-	      /* In ABI 10, we want explict and implicit tags.  */
+	      /* In ABI 10, we want explicit and implicit tags.  */
 	      write_abi_tags (mtags);
 	      return;
 	    }
diff --git a/gcc/cp/name-lookup.c b/gcc/cp/name-lookup.c
index 041d51c..1e6ea6c 100644
--- a/gcc/cp/name-lookup.c
+++ b/gcc/cp/name-lookup.c
@@ -39,7 +39,7 @@ static void set_identifier_type_value_with_scope (tree id, tree decl,
 						  cp_binding_level *b);
 
 /* Create an overload suitable for recording an artificial TYPE_DECL
-   and another decl.  We use this machanism to implement the struct
+   and another decl.  We use this mechanism to implement the struct
    stat hack within a namespace.  It'd be nice to use it everywhere.  */
 
 #define STAT_HACK_P(N) ((N) && TREE_CODE (N) == OVERLOAD && OVL_LOOKUP_P (N))
@@ -285,7 +285,7 @@ vec<tree, va_heap, vl_embed> *name_lookup::shared_scopes;
 name_lookup *name_lookup::active;
 
 /* Name lookup is recursive, becase ADL can cause template
-   instatiation.  This is of course a rare event, so we optimize for
+   instantiation.  This is of course a rare event, so we optimize for
    it not happening.  When we discover an active name-lookup, which
    must be an ADL lookup,  we need to unmark the marked scopes and also
    unmark the lookup we might have been accumulating.  */
@@ -414,7 +414,7 @@ name_lookup::ambiguous (tree thing, tree current)
   return current;
 }
 
-/* FNS is a new overload set to add to the exising set.  */
+/* FNS is a new overload set to add to the existing set.  */
 
 void
 name_lookup::add_overload (tree fns)
@@ -2441,7 +2441,7 @@ do_pushdecl (tree decl, bool is_friend)
 	    }
 
 	  /* If this is a locally defined typedef in a function that
-	     is not a template instantation, record it to implement
+	     is not a template instantiation, record it to implement
 	     -Wunused-local-typedefs.  */
 	  if (!instantiating_current_function_p ())
 	    record_locally_defined_typedef (decl);
@@ -4892,7 +4892,7 @@ suggest_alternative_in_explicit_scope (location_t location, tree name,
   best_match <tree, const char *> bm (name);
   consider_binding_level (name, bm, level, false, FUZZY_LOOKUP_NAME);
 
-  /* See if we have a good suggesion for the user.  */
+  /* See if we have a good suggestion for the user.  */
   const char *fuzzy_name = bm.get_best_meaningful_candidate ();
   if (fuzzy_name)
     {
diff --git a/gcc/cp/name-lookup.h b/gcc/cp/name-lookup.h
index 2e2075c..306c5ca 100644
--- a/gcc/cp/name-lookup.h
+++ b/gcc/cp/name-lookup.h
@@ -112,7 +112,7 @@ enum scope_kind {
 			of an if or switch statement.  */
   sk_function_parms, /* The scope containing function parameters.  */
   sk_class,	     /* The scope containing the members of a class.  */
-  sk_scoped_enum,    /* The scope containing the enumertors of a C++0x
+  sk_scoped_enum,    /* The scope containing the enumerators of a C++0x
                         scoped enumeration.  */
   sk_namespace,	     /* The scope containing the members of a
 			namespace, including the global scope.  */
diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
index 313eebb..2f64e30 100644
--- a/gcc/cp/parser.c
+++ b/gcc/cp/parser.c
@@ -25635,7 +25635,7 @@ cp_parser_lookup_name (cp_parser *parser, tree name,
 	}
 
       /* If the scope is a dependent type and either we deferred lookup or
-	 we did lookup but didn't find the name, rememeber the name.  */
+	 we did lookup but didn't find the name, remember the name.  */
       if (decl == error_mark_node && TYPE_P (parser->scope)
 	  && dependent_type_p (parser->scope))
 	{
diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index a04f2e0..486f213 100644
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -857,7 +857,7 @@ maybe_new_partial_specialization (tree type)
       tree args = CLASSTYPE_TI_ARGS (type);
 
       // If there are no template parameters, this cannot be a new
-      // partial template specializtion?
+      // partial template specialization?
       if (!current_template_parms)
         return NULL_TREE;
 
@@ -11246,7 +11246,7 @@ tsubst_unary_left_fold (tree t, tree args, tsubst_flags_t complain,
 
 /* Substitute into a binary left fold expression.
 
-   Do ths by building a single (non-empty) vector of argumnts and
+   Do ths by building a single (non-empty) vector of arguments and
    building the expression from those elements. */
 
 static tree
@@ -25703,7 +25703,7 @@ append_type_to_template_for_access_check_1 (tree t,
 
 /* Append TYPE_DECL to the template TEMPL.
    TEMPL is either a class type, a FUNCTION_DECL or a a TEMPLATE_DECL.
-   At TEMPL instanciation time, TYPE_DECL will be checked to see
+   At TEMPL instantiation time, TYPE_DECL will be checked to see
    if it can be accessed through SCOPE.
    LOCATION is the location of the usage point of TYPE_DECL.
 
@@ -25958,7 +25958,7 @@ lookup_constraint_satisfaction (tree ci, tree args)
     return NULL_TREE;
 }
 
-/* Memoize the result of a satisfication test. Returns the saved result.  */
+/* Memoize the result of a satisfaction test. Returns the saved result.  */
 
 tree
 memoize_constraint_satisfaction (tree ci, tree args, tree result)
diff --git a/gcc/cp/tree.c b/gcc/cp/tree.c
index bb17278..02d9b16 100644
--- a/gcc/cp/tree.c
+++ b/gcc/cp/tree.c
@@ -612,7 +612,7 @@ build_cplus_new (tree type, tree init, tsubst_flags_t complain)
 }
 
 /* Subroutine of build_vec_init_expr: Build up a single element
-   intialization as a proxy for the full array initialization to get things
+   initialization as a proxy for the full array initialization to get things
    marked as used and any appropriate diagnostics.
 
    Since we're deferring building the actual constructor calls until
diff --git a/gcc/cp/vtable-class-hierarchy.c b/gcc/cp/vtable-class-hierarchy.c
index 1162b8c..6822c15 100644
--- a/gcc/cp/vtable-class-hierarchy.c
+++ b/gcc/cp/vtable-class-hierarchy.c
@@ -51,7 +51,7 @@ along with GCC; see the file COPYING3.  If not see
   hacker targets.
 
   To find and reference the set of valid vtable pointers for any given
-  virtual class, we create a special global varible for each virtual
+  virtual class, we create a special global variable for each virtual
   class.  We refer to this as the "vtable map variable" for that
   class.  The vtable map variable has the type "void *", and is
   initialized by the compiler to NULL.  At runtime when the set of
@@ -436,9 +436,9 @@ vtv_compute_class_hierarchy_transitive_closure (void)
    offset into the vtable (VTABLE_DECL).  It is the actual vtable
    pointer address that will be stored in our list of valid vtable
    pointers for BASE_CLASS.  BASE_CLASS is the record_type node for
-   the base class to whose hiearchy we want to add
+   the base class to whose hierarchy we want to add
    VPTR_ADDRESS. (VTABLE_DECL should be the vtable for BASE_CLASS or
-   one of BASE_CLASS' descendents.  */
+   one of BASE_CLASS' descendants.  */
 
 static bool
 check_and_record_registered_pairs (tree vtable_decl, tree vptr_address,
@@ -1131,7 +1131,7 @@ write_out_vtv_count_data (void)
    init function).  It also generates the calls to
    __VLTChangePermission, if the verification constructor init
    function is going into the preinit array.  INIT_ROUTINE_BODY is
-   the body of our constructior initialization function, to which we
+   the body of our constructor initialization function, to which we
    add our function calls.*/
 
 bool
@@ -1200,7 +1200,7 @@ vtv_generate_init_routine (void)
   pop_lang_context ();
 }
 
-/* This funtion takes a tree containing a class type (BASE_TYPE), and
+/* This function takes a tree containing a class type (BASE_TYPE), and
    it either finds the existing vtbl_map_node for that class in our
    data structure, or it creates a new node and adds it to the data
    structure if there is not one for the class already.  As part of
@@ -1247,7 +1247,7 @@ vtable_find_or_create_map_decl (tree base_type)
       DECL_IGNORED_P (var_decl) = 1;
       DECL_PRESERVE_P (var_decl) = 1;
 
-      /* Put these mmap variables in thr .vtable_map_vars section, so
+      /* Put these mmap variables in the .vtable_map_vars section, so
          we can find and protect them.  */
 
       set_decl_section_name (var_decl, ".vtable_map_vars");
diff --git a/gcc/cse.c b/gcc/cse.c
index 6a968d1..7464476 100644
--- a/gcc/cse.c
+++ b/gcc/cse.c
@@ -4314,7 +4314,7 @@ canon_asm_operands (rtx x, rtx_insn *insn)
 /* Where possible, substitute every register reference in the N_SETS
    number of SETS in INSN with the canonical register.
 
-   Register canonicalization propagatest the earliest register (i.e.
+   Register canonicalization propagates the earliest register (i.e.
    one that is set before INSN) with the same value.  This is a very
    useful, simple form of CSE, to clean up warts from expanding GIMPLE
    to RTL.  For instance, a CONST for an address is usually expanded
@@ -6979,7 +6979,7 @@ count_stores (rtx x, const_rtx set ATTRIBUTE_UNUSED, void *data)
 
 /* Return if DEBUG_INSN pattern PAT needs to be reset because some dead
    pseudo doesn't have a replacement.  COUNTS[X] is zero if register X
-   is dead and REPLACEMENTS[X] is null if it has no replacemenet.
+   is dead and REPLACEMENTS[X] is null if it has no replacement.
    Set *SEEN_REPL to true if we see a dead register that does have
    a replacement.  */
 
diff --git a/gcc/cselib.c b/gcc/cselib.c
index 74c25ac..803c8c0 100644
--- a/gcc/cselib.c
+++ b/gcc/cselib.c
@@ -85,7 +85,7 @@ struct cselib_hasher : nofree_ptr_hash <cselib_val>
        integers).  */
     machine_mode mode;
     rtx x;
-    /* The mode of the contaning MEM, if any, otherwise VOIDmode.  */
+    /* The mode of the containing MEM, if any, otherwise VOIDmode.  */
     machine_mode memmode;
   };
   typedef key *compare_type;
@@ -2688,7 +2688,7 @@ cselib_process_insn (rtx_insn *insn)
       for (x = CALL_INSN_FUNCTION_USAGE (insn); x; x = XEXP (x, 1))
 	if (GET_CODE (XEXP (x, 0)) == CLOBBER)
 	  cselib_invalidate_rtx (XEXP (XEXP (x, 0), 0));
-      /* Flush evertything on setjmp.  */
+      /* Flush everything on setjmp.  */
       if (cselib_preserve_constants
 	  && find_reg_note (insn, REG_SETJMP, NULL))
 	{
diff --git a/gcc/dce.c b/gcc/dce.c
index 7534d2a..44c9b1a 100644
--- a/gcc/dce.c
+++ b/gcc/dce.c
@@ -606,7 +606,7 @@ delete_unmarked_insns (void)
 	  remove_reg_equal_equiv_notes_for_defs (insn);
 
 	  /* If a pure or const call is deleted, this may make the cfg
-	     have unreachable blocks.  We rememeber this and call
+	     have unreachable blocks.  We remember this and call
 	     delete_unreachable_blocks at the end.  */
 	  if (CALL_P (insn))
 	    must_clean = true;
diff --git a/gcc/df-problems.c b/gcc/df-problems.c
index 755aecf..9368b98 100644
--- a/gcc/df-problems.c
+++ b/gcc/df-problems.c
@@ -1018,7 +1018,7 @@ df_lr_finalize (bitmap all_blocks)
 
       /* If dce deletes some instructions, we need to recompute the lr
 	 solution before proceeding further.  The problem is that fast
-	 dce is a pessimestic dataflow algorithm.  In the case where
+	 dce is a pessimistic dataflow algorithm.  In the case where
 	 it deletes a statement S inside of a loop, the uses inside of
 	 S may not be deleted from the dataflow solution because they
 	 were carried around the loop.  While it is conservatively
diff --git a/gcc/double-int.h b/gcc/double-int.h
index 2c70bb5..c01a671 100644
--- a/gcc/double-int.h
+++ b/gcc/double-int.h
@@ -52,14 +52,14 @@ struct double_int
      Two things prevent us from doing so.
      First, defining a constructor makes the class non-POD in C++03,
      and we certainly want double_int to be a POD.
-     Second, the GCC conding conventions prefer explicit conversion,
+     Second, the GCC coding conventions prefer explicit conversion,
      and explicit conversion operators are not available until C++11.  */
 
   static double_int from_uhwi (unsigned HOST_WIDE_INT cst);
   static double_int from_shwi (HOST_WIDE_INT cst);
   static double_int from_pair (HOST_WIDE_INT high, unsigned HOST_WIDE_INT low);
 
-  /* Construct from a fuffer of length LEN.  BUFFER will be read according
+  /* Construct from a buffer of length LEN.  BUFFER will be read according
      to byte endianness and word endianness.  */
   static double_int from_buffer (const unsigned char *buffer, int len);
 
diff --git a/gcc/dwarf2cfi.c b/gcc/dwarf2cfi.c
index 2a527c9..49aa0b0 100644
--- a/gcc/dwarf2cfi.c
+++ b/gcc/dwarf2cfi.c
@@ -1835,7 +1835,7 @@ dwarf2out_frame_debug_expr (rtx expr)
 
           /* Rule 18: If stack is aligned, we will use FP as a
 	     reference to represent the address of the stored
-	     regiser.  */
+	     register.  */
           if (fde
               && fde->stack_realign
 	      && REG_P (src)
diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c
index 036d0a8..c410b56 100644
--- a/gcc/dwarf2out.c
+++ b/gcc/dwarf2out.c
@@ -3240,7 +3240,7 @@ static GTY(()) vec<dw_die_ref, va_gc> *abbrev_die_table;
 
 /* A hash map to remember the stack usage for DWARF procedures.  The value
    stored is the stack size difference between before the DWARF procedure
-   invokation and after it returned.  In other words, for a DWARF procedure
+   invocation and after it returned.  In other words, for a DWARF procedure
    that consumes N stack slots and that pushes M ones, this stores M - N.  */
 static hash_map<dw_die_ref, int> *dwarf_proc_stack_usage_map;
 
@@ -17107,7 +17107,7 @@ function_to_dwarf_procedure (tree fndecl)
 /* Generate Dwarf location list representing LOC.
    If WANT_ADDRESS is false, expression computing LOC will be computed
    If WANT_ADDRESS is 1, expression computing address of LOC will be returned
-   if WANT_ADDRESS is 2, expression computing address useable in location
+   if WANT_ADDRESS is 2, expression computing address usable in location
      will be returned (i.e. DW_OP_reg can be used
      to refer to register values).
 
@@ -18241,7 +18241,7 @@ field_byte_offset (const_tree decl, struct vlr_context *ctx,
     tree_result = fold_build2 (PLUS_EXPR, TREE_TYPE (tree_result),
 			       ctx->variant_part_offset, tree_result);
 
-  /* If the byte offset is a constant, it's simplier to handle a native
+  /* If the byte offset is a constant, it's simpler to handle a native
      constant rather than a DWARF expression.  */
   if (TREE_CODE (tree_result) == INTEGER_CST)
     {
@@ -18395,7 +18395,7 @@ add_data_member_location_attribute (dw_die_ref die,
 	  offset = 0;
 	}
 
-      /* Data member location evalutation starts with the base address on the
+      /* Data member location evaluation starts with the base address on the
 	 stack.  Compute the field offset and add it to this base address.  */
       else if (loc_descr != NULL)
 	add_loc_descr (&loc_descr, new_loc_descr (DW_OP_plus, 0, 0));
@@ -18406,7 +18406,7 @@ add_data_member_location_attribute (dw_die_ref die,
       /* While DW_AT_data_bit_offset has been added already in DWARF4,
 	 e.g. GDB only added support to it in November 2016.  For DWARF5
 	 we need newer debug info consumers anyway.  We might change this
-	 to dwarf_version >= 4 once most consumers catched up.  */
+	 to dwarf_version >= 4 once most consumers are caught up.  */
       if (dwarf_version >= 5
 	  && TREE_CODE (decl) == FIELD_DECL
 	  && DECL_BIT_FIELD_TYPE (decl))
@@ -19885,7 +19885,7 @@ add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr,
       default:
 	/* Because of the complex interaction there can be with other GNAT
 	   encodings, GDB isn't ready yet to handle proper DWARF description
-	   for self-referencial subrange bounds: let GNAT encodings do the
+	   for self-referential subrange bounds: let GNAT encodings do the
 	   magic in such a case.  */
 	if (is_ada ()
 	    && gnat_encodings != DWARF_GNAT_ENCODINGS_MINIMAL
@@ -21637,7 +21637,7 @@ dwarf2out_abstract_function (tree decl)
 
   /* We can be called while recursively when seeing block defining inlined subroutine
      DIE.  Be sure to not clobber the outer location table nor use it or we would
-     get locations in abstract instantces.  */
+     get locations in abstract instances.  */
   old_decl_loc_table = decl_loc_table;
   decl_loc_table = NULL;
   old_cached_dw_loc_list_table = cached_dw_loc_list_table;
@@ -22322,7 +22322,7 @@ gen_subprogram_die (tree decl, dw_die_ref context_die)
       resolve_variable_values ();
     }
 
-  /* Generate child dies for template paramaters.  */
+  /* Generate child dies for template parameters.  */
   if (early_dwarf && debug_info_level > DINFO_LEVEL_TERSE)
     gen_generic_params_dies (decl);
 
@@ -23866,7 +23866,7 @@ analyze_variants_discr (tree variant_part_decl,
 		goto abort;
 
 	      /* Extract the discriminant from the first operand and check it
-		 is consistant with the same analysis in the second
+		 is consistent with the same analysis in the second
 		 operand.  */
 	      candidate_discr_1
 	        = analyze_discr_in_predicate (TREE_OPERAND (lower_op, 0),
@@ -23907,7 +23907,7 @@ analyze_variants_discr (tree variant_part_decl,
 	       matching discriminant values.  Abort everything.  */
 	    goto abort;
 
-	  /* If the discriminant info is not consistant with what we saw so
+	  /* If the discriminant info is not consistent with what we saw so
 	     far, consider the analysis failed and abort everything.  */
 	  if (candidate_discr == NULL_TREE
 	      || (*discr_decl != NULL_TREE && candidate_discr != *discr_decl))
@@ -23990,7 +23990,7 @@ gen_variant_part (tree variant_part_decl, struct vlr_context *vlr_ctx,
 	add_AT_die_ref (variant_part_die, DW_AT_discr, discr_die);
       else
 	/* We have no DIE for the discriminant, so just discard all
-	   discrimimant information in the output.  */
+	   discriminant information in the output.  */
 	discr_decl = NULL_TREE;
     }
 
@@ -24255,7 +24255,7 @@ gen_struct_or_union_type_die (tree type, dw_die_ref context_die,
 
   scope_die = scope_die_for (type, context_die);
 
-  /* Generate child dies for template paramaters.  */
+  /* Generate child dies for template parameters.  */
   if (!type_die && debug_info_level > DINFO_LEVEL_TERSE)
     schedule_generic_params_dies_gen (type);
 
@@ -24834,10 +24834,10 @@ gen_block_die (tree stmt, dw_die_ref context_die)
 	{
 	  /* If STMT block is abstract, that means we have been called
 	     indirectly from dwarf2out_abstract_function.
-	     That function rightfully marks the descendent blocks (of
+	     That function rightfully marks the descendant blocks (of
 	     the abstract function it is dealing with) as being abstract,
 	     precisely to prevent us from emitting any
-	     DW_TAG_inlined_subroutine DIE as a descendent
+	     DW_TAG_inlined_subroutine DIE as a descendant
 	     of an abstract function instance. So in that case, we should
 	     not call gen_inlined_subroutine_die.
 
@@ -25365,7 +25365,7 @@ gen_decl_die (tree decl, tree origin, struct vlr_context *ctx,
 	 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here.  But nothing
 	 should be actually referencing those DIEs, as variable DIEs with that
 	 type would be emitted already in the abstract origin, so it was always
-	 removed during unused type prunning.  Don't add anything in this
+	 removed during unused type pruning.  Don't add anything in this
 	 case.  */
       if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE)
 	break;
@@ -27372,7 +27372,7 @@ dwarf2out_init (const char *filename ATTRIBUTE_UNUSED)
     equate_decl_number_to_die (main_translation_unit, comp_unit_die ());
 }
 
-/* Called before compile () starts outputtting functions, variables
+/* Called before compile () starts outputting functions, variables
    and toplevel asms into assembly.  */
 
 static void
@@ -30186,7 +30186,7 @@ resolve_variable_value (dw_die_ref die)
       }
 }
 
-/* Attempt to optimize DW_OP_GNU_variable_value refering to
+/* Attempt to optimize DW_OP_GNU_variable_value referring to
    temporaries in the current function.  */
 
 static void
diff --git a/gcc/dwarf2out.h b/gcc/dwarf2out.h
index 9402473..75560c7 100644
--- a/gcc/dwarf2out.h
+++ b/gcc/dwarf2out.h
@@ -242,7 +242,7 @@ struct GTY((chain_next ("%h.dw_loc_next"))) dw_loc_descr_node {
      from DW_OP_addr with a dtp-relative symbol relocation.  */
   unsigned int dtprel : 1;
   /* For DW_OP_pick, DW_OP_dup and DW_OP_over operations: true iff.
-     it targets a DWARF prodecure argument.  In this case, it needs to be
+     it targets a DWARF procedure argument.  In this case, it needs to be
      relocated according to the current frame offset.  */
   unsigned int frame_offset_rel : 1;
   int dw_loc_addr;
diff --git a/gcc/edit-context.c b/gcc/edit-context.c
index 6f35ca2..b722f77 100644
--- a/gcc/edit-context.c
+++ b/gcc/edit-context.c
@@ -172,7 +172,7 @@ class edited_line
 };
 
 /* Class for representing edit events that have occurred on one line of
-   one file: the replacement of some text betweeen some columns
+   one file: the replacement of some text between some columns
    on the line.
 
    Subsequent events will need their columns adjusting if they're
diff --git a/gcc/emit-rtl.h b/gcc/emit-rtl.h
index da60a2d..ba3ae43 100644
--- a/gcc/emit-rtl.h
+++ b/gcc/emit-rtl.h
@@ -75,12 +75,12 @@ struct GTY(()) rtl_data {
      result in a register, current_function_return_rtx will always be
      the hard register containing the result.  */
   rtx return_rtx;
-  /* If nonxero, an RTL expression for the lcoation at which the current
+  /* If nonzero, an RTL expression for the location at which the current
      function returns bounds for its result.  */
   rtx return_bnd;
 
   /* Vector of initial-value pairs.  Each pair consists of a pseudo
-     register of approprite mode that stores the initial value a hard
+     register of appropriate mode that stores the initial value a hard
      register REGNO, and that hard register itself.  */
   /* ??? This could be a VEC but there is currently no way to define an
 	 opaque VEC type.  */
diff --git a/gcc/except.h b/gcc/except.h
index 87eab55..56a4c31 100644
--- a/gcc/except.h
+++ b/gcc/except.h
@@ -170,7 +170,7 @@ struct GTY(()) eh_region_d
   struct eh_landing_pad_d *landing_pads;
 
   /* EXC_PTR and FILTER values copied from the runtime for this region.
-     Each region gets its own psuedos so that if there are nested exceptions
+     Each region gets its own pseudos so that if there are nested exceptions
      we do not overwrite the values of the first exception.  */
   rtx exc_ptr_reg, filter_reg;
 
diff --git a/gcc/expmed.c b/gcc/expmed.c
index 0c81280..e65c95d 100644
--- a/gcc/expmed.c
+++ b/gcc/expmed.c
@@ -633,7 +633,7 @@ store_bit_field_using_insv (const extraction_insn *insv, rtx op0,
   /* There are similar overflow check at the start of store_bit_field_1,
      but that only check the situation where the field lies completely
      outside the register, while there do have situation where the field
-     lies partialy in the register, we need to adjust bitsize for this
+     lies partially in the register, we need to adjust bitsize for this
      partial overflow situation.  Without this fix, pr48335-2.c on big-endian
      will broken on those arch support bit insert instruction, like arm, aarch64
      etc.  */
diff --git a/gcc/expr.c b/gcc/expr.c
index 5febf07..50ae044 100644
--- a/gcc/expr.c
+++ b/gcc/expr.c
@@ -2875,7 +2875,7 @@ use_group_regs (rtx *call_fusage, rtx regs)
 }
 
 /* Return the defining gimple statement for SSA_NAME NAME if it is an
-   assigment and the code of the expresion on the RHS is CODE.  Return
+   assignment and the code of the expression on the RHS is CODE.  Return
    NULL otherwise.  */
 
 static gimple *
@@ -2895,7 +2895,7 @@ get_def_for_expr (tree name, enum tree_code code)
 }
 
 /* Return the defining gimple statement for SSA_NAME NAME if it is an
-   assigment and the class of the expresion on the RHS is CLASS.  Return
+   assignment and the class of the expression on the RHS is CLASS.  Return
    NULL otherwise.  */
 
 static gimple *
@@ -8076,7 +8076,7 @@ expand_expr_real (tree exp, rtx target, machine_mode tmode,
 }
 
 /* Try to expand the conditional expression which is represented by
-   TREEOP0 ? TREEOP1 : TREEOP2 using conditonal moves.  If it succeeds
+   TREEOP0 ? TREEOP1 : TREEOP2 using conditional moves.  If it succeeds
    return the rtl reg which represents the result.  Otherwise return
    NULL_RTX.  */
 
@@ -8099,7 +8099,7 @@ expand_cond_expr_using_cmove (tree treeop0 ATTRIBUTE_UNUSED,
 
   /* Conditional move expansion can end up TERing two operands which,
      when recursively hitting conditional expressions can result in
-     exponential behavior if the cmove expansion ultimatively fails.
+     exponential behavior if the cmove expansion ultimately fails.
      It's hardly profitable to TER a cmove into a cmove so avoid doing
      that by failing early if we end up recursing.  */
   if (expanding_cond_expr_using_cmove)
@@ -9764,7 +9764,7 @@ expand_expr_real_1 (tree exp, rtx target, machine_mode tmode,
 	    case GIMPLE_BINARY_RHS:
 	      ops.op1 = gimple_assign_rhs2 (g);
 
-	      /* Try to expand conditonal compare.  */
+	      /* Try to expand conditional compare.  */
 	      if (targetm.gen_ccmp_first)
 		{
 		  gcc_checking_assert (targetm.gen_ccmp_next != NULL);
diff --git a/gcc/fibonacci_heap.h b/gcc/fibonacci_heap.h
index 554a142..d84e360 100644
--- a/gcc/fibonacci_heap.h
+++ b/gcc/fibonacci_heap.h
@@ -239,7 +239,7 @@ private:
   /* Remove NODE from PARENT's child list.  */
   void cut (fibonacci_node_t *node, fibonacci_node_t *parent);
 
-  /* Process cut of node Y and do it recursivelly.  */
+  /* Process cut of node Y and do it recursively.  */
   void cascading_cut (fibonacci_node_t *y);
 
   /* Extract minimum node from the heap.  */
@@ -538,7 +538,7 @@ fibonacci_heap<K,V>::cut (fibonacci_node<K,V> *node,
   node->m_mark = 0;
 }
 
-/* Process cut of node Y and do it recursivelly.  */
+/* Process cut of node Y and do it recursively.  */
 
 template<class K, class V>
 void
diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index b0d03c9..1c0f11f 100644
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -2752,7 +2752,7 @@ combine_comparisons (location_t loc,
    such as MODIFY_EXPR, RETURN_EXPR, as well as STATEMENT_LISTs.
 
    Unless OEP_MATCH_SIDE_EFFECTS is set, the function returns false on
-   any operand with side effect.  This is unnecesarily conservative in the
+   any operand with side effect.  This is unnecessarily conservative in the
    case we know that arg0 and arg1 are in disjoint code paths (such as in
    ?: operator).  In addition OEP_MATCH_SIDE_EFFECTS is used when comparing
    addresses with TREE_CONSTANT flag set so we know that &var == &var
@@ -2887,7 +2887,7 @@ operand_equal_p (const_tree arg0, const_tree arg1, unsigned int flags)
 	return 0;
     }
 
-  /* When not checking adddresses, this is needed for conversions and for
+  /* When not checking addresses, this is needed for conversions and for
      COMPONENT_REF.  Might as well play it safe and always test this.  */
   if (TREE_CODE (TREE_TYPE (arg0)) == ERROR_MARK
       || TREE_CODE (TREE_TYPE (arg1)) == ERROR_MARK
@@ -3157,7 +3157,7 @@ operand_equal_p (const_tree arg0, const_tree arg1, unsigned int flags)
 	case WIDEN_MULT_MINUS_EXPR:
 	  if (!OP_SAME (2))
 	    return 0;
-	  /* The multiplcation operands are commutative.  */
+	  /* The multiplication operands are commutative.  */
 	  /* FALLTHRU */
 
 	case TRUTH_AND_EXPR:
@@ -8124,7 +8124,7 @@ fold_truth_andor (location_t loc, enum tree_code code, tree type,
 	}
       /* Transform (A AND-IF B) into (A AND B), or (A OR-IF B)
 	 into (A OR B).
-	 For sequence point consistancy, we need to check for trapping,
+	 For sequence point consistency, we need to check for trapping,
 	 and side-effects.  */
       else if (code == icode && simple_operand_p_2 (arg0)
                && simple_operand_p_2 (arg1))
diff --git a/gcc/fortran/check.c b/gcc/fortran/check.c
index 45bc68e..dacf986 100644
--- a/gcc/fortran/check.c
+++ b/gcc/fortran/check.c
@@ -3430,7 +3430,7 @@ gfc_check_move_alloc (gfc_expr *from, gfc_expr *to)
       return false;
     }
 
-  /*  This is based losely on F2003 12.4.1.7. It is intended to prevent
+  /*  This is based loosely on F2003 12.4.1.7. It is intended to prevent
       the likes of to = sym->cmp1->cmp2 and from = sym->cmp1, where cmp1
       and cmp2 are allocatable.  After the allocation is transferred,
       the 'to' chain is broken by the nullification of the 'from'. A bit
@@ -4426,7 +4426,7 @@ is_c_interoperable (gfc_expr *expr, const char **msg, bool c_loc, bool c_f_ptr)
       }
     }
 
-  /* Note: The following checks are about interoperatable variables, Fortran
+  /* Note: The following checks are about interoperable variables, Fortran
      15.3.5/15.3.6.  In intrinsics like C_LOC or in procedure interface, more
      is allowed, e.g. assumed-shape arrays with TS 29113.  */
 
diff --git a/gcc/fortran/class.c b/gcc/fortran/class.c
index 2d72e95..0a685c1 100644
--- a/gcc/fortran/class.c
+++ b/gcc/fortran/class.c
@@ -558,7 +558,7 @@ gfc_intrinsic_hash_value (gfc_typespec *ts)
 
 /* Get the _len component from a class/derived object storing a string.
    For unlimited polymorphic entities a ref to the _data component is available
-   while a ref to the _len component is needed.  This routine traverese the
+   while a ref to the _len component is needed.  This routine traverse the
    ref-chain and strips the last ref to a _data from it replacing it with a
    ref to the _len component.  */
 
@@ -1504,7 +1504,7 @@ finalizer_insert_packed_call (gfc_code *block, gfc_finalizer *fini,
 
 
 /* Generate the finalization/polymorphic freeing wrapper subroutine for the
-   derived type "derived". The function first calls the approriate FINAL
+   derived type "derived". The function first calls the appropriate FINAL
    subroutine, then it DEALLOCATEs (finalizes/frees) the allocatable
    components (but not the inherited ones). Last, it calls the wrapper
    subroutine of the parent. The generated wrapper procedure takes as argument
diff --git a/gcc/fortran/decl.c b/gcc/fortran/decl.c
index bd31070..63eac4d 100644
--- a/gcc/fortran/decl.c
+++ b/gcc/fortran/decl.c
@@ -1913,7 +1913,7 @@ build_struct (const char *name, gfc_charlen *cl, gfc_expr **init,
   /* If we are in a nested union/map definition, gfc_add_component will not
      properly find repeated components because:
        (i) gfc_add_component does a flat search, where components of unions
-           and maps are implicity chained so nested components may conflict.
+           and maps are implicitly chained so nested components may conflict.
       (ii) Unions and maps are not linked as components of their parent
            structures until after they are parsed.
      For (i) we use gfc_find_component which searches recursively, and for (ii)
@@ -2243,7 +2243,7 @@ variable_decl (int elem)
 	}
     }
 
-  /* The dummy arguments and result of the abreviated form of MODULE
+  /* The dummy arguments and result of the abbreviated form of MODULE
      PROCEDUREs, used in SUBMODULES should not be redefined.  */
   if (gfc_current_ns->proc_name
       && gfc_current_ns->proc_name->abr_modproc_decl)
@@ -5079,7 +5079,7 @@ copy_prefix (symbol_attribute *dest, locus *where)
 	dest->recursive = 1;
 
       /* Module procedures are unusual in that the 'dest' is copied from
-	 the interface declaration. However, this is an oportunity to
+	 the interface declaration. However, this is an opportunity to
 	 check that the submodule declaration is compliant with the
 	 interface.  */
       if (dest->elemental && !current_attr.elemental)
diff --git a/gcc/fortran/expr.c b/gcc/fortran/expr.c
index 9b2e565..6c11381 100644
--- a/gcc/fortran/expr.c
+++ b/gcc/fortran/expr.c
@@ -3125,7 +3125,7 @@ gfc_check_conformance (gfc_expr *op1, gfc_expr *op2, const char *optype_msgid, .
 /* Given an assignable expression and an arbitrary expression, make
    sure that the assignment can take place.  Only add a call to the intrinsic
    conversion routines, when allow_convert is set.  When this assign is a
-   coarray call, then the convert is done by the coarray routine implictly and
+   coarray call, then the convert is done by the coarray routine implicitly and
    adding the intrinsic conversion would do harm in most cases.  */
 
 bool
diff --git a/gcc/fortran/frontend-passes.c b/gcc/fortran/frontend-passes.c
index be02dce..1284e2b 100644
--- a/gcc/fortran/frontend-passes.c
+++ b/gcc/fortran/frontend-passes.c
@@ -341,7 +341,7 @@ optimize_expr (gfc_expr **e, int *walk_subtrees ATTRIBUTE_UNUSED,
   return 0;
 }
 
-/* Auxiliary function to handle the arguments to reduction intrnisics.  If the
+/* Auxiliary function to handle the arguments to reduction intrinsics.  If the
    function is a scalar, just copy it; otherwise returns the new element, the
    old one can be freed.  */
 
@@ -392,7 +392,7 @@ copy_walk_reduction_arg (gfc_constructor *c, gfc_expr *fn)
   return fcn;
 }
 
-/* Callback function for optimzation of reductions to scalars.  Transform ANY
+/* Callback function for optimization of reductions to scalars.  Transform ANY
    ([f1,f2,f3, ...]) to f1 .or. f2 .or. f3 .or. ..., with ANY, SUM and PRODUCT
    correspondingly.  Handly only the simple cases without MASK and DIM.  */
 
@@ -886,7 +886,7 @@ cfe_code (gfc_code **c, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
   changed_statement = NULL;
 
   /* Do not do anything inside a WHERE statement; scalar assignments, BLOCKs
-     and allocation on assigment are prohibited inside WHERE, and finally
+     and allocation on assignment are prohibited inside WHERE, and finally
      masking an expression would lead to wrong-code when replacing
 
      WHERE (a>0)
@@ -2103,7 +2103,7 @@ doloop_warn (gfc_namespace *ns)
   gfc_code_walker (&ns->code, doloop_code, do_function, NULL);
 }
 
-/* This selction deals with inlining calls to MATMUL.  */
+/* This selection deals with inlining calls to MATMUL.  */
 
 /* Replace calls to matmul outside of straight assignments with a temporary
    variable so that later inlining will work.  */
@@ -2485,7 +2485,7 @@ matmul_lhs_realloc (gfc_expr *c, gfc_expr *a, gfc_expr *b,
 
   /* c comes in as a full ref.  Change it into a copy and make it into an
      element ref so it has the right form for for ALLOCATE.  In the same
-     switch statement, also generate the size comparison for the secod IF
+     switch statement, also generate the size comparison for the second IF
      statement.  */
 
   ar->type = AR_ELEMENT;
diff --git a/gcc/fortran/gfortran.h b/gcc/fortran/gfortran.h
index 26b89be..3504657 100644
--- a/gcc/fortran/gfortran.h
+++ b/gcc/fortran/gfortran.h
@@ -832,7 +832,7 @@ typedef struct
   unsigned always_explicit:1;
 
   /* Set if the symbol is generated and, hence, standard violations
-     shouldn't be flaged.  */
+     shouldn't be flagged.  */
   unsigned artificial:1;
 
   /* Set if the symbol has been referenced in an expression.  No further
@@ -884,7 +884,7 @@ typedef struct
   unsigned oacc_declare_device_resident:1;
   unsigned oacc_declare_link:1;
 
-  /* This is an OpenACC acclerator function at level N - 1  */
+  /* This is an OpenACC accelerator function at level N - 1  */
   unsigned oacc_function:3;
 
   /* Attributes set by compiler extensions (!GCC$ ATTRIBUTES).  */
@@ -1560,7 +1560,7 @@ typedef struct gfc_symbol
   /* Used to avoid multiple resolutions of a single symbol.  */
   unsigned resolved:1;
   /* Set if this is a module function or subroutine with the
-     abreviated declaration in a submodule.  */
+     abbreviated declaration in a submodule.  */
   unsigned abr_modproc_decl:1;
 
   int refs;
diff --git a/gcc/fortran/intrinsic.c b/gcc/fortran/intrinsic.c
index 2f60fe8..126021b 100644
--- a/gcc/fortran/intrinsic.c
+++ b/gcc/fortran/intrinsic.c
@@ -520,7 +520,7 @@ add_sym_1s (const char *name, gfc_isym_id id, enum klass cl, bt type, int kind,
 	   (void *) 0);
 }
 
-/* Add a symbol to the subroutine ilst where the subroutine takes one
+/* Add a symbol to the subroutine list where the subroutine takes one
    printf-style character argument and a variable number of arguments
    to follow.  */
 
diff --git a/gcc/fortran/primary.c b/gcc/fortran/primary.c
index b30afdd..ef9cf84 100644
--- a/gcc/fortran/primary.c
+++ b/gcc/fortran/primary.c
@@ -739,8 +739,8 @@ done:
     }
 
   /* Warn about trailing digits which suggest the user added too many
-     trailing digits, which may cause the appearance of higher pecision
-     than the kind kan support.
+     trailing digits, which may cause the appearance of higher precision
+     than the kind can support.
 
      This is done by replacing the rightmost non-zero digit with zero
      and comparing with the original value.  If these are equal, we
diff --git a/gcc/fortran/resolve.c b/gcc/fortran/resolve.c
index a5f4874..c38e729 100644
--- a/gcc/fortran/resolve.c
+++ b/gcc/fortran/resolve.c
@@ -5181,7 +5181,7 @@ resolve_variable (gfc_expr *e)
       /* Because this is an associate var and the first ref either is a ref to
 	 the _data component or not, no traversal of the ref chain is
 	 needed.  The array ref needs to be inserted after the _data ref,
-	 or when that is not present, which may happend for polymorphic
+	 or when that is not present, which may happen for polymorphic
 	 types, then at the first position.  */
       ref = e->ref;
       if (!ref)
@@ -10464,7 +10464,7 @@ generate_component_assignments (gfc_code **code, gfc_namespace *ns)
 	  || comp1->attr.proc_pointer)
 	continue;
 
-      /* Make an assigment for this component.  */
+      /* Make an assignment for this component.  */
       this_code = build_assignment (EXEC_ASSIGN,
 				    (*code)->expr1, (*code)->expr2,
 				    comp1, comp2, (*code)->loc);
diff --git a/gcc/fortran/trans-array.c b/gcc/fortran/trans-array.c
index 47e8c09..d6cfd35 100644
--- a/gcc/fortran/trans-array.c
+++ b/gcc/fortran/trans-array.c
@@ -801,7 +801,7 @@ gfc_set_loop_bounds_from_array_spec (gfc_interface_mapping * mapping,
    free the array afterwards.
 
    If INITIAL is not NULL, it is packed using internal_pack and the result used
-   as data instead of allocating a fresh, unitialized area of memory.
+   as data instead of allocating a fresh, uninitialized area of memory.
 
    Initialization code is added to PRE and finalization code to POST.
    DYNAMIC is true if the caller may want to extend the array later
@@ -7978,7 +7978,7 @@ duplicate_allocatable_coarray (tree dest, tree dest_tok, tree src,
     }
   else
     {
-      /* Set the rank or unitialized memory access may be reported.  */
+      /* Set the rank or uninitialized memory access may be reported.  */
       tmp = gfc_conv_descriptor_dtype (dest);
       gfc_add_modify (&globalblock, tmp, build_int_cst (TREE_TYPE (tmp), rank));
 
diff --git a/gcc/fortran/trans-expr.c b/gcc/fortran/trans-expr.c
index af1549a..fbf73e6 100644
--- a/gcc/fortran/trans-expr.c
+++ b/gcc/fortran/trans-expr.c
@@ -342,7 +342,7 @@ gfc_vptr_size_get (tree vptr)
 
 
 /* Search for the last _class ref in the chain of references of this
-   expression and cut the chain there.  Albeit this routine is similiar
+   expression and cut the chain there.  Albeit this routine is similar
    to class.c::gfc_add_component_ref (), is there a significant
    difference: gfc_add_component_ref () concentrates on an array ref to
    be the last ref in the chain.  This routine is oblivious to the kind
@@ -9586,7 +9586,7 @@ alloc_scalar_allocatable_for_assignment (stmtblock_t *block,
 
    a = a + 4
 
-   to make sure we do not check for reallocation unneccessarily.  */
+   to make sure we do not check for reallocation unnecessarily.  */
 
 
 static bool
diff --git a/gcc/fortran/trans-stmt.c b/gcc/fortran/trans-stmt.c
index e4f1da5..e20a039 100644
--- a/gcc/fortran/trans-stmt.c
+++ b/gcc/fortran/trans-stmt.c
@@ -1712,7 +1712,7 @@ trans_associate_var (gfc_symbol *sym, gfc_wrapped_block *block)
 	      /* Add the assign to the beginning of the block...  */
 	      gfc_add_modify (&se.pre, charlen,
 			      fold_convert (TREE_TYPE (charlen), tmp));
-	      /* and the oposite way at the end of the block, to hand changes
+	      /* and the opposite way at the end of the block, to hand changes
 		 on the string length back.  */
 	      gfc_add_modify (&se.post, tmp,
 			      fold_convert (TREE_TYPE (tmp), charlen));
@@ -5415,7 +5415,7 @@ gfc_trans_where (gfc_code * code)
 	     is not dependent on writes to x1, and both y's are not
 	     dependent upon their own x's.  In addition to this, the
 	     final two dependency checks below exclude all but the same
-	     array reference if the where and elswhere destinations
+	     array reference if the where and elsewhere destinations
 	     are the same.  In short, this is VERY conservative and this
 	     is needed because the two loops, required by the standard
 	     are coalesced in gfc_trans_where_3.  */
@@ -5633,7 +5633,7 @@ gfc_trans_allocate (gfc_code * code)
 		}
 	      /* Create a temp variable only for component refs to prevent
 		 having to go through the full deref-chain each time and to
-		 simplfy computation of array properties.  */
+		 simplify computation of array properties.  */
 	      temp_var_needed = TREE_CODE (se.expr) == COMPONENT_REF;
 	    }
 	}
@@ -5897,7 +5897,7 @@ gfc_trans_allocate (gfc_code * code)
 	  && DECL_P (expr3) && DECL_ARTIFICIAL (expr3))
 	{
 	  /* Build a temporary symtree and symbol.  Do not add it to the current
-	     namespace to prevent accidently modifying a colliding
+	     namespace to prevent accidentally modifying a colliding
 	     symbol's as.  */
 	  newsym = XCNEW (gfc_symtree);
 	  /* The name of the symtree should be unique, because gfc_create_var ()
@@ -6345,7 +6345,7 @@ gfc_trans_allocate (gfc_code * code)
 	  tmp= gfc_trans_init_assign (ini);
 	  flag_realloc_lhs = realloc_lhs;
 	  gfc_free_statements (ini);
-	  /* Init_expr is freeed by above free_statements, just need to null
+	  /* Init_expr is freed by above free_statements, just need to null
 	     it here.  */
 	  init_expr = NULL;
 	  gfc_add_expr_to_block (&block, tmp);
diff --git a/gcc/fortran/trans.c b/gcc/fortran/trans.c
index 2323e0a..126d96e 100644
--- a/gcc/fortran/trans.c
+++ b/gcc/fortran/trans.c
@@ -476,7 +476,7 @@ trans_runtime_error_vararg (bool error, locus* where, const char* msgid,
 
   /* Build the function call to runtime_(warning,error)_at; because of the
      variable number of arguments, we can't use build_call_expr_loc dinput_location,
-     irectly.  */
+     directly.  */
   if (error)
     fntype = TREE_TYPE (gfor_fndecl_runtime_error_at);
   else
diff --git a/gcc/function.c b/gcc/function.c
index f625489..8b93b5f 100644
--- a/gcc/function.c
+++ b/gcc/function.c
@@ -680,7 +680,7 @@ temp_address_hasher::equal (temp_slot_address_entry *t1,
   return exp_equiv_p (t1->address, t2->address, 0, true);
 }
 
-/* Add ADDRESS as an alias of TEMP_SLOT to the addess -> temp slot mapping.  */
+/* Add ADDRESS as an alias of TEMP_SLOT to the address -> temp slot mapping.  */
 static void
 insert_temp_slot_address (rtx address, struct temp_slot *temp_slot)
 {
@@ -2174,7 +2174,7 @@ use_register_for_decl (const_tree decl)
       /* Otherwise, if RESULT_DECL is DECL_BY_REFERENCE, it will take
 	 the function_result_decl's assignment.  Since it's a pointer,
 	 we can short-circuit a number of the tests below, and we must
-	 duplicat e them because we don't have the
+	 duplicate them because we don't have the
 	 function_result_decl to test.  */
       if (!targetm.calls.allocate_stack_slots_for_args ())
 	return true;
@@ -2185,7 +2185,7 @@ use_register_for_decl (const_tree decl)
       return false;
     }
 
-  /* Decl is implicitly addressible by bound stores and loads
+  /* Decl is implicitly addressable by bound stores and loads
      if it is an aggregate holding bounds.  */
   if (chkp_function_instrumented_p (current_function_decl)
       && TREE_TYPE (decl)
diff --git a/gcc/gcc.c b/gcc/gcc.c
index 4724276..995b274 100644
--- a/gcc/gcc.c
+++ b/gcc/gcc.c
@@ -48,7 +48,7 @@ compilation is specified by a string called a "spec".  */
 
 /* Manage the manipulation of env vars.
 
-   We poison "getenv" and "putenv", so that all enviroment-handling is
+   We poison "getenv" and "putenv", so that all environment-handling is
    done through this class.  Note that poisoning happens in the
    preprocessor at the identifier level, and doesn't distinguish between
      env.getenv ();
@@ -525,7 +525,7 @@ or with constant text in a single argument.
  %2	process CC1PLUS_SPEC as a spec.
  %*	substitute the variable part of a matched option.  (See below.)
 	Note that each comma in the substituted string is replaced by
-	a single space.  A space is appended after the last substition
+	a single space.  A space is appended after the last substitution
 	unless there is more text in current sequence.
  %<S    remove all occurrences of -S from the command line.
         Note - this command is position dependent.  % commands in the
@@ -561,7 +561,7 @@ or with constant text in a single argument.
           if %* appears somewhere in X, then X will be substituted
           once for each matching switch, with the %* replaced by the
           part of that switch that matched the '*'.  A space will be
-	  appended after the last substition unless there is more
+	  appended after the last substitution unless there is more
 	  text in current sequence.
  %{.S:X}  substitutes X, if processing a file with suffix S.
  %{!.S:X} substitutes X, if NOT processing a file with suffix S.
@@ -941,7 +941,7 @@ proper position among the other output files.  */
 /* Conditional to test whether the LTO plugin is used or not.
    FIXME: For slim LTO we will need to enable plugin unconditionally.  This
    still cause problems with PLUGIN_LD != LD and when plugin is built but
-   not useable.  For GCC 4.6 we don't support slim LTO and thus we can enable
+   not usable.  For GCC 4.6 we don't support slim LTO and thus we can enable
    plugin only when LTO is enabled.  We still honor explicit
    -fuse-linker-plugin if the linker used understands -plugin.  */
 
@@ -6872,7 +6872,7 @@ out:
 }
 
 /* This routine reads lines from IN file, adds C++ style comments
-   at the begining of each line and writes result into OUT.  */
+   at the beginning of each line and writes result into OUT.  */
 
 static void
 insert_comments (const char *file_in, const char *file_out)
diff --git a/gcc/gcov-dump.c b/gcc/gcov-dump.c
index d24e72a..57cb858 100644
--- a/gcc/gcov-dump.c
+++ b/gcc/gcov-dump.c
@@ -515,7 +515,7 @@ dump_working_sets (const char *filename ATTRIBUTE_UNUSED,
       if (ws_ix == NUM_GCOV_WORKING_SETS - 1)
         pct = 9990;
       ws_info = &gcov_working_sets[ws_ix];
-      /* Print out the percentage using int arithmatic to avoid float.  */
+      /* Print out the percentage using int arithmetic to avoid float.  */
       printf ("\n");
       print_prefix (filename, depth + 1, 0);
       printf (VALUE_PADDING_PREFIX "%u.%02u%%: num counts=%u, min counter="
diff --git a/gcc/gcov-io.c b/gcc/gcov-io.c
index 64dedd5..fc30b88 100644
--- a/gcc/gcov-io.c
+++ b/gcc/gcov-io.c
@@ -918,7 +918,7 @@ compute_working_sets (const struct gcov_ctr_summary *summary,
   working_set_cum_values[NUM_GCOV_WORKING_SETS-1]
       = summary->sum_all - summary->sum_all/1024;
 
-  /* Next, walk through the histogram in decending order of hotness
+  /* Next, walk through the histogram in descending order of hotness
      and compute the statistics for the working set summary array.
      As histogram entries are accumulated, we check to see which
      working set entries have had their expected cum_value reached
diff --git a/gcc/gcov.c b/gcc/gcov.c
index a5aa4aa..435b4d7 100644
--- a/gcc/gcov.c
+++ b/gcc/gcov.c
@@ -366,7 +366,7 @@ static int flag_long_names = 0;
 
 static int flag_hash_filenames = 0;
 
-/* Print verbose informations.  */
+/* Print verbose information.  */
 
 static int flag_verbose = 0;
 
diff --git a/gcc/genattrtab.c b/gcc/genattrtab.c
index 3629b5f..6df8192 100644
--- a/gcc/genattrtab.c
+++ b/gcc/genattrtab.c
@@ -299,7 +299,7 @@ static rtx min_fn		   (rtx);
    functions and tables.  This made insn-attrtab.c _the_ bottle-neck in
    a parallel build, and even made it impossible to build GCC on machines
    with relatively small RAM space (PR other/29442).  Therefore, the
-   atrribute functions/tables are now written out to three separate
+   attribute functions/tables are now written out to three separate
    files: all "*insn_default_latency" functions go to LATENCY_FILE_NAME,
    all "*internal_dfa_insn_code" functions go to DFA_FILE_NAME, and the
    rest goes to ATTR_FILE_NAME.  */
@@ -2843,7 +2843,7 @@ get_attr_order (struct attr_desc ***ret)
 		}
 	    if (k == num)
 	      {
-		/* Nothing in I depended on anything intersting, so
+		/* Nothing in I depended on anything interesting, so
 		   it's done.  */
 		handled[i] = 1;
 		sorted[j++] = all[i];
@@ -2909,7 +2909,7 @@ optimize_attrs (int num_insn_codes)
 
   iv = ivbuf = XNEWVEC (struct attr_value_list, num_insn_ents);
 
-  /* Create the chain of insn*attr values such that we see dependend
+  /* Create the chain of insn*attr values such that we see dependent
      attributes after their dependencies.  As we use a stack via the
      next pointers start from the end of the topological order.  */
   topnum = get_attr_order (&topsort);
diff --git a/gcc/genautomata.c b/gcc/genautomata.c
index 76dacbc..5f3d884 100644
--- a/gcc/genautomata.c
+++ b/gcc/genautomata.c
@@ -5029,7 +5029,7 @@ struct unit_usage
 {
   unit_decl_t unit_decl;
   /* The following forms a list of units used on the same cycle in the
-     same alternative.  The list is ordered by the correspdoning unit
+     same alternative.  The list is ordered by the corresponding unit
      declarations and there is no unit declaration duplication in the
      list.  */
   struct unit_usage *next;
diff --git a/gcc/gengtype-state.c b/gcc/gengtype-state.c
index 2f27c42..e2ec67c 100644
--- a/gcc/gengtype-state.c
+++ b/gcc/gengtype-state.c
@@ -238,7 +238,7 @@ s_expr_writer::write_any_indent (int leading_spaces)
   m_had_recent_newline = 0;
 }
 
-/* Write the beginning of a new s-expresion e.g. "(!foo "
+/* Write the beginning of a new s-expression e.g. "(!foo "
    The writer automatically adds whitespace to show the hierarchical
    structure of the expressions, so each one starts on a new line,
    and any within it will be at an increased indentation level.  */
@@ -251,7 +251,7 @@ s_expr_writer::begin_s_expr (const char *tag)
   m_indent_amount++;
 }
 
-/* Write out the end of an s-expression: any necssessary indentation,
+/* Write out the end of an s-expression: any necessary indentation,
    a closing parenthesis, and a new line.  */
 void
 s_expr_writer::end_s_expr (void)
@@ -984,7 +984,7 @@ state_writer::write_state_union_type (type_p current)
 
 /* Write a lang_struct type.  This is tricky and was painful to debug,
    we deal with the next field specifically within their lang_struct
-   subfield, which points to a linked list of homonumous types.
+   subfield, which points to a linked list of homonymous types.
    Change this function with extreme care, see also
    read_state_lang_struct_type.  */
 void
diff --git a/gcc/gengtype.c b/gcc/gengtype.c
index ec949a1..904038d 100644
--- a/gcc/gengtype.c
+++ b/gcc/gengtype.c
@@ -1845,7 +1845,7 @@ get_file_gtfilename (const input_file *inpf)
     (langdir ? xasprintf ("gt-%s-%s", langdir, basename)
      : xasprintf ("gt-%s", basename));
 
-  /* Then replace all non alphanumerics characters by '-' and change the
+  /* Then replace all non alphanumeric characters by '-' and change the
      extension to ".h".  We expect the input filename extension was at least
      one character long.  */
 
@@ -2966,7 +2966,7 @@ walk_type (type_p t, struct walk_type_data *d)
 	       This organization requires the base class to have a case in
 	       the switch statement, and hence a tag value is mandatory
 	       for the base class.   This restriction could be removed, but
-	       it would require some restructing of this code.  */
+	       it would require some restructuring of this code.  */
 	    if (!type_tag)
 	      {
 		error_at_line (d->line,
@@ -4674,9 +4674,9 @@ write_roots (pair_p variables, bool emit_pch)
 		     "gt_pch_scalar_rtab");
 }
 
-/* Prints not-as-ugly version of a typename of T to OF.  Trades the uniquness
-   guaranteee for somewhat increased readability.  If name conflicts do happen,
-   this funcion will have to be adjusted to be more like
+/* Prints not-as-ugly version of a typename of T to OF.  Trades the uniqueness
+   guarantee for somewhat increased readability.  If name conflicts do happen,
+   this function will have to be adjusted to be more like
    output_mangled_typename.  */
 
 #define INDENT 2
diff --git a/gcc/gengtype.h b/gcc/gengtype.h
index 61a799f..06dbc50 100644
--- a/gcc/gengtype.h
+++ b/gcc/gengtype.h
@@ -295,7 +295,7 @@ struct type {
       /* The following two fields are not serialized in state files, and
 	 are instead reconstructed on load.  */
 
-      /* The head of a singly-linked list of immediate descendents in
+      /* The head of a singly-linked list of immediate descendants in
 	 the inheritance hierarchy.  */
       type_p first_subclass;
       /* The next in that list.  */
diff --git a/gcc/genhooks.c b/gcc/genhooks.c
index fb380c5..bc36c7c 100644
--- a/gcc/genhooks.c
+++ b/gcc/genhooks.c
@@ -103,11 +103,11 @@ s_hook_eq_p (const void *p1, const void *p2)
    If the doc field starts with '*', the leading '*' is stripped, and the doc
    field is otherwise emitted unaltered; no function signature/
    @deftypefn/deftypevr/@end is emitted.
-   In particular, a doc field of "*" means not to emit any ocumentation for
+   In particular, a doc field of "*" means not to emit any documentation for
    this target.def / hook_array entry at all (there might be documentation
    for this hook in the file named IN_FNAME, though).
    A doc field of 0 is used to append the hook signature after the previous
-   hook's signture, so that one description can be used for a group of hooks.
+   hook's signature, so that one description can be used for a group of hooks.
    When the doc field is "", @deftypefn/@deftypevr and the hook signature
    is emitted, but not the matching @end.  This allows all the free-form
    documentation to be placed in IN_FNAME, to work around GPL/GFDL
diff --git a/gcc/genmatch.c b/gcc/genmatch.c
index f20e39f..5df1962 100644
--- a/gcc/genmatch.c
+++ b/gcc/genmatch.c
@@ -647,7 +647,7 @@ struct expr : public operand
   /* The operator and its operands.  */
   id_base *operation;
   vec<operand *> ops;
-  /* An explicitely specified type - used exclusively for conversions.  */
+  /* An explicitly specified type - used exclusively for conversions.  */
   const char *expr_type;
   /* Whether the operation is to be applied commutatively.  This is
      later lowered to two separate patterns.  */
@@ -1013,7 +1013,7 @@ lower_commutative (simplify *s, vec<simplify *>& simplifiers)
     }
 }
 
-/* Strip conditional conversios using operator OPER from O and its
+/* Strip conditional conversions using operator OPER from O and its
    children if STRIP, else replace them with an unconditional convert.  */
 
 operand *
@@ -2372,7 +2372,7 @@ expr::gen_transform (FILE *f, int indent, const char *dest, bool gimple,
 	  indent += 4;
 	}
       /* ???  Building a stmt can fail for various reasons here, seq being
-         NULL or the stmt referencing SSA names occuring in abnormal PHIs.
+         NULL or the stmt referencing SSA names occurring in abnormal PHIs.
 	 So if we fail here we should continue matching other patterns.  */
       fprintf_indent (f, indent, "code_helper tem_code = %s;\n", opr_name);
       fprintf_indent (f, indent, "tree tem_ops[3] = { ");
@@ -4902,7 +4902,7 @@ round_alloc_size (size_t s)
 }
 
 
-/* The genmatch generator progam.  It reads from a pattern description
+/* The genmatch generator program.  It reads from a pattern description
    and outputs GIMPLE or GENERIC IL matching and simplification routines.  */
 
 int
diff --git a/gcc/genopinit.c b/gcc/genopinit.c
index d98fcd5..87bad41 100644
--- a/gcc/genopinit.c
+++ b/gcc/genopinit.c
@@ -339,7 +339,7 @@ main (int argc, const char **argv)
 	   "}\n\n");
 
   /* C++ (even G++) does not support (non-trivial) designated initializers.
-     To work around that, generate these arrays programatically rather than
+     To work around that, generate these arrays programmatically rather than
      by our traditional multiple inclusion of def files.  */
 
   fprintf (s_file,
diff --git a/gcc/genoutput.c b/gcc/genoutput.c
index 6469bef..28d7260 100644
--- a/gcc/genoutput.c
+++ b/gcc/genoutput.c
@@ -163,7 +163,7 @@ struct data
 static struct data *idata;
 
 /* This variable points to the end of the insn chain.  This is where
-   everything relevant from the machien description is appended to.  */
+   everything relevant from the machine description is appended to.  */
 static struct data **idata_end;
 
 
diff --git a/gcc/genrecog.c b/gcc/genrecog.c
index b69043f..f62fddd 100644
--- a/gcc/genrecog.c
+++ b/gcc/genrecog.c
@@ -1742,7 +1742,7 @@ struct known_conditions
   /* Index N says whether operands[N] has been set.  */
   auto_vec <bool> set_operands;
 
-  /* A guranteed lower bound on the value of peep2_current_count.  */
+  /* A guaranteed lower bound on the value of peep2_current_count.  */
   int peep2_count;
 };
 
@@ -2259,7 +2259,7 @@ struct merge_pattern_info
      These default parameters are used in cases where we match the
      pattern against some state S1, then add more parameters while
      matching against some state S2.  S1 is then left passing fewer
-     parameters than S2.  The array gives us enough informatino to
+     parameters than S2.  The array gives us enough information to
      construct a full parameter list for S1 (see update_parameters).
 
      If we decide to create a subroutine for this pattern,
@@ -2405,7 +2405,7 @@ prune_invalid_results (merge_state_info *sinfo)
     }
 }
 
-/* Return true if PAT represents the biggest posssible match for SINFO;
+/* Return true if PAT represents the biggest possible match for SINFO;
    that is, if the next action of SINFO's state on return from PAT will
    be something that cannot be merged with any other state.  */
 
@@ -3126,7 +3126,7 @@ split_out_patterns (vec <merge_state_info> &states)
      The non-leaf patterns that we try are as deep as possible
      and are an extension of the state's previous best candidate match (PB).
      We need only consider states whose current potential match is also PB;
-     any states that don't match as much as PB cannnot match the new pattern,
+     any states that don't match as much as PB cannot match the new pattern,
      while any states that already match more than PB must be different from
      the new pattern.  */
   for (unsigned int i2 = states.length (); i2-- > 0; )
diff --git a/gcc/gensupport.c b/gcc/gensupport.c
index c79feb4..13d8b3d 100644
--- a/gcc/gensupport.c
+++ b/gcc/gensupport.c
@@ -1930,7 +1930,7 @@ mark_operands_from_match_dup (rtx pattern)
 /* This is a subroutine of adjust_operands_numbers.
    It goes through all expressions in PATTERN and when MATCH_DUP is
    met, all MATCH_OPERANDs inside it is marked as occupied.  The
-   process of marking is done by routin mark_operands_from_match_dup.  */
+   process of marking is done by routine mark_operands_from_match_dup.  */
 static void
 mark_operands_used_in_match_dup (rtx pattern)
 {
diff --git a/gcc/ggc-page.c b/gcc/ggc-page.c
index 5f79e32..6730dae 100644
--- a/gcc/ggc-page.c
+++ b/gcc/ggc-page.c
@@ -1895,7 +1895,7 @@ clear_marks (void)
 
 /* Check if any blocks with a registered finalizer have become unmarked. If so
    run the finalizer and unregister it because the block is about to be freed.
-   Note that no garantee is made about what order finalizers will run in so
+   Note that no guarantee is made about what order finalizers will run in so
    touching other objects in gc memory is extremely unwise.  */
 
 static void
diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c
index d12f9d0..0926f43 100644
--- a/gcc/gimple-fold.c
+++ b/gcc/gimple-fold.c
@@ -120,7 +120,7 @@ can_refer_decl_in_current_unit_p (tree decl, tree from_decl)
 	  && (vnode = varpool_node::get (from_decl)) != NULL
 	  && vnode->in_other_partition))
     return true;
-  /* We are folding reference from external vtable.  The vtable may reffer
+  /* We are folding reference from external vtable.  The vtable may refer
      to a symbol keyed to other compilation unit.  The other compilation
      unit may be in separate DSO and the symbol may be hidden.  */
   if (DECL_VISIBILITY_SPECIFIED (decl)
@@ -6167,7 +6167,7 @@ fold_array_ctor_reference (tree type, tree ctor,
   if (tree val = get_array_ctor_element_at_index (ctor, access_index))
     return fold_ctor_reference (type, val, inner_offset, size, from_decl);
 
-  /* When memory is not explicitely mentioned in constructor,
+  /* When memory is not explicitly mentioned in constructor,
      it is 0 (or out of range).  */
   return build_zero_cst (type);
 }
@@ -6231,7 +6231,7 @@ fold_nonarray_ctor_reference (tree type, tree ctor,
 				      from_decl);
 	}
     }
-  /* When memory is not explicitely mentioned in constructor, it is 0.  */
+  /* When memory is not explicitly mentioned in constructor, it is 0.  */
   return build_zero_cst (type);
 }
 
@@ -6450,7 +6450,7 @@ gimple_get_virt_method_for_vtable (HOST_WIDE_INT token,
   init = ctor_for_folding (v);
 
   /* The virtual tables should always be born with constructors
-     and we always should assume that they are avaialble for
+     and we always should assume that they are available for
      folding.  At the moment we do not stream them in all cases,
      but it should never happen that ctor seem unreachable.  */
   gcc_assert (init);
@@ -6533,7 +6533,7 @@ gimple_get_virt_method_for_vtable (HOST_WIDE_INT token,
    KNOWN_BINFO carries the binfo describing the true type of
    OBJ_TYPE_REF_OBJECT(REF).
    Set CAN_REFER if non-NULL to false if method
-   is not referable or if the virtual table is ill-formed (such as rewriten
+   is not referable or if the virtual table is ill-formed (such as rewritten
    by non-C++ produced symbol). Otherwise just return NULL in that calse.  */
 
 tree
@@ -6901,7 +6901,7 @@ gimple_build (gimple_seq *seq, location_t loc,
 }
 
 /* Build the conversion (TYPE) OP with a result of type TYPE
-   with location LOC if such conversion is neccesary in GIMPLE,
+   with location LOC if such conversion is necessary in GIMPLE,
    simplifying it first.
    Returns the built expression value and appends
    statements possibly defining it to SEQ.  */
@@ -6916,7 +6916,7 @@ gimple_convert (gimple_seq *seq, location_t loc, tree type, tree op)
 
 /* Build the conversion (ptrofftype) OP with a result of a type
    compatible with ptrofftype with location LOC if such conversion
-   is neccesary in GIMPLE, simplifying it first.
+   is necessary in GIMPLE, simplifying it first.
    Returns the built expression value and appends
    statements possibly defining it to SEQ.  */
 
diff --git a/gcc/gimple-ssa-split-paths.c b/gcc/gimple-ssa-split-paths.c
index 70651c5..6c556d6 100644
--- a/gcc/gimple-ssa-split-paths.c
+++ b/gcc/gimple-ssa-split-paths.c
@@ -146,7 +146,7 @@ poor_ifcvt_candidate_code (enum tree_code code)
      jump rather than CSE/DCE opportunities.  So favor duplicating
      small latches.  A latch with just a conditional branch is ideal.
 
-     CSE/DCE opportunties crop up when statements from the predecessors
+     CSE/DCE opportunities crop up when statements from the predecessors
      feed statements in the latch and allow statements in the latch to
      simplify.  */
 
diff --git a/gcc/gimple-ssa-sprintf.c b/gcc/gimple-ssa-sprintf.c
index f43778b..7da4476 100644
--- a/gcc/gimple-ssa-sprintf.c
+++ b/gcc/gimple-ssa-sprintf.c
@@ -29,7 +29,7 @@ along with GCC; see the file COPYING3.  If not see
    For all functions (bounded or not) the pass uses the size of the
    destination object.  That means that it will diagnose calls to
    snprintf not on the basis of the size specified by the function's
-   second argument but rathger on the basis of the size the first
+   second argument but rather on the basis of the size the first
    argument points to (if possible).  For bound-checking built-ins
    like __builtin___snprintf_chk the pass uses the size typically
    determined by __builtin_object_size and passed to the built-in
@@ -39,7 +39,7 @@ along with GCC; see the file COPYING3.  If not see
    including character, integer, floating point, pointer, and strings,
    with the standard C flags, widths, and precisions.  For integers
    and strings it computes the length of output itself.  For floating
-   point it uses MPFR to fornmat known constants with up and down
+   point it uses MPFR to format known constants with up and down
    rounding and uses the resulting range of output lengths.  For
    strings it uses the length of string literals and the sizes of
    character arrays that a character pointer may point to as a bound
@@ -1175,7 +1175,7 @@ get_int_range (tree arg, HOST_WIDE_INT *pmin, HOST_WIDE_INT *pmax,
 	    *pmin = *pmax = -*pmin;
 	  else
 	    {
-	      /* Make sure signed overlow is avoided.  */
+	      /* Make sure signed overflow is avoided.  */
 	      gcc_assert (*pmin != HOST_WIDE_INT_MIN);
 
 	      HOST_WIDE_INT tmp = -*pmin;
@@ -1653,7 +1653,7 @@ format_floating_max (tree type, char spec, HOST_WIDE_INT prec)
   if (MODE_COMPOSITE_P (mode))
     mode = DFmode;
 
-  /* Get the real type format desription for the target.  */
+  /* Get the real type format description for the target.  */
   const real_format *rfmt = REAL_MODE_FORMAT (mode);
   REAL_VALUE_TYPE rv;
 
@@ -1941,7 +1941,7 @@ format_floating (const directive &dir, tree arg)
   /* The minimum and maximum number of bytes produced by the directive.  */
   fmtresult res;
 
-  /* Get the real type format desription for the target.  */
+  /* Get the real type format description for the target.  */
   const REAL_VALUE_TYPE *rvp = TREE_REAL_CST_PTR (arg);
   const real_format *rfmt = REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg)));
 
@@ -1966,7 +1966,7 @@ format_floating (const directive &dir, tree arg)
 	/* Convert the GCC real value representation with the precision
 	   of the real type to the mpfr_t format rounding down in the
 	   first iteration that computes the minimm and up in the second
-	   that computes the maximum.  This order is arbibtrary because
+	   that computes the maximum.  This order is arbitrary because
 	   rounding in either direction can result in longer output.  */
 	mpfr_t mpfrval;
 	mpfr_init2 (mpfrval, rfmt->p);
@@ -2160,7 +2160,7 @@ format_character (const directive &dir, tree arg)
     }
   else
     {
-      /* A plain '%c' directive.  Its ouput is exactly 1.  */
+      /* A plain '%c' directive.  Its output is exactly 1.  */
       res.range.min = res.range.max = 1;
       res.range.likely = res.range.unlikely = 1;
       res.knownrange = true;
diff --git a/gcc/gimple-ssa-store-merging.c b/gcc/gimple-ssa-store-merging.c
index 64b8351..7881d86 100644
--- a/gcc/gimple-ssa-store-merging.c
+++ b/gcc/gimple-ssa-store-merging.c
@@ -20,7 +20,7 @@
 
 /* The purpose of this pass is to combine multiple memory stores of
    constant values to consecutive memory locations into fewer wider stores.
-   For example, if we have a sequence peforming four byte stores to
+   For example, if we have a sequence performing four byte stores to
    consecutive memory locations:
    [p     ] := imm1;
    [p + 1B] := imm2;
diff --git a/gcc/gimple-ssa-strength-reduction.c b/gcc/gimple-ssa-strength-reduction.c
index 25f751a..66a7b62 100644
--- a/gcc/gimple-ssa-strength-reduction.c
+++ b/gcc/gimple-ssa-strength-reduction.c
@@ -433,7 +433,7 @@ static hash_map<tree, name_expansion *> *name_expansions;
 /* Pointer map embodying a mapping from bases to alternative bases.  */
 static hash_map<tree, tree> *alt_base_map;
 
-/* Given BASE, use the tree affine combiniation facilities to
+/* Given BASE, use the tree affine combination facilities to
    find the underlying tree expression for BASE, with any
    immediate offset excluded.
 
diff --git a/gcc/gimple.c b/gcc/gimple.c
index 488f8c8..8861ae8 100644
--- a/gcc/gimple.c
+++ b/gcc/gimple.c
@@ -1041,7 +1041,7 @@ gimple_build_omp_return (bool wait_p)
 /* Build a GIMPLE_OMP_SECTIONS statement.
 
    BODY is a sequence of section statements.
-   CLAUSES are any of the OMP sections contsruct's clauses: private,
+   CLAUSES are any of the OMP sections construct's clauses: private,
    firstprivate, lastprivate, reduction, and nowait.  */
 
 gomp_sections *
diff --git a/gcc/gimple.def b/gcc/gimple.def
index d739a2d..3f11b48 100644
--- a/gcc/gimple.def
+++ b/gcc/gimple.def
@@ -192,7 +192,7 @@ DEFGSCODE(GIMPLE_PHI, "gimple_phi", GSS_PHI)
    EVAL is the sequence of statements to execute on entry to GIMPLE_TRY.
 
    CLEANUP is the sequence of statements to execute according to
-   TRY_KIND.  If TRY_KIND is GIMPLE_TRY_CATCH, CLEANUP is only exected
+   TRY_KIND.  If TRY_KIND is GIMPLE_TRY_CATCH, CLEANUP is only executed
    if an exception is thrown during execution of EVAL.  If TRY_KIND is
    GIMPLE_TRY_FINALLY, CLEANUP is always executed after executing EVAL
    (regardless of whether EVAL finished normally, or jumped out or an
diff --git a/gcc/gimple.h b/gcc/gimple.h
index 460011c..5e2f345 100644
--- a/gcc/gimple.h
+++ b/gcc/gimple.h
@@ -836,7 +836,7 @@ struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
    tell the runtime that it should begin the transaction in
    serial-irrevocable mode.  */
 #define GTMA_DOES_GO_IRREVOCABLE	(1u << 6)
-/* The transaction contains no instrumentation code whatsover, most
+/* The transaction contains no instrumentation code whatsoever, most
    likely because it is guaranteed to go irrevocable upon entry.  */
 #define GTMA_HAS_NO_INSTRUMENTATION	(1u << 7)
 
@@ -1413,7 +1413,7 @@ extern size_t const gimple_ops_offset_[];
 extern enum gimple_statement_structure_enum const gss_for_code_[];
 
 /* This variable holds the currently expanded gimple statement for purposes
-   of comminucating the profile info to the builtin expanders.  */
+   of communicating the profile info to the builtin expanders.  */
 extern gimple *currently_expanding_gimple_stmt;
 
 #define gimple_alloc(c, n) gimple_alloc_stat (c, n MEM_STAT_INFO)
@@ -3593,7 +3593,7 @@ gimple_cond_make_true (gcond *gs)
   gs->subcode = NE_EXPR;
 }
 
-/* Check if conditional statemente GS is of the form 'if (1 == 1)',
+/* Check if conditional statement GS is of the form 'if (1 == 1)',
   'if (0 == 0)', 'if (1 != 0)' or 'if (0 != 1)' */
 
 static inline bool
@@ -3683,7 +3683,7 @@ gimple_goto_dest (const gimple *gs)
 }
 
 
-/* Set DEST to be the destination of the unconditonal jump GS.  */
+/* Set DEST to be the destination of the unconditional jump GS.  */
 
 static inline void
 gimple_goto_set_dest (ggoto *gs, tree dest)
@@ -4848,7 +4848,7 @@ gimple_omp_ordered_set_clauses (gomp_ordered *ord_stmt, tree clauses)
 }
 
 
-/* Return the kind of the OMP_FOR statemement G.  */
+/* Return the kind of the OMP_FOR statement G.  */
 
 static inline int
 gimple_omp_for_kind (const gimple *g)
diff --git a/gcc/gimplify.c b/gcc/gimplify.c
index 2c7fc9f..dcb979b 100644
--- a/gcc/gimplify.c
+++ b/gcc/gimplify.c
@@ -760,7 +760,7 @@ gimple_add_tmp_var (tree tmp)
 /* This page contains routines to unshare tree nodes, i.e. to duplicate tree
    nodes that are referenced more than once in GENERIC functions.  This is
    necessary because gimplification (translation into GIMPLE) is performed
-   by modifying tree nodes in-place, so gimplication of a shared node in a
+   by modifying tree nodes in-place, so gimplification of a shared node in a
    first context could generate an invalid GIMPLE form in a second context.
 
    This is achieved with a simple mark/copy/unmark algorithm that walks the
@@ -1991,7 +1991,7 @@ collect_fallthrough_labels (gimple_stmt_iterator *gsi_p,
   return prev;
 }
 
-/* Return true if the switch fallthough warning should occur.  LABEL is
+/* Return true if the switch fallthrough warning should occur.  LABEL is
    the label statement that we're falling through to.  */
 
 static bool
@@ -3733,7 +3733,7 @@ gimple_boolify (tree expr)
     default:
       if (COMPARISON_CLASS_P (expr))
 	{
-	  /* There expressions always prduce boolean results.  */
+	  /* These expressions always produce boolean results.  */
 	  if (TREE_CODE (type) != BOOLEAN_TYPE)
 	    TREE_TYPE (expr) = boolean_type_node;
 	  return expr;
@@ -5516,7 +5516,7 @@ gimplify_modify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
 	return ret;
     }
 
-  /* In case of va_arg internal fn wrappped in a WITH_SIZE_EXPR, add the type
+  /* In case of va_arg internal fn wrapped in a WITH_SIZE_EXPR, add the type
      size as argument to the call.  */
   if (TREE_CODE (*from_p) == WITH_SIZE_EXPR)
     {
diff --git a/gcc/graph.c b/gcc/graph.c
index 9261732..45071c9 100644
--- a/gcc/graph.c
+++ b/gcc/graph.c
@@ -242,7 +242,7 @@ draw_cfg_nodes (pretty_printer *pp, struct function *fun)
     draw_cfg_nodes_no_loops (pp, fun);
 }
 
-/* Draw all edges in the CFG.  Retreating edges are drawin as not
+/* Draw all edges in the CFG.  Retreating edges are drawn as not
    constraining, this makes the layout of the graph better.
    (??? Calling mark_dfs_back may change the compiler's behavior when
    dumping, but computing back edges here for ourselves is also not
diff --git a/gcc/haifa-sched.c b/gcc/haifa-sched.c
index 1fcc01d..6fbb505 100644
--- a/gcc/haifa-sched.c
+++ b/gcc/haifa-sched.c
@@ -2518,7 +2518,7 @@ model_set_excess_costs (rtx_insn **insns, int count)
   if (print_p)
     fprintf (sched_dump, MODEL_BAR);
 
-  /* Use MAX (baseECC, 0) and baseP to calculcate ECC for each
+  /* Use MAX (baseECC, 0) and baseP to calculate ECC for each
      instruction.  */
   for (i = 0; i < count; i++)
     {
@@ -5547,7 +5547,7 @@ analyze_set_insn_for_autopref (rtx pat, bool write, rtx *base, int *offset)
 /* Functions to model cache auto-prefetcher.
 
    Some of the CPUs have cache auto-prefetcher, which /seems/ to initiate
-   memory prefetches if it sees instructions with consequitive memory accesses
+   memory prefetches if it sees instructions with consecutive memory accesses
    in the instruction stream.  Details of such hardware units are not published,
    so we can only guess what exactly is going on there.
    In the scheduler, we model abstract auto-prefetcher.  If there are memory
@@ -5812,7 +5812,7 @@ autopref_multipass_dfa_lookahead_guard (rtx_insn *insn1, int ready_index)
 
       if (ready_index == 0
 	  && data1->status == AUTOPREF_MULTIPASS_DATA_DONT_DELAY)
-	/* We allow only a single delay on priviledged instructions.
+	/* We allow only a single delay on privileged instructions.
 	   Doing otherwise would cause infinite loop.  */
 	{
 	  if (sched_verbose >= 2)
@@ -9279,7 +9279,7 @@ number_in_ready (void)
   return ready.n_ready;
 }
 
-/* Get number of ready's in the ready list.  */
+/* Get number of readys in the ready list.  */
 
 rtx_insn *
 get_ready_element (int i)
diff --git a/gcc/hash-table.h b/gcc/hash-table.h
index 0f7e21a..eefb8da 100644
--- a/gcc/hash-table.h
+++ b/gcc/hash-table.h
@@ -444,7 +444,7 @@ public:
   void traverse_noresize (Argument argument);
 
   /* Like traverse_noresize, but does resize the table when it is too empty
-     to improve effectivity of subsequent calls.  */
+     to improve effectiveness of subsequent calls.  */
   template <typename Argument,
 	    int (*Callback) (value_type *slot, Argument argument)>
   void traverse (Argument argument);
@@ -970,7 +970,7 @@ hash_table<Descriptor, Allocator>::traverse_noresize (Argument argument)
 }
 
 /* Like traverse_noresize, but does resize the table when it is too empty
-   to improve effectivity of subsequent calls.  */
+   to improve effectiveness of subsequent calls.  */
 
 template <typename Descriptor,
 	  template <typename Type> class Allocator>
diff --git a/gcc/hsa-brig.c b/gcc/hsa-brig.c
index 1a2d45f..b965cff 100644
--- a/gcc/hsa-brig.c
+++ b/gcc/hsa-brig.c
@@ -2062,7 +2062,7 @@ hsa_brig_emit_omp_symbols (void)
 }
 
 /* Create and return __hsa_global_variables symbol that contains
-   all informations consumed by libgomp to link global variables
+   all information consumed by libgomp to link global variables
    with their string names used by an HSA kernel.  */
 
 static tree
@@ -2144,7 +2144,7 @@ hsa_output_global_variables ()
 }
 
 /* Create __hsa_host_functions and __hsa_kernels that contain
-   all informations consumed by libgomp to register all kernels
+   all information consumed by libgomp to register all kernels
    in the BRIG binary.  */
 
 static void
diff --git a/gcc/hsa-common.h b/gcc/hsa-common.h
index 810624e..adf5ba3 100644
--- a/gcc/hsa-common.h
+++ b/gcc/hsa-common.h
@@ -177,7 +177,7 @@ public:
   void set_type (BrigKind16_t t);
 
   /* Function returns pointer to a buffer that contains binary representation
-     of the immeadiate value.  The buffer has length of BRIG_SIZE and
+     of the immediate value.  The buffer has length of BRIG_SIZE and
      a caller is responsible for deallocation of the buffer.  */
   char *emit_to_buffer (unsigned *brig_size);
 
@@ -549,7 +549,7 @@ private:
 				 BRIG_WIDTH_1) {}
 };
 
-/* Report whether P is a contitional branching instruction.  */
+/* Report whether P is a conditional branching instruction.  */
 
 template <>
 template <>
diff --git a/gcc/hsa-gen.c b/gcc/hsa-gen.c
index c5d8a6e..0c12074 100644
--- a/gcc/hsa-gen.c
+++ b/gcc/hsa-gen.c
@@ -1475,7 +1475,7 @@ hsa_insn_phi::hsa_insn_phi (unsigned nops, hsa_op_reg *dst)
 }
 
 /* Constructor of class representing instructions for control flow and
-   sychronization,   */
+   synchronization,   */
 
 hsa_insn_br::hsa_insn_br (unsigned nops, int opc, BrigType16_t t,
 			  BrigWidth8_t width, hsa_op_base *arg0,
@@ -1576,7 +1576,7 @@ hsa_insn_atomic::hsa_insn_atomic (int nops, int opc,
 		       opc == BRIG_OPCODE_SIGNALNORET);
 }
 
-/* Constructor of class representing signal instructions.  OPC is the prinicpal
+/* Constructor of class representing signal instructions.  OPC is the principal
    opcode, SOP is the specific signal operation opcode.  T is the type of the
    instruction.  The instruction operands are provided as ARG[0-3].  */
 
@@ -3394,7 +3394,7 @@ gen_hsa_insns_for_switch_stmt (gswitch *s, hsa_bb *hbb)
   gimple_stmt_iterator it = gsi_for_stmt (s);
   gsi_prev (&it);
 
-  /* Create preambule that verifies that index - lowest_label >= 0.  */
+  /* Create preamble that verifies that index - lowest_label >= 0.  */
   edge e = split_block (hbb->m_bb, gsi_stmt (it));
   e->flags &= ~EDGE_FALLTHRU;
   e->flags |= EDGE_TRUE_VALUE;
diff --git a/gcc/inchash.h b/gcc/inchash.h
index 6af1dad..b6b5b3b 100644
--- a/gcc/inchash.h
+++ b/gcc/inchash.h
@@ -21,8 +21,8 @@ along with GCC; see the file COPYING3.  If not see
 #define INCHASH_H 1
 
 
-/* This file implements an incremential hash function ADT, to be used
-   by code that incrementially hashes a lot of unrelated data
+/* This file implements an incremental hash function ADT, to be used
+   by code that incrementally hashes a lot of unrelated data
    (not in a single memory block) into a single value. The goal
    is to make it easy to plug in efficient hash algorithms.
    Currently it just implements the plain old jhash based
@@ -38,14 +38,14 @@ class hash
 {
  public:
 
-  /* Start incremential hashing, optionally with SEED.  */
+  /* Start incremental hashing, optionally with SEED.  */
   hash (hashval_t seed = 0)
   {
     val = seed;
     bits = 0;
   }
 
-  /* End incremential hashing and provide the final value.  */
+  /* End incremental hashing and provide the final value.  */
   hashval_t end ()
   {
     return val;
diff --git a/gcc/input.c b/gcc/input.c
index 8071810..c77184d 100644
--- a/gcc/input.c
+++ b/gcc/input.c
@@ -881,7 +881,7 @@ make_location (location_t caret, location_t start, location_t finish)
    - the character 'k', if the number is higher than 10 K (in base 2)
      but strictly lower than 10 M (in base 2)
    - the character 'M' if the number is higher than 10 M (in base2)
-   - the charcter ' ' if the number is strictly lower  than 10 K  */
+   - the character ' ' if the number is strictly lower  than 10 K  */
 #define STAT_LABEL(x) ((x) < 10 * ONE_K ? ' ' : ((x) < 10 * ONE_M ? 'k' : 'M'))
 
 /* Display an integer amount as multiple of 1K or 1M (in base 2).
@@ -1640,7 +1640,7 @@ line_table_test::line_table_test ()
 }
 
 /* Constructor.  Store the old value of line_table, and create a new
-   one, using the sitation described in CASE_.  */
+   one, using the situation described in CASE_.  */
 
 line_table_test::line_table_test (const line_table_case &case_)
 {
diff --git a/gcc/internal-fn.h b/gcc/internal-fn.h
index 23ce08a..63feda7 100644
--- a/gcc/internal-fn.h
+++ b/gcc/internal-fn.h
@@ -80,7 +80,7 @@ enum ifn_goacc_loop_kind {
    LEVEL corresponds to the GOMP_DIM of the reduction
    OP is the tree code of the reduction operation
    OFFSET may be used as an offset into a reduction array for the
-          reductions occuring at this level.
+          reductions occurring at this level.
    In general the return value is LOCAL_VAR, which creates a data
    dependency between calls operating on the same reduction.  */
 
diff --git a/gcc/ipa-chkp.c b/gcc/ipa-chkp.c
index c7fc3a0..c6a7fb1 100644
--- a/gcc/ipa-chkp.c
+++ b/gcc/ipa-chkp.c
@@ -725,7 +725,7 @@ chkp_produce_thunks (bool early)
     }
 
   /* Mark instrumentation clones created for aliases and thunks
-     as insttrumented so they could be removed as unreachable
+     as instrumented so they could be removed as unreachable
      now.  */
   if (!early)
     {
diff --git a/gcc/ipa-cp.c b/gcc/ipa-cp.c
index f5e023e..8cee406 100644
--- a/gcc/ipa-cp.c
+++ b/gcc/ipa-cp.c
@@ -185,7 +185,7 @@ public:
   /* Depth first search number and low link for topological sorting of
      values.  */
   int dfs, low_link;
-  /* True if this valye is currently on the topo-sort stack.  */
+  /* True if this value is currently on the topo-sort stack.  */
   bool on_stack;
 
   void add_source (cgraph_edge *cs, ipcp_value *src_val, int src_idx,
@@ -859,7 +859,7 @@ ipcp_lattice<valtype>::set_contains_variable ()
   return ret;
 }
 
-/* Set all aggegate lattices in PLATS to bottom and return true if they were
+/* Set all aggregate lattices in PLATS to bottom and return true if they were
    not previously set as such.  */
 
 static inline bool
@@ -870,7 +870,7 @@ set_agg_lats_to_bottom (struct ipcp_param_lattices *plats)
   return ret;
 }
 
-/* Mark all aggegate lattices in PLATS as containing an unknown value and
+/* Mark all aggregate lattices in PLATS as containing an unknown value and
    return true if they were not previously marked as such.  */
 
 static inline bool
@@ -887,7 +887,7 @@ ipcp_vr_lattice::meet_with (const ipcp_vr_lattice &other)
   return meet_with_1 (&other.m_vr);
 }
 
-/* Meet the current value of the lattice with value ranfge described by VR
+/* Meet the current value of the lattice with value range described by VR
    lattice.  */
 
 bool
@@ -896,7 +896,7 @@ ipcp_vr_lattice::meet_with (const value_range *p_vr)
   return meet_with_1 (p_vr);
 }
 
-/* Meet the current value of the lattice with value ranfge described by
+/* Meet the current value of the lattice with value range described by
    OTHER_VR lattice.  */
 
 bool
@@ -2371,7 +2371,7 @@ ipa_get_indirect_edge_target_1 (struct cgraph_edge *ie,
 
   t = NULL;
 
-  /* Try to work out value of virtual table pointer value in replacemnets.  */
+  /* Try to work out value of virtual table pointer value in replacements.  */
   if (!t && agg_reps && !ie->indirect_info->by_ref)
     {
       while (agg_reps)
@@ -3342,7 +3342,7 @@ ipcp_discover_new_direct_edges (struct cgraph_node *node,
     ipa_update_overall_fn_summary (node);
 }
 
-/* Vector of pointers which for linked lists of clones of an original crgaph
+/* Vector of pointers which for linked lists of clones of an original cgraph
    edge. */
 
 static vec<cgraph_edge *> next_edge_clone;
@@ -4526,7 +4526,7 @@ ipcp_val_agg_replacement_ok_p (ipa_agg_replacement_value *aggvals,
   return false;
 }
 
-/* Return true if offset is minus one because source of a polymorphic contect
+/* Return true if offset is minus one because source of a polymorphic context
    cannot be an aggregate value.  */
 
 DEBUG_FUNCTION bool
@@ -4537,7 +4537,7 @@ ipcp_val_agg_replacement_ok_p (ipa_agg_replacement_value *,
   return offset == -1;
 }
 
-/* Decide wheter to create a special version of NODE for value VAL of parameter
+/* Decide whether to create a special version of NODE for value VAL of parameter
    at the given INDEX.  If OFFSET is -1, the value is for the parameter itself,
    otherwise it is stored at the given OFFSET of the parameter.  KNOWN_CSTS,
    KNOWN_CONTEXTS and KNOWN_AGGS describe the other already known values.  */
diff --git a/gcc/ipa-devirt.c b/gcc/ipa-devirt.c
index c7460ca..c2b8921 100644
--- a/gcc/ipa-devirt.c
+++ b/gcc/ipa-devirt.c
@@ -887,7 +887,7 @@ compare_virtual_tables (varpool_node *prevailing, varpool_node *vtable)
 
       class_type->odr_violated = true;
 
-      /* Complain about size mismatch.  Either we have too many virutal
+      /* Complain about size mismatch.  Either we have too many virtual
  	 functions or too many virtual table pointers.  */
       if (end1 || end2)
 	{
@@ -927,7 +927,7 @@ compare_virtual_tables (varpool_node *prevailing, varpool_node *vtable)
 	  return;
 	}
 
-      /* And in the last case we have either mistmatch in between two virtual
+      /* And in the last case we have either mismatch in between two virtual
 	 methods or two virtual table pointers.  */
       if (warning_at (DECL_SOURCE_LOCATION
 			(TYPE_NAME (DECL_CONTEXT (vtable->decl))), OPT_Wodr,
@@ -979,7 +979,7 @@ warn_odr (tree t1, tree t2, tree st1, tree st2,
   if (!warn || !TYPE_NAME(t1))
     return;
 
-  /* ODR warnings are output druing LTO streaming; we must apply location
+  /* ODR warnings are output during LTO streaming; we must apply location
      cache for potential warnings to be output correctly.  */
   if (lto_location_cache::current_cache)
     lto_location_cache::current_cache->apply_location_cache ();
@@ -1025,7 +1025,7 @@ warn_odr (tree t1, tree t2, tree st1, tree st2,
     *warned = true;
 }
 
-/* Return ture if T1 and T2 are incompatible and we want to recusively
+/* Return true if T1 and T2 are incompatible and we want to recursively
    dive into them from warn_type_mismatch to give sensible answer.  */
 
 static bool
@@ -1046,7 +1046,7 @@ type_mismatch_p (tree t1, tree t2)
    This is hard to do in general.  We basically handle the common cases.
 
    If LOC1 and LOC2 are meaningful locations, use it in the case the types
-   themselves do no thave one.*/
+   themselves do not have one.*/
 
 void
 warn_types_mismatch (tree t1, tree t2, location_t loc1, location_t loc2)
@@ -1102,7 +1102,7 @@ warn_types_mismatch (tree t1, tree t2, location_t loc1, location_t loc2)
       gcc_assert (TYPE_NAME (t1) && TYPE_NAME (t2)
 		  && TREE_CODE (TYPE_NAME (t1)) == TYPE_DECL
 		  && TREE_CODE (TYPE_NAME (t2)) == TYPE_DECL);
-      /* Most of the time, the type names will match, do not be unnecesarily
+      /* Most of the time, the type names will match, do not be unnecessarily
          verbose.  */
       if (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (t1)))
 	  != IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (t2))))
@@ -1611,7 +1611,7 @@ odr_types_equivalent_p (tree t1, tree t2, bool warn, bool *warned,
 		    != TYPE_METHODS (TYPE_MAIN_VARIANT (t2))))
 	      {
 		/* Currently free_lang_data sets TYPE_METHODS to error_mark_node
-		   if it is non-NULL so this loop will never realy execute.  */
+		   if it is non-NULL so this loop will never really execute.  */
 		if (TYPE_METHODS (TYPE_MAIN_VARIANT (t1)) != error_mark_node
 		    && TYPE_METHODS (TYPE_MAIN_VARIANT (t2)) != error_mark_node)
 		  for (f1 = TYPE_METHODS (TYPE_MAIN_VARIANT (t1)),
@@ -3632,7 +3632,7 @@ ipa_devirt (void)
 	       itself.
 
 	       This may need to be revisited once we add further ways to use
-	       the may edges, but it is a resonable thing to do right now.  */
+	       the may edges, but it is a reasonable thing to do right now.  */
 
 	    if ((e->indirect_info->param_index == -1
 		|| (!opt_for_fn (n->decl, flag_devirtualize_speculatively)
diff --git a/gcc/ipa-fnsummary.c b/gcc/ipa-fnsummary.c
index 0e74fc3..3b68078 100644
--- a/gcc/ipa-fnsummary.c
+++ b/gcc/ipa-fnsummary.c
@@ -149,7 +149,7 @@ ipa_dump_hints (FILE *f, ipa_hints hints)
 
 /* Record SIZE and TIME to SUMMARY.
    The accounted code will be executed when EXEC_PRED is true.
-   When NONCONST_PRED is false the code will evaulate to constant and
+   When NONCONST_PRED is false the code will evaluate to constant and
    will get optimized out in specialized clones of the function.   */
 
 void
@@ -170,7 +170,7 @@ ipa_fn_summary::account_size_time (int size, sreal time,
   if (nonconst_pred == false)
     return;
 
-  /* We need to create initial empty unconitional clause, but otherwie
+  /* We need to create initial empty unconditional clause, but otherwise
      we don't need to account empty times and sizes.  */
   if (!size && time == 0 && size_time_table)
     return;
@@ -301,9 +301,9 @@ set_hint_predicate (predicate **p, predicate new_predicate)
 }
 
 
-/* Compute what conditions may or may not hold given invormation about
+/* Compute what conditions may or may not hold given information about
    parameters.  RET_CLAUSE returns truths that may hold in a specialized copy,
-   whie RET_NONSPEC_CLAUSE returns truths that may hold in an nonspecialized
+   while RET_NONSPEC_CLAUSE returns truths that may hold in an nonspecialized
    copy when called in a given context.  It is a bitmask of conditions. Bit
    0 means that condition is known to be false, while bit 1 means that condition
    may or may not be true.  These differs - for example NOT_INLINED condition
@@ -311,7 +311,7 @@ set_hint_predicate (predicate **p, predicate new_predicate)
    the fact that parameter is indeed a constant.
 
    KNOWN_VALS is partial mapping of parameters of NODE to constant values.
-   KNOWN_AGGS is a vector of aggreggate jump functions for each parameter.
+   KNOWN_AGGS is a vector of aggregate jump functions for each parameter.
    Return clause of possible truths. When INLINE_P is true, assume that we are
    inlining.
 
@@ -534,7 +534,7 @@ ipa_fn_summary_alloc (void)
 }
 
 /* We are called multiple time for given function; clear
-   data from previous run so they are not cumulated.  */
+   data from previous run so they are not accumulated.  */
 
 void
 ipa_call_summary::reset ()
@@ -547,7 +547,7 @@ ipa_call_summary::reset ()
 }
 
 /* We are called multiple time for given function; clear
-   data from previous run so they are not cumulated.  */
+   data from previous run so they are not accumulated.  */
 
 void
 ipa_fn_summary::reset (struct cgraph_node *node)
@@ -673,7 +673,7 @@ ipa_fn_summary_t::duplicate (cgraph_node *src,
       info->account_size_time (0, 0, true_pred, true_pred);
 
       /* Remap size_time vectors.
-         Simplify the predicate by prunning out alternatives that are known
+         Simplify the predicate by pruning out alternatives that are known
          to be false.
          TODO: as on optimization, we can also eliminate conditions known
          to be true.  */
@@ -711,7 +711,7 @@ ipa_fn_summary_t::duplicate (cgraph_node *src,
 	  edge_set_predicate (edge, &new_predicate);
 	}
 
-      /* Remap indirect edge predicates with the same simplificaiton as above. 
+      /* Remap indirect edge predicates with the same simplification as above.
          Also copy constantness arrays.   */
       for (edge = dst->indirect_calls; edge; edge = next)
 	{
@@ -738,7 +738,7 @@ ipa_fn_summary_t::duplicate (cgraph_node *src,
       /* If inliner or someone after inliner will ever start producing
          non-trivial clones, we will get trouble with lack of information
          about updating self sizes, because size vectors already contains
-         sizes of the calees.  */
+         sizes of the callees.  */
       gcc_assert (!inlined_to_p || !optimized_out_size);
     }
   else
@@ -1150,12 +1150,12 @@ eliminated_by_inlining_prob (gimple *stmt)
 	    lhs_free = true;
 
 	  /* Writes to parameters, parameters passed by value and return value
-	     (either dirrectly or passed via invisible reference) are free.  
+	     (either directly or passed via invisible reference) are free.
 
 	     TODO: We ought to handle testcase like
 	     struct a {int a,b;};
 	     struct a
-	     retrurnsturct (void)
+	     returnstruct (void)
 	     {
 	     struct a a ={1,2};
 	     return a;
@@ -1163,7 +1163,7 @@ eliminated_by_inlining_prob (gimple *stmt)
 
 	     This translate into:
 
-	     retrurnsturct ()
+	     returnstruct ()
 	     {
 	     int a$b;
 	     int a$a;
@@ -1239,7 +1239,7 @@ set_cond_stmt_execution_predicate (struct ipa_func_body_info *fbi,
 	  enum tree_code this_code = (e->flags & EDGE_TRUE_VALUE
 				      ? code : inverted_code);
 	  /* invert_tree_comparison will return ERROR_MARK on FP
-	     comparsions that are not EQ/NE instead of returning proper
+	     comparisons that are not EQ/NE instead of returning proper
 	     unordered one.  Be sure it is not confused with NON_CONSTANT.  */
 	  if (this_code != ERROR_MARK)
 	    {
@@ -1263,7 +1263,7 @@ set_cond_stmt_execution_predicate (struct ipa_func_body_info *fbi,
      Here we can predicate nonconstant_code.  We can't
      really handle constant_code since we have no predicate
      for this and also the constant code is not known to be
-     optimized away when inliner doen't see operand is constant.
+     optimized away when inliner doesn't see operand is constant.
      Other optimizers might think otherwise.  */
   if (gimple_cond_code (last) != NE_EXPR
       || !integer_zerop (gimple_cond_rhs (last)))
@@ -1510,7 +1510,7 @@ will_be_nonconstant_predicate (struct ipa_func_body_info *fbi,
   HOST_WIDE_INT size;
   struct agg_position_info aggpos;
 
-  /* What statments might be optimized away
+  /* What statements might be optimized away
      when their arguments are constant.  */
   if (gimple_code (stmt) != GIMPLE_ASSIGN
       && gimple_code (stmt) != GIMPLE_COND
@@ -1593,7 +1593,7 @@ struct record_modified_bb_info
   gimple *stmt;
 };
 
-/* Value is initialized in INIT_BB and used in USE_BB.  We want to copute
+/* Value is initialized in INIT_BB and used in USE_BB.  We want to compute
    probability how often it changes between USE_BB.
    INIT_BB->frequency/USE_BB->frequency is an estimate, but if INIT_BB
    is in different loop nest, we can do better.
@@ -1703,7 +1703,7 @@ param_change_prob (gimple *stmt, int i)
 	}
 
       /* Assume that every memory is initialized at entry.
-         TODO: Can we easilly determine if value is always defined
+         TODO: Can we easily determine if value is always defined
          and thus we may skip entry block?  */
       if (ENTRY_BLOCK_PTR_FOR_FN (cfun)->frequency)
 	max = ENTRY_BLOCK_PTR_FOR_FN (cfun)->frequency;
@@ -1911,7 +1911,7 @@ find_foldable_builtin_expect (basic_block bb)
    presence of EH and will be optimized out by optimize_clobbers later in the
    game. 
 
-   NEED_EH is used to recurse in case the clobber has non-EH predecestors
+   NEED_EH is used to recurse in case the clobber has non-EH predecessors
    that can be clobber only, too.. When it is false, the RESX is not necessary
    on the end of basic block.  */
 
@@ -1945,7 +1945,7 @@ clobber_only_eh_bb_p (basic_block bb, bool need_eh = true)
       return false;
     }
 
-  /* See if all predecestors are either throws or clobber only BBs.  */
+  /* See if all predecessors are either throws or clobber only BBs.  */
   FOR_EACH_EDGE (e, ei, bb->preds)
     if (!(e->flags & EDGE_EH)
 	&& !clobber_only_eh_bb_p (e->src, false))
@@ -2186,7 +2186,7 @@ analyze_function_body (struct cgraph_node *node, bool early)
 	      edge_set_predicate (edge, &bb_predicate);
 	    }
 
-	  /* TODO: When conditional jump or swithc is known to be constant, but
+	  /* TODO: When conditional jump or switch is known to be constant, but
 	     we did not translate it into the predicates, we really can account
 	     just maximum of the possible paths.  */
 	  if (fbi.info)
@@ -2285,7 +2285,7 @@ analyze_function_body (struct cgraph_node *node, bool early)
 		will_be_nonconstant = bb_predicate & will_be_nonconstant;
 	      if (will_be_nonconstant != true
 		  && will_be_nonconstant != false)
-		/* This is slightly inprecise.  We may want to represent each
+		/* This is slightly imprecise.  We may want to represent each
 		   loop with independent predicate.  */
 		loop_iterations &= will_be_nonconstant;
 	    }
@@ -2330,7 +2330,7 @@ analyze_function_body (struct cgraph_node *node, bool early)
 		    will_be_nonconstant = bb_predicate & will_be_nonconstant;
 		  if (will_be_nonconstant != true
 		      && will_be_nonconstant != false)
-		    /* This is slightly inprecise.  We may want to represent
+		    /* This is slightly imprecise.  We may want to represent
 		       each loop with independent predicate.  */
 		    loop_stride = loop_stride & will_be_nonconstant;
 		}
@@ -2646,7 +2646,7 @@ estimate_calls_size_and_time (struct cgraph_node *node, int *size,
    POSSIBLE_TRUTHS clause, and KNOWN_VALS, KNOWN_AGGS and KNOWN_CONTEXTS
    information about NODE's arguments.  If non-NULL use also probability
    information present in INLINE_PARAM_SUMMARY vector.
-   Additionally detemine hints determined by the context.  Finally compute
+   Additionally determine hints determined by the context.  Finally compute
    minimal size needed for the call that is independent on the call context and
    can be used for fast estimates.  Return the values in RET_SIZE,
    RET_MIN_SIZE, RET_TIME and RET_HINTS.  */
@@ -2747,7 +2747,7 @@ estimate_node_size_and_time (struct cgraph_node *node,
   gcc_checking_assert ((nonspecialized_time - time) >= -1);
 
   /* Roundoff issues may make specialized time bigger than nonspecialized
-     time.  We do not really want that to happen because some heurstics
+     time.  We do not really want that to happen because some heuristics
      may get confused by seeing negative speedups.  */
   if (time > nonspecialized_time)
     time = nonspecialized_time;
@@ -2842,8 +2842,8 @@ inline_update_callee_summaries (struct cgraph_node *node, int depth)
 }
 
 /* Update change_prob of EDGE after INLINED_EDGE has been inlined.
-   When functoin A is inlined in B and A calls C with parameter that
-   changes with probability PROB1 and C is known to be passthroug
+   When function A is inlined in B and A calls C with parameter that
+   changes with probability PROB1 and C is known to be passthrough
    of argument if B that change with probability PROB2, the probability
    of change is now PROB1*PROB2.  */
 
@@ -3541,7 +3541,7 @@ const pass_data pass_data_ipa_free_fn_summary =
   0, /* properties_destroyed */
   0, /* todo_flags_start */
   /* Early optimizations may make function unreachable.  We can not
-     remove unreachable functions as part of the ealry opts pass because
+     remove unreachable functions as part of the early opts pass because
      TODOs are run before subpasses.  Do it here.  */
   ( TODO_remove_functions | TODO_dump_symtab ), /* todo_flags_finish */
 };
diff --git a/gcc/ipa-fnsummary.h b/gcc/ipa-fnsummary.h
index f50d680..6e222c6 100644
--- a/gcc/ipa-fnsummary.h
+++ b/gcc/ipa-fnsummary.h
@@ -25,14 +25,14 @@ along with GCC; see the file COPYING3.  If not see
 #include "ipa-predicate.h"
 
 
-/* Hints are reasons why IPA heuristics should preffer specializing given
-   function.  They are represtented as bitmap of the following values.  */
+/* Hints are reasons why IPA heuristics should prefer specializing given
+   function.  They are represented as bitmap of the following values.  */
 enum ipa_hints_vals {
   /* When specialization turns indirect call into a direct call,
      it is good idea to do so.  */
   INLINE_HINT_indirect_call = 1,
   /* Inlining may make loop iterations or loop stride known.  It is good idea
-     to do so because it enables loop optimizatoins.  */
+     to do so because it enables loop optimizations.  */
   INLINE_HINT_loop_iterations = 2,
   INLINE_HINT_loop_stride = 4,
   /* Inlining within same strongly connected component of callgraph is often
diff --git a/gcc/ipa-icf-gimple.c b/gcc/ipa-icf-gimple.c
index 08dd980..8323921 100644
--- a/gcc/ipa-icf-gimple.c
+++ b/gcc/ipa-icf-gimple.c
@@ -232,7 +232,7 @@ func_checker::compatible_types_p (tree t1, tree t2)
   if (!types_compatible_p (t1, t2))
     return return_false_with_msg ("types are not compatible");
 
-  /* We do a lot of unnecesary matching of types that are not being
+  /* We do a lot of unnecessary matching of types that are not being
      accessed and thus do not need to be compatible.  In longer term we should
      remove these checks on all types which are not accessed as memory
      locations.
@@ -449,7 +449,7 @@ func_checker::compare_operand (tree t1, tree t2)
 
 	In this case the alias set of the function being replaced must
 	be subset of the alias set of the other function.  At the moment
-	we seek for equivalency classes, so simply require inclussion in
+	we seek for equivalency classes, so simply require inclusion in
 	both directions.  */
 
 	if (!func_checker::compatible_types_p (TREE_TYPE (x1), TREE_TYPE (x2)))
@@ -989,7 +989,7 @@ func_checker::compare_gimple_asm (const gasm *g1, const gasm *g2)
   if (gimple_asm_noutputs (g1) != gimple_asm_noutputs (g2))
     return false;
 
-  /* We do not suppport goto ASM statement comparison.  */
+  /* We do not support goto ASM statement comparison.  */
   if (gimple_asm_nlabels (g1) || gimple_asm_nlabels (g2))
     return false;
 
diff --git a/gcc/ipa-icf-gimple.h b/gcc/ipa-icf-gimple.h
index da904b5..95a67bc 100644
--- a/gcc/ipa-icf-gimple.h
+++ b/gcc/ipa-icf-gimple.h
@@ -19,13 +19,13 @@ You should have received a copy of the GNU General Public License
 along with GCC; see the file COPYING3.  If not see
 <http://www.gnu.org/licenses/>.  */
 
-/* Gimple identical code folding (class func_checker) is an infastructure
+/* Gimple identical code folding (class func_checker) is an infrastructure
    capable of comparing two given functions. The class compares every
    gimple statement and uses many dictionaries to map source and target
    SSA_NAMEs, declarations and other components.
 
-   To use the infrastructure, create an instanse of func_checker and call
-   a comparsion function based on type of gimple statement.  */
+   To use the infrastructure, create an instance of func_checker and call
+   a comparison function based on type of gimple statement.  */
 
 /* Prints string STRING to a FILE with a given number of SPACE_COUNT.  */
 #define FPUTS_SPACES(file, space_count, string) \
@@ -227,7 +227,7 @@ public:
   bool compare_variable_decl (tree t1, tree t2);
 
   /* Return true if types are compatible for polymorphic call analysis.
-     COMPARE_PTR indicates if polymorphic type comparsion should be
+     COMPARE_PTR indicates if polymorphic type comparison should be
      done for pointers, too.  */
   static bool compatible_polymorphic_types_p (tree t1, tree t2,
 					      bool compare_ptr);
diff --git a/gcc/ipa-icf.c b/gcc/ipa-icf.c
index 0b0c1fd..cc9f5f7 100644
--- a/gcc/ipa-icf.c
+++ b/gcc/ipa-icf.c
@@ -355,7 +355,7 @@ sem_item::compare_attributes (const_tree a1, const_tree a2)
 
 /* Compare properties of symbols N1 and N2 that does not affect semantics of
    symbol itself but affects semantics of its references from USED_BY (which
-   may be NULL if it is unknown).  If comparsion is false, symbols
+   may be NULL if it is unknown).  If comparison is false, symbols
    can still be merged but any symbols referring them can't.
 
    If ADDRESS is true, do extra checking needed for IPA_REF_ADDR.
@@ -1160,7 +1160,7 @@ sem_function::merge (sem_item *alias_item)
         }
       /* Do not turn function in one comdat group into wrapper to another
 	 comdat group. Other compiler producing the body of the
-	 another comdat group may make opossite decision and with unfortunate
+	 another comdat group may make opposite decision and with unfortunate
 	 linker choices this may close a loop.  */
       else if (DECL_COMDAT_GROUP (original->decl)
 	       && DECL_COMDAT_GROUP (alias->decl)
@@ -2201,7 +2201,7 @@ sem_variable::merge (sem_item *alias_item)
       return false;
     }
 
-  /* We can not merge if address comparsion metters.  */
+  /* We can not merge if address comparison matters.  */
   if (alias_address_matters && flag_merge_constants < 2)
     {
       if (dump_file)
@@ -3315,7 +3315,7 @@ sem_item_optimizer::process_cong_reduction (void)
 	     "new classes.\n", new_classes);
 }
 
-/* Debug function prints all informations about congruence classes.  */
+/* Debug function prints all information about congruence classes.  */
 
 void
 sem_item_optimizer::dump_cong_classes (void)
@@ -3621,7 +3621,7 @@ ipa_icf_read_summary (void)
   optimizer->register_hooks ();
 }
 
-/* Semantic equality exection function.  */
+/* Semantic equality execution function.  */
 
 static unsigned int
 ipa_icf_driver (void)
diff --git a/gcc/ipa-icf.h b/gcc/ipa-icf.h
index c57224c..69aa3e3 100644
--- a/gcc/ipa-icf.h
+++ b/gcc/ipa-icf.h
@@ -24,7 +24,7 @@ class sem_item;
 
 /* Congruence class encompasses a collection of either functions or
    read-only variables. These items are considered to be equivalent
-   if not proved the oposite.  */
+   if not proved the opposite.  */
 class congruence_class
 {
 public:
@@ -172,7 +172,7 @@ public:
   virtual bool equals_wpa (sem_item *item,
 			   hash_map <symtab_node *, sem_item *> &ignored_nodes) = 0;
 
-  /* Returns true if the item equals to ITEM given as arguemnt.  */
+  /* Returns true if the item equals to ITEM given as argument.  */
   virtual bool equals (sem_item *item,
 		       hash_map <symtab_node *, sem_item *> &ignored_nodes) = 0;
 
@@ -329,7 +329,7 @@ public:
   static sem_function *parse (cgraph_node *node, bitmap_obstack *stack);
 
   /* Perform additional checks needed to match types of used function
-     paramters.  */
+     parameters.  */
   bool compatible_parm_types_p (tree, tree);
 
   /* Exception handling region tree.  */
@@ -548,7 +548,7 @@ private:
      is split.  */
   unsigned subdivide_classes_by_sensitive_refs();
 
-  /* Debug function prints all informations about congruence classes.  */
+  /* Debug function prints all information about congruence classes.  */
   void dump_cong_classes (void);
 
   /* Build references according to call graph.  */
@@ -587,7 +587,7 @@ private:
   static bool release_split_map (congruence_class * const &cls, bitmap const &b,
 				 traverse_split_pair *pair);
 
-  /* Process split operation for a cognruence class CLS,
+  /* Process split operation for a congruence class CLS,
      where bitmap B splits congruence class members. DATA is used
      as argument of split pair.  */
   static bool traverse_congruence_split (congruence_class * const &cls,
diff --git a/gcc/ipa-inline-transform.c b/gcc/ipa-inline-transform.c
index 01a6833..b4c5cab 100644
--- a/gcc/ipa-inline-transform.c
+++ b/gcc/ipa-inline-transform.c
@@ -179,7 +179,7 @@ clone_inlined_nodes (struct cgraph_edge *e, bool duplicate,
     {
       /* We may eliminate the need for out-of-line copy to be output.
 	 In that case just go ahead and re-use it.  This is not just an
-	 memory optimization.  Making offline copy of fuction disappear
+	 memory optimization.  Making offline copy of function disappear
 	 from the program will improve future decisions on inlining.  */
       if (!e->callee->callers->next_caller
 	  /* Recursive inlining never wants the master clone to
diff --git a/gcc/ipa-inline.c b/gcc/ipa-inline.c
index 0ebe147..6bb3c2a 100644
--- a/gcc/ipa-inline.c
+++ b/gcc/ipa-inline.c
@@ -395,7 +395,7 @@ can_inline_edge_p (struct cgraph_edge *e, bool report,
       ipa_fn_summary *callee_info = ipa_fn_summaries->get (callee);
 
      /* Until GCC 4.9 we did not check the semantics alterning flags
-	bellow and inline across optimization boundry.
+	below and inline across optimization boundary.
 	Enabling checks bellow breaks several packages by refusing
 	to inline library always_inline functions. See PR65873.
 	Disable the check for early inlining for now until better solution
@@ -431,7 +431,7 @@ can_inline_edge_p (struct cgraph_edge *e, bool report,
 		  && DECL_FUNCTION_PERSONALITY (callee->decl))
 	      || (check_maybe_up (flag_exceptions)
 		  && DECL_FUNCTION_PERSONALITY (callee->decl))
-	      /* When devirtualization is diabled for callee, it is not safe
+	      /* When devirtualization is disabled for callee, it is not safe
 		 to inline it as we possibly mangled the type info.
 		 Allow early inlining of always inlines.  */
 	      || (!early && check_maybe_down (flag_devirtualize)))
@@ -1084,7 +1084,7 @@ edge_badness (struct cgraph_edge *edge, bool dump)
 	     if (need_more_work)
 	       noninline_callee ();
 	   }
-	 Withhout panilizing this case, we usually inline noninline_callee
+	 Withhout penalizing this case, we usually inline noninline_callee
 	 into the inline_caller because overall_growth is small preventing
 	 further inlining of inline_caller.
 
@@ -1131,7 +1131,7 @@ edge_badness (struct cgraph_edge *edge, bool dump)
 	}
       if (overall_growth > 0)
         {
-	  /* Strongly preffer functions with few callers that can be inlined
+	  /* Strongly prefer functions with few callers that can be inlined
 	     fully.  The square root here leads to smaller binaries at average.
 	     Watch however for extreme cases and return to linear function
 	     when growth is large.  */
@@ -1217,7 +1217,7 @@ update_edge_key (edge_heap_t *heap, struct cgraph_edge *edge)
       gcc_checking_assert (n->get_data () == edge);
 
       /* fibonacci_heap::replace_key does busy updating of the
-	 heap that is unnecesarily expensive.
+	 heap that is unnecessarily expensive.
 	 We do lazy increases: after extracting minimum if the key
 	 turns out to be out of date, it is re-inserted into heap
 	 with correct value.  */
@@ -1251,7 +1251,7 @@ update_edge_key (edge_heap_t *heap, struct cgraph_edge *edge)
 
 
 /* NODE was inlined.
-   All caller edges needs to be resetted because
+   All caller edges needs to be reset because
    size estimates change. Similarly callees needs reset
    because better context may be known.  */
 
@@ -1366,7 +1366,7 @@ update_callee_keys (edge_heap_t *heap, struct cgraph_node *node,
 	enum availability avail;
 	struct cgraph_node *callee;
 	/* We do not reset callee growth cache here.  Since we added a new call,
-	   growth chould have just increased and consequentely badness metric
+	   growth could have just increased and consequently badness metric
            don't need updating.  */
 	if (e->inline_failed
 	    && (callee = e->callee->ultimate_alias_target (&avail, e->caller))
@@ -1877,7 +1877,7 @@ inline_small_functions (void)
       edge_growth_cache[edge->uid].hints = old_hints_est + 1;
 
       /* When updating the edge costs, we only decrease badness in the keys.
-	 Increases of badness are handled lazilly; when we see key with out
+	 Increases of badness are handled lazily; when we see key with out
 	 of date value on it, we re-insert it now.  */
       current_badness = edge_badness (edge, false);
       /* Disable checking for profile because roundoff errors may cause slight
@@ -2442,7 +2442,7 @@ ipa_inline (void)
      into callee often leads to better optimization of callee due to
      increased context for optimization.
      For example if main() function calls a function that outputs help
-     and then function that does the main optmization, we should inline
+     and then function that does the main optimization, we should inline
      the second with priority even if both calls are cold by themselves.
 
      We probably want to implement new predicate replacing our use of
@@ -2631,7 +2631,7 @@ early_inliner (function *fun)
     node->verify ();
   node->remove_all_references ();
 
-  /* Rebuild this reference because it dosn't depend on
+  /* Rebuild this reference because it doesn't depend on
      function's body and it's required to pass cgraph_node
      verification.  */
   if (node->instrumented_version
diff --git a/gcc/ipa-polymorphic-call.c b/gcc/ipa-polymorphic-call.c
index abbcfbf..dfc18c7 100644
--- a/gcc/ipa-polymorphic-call.c
+++ b/gcc/ipa-polymorphic-call.c
@@ -100,7 +100,7 @@ possible_placement_new (tree type, tree expected_type,
    to represent it.
 
    If OTR_TYPE is NULL, just find outermost polymorphic type with
-   virtual table present at possition OFFSET.
+   virtual table present at position OFFSET.
 
    For example when THIS represents type
    class A
@@ -148,7 +148,7 @@ ipa_polymorphic_call_context::restrict_to_inner_class (tree otr_type,
     Because the instance type may contain field whose type is of OUTER_TYPE,
     we can not derive any effective information about it.
 
-    TODO: In the case we know all derrived types, we can definitely do better
+    TODO: In the case we know all derived types, we can definitely do better
     here.  */
   else if (TYPE_SIZE (outer_type)
 	   && tree_fits_shwi_p (TYPE_SIZE (outer_type))
@@ -241,7 +241,7 @@ ipa_polymorphic_call_context::restrict_to_inner_class (tree otr_type,
 	      if (cur_offset != 0)
 		goto no_useful_type_info;
 	      /* If we determined type precisely or we have no clue on
- 		 speuclation, we are done.  */
+ 		 speculation, we are done.  */
 	      if (!maybe_derived_type || !speculative_outer_type
 		  || !speculation_consistent_p (speculative_outer_type,
 					        speculative_offset,
@@ -395,7 +395,7 @@ no_useful_type_info:
 	      else
 		return true;
 	    }
-	  /* We found no way to embedd EXPECTED_TYPE in TYPE.
+	  /* We found no way to embed EXPECTED_TYPE in TYPE.
 	     We still permit two special cases - placement new and
 	     the case of variadic types containing themselves.  */
 	  if (!speculative
@@ -552,7 +552,7 @@ decl_maybe_in_construction_p (tree base, tree outer_type,
     return true;
 
   /* Pure functions can not do any changes on the dynamic type;
-     that require writting to memory.  */
+     that require writing to memory.  */
   if ((!base || !auto_var_in_fn_p (base, function))
       && flags_from_decl_or_type (function) & (ECF_PURE | ECF_CONST))
     return false;
@@ -917,7 +917,7 @@ ipa_polymorphic_call_context::ipa_polymorphic_call_context (tree fndecl,
 	      && max_size == size)
 	    {
 	      /* We found dereference of a pointer.  Type of the pointer
-		 and MEM_REF is meaningless, but we can look futher.  */
+		 and MEM_REF is meaningless, but we can look further.  */
 	      if (TREE_CODE (base) == MEM_REF)
 		{
 		  base_pointer = TREE_OPERAND (base, 0);
@@ -1078,7 +1078,7 @@ ipa_polymorphic_call_context::ipa_polymorphic_call_context (tree fndecl,
 			      offset,
 			      true, NULL /* Do not change type here */);
   /* TODO: There are multiple ways to derive a type.  For instance
-     if BASE_POINTER is passed to an constructor call prior our refernece.
+     if BASE_POINTER is passed to an constructor call prior our reference.
      We do not make this type of flow sensitive analysis yet.  */
   if (instance)
     *instance = base_pointer;
@@ -1282,7 +1282,7 @@ extr_type_from_vtbl_ptr_store (gimple *stmt, struct type_change_info *tci,
     {
       if (dump_file)
 	fprintf (dump_file, "    Construction vtable used\n");
-      /* FIXME: We should suport construction contexts.  */
+      /* FIXME: We should support construction contexts.  */
       return NULL;
     }
  
@@ -1533,7 +1533,7 @@ ipa_polymorphic_call_context::get_dynamic_type (tree instance,
     otr_type = TYPE_MAIN_VARIANT (otr_type);
 
   /* Walk into inner type. This may clear maybe_derived_type and save us
-     from useless work.  It also makes later comparsions with static type
+     from useless work.  It also makes later comparisons with static type
      easier.  */
   if (outer_type && otr_type)
     {
@@ -1549,7 +1549,7 @@ ipa_polymorphic_call_context::get_dynamic_type (tree instance,
   if (TREE_CODE (instance) == MEM_REF)
     return false;
 
-  /* We need to obtain refernce to virtual table pointer.  It is better
+  /* We need to obtain reference to virtual table pointer.  It is better
      to look it up in the code rather than build our own.  This require bit
      of pattern matching, but we end up verifying that what we found is
      correct. 
@@ -1723,7 +1723,7 @@ ipa_polymorphic_call_context::get_dynamic_type (tree instance,
 
      Therefore if the static outer type was found (outer_type)
      we can safely ignore tci.speculative that is set on calls and give up
-     only if there was dyanmic type store that may affect given variable
+     only if there was dynamic type store that may affect given variable
      (seen_unanalyzed_store)  */
 
   if (!tci.type_maybe_changed
@@ -1850,7 +1850,7 @@ ipa_polymorphic_call_context::combine_speculation_with
     return false;
 
   /* restrict_to_inner_class may eliminate wrong speculation making our job
-     easeier.  */
+     easier.  */
   if (otr_type)
     restrict_to_inner_class (otr_type);
 
@@ -1898,7 +1898,7 @@ ipa_polymorphic_call_context::combine_speculation_with
     }
   /* Choose type that contains the other.  This one either contains the outer
      as a field (thus giving exactly one target) or is deeper in the type
-     hiearchy.  */
+     hierarchy.  */
   else if (speculative_outer_type
 	   && speculative_maybe_derived_type
 	   && (new_offset > speculative_offset
@@ -1950,7 +1950,7 @@ ipa_polymorphic_call_context::meet_speculation_with
     }
 
   /* restrict_to_inner_class may eliminate wrong speculation making our job
-     easeier.  */
+     easier.  */
   if (otr_type)
     restrict_to_inner_class (otr_type);
 
@@ -2030,8 +2030,8 @@ ipa_polymorphic_call_context::meet_speculation_with
     }
 }
 
-/* Assume that both THIS and a given context is valid and strenghten THIS
-   if possible.  Return true if any strenghtening was made.
+/* Assume that both THIS and a given context is valid and strengthen THIS
+   if possible.  Return true if any strengthening was made.
    If actual type the context is being used in is known, OTR_TYPE should be
    set accordingly. This improves quality of combined result.  */
 
@@ -2196,7 +2196,7 @@ ipa_polymorphic_call_context::combine_with (ipa_polymorphic_call_context ctx,
 	      goto invalidate;
 	    }
 	}
-      /* Pick variant deeper in the hiearchy.  */
+      /* Pick variant deeper in the hierarchy.  */
       else
 	{
 	  outer_type = ctx.outer_type;
@@ -2522,7 +2522,7 @@ ipa_polymorphic_call_context::meet_with (ipa_polymorphic_call_context ctx,
       if (!dynamic && ctx.dynamic)
 	dynamic = true;
     }
-  /* TODO handle merging using hiearchy. */
+  /* TODO handle merging using hierarchy. */
   else
     {
       if (dump_file && (dump_flags & TDF_DETAILS))
diff --git a/gcc/ipa-predicate.c b/gcc/ipa-predicate.c
index f10e234..60b4092 100644
--- a/gcc/ipa-predicate.c
+++ b/gcc/ipa-predicate.c
@@ -338,8 +338,8 @@ dump_clause (FILE *f, conditions conds, clause_t clause)
 }
 
 
-/* Dump THIS to F. CONDS a vector of conditions used when evauating
-   predicats. When NL is true new line is output at the end of dump.  */
+/* Dump THIS to F. CONDS a vector of conditions used when evaluating
+   predicates. When NL is true new line is output at the end of dump.  */
 
 void
 predicate::dump (FILE *f, conditions conds, bool nl) const
diff --git a/gcc/ipa-predicate.h b/gcc/ipa-predicate.h
index 6d48819..7e5bd81 100644
--- a/gcc/ipa-predicate.h
+++ b/gcc/ipa-predicate.h
@@ -86,7 +86,7 @@ public:
       first_dynamic_condition = 2
     };
 
-  /* Maximal number of conditions predicate can reffer to.  This is limited
+  /* Maximal number of conditions predicate can refer to.  This is limited
      by using clause_t to be 32bit.  */
   static const int num_conditions = 32;
 
diff --git a/gcc/ipa-profile.c b/gcc/ipa-profile.c
index 54bb5bf..f41c95c 100644
--- a/gcc/ipa-profile.c
+++ b/gcc/ipa-profile.c
@@ -563,7 +563,7 @@ ipa_profile (void)
   histogram.release ();
   histogram_pool.release ();
 
-  /* Produce speculative calls: we saved common traget from porfiling into
+  /* Produce speculative calls: we saved common traget from profiling into
      e->common_target_id.  Now, at link time, we can look up corresponding
      function node and produce speculative call.  */
 
diff --git a/gcc/ipa-prop.c b/gcc/ipa-prop.c
index 81fbb52..15e8197 100644
--- a/gcc/ipa-prop.c
+++ b/gcc/ipa-prop.c
@@ -570,7 +570,7 @@ ipa_set_ancestor_jf (struct ipa_jump_func *jfunc, HOST_WIDE_INT offset,
   jfunc->value.ancestor.agg_preserved = agg_preserved;
 }
 
-/* Get IPA BB information about the given BB.  FBI is the context of analyzis
+/* Get IPA BB information about the given BB.  FBI is the context of analysis
    of this function body.  */
 
 static struct ipa_bb_info *
@@ -682,7 +682,7 @@ check_stmt_for_type_change (ao_ref *ao ATTRIBUTE_UNUSED, tree vdef, void *data)
 
 /* See if ARG is PARAM_DECl describing instance passed by pointer
    or reference in FUNCTION.  Return false if the dynamic type may change
-   in between beggining of the function until CALL is invoked.
+   in between beginning of the function until CALL is invoked.
 
    Generally functions are not allowed to change type of such instances,
    but they call destructors.  We assume that methods can not destroy the THIS
@@ -693,10 +693,10 @@ static bool
 param_type_may_change_p (tree function, tree arg, gimple *call)
 {
   /* Pure functions can not do any changes on the dynamic type;
-     that require writting to memory.  */
+     that require writing to memory.  */
   if (flags_from_decl_or_type (function) & (ECF_PURE | ECF_CONST))
     return false;
-  /* We need to check if we are within inlined consturctor
+  /* We need to check if we are within inlined constructor
      or destructor (ideally we would have way to check that the
      inline cdtor is actually working on ARG, but we don't have
      easy tie on this, so punt on all non-pure cdtors.
@@ -742,7 +742,7 @@ param_type_may_change_p (tree function, tree arg, gimple *call)
    returned by get_ref_base_and_extent, as is the offset. 
 
    This is helper function for detect_type_change and detect_type_change_ssa
-   that does the heavy work which is usually unnecesary.  */
+   that does the heavy work which is usually unnecessary.  */
 
 static bool
 detect_type_change_from_memory_writes (tree arg, tree base, tree comp_type,
@@ -875,7 +875,7 @@ find_dominating_aa_status (struct ipa_func_body_info *fbi, basic_block bb,
 }
 
 /* Get AA status structure for the given BB and parameter with INDEX.  Allocate
-   structures and/or intialize the result with a dominating description as
+   structures and/or initialize the result with a dominating description as
    necessary.  */
 
 static struct ipa_param_aa_status *
@@ -1025,8 +1025,8 @@ parm_ref_data_pass_through_p (struct ipa_func_body_info *fbi, int index,
   bool modified = false;
   ao_ref refd;
 
-  /* It's unnecessary to calculate anything about memory contnets for a const
-     function because it is not goin to use it.  But do not cache the result
+  /* It's unnecessary to calculate anything about memory contents for a const
+     function because it is not going to use it.  But do not cache the result
      either.  Also, no such calculations for non-pointers.  */
   if (!gimple_vuse (call)
       || !POINTER_TYPE_P (TREE_TYPE (parm))
@@ -1817,7 +1817,7 @@ ipa_set_jfunc_vr (ipa_jump_func *jf, enum value_range_type type,
   jf->m_vr = ipa_get_value_range (type, min, max);
 }
 
-/* Assign to JF a pointer to a value_range just liek TMP but either fetch a
+/* Assign to JF a pointer to a value_range just like TMP but either fetch a
    copy from ipa_vr_hash_table or allocate a new on in GC memory.  */
 
 static void
@@ -2839,7 +2839,7 @@ ipa_make_edge_direct_to_target (struct cgraph_edge *ie, tree target,
 	  /* Member pointer call that goes through a VMT lookup.  */
 	  if (ie->indirect_info->member_ptr
 	      /* Or if target is not an invariant expression and we do not
-		 know if it will evaulate to function at runtime.
+		 know if it will evaluate to function at runtime.
 		 This can happen when folding through &VAR, where &VAR
 		 is IP invariant, but VAR itself is not.
 
@@ -2878,7 +2878,7 @@ ipa_make_edge_direct_to_target (struct cgraph_edge *ie, tree target,
   else
     callee = cgraph_node::get (target);
 
-  /* Because may-edges are not explicitely represented and vtable may be external,
+  /* Because may-edges are not explicitly represented and vtable may be external,
      we may create the first reference to the object in the unit.  */
   if (!callee || callee->global.inlined_to)
     {
@@ -3549,7 +3549,7 @@ combine_controlled_uses_counters (int c, int d)
     return c + d - 1;
 }
 
-/* Propagate number of controlled users from CS->caleee to the new root of the
+/* Propagate number of controlled users from CS->callee to the new root of the
    tree of inlined nodes.  */
 
 static void
@@ -3783,7 +3783,7 @@ ipa_edge_args_sum_t::remove (cgraph_edge *cs, ipa_edge_args *args)
 }
 
 /* Method invoked when an edge is duplicated.  Copy ipa_edge_args and adjust
-   reference count data strucutres accordingly.  */
+   reference count data structures accordingly.  */
 
 void
 ipa_edge_args_sum_t::duplicate (cgraph_edge *src, cgraph_edge *dst,
diff --git a/gcc/ipa-prop.h b/gcc/ipa-prop.h
index fa5bed4..918e8c5 100644
--- a/gcc/ipa-prop.h
+++ b/gcc/ipa-prop.h
@@ -58,7 +58,7 @@ along with GCC; see the file COPYING3.  If not see
 enum jump_func_type
 {
   IPA_JF_UNKNOWN = 0,  /* newly allocated and zeroed jump functions default */
-  IPA_JF_CONST,             /* represented by field costant */
+  IPA_JF_CONST,             /* represented by field constant */
   IPA_JF_PASS_THROUGH,	    /* represented by field pass_through */
   IPA_JF_ANCESTOR	    /* represented by field ancestor */
 };
@@ -110,7 +110,7 @@ struct GTY(()) ipa_ancestor_jf_data
   unsigned agg_preserved : 1;
 };
 
-/* An element in an aggegate part of a jump function describing a known value
+/* An element in an aggregate part of a jump function describing a known value
    at a given offset.  When it is part of a pass-through jump function with
    agg_preserved set or an ancestor jump function with agg_preserved set, all
    unlisted positions are assumed to be preserved but the value can be a type
@@ -170,17 +170,17 @@ struct GTY(()) ipa_vr
    types of jump functions supported.  */
 struct GTY (()) ipa_jump_func
 {
-  /* Aggregate contants description.  See struct ipa_agg_jump_function and its
+  /* Aggregate constants description.  See struct ipa_agg_jump_function and its
      description.  */
   struct ipa_agg_jump_function agg;
 
   /* Information about zero/non-zero bits.  The pointed to structure is shared
-     betweed different jump functions.  Use ipa_set_jfunc_bits to set this
+     between different jump functions.  Use ipa_set_jfunc_bits to set this
      field.  */
   struct ipa_bits *bits;
 
   /* Information about value range, containing valid data only when vr_known is
-     true.  The pointed to structure is shared betweed different jump
+     true.  The pointed to structure is shared between different jump
      functions.  Use ipa_set_jfunc_vr to set this field.  */
   struct value_range *m_vr;
 
@@ -197,7 +197,7 @@ struct GTY (()) ipa_jump_func
 };
 
 
-/* Return the constant stored in a constant jump functin JFUNC.  */
+/* Return the constant stored in a constant jump function JFUNC.  */
 
 static inline tree
 ipa_get_jf_constant (struct ipa_jump_func *jfunc)
@@ -288,7 +288,7 @@ ipa_get_jf_ancestor_agg_preserved (struct ipa_jump_func *jfunc)
   return jfunc->value.ancestor.agg_preserved;
 }
 
-/* Return true if ancestor jump function JFUNC presrves type information.  */
+/* Return true if ancestor jump function JFUNC preserves type information.  */
 
 static inline bool
 ipa_get_jf_ancestor_type_preserved (struct ipa_jump_func *jfunc)
@@ -355,7 +355,7 @@ struct GTY((for_user)) ipa_node_params
   /* Node has been completely replaced by clones and will be removed after
      ipa-cp is finished.  */
   unsigned node_dead : 1;
-  /* Node is involved in a recursion, potentionally indirect.  */
+  /* Node is involved in a recursion, potentially indirect.  */
   unsigned node_within_scc : 1;
   /* Node is calling a private function called only once.  */
   unsigned node_calling_single_call : 1;
@@ -535,7 +535,7 @@ struct GTY(()) ipa_agg_replacement_value
   HOST_WIDE_INT offset;
   /* The constant value.  */
   tree value;
-  /* The paramter index.  */
+  /* The parameter index.  */
   int index;
   /* Whether the value was passed by reference.  */
   bool by_ref;
@@ -626,7 +626,7 @@ public:
 			  ipa_node_params *data2);
 };
 
-/* Summary to manange ipa_edge_args structures.  */
+/* Summary to manage ipa_edge_args structures.  */
 
 class GTY((user)) ipa_edge_args_sum_t : public call_summary <ipa_edge_args *>
 {
@@ -782,7 +782,7 @@ enum ipa_parm_op {
 
   /* This adjustment describes a parameter that is about to be removed
      completely.  Most users will probably need to book keep those so that they
-     don't leave behinfd any non default def ssa names belonging to them.  */
+     don't leave behind any non default def ssa names belonging to them.  */
   IPA_PARM_OP_REMOVE
 };
 
@@ -805,7 +805,7 @@ struct ipa_parm_adjustment
      be a pointer to this type.  */
   tree type;
 
-  /* Alias refrerence type to be used in MEM_REFs when adjusting caller
+  /* Alias reference type to be used in MEM_REFs when adjusting caller
      arguments.  */
   tree alias_ptr_type;
 
diff --git a/gcc/ipa-ref.h b/gcc/ipa-ref.h
index fc1e95f..7c0a740 100644
--- a/gcc/ipa-ref.h
+++ b/gcc/ipa-ref.h
@@ -47,7 +47,7 @@ public:
      function.  */
   bool cannot_lead_to_return ();
 
-  /* Return true if refernece may be used in address compare.  */
+  /* Return true if reference may be used in address compare.  */
   bool address_matters_p ();
 
   /* Return reference list this reference is in.  */
diff --git a/gcc/ipa-reference.c b/gcc/ipa-reference.c
index 45c2e3f..d85e9f4 100644
--- a/gcc/ipa-reference.c
+++ b/gcc/ipa-reference.c
@@ -321,7 +321,7 @@ union_static_var_sets (bitmap &x, bitmap y)
 	     In that case, we want to make that visible explicitly.
 	     Even though bitmap_equal_p can be very expensive, it
 	     turns out to be an overall win to check this here for
-	     an LTO bootstrap of GCC itself.  Liberally extrapoliate
+	     an LTO bootstrap of GCC itself.  Liberally extrapolate
 	     that result to be applicable to all cases.  */
 	  if (bitmap_equal_p (x, all_module_statics))
 	    {
diff --git a/gcc/ipa-split.c b/gcc/ipa-split.c
index 7778b9c..eb3c3a7 100644
--- a/gcc/ipa-split.c
+++ b/gcc/ipa-split.c
@@ -163,7 +163,7 @@ test_nonssa_use (gimple *, tree t, tree, void *data)
       || (VAR_P (t)
 	  && auto_var_in_fn_p (t, current_function_decl))
       || TREE_CODE (t) == RESULT_DECL
-	 /* Normal labels are part of CFG and will be handled gratefuly.
+	 /* Normal labels are part of CFG and will be handled gratefully.
 	    Forced labels however can be used directly by statements and
 	    need to stay in one partition along with their uses.  */
       || (TREE_CODE (t) == LABEL_DECL
diff --git a/gcc/ipa-utils.c b/gcc/ipa-utils.c
index 39db923..07bbc1d 100644
--- a/gcc/ipa-utils.c
+++ b/gcc/ipa-utils.c
@@ -631,7 +631,8 @@ ipa_merge_profiles (struct cgraph_node *dst,
   src->decl = oldsrcdecl;
 }
 
-/* Return true if call to DEST is known to be self-recusive call withing FUNC.   */
+/* Return true if call to DEST is known to be self-recursive call within
+   FUNC.  */
 
 bool
 recursive_call_p (tree func, tree dest)
@@ -648,7 +649,7 @@ recursive_call_p (tree func, tree dest)
     return true;
   if (!dest_node->semantically_equivalent_p (cnode))
     return false;
-  /* If there is only one way to call the fuction or we know all of them
+  /* If there is only one way to call the function or we know all of them
      are semantically equivalent, we still can consider call recursive.  */
   FOR_EACH_ALIAS (cnode, alias)
     if (!dest_node->semantically_equivalent_p (alias->referring))
diff --git a/gcc/ipa-utils.h b/gcc/ipa-utils.h
index e992f65..9c433ed 100644
--- a/gcc/ipa-utils.h
+++ b/gcc/ipa-utils.h
@@ -169,7 +169,7 @@ possible_polymorphic_call_target_p (struct cgraph_edge *e,
 inline bool
 polymorphic_type_binfo_p (const_tree binfo)
 {
-  /* See if BINFO's type has an virtual table associtated with it.
+  /* See if BINFO's type has an virtual table associated with it.
      Check is defensive because of Java FE produces BINFOs
      without BINFO_TYPE set.   */
   return (BINFO_TYPE (binfo) && TYPE_BINFO (BINFO_TYPE (binfo))
diff --git a/gcc/ipa-visibility.c b/gcc/ipa-visibility.c
index d5a3ae5..f04445b 100644
--- a/gcc/ipa-visibility.c
+++ b/gcc/ipa-visibility.c
@@ -91,7 +91,7 @@ non_local_p (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
 {
   return !(node->only_called_directly_or_aliased_p ()
 	   /* i386 would need update to output thunk with local calling
-	      convetions.  */
+	      conventions.  */
 	   && !node->thunk.thunk_p
 	   && node->definition
 	   && !DECL_EXTERNAL (node->decl)
@@ -215,7 +215,7 @@ cgraph_externally_visible_p (struct cgraph_node *node,
     return true;
   if (node->resolution == LDPR_PREVAILING_DEF_IRONLY)
     return false;
-  /* When doing LTO or whole program, we can bring COMDAT functoins static.
+  /* When doing LTO or whole program, we can bring COMDAT functions static.
      This improves code quality and we know we will duplicate them at most twice
      (in the case that we are not using plugin and link with object file
       implementing same COMDAT)  */
@@ -295,7 +295,7 @@ varpool_node::externally_visible_p (void)
   /* As a special case, the COMDAT virtual tables can be unshared.
      In LTO mode turn vtables into static variables.  The variable is readonly,
      so this does not enable more optimization, but referring static var
-     is faster for dynamic linking.  Also this match logic hidding vtables
+     is faster for dynamic linking.  Also this match logic hiding vtables
      from LTO symbol tables.  */
   if (((in_lto_p || flag_whole_program) && !flag_incremental_link)
       && DECL_COMDAT (decl)
@@ -318,7 +318,7 @@ varpool_node::externally_visible_p (void)
      inline definitions.
 
      FIXME: We can do so for readonly vars with no address taken and
-     possibly also for vtables since no direct pointer comparsion is done.
+     possibly also for vtables since no direct pointer comparison is done.
      It might be interesting to do so to reduce linking overhead.  */
   if (DECL_COMDAT (decl) || DECL_WEAK (decl))
     return true;
diff --git a/gcc/ipa.c b/gcc/ipa.c
index 3dc8e41..0471a84 100644
--- a/gcc/ipa.c
+++ b/gcc/ipa.c
@@ -81,7 +81,7 @@ update_inlined_to_pointer (struct cgraph_node *node, struct cgraph_node *inlined
 
    The queue is linked via AUX pointers and terminated by pointer to 1.
    We enqueue nodes at two occasions: when we find them reachable or when we find
-   their bodies needed for further clonning.  In the second case we mark them
+   their bodies needed for further cloning.  In the second case we mark them
    by pointer to 2 after processing so they are re-queue when they become
    reachable.  */
 
@@ -151,7 +151,7 @@ process_references (symtab_node *snode,
    devirtualization happens.  After inlining still keep their declarations
    around, so we can devirtualize to a direct call.
 
-   Also try to make trivial devirutalization when no or only one target is
+   Also try to make trivial devirtualization when no or only one target is
    possible.  */
 
 static void
@@ -282,7 +282,7 @@ walk_polymorphic_call_targets (hash_set<void *> *reachable_call_targets,
    - C++ virtual tables keyed to other unit are represented as DECL_EXTERNAL
      variables with DECL_INITIAL set.  We finalize these and keep reachable
      ones around for constant folding purposes.  After inlining we however
-     stop walking their references to let everything static referneced by them
+     stop walking their references to let everything static referenced by them
      to be removed when it is otherwise unreachable.
 
    We maintain queue of both reachable symbols (i.e. defined symbols that needs
@@ -770,7 +770,7 @@ set_writeonly_bit (varpool_node *vnode, void *data)
   return false;
 }
 
-/* Clear addressale bit of VNODE.  */
+/* Clear addressable bit of VNODE.  */
 
 bool
 clear_addressable_bit (varpool_node *vnode, void *data ATTRIBUTE_UNUSED)
@@ -783,12 +783,12 @@ clear_addressable_bit (varpool_node *vnode, void *data ATTRIBUTE_UNUSED)
 /* Discover variables that have no longer address taken or that are read only
    and update their flags.
 
-   Return true when unreachable symbol removan should be done.
+   Return true when unreachable symbol removal should be done.
 
    FIXME: This can not be done in between gimplify and omp_expand since
    readonly flag plays role on what is shared and what is not.  Currently we do
    this transformation as part of whole program visibility and re-do at
-   ipa-reference pass (to take into account clonning), but it would
+   ipa-reference pass (to take into account cloning), but it would
    make sense to do it before early optimizations.  */
 
 bool
@@ -1190,7 +1190,7 @@ make_pass_ipa_cdtor_merge (gcc::context *ctxt)
 #define BOTTOM ((cgraph_node *)(size_t) 2)
 
 /* Meet operation for single user dataflow.
-   Here we want to associate variables with sigle function that may access it.
+   Here we want to associate variables with single function that may access it.
 
    FUNCTION is current single user of a variable, VAR is variable that uses it.
    Latttice is stored in SINGLE_USER_MAP.
@@ -1261,7 +1261,7 @@ propagate_single_user (varpool_node *vnode, cgraph_node *function,
 
 /* Pass setting used_by_single_function flag.
    This flag is set on variable when there is only one function that may
-   possibly referr to it.  */
+   possibly refer to it.  */
 
 static unsigned int
 ipa_single_use (void)
diff --git a/gcc/jit/jit-playback.c b/gcc/jit/jit-playback.c
index 76cc88f..3002fe0 100644
--- a/gcc/jit/jit-playback.c
+++ b/gcc/jit/jit-playback.c
@@ -1742,7 +1742,7 @@ auto_argvec::~auto_argvec ()
 
 /* Compile a playback::context:
 
-   - Use the context's options to cconstruct command-line options, and
+   - Use the context's options to construct command-line options, and
      call into the rest of GCC (toplev::main).
    - Assuming it succeeds, we have a .s file.
    - We then run the "postprocess" vfunc:
@@ -2936,7 +2936,7 @@ playback::context::
 get_source_file (const char *filename)
 {
   /* Locate the file.
-     For simplicitly, this is currently a linear search.
+     For simplicity, this is currently a linear search.
      Replace with a hash if this shows up in the profile.  */
   int i;
   source_file *file;
@@ -2977,7 +2977,7 @@ playback::source_file::
 get_source_line (int line_num)
 {
   /* Locate the line.
-     For simplicitly, this is currently a linear search.
+     For simplicity, this is currently a linear search.
      Replace with a hash if this shows up in the profile.  */
   int i;
   source_line *line;
diff --git a/gcc/jit/jit-recording.c b/gcc/jit/jit-recording.c
index 723ddb3..fb8c380 100644
--- a/gcc/jit/jit-recording.c
+++ b/gcc/jit/jit-recording.c
@@ -534,7 +534,7 @@ recording::context::~context ()
       free (m_last_error_str);
 }
 
-/* Add the given mememto to the list of those tracked by this
+/* Add the given memento to the list of those tracked by this
    gcc::jit::recording::context, so that e.g. it can be deleted
    when this context is released.  */
 
@@ -3423,7 +3423,7 @@ recording::function::replay_into (replayer *r)
 }
 
 /* Create a recording::local instance and add it to
-   the functions's context's list of mementos, and to the function's
+   the function's context's list of mementos, and to the function's
    list of locals.
 
    Implements the post-error-checking part of
@@ -3441,7 +3441,7 @@ recording::function::new_local (recording::location *loc,
 }
 
 /* Create a recording::block instance and add it to
-   the functions's context's list of mementos, and to the function's
+   the function's context's list of mementos, and to the function's
    list of blocks.
 
    Implements the post-error-checking part of
diff --git a/gcc/jit/libgccjit.c b/gcc/jit/libgccjit.c
index 9b003e3..80ec7e7 100644
--- a/gcc/jit/libgccjit.c
+++ b/gcc/jit/libgccjit.c
@@ -289,7 +289,7 @@ struct gcc_jit_timer : public timer
 
 /* Format the given string, and report it as an error, either on CTXT
    if non-NULL, or by printing to stderr if we have a NULL context.
-   LOC gives the source location where the error occcurred, and can be
+   LOC gives the source location where the error occurred, and can be
    NULL.  */
 
 static void
@@ -847,7 +847,7 @@ gcc_jit_context_new_function (gcc_jit_context *ctxt,
   RETURN_NULL_IF_FAIL (return_type, ctxt, loc, "NULL return_type");
   RETURN_NULL_IF_FAIL (name, ctxt, loc, "NULL name");
   /* The assembler can only handle certain names, so for now, enforce
-     C's rules for identiers upon the name, using ISALPHA and ISALNUM
+     C's rules for identifiers upon the name, using ISALPHA and ISALNUM
      from safe-ctype.h to ignore the current locale.
      Eventually we'll need some way to interact with e.g. C++ name
      mangling.  */
diff --git a/gcc/jit/libgccjit.h b/gcc/jit/libgccjit.h
index 898ee98..538a197 100644
--- a/gcc/jit/libgccjit.h
+++ b/gcc/jit/libgccjit.h
@@ -1151,7 +1151,7 @@ gcc_jit_context_new_case (gcc_jit_context *ctxt,
 extern gcc_jit_object *
 gcc_jit_case_as_object (gcc_jit_case *case_);
 
-/* Terminate a block by adding evalation of an rvalue, then performing
+/* Terminate a block by adding evaluation of an rvalue, then performing
    a multiway branch.
 
    This is roughly equivalent to this C code:
diff --git a/gcc/loop-invariant.c b/gcc/loop-invariant.c
index cda42ef..9f87810 100644
--- a/gcc/loop-invariant.c
+++ b/gcc/loop-invariant.c
@@ -795,7 +795,7 @@ canonicalize_address_mult (rtx x)
 
 #define MAX_CANON_ADDR_PARTS (5)
 
-/* Collect sub expressions in address X with PLUS as the seperator.
+/* Collect sub expressions in address X with PLUS as the separator.
    Sub expressions are stored in vector ADDR_PARTS.  */
 
 static void
@@ -815,7 +815,7 @@ collect_address_parts (rtx x, vec<rtx> *addr_parts)
 }
 
 /* Compare function for sorting sub expressions X and Y based on
-   precedence defined for communitive operations.  */
+   precedence defined for commutative operations.  */
 
 static int
 compare_address_parts (const void *x, const void *y)
@@ -833,7 +833,7 @@ compare_address_parts (const void *x, const void *y)
      2) Divide address into sub expressions with PLUS as the
 	separator.
      3) Sort sub expressions according to precedence defined
-	for communative operations.
+	for commutative operations.
      4) Simplify CONST_INT_P sub expressions.
      5) Create new canonicalized address and return.
    Callers should prepare a copy of X because this function may
diff --git a/gcc/loop-unroll.c b/gcc/loop-unroll.c
index 5feaa8c..cf208fe 100644
--- a/gcc/loop-unroll.c
+++ b/gcc/loop-unroll.c
@@ -1186,7 +1186,7 @@ decide_unroll_stupid (struct loop *loop, int flags)
 
   /* Do not unroll loops with branches inside -- it increases number
      of mispredicts. 
-     TODO: this heuristic needs tunning; call inside the loop body
+     TODO: this heuristic needs tuning; call inside the loop body
      is also relatively good reason to not unroll.  */
   if (num_loop_branches (loop) > 1)
     {
diff --git a/gcc/lra-assigns.c b/gcc/lra-assigns.c
index e4cc43a..4cb1c53 100644
--- a/gcc/lra-assigns.c
+++ b/gcc/lra-assigns.c
@@ -233,7 +233,7 @@ reload_pseudo_compare_func (const void *v1p, const void *v2p)
   if ((diff = regno_assign_info[r1].first - regno_assign_info[r2].first) != 0)
     return diff;
   /* Prefer pseudos with longer live ranges.  It sets up better
-     prefered hard registers for the thread pseudos and decreases
+     preferred hard registers for the thread pseudos and decreases
      register-register moves between the thread pseudos.  */
   if ((diff = regno_live_length[r2] - regno_live_length[r1]) != 0)
     return diff;
diff --git a/gcc/lra-coalesce.c b/gcc/lra-coalesce.c
index 44887b1..124a764 100644
--- a/gcc/lra-coalesce.c
+++ b/gcc/lra-coalesce.c
@@ -338,7 +338,7 @@ lra_coalesce (void)
      should have different values, otherwise they can get the same
      hard reg and this is wrong for insn using p2 before coalescing.
      The situation even can be more complicated when new reload
-     pseudos occur after the inheriatnce.  So invalidate the result
+     pseudos occur after the inheritance.  So invalidate the result
      pseudos.  */
   for (i = 0; i < max_regno; i++)
     if (first_coalesced_pseudo[i] == i
diff --git a/gcc/lra-constraints.c b/gcc/lra-constraints.c
index c6465c7..e013a04 100644
--- a/gcc/lra-constraints.c
+++ b/gcc/lra-constraints.c
@@ -53,7 +53,7 @@
    choice is still valid.
 
    The inheritance/spilt pass is to transform code to achieve
-   ineheritance and live range splitting.  It is done on backward
+   inheritance and live range splitting.  It is done on backward
    traversal of EBBs.
 
    The inheritance optimization goal is to reuse values in hard
@@ -879,7 +879,7 @@ regno_val_use_in (unsigned int regno, rtx x)
 }
 
 /* Return true if all current insn non-output operands except INS (it
-   has a negaitve end marker) do not use pseudos with the same value
+   has a negative end marker) do not use pseudos with the same value
    as REGNO.  */
 static bool
 check_conflict_input_operands (int regno, signed char *ins)
@@ -2347,7 +2347,7 @@ process_alt_operands (int only_alternative)
 		  else
 		    {
 		      /* Prefer won reg to spilled pseudo under other
-			 equal conditions for possibe inheritance.  */
+			 equal conditions for possible inheritance.  */
 		      if (! scratch_p)
 			{
 			  if (lra_dump_file != NULL)
@@ -2689,7 +2689,7 @@ process_alt_operands (int only_alternative)
 
 		 Non-pseudo spill may happen also.  Suppose a target allows both
 		 register and memory in the operand constraint alternatives,
-		 then it's typical that an eliminable register has a substition
+		 then it's typical that an eliminable register has a substitution
 		 of "base + offset" which can either be reloaded by a simple
 		 "new_reg <= base + offset" which will match the register
 		 constraint, or a similar reg addition followed by further spill
@@ -3426,7 +3426,7 @@ process_address_1 (int nop, bool check_only_p,
 	      delete_insns_since (PREV_INSN (last_insn));
 	    }
 	}
-      /* Try if target can split displacement into legitimite new disp
+      /* Try if target can split displacement into legitimate new disp
 	 and offset.  If it's the case, we replace the last insn with
 	 insns for base + offset => new_reg and set new_reg + new disp
 	 to *ad.inner.  */
@@ -3478,7 +3478,7 @@ process_address_1 (int nop, bool check_only_p,
       Index part of address may become invalid.  For example, we
       changed pseudo on the equivalent memory and a subreg of the
       pseudo onto the memory of different mode for which the scale is
-      prohibitted.  */
+      prohibited.  */
       new_reg = index_part_to_reg (&ad);
       *ad.inner = simplify_gen_binary (PLUS, GET_MODE (new_reg),
 				       *ad.base_term, new_reg);
@@ -4135,7 +4135,7 @@ curr_insn_transform (bool check_only_p)
 	      && REG_P (op)
 	      /* When we assign NO_REGS it means that we will not
 		 assign a hard register to the scratch pseudo by
-		 assigment pass and the scratch pseudo will be
+		 assignment pass and the scratch pseudo will be
 		 spilled.  Spilled scratch pseudos are transformed
 		 back to scratches at the LRA end.  */
 	      && lra_former_scratch_operand_p (curr_insn, i)
@@ -4661,7 +4661,7 @@ lra_constraints (bool first_p)
     lra_risky_transformations_p = first_p;
   new_insn_uid_start = get_max_uid ();
   new_regno_start = first_p ? lra_constraint_new_regno_start : max_reg_num ();
-  /* Mark used hard regs for target stack size calulations.  */
+  /* Mark used hard regs for target stack size calculations.  */
   for (i = FIRST_PSEUDO_REGISTER; i < new_regno_start; i++)
     if (lra_reg_info[i].nrefs != 0
 	&& (hard_regno = lra_get_regno_hard_regno (i)) >= 0)
@@ -4895,7 +4895,7 @@ lra_constraints_finish (void)
 
 
 
-/* Structure describes invariants for ineheritance.  */
+/* Structure describes invariants for inheritance.  */
 struct lra_invariant
 {
   /* The order number of the invariant.  */
@@ -5116,7 +5116,7 @@ check_secondary_memory_needed_p (enum reg_class inher_cl ATTRIBUTE_UNUSED,
    (inheritance/split pseudos and original registers).	*/
 static bitmap_head check_only_regs;
 
-/* Reload pseudos can not be involded in invariant inheritance in the
+/* Reload pseudos can not be involved in invariant inheritance in the
    current EBB.  */
 static bitmap_head invalid_invariant_regs;
 
@@ -5626,7 +5626,7 @@ split_reg (bool before_p, int original_regno, rtx_insn *insn,
    defines or uses REGNO in its insn biggest MODE (we use it only if
    REGNO is a hard register).  POTENTIAL_RELOAD_HARD_REGS contains
    hard registers which might be used for reloads since the EBB end.
-   Put the save before INSN if BEFORE_P is true.  MAX_UID is maximla
+   Put the save before INSN if BEFORE_P is true.  MAX_UID is maximal
    uid before starting INSN processing.  Return true if we succeed in
    such transformation.  */
 static bool
diff --git a/gcc/lra-eliminations.c b/gcc/lra-eliminations.c
index ab51b67..208b19f 100644
--- a/gcc/lra-eliminations.c
+++ b/gcc/lra-eliminations.c
@@ -309,7 +309,7 @@ move_plus_up (rtx x)
    substitution if UPDATE_P, or the full offset if FULL_P, or
    otherwise zero.  If FULL_P, we also use the SP offsets for
    elimination to SP.  If UPDATE_P, use UPDATE_SP_OFFSET for updating
-   offsets of register elimnable to SP.  If UPDATE_SP_OFFSET is
+   offsets of register eliminable to SP.  If UPDATE_SP_OFFSET is
    non-zero, don't use difference of the offset and the previous
    offset.
 
@@ -863,7 +863,7 @@ mark_not_eliminable (rtx x, machine_mode mem_mode)
 #ifdef HARD_FRAME_POINTER_REGNUM
 
 /* Find offset equivalence note for reg WHAT in INSN and return the
-   found elmination offset.  If the note is not found, return NULL.
+   found elimination offset.  If the note is not found, return NULL.
    Remove the found note.  */
 static rtx
 remove_reg_equal_offset_note (rtx_insn *insn, rtx what)
diff --git a/gcc/lra-int.h b/gcc/lra-int.h
index 4050717..83a7ca7 100644
--- a/gcc/lra-int.h
+++ b/gcc/lra-int.h
@@ -105,7 +105,7 @@ struct lra_reg
   /* Value holding by register.	 If the pseudos have the same value
      they do not conflict.  */
   int val;
-  /* Offset from relative eliminate register to pesudo reg.  */
+  /* Offset from relative eliminate register to pseudo reg.  */
   int offset;
   /* These members are set up in lra-lives.c and updated in
      lra-coalesce.c.  */
diff --git a/gcc/lra-remat.c b/gcc/lra-remat.c
index f28993e..6a5c690 100644
--- a/gcc/lra-remat.c
+++ b/gcc/lra-remat.c
@@ -85,7 +85,7 @@ typedef struct cand *cand_t;
 typedef const struct cand *const_cand_t;
 
 /* Insn candidates for rematerialization.  The candidate insn should
-   have the following properies:
+   have the following properties:
    o no any memory (as access to memory is non-profitable)
    o no INOUT regs (it means no non-paradoxical subreg of output reg)
    o one output spilled pseudo (or reload pseudo of a spilled pseudo)
@@ -133,7 +133,7 @@ struct remat_bb_data
   /* Registers becoming dead in the BB.  */
   bitmap_head dead_regs;
   /* Cands present in the BB whose in/out regs are not changed after
-     the cands occurence and are not dead (except the reload
+     the cands occurrence and are not dead (except the reload
      regno).  */
   bitmap_head gen_cands;
   bitmap_head livein_cands; /* cands whose inputs live at the BB start.  */
@@ -1103,7 +1103,7 @@ do_remat (void)
 
 	  cand = NULL;
 	  /* Check possibility of rematerialization (hard reg or
-	     unpsilled pseudo <- spilled pseudo): */
+	     unspilled pseudo <- spilled pseudo): */
 	  if (dst_regno >= 0 && src_regno >= FIRST_PSEUDO_REGISTER
 	      && reg_renumber[src_regno] < 0
 	      && (dst_regno < FIRST_PSEUDO_REGISTER
diff --git a/gcc/lra.c b/gcc/lra.c
index 1230b25..d43c1a1 100644
--- a/gcc/lra.c
+++ b/gcc/lra.c
@@ -70,11 +70,11 @@ along with GCC; see the file COPYING3.	If not see
          |    to memory   |<----| Rematerialization |
          |  substitution  |      -------------------
           ----------------        
-                  | No susbtitions
+                  | No substitutions
                   V                
       -------------------------
      | Hard regs substitution, |
-     |  devirtalization, and   |------> Finish
+     |  devirtualization, and  |------> Finish
      | restoring scratches got |
      |         memory          |
       -------------------------
diff --git a/gcc/lto-cgraph.c b/gcc/lto-cgraph.c
index 77605f7..f2b5917 100644
--- a/gcc/lto-cgraph.c
+++ b/gcc/lto-cgraph.c
@@ -427,7 +427,7 @@ lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node,
 	 FIXME: At the moment they can be, when partition contains an inline
 	 clone that is clone of inline clone from outside partition.  We can
 	 reshape the clone tree and make other tree to be the root, but it
-	 needs a bit extra work and will be promplty done by cgraph_remove_node
+	 needs a bit extra work and will be promptly done by cgraph_remove_node
 	 after reading back.  */
       in_other_partition = 1;
     }
@@ -727,7 +727,7 @@ output_profile_summary (struct lto_simple_output_block *ob)
           streamer_write_gcov_count_stream (ob->main_stream,
                                       profile_info->histogram[h_ix].cum_value);
          }
-      /* IPA-profile computes hot bb threshold based on cumulated
+      /* IPA-profile computes hot bb threshold based on accumulated
 	 whole program profile.  We need to stream it down to ltrans.  */
        if (flag_wpa)
          streamer_write_gcov_count_stream (ob->main_stream,
@@ -964,7 +964,7 @@ compute_ltrans_boundary (lto_symtab_encoder_t in_encoder)
 		}
 	    }
     }
-  /* Be sure to also insert alias targert and thunk callees.  These needs
+  /* Be sure to also insert alias target and thunk callees.  These needs
      to stay to aid local calling conventions.  */
   for (i = 0; i < lto_symtab_encoder_size (encoder); i++)
     {
@@ -1218,7 +1218,7 @@ get_alias_symbol (tree decl)
 }
 
 /* Read a node from input_block IB.  TAG is the node's tag just read.
-   Return the node read or overwriten.  */
+   Return the node read or overwritten.  */
 
 static struct cgraph_node *
 input_node (struct lto_file_decl_data *file_data,
@@ -1345,7 +1345,7 @@ input_node (struct lto_file_decl_data *file_data,
 }
 
 /* Read a node from input_block IB.  TAG is the node's tag just read.
-   Return the node read or overwriten.  */
+   Return the node read or overwritten.  */
 
 static varpool_node *
 input_varpool_node (struct lto_file_decl_data *file_data,
@@ -1426,7 +1426,7 @@ input_varpool_node (struct lto_file_decl_data *file_data,
 }
 
 /* Read a node from input_block IB.  TAG is the node's tag just read.
-   Return the node read or overwriten.  */
+   Return the node read or overwritten.  */
 
 static void
 input_ref (struct lto_input_block *ib,
@@ -1692,7 +1692,7 @@ input_profile_summary (struct lto_input_block *ib,
           file_data->profile_info.histogram[h_ix].cum_value
               = streamer_read_gcov_count (ib);
         }
-      /* IPA-profile computes hot bb threshold based on cumulated
+      /* IPA-profile computes hot bb threshold based on accumulated
 	 whole program profile.  We need to stream it down to ltrans.  */
       if (flag_ltrans)
 	set_hot_bb_threshold (streamer_read_gcov_count (ib));
@@ -1798,7 +1798,7 @@ merge_profile_summaries (struct lto_file_decl_data **file_data_vec)
   if (lto_gcov_summary.sum_max < max_runs)
     lto_gcov_summary.sum_max = max_runs;
 
-  /* If merging already happent at WPA time, we are done.  */
+  /* If merging already happened at WPA time, we are done.  */
   if (flag_ltrans)
     return;
 
diff --git a/gcc/lto-opts.c b/gcc/lto-opts.c
index 9618bfb..a48eb01 100644
--- a/gcc/lto-opts.c
+++ b/gcc/lto-opts.c
@@ -74,7 +74,7 @@ lto_write_options (void)
      enabled by the frontend.
      This for now includes an explicit set of options that we also handle
      explicitly in lto-wrapper.c.  In the end the effects on GIMPLE IL
-     semantics should be explicitely encoded in the IL or saved per
+     semantics should be explicitly encoded in the IL or saved per
      function rather than per compilation unit.  */
   /* -fexceptions causes the EH machinery to be initialized, enabling
      generation of unwind data so that explicit throw() calls work.  */
diff --git a/gcc/lto-section-in.c b/gcc/lto-section-in.c
index 984a648..b1d3f3c 100644
--- a/gcc/lto-section-in.c
+++ b/gcc/lto-section-in.c
@@ -413,7 +413,7 @@ lto_free_function_in_decl_state (struct lto_in_decl_state *state)
   ggc_free (state);
 }
 
-/* Free decl_states associated with NODE.  This makes it possible to furhter
+/* Free decl_states associated with NODE.  This makes it possible to further
    release trees needed by the NODE's body.  */
 
 void
diff --git a/gcc/lto-streamer-in.c b/gcc/lto-streamer-in.c
index afed037..90aeb5f 100644
--- a/gcc/lto-streamer-in.c
+++ b/gcc/lto-streamer-in.c
@@ -208,7 +208,7 @@ lto_location_cache::apply_location_cache ()
   return true;
 }
 
-/* Tree merging did not suceed; mark all changes in the cache as accepted.  */
+/* Tree merging did not succeed; mark all changes in the cache as accepted.  */
 
 void
 lto_location_cache::accept_location_cache ()
@@ -217,7 +217,7 @@ lto_location_cache::accept_location_cache ()
   accepted_length = loc_cache.length ();
 }
 
-/* Tree merging did suceed; throw away recent changes.  */
+/* Tree merging did succeed; throw away recent changes.  */
 
 void
 lto_location_cache::revert_location_cache ()
@@ -227,7 +227,7 @@ lto_location_cache::revert_location_cache ()
 
 /* Read a location bitpack from input block IB and either update *LOC directly
    or add it to the location cache.
-   It is neccesary to call apply_location_cache to get *LOC updated.  */
+   It is necessary to call apply_location_cache to get *LOC updated.  */
 
 void
 lto_location_cache::input_location (location_t *loc, struct bitpack_d *bp,
@@ -265,7 +265,7 @@ lto_location_cache::input_location (location_t *loc, struct bitpack_d *bp,
   if (column_change)
     stream_col = bp_unpack_var_len_unsigned (bp);
 
-  /* This optimization saves location cache operations druing gimple
+  /* This optimization saves location cache operations during gimple
      streaming.  */
      
   if (current_file == stream_file && current_line == stream_line
@@ -282,7 +282,7 @@ lto_location_cache::input_location (location_t *loc, struct bitpack_d *bp,
 
 /* Read a location bitpack from input block IB and either update *LOC directly
    or add it to the location cache.
-   It is neccesary to call apply_location_cache to get *LOC updated.  */
+   It is necessary to call apply_location_cache to get *LOC updated.  */
 
 void
 lto_input_location (location_t *loc, struct bitpack_d *bp,
@@ -307,7 +307,7 @@ stream_input_location_now (struct bitpack_d *bp, struct data_in *data_in)
 /* Read a reference to a tree node from DATA_IN using input block IB.
    TAG is the expected node that should be found in IB, if TAG belongs
    to one of the indexable trees, expect to read a reference index to
-   be looked up in one of the symbol tables, otherwise read the pysical
+   be looked up in one of the symbol tables, otherwise read the physical
    representation of the tree using stream_read_tree.  FN is the
    function scope for the read tree.  */
 
diff --git a/gcc/lto-streamer-out.c b/gcc/lto-streamer-out.c
index b96b9df..56634a5 100644
--- a/gcc/lto-streamer-out.c
+++ b/gcc/lto-streamer-out.c
@@ -115,7 +115,7 @@ output_type_ref (struct output_block *ob, tree node)
 
 
 /* Return true if tree node T is written to various tables.  For these
-   nodes, we sometimes want to write their phyiscal representation
+   nodes, we sometimes want to write their physical representation
    (via lto_output_tree), and sometimes we need to emit an index
    reference into a table (via lto_output_tree_ref).  */
 
@@ -313,7 +313,7 @@ lto_is_streamable (tree expr)
 /* Very rough estimate of streaming size of the initializer.  If we ignored
    presence of strings, we could simply just count number of non-indexable
    tree nodes and number of references to indexable nodes.  Strings however
-   may be very large and we do not want to dump them int othe global stream.
+   may be very large and we do not want to dump them into the global stream.
 
    Count the size of initializer until the size in DATA is positive.  */
 
@@ -643,7 +643,7 @@ DFS::DFS (struct output_block *ob, tree expr, bool ref_p, bool this_ref_p,
 	     this way.
 	     ???  We still wrap these in LTO_tree_scc so at the
 	     input side we can properly identify the tree we want
-	     to ultimatively return.  */
+	     to ultimately return.  */
 	  if (size == 1)
 	    lto_output_tree_1 (ob, expr, scc_hash, ref_p, this_ref_p);
 	  else
@@ -879,7 +879,7 @@ DFS::DFS_write_tree_body (struct output_block *ob,
 	 handle - those that represent inlined function scopes.
 	 For the drop rest them on the floor instead of ICEing
 	 in dwarf2out.c, but keep the notion of whether the block
-	 is an inlined block by refering to itself for the sake of
+	 is an inlined block by referring to itself for the sake of
 	 tree_nonartificial_location.  */
       if (inlined_function_outer_scope_p (expr))
 	{
@@ -2339,7 +2339,7 @@ lto_output (void)
 	      decl_state = lto_new_out_decl_state ();
 	      lto_push_out_decl_state (decl_state);
 	      if (gimple_has_body_p (node->decl) || !flag_wpa
-		  /* Thunks have no body but they may be synthetized
+		  /* Thunks have no body but they may be synthesized
 		     at WPA time.  */
 		  || DECL_ARGUMENTS (node->decl))
 		output_function (node);
diff --git a/gcc/lto-streamer.h b/gcc/lto-streamer.h
index 7cf4b0b..5a4d91b 100644
--- a/gcc/lto-streamer.h
+++ b/gcc/lto-streamer.h
@@ -75,7 +75,7 @@ along with GCC; see the file COPYING3.  If not see
 
      LTO_function     - The tag.
      eh tree          - This is all of the exception handling regions
-                        put out in a post order traversial of the
+                        put out in a post order traversal of the
                         tree.  Siblings are output as lists terminated
 			by a 0.  The set of fields matches the fields
 			defined in except.c.
@@ -293,7 +293,7 @@ typedef void (lto_free_section_data_f) (struct lto_file_decl_data *,
 					size_t);
 
 /* The location cache holds expanded locations for streamed in trees.
-   This is done to reduce memory usage of libcpp linemap that strongly preffers
+   This is done to reduce memory usage of libcpp linemap that strongly prefers
    locations to be inserted in the soruce order.  */
 
 class lto_location_cache
@@ -302,9 +302,10 @@ public:
   /* Apply all changes in location cache.  Add locations into linemap and patch
      trees.  */
   bool apply_location_cache ();
-  /* Tree merging did not suceed; mark all changes in the cache as accepted.  */
+  /* Tree merging did not succeed; mark all changes in the cache as
+     accepted.  */
   void accept_location_cache ();
-  /* Tree merging did suceed; throw away recent changes.  */
+  /* Tree merging did succeed; throw away recent changes.  */
   void revert_location_cache ();
   void input_location (location_t *loc, struct bitpack_d *bp,
 		       struct data_in *data_in);
diff --git a/gcc/lto-wrapper.c b/gcc/lto-wrapper.c
index 4b86f93..0598af5 100644
--- a/gcc/lto-wrapper.c
+++ b/gcc/lto-wrapper.c
@@ -872,7 +872,7 @@ find_crtoffloadtable (void)
 
 /* A subroutine of run_gcc.  Examine the open file FD for lto sections with
    name prefix PREFIX, at FILE_OFFSET, and store any options we find in OPTS
-   and OPT_COUNT.  Return true if we found a matchingn section, false
+   and OPT_COUNT.  Return true if we found a matching section, false
    otherwise.  COLLECT_GCC holds the value of the environment variable with
    the same name.  */
 
diff --git a/gcc/lto/lto-lang.c b/gcc/lto/lto-lang.c
index 52ab2a8..3800093 100644
--- a/gcc/lto/lto-lang.c
+++ b/gcc/lto/lto-lang.c
@@ -831,7 +831,7 @@ lto_post_options (const char **pfilename ATTRIBUTE_UNUSED)
       break;
 
     case LTO_LINKER_OUTPUT_DYN: /* .so: PID library */
-      /* On some targets, like i386 it makes sense to build PIC library wihout
+      /* On some targets, like i386 it makes sense to build PIC library without
 	 -fpic for performance reasons.  So no need to adjust flags.  */
       break;
 
diff --git a/gcc/lto/lto-partition.c b/gcc/lto/lto-partition.c
index 3600ab2..ccaa093 100644
--- a/gcc/lto/lto-partition.c
+++ b/gcc/lto/lto-partition.c
@@ -91,7 +91,7 @@ add_references_to_partition (ltrans_partition part, symtab_node *node)
   for (i = 0; node->iterate_reference (i, ref); i++)
     if (ref->referred->get_partitioning_class () == SYMBOL_DUPLICATE)
       add_symbol_to_partition (part, ref->referred);
-    /* References to a readonly variable may be constant foled into its value.
+    /* References to a readonly variable may be constant folded into its value.
        Recursively look into the initializers of the constant variable and add
        references, too.  */
     else if (is_a <varpool_node *> (ref->referred)
@@ -213,7 +213,7 @@ static symtab_node *
 contained_in_symbol (symtab_node *node)
 {
   /* There is no need to consider transparent aliases to be part of the
-     definition: they are only useful insite the partition they are output
+     definition: they are only useful inside the partition they are output
      and thus we will always see an explicit reference to it.  */
   if (node->transparent_alias)
     return node;
@@ -488,7 +488,7 @@ lto_balanced_map (int n_lto_partitions, int max_partition_size)
   /* Streaming works best when the source units do not cross partition
      boundaries much.  This is because importing function from a source
      unit tends to import a lot of global trees defined there.  We should
-     get better about minimizing the function bounday, but until that
+     get better about minimizing the function boundary, but until that
      things works smoother if we order in source order.  */
   qsort (order, n_nodes, sizeof (struct cgraph_node *), node_cmp);
   noreorder.qsort (node_cmp);
@@ -1067,7 +1067,7 @@ rename_statics (lto_symtab_encoder_t encoder, symtab_node *node)
 	    || lto_symtab_encoder_lookup (encoder, s) != LCC_NOT_FOUND))
        break;
 
-  /* OK, no confict, so we have nothing to do.  */
+  /* OK, no conflict, so we have nothing to do.  */
   if (!s)
     return;
 
diff --git a/gcc/lto/lto-symtab.c b/gcc/lto/lto-symtab.c
index 9fd9486..e6f7736 100644
--- a/gcc/lto/lto-symtab.c
+++ b/gcc/lto/lto-symtab.c
@@ -85,7 +85,7 @@ lto_cgraph_replace_node (struct cgraph_node *node,
 	  e->call_stmt_cannot_inline_p = 1;
 	}
     }
-  /* Redirect incomming references.  */
+  /* Redirect incoming references.  */
   prevailing_node->clone_referring (node);
 
   /* Fix instrumentation references.  */
@@ -181,7 +181,7 @@ lto_varpool_replace_node (varpool_node *vnode,
   vnode->remove ();
 }
 
-/* Return non-zero if we want to output waring about T1 and T2.
+/* Return non-zero if we want to output warning about T1 and T2.
    Return value is a bitmask of reasons of violation:
    Bit 0 indicates that types are not compatible.
    Bit 1 indicates that types are not compatible because of C++ ODR rule.
@@ -194,11 +194,11 @@ lto_varpool_replace_node (varpool_node *vnode,
    implementation should be coarse enough so all valid type transitions
    across different languages are allowed.
 
-   In partiucular we thus allow almost arbitrary type changes with
+   In particular we thus allow almost arbitrary type changes with
    -fno-strict-aliasing which may be tough of as a feature rather than bug
    as it allows to implement dodgy tricks in the language runtimes.
 
-   Naturally this code can be strenghtened significantly if we could track
+   Naturally this code can be strengthened significantly if we could track
    down the language of origin.  */
 
 static int
@@ -754,7 +754,7 @@ lto_symtab_merge_decls_1 (symtab_node *first)
 	 variable is actually used).
 	 When there are multiple variants, chose one with size.
 	 This is needed for C++ typeinfos, for example in
-	 lto/20081204-1 there are typeifos in both units, just
+	 lto/20081204-1 there are typeinfos in both units, just
 	 one of them do have size.  */
       if (TREE_CODE (prevailing->decl) == VAR_DECL)
 	{
@@ -929,8 +929,8 @@ lto_symtab_merge_symbols (void)
 
       /* Do the actual merging.  
          At this point we invalidate hash translating decls into symtab nodes
-	 because after removing one of duplicate decls the hash is not correcly
-	 updated to the ohter dupliate.  */
+	 because after removing one of duplicate decls the hash is not correctly
+	 updated to the ohter duplicate.  */
       FOR_EACH_SYMBOL (node)
 	if (lto_symtab_symbol_p (node)
 	    && node->next_sharing_asm_name
@@ -990,10 +990,11 @@ lto_symtab_merge_symbols (void)
 }
 
 /* Virtual tables may matter for code generation even if they are not
-   directly refernced by the code because they may be used for devirtualizaiton.
+   directly referenced by the code because they may be used for
+   devirtualization.
    For this reason it is important to merge even virtual tables that have no
    associated symbol table entries.  Without doing so we lose optimization
-   oppurtunities by losing track of the vtable constructor.
+   opportunities by losing track of the vtable constructor.
    FIXME: we probably ought to introduce explicit symbol table entries for
    those before streaming.  */
 
diff --git a/gcc/lto/lto.c b/gcc/lto/lto.c
index 44ddf41..86d0f23 100644
--- a/gcc/lto/lto.c
+++ b/gcc/lto/lto.c
@@ -1752,7 +1752,7 @@ lto_read_decls (struct lto_file_decl_data *decl_data, const void *data,
 		  && TREE_CODE (t) == TYPE_DECL)
 		{
 		  /* Dwarf2out needs location information.
-		     TODO: Moving this out of the streamer loop may noticealy
+		     TODO: Moving this out of the streamer loop may noticeably
 		     improve ltrans linemap memory use.  */
 		  data_in->location_cache.apply_location_cache ();
 		  debug_hooks->type_decl (t, !DECL_FILE_SCOPE_P (t));
@@ -2357,7 +2357,7 @@ stream_out (char *temp_filename, lto_symtab_encoder_t encoder,
 	  do_stream_out (temp_filename, encoder);
 	  exit (0);
 	}
-      /* Fork failed; lets do the job ourseleves.  */
+      /* Fork failed; lets do the job ourselves.  */
       else if (cpid == -1)
         do_stream_out (temp_filename, encoder);
       else
@@ -2838,7 +2838,7 @@ read_cgraph_and_symbols (unsigned nfiles, const char **fnames)
   canonical_type_hash_cache = NULL;
 
   /* At this stage we know that majority of GGC memory is reachable.  
-     Growing the limits prevents unnecesary invocation of GGC.  */
+     Growing the limits prevents unnecessary invocation of GGC.  */
   ggc_grow ();
   ggc_collect ();
 
@@ -3063,7 +3063,7 @@ do_whole_program_analysis (void)
 
   lto_parallelism = 1;
 
-  /* TODO: jobserver communicatoin is not supported, yet.  */
+  /* TODO: jobserver communication is not supported, yet.  */
   if (!strcmp (flag_wpa, "jobserver"))
     lto_parallelism = -1;
   else
@@ -3148,7 +3148,7 @@ do_whole_program_analysis (void)
 
   /* Collect a last time - in lto_wpa_write_files we may end up forking
      with the idea that this doesn't increase memory usage.  So we
-     absoultely do not want to collect after that.  */
+     absolutely do not want to collect after that.  */
   ggc_collect ();
 
   timevar_start (TV_PHASE_STREAM_OUT);
diff --git a/gcc/machmode.def b/gcc/machmode.def
index afe6851..f1836e4 100644
--- a/gcc/machmode.def
+++ b/gcc/machmode.def
@@ -179,7 +179,7 @@ RANDOM_MODE (BLK);
 FRACTIONAL_INT_MODE (BI, 1, 1);
 
 /* Basic integer modes.  We go up to TI in generic code (128 bits).
-   TImode is needed here because the some front ends now genericly
+   TImode is needed here because the some front ends now generically
    support __int128.  If the front ends decide to generically support
    larger types, then corresponding modes must be added here.  The
    name OI is reserved for a 256-bit type (needed by some back ends).
diff --git a/gcc/machmode.h b/gcc/machmode.h
index 42b14d0..e27bb94 100644
--- a/gcc/machmode.h
+++ b/gcc/machmode.h
@@ -361,13 +361,13 @@ extern void init_adjust_machine_modes (void);
    && GET_MODE_PRECISION (MODE) <= HOST_BITS_PER_WIDE_INT)
 
 struct int_n_data_t {
-  /* These parts are initailized by genmodes output */
+  /* These parts are initialized by genmodes output */
   unsigned int bitsize;
   machine_mode m;
   /* RID_* is RID_INTN_BASE + index into this array */
 };
 
-/* This is also in tree.h.  genmodes.c guarantees the're sorted from
+/* This is also in tree.h.  genmodes.c guarantees they're sorted from
    smallest bitsize to largest bitsize. */
 extern bool int_n_enabled_p[NUM_INT_N_ENTS];
 extern const int_n_data_t int_n_data[NUM_INT_N_ENTS];
diff --git a/gcc/mem-stats.h b/gcc/mem-stats.h
index a5f8e32..257c0b3 100644
--- a/gcc/mem-stats.h
+++ b/gcc/mem-stats.h
@@ -245,7 +245,7 @@ struct mem_usage
   size_t m_instances;
 };
 
-/* Memory usage pair that connectes memory usage and number
+/* Memory usage pair that connects memory usage and number
    of allocated bytes.  */
 template <class T>
 struct mem_usage_pair
@@ -291,7 +291,7 @@ public:
   typedef hash_map <const void *, std::pair<T *, size_t> > reverse_object_map_t;
   typedef std::pair <mem_location *, T *> mem_list_t;
 
-  /* Default contructor.  */
+  /* Default constructor.  */
   mem_alloc_description ();
 
   /* Default destructor.  */
@@ -311,7 +311,7 @@ public:
   register_descriptor (const void *ptr, mem_location *location);
 
   /* Register memory allocation descriptor for container PTR.  ORIGIN identifies
-     type of container and GGC identifes if the allocation is handled in GGC
+     type of container and GGC identifies if the allocation is handled in GGC
      memory.  Each location is identified by file NAME, LINE in source code and
      FUNCTION name.  */
   T *
@@ -336,7 +336,7 @@ public:
   release_instance_overhead (void *ptr, size_t size,
 				  bool remove_from_map = false);
 
-  /* Release intance object identified by PTR pointer.  */
+  /* Release instance object identified by PTR pointer.  */
   void
   release_object_overhead (void *ptr);
 
@@ -425,7 +425,7 @@ mem_alloc_description<T>::register_descriptor (const void *ptr,
 }
 
 /* Register memory allocation descriptor for container PTR.  ORIGIN identifies
-   type of container and GGC identifes if the allocation is handled in GGC
+   type of container and GGC identifies if the allocation is handled in GGC
    memory.  Each location is identified by file NAME, LINE in source code and
    FUNCTION name.  */
 
@@ -517,7 +517,7 @@ mem_alloc_description<T>::release_instance_overhead (void *ptr, size_t size,
     m_reverse_map->remove (ptr);
 }
 
-/* Release intance object identified by PTR pointer.  */
+/* Release instance object identified by PTR pointer.  */
 
 template <class T>
 inline void
@@ -531,7 +531,7 @@ mem_alloc_description<T>::release_object_overhead (void *ptr)
     }
 }
 
-/* Default contructor.  */
+/* Default constructor.  */
 
 template <class T>
 inline
diff --git a/gcc/mode-switching.c b/gcc/mode-switching.c
index 15b813f..de995cf 100644
--- a/gcc/mode-switching.c
+++ b/gcc/mode-switching.c
@@ -732,7 +732,7 @@ optimize_mode_switching (void)
 	  struct bb_info *info = bb_info[j];
 	  int last_mode = no_mode;
 
-	  /* intialize mode in availability for bb.  */
+	  /* initialize mode in availability for bb.  */
 	  for (i = 0; i < no_mode; i++)
 	    if (mode_bit_p (avout[bb->index], j, i))
 	      {
@@ -746,7 +746,7 @@ optimize_mode_switching (void)
 	      }
 	  info[bb->index].mode_out = last_mode;
 
-	  /* intialize mode out availability for bb.  */
+	  /* initialize mode out availability for bb.  */
 	  last_mode = no_mode;
 	  for (i = 0; i < no_mode; i++)
 	    if (mode_bit_p (avin[bb->index], j, i))
diff --git a/gcc/modulo-sched.c b/gcc/modulo-sched.c
index 720391f..7478f67 100644
--- a/gcc/modulo-sched.c
+++ b/gcc/modulo-sched.c
@@ -719,7 +719,7 @@ schedule_reg_moves (partial_schedule_ptr ps)
 		gcc_assert (set);
 		/* If the instruction contains auto-inc register then
 		   validate that the regmov is being generated for the
-		   target regsiter rather then the inc'ed register.	*/
+		   target register rather then the inc'ed register.	*/
 		gcc_assert (!autoinc_var_is_used_p (u->insn, e->dest->insn));
 	      }
 	    
@@ -1049,7 +1049,7 @@ optimize_sc (partial_schedule_ptr ps, ddg_ptr g)
 
 	  /* The branch was failed to be placed in row ii - 1.
 	     Put it back in it's original place in the partial
-	     schedualing.  */
+	     scheduling.  */
 	  set_must_precede_follow (&tmp_follow, must_follow, &tmp_precede,
 				   must_precede, branch_cycle, start, end,
 				   step);
diff --git a/gcc/omp-expand.c b/gcc/omp-expand.c
index 7a7c747..9ff41ad 100644
--- a/gcc/omp-expand.c
+++ b/gcc/omp-expand.c
@@ -5329,7 +5329,7 @@ expand_oacc_for (struct omp_region *region, struct omp_for_data *fd)
   basic_block cont_bb = region->cont; /* BB ending in OMP_CONTINUE  */
   basic_block bottom_bb = NULL;
 
-  /* entry_bb has two sucessors; the branch edge is to the exit
+  /* entry_bb has two successors; the branch edge is to the exit
      block,  fallthrough edge to body.  */
   gcc_assert (EDGE_COUNT (entry_bb->succs) == 2
 	      && BRANCH_EDGE (entry_bb)->dest == exit_bb);
@@ -5808,7 +5808,7 @@ expand_omp_for (struct omp_region *region, gimple *inner_stmt)
       FALLTHRU_EDGE (region->cont)->flags &= ~EDGE_ABNORMAL;
     }
   else
-    /* If there isn't a continue then this is a degerate case where
+    /* If there isn't a continue then this is a degenerate case where
        the introduction of abnormal edges during lowering will prevent
        original loops from being detected.  Fix that up.  */
     loops_state_set (LOOPS_NEED_FIXUP);
@@ -6397,7 +6397,7 @@ expand_omp_atomic_fetch_op (basic_block load_bb,
 
   /* We could test all of the various optabs involved, but the fact of the
      matter is that (with the exception of i486 vs i586 and xadd) all targets
-     that support any atomic operaton optab also implements compare-and-swap.
+     that support any atomic operation optab also implements compare-and-swap.
      Let optabs.c take care of expanding any compare-and-swap loop.  */
   if (!can_compare_and_swap_p (imode, true) || !can_atomic_load_p (imode))
     return false;
@@ -6797,7 +6797,7 @@ mark_loops_in_oacc_kernels_region (basic_block region_entry,
     loop->in_oacc_kernels_region = true;
 }
 
-/* Types used to pass grid and wortkgroup sizes to kernel invocation.  */
+/* Types used to pass grid and workgroup sizes to kernel invocation.  */
 
 struct GTY(()) grid_launch_attributes_trees
 {
@@ -7087,7 +7087,7 @@ expand_omp_target (struct omp_region *region)
       mark_loops_in_oacc_kernels_region (region->entry, region->exit);
 
       /* Further down, both OpenACC kernels and OpenACC parallel constructs
-	 will be mappted to BUILT_IN_GOACC_PARALLEL, and to distinguish the
+	 will be mapped to BUILT_IN_GOACC_PARALLEL, and to distinguish the
 	 two, there is an "oacc kernels" attribute set for OpenACC kernels.  */
       DECL_ATTRIBUTES (child_fn)
 	= tree_cons (get_identifier ("oacc kernels"),
diff --git a/gcc/omp-general.c b/gcc/omp-general.c
index 9a5ed88..d7e24f4 100644
--- a/gcc/omp-general.c
+++ b/gcc/omp-general.c
@@ -1,5 +1,5 @@
-/* General types and functions that are uselful for processing of OpenMP,
-   OpenACC and similar directivers at various stages of compilation.
+/* General types and functions that are useful for processing of OpenMP,
+   OpenACC and similar directives at various stages of compilation.
 
    Copyright (C) 2005-2017 Free Software Foundation, Inc.
 
@@ -559,7 +559,7 @@ oacc_set_fn_attrib (tree fn, tree clauses, vec<tree> *args)
     }
 }
 
-/*  Process the routine's dimension clauess to generate an attribute
+/*  Process the routine's dimension clauses to generate an attribute
     value.  Issue diagnostics as appropriate.  We default to SEQ
     (OpenACC 2.5 clarifies this). All dimensions have a size of zero
     (dynamic).  TREE_PURPOSE is set to indicate whether that dimension
diff --git a/gcc/omp-general.h b/gcc/omp-general.h
index d28eb4b..302a515 100644
--- a/gcc/omp-general.h
+++ b/gcc/omp-general.h
@@ -1,5 +1,5 @@
-/* General types and functions that are uselful for processing of OpenMP,
-   OpenACC and similar directivers at various stages of compilation.
+/* General types and functions that are useful for processing of OpenMP,
+   OpenACC and similar directives at various stages of compilation.
 
    Copyright (C) 2005-2017 Free Software Foundation, Inc.
 
diff --git a/gcc/omp-grid.c b/gcc/omp-grid.c
index a7b6f60..a48b62b 100644
--- a/gcc/omp-grid.c
+++ b/gcc/omp-grid.c
@@ -988,7 +988,7 @@ grid_copy_leading_local_assignments (gimple_seq src, gimple_stmt_iterator *dst,
 }
 
 /* Statement walker function to make adjustments to statements within the
-   gridifed kernel copy.  */
+   gridified kernel copy.  */
 
 static tree
 grid_process_grid_body (gimple_stmt_iterator *gsi, bool *handled_ops_p,
@@ -1038,7 +1038,7 @@ grid_eliminate_combined_simd_part (gomp_for *parloop)
   gomp_for *simd = as_a <gomp_for *> (stmt);
 
   /* Copy over the iteration properties because the body refers to the index in
-     the bottmom-most loop.  */
+     the bottom-most loop.  */
   unsigned i, collapse = gimple_omp_for_collapse (parloop);
   gcc_checking_assert (collapse == gimple_omp_for_collapse (simd));
   for (i = 0; i < collapse; i++)
@@ -1053,7 +1053,7 @@ grid_eliminate_combined_simd_part (gomp_for *parloop)
   while (*tgt)
     tgt = &OMP_CLAUSE_CHAIN (*tgt);
 
-  /* Copy over all clauses, except for linaer clauses, which are turned into
+  /* Copy over all clauses, except for linear clauses, which are turned into
      private clauses, and all other simd-specificl clauses, which are
      ignored.  */
   tree *pc = gimple_omp_for_clauses_ptr (simd);
diff --git a/gcc/omp-low.c b/gcc/omp-low.c
index 9a16248..2028b23 100644
--- a/gcc/omp-low.c
+++ b/gcc/omp-low.c
@@ -4081,7 +4081,7 @@ lower_rec_input_clauses (tree clauses, gimple_seq *ilist, gimple_seq *dlist,
 		{
 		  /* For reduction in SIMD loop, defer adding the
 		     initialization of the reference, because if we decide
-		     to use SIMD array for it, the initilization could cause
+		     to use SIMD array for it, the initialization could cause
 		     expansion ICE.  */
 		  if (c_kind == OMP_CLAUSE_REDUCTION && is_simd)
 		    x = NULL_TREE;
@@ -5645,7 +5645,7 @@ lower_send_shared_vars (gimple_seq *ilist, gimple_seq *olist, omp_context *ctx)
     }
 }
 
-/* Emit an OpenACC head marker call, encapulating the partitioning and
+/* Emit an OpenACC head marker call, encapsulating the partitioning and
    other information that must be processed by the target compiler.
    Return the maximum number of dimensions the associated loop might
    be partitioned over.  */
@@ -5747,7 +5747,7 @@ lower_oacc_head_mark (location_t loc, tree ddvar, tree clauses,
   return levels;
 }
 
-/* Emit an OpenACC lopp head or tail marker to SEQ.  LEVEL is the
+/* Emit an OpenACC loop head or tail marker to SEQ.  LEVEL is the
    partitioning level of the enclosed region.  */ 
 
 static void
@@ -8947,7 +8947,7 @@ lower_omp (gimple_seq *body, omp_context *ctx)
   gimple_stmt_iterator gsi;
   for (gsi = gsi_start (*body); !gsi_end_p (gsi); gsi_next (&gsi))
     lower_omp_1 (&gsi, ctx);
-  /* During gimplification, we haven't folded statments inside offloading
+  /* During gimplification, we haven't folded statements inside offloading
      or taskreg regions (gimplify.c:maybe_fold_stmt); do that now.  */
   if (target_nesting_level || taskreg_nesting_level)
     for (gsi = gsi_start (*body); !gsi_end_p (gsi); gsi_next (&gsi))
diff --git a/gcc/omp-offload.c b/gcc/omp-offload.c
index 54a4e90..d9c6175 100644
--- a/gcc/omp-offload.c
+++ b/gcc/omp-offload.c
@@ -491,14 +491,14 @@ oacc_xform_tile (gcall *call)
   e_mask = 0;
 #endif
   if (!e_mask)
-    /* Not paritioning.  */
+    /* Not partitioning.  */
     span = integer_one_node;
   else if (!integer_zerop (tile_size))
     /* User explicitly specified size.  */
     span = tile_size;
   else
     {
-      /* Pick a size based on the paritioning of the element loop and
+      /* Pick a size based on the partitioning of the element loop and
 	 the number of loop nests.  */
       tree first_size = NULL_TREE;
       tree second_size = NULL_TREE;
@@ -1077,7 +1077,7 @@ oacc_loop_process (oacc_loop *loop)
     oacc_loop_process (loop->sibling);
 }
 
-/* Walk the OpenACC loop heirarchy checking and assigning the
+/* Walk the OpenACC loop hierarchy checking and assigning the
    programmer-specified partitionings.  OUTER_MASK is the partitioning
    this loop is contained within.  Return mask of partitioning
    encountered.  If any auto loops are discovered, set GOMP_DIM_MAX
@@ -1227,7 +1227,7 @@ oacc_loop_fixed_partitions (oacc_loop *loop, unsigned outer_mask)
   return mask_all;
 }
 
-/* Walk the OpenACC loop heirarchy to assign auto-partitioned loops.
+/* Walk the OpenACC loop hierarchy to assign auto-partitioned loops.
    OUTER_MASK is the partitioning this loop is contained within.
    OUTER_ASSIGN is true if an outer loop is being auto-partitioned.
    Return the cumulative partitioning used by this loop, siblings and
@@ -1348,7 +1348,7 @@ oacc_loop_auto_partitions (oacc_loop *loop, unsigned outer_mask,
   return inner_mask;
 }
 
-/* Walk the OpenACC loop heirarchy to check and assign partitioning
+/* Walk the OpenACC loop hierarchy to check and assign partitioning
    axes.  Return mask of partitioning.  */
 
 static unsigned
diff --git a/gcc/omp-simd-clone.c b/gcc/omp-simd-clone.c
index 99589d4..1639940 100644
--- a/gcc/omp-simd-clone.c
+++ b/gcc/omp-simd-clone.c
@@ -277,7 +277,7 @@ simd_clone_clauses_extract (struct cgraph_node *node, tree clauses,
 }
 
 /* Given a SIMD clone in NODE, calculate the characteristic data
-   type and return the coresponding type.  The characteristic data
+   type and return the corresponding type.  The characteristic data
    type is computed as described in the Intel Vector ABI.  */
 
 static tree
@@ -899,7 +899,7 @@ ipa_simd_modify_stmt_ops (tree *tp, int *walk_subtrees, void *data)
    offset into the corresponding simd_array.
 
    This function will replace all function argument uses with their
-   corresponding simd array elements, and ajust the return values
+   corresponding simd array elements, and adjust the return values
    accordingly.  */
 
 static void
diff --git a/gcc/optabs-query.c b/gcc/optabs-query.c
index 4899333..f025895 100644
--- a/gcc/optabs-query.c
+++ b/gcc/optabs-query.c
@@ -442,7 +442,7 @@ find_widening_optab_handler_and_mode (optab op, machine_mode to_mode,
   return CODE_FOR_nothing;
 }
 
-/* Return non-zero if a highpart multiply is supported of can be synthisized.
+/* Return non-zero if a highpart multiply is supported of can be synthesized.
    For the benefit of expand_mult_highpart, the return value is 1 for direct,
    2 for even/odd widening, and 3 for hi/lo widening.  */
 
@@ -613,7 +613,7 @@ lshift_cheap_p (bool speed_p)
   static bool init[2] = { false, false };
   static bool cheap[2] = { true, true };
 
-  /* If the targer has no lshift in word_mode, the operation will most
+  /* If the target has no lshift in word_mode, the operation will most
      probably not be cheap.  ??? Does GCC even work for such targets?  */
   if (optab_handler (ashl_optab, word_mode) == CODE_FOR_nothing)
     return false;
diff --git a/gcc/optabs.c b/gcc/optabs.c
index b69e759..7e7ce11 100644
--- a/gcc/optabs.c
+++ b/gcc/optabs.c
@@ -5513,7 +5513,7 @@ expand_vec_perm (machine_mode mode, rtx v0, rtx v1, rtx sel, rtx target)
 	}
     }
 
-  /* Otherwise expand as a fully variable permuation.  */
+  /* Otherwise expand as a fully variable permutation.  */
   icode = direct_optab_handler (vec_perm_optab, mode);
   if (icode != CODE_FOR_nothing)
     {
@@ -5558,7 +5558,7 @@ expand_vec_perm (machine_mode mode, rtx v0, rtx v1, rtx sel, rtx target)
       gcc_assert (sel != NULL);
 
       /* Add the byte offset to each byte element.  */
-      /* Note that the definition of the indicies here is memory ordering,
+      /* Note that the definition of the indices here is memory ordering,
 	 so there should be no difference between big and little endian.  */
       vec = rtvec_alloc (w);
       for (i = 0; i < w; ++i)
@@ -5861,7 +5861,7 @@ expand_compare_and_swap_loop (rtx mem, rtx old_reg, rtx new_reg, rtx seq)
 }
 
 
-/* This function tries to emit an atomic_exchange intruction.  VAL is written
+/* This function tries to emit an atomic_exchange instruction.  VAL is written
    to *MEM using memory model MODEL. The previous contents of *MEM are returned,
    using TARGET if possible.  */
    
@@ -5891,7 +5891,7 @@ maybe_emit_atomic_exchange (rtx target, rtx mem, rtx val, enum memmodel model)
 /* This function tries to implement an atomic exchange operation using
    __sync_lock_test_and_set. VAL is written to *MEM using memory model MODEL.
    The previous contents of *MEM are returned, using TARGET if possible.
-   Since this instructionn is an acquire barrier only, stronger memory
+   Since this instruction is an acquire barrier only, stronger memory
    models may require additional barriers to be emitted.  */
 
 static rtx
@@ -6572,7 +6572,7 @@ maybe_optimize_fetch_op (rtx target, rtx mem, rtx val, enum rtx_code code,
   return NULL_RTX;
 }
 
-/* Try to emit an instruction for a specific operation varaition. 
+/* Try to emit an instruction for a specific operation variation.
    OPTAB contains the OP functions.
    TARGET is an optional place to return the result. const0_rtx means unused.
    MEM is the memory location to operate on.
@@ -6675,7 +6675,7 @@ expand_atomic_fetch_op_no_fallback (rtx target, rtx mem, rtx val,
       if (result)
         return result;
 
-      /* Next try the old style withuot a memory model.  */
+      /* Next try the old style without a memory model.  */
       result = maybe_emit_op (&optab, target, mem, val, false, model, true);
       if (result)
         return result;
diff --git a/gcc/opts.c b/gcc/opts.c
index ffedb10..eead6ec 100644
--- a/gcc/opts.c
+++ b/gcc/opts.c
@@ -927,7 +927,7 @@ finish_options (struct gcc_options *opts, struct gcc_options *opts_set,
 	}
     }
 
-  /* Tune vectorization related parametees according to cost model.  */
+  /* Tune vectorization related parameters according to cost model.  */
   if (opts->x_flag_vect_cost_model == VECT_COST_MODEL_CHEAP)
     {
       maybe_set_param_value (PARAM_VECT_MAX_VERSION_FOR_ALIAS_CHECKS,
diff --git a/gcc/params.def b/gcc/params.def
index 6b07518..e88bb8f 100644
--- a/gcc/params.def
+++ b/gcc/params.def
@@ -35,7 +35,7 @@ along with GCC; see the file COPYING3.  If not see
      - The maximum acceptable value for the parameter (if greater than
      the minimum).
 
-   The DEFPARAMENUM<N> macro is similar, but instead of the minumum and maximum
+   The DEFPARAMENUM<N> macro is similar, but instead of the minimum and maximum
    arguments, it contains a list of <N> allowed strings, corresponding to
    integer values 0..<N>-1.  Note that the default argument needs to be
    specified as one of the allowed strings, rather than an integer value.
@@ -268,7 +268,7 @@ DEFPARAM(PARAM_MAX_HOIST_DEPTH,
 	 30, 0, 0)
 
 
-/* When synthesizing expnonentiation by a real constant operations using square
+/* When synthesizing exponentiation by a real constant operations using square
    roots, this controls how deep sqrt chains we are willing to generate.  */
 DEFPARAM(PARAM_MAX_POW_SQRT_DEPTH,
 	 "max-pow-sqrt-depth",
diff --git a/gcc/passes.c b/gcc/passes.c
index 64493ba..cf7f26c 100644
--- a/gcc/passes.c
+++ b/gcc/passes.c
@@ -73,7 +73,7 @@ opt_pass *current_pass;
    need to implement cloning, but passes that support multiple instances
    *must* provide their own implementation of the clone method.
 
-   Handle this by providing a default implemenation, but make it a fatal
+   Handle this by providing a default implementation, but make it a fatal
    error to call it.  */
 
 opt_pass *
@@ -1520,7 +1520,7 @@ pass_manager::register_pass (struct register_pass_info *pass_info)
    compile ()
        ipa_passes () 			-> all_small_ipa_passes
 					-> Analysis of all_regular_ipa_passes
-	* possible LTO streaming at copmilation time *
+	* possible LTO streaming at compilation time *
 					-> Execution of all_regular_ipa_passes
 	* possible LTO streaming at link time *
 					-> all_late_ipa_passes
diff --git a/gcc/postreload-gcse.c b/gcc/postreload-gcse.c
index cbc0df2..579b593 100644
--- a/gcc/postreload-gcse.c
+++ b/gcc/postreload-gcse.c
@@ -1369,7 +1369,7 @@ gcse_after_reload_main (rtx f ATTRIBUTE_UNUSED)
 
   if (expr_table->elements () > 0)
     {
-      /* Knowing which MEMs are transparent through a block can signifiantly
+      /* Knowing which MEMs are transparent through a block can significantly
 	 increase the number of redundant loads found.  So compute transparency
 	 information for each memory expression in the hash table.  */
       df_analyze ();
diff --git a/gcc/predict.c b/gcc/predict.c
index ac35fa4..0dc02b4 100644
--- a/gcc/predict.c
+++ b/gcc/predict.c
@@ -1097,7 +1097,7 @@ combine_predictions_for_bb (basic_block bb, bool dry_run)
      The only approximation is to equally distribute 1-p1 to all edges
      different from b1.
 
-     According to numbers we've got from SPEC2006 benchark, there's only
+     According to numbers we've got from SPEC2006 benchmark, there's only
      one interesting reliable predictor (noreturn call), which can be
      handled with a bit easier approach.  */
   if (nedges != 2)
@@ -2520,7 +2520,7 @@ is_exit_with_zero_arg (const gimple *stmt)
       && !gimple_call_builtin_p (stmt, BUILT_IN__EXIT2))
     return false;
 
-  /* Argument is an interger zero. */
+  /* Argument is an integer zero. */
   return integer_zerop (gimple_call_arg (stmt, 0));
 }
 
@@ -2890,7 +2890,7 @@ predict_paths_for_bb (basic_block cur, basic_block bb,
 	 using predictor.  Otherwise we need to look for paths
 	 leading to e->src.
 
-	 The second may lead to infinite loop in the case we are predicitng
+	 The second may lead to infinite loop in the case we are predicting
 	 regions that are only reachable by abnormal edges.  We simply
 	 prevent visiting given BB twice.  */
       if (found)
@@ -3640,7 +3640,7 @@ make_pass_strip_predict_hints (gcc::context *ctxt)
 
 /* Rebuild function frequencies.  Passes are in general expected to
    maintain profile by hand, however in some cases this is not possible:
-   for example when inlining several functions with loops freuqencies might run
+   for example when inlining several functions with loops frequencies might run
    out of scale and thus needs to be recomputed.  */
 
 void
@@ -3681,7 +3681,7 @@ rebuild_frequencies (void)
   timevar_pop (TV_REBUILD_FREQUENCIES);
 }
 
-/* Perform a dry run of the branch prediction pass and report comparsion of
+/* Perform a dry run of the branch prediction pass and report comparison of
    the predicted and real profile into the dump file.  */
 
 void
@@ -3745,7 +3745,7 @@ force_edge_cold (edge e, bool impossible)
 	prob_sum += e2->probability;
       }
 
-  /* If there are other edges out of e->src, redistribute probabilitity
+  /* If there are other edges out of e->src, redistribute probability
      there.  */
   if (prob_sum)
     {
@@ -3780,10 +3780,10 @@ force_edge_cold (edge e, bool impossible)
     {
       e->probability = REG_BR_PROB_BASE;
 
-      /* If we did not adjusting, the source basic block has no likely edeges
+      /* If we did not adjusting, the source basic block has no likely edges
  	 leaving other direction. In that case force that bb cold, too.
 	 This in general is difficult task to do, but handle special case when
-	 BB has only one predecestor.  This is common case when we are updating
+	 BB has only one predecessor.  This is common case when we are updating
 	 after loop transforms.  */
       if (!prob_sum && !count_sum && single_pred_p (e->src)
 	  && e->src->frequency > (impossible ? 0 : 1))
diff --git a/gcc/predict.def b/gcc/predict.def
index fcda6c4..b78a35b 100644
--- a/gcc/predict.def
+++ b/gcc/predict.def
@@ -120,7 +120,7 @@ DEF_PREDICTOR (PRED_CALL, "call", HITRATE (67), 0)
 
 /* PRED_CALL is not very reliable predictor and it turns out to be even
    less reliable for indirect calls and polymorphic calls.  For spec2k6
-   the predictio nis slightly in the direction of taking the call.  */
+   the prediction is slightly in the direction of taking the call.  */
 DEF_PREDICTOR (PRED_INDIR_CALL, "indirect call", HITRATE (86), 0)
 DEF_PREDICTOR (PRED_POLYMORPHIC_CALL, "polymorphic call", HITRATE (59), 0)
 
diff --git a/gcc/pretty-print.c b/gcc/pretty-print.c
index 570dec7..e58436f 100644
--- a/gcc/pretty-print.c
+++ b/gcc/pretty-print.c
@@ -184,7 +184,7 @@ pp_write_text_as_dot_label_to_stream (pretty_printer *pp, bool for_record)
 	/* The following characters always have to be escaped
 	   for use in labels.  */
 	case '\\':
-	  /* There is a bug in some (f.i. 2.36.0) versions of graphiz
+	  /* There is a bug in some (f.i. 2.36.0) versions of graphviz
 	     ( http://www.graphviz.org/mantisbt/view.php?id=2524 ) related to
 	     backslash as last char in label.  Let's avoid triggering it.  */
 	  gcc_assert (*(p + 1) != '\0');
diff --git a/gcc/print-rtl.c b/gcc/print-rtl.c
index 20bdafd..b683452 100644
--- a/gcc/print-rtl.c
+++ b/gcc/print-rtl.c
@@ -114,7 +114,7 @@ uses_rtx_reuse_p (const_rtx x)
     }
 }
 
-/* Traverse X and its descendents, determining if we see any rtx more than
+/* Traverse X and its descendants, determining if we see any rtx more than
    once.  Any rtx suitable for "reuse_rtx" that is seen more than once is
    assigned an ID.  */
 
@@ -481,7 +481,7 @@ rtx_writer::print_rtx_operand_code_r (const_rtx in_rtx)
     else if (m_compact)
       {
 	/* In compact mode, print pseudos with '< and '>' wrapping the regno,
-	   offseting it by (LAST_VIRTUAL_REGISTER + 1), so that the
+	   offsetting it by (LAST_VIRTUAL_REGISTER + 1), so that the
 	   first non-virtual pseudo is dumped as "<0>".  */
 	gcc_assert (regno > LAST_VIRTUAL_REGISTER);
 	fprintf (m_outfile, " <%d>", regno - (LAST_VIRTUAL_REGISTER + 1));
diff --git a/gcc/print-rtl.h b/gcc/print-rtl.h
index eee949a..170f65a 100644
--- a/gcc/print-rtl.h
+++ b/gcc/print-rtl.h
@@ -125,7 +125,7 @@ extern void print_rtx_function (FILE *file, function *fn, bool compact);
    Dumping with reuse-support is done in two passes:
 
    (a) a first pass in which "preprocess" is called on each top-level rtx
-       to be seen in the dump.  This traverses the rtx and its descendents,
+       to be seen in the dump.  This traverses the rtx and its descendants,
        identifying rtx that will be seen more than once in the actual dump,
        and assigning them reuse IDs.
 
diff --git a/gcc/profile.c b/gcc/profile.c
index 3346af4..5a8375a 100644
--- a/gcc/profile.c
+++ b/gcc/profile.c
@@ -227,7 +227,7 @@ get_working_sets (void)
           if (ws_ix == NUM_GCOV_WORKING_SETS - 1)
             pct = 9990;
           ws_info = &gcov_working_sets[ws_ix];
-          /* Print out the percentage using int arithmatic to avoid float.  */
+          /* Print out the percentage using int arithmetic to avoid float.  */
           fprintf (dump_file, "\t\t%u.%02u%%: num counts=%u, min counter="
                    "%" PRId64 "\n",
                    pct / 100, pct - (pct / 100 * 100),
diff --git a/gcc/read-md.h b/gcc/read-md.h
index fea7011..5a79679 100644
--- a/gcc/read-md.h
+++ b/gcc/read-md.h
@@ -254,7 +254,7 @@ class md_reader
   int m_last_line;
 };
 
-/* Global singleton; constrast with rtx_reader_ptr below.  */
+/* Global singleton; contrast with rtx_reader_ptr below.  */
 extern md_reader *md_reader_ptr;
 
 /* An md_reader subclass which skips unknown directives, for
@@ -303,7 +303,7 @@ class rtx_reader : public md_reader
   auto_vec<rtx> m_reuse_rtx_by_id;
 };
 
-/* Global singleton; constrast with md_reader_ptr above.  */
+/* Global singleton; contrast with md_reader_ptr above.  */
 extern rtx_reader *rtx_reader_ptr;
 
 extern void (*include_callback) (const char *);
diff --git a/gcc/real.c b/gcc/real.c
index a5671b2..2ddfe5a8d 100644
--- a/gcc/real.c
+++ b/gcc/real.c
@@ -3111,7 +3111,7 @@ const struct real_format motorola_single_format =
       - Denormals can be represented, but are treated as +0.0 when
 	used as an operand and are never generated as a result.
       - -0.0 can be represented, but a zero result is always +0.0.
-      - the only supported rounding mode is trunction (towards zero).  */
+      - the only supported rounding mode is truncation (towards zero).  */
 const struct real_format spu_single_format =
   {
     encode_ieee_single,
diff --git a/gcc/reg-notes.def b/gcc/reg-notes.def
index 8734d26..1c42651 100644
--- a/gcc/reg-notes.def
+++ b/gcc/reg-notes.def
@@ -167,7 +167,7 @@ REG_CFA_NOTE (CFA_VAL_EXPRESSION)
 REG_CFA_NOTE (CFA_RESTORE)
 
 /* Attached to insns that are RTX_FRAME_RELATED_P, marks insn that sets
-   vDRAP from DRAP.  If vDRAP is a register, vdrap_reg is initalized
+   vDRAP from DRAP.  If vDRAP is a register, vdrap_reg is initialized
    to the argument, if it is a MEM, it is ignored.  */
 REG_CFA_NOTE (CFA_SET_VDRAP)
 
diff --git a/gcc/reginfo.c b/gcc/reginfo.c
index a7df02d..24fc3ec 100644
--- a/gcc/reginfo.c
+++ b/gcc/reginfo.c
@@ -888,7 +888,7 @@ reg_allocno_class (int regno)
 
 
 
-/* Allocate space for reg info and initilize it.  */
+/* Allocate space for reg info and initialize it.  */
 static void
 allocate_reg_info (void)
 {
diff --git a/gcc/reload.c b/gcc/reload.c
index 8074e54..cea2513 100644
--- a/gcc/reload.c
+++ b/gcc/reload.c
@@ -6105,7 +6105,7 @@ find_reloads_address_part (rtx x, rtx *loc, enum reg_class rclass,
 }
 
 /* X, a subreg of a pseudo, is a part of an address that needs to be
-   reloaded, and the pseusdo is equivalent to a memory location.
+   reloaded, and the pseudo is equivalent to a memory location.
 
    Attempt to replace the whole subreg by a (possibly narrower or wider)
    memory reference.  If this is possible, return this new memory
diff --git a/gcc/reload1.c b/gcc/reload1.c
index e993749..7f14dbd 100644
--- a/gcc/reload1.c
+++ b/gcc/reload1.c
@@ -742,7 +742,7 @@ will_delete_init_insn_p (rtx_insn *insn)
    so any pseudo reg that is spilled must go to the stack.
 
    Return value is TRUE if reload likely left dead insns in the
-   stream and a DCE pass should be run to elimiante them.  Else the
+   stream and a DCE pass should be run to eliminate them.  Else the
    return value is FALSE.  */
 
 bool
diff --git a/gcc/resource.c b/gcc/resource.c
index 95911c5..c5be881 100644
--- a/gcc/resource.c
+++ b/gcc/resource.c
@@ -374,7 +374,7 @@ mark_referenced_resources (rtx x, struct resources *res,
       /* In addition to the usual references, also consider all outputs
 	 as referenced, to compensate for mark_set_resources treating
 	 them as killed.  This is similar to ZERO_EXTRACT / STRICT_LOW_PART
-	 handling, execpt that we got a partial incidence instead of a partial
+	 handling, except that we got a partial incidence instead of a partial
 	 width.  */
       mark_set_resources (x, res, 0,
 			  include_delayed_effects
@@ -1011,7 +1011,7 @@ mark_target_live_regs (rtx_insn *insns, rtx target_maybe_return, struct resource
 	  if (CALL_P (real_insn))
 	    {
 	      /* Values in call-clobbered registers survive a COND_EXEC CALL
-		 if that is not executed; this matters for resoure use because
+		 if that is not executed; this matters for resource use because
 		 they may be used by a complementarily (or more strictly)
 		 predicated instruction, or if the CALL is NORETURN.  */
 	      if (GET_CODE (PATTERN (real_insn)) != COND_EXEC)
diff --git a/gcc/rtl.def b/gcc/rtl.def
index 4c2607a..01cdeb6 100644
--- a/gcc/rtl.def
+++ b/gcc/rtl.def
@@ -1311,11 +1311,11 @@ DEF_RTL_EXPR(COND, "cond", "Ee", RTX_EXTRA)
    that match the substitution pattern.
 
    Operand:
-   0: The name of the substitition template.
+   0: The name of the substitution template.
    1: Input template to match to see if a substitution is applicable.
    2: A C expression giving an additional condition for the generated
       new define_expand or define_insn.
-   3: Output tempalate to generate via substitution.
+   3: Output template to generate via substitution.
 
    Within a DEFINE_SUBST template, the meaning of some RTL expressions is
    different from their usual interpretation: a MATCH_OPERAND matches any
@@ -1335,7 +1335,7 @@ DEF_RTL_EXPR(DEFINE_SUBST, "define_subst", "sEsE", RTX_EXTRA)
       name, for the case that the DEFINE_SUBST is not applied (i.e. the
       unmodified version of the pattern).
    3: String to substitute for the subst-attribute name in the pattern
-      name, for the case that the DEFINE_SUBST is applied to the patten.
+      name, for the case that the DEFINE_SUBST is applied to the pattern.
       
    The use of DEFINE_SUBST and DEFINE_SUBST_ATTR is explained in the
    GCC internals manual, under "RTL Templates Transformations".  */
diff --git a/gcc/sanopt.c b/gcc/sanopt.c
index 70b7aeb..b129169 100644
--- a/gcc/sanopt.c
+++ b/gcc/sanopt.c
@@ -533,7 +533,7 @@ sanopt_optimize_walker (basic_block bb, struct sanopt_ctx *ctx)
       if (!is_gimple_call (stmt))
 	{
 	  /* Handle asm volatile or asm with "memory" clobber
-	     the same as potentionally freeing call.  */
+	     the same as potentially freeing call.  */
 	  gasm *asm_stmt = dyn_cast <gasm *> (stmt);
 	  if (asm_stmt
 	      && asan_check_optimize
diff --git a/gcc/sched-deps.c b/gcc/sched-deps.c
index b2393bf..75422a2 100644
--- a/gcc/sched-deps.c
+++ b/gcc/sched-deps.c
@@ -2728,7 +2728,7 @@ sched_analyze_2 (struct deps_desc *deps, rtx x, rtx_insn *insn)
 	 a jump insn which usually generates MOVE_BARRIER preventing
 	 to move insns containing registers or memories through the
 	 barrier.  It is also wrong with generated code performance
-	 point of view as prefetch withouth dependecies will have a
+	 point of view as prefetch without dependencies will have a
 	 tendency to be issued later instead of earlier.  It is hard
 	 to generate accurate dependencies for prefetch insns as
 	 prefetch has only the start address but it is better to have
@@ -4703,7 +4703,7 @@ attempt_change (struct mem_inc_info *mii, rtx new_addr)
 
 /* Return true if INSN is of a form "a = b op c" where a and b are
    regs.  op is + if c is a reg and +|- if c is a const.  Fill in
-   informantion in MII about what is found.
+   information in MII about what is found.
    BEFORE_MEM indicates whether the increment is found before or after
    a corresponding memory reference.  */
 
diff --git a/gcc/sel-sched-dump.c b/gcc/sel-sched-dump.c
index 388a8af..eb6fefa 100644
--- a/gcc/sel-sched-dump.c
+++ b/gcc/sel-sched-dump.c
@@ -590,7 +590,7 @@ sel_print_insn (const rtx_insn *insn, int aligned ATTRIBUTE_UNUSED)
 /* Functions for pretty printing of CFG.  */
 /* FIXME: Using pretty-print here could simplify this stuff.  */
 
-/* Replace all occurencies of STR1 to STR2 in BUF.
+/* Replace all occurrences of STR1 to STR2 in BUF.
    The BUF must be large enough to hold the result.  */
 static void
 replace_str_in_buf (char *buf, const char *str1, const char *str2)
@@ -711,7 +711,7 @@ sel_dump_cfg_edge (FILE *f, edge e)
 }
 
 
-/* Return true if BB has a predesessor from current region.
+/* Return true if BB has a predecessor from current region.
    TODO: Either make this function to trace back through empty block
    or just remove those empty blocks.  */
 static bool
diff --git a/gcc/sel-sched-ir.h b/gcc/sel-sched-ir.h
index 76ec10d..ea3d52d 100644
--- a/gcc/sel-sched-ir.h
+++ b/gcc/sel-sched-ir.h
@@ -405,7 +405,7 @@ struct _list_iterator
   /* The list we're iterating.  */
   _list_t *lp;
 
-  /* True when this iterator supprts removing.  */
+  /* True when this iterator supports removing.  */
   bool can_remove_p;
 
   /* True when we've actually removed something.  */
@@ -744,7 +744,7 @@ struct _sel_insn_data
   /* A hashtable caching the result of insn transformations through this one.  */
   htab_t transformed_insns;
 
-  /* A context incapsulating this insn.  */
+  /* A context encapsulating this insn.  */
   struct deps_desc deps_context;
 
   /* This field is initialized at the beginning of scheduling and is used
@@ -1007,7 +1007,7 @@ struct succ_iterator
 /* A structure returning all successor's information.  */
 struct succs_info
 {
-  /* Flags that these succcessors were computed with.  */
+  /* Flags that these successors were computed with.  */
   short flags;
 
   /* Successors that correspond to the flags.  */
diff --git a/gcc/sel-sched.c b/gcc/sel-sched.c
index 708d088..cb39a35 100644
--- a/gcc/sel-sched.c
+++ b/gcc/sel-sched.c
@@ -460,7 +460,7 @@ flist_t fences;
 static bool enable_schedule_as_rhs_p;
 
 /* Used in verify_target_availability to assert that target reg is reported
-   unavailabile by both TARGET_UNAVAILABLE and find_used_regs only if
+   unavailable by both TARGET_UNAVAILABLE and find_used_regs only if
    we haven't scheduled anything on the previous fence.
    if scheduled_something_on_previous_fence is true, TARGET_UNAVAILABLE can
    have more conservative value than the one returned by the
@@ -529,7 +529,7 @@ static bitmap code_motion_visited_blocks = NULL;
 /* The number of bookkeeping copies created.  */
 static int stat_bookkeeping_copies;
 
-/* The number of insns that required bookkeeiping for their scheduling.  */
+/* The number of insns that required bookkeeping for their scheduling.  */
 static int stat_insns_needed_bookkeeping;
 
 /* The number of insns that got renamed.  */
@@ -1738,7 +1738,7 @@ find_best_reg_for_expr (expr_t expr, blist_t bnds, bool *is_orig_reg_p)
 }
 
 
-/* Return true if dependence described by DS can be overcomed.  */
+/* Return true if dependence described by DS can be overcome.  */
 static bool
 can_speculate_dep_p (ds_t ds)
 {
@@ -2149,7 +2149,7 @@ moveup_expr (expr_t expr, insn_t through_insn, bool inside_insn_group,
      insn is pulled ahead of it.  It's hard to figure out how to
      introduce such a notion in sel-sched, but it already fails to
      support debug insns in other ways, so we just go ahead and
-     let the deug insns go corrupt for now.  */
+     let the debug insns go corrupt for now.  */
   if (DEBUG_INSN_P (through_insn) && !DEBUG_INSN_P (insn))
     return MOVEUP_EXPR_SAME;
 
@@ -2536,7 +2536,7 @@ moveup_expr_cached (expr_t expr, insn_t insn, bool inside_insn_group)
        basic blocks.  */;
   else if (try_bitmap_cache (expr, insn, inside_insn_group, &res))
     /* When inside insn group, we do not want remove stores conflicting
-       with previosly issued loads.  */
+       with previously issued loads.  */
     got_answer = ! inside_insn_group || res != MOVEUP_EXPR_NULL;
   else if (try_transformation_cache (expr, insn, &res))
     got_answer = true;
@@ -3047,7 +3047,7 @@ propagate_lv_set (regset lv, insn_t insn)
   df_simulate_one_insn_backwards (BLOCK_FOR_INSN (insn), insn, lv);
 }
 
-/* Return livness set at the end of BB.  */
+/* Return liveness set at the end of BB.  */
 static regset
 compute_live_after_bb (basic_block bb)
 {
@@ -3156,7 +3156,7 @@ compute_live (insn_t insn)
     }
 
   /* We return LV to the pool, but will not clear it there.  Thus we can
-     legimatelly use LV till the next use of regset_pool_get ().  */
+     legitimately use LV till the next use of regset_pool_get ().  */
   return_regset_to_pool (lv);
   return lv;
 }
@@ -4715,7 +4715,7 @@ find_place_for_bookkeeping (edge e1, edge e2, fence_t *fence_to_rewind)
   return place_to_insert;
 }
 
-/* Find a proper seqno for bookkeeing insn inserted at PLACE_TO_INSERT
+/* Find a proper seqno for bookkeeping insn inserted at PLACE_TO_INSERT
    for JOIN_POINT.   */
 static int
 find_seqno_for_bookkeeping (insn_t place_to_insert, insn_t join_point)
@@ -5669,7 +5669,7 @@ update_and_record_unavailable_insns (basic_block book_block)
   rtx_insn *bb_end = sel_bb_end (book_block);
 
   /* First, get correct liveness in the bookkeeping block.  The problem is
-     the range between the bookeeping insn and the end of block.  */
+     the range between the bookkeeping insn and the end of block.  */
   update_liveness_on_insn (bb_end);
   if (control_flow_insn_p (bb_end))
     update_liveness_on_insn (PREV_INSN (bb_end));
@@ -5980,7 +5980,7 @@ remove_insn_from_stream (rtx_insn *insn, bool only_disconnect)
 
 /* This function is called when original expr is found.
    INSN - current insn traversed, EXPR - the corresponding expr found.
-   LPARAMS is the local parameters of code modion driver, STATIC_PARAMS
+   LPARAMS is the local parameters of code motion driver, STATIC_PARAMS
    is static parameters of move_op.  */
 static void
 move_op_orig_expr_found (insn_t insn, expr_t expr,
diff --git a/gcc/shrink-wrap.c b/gcc/shrink-wrap.c
index 1ac4ea3..79116b8 100644
--- a/gcc/shrink-wrap.c
+++ b/gcc/shrink-wrap.c
@@ -751,7 +751,7 @@ try_shrink_wrapping (edge *entry_edge, rtx_insn *prologue_seq)
   /* Now see if we can put the prologue at the start of PRO.  Putting it
      there might require duplicating a block that cannot be duplicated,
      or in some cases we cannot insert the prologue there at all.  If PRO
-     wont't do, try again with the immediate dominator of PRO, and so on.
+     won't do, try again with the immediate dominator of PRO, and so on.
 
      The blocks that need duplicating are those reachable from PRO but
      not dominated by it.  We keep in BB_WITH a bitmap of the blocks
@@ -974,7 +974,7 @@ try_shrink_wrapping (edge *entry_edge, rtx_insn *prologue_seq)
 	  handle_simple_exit (e);
 
   /* Finally, we want a single edge to put the prologue on.  Make a new
-     block before the PRO block; the edge beteen them is the edge we want.
+     block before the PRO block; the edge between them is the edge we want.
      Then redirect those edges into PRO that come from blocks without the
      prologue, to point to the new block instead.  The new prologue block
      is put at the end of the insn chain.  */
diff --git a/gcc/simplify-rtx.c b/gcc/simplify-rtx.c
index 7cab26a..a25d658 100644
--- a/gcc/simplify-rtx.c
+++ b/gcc/simplify-rtx.c
@@ -1440,7 +1440,7 @@ simplify_unary_operation_1 (enum rtx_code code, machine_mode mode, rtx op)
 	      else /* rcode == SIGN_EXTEND */
 		bits += GET_MODE_PRECISION (GET_MODE (XEXP (rhs, 0)));
 
-	      /* We can only widen multiplies if the result is mathematiclly
+	      /* We can only widen multiplies if the result is mathematically
 		 equivalent.  I.e. if overflow was impossible.  */
 	      if (bits <= GET_MODE_PRECISION (GET_MODE (op)))
 		return simplify_gen_binary
@@ -1577,7 +1577,7 @@ simplify_unary_operation_1 (enum rtx_code code, machine_mode mode, rtx op)
 	      else /* rcode == ZERO_EXTEND */
 		bits += GET_MODE_PRECISION (GET_MODE (XEXP (rhs, 0)));
 
-	      /* We can only widen multiplies if the result is mathematiclly
+	      /* We can only widen multiplies if the result is mathematically
 		 equivalent.  I.e. if overflow was impossible.  */
 	      if (bits <= GET_MODE_PRECISION (GET_MODE (op)))
 		return simplify_gen_binary
diff --git a/gcc/stringpool.h b/gcc/stringpool.h
index be3a057..6f59bcc 100644
--- a/gcc/stringpool.h
+++ b/gcc/stringpool.h
@@ -1,4 +1,4 @@
-/* Declarations and definitons for stringpool.c.
+/* Declarations and definitions for stringpool.c.
    Copyright (C) 2013-2017 Free Software Foundation, Inc.
 
 This file is part of GCC.
diff --git a/gcc/symbol-summary.h b/gcc/symbol-summary.h
index e672c81..8dc4575 100644
--- a/gcc/symbol-summary.h
+++ b/gcc/symbol-summary.h
@@ -76,7 +76,7 @@ public:
     m_released = true;
   }
 
-  /* Traverses all summarys with a function F called with
+  /* Traverses all summaries with a function F called with
      ARG as argument.  */
   template<typename Arg, bool (*f)(const T &, Arg)>
   void traverse (Arg a) const
@@ -305,7 +305,7 @@ public:
     m_released = true;
   }
 
-  /* Traverses all summarys with a function F called with
+  /* Traverses all summaries with a function F called with
      ARG as argument.  */
   template<typename Arg, bool (*f)(const T &, Arg)>
   void traverse (Arg a) const
diff --git a/gcc/symtab.c b/gcc/symtab.c
index 0145910..f69a2f1 100644
--- a/gcc/symtab.c
+++ b/gcc/symtab.c
@@ -729,7 +729,7 @@ symtab_node::remove_stmt_references (gimple *stmt)
 }
 
 /* Remove all stmt references in non-speculative references.
-   Those are not maintained during inlining & clonning.
+   Those are not maintained during inlining & cloning.
    The exception are speculative references that are updated along
    with callgraph edges associated with them.  */
 
@@ -1383,7 +1383,7 @@ symtab_node::ultimate_alias_target_1 (enum availability *availability,
      availability prevails the availability of its target (i.e. static alias of
      weak definition is available.
 
-     Transaparent alias is just alternative anme of a given symbol used within
+     Transaparent alias is just alternative name of a given symbol used within
      one compilation unit and is translated prior hitting the object file.  It
      inherits the visibility of its target.
      Weakref is a different animal (and noweak definition is weak).
@@ -1600,7 +1600,7 @@ symtab_node::set_init_priority (priority_type priority)
   h->init = priority;
 }
 
-/* Set fialization priority to PRIORITY.  */
+/* Set finalization priority to PRIORITY.  */
 
 void
 cgraph_node::set_fini_priority (priority_type priority)
@@ -1745,7 +1745,7 @@ symtab_node::noninterposable_alias (symtab_node *node, void *data)
   return false;
 }
 
-/* If node can not be overwriten by static or dynamic linker to point to
+/* If node can not be overwritten by static or dynamic linker to point to
    different definition, return NODE. Otherwise look for alias with such
    property and if none exists, introduce new one.  */
 
@@ -1845,7 +1845,7 @@ enum symbol_partitioning_class
 symtab_node::get_partitioning_class (void)
 {
   /* Inline clones are always duplicated.
-     This include external delcarations.   */
+     This include external declarations.   */
   cgraph_node *cnode = dyn_cast <cgraph_node *> (this);
 
   if (DECL_ABSTRACT_P (decl))
@@ -1945,7 +1945,7 @@ symtab_node::nonzero_address ()
 
   /* If target is defined and not extern, we know it will be output and thus
      it will bind to non-NULL.
-     Play safe for flag_delete_null_pointer_checks where weak definition maye
+     Play safe for flag_delete_null_pointer_checks where weak definition may
      be re-defined by NULL.  */
   if (definition && !DECL_EXTERNAL (decl)
       && (flag_delete_null_pointer_checks || !DECL_WEAK (decl)))
@@ -2004,7 +2004,7 @@ symtab_node::equal_address_to (symtab_node *s2, bool memory_accessed)
      code and are used only within speculation.  In this case we may make
      symbol equivalent to its alias even if interposition may break this
      rule.  Doing so will allow us to turn speculative inlining into
-     non-speculative more agressively.  */
+     non-speculative more aggressively.  */
   if (DECL_VIRTUAL_P (this->decl) && avail1 >= AVAIL_AVAILABLE)
     binds_local1 = true;
   if (DECL_VIRTUAL_P (s2->decl) && avail2 >= AVAIL_AVAILABLE)
@@ -2039,7 +2039,7 @@ symtab_node::equal_address_to (symtab_node *s2, bool memory_accessed)
   if (rs1->alias || rs2->alias)
     return -1;
 
-  /* If we have a non-interposale definition of at least one of the symbols
+  /* If we have a non-interposable definition of at least one of the symbols
      and the other symbol is different, we know other unit can not interpose
      it to the first symbol; all aliases of the definition needs to be 
      present in the current unit.  */
@@ -2060,7 +2060,7 @@ symtab_node::equal_address_to (symtab_node *s2, bool memory_accessed)
 
   /* TODO: Alias oracle basically assume that addresses of global variables
      are different unless they are declared as alias of one to another while
-     the code folding comparsions doesn't.
+     the code folding comparisons doesn't.
      We probably should be consistent and use this fact here, too, but for
      the moment return false only when we are called from the alias oracle.  */
 
diff --git a/gcc/target-hooks-macros.h b/gcc/target-hooks-macros.h
index 8e3e2af..7825014 100644
--- a/gcc/target-hooks-macros.h
+++ b/gcc/target-hooks-macros.h
@@ -52,7 +52,7 @@
    under the GPL, but not under the GFDL, put it in a comment above the hook
    definition.  If the function declaration is available both under GPL and
    GFDL, but the documentation is only available under the GFDL, put the
-   documentaton in tm.texi.in, heading with @hook <hookname> and closing
+   documentation in tm.texi.in, heading with @hook <hookname> and closing
    the paragraph with @end deftypefn / deftypevr as appropriate, and marking
    the next autogenerated hook with @hook <hookname>.
    In both these cases, leave the DOC string empty, i.e. "".
@@ -68,7 +68,7 @@
     A documentation string of "*" means not to emit any documentation at all,
    and is mainly used internally for DEFHOOK_UNDOC.  It should generally not
    be used otherwise, but it has its use for exceptional cases where automatic
-   documentation is not wanted, and the real documentation is elsewere, like
+   documentation is not wanted, and the real documentation is elsewhere, like
    for TARGET_ASM_{,UN}ALIGNED_INT_OP, which are hooks only for implementation
    purposes; they refer to structs, the components of which are documented as
    separate hooks TARGET_ASM_{,UN}ALIGNED_[HSDT]I_OP.
diff --git a/gcc/target.def b/gcc/target.def
index bd60484..9975cbc 100644
--- a/gcc/target.def
+++ b/gcc/target.def
@@ -708,7 +708,7 @@ nothing.",
  void, (void),
  hook_void_void)
 
-/* Output any boilerplace text needed at the end of a
+/* Output any boilerplate text needed at the end of a
    translation unit before debug and unwind info is emitted.  */
 DEFHOOK
 (code_end,
@@ -1510,7 +1510,7 @@ of instructions divided by the issue rate.",
  int, (struct ddg *g), NULL)
 
 /* The following member value is a function that initializes dispatch
-   schedling and adds instructions to dispatch window according to its
+   scheduling and adds instructions to dispatch window according to its
    parameters.  */
 DEFHOOK
 (dispatch_do,
@@ -1520,7 +1520,7 @@ void, (rtx_insn *insn, int x),
 hook_void_rtx_insn_int)
 
 /* The following member value is a a function that returns true is
-   dispatch schedling is supported in hardware and condition passed
+   dispatch scheduling is supported in hardware and condition passed
    as the second parameter is true.  */
 DEFHOOK
 (dispatch,
diff --git a/gcc/targhooks.c b/gcc/targhooks.c
index 1cdec06..40ed8f0 100644
--- a/gcc/targhooks.c
+++ b/gcc/targhooks.c
@@ -552,7 +552,7 @@ default_floatn_mode (int n, bool extended)
   return VOIDmode;
 }
 
-/* Make some target macros useable by target-independent code.  */
+/* Make some target macros usable by target-independent code.  */
 bool
 targhook_words_big_endian (void)
 {
@@ -1136,7 +1136,7 @@ default_builtin_vector_alignment_reachable (const_tree /*type*/, bool is_packed)
 }
 
 /* By default, assume that a target supports any factor of misalignment
-   memory access if it supports movmisalign patten.
+   memory access if it supports movmisalign pattern.
    is_packed is true if the memory access is defined in a packed struct.  */
 bool
 default_builtin_support_vector_misalignment (machine_mode mode,
diff --git a/gcc/trans-mem.c b/gcc/trans-mem.c
index f9809d5..dc49e1f 100644
--- a/gcc/trans-mem.c
+++ b/gcc/trans-mem.c
@@ -4450,7 +4450,7 @@ ipa_tm_scan_irr_block (basic_block bb)
   return false;
 }
 
-/* For each of the blocks seeded witin PQUEUE, walk the CFG looking
+/* For each of the blocks seeded within PQUEUE, walk the CFG looking
    for new irrevocable blocks, marking them in NEW_IRR.  Don't bother
    scanning past OLD_IRR or EXIT_BLOCKS.  */
 
diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c
index 6cb03ed..3f4dc80 100644
--- a/gcc/tree-cfg.c
+++ b/gcc/tree-cfg.c
@@ -2633,7 +2633,7 @@ stmt_starts_bb_p (gimple *stmt, gimple *prev_stmt)
 	  && gimple_code (prev_stmt) != GIMPLE_LABEL
 	  && (gimple_code (prev_stmt) != GIMPLE_CALL
 	      || ! gimple_call_internal_p (prev_stmt, IFN_PHI)))
-	/* PHI nodes start a new block unless preceeded by a label
+	/* PHI nodes start a new block unless preceded by a label
 	   or another PHI.  */
 	return true;
     }
@@ -7994,7 +7994,7 @@ gimple_block_ends_with_condjump_p (const_basic_block bb)
 
 
 /* Return true if statement T may terminate execution of BB in ways not
-   explicitly represtented in the CFG.  */
+   explicitly represented in the CFG.  */
 
 bool
 stmt_can_terminate_bb_p (gimple *t)
diff --git a/gcc/tree-cfgcleanup.c b/gcc/tree-cfgcleanup.c
index 94a172f..44888a1 100644
--- a/gcc/tree-cfgcleanup.c
+++ b/gcc/tree-cfgcleanup.c
@@ -558,7 +558,7 @@ remove_forwarder_block (basic_block bb)
       set_immediate_dominator (CDI_DOMINATORS, dest, dom);
     }
 
-  /* Adjust latch infomation of BB's parent loop as otherwise
+  /* Adjust latch information of BB's parent loop as otherwise
      the cfg hook has a hard time not to kill the loop.  */
   if (current_loops && bb->loop_father->latch == bb)
     bb->loop_father->latch = pred;
@@ -696,7 +696,7 @@ cleanup_tree_cfg_1 (void)
   /* Start by iterating over all basic blocks looking for edge removal
      opportunities.  Do this first because incoming SSA form may be
      invalid and we want to avoid performing SSA related tasks such
-     as propgating out a PHI node during BB merging in that state.  */
+     as propagating out a PHI node during BB merging in that state.  */
   n = last_basic_block_for_fn (cfun);
   for (i = NUM_FIXED_BLOCKS; i < n; i++)
     {
@@ -1020,7 +1020,7 @@ remove_forwarder_block_with_phi (basic_block bb)
 
   set_immediate_dominator (CDI_DOMINATORS, dest, dom);
 
-  /* Adjust latch infomation of BB's parent loop as otherwise
+  /* Adjust latch information of BB's parent loop as otherwise
      the cfg hook has a hard time not to kill the loop.  */
   if (current_loops && bb->loop_father->latch == bb)
     bb->loop_father->latch = pred;
diff --git a/gcc/tree-chkp-opt.c b/gcc/tree-chkp-opt.c
index a08f081..5196956 100644
--- a/gcc/tree-chkp-opt.c
+++ b/gcc/tree-chkp-opt.c
@@ -54,7 +54,7 @@ struct address_t
   vec<struct pol_item> pol;
 };
 
-/* Structure to hold check informtation.  */
+/* Structure to hold check information.  */
 struct check_info
 {
   /* Type of the check.  */
@@ -811,7 +811,7 @@ chkp_remove_excess_intersections (void)
     }
 }
 
-/*  Try to remove all checks which are known to alwyas pass.  */
+/*  Try to remove all checks which are known to always pass.  */
 static void
 chkp_remove_constant_checks (void)
 {
diff --git a/gcc/tree-chkp.c b/gcc/tree-chkp.c
index 2300e98..9f08258 100644
--- a/gcc/tree-chkp.c
+++ b/gcc/tree-chkp.c
@@ -1,4 +1,4 @@
-/* Pointer Bounds Checker insrumentation pass.
+/* Pointer Bounds Checker instrumentation pass.
    Copyright (C) 2014-2017 Free Software Foundation, Inc.
    Contributed by Ilya Enkovich (ilya.enkovich@intel.com)
 
@@ -671,7 +671,7 @@ chkp_completed_bounds (tree bounds)
   return chkp_completed_bounds_set->contains (bounds);
 }
 
-/* Clear comleted bound marks.  */
+/* Clear completed bound marks.  */
 static void
 chkp_erase_completed_bounds (void)
 {
@@ -708,7 +708,7 @@ chkp_incomplete_bounds (tree bounds)
   return chkp_incomplete_bounds_map->get (bounds) != NULL;
 }
 
-/* Clear incomleted bound marks.  */
+/* Clear incomplete bound marks.  */
 static void
 chkp_erase_incomplete_bounds (void)
 {
@@ -873,7 +873,7 @@ chkp_find_valid_phi_bounds (tree const &bounds, tree *slot, bool *res)
 }
 
 /* Helper function for chkp_finish_incomplete_bounds.
-   Marks all incompleted bounds as invalid.  */
+   Marks all incomplete bounds as invalid.  */
 bool
 chkp_mark_invalid_bounds_walker (tree const &bounds,
 				 tree *slot ATTRIBUTE_UNUSED,
@@ -889,11 +889,11 @@ chkp_mark_invalid_bounds_walker (tree const &bounds,
 
 /* When all bound phi nodes have all their args computed
    we have enough info to find valid bounds.  We iterate
-   through all incompleted bounds searching for valid
+   through all incomplete bounds searching for valid
    bounds.  Found valid bounds are marked as completed
-   and all remaining incompleted bounds are recomputed.
+   and all remaining incomplete bounds are recomputed.
    Process continues until no new valid bounds may be
-   found.  All remained incompleted bounds are marked as
+   found.  All remained incomplete bounds are marked as
    invalid (i.e. have no valid source of bounds).  */
 static void
 chkp_finish_incomplete_bounds (void)
@@ -995,7 +995,7 @@ chkp_set_bounds (tree node, tree val)
 
 /* Check if statically initialized variable VAR require
    static bounds initialization.  If VAR is added into
-   bounds initlization list then 1 is returned. Otherwise
+   bounds initialization list then 1 is returned. Otherwise
    return 0.  */
 extern bool
 chkp_register_var_initializer (tree var)
@@ -1020,7 +1020,7 @@ chkp_register_var_initializer (tree var)
 /* Helper function for chkp_finish_file.
 
    Add new modification statement (RHS is assigned to LHS)
-   into list of static initializer statementes (passed in ARG).
+   into list of static initializer statements (passed in ARG).
    If statements list becomes too big, emit checker constructor
    and start the new one.  */
 static void
@@ -1107,7 +1107,7 @@ chkp_output_static_bounds (tree bnd_var, tree var,
     }
 }
 
-/* Return entry block to be used for checker initilization code.
+/* Return entry block to be used for checker initialization code.
    Create new block if required.  */
 static basic_block
 chkp_get_entry_block (void)
@@ -1432,7 +1432,7 @@ chkp_check_upper (tree addr, tree bounds,
 }
 
 /* Generate lower and upper bound checks for memory access
-   to memory slot [FIRST, LAST] againsr BOUNDS.  Checks
+   to memory slot [FIRST, LAST] against BOUNDS.  Checks
    are inserted before the position pointed by ITER.
    DIRFLAG indicates whether memory access is load or store.  */
 void
@@ -1511,7 +1511,7 @@ chkp_build_component_ref (tree obj, tree field)
 
   /* If object is TMR then we do not use component_ref but
      add offset instead.  We need it to be able to get addr
-     of the reasult later.  */
+     of the result later.  */
   if (TREE_CODE (obj) == TARGET_MEM_REF)
     {
       tree offs = TMR_OFFSET (obj);
@@ -1541,7 +1541,7 @@ chkp_build_array_ref (tree arr, tree etype, tree esize,
 
   /* If object is TMR then we do not use array_ref but
      add offset instead.  We need it to be able to get addr
-     of the reasult later.  */
+     of the result later.  */
   if (TREE_CODE (arr) == TARGET_MEM_REF)
     {
       tree offs = TMR_OFFSET (arr);
@@ -1637,7 +1637,7 @@ chkp_find_bounds_for_elem (tree elem, tree *all_bounds,
 }
 
 /* Fill HAVE_BOUND output bitmap with information about
-   bounds requred for object of type TYPE.
+   bounds required for object of type TYPE.
 
    OFFS is used for recursive calls and holds basic
    offset of TYPE in outer structure in bits.
@@ -2153,7 +2153,7 @@ chkp_get_none_bounds (void)
 }
 
 /* Return bounds to be used as a result of operation which
-   should not create poiunter (e.g. MULT_EXPR).  */
+   should not create pointer (e.g. MULT_EXPR).  */
 static tree
 chkp_get_invalid_op_bounds (void)
 {
@@ -2920,7 +2920,7 @@ chkp_build_make_bounds_call (tree lower_bound, tree size)
 			  call, 2, lower_bound, size);
 }
 
-/* Create static bounds var of specfified OBJ which is
+/* Create static bounds var of specified OBJ which is
    is either VAR_DECL or string constant.  */
 static tree
 chkp_make_static_bounds (tree obj)
@@ -3217,7 +3217,7 @@ chkp_get_bounds_for_string_cst (tree cst)
   return bounds;
 }
 
-/* Generate code to instersect bounds BOUNDS1 and BOUNDS2 and
+/* Generate code to intersect bounds BOUNDS1 and BOUNDS2 and
    return the result.  if ITER is not NULL then Code is inserted
    before position pointed by ITER.  Otherwise code is added to
    entry block.  */
@@ -3269,7 +3269,7 @@ chkp_intersect_bounds (tree bounds1, tree bounds2, gimple_stmt_iterator *iter)
 }
 
 /* Return 1 if we are allowed to narrow bounds for addressed FIELD
-   and 0 othersize.  REF is reference to the field.  */
+   and 0 otherwise.  REF is reference to the field.  */
 
 static bool
 chkp_may_narrow_to_field (tree ref, tree field)
@@ -3358,7 +3358,7 @@ chkp_narrow_bounds_to_field (tree bounds, tree component,
 
 /* Parse field or array access NODE.
 
-   PTR ouput parameter holds a pointer to the outermost
+   PTR output parameter holds a pointer to the outermost
    object.
 
    BITFIELD output parameter is set to 1 if bitfield is
@@ -3610,7 +3610,7 @@ chkp_make_addressed_object_bounds (tree obj, gimple_stmt_iterator *iter)
 
    If PTR_SRC is not NULL_TREE then ITER points to statements which loads
    PTR.  If PTR is a any memory reference then ITER points to a statement
-   after which bndldx will be inserterd.  In both cases ITER will be updated
+   after which bndldx will be inserted.  In both cases ITER will be updated
    to point to the inserted bndldx statement.  */
 
 static tree
@@ -3782,7 +3782,7 @@ chkp_find_bounds_loaded (tree ptr, tree ptr_src, gimple_stmt_iterator *iter)
 /* Helper function which checks type of RHS and finds all pointers in
    it.  For each found pointer we build it's accesses in LHS and RHS
    objects and then call HANDLER for them.  Function is used to copy
-   or initilize bounds for copied object.  */
+   or initialize bounds for copied object.  */
 static void
 chkp_walk_pointer_assignments (tree lhs, tree rhs, void *arg,
 			       assign_handler handler)
@@ -3890,7 +3890,7 @@ chkp_copy_bounds_for_elem (tree lhs, tree rhs, void *arg)
   chkp_build_bndstx (addr, rhs, bounds, iter);
 }
 
-/* Emit static bound initilizers and size vars.  */
+/* Emit static bound initializers and size vars.  */
 void
 chkp_finish_file (void)
 {
diff --git a/gcc/tree-chrec.c b/gcc/tree-chrec.c
index 66d3a7b..fafcb28 100644
--- a/gcc/tree-chrec.c
+++ b/gcc/tree-chrec.c
@@ -1644,7 +1644,7 @@ scev_is_linear_expression (tree scev)
     }
 }
 
-/* Determines whether the expression CHREC contains only interger consts
+/* Determines whether the expression CHREC contains only integer consts
    in the right parts.  */
 
 bool
diff --git a/gcc/tree-core.h b/gcc/tree-core.h
index ea73477..844a102 100644
--- a/gcc/tree-core.h
+++ b/gcc/tree-core.h
@@ -153,8 +153,8 @@ enum built_in_class {
   BUILT_IN_NORMAL
 };
 
-/* Last marker used for LTO stremaing of built_in_class.  We can not add it
-   to the enum since we need the enumb to fit in 2 bits.  */
+/* Last marker used for LTO streaming of built_in_class.  We can not add it
+   to the enum since we need the enum to fit in 2 bits.  */
 #define BUILT_IN_LAST (BUILT_IN_NORMAL + 1)
 
 /* Codes that identify the various built in functions
diff --git a/gcc/tree-data-ref.c b/gcc/tree-data-ref.c
index d16bc36..fe0a2ad 100644
--- a/gcc/tree-data-ref.c
+++ b/gcc/tree-data-ref.c
@@ -1107,7 +1107,7 @@ create_data_ref (loop_p nest, loop_p loop, tree memref, gimple *stmt,
   return dr;
 }
 
-/*  A helper function computes order between two tree epxressions T1 and T2.
+/*  A helper function computes order between two tree expressions T1 and T2.
     This is used in comparator functions sorting objects based on the order
     of tree expressions.  The function returns -1, 0, or 1.  */
 
@@ -1266,7 +1266,7 @@ comp_dr_with_seg_len_pair (const void *pa_, const void *pb_)
    memory of store_ptr_0 cannot be between the memory of load_ptr_0 and
    load_ptr_1.)
 
-   we then can use only the following expression to finish the alising checks
+   we then can use only the following expression to finish the aliasing checks
    between store_ptr_0 & load_ptr_0 and store_ptr_0 & load_ptr_1:
 
    ((store_ptr_0 + store_segment_length_0) <= load_ptr_0)
@@ -1529,7 +1529,7 @@ create_intersect_range_checks_index (struct loop *loop, tree *cond_expr,
      by DR.  In other words, alias is checked if memory segment accessed by
      DR_A in some iterations intersect with memory segment accessed by DR_B
      in the same amount iterations.
-     Note segnment length is a linear function of number of iterations with
+     Note segment length is a linear function of number of iterations with
      DR_STEP as the coefficient.  */
   unsigned HOST_WIDE_INT niter_len1 = (seg_len1 + abs_step - 1) / abs_step;
   unsigned HOST_WIDE_INT niter_len2 = (seg_len2 + abs_step - 1) / abs_step;
diff --git a/gcc/tree-eh.c b/gcc/tree-eh.c
index fc016d7..fa36472 100644
--- a/gcc/tree-eh.c
+++ b/gcc/tree-eh.c
@@ -946,7 +946,7 @@ lower_try_finally_fallthru_label (struct leh_tf_state *tf)
   return label;
 }
 
-/* A subroutine of lower_try_finally.  If FINALLY consits of a
+/* A subroutine of lower_try_finally.  If FINALLY consists of a
    GIMPLE_EH_ELSE node, return it.  */
 
 static inline geh_else *
@@ -4228,7 +4228,7 @@ cleanup_empty_eh_merge_phis (basic_block new_bb, basic_block old_bb,
   for (ei = ei_start (old_bb->preds); (e = ei_safe_edge (ei)); )
     if (e->flags & EDGE_EH)
       {
-	/* ???  CFG manipluation routines do not try to update loop
+	/* ???  CFG manipulation routines do not try to update loop
 	   form on edge redirection.  Do so manually here for now.  */
 	/* If we redirect a loop entry or latch edge that will either create
 	   a multiple entry loop or rotate the loop.  If the loops merge
diff --git a/gcc/tree-if-conv.c b/gcc/tree-if-conv.c
index eb63795..67294df 100644
--- a/gcc/tree-if-conv.c
+++ b/gcc/tree-if-conv.c
@@ -674,7 +674,7 @@ struct ifc_dr {
 /* Iterates over DR's and stores refs, DR and base refs, DR pairs in
    HASH tables.  While storing them in HASH table, it checks if the
    reference is unconditionally read or written and stores that as a flag
-   information.  For base reference it checks if it is written atlest once
+   information.  For base reference it checks if it is written at least once
    unconditionally and stores it as flag information along with DR.
    In other words for every data reference A in STMT there exist other
    accesses to a data reference with the same base with predicates that
@@ -762,7 +762,7 @@ idx_within_array_bound (tree ref, tree *idx, void *dta)
       || !high || TREE_CODE (high) != INTEGER_CST)
     return false;
 
-  /* Check if the intial idx is within bound.  */
+  /* Check if the initial idx is within bound.  */
   if (wi::to_widest (init) < wi::to_widest (low)
       || wi::to_widest (init) > wi::to_widest (high))
     return false;
@@ -840,9 +840,9 @@ base_object_writable (tree ref)
    iteration unconditionally.
 
    Returns true for the memory reference in STMT, same memory reference
-   is read or written unconditionally atleast once and the base memory
+   is read or written unconditionally at least once and the base memory
    reference is written unconditionally once.  This is to check reference
-   will not write fault.  Also retuns true if the memory reference is
+   will not write fault.  Also returns true if the memory reference is
    unconditionally read once then we are conditionally writing to memory
    which is defined as read and write and is bound to the definition
    we are seeing.  */
@@ -880,7 +880,7 @@ ifcvt_memrefs_wont_trap (gimple *stmt, vec<data_reference_p> drs)
       if (DR_IS_READ (a))
 	return true;
 
-      /* an unconditionaly write won't trap if the base is written
+      /* an unconditional write won't trap if the base is written
          to unconditionally.  */
       if (base_master_dr
 	  && DR_BASE_W_UNCONDITIONALLY (*base_master_dr))
@@ -1826,7 +1826,7 @@ predicate_scalar_phi (gphi *phi, gimple_stmt_iterator *gsi)
 	}
       else
 	cond = bb_predicate (first_edge->src);
-      /* Gimplify the condition to a valid cond-expr conditonal operand.  */
+      /* Gimplify the condition to a valid cond-expr conditional operand.  */
       cond = force_gimple_operand_gsi_1 (gsi, unshare_expr (cond),
 					 is_gimple_condexpr, NULL_TREE,
 					 true, GSI_SAME_STMT);
@@ -1898,7 +1898,7 @@ predicate_scalar_phi (gphi *phi, gimple_stmt_iterator *gsi)
 	}
     }
 
-  /* Put element with max number of occurences to the end of ARGS.  */
+  /* Put element with max number of occurrences to the end of ARGS.  */
   if (max_ind != -1 && max_ind +1 != (int) args_len)
     std::swap (args[args_len - 1], args[max_ind]);
 
@@ -1919,7 +1919,7 @@ predicate_scalar_phi (gphi *phi, gimple_stmt_iterator *gsi)
 	  swap = true;
 	  cond = TREE_OPERAND (cond, 0);
 	}
-      /* Gimplify the condition to a valid cond-expr conditonal operand.  */
+      /* Gimplify the condition to a valid cond-expr conditional operand.  */
       cond = force_gimple_operand_gsi_1 (gsi, unshare_expr (cond),
 					 is_gimple_condexpr, NULL_TREE,
 					 true, GSI_SAME_STMT);
@@ -2561,7 +2561,7 @@ version_loop_for_if_conversion (struct loop *loop)
     saved_preds[i] = ifc_bbs[i]->aux;
 
   initialize_original_copy_tables ();
-  /* At this point we invalidate porfile confistency until IFN_LOOP_VECTORIZED
+  /* At this point we invalidate profile consistency until IFN_LOOP_VECTORIZED
      is re-merged in the vectorizer.  */
   new_loop = loop_version (loop, cond, &cond_bb,
 			   REG_BR_PROB_BASE, REG_BR_PROB_BASE,
diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c
index f3ec404..dfab70d 100644
--- a/gcc/tree-inline.c
+++ b/gcc/tree-inline.c
@@ -3531,7 +3531,7 @@ declare_return_variable (copy_body_data *id, tree return_slot, tree modify_dest,
 }
 
 /* Determine if the function can be copied.  If so return NULL.  If
-   not return a string describng the reason for failure.  */
+   not return a string describing the reason for failure.  */
 
 const char *
 copy_forbidden (struct function *fun)
@@ -5266,7 +5266,7 @@ replace_locals_op (tree *tp, int *walk_subtrees, void *data)
       /* Before the omplower pass completes, some OMP clauses can contain
 	 sequences that are neither copied by gimple_seq_copy nor walked by
 	 walk_gimple_seq.  To make copy_gimple_seq_and_replace_locals work even
-	 in those situations, we have to copy and process them explicitely.  */
+	 in those situations, we have to copy and process them explicitly.  */
 
       if (OMP_CLAUSE_CODE (expr) == OMP_CLAUSE_LASTPRIVATE)
 	{
diff --git a/gcc/tree-into-ssa.c b/gcc/tree-into-ssa.c
index d405637..c1226eb 100644
--- a/gcc/tree-into-ssa.c
+++ b/gcc/tree-into-ssa.c
@@ -347,7 +347,7 @@ get_ssa_name_ann (tree name)
   return info;
 }
 
-/* Return and allocate the auxiliar information for DECL.  */
+/* Return and allocate the auxiliary information for DECL.  */
 
 static inline var_info *
 get_var_info (tree decl)
@@ -380,7 +380,7 @@ clear_ssa_name_info (void)
 }
 
 
-/* Get access to the auxiliar information stored per SSA name or decl.  */
+/* Get access to the auxiliary information stored per SSA name or decl.  */
 
 static inline common_info *
 get_common_info (tree var)
@@ -2413,7 +2413,7 @@ public:
   /* opt_pass methods: */
   virtual bool gate (function *fun)
     {
-      /* Do nothing for funcions that was produced already in SSA form.  */
+      /* Do nothing for functions that was produced already in SSA form.  */
       return !(fun->curr_properties & PROP_ssa);
     }
 
@@ -3192,7 +3192,7 @@ insert_updated_phi_nodes_compare_uids (const void *a, const void *b)
    calling create_new_def_for to create new defs for names that the
    caller wants to replace.
 
-   The caller cretaes the new names to be inserted and the names that need
+   The caller creates the new names to be inserted and the names that need
    to be replaced by calling create_new_def_for for each old definition
    to be replaced.  Note that the function assumes that the
    new defining statement has already been inserted in the IL.
@@ -3352,7 +3352,7 @@ update_ssa (unsigned update_flags)
       statistics_counter_event (cfun, "Symbol to SSA rewrite", 1);
 
       /* If we rename bare symbols initialize the mapping to
-         auxiliar info we need to keep track of.  */
+         auxiliary info we need to keep track of.  */
       var_infos = new hash_table<var_info_hasher> (47);
 
       /* If we have to rename some symbols from scratch, we need to
diff --git a/gcc/tree-loop-distribution.c b/gcc/tree-loop-distribution.c
index a60454b..f5f29d3f 100644
--- a/gcc/tree-loop-distribution.c
+++ b/gcc/tree-loop-distribution.c
@@ -1400,7 +1400,7 @@ pg_add_dependence_edges (struct graph *rdg, vec<loop_p> loops, int dir,
 		std::swap (dr1, dr2);
 		this_dir = -this_dir;
 	      }
-	    /* Known dependences can still be unordered througout the
+	    /* Known dependences can still be unordered throughout the
 	       iteration space, see gcc.dg/tree-ssa/ldist-16.c.  */
 	    if (DDR_NUM_DIST_VECTS (ddr) != 1)
 	      this_dir = 2;
@@ -1868,7 +1868,8 @@ out:
   if (changed)
     {
       /* Destroy loop bodies that could not be reused.  Do this late as we
-	 otherwise can end up refering to stale data in control dependences.  */
+	 otherwise can end up referring to stale data in control
+	 dependences.  */
       unsigned i;
       FOR_EACH_VEC_ELT (loops_to_be_destroyed, i, loop)
 	  destroy_loop (loop);
diff --git a/gcc/tree-predcom.c b/gcc/tree-predcom.c
index 23e7870..e307167 100644
--- a/gcc/tree-predcom.c
+++ b/gcc/tree-predcom.c
@@ -2502,7 +2502,7 @@ tree_predictive_commoning_loop (struct loop *loop)
   if (dump_file && (dump_flags & TDF_DETAILS))
     fprintf (dump_file, "Processing loop %d\n",  loop->num);
 
-  /* Nothing for predicitive commoning if loop only iterates 1 time.  */
+  /* Nothing for predictive commoning if loop only iterates 1 time.  */
   if (get_max_loop_iterations_int (loop) == 0)
     {
       if (dump_file && (dump_flags & TDF_DETAILS))
diff --git a/gcc/tree-profile.c b/gcc/tree-profile.c
index a49ec37..3e5fe24 100644
--- a/gcc/tree-profile.c
+++ b/gcc/tree-profile.c
@@ -627,7 +627,7 @@ tree_profiling (void)
 	continue;
       /* Do not instrument extern inline functions when testing coverage.
 	 While this is not perfectly consistent (early inlined extern inlines
-	 will get acocunted), testsuite expects that.  */
+	 will get accounted), testsuite expects that.  */
       if (DECL_EXTERNAL (node->decl)
 	  && flag_test_coverage)
 	continue;
@@ -749,7 +749,7 @@ pass_ipa_tree_profile::gate (function *)
 {
   /* When profile instrumentation, use or test coverage shall be performed.
      But for AutoFDO, this there is no instrumentation, thus this pass is
-     diabled.  */
+     disabled.  */
   return (!in_lto_p && !flag_auto_profile
 	  && (flag_branch_probabilities || flag_test_coverage
 	      || profile_arc_flag));
diff --git a/gcc/tree-scalar-evolution.c b/gcc/tree-scalar-evolution.c
index 95f65b0..bc7c715 100644
--- a/gcc/tree-scalar-evolution.c
+++ b/gcc/tree-scalar-evolution.c
@@ -3316,7 +3316,7 @@ scev_reset (void)
 
    We do not use information whether TYPE can overflow so it is safe to
    use this test even for derived IVs not computed every iteration or
-   hypotetical IVs to be inserted into code.  */
+   hypothetical IVs to be inserted into code.  */
 
 bool
 iv_can_overflow_p (struct loop *loop, tree type, tree base, tree step)
@@ -3357,7 +3357,7 @@ iv_can_overflow_p (struct loop *loop, tree type, tree base, tree step)
   gcc_checking_assert (wi::ge_p (base_min, type_min, sgn)
 		       && wi::le_p (base_max, type_max, sgn));
 
-  /* Account the possible increment in the last ieration.  */
+  /* Account the possible increment in the last iteration.  */
   bool overflow = false;
   nit = wi::add (nit, 1, SIGNED, &overflow);
   if (overflow)
diff --git a/gcc/tree-sra.c b/gcc/tree-sra.c
index f25818f..51cf58e 100644
--- a/gcc/tree-sra.c
+++ b/gcc/tree-sra.c
@@ -403,7 +403,7 @@ static struct
   int deleted;
 
   /* Number of times sra_modify_assign has to deal with subaccesses of LHS and
-     RHS reparately due to type conversions or nonexistent matching
+     RHS separately due to type conversions or nonexistent matching
      references.  */
   int separate_lhs_rhs_handling;
 
@@ -2517,7 +2517,7 @@ child_would_conflict_in_lacc (struct access *lacc, HOST_WIDE_INT norm_offset,
    Return the new access or NULL if it cannot be created.  Note that this
    access is created long after all splicing and sorting, it's not located in
    any access vector and is automatically a representative of its group.  Set
-   the gpr_write flag of the new accesss if SET_GRP_WRITE is true.  */
+   the gpr_write flag of the new access if SET_GRP_WRITE is true.  */
 
 static struct access *
 create_artificial_child_access (struct access *parent, struct access *model,
@@ -3138,7 +3138,7 @@ sra_modify_expr (tree *expr, gimple_stmt_iterator *gsi, bool write)
 }
 
 /* Where scalar replacements of the RHS have been written to when a replacement
-   of a LHS of an assigments cannot be direclty loaded from a replacement of
+   of a LHS of an assignments cannot be directly loaded from a replacement of
    the RHS. */
 enum unscalarized_data_handling { SRA_UDH_NONE,  /* Nothing done so far. */
 				  SRA_UDH_RIGHT, /* Data flushed to the RHS. */
@@ -3391,7 +3391,7 @@ contains_vce_or_bfcref_p (const_tree ref)
 }
 
 /* Examine both sides of the assignment statement pointed to by STMT, replace
-   them with a scalare replacement if there is one and generate copying of
+   them with a scalar replacement if there is one and generate copying of
    replacements if scalarized aggregates have been used in the assignment.  GSI
    is used to hold generated statements for type conversions and subtree
    copying.  */
diff --git a/gcc/tree-ssa-address.c b/gcc/tree-ssa-address.c
index 8257fde..0fb020f 100644
--- a/gcc/tree-ssa-address.c
+++ b/gcc/tree-ssa-address.c
@@ -1000,7 +1000,7 @@ copy_ref_info (tree new_ref, tree old_ref)
 	      && !(TREE_CODE (new_ref) == TARGET_MEM_REF
 		   && (TMR_INDEX2 (new_ref)
 		       /* TODO: Below conditions can be relaxed if TMR_INDEX
-			  is an indcution variable and its initial value and
+			  is an induction variable and its initial value and
 			  step are aligned.  */
 		       || (TMR_INDEX (new_ref) && !TMR_STEP (new_ref))
 		       || (TMR_STEP (new_ref)
diff --git a/gcc/tree-ssa-alias.c b/gcc/tree-ssa-alias.c
index 74ee2b0..83a6d59 100644
--- a/gcc/tree-ssa-alias.c
+++ b/gcc/tree-ssa-alias.c
@@ -162,7 +162,7 @@ ptr_deref_may_alias_decl_p (tree ptr, tree decl)
      data-dependence analysis can feed us those.  */
   STRIP_NOPS (ptr);
 
-  /* Anything we do not explicilty handle aliases.  */
+  /* Anything we do not explicitly handle aliases.  */
   if ((TREE_CODE (ptr) != SSA_NAME
        && TREE_CODE (ptr) != ADDR_EXPR
        && TREE_CODE (ptr) != POINTER_PLUS_EXPR)
@@ -327,7 +327,7 @@ bool
 ptrs_compare_unequal (tree ptr1, tree ptr2)
 {
   /* First resolve the pointers down to a SSA name pointer base or
-     a VAR_DECL, PARM_DECL or RESULT_DECL.  This explicitely does
+     a VAR_DECL, PARM_DECL or RESULT_DECL.  This explicitly does
      not yet try to handle LABEL_DECLs, FUNCTION_DECLs, CONST_DECLs
      or STRING_CSTs which needs points-to adjustments to track them
      in the points-to sets.  */
diff --git a/gcc/tree-ssa-ccp.c b/gcc/tree-ssa-ccp.c
index f18f2e0..7c8323f 100644
--- a/gcc/tree-ssa-ccp.c
+++ b/gcc/tree-ssa-ccp.c
@@ -104,7 +104,7 @@ along with GCC; see the file COPYING3.  If not see
    precision of the type of the variable are always zero.  The
    uninteresting case is a variable of UNSIGNED type that has the
    maximum precision of the target.  Such variables can go to VARYING,
-   but this causes no loss of infomation since these variables will
+   but this causes no loss of information since these variables will
    never be extended.
 
    References:
diff --git a/gcc/tree-ssa-coalesce.c b/gcc/tree-ssa-coalesce.c
index e166314..8530cf7 100644
--- a/gcc/tree-ssa-coalesce.c
+++ b/gcc/tree-ssa-coalesce.c
@@ -187,11 +187,11 @@ coalesce_cost_edge (edge e)
 	if (e2 != e)
 	  {
 	    /* Putting code on EH edge that leads to BB
-	       with multiple predecestors imply splitting of
+	       with multiple predecessors imply splitting of
 	       edge too.  */
 	    if (mult < 2)
 	      mult = 2;
-	    /* If there are multiple EH predecestors, we
+	    /* If there are multiple EH predecessors, we
 	       also copy EH regions and produce separate
 	       landing pad.  This is expensive.  */
 	    if (e2->flags & EDGE_EH)
diff --git a/gcc/tree-ssa-dce.c b/gcc/tree-ssa-dce.c
index 9343249..43d4761 100644
--- a/gcc/tree-ssa-dce.c
+++ b/gcc/tree-ssa-dce.c
@@ -564,7 +564,7 @@ mark_all_reaching_defs_necessary_1 (ao_ref *ref ATTRIBUTE_UNUSED,
 	return false;
     }
 
-  /* We want to skip statments that do not constitute stores but have
+  /* We want to skip statements that do not constitute stores but have
      a virtual definition.  */
   if (is_gimple_call (def_stmt))
     {
@@ -684,7 +684,7 @@ propagate_necessity (bool aggressive)
 	     We need to mark control dependence of the empty basic blocks, since they
 	     contains computation of PHI operands.
 
-	     Doing so is too restrictive in the case the predecestor block is in
+	     Doing so is too restrictive in the case the predecessor block is in
 	     the loop. Consider:
 
 	      if (b)
@@ -697,7 +697,7 @@ propagate_necessity (bool aggressive)
 	      return j;
 
 	     There is PHI for J in the BB containing return statement.
-	     In this case the control dependence of predecestor block (that is
+	     In this case the control dependence of predecessor block (that is
 	     within the empty loop) also contains the block determining number
 	     of iterations of the block that would prevent removing of empty
 	     loop in this case.
@@ -727,12 +727,12 @@ propagate_necessity (bool aggressive)
 		   case 2 happens iff there is no other way from B to C except
 		   the edge B->C.
 
-		   There is other way from B to C iff there is succesor of B that
+		   There is other way from B to C iff there is successor of B that
 		   is not postdominated by B.  Testing this condition is somewhat
-		   expensive, because we need to iterate all succesors of B.
+		   expensive, because we need to iterate all successors of B.
 		   We are safe to assume that this does not happen: we will mark B
 		   as needed when processing the other path from B to C that is
-		   conrol dependent on B and marking control dependencies of B
+		   control dependent on B and marking control dependencies of B
 		   itself is harmless because they will be processed anyway after
 		   processing control statement in B.
 
@@ -1571,7 +1571,7 @@ perform_tree_ssa_dce (bool aggressive)
   calculate_dominance_info (CDI_DOMINATORS);
 
   /* Preheaders are needed for SCEV to work.
-     Simple lateches and recorded exits improve chances that loop will
+     Simple latches and recorded exits improve chances that loop will
      proved to be finite in testcases such as in loop-15.c and loop-24.c  */
   bool in_loop_pipeline = scev_initialized_p ();
   if (aggressive && ! in_loop_pipeline)
diff --git a/gcc/tree-ssa-dom.c b/gcc/tree-ssa-dom.c
index 494b472..308d9cb 100644
--- a/gcc/tree-ssa-dom.c
+++ b/gcc/tree-ssa-dom.c
@@ -546,7 +546,7 @@ pass_dominator::execute (function *fun)
   /* Fixup stmts that became noreturn calls.  This may require splitting
      blocks and thus isn't possible during the dominator walk or before
      jump threading finished.  Do this in reverse order so we don't
-     inadvertedly remove a stmt we want to fixup by visiting a dominating
+     inadvertently remove a stmt we want to fixup by visiting a dominating
      now noreturn call first.  */
   while (!need_noreturn_fixup.is_empty ())
     {
@@ -1326,7 +1326,7 @@ eliminate_redundant_computations (gimple_stmt_iterator* gsi,
    Detect and record those equivalences into AVAIL_EXPRS_STACK. 
 
    We handle only very simple copy equivalences here.  The heavy
-   lifing is done by eliminate_redundant_computations.  */
+   lifting is done by eliminate_redundant_computations.  */
 
 static void
 record_equivalences_from_stmt (gimple *stmt, int may_optimize_p,
diff --git a/gcc/tree-ssa-dse.c b/gcc/tree-ssa-dse.c
index 70c8b07..27f1912 100644
--- a/gcc/tree-ssa-dse.c
+++ b/gcc/tree-ssa-dse.c
@@ -83,7 +83,7 @@ enum dse_store_status
 
    Return TRUE if the the statement was analyzed, FALSE otherwise.
 
-   It is always safe to return FALSE.  But typically better optimziation
+   It is always safe to return FALSE.  But typically better optimization
    can be achieved by analyzing more statements.  */
 
 static bool
diff --git a/gcc/tree-ssa-forwprop.c b/gcc/tree-ssa-forwprop.c
index 5719b99..c8b44b5 100644
--- a/gcc/tree-ssa-forwprop.c
+++ b/gcc/tree-ssa-forwprop.c
@@ -2519,7 +2519,7 @@ pass_forwprop::execute (function *fun)
 
   /* Fixup stmts that became noreturn calls.  This may require splitting
      blocks and thus isn't possible during the walk.  Do this
-     in reverse order so we don't inadvertedly remove a stmt we want to
+     in reverse order so we don't inadvertently remove a stmt we want to
      fixup by visiting a dominating now noreturn call first.  */
   while (!to_fixup.is_empty ())
     {
diff --git a/gcc/tree-ssa-ifcombine.c b/gcc/tree-ssa-ifcombine.c
index 9d9c5ac..5d8cf9f 100644
--- a/gcc/tree-ssa-ifcombine.c
+++ b/gcc/tree-ssa-ifcombine.c
@@ -807,7 +807,7 @@ pass_tree_ifcombine::execute (function *fun)
 
      We walk the blocks in order that guarantees that a block with
      a single predecessor is processed after the predecessor.
-     This ensures that we collapse outter ifs before visiting the
+     This ensures that we collapse outer ifs before visiting the
      inner ones, and also that we do not try to visit a removed
      block.  This is opposite of PHI-OPT, because we cascade the
      combining rather than cascading PHIs. */
diff --git a/gcc/tree-ssa-live.c b/gcc/tree-ssa-live.c
index c77075e..1a3c9cb 100644
--- a/gcc/tree-ssa-live.c
+++ b/gcc/tree-ssa-live.c
@@ -411,7 +411,7 @@ remove_unused_scope_block_p (tree scope, bool in_ctor_dtor_block)
 
       /* Debug info of nested function refers to the block of the
 	 function.  We might stil call it even if all statements
-	 of function it was nested into was elliminated.
+	 of function it was nested into was eliminated.
 
 	 TODO: We can actually look into cgraph to see if function
 	 will be output to file.  */
diff --git a/gcc/tree-ssa-loop-im.c b/gcc/tree-ssa-loop-im.c
index c0e06bb..b305fbd 100644
--- a/gcc/tree-ssa-loop-im.c
+++ b/gcc/tree-ssa-loop-im.c
@@ -723,7 +723,7 @@ determine_max_movement (gimple *stmt, bool must_preserve_exec)
 
 	  /* We want to avoid unconditionally executing very expensive
 	     operations.  As costs for our dependencies cannot be
-	     negative just claim we are not invariand for this case.
+	     negative just claim we are not invariant for this case.
 	     We also are not sure whether the control-flow inside the
 	     loop will vanish.  */
 	  if (total_cost - min_cost >= 2 * LIM_EXPENSIVE
@@ -2205,7 +2205,7 @@ ref_indep_loop_p_1 (int safelen, struct loop *loop, im_mem_ref *ref,
       if (bitmap_set_bit (&ref->indep_loop, LOOP_DEP_BIT (loop->num, stored_p))
 	  && stored_p)
 	{
-	  /* If it's independend against all refs then it's independent
+	  /* If it's independent against all refs then it's independent
 	     against stores, too.  */
 	  bitmap_set_bit (&ref->indep_loop, LOOP_DEP_BIT (loop->num, false));
 	}
diff --git a/gcc/tree-ssa-loop-ivcanon.c b/gcc/tree-ssa-loop-ivcanon.c
index 31a4b32..a258d28 100644
--- a/gcc/tree-ssa-loop-ivcanon.c
+++ b/gcc/tree-ssa-loop-ivcanon.c
@@ -197,7 +197,7 @@ constant_after_peeling (tree op, gimple *stmt, struct loop *loop)
 }
 
 /* Computes an estimated number of insns in LOOP.
-   EXIT (if non-NULL) is an exite edge that will be eliminated in all but last
+   EXIT (if non-NULL) is an exit edge that will be eliminated in all but last
    iteration of the loop.
    EDGE_TO_CANCEL (if non-NULL) is an non-exit edge eliminated in the last iteration
    of loop.
@@ -442,7 +442,7 @@ loop_edge_to_cancel (struct loop *loop)
   edge edge_to_cancel;
   gimple_stmt_iterator gsi;
 
-  /* We want only one predecestor of the loop.  */
+  /* We want only one predecessor of the loop.  */
   if (EDGE_COUNT (loop->latch->preds) > 1)
     return NULL;
 
@@ -451,7 +451,7 @@ loop_edge_to_cancel (struct loop *loop)
   FOR_EACH_VEC_ELT (exits, i, edge_to_cancel)
     {
        /* Find the other edge than the loop exit
-          leaving the conditoinal.  */
+          leaving the conditional.  */
        if (EDGE_COUNT (edge_to_cancel->src->succs) != 2)
          continue;
        if (EDGE_SUCC (edge_to_cancel->src, 0) == edge_to_cancel)
@@ -670,7 +670,7 @@ unloop_loops (bitmap loop_closed_ssa_invalidated,
 /* Tries to unroll LOOP completely, i.e. NITER times.
    UL determines which loops we are allowed to unroll.
    EXIT is the exit of the loop that should be eliminated.
-   MAXITER specfy bound on number of iterations, -1 if it is
+   MAXITER specify bound on number of iterations, -1 if it is
    not known or too large for HOST_WIDE_INT.  The location
    LOCUS corresponding to the loop is used when emitting
    a summary of the unroll to the dump file.  */
@@ -780,7 +780,7 @@ try_unroll_loop_completely (struct loop *loop,
 	  <= ninsns + (size.constant_iv != false))
 	;
       /* We unroll only inner loops, because we do not consider it profitable
-	 otheriwse.  We still can cancel loopback edge of not rolling loop;
+	 otherwise.  We still can cancel loopback edge of not rolling loop;
 	 this is always a good idea.  */
       else if (ul == UL_NO_GROWTH)
 	{
@@ -814,7 +814,7 @@ try_unroll_loop_completely (struct loop *loop,
       /* If there is pure/const call in the function, then we
 	 can still optimize the unrolled loop body if it contains
 	 some other interesting code than the calls and code
-	 storing or cumulating the return value.  */
+	 storing or accumulating the return value.  */
       else if (size.num_pure_calls_on_hot_path
 	       /* One IV increment, one test, one ivtmp store
 		  and one useful stmt.  That is about minimal loop
diff --git a/gcc/tree-ssa-loop-ivopts.c b/gcc/tree-ssa-loop-ivopts.c
index c03d177..d037092 100644
--- a/gcc/tree-ssa-loop-ivopts.c
+++ b/gcc/tree-ssa-loop-ivopts.c
@@ -422,7 +422,7 @@ struct iv_cand
   bitmap inv_vars;	/* The list of invariant ssa_vars used in step of the
 			   iv_cand.  */
   bitmap inv_exprs;	/* If step is more complicated than a single ssa_var,
-			   hanlde it as a new invariant expression which will
+			   handle it as a new invariant expression which will
 			   be hoisted out of loop.  */
   struct iv *orig_iv;	/* The original iv if this cand is added from biv with
 			   smaller type.  */
@@ -473,7 +473,7 @@ struct iv_inv_expr_ent
 {
   /* Tree expression of the entry.  */
   tree expr;
-  /* Unique indentifier.  */
+  /* Unique identifier.  */
   int id;
   /* Hash value.  */
   hashval_t hash;
@@ -2550,13 +2550,13 @@ group_compare_offset (const void *a, const void *b)
    contains more than two uses with distinct addr_offsets.  Return
    false otherwise.  We want to split such groups because:
 
-     1) Small groups don't have much benefit and may interfer with
+     1) Small groups don't have much benefit and may interfere with
 	general candidate selection.
      2) Size for problem with only small groups is usually small and
 	general algorithm can handle it well.
 
    TODO -- Above claim may not hold when we want to merge memory
-   accesses with conseuctive addresses.  */
+   accesses with consecutive addresses.  */
 
 static bool
 split_small_address_groups_p (struct ivopts_data *data)
@@ -2956,7 +2956,7 @@ find_inv_vars (struct ivopts_data *data, tree *expr_p, bitmap *inv_vars)
    It's hard to make decision whether constant part should be stripped
    or not.  We choose to not strip based on below facts:
      1) We need to count ADD cost for constant part if it's stripped,
-	which is't always trivial where this functions is called.
+	which isn't always trivial where this functions is called.
      2) Stripping constant away may be conflict with following loop
 	invariant hoisting pass.
      3) Not stripping constant away results in more invariant exprs,
@@ -3812,7 +3812,7 @@ get_computation_aff_1 (struct loop *loop, gimple *at, struct iv_use *use,
 	  inner_type = TREE_TYPE (inner_base);
 	  /* If candidate is added from a biv whose type is smaller than
 	     ctype, we know both candidate and the biv won't overflow.
-	     In this case, it's safe to skip the convertion in candidate.
+	     In this case, it's safe to skip the conversion in candidate.
 	     As an example, (unsigned short)((unsigned long)A) equals to
 	     (unsigned short)A, if A has a type no larger than short.  */
 	  if (TYPE_PRECISION (inner_type) <= TYPE_PRECISION (uutype))
diff --git a/gcc/tree-ssa-loop-niter.c b/gcc/tree-ssa-loop-niter.c
index e67cd93..9adf2cb 100644
--- a/gcc/tree-ssa-loop-niter.c
+++ b/gcc/tree-ssa-loop-niter.c
@@ -286,7 +286,7 @@ refine_value_range_using_guard (tree type, tree var,
        2) cmp == LE_EXPR && offc0 < 0
 
 	    (varc0 + offc0) doesn't underflow
-	    && (varc1 + offc1 - offc0) doesn't overfloe
+	    && (varc1 + offc1 - offc0) doesn't overflow
 
 	  In this case, (varc0 + offc0) will never underflow if we can
 	  prove (varc1 + offc1 - offc0) doesn't overflow.
@@ -1155,7 +1155,7 @@ number_of_iterations_lt_to_ne (tree type, affine_iv *iv0, affine_iv *iv1,
      then the computation of the final value does not overflow.  There
      are three cases:
        1) The case if the new final value is equal to the current one.
-       2) Induction varaible has pointer type, as the code cannot rely
+       2) Induction variable has pointer type, as the code cannot rely
 	  on the object to that the pointer points being placed at the
 	  end of the address space (and more pragmatically,
 	  TYPE_{MIN,MAX}_VALUE is not defined for pointers).
@@ -3266,7 +3266,7 @@ idx_infer_loop_bounds (tree base, tree *idx, void *dta)
       && tree_int_cst_compare (next, high) <= 0)
     return true;
 
-  /* If access is not executed on every iteration, we must ensure that overlow
+  /* If access is not executed on every iteration, we must ensure that overflow
      may not make the access valid later.  */
   if (!dominated_by_p (CDI_DOMINATORS, loop->latch, gimple_bb (data->stmt))
       && scev_probably_wraps_p (NULL_TREE,
@@ -3428,7 +3428,7 @@ infer_loop_bounds_from_signedness (struct loop *loop, gimple *stmt)
   record_nonwrapping_iv (loop, base, step, stmt, low, high, false, true);
 }
 
-/* The following analyzers are extracting informations on the bounds
+/* The following analyzers are extracting information on the bounds
    of LOOP from the following undefined behaviors:
 
    - data references should not access elements over the statically
@@ -3632,7 +3632,7 @@ discover_iteration_bound_by_body_walk (struct loop *loop)
 	      if (entry && *entry < bound_index)
 		bound_index = *entry;
 
-	      /* Insert succesors into the queue, watch for latch edge
+	      /* Insert successors into the queue, watch for latch edge
 		 and record greatest index we saw.  */
 	      FOR_EACH_EDGE (e, ei, bb->succs)
 		{
@@ -3679,7 +3679,7 @@ discover_iteration_bound_by_body_walk (struct loop *loop)
 }
 
 /* See if every path cross the loop goes through a statement that is known
-   to not execute at the last iteration. In that case we can decrese iteration
+   to not execute at the last iteration. In that case we can decrease iteration
    count by 1.  */
 
 static void
@@ -4163,7 +4163,7 @@ n_of_executions_at_most (gimple *stmt,
 
 	  /* By stmt_dominates_stmt_p we already know that STMT appears
 	     before NITER_BOUND->STMT.  Still need to test that the loop
-	     can not be terinated by a side effect in between.  */
+	     can not be terminated by a side effect in between.  */
 	  for (bsi = gsi_for_stmt (stmt); gsi_stmt (bsi) != niter_bound->stmt;
 	       gsi_next (&bsi))
 	    if (gimple_has_side_effects (gsi_stmt (bsi)))
diff --git a/gcc/tree-ssa-loop-niter.h b/gcc/tree-ssa-loop-niter.h
index b009857..a7fd58a 100644
--- a/gcc/tree-ssa-loop-niter.h
+++ b/gcc/tree-ssa-loop-niter.h
@@ -1,4 +1,4 @@
-/* Header file for loop interation estimates.
+/* Header file for loop iteration estimates.
    Copyright (C) 2013-2017 Free Software Foundation, Inc.
 
 This file is part of GCC.
diff --git a/gcc/tree-ssa-loop-prefetch.c b/gcc/tree-ssa-loop-prefetch.c
index f5f2802..27c501c 100644
--- a/gcc/tree-ssa-loop-prefetch.c
+++ b/gcc/tree-ssa-loop-prefetch.c
@@ -131,7 +131,7 @@ along with GCC; see the file COPYING3.  If not see
       heuristic that disables prefetching in a loop if the prefetching
       cost is above a certain limit.  The relative prefetching cost is
       estimated by taking the ratio between the prefetch count and the
-      total intruction count (this models the I-cache cost).
+      total instruction count (this models the I-cache cost).
 
    The limits used in these heuristics are defined as parameters with
    reasonable default values. Machine-specific default values will be
@@ -1040,7 +1040,7 @@ schedule_prefetches (struct mem_ref_group *groups, unsigned unroll_factor,
 	  continue;
 
         /* The loop is far from being sufficiently unrolled for this
-           prefetch.  Do not generate prefetch to avoid many redudant
+           prefetch.  Do not generate prefetch to avoid many redundant
            prefetches.  */
         if (ref->prefetch_mod / unroll_factor > PREFETCH_MOD_TO_UNROLL_FACTOR_RATIO)
           continue;
@@ -1723,7 +1723,7 @@ determine_loop_nest_reuse (struct loop *loop, struct mem_ref_group *refs,
 }
 
 /* Determine whether or not the trip count to ahead ratio is too small based
-   on prefitablility consideration.
+   on profitability consideration.
    AHEAD: the iteration ahead distance,
    EST_NITER: the estimated trip count.  */
 
@@ -1748,7 +1748,7 @@ trip_count_to_ahead_ratio_too_small_p (unsigned ahead, HOST_WIDE_INT est_niter)
 }
 
 /* Determine whether or not the number of memory references in the loop is
-   reasonable based on the profitablity and compilation time considerations.
+   reasonable based on the profitability and compilation time considerations.
    NINSNS: estimated number of instructions in the loop,
    MEM_REF_COUNT: total number of memory references in the loop.  */
 
@@ -1791,7 +1791,7 @@ mem_ref_count_reasonable_p (unsigned ninsns, unsigned mem_ref_count)
 }
 
 /* Determine whether or not the instruction to prefetch ratio in the loop is
-   too small based on the profitablity consideration.
+   too small based on the profitability consideration.
    NINSNS: estimated number of instructions in the loop,
    PREFETCH_COUNT: an estimate of the number of prefetches,
    UNROLL_FACTOR:  the factor to unroll the loop if prefetching.  */
@@ -1871,7 +1871,7 @@ loop_prefetch_arrays (struct loop *loop)
   refs = gather_memory_references (loop, &no_other_refs, &mem_ref_count);
 
   /* Give up prefetching if the number of memory references in the
-     loop is not reasonable based on profitablity and compilation time
+     loop is not reasonable based on profitability and compilation time
      considerations.  */
   if (!mem_ref_count_reasonable_p (ninsns, mem_ref_count))
     goto fail;
diff --git a/gcc/tree-ssa-math-opts.c b/gcc/tree-ssa-math-opts.c
index d044374..99edc55 100644
--- a/gcc/tree-ssa-math-opts.c
+++ b/gcc/tree-ssa-math-opts.c
@@ -1080,7 +1080,7 @@ powi_as_mults (gimple_stmt_iterator *gsi, location_t loc,
 /* ARG0 and N are the two arguments to a powi builtin in GSI with
    location info LOC.  If the arguments are appropriate, create an
    equivalent sequence of statements prior to GSI using an optimal
-   number of multiplications, and return an expession holding the
+   number of multiplications, and return an expression holding the
    result.  */
 
 static tree
@@ -1519,7 +1519,7 @@ expand_pow_as_sqrts (gimple_stmt_iterator *gsi, location_t loc,
 /* ARG0 and ARG1 are the two arguments to a pow builtin call in GSI
    with location info LOC.  If possible, create an equivalent and
    less expensive sequence of statements prior to GSI, and return an
-   expession holding the result.  */
+   expression holding the result.  */
 
 static tree
 gimple_expand_builtin_pow (gimple_stmt_iterator *gsi, location_t loc, 
@@ -1615,7 +1615,7 @@ gimple_expand_builtin_pow (gimple_stmt_iterator *gsi, location_t loc,
 
 
   /* Attempt to expand the POW as a product of square root chains.
-     Expand the 0.25 case even when otpimising for size.  */
+     Expand the 0.25 case even when optimising for size.  */
   if (flag_unsafe_math_optimizations
       && sqrtfn
       && hw_sqrt_exists
@@ -2812,8 +2812,8 @@ bswap_replace (gimple *cur_stmt, gimple *ins_stmt, tree fndecl,
 }
 
 /* Find manual byte swap implementations as well as load in a given
-   endianness. Byte swaps are turned into a bswap builtin invokation
-   while endian loads are converted to bswap builtin invokation or
+   endianness. Byte swaps are turned into a bswap builtin invocation
+   while endian loads are converted to bswap builtin invocation or
    simple load according to the target endianness.  */
 
 unsigned int
@@ -3179,7 +3179,7 @@ convert_mult_to_widen (gimple *stmt, gimple_stmt_iterator *gsi)
 	return false;
     }
 
-  /* Ensure that the inputs to the handler are in the correct precison
+  /* Ensure that the inputs to the handler are in the correct precision
      for the opcode.  This will be the full mode size.  */
   actual_precision = GET_MODE_PRECISION (actual_mode);
   if (2 * actual_precision > TYPE_PRECISION (type))
@@ -3390,7 +3390,7 @@ convert_plusminus_to_widen (gimple_stmt_iterator *gsi, gimple *stmt,
   if (handler == CODE_FOR_nothing)
     return false;
 
-  /* Ensure that the inputs to the handler are in the correct precison
+  /* Ensure that the inputs to the handler are in the correct precision
      for the opcode.  This will be the full mode size.  */
   actual_precision = GET_MODE_PRECISION (actual_mode);
   if (actual_precision != TYPE_PRECISION (type1)
@@ -3946,7 +3946,7 @@ convert_to_divmod (gassign *stmt)
   stmts.safe_push (top_stmt);
   bool div_seen = (gimple_assign_rhs_code (top_stmt) == TRUNC_DIV_EXPR);
 
-  /* Part 2: Add all trunc_div/trunc_mod statements domianted by top_bb
+  /* Part 2: Add all trunc_div/trunc_mod statements dominated by top_bb
      to stmts vector. The 2nd loop will always add stmt to stmts vector, since
      gimple_bb (top_stmt) dominates gimple_bb (stmt), so the
      2nd loop ends up adding at-least single trunc_mod_expr stmt.  */  
diff --git a/gcc/tree-ssa-pre.c b/gcc/tree-ssa-pre.c
index 2a431c9..7473189 100644
--- a/gcc/tree-ssa-pre.c
+++ b/gcc/tree-ssa-pre.c
@@ -2132,7 +2132,7 @@ compute_antic_aux (basic_block block, bool block_has_abnormal_pred_edge)
 	      /* Unvisited successors get their ANTIC_IN replaced by the
 		 maximal set to arrive at a maximum ANTIC_IN solution.
 		 We can ignore them in the intersection operation and thus
-		 need not explicitely represent that maximum solution.  */
+		 need not explicitly represent that maximum solution.  */
 	      if (dump_file && (dump_flags & TDF_DETAILS))
 		fprintf (dump_file, "ANTIC_IN is MAX on %d->%d\n",
 			 e->src->index, e->dest->index);
@@ -3948,7 +3948,7 @@ compute_avail (void)
 			 load make sure we do not use its expression
 			 for insertion if it wouldn't be a valid
 			 replacement.  */
-		      /* At the momemt we have a testcase
+		      /* At the moment we have a testcase
 			 for hoist insertion of aligned vs. misaligned
 			 variants in gcc.dg/torture/pr65270-1.c thus
 			 with just alignment to be considered we can
@@ -4838,7 +4838,7 @@ fini_eliminate (void)
 
   /* Fixup stmts that became noreturn calls.  This may require splitting
      blocks and thus isn't possible during the dominator walk.  Do this
-     in reverse order so we don't inadvertedly remove a stmt we want to
+     in reverse order so we don't inadvertently remove a stmt we want to
      fixup by visiting a dominating now noreturn call first.  */
   while (!el_to_fixup.is_empty ())
     {
diff --git a/gcc/tree-ssa-propagate.c b/gcc/tree-ssa-propagate.c
index 00ab3d7..e15fe1b 100644
--- a/gcc/tree-ssa-propagate.c
+++ b/gcc/tree-ssa-propagate.c
@@ -1216,7 +1216,7 @@ substitute_and_fold (ssa_prop_get_value_fn get_value_fn,
 
   /* Fixup stmts that became noreturn calls.  This may require splitting
      blocks and thus isn't possible during the dominator walk.  Do this
-     in reverse order so we don't inadvertedly remove a stmt we want to
+     in reverse order so we don't inadvertently remove a stmt we want to
      fixup by visiting a dominating now noreturn call first.  */
   while (!walker.stmts_to_fixup.is_empty ())
     {
diff --git a/gcc/tree-ssa-reassoc.c b/gcc/tree-ssa-reassoc.c
index a2b0955..0ad5525 100644
--- a/gcc/tree-ssa-reassoc.c
+++ b/gcc/tree-ssa-reassoc.c
@@ -444,7 +444,7 @@ get_rank (tree e)
       /* Otherwise, find the maximum rank for the operands.  As an
 	 exception, remove the bias from loop-carried phis when propagating
 	 the rank so that dependent operations are not also biased.  */
-      /* Simply walk over all SSA uses - this takes advatage of the
+      /* Simply walk over all SSA uses - this takes advantage of the
          fact that non-SSA operands are is_gimple_min_invariant and
 	 thus have rank 0.  */
       rank = 0;
@@ -1265,7 +1265,7 @@ zero_one_operation (tree *def, enum tree_code opcode, tree op)
   tree orig_def = *def;
   gimple *stmt = SSA_NAME_DEF_STMT (*def);
   /* PR72835 - Record the stmt chain that has to be updated such that
-     we dont use the same LHS when the values computed are different.  */
+     we don't use the same LHS when the values computed are different.  */
   auto_vec<gimple *, 64> stmts_to_fix;
 
   do
@@ -4104,7 +4104,7 @@ remove_visited_stmt_chain (tree var)
     }
 }
 
-/* This function checks three consequtive operands in
+/* This function checks three consecutive operands in
    passed operands vector OPS starting from OPINDEX and
    swaps two operands if it is profitable for binary operation
    consuming OPINDEX + 1 abnd OPINDEX + 2 operands.
@@ -5298,7 +5298,7 @@ attempt_builtin_powi (gimple *stmt, vec<operand_entry *> *ops)
 	     high-occurrence elements are visited first, and within the
 	     same occurrence count, lower-ranked elements are visited
 	     first).  Form a linear product of all elements in this order
-	     whose occurrencce count is at least that of element J.
+	     whose occurrence count is at least that of element J.
 	     Record the SSA name representing the product of each element
 	     with all subsequent elements in the vector.  */
 	  if (j == vec_len - 1)
diff --git a/gcc/tree-ssa-sccvn.c b/gcc/tree-ssa-sccvn.c
index c140c35..50fe39e 100644
--- a/gcc/tree-ssa-sccvn.c
+++ b/gcc/tree-ssa-sccvn.c
@@ -3870,7 +3870,7 @@ visit_phi (gimple *phi)
   
   /* If none of the edges was executable or all incoming values are
      undefined keep the value-number at VN_TOP.  If only a single edge
-     is exectuable use its value.  */
+     is executable use its value.  */
   if (sameval == VN_TOP
       || n_executable == 1)
     return set_ssa_val_to (PHI_RESULT (phi), sameval);
diff --git a/gcc/tree-ssa-sink.c b/gcc/tree-ssa-sink.c
index acf832d..4914a1a 100644
--- a/gcc/tree-ssa-sink.c
+++ b/gcc/tree-ssa-sink.c
@@ -177,7 +177,7 @@ nearest_common_dominator_of_uses (def_operand_p def_p, bool *debug_stmts)
 
    If the resulting block is in a shallower loop nest, then use it.  Else
    only use the resulting block if it has significantly lower execution
-   frequency than EARLY_BB to avoid gratutious statement movement.  We
+   frequency than EARLY_BB to avoid gratuitous statement movement.  We
    consider statements with VOPS more desirable to move.
 
    This pass would obviously benefit from PDO as it utilizes block
@@ -224,7 +224,7 @@ select_best_block (basic_block early_bb,
     }
 
   /* If BEST_BB is at the same nesting level, then require it to have
-     significantly lower execution frequency to avoid gratutious movement.  */
+     significantly lower execution frequency to avoid gratuitous movement.  */
   if (bb_loop_depth (best_bb) == bb_loop_depth (early_bb)
       && best_bb->frequency < (early_bb->frequency * threshold / 100.0))
     return best_bb;
diff --git a/gcc/tree-ssa-strlen.c b/gcc/tree-ssa-strlen.c
index e4f18db..3b1f8b5 100644
--- a/gcc/tree-ssa-strlen.c
+++ b/gcc/tree-ssa-strlen.c
@@ -2143,7 +2143,7 @@ handle_char_store (gimple_stmt_iterator *gsi)
 	 the same.  In that case we move to the next gimple statement and
 	 return to signal the caller that it shouldn't invalidate anything.  
 
-	 This is benefical for cases like:
+	 This is beneficial for cases like:
 
 	 char p[20];
 	 void foo (char *q)
diff --git a/gcc/tree-ssa-structalias.c b/gcc/tree-ssa-structalias.c
index a4abd28..3ad8e88 100644
--- a/gcc/tree-ssa-structalias.c
+++ b/gcc/tree-ssa-structalias.c
@@ -5083,7 +5083,7 @@ find_func_clobbers (struct function *fn, gimple *origt)
 	}
     }
 
-  /* Account for uses in assigments and returns.  */
+  /* Account for uses in assignments and returns.  */
   if (gimple_assign_single_p (t)
       || (gimple_code (t) == GIMPLE_RETURN
 	  && gimple_return_retval (as_a <greturn *> (t)) != NULL_TREE))
@@ -7414,7 +7414,7 @@ maybe_set_dependence_info (tree ref, tree ptr,
   return false;
 }
 
-/* Compute the set of independend memory references based on restrict
+/* Compute the set of independent memory references based on restrict
    tags and their conservative propagation to the points-to sets.  */
 
 static void
@@ -7763,7 +7763,7 @@ debug_varmap (void)
   dump_varmap (stderr);
 }
 
-/* Compute whether node is refered to non-locally.  Worker for
+/* Compute whether node is referred to non-locally.  Worker for
    cgraph_for_symbol_thunks_and_aliases.  */
 static bool
 refered_from_nonlocal_fn (struct cgraph_node *node, void *data)
diff --git a/gcc/tree-ssa-threadbackward.c b/gcc/tree-ssa-threadbackward.c
index 24def1d..dcffeda 100644
--- a/gcc/tree-ssa-threadbackward.c
+++ b/gcc/tree-ssa-threadbackward.c
@@ -330,7 +330,7 @@ profitable_jump_thread_path (vec<basic_block, va_gc> *&path,
 
   /* Threading is profitable if the path duplicated is hot but also
      in a case we separate cold path from hot path and permit optimization
-     of the hot path later.  Be on the agressive side here. In some testcases,
+     of the hot path later.  Be on the aggressive side here. In some testcases,
      as in PR 78407 this leads to noticeable improvements.  */
   if (speed_p && (optimize_edge_for_speed_p (taken_edge) || contains_hot_bb))
     {
diff --git a/gcc/tree-ssa-threadedge.c b/gcc/tree-ssa-threadedge.c
index 536c471..15c1336 100644
--- a/gcc/tree-ssa-threadedge.c
+++ b/gcc/tree-ssa-threadedge.c
@@ -814,7 +814,7 @@ propagate_threaded_block_debug_into (basic_block dest, basic_block src)
     fewvars.release ();
 }
 
-/* See if TAKEN_EDGE->dest is a threadable block with no side effecs (ie, it
+/* See if TAKEN_EDGE->dest is a threadable block with no side effects (ie, it
    need not be duplicated as part of the CFG/SSA updating process).
 
    If it is threadable, add it to PATH and VISITED and recurse, ultimately
diff --git a/gcc/tree-ssa-threadupdate.c b/gcc/tree-ssa-threadupdate.c
index 3198268..1c6fd88 100644
--- a/gcc/tree-ssa-threadupdate.c
+++ b/gcc/tree-ssa-threadupdate.c
@@ -2584,7 +2584,7 @@ thread_through_all_blocks (bool may_peel_loop_headers)
   return retval;
 }
 
-/* Delete the jump threading path PATH.  We have to explcitly delete
+/* Delete the jump threading path PATH.  We have to explicitly delete
    each entry in the vector, then the container.  */
 
 void
diff --git a/gcc/tree-ssa-uninit.c b/gcc/tree-ssa-uninit.c
index b587599..225820c 100644
--- a/gcc/tree-ssa-uninit.c
+++ b/gcc/tree-ssa-uninit.c
@@ -326,7 +326,7 @@ warn_uninitialized_vars (bool warn_possibly_uninitialized)
 		 clobbers on all paths to entry.  */
 	      if (fentry_reached
 		  /* ???  We'd like to use ref_may_alias_global_p but that
-		     excludes global readonly memory and thus we get bougs
+		     excludes global readonly memory and thus we get bogus
 		     warnings from p = cond ? "a" : "b" for example.  */
 		  && (!VAR_P (base)
 		      || is_global_var (base)))
@@ -613,7 +613,7 @@ typedef vec<pred_chain, va_heap, vl_ptr> pred_chain_union;
    is the result of AND operation of pred_info mapped to each edge.
    A composite predicate is presented by a vector of pred_info.  On
    return, *PREDS points to the resulting array of composite predicates.
-   *NUM_PREDS is the number of composite predictes.  */
+   *NUM_PREDS is the number of composite predicates.  */
 
 static bool
 convert_control_dep_chain_into_preds (vec<edge> *dep_chains,
@@ -655,7 +655,7 @@ convert_control_dep_chain_into_preds (vec<edge> *dep_chains,
 	  if (is_gimple_call (cond_stmt) && EDGE_COUNT (e->src->succs) >= 2)
 	    /* Ignore EH edge.  Can add assertion on the other edge's flag.  */
 	    continue;
-	  /* Skip if there is essentially one succesor.  */
+	  /* Skip if there is essentially one successor.  */
 	  if (EDGE_COUNT (e->src->succs) == 2)
 	    {
 	      edge e1;
@@ -1213,7 +1213,7 @@ prune_uninit_phi_opnds (gphi *phi, unsigned uninit_opnds, gphi *flag_def,
 
 /* A helper function that determines if the predicate set
    of the use is not overlapping with that of the uninit paths.
-   The most common senario of guarded use is in Example 1:
+   The most common scenario of guarded use is in Example 1:
      Example 1:
 	   if (some_cond)
 	   {
@@ -2027,7 +2027,7 @@ is_degenerated_phi (gimple *phi, pred_info *pred_p)
 }
 
 /* Normalize one predicate PRED
-   1) if PRED can no longer be normlized, put it into NORM_PREDS.
+   1) if PRED can no longer be normalized, put it into NORM_PREDS.
    2) otherwise if PRED is of the form x != 0, follow x's definition
       and put normalized predicates into WORK_LIST.  */
 
diff --git a/gcc/tree-ssanames.h b/gcc/tree-ssanames.h
index 9a18394..058fb80 100644
--- a/gcc/tree-ssanames.h
+++ b/gcc/tree-ssanames.h
@@ -1,4 +1,4 @@
-/* SSA name expresssons routines
+/* SSA name expression routines
    Copyright (C) 2013-2017 Free Software Foundation, Inc.
 
 This file is part of GCC.
diff --git a/gcc/tree-streamer-out.c b/gcc/tree-streamer-out.c
index 05239fb..d7841cc 100644
--- a/gcc/tree-streamer-out.c
+++ b/gcc/tree-streamer-out.c
@@ -769,7 +769,7 @@ write_ts_block_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
   /* Stream BLOCK_ABSTRACT_ORIGIN for the limited cases we can handle - those
      that represent inlined function scopes.
      For the rest them on the floor instead of ICEing in dwarf2out.c, but
-     keep the notion of whether the block is an inlined block by refering
+     keep the notion of whether the block is an inlined block by referring
      to itself for the sake of tree_nonartificial_location.  */
   if (inlined_function_outer_scope_p (expr))
     {
diff --git a/gcc/tree-vect-data-refs.c b/gcc/tree-vect-data-refs.c
index e8e2658..cd80057 100644
--- a/gcc/tree-vect-data-refs.c
+++ b/gcc/tree-vect-data-refs.c
@@ -790,7 +790,7 @@ vect_compute_data_ref_alignment (struct data_reference *dr)
     {
       /* Note all this only works if DR_BASE_ADDRESS is the same as
 	 MEM_REF operand zero, otherwise DR/SCEV analysis might have factored
-	 in other offsets.  We need to rework DR to compute the alingment
+	 in other offsets.  We need to rework DR to compute the alignment
 	 of DR_BASE_ADDRESS as long as all information is still available.  */
       if (operand_equal_p (TREE_OPERAND (base, 0), base_addr, 0))
 	{
@@ -5376,7 +5376,7 @@ vect_permute_load_chain (vec<tree> dr_chain,
    Given a chain of loads in DR_CHAIN of LENGTH 2 or 3, generate
    sequence of stmts to reorder the input data accordingly.
    Return the final references for loads in RESULT_CHAIN.
-   Return true if successed, false otherwise.
+   Return true if successful, false otherwise.
 
    E.g., LENGTH is 3 and the scalar type is short, i.e., VF is 8.
    The input is 3 vectors each containing 8 elements.  We assign a
diff --git a/gcc/tree-vect-generic.c b/gcc/tree-vect-generic.c
index c1b3c24..353f154 100644
--- a/gcc/tree-vect-generic.c
+++ b/gcc/tree-vect-generic.c
@@ -1172,7 +1172,7 @@ type_for_widest_vector_mode (tree type, optab op)
    ARRAY_REF expression.
 
    GSI is required to insert temporary variables while building a
-   refernece to the element of the vector VECT.
+   reference to the element of the vector VECT.
 
    PTMPVEC is a pointer to the temporary variable for caching
    purposes.  In case when PTMPVEC is NULL new temporary variable
diff --git a/gcc/tree-vect-loop-manip.c b/gcc/tree-vect-loop-manip.c
index 42b9f48..c5ddd56 100644
--- a/gcc/tree-vect-loop-manip.c
+++ b/gcc/tree-vect-loop-manip.c
@@ -1151,7 +1151,7 @@ vect_gen_scalar_loop_niters (tree niters_prolog, int int_niters_prolog,
 	  return build_int_cst (type, *bound_scalar);
 	}
       /* Peeling for unknown times.  Note BOUND_PROLOG is the upper
-	 bound (inlcuded) of niters of prolog loop.  */
+	 bound (included) of niters of prolog loop.  */
       if (th >=  vfm1 + bound_prolog)
 	{
 	  *bound_scalar = th;
@@ -1264,7 +1264,7 @@ vect_gen_vector_loop_niters_mult_vf (loop_vec_info loop_vinfo,
   *niters_vector_mult_vf_ptr = niters_vector_mult_vf;
 }
 
-/* Function slpeel_tree_duplicate_loop_to_edge_cfg duplciates FIRST/SECOND
+/* Function slpeel_tree_duplicate_loop_to_edge_cfg duplicates FIRST/SECOND
    from SECOND/FIRST and puts it at the original loop's preheader/exit
    edge, the two loops are arranged as below:
 
diff --git a/gcc/tree-vect-loop.c b/gcc/tree-vect-loop.c
index 107f082..b61d7ec 100644
--- a/gcc/tree-vect-loop.c
+++ b/gcc/tree-vect-loop.c
@@ -2045,7 +2045,7 @@ start_over:
   if (!ok)
     return false;
 
-  /* Do not invoke vect_enhance_data_refs_alignment for eplilogue
+  /* Do not invoke vect_enhance_data_refs_alignment for epilogue
      vectorization.  */
   if (!LOOP_VINFO_EPILOGUE_P (loop_vinfo))
     {
@@ -4185,7 +4185,7 @@ vect_create_epilog_for_reduction (vec<tree> vect_defs, gimple *stmt,
 	      == INTEGER_INDUC_COND_REDUCTION)
 	    {
 	      /* Initialise the reduction phi to zero.  This prevents initial
-		 values of non-zero interferring with the reduction op.  */
+		 values of non-zero interfering with the reduction op.  */
 	      gcc_assert (ncopies == 1);
 	      gcc_assert (i == 0);
 
@@ -5680,7 +5680,7 @@ vectorizable_reduction (gimple *stmt, gimple_stmt_iterator *gsi,
       return false;
     }
 
-  /* In case of widenning multiplication by a constant, we update the type
+  /* In case of widening multiplication by a constant, we update the type
      of the constant to be the type of the other operand.  We check that the
      constant fits the type in the pattern recognition pass.  */
   if (code == DOT_PROD_EXPR
diff --git a/gcc/tree-vect-patterns.c b/gcc/tree-vect-patterns.c
index 39f0133..377285c7 100644
--- a/gcc/tree-vect-patterns.c
+++ b/gcc/tree-vect-patterns.c
@@ -77,8 +77,8 @@ struct vect_recog_func
 };
 
 /* Note that ordering matters - the first pattern matching on a stmt
-   is taken which means usually the more complex one needs to preceed
-   the less comples onex (widen_sum only after dot_prod or sad for example).  */
+   is taken which means usually the more complex one needs to precede
+   the less complex one (widen_sum only after dot_prod or sad for example).  */
 static vect_recog_func vect_vect_recog_func_ptrs[NUM_PATTERNS] = {
       { vect_recog_widen_mult_pattern, "widen_mult" },
       { vect_recog_dot_prod_pattern, "dot_prod" },
@@ -680,7 +680,7 @@ vect_recog_sad_pattern (vec<gimple *> *stmts, tree *type_in,
 
    Otherwise, if the type of the result (TYPE) is at least 4 times bigger than
    HALF_TYPE, and there is an intermediate type (2 times smaller than TYPE)
-   that satisfies the above restrictions,  we can perform a widening opeartion
+   that satisfies the above restrictions,  we can perform a widening operation
    from the intermediate type to TYPE and replace a_T = (TYPE) a_t;
    with a_it = (interm_type) a_t;  Store such operation in *WSTMT.  */
 
@@ -980,7 +980,7 @@ vect_recog_widen_mult_pattern (vec<gimple *> *stmts,
       STMT_VINFO_VECTYPE (new_stmt_info) = vectype;
     }
 
-  /* If ITYPE is not TYPE, we need to build a type convertion stmt to convert
+  /* If ITYPE is not TYPE, we need to build a type conversion stmt to convert
      the result of the widen-mult operation into type TYPE.  */
   if (itype != type)
     {
@@ -1488,7 +1488,7 @@ vect_recog_over_widening_pattern (vec<gimple *> *stmts,
         return NULL;
 
       /* We want to collect all the statements for which we create pattern
-         statetments, except for the case when the last statement in the
+         statements, except for the case when the last statement in the
          sequence doesn't have a corresponding pattern statement.  In such
          case we associate the last pattern statement with the last statement
          in the sequence.  Therefore, we only add the original statement to
@@ -1525,7 +1525,7 @@ vect_recog_over_widening_pattern (vec<gimple *> *stmts,
     {
       use_lhs = gimple_assign_lhs (use_stmt);
       use_type = TREE_TYPE (use_lhs);
-      /* Support only type demotion or signedess change.  */
+      /* Support only type demotion or signedness change.  */
       if (!INTEGRAL_TYPE_P (use_type)
 	  || TYPE_PRECISION (type) <= TYPE_PRECISION (use_type))
         return NULL;
@@ -3841,7 +3841,7 @@ build_mask_conversion (tree mask, tree vectype, stmt_vec_info stmt_vinfo,
 /* Function vect_recog_mask_conversion_pattern
 
    Try to find statements which require boolean type
-   converison.  Additional conversion statements are
+   conversion.  Additional conversion statements are
    added to handle such cases.  For example:
 
    bool m_1, m_2, m_3;
diff --git a/gcc/tree-vect-slp.c b/gcc/tree-vect-slp.c
index 31194b8..41d63e3 100644
--- a/gcc/tree-vect-slp.c
+++ b/gcc/tree-vect-slp.c
@@ -485,11 +485,11 @@ again:
    is false then this indicates the comparison could not be
    carried out or the stmts will never be vectorized by SLP.
 
-   Note COND_EXPR is possibly ismorphic to another one after swapping its
+   Note COND_EXPR is possibly isomorphic to another one after swapping its
    operands.  Set SWAP[i] to 1 if stmt I is COND_EXPR and isomorphic to
    the first stmt by swapping the two operands of comparison; set SWAP[i]
-   to 2 if stmt I is isormorphic to the first stmt by inverting the code
-   of comparison.  Take A1 >= B1 ? X1 : Y1 as an exmple, it can be swapped
+   to 2 if stmt I is isomorphic to the first stmt by inverting the code
+   of comparison.  Take A1 >= B1 ? X1 : Y1 as an example, it can be swapped
    to (B1 <= A1 ? X1 : Y1); or be inverted to (A1 < B1) ? Y1 : X1.  */
 
 static bool
@@ -1046,7 +1046,7 @@ vect_build_slp_tree (vec_info *vinfo,
          simply treat nodes we fail to build as externally defined
 	 (and thus build vectors from the scalar defs).
 	 The cost model will reject outright expensive cases.
-	 ???  This doesn't treat cases where permutation ultimatively
+	 ???  This doesn't treat cases where permutation ultimately
 	 fails (or we don't try permutation below).  Ideally we'd
 	 even compute a permutation that will end up with the maximum
 	 SLP tree size...  */
@@ -1433,7 +1433,7 @@ vect_supported_load_permutation_p (slp_instance slp_instn)
 
   /* In basic block vectorization we allow any subchain of an interleaving
      chain.
-     FORNOW: not supported in loop SLP because of realignment compications.  */
+     FORNOW: not supported in loop SLP because of realignment complications.  */
   if (STMT_VINFO_BB_VINFO (vinfo_for_stmt (stmt)))
     {
       /* Check whether the loads in an instance form a subchain and thus
diff --git a/gcc/tree-vect-stmts.c b/gcc/tree-vect-stmts.c
index 1e9d42c..68b6a61 100644
--- a/gcc/tree-vect-stmts.c
+++ b/gcc/tree-vect-stmts.c
@@ -2340,7 +2340,7 @@ vectorizable_mask_load_store (gimple *stmt, gimple_stmt_iterator *gsi,
 	      tree rhs = gimple_call_arg (stmt, 3);
 	      vec_rhs = vect_get_vec_def_for_operand (rhs, stmt);
 	      vec_mask = vect_get_vec_def_for_operand (mask, stmt);
-	      /* We should have catched mismatched types earlier.  */
+	      /* We should have caught mismatched types earlier.  */
 	      gcc_assert (useless_type_conversion_p (vectype,
 						     TREE_TYPE (vec_rhs)));
 	      dataref_ptr = vect_create_data_ref_ptr (stmt, vectype, NULL,
@@ -6255,7 +6255,7 @@ vectorizable_store (gimple *stmt, gimple_stmt_iterator *gsi, gimple **vec_stmt,
 		}
 	    }
 
-	  /* We should have catched mismatched types earlier.  */
+	  /* We should have caught mismatched types earlier.  */
 	  gcc_assert (useless_type_conversion_p (vectype,
 						 TREE_TYPE (vec_oprnd)));
 	  bool simd_lane_access_p
@@ -6511,7 +6511,7 @@ hoist_defs_of_uses (gimple *stmt, struct loop *loop)
 	{
 	  /* Make sure we don't need to recurse.  While we could do
 	     so in simple cases when there are more complex use webs
-	     we don't have an easy way to preserve stmt order to fulfil
+	     we don't have an easy way to preserve stmt order to fulfill
 	     dependencies within them.  */
 	  tree op2;
 	  ssa_op_iter i2;
diff --git a/gcc/tree-vectorizer.h b/gcc/tree-vectorizer.h
index df8da9e..ee17f3a 100644
--- a/gcc/tree-vectorizer.h
+++ b/gcc/tree-vectorizer.h
@@ -207,7 +207,7 @@ typedef struct _loop_vec_info : public vec_info {
   /* Condition under which this loop is analyzed and versioned.  */
   tree num_iters_assumptions;
 
-  /* Threshold of number of iterations below which vectorzation will not be
+  /* Threshold of number of iterations below which vectorization will not be
      performed. It is calculated from MIN_PROFITABLE_ITERS and
      PARAM_MIN_VECT_LOOP_BOUND.  */
   unsigned int th;
diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c
index 716a7c2..2487541 100644
--- a/gcc/tree-vrp.c
+++ b/gcc/tree-vrp.c
@@ -1234,7 +1234,7 @@ value_range_nonnegative_p (value_range *vr)
   return false;
 }
 
-/* If *VR has a value rante that is a single constant value return that,
+/* If *VR has a value range that is a single constant value return that,
    otherwise return NULL_TREE.  */
 
 static tree
@@ -2468,7 +2468,7 @@ extract_range_from_binary_expr_1 (value_range *vr,
 	  vrp_int size = sizem1 + 1;
 
 	  /* Extend the values using the sign of the result to PREC2.
-	     From here on out, everthing is just signed math no matter
+	     From here on out, everything is just signed math no matter
 	     what the input types were.  */
           vrp_int min0 = vrp_int_cst (vr0.min);
           vrp_int max0 = vrp_int_cst (vr0.max);
@@ -2646,7 +2646,7 @@ extract_range_from_binary_expr_1 (value_range *vr,
 		      /* For non-negative numbers, we're shifting out only
 			 zeroes, the value increases monotonically.
 			 For negative numbers, we're shifting out only ones, the
-			 value decreases monotomically.  */
+			 value decreases monotonically.  */
 		      in_bounds = true;
 		    }
 		}
@@ -4141,7 +4141,7 @@ adjust_range_with_scev (value_range *vr, struct loop *loop,
    - Return NULL_TREE if it is not always possible to determine the
      value of the comparison.
 
-   Also set *STRICT_OVERFLOW_P to indicate whether comparision evaluation
+   Also set *STRICT_OVERFLOW_P to indicate whether comparison evaluation
    assumed signed overflow is undefined.  */
 
 
@@ -4282,7 +4282,7 @@ compare_ranges (enum tree_code comp, value_range *vr0, value_range *vr1,
    values in VR.  Return BOOLEAN_FALSE_NODE if the comparison
    always returns false.  Return NULL_TREE if it is not always
    possible to determine the value of the comparison.  Also set
-   *STRICT_OVERFLOW_P to indicate whether comparision evaluation
+   *STRICT_OVERFLOW_P to indicate whether comparison evaluation
    assumed signed overflow is undefined.  */
 
 static tree
@@ -7899,7 +7899,7 @@ vrp_visit_switch_stmt (gswitch *stmt, edge *taken_edge_p)
 
 
 /* Evaluate statement STMT.  If the statement produces a useful range,
-   set VR and corepsponding OUTPUT_P.
+   set VR and corresponding OUTPUT_P.
 
    If STMT is a conditional branch and we can determine its truth
    value, the taken edge is recorded in *TAKEN_EDGE_P.  */
@@ -10212,7 +10212,7 @@ simplify_stmt_using_ranges (gimple_stmt_iterator *gsi)
 	      cmp_var = rhs1;
 	    }
 
-	  /* If we could not find two-vals or the optimzation is invalid as
+	  /* If we could not find two-vals or the optimization is invalid as
 	     in divide by zero, new_rhs1 / new_rhs will be NULL_TREE.  */
 	  if (new_rhs1 && new_rhs2)
 	    {
@@ -11213,7 +11213,7 @@ execute_early_vrp ()
 
   /* Fixup stmts that became noreturn calls.  This may require splitting
      blocks and thus isn't possible during the dominator walk.  Do this
-     in reverse order so we don't inadvertedly remove a stmt we want to
+     in reverse order so we don't inadvertently remove a stmt we want to
      fixup by visiting a dominating now noreturn call first.  */
   while (!walker.stmts_to_fixup.is_empty ())
     {
diff --git a/gcc/tree.c b/gcc/tree.c
index a58f9aa..70b55e2 100644
--- a/gcc/tree.c
+++ b/gcc/tree.c
@@ -1162,7 +1162,7 @@ copy_node_stat (tree node MEM_STAT_DECL)
 	  SET_DECL_VALUE_EXPR (t, DECL_VALUE_EXPR (node));
 	  DECL_HAS_VALUE_EXPR_P (t) = 1;
 	}
-      /* DECL_DEBUG_EXPR is copied explicitely by callers.  */
+      /* DECL_DEBUG_EXPR is copied explicitly by callers.  */
       if (VAR_P (node))
 	{
 	  DECL_HAS_DEBUG_EXPR_P (t) = 0;
@@ -4621,7 +4621,7 @@ build5_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
   return t;
 }
 
-/* Build a simple MEM_REF tree with the sematics of a plain INDIRECT_REF
+/* Build a simple MEM_REF tree with the semantics of a plain INDIRECT_REF
    on the pointer PTR.  */
 
 tree
@@ -9765,7 +9765,7 @@ get_file_function_name (const char *type)
   /* If the target is handling the constructors/destructors, they
      will be local to this file and the name is only necessary for
      debugging purposes. 
-     We also assign sub_I and sub_D sufixes to constructors called from
+     We also assign sub_I and sub_D suffixes to constructors called from
      the global static constructors.  These are always local.  */
   else if (((type[0] == 'I' || type[0] == 'D') && targetm.have_ctors_dtors)
 	   || (strncmp (type, "sub_", 4) == 0
@@ -13481,7 +13481,7 @@ verify_type_variant (const_tree t, tree tv)
     verify_variant_match (TYPE_TRANSPARENT_AGGR);
   else if (TREE_CODE (t) == ARRAY_TYPE)
     verify_variant_match (TYPE_NONALIASED_COMPONENT);
-  /* During LTO we merge variant lists from diferent translation units
+  /* During LTO we merge variant lists from different translation units
      that may differ BY TYPE_CONTEXT that in turn may point 
      to TRANSLATION_UNIT_DECL.
      Ada also builds variants of types with different TYPE_CONTEXT.   */
@@ -13691,7 +13691,7 @@ gimple_canonical_types_compatible_p (const_tree t1, const_tree t2,
      need to ensure that we are never called on it.
 
      FIXME: For more correctness the function probably should have three modes
-	1) mode assuming that types are complete mathcing their structure
+	1) mode assuming that types are complete matching their structure
 	2) mode allowing incomplete types but producing equivalence classes
 	   and thus ignoring all info from complete types
 	3) mode allowing incomplete types to match complete but checking
@@ -13712,7 +13712,7 @@ gimple_canonical_types_compatible_p (const_tree t1, const_tree t2,
       /* Do not use TYPE_CANONICAL of pointer types.  For LTO streamed types
 	 they are always NULL, but they are set to non-NULL for types
 	 constructed by build_pointer_type and variants.  In this case the
-	 TYPE_CANONICAL is more fine grained than the equivalnce we test (where
+	 TYPE_CANONICAL is more fine grained than the equivalence we test (where
 	 all pointers are considered equal.  Be sure to not return false
 	 negatives.  */
       gcc_checking_assert (canonical_type_used_p (t1)
@@ -13745,7 +13745,7 @@ gimple_canonical_types_compatible_p (const_tree t1, const_tree t2,
       || TREE_CODE (t1) == OFFSET_TYPE
       || POINTER_TYPE_P (t1))
     {
-      /* Can't be the same type if they have different recision.  */
+      /* Can't be the same type if they have different precision.  */
       if (TYPE_PRECISION (t1) != TYPE_PRECISION (t2))
 	return false;
 
@@ -14125,7 +14125,7 @@ verify_type (const_tree t)
 	tree value = TREE_VALUE (l);
 	tree name = TREE_PURPOSE (l);
 
-	/* C FE porduce INTEGER_CST of INTEGER_TYPE, while C++ FE uses
+	/* C FE produce INTEGER_CST of INTEGER_TYPE, while C++ FE uses
  	   CONST_DECL of ENUMERAL TYPE.  */
 	if (TREE_CODE (value) != INTEGER_CST && TREE_CODE (value) != CONST_DECL)
 	  {
@@ -14511,7 +14511,7 @@ get_nonnull_args (const_tree fntype)
   /* A function declaration can specify multiple attribute nonnull,
      each with zero or more arguments.  The loop below creates a bitmap
      representing a union of all the arguments.  An empty (but non-null)
-     bitmap means that all arguments have been declaraed nonnull.  */
+     bitmap means that all arguments have been declared nonnull.  */
   for ( ; attrs; attrs = TREE_CHAIN (attrs))
     {
       attrs = lookup_attribute ("nonnull", attrs);
diff --git a/gcc/tree.h b/gcc/tree.h
index c6e883c..96b2214 100644
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -2741,7 +2741,7 @@ extern void decl_value_expr_insert (tree, tree);
 #define DECL_SEEN_IN_BIND_EXPR_P(NODE) \
   (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.seen_in_bind_expr)
 
-/* Value of the decls's visibility attribute */
+/* Value of the decl's visibility attribute */
 #define DECL_VISIBILITY(NODE) \
   (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.visibility)
 
@@ -2998,7 +2998,7 @@ extern vec<tree, va_gc> **decl_debug_args_insert (tree);
    (FUNCTION_DECL_CHECK (NODE)->function_decl.versioned_function)
 
 /* In FUNCTION_DECL, this is set if this function is a C++ constructor.
-   Devirtualization machinery uses this knowledge for determing type of the
+   Devirtualization machinery uses this knowledge for determining type of the
    object constructed.  Also we assume that constructor address is not
    important.  */
 #define DECL_CXX_CONSTRUCTOR_P(NODE)\
@@ -4922,7 +4922,7 @@ tree_code_for_canonical_type_merging (enum tree_code code)
   return code;
 }
 
-/* Return ture if get_alias_set care about TYPE_CANONICAL of given type.
+/* Return true if get_alias_set care about TYPE_CANONICAL of given type.
    We don't define the types for pointers, arrays and vectors.  The reason is
    that pointers are handled specially: ptr_type_node accesses conflict with
    accesses to all other pointers.  This is done by alias.c.
@@ -5332,7 +5332,7 @@ wi::extended_tree <N>::get_len () const
   else
     /* This class is designed to be used for specific output precisions
        and needs to be as fast as possible, so there is no fallback for
-       other casees.  */
+       other cases.  */
     gcc_unreachable ();
 }
 
diff --git a/gcc/ubsan.c b/gcc/ubsan.c
index a4808d2..9b021e1 100644
--- a/gcc/ubsan.c
+++ b/gcc/ubsan.c
@@ -1473,7 +1473,7 @@ instrument_bool_enum_load (gimple_stmt_iterator *gsi)
 }
 
 /* Determine if we can propagate given LOCATION to ubsan_data descriptor to use
-   new style handlers.  Libubsan uses heuristics to destinguish between old and
+   new style handlers.  Libubsan uses heuristics to distinguish between old and
    new styles and relies on these properties for filename:
 
    a) Location's filename must not be NULL.
diff --git a/gcc/value-prof.c b/gcc/value-prof.c
index 7f1574a..ea4af0c 100644
--- a/gcc/value-prof.c
+++ b/gcc/value-prof.c
@@ -84,7 +84,7 @@ along with GCC; see the file COPYING3.  If not see
    compute_value_histograms() that translates the collected data to
    histograms and attaches them to the profiled statements via
    gimple_add_histogram_value().  Histograms are stored in a hash table
-   that is attached to every intrumented function, see VALUE_HISTOGRAMS
+   that is attached to every instrumented function, see VALUE_HISTOGRAMS
    in function.h.
    
    The value-profile transformations driver is the function
diff --git a/gcc/var-tracking.c b/gcc/var-tracking.c
index 5c38c1d..1335b66 100644
--- a/gcc/var-tracking.c
+++ b/gcc/var-tracking.c
@@ -1688,7 +1688,7 @@ shared_hash_find (shared_hash *vars, decl_or_value dv)
   return shared_hash_find_1 (vars, dv, dv_htab_hash (dv));
 }
 
-/* Return true if TVAL is better than CVAL as a canonival value.  We
+/* Return true if TVAL is better than CVAL as a canonical value.  We
    choose lowest-numbered VALUEs, using the RTX address as a
    tie-breaker.  The idea is to arrange them into a star topology,
    such that all of them are at most one step away from the canonical
diff --git a/gcc/varasm.c b/gcc/varasm.c
index 096871d..74ad500 100644
--- a/gcc/varasm.c
+++ b/gcc/varasm.c
@@ -5973,7 +5973,7 @@ finish_tm_clone_pairs (void)
   if (tm_clone_hash == NULL)
     return;
 
-  /* We need a determenistic order for the .tm_clone_table, otherwise
+  /* We need a deterministic order for the .tm_clone_table, otherwise
      we will get bootstrap comparison failures, so dump the hash table
      to a vector, sort it, and dump the vector.  */
 
diff --git a/gcc/varpool.c b/gcc/varpool.c
index ab59c80..756f325 100644
--- a/gcc/varpool.c
+++ b/gcc/varpool.c
@@ -202,7 +202,7 @@ varpool_node::remove_initializer (void)
       && debug_info_level == DINFO_LEVEL_NONE
       /* When doing declaration merging we have duplicate
 	 entries for given decl.  Do not attempt to remove
-	 the boides, or we will end up remiving
+	 the bodies, or we will end up removing
 	 wrong one.  */
       && symtab->state != LTO_STREAMING)
     DECL_INITIAL (decl) = error_mark_node;
@@ -362,7 +362,7 @@ varpool_node::ctor_useable_for_folding_p (void)
      overridden at link or run time.
 
      It is actually requirement for C++ compiler to optimize const variables
-     consistently. As a GNU extension, do not enfore this rule for user defined
+     consistently. As a GNU extension, do not enforce this rule for user defined
      weak variables, so we support interposition on:
      static const int dummy = 0;
      extern const int foo __attribute__((__weak__, __alias__("dummy"))); 
@@ -412,7 +412,7 @@ ctor_for_folding (tree decl)
     return error_mark_node;
 
   /* Do not care about automatic variables.  Those are never initialized
-     anyway, because gimplifier exapnds the code.  */
+     anyway, because gimplifier expands the code.  */
   if (!TREE_STATIC (decl) && !DECL_EXTERNAL (decl))
     {
       gcc_assert (!TREE_PUBLIC (decl));
@@ -555,7 +555,7 @@ varpool_node::assemble_aliases (void)
 bool
 varpool_node::assemble_decl (void)
 {
-  /* Aliases are outout when their target is produced or by
+  /* Aliases are output when their target is produced or by
      output_weakrefs.  */
   if (alias)
     return false;
@@ -793,8 +793,8 @@ varpool_node::create_extra_name_alias (tree alias, tree decl)
   alias_node = varpool_node::create_alias (alias, decl);
   alias_node->cpp_implicit_alias = true;
 
-  /* Extra name alias mechanizm creates aliases really late
-     via DECL_ASSEMBLER_NAME mechanizm.
+  /* Extra name alias mechanism creates aliases really late
+     via DECL_ASSEMBLER_NAME mechanism.
      This is unfortunate because they are not going through the
      standard channels.  Ensure they get output.  */
   if (symtab->cpp_implicit_aliases_done)
diff --git a/gcc/wide-int.cc b/gcc/wide-int.cc
index dab4c19..8fc2849 100644
--- a/gcc/wide-int.cc
+++ b/gcc/wide-int.cc
@@ -390,7 +390,7 @@ wi::force_to_size (HOST_WIDE_INT *val, const HOST_WIDE_INT *xval,
 }
 
 /* This function hides the fact that we cannot rely on the bits beyond
-   the precision.  This issue comes up in the relational comparisions
+   the precision.  This issue comes up in the relational comparisons
    where we do allow comparisons of values of different precisions.  */
 static inline HOST_WIDE_INT
 selt (const HOST_WIDE_INT *a, unsigned int len,
diff --git a/gcc/wide-int.h b/gcc/wide-int.h
index 2115b61..7235dcd 100644
--- a/gcc/wide-int.h
+++ b/gcc/wide-int.h
@@ -36,7 +36,7 @@ along with GCC; see the file COPYING3.  If not see
      bits above the precision that has been specified.  Because of
      this, the default flavor has semantics that are simple to
      understand and in general model the underlying hardware that the
-     compiler is targetted for.
+     compiler is targeted for.
 
      This flavor must be used at the RTL level of gcc because there
      is, in general, not enough information in the RTL representation
@@ -116,7 +116,7 @@ along with GCC; see the file COPYING3.  If not see
 
    The offset_int and the widest_int flavors are more expensive
    than the default wide int, so in addition to the caveats with these
-   two, the default is the prefered representation.
+   two, the default is the preferred representation.
 
    All three flavors of wide_int are represented as a vector of
    HOST_WIDE_INTs.  The default and widest_int vectors contain enough elements
@@ -225,7 +225,7 @@ along with GCC; see the file COPYING3.  If not see
 
 /* The MAX_BITSIZE_MODE_ANY_INT is automatically generated by a very
    early examination of the target's mode file.  The WIDE_INT_MAX_ELTS
-   can accomodate at least 1 more bit so that unsigned numbers of that
+   can accommodate at least 1 more bit so that unsigned numbers of that
    mode can be represented as a signed value.  Note that it is still
    possible to create fixed_wide_ints that have precisions greater than
    MAX_BITSIZE_MODE_ANY_INT.  This can be useful when representing a
@@ -2139,7 +2139,7 @@ wi::set_bit (const T &x, unsigned int bit)
   return result;
 }
 
-/* Return the mininum of X and Y, treating them both as having
+/* Return the minimum of X and Y, treating them both as having
    signedness SGN.  */
 template <typename T1, typename T2>
 inline WI_BINARY_RESULT (T1, T2)
@@ -2170,7 +2170,7 @@ wi::umin (const T1 &x, const T2 &y)
   return wi::min (x, y, UNSIGNED);
 }
 
-/* Return the maxinum of X and Y, treating them both as having
+/* Return the maximum of X and Y, treating them both as having
    signedness SGN.  */
 template <typename T1, typename T2>
 inline WI_BINARY_RESULT (T1, T2)
@@ -2348,7 +2348,7 @@ wi::add (const T1 &x, const T2 &y)
   return result;
 }
 
-/* Return X + Y.  Treat X and Y as having the signednes given by SGN
+/* Return X + Y.  Treat X and Y as having the signedness given by SGN
    and indicate in *OVERFLOW whether the operation overflowed.  */
 template <typename T1, typename T2>
 inline WI_BINARY_RESULT (T1, T2)
@@ -2421,7 +2421,7 @@ wi::sub (const T1 &x, const T2 &y)
   return result;
 }
 
-/* Return X - Y.  Treat X and Y as having the signednes given by SGN
+/* Return X - Y.  Treat X and Y as having the signedness given by SGN
    and indicate in *OVERFLOW whether the operation overflowed.  */
 template <typename T1, typename T2>
 inline WI_BINARY_RESULT (T1, T2)
@@ -2471,7 +2471,7 @@ wi::mul (const T1 &x, const T2 &y)
   return result;
 }
 
-/* Return X * Y.  Treat X and Y as having the signednes given by SGN
+/* Return X * Y.  Treat X and Y as having the signedness given by SGN
    and indicate in *OVERFLOW whether the operation overflowed.  */
 template <typename T1, typename T2>
 inline WI_BINARY_RESULT (T1, T2)
@@ -2521,7 +2521,7 @@ wi::mul_high (const T1 &x, const T2 &y, signop sgn)
   return result;
 }
 
-/* Return X / Y, rouding towards 0.  Treat X and Y as having the
+/* Return X / Y, rounding towards 0.  Treat X and Y as having the
    signedness given by SGN.  Indicate in *OVERFLOW if the result
    overflows.  */
 template <typename T1, typename T2>
@@ -2540,7 +2540,7 @@ wi::div_trunc (const T1 &x, const T2 &y, signop sgn, bool *overflow)
   return quotient;
 }
 
-/* Return X / Y, rouding towards 0.  Treat X and Y as signed values.  */
+/* Return X / Y, rounding towards 0.  Treat X and Y as signed values.  */
 template <typename T1, typename T2>
 inline WI_BINARY_RESULT (T1, T2)
 wi::sdiv_trunc (const T1 &x, const T2 &y)
@@ -2548,7 +2548,7 @@ wi::sdiv_trunc (const T1 &x, const T2 &y)
   return div_trunc (x, y, SIGNED);
 }
 
-/* Return X / Y, rouding towards 0.  Treat X and Y as unsigned values.  */
+/* Return X / Y, rounding towards 0.  Treat X and Y as unsigned values.  */
 template <typename T1, typename T2>
 inline WI_BINARY_RESULT (T1, T2)
 wi::udiv_trunc (const T1 &x, const T2 &y)
@@ -2556,7 +2556,7 @@ wi::udiv_trunc (const T1 &x, const T2 &y)
   return div_trunc (x, y, UNSIGNED);
 }
 
-/* Return X / Y, rouding towards -inf.  Treat X and Y as having the
+/* Return X / Y, rounding towards -inf.  Treat X and Y as having the
    signedness given by SGN.  Indicate in *OVERFLOW if the result
    overflows.  */
 template <typename T1, typename T2>
@@ -2581,7 +2581,7 @@ wi::div_floor (const T1 &x, const T2 &y, signop sgn, bool *overflow)
   return quotient;
 }
 
-/* Return X / Y, rouding towards -inf.  Treat X and Y as signed values.  */
+/* Return X / Y, rounding towards -inf.  Treat X and Y as signed values.  */
 template <typename T1, typename T2>
 inline WI_BINARY_RESULT (T1, T2)
 wi::sdiv_floor (const T1 &x, const T2 &y)
@@ -2589,7 +2589,7 @@ wi::sdiv_floor (const T1 &x, const T2 &y)
   return div_floor (x, y, SIGNED);
 }
 
-/* Return X / Y, rouding towards -inf.  Treat X and Y as unsigned values.  */
+/* Return X / Y, rounding towards -inf.  Treat X and Y as unsigned values.  */
 /* ??? Why do we have both this and udiv_trunc.  Aren't they the same?  */
 template <typename T1, typename T2>
 inline WI_BINARY_RESULT (T1, T2)
@@ -2598,7 +2598,7 @@ wi::udiv_floor (const T1 &x, const T2 &y)
   return div_floor (x, y, UNSIGNED);
 }
 
-/* Return X / Y, rouding towards +inf.  Treat X and Y as having the
+/* Return X / Y, rounding towards +inf.  Treat X and Y as having the
    signedness given by SGN.  Indicate in *OVERFLOW if the result
    overflows.  */
 template <typename T1, typename T2>
@@ -2623,7 +2623,7 @@ wi::div_ceil (const T1 &x, const T2 &y, signop sgn, bool *overflow)
   return quotient;
 }
 
-/* Return X / Y, rouding towards nearest with ties away from zero.
+/* Return X / Y, rounding towards nearest with ties away from zero.
    Treat X and Y as having the signedness given by SGN.  Indicate
    in *OVERFLOW if the result overflows.  */
 template <typename T1, typename T2>
@@ -2666,7 +2666,7 @@ wi::div_round (const T1 &x, const T2 &y, signop sgn, bool *overflow)
   return quotient;
 }
 
-/* Return X / Y, rouding towards 0.  Treat X and Y as having the
+/* Return X / Y, rounding towards 0.  Treat X and Y as having the
    signedness given by SGN.  Store the remainder in *REMAINDER_PTR.  */
 template <typename T1, typename T2>
 inline WI_BINARY_RESULT (T1, T2)
@@ -2711,7 +2711,7 @@ wi::gcd (const T1 &a, const T2 &b, signop sgn)
   return y;
 }
 
-/* Compute X / Y, rouding towards 0, and return the remainder.
+/* Compute X / Y, rounding towards 0, and return the remainder.
    Treat X and Y as having the signedness given by SGN.  Indicate
    in *OVERFLOW if the division overflows.  */
 template <typename T1, typename T2>
@@ -2732,7 +2732,7 @@ wi::mod_trunc (const T1 &x, const T2 &y, signop sgn, bool *overflow)
   return remainder;
 }
 
-/* Compute X / Y, rouding towards 0, and return the remainder.
+/* Compute X / Y, rounding towards 0, and return the remainder.
    Treat X and Y as signed values.  */
 template <typename T1, typename T2>
 inline WI_BINARY_RESULT (T1, T2)
@@ -2741,7 +2741,7 @@ wi::smod_trunc (const T1 &x, const T2 &y)
   return mod_trunc (x, y, SIGNED);
 }
 
-/* Compute X / Y, rouding towards 0, and return the remainder.
+/* Compute X / Y, rounding towards 0, and return the remainder.
    Treat X and Y as unsigned values.  */
 template <typename T1, typename T2>
 inline WI_BINARY_RESULT (T1, T2)
@@ -2750,7 +2750,7 @@ wi::umod_trunc (const T1 &x, const T2 &y)
   return mod_trunc (x, y, UNSIGNED);
 }
 
-/* Compute X / Y, rouding towards -inf, and return the remainder.
+/* Compute X / Y, rounding towards -inf, and return the remainder.
    Treat X and Y as having the signedness given by SGN.  Indicate
    in *OVERFLOW if the division overflows.  */
 template <typename T1, typename T2>
@@ -2776,7 +2776,7 @@ wi::mod_floor (const T1 &x, const T2 &y, signop sgn, bool *overflow)
   return remainder;
 }
 
-/* Compute X / Y, rouding towards -inf, and return the remainder.
+/* Compute X / Y, rounding towards -inf, and return the remainder.
    Treat X and Y as unsigned values.  */
 /* ??? Why do we have both this and umod_trunc.  Aren't they the same?  */
 template <typename T1, typename T2>
@@ -2786,7 +2786,7 @@ wi::umod_floor (const T1 &x, const T2 &y)
   return mod_floor (x, y, UNSIGNED);
 }
 
-/* Compute X / Y, rouding towards +inf, and return the remainder.
+/* Compute X / Y, rounding towards +inf, and return the remainder.
    Treat X and Y as having the signedness given by SGN.  Indicate
    in *OVERFLOW if the division overflows.  */
 template <typename T1, typename T2>
@@ -2812,7 +2812,7 @@ wi::mod_ceil (const T1 &x, const T2 &y, signop sgn, bool *overflow)
   return remainder;
 }
 
-/* Compute X / Y, rouding towards nearest with ties away from zero,
+/* Compute X / Y, rounding towards nearest with ties away from zero,
    and return the remainder.  Treat X and Y as having the signedness
    given by SGN.  Indicate in *OVERFLOW if the division overflows.  */
 template <typename T1, typename T2>
diff --git a/include/ansidecl.h b/include/ansidecl.h
index f6e1761..cad1ab4 100644
--- a/include/ansidecl.h
+++ b/include/ansidecl.h
@@ -1,4 +1,4 @@
-/* ANSI and traditional C compatability macros
+/* ANSI and traditional C compatibility macros
    Copyright (C) 1991-2017 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
diff --git a/include/demangle.h b/include/demangle.h
index 996203b..3c5ac19 100644
--- a/include/demangle.h
+++ b/include/demangle.h
@@ -289,13 +289,13 @@ enum demangle_component_type
      which this vtable is built.  */
   DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE,
   /* A typeinfo structure.  This has one subtree, the type for which
-     this is the tpeinfo structure.  */
+     this is the typeinfo structure.  */
   DEMANGLE_COMPONENT_TYPEINFO,
   /* A typeinfo name.  This has one subtree, the type for which this
      is the typeinfo name.  */
   DEMANGLE_COMPONENT_TYPEINFO_NAME,
   /* A typeinfo function.  This has one subtree, the type for which
-     this is the tpyeinfo function.  */
+     this is the typeinfo function.  */
   DEMANGLE_COMPONENT_TYPEINFO_FN,
   /* A thunk.  This has one subtree, the name for which this is a
      thunk.  */
diff --git a/include/gomp-constants.h b/include/gomp-constants.h
index 87484f5..a9b1a56 100644
--- a/include/gomp-constants.h
+++ b/include/gomp-constants.h
@@ -247,7 +247,7 @@ enum gomp_map_kind
 /* Target argument index of THREAD_LIMIT.  */
 #define GOMP_TARGET_ARG_THREAD_LIMIT		(2 << 8)
 
-/* If the value is directly embeded in target argument, it should be a 16-bit
+/* If the value is directly embedded in target argument, it should be a 16-bit
    at most and shifted by this many bits.  */
 #define GOMP_TARGET_ARG_VALUE_SHIFT		16
 
diff --git a/include/libiberty.h b/include/libiberty.h
index a0cbbcf..0c19886 100644
--- a/include/libiberty.h
+++ b/include/libiberty.h
@@ -3,7 +3,7 @@
    Copyright (C) 1997-2017 Free Software Foundation, Inc.
    
    Note - certain prototypes declared in this header file are for
-   functions whoes implementation copyright does not belong to the
+   functions whose implementation copyright does not belong to the
    FSF.  Those prototypes are present in this file for reference
    purposes only and their presence in this file should not construed
    as an indication of ownership by the FSF of the implementation of
@@ -442,7 +442,7 @@ extern struct pex_obj *pex_init (int flags, const char *pname,
 #define PEX_BINARY_INPUT	0x10
 
 /* Output file should be opened in binary mode.  This flag is ignored
-   on Unix.  For proper behaviour PEX_BINARY_INPUT and
+   on Unix.  For proper behavior PEX_BINARY_INPUT and
    PEX_BINARY_OUTPUT have to match appropriately--i.e., a call using
    PEX_BINARY_OUTPUT should be followed by a call using
    PEX_BINARY_INPUT.  */
diff --git a/include/plugin-api.h b/include/plugin-api.h
index 3a3e8b4..d6c984a 100644
--- a/include/plugin-api.h
+++ b/include/plugin-api.h
@@ -300,7 +300,7 @@ enum ld_plugin_status
                                          size_t* len);
 
 /* The linker's interface for specifying the desired order of sections.
-   The sections should be specifed using the array SECTION_LIST in the
+   The sections should be specified using the array SECTION_LIST in the
    order in which they should appear in the final layout.  NUM_SECTIONS
    specifies the number of entries in each array.  This should be invoked
    in the all_symbols_read handler.  */
diff --git a/include/safe-ctype.h b/include/safe-ctype.h
index 16d8ebf..e3199fc 100644
--- a/include/safe-ctype.h
+++ b/include/safe-ctype.h
@@ -112,7 +112,7 @@ extern const unsigned char  _sch_tolower[256];
 #define TOUPPER(c) _sch_toupper[(c) & 0xff]
 #define TOLOWER(c) _sch_tolower[(c) & 0xff]
 
-/* Prevent the users of safe-ctype.h from accidently using the routines
+/* Prevent the users of safe-ctype.h from accidentally using the routines
    from ctype.h.  Initially, the approach was to produce an error when
    detecting that ctype.h has been included.  But this was causing
    trouble as ctype.h might get indirectly included as a result of
diff --git a/include/splay-tree.h b/include/splay-tree.h
index d8210f0..3860b73 100644
--- a/include/splay-tree.h
+++ b/include/splay-tree.h
@@ -98,7 +98,7 @@ struct splay_tree_s {
   /* The root of the tree.  */
   splay_tree_node root;
 
-  /* The comparision function.  */
+  /* The comparison function.  */
   splay_tree_compare_fn comp;
 
   /* The deallocate-key function.  NULL if no cleanup is necessary.  */
diff --git a/libcpp/include/cpplib.h b/libcpp/include/cpplib.h
index b843992..6b8efab 100644
--- a/libcpp/include/cpplib.h
+++ b/libcpp/include/cpplib.h
@@ -460,7 +460,7 @@ struct cpp_options
   unsigned char user_literals;
 
   /* Nonzero means warn when a string or character literal is followed by a
-     ud-suffix which does not beging with an underscore.  */
+     ud-suffix which does not begin with an underscore.  */
   unsigned char warn_literal_suffix;
 
   /* Nonzero means interpret imaginary, fixed-point, or other gnu extension
diff --git a/libcpp/include/line-map.h b/libcpp/include/line-map.h
index 90d65d7..ba422ed 100644
--- a/libcpp/include/line-map.h
+++ b/libcpp/include/line-map.h
@@ -109,7 +109,7 @@ typedef unsigned int linenum_type;
              |   This packing scheme means we effectively have
              |     (column_bits - range_bits)
              |   of bits for the columns, typically (12 - 5) = 7, for 128
-             |   columns; longer line widths are accomodated by starting a
+             |   columns; longer line widths are accommodated by starting a
              |   new ordmap with a higher column_bits.
              |
              | ordmap[2]->start_location-1   | Final location in ordmap 1
@@ -1225,7 +1225,7 @@ int linemap_compare_locations (struct line_maps *set,
 			       source_location   post);
 
 /* Return TRUE if LOC_A denotes the location a token that comes
-   topogically before the token denoted by location LOC_B, or if they
+   topologically before the token denoted by location LOC_B, or if they
    are equal.  */
 inline bool
 linemap_location_before_p (struct line_maps *set,
diff --git a/libcpp/internal.h b/libcpp/internal.h
index f24e85c..0356745 100644
--- a/libcpp/internal.h
+++ b/libcpp/internal.h
@@ -323,7 +323,7 @@ struct cpp_buffer
   struct _cpp_file *file;
 
   /* Saved value of __TIMESTAMP__ macro - date and time of last modification
-     of the assotiated file.  */
+     of the associated file.  */
   const unsigned char *timestamp;
 
   /* Value of if_stack at start of this file.
diff --git a/libgcc/libgcov-util.c b/libgcc/libgcov-util.c
index fd1d1dd..b404e25 100644
--- a/libgcc/libgcov-util.c
+++ b/libgcc/libgcov-util.c
@@ -1077,7 +1077,7 @@ struct overlap_t {
 #define FLAG_BOTH_COLD(flag) ((flag & 0x2) && (flag & 0x20))
 #define FLAG_ONE_HOT(flag) ((flag & 0x4) || (flag & 0x40))
 
-/* Cumlative overlap dscore for profile1 and profile2.  */
+/* Cumulative overlap dscore for profile1 and profile2.  */
 static double overlap_sum_1, overlap_sum_2;
 
 /* sum_all for profile1 and profile2.  */
diff --git a/zlib/zlib.h b/zlib/zlib.h
index 49dfcec..c005686 100644
--- a/zlib/zlib.h
+++ b/zlib/zlib.h
@@ -276,7 +276,7 @@ ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
   == 0), or after each call of deflate().  If deflate returns Z_OK and with
   zero avail_out, it must be called again after making room in the output
   buffer because there might be more output pending. See deflatePending(),
-  which can be used if desired to determine whether or not there is more ouput
+  which can be used if desired to determine whether or not there is more output
   in that case.
 
     Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to
@@ -1435,12 +1435,12 @@ ZEXTERN z_size_t ZEXPORT gzfread OF((voidp buf, z_size_t size, z_size_t nitems,
 
      In the event that the end of file is reached and only a partial item is
    available at the end, i.e. the remaining uncompressed data length is not a
-   multiple of size, then the final partial item is nevetheless read into buf
+   multiple of size, then the final partial item is nevertheless read into buf
    and the end-of-file flag is set.  The length of the partial item read is not
    provided, but could be inferred from the result of gztell().  This behavior
    is the same as the behavior of fread() implementations in common libraries,
    but it prevents the direct use of gzfread() to read a concurrently written
-   file, reseting and retrying on end-of-file, when size is not 1.
+   file, resetting and retrying on end-of-file, when size is not 1.
 */
 
 ZEXTERN int ZEXPORT gzwrite OF((gzFile file,
-- 
1.8.5.3

