diff options
| author | Sandra Loosemore <sandra@codesourcery.com> | 2019-01-09 16:37:45 -0500 |
|---|---|---|
| committer | Sandra Loosemore <sandra@gcc.gnu.org> | 2019-01-09 16:37:45 -0500 |
| commit | 67914693144c02e0be2e6356d9162e775fb4971d (patch) | |
| tree | 63ea86de007194fa30edb25c79acb6a6136e5cab /gcc | |
| parent | ee0b3cea205eb7e832d7262425ddee8ed34778e5 (diff) | |
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
Diffstat (limited to 'gcc')
188 files changed, 624 insertions, 408 deletions
diff --git a/gcc/ChangeLog b/gcc/ChangeLog index c8fdce94c69..749b9bcd310 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 dc0eba7bc9a..2fa9083d1b3 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 7995c202ee1..402ad9288b1 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 78bdb4027ad..5ec9fb486e5 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 0a2d2b01a66..74ecdec96a4 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 410053036d5..9de9a606c6f 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 910d1e91247..ae4a8c6195c 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 318e29efd05..12974515af2 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 93f53543d12..b64e3ea264d 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 28155b8c0aa..6135bc5a4e2 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 2e5d411f217..e11977e98df 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 cac4af34595..c9788d0286a 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 920169c411d..c016da3875c 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 10ae2a98f75..4688de91cfe 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 c39a24d0b27..1cf9ac53a28 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 dabfa9e0e32..3638a1b10ee 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 a8c9d15f273..e226c7dd353 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 b87e0b66167..a5dac6d7303 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 0b0bc854db7..1c300af19bc 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 2c0663db561..c416ad4b43e 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 9a8f1597810..de2c8d5df9c 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 f003a0ff333..72fbf2a8528 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 89119c3b894..ab4a0ab9a2e 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 3419b6bd0f8..839238057ce 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 7acbce7653a..5cebabeaea7 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 93c7897239a..aa759624f8f 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 0829b9c4e75..1aac8317dd4 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 dd361a93957..8a3c9094a99 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 76d13c40934..ea95290eae2 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 9a4d4967b12..69a9eea8a25 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 240118a4544..be9ea9ab5aa 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 628ec80123e..0e23eaaa79c 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 6555ea7d9f9..09e401cca20 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 c56661418a8..bd389ea7284 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 3f84bf0d3b5..5830c8514c2 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 bb432aefe69..183afff3725 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 65d601b1a08..d2fbce0c968 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 2c1c0681d40..9e3cbe399f3 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 1051a2ce413..b4f4edee9d1 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 14b2f2aff23..79ae8ea2a34 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 868538ba3da..5042683e388 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 669c18545fc..6fee4d9c8c2 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 548032f5675..0357dc88e59 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 ee03c8aca42..3ea7c3801f5 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 35fae653add..fcb7cffc2cf 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 e28c45f7a03..83543778619 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 fbbf7ca8a90..75ab5949bf0 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 3167b49b6e0..b3ee2a5db2f 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 44739049b8d..56489465c0c 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 f441943dc8e..be669f2f321 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 e216ef50378..84f59a2c356 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 cd0e29a5b06..65c0130cc07 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 bd74d0a93d9..81577dfe5cd 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 eeccf650ae5..644d01e0b87 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 21c3ea5b3a3..ee1a1c62d58 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 7f33be4f29c..f0130571d58 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 bf93abee5d1..299adef4a7b 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 7d4d2127d63..4f3cd4f9ed7 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 56649bfd45a..abfb1d19ed1 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 d19dc09425a..771e8278e50 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 42b0296d3cf..18b8af0d956 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 634c773b95a..29039eaeb5a 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 58329101853..f5f2de75683 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 edc090253af..ddde4a7287b 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 0407308e28f..389c52d4284 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 187d6120cea..4b0aa7cee06 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 bc28d48d1db..edf66b57419 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 8ce6bc59c73..10fef2f3544 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 b207a34defc..b7f55a7e73b 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 818ee2deaa1..6ccba9d53ad 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 0fdb9149bce..640a6ece44e 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 14e402cd57a..8e81904ed86 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 8809b5b5b6e..6c6139b96f5 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 29a57d3268d..460c45db5dd 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 cd8d4dd26eb..bc318f757aa 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 e8e05f04f32..d65d5deded3 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 e47ee1ecc4f..941c2e39374 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 7b5597e4536..668e8d9bc72 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 ade7059e9b6..4ea37a331ca 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 4c0bda99af9..9ff1c35b2a0 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 6b33c57e873..5dcd91af6cf 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 19f97d1cb19..fa764dcdab1 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 beafe8da8bc..a681ecaf249 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 cd52c73031b..06c21d969f2 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 738022a6b1f..e71e76ee9cf 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 c92d8913334..474ad0bf930 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 b997ae53fc2..64d52588d6e 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 62cca292e0f..6b785a6db4e 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 a9928352f78..d408eed77b5 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 529149acda3..2d25f9eec5f 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 3713881b5f2..64e20cd128a 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 13753232ab7..9422b0d2b8a 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 84432564ac2..afdc7f8c5b2 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 9f41b44e725..a72819662fb 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 77feb4528ce..7b2f6e6bd75 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 4980fd93cec..69cc3f3b907 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 247aba7045a..3489ed59ce2 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 9c54edd5c88..bba73b2d1e2 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 6bc9cb3c57f..dbb95b08971 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 ebaf5825e1e..056be1139db 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 0910a9cbcc1..4a3a193bc9c 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 8e344001105..2c1843aa816 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 44808cfbe68..7d8c5ab9baf 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 4e57b88d131..de9563d808c 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 d5d9ca9dee2..6830f8d7f3f 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 ba0c7c2d83e..d2dcf7c2d43 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 95f91b7609c..8ad12d30bb2 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 eeef7bb26dc..cfd03abb07d 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 ebcccefc00a..5752e5c5085 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 3505899cbf3..26268bc0c7c 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 2f87c8125fd..83caa3a8ed8 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 565f7a0c372..aa91b56c81f 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 b57468bcabe..7ec709db830 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 e5d880417d6..0ca70a0053a 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 181fba5d943..3c7fe4e6450 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 c9e422a797b..af5b8217688 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 4b9c11d3b3a..ccdc2aba181 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 0e7232ab019..8e1d039ee28 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 715be59955f..3e82f1e10d5 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 6a9436bc6e4..cbc66736c04 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 fcc0aa207b9..4f68a7381b7 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 e59f499f5f1..13128045246 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 7ffcd353368..e3b5ddb5226 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 e7d4830eccb..ee9fd51f129 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 7b60691d19e..a00ec389bf9 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 61efc376452..8dde7d20904 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 29c362029c3..c19b76a579c 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 75ee74280a4..592b9908597 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 a6af812f514..b941c76a878 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 209ce86c42a..b26c883b732 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 3c18f30274e..6b183df3b0f 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 988e89b8fa3..6972e6e9ef3 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 83b0edf6e28..22da4c78b8c 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 a95ef317109..bb332f8221c 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 50536b7d961..aa81466fdcb 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 cc5f70a1aa2..777225e9154 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 cc9e657848a..a165351ca96 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 0ac8adf286f..43ee91a5b13 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 96b74003408..06564ddf4bd 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 7374b0d6883..a1dba1ac8fb 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 6fedf777bfb..d0c498fced2 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 e49514ba63b..e23e607a5e1 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 6cfd5e2f234..3ad11a81ec5 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 b703402d0db..9e4429f36cb 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 1f26ffbf943..d2b565438e7 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 5e1ed44b060..f8a23ed9f58 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 6c8ff301020..f4c9d946cb5 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 71a2ba4f029..70891e6e364 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 5f40f65dbc6..401c38fe0e2 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 e15cf08b551..a9e934d7fa0 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 d459e091167..4875eef96a8 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 bc309fec7df..83688b3c9c4 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 a3c6b1962ec..e8e508ef692 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 2bae6ef2349..bf4b2ddca18 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 ab5710144e6..e0f55ee5e2e 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 748155a5823..83580a259f3 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 d9c2b2d1234..c9fa16b353b 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 e8f0f703d4e..2aeb1ff8445 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 9eb4de5d0fc..0acfaaed3f7 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 268d26cab07..2b1e9340bce 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 225422b0fff..6041f4208b0 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 a76eab68e15..d4b053d68e1 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 ecf732521ab..4541c955403 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 895e25953a8..c8063486f2d 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 c835fca5342..75d1df12e1d 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 e12a56f7671..7df052de0cf 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 dc2aef37f7d..9f976922d54 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 30fadde86cf..5860e7c3f19 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 24bc135fa8e..e4851daaa3f 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 27676f4193a..10b4d3f2514 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 e17668580ec..7dd8d58539e 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 534c7222907..458f7112bbe 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 f3779e9a83d..eeb6281c652 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 0919931cec3..d8a84402d4b 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 91b9725f422..eb0c1c94b92 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 89713e13fca..af0c9816bf7 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 587e94347cd..622d18abacb 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 a81fbf4eb31..f367800da41 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 025e4037596..219791ea4ba 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 a631b637c64..6b78dc1c06c 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 f7aae524bb9..c3ea2d680d8 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 fb045063337..bccef879db0 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 dad19776efc..32cf730f4ee 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 247ee619aa8..51f52bb5bd3 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 b39f576e453..ce7e8086b39 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 132df552c68..2e112ee17c6 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 b2512bbb42c..39b2ca51f76 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 53c6300e540..f4058ea1fe9 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 |