PR other/16615 [1/5]

2019-01-09  Sandra Loosemore  <sandra@codesourcery.com>

	PR other/16615 [1/5]

	contrib/
	* mklog: Mechanically replace "can not" with "cannot".

	gcc/
	* Makefile.in: Mechanically replace "can not" with "cannot".
	* alias.c: Likewise.
	* builtins.c: Likewise.
	* calls.c: Likewise.
	* cgraph.c: Likewise.
	* cgraph.h: Likewise.
	* cgraphclones.c: Likewise.
	* cgraphunit.c: Likewise.
	* combine-stack-adj.c: Likewise.
	* combine.c: Likewise.
	* common/config/i386/i386-common.c: Likewise.
	* config/aarch64/aarch64.c: Likewise.
	* config/alpha/sync.md: Likewise.
	* config/arc/arc.c: Likewise.
	* config/arc/predicates.md: Likewise.
	* config/arm/arm-c.c: Likewise.
	* config/arm/arm.c: Likewise.
	* config/arm/arm.h: Likewise.
	* config/arm/arm.md: Likewise.
	* config/arm/cortex-r4f.md: Likewise.
	* config/csky/csky.c: Likewise.
	* config/csky/csky.h: Likewise.
	* config/darwin-f.c: Likewise.
	* config/epiphany/epiphany.md: Likewise.
	* config/i386/i386.c: Likewise.
	* config/i386/sol2.h: Likewise.
	* config/m68k/m68k.c: Likewise.
	* config/mcore/mcore.h: Likewise.
	* config/microblaze/microblaze.md: Likewise.
	* config/mips/20kc.md: Likewise.
	* config/mips/sb1.md: Likewise.
	* config/nds32/nds32.c: Likewise.
	* config/nds32/predicates.md: Likewise.
	* config/pa/pa.c: Likewise.
	* config/rs6000/e300c2c3.md: Likewise.
	* config/rs6000/rs6000.c: Likewise.
	* config/s390/s390.h: Likewise.
	* config/sh/sh.c: Likewise.
	* config/sh/sh.md: Likewise.
	* config/spu/vmx2spu.h: Likewise.
	* cprop.c: Likewise.
	* dbxout.c: Likewise.
	* df-scan.c: Likewise.
	* doc/cfg.texi: Likewise.
	* doc/extend.texi: Likewise.
	* doc/fragments.texi: Likewise.
	* doc/gty.texi: Likewise.
	* doc/invoke.texi: Likewise.
	* doc/lto.texi: Likewise.
	* doc/md.texi: Likewise.
	* doc/objc.texi: Likewise.
	* doc/rtl.texi: Likewise.
	* doc/tm.texi: Likewise.
	* dse.c: Likewise.
	* emit-rtl.c: Likewise.
	* emit-rtl.h: Likewise.
	* except.c: Likewise.
	* expmed.c: Likewise.
	* expr.c: Likewise.
	* fold-const.c: Likewise.
	* genautomata.c: Likewise.
	* gimple-fold.c: Likewise.
	* hard-reg-set.h: Likewise.
	* ifcvt.c: Likewise.
	* ipa-comdats.c: Likewise.
	* ipa-cp.c: Likewise.
	* ipa-devirt.c: Likewise.
	* ipa-fnsummary.c: Likewise.
	* ipa-icf.c: Likewise.
	* ipa-inline-transform.c: Likewise.
	* ipa-inline.c: Likewise.
	* ipa-polymorphic-call.c: Likewise.
	* ipa-profile.c: Likewise.
	* ipa-prop.c: Likewise.
	* ipa-pure-const.c: Likewise.
	* ipa-reference.c: Likewise.
	* ipa-split.c: Likewise.
	* ipa-visibility.c: Likewise.
	* ipa.c: Likewise.
	* ira-build.c: Likewise.
	* ira-color.c: Likewise.
	* ira-conflicts.c: Likewise.
	* ira-costs.c: Likewise.
	* ira-int.h: Likewise.
	* ira-lives.c: Likewise.
	* ira.c: Likewise.
	* ira.h: Likewise.
	* loop-invariant.c: Likewise.
	* loop-unroll.c: Likewise.
	* lower-subreg.c: Likewise.
	* lra-assigns.c: Likewise.
	* lra-constraints.c: Likewise.
	* lra-eliminations.c: Likewise.
	* lra-lives.c: Likewise.
	* lra-remat.c: Likewise.
	* lra-spills.c: Likewise.
	* lra.c: Likewise.
	* lto-cgraph.c: Likewise.
	* lto-streamer-out.c: Likewise.
	* postreload-gcse.c: Likewise.
	* predict.c: Likewise.
	* profile-count.h: Likewise.
	* profile.c: Likewise.
	* recog.c: Likewise.
	* ree.c: Likewise.
	* reload.c: Likewise.
	* reload1.c: Likewise.
	* reorg.c: Likewise.
	* resource.c: Likewise.
	* rtl.def: Likewise.
	* rtl.h: Likewise.
	* rtlanal.c: Likewise.
	* sched-deps.c: Likewise.
	* sched-ebb.c: Likewise.
	* sched-rgn.c: Likewise.
	* sel-sched-ir.c: Likewise.
	* sel-sched.c: Likewise.
	* shrink-wrap.c: Likewise.
	* simplify-rtx.c: Likewise.
	* symtab.c: Likewise.
	* target.def: Likewise.
	* toplev.c: Likewise.
	* tree-call-cdce.c: Likewise.
	* tree-cfg.c: Likewise.
	* tree-complex.c: Likewise.
	* tree-core.h: Likewise.
	* tree-eh.c: Likewise.
	* tree-inline.c: Likewise.
	* tree-loop-distribution.c: Likewise.
	* tree-nrv.c: Likewise.
	* tree-profile.c: Likewise.
	* tree-sra.c: Likewise.
	* tree-ssa-alias.c: Likewise.
	* tree-ssa-dce.c: Likewise.
	* tree-ssa-dom.c: Likewise.
	* tree-ssa-forwprop.c: Likewise.
	* tree-ssa-loop-im.c: Likewise.
	* tree-ssa-loop-ivcanon.c: Likewise.
	* tree-ssa-loop-ivopts.c: Likewise.
	* tree-ssa-loop-niter.c: Likewise.
	* tree-ssa-phionlycprop.c: Likewise.
	* tree-ssa-phiopt.c: Likewise.
	* tree-ssa-propagate.c: Likewise.
	* tree-ssa-threadedge.c: Likewise.
	* tree-ssa-threadupdate.c: Likewise.
	* tree-ssa-uninit.c: Likewise.
	* tree-ssanames.c: Likewise.
	* tree-streamer-out.c: Likewise.
	* tree.c: Likewise.
	* tree.h: Likewise.
	* vr-values.c: Likewise.

	gcc/ada/
	* exp_ch9.adb: Mechanically replace "can not" with "cannot".
	* libgnat/s-regpat.ads: Likewise.
	* par-ch4.adb: Likewise.
	* set_targ.adb: Likewise.
	* types.ads: Likewise.

	gcc/cp/
	* cp-tree.h: Mechanically replace "can not" with "cannot".
	* parser.c: Likewise.
	* pt.c: Likewise.

	gcc/fortran/
	* class.c: Mechanically replace "can not" with "cannot".
	* decl.c: Likewise.
	* expr.c: Likewise.
	* gfc-internals.texi: Likewise.
	* intrinsic.texi: Likewise.
	* invoke.texi: Likewise.
	* io.c: Likewise.
	* match.c: Likewise.
	* parse.c: Likewise.
	* primary.c: Likewise.
	* resolve.c: Likewise.
	* symbol.c: Likewise.
	* trans-array.c: Likewise.
	* trans-decl.c: Likewise.
	* trans-intrinsic.c: Likewise.
	* trans-stmt.c: Likewise.

	gcc/go/
	* go-backend.c: Mechanically replace "can not" with "cannot".
	* go-gcc.cc: Likewise.

	gcc/lto/
	* lto-partition.c: Mechanically replace "can not" with "cannot".
	* lto-symtab.c: Likewise.
	* lto.c: Likewise.

	gcc/objc/
	* objc-act.c: Mechanically replace "can not" with "cannot".

	libbacktrace/
	* backtrace.h: Mechanically replace "can not" with "cannot".

	libgcc/
	* config/c6x/libunwind.S: Mechanically replace "can not" with
	"cannot".
	* config/tilepro/atomic.h: Likewise.
	* config/vxlib-tls.c: Likewise.
	* generic-morestack-thread.c: Likewise.
	* generic-morestack.c: Likewise.
	* mkmap-symver.awk: Likewise.

	libgfortran/
	* caf/single.c: Mechanically replace "can not" with "cannot".
	* io/unit.c: Likewise.

	libobjc/
	* class.c: Mechanically replace "can not" with "cannot".
	* objc/runtime.h: Likewise.
	* sendmsg.c: Likewise.

	liboffloadmic/
	* include/coi/common/COIResult_common.h: Mechanically replace
	"can not" with "cannot".
	* include/coi/source/COIBuffer_source.h: Likewise.

	libstdc++-v3/
	* include/ext/bitmap_allocator.h: Mechanically replace "can not"
	with "cannot".

From-SVN: r267783

188 files changed, 624 insertions, 408 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index c8fdce9..749b9bc 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,159 @@
+2019-01-09  Sandra Loosemore  <sandra@codesourcery.com>
+
+	PR other/16615
+
+	* Makefile.in: Mechanically replace "can not" with "cannot".
+	* alias.c: Likewise.
+	* builtins.c: Likewise.
+	* calls.c: Likewise.
+	* cgraph.c: Likewise.
+	* cgraph.h: Likewise.
+	* cgraphclones.c: Likewise.
+	* cgraphunit.c: Likewise.
+	* combine-stack-adj.c: Likewise.
+	* combine.c: Likewise.
+	* common/config/i386/i386-common.c: Likewise.
+	* config/aarch64/aarch64.c: Likewise.
+	* config/alpha/sync.md: Likewise.
+	* config/arc/arc.c: Likewise.
+	* config/arc/predicates.md: Likewise.
+	* config/arm/arm-c.c: Likewise.
+	* config/arm/arm.c: Likewise.
+	* config/arm/arm.h: Likewise.
+	* config/arm/arm.md: Likewise.
+	* config/arm/cortex-r4f.md: Likewise.
+	* config/csky/csky.c: Likewise.
+	* config/csky/csky.h: Likewise.
+	* config/darwin-f.c: Likewise.
+	* config/epiphany/epiphany.md: Likewise.
+	* config/i386/i386.c: Likewise.
+	* config/i386/sol2.h: Likewise.
+	* config/m68k/m68k.c: Likewise.
+	* config/mcore/mcore.h: Likewise.
+	* config/microblaze/microblaze.md: Likewise.
+	* config/mips/20kc.md: Likewise.
+	* config/mips/sb1.md: Likewise.
+	* config/nds32/nds32.c: Likewise.
+	* config/nds32/predicates.md: Likewise.
+	* config/pa/pa.c: Likewise.
+	* config/rs6000/e300c2c3.md: Likewise.
+	* config/rs6000/rs6000.c: Likewise.
+	* config/s390/s390.h: Likewise.
+	* config/sh/sh.c: Likewise.
+	* config/sh/sh.md: Likewise.
+	* config/spu/vmx2spu.h: Likewise.
+	* cprop.c: Likewise.
+	* dbxout.c: Likewise.
+	* df-scan.c: Likewise.
+	* doc/cfg.texi: Likewise.
+	* doc/extend.texi: Likewise.
+	* doc/fragments.texi: Likewise.
+	* doc/gty.texi: Likewise.
+	* doc/invoke.texi: Likewise.
+	* doc/lto.texi: Likewise.
+	* doc/md.texi: Likewise.
+	* doc/objc.texi: Likewise.
+	* doc/rtl.texi: Likewise.
+	* doc/tm.texi: Likewise.
+	* dse.c: Likewise.
+	* emit-rtl.c: Likewise.
+	* emit-rtl.h: Likewise.
+	* except.c: Likewise.
+	* expmed.c: Likewise.
+	* expr.c: Likewise.
+	* fold-const.c: Likewise.
+	* genautomata.c: Likewise.
+	* gimple-fold.c: Likewise.
+	* hard-reg-set.h: Likewise.
+	* ifcvt.c: Likewise.
+	* ipa-comdats.c: Likewise.
+	* ipa-cp.c: Likewise.
+	* ipa-devirt.c: Likewise.
+	* ipa-fnsummary.c: Likewise.
+	* ipa-icf.c: Likewise.
+	* ipa-inline-transform.c: Likewise.
+	* ipa-inline.c: Likewise.
+	* ipa-polymorphic-call.c: Likewise.
+	* ipa-profile.c: Likewise.
+	* ipa-prop.c: Likewise.
+	* ipa-pure-const.c: Likewise.
+	* ipa-reference.c: Likewise.
+	* ipa-split.c: Likewise.
+	* ipa-visibility.c: Likewise.
+	* ipa.c: Likewise.
+	* ira-build.c: Likewise.
+	* ira-color.c: Likewise.
+	* ira-conflicts.c: Likewise.
+	* ira-costs.c: Likewise.
+	* ira-int.h: Likewise.
+	* ira-lives.c: Likewise.
+	* ira.c: Likewise.
+	* ira.h: Likewise.
+	* loop-invariant.c: Likewise.
+	* loop-unroll.c: Likewise.
+	* lower-subreg.c: Likewise.
+	* lra-assigns.c: Likewise.
+	* lra-constraints.c: Likewise.
+	* lra-eliminations.c: Likewise.
+	* lra-lives.c: Likewise.
+	* lra-remat.c: Likewise.
+	* lra-spills.c: Likewise.
+	* lra.c: Likewise.
+	* lto-cgraph.c: Likewise.
+	* lto-streamer-out.c: Likewise.
+	* postreload-gcse.c: Likewise.
+	* predict.c: Likewise.
+	* profile-count.h: Likewise.
+	* profile.c: Likewise.
+	* recog.c: Likewise.
+	* ree.c: Likewise.
+	* reload.c: Likewise.
+	* reload1.c: Likewise.
+	* reorg.c: Likewise.
+	* resource.c: Likewise.
+	* rtl.def: Likewise.
+	* rtl.h: Likewise.
+	* rtlanal.c: Likewise.
+	* sched-deps.c: Likewise.
+	* sched-ebb.c: Likewise.
+	* sched-rgn.c: Likewise.
+	* sel-sched-ir.c: Likewise.
+	* sel-sched.c: Likewise.
+	* shrink-wrap.c: Likewise.
+	* simplify-rtx.c: Likewise.
+	* symtab.c: Likewise.
+	* target.def: Likewise.
+	* toplev.c: Likewise.
+	* tree-call-cdce.c: Likewise.
+	* tree-cfg.c: Likewise.
+	* tree-complex.c: Likewise.
+	* tree-core.h: Likewise.
+	* tree-eh.c: Likewise.
+	* tree-inline.c: Likewise.
+	* tree-loop-distribution.c: Likewise.
+	* tree-nrv.c: Likewise.
+	* tree-profile.c: Likewise.
+	* tree-sra.c: Likewise.
+	* tree-ssa-alias.c: Likewise.
+	* tree-ssa-dce.c: Likewise.
+	* tree-ssa-dom.c: Likewise.
+	* tree-ssa-forwprop.c: Likewise.
+	* tree-ssa-loop-im.c: Likewise.
+	* tree-ssa-loop-ivcanon.c: Likewise.
+	* tree-ssa-loop-ivopts.c: Likewise.
+	* tree-ssa-loop-niter.c: Likewise.
+	* tree-ssa-phionlycprop.c: Likewise.
+	* tree-ssa-phiopt.c: Likewise.
+	* tree-ssa-propagate.c: Likewise.
+	* tree-ssa-threadedge.c: Likewise.
+	* tree-ssa-threadupdate.c: Likewise.
+	* tree-ssa-uninit.c: Likewise.
+	* tree-ssanames.c: Likewise.
+	* tree-streamer-out.c: Likewise.
+	* tree.c: Likewise.
+	* tree.h: Likewise.
+	* vr-values.c: Likewise.
+
 2019-01-09  Uroš Bizjak  <ubizjak@gmail.com>
 
 	* config/i386/i386-protos.h (ix86_expand_xorsign): New prototype.
diff --git a/gcc/Makefile.in b/gcc/Makefile.in
index dc0eba7..2fa9083 100644
--- a/gcc/Makefile.in
+++ b/gcc/Makefile.in
@@ -746,7 +746,7 @@ EXTRA_HEADERS =@extra_headers_list@
 USE_GCC_STDINT = @use_gcc_stdint@
 
 # The configure script will set this to collect2$(exeext), except on a
-# (non-Unix) host which can not build collect2, for which it will be
+# (non-Unix) host which cannot build collect2, for which it will be
 # set to empty.
 COLLECT2 = @collect2@
 
diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog
index 7995c20..402ad92 100644
--- a/gcc/ada/ChangeLog
+++ b/gcc/ada/ChangeLog
@@ -1,3 +1,13 @@
+2019-01-09  Sandra Loosemore  <sandra@codesourcery.com>
+
+	PR other/16615
+
+	* exp_ch9.adb: Mechanically replace "can not" with "cannot".
+	* libgnat/s-regpat.ads: Likewise.
+	* par-ch4.adb: Likewise.
+	* set_targ.adb: Likewise.
+	* types.ads: Likewise.
+
 2019-01-08  Justin Squirek  <squirek@adacore.com>
 
 	Revert:
diff --git a/gcc/ada/exp_ch9.adb b/gcc/ada/exp_ch9.adb
index 78bdb40..5ec9fb4 100644
--- a/gcc/ada/exp_ch9.adb
+++ b/gcc/ada/exp_ch9.adb
@@ -3741,7 +3741,7 @@ package body Exp_Ch9 is
             raise Program_Error;
       end case;
 
-      --  When exceptions can not be propagated, we never need to call
+      --  When exceptions cannot be propagated, we never need to call
       --  Exception_Complete_Entry_Body.
 
       if No_Exception_Handlers_Set then
diff --git a/gcc/ada/libgnat/s-regpat.ads b/gcc/ada/libgnat/s-regpat.ads
index 0a2d2b0..74ecdec 100644
--- a/gcc/ada/libgnat/s-regpat.ads
+++ b/gcc/ada/libgnat/s-regpat.ads
@@ -347,7 +347,7 @@ package System.Regpat is
    --  N'th parenthesized subexpressions; Matches (0) is for the whole
    --  expression.
    --
-   --  Non-capturing parenthesis (introduced with (?:...)) can not be
+   --  Non-capturing parenthesis (introduced with (?:...)) cannot be
    --  retrieved and do not count in the match array index.
    --
    --  For instance, if your regular expression is: "a((b*)c+)(d+)", then
diff --git a/gcc/ada/par-ch4.adb b/gcc/ada/par-ch4.adb
index 4100530..9de9a60 100644
--- a/gcc/ada/par-ch4.adb
+++ b/gcc/ada/par-ch4.adb
@@ -1884,7 +1884,7 @@ package body Ch4 is
    --  called in all contexts where a right parenthesis cannot legitimately
    --  follow an expression.
 
-   --  Error recovery: can not raise Error_Resync
+   --  Error recovery: cannot raise Error_Resync
 
    function P_Expression_No_Right_Paren return Node_Id is
       Expr : constant Node_Id := P_Expression;
diff --git a/gcc/ada/set_targ.adb b/gcc/ada/set_targ.adb
index 910d1e9..ae4a8c6 100755
--- a/gcc/ada/set_targ.adb
+++ b/gcc/ada/set_targ.adb
@@ -820,7 +820,7 @@ package body Set_Targ is
 
 begin
    --  First step: see if the -gnateT switch is present. As we have noted,
-   --  this has to be done very early, so can not depend on the normal circuit
+   --  this has to be done very early, so cannot depend on the normal circuit
    --  for reading switches and setting switches in Opt. The following code
    --  will set Opt.Target_Dependent_Info_Read_Name if the switch -gnateT=name
    --  is present in the options string.
diff --git a/gcc/ada/types.ads b/gcc/ada/types.ads
index 318e29e..1297451 100644
--- a/gcc/ada/types.ads
+++ b/gcc/ada/types.ads
@@ -138,7 +138,7 @@ package Types is
    -- Types Used for Text Buffer Handling --
    -----------------------------------------
 
-   --  We can not use type String for text buffers, since we must use the
+   --  We cannot use type String for text buffers, since we must use the
    --  standard 32-bit integer as an index value, since we count on all index
    --  values being the same size.
 
diff --git a/gcc/alias.c b/gcc/alias.c
index 93f5354..b64e3ea 100644
--- a/gcc/alias.c
+++ b/gcc/alias.c
@@ -832,7 +832,7 @@ get_alias_set (tree t)
 {
   alias_set_type set;
 
-  /* We can not give up with -fno-strict-aliasing because we need to build
+  /* We cannot give up with -fno-strict-aliasing because we need to build
      proper type representation for possible functions which are build with
      -fstrict-aliasing.  */
 
@@ -894,7 +894,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 cannot be meaningfuly computed by the frotnend.  */
       if (canonical_type_used_p (t))
 	{
 	  /* In LTO we set canonical types for all types where it makes
@@ -1058,7 +1058,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
+	     We cannot 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.  */
 	  gcc_checking_assert (p == TYPE_MAIN_VARIANT (p));
@@ -2061,7 +2061,7 @@ may_be_sp_based_p (rtx x)
 }
 
 /* BASE1 and BASE2 are decls.  Return 1 if they refer to same object, 0
-   if they refer to different objects and -1 if we can not decide.  */
+   if they refer to different objects and -1 if we cannot decide.  */
 
 int
 compare_base_decls (tree base1, tree base2)
@@ -2135,7 +2135,7 @@ compare_base_symbol_refs (const_rtx x_base, const_rtx y_base)
 
       symtab_node *x_node = symtab_node::get_create (x_decl)
 			    ->ultimate_alias_target ();
-      /* External variable can not be in section anchor.  */
+      /* External variable cannot be in section anchor.  */
       if (!x_node->definition)
 	return 0;
       x_base = XEXP (DECL_RTL (x_node->decl), 0);
@@ -2651,7 +2651,7 @@ memrefs_conflict_p (poly_int64 xsize, rtx x, poly_int64 ysize, rtx y,
    ways.
 
    If both memory references are volatile, then there must always be a
-   dependence between the two references, since their order can not be
+   dependence between the two references, since their order cannot be
    changed.  A volatile and non-volatile reference can be interchanged
    though.
 
diff --git a/gcc/builtins.c b/gcc/builtins.c
index 28155b8..6135bc5 100644
--- a/gcc/builtins.c
+++ b/gcc/builtins.c
@@ -6529,7 +6529,7 @@ expand_builtin_atomic_fetch_op (machine_mode mode, tree exp, rtx target,
   gcc_assert (TREE_OPERAND (addr, 0) == fndecl);
   TREE_OPERAND (addr, 0) = builtin_decl_explicit (ext_call);
 
-  /* If we will emit code after the call, the call can not be a tail call.
+  /* If we will emit code after the call, the call cannot be a tail call.
      If it is emitted as a tail call, a barrier is emitted after it, and
      then all trailing code is removed.  */
   if (!ignore)
diff --git a/gcc/calls.c b/gcc/calls.c
index 2e5d411..e11977e 100644
--- a/gcc/calls.c
+++ b/gcc/calls.c
@@ -3145,7 +3145,7 @@ can_implement_as_sibling_call_p (tree exp,
     }
 
 #ifdef REG_PARM_STACK_SPACE
-  /* If outgoing reg parm stack space changes, we can not do sibcall.  */
+  /* If outgoing reg parm stack space changes, we cannot do sibcall.  */
   if (OUTGOING_REG_PARM_STACK_SPACE (funtype)
       != OUTGOING_REG_PARM_STACK_SPACE (TREE_TYPE (current_function_decl))
       || (reg_parm_stack_space != REG_PARM_STACK_SPACE (current_function_decl)))
@@ -4294,7 +4294,7 @@ expand_call (tree exp, rtx target, int ignore)
 
 	  emit_move_insn (temp, valreg);
 
-	  /* The return value from a malloc-like function can not alias
+	  /* The return value from a malloc-like function cannot alias
 	     anything else.  */
 	  last = get_last_insn ();
 	  add_reg_note (last, REG_NOALIAS, temp);
diff --git a/gcc/cgraph.c b/gcc/cgraph.c
index cac4af3..c9788d0 100644
--- a/gcc/cgraph.c
+++ b/gcc/cgraph.c
@@ -2708,7 +2708,7 @@ cgraph_node::set_pure_flag (bool pure, bool looping)
   return info.changed;
 }
 
-/* Return true when cgraph_node can not return or throw and thus
+/* Return true when cgraph_node cannot return or throw and thus
    it is safe to ignore its side effects for IPA analysis.  */
 
 bool
@@ -2722,7 +2722,7 @@ cgraph_node::cannot_return_p (void)
 	     == (ECF_NORETURN | ECF_NOTHROW));
 }
 
-/* Return true when call of edge can not lead to return from caller
+/* Return true when call of edge cannot lead to return from caller
    and thus it is safe to ignore its side effects for IPA analysis
    when computing side effects of the caller.
    FIXME: We could actually mark all edges that have no reaching
diff --git a/gcc/cgraph.h b/gcc/cgraph.h
index 920169c..c016da3 100644
--- a/gcc/cgraph.h
+++ b/gcc/cgraph.h
@@ -51,7 +51,7 @@ enum symtab_type
 struct GTY((for_user)) section_hash_entry
 {
   int ref_count;
-  char *name;  /* As long as this datastructure stays in GGC, we can not put
+  char *name;  /* As long as this datastructure stays in GGC, we cannot put
 		  string at the tail of structure of GGC dies in horrible
 		  way  */
 };
@@ -283,7 +283,7 @@ public:
 				    void *data,
 				    bool include_overwrite);
 
-  /* If node can not be interposable by static or dynamic linker to point to
+  /* If node cannot be interposable by static or dynamic linker to point to
      different definition, return this symbol. Otherwise look for alias with
      such property and if none exists, introduce new one.  */
   symtab_node *noninterposable_alias (void);
@@ -482,7 +482,7 @@ public:
   /* C++ frontend produce same body aliases and extra name aliases for
      virtual functions and vtables that are obviously equivalent.
      Those aliases are bit special, especially because C++ frontend
-     visibility code is so ugly it can not get them right at first time
+     visibility code is so ugly it cannot get them right at first time
      and their visibility needs to be copied from their "masters" at
      the end of parsing.  */
   unsigned cpp_implicit_alias : 1;
@@ -709,7 +709,7 @@ struct GTY(()) cgraph_local_info {
   /* False when there is something makes versioning impossible.  */
   unsigned versionable : 1;
 
-  /* False when function calling convention and signature can not be changed.
+  /* False when function calling convention and signature cannot be changed.
      This is the case when __builtin_apply_args is used.  */
   unsigned can_change_signature : 1;
 
@@ -1229,7 +1229,7 @@ public:
      compilation units.  */
   bool can_be_local_p (void);
 
-  /* Return true when cgraph_node can not return or throw and thus
+  /* Return true when cgraph_node cannot return or throw and thus
      it is safe to ignore its side effects for IPA analysis.  */
   bool cannot_return_p (void);
 
@@ -1577,7 +1577,7 @@ public:
 
   /* Adjust all offsets in contexts by given number of bits.  */
   void offset_by (HOST_WIDE_INT);
-  /* Use when we can not track dynamic type change.  This speculatively assume
+  /* Use when we cannot 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
@@ -1709,7 +1709,7 @@ struct GTY((chain_next ("%h.next_caller"), chain_prev ("%h.prev_caller"),
   /* Verify edge count and frequency.  */
   bool verify_count ();
 
-  /* Return true when call of edge can not lead to return from caller
+  /* Return true when call of edge cannot lead to return from caller
      and thus it is safe to ignore its side effects for IPA analysis
      when computing side effects of the caller.  */
   bool cannot_lead_to_return_p (void);
@@ -2933,7 +2933,7 @@ cgraph_node::can_remove_if_no_direct_calls_and_refs_p (void)
   /* Extern inlines can always go, we will use the external definition.  */
   if (DECL_EXTERNAL (decl))
     return true;
-  /* When function is needed, we can not remove it.  */
+  /* When function is needed, we cannot remove it.  */
   if (force_output || used_from_other_partition)
     return false;
   if (DECL_STATIC_CONSTRUCTOR (decl)
diff --git a/gcc/cgraphclones.c b/gcc/cgraphclones.c
index 10ae2a9..4688de9 100644
--- a/gcc/cgraphclones.c
+++ b/gcc/cgraphclones.c
@@ -648,7 +648,7 @@ cgraph_node::create_virtual_clone (vec<cgraph_edge *> redirect_callers,
   DECL_ARGUMENTS (new_decl) = NULL;
   DECL_INITIAL (new_decl) = NULL;
   DECL_RESULT (new_decl) = NULL; 
-  /* We can not do DECL_RESULT (new_decl) = NULL; here because of LTO partitioning
+  /* We cannot do DECL_RESULT (new_decl) = NULL; here because of LTO partitioning
      sometimes storing only clone decl instead of original.  */
 
   /* Generate a new name for the new version. */
diff --git a/gcc/cgraphunit.c b/gcc/cgraphunit.c
index c39a24d..1cf9ac5 100644
--- a/gcc/cgraphunit.c
+++ b/gcc/cgraphunit.c
@@ -1051,7 +1051,7 @@ analyze_functions (bool first_time)
   symtab->state = CONSTRUCTION;
   input_location = UNKNOWN_LOCATION;
 
-  /* Ugly, but the fixup can not happen at a time same body alias is created;
+  /* Ugly, but the fixup cannot happen at a time same body alias is created;
      C++ FE is confused about the COMDAT groups being right.  */
   if (symtab->cpp_implicit_aliases_done)
     FOR_EACH_SYMBOL (node)
diff --git a/gcc/combine-stack-adj.c b/gcc/combine-stack-adj.c
index dabfa9e..3638a1b 100644
--- a/gcc/combine-stack-adj.c
+++ b/gcc/combine-stack-adj.c
@@ -540,7 +540,7 @@ combine_stack_adjustments_for_block (basic_block bb)
 		 Also we need to be careful to not move stack pointer
 		 such that we create stack accesses outside the allocated
 		 area.  We can combine an allocation into the first insn,
-		 or a deallocation into the second insn.  We can not
+		 or a deallocation into the second insn.  We cannot
 		 combine an allocation followed by a deallocation.
 
 		 The only somewhat frequent occurrence of the later is when
diff --git a/gcc/combine.c b/gcc/combine.c
index a8c9d15..e226c7dd 100644
--- a/gcc/combine.c
+++ b/gcc/combine.c
@@ -530,7 +530,7 @@ target_canonicalize_comparison (enum rtx_code *code, rtx *op0, rtx *op1,
 }
 
 /* Try to split PATTERN found in INSN.  This returns NULL_RTX if
-   PATTERN can not be split.  Otherwise, it returns an insn sequence.
+   PATTERN cannot be split.  Otherwise, it returns an insn sequence.
    This is a wrapper around split_insns which ensures that the
    reg_stat vector is made larger if the splitter creates a new
    register.  */
diff --git a/gcc/common/config/i386/i386-common.c b/gcc/common/config/i386/i386-common.c
index b87e0b6..a5dac6d 100644
--- a/gcc/common/config/i386/i386-common.c
+++ b/gcc/common/config/i386/i386-common.c
@@ -1411,7 +1411,7 @@ ix86_option_init_struct (struct gcc_options *opts)
 }
 
 /* On the x86 -fsplit-stack and -fstack-protector both use the same
-   field in the TCB, so they can not be used together.  */
+   field in the TCB, so they cannot be used together.  */
 
 static bool
 ix86_supports_split_stack (bool report ATTRIBUTE_UNUSED,
diff --git a/gcc/config/aarch64/aarch64.c b/gcc/config/aarch64/aarch64.c
index 0b0bc85..1c300af 100644
--- a/gcc/config/aarch64/aarch64.c
+++ b/gcc/config/aarch64/aarch64.c
@@ -14780,7 +14780,7 @@ aarch64_simd_dup_constant (rtx vals)
 /* Generate code to load VALS, which is a PARALLEL containing only
    constants (for vec_init) or CONST_VECTOR, efficiently into a
    register.  Returns an RTX to copy into the register, or NULL_RTX
-   for a PARALLEL that can not be converted into a CONST_VECTOR.  */
+   for a PARALLEL that cannot be converted into a CONST_VECTOR.  */
 static rtx
 aarch64_simd_make_constant (rtx vals)
 {
@@ -14818,12 +14818,12 @@ aarch64_simd_make_constant (rtx vals)
     /* Loaded using DUP.  */
     return const_dup;
   else if (const_vec != NULL_RTX)
-    /* Load from constant pool. We can not take advantage of single-cycle
+    /* Load from constant pool. We cannot take advantage of single-cycle
        LD1 because we need a PC-relative addressing mode.  */
     return const_vec;
   else
     /* A PARALLEL containing something not valid inside CONST_VECTOR.
-       We can not construct an initializer.  */
+       We cannot construct an initializer.  */
     return NULL_RTX;
 }
 
diff --git a/gcc/config/alpha/sync.md b/gcc/config/alpha/sync.md
index 2c0663d..c416ad4 100644
--- a/gcc/config/alpha/sync.md
+++ b/gcc/config/alpha/sync.md
@@ -65,7 +65,7 @@
 ;; the lock is cleared by a normal load or store.  This means we cannot
 ;; expand a ll/sc sequence before reload, lest a register spill is
 ;; inserted inside the sequence.  It is also UNPREDICTABLE whether the
-;; lock is cleared by a TAKEN branch.  This means that we can not expand
+;; lock is cleared by a TAKEN branch.  This means that we cannot expand
 ;; a ll/sc sequence containing a branch (i.e. compare-and-swap) until after
 ;; the final basic-block reordering pass.
 
diff --git a/gcc/config/arc/arc.c b/gcc/config/arc/arc.c
index 9a8f159..de2c8d5 100644
--- a/gcc/config/arc/arc.c
+++ b/gcc/config/arc/arc.c
@@ -8477,7 +8477,7 @@ arc_reorg (void)
         Brcc.d b, c, s9
         Brcc.d b, u6, s9
 
-        For cc={GT, LE, GTU, LEU}, u6=63 can not be allowed,
+        For cc={GT, LE, GTU, LEU}, u6=63 cannot be allowed,
       since they are encoded by the assembler as {GE, LT, HS, LS} 64, which
       does not have a delay slot
 
diff --git a/gcc/config/arc/predicates.md b/gcc/config/arc/predicates.md
index f003a0f..72fbf2a 100644
--- a/gcc/config/arc/predicates.md
+++ b/gcc/config/arc/predicates.md
@@ -696,7 +696,7 @@
        (match_test "REGNO (op) == (TARGET_BIG_ENDIAN ? 59 : 58)")
        (match_test "TARGET_V2")))
 
-; Unfortunately, we can not allow a const_int_operand before reload, because
+; Unfortunately, we cannot allow a const_int_operand before reload, because
 ; reload needs a non-void mode to guide it how to reload the inside of a
 ; {sign_}extend.
 (define_predicate "extend_operand"
diff --git a/gcc/config/arm/arm-c.c b/gcc/config/arm/arm-c.c
index 89119c3..ab4a0ab 100644
--- a/gcc/config/arm/arm-c.c
+++ b/gcc/config/arm/arm-c.c
@@ -28,7 +28,7 @@
 #include "c-family/c-pragma.h"
 #include "stringpool.h"
 
-/* Output C specific EABI object attributes.  These can not be done in
+/* Output C specific EABI object attributes.  These cannot be done in
    arm.c because they require information from the C frontend.  */
 
 static void
diff --git a/gcc/config/arm/arm.c b/gcc/config/arm/arm.c
index 3419b6b..8392380 100644
--- a/gcc/config/arm/arm.c
+++ b/gcc/config/arm/arm.c
@@ -2885,7 +2885,7 @@ arm_option_check_internal (struct gcc_options *opts)
     error ("iWMMXt unsupported under Thumb mode");
 
   if (TARGET_HARD_TP && TARGET_THUMB1_P (flags))
-    error ("can not use -mtp=cp15 with 16-bit Thumb");
+    error ("cannot use -mtp=cp15 with 16-bit Thumb");
 
   if (TARGET_THUMB_P (flags) && TARGET_VXWORKS_RTP && flag_pic)
     {
@@ -12327,7 +12327,7 @@ neon_vdup_constant (rtx vals)
 /* Generate code to load VALS, which is a PARALLEL containing only
    constants (for vec_init) or CONST_VECTOR, efficiently into a
    register.  Returns an RTX to copy into the register, or NULL_RTX
-   for a PARALLEL that can not be converted into a CONST_VECTOR.  */
+   for a PARALLEL that cannot be converted into a CONST_VECTOR.  */
 
 rtx
 neon_make_constant (rtx vals)
@@ -12369,13 +12369,13 @@ neon_make_constant (rtx vals)
     return target;
   else if (const_vec != NULL_RTX)
     /* Load from constant pool.  On Cortex-A8 this takes two cycles
-       (for either double or quad vectors).  We can not take advantage
+       (for either double or quad vectors).  We cannot take advantage
        of single-cycle VLD1 because we need a PC-relative addressing
        mode.  */
     return const_vec;
   else
     /* A PARALLEL containing something not valid inside CONST_VECTOR.
-       We can not construct an initializer.  */
+       We cannot construct an initializer.  */
     return NULL_RTX;
 }
 
@@ -16063,7 +16063,7 @@ add_minipool_forward_ref (Mfix *fix)
   Mnode *       mp;
 
   /* If the minipool starts before the end of FIX->INSN then this FIX
-     can not be placed into the current pool.  Furthermore, adding the
+     cannot be placed into the current pool.  Furthermore, adding the
      new constant pool entry may cause the pool to start FIX_SIZE bytes
      earlier.  */
   if (minipool_vector_head &&
diff --git a/gcc/config/arm/arm.h b/gcc/config/arm/arm.h
index 7acbce7..5cebabe 100644
--- a/gcc/config/arm/arm.h
+++ b/gcc/config/arm/arm.h
@@ -1168,7 +1168,7 @@ enum reg_class
    : GET_MODE_SIZE (MODE) >= 4 ? BASE_REGS			\
    : LO_REGS)
 
-/* For Thumb we can not support SP+reg addressing, so we return LO_REGS
+/* For Thumb we cannot support SP+reg addressing, so we return LO_REGS
    instead of BASE_REGS.  */
 #define MODE_BASE_REG_REG_CLASS(MODE) BASE_REG_CLASS
 
@@ -1647,7 +1647,7 @@ enum arm_auto_incmodes
    : ARM_REGNO_OK_FOR_BASE_P (REGNO))
 
 /* Nonzero if X can be the base register in a reg+reg addressing mode.
-   For Thumb, we can not use SP + reg, so reject SP.  */
+   For Thumb, we cannot use SP + reg, so reject SP.  */
 #define REGNO_MODE_OK_FOR_REG_BASE_P(X, MODE)	\
   REGNO_MODE_OK_FOR_BASE_P (X, QImode)
 
@@ -1823,7 +1823,7 @@ enum arm_auto_incmodes
    : ARM_REG_OK_FOR_INDEX_P (X))
 
 /* Nonzero if X can be the base register in a reg+reg addressing mode.
-   For Thumb, we can not use SP + reg, so reject SP.  */
+   For Thumb, we cannot use SP + reg, so reject SP.  */
 #define REG_MODE_OK_FOR_REG_BASE_P(X, MODE)	\
   REG_OK_FOR_INDEX_P (X)
 
diff --git a/gcc/config/arm/arm.md b/gcc/config/arm/arm.md
index 93c7897..aa75962 100644
--- a/gcc/config/arm/arm.md
+++ b/gcc/config/arm/arm.md
@@ -287,7 +287,7 @@
 ; CLOB means that the condition codes are altered in an undefined manner, if
 ;   they are altered at all
 ;
-; UNCONDITIONAL means the instruction can not be conditionally executed and
+; UNCONDITIONAL means the instruction cannot be conditionally executed and
 ;   that the instruction does not use or alter the condition codes.
 ;
 ; NOCOND means that the instruction does not use or alter the condition
@@ -7406,7 +7406,7 @@
 )
 
 ;; DImode comparisons.  The generic code generates branches that
-;; if-conversion can not reduce to a conditional compare, so we do
+;; if-conversion cannot reduce to a conditional compare, so we do
 ;; that directly.
 
 (define_insn_and_split "*arm_cmpdi_insn"
diff --git a/gcc/config/arm/cortex-r4f.md b/gcc/config/arm/cortex-r4f.md
index 0829b9c..1aac831 100644
--- a/gcc/config/arm/cortex-r4f.md
+++ b/gcc/config/arm/cortex-r4f.md
@@ -115,7 +115,7 @@
 		  "cortex_r4_fmacs"
 		  "arm_no_early_mul_dep")
 
-;; Double precision operations.  These can not dual issue.
+;; Double precision operations.  These cannot dual issue.
 
 (define_insn_reservation "cortex_r4_fmacd" 20
  (and (eq_attr "tune_cortexr4" "yes")
diff --git a/gcc/config/csky/csky.c b/gcc/config/csky/csky.c
index dd361a9..8a3c909 100644
--- a/gcc/config/csky/csky.c
+++ b/gcc/config/csky/csky.c
@@ -967,7 +967,7 @@ add_csky_minipool_forward_ref (Mfix *fix)
   Mnode *mp;
 
   /* If the minipool starts before the end of FIX->INSN then this FIX
-     can not be placed into the current pool.  Furthermore, adding the
+     cannot be placed into the current pool.  Furthermore, adding the
      new constant pool entry may cause the pool to start FIX_SIZE bytes
      earlier.  */
   if (minipool_vector_head
diff --git a/gcc/config/csky/csky.h b/gcc/config/csky/csky.h
index 76d13c40..ea95290 100644
--- a/gcc/config/csky/csky.h
+++ b/gcc/config/csky/csky.h
@@ -923,7 +923,7 @@ extern const int csky_dbx_regno[];
 #define MOVE_MAX 4
 
 /* Shift counts are truncated to 6-bits (0 to 63) instead of the expected
-   5-bits, so we can not define SHIFT_COUNT_TRUNCATED to true for this
+   5-bits, so we cannot define SHIFT_COUNT_TRUNCATED to true for this
    target.  */
 #define SHIFT_COUNT_TRUNCATED 0
 
diff --git a/gcc/config/darwin-f.c b/gcc/config/darwin-f.c
index 9a4d496..69a9eea 100644
--- a/gcc/config/darwin-f.c
+++ b/gcc/config/darwin-f.c
@@ -22,7 +22,7 @@ along with GCC; see the file COPYING3.  If not see
 /* Provide stubs for the hooks defined by darwin.h
      TARGET_EXTRA_PRE_INCLUDES, TARGET_EXTRA_INCLUDES
 
-   As both, gcc and gfortran link in incpath.o, we can not
+   As both, gcc and gfortran link in incpath.o, we cannot
    conditionally undefine said hooks if fortran is build.
    However, we can define do-nothing stubs of said hooks as
    we are not interested in objc include files in Fortran.
diff --git a/gcc/config/epiphany/epiphany.md b/gcc/config/epiphany/epiphany.md
index 240118a..be9ea9a 100644
--- a/gcc/config/epiphany/epiphany.md
+++ b/gcc/config/epiphany/epiphany.md
@@ -1039,7 +1039,7 @@
 ; use next_active_insn to look at the 'following' insn.  That should
 ; exist, because peephole2 runs after reload, and there has to be
 ; a return after an fp_int insn.
-; ??? However, we can not even ordinarily match the preceding insn;
+; ??? However, we cannot even ordinarily match the preceding insn;
 ; there is some bug in the generators such that then it leaves out
 ; the check for PARALLEL before the length check for the then-second
 ; main insn.  Observed when compiling compatibility-atomic-c++0x.cc
diff --git a/gcc/config/i386/i386.c b/gcc/config/i386/i386.c
index 628ec80..0e23eaa 100644
--- a/gcc/config/i386/i386.c
+++ b/gcc/config/i386/i386.c
@@ -29759,13 +29759,13 @@ ix86_local_alignment (tree exp, machine_mode mode,
      a C99 variable-length array variable always has alignment of at least 16 bytes.
 
      This was added to allow use of aligned SSE instructions at arrays.  This
-     rule is meant for static storage (where compiler can not do the analysis
+     rule is meant for static storage (where compiler cannot do the analysis
      by itself).  We follow it for automatic variables only when convenient.
      We fully control everything in the function compiled and functions from
-     other unit can not rely on the alignment.
+     other unit cannot rely on the alignment.
 
      Exclude va_list type.  It is the common case of local array where
-     we can not benefit from the alignment.  
+     we cannot benefit from the alignment.  
 
      TODO: Probably one should optimize for size only when var is not escaping.  */
   if (TARGET_64BIT && optimize_function_for_speed_p (cfun)
diff --git a/gcc/config/i386/sol2.h b/gcc/config/i386/sol2.h
index 6555ea7..09e401c 100644
--- a/gcc/config/i386/sol2.h
+++ b/gcc/config/i386/sol2.h
@@ -26,7 +26,7 @@ along with GCC; see the file COPYING3.  If not see
 #undef STACK_REALIGN_DEFAULT
 #define STACK_REALIGN_DEFAULT (TARGET_64BIT ? 0 : 1)
 
-/* Old versions of the Solaris assembler can not handle the difference of
+/* Old versions of the Solaris assembler cannot handle the difference of
    labels in different sections, so force DW_EH_PE_datarel if so.  */
 #ifndef HAVE_AS_IX86_DIFF_SECT_DELTA
 #undef ASM_PREFERRED_EH_DATA_FORMAT
diff --git a/gcc/config/m68k/m68k.c b/gcc/config/m68k/m68k.c
index c566614..bd389ea 100644
--- a/gcc/config/m68k/m68k.c
+++ b/gcc/config/m68k/m68k.c
@@ -2541,7 +2541,7 @@ m68k_call_tls_get_addr (rtx x, rtx eqv, enum m68k_reloc reloc)
      consider (plus (%a5) (const (unspec))) to be a good enough
      operand for push, so it forces it into a register.  The bad
      thing about this is that combiner, due to copy propagation and other
-     optimizations, sometimes can not later fix this.  As a consequence,
+     optimizations, sometimes cannot later fix this.  As a consequence,
      additional register may be allocated resulting in a spill.
      For reference, see args processing loops in
      calls.c:emit_library_call_value_1.
diff --git a/gcc/config/mcore/mcore.h b/gcc/config/mcore/mcore.h
index 3f84bf0d..5830c85 100644
--- a/gcc/config/mcore/mcore.h
+++ b/gcc/config/mcore/mcore.h
@@ -533,7 +533,7 @@ extern const enum reg_class regno_reg_class[FIRST_PSEUDO_REGISTER];
 #define SLOW_BYTE_ACCESS TARGET_SLOW_BYTES
 
 /* Shift counts are truncated to 6-bits (0 to 63) instead of the expected
-   5-bits, so we can not define SHIFT_COUNT_TRUNCATED to true for this
+   5-bits, so we cannot define SHIFT_COUNT_TRUNCATED to true for this
    target.  */
 #define SHIFT_COUNT_TRUNCATED 0
 
diff --git a/gcc/config/microblaze/microblaze.md b/gcc/config/microblaze/microblaze.md
index bb432ae..183afff 100644
--- a/gcc/config/microblaze/microblaze.md
+++ b/gcc/config/microblaze/microblaze.md
@@ -124,10 +124,10 @@
      DEFINE_AUTOMATON).
 
      All define_reservations and define_cpu_units should have unique
-     names which can not be "nothing".
+     names which cannot be "nothing".
 
    o (exclusion_set string string) means that each CPU function unit
-     in the first string can not be reserved simultaneously with each
+     in the first string cannot be reserved simultaneously with each
      unit whose name is in the second string and vise versa.  CPU
      units in the string are separated by commas. For example, it is
      useful for description CPU with fully pipelined floating point
@@ -135,18 +135,18 @@
      floating point insns or only double floating point insns.
 
    o (presence_set string string) means that each CPU function unit in
-     the first string can not be reserved unless at least one of units
+     the first string cannot be reserved unless at least one of units
      whose names are in the second string is reserved.  This is an
      asymmetric relation.  CPU units in the string are separated by
      commas.  For example, it is useful for description that slot1 is
      reserved after slot0 reservation for a VLIW processor.
 
    o (absence_set string string) means that each CPU function unit in
-     the first string can not be reserved only if each unit whose name
+     the first string cannot be reserved only if each unit whose name
      is in the second string is not reserved.  This is an asymmetric
      relation (actually exclusion set is analogous to this one but it
      is symmetric).  CPU units in the string are separated by commas.
-     For example, it is useful for description that slot0 can not be
+     For example, it is useful for description that slot0 cannot be
      reserved after slot1 or slot2 reservation for a VLIW processor.
 
    o (define_bypass number out_insn_names in_insn_names) names bypass with
@@ -169,7 +169,7 @@
      case, you describe common part and use one its name (the 1st
      parameter) in regular expression in define_insn_reservation.  All
      define_reservations, define results and define_cpu_units should
-     have unique names which can not be "nothing".
+     have unique names which cannot be "nothing".
 
    o (define_insn_reservation name default_latency condition regexpr)
      describes reservation of cpu functional units (the 3nd operand)
diff --git a/gcc/config/mips/20kc.md b/gcc/config/mips/20kc.md
index 65d601b..d2fbce0 100644
--- a/gcc/config/mips/20kc.md
+++ b/gcc/config/mips/20kc.md
@@ -71,7 +71,7 @@
 (exclusion_set "r20kc_fpu_add" "r20kc_fpu_mpy, r20kc_fpu_divsqrt")
 (exclusion_set "r20kc_fpu_mpy" "r20kc_fpu_divsqrt")
 
-;; After branch any insn can not be issued.
+;; After branch any insn cannot be issued.
 (absence_set "r20kc_iss0,r20kc_iss1" "r20kc_ixub_branch")
 
 ;;
diff --git a/gcc/config/mips/sb1.md b/gcc/config/mips/sb1.md
index 2c1c068..9e3cbe3 100644
--- a/gcc/config/mips/sb1.md
+++ b/gcc/config/mips/sb1.md
@@ -127,7 +127,7 @@
 ;; register as destination.
 
 ;; ??? SB-1 can co-issue a load with a dependent arith insn if it executes on
-;; an EX unit.  Can not co-issue if the dependent insn executes on an LS unit.
+;; an EX unit.  Cannot co-issue if the dependent insn executes on an LS unit.
 ;; SB-1A can always co-issue here.
 
 ;; A load normally has a latency of zero cycles.  In some cases, dependent
@@ -144,7 +144,7 @@
        (eq_attr "type" "load,prefetch"))
   "sb1_ls0 | sb1_ls1")
 
-;; Can not co-issue fpload with fp exe when in 32-bit mode.
+;; Cannot co-issue fpload with fp exe when in 32-bit mode.
 
 (define_insn_reservation "ir_sb1_fpload" 0
   (and (eq_attr "cpu" "sb1,sb1a")
@@ -252,7 +252,7 @@
        (eq_attr "type" "const,arith,logical,move,signext"))
   "sb1_ls1 | sb1_ex1 | sb1_ex0")
 
-;; On SB-1A, simple alu instructions can not execute on the LS1 unit, and we
+;; On SB-1A, simple alu instructions cannot execute on the LS1 unit, and we
 ;; have none of the above problems.
 
 (define_insn_reservation "ir_sb1a_simple_alu" 1
diff --git a/gcc/config/nds32/nds32.c b/gcc/config/nds32/nds32.c
index 1051a2c..b4f4ede 100644
--- a/gcc/config/nds32/nds32.c
+++ b/gcc/config/nds32/nds32.c
@@ -1354,7 +1354,7 @@ nds32_emit_adjust_frame (rtx to_reg, rtx from_reg, int adjust_value)
       frame_adjust_insn = emit_insn (frame_adjust_insn);
 
       /* Because (tmp_reg <- full_value) may be split into two
-	 rtl patterns, we can not set its RTX_FRAME_RELATED_P.
+	 rtl patterns, we cannot set its RTX_FRAME_RELATED_P.
 	 We need to construct another (sp <- sp + full_value)
 	 and then insert it into sp_adjust_insn's reg note to
 	 represent a frame related expression.
@@ -5352,7 +5352,7 @@ nds32_can_use_return_insn (void)
   int sp_adjust;
 
   /* Prior to reloading, we can't tell how many registers must be saved.
-     Thus we can not determine whether this function has null epilogue.  */
+     Thus we cannot determine whether this function has null epilogue.  */
   if (!reload_completed)
     return 0;
 
diff --git a/gcc/config/nds32/predicates.md b/gcc/config/nds32/predicates.md
index 14b2f2a..79ae8ea 100644
--- a/gcc/config/nds32/predicates.md
+++ b/gcc/config/nds32/predicates.md
@@ -114,7 +114,7 @@
        (not (match_code "high,const,symbol_ref,label_ref")))
 {
   /* If the constant op does NOT satisfy Is20 nor Ihig,
-     we can not perform move behavior by a single instruction.  */
+     we cannot perform move behavior by a single instruction.  */
   if (CONST_INT_P (op)
       && !satisfies_constraint_Is20 (op)
       && !satisfies_constraint_Ihig (op))
@@ -128,7 +128,7 @@
        (not (match_code "high,const,symbol_ref,label_ref")))
 {
   /* If the constant op does NOT satisfy Is20 nor Ihig,
-     we can not perform move behavior by a single instruction.  */
+     we cannot perform move behavior by a single instruction.  */
   if (GET_CODE (op) == CONST_VECTOR
       && !satisfies_constraint_CVs2 (op)
       && !satisfies_constraint_CVhi (op))
diff --git a/gcc/config/pa/pa.c b/gcc/config/pa/pa.c
index 868538b..5042683 100644
--- a/gcc/config/pa/pa.c
+++ b/gcc/config/pa/pa.c
@@ -4013,7 +4013,7 @@ pa_expand_prologue (void)
 	     the callee registers.  */
 	  if (VAL_14_BITS_P (actual_fsize) && local_fsize == 0)
 	    merge_sp_adjust_with_store = 1;
-	  /* Can not optimize.  Adjust the stack frame by actual_fsize
+	  /* Cannot optimize.  Adjust the stack frame by actual_fsize
 	     bytes.  */
 	  else
 	    set_reg_plus_d (STACK_POINTER_REGNUM, STACK_POINTER_REGNUM,
diff --git a/gcc/config/rs6000/e300c2c3.md b/gcc/config/rs6000/e300c2c3.md
index 669c185..6fee4d9 100644
--- a/gcc/config/rs6000/e300c2c3.md
+++ b/gcc/config/rs6000/e300c2c3.md
@@ -22,7 +22,7 @@
 (define_cpu_unit "ppce300c3_decode_0,ppce300c3_decode_1" "ppce300c3_most")
 
 ;; We don't simulate general issue queue (GIC).  If we have SU insn
-;; and then SU1 insn, they can not be issued on the same cycle
+;; and then SU1 insn, they cannot be issued on the same cycle
 ;; (although SU1 insn and then SU insn can be issued) because the SU
 ;; insn will go to SU1 from GIC0 entry.  Fortunately, the first cycle
 ;; multipass insn scheduling will find the situation and issue the SU1
@@ -31,7 +31,7 @@
 
 ;; We could describe completion buffers slots in combination with the
 ;; retirement units and the order of completion but the result
-;; automaton would behave in the same way because we can not describe
+;; automaton would behave in the same way because we cannot describe
 ;; real latency time with taking in order completion into account.
 ;; Actually we could define the real latency time by querying reserved
 ;; automaton units but the current scheduler uses latency time before
diff --git a/gcc/config/rs6000/rs6000.c b/gcc/config/rs6000/rs6000.c
index 548032f..0357dc8 100644
--- a/gcc/config/rs6000/rs6000.c
+++ b/gcc/config/rs6000/rs6000.c
@@ -8118,7 +8118,7 @@ legitimate_lo_sum_address_p (machine_mode mode, rtx x, int strict)
 	 recognizes some LO_SUM addresses as valid although this
 	 function says opposite.  In most cases, LRA through different
 	 transformations can generate correct code for address reloads.
-	 It can not manage only some LO_SUM cases.  So we need to add
+	 It cannot manage only some LO_SUM cases.  So we need to add
 	 code analogous to one in rs6000_legitimize_reload_address for
 	 LOW_SUM here saying that some addresses are still valid.  */
       large_toc_ok = (lra_in_progress && TARGET_CMODEL != CMODEL_SMALL
@@ -28983,7 +28983,7 @@ rs6000_output_function_epilogue (FILE *file)
 	 length fields that follow.  However, if you omit the optional
 	 fields, the assembler outputs zeros for all optional fields
 	 anyways, giving each variable length field is minimum length
-	 (as defined in sys/debug.h).  Thus we can not use the .tbtab
+	 (as defined in sys/debug.h).  Thus we cannot use the .tbtab
 	 pseudo-op at all.  */
 
       /* An all-zero word flags the start of the tbtab, for debuggers
diff --git a/gcc/config/s390/s390.h b/gcc/config/s390/s390.h
index ee03c8a..3ea7c38 100644
--- a/gcc/config/s390/s390.h
+++ b/gcc/config/s390/s390.h
@@ -1047,7 +1047,7 @@ extern const struct s390_processor processor_table[];
 
 /* Target pragma.  */
 
-/* resolve_overloaded_builtin can not be defined the normal way since
+/* resolve_overloaded_builtin cannot be defined the normal way since
    it is defined in code which technically belongs to the
    front-end.  */
 #define REGISTER_TARGET_PRAGMAS()		\
diff --git a/gcc/config/sh/sh.c b/gcc/config/sh/sh.c
index 35fae65..fcb7cff 100644
--- a/gcc/config/sh/sh.c
+++ b/gcc/config/sh/sh.c
@@ -921,7 +921,7 @@ sh_option_override (void)
 	 to the pressure on R0.  */
       /* Enable sched1 for SH4 if the user explicitly requests.
 	 When sched1 is enabled, the ready queue will be reordered by
-	 the target hooks if pressure is high.  We can not do this for
+	 the target hooks if pressure is high.  We cannot do this for
 	 PIC, SH3 and lower as they give spill failures for R0.  */
       if (!TARGET_HARD_SH4 || flag_pic)
 	flag_schedule_insns = 0;
diff --git a/gcc/config/sh/sh.md b/gcc/config/sh/sh.md
index e28c45f..8354377 100644
--- a/gcc/config/sh/sh.md
+++ b/gcc/config/sh/sh.md
@@ -7170,7 +7170,7 @@
 })
 
 ;; The use of operand 1 / 2 helps us distinguish case table jumps
-;; which can be present in structured code from indirect jumps which can not
+;; which can be present in structured code from indirect jumps which cannot
 ;; be present in structured code.  This allows -fprofile-arcs to work.
 
 ;; For SH1 processors.
diff --git a/gcc/config/spu/vmx2spu.h b/gcc/config/spu/vmx2spu.h
index fbbf7ca..75ab594 100644
--- a/gcc/config/spu/vmx2spu.h
+++ b/gcc/config/spu/vmx2spu.h
@@ -2302,7 +2302,7 @@ static inline vec_int4 vec_unpackh(vec_short8 a)
 
 #ifdef SUPPORT_UNPACK_PIXEL
 /* Due to type conflicts, unpacking of pixel types and boolean shorts
- * can not simultaneously be supported. By default, the boolean short is
+ * cannot simultaneously be supported. By default, the boolean short is
  * supported.
  */
 static inline vec_uint4 vec_unpackh(vec_pixel8 a)
@@ -2356,7 +2356,7 @@ static inline vec_int4 vec_unpackl(vec_short8 a)
 
 #ifdef SUPPORT_UNPACK_PIXEL
 /* Due to type conflicts, unpacking of pixel types and boolean shorts
- * can not simultaneously be supported. By default, the boolean short is
+ * cannot simultaneously be supported. By default, the boolean short is
  * supported.
  */
 static inline vec_uint4 vec_unpackl(vec_pixel8 a)
diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 3167b49..b3ee2a5 100644
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,11 @@
+2019-01-09  Sandra Loosemore  <sandra@codesourcery.com>
+
+	PR other/16615
+
+	* cp-tree.h: Mechanically replace "can not" with "cannot".
+	* parser.c: Likewise.
+	* pt.c: Likewise.
+
 2019-01-08  Paolo Carlini  <paolo.carlini@oracle.com>
 
 	* decl.c (grok_reference_init): Improve error location.
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index 4473904..5648946 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -4229,7 +4229,7 @@ more_aggr_init_expr_args_p (const aggr_init_expr_arg_iterator *iter)
 #define IMPLICIT_CONV_EXPR_NONTYPE_ARG(NODE) \
   (TREE_LANG_FLAG_1 (IMPLICIT_CONV_EXPR_CHECK (NODE)))
 
-/* Nonzero means that an object of this type can not be initialized using
+/* Nonzero means that an object of this type cannot be initialized using
    an initializer list.  */
 #define CLASSTYPE_NON_AGGREGATE(NODE) \
   (LANG_TYPE_CLASS_CHECK (NODE)->non_aggregate)
diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
index f441943..be669f2 100644
--- a/gcc/cp/parser.c
+++ b/gcc/cp/parser.c
@@ -1646,7 +1646,7 @@ declarator_can_be_parameter_pack (cp_declarator *declarator)
 
   /* Search for a declarator name, or any other declarator that goes
      after the point where the ellipsis could appear in a parameter
-     pack. If we find any of these, then this declarator can not be
+     pack. If we find any of these, then this declarator cannot be
      made into a parameter pack.  */
   bool found = false;
   while (declarator && !found)
diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index e216ef5..84f59a2 100644
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -1925,7 +1925,7 @@ explicit_class_specialization_p (tree type)
 }
 
 /* Print the list of functions at FNS, going through all the overloads
-   for each element of the list.  Alternatively, FNS can not be a
+   for each element of the list.  Alternatively, FNS cannot be a
    TREE_LIST, in which case it will be printed together with all the
    overloads.
 
@@ -22065,7 +22065,7 @@ unify (tree tparms, tree targs, tree parm, tree arg, int strict,
       /* If the argument deduction results is a METHOD_TYPE,
          then there is a problem.
          METHOD_TYPE doesn't map to any real C++ type the result of
-	 the deduction can not be of that type.  */
+	 the deduction cannot be of that type.  */
       if (TREE_CODE (arg) == METHOD_TYPE)
 	return unify_method_type_error (explain_p, arg);
 
diff --git a/gcc/cprop.c b/gcc/cprop.c
index cd0e29a..65c0130 100644
--- a/gcc/cprop.c
+++ b/gcc/cprop.c
@@ -839,7 +839,7 @@ find_avail_set (int regno, rtx_insn *insn, struct cprop_expr *set_ret[2])
        (set (reg X) (reg Y))
        (set (reg Y) (reg X))
 
-     This can not happen since the set of (reg Y) would have killed the
+     This cannot happen since the set of (reg Y) would have killed the
      set of (reg X) making it unavailable at the start of this block.  */
   while (1)
     {
diff --git a/gcc/dbxout.c b/gcc/dbxout.c
index bd74d0a..81577df 100644
--- a/gcc/dbxout.c
+++ b/gcc/dbxout.c
@@ -2817,7 +2817,7 @@ dbxout_symbol (tree decl, int local ATTRIBUTE_UNUSED)
                 /* Do not generate a tag for incomplete records.  */
                 && COMPLETE_TYPE_P (type)
 		/* Do not generate a tag for records of variable size,
-		   since this type can not be properly described in the
+		   since this type cannot be properly described in the
 		   DBX format, and it confuses some tools such as objdump.  */
 		&& tree_fits_uhwi_p (TYPE_SIZE (type)))
 	      {
diff --git a/gcc/df-scan.c b/gcc/df-scan.c
index eeccf65..644d01e 100644
--- a/gcc/df-scan.c
+++ b/gcc/df-scan.c
@@ -2982,7 +2982,7 @@ df_uses_record (struct df_collection_rec *collection_rec,
 	   scanned and regs_asm_clobbered is filled out.
 
 	   For all ASM_OPERANDS, we must traverse the vector of input
-	   operands.  We can not just fall through here since then we
+	   operands.  We cannot just fall through here since then we
 	   would be confused by the ASM_INPUT rtx inside ASM_OPERANDS,
 	   which do not indicate traditional asms unlike their normal
 	   usage.  */
diff --git a/gcc/doc/cfg.texi b/gcc/doc/cfg.texi
index 21c3ea5..ee1a1c6 100644
--- a/gcc/doc/cfg.texi
+++ b/gcc/doc/cfg.texi
@@ -32,7 +32,7 @@ passes pipeline, and even from @code{GIMPLE} to @code{RTL}.
 
 Often the CFG may be better viewed as integral part of instruction
 chain, than structure built on the top of it.  Updating the compiler's
-intermediate representation for instructions can not be easily done
+intermediate representation for instructions cannot be easily done
 without proper maintenance of the CFG simultaneously.
 
 @menu
diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi
index 7f33be4..f013057 100644
--- a/gcc/doc/extend.texi
+++ b/gcc/doc/extend.texi
@@ -10054,7 +10054,7 @@ register.
 
 @subsubheading Declaring the variable
 
-Global register variables can not have initial values, because an
+Global register variables cannot have initial values, because an
 executable file has no means to supply initial contents for a register.
 
 When selecting a register, choose one that is normally saved and 
diff --git a/gcc/doc/fragments.texi b/gcc/doc/fragments.texi
index bf93abe..299adef 100644
--- a/gcc/doc/fragments.texi
+++ b/gcc/doc/fragments.texi
@@ -63,7 +63,7 @@ in @code{EXTRA-PARTS}.
 @findex MULTILIB_OPTIONS
 @item MULTILIB_OPTIONS
 For some targets, invoking GCC in different ways produces objects
-that can not be linked together.  For example, for some targets GCC
+that cannot be linked together.  For example, for some targets GCC
 produces both big and little endian code.  For these targets, you must
 arrange for multiple versions of @file{libgcc.a} to be compiled, one for
 each set of incompatible options.  When GCC invokes the linker, it
diff --git a/gcc/doc/gty.texi b/gcc/doc/gty.texi
index 7d4d212..4f3cd4f 100644
--- a/gcc/doc/gty.texi
+++ b/gcc/doc/gty.texi
@@ -362,7 +362,7 @@ referenced.  But the memory that the pointer points to is an array of
 find pointers to mark or relocate, which is why it is marked with the
 @code{atomic} option.
 
-Note that, currently, global variables can not be marked with
+Note that, currently, global variables cannot be marked with
 @code{atomic}; only fields of a struct can.  This is a known
 limitation.  It would be useful to be able to mark global pointers
 with @code{atomic} to make the PCH machinery aware of them so that
diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi
index 56649bf..abfb1d1 100644
--- a/gcc/doc/invoke.texi
+++ b/gcc/doc/invoke.texi
@@ -13064,7 +13064,7 @@ most of benefits of whole program optimizations are however lost.
 During the incremental link (by @option{-r}) the linker plugin will default to
 @option{rel}. With current interfaces to GNU Binutils it is however not
 possible to link incrementally LTO objects and non-LTO objects into a single
-mixed object file.  In the case any of object files in incremental link can not
+mixed object file.  In the case any of object files in incremental link cannot
 be used for link-time optimization the linker plugin will output warning and
 use @samp{nolto-rel}. To maintain the whole program optimization it is
 recommended to link such objects into static library instead. Alternatively it
@@ -25771,7 +25771,7 @@ if this option were not present.
 @item -mfixed-range=@var{register-range}
 @opindex mfixed-range
 Generate code treating the given register range as fixed registers.
-A fixed register is one that the register allocator can not use.  This is
+A fixed register is one that the register allocator cannot use.  This is
 useful when compiling kernel code.  A register range is specified as
 two registers separated by a dash.  Multiple register ranges can be
 specified separated by a comma.
@@ -28463,7 +28463,7 @@ Note that @option{-mcmodel=large} is incompatible with
 not be reachable in the large code model.
 
 Note that @option{-mindirect-branch=thunk-extern} is incompatible with
-@option{-fcf-protection=branch} since the external thunk can not be modified
+@option{-fcf-protection=branch} since the external thunk cannot be modified
 to disable control-flow check.
 
 @item -mfunction-return=@var{choice}
diff --git a/gcc/doc/lto.texi b/gcc/doc/lto.texi
index d19dc09..771e827 100644
--- a/gcc/doc/lto.texi
+++ b/gcc/doc/lto.texi
@@ -353,7 +353,7 @@ To simplify development, the GCC pass manager differentiates
 between normal inter-procedural passes and small inter-procedural
 passes.  A @emph{small inter-procedural pass}
 (@code{SIMPLE_IPA_PASS}) is a pass that does
-everything at once and thus it can not be executed during WPA in
+everything at once and thus it cannot be executed during WPA in
 WHOPR mode.  It defines only the @emph{Execute} stage and during
 this stage it accesses and modifies the function bodies.  Such
 passes are useful for optimization at LGEN or LTRANS time and are
diff --git a/gcc/doc/md.texi b/gcc/doc/md.texi
index 42b0296..18b8af0 100644
--- a/gcc/doc/md.texi
+++ b/gcc/doc/md.texi
@@ -4583,7 +4583,7 @@ The syntax and semantics are otherwise identical to
 
 @deffn {MD Expression} define_special_memory_constraint name docstring exp
 Use this expression for constraints that match a subset of all memory
-operands: that is, @code{reload} can not make them match by reloading
+operands: that is, @code{reload} cannot make them match by reloading
 the address as it is described for @code{define_memory_constraint} or
 such address reload is undesirable with the performance point of view.
 
@@ -6213,8 +6213,8 @@ in a way that the blocks are not required to be aligned according to it in
 all cases. This expected alignment is also in bytes, just like operand 4.
 Expected size, when unknown, is set to @code{(const_int -1)}.
 Operand 7 is the minimal size of the block and operand 8 is the
-maximal size of the block (NULL if it can not be represented as CONST_INT).
-Operand 9 is the probable maximal size (i.e.@: we can not rely on it for
+maximal size of the block (NULL if it cannot be represented as CONST_INT).
+Operand 9 is the probable maximal size (i.e.@: we cannot rely on it for
 correctness, but it can be used for choosing proper code sequence for a
 given size).
 
@@ -9901,7 +9901,7 @@ the common part by the following construction
 @var{reservation-name} is a string giving name of @var{regexp}.
 Functional unit names and reservation names are in the same name
 space.  So the reservation names should be different from the
-functional unit names and can not be the reserved name @samp{nothing}.
+functional unit names and cannot be the reserved name @samp{nothing}.
 
 @findex define_bypass
 @cindex instruction latency time
@@ -9967,7 +9967,7 @@ separated by comma.  Currently pattern is one unit or units
 separated by white-spaces.
 
 The first construction (@samp{exclusion_set}) means that each
-functional unit in the first string can not be reserved simultaneously
+functional unit in the first string cannot be reserved simultaneously
 with a unit whose name is in the second string and vice versa.  For
 example, the construction is useful for describing processors
 (e.g.@: some SPARC processors) with a fully pipelined floating point
@@ -9975,7 +9975,7 @@ functional unit which can execute simultaneously only single floating
 point insns or only double floating point insns.
 
 The second construction (@samp{presence_set}) means that each
-functional unit in the first string can not be reserved unless at
+functional unit in the first string cannot be reserved unless at
 least one of pattern of units whose names are in the second string is
 reserved.  This is an asymmetric relation.  For example, it is useful
 for description that @acronym{VLIW} @samp{slot1} is reserved after
@@ -10030,7 +10030,7 @@ can be described as:
 (absence_set "slot0" "slot1, slot2")
 @end smallexample
 
-Or @samp{slot2} can not be reserved if @samp{slot0} and unit @samp{b0}
+Or @samp{slot2} cannot be reserved if @samp{slot0} and unit @samp{b0}
 are reserved or @samp{slot1} and unit @samp{b1} are reserved.  In
 this case we could write
 
@@ -10133,7 +10133,7 @@ are issued into the second pipeline.  Integer division and
 multiplication insns can be executed only in the second integer
 pipeline and their results are ready correspondingly in 9 and 4
 cycles.  The integer division is not pipelined, i.e.@: the subsequent
-integer division insn can not be issued until the current division
+integer division insn cannot be issued until the current division
 insn finished.  Floating point insns are fully pipelined and their
 results are ready in 3 cycles.  Where the result of a floating point
 insn is used by an integer insn, an additional delay of one cycle is
diff --git a/gcc/doc/objc.texi b/gcc/doc/objc.texi
index 634c773..29039ea 100644
--- a/gcc/doc/objc.texi
+++ b/gcc/doc/objc.texi
@@ -1165,7 +1165,7 @@ in dynamically registering the method.
 To configure the hook, you set the global variable
 @code{__objc_msg_forward2} to a function with the same argument and
 return types of @code{objc_msg_lookup()}.  When
-@code{objc_msg_lookup()} can not find a method implementation, it
+@code{objc_msg_lookup()} cannot find a method implementation, it
 invokes the hook function you provided to get a method implementation
 to return.  So, in practice @code{__objc_msg_forward2} allows you to
 extend @code{objc_msg_lookup()} by adding some custom code that is
diff --git a/gcc/doc/rtl.texi b/gcc/doc/rtl.texi
index 5832910..f5f2de7 100644
--- a/gcc/doc/rtl.texi
+++ b/gcc/doc/rtl.texi
@@ -2897,7 +2897,7 @@ in the @code{insv} or @code{extv} pattern.
 The mode @var{m} is the same as the mode that would be used for
 @var{loc} if it were a register.
 
-A @code{sign_extract} can not appear as an lvalue, or part thereof,
+A @code{sign_extract} cannot appear as an lvalue, or part thereof,
 in RTL.
 
 @findex zero_extract
@@ -3157,7 +3157,7 @@ given the value @var{x} and the rest of the register is not changed.
 If @var{lval} is a @code{zero_extract}, then the referenced part of
 the bit-field (a memory or register reference) specified by the
 @code{zero_extract} is given the value @var{x} and the rest of the
-bit-field is not changed.  Note that @code{sign_extract} can not
+bit-field is not changed.  Note that @code{sign_extract} cannot
 appear in @var{lval}.
 
 If @var{lval} is @code{(cc0)}, it has no machine mode, and @var{x} may
diff --git a/gcc/doc/tm.texi b/gcc/doc/tm.texi
index edc0902..ddde4a7 100644
--- a/gcc/doc/tm.texi
+++ b/gcc/doc/tm.texi
@@ -4960,7 +4960,7 @@ or @code{NULL} if this is an indirect call.
 It is not uncommon for limitations of calling conventions to prevent
 tail calls to functions outside the current unit of translation, or
 during PIC compilation.  The hook is used to enforce these restrictions,
-as the @code{sibcall} md pattern can not fail, or fall over to a
+as the @code{sibcall} md pattern cannot fail, or fall over to a
 ``normal'' call.  The criteria for successful sibling call optimization
 may vary greatly between different architectures.
 @end deftypefn
diff --git a/gcc/dse.c b/gcc/dse.c
index 0407308..389c52d 100644
--- a/gcc/dse.c
+++ b/gcc/dse.c
@@ -2587,7 +2587,7 @@ remove_useless_values (cselib_val *base)
       bool del = false;
 
       /* If ANY of the store_infos match the cselib group that is
-	 being deleted, then the insn can not be deleted.  */
+	 being deleted, then the insn cannot be deleted.  */
       while (store_info)
 	{
 	  if ((store_info->group_id == -1)
diff --git a/gcc/emit-rtl.c b/gcc/emit-rtl.c
index 187d612..4b0aa7c 100644
--- a/gcc/emit-rtl.c
+++ b/gcc/emit-rtl.c
@@ -1781,7 +1781,7 @@ operand_subword_force (rtx op, poly_uint64 offset, machine_mode mode)
 
   if (mode != BLKmode && mode != VOIDmode)
     {
-      /* If this is a register which can not be accessed by words, copy it
+      /* If this is a register which cannot be accessed by words, copy it
 	 to a pseudo register.  */
       if (REG_P (op))
 	op = copy_to_reg (op);
diff --git a/gcc/emit-rtl.h b/gcc/emit-rtl.h
index bc28d48..edf66b5 100644
--- a/gcc/emit-rtl.h
+++ b/gcc/emit-rtl.h
@@ -245,7 +245,7 @@ struct GTY(()) rtl_data {
   /* True if dbr_schedule has already been called for this function.  */
   bool dbr_scheduled_p;
 
-  /* True if current function can not throw.  Unlike
+  /* True if current function cannot throw.  Unlike
      TREE_NOTHROW (current_function_decl) it is set even for overwritable
      function where currently compiled version of it is nothrow.  */
   bool nothrow;
diff --git a/gcc/except.c b/gcc/except.c
index 8ce6bc5..10fef2f 100644
--- a/gcc/except.c
+++ b/gcc/except.c
@@ -1159,7 +1159,7 @@ sjlj_emit_function_enter (rtx_code_label *dispatch_label)
 
   /* We're storing this libcall's address into memory instead of
      calling it directly.  Thus, we must call assemble_external_libcall
-     here, as we can not depend on emit_library_call to do it for us.  */
+     here, as we cannot depend on emit_library_call to do it for us.  */
   assemble_external_libcall (personality);
   mem = adjust_address (fc, Pmode, sjlj_fc_personality_ofs);
   emit_move_insn (mem, personality);
diff --git a/gcc/expmed.c b/gcc/expmed.c
index b207a34..b7f55a7 100644
--- a/gcc/expmed.c
+++ b/gcc/expmed.c
@@ -3876,7 +3876,7 @@ expmed_mult_highpart_optab (scalar_int_mode mode, rtx op0, rtx op1,
 
 /* Emit code to multiply OP0 and OP1 (where OP1 is an integer constant),
    putting the high half of the result in TARGET if that is convenient,
-   and return where the result is.  If the operation can not be performed,
+   and return where the result is.  If the operation cannot be performed,
    0 is returned.
 
    MODE is the mode of operation and result.
diff --git a/gcc/expr.c b/gcc/expr.c
index 818ee2d..6ccba9d 100644
--- a/gcc/expr.c
+++ b/gcc/expr.c
@@ -1550,7 +1550,7 @@ compare_by_pieces (rtx arg0, rtx arg1, unsigned HOST_WIDE_INT len,
    ALIGN is the maximum alignment we can assume they have.
    METHOD describes what kind of copy this is, and what mechanisms may be used.
    MIN_SIZE is the minimal size of block to move
-   MAX_SIZE is the maximal size of block to move, if it can not be represented
+   MAX_SIZE is the maximal size of block to move, if it cannot be represented
    in unsigned HOST_WIDE_INT, than it is mask of all ones.
 
    Return the address of the new block, if memcpy is called and returns it,
@@ -1789,7 +1789,7 @@ emit_block_move_via_movmem (rtx x, rtx y, rtx size, unsigned int align,
 	  if (nops >= 8)
 	    {
 	      create_integer_operand (&ops[6], min_size);
-	      /* If we can not represent the maximal size,
+	      /* If we cannot represent the maximal size,
 		 make parameter NULL.  */
 	      if ((HOST_WIDE_INT) max_size != -1)
 	        create_integer_operand (&ops[7], max_size);
@@ -1798,7 +1798,7 @@ emit_block_move_via_movmem (rtx x, rtx y, rtx size, unsigned int align,
 	    }
 	  if (nops == 9)
 	    {
-	      /* If we can not represent the maximal size,
+	      /* If we cannot represent the maximal size,
 		 make parameter NULL.  */
 	      if ((HOST_WIDE_INT) probable_max_size != -1)
 	        create_integer_operand (&ops[8], probable_max_size);
@@ -3144,7 +3144,7 @@ set_storage_via_setmem (rtx object, rtx size, rtx val, unsigned int align,
 	  if (nops >= 8)
 	    {
 	      create_integer_operand (&ops[6], min_size);
-	      /* If we can not represent the maximal size,
+	      /* If we cannot represent the maximal size,
 		 make parameter NULL.  */
 	      if ((HOST_WIDE_INT) max_size != -1)
 	        create_integer_operand (&ops[7], max_size);
@@ -3153,7 +3153,7 @@ set_storage_via_setmem (rtx object, rtx size, rtx val, unsigned int align,
 	    }
 	  if (nops == 9)
 	    {
-	      /* If we can not represent the maximal size,
+	      /* If we cannot represent the maximal size,
 		 make parameter NULL.  */
 	      if ((HOST_WIDE_INT) probable_max_size != -1)
 	        create_integer_operand (&ops[8], probable_max_size);
diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index 0fdb914..640a6ec 100644
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -735,7 +735,7 @@ fold_negate_expr (location_t loc, tree t)
   return fold_convert_loc (loc, type, tem);
 }
 
-/* Like fold_negate_expr, but return a NEGATE_EXPR tree, if T can not be
+/* Like fold_negate_expr, but return a NEGATE_EXPR tree, if T cannot be
    negated in a simpler way.  Also allow for T to be NULL_TREE, in which case
    return NULL_TREE. */
 
@@ -8419,7 +8419,7 @@ maybe_canonicalize_comparison (location_t loc, enum tree_code code, tree type,
 
 /* Return whether BASE + OFFSET + BITPOS may wrap around the address
    space.  This is used to avoid issuing overflow warnings for
-   expressions like &p->x which can not wrap.  */
+   expressions like &p->x which cannot wrap.  */
 
 static bool
 pointer_may_wrap_p (tree base, tree offset, poly_int64 bitpos)
diff --git a/gcc/fortran/ChangeLog b/gcc/fortran/ChangeLog
index 14e402c..8e81904 100644
--- a/gcc/fortran/ChangeLog
+++ b/gcc/fortran/ChangeLog
@@ -1,3 +1,24 @@
+2019-01-09  Sandra Loosemore  <sandra@codesourcery.com>
+
+	PR other/16615
+
+	* class.c: Mechanically replace "can not" with "cannot".
+	* decl.c: Likewise.
+	* expr.c: Likewise.
+	* gfc-internals.texi: Likewise.
+	* intrinsic.texi: Likewise.
+	* invoke.texi: Likewise.
+	* io.c: Likewise.
+	* match.c: Likewise.
+	* parse.c: Likewise.
+	* primary.c: Likewise.
+	* resolve.c: Likewise.
+	* symbol.c: Likewise.
+	* trans-array.c: Likewise.
+	* trans-decl.c: Likewise.
+	* trans-intrinsic.c: Likewise.
+	* trans-stmt.c: Likewise.
+
 2019-01-09  Thomas Koenig  <tkoenig@gcc.gnu.org>
 
 	PR fortran/68426
diff --git a/gcc/fortran/class.c b/gcc/fortran/class.c
index 8809b5b..6c6139b 100644
--- a/gcc/fortran/class.c
+++ b/gcc/fortran/class.c
@@ -630,7 +630,7 @@ gfc_build_class_symbol (gfc_typespec *ts, symbol_attribute *attr,
 		   || attr->select_type_temporary || attr->associate_var;
 
   if (!attr->class_ok)
-    /* We can not build the class container yet.  */
+    /* We cannot build the class container yet.  */
     return true;
 
   /* Determine the name of the encapsulating type.  */
diff --git a/gcc/fortran/decl.c b/gcc/fortran/decl.c
index 29a57d3..460c45d 100644
--- a/gcc/fortran/decl.c
+++ b/gcc/fortran/decl.c
@@ -2440,7 +2440,7 @@ variable_decl (int elem)
 
   /* At this point, we know for sure if the symbol is PARAMETER and can thus
      determine (and check) whether it can be implied-shape.  If it
-     was parsed as assumed-size, change it because PARAMETERs can not
+     was parsed as assumed-size, change it because PARAMETERs cannot
      be assumed-size.
 
      An explicit-shape-array cannot appear under several conditions.
@@ -5673,7 +5673,7 @@ verify_bind_c_sym (gfc_symbol *tmp_sym, gfc_typespec *ts,
 	  retval = false;
 	}
 
-      /* Scalar variables that are bind(c) can not have the pointer
+      /* Scalar variables that are bind(c) cannot have the pointer
 	 or allocatable attributes.  */
       if (tmp_sym->attr.is_bind_c == 1)
 	{
@@ -5702,7 +5702,7 @@ verify_bind_c_sym (gfc_symbol *tmp_sym, gfc_typespec *ts,
 	gfc_error ("Return type of BIND(C) function %qs at %L cannot "
 		   "be an array", tmp_sym->name, &(tmp_sym->declared_at));
 
-      /* BIND(C) functions can not return a character string.  */
+      /* BIND(C) functions cannot return a character string.  */
       if (bind_c_function && tmp_sym->ts.type == BT_CHARACTER)
 	if (tmp_sym->ts.u.cl == NULL || tmp_sym->ts.u.cl->length == NULL
 	    || tmp_sym->ts.u.cl->length->expr_type != EXPR_CONSTANT
diff --git a/gcc/fortran/expr.c b/gcc/fortran/expr.c
index cd8d4dd..bc318f7 100644
--- a/gcc/fortran/expr.c
+++ b/gcc/fortran/expr.c
@@ -2050,7 +2050,7 @@ scalarize_intrinsic_call (gfc_expr *, bool init_flag);
      1   Simplifying array constructors -- will substitute
 	 iterator values.
    Returns false on error, true otherwise.
-   NOTE: Will return true even if the expression can not be simplified.  */
+   NOTE: Will return true even if the expression cannot be simplified.  */
 
 bool
 gfc_simplify_expr (gfc_expr *p, int type)
@@ -5981,7 +5981,7 @@ gfc_check_vardef_context (gfc_expr* e, bool pointer, bool alloc_obj,
       if (pointer && is_pointer)
 	{
 	  if (context)
-	    gfc_error ("Variable %qs is PROTECTED and can not appear in a"
+	    gfc_error ("Variable %qs is PROTECTED and cannot appear in a"
 		       " pointer association context (%s) at %L",
 		       sym->name, context, &e->where);
 	  return false;
@@ -5989,7 +5989,7 @@ gfc_check_vardef_context (gfc_expr* e, bool pointer, bool alloc_obj,
       if (!pointer && !is_pointer)
 	{
 	  if (context)
-	    gfc_error ("Variable %qs is PROTECTED and can not appear in a"
+	    gfc_error ("Variable %qs is PROTECTED and cannot appear in a"
 		       " variable definition context (%s) at %L",
 		       sym->name, context, &e->where);
 	  return false;
@@ -6001,7 +6001,7 @@ gfc_check_vardef_context (gfc_expr* e, bool pointer, bool alloc_obj,
   if (!pointer && !own_scope && gfc_pure (NULL) && gfc_impure_variable (sym))
     {
       if (context)
-	gfc_error ("Variable %qs can not appear in a variable definition"
+	gfc_error ("Variable %qs cannot appear in a variable definition"
 		   " context (%s) at %L in PURE procedure",
 		   sym->name, context, &e->where);
       return false;
@@ -6075,9 +6075,9 @@ gfc_check_vardef_context (gfc_expr* e, bool pointer, bool alloc_obj,
       if (!gfc_check_vardef_context (assoc->target, pointer, false, false, NULL))
 	{
 	  if (context)
-	    gfc_error ("Associate-name %qs can not appear in a variable"
+	    gfc_error ("Associate-name %qs cannot appear in a variable"
 		       " definition context (%s) at %L because its target"
-		       " at %L can not, either",
+		       " at %L cannot, either",
 		       name, context, &e->where,
 		       &assoc->target->where);
 	  return false;
diff --git a/gcc/fortran/gfc-internals.texi b/gcc/fortran/gfc-internals.texi
index e8e05f0..d65d5de 100644
--- a/gcc/fortran/gfc-internals.texi
+++ b/gcc/fortran/gfc-internals.texi
@@ -715,7 +715,7 @@ array member @code{tb_op} indexed by the intrinsic operator's enum
 value.  Those need not be packed into @code{gfc_symtree} structures and are
 only @code{gfc_typebound_proc} instances.
 
-When an operator call or assignment is found that can not be handled in
+When an operator call or assignment is found that cannot be handled in
 another way (i.e. neither matches an intrinsic nor interface operator
 definition) but that contains a derived-type expression, all type-bound
 operators defined on that derived-type are checked for a match with
diff --git a/gcc/fortran/intrinsic.texi b/gcc/fortran/intrinsic.texi
index e47ee1e..941c2e3 100644
--- a/gcc/fortran/intrinsic.texi
+++ b/gcc/fortran/intrinsic.texi
@@ -6762,7 +6762,7 @@ kind.
 
 @item @emph{Return value}:
 After @code{GETARG} returns, the @var{VALUE} argument holds the
-@var{POS}th command line argument. If @var{VALUE} can not hold the
+@var{POS}th command line argument. If @var{VALUE} cannot hold the
 argument, it is truncated to fit the length of @var{VALUE}. If there are
 less than @var{POS} arguments specified at the command line, @var{VALUE}
 will be filled with blanks. If @math{@var{POS} = 0}, @var{VALUE} is set
@@ -6875,7 +6875,7 @@ and of default kind.
 
 @item @emph{Return value}:
 After @code{GET_COMMAND_ARGUMENT} returns, the @var{VALUE} argument holds the 
-@var{NUMBER}-th command line argument. If @var{VALUE} can not hold the argument, it is 
+@var{NUMBER}-th command line argument. If @var{VALUE} cannot hold the argument, it is 
 truncated to fit the length of @var{VALUE}. If there are less than @var{NUMBER}
 arguments specified at the command line, @var{VALUE} will be filled with blanks. 
 If @math{@var{NUMBER} = 0}, @var{VALUE} is set to the name of the program (on
diff --git a/gcc/fortran/invoke.texi b/gcc/fortran/invoke.texi
index 7b5597e..668e8d9 100644
--- a/gcc/fortran/invoke.texi
+++ b/gcc/fortran/invoke.texi
@@ -1112,7 +1112,7 @@ time.  This option is implied by @option{-Wall}.
 @item -Wdo-subscript
 @opindex @code{Wdo-subscript}
 Warn if an array subscript inside a DO loop could lead to an
-out-of-bounds access even if the compiler can not prove that the
+out-of-bounds access even if the compiler cannot prove that the
 statement is actually executed, in cases like
 @smallexample
   real a(3)
diff --git a/gcc/fortran/io.c b/gcc/fortran/io.c
index ade7059..4ea37a3 100644
--- a/gcc/fortran/io.c
+++ b/gcc/fortran/io.c
@@ -4619,7 +4619,7 @@ gfc_match_inquire (void)
       && ((mpz_get_si (inquire->unit->value.integer) == GFC_INTERNAL_UNIT4)
       || (mpz_get_si (inquire->unit->value.integer) == GFC_INTERNAL_UNIT)))
     {
-      gfc_error ("UNIT number in INQUIRE statement at %L can not "
+      gfc_error ("UNIT number in INQUIRE statement at %L cannot "
 		 "be %d", &loc, (int) mpz_get_si (inquire->unit->value.integer));
       goto cleanup;
     }
diff --git a/gcc/fortran/match.c b/gcc/fortran/match.c
index 4c0bda9..9ff1c35 100644
--- a/gcc/fortran/match.c
+++ b/gcc/fortran/match.c
@@ -5144,7 +5144,7 @@ gfc_match_common (void)
                 }
 
               if (sym->attr.is_bind_c == 1)
-                gfc_error_now ("Variable %qs in common block %qs at %C can not "
+                gfc_error_now ("Variable %qs in common block %qs at %C cannot "
                                "be bind(c) since it is not global", sym->name,
 			       t->name);
             }
diff --git a/gcc/fortran/parse.c b/gcc/fortran/parse.c
index 6b33c57..5dcd91a 100644
--- a/gcc/fortran/parse.c
+++ b/gcc/fortran/parse.c
@@ -3746,7 +3746,7 @@ loop:
 	  break;
       }
 
-  /* If we find a statement that can not be followed by an IMPLICIT statement
+  /* If we find a statement that cannot be followed by an IMPLICIT statement
      (and thus we can expect to see none any further), type the function result
      if it has not yet been typed.  Be careful not to give the END statement
      to verify_st_order!  */
@@ -4543,7 +4543,7 @@ parse_associate (void)
 	 in case of association to a derived-type.  */
       sym->ts = a->target->ts;
 
-      /* Check if the target expression is array valued.  This can not always
+      /* Check if the target expression is array valued.  This cannot always
 	 be done by looking at target.rank, because that might not have been
 	 set yet.  Therefore traverse the chain of refs, looking for the last
 	 array ref and evaluate that.  */
diff --git a/gcc/fortran/primary.c b/gcc/fortran/primary.c
index 19f97d1..fa764dc 100644
--- a/gcc/fortran/primary.c
+++ b/gcc/fortran/primary.c
@@ -1570,7 +1570,7 @@ match_actual_arg (gfc_expr **result)
 	  gfc_set_sym_referenced (sym);
 	  if (sym->attr.flavor == FL_NAMELIST)
 	    {
-	      gfc_error ("Namelist %qs can not be an argument at %L",
+	      gfc_error ("Namelist %qs cannot be an argument at %L",
 	      sym->name, &where);
 	      break;
 	    }
@@ -3598,7 +3598,7 @@ gfc_match_rvalue (gfc_expr **result)
       /* F08:C612.  */
       if (gfc_peek_ascii_char() == '%')
 	{
-	  gfc_error ("The leftmost part-ref in a data-ref can not be a "
+	  gfc_error ("The leftmost part-ref in a data-ref cannot be a "
 		     "function reference at %C");
 	  m = MATCH_ERROR;
 	}
diff --git a/gcc/fortran/resolve.c b/gcc/fortran/resolve.c
index beafe8d..a681eca 100644
--- a/gcc/fortran/resolve.c
+++ b/gcc/fortran/resolve.c
@@ -1089,7 +1089,7 @@ resolve_common_blocks (gfc_symtree *common_root)
 	       sym->name, &common_root->n.common->where, &sym->declared_at);
 
   if (sym->attr.external)
-    gfc_error ("COMMON block %qs at %L can not have the EXTERNAL attribute",
+    gfc_error ("COMMON block %qs at %L cannot have the EXTERNAL attribute",
 	       sym->name, &common_root->n.common->where);
 
   if (sym->attr.intrinsic)
@@ -9319,7 +9319,7 @@ resolve_select_type (gfc_code *code, gfc_namespace *old_ns)
 	default_case->next = if_st;
     }
 
-  /* Resolve the internal code.  This can not be done earlier because
+  /* Resolve the internal code.  This cannot be done earlier because
      it requires that the sym->assoc of selectors is set already.  */
   gfc_current_ns = ns;
   gfc_resolve_blocks (code->block, gfc_current_ns);
@@ -9453,7 +9453,7 @@ resolve_transfer (gfc_code *code)
 	  return;
 	}
 
-      /* C_PTR and C_FUNPTR have private components which means they can not
+      /* C_PTR and C_FUNPTR have private components which means they cannot
          be printed.  However, if -std=gnu and not -pedantic, allow
          the component to be printed to help debugging.  */
       if (ts->u.derived->ts.f90_type == BT_VOID)
@@ -15311,7 +15311,7 @@ resolve_symbol (gfc_symbol *sym)
 	  for (; formal; formal = formal->next)
 	    if (formal->sym && formal->sym->attr.flavor == FL_NAMELIST)
 	      {
-		gfc_error ("Namelist %qs can not be an argument to "
+		gfc_error ("Namelist %qs cannot be an argument to "
 			   "subroutine or function at %L",
 			   formal->sym->name, &sym->declared_at);
 		return;
diff --git a/gcc/fortran/symbol.c b/gcc/fortran/symbol.c
index cd52c73..06c21d9 100644
--- a/gcc/fortran/symbol.c
+++ b/gcc/fortran/symbol.c
@@ -4470,7 +4470,7 @@ verify_bind_c_derived_type (gfc_symbol *derived_sym)
 	  && curr_comp->ts.u.derived->ts.is_iso_c != 1
           && curr_comp->ts.u.derived != derived_sym)
         {
-          /* This should be allowed; the draft says a derived-type can not
+          /* This should be allowed; the draft says a derived-type cannot
              have type parameters if it is has the BIND attribute.  Type
              parameters seem to be for making parameterized derived types.
              There's no need to verify the type if it is c_ptr/c_funptr.  */
diff --git a/gcc/fortran/trans-array.c b/gcc/fortran/trans-array.c
index 738022a..e71e76e 100644
--- a/gcc/fortran/trans-array.c
+++ b/gcc/fortran/trans-array.c
@@ -9078,7 +9078,7 @@ structure_alloc_comps (gfc_symbol * der_type, tree decl,
 				     TREE_TYPE (len), len, tmp);
 	      gfc_add_expr_to_block (&fnblock, tmp);
 	      size = size_of_string_in_bytes (c->ts.kind, len);
-	      /* This component can not have allocatable components,
+	      /* This component cannot have allocatable components,
 		 therefore add_when_allocated of duplicate_allocatable ()
 		 is always NULL.  */
 	      tmp = duplicate_allocatable (dcmp, comp, ctype, rank,
diff --git a/gcc/fortran/trans-decl.c b/gcc/fortran/trans-decl.c
index c92d891..474ad0b 100644
--- a/gcc/fortran/trans-decl.c
+++ b/gcc/fortran/trans-decl.c
@@ -1369,7 +1369,7 @@ gfc_add_assign_aux_vars (gfc_symbol * sym)
   gfc_finish_var_decl (length, sym);
   gfc_finish_var_decl (addr, sym);
   /*  STRING_LENGTH is also used as flag. Less than -1 means that
-      ASSIGN_ADDR can not be used. Equal -1 means that ASSIGN_ADDR is the
+      ASSIGN_ADDR cannot be used. Equal -1 means that ASSIGN_ADDR is the
       target label's address. Otherwise, value is the length of a format string
       and ASSIGN_ADDR is its address.  */
   if (TREE_STATIC (length))
diff --git a/gcc/fortran/trans-intrinsic.c b/gcc/fortran/trans-intrinsic.c
index b997ae5..64d5258 100644
--- a/gcc/fortran/trans-intrinsic.c
+++ b/gcc/fortran/trans-intrinsic.c
@@ -1432,7 +1432,7 @@ conv_expr_ref_to_caf_ref (stmtblock_t *block, gfc_expr *expr)
 			  gcc_assert (end != NULL_TREE);
 			  /* Multiply with the product of array's stride and
 			     the step of the ref to a virtual upper bound.
-			     We can not compute the actual upper bound here or
+			     We cannot compute the actual upper bound here or
 			     the caflib would compute the extend
 			     incorrectly.  */
 			  end = fold_build2 (MULT_EXPR, gfc_array_index_type,
diff --git a/gcc/fortran/trans-stmt.c b/gcc/fortran/trans-stmt.c
index 62cca29..6b785a6 100644
--- a/gcc/fortran/trans-stmt.c
+++ b/gcc/fortran/trans-stmt.c
@@ -6303,7 +6303,7 @@ gfc_trans_allocate (gfc_code * code)
 	al_len = se.string_length;
 
       al_len_needs_set = al_len != NULL_TREE;
-      /* When allocating an array one can not use much of the
+      /* When allocating an array one cannot use much of the
 	 pre-evaluated expr3 expressions, because for most of them the
 	 scalarizer is needed which is not available in the pre-evaluation
 	 step.  Therefore gfc_array_allocate () is responsible (and able)
@@ -6554,7 +6554,7 @@ gfc_trans_allocate (gfc_code * code)
 		 information in future loop iterations.  */
 	      if (tmp_expr3_len_flag)
 		/* No need to reset tmp_expr3_len_flag, because the
-		   presence of an expr3 can not change within in the
+		   presence of an expr3 cannot change within in the
 		   loop.  */
 		expr3_len = NULL_TREE;
 	    }
diff --git a/gcc/genautomata.c b/gcc/genautomata.c
index a992835..d408eed 100644
--- a/gcc/genautomata.c
+++ b/gcc/genautomata.c
@@ -5539,9 +5539,9 @@ form_reservs_matter (automaton_t automaton)
       if (units_array [unit]->automaton_decl
 	  == automaton->corresponding_automaton_decl
 	  && (cycle >= units_array [unit]->min_occ_cycle_num
-	      /* We can not remove queried unit from reservations.  */
+	      /* We cannot remove queried unit from reservations.  */
 	      || units_array [unit]->query_p
-	      /* We can not remove units which are used
+	      /* We cannot remove units which are used
 		 `exclusion_set', `presence_set',
 		 `final_presence_set', `absence_set', and
 		 `final_absence_set'.  */
@@ -9207,7 +9207,7 @@ generate (void)
 #define STANDARD_OUTPUT_DESCRIPTION_FILE_SUFFIX ".dfa"
 
 /* The function returns suffix of given file name.  The returned
-   string can not be changed.  */
+   string cannot be changed.  */
 static const char *
 file_name_suffix (const char *file_name)
 {
@@ -9222,7 +9222,7 @@ file_name_suffix (const char *file_name)
 /* The function returns base name of given file name, i.e. pointer to
    first char after last `/' (or `\' for WIN32) in given file name,
    given file name itself if the directory name is absent.  The
-   returned string can not be changed.  */
+   returned string cannot be changed.  */
 static const char *
 base_file_name (const char *file_name)
 {
diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c
index 529149a..2d25f9e 100644
--- a/gcc/gimple-fold.c
+++ b/gcc/gimple-fold.c
@@ -380,8 +380,8 @@ fold_gimple_assign (gimple_stmt_iterator *si)
 			STRIP_USELESS_TYPE_CONVERSION (val);
 		      }
 		    else
-		      /* We can not use __builtin_unreachable here because it
-			 can not have address taken.  */
+		      /* We cannot use __builtin_unreachable here because it
+			 cannot have address taken.  */
 		      val = build_int_cst (TREE_TYPE (val), 0);
 		    return val;
 		  }
@@ -6988,7 +6988,7 @@ fold_const_aggregate_ref_1 (tree t, tree (*valueize) (tree))
 		     but don't fold.  */
 		  if (maybe_lt (offset, 0))
 		    return NULL_TREE;
-		  /* We can not determine ctor.  */
+		  /* We cannot determine ctor.  */
 		  if (!ctor)
 		    return NULL_TREE;
 		  return fold_ctor_reference (TREE_TYPE (t), ctor, offset,
@@ -7013,7 +7013,7 @@ fold_const_aggregate_ref_1 (tree t, tree (*valueize) (tree))
       /* We do not know precise address.  */
       if (!known_size_p (max_size) || maybe_ne (max_size, size))
 	return NULL_TREE;
-      /* We can not determine ctor.  */
+      /* We cannot determine ctor.  */
       if (!ctor)
 	return NULL_TREE;
 
diff --git a/gcc/go/ChangeLog b/gcc/go/ChangeLog
index 3713881..64e20cd 100644
--- a/gcc/go/ChangeLog
+++ b/gcc/go/ChangeLog
@@ -1,3 +1,10 @@
+2019-01-09  Sandra Loosemore  <sandra@codesourcery.com>
+
+	PR other/16615
+
+	* go-backend.c: Mechanically replace "can not" with "cannot".
+	* go-gcc.cc: Likewise.
+
 2019-01-01  Jakub Jelinek  <jakub@redhat.com>
 
 	Update copyright years.
diff --git a/gcc/go/go-backend.c b/gcc/go/go-backend.c
index 1375323..9422b0d 100644
--- a/gcc/go/go-backend.c
+++ b/gcc/go/go-backend.c
@@ -82,7 +82,7 @@ go_field_alignment (tree t)
 }
 
 /* This is called by the Go frontend proper if the unsafe package was
-   imported.  When that happens we can not do type-based alias
+   imported.  When that happens we cannot do type-based alias
    analysis.  */
 
 void
diff --git a/gcc/go/go-gcc.cc b/gcc/go/go-gcc.cc
index 8443256..afdc7f8 100644
--- a/gcc/go/go-gcc.cc
+++ b/gcc/go/go-gcc.cc
@@ -760,7 +760,7 @@ Gcc_backend::Gcc_backend()
 							NULL_TREE),
 		       false, false);
 
-  // The compiler uses __builtin_unreachable for cases that can not
+  // The compiler uses __builtin_unreachable for cases that cannot
   // occur.
   this->define_builtin(BUILT_IN_UNREACHABLE, "__builtin_unreachable", NULL,
 		       build_function_type(void_type_node, void_list_node),
@@ -909,7 +909,7 @@ Gcc_backend::function_type(const Btyped_identifier& receiver,
   if (result == error_mark_node)
     return this->error_type();
 
-  // The libffi library can not represent a zero-sized object.  To
+  // The libffi library cannot represent a zero-sized object.  To
   // avoid causing confusion on 32-bit SPARC, we treat a function that
   // returns a zero-sized value as returning void.  That should do no
   // harm since there is no actual value to be returned.  See
diff --git a/gcc/hard-reg-set.h b/gcc/hard-reg-set.h
index 9f41b44..a728196 100644
--- a/gcc/hard-reg-set.h
+++ b/gcc/hard-reg-set.h
@@ -674,7 +674,7 @@ struct target_hard_regs {
      with the local stack frame are safe, but scant others.  */
   HARD_REG_SET x_regs_invalidated_by_call;
 
-  /* Call used hard registers which can not be saved because there is no
+  /* Call used hard registers which cannot be saved because there is no
      insn for this.  */
   HARD_REG_SET x_no_caller_save_reg_set;
 
diff --git a/gcc/ifcvt.c b/gcc/ifcvt.c
index 77feb45..7b2f6e6 100644
--- a/gcc/ifcvt.c
+++ b/gcc/ifcvt.c
@@ -503,7 +503,7 @@ cond_exec_process_if_block (ce_if_block * ce_info,
     return FALSE;
 
   /* If the conditional jump is more than just a conditional jump,
-     then we can not do conditional execution conversion on this block.  */
+     then we cannot do conditional execution conversion on this block.  */
   if (! onlyjump_p (BB_END (test_bb)))
     return FALSE;
 
@@ -652,7 +652,7 @@ cond_exec_process_if_block (ce_if_block * ce_info,
 	    goto fail;
 
 	  /* If the conditional jump is more than just a conditional jump, then
-	     we can not do conditional execution conversion on this block.  */
+	     we cannot do conditional execution conversion on this block.  */
 	  if (! onlyjump_p (BB_END (bb)))
 	    goto fail;
 
@@ -4022,7 +4022,7 @@ noce_find_if_block (basic_block test_bb, edge then_edge, edge else_edge,
     }
 
   /* If the conditional jump is more than just a conditional
-     jump, then we can not do if-conversion on this block.  */
+     jump, then we cannot do if-conversion on this block.  */
   jump = BB_END (test_bb);
   if (! onlyjump_p (jump))
     return FALSE;
@@ -4642,7 +4642,7 @@ find_cond_trap (basic_block test_bb, edge then_edge, edge else_edge)
     return FALSE;
 
   /* If the conditional jump is more than just a conditional jump, then
-     we can not do if-conversion on this block.  Give up for returnjump_p,
+     we cannot do if-conversion on this block.  Give up for returnjump_p,
      changing a conditional return followed by unconditional trap for
      conditional trap followed by unconditional return is likely not
      beneficial and harder to handle.  */
diff --git a/gcc/ipa-comdats.c b/gcc/ipa-comdats.c
index 4980fd9..69cc3f3 100644
--- a/gcc/ipa-comdats.c
+++ b/gcc/ipa-comdats.c
@@ -82,7 +82,7 @@ propagate_comdat_group (struct symtab_node *symbol,
 	  continue;
 	}
 
-      /* One COMDAT group can not hold both variables and functions at
+      /* One COMDAT group cannot hold both variables and functions at
 	 a same time.  For now we just go to BOTTOM, in future we may
 	 invent special comdat groups for this case.  */
 
@@ -127,7 +127,7 @@ propagate_comdat_group (struct symtab_node *symbol,
 
 	if (cgraph_node * cn = dyn_cast <cgraph_node *> (symbol2))
 	  {
-	    /* Thunks can not call across section boundary.  */
+	    /* Thunks cannot call across section boundary.  */
 	    if (cn->thunk.thunk_p)
 	      newgroup = propagate_comdat_group (symbol2, newgroup, map);
 	    /* If we see inline clone, its comdat group actually
@@ -257,7 +257,7 @@ ipa_comdats (void)
 	/* Mark the symbol so we won't waste time visiting it for dataflow.  */
 	symbol->aux = (symtab_node *) (void *) 1;
       }
-    /* See symbols that can not be privatized to comdats; that is externally
+    /* See symbols that cannot be privatized to comdats; that is externally
        visible symbols or otherwise used ones.  We also do not want to mangle
        user section names.  */
     else if (symbol->externally_visible
diff --git a/gcc/ipa-cp.c b/gcc/ipa-cp.c
index 247aba7..3489ed5 100644
--- a/gcc/ipa-cp.c
+++ b/gcc/ipa-cp.c
@@ -1129,7 +1129,7 @@ count_callers (cgraph_node *node, void *data)
   int *caller_count = (int *) data;
 
   for (cgraph_edge *cs = node->callers; cs; cs = cs->next_caller)
-    /* Local thunks can be handled transparently, but if the thunk can not
+    /* Local thunks can be handled transparently, but if the thunk cannot
        be optimized out, count it as a real use.  */
     if (!cs->caller->thunk.thunk_p || !cs->caller->local.local)
       ++*caller_count;
diff --git a/gcc/ipa-devirt.c b/gcc/ipa-devirt.c
index 9c54edd..bba73b2 100644
--- a/gcc/ipa-devirt.c
+++ b/gcc/ipa-devirt.c
@@ -244,7 +244,7 @@ type_all_ctors_visible_p (tree t)
 {
   return !flag_ltrans
 	 && symtab->state >= CONSTRUCTION
-	 /* We can not always use type_all_derivations_known_p.
+	 /* We cannot always use type_all_derivations_known_p.
 	    For function local types we must assume case where
 	    the function is COMDAT and shared in between units.
 
@@ -1144,12 +1144,12 @@ warn_types_mismatch (tree t1, tree t2, location_t loc1, location_t loc2)
          verbose.  */
       if (IDENTIFIER_POINTER (n1) != IDENTIFIER_POINTER (n2))
         inform (loc_t1,
-	        "type %qT defined in anonymous namespace can not match "
+	        "type %qT defined in anonymous namespace cannot match "
 	        "type %qT across the translation unit boundary",
 	        t1, t2);
       else
         inform (loc_t1,
-	        "type %qT defined in anonymous namespace can not match "
+	        "type %qT defined in anonymous namespace cannot match "
 	        "across the translation unit boundary",
 	        t1);
       if (loc_t2_useful)
@@ -1312,7 +1312,7 @@ odr_types_equivalent_p (tree t1, tree t2, bool warn, bool *warned,
       || (type_with_linkage_p (TYPE_MAIN_VARIANT (t2))
 	  && type_in_anonymous_namespace_p (TYPE_MAIN_VARIANT (t2))))
     {
-      /* We can not trip this when comparing ODR types, only when trying to
+      /* We cannot trip this when comparing ODR types, only when trying to
 	 match different ODR derivations from different declarations.
 	 So WARN should be always false.  */
       gcc_assert (!warn);
@@ -2120,7 +2120,7 @@ get_odr_type (tree type, bool insert)
       val->all_derivations_known = type_all_derivations_known_p (type);
       for (i = 0; i < BINFO_N_BASE_BINFOS (binfo); i++)
 	/* For now record only polymorphic types. other are
-	   pointless for devirtualization and we can not precisely
+	   pointless for devirtualization and we cannot precisely
 	   determine ODR equivalency of these during LTO.  */
 	if (polymorphic_type_binfo_p (BINFO_BASE_BINFO (binfo, i)))
 	  {
@@ -2467,7 +2467,7 @@ is_cxa_pure_virtual_p (tree target)
 
 /* If TARGET has associated node, record it in the NODES array.
    CAN_REFER specify if program can refer to the target directly.
-   if TARGET is unknown (NULL) or it can not be inserted (for example because
+   if TARGET is unknown (NULL) or it cannot be inserted (for example because
    its body was already removed and there is no way to refer to it), clear
    COMPLETEP.  */
 
@@ -2568,7 +2568,7 @@ maybe_record_node (vec <cgraph_node *> &nodes,
   else if (!completep)
     ;
   /* We have definition of __cxa_pure_virtual that is not accessible (it is
-     optimized out or partitioned to other unit) so we can not add it.  When
+     optimized out or partitioned to other unit) so we cannot add it.  When
      not sanitizing, there is nothing to do.
      Otherwise declare the list incomplete.  */
   else if (pure_virtual)
@@ -3805,7 +3805,7 @@ ipa_devirt (void)
 		ndropped++;
 	        if (dump_file)
 		  fprintf (dump_file, "Dropping polymorphic call info;"
-			   " it can not be used by ipa-prop\n");
+			   " it cannot be used by ipa-prop\n");
 	      }
 
 	    if (!opt_for_fn (n->decl, flag_devirtualize_speculatively))
diff --git a/gcc/ipa-fnsummary.c b/gcc/ipa-fnsummary.c
index 6bc9cb3..dbb95b0 100644
--- a/gcc/ipa-fnsummary.c
+++ b/gcc/ipa-fnsummary.c
@@ -307,7 +307,7 @@ set_hint_predicate (predicate **p, predicate new_predicate)
    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
-   is always false in the second and also builtin_constant_p tests can not use
+   is always false in the second and also builtin_constant_p tests cannot use
    the fact that parameter is indeed a constant.
 
    KNOWN_VALS is partial mapping of parameters of NODE to constant values.
@@ -2219,7 +2219,7 @@ analyze_function_body (struct cgraph_node *node, bool early)
 	      struct predicate p = bb_predicate & will_be_nonconstant;
 
 	      /* We can ignore statement when we proved it is never going
-		 to happen, but we can not do that for call statements
+		 to happen, but we cannot do that for call statements
 		 because edges are accounted specially.  */
 
 	      if (*(is_gimple_call (stmt) ? &bb_predicate : &p) != false)
@@ -2430,7 +2430,7 @@ compute_fn_summary (struct cgraph_node *node, bool early)
       info->account_size_time (2 * ipa_fn_summary::size_scale, 0, t, t);
       ipa_update_overall_fn_summary (node);
       info->self_size = info->size;
-      /* We can not inline instrumentation clones.  */
+      /* We cannot inline instrumentation clones.  */
       if (node->thunk.add_pointer_bounds_args)
 	{
           info->inlinable = false;
@@ -2471,7 +2471,7 @@ compute_fn_summary (struct cgraph_node *node, bool early)
 	     node->local.can_change_signature = true;
 	   else
 	     {
-	       /* Functions calling builtin_apply can not change signature.  */
+	       /* Functions calling builtin_apply cannot change signature.  */
 	       for (e = node->callees; e; e = e->next_callee)
 		 {
 		   tree cdecl = e->callee->decl;
diff --git a/gcc/ipa-icf.c b/gcc/ipa-icf.c
index ebaf582..056be11 100644
--- a/gcc/ipa-icf.c
+++ b/gcc/ipa-icf.c
@@ -368,7 +368,7 @@ sem_item::compare_referenced_symbol_properties (symtab_node *used_by,
 	  && (!used_by || !is_a <cgraph_node *> (used_by) || address
 	      || opt_for_fn (used_by->decl, flag_devirtualize)))
 	return return_false_with_msg
-		 ("references to virtual tables can not be merged");
+		 ("references to virtual tables cannot be merged");
 
       if (address && DECL_ALIGN (n1->decl) != DECL_ALIGN (n2->decl))
 	return return_false_with_msg ("alignment mismatch");
@@ -1083,23 +1083,23 @@ sem_function::merge (sem_item *alias_item)
   if (original->can_be_discarded_p ())
     original_discardable = true;
   /* Also consider case where we have resolution info and we know that
-     original's definition is not going to be used.  In this case we can not
+     original's definition is not going to be used.  In this case we cannot
      create alias to original.  */
   if (node->resolution != LDPR_UNKNOWN
       && !decl_binds_to_current_def_p (node->decl))
     original_discardable = original_discarded = true;
 
   /* Creating a symtab alias is the optimal way to merge.
-     It however can not be used in the following cases:
+     It however cannot be used in the following cases:
 
      1) if ORIGINAL and ALIAS may be possibly compared for address equality.
      2) if ORIGINAL is in a section that may be discarded by linker or if
-	it is an external functions where we can not create an alias
+	it is an external functions where we cannot create an alias
 	(ORIGINAL_DISCARDABLE)
      3) if target do not support symbol aliases.
      4) original and alias lie in different comdat groups.
 
-     If we can not produce alias, we will turn ALIAS into WRAPPER of ORIGINAL
+     If we cannot produce alias, we will turn ALIAS into WRAPPER of ORIGINAL
      and/or redirect all callers from ALIAS to ORIGINAL.  */
   if ((original_address_matters && alias_address_matters)
       || (original_discardable
@@ -1149,7 +1149,7 @@ sem_function::merge (sem_item *alias_item)
 	{
 	  if (dump_file)
 	    fprintf (dump_file,
-		     "can not create wrapper of stdarg function.\n");
+		     "cannot create wrapper of stdarg function.\n");
 	}
       else if (ipa_fn_summaries
 	       && ipa_fn_summaries->get (alias) != NULL
@@ -1184,7 +1184,7 @@ sem_function::merge (sem_item *alias_item)
       if (!redirect_callers && !create_wrapper)
 	{
 	  if (dump_file)
-	    fprintf (dump_file, "Not unifying; can not redirect callers nor "
+	    fprintf (dump_file, "Not unifying; cannot redirect callers nor "
 		     "produce wrapper\n\n");
 	  return false;
 	}
@@ -1193,7 +1193,7 @@ sem_function::merge (sem_item *alias_item)
 	 If ORIGINAL is interposable, we need to call a local alias.
 	 Also produce local alias (if possible) as an optimization.
 
-	 Local aliases can not be created inside comdat groups because that
+	 Local aliases cannot be created inside comdat groups because that
 	 prevents inlining.  */
       if (!original_discardable && !original->get_comdat_group ())
 	{
@@ -1203,12 +1203,12 @@ sem_function::merge (sem_item *alias_item)
 	      && original->get_availability () > AVAIL_INTERPOSABLE)
 	    local_original = original;
 	}
-      /* If we can not use local alias, fallback to the original
+      /* If we cannot use local alias, fallback to the original
 	 when possible.  */
       else if (original->get_availability () > AVAIL_INTERPOSABLE)
 	local_original = original;
 
-      /* If original is COMDAT local, we can not really redirect calls outside
+      /* If original is COMDAT local, we cannot really redirect calls outside
 	 of its comdat group to it.  */
       if (original->comdat_local_p ())
         redirect_callers = false;
@@ -1216,7 +1216,7 @@ sem_function::merge (sem_item *alias_item)
 	{
 	  if (dump_file)
 	    fprintf (dump_file, "Not unifying; "
-		     "can not produce local alias.\n\n");
+		     "cannot produce local alias.\n\n");
 	  return false;
 	}
 
@@ -1224,7 +1224,7 @@ sem_function::merge (sem_item *alias_item)
 	{
 	  if (dump_file)
 	    fprintf (dump_file, "Not unifying; "
-		     "can not redirect callers nor produce a wrapper\n\n");
+		     "cannot redirect callers nor produce a wrapper\n\n");
 	  return false;
 	}
       if (!create_wrapper
@@ -1233,7 +1233,7 @@ sem_function::merge (sem_item *alias_item)
 	  && !alias->can_remove_if_no_direct_calls_p ())
 	{
 	  if (dump_file)
-	    fprintf (dump_file, "Not unifying; can not make wrapper and "
+	    fprintf (dump_file, "Not unifying; cannot make wrapper and "
 		     "function has other uses than direct calls\n\n");
 	  return false;
 	}
@@ -2124,7 +2124,7 @@ sem_variable::merge (sem_item *alias_item)
   /* See if original is in a section that can be discarded if the main
      symbol is not used.
      Also consider case where we have resolution info and we know that
-     original's definition is not going to be used.  In this case we can not
+     original's definition is not going to be used.  In this case we cannot
      create alias to original.  */
   if (original->can_be_discarded_p ()
       || (node->resolution != LDPR_UNKNOWN
@@ -2160,7 +2160,7 @@ sem_variable::merge (sem_item *alias_item)
       return false;
     }
 
-  /* We can not merge if address comparsion metters.  */
+  /* We cannot merge if address comparsion metters.  */
   if (alias_address_matters && flag_merge_constants < 2)
     {
       if (dump_file)
diff --git a/gcc/ipa-inline-transform.c b/gcc/ipa-inline-transform.c
index 0910a9c..4a3a193 100644
--- a/gcc/ipa-inline-transform.c
+++ b/gcc/ipa-inline-transform.c
@@ -596,7 +596,7 @@ save_inline_function_body (struct cgraph_node *node)
   /* When doing recursive inlining, the clone may become unnecessary.
      This is possible i.e. in the case when the recursive function is proved to be
      non-throwing and the recursion happens only in the EH landing pad.
-     We can not remove the clone until we are done with saving the body.
+     We cannot remove the clone until we are done with saving the body.
      Remove it now.  */
   if (!first_clone->callers)
     {
diff --git a/gcc/ipa-inline.c b/gcc/ipa-inline.c
index 8e34400..2c1843a 100644
--- a/gcc/ipa-inline.c
+++ b/gcc/ipa-inline.c
@@ -59,7 +59,7 @@ along with GCC; see the file COPYING3.  If not see
 	 optimization) and thus improve quality of analysis done by real IPA
 	 optimizers.
 
-	 Because of lack of whole unit knowledge, the pass can not really make
+	 Because of lack of whole unit knowledge, the pass cannot really make
 	 good code size/performance tradeoffs.  It however does very simple
 	 speculative inlining allowing code size to grow by
 	 EARLY_INLINING_INSNS when callee is leaf function.  In this case the
@@ -562,7 +562,7 @@ can_early_inline_edge_p (struct cgraph_edge *e)
 {
   struct cgraph_node *callee = e->callee->ultimate_alias_target ();
   /* Early inliner might get called at WPA stage when IPA pass adds new
-     function.  In this case we can not really do any of early inlining
+     function.  In this case we cannot really do any of early inlining
      because function bodies are missing.  */
   if (cgraph_inline_failed_type (e->inline_failed) == CIF_FINAL_ERROR)
     return false;
diff --git a/gcc/ipa-polymorphic-call.c b/gcc/ipa-polymorphic-call.c
index 44808cf..7d8c5ab 100644
--- a/gcc/ipa-polymorphic-call.c
+++ b/gcc/ipa-polymorphic-call.c
@@ -112,7 +112,7 @@ possible_placement_new (tree type, tree expected_type,
    If the same is produced by multiple inheritance, we end up with A and offset
    sizeof(int). 
 
-   If we can not find corresponding class, give up by setting
+   If we cannot find corresponding class, give up by setting
    THIS->OUTER_TYPE to OTR_TYPE and THIS->OFFSET to NULL. 
    Return true when lookup was sucesful.
 
@@ -146,7 +146,7 @@ ipa_polymorphic_call_context::restrict_to_inner_class (tree otr_type,
     derived from OUTER_TYPE.
 
     Because the instance type may contain field whose type is of OUTER_TYPE,
-    we can not derive any effective information about it.
+    we cannot derive any effective information about it.
 
     TODO: In the case we know all derrived types, we can definitely do better
     here.  */
@@ -191,7 +191,7 @@ ipa_polymorphic_call_context::restrict_to_inner_class (tree otr_type,
       tree fld;
 
       /* If we do not know size of TYPE, we need to be more conservative
-         about accepting cases where we can not find EXPECTED_TYPE.
+         about accepting cases where we cannot find EXPECTED_TYPE.
 	 Generally the types that do matter here are of constant size.
 	 Size_unknown case should be very rare.  */
       if (TYPE_SIZE (type)
@@ -233,7 +233,7 @@ ipa_polymorphic_call_context::restrict_to_inner_class (tree otr_type,
 		  && type_known_to_have_no_derivations_p (outer_type))
 		maybe_derived_type = false;
 
-	      /* Type can not contain itself on an non-zero offset.  In that case
+	      /* Type cannot contain itself on an non-zero offset.  In that case
 		 just give up.  Still accept the case where size is now known.
 		 Either the second copy may appear past the end of type or within
 		 the non-POD buffer located inside the variably sized type
@@ -287,7 +287,7 @@ ipa_polymorphic_call_context::restrict_to_inner_class (tree otr_type,
 	      size = tree_to_uhwi (DECL_SIZE (fld));
 
 	      /* We can always skip types smaller than pointer size:
-		 those can not contain a virtual table pointer.
+		 those cannot contain a virtual table pointer.
 
 		 Disqualifying fields that are too small to fit OTR_TYPE
 		 saves work needed to walk them for no benefit.
@@ -552,7 +552,7 @@ decl_maybe_in_construction_p (tree base, tree outer_type,
   if (DECL_STRUCT_FUNCTION (function)->after_inlining)
     return true;
 
-  /* Pure functions can not do any changes on the dynamic type;
+  /* Pure functions cannot do any changes on the dynamic type;
      that require writting to memory.  */
   if ((!base || !auto_var_in_fn_p (base, function))
       && flags_from_decl_or_type (function) & (ECF_PURE | ECF_CONST))
@@ -1745,7 +1745,7 @@ ipa_polymorphic_call_context::get_dynamic_type (tree instance,
      sub-objects and the code written by the user is run.  Only this may
      include calling virtual functions, directly or indirectly.
 
-     4) placement new can not be used to change type of non-POD statically
+     4) placement new cannot be used to change type of non-POD statically
      allocated variables.
 
      There is no way to call a constructor of an ancestor sub-object in any
@@ -2333,7 +2333,7 @@ ipa_polymorphic_call_context::make_speculative (tree otr_type)
 			    otr_type);
 }
 
-/* Use when we can not track dynamic type change.  This speculatively assume
+/* Use when we cannot track dynamic type change.  This speculatively assume
    type change is not happening.  */
 
 void
diff --git a/gcc/ipa-profile.c b/gcc/ipa-profile.c
index 4e57b88..de9563d 100644
--- a/gcc/ipa-profile.c
+++ b/gcc/ipa-profile.c
@@ -391,7 +391,7 @@ ipa_propagate_frequency (struct cgraph_node *node)
   struct ipa_propagate_frequency_data d = {node, true, true, true, true};
   bool changed = false;
 
-  /* We can not propagate anything useful about externally visible functions
+  /* We cannot propagate anything useful about externally visible functions
      nor about virtuals.  */
   if (!node->local.local
       || node->alias
diff --git a/gcc/ipa-prop.c b/gcc/ipa-prop.c
index d5d9ca9..6830f8d 100644
--- a/gcc/ipa-prop.c
+++ b/gcc/ipa-prop.c
@@ -686,14 +686,14 @@ check_stmt_for_type_change (ao_ref *ao ATTRIBUTE_UNUSED, tree vdef, void *data)
    in between beggining 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
+   but they call destructors.  We assume that methods cannot destroy the THIS
    pointer.  Also as a special cases, constructor and destructors may change
    type of the THIS pointer.  */
 
 static bool
 param_type_may_change_p (tree function, tree arg, gimple *call)
 {
-  /* Pure functions can not do any changes on the dynamic type;
+  /* Pure functions cannot do any changes on the dynamic type;
      that require writting to memory.  */
   if (flags_from_decl_or_type (function) & (ECF_PURE | ECF_CONST))
     return false;
@@ -1971,7 +1971,7 @@ ipa_compute_jump_functions_for_edge (struct ipa_func_body_info *fbi,
 	    }
 	}
 
-      /* If ARG is pointer, we can not use its type to determine the type of aggregate
+      /* If ARG is pointer, we cannot use its type to determine the type of aggregate
 	 passed (because type conversions are ignored in gimple).  Usually we can
 	 safely get type from function declaration, but in case of K&R prototypes or
 	 variadic functions we can try our luck with type of the pointer passed.
@@ -2875,7 +2875,7 @@ ipa_make_edge_direct_to_target (struct cgraph_edge *ie, tree target,
 	{
 	  if (dump_file)
 	    fprintf (dump_file, "ipa-prop: Discovered call to a known target "
-		     "(%s -> %s) but can not refer to it. Giving up.\n",
+		     "(%s -> %s) but cannot refer to it. Giving up.\n",
 		     ie->caller->dump_name (),
 		     ie->callee->dump_name ());
 	  return NULL;
@@ -2914,7 +2914,7 @@ ipa_make_edge_direct_to_target (struct cgraph_edge *ie, tree target,
 
   ipa_check_create_node_params ();
 
-  /* We can not make edges to inline clones.  It is bug that someone removed
+  /* We cannot make edges to inline clones.  It is bug that someone removed
      the cgraph node too early.  */
   gcc_assert (!callee->global.inlined_to);
 
diff --git a/gcc/ipa-pure-const.c b/gcc/ipa-pure-const.c
index ba0c7c2..d2dcf7c 100644
--- a/gcc/ipa-pure-const.c
+++ b/gcc/ipa-pure-const.c
@@ -1087,7 +1087,7 @@ end:
 		if (!finite_loop_p (loop))
 		  {
 		    if (dump_file)
-		      fprintf (dump_file, "    can not prove finiteness of "
+		      fprintf (dump_file, "    cannot prove finiteness of "
 			       "loop %i\n", loop->num);
 		    l->looping =true;
 		    break;
@@ -1186,7 +1186,7 @@ pure_const_generate_summary (void)
 
   /* Process all of the functions.
 
-     We process AVAIL_INTERPOSABLE functions.  We can not use the results
+     We process AVAIL_INTERPOSABLE functions.  We cannot use the results
      by default, but the info can be used at LTO with -fwhole-program or
      when function got cloned and the clone is AVAILABLE.  */
 
@@ -2292,7 +2292,7 @@ pass_nothrow::execute (function *)
 
   node = cgraph_node::get (current_function_decl);
 
-  /* We run during lowering, we can not really use availability yet.  */
+  /* We run during lowering, we cannot really use availability yet.  */
   if (cgraph_node::get (current_function_decl)->get_availability ()
       <= AVAIL_INTERPOSABLE)
     {
diff --git a/gcc/ipa-reference.c b/gcc/ipa-reference.c
index 95f91b7..8ad12d3 100644
--- a/gcc/ipa-reference.c
+++ b/gcc/ipa-reference.c
@@ -239,7 +239,7 @@ is_improper (symtab_node *n, void *v ATTRIBUTE_UNUSED)
   if (TREE_READONLY (t))
     return true;
 
-  /* We can not track variables with address taken.  */
+  /* We cannot track variables with address taken.  */
   if (TREE_ADDRESSABLE (t))
     return true;
 
@@ -641,7 +641,7 @@ get_read_write_all_from_node (struct cgraph_node *node,
 {
   struct cgraph_edge *e, *ie;
 
-  /* When function is overwritable, we can not assume anything.  */
+  /* When function is overwritable, we cannot assume anything.  */
   if (node->get_availability () <= AVAIL_INTERPOSABLE
       || (node->analyzed && !opt_for_fn (node->decl, flag_ipa_reference)))
     read_write_all_from_decl (node, read_all, write_all);
diff --git a/gcc/ipa-split.c b/gcc/ipa-split.c
index eeef7bb..cfd03ab 100644
--- a/gcc/ipa-split.c
+++ b/gcc/ipa-split.c
@@ -452,7 +452,7 @@ consider_split (struct split_point *current, bitmap non_ssa_vars,
        < (ENTRY_BLOCK_PTR_FOR_FN (cfun)->count.apply_scale
 	   (PARAM_VALUE (PARAM_PARTIAL_INLINING_ENTRY_PROBABILITY), 100))))
     {
-      /* When profile is guessed, we can not expect it to give us
+      /* When profile is guessed, we cannot expect it to give us
 	 realistic estimate on likelyness of function taking the
 	 complex path.  As a special case, when tail of the function is
 	 a loop, enable splitting since inlining code skipping the loop
@@ -729,7 +729,7 @@ consider_split (struct split_point *current, bitmap non_ssa_vars,
    of the form:
    <retval> = tmp_var;
    return <retval>
-   but return_bb can not be more complex than this (except for
+   but return_bb cannot be more complex than this (except for
    -fsanitize=thread we allow TSAN_FUNC_EXIT () internal call in there).
    If nothing is found, return the exit block.
 
@@ -878,7 +878,7 @@ visit_bb (basic_block bb, basic_block return_bb,
       if (gimple_clobber_p (stmt))
 	continue;
 
-      /* FIXME: We can split regions containing EH.  We can not however
+      /* FIXME: We can split regions containing EH.  We cannot however
 	 split RESX, EH_DISPATCH and EH_POINTER referring to same region
 	 into different partitions.  This would require tracking of
 	 EH regions and checking in consider_split_point if they 
@@ -1003,7 +1003,7 @@ struct stack_entry
   sreal overall_time;
   int overall_size;
 
-  /* When false we can not split on this BB.  */
+  /* When false we cannot split on this BB.  */
   bool can_split;
 };
 
@@ -1071,7 +1071,7 @@ find_split_points (basic_block return_bb, sreal overall_time, int overall_size)
 	  if (pos <= entry->earliest && !entry->can_split
 	      && dump_file && (dump_flags & TDF_DETAILS))
 	    fprintf (dump_file,
-		     "found articulation at bb %i but can not split\n",
+		     "found articulation at bb %i but cannot split\n",
 		     entry->bb->index);
 	  if (pos <= entry->earliest && entry->can_split)
 	     {
@@ -1344,7 +1344,7 @@ split_function (basic_block return_bb, struct split_point *split_point,
   node->tp_first_run = cur_node->tp_first_run + 1;
 
   /* For usual cloning it is enough to clear builtin only when signature
-     changes.  For partial inlining we however can not expect the part
+     changes.  For partial inlining we however cannot expect the part
      of builtin implementation to have same semantic as the whole.  */
   if (fndecl_built_in_p (node->decl))
     {
diff --git a/gcc/ipa-visibility.c b/gcc/ipa-visibility.c
index ebcccef..5752e5c 100644
--- a/gcc/ipa-visibility.c
+++ b/gcc/ipa-visibility.c
@@ -42,7 +42,7 @@ along with GCC; see the file COPYING3.  If not see
       its calling convention.  We simply mark all static functions whose
       address is not taken as local.
 
-      externally_visible flag is set for symbols that can not be privatized.
+      externally_visible flag is set for symbols that cannot be privatized.
       For privatized symbols we clear TREE_PUBLIC flag and dismantle comdat
       group.
 
@@ -87,7 +87,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "stringpool.h"
 #include "attribs.h"
 
-/* Return true when NODE can not be local. Worker for cgraph_local_node_p.  */
+/* Return true when NODE cannot be local. Worker for cgraph_local_node_p.  */
 
 static bool
 non_local_p (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
@@ -147,7 +147,7 @@ comdat_can_be_unshared_p_1 (symtab_node *node)
           && !flag_whole_program))
     return false;
 
-  /* Non-readonly and volatile variables can not be duplicated.  */
+  /* Non-readonly and volatile variables cannot be duplicated.  */
   if (is_a <varpool_node *> (node)
       && (!TREE_READONLY (node->decl)
 	  || TREE_THIS_VOLATILE (node->decl)))
@@ -158,7 +158,7 @@ comdat_can_be_unshared_p_1 (symtab_node *node)
 /* COMDAT functions must be shared only if they have address taken,
    otherwise we can produce our own private implementation with
    -fwhole-program.  
-   Return true when turning COMDAT function static can not lead to wrong
+   Return true when turning COMDAT function static cannot lead to wrong
    code when the resulting object links with a library defining same COMDAT.
 
    Virtual functions do have their addresses taken from the vtables,
@@ -464,7 +464,7 @@ optimize_weakref (symtab_node *node)
 
   gcc_assert (node->weakref);
 
-  /* Weakrefs with no target defined can not be optimized.  */
+  /* Weakrefs with no target defined cannot be optimized.  */
   if (!node->analyzed)
     return;
   symtab_node *target = node->get_alias_target ();
@@ -674,7 +674,7 @@ function_and_variable_visibility (bool whole_program)
 	}
 
       /* C++ FE on lack of COMDAT support create local COMDAT functions
-	 (that ought to be shared but can not due to object format
+	 (that ought to be shared but cannot due to object format
 	 limitations).  It is necessary to keep the flag to make rest of C++ FE
 	 happy.  Clear the flag here to avoid confusion in middle-end.  */
       if (DECL_COMDAT (node->decl) && !TREE_PUBLIC (node->decl))
@@ -750,8 +750,8 @@ function_and_variable_visibility (bool whole_program)
       if (!node->local.local)
         node->local.local |= node->local_p ();
 
-      /* If we know that function can not be overwritten by a
-	 different semantics and moreover its section can not be
+      /* If we know that function cannot be overwritten by a
+	 different semantics and moreover its section cannot be
 	 discarded, replace all direct calls by calls to an
 	 noninterposable alias.  This make dynamic linking cheaper and
 	 enable more optimization.
@@ -787,7 +787,7 @@ function_and_variable_visibility (bool whole_program)
 		  || vnode->weakref
       		  || TREE_PUBLIC (vnode->decl)
 		  || DECL_EXTERNAL (vnode->decl));
-      /* In several cases declarations can not be common:
+      /* In several cases declarations cannot be common:
 
 	 - when declaration has initializer
 	 - when it is in weak
diff --git a/gcc/ipa.c b/gcc/ipa.c
index 3505899..26268bc 100644
--- a/gcc/ipa.c
+++ b/gcc/ipa.c
@@ -760,7 +760,7 @@ clear_addressable_bit (varpool_node *vnode, void *data ATTRIBUTE_UNUSED)
 
    Return true when unreachable symbol removal should be done.
 
-   FIXME: This can not be done in between gimplify and omp_expand since
+   FIXME: This cannot 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
diff --git a/gcc/ira-build.c b/gcc/ira-build.c
index 2f87c81..83caa3a 100644
--- a/gcc/ira-build.c
+++ b/gcc/ira-build.c
@@ -45,7 +45,7 @@ ira_loop_tree_node_t ira_loop_tree_root;
 int ira_loop_tree_height;
 
 /* All nodes representing basic blocks are referred through the
-   following array.  We can not use basic block member `aux' for this
+   following array.  We cannot use basic block member `aux' for this
    because it is used for insertion of insns on edges.  */
 ira_loop_tree_node_t ira_bb_nodes;
 
@@ -259,7 +259,7 @@ add_loop_to_tree (struct loop *loop)
   struct loop *parent;
   ira_loop_tree_node_t loop_node, parent_node;
 
-  /* We can not use loop node access macros here because of potential
+  /* We cannot use loop node access macros here because of potential
      checking and because the nodes are not initialized enough
      yet.  */
   if (loop != NULL && loop_outer (loop) != NULL)
@@ -334,7 +334,7 @@ form_loop_tree (void)
   struct loop *parent;
   ira_loop_tree_node_t bb_node, loop_node;
 
-  /* We can not use loop/bb node access macros because of potential
+  /* We cannot use loop/bb node access macros because of potential
      checking and because the nodes are not initialized enough
      yet.  */
   FOR_EACH_BB_FN (bb, cfun)
@@ -2166,7 +2166,7 @@ low_pressure_loop_node_p (ira_loop_tree_node_t node)
 #ifdef STACK_REGS
 /* Return TRUE if LOOP has a complex enter or exit edge.  We don't
    form a region from such loop if the target use stack register
-   because reg-stack.c can not deal with such edges.  */
+   because reg-stack.c cannot deal with such edges.  */
 static bool
 loop_with_complex_edge_p (struct loop *loop)
 {
@@ -2619,8 +2619,8 @@ remove_unnecessary_regions (bool all_p)
 
 /* At this point true value of allocno attribute bad_spill_p means
    that there is an insn where allocno occurs and where the allocno
-   can not be used as memory.  The function updates the attribute, now
-   it can be true only for allocnos which can not be used as memory in
+   cannot be used as memory.  The function updates the attribute, now
+   it can be true only for allocnos which cannot be used as memory in
    an insn and in whose live ranges there is other allocno deaths.
    Spilling allocnos with true value will not improve the code because
    it will not make other allocnos colorable and additional reloads
diff --git a/gcc/ira-color.c b/gcc/ira-color.c
index 565f7a0..aa91b56 100644
--- a/gcc/ira-color.c
+++ b/gcc/ira-color.c
@@ -1575,7 +1575,7 @@ update_conflict_hard_regno_costs (int *costs, enum reg_class aclass,
 /* Set up conflicting (through CONFLICT_REGS) for each object of
    allocno A and the start allocno profitable regs (through
    START_PROFITABLE_REGS).  Remember that the start profitable regs
-   exclude hard regs which can not hold value of mode of allocno A.
+   exclude hard regs which cannot hold value of mode of allocno A.
    This covers mostly cases when multi-register value should be
    aligned.  */
 static inline void
@@ -2272,7 +2272,7 @@ bucket_allocno_compare_func (const void *v1p, const void *v2p)
   /* Push pseudos requiring less hard registers first.  It means that
      we will assign pseudos requiring more hard registers first
      avoiding creation small holes in free hard register file into
-     which the pseudos requiring more hard registers can not fit.  */
+     which the pseudos requiring more hard registers cannot fit.  */
   if ((diff = (ira_reg_class_max_nregs[cl1][ALLOCNO_MODE (a1)]
 	       - ira_reg_class_max_nregs[cl2][ALLOCNO_MODE (a2)])) != 0)
     return diff;
diff --git a/gcc/ira-conflicts.c b/gcc/ira-conflicts.c
index b57468b..7ec709d 100644
--- a/gcc/ira-conflicts.c
+++ b/gcc/ira-conflicts.c
@@ -289,7 +289,7 @@ process_regs_for_copy (rtx reg1, rtx reg2, bool constraint_p,
 
   if (! IN_RANGE (allocno_preferenced_hard_regno,
 		  0, FIRST_PSEUDO_REGISTER - 1))
-    /* Can not be tied.  */
+    /* Cannot be tied.  */
     return false;
   rclass = REGNO_REG_CLASS (allocno_preferenced_hard_regno);
   mode = ALLOCNO_MODE (a);
@@ -300,7 +300,7 @@ process_regs_for_copy (rtx reg1, rtx reg2, bool constraint_p,
     return false;
   index = ira_class_hard_reg_index[aclass][allocno_preferenced_hard_regno];
   if (index < 0)
-    /* Can not be tied.  It is not in the allocno class.  */
+    /* Cannot be tied.  It is not in the allocno class.  */
     return false;
   ira_init_register_move_cost_if_necessary (mode);
   if (HARD_REGISTER_P (reg1))
diff --git a/gcc/ira-costs.c b/gcc/ira-costs.c
index e5d8804..0ca70a0 100644
--- a/gcc/ira-costs.c
+++ b/gcc/ira-costs.c
@@ -389,8 +389,8 @@ setup_regno_cost_classes_by_aclass (int regno, enum reg_class aclass)
 
 /* Setup cost classes for pseudo REGNO with MODE.  Usage of MODE can
    decrease number of cost classes for the pseudo, if hard registers
-   of some important classes can not hold a value of MODE.  So the
-   pseudo can not get hard register of some important classes and cost
+   of some important classes cannot hold a value of MODE.  So the
+   pseudo cannot get hard register of some important classes and cost
    calculation for such important classes is only wasting CPU
    time.  */
 static void
diff --git a/gcc/ira-int.h b/gcc/ira-int.h
index 181fba5..3c7fe4e 100644
--- a/gcc/ira-int.h
+++ b/gcc/ira-int.h
@@ -107,7 +107,7 @@ struct ira_loop_tree_node
 
   /* Allocnos in the loop corresponding to their regnos.  If it is
      NULL the loop does not form a separate register allocation region
-     (e.g. because it has abnormal enter/exit edges and we can not put
+     (e.g. because it has abnormal enter/exit edges and we cannot put
      code for register shuffling on the edges if a different
      allocation is used for a pseudo-register on different sides of
      the edges).  Caps are not in the map (remember we can have more
@@ -145,7 +145,7 @@ extern ira_loop_tree_node_t ira_loop_tree_root;
 extern int ira_loop_tree_height;
 
 /* All nodes representing basic blocks are referred through the
-   following array.  We can not use basic block member `aux' for this
+   following array.  We cannot use basic block member `aux' for this
    because it is used for insertion of insns on edges.  */
 extern ira_loop_tree_node_t ira_bb_nodes;
 
@@ -250,7 +250,7 @@ struct ira_object
      of other ira_objects that this one can conflict with.  */
   int min, max;
   /* Initial and accumulated hard registers conflicting with this
-     object and as a consequences can not be assigned to the allocno.
+     object and as a consequences cannot be assigned to the allocno.
      All non-allocatable hard regs and hard regs of register classes
      different from given allocno one are included in the sets.  */
   HARD_REG_SET conflict_hard_regs, total_conflict_hard_regs;
@@ -795,7 +795,7 @@ struct target_ira_int {
   struct costs *x_op_costs[MAX_RECOG_OPERANDS];
   struct costs *x_this_op_costs[MAX_RECOG_OPERANDS];
 
-  /* Hard registers that can not be used for the register allocator for
+  /* Hard registers that cannot be used for the register allocator for
      all functions of the current compilation unit.  */
   HARD_REG_SET x_no_unit_alloc_regs;
 
diff --git a/gcc/ira-lives.c b/gcc/ira-lives.c
index c9e422a..af5b821 100644
--- a/gcc/ira-lives.c
+++ b/gcc/ira-lives.c
@@ -1381,7 +1381,7 @@ process_bb_node_lives (ira_loop_tree_node_t loop_tree_node)
 		  /* We should create a conflict of PIC pseudo with
 		     PIC hard reg as PIC hard reg can have a wrong
 		     value after jump described by the abnormal edge.
-		     In this case we can not allocate PIC hard reg to
+		     In this case we cannot allocate PIC hard reg to
 		     PIC pseudo as PIC pseudo will also have a wrong
 		     value.  This code is not critical as LRA can fix
 		     it but it is better to have the right allocation
diff --git a/gcc/ira.c b/gcc/ira.c
index 4b9c11d..ccdc2ab 100644
--- a/gcc/ira.c
+++ b/gcc/ira.c
@@ -233,7 +233,7 @@ along with GCC; see the file COPYING3.  If not see
 	 more profitable than memory usage.
 
        * Popping the allocnos from the stack and assigning them hard
-         registers.  If IRA can not assign a hard register to an
+         registers.  If IRA cannot assign a hard register to an
          allocno and the allocno is coalesced, IRA undoes the
          coalescing and puts the uncoalesced allocnos onto the stack in
          the hope that some such allocnos will get a hard register
@@ -937,7 +937,7 @@ setup_uniform_class_p (void)
       ira_uniform_class_p[cl] = false;
       if (ira_class_hard_regs_num[cl] == 0)
 	continue;
-      /* We can not use alloc_reg_class_subclasses here because move
+      /* We cannot use alloc_reg_class_subclasses here because move
 	 cost hooks does not take into account that some registers are
 	 unavailable for the subtarget.  E.g. for i686, INT_SSE_REGS
 	 is element of alloc_reg_class_subclasses for GENERAL_REGS
@@ -966,7 +966,7 @@ setup_uniform_class_p (void)
    IRA_IMPORTANT_CLASSES, and IRA_IMPORTANT_CLASSES_NUM.
 
    Target may have many subtargets and not all target hard registers can
-   be used for allocation, e.g. x86 port in 32-bit mode can not use
+   be used for allocation, e.g. x86 port in 32-bit mode cannot use
    hard registers introduced in x86-64 like r8-r15).  Some classes
    might have the same allocatable hard registers, e.g.  INDEX_REGS
    and GENERAL_REGS in x86 port in 32-bit mode.  To decrease different
@@ -3506,7 +3506,7 @@ update_equiv_regs (void)
 	      rtx_insn_list *list;
 
 	      /* If we have already processed this pseudo and determined it
-		 can not have an equivalence, then honor that decision.  */
+		 cannot have an equivalence, then honor that decision.  */
 	      if (reg_equiv[regno].no_equiv)
 		continue;
 
@@ -5390,7 +5390,7 @@ ira (FILE *f)
   if (ira_conflicts_p && ! ira_use_lra_p)
     /* Opposite to reload pass, LRA does not use any conflict info
        from IRA.  We don't rebuild conflict info for LRA (through
-       ira_flattening call) and can not use the check here.  We could
+       ira_flattening call) and cannot use the check here.  We could
        rebuild this info for LRA in the check mode but there is a risk
        that code generated with the check and without it will be a bit
        different.  Calling ira_flattening in any mode would be a
diff --git a/gcc/ira.h b/gcc/ira.h
index 0e7232a..8e1d039 100644
--- a/gcc/ira.h
+++ b/gcc/ira.h
@@ -109,7 +109,7 @@ struct target_ira
      index [CL][M] gives the number of that register, otherwise it is -1.  */
   short x_ira_class_singleton[N_REG_CLASSES][MAX_MACHINE_MODE];
 
-  /* Function specific hard registers can not be used for the register
+  /* Function specific hard registers cannot be used for the register
      allocation.  */
   HARD_REG_SET x_ira_no_alloc_regs;
 
diff --git a/gcc/loop-invariant.c b/gcc/loop-invariant.c
index 715be59..3e82f1e 100644
--- a/gcc/loop-invariant.c
+++ b/gcc/loop-invariant.c
@@ -1053,7 +1053,7 @@ check_dependencies (rtx_insn *insn, bitmap depends_on)
   return true;
 }
 
-/* Pre-check candidate DEST to skip the one which can not make a valid insn
+/* Pre-check candidate DEST to skip the one which cannot make a valid insn
    during move_invariant_reg.  SIMPLE is to skip HARD_REGISTER.  */
 static bool
 pre_check_invariant_p (bool simple, rtx dest)
@@ -1365,7 +1365,7 @@ get_inv_cost (struct invariant *inv, int *comp_cost, unsigned *regs_needed,
        This usually has the effect that FP constant loads from the constant
        pool are not moved out of the loop.
 
-       Note that this also means that dependent invariants can not be moved.
+       Note that this also means that dependent invariants cannot be moved.
        However, the primary purpose of this pass is to move loop invariant
        address arithmetic out of loops, and address arithmetic that depends
        on floating point constants is unlikely to ever occur.  */
diff --git a/gcc/loop-unroll.c b/gcc/loop-unroll.c
index 6a9436b..cbc6673 100644
--- a/gcc/loop-unroll.c
+++ b/gcc/loop-unroll.c
@@ -1407,7 +1407,7 @@ analyze_insn_to_expand_var (struct loop *loop, rtx_insn *insn)
     }
 
   /* Hmm, this is a bit paradoxical.  We know that INSN is a valid insn
-     in MD.  But if there is no optab to generate the insn, we can not
+     in MD.  But if there is no optab to generate the insn, we cannot
      perform the variable expansion.  This can happen if an MD provides
      an insn but not a named pattern to generate it, for example to avoid
      producing code that needs additional mode switches like for x87/mmx.
diff --git a/gcc/lower-subreg.c b/gcc/lower-subreg.c
index fcc0aa2..4f68a73 100644
--- a/gcc/lower-subreg.c
+++ b/gcc/lower-subreg.c
@@ -79,7 +79,7 @@ along with GCC; see the file COPYING3.  If not see
 static bitmap decomposable_context;
 
 /* Bit N in this bitmap is set if regno N is used in a context in
-   which it can not be decomposed.  */
+   which it cannot be decomposed.  */
 static bitmap non_decomposable_context;
 
 /* Bit N in this bitmap is set if regno N is used in a subreg
@@ -561,7 +561,7 @@ find_decomposable_subregs (rtx *loc, enum classify_move_insn *pcmi)
 	     the register.
 
 	     If this is not a simple copy from one location to another,
-	     then we can not decompose this register.  If this is a simple
+	     then we cannot decompose this register.  If this is a simple
 	     copy we want to decompose, and the mode is right,
 	     then we mark the register as decomposable.
 	     Otherwise we don't say anything about this register --
@@ -982,7 +982,7 @@ resolve_simple_move (rtx set, rtx_insn *insn)
   /* It's possible for the code to use a subreg of a decomposed
      register while forming an address.  We need to handle that before
      passing the address to emit_move_insn.  We pass NULL_RTX as the
-     insn parameter to resolve_subreg_use because we can not validate
+     insn parameter to resolve_subreg_use because we cannot validate
      the insn yet.  */
   if (MEM_P (src) || MEM_P (dest))
     {
diff --git a/gcc/lra-assigns.c b/gcc/lra-assigns.c
index e59f499..1312804 100644
--- a/gcc/lra-assigns.c
+++ b/gcc/lra-assigns.c
@@ -564,7 +564,7 @@ find_hard_regno_for_1 (int regno, int *cost, int try_only_hard_regno,
 				    lra_reg_info[conflict_regno].biggest_mode);
 	  /* Remember about multi-register pseudos.  For example, 2
 	     hard register pseudos can start on the same hard register
-	     but can not start on HR and HR+1/HR-1.  */
+	     but cannot start on HR and HR+1/HR-1.  */
 	  for (hr = conflict_hr + 1;
 	       hr < FIRST_PSEUDO_REGISTER && hr < conflict_hr + nregs;
 	       hr++)
@@ -634,7 +634,7 @@ find_hard_regno_for_1 (int regno, int *cost, int try_only_hard_regno,
 				     PSEUDO_REGNO_MODE (regno), hard_regno)
 	  && targetm.hard_regno_mode_ok (hard_regno,
 					 PSEUDO_REGNO_MODE (regno))
-	  /* We can not use prohibited_class_mode_regs for all classes
+	  /* We cannot use prohibited_class_mode_regs for all classes
 	     because it is not defined for all classes.  */
 	  && (ira_allocno_class_translate[rclass] != rclass
 	      || ! TEST_HARD_REG_BIT (ira_prohibited_class_mode_regs
@@ -785,7 +785,7 @@ lra_setup_reg_renumber (int regno, int hard_regno, bool print_p)
 {
   int i, hr;
 
-  /* We can not just reassign hard register.  */
+  /* We cannot just reassign hard register.  */
   lra_assert (hard_regno < 0 || reg_renumber[regno] < 0);
   if ((hr = hard_regno) < 0)
     hr = reg_renumber[regno];
@@ -1434,7 +1434,7 @@ assign_by_spills (void)
 	  fails_p = nfails != 0;
 	  break;
 	}
-      /* This is a very rare event.  We can not assign a hard register
+      /* This is a very rare event.  We cannot assign a hard register
 	 to reload pseudo because the hard register was assigned to
 	 another reload pseudo on a previous assignment pass.  For x86
 	 example, on the 1st pass we assigned CX (although another
diff --git a/gcc/lra-constraints.c b/gcc/lra-constraints.c
index 7ffcd35..e3b5ddb 100644
--- a/gcc/lra-constraints.c
+++ b/gcc/lra-constraints.c
@@ -985,7 +985,7 @@ match_reload (signed char out, signed char *ins, signed char *outs,
 	 operand ("a").  "b" must then be copied into a new register
 	 so that it doesn't clobber the current value of "a".
 
-	 We can not use the same value if the output pseudo is
+	 We cannot use the same value if the output pseudo is
 	 early clobbered or the input pseudo is mentioned in the
 	 output, e.g. as an address part in memory, because
 	 output reload will actually extend the pseudo liveness.
@@ -1880,7 +1880,7 @@ update_and_check_small_class_inputs (int nop, enum reg_class op_class)
 /* Major function to choose the current insn alternative and what
    operands should be reloaded and how.	 If ONLY_ALTERNATIVE is not
    negative we should consider only this alternative.  Return false if
-   we can not choose the alternative or find how to reload the
+   we cannot choose the alternative or find how to reload the
    operands.  */
 static bool
 process_alt_operands (int only_alternative)
@@ -2638,7 +2638,7 @@ process_alt_operands (int only_alternative)
 		  goto fail;
 		}
 
-	      /* Alternative loses if it required class pseudo can not
+	      /* Alternative loses if it required class pseudo cannot
 		 hold value of required mode.  Such insns can be
 		 described by insn definitions with mode iterators.  */
 	      if (GET_MODE (*curr_id->operand_loc[nop]) != VOIDmode
@@ -2662,7 +2662,7 @@ process_alt_operands (int only_alternative)
 		  if (lra_dump_file != NULL)
 		    fprintf (lra_dump_file,
 			     "            alt=%d: reload pseudo for op %d "
-			     " can not hold the mode value -- refuse\n",
+			     " cannot hold the mode value -- refuse\n",
 			     nalt, nop);
 		  goto fail;
 		}
@@ -4008,7 +4008,7 @@ curr_insn_transform (bool check_only_p)
       if (sec_mode != rld_mode)
         {
 	  /* If the target says specifically to use another mode for
-	     secondary memory moves we can not reuse the original
+	     secondary memory moves we cannot reuse the original
 	     insn.  */
 	  after = emit_spill_move (false, new_reg, dest);
 	  lra_process_new_insns (curr_insn, NULL, after,
@@ -4767,7 +4767,7 @@ lra_constraints (bool first_p)
 	  {
 	    bool pseudo_p = contains_reg_p (x, false, false);
 
-	    /* After RTL transformation, we can not guarantee that
+	    /* After RTL transformation, we cannot guarantee that
 	       pseudo in the substitution was not reloaded which might
 	       make equivalence invalid.  For example, in reverse
 	       equiv of p0
@@ -4800,7 +4800,7 @@ lra_constraints (bool first_p)
 		|| (! reverse_equiv_p (i)
 		    && (init_insn_rhs_dead_pseudo_p (i)
 			/* If we reloaded the pseudo in an equivalence
-			   init insn, we can not remove the equiv init
+			   init insn, we cannot remove the equiv init
 			   insns and the init insns might write into
 			   const memory in this case.  */
 			|| contains_reloaded_insn_p (i)))
@@ -4882,7 +4882,7 @@ lra_constraints (bool first_p)
 	      if ((REG_P (dest_reg)
 		   && (x = get_equiv (dest_reg)) != dest_reg
 		   /* Remove insns which set up a pseudo whose value
-		      can not be changed.  Such insns might be not in
+		      cannot be changed.  Such insns might be not in
 		      init_insns because we don't update equiv data
 		      during insn transformations.
 		      
@@ -5195,7 +5195,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 cannot be involded in invariant inheritance in the
    current EBB.  */
 static bitmap_head invalid_invariant_regs;
 
@@ -6316,12 +6316,12 @@ inherit_in_ebb (rtx_insn *head, rtx_insn *tail)
 		      /* Don't do inheritance if the pseudo is also
 			 used in the insn.  */
 		      if (r == NULL)
-			/* We can not do inheritance right now
+			/* We cannot do inheritance right now
 			   because the current insn reg info (chain
 			   regs) can change after that.  */
 			add_to_inherit (dst_regno, next_usage_insns);
 		    }
-		  /* We can not process one reg twice here because of
+		  /* We cannot process one reg twice here because of
 		     usage_insns invalidation.  */
 		  if ((dst_regno < FIRST_PSEUDO_REGISTER
 		       || reg_renumber[dst_regno] >= 0)
@@ -6741,7 +6741,7 @@ remove_inheritance_pseudos (bitmap remove_pseudos)
   bool change_p, done_p;
 
   change_p = ! bitmap_empty_p (remove_pseudos);
-  /* We can not finish the function right away if CHANGE_P is true
+  /* We cannot finish the function right away if CHANGE_P is true
      because we need to marks insns affected by previous
      inheritance/split pass for processing by the subsequent
      constraint pass.  */
@@ -6782,7 +6782,7 @@ remove_inheritance_pseudos (bitmap remove_pseudos)
 		{
 		  /* reload pseudo <- invariant inheritance pseudo */
 		  start_sequence ();
-		  /* We can not just change the source.  It might be
+		  /* We cannot just change the source.  It might be
 		     an insn different from the move.  */
 		  emit_insn (lra_reg_info[sregno].restore_rtx);
 		  rtx_insn *new_insns = get_insns ();
diff --git a/gcc/lra-eliminations.c b/gcc/lra-eliminations.c
index e7d4830..ee9fd51 100644
--- a/gcc/lra-eliminations.c
+++ b/gcc/lra-eliminations.c
@@ -1109,7 +1109,7 @@ eliminate_regs_in_insn (rtx_insn *insn, bool replace_p, bool first_p,
 	    {
 	      /* If we are assigning to a hard register that can be
 		 eliminated, it must be as part of a PARALLEL, since
-		 the code above handles single SETs.  This reg can not
+		 the code above handles single SETs.  This reg cannot
 		 be longer eliminated -- it is forced by
 		 mark_not_eliminable.  */
 	      for (ep = reg_eliminate;
@@ -1236,7 +1236,7 @@ update_reg_eliminate (bitmap insns_with_changed_offsets)
 		     "	Elimination %d to %d is not possible anymore\n",
 		     ep->from, ep->to);
 	  /* If after processing RTL we decides that SP can be used as
-	     a result of elimination, it can not be changed.  */
+	     a result of elimination, it cannot be changed.  */
 	  gcc_assert ((ep->to_rtx != stack_pointer_rtx)
 		      || (ep->from < FIRST_PSEUDO_REGISTER
 			  && fixed_regs [ep->from]));
diff --git a/gcc/lra-lives.c b/gcc/lra-lives.c
index 7b60691..a00ec38 100644
--- a/gcc/lra-lives.c
+++ b/gcc/lra-lives.c
@@ -1073,7 +1073,7 @@ process_bb_lives (basic_block bb, int &curr_point, bool dead_insn_p)
 	      /* We should create a conflict of PIC pseudo with PIC
 		 hard reg as PIC hard reg can have a wrong value after
 		 jump described by the abnormal edge.  In this case we
-		 can not allocate PIC hard reg to PIC pseudo as PIC
+		 cannot allocate PIC hard reg to PIC pseudo as PIC
 		 pseudo will also have a wrong value.  */
 	      || (px == REAL_PIC_OFFSET_TABLE_REGNUM
 		  && pic_offset_table_rtx != NULL_RTX
diff --git a/gcc/lra-remat.c b/gcc/lra-remat.c
index 61efc37..8dde7d2 100644
--- a/gcc/lra-remat.c
+++ b/gcc/lra-remat.c
@@ -253,7 +253,7 @@ finish_cand_table (void)
 
 
 
-/* Return true if X contains memory or some UNSPEC.  We can not just
+/* Return true if X contains memory or some UNSPEC.  We cannot just
    check insn operands as memory or unspec might be not an operand
    itself but contain an operand.  Insn with memory access is not
    profitable for rematerialization.  Rematerialization of UNSPEC
@@ -287,7 +287,7 @@ bad_for_rematerialization_p (rtx x)
   return false;
 }
 
-/* If INSN can not be used for rematerialization, return negative
+/* If INSN cannot be used for rematerialization, return negative
    value.  If INSN can be considered as a candidate for
    rematerialization, return value which is the operand number of the
    pseudo for which the insn can be used for rematerialization.  Here
@@ -306,10 +306,10 @@ operand_to_remat (rtx_insn *insn)
   /* First find a pseudo which can be rematerialized.  */
   for (reg = id->regs; reg != NULL; reg = reg->next)
     {
-      /* True FRAME_POINTER_NEEDED might be because we can not follow
+      /* True FRAME_POINTER_NEEDED might be because we cannot follow
 	 changing sp offsets, e.g. alloca is used.  If the insn contains
-	 stack pointer in such case, we can not rematerialize it as we
-	 can not know sp offset at a rematerialization place.  */
+	 stack pointer in such case, we cannot rematerialize it as we
+	 cannot know sp offset at a rematerialization place.  */
       if (reg->regno == STACK_POINTER_REGNUM && frame_pointer_needed)
 	return -1;
       else if (reg->type == OP_OUT && ! reg->subreg_p
diff --git a/gcc/lra-spills.c b/gcc/lra-spills.c
index 29c3620..c19b76a 100644
--- a/gcc/lra-spills.c
+++ b/gcc/lra-spills.c
@@ -232,7 +232,7 @@ assign_spill_hard_regs (int *pseudo_regnos, int n)
   basic_block bb;
   HARD_REG_SET conflict_hard_regs;
   bitmap setjump_crosses = regstat_get_setjmp_crosses ();
-  /* Hard registers which can not be used for any purpose at given
+  /* Hard registers which cannot be used for any purpose at given
      program point because they are unallocatable or already allocated
      for other pseudos.	 */
   HARD_REG_SET *reserved_hard_regs;
diff --git a/gcc/lra.c b/gcc/lra.c
index 75ee742..592b990 100644
--- a/gcc/lra.c
+++ b/gcc/lra.c
@@ -881,7 +881,7 @@ collect_non_operand_hard_regs (rtx_insn *insn, rtx *x,
 	      }
 	  if (curr == NULL)
 	    {
-	      /* This is a new hard regno or the info can not be
+	      /* This is a new hard regno or the info cannot be
 		 integrated into the found structure.	 */
 #ifdef STACK_REGS
 	      early_clobber
@@ -1495,7 +1495,7 @@ add_regs_to_insn_regno_info (lra_insn_recog_data_t data, rtx x,
 	    if (curr->regno == regno)
 	      {
 		if (curr->subreg_p != subreg_p || curr->biggest_mode != mode)
-		  /* The info can not be integrated into the found
+		  /* The info cannot be integrated into the found
 		     structure.  */
 		  data->regs = new_insn_reg (data->insn, regno, type, mode,
 					     subreg_p, early_clobber,
diff --git a/gcc/lto-cgraph.c b/gcc/lto-cgraph.c
index a6af812..b941c76 100644
--- a/gcc/lto-cgraph.c
+++ b/gcc/lto-cgraph.c
@@ -421,7 +421,7 @@ lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node,
   if (boundary_p && node->analyzed
       && node->get_partitioning_class () == SYMBOL_PARTITION)
     {
-      /* Inline clones can not be part of boundary.  
+      /* Inline clones cannot be part of boundary.  
          gcc_assert (!node->global.inlined_to);  
 
 	 FIXME: At the moment they can be, when partition contains an inline
diff --git a/gcc/lto-streamer-out.c b/gcc/lto-streamer-out.c
index 209ce86..b26c883 100644
--- a/gcc/lto-streamer-out.c
+++ b/gcc/lto-streamer-out.c
@@ -857,7 +857,7 @@ DFS::DFS_write_tree_body (struct output_block *ob,
       /* TYPE_CANONICAL is re-computed during type merging, so no need
 	 to follow it here.  */
       /* Do not stream TYPE_STUB_DECL; it is not needed by LTO but currently
-	 it can not be freed by free_lang_data without triggering ICEs in
+	 it cannot be freed by free_lang_data without triggering ICEs in
 	 langhooks.  */
     }
 
diff --git a/gcc/lto/ChangeLog b/gcc/lto/ChangeLog
index 3c18f30..6b183df 100644
--- a/gcc/lto/ChangeLog
+++ b/gcc/lto/ChangeLog
@@ -1,3 +1,11 @@
+2019-01-09  Sandra Loosemore  <sandra@codesourcery.com>
+
+	PR other/16615
+
+	* lto-partition.c: Mechanically replace "can not" with "cannot".
+	* lto-symtab.c: Likewise.
+	* lto.c: Likewise.
+
 2019-01-01  Jakub Jelinek  <jakub@redhat.com>
 
 	Update copyright years.
diff --git a/gcc/lto/lto-partition.c b/gcc/lto/lto-partition.c
index 988e89b..6972e6e 100644
--- a/gcc/lto/lto-partition.c
+++ b/gcc/lto/lto-partition.c
@@ -250,14 +250,14 @@ add_symbol_to_partition (ltrans_partition part, symtab_node *node)
 {
   symtab_node *node1;
 
-  /* Verify that we do not try to duplicate something that can not be.  */
+  /* Verify that we do not try to duplicate something that cannot be.  */
   gcc_checking_assert (node->get_partitioning_class () == SYMBOL_DUPLICATE
 		       || !symbol_partitioned_p (node));
 
   while ((node1 = contained_in_symbol (node)) != node)
     node = node1;
 
-  /* If we have duplicated symbol contained in something we can not duplicate,
+  /* If we have duplicated symbol contained in something we cannot duplicate,
      we are very badly screwed.  The other way is possible, so we do not
      assert this in add_symbol_to_partition_1. 
 
@@ -1093,7 +1093,7 @@ rename_statics (lto_symtab_encoder_t encoder, symtab_node *node)
     return;
 
   /* Now walk symbols sharing the same name and see if there are any conflicts.
-     (all types of symbols counts here, since we can not have static of the
+     (all types of symbols counts here, since we cannot have static of the
      same name as external or public symbol.)  */
   for (s = symtab_node::get_for_asmname (name);
        s; s = s->next_sharing_asm_name)
diff --git a/gcc/lto/lto-symtab.c b/gcc/lto/lto-symtab.c
index 83b0edf..22da4c7 100644
--- a/gcc/lto/lto-symtab.c
+++ b/gcc/lto/lto-symtab.c
@@ -240,7 +240,7 @@ warn_type_compatibility_p (tree prevailing_type, tree type,
   prevailing_type = TYPE_MAIN_VARIANT (prevailing_type);
   type = TYPE_MAIN_VARIANT (type);
 
-  /* We can not use types_compatible_p because we permit some changes
+  /* We cannot use types_compatible_p because we permit some changes
      across types.  For example unsigned size_t and "signed size_t" may be
      compatible when merging C and Fortran types.  */
   if (COMPLETE_TYPE_P (prevailing_type)
diff --git a/gcc/lto/lto.c b/gcc/lto/lto.c
index a95ef31..bb332f8 100644
--- a/gcc/lto/lto.c
+++ b/gcc/lto/lto.c
@@ -290,7 +290,7 @@ hash_canonical_type (tree type)
   enum tree_code code;
 
   /* We compute alias sets only for types that needs them.
-     Be sure we do not recurse to something else as we can not hash incomplete
+     Be sure we do not recurse to something else as we cannot hash incomplete
      types in a way they would have same hash value as compatible complete
      types.  */
   gcc_checking_assert (type_with_alias_set_p (type));
diff --git a/gcc/objc/ChangeLog b/gcc/objc/ChangeLog
index 50536b7..aa81466 100644
--- a/gcc/objc/ChangeLog
+++ b/gcc/objc/ChangeLog
@@ -1,3 +1,9 @@
+2019-01-09  Sandra Loosemore  <sandra@codesourcery.com>
+
+	PR other/16615
+
+	* objc-act.c: Mechanically replace "can not" with "cannot".
+
 2019-01-01  Jakub Jelinek  <jakub@redhat.com>
 
 	Update copyright years.
diff --git a/gcc/objc/objc-act.c b/gcc/objc/objc-act.c
index cc5f70a..777225e 100644
--- a/gcc/objc/objc-act.c
+++ b/gcc/objc/objc-act.c
@@ -907,7 +907,7 @@ objc_add_property_declaration (location_t location, tree decl,
 
   if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
     {
-      error_at (location, "property can not be an array");
+      error_at (location, "property cannot be an array");
       return;
     }
 
@@ -922,10 +922,10 @@ objc_add_property_declaration (location_t location, tree decl,
 	 describe a pair of accessor methods, so its type (which is
 	 the type of the return value of the getter and the first
 	 argument of the setter) can't be a bitfield (as return values
-	 and arguments of functions can not be bitfields).  The
+	 and arguments of functions cannot be bitfields).  The
 	 underlying instance variable could be a bitfield, but that is
 	 a different matter.  */
-      error_at (location, "property can not be a bit-field");
+      error_at (location, "property cannot be a bit-field");
       return;
     }
 #endif
@@ -1743,7 +1743,7 @@ objc_build_setter_call (tree lhs, tree rhs)
 
   if (PROPERTY_READONLY (property_decl))
     {
-      error ("readonly property can not be set");
+      error ("readonly property cannot be set");
       return error_mark_node;
     }
   else
@@ -2053,7 +2053,7 @@ objc_start_method_definition (bool is_class_method, tree decl, tree attributes,
 #endif
 
   if (attributes)
-    warning_at (input_location, 0, "method attributes can not be specified in @implementation context");
+    warning_at (input_location, 0, "method attributes cannot be specified in @implementation context");
   else
     objc_decl_method_attributes (&decl, attributes, 0);
 
@@ -4210,7 +4210,7 @@ objc_begin_catch_clause (tree decl)
   else if (TYPE_HAS_OBJC_INFO (TREE_TYPE (type))
 	   && TYPE_OBJC_PROTOCOL_LIST (TREE_TYPE (type)))
     {
-      error ("@catch parameter can not be protocol-qualified");
+      error ("@catch parameter cannot be protocol-qualified");
       type = error_mark_node;
     }
   else if (POINTER_TYPE_P (type) && objc_is_object_id (TREE_TYPE (type)))
@@ -4677,7 +4677,7 @@ adjust_type_for_id_default (tree type)
     TREE_VALUE (type) = objc_object_type;
   else if (TREE_CODE (TREE_VALUE (type)) == RECORD_TYPE
 	   && TYPED_OBJECT (TREE_VALUE (type)))
-    error ("can not use an object as parameter to a method");
+    error ("cannot use an object as parameter to a method");
 
   return type;
 }
@@ -7225,7 +7225,7 @@ objc_synthesize_getter (tree klass, tree class_methods ATTRIBUTE_UNUSED, tree pr
 	  {
 	    /* This should never happen.  */
 	    error_at (location,
-		      "can not find instance variable associated with property");
+		      "cannot find instance variable associated with property");
 	    ret_val = error_mark_node;
 	    break;
 	  }
@@ -7421,7 +7421,7 @@ objc_synthesize_setter (tree klass, tree class_methods ATTRIBUTE_UNUSED, tree pr
 	if (!ivar || is_private (ivar))
 	  {
 	    error_at (location,
-		      "can not find instance variable associated with property");
+		      "cannot find instance variable associated with property");
 	    statement = error_mark_node;
 	    break;
 	  }
@@ -7727,7 +7727,7 @@ objc_add_synthesize_declaration (location_t location, tree property_and_ivar_lis
 
   if (TREE_CODE (objc_implementation_context) == CATEGORY_IMPLEMENTATION_TYPE)
     {
-      error_at (location, "%<@synthesize%> can not be used in categories");
+      error_at (location, "%<@synthesize%> cannot be used in categories");
       return;
     }
 
diff --git a/gcc/postreload-gcse.c b/gcc/postreload-gcse.c
index cc9e657..a165351 100644
--- a/gcc/postreload-gcse.c
+++ b/gcc/postreload-gcse.c
@@ -1392,7 +1392,7 @@ gcse_after_reload_main (rtx f ATTRIBUTE_UNUSED)
 	 increase the number of redundant loads found.  So compute transparency
 	 information for each memory expression in the hash table.  */
       df_analyze ();
-      /* This can not be part of the normal allocation routine because
+      /* This cannot be part of the normal allocation routine because
 	 we have to know the number of elements in the hash table.  */
       transp = sbitmap_vector_alloc (last_basic_block_for_fn (cfun),
 				     expr_table->elements ());
diff --git a/gcc/predict.c b/gcc/predict.c
index 0ac8adf..43ee91a 100644
--- a/gcc/predict.c
+++ b/gcc/predict.c
@@ -826,7 +826,7 @@ unlikely_executed_bb_p (basic_block bb)
   return false;
 }
 
-/* We can not predict the probabilities of outgoing edges of bb.  Set them
+/* We cannot predict the probabilities of outgoing edges of bb.  Set them
    evenly and hope for the best.  If UNLIKELY_EDGES is not null, distribute
    even probability for all edges not mentioned in the set.  These edges
    are given PROB_VERY_UNLIKELY probability.  Similarly for LIKELY_EDGES,
@@ -4266,7 +4266,7 @@ report_predictor_hitrates (void)
    we are not 100% sure.
 
    This function locally updates profile without attempt to keep global
-   consistency which can not be reached in full generality without full profile
+   consistency which cannot be reached in full generality without full profile
    rebuild from probabilities alone.  Doing so is not necessarily a good idea
    because frequencies and counts may be more realistic then probabilities.
 
@@ -4344,7 +4344,7 @@ force_edge_cold (edge e, bool impossible)
 	{
 	  if (impossible)
 	    e->probability = profile_probability::never ();
-	  /* If BB has some edges out that are not impossible, we can not
+	  /* If BB has some edges out that are not impossible, we cannot
 	     assume that BB itself is.  */
 	  impossible = false;
 	}
diff --git a/gcc/profile-count.h b/gcc/profile-count.h
index 96b7400..06564dd 100644
--- a/gcc/profile-count.h
+++ b/gcc/profile-count.h
@@ -30,7 +30,7 @@ enum profile_quality {
   /* Uninitialized value.  */
   profile_uninitialized,
   /* Profile is based on static branch prediction heuristics and may
-     or may not match reality.  It is local to function and can not be compared
+     or may not match reality.  It is local to function and cannot be compared
      inter-procedurally.  Never used by probabilities (they are always local).
    */
   profile_guessed_local,
@@ -539,7 +539,7 @@ public:
     }
 
   /* Comparsions are three-state and conservative.  False is returned if
-     the inequality can not be decided.  */
+     the inequality cannot be decided.  */
   bool operator< (const profile_probability &other) const
     {
       return initialized_p () && other.initialized_p () && m_val < other.m_val;
@@ -596,7 +596,7 @@ public:
         was never run in train feedback) but they hold local static profile
         estimate.
 
-   Counters of type 1 and 3 can not be mixed with counters of different type
+   Counters of type 1 and 3 cannot be mixed with counters of different type
    within operation (because whole function should use one type of counter)
    with exception that global zero mix in most operations where outcome is
    well defined.
@@ -829,7 +829,7 @@ public:
     }
 
   /* Comparsions are three-state and conservative.  False is returned if
-     the inequality can not be decided.  */
+     the inequality cannot be decided.  */
   bool operator< (const profile_count &other) const
     {
       if (!initialized_p () || !other.initialized_p ())
diff --git a/gcc/profile.c b/gcc/profile.c
index 7374b0d..a1dba1a 100644
--- a/gcc/profile.c
+++ b/gcc/profile.c
@@ -1218,7 +1218,7 @@ branch_prob (bool thunk)
      various transformations.  */
   if (thunk)
     {
-      /* At stream in time we do not have CFG, so we can not do checksums.  */
+      /* At stream in time we do not have CFG, so we cannot do checksums.  */
       cfg_checksum = 0;
       lineno_checksum = 0;
     }
diff --git a/gcc/recog.c b/gcc/recog.c
index 6fedf77..d0c498f 100644
--- a/gcc/recog.c
+++ b/gcc/recog.c
@@ -2967,7 +2967,7 @@ split_all_insns (void)
 
 	     If that happens and INSN was the last reference to the
 	     given EH region, then the EH region will become unreachable.
-	     We can not leave the unreachable blocks in the CFG as that
+	     We cannot leave the unreachable blocks in the CFG as that
 	     will trigger a checking failure.
 
 	     So track if INSN has a REG_EH_REGION note.  If so and we
diff --git a/gcc/ree.c b/gcc/ree.c
index e49514b..e23e607 100644
--- a/gcc/ree.c
+++ b/gcc/ree.c
@@ -1206,7 +1206,7 @@ add_removable_extension (const_rtx expr, rtx_insn *insn,
 
       /* Fourth, if the extended version occupies more registers than the
 	 original and the source of the extension is the same hard register
-	 as the destination of the extension, then we can not eliminate
+	 as the destination of the extension, then we cannot eliminate
 	 the extension without deep analysis, so just punt.
 
 	 We allow this when the registers are different because the
diff --git a/gcc/reload.c b/gcc/reload.c
index 6cfd5e2..3ad11a8 100644
--- a/gcc/reload.c
+++ b/gcc/reload.c
@@ -408,7 +408,7 @@ push_secondary_reload (int in_p, rtx x, int opnum, int optional,
 
      The convention is that secondary input reloads are valid only if the
      secondary_class is different from class.  If you have such a case, you
-     can not use secondary reloads, you must work around the problem some
+     cannot use secondary reloads, you must work around the problem some
      other way.
 
      Allow this when a reload_in/out pattern is being used.  I.e. assume
@@ -6528,7 +6528,7 @@ reg_overlap_mentioned_for_reload_p (rtx x, rtx in)
       || GET_RTX_CLASS (GET_CODE (x)) == RTX_AUTOINC)
     x = XEXP (x, 0);
 
-  /* If either argument is a constant, then modifying X can not affect IN.  */
+  /* If either argument is a constant, then modifying X cannot affect IN.  */
   if (CONSTANT_P (x) || CONSTANT_P (in))
     return 0;
   else if (GET_CODE (x) == SUBREG && MEM_P (SUBREG_REG (x)))
diff --git a/gcc/reload1.c b/gcc/reload1.c
index b703402..9e4429f 100644
--- a/gcc/reload1.c
+++ b/gcc/reload1.c
@@ -6048,7 +6048,7 @@ reload_reg_free_for_value_p (int start_regno, int regno, int opnum,
    RELOADNUM is the number of the reload we want to load this value for;
    a reload does not conflict with itself.
 
-   When IGNORE_ADDRESS_RELOADS is set, we can not have conflicts with
+   When IGNORE_ADDRESS_RELOADS is set, we cannot have conflicts with
    reloads that load an address for the very reload we are considering.
 
    The caller has to make sure that there is no conflict with the return
@@ -8764,9 +8764,9 @@ gen_reload (rtx out, rtx in, int opnum, enum reload_type type)
     emit_insn (gen_rtx_SET (out, in));
 
   /* Return the first insn emitted.
-     We can not just return get_last_insn, because there may have
+     We cannot just return get_last_insn, because there may have
      been multiple instructions emitted.  Also note that gen_move_insn may
-     emit more than one insn itself, so we can not assume that there is one
+     emit more than one insn itself, so we cannot assume that there is one
      insn emitted per emit_insn_before call.  */
 
   return last ? NEXT_INSN (last) : get_insns ();
diff --git a/gcc/reorg.c b/gcc/reorg.c
index 1f26ffb..d2b5654 100644
--- a/gcc/reorg.c
+++ b/gcc/reorg.c
@@ -1064,9 +1064,9 @@ steal_delay_list_from_target (rtx_insn *insn, rtx condition, rtx_sequence *seq,
      ??? It may be possible to move other sets into INSN in addition to
      moving the instructions in the delay slots.
 
-     We can not steal the delay list if one of the instructions in the
+     We cannot steal the delay list if one of the instructions in the
      current delay_list modifies the condition codes and the jump in the
-     sequence is a conditional jump. We can not do this because we can
+     sequence is a conditional jump. We cannot do this because we can
      not change the direction of the jump because the condition codes
      will effect the direction of the jump in the sequence.  */
 
diff --git a/gcc/resource.c b/gcc/resource.c
index 5e1ed44..f8a23ed 100644
--- a/gcc/resource.c
+++ b/gcc/resource.c
@@ -265,7 +265,7 @@ mark_referenced_resources (rtx x, struct resources *res,
       res->volatil |= MEM_VOLATILE_P (x);
 
       /* For all ASM_OPERANDS, we must traverse the vector of input operands.
-	 We can not just fall through here since then we would be confused
+	 We cannot just fall through here since then we would be confused
 	 by the ASM_INPUT rtx inside ASM_OPERANDS, which do not indicate
 	 traditional asms unlike their normal usage.  */
 
@@ -817,7 +817,7 @@ mark_set_resources (rtx x, struct resources *res, int in_dest,
       res->volatil |= MEM_VOLATILE_P (x);
 
       /* For all ASM_OPERANDS, we must traverse the vector of input operands.
-	 We can not just fall through here since then we would be confused
+	 We cannot just fall through here since then we would be confused
 	 by the ASM_INPUT rtx inside ASM_OPERANDS, which do not indicate
 	 traditional asms unlike their normal usage.  */
 
diff --git a/gcc/rtl.def b/gcc/rtl.def
index 6c8ff30..f4c9d94 100644
--- a/gcc/rtl.def
+++ b/gcc/rtl.def
@@ -298,7 +298,7 @@ DEF_RTL_EXPR(SET, "set", "ee", RTX_EXTRA)
    For example, subroutine calls will use the register
    in which the static chain is passed.
 
-   USE can not appear as an operand of other rtx except for PARALLEL.
+   USE cannot appear as an operand of other rtx except for PARALLEL.
    USE is not deletable, as it indicates that the operand
    is used in some unknown way.  */
 DEF_RTL_EXPR(USE, "use", "e", RTX_EXTRA)
@@ -307,7 +307,7 @@ DEF_RTL_EXPR(USE, "use", "e", RTX_EXTRA)
    For example, subroutine calls will clobber some physical registers
    (the ones that are by convention not saved).
 
-   CLOBBER can not appear as an operand of other rtx except for PARALLEL.
+   CLOBBER cannot appear as an operand of other rtx except for PARALLEL.
    CLOBBER of a hard register appearing by itself (not within PARALLEL)
    is considered undeletable before reload.  */
 DEF_RTL_EXPR(CLOBBER, "clobber", "e", RTX_EXTRA)
@@ -683,7 +683,7 @@ DEF_RTL_EXPR(PARITY, "parity", "e", RTX_UNARY)
    operand 2 counts from the msb of the memory unit.
    Otherwise, the first bit is the lsb and operand 2 counts from
    the lsb of the memory unit.
-   This kind of expression can not appear as an lvalue in RTL.  */
+   This kind of expression cannot appear as an lvalue in RTL.  */
 DEF_RTL_EXPR(SIGN_EXTRACT, "sign_extract", "eee", RTX_BITFIELD_OPS)
 
 /* Similar for unsigned bit-field.
@@ -1079,7 +1079,7 @@ DEF_RTL_EXPR(DEFINE_CPU_UNIT, "define_cpu_unit", "sS", RTX_EXTRA)
 DEF_RTL_EXPR(DEFINE_QUERY_CPU_UNIT, "define_query_cpu_unit", "sS", RTX_EXTRA)
 
 /* (exclusion_set string string) means that each CPU functional unit
-   in the first string can not be reserved simultaneously with any
+   in the first string cannot be reserved simultaneously with any
    unit whose name is in the second string and vise versa.  CPU units
    in the string are separated by commas.  For example, it is useful
    for description CPU with fully pipelined floating point functional
@@ -1089,7 +1089,7 @@ DEF_RTL_EXPR(DEFINE_QUERY_CPU_UNIT, "define_query_cpu_unit", "sS", RTX_EXTRA)
 DEF_RTL_EXPR(EXCLUSION_SET, "exclusion_set", "ss", RTX_EXTRA)
 
 /* (presence_set string string) means that each CPU functional unit in
-   the first string can not be reserved unless at least one of pattern
+   the first string cannot be reserved unless at least one of pattern
    of units whose names are in the second string is reserved.  This is
    an asymmetric relation.  CPU units or unit patterns in the strings
    are separated by commas.  Pattern is one unit name or unit names
@@ -1139,13 +1139,13 @@ DEF_RTL_EXPR(FINAL_PRESENCE_SET, "final_presence_set", "ss", RTX_EXTRA)
    are separated by commas.  Pattern is one unit name or unit names
    separated by white-spaces.
 
-   For example, it is useful for description that slot0 can not be
+   For example, it is useful for description that slot0 cannot be
    reserved after slot1 or slot2 reservation for a VLIW processor.  We
    could describe it by the following construction
 
       (absence_set "slot2" "slot0, slot1")
 
-   Or slot2 can not be reserved if slot0 and unit b0 are reserved or
+   Or slot2 cannot be reserved if slot0 and unit b0 are reserved or
    slot1 and unit b1 are reserved .  In this case we could write
 
       (absence_set "slot2" "slot0 b0, slot1 b1")
diff --git a/gcc/rtl.h b/gcc/rtl.h
index 71a2ba4..70891e6 100644
--- a/gcc/rtl.h
+++ b/gcc/rtl.h
@@ -1629,7 +1629,7 @@ extern const char * const reg_note_name[];
    are passed to the function.
      CLOBBER expressions document the registers explicitly clobbered
    by this CALL_INSN.
-     Pseudo registers can not be mentioned in this list.  */
+     Pseudo registers cannot be mentioned in this list.  */
 #define CALL_INSN_FUNCTION_USAGE(INSN)	XEXP(INSN, 7)
 
 /* The label-number of a code-label.  The assembler label
diff --git a/gcc/rtlanal.c b/gcc/rtlanal.c
index 5f40f65..401c38f 100644
--- a/gcc/rtlanal.c
+++ b/gcc/rtlanal.c
@@ -1806,7 +1806,7 @@ reg_overlap_mentioned_p (const_rtx x, const_rtx in)
 {
   unsigned int regno, endregno;
 
-  /* If either argument is a constant, then modifying X can not
+  /* If either argument is a constant, then modifying X cannot
      affect IN.  Here we look at IN, we can profitably combine
      CONSTANT_P (x) with the switch statement below.  */
   if (CONSTANT_P (in))
diff --git a/gcc/sched-deps.c b/gcc/sched-deps.c
index e15cf08..a9e934d 100644
--- a/gcc/sched-deps.c
+++ b/gcc/sched-deps.c
@@ -2770,7 +2770,7 @@ sched_analyze_2 (struct deps_desc *deps, rtx x, rtx_insn *insn)
 	  reg_pending_barrier = TRUE_BARRIER;
 
 	/* For all ASM_OPERANDS, we must traverse the vector of input operands.
-	   We can not just fall through here since then we would be confused
+	   We cannot just fall through here since then we would be confused
 	   by the ASM_INPUT rtx inside ASM_OPERANDS, which do not indicate
 	   traditional asms unlike their normal usage.  */
 
@@ -4602,7 +4602,7 @@ check_dep (dep_t dep, bool relaxed_p)
 		&& (ds & DEP_CONTROL)
 		&& !(ds & (DEP_OUTPUT | DEP_ANTI | DEP_TRUE)));
 
-  /* HARD_DEP can not appear in dep_status of a link.  */
+  /* HARD_DEP cannot appear in dep_status of a link.  */
   gcc_assert (!(ds & HARD_DEP));
 
   /* Check that dependence status is set correctly when speculation is not
diff --git a/gcc/sched-ebb.c b/gcc/sched-ebb.c
index d459e09..4875eef 100644
--- a/gcc/sched-ebb.c
+++ b/gcc/sched-ebb.c
@@ -419,7 +419,7 @@ add_deps_for_risky_insns (rtx_insn *head, rtx_insn *tail)
 	    case PRISKY_CANDIDATE:
 	      /* ??? We could implement better checking PRISKY_CANDIDATEs
 		 analogous to sched-rgn.c.  */
-	      /* We can not change the mode of the backward
+	      /* We cannot change the mode of the backward
 		 dependency because REG_DEP_ANTI has the lowest
 		 rank.  */
 	      if (! sched_insns_conditions_mutex_p (insn, prev))
diff --git a/gcc/sched-rgn.c b/gcc/sched-rgn.c
index bc309fe..83688b3 100644
--- a/gcc/sched-rgn.c
+++ b/gcc/sched-rgn.c
@@ -927,7 +927,7 @@ haifa_find_rgns (void)
 	     The algorithm in the DFS traversal may not mark B & D as part
 	     of the loop (i.e. they will not have max_hdr set to A).
 
-	     We know they can not be loop latches (else they would have
+	     We know they cannot be loop latches (else they would have
 	     had max_hdr set since they'd have a backedge to a dominator
 	     block).  So we don't need them on the initial queue.
 
diff --git a/gcc/sel-sched-ir.c b/gcc/sel-sched-ir.c
index a3c6b19..e8e508e 100644
--- a/gcc/sel-sched-ir.c
+++ b/gcc/sel-sched-ir.c
@@ -3782,7 +3782,7 @@ maybe_tidy_empty_bb (basic_block bb)
 
           if (!(e->flags & EDGE_FALLTHRU))
             {
-	      /* We can not invalidate computed topological order by moving
+	      /* We cannot invalidate computed topological order by moving
 	         the edge destination block (E->SUCC) along a fallthru edge.
 
 		 We will update dominators here only when we'll get
diff --git a/gcc/sel-sched.c b/gcc/sel-sched.c
index 2bae6ef..bf4b2dd 100644
--- a/gcc/sel-sched.c
+++ b/gcc/sel-sched.c
@@ -3227,7 +3227,7 @@ get_spec_check_type_for_insn (insn_t insn, expr_t expr)
    ORIGINAL_INSNS list.
 
    REG_RENAME_P denotes the set of hardware registers that
-   can not be used with renaming due to the register class restrictions,
+   cannot be used with renaming due to the register class restrictions,
    mode restrictions and other (the register we'll choose should be
    compatible class with the original uses, shouldn't be in call_used_regs,
    should be HARD_REGNO_RENAME_OK etc).
@@ -5849,7 +5849,7 @@ maybe_emit_renaming_copy (rtx_insn *insn,
   bool insn_emitted  = false;
   rtx cur_reg;
 
-  /* Bail out early when expression can not be renamed at all.  */
+  /* Bail out early when expression cannot be renamed at all.  */
   if (!EXPR_SEPARABLE_P (params->c_expr))
     return false;
 
diff --git a/gcc/shrink-wrap.c b/gcc/shrink-wrap.c
index ab57101..e0f55ee 100644
--- a/gcc/shrink-wrap.c
+++ b/gcc/shrink-wrap.c
@@ -477,10 +477,10 @@ prepare_shrink_wrap (basic_block entry_block)
   dead_debug_local_finish (&debug, NULL);
 }
 
-/* Return whether basic block PRO can get the prologue.  It can not if it
+/* Return whether basic block PRO can get the prologue.  It cannot if it
    has incoming complex edges that need a prologue inserted (we make a new
    block for the prologue, so those edges would need to be redirected, which
-   does not work).  It also can not if there exist registers live on entry
+   does not work).  It also cannot if there exist registers live on entry
    to PRO that are clobbered by the prologue.  */
 
 static bool
diff --git a/gcc/simplify-rtx.c b/gcc/simplify-rtx.c
index 748155a..83580a2 100644
--- a/gcc/simplify-rtx.c
+++ b/gcc/simplify-rtx.c
@@ -6581,7 +6581,7 @@ simplify_subreg (machine_mode outermode, rtx op,
 
 	  /* Propagate original regno.  We don't have any way to specify
 	     the offset inside original regno, so do so only for lowpart.
-	     The information is used only by alias analysis that can not
+	     The information is used only by alias analysis that cannot
 	     grog partial register anyway.  */
 
 	  if (known_eq (subreg_lowpart_offset (outermode, innermode), byte))
diff --git a/gcc/symtab.c b/gcc/symtab.c
index d9c2b2d..c9fa16b 100644
--- a/gcc/symtab.c
+++ b/gcc/symtab.c
@@ -1761,7 +1761,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 cannot be overwriten 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.  */
 
@@ -1882,9 +1882,9 @@ symtab_node::get_partitioning_class (void)
     {
       if (alias && definition && !ultimate_alias_target ()->definition)
 	return SYMBOL_EXTERNAL;
-      /* Constant pool references use local symbol names that can not
+      /* Constant pool references use local symbol names that cannot
          be promoted global.  We should never put into a constant pool
-         objects that can not be duplicated across partitions.  */
+         objects that cannot be duplicated across partitions.  */
       if (DECL_IN_CONSTANT_POOL (decl))
 	return SYMBOL_DUPLICATE;
       if (DECL_HARD_REGISTER (decl))
@@ -1923,7 +1923,7 @@ symtab_node::nonzero_address ()
 
 	  if (target->alias && target->weakref)
 	    return false;
-	  /* We can not recurse to target::nonzero.  It is possible that the
+	  /* We cannot recurse to target::nonzero.  It is possible that the
 	     target is used only via the alias.
 	     We may walk references and look for strong use, but we do not know
 	     if this strong use will survive to final binary, so be
@@ -2016,7 +2016,7 @@ symtab_node::equal_address_to (symtab_node *s2, bool memory_accessed)
   bool really_binds_local1 = binds_local1;
   bool really_binds_local2 = binds_local2;
 
-  /* Addresses of vtables and virtual functions can not be used by user
+  /* Addresses of vtables and virtual functions cannot be used by user
      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
@@ -2042,7 +2042,7 @@ symtab_node::equal_address_to (symtab_node *s2, bool memory_accessed)
       return 1;
     }
 
-  /* If both symbols may resolve to NULL, we can not really prove them
+  /* If both symbols may resolve to NULL, we cannot really prove them
      different.  */
   if (!memory_accessed && !nonzero_address () && !s2->nonzero_address ())
     return -1;
@@ -2056,7 +2056,7 @@ symtab_node::equal_address_to (symtab_node *s2, bool memory_accessed)
     return -1;
 
   /* If we have a non-interposale definition of at least one of the symbols
-     and the other symbol is different, we know other unit can not interpose
+     and the other symbol is different, we know other unit cannot interpose
      it to the first symbol; all aliases of the definition needs to be 
      present in the current unit.  */
   if (((really_binds_local1 || really_binds_local2)
@@ -2147,7 +2147,7 @@ symtab_node::can_increase_alignment_p (void)
   if (TREE_ASM_WRITTEN (target->decl))
     return false;
 
-  /* If target is already placed in an anchor, we can not touch its
+  /* If target is already placed in an anchor, we cannot touch its
      alignment.  */
   if (DECL_RTL_SET_P (target->decl)
       && MEM_P (DECL_RTL (target->decl))
@@ -2342,7 +2342,7 @@ symtab_node::output_to_lto_symbol_table_p (void)
 
  /* Ignore all references from external vars initializers - they are not really
     part of the compilation unit until they are used by folding.  Some symbols,
-    like references to external construction vtables can not be referred to at
+    like references to external construction vtables cannot be referred to at
     all.  We decide this at can_refer_decl_in_current_unit_p.  */
  if (!definition || DECL_EXTERNAL (decl))
     {
diff --git a/gcc/target.def b/gcc/target.def
index e8f0f70..2aeb1ff 100644
--- a/gcc/target.def
+++ b/gcc/target.def
@@ -2911,7 +2911,7 @@ or @code{NULL} if this is an indirect call.\n\
 It is not uncommon for limitations of calling conventions to prevent\n\
 tail calls to functions outside the current unit of translation, or\n\
 during PIC compilation.  The hook is used to enforce these restrictions,\n\
-as the @code{sibcall} md pattern can not fail, or fall over to a\n\
+as the @code{sibcall} md pattern cannot fail, or fall over to a\n\
 ``normal'' call.  The criteria for successful sibling call optimization\n\
 may vary greatly between different architectures.",
  bool, (tree decl, tree exp),
diff --git a/gcc/toplev.c b/gcc/toplev.c
index 9eb4de5..0acfaae 100644
--- a/gcc/toplev.c
+++ b/gcc/toplev.c
@@ -604,7 +604,7 @@ compile_file (void)
   invoke_plugin_callbacks (PLUGIN_FINISH_UNIT, NULL);
 
   /* This must be at the end.  Some target ports emit end of file directives
-     into the assembly file here, and hence we can not output anything to the
+     into the assembly file here, and hence we cannot output anything to the
      assembly file after this point.  */
   targetm.asm_out.file_end ();
 
@@ -1730,7 +1730,7 @@ process_options (void)
       flag_stack_clash_protection = 0;
     }
 
-  /* We can not support -fstack-check= and -fstack-clash-protection at
+  /* We cannot support -fstack-check= and -fstack-clash-protection at
      the same time.  */
   if (flag_stack_check != NO_STACK_CHECK && flag_stack_clash_protection)
     {
diff --git a/gcc/tree-call-cdce.c b/gcc/tree-call-cdce.c
index 268d26c..2b1e934 100644
--- a/gcc/tree-call-cdce.c
+++ b/gcc/tree-call-cdce.c
@@ -172,7 +172,7 @@ check_target_format (tree arg)
       || (mode == DFmode
 	  && (rfmt == &ieee_double_format || rfmt == &mips_double_format
 	      || rfmt == &motorola_double_format))
-      /* For long double, we can not really check XFmode
+      /* For long double, we cannot really check XFmode
          which is only defined on intel platforms.
          Candidate pre-selection using builtin function
          code guarantees that we are checking formats
diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c
index 225422b..6041f42 100644
--- a/gcc/tree-cfg.c
+++ b/gcc/tree-cfg.c
@@ -2136,7 +2136,7 @@ gimple_merge_blocks (basic_block a, basic_block b)
 	     a situation where we have a forced label in block B
 	     However, the label at the start of block B might still be
 	     used in other ways (think about the runtime checking for
-	     Fortran assigned gotos).  So we can not just delete the
+	     Fortran assigned gotos).  So we cannot just delete the
 	     label.  Instead we move the label to the start of block A.  */
 	  if (FORCED_LABEL (label))
 	    {
@@ -2359,7 +2359,7 @@ find_taken_edge (basic_block bb, tree val)
   if (computed_goto_p (stmt))
     {
       /* Only optimize if the argument is a label, if the argument is
-	 not a label then we can not construct a proper CFG.
+	 not a label then we cannot construct a proper CFG.
 
          It may be the case that we only need to allow the LABEL_REF to
          appear inside an ADDR_EXPR, but we also allow the LABEL_REF to
diff --git a/gcc/tree-complex.c b/gcc/tree-complex.c
index a76eab6..d4b053d 100644
--- a/gcc/tree-complex.c
+++ b/gcc/tree-complex.c
@@ -1682,7 +1682,7 @@ expand_complex_operations_1 (gimple_stmt_iterator *gsi)
       ac = gimple_assign_rhs1 (stmt);
       bc = (gimple_num_ops (stmt) > 2) ? gimple_assign_rhs2 (stmt) : NULL;
     }
-  /* GIMPLE_CALL can not get here.  */
+  /* GIMPLE_CALL cannot get here.  */
   else
     {
       ac = gimple_cond_lhs (stmt);
diff --git a/gcc/tree-core.h b/gcc/tree-core.h
index ecf7325..4541c95 100644
--- a/gcc/tree-core.h
+++ b/gcc/tree-core.h
@@ -156,7 +156,7 @@ enum built_in_class {
   BUILT_IN_NORMAL
 };
 
-/* Last marker used for LTO stremaing of built_in_class.  We can not add it
+/* Last marker used for LTO stremaing of built_in_class.  We cannot add it
    to the enum since we need the enumb to fit in 2 bits.  */
 #define BUILT_IN_LAST (BUILT_IN_NORMAL + 1)
 
diff --git a/gcc/tree-eh.c b/gcc/tree-eh.c
index 895e259..c806348 100644
--- a/gcc/tree-eh.c
+++ b/gcc/tree-eh.c
@@ -4763,7 +4763,7 @@ verify_eh_edges (gimple *stmt)
     {
       if (eh_edge)
 	{
-	  error ("BB %i can not throw but has an EH edge", bb->index);
+	  error ("BB %i cannot throw but has an EH edge", bb->index);
 	  return true;
 	}
       return false;
diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c
index c835fca..75d1df1 100644
--- a/gcc/tree-inline.c
+++ b/gcc/tree-inline.c
@@ -615,7 +615,7 @@ remap_type (tree type, copy_body_data *id)
 static bool
 can_be_nonlocal (tree decl, copy_body_data *id)
 {
-  /* We can not duplicate function decls.  */
+  /* We cannot duplicate function decls.  */
   if (TREE_CODE (decl) == FUNCTION_DECL)
     return true;
 
@@ -2778,7 +2778,7 @@ copy_cfg_body (copy_body_data * id,
 	    && bb->index != ENTRY_BLOCK
 	    && bb->index != EXIT_BLOCK)
 	  maybe_move_debug_stmts_to_successors (id, (basic_block) bb->aux);
-	/* Update call edge destinations.  This can not be done before loop
+	/* Update call edge destinations.  This cannot be done before loop
 	   info is updated, because we may split basic blocks.  */
 	if (id->transform_call_graph_edges == CB_CGE_DUPLICATE
 	    && bb->index != ENTRY_BLOCK
@@ -2796,7 +2796,7 @@ copy_cfg_body (copy_body_data * id,
 	maybe_move_debug_stmts_to_successors (id,
 					      BASIC_BLOCK_FOR_FN (cfun, last));
       BASIC_BLOCK_FOR_FN (cfun, last)->aux = NULL;
-      /* Update call edge destinations.  This can not be done before loop
+      /* Update call edge destinations.  This cannot be done before loop
 	 info is updated, because we may split basic blocks.  */
       if (id->transform_call_graph_edges == CB_CGE_DUPLICATE)
 	redirect_all_calls (id, BASIC_BLOCK_FOR_FN (cfun, last));
@@ -3527,7 +3527,7 @@ copy_forbidden (struct function *fun)
 static const char *inline_forbidden_reason;
 
 /* A callback for walk_gimple_seq to handle statements.  Returns non-null
-   iff a function can not be inlined.  Also sets the reason why. */
+   iff a function cannot be inlined.  Also sets the reason why. */
 
 static tree
 inline_forbidden_p_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
diff --git a/gcc/tree-loop-distribution.c b/gcc/tree-loop-distribution.c
index e12a56f..7df052d 100644
--- a/gcc/tree-loop-distribution.c
+++ b/gcc/tree-loop-distribution.c
@@ -1896,7 +1896,7 @@ pg_add_dependence_edges (struct graph *rdg, int dir,
 	      /* Be conservative.  If data references are not well analyzed,
 		 or the two data references have the same base address and
 		 offset, add dependence and consider it alias to each other.
-		 In other words, the dependence can not be resolved by
+		 In other words, the dependence cannot be resolved by
 		 runtime alias check.  */
 	      if (!DR_BASE_ADDRESS (dr1) || !DR_BASE_ADDRESS (dr2)
 		  || !DR_OFFSET (dr1) || !DR_OFFSET (dr2)
@@ -2109,7 +2109,7 @@ build_partition_graph (struct graph *rdg,
 
 	  /* Add edge to partition graph if there exists dependence.  There
 	     are two types of edges.  One type edge is caused by compilation
-	     time known dependence, this type can not be resolved by runtime
+	     time known dependence, this type cannot be resolved by runtime
 	     alias check.  The other type can be resolved by runtime alias
 	     check.  */
 	  if (dir == 1 || dir == 2
diff --git a/gcc/tree-nrv.c b/gcc/tree-nrv.c
index dc2aef3..9f97692 100644
--- a/gcc/tree-nrv.c
+++ b/gcc/tree-nrv.c
@@ -193,7 +193,7 @@ pass_nrv::execute (function *fun)
 	      if (found != NULL)
 		{
 		  /* If we found a return statement using a different variable
-		     than previous return statements, then we can not perform
+		     than previous return statements, then we cannot perform
 		     NRV optimizations.  */
 		  if (found != rhs)
 		    return 0;
diff --git a/gcc/tree-profile.c b/gcc/tree-profile.c
index 30fadde..5860e7c 100644
--- a/gcc/tree-profile.c
+++ b/gcc/tree-profile.c
@@ -763,7 +763,7 @@ tree_profiling (void)
 
       if (node->thunk.thunk_p)
 	{
-	  /* We can not expand variadic thunks to Gimple.  */
+	  /* We cannot expand variadic thunks to Gimple.  */
 	  if (stdarg_p (TREE_TYPE (node->decl)))
 	    continue;
 	  thunk = true;
diff --git a/gcc/tree-sra.c b/gcc/tree-sra.c
index 24bc135..e4851da 100644
--- a/gcc/tree-sra.c
+++ b/gcc/tree-sra.c
@@ -5430,7 +5430,7 @@ ipa_sra_preliminary_function_checks (struct cgraph_node *node)
   if (!node->local.can_change_signature)
     {
       if (dump_file)
-	fprintf (dump_file, "Function can not change signature.\n");
+	fprintf (dump_file, "Function cannot change signature.\n");
       return false;
     }
 
diff --git a/gcc/tree-ssa-alias.c b/gcc/tree-ssa-alias.c
index 27676f4..10b4d3f 100644
--- a/gcc/tree-ssa-alias.c
+++ b/gcc/tree-ssa-alias.c
@@ -202,7 +202,7 @@ ptr_deref_may_alias_decl_p (tree ptr, tree decl)
 	return true;
     }
 
-  /* Non-aliased variables can not be pointed to.  */
+  /* Non-aliased variables cannot be pointed to.  */
   if (!may_be_aliased (decl))
     return false;
 
diff --git a/gcc/tree-ssa-dce.c b/gcc/tree-ssa-dce.c
index e176685..7dd8d58 100644
--- a/gcc/tree-ssa-dce.c
+++ b/gcc/tree-ssa-dce.c
@@ -420,7 +420,7 @@ find_obviously_necessary_stmts (bool aggressive)
 	if (!finite_loop_p (loop))
 	  {
 	    if (dump_file)
-	      fprintf (dump_file, "can not prove finiteness of loop %i\n", loop->num);
+	      fprintf (dump_file, "cannot prove finiteness of loop %i\n", loop->num);
 	    mark_control_dependent_edges_necessary (loop->latch, false);
 	  }
     }
diff --git a/gcc/tree-ssa-dom.c b/gcc/tree-ssa-dom.c
index 534c722..458f711 100644
--- a/gcc/tree-ssa-dom.c
+++ b/gcc/tree-ssa-dom.c
@@ -1136,7 +1136,7 @@ record_equivalences_from_phis (basic_block bb)
 	  t = dom_valueize (t);
 
 	  /* If T is an SSA_NAME and its associated edge is a backedge,
-	     then quit as we can not utilize this equivalence.  */
+	     then quit as we cannot utilize this equivalence.  */
 	  if (TREE_CODE (t) == SSA_NAME
 	      && (gimple_phi_arg_edge (phi, i)->flags & EDGE_DFS_BACK))
 	    break;
@@ -1376,7 +1376,7 @@ cprop_into_successor_phis (basic_block bb,
 	continue;
 
       /* We may have an equivalence associated with this edge.  While
-	 we can not propagate it into non-dominated blocks, we can
+	 we cannot propagate it into non-dominated blocks, we can
 	 propagate them into PHIs in non-dominated blocks.  */
 
       /* Push the unwind marker so we can reset the const and copies
@@ -1521,7 +1521,7 @@ eliminate_redundant_computations (gimple_stmt_iterator* gsi,
   else
     def = gimple_get_lhs (stmt);
 
-  /* Certain expressions on the RHS can be optimized away, but can not
+  /* Certain expressions on the RHS can be optimized away, but cannot
      themselves be entered into the hash tables.  */
   if (! def
       || TREE_CODE (def) != SSA_NAME
diff --git a/gcc/tree-ssa-forwprop.c b/gcc/tree-ssa-forwprop.c
index f3779e9..eeb6281 100644
--- a/gcc/tree-ssa-forwprop.c
+++ b/gcc/tree-ssa-forwprop.c
@@ -280,7 +280,7 @@ can_propagate_from (gimple *def_stmt)
     return false;
 
   /* If the definition is a conversion of a pointer to a function type,
-     then we can not apply optimizations as some targets require
+     then we cannot apply optimizations as some targets require
      function pointers to be canonicalized and in this case this
      optimization could eliminate a necessary canonicalization.  */
   if (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt)))
diff --git a/gcc/tree-ssa-loop-im.c b/gcc/tree-ssa-loop-im.c
index 0919931..d8a8440 100644
--- a/gcc/tree-ssa-loop-im.c
+++ b/gcc/tree-ssa-loop-im.c
@@ -1855,7 +1855,7 @@ execute_sm_if_changed (edge ex, tree mem, tree tmp_var, tree flag,
   /* Flag is set in FLAG_BBS. Determine probability that flag will be true
      at loop exit.
 
-     This code may look fancy, but it can not update profile very realistically
+     This code may look fancy, but it cannot update profile very realistically
      because we do not know the probability that flag will be true at given
      loop exit.
 
diff --git a/gcc/tree-ssa-loop-ivcanon.c b/gcc/tree-ssa-loop-ivcanon.c
index 91b9725..eb0c1c9 100644
--- a/gcc/tree-ssa-loop-ivcanon.c
+++ b/gcc/tree-ssa-loop-ivcanon.c
@@ -718,7 +718,7 @@ try_unroll_loop_completely (struct loop *loop,
       if (edge_to_cancel == exit)
 	edge_to_cancel = EDGE_SUCC (exit->src, 1);
     }
-  /* We do not know the number of iterations and thus we can not eliminate
+  /* We do not know the number of iterations and thus we cannot eliminate
      the EXIT edge.  */
   else
     exit = NULL;
@@ -730,7 +730,7 @@ try_unroll_loop_completely (struct loop *loop,
     {
       n_unroll = maxiter;
       n_unroll_found = true;
-      /* Loop terminates before the IV variable test, so we can not
+      /* Loop terminates before the IV variable test, so we cannot
 	 remove it in the last iteration.  */
       edge_to_cancel = NULL;
     }
@@ -1443,7 +1443,7 @@ tree_unroll_loops_completely (bool may_increase_size, bool unroll_outer)
 
           unloop_loops (loop_closed_ssa_invalidated, &irred_invalidated);
 
-	  /* We can not use TODO_update_ssa_no_phi because VOPS gets confused.  */
+	  /* We cannot use TODO_update_ssa_no_phi because VOPS gets confused.  */
 	  if (loop_closed_ssa_invalidated
 	      && !bitmap_empty_p (loop_closed_ssa_invalidated))
             rewrite_into_loop_closed_ssa (loop_closed_ssa_invalidated,
diff --git a/gcc/tree-ssa-loop-ivopts.c b/gcc/tree-ssa-loop-ivopts.c
index 89713e1..af0c981 100644
--- a/gcc/tree-ssa-loop-ivopts.c
+++ b/gcc/tree-ssa-loop-ivopts.c
@@ -1438,7 +1438,7 @@ find_givs_in_stmt_scev (struct ivopts_data *data, gimple *stmt, affine_iv *iv)
     return false;
 
   /* If STMT could throw, then do not consider STMT as defining a GIV.
-     While this will suppress optimizations, we can not safely delete this
+     While this will suppress optimizations, we cannot safely delete this
      GIV and associated statements, even if it appears it is not used.  */
   if (stmt_could_throw_p (cfun, stmt))
     return false;
diff --git a/gcc/tree-ssa-loop-niter.c b/gcc/tree-ssa-loop-niter.c
index 587e943..622d18a 100644
--- a/gcc/tree-ssa-loop-niter.c
+++ b/gcc/tree-ssa-loop-niter.c
@@ -4505,7 +4505,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.  */
+	     cannot be terinated 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-phionlycprop.c b/gcc/tree-ssa-phionlycprop.c
index a81fbf4..f367800 100644
--- a/gcc/tree-ssa-phionlycprop.c
+++ b/gcc/tree-ssa-phionlycprop.c
@@ -497,7 +497,7 @@ pass_phi_only_cprop::execute (function *fun)
 {
   bool cfg_altered = false;
 
-  /* Bitmap of blocks which need EH information updated.  We can not
+  /* Bitmap of blocks which need EH information updated.  We cannot
      update it on-the-fly as doing so invalidates the dominator tree.  */
   auto_bitmap need_eh_cleanup;
 
diff --git a/gcc/tree-ssa-phiopt.c b/gcc/tree-ssa-phiopt.c
index 025e403..219791e 100644
--- a/gcc/tree-ssa-phiopt.c
+++ b/gcc/tree-ssa-phiopt.c
@@ -1852,14 +1852,14 @@ abs_replacement (basic_block cond_bb, basic_block middle_bb,
      form arg0 = -arg1 or arg1 = -arg0.  */
 
   assign = last_and_only_stmt (middle_bb);
-  /* If we did not find the proper negation assignment, then we can not
+  /* If we did not find the proper negation assignment, then we cannot
      optimize.  */
   if (assign == NULL)
     return false;
 
   /* If we got here, then we have found the only executable statement
      in OTHER_BLOCK.  If it is anything other than arg = -arg1 or
-     arg1 = -arg0, then we can not optimize.  */
+     arg1 = -arg0, then we cannot optimize.  */
   if (gimple_code (assign) != GIMPLE_ASSIGN)
     return false;
 
diff --git a/gcc/tree-ssa-propagate.c b/gcc/tree-ssa-propagate.c
index a631b63..6b78dc1 100644
--- a/gcc/tree-ssa-propagate.c
+++ b/gcc/tree-ssa-propagate.c
@@ -339,7 +339,7 @@ ssa_propagation_engine::simulate_block (basic_block block)
       /* Note that we have simulated this block.  */
       block->flags |= BB_VISITED;
 
-      /* We can not predict when abnormal and EH edges will be executed, so
+      /* We cannot predict when abnormal and EH edges will be executed, so
 	 once a block is considered executable, we consider any
 	 outgoing abnormal edges as executable.
 
diff --git a/gcc/tree-ssa-threadedge.c b/gcc/tree-ssa-threadedge.c
index f7aae52..c3ea2d6 100644
--- a/gcc/tree-ssa-threadedge.c
+++ b/gcc/tree-ssa-threadedge.c
@@ -140,7 +140,7 @@ record_temporary_equivalences_from_phis (edge e,
       tree dst = gimple_phi_result (phi);
 
       /* If the desired argument is not the same as this PHI's result
-	 and it is set by a PHI in E->dest, then we can not thread
+	 and it is set by a PHI in E->dest, then we cannot thread
 	 through E->dest.  */
       if (src != dst
 	  && TREE_CODE (src) == SSA_NAME
@@ -253,13 +253,13 @@ record_temporary_equivalences_from_stmts_at_dest (edge e,
 	continue;
 
       /* If the statement has volatile operands, then we assume we
-	 can not thread through this block.  This is overly
+	 cannot thread through this block.  This is overly
 	 conservative in some ways.  */
       if (gimple_code (stmt) == GIMPLE_ASM
 	  && gimple_asm_volatile_p (as_a <gasm *> (stmt)))
 	return NULL;
 
-      /* If the statement is a unique builtin, we can not thread
+      /* If the statement is a unique builtin, we cannot thread
 	 through here.  */
       if (gimple_code (stmt) == GIMPLE_CALL
 	  && gimple_call_internal_p (stmt)
@@ -906,7 +906,7 @@ thread_around_empty_blocks (edge taken_edge,
   tree cond;
 
   /* The key property of these blocks is that they need not be duplicated
-     when threading.  Thus they can not have visible side effects such
+     when threading.  Thus they cannot have visible side effects such
      as PHI nodes.  */
   if (!gsi_end_p (gsi_start_phis (bb)))
     return false;
diff --git a/gcc/tree-ssa-threadupdate.c b/gcc/tree-ssa-threadupdate.c
index fb04506..bccef87 100644
--- a/gcc/tree-ssa-threadupdate.c
+++ b/gcc/tree-ssa-threadupdate.c
@@ -2550,7 +2550,7 @@ thread_through_all_blocks (bool may_peel_loop_headers)
      Consider if we have two jump threading paths A and B.  If the
      target edge of A is the starting edge of B and we thread path A
      first, then we create an additional incoming edge into B->dest that
-     we can not discover as a jump threading path on this iteration.
+     we cannot discover as a jump threading path on this iteration.
 
      If we instead thread B first, then the edge into B->dest will have
      already been redirected before we process path A and path A will
diff --git a/gcc/tree-ssa-uninit.c b/gcc/tree-ssa-uninit.c
index dad1977..32cf730 100644
--- a/gcc/tree-ssa-uninit.c
+++ b/gcc/tree-ssa-uninit.c
@@ -1464,7 +1464,7 @@ pred_expr_equal_p (pred_info x1, tree x2)
 
 /* Returns true of the domain of single predicate expression
    EXPR1 is a subset of that of EXPR2.  Returns false if it
-   can not be proved.  */
+   cannot be proved.  */
 
 static bool
 is_pred_expr_subset_of (pred_info expr1, pred_info expr2)
@@ -1502,7 +1502,7 @@ is_pred_expr_subset_of (pred_info expr1, pred_info expr2)
 }
 
 /* Returns true if the domain of PRED1 is a subset
-   of that of PRED2.  Returns false if it can not be proved so.  */
+   of that of PRED2.  Returns false if it cannot be proved so.  */
 
 static bool
 is_pred_chain_subset_of (pred_chain pred1, pred_chain pred2)
@@ -2404,7 +2404,7 @@ uninit_uses_cannot_happen (gphi *phi, unsigned uninit_opnds,
    USE_STMT is guarded with a predicate set not overlapping with
    predicate sets of all runtime paths that do not have a definition.
 
-   Returns false if it is not or it can not be determined.  USE_BB is
+   Returns false if it is not or it cannot be determined.  USE_BB is
    the bb of the use (for phi operand use, the bb is not the bb of
    the phi stmt, but the src bb of the operand edge).
 
@@ -2735,7 +2735,7 @@ execute_early_warn_uninitialized (void)
 
   warn_uninitialized_vars (/*warn_possibly_uninitialized=*/!optimize);
 
-  /* Post-dominator information can not be reliably updated.  Free it
+  /* Post-dominator information cannot be reliably updated.  Free it
      after the use.  */
 
   free_dominance_info (CDI_POST_DOMINATORS);
diff --git a/gcc/tree-ssanames.c b/gcc/tree-ssanames.c
index 247ee61..51f52bb 100644
--- a/gcc/tree-ssanames.c
+++ b/gcc/tree-ssanames.c
@@ -591,7 +591,7 @@ release_ssa_name_fn (struct function *fn, tree var)
      keep a status bit in the SSA_NAME node itself to indicate it has
      been put on the free list.
 
-     Note that once on the freelist you can not reference the SSA_NAME's
+     Note that once on the freelist you cannot reference the SSA_NAME's
      defining statement.  */
   if (! SSA_NAME_IN_FREE_LIST (var))
     {
diff --git a/gcc/tree-streamer-out.c b/gcc/tree-streamer-out.c
index b39f576..ce7e808 100644
--- a/gcc/tree-streamer-out.c
+++ b/gcc/tree-streamer-out.c
@@ -694,7 +694,7 @@ write_ts_type_common_tree_pointers (struct output_block *ob, tree expr,
   /* TYPE_CANONICAL is re-computed during type merging, so no need
      to stream it here.  */
   /* Do not stream TYPE_STUB_DECL; it is not needed by LTO but currently
-     it can not be freed by free_lang_data without triggering ICEs in
+     it cannot be freed by free_lang_data without triggering ICEs in
      langhooks.  */
 }
 
diff --git a/gcc/tree.c b/gcc/tree.c
index 132df55..2e112ee 100644
--- a/gcc/tree.c
+++ b/gcc/tree.c
@@ -5658,7 +5658,7 @@ free_lang_data_in_decl (tree decl, struct free_lang_data_d *fld)
 	 use for middle-end.
 
 	 It would make more sense if frontends set TREE_ADDRESSABLE to 0 only
-	 for public objects that indeed can not be adressed, but it is not
+	 for public objects that indeed cannot be adressed, but it is not
 	 the case.  Set the flag to true so we do not get merge failures for
 	 i.e. virtual tables between units that take address of it and
 	 units that don't.  */
@@ -14239,7 +14239,7 @@ verify_type (const_tree t)
       debug_tree (ct);
       error_found = true;
     }
-  /* Method and function types can not be used to address memory and thus
+  /* Method and function types cannot be used to address memory and thus
      TYPE_CANONICAL really matters only for determining useless conversions.
 
      FIXME: C++ FE produce declarations of builtin functions that are not
@@ -14247,7 +14247,7 @@ verify_type (const_tree t)
   else if (TREE_CODE (t) == FUNCTION_TYPE)
     ;
   else if (t != ct
-	   /* FIXME: gimple_canonical_types_compatible_p can not compare types
+	   /* FIXME: gimple_canonical_types_compatible_p cannot compare types
 	      with variably sized arrays because their sizes possibly
 	      gimplified to different variables.  */
 	   && !variably_modified_type_p (ct, NULL)
diff --git a/gcc/tree.h b/gcc/tree.h
index b2512bb..39b2ca5 100644
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -5867,7 +5867,7 @@ type_with_alias_set_p (const_tree t)
   if (COMPLETE_TYPE_P (t))
     return true;
 
-  /* Incomplete types can not be accessed in general except for arrays
+  /* Incomplete types cannot be accessed in general except for arrays
      where we can fetch its element despite we have no array bounds.  */
   if (TREE_CODE (t) == ARRAY_TYPE && COMPLETE_TYPE_P (TREE_TYPE (t)))
     return true;
diff --git a/gcc/vr-values.c b/gcc/vr-values.c
index 53c6300..f4058ea 100644
--- a/gcc/vr-values.c
+++ b/gcc/vr-values.c
@@ -2390,7 +2390,7 @@ vr_values::vrp_evaluate_conditional_warnv_with_ops (enum tree_code code,
 }
 
 /* Given (CODE OP0 OP1) within STMT, try to simplify it based on value range
-   information.  Return NULL if the conditional can not be evaluated.
+   information.  Return NULL if the conditional cannot be evaluated.
    The ranges of all the names equivalent with the operands in COND
    will be used when trying to compute the value.  If the result is
    based on undefined signed overflow, issue a warning if