Patchwork [doc] extend.texi copy-editing, 2/N (which/that usage)

login
register
mail settings
Submitter Sandra Loosemore
Date Nov. 11, 2012, 1:50 a.m.
Message ID <509F0478.8010308@codesourcery.com>
Download mbox | patch
Permalink /patch/198229/
State New
Headers show

Comments

Sandra Loosemore - Nov. 11, 2012, 1:50 a.m.
This patch continues my series of copy-edits to the GCC user 
documentation.  Here I've fixed a number of problems in extend.texi with 
confusion between "which" and "that", as I previously did for invoke.texi.

Committed as obvious since there are no changes to content, just grammar.

-Sandra


2012-11-10  Sandra Loosemore  <sandra@codesourcery.com>

	gcc/
	* doc/extend.texi: Copy-edit to fix incorrect uses of "which"
	and "that" throughout the file.

Patch

Index: gcc/doc/extend.texi
===================================================================
--- gcc/doc/extend.texi	(revision 193399)
+++ gcc/doc/extend.texi	(working copy)
@@ -463,7 +463,7 @@  C++ Conference Proceedings, October 17-2
 A nested function can jump to a label inherited from a containing
 function, provided the label is explicitly declared in the containing
 function (@pxref{Local Labels}).  Such a jump returns instantly to the
-containing function, exiting the nested function which did the
+containing function, exiting the nested function that did the
 @code{goto} and any intermediate functions as well.  Here is an example:
 
 @smallexample
@@ -571,7 +571,7 @@  returned by @code{__builtin_apply}.
 
 @deftypefn {Built-in Function} {} __builtin_va_arg_pack ()
 This built-in function represents all anonymous arguments of an inline
-function.  It can be used only in inline functions which are always
+function.  It can be used only in inline functions that are always
 inlined, never compiled as a separate function, such as those using
 @code{__attribute__ ((__always_inline__))} or
 @code{__attribute__ ((__gnu_inline__))} extern inline functions.
@@ -597,7 +597,7 @@  myprintf (FILE *f, const char *format, .
 
 @deftypefn {Built-in Function} {size_t} __builtin_va_arg_pack_len ()
 This built-in function returns the number of anonymous arguments of
-an inline function.  It can be used only in inline functions which
+an inline function.  It can be used only in inline functions that
 are always inlined, never compiled as a separate function, such
 as those using @code{__attribute__ ((__always_inline__))} or
 @code{__attribute__ ((__gnu_inline__))} extern inline functions.
@@ -674,7 +674,7 @@  such a type.
 
 @code{typeof} is often useful in conjunction with the
 statements-within-expressions feature.  Here is how the two together can
-be used to define a safe ``maximum'' macro that operates on any
+be used to define a safe ``maximum'' macro which operates on any
 arithmetic type and evaluates each of its arguments exactly once:
 
 @smallexample
@@ -750,7 +750,7 @@  pointers to @code{char}.
 @end itemize
 
 @emph{Compatibility Note:} In addition to @code{typeof}, GCC 2 supported
-a more limited extension which permitted one to write
+a more limited extension that permitted one to write
 
 @smallexample
 typedef @var{T} = @var{expr};
@@ -759,7 +759,7 @@  typedef @var{T} = @var{expr};
 @noindent
 with the effect of declaring @var{T} to have the type of the expression
 @var{expr}.  This extension does not work with GCC 3 (versions between
-3.0 and 3.2 crash; 3.2.1 and later give an error).  Code which
+3.0 and 3.2 crash; 3.2.1 and later give an error).  Code that
 relies on it should be rewritten to use @code{typeof}:
 
 @smallexample
@@ -1417,7 +1417,7 @@  space.
 @cindex flexible array members
 
 Zero-length arrays are allowed in GNU C@.  They are very useful as the
-last element of a structure which is really a header for a variable-length
+last element of a structure that is really a header for a variable-length
 object:
 
 @smallexample
@@ -1877,7 +1877,7 @@  int a[6] = @{ 0, 0, 15, 0, 29, 0 @};
 The index values must be constant expressions, even if the array being
 initialized is automatic.
 
-An alternative syntax for this which has been obsolete since GCC 2.5 but
+An alternative syntax for this that has been obsolete since GCC 2.5 but
 GCC still accepts is to write @samp{[@var{index}]} before the element
 value, with no @samp{=}.
 
@@ -1919,7 +1919,7 @@  is equivalent to
 struct point p = @{ xvalue, yvalue @};
 @end smallexample
 
-Another syntax which has the same meaning, obsolete since GCC 2.5, is
+Another syntax that has the same meaning, obsolete since GCC 2.5, is
 @samp{@var{fieldname}:}, as shown here:
 
 @smallexample
@@ -2210,7 +2210,7 @@  if no optimization level is specified.
 
 @item gnu_inline
 @cindex @code{gnu_inline} function attribute
-This attribute should be used with a function which is also declared
+This attribute should be used with a function that is also declared
 with the @code{inline} keyword.  It directs GCC to treat the function
 as if it were defined in gnu90 mode even when compiling in C99 or
 gnu99 mode.
@@ -2248,7 +2248,7 @@  behavior.
 
 @item artificial
 @cindex @code{artificial} function attribute
-This attribute is useful for small inline wrappers which if possible
+This attribute is useful for small inline wrappers that if possible
 should appear during debugging as a unit.  Depending on the debug
 info format it either means marking the function as artificial
 or using the caller location for all instructions within the inlined
@@ -2271,7 +2271,7 @@  the current inlining parameters.
 @cindex @code{error} function attribute
 If this attribute is used on a function declaration and a call to such a function
 is not eliminated through dead code elimination or other optimizations, an error
-which includes @var{message} is diagnosed.  This is useful
+that includes @var{message} is diagnosed.  This is useful
 for compile time checking, especially together with @code{__builtin_constant_p}
 and inline functions where checking the inline function arguments is not
 possible through @code{extern char [(condition) ? 1 : -1];} tricks.
@@ -2284,7 +2284,7 @@  functions or when not emitting debugging
 @cindex @code{warning} function attribute
 If this attribute is used on a function declaration and a call to such a function
 is not eliminated through dead code elimination or other optimizations, a warning
-which includes @var{message} is diagnosed.  This is useful
+that includes @var{message} is diagnosed.  This is useful
 for compile time checking, especially together with @code{__builtin_constant_p}
 and inline functions.  While it is possible to define the function with
 a message in @code{.gnu.warning*} section, when using this attribute the problem
@@ -2499,7 +2499,7 @@  the effect of the @option{-fwhole-progra
 object remains visible outside the current compilation unit. If @option{-fwhole-program} is used together with @option{-flto} and @command{gold} is used as the linker plugin, @code{externally_visible} attributes are automatically added to functions (not variable yet due to a current @command{gold} issue) that are accessed outside of LTO objects according to resolution file produced by @command{gold}.  For other linkers that cannot generate resolution file, explicit @code{externally_visible} attributes are still necessary.
 
 @item far
-@cindex functions which handle memory bank switching
+@cindex functions that handle memory bank switching
 On 68HC11 and 68HC12 the @code{far} attribute causes the compiler to
 use a calling convention that takes care of switching memory banks when
 entering and leaving a function.  This calling convention is also the
@@ -2516,7 +2516,7 @@  instead of using @code{rts}.  The board-
 the @code{rtc}.
 
 On MeP targets this causes the compiler to use a calling convention
-which assumes the called function is too far away for the built-in
+that assumes the called function is too far away for the built-in
 addressing modes.
 
 @item fast_interrupt
@@ -2551,7 +2551,7 @@  and for static member methods.
 @cindex @code{format} function attribute
 @opindex Wformat
 The @code{format} attribute specifies that a function takes @code{printf},
-@code{scanf}, @code{strftime} or @code{strfmon} style arguments which
+@code{scanf}, @code{strftime} or @code{strfmon} style arguments that
 should be type-checked against a format string.  For example, the
 declaration:
 
@@ -2598,7 +2598,7 @@  attribute are 2 and 3.
 @opindex ffreestanding
 @opindex fno-builtin
 The @code{format} attribute allows you to identify your own functions
-which take format strings as arguments, so that GCC can check the
+that take format strings as arguments, so that GCC can check the
 calls to these functions for errors.  The compiler always (unless
 @option{-ffreestanding} or @option{-fno-builtin} is used) checks formats
 for the standard library functions @code{printf}, @code{fprintf},
@@ -2657,7 +2657,7 @@  an implicit @code{this} argument, the ar
 be counted from two.
 
 The @code{format-arg} attribute allows you to identify your own
-functions which modify format strings, so that GCC can check the
+functions that modify format strings, so that GCC can check the
 calls to @code{printf}, @code{scanf}, @code{strftime} or @code{strfmon}
 type function whose operands are a call to one of your own function.
 The compiler always treats @code{gettext}, @code{dgettext}, and
@@ -2708,7 +2708,7 @@  the code size by 2 bytes for each call g
 subroutine. The argument to the attribute is the vector number entry
 from the special page vector table which contains the 16 low-order
 bits of the subroutine's entry address. Each vector table has special
-page number (18 to 255) which are used in @code{jsrs} instruction.
+page number (18 to 255) that is used in @code{jsrs} instructions.
 Jump addresses of the routines are generated by adding 0x0F0000 (in
 case of M16C targets) or 0xFF0000 (in case of M32C targets), to the 2
 byte addresses set in the vector table. Therefore you need to ensure
@@ -3079,7 +3079,7 @@  zero -, or if the callee is responsible 
 equal to one.  The default i386 ABI assumes that the callee pops the
 stack for hidden pointer.
 
-Note, that on 32-bit i386 Windows targets the compiler assumes that the
+Note that on 32-bit i386 Windows targets, the compiler assumes that the
 caller pops the stack for hidden pointer.
 
 @item ms_hook_prologue
@@ -3103,7 +3103,7 @@  body of an assembly function, while allo
 the requisite function declaration for the assembler.
 
 @item near
-@cindex functions which do not handle memory bank switching on 68HC11/68HC12
+@cindex functions that do not handle memory bank switching on 68HC11/68HC12
 On 68HC11 and 68HC12 the @code{near} attribute causes the compiler to
 use the normal calling convention based on @code{jsr} and @code{rts}.
 This attribute can be used to cancel the effect of the @option{-mlong-calls}
@@ -3148,7 +3148,7 @@  inlining.
 @c Don't enumerate the optimizations by name here; we try to be
 @c future-compatible with this mechanism.
 If the function does not have side-effects, there are optimizations
-other than inlining that causes function calls to be optimized away,
+other than inlining that cause function calls to be optimized away,
 although the function call is live.  To keep such calls from being
 optimized away, put
 @smallexample
@@ -3160,7 +3160,7 @@  side-effect.
 @item noclone
 @cindex @code{noclone} function attribute
 This function attribute prevents a function from being considered for
-cloning - a mechanism which produces specialized copies of functions
+cloning---a mechanism that produces specialized copies of functions
 and which is (currently) performed by interprocedural constant
 propagation.
 
@@ -3255,7 +3255,7 @@  implemented in GCC versions earlier than
 @cindex @code{nosave_low_regs} attribute
 Use this attribute on SH targets to indicate that an @code{interrupt_handler}
 function should not save and restore registers R0..R7.  This can be used on SH3*
-and SH4* targets which have a second R0..R7 register bank for non-reentrant
+and SH4* targets that have a second R0..R7 register bank for non-reentrant
 interrupt handlers.
 
 @item optimize
@@ -3310,7 +3310,7 @@  The @code{pcs} attribute can be used to 
 used for a function on ARM.  The attribute takes an argument that specifies
 the calling convention to use.
 
-When compiling using the AAPCS ABI (or a variant of that) then valid
+When compiling using the AAPCS ABI (or a variant of it) then valid
 values for the argument are @code{"aapcs"} and @code{"aapcs-vfp"}.  In
 order to use a variant other than @code{"aapcs"} then the compiler must
 be permitted to use the appropriate co-processor registers (i.e., the
@@ -3589,7 +3589,7 @@  more than one function to be compiled wi
 
 For instance on a 386, you could compile one function with
 @code{target("sse4.1,arch=core2")} and another with
-@code{target("sse4a,arch=amdfam10")} that is equivalent to
+@code{target("sse4a,arch=amdfam10")}.  This is equivalent to
 compiling the first function with @option{-msse4.1} and
 @option{-march=core2} options, and the second function with
 @option{-msse4a} and @option{-march=amdfam10} options.  It is up to the
@@ -4044,7 +4044,7 @@  All visibilities are supported on many, 
 pseudo-op).  Default visibility is supported everywhere.  Hidden
 visibility is supported on Darwin targets.
 
-The visibility attribute should be applied only to declarations which
+The visibility attribute should be applied only to declarations that
 would otherwise have external linkage.  The attribute should be applied
 consistently, so that the same entity should not be declared with
 different settings of the attribute.
@@ -4109,7 +4109,7 @@  results in warning on line 5.
 @cindex @code{weak} attribute
 The @code{weak} attribute causes the declaration to be emitted as a weak
 symbol rather than a global.  This is primarily useful in defining
-library functions which can be overridden in user code, though it can
+library functions that can be overridden in user code, though it can
 also be used with non-function declarations.  Weak symbols are supported
 for ELF targets, and also for a.out targets when using the GNU assembler
 and linker.
@@ -4246,8 +4246,8 @@  specifiers, not separated by any other t
 In GNU C, an attribute specifier list may appear after the colon following a
 label, other than a @code{case} or @code{default} label.  The only
 attribute it makes sense to use after a label is @code{unused}.  This
-feature is intended for code generated by programs which contains labels
-that may be unused but which is compiled with @option{-Wall}.  It is
+feature is intended for program-generated code that may contain unused labels,
+but which is compiled with @option{-Wall}.  It is
 not normally appropriate to use in it human-written code, though it
 could be useful in cases where the code that jumps to the label is
 contained within an @code{#ifdef} conditional.  GNU C++ only permits
@@ -4300,7 +4300,7 @@  specifiers and qualifiers may be an attr
 other specifiers or qualifiers.
 
 At present, the first parameter in a function prototype must have some
-type specifier which is not an attribute specifier; this resolves an
+type specifier that is not an attribute specifier; this resolves an
 ambiguity in the interpretation of @code{void f(int
 (__attribute__((foo)) x))}, but is subject to change.  At present, if
 the parentheses of a function declarator contain only attributes then
@@ -4548,8 +4548,8 @@  struct foo @{ int x[2] __attribute__ ((a
 @end smallexample
 
 @noindent
-This is an alternative to creating a union with a @code{double} member
-that forces the union to be double-word aligned.
+This is an alternative to creating a union with a @code{double} member,
+which forces the union to be double-word aligned.
 
 As in the preceding examples, you can explicitly specify the alignment
 (in bytes) that you wish the compiler to use for a given variable or
@@ -4557,7 +4557,7 @@  structure field.  Alternatively, you can
 and just ask the compiler to align a variable or field to the
 default alignment for the target architecture you are compiling for.
 The default alignment is sufficient for all scalar types, but may not be
-enough for all vector types on a target which supports vector operations.
+enough for all vector types on a target that supports vector operations.
 The default alignment is fixed for a particular target ABI.
 
 Gcc also provides a target specific macro @code{__BIGGEST_ALIGNMENT__},
@@ -4931,7 +4931,7 @@  addresses).
 The MeP target has a number of addressing modes and busses.  The
 @code{near} space spans the standard memory space's first 16 megabytes
 (24 bits).  The @code{far} space spans the entire 32-bit memory space.
-The @code{based} space is a 128 byte region in the memory space which
+The @code{based} space is a 128 byte region in the memory space that
 is addressed relative to the @code{$tp} register.  The @code{tiny}
 space is a 65536 byte region relative to the @code{$gp} register.  In
 addition to these memory regions, the MeP target has a separate 16-bit
@@ -5227,16 +5227,16 @@  struct S @{ short f[3]; @} __attribute__
 
 Whenever you leave out the alignment factor in an @code{aligned}
 attribute specification, the compiler automatically sets the alignment
-for the type to the largest alignment which is ever used for any data
+for the type to the largest alignment that is ever used for any data
 type on the target machine you are compiling for.  Doing this can often
 make copy operations more efficient, because the compiler can use
 whatever instructions copy the biggest chunks of memory when performing
-copies to or from the variables which have types that you have aligned
+copies to or from the variables that have types that you have aligned
 this way.
 
 In the example above, if the size of each @code{short} is 2 bytes, then
 the size of the entire @code{struct S} type is 6 bytes.  The smallest
-power of two which is greater than or equal to that is 8, so the
+power of two that is greater than or equal to that is 8, so the
 compiler sets the alignment for the entire @code{struct S} type to 8
 bytes.
 
@@ -5299,7 +5299,7 @@  struct __attribute__ ((__packed__)) my_p
 @end smallexample
 
 You may only specify this attribute on the definition of an @code{enum},
-@code{struct} or @code{union}, not on a @code{typedef} which does not
+@code{struct} or @code{union}, not on a @code{typedef} that does not
 also define the enumerated type, structure or union.
 
 @item transparent_union
@@ -5722,7 +5722,7 @@  implementation defined as to what consti
 minimum requirement is that at a sequence point all previous accesses
 to volatile objects have stabilized and no subsequent accesses have
 occurred.  Thus an implementation is free to reorder and combine
-volatile accesses which occur between sequence points, but cannot do
+volatile accesses that occur between sequence points, but cannot do
 so for accesses across a sequence point.  The use of volatile does
 not allow you to violate the restriction on updating objects multiple
 times between two sequence points.
@@ -5872,7 +5872,7 @@  operand and list it with the output oper
 You may, as an alternative, logically split its function into two
 separate operands, one input operand and one write-only output
 operand.  The connection between them is expressed by constraints
-which say they need to be in the same location when the instruction
+that say they need to be in the same location when the instruction
 executes.  You can use the same C expression for both operands, or
 different expressions.  For example, here we write the (fictitious)
 @samp{combine} instruction with @code{bar} as its read-only source
@@ -6075,7 +6075,7 @@  encapsulate them in macros that look lik
 @noindent
 Here the variable @code{__arg} is used to make sure that the instruction
 operates on a proper @code{double} value, and to accept only those
-arguments @code{x} which can convert automatically to a @code{double}.
+arguments @code{x} that can convert automatically to a @code{double}.
 
 Another way to make sure the instruction operates on the correct data
 type is to use a cast in the @code{asm}.  This is different from using a
@@ -6115,7 +6115,7 @@  prove that control flow never reaches th
 instruction.)  Note that even a volatile @code{asm} instruction
 can be moved relative to other code, including across jump
 instructions.  For example, on many targets there is a system
-register which can be set to control the rounding mode of
+register that can be set to control the rounding mode of
 floating point operations.  You might try
 setting it with a volatile @code{asm}, like this PowerPC example:
 
@@ -6425,7 +6425,7 @@  register variable should be allocated.
 @item
 Global register variables reserve registers throughout the program.
 This may be useful in programs such as programming language
-interpreters which have a couple of global variables that are accessed
+interpreters that have a couple of global variables that are accessed
 very often.
 
 @item
@@ -6462,8 +6462,8 @@  register int *foo asm ("a5");
 @end smallexample
 
 @noindent
-Here @code{a5} is the name of the register which should be used.  Choose a
-register which is normally saved and restored by function calls on your
+Here @code{a5} is the name of the register that should be used.  Choose a
+register that is normally saved and restored by function calls on your
 machine, so that library routines will not clobber it.
 
 Naturally the register name is cpu-dependent, so you need to
@@ -6505,18 +6505,18 @@  might have put something else in that re
 recompile @code{qsort} with the same global register variable, you can
 solve this problem.)
 
-If you want to recompile @code{qsort} or other source files which do not
+If you want to recompile @code{qsort} or other source files that do not
 actually use your global register variable, so that they do not use that
 register for any other purpose, then it suffices to specify the compiler
 option @option{-ffixed-@var{reg}}.  You need not actually add a global
 register declaration to their source code.
 
-A function which can alter the value of a global register variable cannot
+A function that can alter the value of a global register variable cannot
 safely be called from a function compiled without this variable, because it
 could clobber the value the caller expects to find there on return.
-Therefore, the function which is the entry point into the part of the
+Therefore, the function that is the entry point into the part of the
 program that uses the global register variable must explicitly save and
-restore the value which belongs to its caller.
+restore the value that belongs to its caller.
 
 @cindex register variable after @code{longjmp}
 @cindex global register after @code{longjmp}
@@ -6561,7 +6561,7 @@  register int *foo asm ("a5");
 @end smallexample
 
 @noindent
-Here @code{a5} is the name of the register which should be used.  Note
+Here @code{a5} is the name of the register that should be used.  Note
 that this is the same syntax used for defining global register
 variables, but for a local variable it appears within a function.
 
@@ -6592,7 +6592,7 @@  according to dataflow analysis.  Referen
 be deleted or moved or simplified.
 
 As for global register variables, it's recommended that you choose a
-register which is normally saved and restored by function calls on
+register that is normally saved and restored by function calls on
 your machine, so that library routines will not clobber it.  A common
 pitfall is to initialize multiple call-clobbered registers with
 arbitrary expressions, where a function call or library call for an
@@ -6651,7 +6651,7 @@  effect aside from this.
 You can define an @code{enum} tag without specifying its possible values.
 This results in an incomplete type, much like what you get if you write
 @code{struct foo} without describing the elements.  A later declaration
-which does specify the possible values completes the type.
+that does specify the possible values completes the type.
 
 You can't allocate variables or storage using the type while it is
 incomplete.  However, you can work with pointers to that type.
@@ -6668,7 +6668,7 @@  This extension is not supported by GNU C
 @cindex @code{__FUNCTION__} identifier
 @cindex @code{__PRETTY_FUNCTION__} identifier
 
-GCC provides three magic variables which hold the name of the current
+GCC provides three magic variables that hold the name of the current
 function, as a string.  The first of these is @code{__func__}, which
 is part of the C99 standard:
 
@@ -6797,7 +6797,7 @@  of the function.  Calling @code{__builti
 @code{1} yields the frame address of the caller of the current function,
 and so forth.
 
-The frame is the area on the stack which holds local variables and saved
+The frame is the area on the stack that holds local variables and saved
 registers.  The frame address is normally the address of the first word
 pushed on to the stack by the function.  However, the exact definition
 depends upon the processor and the calling convention.  If the processor
@@ -6817,7 +6817,7 @@  purposes.
 @node Vector Extensions
 @section Using vector instructions through built-in functions
 
-On some targets, the instruction set contains SIMD vector instructions that
+On some targets, the instruction set contains SIMD vector instructions which
 operate on multiple values contained in one large register at the same time.
 For example, on the i386 the MMX, 3DNow!@: and SSE extensions can be used
 this way.
@@ -7033,7 +7033,7 @@  All of the routines are described in the
 not clear what is meant by that; it could mean that @emph{only} the
 following variables are protected, or it could mean that these variables
 should in addition be protected.  At present GCC ignores this list and
-protects all variables which are globally accessible.  If in the future
+protects all variables that are globally accessible.  If in the future
 we make some use of this list, an empty list will continue to mean all
 globally accessible variables.
 
@@ -7158,14 +7158,14 @@  to be resolved at runtime.
 The four non-arithmetic functions (load, store, exchange, and 
 compare_exchange) all have a generic version as well.  This generic
 version works on any data type.  If the data type size maps to one
-of the integral sizes which may have lock free support, the generic
+of the integral sizes that may have lock free support, the generic
 version utilizes the lock free built-in function.  Otherwise an
 external call is left to be resolved at runtime.  This external call is
 the same format with the addition of a @samp{size_t} parameter inserted
 as the first parameter indicating the size of the object being pointed to.
 All objects must be the same size.
 
-There are 6 different memory models which can be specified.  These map
+There are 6 different memory models that can be specified.  These map
 to the same names in the C++11 standard.  Refer there or to the
 @uref{http://gcc.gnu.org/wiki/Atomic/GCCMM/AtomicSync,GCC wiki on
 atomic synchronization} for more detailed definitions.  These memory
@@ -7371,7 +7371,7 @@  This built-in function returns true if o
 generate lock free atomic instructions for the target architecture.  
 @var{size} must resolve to a compile time constant and the result also resolves to compile time constant.
 
-@var{ptr} is an optional pointer to the object which may be used to determine
+@var{ptr} is an optional pointer to the object that may be used to determine
 alignment.  A value of 0 indicates typical alignment should be used.  The 
 compiler may also ignore this parameter.
 
@@ -7388,7 +7388,7 @@  generate lock free atomic instructions f
 it is not known to be lock free a call is made to a runtime routine named
 @code{__atomic_is_lock_free}.
 
-@var{ptr} is an optional pointer to the object which may be used to determine
+@var{ptr} is an optional pointer to the object that may be used to determine
 alignment.  A value of 0 indicates typical alignment should be used.  The 
 compiler may also ignore this parameter.
 @end deftypefn
@@ -8542,7 +8542,7 @@  significant bit position.  If @var{x} is
 
 @deftypefn {Built-in Function} int __builtin_clrsb (int x)
 Returns the number of leading redundant sign bits in @var{x}, i.e. the
-number of bits following the most significant bit which are identical
+number of bits following the most significant bit that are identical
 to it.  There are no special cases for 0 or other values. 
 @end deftypefn
 
@@ -8955,7 +8955,7 @@  void __builtin_avr_delay_cycles (unsigne
 
 @noindent
 @code{ticks} is the number of ticks to delay execution. Note that this
-built-in does not take into account the effect of interrupts which
+built-in does not take into account the effect of interrupts that
 might increase delay time. @code{ticks} must be a compile time
 integer constant; delays with a variable number of cycles are not supported.
 
@@ -9465,10 +9465,10 @@  into the data cache.  The instruction is
 These built-in functions are available for the i386 and x86-64 family
 of computers, depending on the command-line switches used.
 
-Note that, if you specify command-line switches such as @option{-msse},
+If you specify command-line switches such as @option{-msse},
 the compiler could use the extended instruction sets even if the built-ins
 are not used explicitly in the program.  For this reason, applications
-which perform runtime CPU detection must compile separate files for each
+that perform runtime CPU detection must compile separate files for each
 supported architecture, using the appropriate flags.  In particular,
 the file containing the CPU detection code should be compiled without
 these options.
@@ -9532,9 +9532,9 @@  to check CPU type and features, @code{__
 executed before any constructors are called.  The CPU detection code is
 automatically executed in a very high priority constructor.
 
-For example, this function has to be used in @code{ifunc} resolvers which
+For example, this function has to be used in @code{ifunc} resolvers that
 check for CPU type using the builtins @code{__builtin_cpu_is}
-and @code{__builtin_cpu_supports}, or in constructors on targets which
+and @code{__builtin_cpu_supports}, or in constructors on targets that
 don't support constructor priority.
 @smallexample
 
@@ -11578,7 +11578,7 @@  picoChip instruction set.
 @table @code
 @item int __builtin_sbc (int @var{value})
 Sign bit count.  Return the number of consecutive bits in @var{value}
-which have the same value as the sign-bit.  The result is the number of
+that have the same value as the sign-bit.  The result is the number of
 leading sign bits minus one, giving the number of redundant sign bits in
 @var{value}.
 
@@ -14328,8 +14328,8 @@  asm ("cpfoo %0" : "=B" (x));
 @item GCC disinterrupt @var{name} , @var{name} @dots{}
 @cindex pragma, disinterrupt
 For the named functions, the compiler adds code to disable interrupts
-for the duration of those functions.  Any functions so named, which
-are not encountered in the source, cause a warning that the pragma is
+for the duration of those functions.  If any functions so named 
+are not encountered in the source, a warning is emitted that the pragma is
 not used.  Examples:
 
 @example
@@ -14445,7 +14445,7 @@  adding a call to the @code{.init} sectio
 @subsection Symbol-Renaming Pragmas
 
 For compatibility with the Solaris system headers, GCC
-supports two @code{#pragma} directives which change the name used in
+supports two @code{#pragma} directives that change the name used in
 assembly for a given declaration. To get this effect
 on all platforms supported by GCC, use the asm labels extension (@pxref{Asm
 Labels}).
@@ -14484,7 +14484,7 @@  always the C-language name.
 @subsection Structure-Packing Pragmas
 
 For compatibility with Microsoft Windows compilers, GCC supports a
-set of @code{#pragma} directives which change the maximum alignment of
+set of @code{#pragma} directives that change the maximum alignment of
 members of structures (other than zero-width bitfields), unions, and
 classes subsequently defined. The @var{n} value below always is required
 to be a small power of two and specifies the new alignment in bytes.
@@ -14560,7 +14560,7 @@  are controllable and which option contro
 @var{kind} is @samp{error} to treat this diagnostic as an error,
 @samp{warning} to treat it like a warning (even if @option{-Werror} is
 in effect), or @samp{ignored} if the diagnostic is to be ignored.
-@var{option} is a double quoted string which matches the command-line
+@var{option} is a double quoted string that matches the command-line
 option.
 
 @example
@@ -15046,7 +15046,7 @@  duration.
 Change paragraph 1
 
 @quotation
-All objects which have neither thread storage duration, dynamic
+All objects that have neither thread storage duration, dynamic
 storage duration nor are local [@dots{}].
 @end quotation
 
@@ -15161,7 +15161,7 @@  volatile int *src = @var{somevalue};
 The C++ standard specifies that such expressions do not undergo lvalue
 to rvalue conversion, and that the type of the dereferenced object may
 be incomplete.  The C++ standard does not specify explicitly that it
-is lvalue to rvalue conversion which is responsible for causing an
+is lvalue to rvalue conversion that is responsible for causing an
 access.  There is reason to believe that it is, because otherwise
 certain simple expressions become undefined.  However, because it
 would surprise most programmers, G++ treats dereferencing a pointer to
@@ -15232,7 +15232,7 @@  definition @code{T *__restrict__ const t
 interpretation of a @code{__restrict__} member function qualifier is
 different to that of @code{const} or @code{volatile} qualifier, in that it
 is applied to the pointer rather than the object.  This is consistent with
-other compilers which implement restricted pointers.
+other compilers that implement restricted pointers.
 
 As with all outermost parameter qualifiers, @code{__restrict__} is
 ignored in function definition matching.  This means you only need to
@@ -15243,7 +15243,7 @@  in a function prototype as well.
 @section Vague Linkage
 @cindex vague linkage
 
-There are several constructs in C++ which require space in the object
+There are several constructs in C++ that require space in the object
 file but are not clearly tied to a single translation unit.  We say that
 these constructs have ``vague linkage''.  Typically such constructs are
 emitted wherever they are needed, though sometimes we can be more
@@ -15275,7 +15275,7 @@  and the vtable is only emitted in the tr
 method is defined.
 
 @emph{Note:} If the chosen key method is later defined as inline, the
-vtable is still emitted in every translation unit which defines it.
+vtable is still emitted in every translation unit that defines it.
 Make sure that any inline virtuals are declared inline in the class
 body, even if they are not defined there.
 
@@ -15307,7 +15307,7 @@  On targets that don't support COMDAT, bu
 uses them.  This way one copy overrides all the others, but
 the unused copies still take up space in the executable.
 
-For targets which do not support either COMDAT or weak symbols,
+For targets that do not support either COMDAT or weak symbols,
 most entities with vague linkage are emitted as local symbols to
 avoid duplicate definition errors from the linker.  This does not happen
 for local statics in inlines, however, as having multiple copies
@@ -15472,7 +15472,7 @@  You have the following options for deali
 @opindex frepo
 Compile your template-using code with @option{-frepo}.  The compiler
 generates files with the extension @samp{.rpo} listing all of the
-template instantiations used in the corresponding object files which
+template instantiations used in the corresponding object files that
 could be instantiated there; the link wrapper, @samp{collect2},
 then updates the @samp{.rpo} files to tell the compiler where to place
 those instantiations and rebuild any affected object files.  The
@@ -15704,8 +15704,9 @@  int main()
 @node Type Traits
 @section Type Traits
 
-The C++ front-end implements syntactic extensions that allow to
-determine at compile time various characteristics of a type (or of a
+The C++ front-end implements syntactic extensions that allow
+compile-time determination of 
+various characteristics of a type (or of a
 pair of types).
 
 @table @code
@@ -15955,7 +15956,7 @@  deprecated.   @xref{Deprecated Features}
 @table @code
 @item For scope
 If a variable is declared at for scope, it used to remain in scope until
-the end of the scope which contained the for statement (rather than just
+the end of the scope that contained the for statement (rather than just
 within the for scope).  G++ retains this, but issues a warning, if such a
 variable is accessed outside the for scope.