+2017-03-21 Martin Sebor <msebor@redhat.com>
+
+ * doc/extend.texi: Use "cannot" instead of "can't."
+ * doc/hostconfig.texi: Same.
+ * doc/install.texi: Same.
+ * doc/invoke.texi: Same.
+ * doc/loop.texi: Same.
+ * doc/md.texi: Same.
+ * doc/objc.texi: Same.
+ * doc/rtl.texi: Same.
+ * doc/tm.texi: Same.
+ * doc/tm.texi.in: Same.
+ * doc/trouble.texi: Same.
+
2017-03-21 Alexandre Oliva <aoliva@redhat.com>
PR debug/63238
function, unless you specify the option @option{-fkeep-inline-functions}.
If there is a nonintegrated call, then the function is compiled to
assembler code as usual. The function must also be compiled as usual if
-the program refers to its address, because that can't be inlined.
+the program refers to its address, because that cannot be inlined.
@opindex Winline
Note that certain usages in a function definition can make it unsuitable
@code{struct foo} without describing the elements. A later declaration
that does specify the possible values completes the type.
-You can't allocate variables or storage using the type while it is
+You cannot allocate variables or storage using the type while it is
incomplete. However, you can work with pointers to that type.
This extension may not be very useful, but it makes the handling of
@menu
* Host Common:: Things every host probably needs implemented.
-* Filesystem:: Your host can't have the letter `a' in filenames?
+* Filesystem:: Your host cannot have the letter `a' in filenames?
* Host Misc:: Rare configuration options for hosts.
@end menu
Refer to @uref{binaries.html,,binaries} for information about obtaining
precompiled GCC binaries for HP-UX@. Precompiled binaries must be obtained
-to build the Ada language as it can't be bootstrapped using C@. Ada is
+to build the Ada language as it cannot be bootstrapped using C@. Ada is
only available for the 32-bit PA-RISC runtime.
Starting with GCC 3.4 an ISO C compiler is required to bootstrap. The
HP linker be used for link editing on this target.
At this time, the GNU linker does not support the creation of long
-branch stubs. As a result, it can't successfully link binaries
+branch stubs. As a result, it cannot successfully link binaries
containing branch offsets larger than 8 megabytes. In addition,
there are problems linking shared libraries, linking executables
with @option{-static}, and with dwarf2 unwind and exception support.
It also doesn't provide stubs for internal calls to global functions
-in shared libraries, so these calls can't be overloaded.
+in shared libraries, so these calls cannot be overloaded.
The HP dynamic loader does not support GNU symbol versioning, so symbol
versioning is not supported. It may be necessary to disable symbol
@opindex Winvalid-pch
@opindex Wno-invalid-pch
Warn if a precompiled header (@pxref{Precompiled Headers}) is found in
-the search path but can't be used.
+the search path but cannot be used.
@item -Wlong-long
@opindex Wlong-long
the available options are shown at startup of the instrumented program. See
@url{https://github.com/google/sanitizers/wiki/AddressSanitizerFlags#run-time-flags}
for a list of supported options.
-The option can't be combined with @option{-fsanitize=thread}
+The option cannot be combined with @option{-fsanitize=thread}
and/or @option{-fcheck-pointer-bounds}.
@item -fsanitize=kernel-address
@opindex fsanitize=kernel-address
Enable AddressSanitizer for Linux kernel.
See @uref{https://github.com/google/kasan/wiki} for more details.
-The option can't be combined with @option{-fcheck-pointer-bounds}.
+The option cannot be combined with @option{-fcheck-pointer-bounds}.
@item -fsanitize=thread
@opindex fsanitize=thread
environment variable; see
@url{https://github.com/google/sanitizers/wiki/ThreadSanitizerFlags} for a list of
supported options.
-The option can't be combined with @option{-fsanitize=address},
+The option cannot be combined with @option{-fsanitize=address},
@option{-fsanitize=leak} and/or @option{-fcheck-pointer-bounds}.
@item -fsanitize=leak
@uref{https://github.com/google/sanitizers/wiki/AddressSanitizerLeakSanitizer} for more
details. The run-time behavior can be influenced using the
@env{LSAN_OPTIONS} environment variable.
-The option can't be combined with @option{-fsanitize=thread}.
+The option cannot be combined with @option{-fsanitize=thread}.
@item -fsanitize=undefined
@opindex fsanitize=undefined
This option enables instrumentation of array bounds. Various out of bounds
accesses are detected. Flexible array members, flexible array member-like
arrays, and initializers of variables with static storage are not instrumented.
-The option can't be combined with @option{-fcheck-pointer-bounds}.
+The option cannot be combined with @option{-fcheck-pointer-bounds}.
@item -fsanitize=bounds-strict
@opindex fsanitize=bounds-strict
This option enables strict instrumentation of array bounds. Most out of bounds
accesses are detected, including flexible array members and flexible array
member-like arrays. Initializers of variables with static storage are not
-instrumented. The option can't be combined
+instrumented. The option cannot be combined
with @option{-fcheck-pointer-bounds}.
@item -fsanitize=alignment
@item -mcbranch-force-delay-slot
@opindex mcbranch-force-delay-slot
Force the usage of delay slots for conditional branches, which stuffs the delay
-slot with a @code{nop} if a suitable instruction can't be found. By default
+slot with a @code{nop} if a suitable instruction cannot be found. By default
this option is disabled. It can be enabled to work around hardware bugs as
found in the original SH7055.
@strong{Warning:} the requisite libraries are not part of GCC@.
Normally the facilities of the machine's usual C compiler are used, but
-this can't be done directly in cross-compilation. You must make your
+this cannot be done directly in cross-compilation. You must make your
own arrangements to provide suitable library functions for
cross-compilation.
@findex COMPILER_PATH
The value of @env{COMPILER_PATH} is a colon-separated list of
directories, much like @env{PATH}. GCC tries the directories thus
-specified when searching for subprograms, if it can't find the
+specified when searching for subprograms, if it cannot find the
subprograms using @env{GCC_EXEC_PREFIX}.
@item LIBRARY_PATH
The value of @env{LIBRARY_PATH} is a colon-separated list of
directories, much like @env{PATH}. When configured as a native compiler,
GCC tries the directories thus specified when searching for special
-linker files, if it can't find them using @env{GCC_EXEC_PREFIX}. Linking
+linker files, if it cannot find them using @env{GCC_EXEC_PREFIX}. Linking
using GCC also uses these directories when searching for ordinary
libraries for the @option{-l} option (but directories specified with
@option{-L} come first).
compiler looks for a precompiled header in each directory just before it
looks for the include file in that directory. The name searched for is
the name specified in the @code{#include} with @samp{.gch} appended. If
-the precompiled header file can't be used, it is ignored.
+the precompiled header file cannot be used, it is ignored.
For instance, if you have @code{#include "all.h"}, and you have
@file{all.h.gch} in the same directory as @file{all.h}, then the
Only one precompiled header can be used in a particular compilation.
@item
-A precompiled header can't be used once the first C token is seen. You
+A precompiled header cannot be used once the first C token is seen. You
can have preprocessor directives before a precompiled header; you cannot
include a precompiled header from inside another header.
@item
The precompiled header file must be produced for the same language as
-the current compilation. You can't use a C precompiled header for a C++
+the current compilation. You cannot use a C precompiled header for a C++
compilation.
@item
@code{@{i_init, + i_step@}_for1} and @code{@{j_init, +, j_step@}_for2}
relative to @code{a}.
-Usually, the object the pointer refers to is either unknown, or we can't
+Usually, the object the pointer refers to is either unknown, or we cannot
prove that the access is confined to the boundaries of a certain object.
Two data references can be compared only if at least one of these two
Memory location with B base register, but not using a long offset.
@item W
-A memory operand with an address that can't be used in an unaligned access.
+A memory operand with an address that cannot be used in an unaligned access.
@end ifset
@item Z
The GNU Objective-C runtime provides a hook, called
@code{__objc_msg_forward2}, which is called by
-@code{objc_msg_lookup()} when it can't find a method implementation in
+@code{objc_msg_lookup()} when it cannot find a method implementation in
the runtime tables and after calling @code{+resolveInstanceMethod:}
and @code{+resolveClassMethod:} has been attempted and did not succeed
in dynamically registering the method.
of comparison. The result is computed without overflow, as if with
infinite precision.
-Of course, machines can't really subtract with infinite precision.
+Of course, machines cannot really subtract with infinite precision.
However, they can pretend to do so when only the sign of the result will
be used, which is the case when the result is stored in the condition
code. And that is the @emph{only} way this kind of expression may
immediate values into general-purpose registers, but does not have an
instruction for loading an immediate value into a floating-point
register, so @code{PREFERRED_RELOAD_CLASS} returns @code{NO_REGS} when
-@var{x} is a floating-point constant. If the constant can't be loaded
+@var{x} is a floating-point constant. If the constant cannot be loaded
into any kind of register, code generation will be better if
@code{TARGET_LEGITIMATE_CONSTANT_P} makes the constant illegitimate instead
of using @code{TARGET_PREFERRED_RELOAD_CLASS}.
ordinarily be used.
Unlike @code{PREFERRED_RELOAD_CLASS}, this macro should be used when
-there are certain modes that simply can't go in certain reload classes.
+there are certain modes that simply cannot go in certain reload classes.
The value is a register class; perhaps @var{class}, or perhaps another,
smaller class.
the FPSCR PR bit has to be cleared, while for a double precision
operation, this bit has to be set. Changing the PR bit requires a general
purpose register as a scratch register, hence these FPSCR sets have to
-be inserted before reload, i.e.@: you can't put this into instruction emitting
+be inserted before reload, i.e.@: you cannot put this into instruction emitting
or @code{TARGET_MACHINE_DEPENDENT_REORG}.
You can have multiple entities that are mode-switched, and select at run time
immediate values into general-purpose registers, but does not have an
instruction for loading an immediate value into a floating-point
register, so @code{PREFERRED_RELOAD_CLASS} returns @code{NO_REGS} when
-@var{x} is a floating-point constant. If the constant can't be loaded
+@var{x} is a floating-point constant. If the constant cannot be loaded
into any kind of register, code generation will be better if
@code{TARGET_LEGITIMATE_CONSTANT_P} makes the constant illegitimate instead
of using @code{TARGET_PREFERRED_RELOAD_CLASS}.
ordinarily be used.
Unlike @code{PREFERRED_RELOAD_CLASS}, this macro should be used when
-there are certain modes that simply can't go in certain reload classes.
+there are certain modes that simply cannot go in certain reload classes.
The value is a register class; perhaps @var{class}, or perhaps another,
smaller class.
the FPSCR PR bit has to be cleared, while for a double precision
operation, this bit has to be set. Changing the PR bit requires a general
purpose register as a scratch register, hence these FPSCR sets have to
-be inserted before reload, i.e.@: you can't put this into instruction emitting
+be inserted before reload, i.e.@: you cannot put this into instruction emitting
or @code{TARGET_MACHINE_DEPENDENT_REORG}.
You can have multiple entities that are mode-switched, and select at run time
This is necessary, but doesn't always work smoothly.
* Standard Libraries:: GCC uses the system C library, which might not be
compliant with the ISO C standard.
-* Disappointments:: Regrettable things we can't change, but not quite bugs.
+* Disappointments:: Regrettable things we cannot change, but not quite bugs.
* C++ Misunderstandings:: Common misunderstandings with GNU C++.
* Non-bugs:: Things we think are right, but some others disagree.
* Warnings and Errors:: Which problems in your code get warnings,
compiler will look for a name declared at the enclosing namespace scope
(which is the global scope here). It will not look into the base class,
since that is dependent and you may declare specializations of
-@code{Base} even after declaring @code{Derived}, so the compiler can't
+@code{Base} even after declaring @code{Derived}, so the compiler cannot
really know what @code{i} would refer to. If there is no global
variable @code{i}, then you will get an error message.
projects / gcc.git / commitdiff