+2001-06-26 Joseph S. Myers <jsm28@cam.ac.uk>
+
+ * doc/c-tree.texi, doc/cpp.texi, doc/extend.texi, doc/gcc.texi,
+ doc/install.texi, doc/invoke.texi, doc/objc.texi, doc/rtl.texi,
+ doc/tm.texi: Use two spaces after ends of sentences.
+
2001-06-26 Daniel Berlin <dan@cgsoftware.com>
* toplev.c (display_help): Fix param thinko.
@item TYPE_PTROB_P
This predicate holds for a pointer to object type. Note however that it
-does not hold for the generic pointer to object type @code{void *}. You
+does not hold for the generic pointer to object type @code{void *}. You
may use @code{TYPE_PTROBV_P} to test for a pointer to object type as
well as @code{void *}.
@item TYPENAME_TYPE
Used to represent a construct of the form @code{typename T::A}. The
@code{TYPE_CONTEXT} is @code{T}; the @code{TYPE_NAME} is an
-@code{IDENTIFIER_NODE} for @code{A}. If the type is specified via a
+@code{IDENTIFIER_NODE} for @code{A}. If the type is specified via a
template-id, then @code{TYPENAME_TYPE_FULLNAME} yields a
@code{TEMPLATE_ID_EXPR}. The @code{TREE_TYPE} is non-@code{NULL} if the
node is implicitly generated in support for the implicit typename
list. Given one member, the next can be found by following the
@code{TREE_CHAIN}. You should not depend in any way on the order in
which fields appear on this list. All nodes on this list will be
-@samp{DECL} nodes. A @code{FIELD_DECL} is used to represent a non-static
+@samp{DECL} nodes. A @code{FIELD_DECL} is used to represent a non-static
data member, a @code{VAR_DECL} is used to represent a static data
member, and a @code{TYPE_DECL} is used to represent a type. Note that
the @code{CONST_DECL} for an enumeration constant will appear on this
you should always use the @code{DECL_SIZE} and @code{DECL_ALIGN} rather
than the @code{TYPE_SIZE} and @code{TYPE_ALIGN} given by the
@code{TREE_TYPE}, since special attributes may have been applied to the
-variable to give it a particular size and alignment. You may use the
+variable to give it a particular size and alignment. You may use the
predicates @code{DECL_THIS_STATIC} or @code{DECL_THIS_EXTERN} to test
whether the storage class specifiers @code{static} or @code{extern} were
used to declare a variable.
@code{terminate} must be called.
@item USING_STMT
-Used to represent a @code{using} directive. The namespace is given by
-@code{USING_STMT_NAMESPACE}, which will be a NAMESPACE_DECL. This node
+Used to represent a @code{using} directive. The namespace is given by
+@code{USING_STMT_NAMESPACE}, which will be a NAMESPACE_DECL. This node
is needed inside template functions, to implement using directives
during instantiation.
After the textual transformations are finished, the input file is
converted into a sequence of @dfn{preprocessing tokens}. These mostly
correspond to the syntactic tokens used by the C compiler, but there are
-a few differences. White space separates tokens; it is not itself a
+a few differences. White space separates tokens; it is not itself a
token of any kind. Tokens do not have to be separated by white space,
but it is often necessary to avoid ambiguities.
@end example
@noindent
-(where @samp{^@@} is ASCII NUL). Within string or character constants,
+(where @samp{^@@} is ASCII NUL). Within string or character constants,
NULs are preserved. In the latter two cases the preprocessor emits a
warning message.
@expansion{} fprintf(stderr, "success!\n", );
@end example
-GNU CPP has a pair of extensions which deal with this problem. First,
+GNU CPP has a pair of extensions which deal with this problem. First,
you are allowed to leave the variable argument out entirely:
@example
@ftable @code
@item #pragma GCC dependency
@code{#pragma GCC dependency} allows you to check the relative dates of
-the current file and another file. If the other file is more recent than
-the current file, a warning is issued. This is useful if the current
+the current file and another file. If the other file is more recent than
+the current file, a warning is issued. This is useful if the current
file is derived from the other file, and should be regenerated. The
other file is searched for using the normal include search path.
Optional trailing text can be used to give more information in the
@item Number of parameters in a macro definition and arguments in a macro call.
-We allow @code{USHRT_MAX}, which is no smaller than 65,535. The minimum
+We allow @code{USHRT_MAX}, which is no smaller than 65,535. The minimum
required by the standard is 127.
@item Number of characters on a logical source line.
@end example
@noindent
-@var{predicate} must be a single identifier. @var{answer} can be any
+@var{predicate} must be a single identifier. @var{answer} can be any
sequence of tokens; all characters are significant except for leading
and trailing whitespace, and differences in internal whitespace
sequences are ignored. (This is similar to the rules governing macro
@item -MQ @var{target}
Same as @option{-MT}, but it quotes any characters which are special to
-Make. @option{@w{-MQ '$(objpfx)foo.o'}} gives
+Make. @option{@w{-MQ '$(objpfx)foo.o'}} gives
@example
$$(objpfx)foo.o: foo.c
@item -gcc
Define the macros @sc{__gnuc__}, @sc{__gnuc_minor__} and
-@sc{__gnuc_patchlevel__}. These are defined automatically when you use
+@sc{__gnuc_patchlevel__}. These are defined automatically when you use
@command{gcc -E}; you can turn them off in that case with
@option{-no-gcc}.
@item -traditional
Try to imitate the behavior of old-fashioned C, as opposed to ISO
-C@. @xref{Traditional Mode}.
+C@. @xref{Traditional Mode}.
@item -trigraphs
Process trigraph sequences. @xref{Initial processing}.
Use this option on the AVR to indicate that the specified
function is an signal handler. The compiler will generate function
entry and exit sequences suitable for use in an signal handler when this
-attribute is present. Interrupts will be disabled inside function.
+attribute is present. Interrupts will be disabled inside function.
@item naked
@cindex function without a prologue/epilogue code
@cindex @code{shared} variable attribute
On Windows NT, in addition to putting variable definitions in a named
section, the section can also be shared among all running copies of an
-executable or DLL. For example, this small program defines shared data
+executable or DLL. For example, this small program defines shared data
by putting it in a named section @code{shared} and marking the section
shareable:
@cindex @code{__func__} identifier
GCC predefines two magic identifiers to hold the name of the current
-function. The identifier @code{__FUNCTION__} holds the name of the function
-as it appears in the source. The identifier @code{__PRETTY_FUNCTION__}
+function. The identifier @code{__FUNCTION__} holds the name of the function
+as it appears in the source. The identifier @code{__PRETTY_FUNCTION__}
holds the name of the function pretty printed in a language specific
fashion.
@end smallexample
The compiler automagically replaces the identifiers with a string
-literal containing the appropriate name. Thus, they are neither
+literal containing the appropriate name. Thus, they are neither
preprocessor macros, like @code{__FILE__} and @code{__LINE__}, nor
-variables. This means that they catenate with other string literals, and
-that they can be used to initialize char arrays. For example
+variables. This means that they catenate with other string literals, and
+that they can be used to initialize char arrays. For example
@smallexample
char here[] = "Function " __FUNCTION__ " in " __FILE__;
@end smallexample
appeared, where function-name is the name of the lexically-enclosing
-function. This name is the unadorned name of the function.
+function. This name is the unadorned name of the function.
@end display
By this definition, @code{__func__} is a variable, not a string literal.
@cindex volatile write
@cindex volatile access
-Both the C and C++ standard have the concept of volatile objects. These
-are normally accessed by pointers and used for accessing hardware. The
+Both the C and C++ standard have the concept of volatile objects. These
+are normally accessed by pointers and used for accessing hardware. The
standards encourage compilers to refrain from optimizations
concerning accesses to volatile objects that it might perform on
-non-volatile objects. The C standard leaves it implementation defined
-as to what constitutes a volatile access. The C++ standard omits to
+non-volatile objects. The C standard leaves it implementation defined
+as to what constitutes a volatile access. The C++ standard omits to
specify this, except to say that C++ should behave in a similar manner
-to C with respect to volatiles, where possible. The minimum either
+to C with respect to volatiles, where possible. The minimum either
standard specifies 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
+occurred. Thus an implementation is free to reorder and combine
volatile accesses which occur between sequence points, but cannot do so
-for accesses across a sequence point. The use of volatiles does not
+for accesses across a sequence point. The use of volatiles does not
allow you to violate the restriction on updating objects multiple times
within a sequence point.
In most expressions, it is intuitively obvious what is a read and what is
-a write. For instance
+a write. For instance
@example
volatile int *dst = @var{somevalue};
@noindent
will cause a read of the volatile object pointed to by @var{src} and stores the
-value into the volatile object pointed to by @var{dst}. There is no
+value into the volatile object pointed to by @var{dst}. There is no
guarantee that these reads and writes are atomic, especially for objects
larger than @code{int}.
Less obvious expressions are where something which looks like an access
-is used in a void context. An example would be,
+is used in a void context. An example would be,
@example
volatile int *src = @var{somevalue};
With C, such expressions are rvalues, and as rvalues cause a read of
the object, GCC interprets this as a read of the volatile being pointed
-to. The C++ standard specifies that such expressions do not undergo
+to. 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
+object may be incomplete. The C++ standard does not specify explicitly
that it is this lvalue to rvalue conversion which is responsible for
-causing an access. However, there is reason to believe that it is,
-because otherwise certain simple expressions become undefined. However,
+causing an access. However, 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 volatile object of complete type in a void context as a read
-of the object. When the object has incomplete type, G++ issues a
+of the object. When the object has incomplete type, G++ issues a
warning.
@example
@end example
In this example, a warning is issued for @code{*ptr1}, and @code{*ptr2}
-causes a read of the object pointed to. If you wish to force an error on
+causes a read of the object pointed to. If you wish to force an error on
the first case, you must force a conversion to rvalue with, for instance
a static cast, @code{static_cast<S>(*ptr1)}.
When using a reference to volatile, G++ does not treat equivalent
expressions as accesses to volatiles, but instead issues a warning that
-no volatile is accessed. The rationale for this is that otherwise it
+no volatile is accessed. The rationale for this is that otherwise it
becomes difficult to determine where volatile access occur, and not
possible to ignore the return value from functions returning volatile
-references. Again, if you wish to force a read, cast the reference to
+references. Again, if you wish to force a read, cast the reference to
an rvalue.
@node Restricted Pointers
As with gcc, g++ understands the C99 feature of restricted pointers,
specified with the @code{__restrict__}, or @code{__restrict} type
-qualifier. Because you cannot compile C++ by specifying the @option{-std=c99}
+qualifier. Because you cannot compile C++ by specifying the @option{-std=c99}
language flag, @code{restrict} is not a keyword in C++.
In addition to allowing restricted pointers, you can specify restricted
@noindent
Within the body of @code{T::fn}, @var{this} will have the effective
-definition @code{T *__restrict__ const this}. Notice that the
+definition @code{T *__restrict__ const this}. Notice that the
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
+is applied to the pointer rather than the object. This is consistent with
other compilers which implement restricted pointers.
As with all outermost parameter qualifiers, @code{__restrict__} is
-ignored in function definition matching. This means you only need to
+ignored in function definition matching. This means you only need to
specify @code{__restrict__} in a function definition, rather than
in a function prototype as well.
@end example
For PMF constants (i.e. expressions of the form @samp{&Klasse::Member}),
-no object is needed to obtain the address of the function. They can be
+no object is needed to obtain the address of the function. They can be
converted to function pointers directly:
@example
@section Deprecated Features
In the past, the GNU C++ compiler was extended to experiment with new
-features, at a time when the C++ language was still evolving. Now that
+features, at a time when the C++ language was still evolving. Now that
the C++ standard is complete, some of those features are superseded by
-superior alternatives. Using the old features might cause a warning in
-some cases that the feature will be dropped in the future. In other
+superior alternatives. Using the old features might cause a warning in
+some cases that the feature will be dropped in the future. In other
cases, the feature might be gone already.
While the list below is not exhaustive, it documents some of the options
@item -fexternal-templates
@itemx -falt-external-templates
These are two of the many ways for g++ to implement template
-instantiation. @xref{Template Instantiation}. The C++ standard clearly
+instantiation. @xref{Template Instantiation}. The C++ standard clearly
defines how template definitions have to be organized across
-implementation units. g++ has an implicit instantiation mechanism that
+implementation units. g++ has an implicit instantiation mechanism that
should work just fine for standard-conforming code.
@item -fstrict-prototype
@itemx -fno-strict-prototype
Previously it was possible to use an empty prototype parameter list to
indicate an unspecified number of parameters (like C), rather than no
-parameters, as C++ demands. This feature has been removed, except where
+parameters, as C++ demands. This feature has been removed, except where
it is required for backwards compatibility @xref{Backwards Compatibility}.
@end table
@cindex ARM [Annotated C++ Reference Manual]
Now that there is a definitive ISO standard C++, g++ has a specification
-to adhere to. The C++ language evolved over time, and features that
+to adhere to. The C++ language evolved over time, and features that
used to be acceptable in previous drafts of the standard, such as the ARM
-[Annotated C++ Reference Manual], are no longer accepted. In order to allow
+[Annotated C++ Reference Manual], are no longer accepted. In order to allow
compilation of C++ written to such drafts, g++ contains some backwards
-compatibilities. @emph{All such backwards compatibility features are
+compatibilities. @emph{All such backwards compatibility features are
liable to disappear in future versions of g++.} They should be considered
deprecated @xref{Deprecated Features}.
@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
-within the for scope). g++ retains this, but issues a warning, if such a
+within the for scope). g++ retains this, but issues a warning, if such a
variable is accessed outside the for scope.
@item implicit C language
Old C system header files did not contain an @code{extern "C" @{@dots{}@}}
-scope to set the language. On such systems, all header files are
-implicitly scoped inside a C language scope. Also, an empty prototype
+scope to set the language. On such systems, all header files are
+implicitly scoped inside a C language scope. Also, an empty prototype
@code{()} will be treated as an unspecified number of arguments, rather
than no arguments, as C++ demands.
@end table
@cindex CHILL
Several versions of the compiler (C, C++, Objective-C, Fortran, Java
and CHILL) are integrated; this is why we use the name
-``GNU Compiler Collection''. GCC can compile programs written in any of these
-languages. The Fortran, CHILL, and Java compilers are described in
+``GNU Compiler Collection''. GCC can compile programs written in any of these
+languages. The Fortran, CHILL, and Java compilers are described in
separate manuals.
@cindex GCC
affecting the behavior of ``GCC'' or sometimes just ``the compiler''.
Front ends for other languages, such as Ada 95 and Pascal exist but
-have not yet been integrated into GCC. These front ends, like that for C++,
+have not yet been integrated into GCC. These front ends, like that for C++,
are built in subdirectories of GCC and link to it. The result is an
integrated compiler that can compile programs written in C, C++,
Objective-C, or any of the languages for which you have installed front
@subsection Implicit Copy-Assignment for Virtual Bases
When a base class is virtual, only one subobject of the base class
-belongs to each full object. Also, the constructors and destructors are
-invoked only once, and called from the most-derived class. However, such
-objects behave unspecified when being assigned. For example:
+belongs to each full object. Also, the constructors and destructors are
+invoked only once, and called from the most-derived class. However, such
+objects behave unspecified when being assigned. For example:
@example
struct Base@{
@end example
The C++ standard specifies that @samp{Base::Base} is only called once
-when constructing or copy-constructing a Derived object. It is
+when constructing or copy-constructing a Derived object. It is
unspecified whether @samp{Base::operator=} is called more than once when
the implicit copy-assignment for Derived objects is invoked (as it is
inside @samp{func} in the example).
g++ implements the ``intuitive'' algorithm for copy-assignment: assign all
-direct bases, then assign all members. In that algorithm, the virtual
-base subobject can be encountered many times. In the example, copying
+direct bases, then assign all members. In that algorithm, the virtual
+base subobject can be encountered many times. In the example, copying
proceeds in the following order: @samp{val}, @samp{name} (via
@code{strdup}), @samp{bval}, and @samp{name} again.
If application code relies on copy-assignment, a user-defined
-copy-assignment operator removes any uncertainties. With such an
+copy-assignment operator removes any uncertainties. With such an
operator, the application can define whether and how the virtual base
subobject is assigned.
preprocessor output generated by adding @option{-save-temps} to the
compilation command (@pxref{Debugging Options}). When you do this, use
the same @option{-I}, @option{-D} or @option{-U} options that you used in
-actual compilation. Then send the @var{input}.i or @var{input}.ii files
+actual compilation. Then send the @var{input}.i or @var{input}.ii files
generated.
A single statement is not enough of an example. In order to compile it,
@cindex gccbug script
To simplify creation of bug reports, and to allow better tracking of
-reports, we use the GNATS bug tracking system. Part of that system is
-the @code{gccbug} script. This is a Unix shell script, so you need a
-shell to run it. It is normally installed in the same directory where
+reports, we use the GNATS bug tracking system. Part of that system is
+the @code{gccbug} script. This is a Unix shell script, so you need a
+shell to run it. It is normally installed in the same directory where
@code{gcc} is installed.
The gccbug script is derived from send-pr, @pxref{using
-send-pr,,Creating new Problem Reports,send-pr,Reporting Problems}. When
+send-pr,,Creating new Problem Reports,send-pr,Reporting Problems}. When
invoked, it starts a text editor so you can fill out the various fields
-of the report. When the you quit the editor, the report is automatically
+of the report. When the you quit the editor, the report is automatically
send to the bug reporting address.
A number of fields in this bug report form are specific to GCC, and are
The parsing pass is invoked only once, to parse the entire input. A
high level tree representation is then generated from the input,
one function at a time. This tree code is then transformed into RTL
-intermediate code, and processed. The files involved in transforming
+intermediate code, and processed. The files involved in transforming
the trees into RTL are @file{expr.c}, @file{expmed.c}, and
@file{stmt.c}.
@c Note, the above files aren't strictly the only files involved. It's
@opindex di
The option @option{-di} causes a debugging dump of the RTL code after
-this pass is run. This dump file's name is made by appending
+this pass is run. This dump file's name is made by appending
@samp{.sibling} to the input file name.
@cindex jump optimization
@cindex Single Static Assignment optimizations
@opindex fssa
@item
-Static Single Assignment (SSA) based optimization passes. The
+Static Single Assignment (SSA) based optimization passes. The
SSA conversion passes (to/from) are turned on by the @option{-fssa}
option (it is also done automatically if you enable an SSA optimization pass).
-These passes utilize a form called Static Single Assignment. In SSA form,
+These passes utilize a form called Static Single Assignment. In SSA form,
each variable (pseudo register) is only set once, giving you def-use
and use-def chains for free, and enabling a lot more optimization
passes to be run in linear time.
@opindex dX
The option @option{-dX} causes a debugging dump of the RTL code after
-this pass. This dump file's name is made by appending @samp{.dce} to
+this pass. This dump file's name is made by appending @samp{.dce} to
the input file name.
@end itemize
@cindex global common subexpression elimination
If MR PRE GCSE is done, code hoisting (aka unification) is also done, as
well as load motion.
If you are optimizing for speed, LCM (lazy code motion) based GCSE is
-done. LCM is based on the work of Knoop, Ruthing, and Steffen. LCM
+done. LCM is based on the work of Knoop, Ruthing, and Steffen. LCM
based GCSE also does loop invariant code motion. We also perform load
and store motion when optimizing for speed.
Regardless of which type of GCSE is used, the GCSE pass also performs
@cindex register movement
@item
-Register movement (@file{regmove.c}). This pass looks for cases where
+Register movement (@file{regmove.c}). This pass looks for cases where
matching constraints would force an instruction to need a reload, and
this reload would be a register to register move. It then attempts
to change the registers used by the instruction to avoid the move
@cindex reordering, block
@item
Basic block reordering. This pass implements profile guided code
-positioning. If profile information is not available, various types of
+positioning. If profile information is not available, various types of
static analysis are performed to make the predictions normally coming
from the profile feedback (IE execution frequency, branch probability,
-etc). It is implemented in the file @file{bb-reorder.c}, and the
+etc). It is implemented in the file @file{bb-reorder.c}, and the
various prediction routines are in @file{predict.c}.
@opindex dB
The option @option{-dB} causes a debugging dump of the RTL code after
-this pass. This dump file's name is made by appending @samp{.bbro} to
+this pass. This dump file's name is made by appending @samp{.bbro} to
the input file name.
@cindex cross-jumping
@item UPDATE_PATH_HOST_CANONICALIZE (@var{path}, @var{key})
If defined, a C statement (sans semicolon) that performs host-dependent
canonicalization when a path used in a compilation driver or preprocessor is
-canonicalized. @var{path} is the path to be canonicalized, and @var{key} is
-a translation prefix when its value isn't @code{NULL}. If the C statement
+canonicalized. @var{path} is the path to be canonicalized, and @var{key} is
+a translation prefix when its value isn't @code{NULL}. If the C statement
does canonicalize @var{path}, the new path should be returned.
@end table
@settitle Installing GCC: Binaries
@end ifset
-@comment $Id: install.texi,v 1.33 2001/06/23 23:41:59 jsm28 Exp $
+@comment $Id: install.texi,v 1.34 2001/06/25 00:21:28 jsm28 Exp $
@c Copyright (C) 2001 Free Software Foundation, Inc.
@c *** Converted to texinfo by Dean Wakerley, dean@wakerley.com
as detailing some target specific installation instructions.
GCC includes several components that previously were separate distributions
-with their own installation instructions. This document supersedes all
-package specific installation instructions. We provide the component
+with their own installation instructions. This document supersedes all
+package specific installation instructions. We provide the component
specific installation information in the source distribution for historical
reference purposes only.
@end ifnotinfo
Please note that GCC does not support @samp{make uninstall} and probably
-won't do so in the near future as this would open a can of worms. Instead,
+won't do so in the near future as this would open a can of worms. Instead,
we suggest that you install GCC into a directory of its own and simply
remove that directory when you do not need that specific version of GCC
any longer.
If you choose to download specific components, you must download the core
gcc distribution plus any language specific distributions you wish to
use. The core distribution includes the C language front end as well as the
-shared components. Each language has a tarball which includes the language
+shared components. Each language has a tarball which includes the language
front end as well as the language runtime (when appropriate).
Unpack the core distribution as well as any language specific
@item @anchor{with-gnu-as}--with-gnu-as
Specify that the compiler should assume that the
-assembler it finds is the GNU assembler. However, this does not modify
+assembler it finds is the GNU assembler. However, this does not modify
the rules to find an assembler and will result in confusion if found
assembler is not actually the GNU assembler. (Confusion will also
result if the compiler finds the GNU assembler but has not been
@file{@var{exec_prefix}/lib/gcc-lib/@var{target}/@var{version}}
directory, where @var{exec_prefix} defaults to @var{prefix} which
defaults to @file{/usr/local} unless overridden by the
-@option{--prefix=/pathname} switch described above. @var{target} is the
+@option{--prefix=/pathname} switch described above. @var{target} is the
target system triple, such as @var{sparc-sun-solaris2.7}, and
@var{version} denotes the GCC version, such as 2.95.2.
@item
Check operating system specific directories (e.g. @file{/usr/ccs/bin} on
Sun Solaris).
@end itemize
-Note that these rules do not check for the value of @env{PATH}. You may
+Note that these rules do not check for the value of @env{PATH}. You may
want to use @option{--with-as} if no assembler is installed in the
directories listed above, or if you have multiple assemblers installed
and want to choose one that is not found by the above rules.
Specify which cpu variant the
compiler should generate code for by default. This is currently
only supported on the some ports, specifically arm, powerpc, and
-SPARC. If configure does not recognize the model name (e.g. arm700,
+SPARC. If configure does not recognize the model name (e.g. arm700,
603e, or ultrasparc) you provide, please check the configure script
for a complete list of supported models.
@item --enable-maintainer-mode
The build rules that
regenerate the GCC master message catalog @file{gcc.pot} are normally
-disabled. This is because it can only be rebuilt if the complete source
-tree is present. If you have changed the sources and want to rebuild the
+disabled. This is because it can only be rebuilt if the complete source
+tree is present. If you have changed the sources and want to rebuild the
catalog, configuring with @option{--enable-maintainer-mode} will enable
-this. Note that you need a recent version of the @code{gettext} tools
+this. Note that you need a recent version of the @code{gettext} tools
to do so.
@item --enable-version-specific-runtime-libs
@file{@var{libsubdir}/include/g++} unless you overruled it by using
@option{--with-gxx-include-dir=@var{dirname}}. Using this option is
particularly useful if you intend to use several versions of GCC in
-parallel. This is currently supported by @samp{libf2c} and
+parallel. This is currently supported by @samp{libf2c} and
@samp{libstdc++}.
@item --enable-languages=@var{lang1},@var{lang2},@dots{}
Specify that only a particular subset of compilers and
-their runtime libraries should be built. For a list of valid values for
+their runtime libraries should be built. For a list of valid values for
@var{langN} you can issue the following command in the
@file{gcc} directory of your GCC source tree:@* @samp{grep language=
*/config-lang.in}@* Currently, you can use any of the following:
@end smallexample
@var{KEY} defaults to GCC version number, and can be overridden by the
-@option{--enable-win32-registry=@var{KEY}} option. Vendors and distributors
+@option{--enable-win32-registry=@var{KEY}} option. Vendors and distributors
who use custom installers are encouraged to provide a different key,
perhaps one comprised of vendor name and GCC version number, to
-avoid conflict with existing installations. This feature is enabled
+avoid conflict with existing installations. This feature is enabled
by default, and can be disabled by @option{--disable-win32-registry}
option. This option has no effect on the other hosts.
@itemx --disable-nls
The @option{--enable-nls} option enables Native Language Support (NLS),
which lets GCC output diagnostics in languages other than American
-English. Native Language Support is enabled by default if not doing a
-canadian cross build. The @option{--disable-nls} option disables NLS.
+English. Native Language Support is enabled by default if not doing a
+canadian cross build. The @option{--disable-nls} option disables NLS.
@item --with-included-gettext
If NLS is enabled, the @option{--with-included-gettext} option causes the build
If you used the flag @option{--enable-languages=@dots{}} to restrict
the compilers to be built, only those you've actually enabled will be
-built. This will of course only build those runtime libraries, for
+built. This will of course only build those runtime libraries, for
which the particular compiler has been built. Please note,
that re-defining LANGUAGES when calling @samp{make bootstrap}
@strong{does not} work anymore!
to current development versions of GCC and GCC 3.0 or later.
GCC 2.95.x does not come with a testsuite.}
-Before you install GCC, you might wish to run the testsuite. This
+Before you install GCC, you might wish to run the testsuite. This
step is optional and may require you to download additional software.
First, you must have @uref{download.html,,downloaded the testsuites}.
As a first possibility to cut down the number of tests that are run it is
possible to use @samp{make check-gcc} or @samp{make check-g++}
-in the gcc subdirectory of the object directory. To further cut down the
+in the gcc subdirectory of the object directory. To further cut down the
tests the following is possible:
@example
@section How to interpret test results
After the testsuite has run you'll find various @file{*.sum} and @file{*.log}
-files in the testsuite subdirectories. The @file{*.log} files contain a
+files in the testsuite subdirectories. The @file{*.log} files contain a
detailed log of the compiler invocations and the corresponding
-results, the @file{*.sum} files summarize the results. These summaries list
+results, the @file{*.sum} files summarize the results. These summaries list
all the tests that have been run with a corresponding status code:
@itemize @bullet
@section Submitting test results
If you want to report the results to the GCC project, use the
-@file{contrib/test_summary} shell script. Start it in the @var{objdir} with
+@file{contrib/test_summary} shell script. Start it in the @var{objdir} with
@example
@var{srcdir}/contrib/test_summary -p your_commentary.txt \
@end example
This script uses the @command{Mail} program to send the results, so
-make sure it is in your @env{PATH}. The file @file{your_commentary.txt} is
+make sure it is in your @env{PATH}. The file @file{your_commentary.txt} is
prepended to the testsuite summary and should contain any special
-remarks you have on your results or your build environment. Please
+remarks you have on your results or your build environment. Please
do not edit the testsuite result block or the subject line, as these
messages are automatically parsed and presented at the
@uref{http://gcc.gnu.org/testresults/,,GCC testresults} web
page. Here you can also gather information on how specific tests
-behave on different platforms and compare them with your results. A
+behave on different platforms and compare them with your results. A
few failing testcases are possible even on released versions and you
should look here first if you think your results are unreasonable.
@cindex Binaries
@cindex Installing GCC: Binaries
-We are often asked about pre-compiled versions of GCC. While we cannot
+We are often asked about pre-compiled versions of GCC. While we cannot
provide these for all platforms, below you'll find links to binaries for
various platforms where creating them by yourself is not easy due to various
reasons.
distribution CD-ROM from the
@uref{http://www.fsf.org/order/order.html,,Free Software Foundation}.
It contains binaries for a number of platforms, and
-includes not only GCC, but other stuff as well. The current CD does
+includes not only GCC, but other stuff as well. The current CD does
not contain the latest version of GCC, but it should allow
-bootstrapping the compiler. An updated version of that disk is in the
+bootstrapping the compiler. An updated version of that disk is in the
works.
@html
The MIL-STD-1750A cross configuration produces output for
@code{as1750}, an assembler/linker available under the GNU Public
-License for the 1750A. @code{as1750} can be obtained at
+License for the 1750A. @code{as1750} can be obtained at
@uref{ftp://ftp.fta-berlin.de/pub/crossgcc/1750gals/}.
A similarly licensed simulator for
the 1750A is available from same address.
@heading @anchor{ix86-*-linux*oldld}i?86-*-linux*oldld
Use this configuration to generate @file{a.out} binaries on Linux-based
GNU systems if you do not have gas/binutils version 2.5.2 or later
-installed. This is an obsolete configuration.
+installed. This is an obsolete configuration.
@html
</p>
@end html
@heading @anchor{ix86-*-linux*aout}i?86-*-linux*aout
Use this configuration to generate @file{a.out} binaries on Linux-based
-GNU systems. This configuration is being superseded. You must use
+GNU systems. This configuration is being superseded. You must use
gas/binutils version 2.5.2 or later.
@html
Use of the @option{-march-pentiumpro} flag can result in
unrecognized opcodes when using the native assembler on OS versions before
-5.0.6. (Support for P6 opcodes was added to the native ELF assembler in
+5.0.6. (Support for P6 opcodes was added to the native ELF assembler in
that version.) While it's rather rare to see these emitted by GCC yet,
errors of the basic form:
<hr>
@end html
@heading @anchor{m68k-bull-sysv}m68k-bull-sysv
-Bull DPX/2 series 200 and 300 with BOS-2.00.45 up to BOS-2.01. GCC works
-either with native assembler or GNU assembler. You can use
+Bull DPX/2 series 200 and 300 with BOS-2.00.45 up to BOS-2.01. GCC works
+either with native assembler or GNU assembler. You can use
GNU assembler with native coff generation by providing @option{--with-gnu-as} to
the configure script or use GNU assembler with dbx-in-coff encapsulation
-by providing @samp{--with-gnu-as --stabs}. For any problem with native
+by providing @samp{--with-gnu-as --stabs}. For any problem with native
assembler or for availability of the DPX/2 port of GAS, contact
@email{F.Pierresteguy@@frcl.bull.fr}.
GNU as is distributed as part of the binutils package.
You must use GAS on these platforms, as the native assembler can not handle
-the code for exception handling support. Either of these messages indicates
+the code for exception handling support. Either of these messages indicates
that you are using the MIPS assembler when instead you should be using GAS:
@samp{ as0: Error: ./libgcc2.c, line 1:Badly delimited numeric literal
target. See the link below for details.
GCC does not correctly pass/return structures which are
-smaller than 16 bytes and which are not 8 bytes. The problem is very
-involved and difficult to fix. It affects a number of other targets also,
+smaller than 16 bytes and which are not 8 bytes. The problem is very
+involved and difficult to fix. It affects a number of other targets also,
but IRIX 6 is affected the most, because it is a 64 bit target, and 4 byte
-structures are common. The exact problem is that structures are being padded
+structures are common. The exact problem is that structures are being padded
at the wrong end, e.g. a 4 byte structure is loaded into the lower 4 bytes
of the register when it should be loaded into the upper 4 bytes of the
register.
GCC is consistent with itself, but not consistent with the SGI C compiler
(and the SGI supplied runtime libraries), so the only failures that can
happen are when there are library functions that take/return such
-structures. There are very few such library functions. I can only recall
+structures. There are very few such library functions. I can only recall
seeing two of them: inet_ntoa, and semctl.
See @uref{http://freeware.sgi.com/,,http://freeware.sgi.com/} for more
You will need
@uref{ftp://ftp.varesearch.com/pub/support/hjl/binutils,,binutils-2.9.4.0.8}
-or newer for a working GCC. It is strongly recommended to recompile binutils
+or newer for a working GCC. It is strongly recommended to recompile binutils
if you initially built it with gcc-2.7.2.x.
You can specify a default version for the @option{-mcpu=@var{cpu_type}}
@end html
@heading @anchor{*-*-solaris*}*-*-solaris*
-Starting with Solaris, Sun does not ship a C compiler any more. To
+Starting with Solaris, Sun does not ship a C compiler any more. To
bootstrap and install GCC you first have to install a pre-built
compiler, see our @uref{binaries.html,,binaries page} for
details.
@file{/usr/ucb} from your @code{PATH}.
All releases of GNU binutils prior to 2.11.1 have known bugs on this
-platform. We recommend the use of GNU binutils 2.11.1 or the vendor
+platform. We recommend the use of GNU binutils 2.11.1 or the vendor
tools (Sun as, Sun ld).
Unfortunately, C++ shared libraries, including libstdc++, won't work
properly if assembled with Sun as: the linker will complain about
relocations in read-only sections, in the definition of virtual
-tables. Also, Sun as fails to process long symbols resulting from
+tables. Also, Sun as fails to process long symbols resulting from
mangling template-heavy C++ function names.
@html
@item -fno-gnu-keywords
@opindex fno-gnu-keywords
Do not recognize @code{typeof} as a keyword, so that code can use this
-word as an identifier. You can use the keyword @code{__typeof__} instead.
+word as an identifier. You can use the keyword @code{__typeof__} instead.
@option{-ansi} implies @option{-fno-gnu-keywords}.
@item -fno-honor-std
@opindex ftemplate-depth
Set the maximum instantiation depth for template classes to @var{n}.
A limit on the template instantiation depth is needed to detect
-endless recursions during template class instantiation. ANSI/ISO C++
+endless recursions during template class instantiation. ANSI/ISO C++
conforming programs must not rely on a maximum depth greater than 17.
@item -fuse-cxa-atexit
@item -Wno-deprecated (C++ only)
@opindex Wno-deprecated
-Do not warn about usage of deprecated features. @xref{Deprecated Features}.
+Do not warn about usage of deprecated features. @xref{Deprecated Features}.
@item -Wno-non-template-friend (C++ only)
@opindex Wno-non-template-friend
Disable warnings when non-templatized friend functions are declared
-within a template. With the advent of explicit template specification
+within a template. With the advent of explicit template specification
support in g++, if the name of the friend is an unqualified-id (i.e.,
@samp{friend foo(int)}), the C++ language specification demands that the
-friend declare or define an ordinary, nontemplate function. (Section
-14.5.3). Before g++ implemented explicit specification, unqualified-ids
+friend declare or define an ordinary, nontemplate function. (Section
+14.5.3). Before g++ implemented explicit specification, unqualified-ids
could be interpreted as a particular specialization of a templatized
-function. Because this non-conforming behavior is no longer the default
+function. Because this non-conforming behavior is no longer the default
behavior for g++, @option{-Wnon-template-friend} allows the compiler to
check existing code for potential trouble spots, and is on by default.
This new compiler behavior can be turned off with
return-value in a function whose return-type is not @code{void}.
For C++, a function without return type always produces a diagnostic
-message, even when @option{-Wno-return-type} is specified. The only
+message, even when @option{-Wno-return-type} is specified. The only
exceptions are @samp{main} and functions defined in system headers.
@item -Wswitch
@item -fdump-translation-unit-@var{number} (C and C++ only)
@opindex fdump-translation-unit
Dump a representation of the tree structure for the entire translation
-unit to a file. The file name is made by appending @file{.tu} to the
-source file name. If the @samp{-@var{number}} form is used, @var{number}
+unit to a file. The file name is made by appending @file{.tu} to the
+source file name. If the @samp{-@var{number}} form is used, @var{number}
controls the details of the dump as described for the @option{-fdump-tree} options.
@item -fdump-class-hierarchy (C++ only)
@item -fdump-class-hierarchy-@var{number} (C++ only)
@opindex fdump-class-hierarchy
Dump a representation of each class's hierarchy and virtual function
-table layout to a file. The file name is made by appending @file{.class}
-to the source file name. If the @samp{-@var{number}} form is used, @var{number}
+table layout to a file. The file name is made by appending @file{.class}
+to the source file name. If the @samp{-@var{number}} form is used, @var{number}
controls the details of the dump as described for the @option{-fdump-tree}
options.
@item -fdump-ast-@var{switch}-@var{number} (C++ only)
@opindex fdump-ast
Control the dumping at various stages of processing the abstract syntax
-tree to a file. The file name is generated by appending a switch
-specific suffix to the source file name. If the @samp{-@var{number}} form is
+tree to a file. The file name is generated by appending a switch
+specific suffix to the source file name. If the @samp{-@var{number}} form is
used, @var{number} is a bit mask which controls the details of the
-dump. The following bits are meaningful (these are not set symbolically,
+dump. The following bits are meaningful (these are not set symbolically,
as the primary function of these dumps is for debugging gcc itself):
@table @samp
@item bit0 (1)
-Print the address of each node. Usually this is not meaningful as it
+Print the address of each node. Usually this is not meaningful as it
changes according to the environment and source file.
@item bit1 (2)
Inhibit dumping of members of a scope or body of a function, unless they
@item -fgcse-lm
@opindex fgcse-lm
When @option{-fgcse-lm} is enabled, global common subexpression elimination will
-attempt to move loads which are only killed by stores into themselves. This
+attempt to move loads which are only killed by stores into themselves. This
allows a loop containing a load/store sequence to be changed to a load outside
the loop, and a copy/store within the loop.
@item -fgcse-sm
@opindex fgcse-sm
When @option{-fgcse-sm} is enabled, A store motion pass is run after global common
-subexpression elimination. This pass will attempt to move stores out of loops.
+subexpression elimination. This pass will attempt to move stores out of loops.
When used in conjunction with @option{-fgcse-lm}, loops containing a load/store sequence
can be changed to a load before the loop and a store after the loop.
object file name for that source file, a colon, and the names of all the
included files. Unless overridden explicitly, the object file name
consists of the basename of the source file with any suffix replaced with
-object file suffix. If there are many included files then the
+object file suffix. If there are many included files then the
rule is split into several lines using @samp{\}-newline.
@option{-M} implies @option{-E}.
@opindex nostdlib
Do not use the standard system startup files or libraries when linking.
No startup files and only the libraries you specify will be passed to
-the linker. The compiler may generate calls to memcmp, memset, and memcpy
+the linker. The compiler may generate calls to memcmp, memset, and memcpy
for System V (and ISO C) environments or to bcopy and bzero for
BSD environments. These entries are usually resolved by entries in
libc. These entry points should be supplied through some other
results, you must also specify the same set of options that were used to
generate code (@option{-fpic}, @option{-fPIC}, or model suboptions)
when you specify this option.@footnote{On some systems, @samp{gcc -shared}
-needs to build supplementary stub code for constructors to work. On
+needs to build supplementary stub code for constructors to work. On
multi-libbed systems, @samp{gcc -shared} must select the correct support
libraries to link against. Failing to supply the correct flags may lead
-to subtle defects. Supplying them in cases where they are not necessary
+to subtle defects. Supplying them in cases where they are not necessary
is innocuous.}
@item -shared-libgcc
file, substituting your own version, since these directories are
searched before the system header file directories. However, you should
not use this option to add directories that contain vendor-supplied
-system header files (use @option{-isystem} for that). If you use more than
+system header files (use @option{-isystem} for that). If you use more than
one @option{-I} option, the directories are scanned in left-to-right
order; the standard system directories come after.
@item %.@var{SUFFIX}
Substitutes @var{.SUFFIX} for the suffixes of a matched switch's args
-when it is subsequently output with @samp{%*}. @var{SUFFIX} is
+when it is subsequently output with @samp{%*}. @var{SUFFIX} is
terminated by the next space or %.
@item %w
@item -mcpu32
@opindex mcpu32
-Generate output for a CPU32. This is the default
+Generate output for a CPU32. This is the default
when the compiler is configured for CPU32-based systems.
Use this option for microcontrollers with a
This is also appropriate for the older SparcStation 1, 2, IPX etc.
With @option{-msupersparc} the compiler optimizes code for the SuperSparc cpu, as
-used in the SparcStation 10, 1000 and 2000 series. This flag also enables use
+used in the SparcStation 10, 1000 and 2000 series. This flag also enables use
of the full SPARC v8 instruction set.
These options are deprecated and will be deleted in a future GCC release.
@end enumerate
@option{-msvr4} is the default for the m88k-motorola-sysv4 and
-m88k-dg-dgux m88k configurations. @option{-msvr3} is the default for all
+m88k-dg-dgux m88k configurations. @option{-msvr3} is the default for all
other m88k configurations.
@item -mversion-03.00
@opindex mno-fancy-math-387
Some 387 emulators do not support the @code{sin}, @code{cos} and
@code{sqrt} instructions for the 387. Specify this option to avoid
-generating those instructions. This option is the default on FreeBSD.
+generating those instructions. This option is the default on FreeBSD.
As of revision 2.6.1, these instructions are not generated unless you
also use the @option{-funsafe-math-optimizations} switch.
@item -mpush-args
@opindex mpush-args
-Use PUSH operations to store outgoing parameters. This method is shorter
+Use PUSH operations to store outgoing parameters. This method is shorter
and usually equally fast as method using SUB/MOV operations and is enabled
-by default. In some cases disabling it may improve performance because of
+by default. In some cases disabling it may improve performance because of
improved scheduling and reduced dependencies.
@item -maccumulate-outgoing-args
@opindex maccumulate-outgoing-args
If enabled, the maximum amount of space required for outgoing arguments will be
-computed in the function prologue. This in faster on most modern CPUs
+computed in the function prologue. This in faster on most modern CPUs
because of reduced dependencies, improved scheduling and reduced stack usage
when preferred stack boundary is not equal to 2. The drawback is a notable
-increase in code size. This switch implies @option{-mno-push-args}.
+increase in code size. This switch implies @option{-mno-push-args}.
@item -mthreads
@opindex mthreads
-Support thread-safe exception handling on @samp{Mingw32}. Code that relies
+Support thread-safe exception handling on @samp{Mingw32}. Code that relies
on thread-safe exception handling must compile and link all code with the
-@option{-mthreads} option. When compiling, @option{-mthreads} defines
+@option{-mthreads} option. When compiling, @option{-mthreads} defines
@option{-D_MT}; when linking, it links in a special thread helper library
@option{-lmingwthrd} which cleans up per thread exception handling data.
@item -mno-align-stringops
@opindex mno-align-stringops
-Do not align destination of inlined string operations. This switch reduces
+Do not align destination of inlined string operations. This switch reduces
code size and improves performance in case the destination is already aligned,
but gcc don't know about it.
@item -minline-all-stringops
@opindex minline-all-stringops
By default GCC inlines string operations only when destination is known to be
-aligned at least to 4 byte boundary. This enables more inlining, increase code
+aligned at least to 4 byte boundary. This enables more inlining, increase code
size, but may improve performance of code that depends on fast memcpy, strlen
and memset for short lengths.
@table @gcctabopt
@item -mc300
@opindex mc300
-Produce code for a C300 Clipper processor. This is the default.
+Produce code for a C300 Clipper processor. This is the default.
@item -mc400
@opindex mc400
@item -m32381
@opindex m32381
Generate output containing 32381 instructions for floating point. This
-also implies @option{-m32081}. The 32381 is only compatible with the 32332
-and 32532 cpus. This is the default for the pc532-netbsd configuration.
+also implies @option{-m32081}. The 32381 is only compatible with the 32332
+and 32532 cpus. This is the default for the pc532-netbsd configuration.
@item -mmulti-add
@opindex mmulti-add
Try and generate multiply-add floating point instructions @code{polyF}
-and @code{dotF}. This option is only available if the @option{-m32381}
-option is in effect. Using these instructions requires changes to to
+and @code{dotF}. This option is only available if the @option{-m32381}
+option is in effect. Using these instructions requires changes to to
register allocation which generally has a negative impact on
performance. This option should only be enabled when compiling code
particularly likely to make heavy use of multiply-add instructions.
@item -mnomulti-add
@opindex mnomulti-add
Do not try and generate multiply-add floating point instructions
-@code{polyF} and @code{dotF}. This is the default on all platforms.
+@code{polyF} and @code{dotF}. This is the default on all platforms.
@item -msoft-float
@opindex msoft-float
@item -mnobitfield
@opindex mnobitfield
-Do not use the bit-field instructions. On some machines it is faster to
-use shifting and masking operations. This is the default for the pc532.
+Do not use the bit-field instructions. On some machines it is faster to
+use shifting and masking operations. This is the default for the pc532.
@item -mbitfield
@opindex mbitfield
-Do use the bit-field instructions. This is the default for all platforms
+Do use the bit-field instructions. This is the default for all platforms
except the pc532.
@item -mrtd
@item -mnoregparam
@opindex mnoregparam
-Do not pass any arguments in registers. This is the default for all
+Do not pass any arguments in registers. This is the default for all
targets.
@item -msb
@opindex msb
It is OK to use the sb as an index register which is always loaded with
-zero. This is the default for the pc532-netbsd target.
+zero. This is the default for the pc532-netbsd target.
@item -mnosb
@opindex mnosb
The sb register is not available for use or has not been initialized to
-zero by the run time system. This is the default for all targets except
-the pc532-netbsd. It is also implied whenever @option{-mhimem} or
+zero by the run time system. This is the default for all targets except
+the pc532-netbsd. It is also implied whenever @option{-mhimem} or
@option{-fpic} is set.
@item -mhimem
@item -mcall-prologues
@opindex mcall-prologues
Functions prologues/epilogues expanded as call to appropriate
-subroutines. Code size will be smaller.
+subroutines. Code size will be smaller.
@item -mno-tablejump
@opindex mno-tablejump
@table @gcctabopt
@item -fexceptions
@opindex fexceptions
-Enable exception handling. Generates extra code needed to propagate
+Enable exception handling. Generates extra code needed to propagate
exceptions. For some targets, this implies GCC will generate frame
unwind information for all functions, which can produce significant data
size overhead, although it does not affect execution. If you do not
This section describes several environment variables that affect how GCC
operates. Some of them work by specifying directories or prefixes to use
-when searching for various kinds of files. Some are used to specify other
+when searching for various kinds of files. Some are used to specify other
aspects of the compilation environment.
@ifclear INTERNALS
@item LANG
@findex LANG
@cindex locale definition
-This variable is used to pass locale information to the compiler. One way in
+This variable is used to pass locale information to the compiler. One way in
which this information is used is to determine the character set to be used
when character literals, string literals and comments are parsed in C and C++.
When the compiler is configured to allow multibyte characters,
@chapter GNU Objective-C runtime features
This document is meant to describe some of the GNU Objective-C runtime
-features. It is not intended to teach you Objective-C, there are several
+features. It is not intended to teach you Objective-C, there are several
resources on the Internet that present the language. Questions and
comments about this document to Ovidiu Predescu
@email{ovidiu@@cup.hp.com}.
The GNU Objective-C runtime provides a way that allows you to execute
code before the execution of the program enters the @code{main}
-function. The code is executed on a per-class and a per-category basis,
+function. The code is executed on a per-class and a per-category basis,
through a special class method @code{+load}.
This facility is very useful if you want to initialize global variables
which can be accessed by the program directly, without sending a message
-to the class first. The usual way to initialize global variables, in the
+to the class first. The usual way to initialize global variables, in the
@code{+initialize} method, might not be useful because
@code{+initialize} is only called when the first message is sent to a
class object, which in some cases could be too late.
@end example
In this example, the initialization of @code{Stdin}, @code{Stdout} and
-@code{Stderr} in @code{+initialize} occurs too late. The programmer can
+@code{Stderr} in @code{+initialize} occurs too late. The programmer can
send a message to one of these objects before the variables are actually
-initialized, thus sending messages to the @code{nil} object. The
+initialized, thus sending messages to the @code{nil} object. The
@code{+initialize} method which actually initializes the global
variables is not invoked until the first message is sent to the class
-object. The solution would require these variables to be initialized
+object. The solution would require these variables to be initialized
just before entering @code{main}.
The correct solution of the above problem is to use the @code{+load}
@end example
-The @code{+load} is a method that is not overridden by categories. If a
+The @code{+load} is a method that is not overridden by categories. If a
class and a category of it both implement @code{+load}, both methods are
invoked. This allows some additional initializations to be performed in
a category.
@end itemize
You should make no assumptions about receiving @code{+load} in sibling
-classes when you write @code{+load} of a class. The order in which
+classes when you write @code{+load} of a class. The order in which
sibling classes receive @code{+load} is not guaranteed.
The order in which @code{+load} and @code{+initialize} are called could
-be problematic if this matters. If you don't allocate objects inside
+be problematic if this matters. If you don't allocate objects inside
@code{+load}, it is guaranteed that @code{+load} is called before
-@code{+initialize}. If you create an object inside @code{+load} the
+@code{+initialize}. If you create an object inside @code{+load} the
@code{+initialize} method of object's class is invoked even if
-@code{+load} was not invoked. Note if you explicitly call @code{+load}
-on a class, @code{+initialize} will be called first. To avoid possible
+@code{+load} was not invoked. Note if you explicitly call @code{+load}
+on a class, @code{+initialize} will be called first. To avoid possible
problems try to implement only one of these methods.
The @code{+load} method is also invoked when a bundle is dynamically
-loaded into your running program. This happens automatically without any
-intervening operation from you. When you write bundles and you need to
+loaded into your running program. This happens automatically without any
+intervening operation from you. When you write bundles and you need to
write @code{+load} you can safely create and send messages to objects whose
-classes already exist in the running program. The same restrictions as
+classes already exist in the running program. The same restrictions as
above apply to classes defined in bundle.
@section Type encoding
The Objective-C compiler generates type encodings for all the
-types. These type encodings are used at runtime to find out information
+types. These type encodings are used at runtime to find out information
about selectors and methods and about objects and classes.
The types are encoded in the following way:
The encoding of bit-fields has changed to allow bit-fields to be properly
handled by the runtime functions that compute sizes and alignments of
-types that contain bit-fields. The previous encoding contained only the
-size of the bit-field. Using only this information it is not possible to
-reliably compute the size occupied by the bit-field. This is very
+types that contain bit-fields. The previous encoding contained only the
+size of the bit-field. Using only this information it is not possible to
+reliably compute the size occupied by the bit-field. This is very
important in the presence of the Boehm's garbage collector because the
objects are allocated using the typed memory facility available in this
-collector. The typed memory allocation requires information about where
+collector. The typed memory allocation requires information about where
the pointers are located inside the object.
The position in the bit-field is the position, counting in bits, of the
@sp 1
In addition to the types the compiler also encodes the type
-specifiers. The table below describes the encoding of the current
+specifiers. The table below describes the encoding of the current
Objective-C type specifiers:
@sp 1
@sp 1
-The type specifiers are encoded just before the type. Unlike types
+The type specifiers are encoded just before the type. Unlike types
however, the type specifiers are only encoded when they appear in method
argument types.
Support for a new memory management policy has been added by using a
powerful conservative garbage collector, known as the
-Boehm-Demers-Weiser conservative garbage collector. It is available from
+Boehm-Demers-Weiser conservative garbage collector. It is available from
@w{@uref{http://www.hpl.hp.com/personal/Hans_Boehm/gc/}}.
To enable the support for it you have to configure the compiler using an
-additional argument, @w{@option{--enable-objc-gc}}. You need to have
-garbage collector installed before building the compiler. This will
+additional argument, @w{@option{--enable-objc-gc}}. You need to have
+garbage collector installed before building the compiler. This will
build an additional runtime library which has several enhancements to
-support the garbage collector. The new library has a new name,
+support the garbage collector. The new library has a new name,
@file{libobjc_gc.a} to not conflict with the non-garbage-collected
library.
When the garbage collector is used, the objects are allocated using the
so-called typed memory allocation mechanism available in the
-Boehm-Demers-Weiser collector. This mode requires precise information on
-where pointers are located inside objects. This information is computed
+Boehm-Demers-Weiser collector. This mode requires precise information on
+where pointers are located inside objects. This information is computed
once per class, immediately after the class has been initialized.
There is a new runtime function @code{class_ivar_set_gcinvisible()}
which can be used to declare a so-called @dfn{weak pointer}
-reference. Such a pointer is basically hidden for the garbage collector;
+reference. Such a pointer is basically hidden for the garbage collector;
this can be useful in certain situations, especially when you want to
keep track of the allocated objects, yet allow them to be
-collected. This kind of pointers can only be members of objects, you
-cannot declare a global pointer as a weak reference. Every type which is
+collected. This kind of pointers can only be members of objects, you
+cannot declare a global pointer as a weak reference. Every type which is
a pointer type can be declared a weak pointer, including @code{id},
@code{Class} and @code{SEL}.
-Here is an example of how to use this feature. Suppose you want to
+Here is an example of how to use this feature. Suppose you want to
implement a class whose instances hold a weak pointer reference; the
following class does this:
@end example
Weak pointers are supported through a new type character specifier
-represented by the @samp{!} character. The
+represented by the @samp{!} character. The
@code{class_ivar_set_gcinvisible()} function adds or removes this
specifier to the string type description of the instance variable named
as argument.
@section Constant string objects
GNU Objective-C provides constant string objects that are generated
-directly by the compiler. You declare a constant string object by
+directly by the compiler. You declare a constant string object by
prefixing a C constant string with the character @samp{@@}:
@example
The constant string objects are usually instances of the
@code{NXConstantString} class which is provided by the GNU Objective-C
-runtime. To get the definition of this class you must include the
+runtime. To get the definition of this class you must include the
@file{objc/NXConstStr.h} header file.
User defined libraries may want to implement their own constant string
-class. To be able to support them, the GNU Objective-C compiler provides
+class. To be able to support them, the GNU Objective-C compiler provides
a new command line options @option{-fconstant-string-class=@var{class-name}}.
The provided class should adhere to a strict structure, the same
as @code{NXConstantString}'s structure:
@end example
User class libraries may choose to inherit the customized constant
-string class from a different class than @code{Object}. There is no
+string class from a different class than @code{Object}. There is no
requirement in the methods the constant string class has to implement.
When a file is compiled with the @option{-fconstant-string-class} option,
all the constant string objects will be instances of the class specified
-as argument to this option. It is possible to have multiple compilation
+as argument to this option. It is possible to have multiple compilation
units referring to different constant string classes, neither the
compiler nor the linker impose any restrictions in doing this.
@item i
An RTX code for an entire instruction: @code{INSN}, @code{JUMP_INSN}, and
-@code{CALL_INSN}. @xref{Insns}.
+@code{CALL_INSN}. @xref{Insns}.
@item m
An RTX code for something that matches in insns, such as
@item (mem:@var{m} @var{addr} @var{alias})
This RTX represents a reference to main memory at an address
represented by the expression @var{addr}. @var{m} specifies how large
-a unit of memory is accessed. @var{alias} specifies an alias set for the
-reference. In general two items are in different alias sets if they cannot
+a unit of memory is accessed. @var{alias} specifies an alias set for the
+reference. In general two items are in different alias sets if they cannot
reference the same memory address.
@findex addressof
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
validly be used: as a value to be stored in the condition codes, either
-@code{(cc0)} or a register. @xref{Comparisons}.
+@code{(cc0)} or a register. @xref{Comparisons}.
The mode @var{m} is not related to the modes of @var{x} and @var{y}, but
instead is the mode of the condition code value. If @code{(cc0)} is
The mode of a top level SUBREG (or what may become one).
@end table
The default function can be found in rtlanal.c, function
-@code{subreg_regno_offset}. Normally this does not need to be defined.
+@code{subreg_regno_offset}. Normally this does not need to be defined.
@end table
@node Leaf Functions
@findex PUSH_ARGS
@item PUSH_ARGS
-A C expression. If nonzero, push insns will be used to pass
+A C expression. If nonzero, push insns will be used to pass
outgoing arguments.
If the target machine does not have a push instruction, set it to zero.
That directs GCC to use an alternate strategy: to
@findex ACCUMULATE_OUTGOING_ARGS
@findex current_function_outgoing_args_size
@item ACCUMULATE_OUTGOING_ARGS
-A C expression. If nonzero, the maximum amount of space required for outgoing arguments
+A C expression. If nonzero, the maximum amount of space required for outgoing arguments
will be computed and placed into the variable
@code{current_function_outgoing_args_size}. No space will be pushed
onto the stack for each call; instead, the function prologue should
@item __builtin_next_arg (@var{lastarg})
This is the equivalent of @code{__builtin_args_info}, for stack
arguments. It returns the address of the first anonymous stack
-argument, as type @code{void *}. If @code{ARGS_GROW_DOWNWARD}, it
+argument, as type @code{void *}. If @code{ARGS_GROW_DOWNWARD}, it
returns the address of the location above the first anonymous stack
argument. Use it in @code{va_start} to initialize the pointer for
fetching arguments from the stack. Also use it in @code{va_start} to
@findex INIT_TARGET_OPTABS
@item INIT_TARGET_OPTABS
Define this macro as a C statement that declares additional library
-routines renames existing ones. @code{init_optabs} calls this macro after
+routines renames existing ones. @code{init_optabs} calls this macro after
initializing all the normal library routines.
@findex FLOAT_LIB_COMPARE_RETURNS_BOOL (@var{mode}, @var{comparison})
argument of this macro. This is used in @file{crtstuff.c} if
@code{INIT_SECTION_ASM_OP} or @code{FINI_SECTION_ASM_OP} to calls to
initialization and finalization functions from the init and fini
-sections. By default, this macro is a simple function call. Some
+sections. By default, this macro is a simple function call. Some
ports need hand-crafted assembly code to avoid dependencies on
registers initialized in the function prologue or to ensure that
constant pools don't end up too far way in the text section.
@samp{MD_INIT_BUILTINS}. @var{exp} is the expression for the function call;
the result should go to @var{target} if that is convenient, and have mode
@var{mode} if that is convenient. @var{subtarget} may be used as the target
-for computing one of @var{exp}'s operands. @var{ignore} is nonzero if the value
+for computing one of @var{exp}'s operands. @var{ignore} is nonzero if the value
is to be ignored.
This macro should return the result of the call to the built-in function.
projects / gcc.git / commitdiff