[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Bug-gnupress] Context diffs for 007, 009 and 014
|
From: |
Peter Kaiser |
|
Subject: |
[Bug-gnupress] Context diffs for 007, 009 and 014 |
|
Date: |
Fri, 16 May 2003 00:07:56 +0200 |
Here are source code context diffs for PDFs 007, 009, and 014. Working in
the .texi code, I lapped over the edges of the PDF sections in some places
as I made global changes of some phrasings.
Here are some things I changed systematically in the sections I worked on:
Changing weak or passive verbs to active ones
Adding "-" to compound adjectives (e.g., "8-bit field" -> "8-bit
field") and removing "-" where inappropriate ("some bit-fields" ->
"some bit fields")
Deleting the boring, unnecessary "Note that"
It's clear that some parts were written by authors whose native language
isn't English; if you know which those are, they deserve special attention.
___Pete
*** tm.texi.~1~ Wed Feb 12 19:40:20 2003
--- tm.texi Thu May 15 13:33:20 2003
***************
*** 9105,9111 ****
the hard register itself, if it is known not to be clobbered---or a
@code{MEM}.
If you are returning a @code{MEM}, this is only a hint for the allocator;
! it might decide to use another register anyways.
You may use @code{current_function_leaf_function} in the definition of the
macro, functions that use @code{REG_N_SETS}, to determine if the hard
register in question will not be clobbered.
--- 9105,9111 ----
the hard register itself, if it is known not to be clobbered---or a
@code{MEM}.
If you are returning a @code{MEM}, this is only a hint for the allocator;
! it might decide to use another register anyway.
You may use @code{current_function_leaf_function} in the definition of the
macro, functions that use @code{REG_N_SETS}, to determine if the hard
register in question will not be clobbered.
*** extend.texi.~1~ Tue May 13 17:45:12 2003
--- extend.texi Thu May 15 14:18:48 2003
***************
*** 36,42 ****
@item
@cite{How a diagnostic is identified (3.10, 5.1.1.3).}
! Diagnostics consist of all the output sent to stderr by GCC.
@item
@cite{Whether each nonempty sequence of white-space characters other than
--- 36,42 ----
@item
@cite{How a diagnostic is identified (3.10, 5.1.1.3).}
! Diagnostics consist of all the output GCC sends to stderr.
@item
@cite{Whether each nonempty sequence of white-space characters other than
***************
*** 47,54 ****
@node Environment implementation
@section Environment
! The behavior of these points are dependent on the implementation
! of the C library, and are not defined by GCC itself.
@node Identifiers implementation
@section Identifiers
--- 47,54 ----
@node Environment implementation
@section Environment
! The behavior of these points depends on the implementation
! of the C library, and is not defined by GCC itself.
@node Identifiers implementation
@section Identifiers
***************
*** 63,69 ****
(5.2.4.1, 6.4.2).}
For internal names, all characters are significant. For external names,
! the number of significant characters are defined by the linker; for
almost all targets, all characters are significant.
@end itemize
--- 63,69 ----
(5.2.4.1, 6.4.2).}
For internal names, all characters are significant. For external names,
! the number of significant characters is defined by the linker; for
almost all targets, all characters are significant.
@end itemize
***************
*** 196,207 ****
@item
@cite{Whether the ``inexact'' floating-point exception can be raised
when the rounded result actually does equal the mathematical result
! in an IEC 60559 conformant implementation (F.9).}
@item
@cite{Whether the ``underflow'' (and ``inexact'') floating-point
exception can be raised when a result is tiny but not inexact in an
! IEC 60559 conformant implementation (F.9).}
@end itemize
--- 196,207 ----
@item
@cite{Whether the ``inexact'' floating-point exception can be raised
when the rounded result actually does equal the mathematical result
! in an IEC 60559-conformant implementation (F.9).}
@item
@cite{Whether the ``underflow'' (and ``inexact'') floating-point
exception can be raised when a result is tiny but not inexact in an
! IEC 60559-conformant implementation (F.9).}
@end itemize
***************
*** 258,271 ****
@item
When @option{-O0} is in use, the compiler allocates distinct stack
! memory for all variables that do not have the @code{register}
storage-class specifier; if @code{register} is specified, the variable
! may have a shorter lifespan than the code would indicate and may never
be placed in memory.
@item
On some rare x86 targets, @code{setjmp} doesn't save the registers in
! all circumstances. In those cases, GCC doesn't allocate any variables
in registers unless they are marked @code{register}.
@end itemize
--- 258,271 ----
@item
When @option{-O0} is in use, the compiler allocates distinct stack
! memory for all variables that have no @code{register}
storage-class specifier; if @code{register} is specified, the variable
! may have a shorter lifespan than the code would indicate, and may never
be placed in memory.
@item
On some rare x86 targets, @code{setjmp} doesn't save the registers in
! all circumstances. In those cases, GCC allocates no variables
in registers unless they are marked @code{register}.
@end itemize
***************
*** 274,306 ****
@cite{The extent to which suggestions made by using the inline function
specifier are effective (6.7.4).}
! GCC will not inline any functions if the @option{-fno-inline} option is
! used or if @option{-O0} is used. Otherwise, GCC may still be unable to
inline a function for many reasons; the @option{-Winline} option may be
! used to determine if a function has not been inlined and why not.
@end itemize
@node Structures unions enumerations and bit-fields implementation
! @section Structures, unions, enumerations, and bit-fields
@itemize @bullet
@item
! @cite{Whether a ``plain'' int bit-field is treated as a @code{signed int}
! bit-field or as an @code{unsigned int} bit-field (6.7.2, 6.7.2.1).}
@item
@cite{Allowable bit-field types other than @code{_Bool}, @code{signed int},
and @code{unsigned int} (6.7.2.1).}
@item
! @cite{Whether a bit-field can straddle a storage-unit boundary (6.7.2.1).}
@item
! @cite{The order of allocation of bit-fields within a unit (6.7.2.1).}
@item
! @cite{The alignment of non-bit-field members of structures (6.7.2.1).}
@item
@cite{The integer type compatible with each enumerated type (6.7.2.2).}
--- 274,306 ----
@cite{The extent to which suggestions made by using the inline function
specifier are effective (6.7.4).}
! GCC will inline no functions if the @option{-fno-inline} option is
! used or if @option{-O0} is used. Otherwise, it may still be unable to
inline a function for many reasons; the @option{-Winline} option may be
! used to determine whether a function has been inlined, and if not, why not.
@end itemize
@node Structures unions enumerations and bit-fields implementation
! @section Structures, unions, enumerations, and bit fields
@itemize @bullet
@item
! @cite{Whether a ``plain'' int bit field is treated as a @code{signed int}
! bit field or as an @code{unsigned int} bit field (6.7.2, 6.7.2.1).}
@item
@cite{Allowable bit-field types other than @code{_Bool}, @code{signed int},
and @code{unsigned int} (6.7.2.1).}
@item
! @cite{Whether a bit field can straddle a storage-unit boundary (6.7.2.1).}
@item
! @cite{The order of allocation of bit fields within a unit (6.7.2.1).}
@item
! @cite{The alignment of members of structures other than bit fields
(6.7.2.1).}
@item
@cite{The integer type compatible with each enumerated type (6.7.2.2).}
***************
*** 537,543 ****
must use @code{typeof} (@pxref{Typeof}).
Embedded statements are not allowed in constant expressions, such as
! the value of an enumeration constant, the width of a bit-field, or
the initial value of a static variable.
Statement expressions are not supported fully in G++, and their fate
--- 537,543 ----
must use @code{typeof} (@pxref{Typeof}).
Embedded statements are not allowed in constant expressions, such as
! the value of an enumeration constant, the width of a bit field, or
the initial value of a static variable.
Statement expressions are not supported fully in G++, and their fate
***************
*** 3697,3703 ****
assembler input. The extended @code{asm} feature is most often used for
machine instructions the compiler itself does not know exist. If
the output expression cannot be directly addressed (for example, it is a
! bit-field), your constraint must allow a register. In that case, GCC
will use the register as the output of the @code{asm}, and then store
that register into the output.
--- 3697,3703 ----
assembler input. The extended @code{asm} feature is most often used for
machine instructions the compiler itself does not know exist. If
the output expression cannot be directly addressed (for example, it is a
! bit field), your constraint must allow a register. In that case, GCC
will use the register as the output of the @code{asm}, and then store
that register into the output.
***************
*** 6403,6409 ****
GCC supports several types of pragmas, primarily in order to compile
code originally written for other compilers. Note that in general
! we do not recommend the use of pragmas; @xref{Function Attributes},
for further explanation.
@menu
--- 6403,6409 ----
GCC supports several types of pragmas, primarily in order to compile
code originally written for other compilers. Note that in general
! we recommend against the use of pragmas; @xref{Function Attributes},
for further explanation.
@menu
***************
*** 6417,6425 ****
@node ARM Pragmas
@subsection ARM Pragmas
! The ARM target defines pragmas for controlling the default addition of
! @code{long_call} and @code{short_call} attributes to functions.
! @xref{Function Attributes}, for information about the effects of these
attributes.
@table @code
--- 6417,6425 ----
@node ARM Pragmas
@subsection ARM Pragmas
! The ARM target defines pragmas to control adding
! @code{long_call} and @code{short_call} attributes to functions by default.
! @xref{Function Attributes}, about the effects of these
attributes.
@table @code
***************
*** 6440,6450 ****
@node RS/6000 and PowerPC Pragmas
@subsection RS/6000 and PowerPC Pragmas
! The RS/6000 and PowerPC targets define one pragma for controlling
! whether or not the @code{longcall} attribute is added to function
declarations by default. This pragma overrides the @option{-mlongcall}
option, but not the @code{longcall} and @code{shortcall} attributes.
! @xref{RS/6000 and PowerPC Options}, for more information about when long
calls are and are not necessary.
@table @code
--- 6440,6450 ----
@node RS/6000 and PowerPC Pragmas
@subsection RS/6000 and PowerPC Pragmas
! The RS/6000 and PowerPC targets define one pragma to control
! whether to add the @code{longcall} attribute to function
declarations by default. This pragma overrides the @option{-mlongcall}
option, but not the @code{longcall} and @code{shortcall} attributes.
! @xref{RS/6000 and PowerPC Options}, about when long
calls are and are not necessary.
@table @code
***************
*** 6468,6475 ****
@node Darwin Pragmas
@subsection Darwin Pragmas
! The following pragmas are available for all architectures running the
! Darwin operating system. These are useful for compatibility with other
Mac OS compilers.
@table @code
--- 6468,6475 ----
@node Darwin Pragmas
@subsection Darwin Pragmas
! These pragmas are available for all architectures running the
! Darwin operating system. They are useful for compatibility with other
Mac OS compilers.
@table @code
***************
*** 6491,6498 ****
@item unused (@var{var} [, @address@hidden)
@cindex pragma, unused
! This pragma declares variables to be possibly unused. GCC will not
! produce warnings for the listed variables. The effect is similar to
that of the @code{unused} attribute, except that this pragma may appear
anywhere within the variables' scopes.
@end table
--- 6491,6498 ----
@item unused (@var{var} [, @address@hidden)
@cindex pragma, unused
! This pragma declares variables to be possibly unused. GCC produces
! no warnings for the variables listed. The effect is like
that of the @code{unused} attribute, except that this pragma may appear
anywhere within the variables' scopes.
@end table
***************
*** 6500,6507 ****
@node Solaris Pragmas
@subsection Solaris Pragmas
! For compatibility with the SunPRO compiler, the following pragma
! is supported.
@table @code
@item redefine_extname @var{oldname} @var{newname}
--- 6500,6506 ----
@node Solaris Pragmas
@subsection Solaris Pragmas
! This pragma is supported for compatibility with the SunPRO compiler.
@table @code
@item redefine_extname @var{oldname} @var{newname}
***************
*** 6517,6524 ****
@node Tru64 Pragmas
@subsection Tru64 Pragmas
! For compatibility with the Compaq C compiler, the following pragma
! is supported.
@table @code
@item extern_prefix @var{string}
--- 6516,6522 ----
@node Tru64 Pragmas
@subsection Tru64 Pragmas
! This pragma is supported for compatibility with the Compaq C compiler.
@table @code
@item extern_prefix @var{string}
***************
*** 6557,6568 ****
@end example
In this example, the user would be able to access members of the unnamed
! union with code like @samp{foo.b}. Note that only unnamed structs and
! unions are allowed, you may not have, for example, an unnamed
@code{int}.
You must never create such structures that cause ambiguous field
definitions.
! For example, this structure:
@example
struct @{
--- 6555,6566 ----
@end example
In this example, the user would be able to access members of the unnamed
! union with code like @samp{foo.b}. Only unnamed structs and
! unions are allowed, and you may not, for example, have an unnamed
@code{int}.
You must never create such structures that cause ambiguous field
definitions.
! For example, in the structure:
@example
struct @{
***************
*** 6573,6580 ****
@} foo;
@end example
! It is ambiguous which @code{a} is being referred to with @samp{foo.a}.
! Such constructs are not supported and must be avoided. In the future,
such constructs may be detected and treated as compilation errors.
@node Thread-Local
--- 6571,6578 ----
@} foo;
@end example
! it is ambiguous to which @code{a} @samp{foo.a} refers.
! Such constructs are unsupported and must be avoided. In the future,
such constructs may be detected and treated as compilation errors.
@node Thread-Local
***************
*** 6583,6593 ****
@cindex @acronym{TLS}
@cindex __thread
! Thread-local storage (@acronym{TLS}) is a mechanism by which variables
! are allocated such that there is one instance of the variable per extant
thread. The run-time model GCC uses to implement this originates
! in the IA-64 processor-specific ABI, but has since been migrated
! to other processors as well. It requires significant support from
the linker (@command{ld}), dynamic linker (@command{ld.so}), and
system libraries (@file{libc.so} and @file{libpthread.so}), so it
is not available everywhere.
--- 6581,6591 ----
@cindex @acronym{TLS}
@cindex __thread
! Thread-local storage (@acronym{TLS}) is a mechanism which allocates
variables
! so that there is one instance of the variable per extant
thread. The run-time model GCC uses to implement this originates
! in the IA-64 processor-specific ABI, but has since also been applied
! to other processors. It requires significant support from
the linker (@command{ld}), dynamic linker (@command{ld.so}), and
system libraries (@file{libc.so} and @file{libpthread.so}), so it
is not available everywhere.
*** invoke.texi.~1~ Tue May 13 18:51:22 2003
--- invoke.texi Thu May 15 14:07:14 2003
***************
*** 286,292 ****
@item Preprocessor Options
@xref{Preprocessor Options,,Options Controlling the Preprocessor}.
! @gccoptlist{-$ address@hidden@var{answer} @gol
address@hidden@address@hidden@r{]} @gol
-C -dD -dI -dM -dN @gol
address@hidden@address@hidden@r{]} -E -H @gol
--- 286,292 ----
@item Preprocessor Options
@xref{Preprocessor Options,,Options Controlling the Preprocessor}.
! @gccoptlist{-$ address@hidden@var{answer} @gol
address@hidden@address@hidden@r{]} @gol
-C -dD -dI -dM -dN @gol
address@hidden@address@hidden@r{]} -E -H @gol
***************
*** 510,516 ****
-mnumerics -mold-align -msoft-float -mstrict-align @gol
-mtail-call}
! @emph{DEC Alpha Options}
@gccoptlist{-mno-fp-regs -msoft-float -malpha-as -mgas @gol
-mieee -mieee-with-inexact -mieee-conformant @gol
address@hidden address@hidden @gol
--- 510,516 ----
-mnumerics -mold-align -msoft-float -mstrict-align @gol
-mtail-call}
! @emph{HP Alpha Options}
@gccoptlist{-mno-fp-regs -msoft-float -malpha-as -mgas @gol
-mieee -mieee-with-inexact -mieee-conformant @gol
address@hidden address@hidden @gol
***************
*** 521,527 ****
-mexplicit-relocs -msmall-data -mlarge-data @gol
address@hidden
! @emph{DEC Alpha/VMS Options}
@gccoptlist{-mvms-return-codes}
@emph{H8/300 Options}
--- 521,527 ----
-mexplicit-relocs -msmall-data -mlarge-data @gol
address@hidden
! @emph{HP Alpha/VMS Options}
@gccoptlist{-mvms-return-codes}
@emph{H8/300 Options}
***************
*** 650,657 ****
-mno-nested-cond-exec -mtomcat-stats @gol
address@hidden
-
-
@item Code Generation Options
@xref{Code Gen Options,,Options for Code Generation Conventions}.
@address@hidden address@hidden @gol
--- 650,655 ----
***************
*** 718,724 ****
C++ source code which should not be preprocessed.
@item @var{file}.m
! Objective-C source code. Note that you must link with the library
@file{libobjc.a} to make an Objective-C program work.
@item @var{file}.mi
--- 716,722 ----
C++ source code which should not be preprocessed.
@item @var{file}.m
! Objective-C source code. You must link with the library
@file{libobjc.a} to make an Objective-C program work.
@item @var{file}.mi
***************
*** 733,739 ****
@itemx @var{file}.cpp
@itemx @var{file}.c++
@itemx @var{file}.C
! C++ source code which must be preprocessed. Note that in @samp{.cxx},
the last two letters must both be literally @samp{x}. Likewise,
@samp{.C} refers to a literal capital address@hidden
--- 731,737 ----
@itemx @var{file}.cpp
@itemx @var{file}.c++
@itemx @var{file}.C
! C++ source code which must be preprocessed. In @samp{.cxx},
the last two letters must both be literally @samp{x}. Likewise,
@samp{.C} refers to a literal capital address@hidden
***************
*** 826,832 ****
If you only want some of the stages of compilation, you can use
@option{-x} (or filename suffixes) to tell @command{gcc} where to start, and
one of the options @option{-c}, @option{-S}, or @option{-E} to say where
! @command{gcc} is to stop. Note that some combinations (for example,
@samp{-x cpp-output -E}) instruct @command{gcc} to do nothing at all.
@table @gcctabopt
--- 824,830 ----
If you only want some of the stages of compilation, you can use
@option{-x} (or filename suffixes) to tell @command{gcc} where to start, and
one of the options @option{-c}, @option{-S}, or @option{-E} to say where
! @command{gcc} is to stop. Some combinations (for example,
@samp{-x cpp-output -E}) instruct @command{gcc} to do nothing at all.
@table @gcctabopt
***************
*** 908,914 ****
@item --target-help
@opindex target-help
! Print (on the standard output) a description of target specific command
line options for each tool.
@item --version
--- 906,912 ----
@item --target-help
@opindex target-help
! Emit to standard output a description of target-specific command
line options for each tool.
@item --version
***************
*** 1196,1202 ****
@opindex fsigned-char
Let the type @code{char} be signed, like @code{signed char}.
! Note that this is equivalent to @option{-fno-unsigned-char}, which is
the negative form of @option{-funsigned-char}. Likewise, the option
@option{-fno-signed-char} is equivalent to @option{-funsigned-char}.
--- 1194,1200 ----
@opindex fsigned-char
Let the type @code{char} be signed, like @code{signed char}.
! This is equivalent to @option{-fno-unsigned-char}, which is
the negative form of @option{-funsigned-char}. Likewise, the option
@option{-fno-signed-char} is equivalent to @option{-funsigned-char}.
***************
*** 1208,1216 ****
@opindex funsigned-bitfields
@opindex fno-signed-bitfields
@opindex fno-unsigned-bitfields
! These options control whether a bit-field is signed or unsigned, when the
declaration does not use either @code{signed} or @code{unsigned}. By
! default, such a bit-field is signed, because this is consistent: the
basic integer types such as @code{int} are signed types.
@item -fwritable-strings
--- 1206,1214 ----
@opindex funsigned-bitfields
@opindex fno-signed-bitfields
@opindex fno-unsigned-bitfields
! These options control whether a bit field is signed or unsigned, when the
declaration does not use either @code{signed} or @code{unsigned}. By
! default, such a bit field is signed, because this is consistent: the
basic integer types such as @code{int} are signed types.
@item -fwritable-strings
***************
*** 1419,1426 ****
Disable generation of information about every class with virtual
functions for use by the C++ runtime type identification features
(@samp{dynamic_cast} and @samp{typeid}). If you don't use those parts
! of the language, you can save some space by using this flag. Note that
! exception handling uses the same information, but it will generate it as
needed.
@item -fstats
--- 1417,1424 ----
Disable generation of information about every class with virtual
functions for use by the C++ runtime type identification features
(@samp{dynamic_cast} and @samp{typeid}). If you don't use those parts
! of the language, you can save some space by using this flag.
! Exception handling uses the same information, but it will generate it as
needed.
@item -fstats
***************
*** 1476,1482 ****
@item -fno-default-inline
@opindex fno-default-inline
Do not assume @samp{inline} for functions defined inside a class scope.
! @xref{Optimize Options,,Options That Control Optimization}. Note that these
functions will have linkage like inline functions; they just won't be
inlined by default.
--- 1474,1480 ----
@item -fno-default-inline
@opindex fno-default-inline
Do not assume @samp{inline} for functions defined inside a class scope.
! @xref{Optimize Options,,Options That Control Optimization}. These
functions will have linkage like inline functions; they just won't be
inlined by default.
***************
*** 1484,1490 ****
@opindex Wabi
Warn when G++ generates code that is probably not compatible with the
vendor-neutral C++ ABI. Although an effort has been made to warn about
! all such cases, there are probably some cases that are not warned about,
even though G++ is generating incompatible code. There may also be
cases where warnings are emitted even though the code that is generated
will be compatible.
--- 1482,1488 ----
@opindex Wabi
Warn when G++ generates code that is probably not compatible with the
vendor-neutral C++ ABI. Although an effort has been made to warn about
! all such cases, there are probably some cases that are not warned about,
even though G++ is generating incompatible code. There may also be
cases where warnings are emitted even though the code that is generated
will be compatible.
***************
*** 1498,1504 ****
@itemize @bullet
@item
! Incorrect handling of tail-padding for bit-fields. G++ may attempt to
pack data into the same byte as a base class. For example:
@smallexample
--- 1496,1502 ----
@itemize @bullet
@item
! Incorrect handling of tail-padding for bit fields. G++ may attempt to
pack data into the same byte as a base class. For example:
@smallexample
***************
*** 1508,1514 ****
@noindent
In this case, G++ will place @code{B::f2} into the same byte
! as @code{A::f1}; other compilers will not. You can avoid this problem
by explicitly padding @code{A} so that its size is a multiple of the
byte size on your platform; that will cause G++ and other compilers to
layout @code{B} identically.
--- 1506,1512 ----
@noindent
In this case, G++ will place @code{B::f2} into the same byte
! as @code{A::f1}; other compilers will not. You can avoid this problem
by explicitly padding @code{A} so that its size is a multiple of the
byte size on your platform; that will cause G++ and other compilers to
layout @code{B} identically.
***************
*** 1531,1538 ****
compilers to layout @code{C} identically.
@item
! Incorrect handling of bit-fields with declared widths greater than that
! of their underlying types, when the bit-fields appear in a union. For
example:
@smallexample
--- 1529,1536 ----
compilers to layout @code{C} identically.
@item
! Incorrect handling of bit fields with declared widths greater than that
! of their underlying types, when the bit fields appear in a union. For
example:
@smallexample
***************
*** 1545,1551 ****
@item
Empty classes can be placed at incorrect offsets. For example:
!
@smallexample
struct A @address@hidden;
--- 1543,1549 ----
@item
Empty classes can be placed at incorrect offsets. For example:
!
@smallexample
struct A @address@hidden;
***************
*** 1638,1644 ****
@end itemize
! Also warn about violations of the following style guidelines from
Scott Meyers' @cite{More Effective C++} book:
@itemize @bullet
--- 1636,1642 ----
@end itemize
! Also warn about violations of the following style guidelines from
Scott Meyers' @cite{More Effective C++} book:
@itemize @bullet
***************
*** 1819,1825 ****
@opindex Wundeclared-selector
Warn if a @code{@@selector(@dots{})} expression referring to an
undeclared selector is found. A selector is considered undeclared if no
! method with that name has been declared before the
@code{@@selector(@dots{})} expression, either explicitly in an
@code{@@interface} or @code{@@protocol} declaration, or implicitly in
an @code{@@implementation} section. This option always performs its
--- 1817,1823 ----
@opindex Wundeclared-selector
Warn if a @code{@@selector(@dots{})} expression referring to an
undeclared selector is found. A selector is considered undeclared if no
! method with that name has been declared before the
@code{@@selector(@dots{})} expression, either explicitly in an
@code{@@interface} or @code{@@protocol} declaration, or implicitly in
an @code{@@implementation} section. This option always performs its
***************
*** 1840,1846 ****
@cindex message formatting
Traditionally, diagnostic messages have been formatted irrespective of
! the output device's aspect (e.g.@: its width, @dots{}). The options
described
below can be used to control the diagnostic messages formatting
algorithm, e.g.@: how many characters per line, how often source location
information should be reported. Right now, only the C++ front end can
--- 1838,1844 ----
@cindex message formatting
Traditionally, diagnostic messages have been formatted irrespective of
! the output device's aspect (e.g.@, its width, @dots{}). The options
described
below can be used to control the diagnostic messages formatting
algorithm, e.g.@: how many characters per line, how often source location
information should be reported. Right now, only the C++ front end can
***************
*** 1992,2000 ****
@option{-Wformat} is included in @option{-Wall}. For more control over some
aspects of format checking, the options @option{-Wno-format-y2k},
! @option{-Wno-format-extra-args},
@option{-Wno-format-zero-length},
! @option{-Wformat-nonliteral},
@option{-Wformat-security}, and
@option{-Wformat=2} are available, but are not included in @option{-Wall}.
--- 1990,1998 ----
@option{-Wformat} is included in @option{-Wall}. For more control over some
aspects of format checking, the options @option{-Wno-format-y2k},
! @option{-Wno-format-extra-args},
@option{-Wno-format-zero-length},
! @option{-Wformat-nonliteral},
@option{-Wformat-security}, and
@option{-Wformat=2} are available, but are not included in @option{-Wall}.
***************
*** 2198,2204 ****
@item -Wswitch-default
@opindex Wswitch-switch
! Warn whenever a @code{switch} statement does not have a @code{default}
case.
@item -Wswitch-enum
--- 2196,2202 ----
@item -Wswitch-default
@opindex Wswitch-switch
! Warn whenever a @code{switch} statement has no @code{default}
case.
@item -Wswitch-enum
***************
*** 2270,2276 ****
is other than 1, 2, 4 or 8 bytes. Also, they do not occur for
structures, unions or arrays, even when they are in registers.
! Note that there may be no warning about a variable that is used only
to compute a value that itself is never used, because such
computations may be deleted by data flow analysis before the warnings
are printed.
--- 2268,2274 ----
is other than 1, 2, 4 or 8 bytes. Also, they do not occur for
structures, unions or arrays, even when they are in registers.
! There may be no warning about a variable that is used only
to compute a value that itself is never used, because such
computations may be deleted by data flow analysis before the warnings
are printed.
***************
*** 2459,2477 ****
that they usually do not indicate real problems and would only make the
compiler output harder to read. Using this command line option tells
GCC to emit warnings from system headers as if they occurred in user
! code. However, note that using @option{-Wall} in conjunction with this
! option will @emph{not} warn about unknown pragmas in system
headers---for that, @option{-Wunknown-pragmas} must also be used.
@item -Wfloat-equal
@opindex Wfloat-equal
Warn if floating point values are used in equality comparisons.
! The idea behind this is that sometimes it is convenient (for the
! programmer) to consider floating-point values as approximations to
! infinitely precise real numbers. If you are doing this, then you need
! to compute (by analyzing the code, or in some other way) the maximum or
! likely maximum error that the computation introduces, and allow for it
when performing comparisons (and when producing output, but that's a
different problem). In particular, instead of testing for equality, you
would check to see whether the two values have ranges that overlap; and
--- 2457,2475 ----
that they usually do not indicate real problems and would only make the
compiler output harder to read. Using this command line option tells
GCC to emit warnings from system headers as if they occurred in user
! code. Using @option{-Wall} in conjunction with this
! option, however, will @emph{not} warn about unknown pragmas in system
headers---for that, @option{-Wunknown-pragmas} must also be used.
@item -Wfloat-equal
@opindex Wfloat-equal
Warn if floating point values are used in equality comparisons.
! The idea behind this is that it is sometimes convenient for the
! programmer to consider floating-point values as approximations to
! infinitely precise real numbers. If you are doing this, then you must
! compute (by analyzing the code, or in some other way) the maximum or
! probable maximum error that the computation introduces, and allow for it
when performing comparisons (and when producing output, but that's a
different problem). In particular, instead of testing for equality, you
would check to see whether the two values have ranges that overlap; and
***************
*** 2510,2519 ****
@item
The @samp{U} integer constant suffix, or the @samp{F} or @samp{L}
floating point
constant suffixes. (Traditional C does support the @samp{L} suffix on
integer
! constants.) Note, these suffixes appear in macros defined in the system
! headers of most modern systems, e.g.@: the @samp{_MIN}/@samp{_MAX} macros
in @code{<limits.h>}.
! Use of these macros in user code might normally lead to spurious
! warnings, however gcc's integrated preprocessor has enough context to
avoid warning in these cases.
@item
--- 2508,2517 ----
@item
The @samp{U} integer constant suffix, or the @samp{F} or @samp{L}
floating point
constant suffixes. (Traditional C does support the @samp{L} suffix on
integer
! constants.) These suffixes appear in macros defined in the system
! headers of most modern systems, e.g.,@ the @samp{_MIN}/@samp{_MAX} macros
in @code{<limits.h>}.
! Although using these macros in user code might normally lead to spurious
! warnings, gcc's integrated preprocessor has enough context to
avoid warning in these cases.
@item
***************
*** 2674,2680 ****
@item -Wmissing-noreturn
@opindex Wmissing-noreturn
Warn about functions which might be candidates for attribute
@code{noreturn}.
! Note these are only possible candidates, not absolute ones. Care should
be taken to manually verify functions actually do not ever return before
adding the @code{noreturn} attribute, otherwise subtle code generation
bugs could be introduced. You will not get a warning for @code{main} in
--- 2672,2678 ----
@item -Wmissing-noreturn
@opindex Wmissing-noreturn
Warn about functions which might be candidates for attribute
@code{noreturn}.
! These are only possible candidates, not absolute ones. Care should
be taken to manually verify functions actually do not ever return before
adding the @code{noreturn} attribute, otherwise subtle code generation
bugs could be introduced. You will not get a warning for @code{main} in
***************
*** 2684,2690 ****
@opindex Wmissing-format-attribute
@opindex Wformat
If @option{-Wformat} is enabled, also warn about functions which might be
! candidates for @code{format} attributes. Note these are only possible
candidates, not absolute ones. GCC will guess that @code{format}
attributes might be appropriate for any function that calls a function
like @code{vprintf} or @code{vscanf}, but this might not always be the
--- 2682,2688 ----
@opindex Wmissing-format-attribute
@opindex Wformat
If @option{-Wformat} is enabled, also warn about functions which might be
! candidates for @code{format} attributes. These are only possible
candidates, not absolute ones. GCC will guess that @code{format}
attributes might be appropriate for any function that calls a function
like @code{vprintf} or @code{vscanf}, but this might not always be the
***************
*** 2916,2922 ****
present in the program. Some debuggers support macro expansion when
you use @option{-g3}.
! Note that in order to avoid confusion between DWARF1 debug level 2,
and DWARF2, neither @option{-gdwarf} nor @option{-gdwarf-2} accept
a concatenated debug level. Instead use an additional
@address@hidden
option to change the debug level for DWARF1 or DWARF2.
--- 2914,2920 ----
present in the program. Some debuggers support macro expansion when
you use @option{-g3}.
! In order to avoid confusion between DWARF1 debug level 2,
and DWARF2, neither @option{-gdwarf} nor @option{-gdwarf-2} accept
a concatenated debug level. Instead use an additional
@address@hidden
option to change the debug level for DWARF1 or DWARF2.
***************
*** 3369,3375 ****
time, without performing any optimizations that take a great deal of
compilation time.
! @option{-O} turns on the following optimization flags:
@gccoptlist{-fdefer-pop @gol
-fmerge-constants @gol
-fthread-jumps @gol
--- 3367,3373 ----
time, without performing any optimizations that take a great deal of
compilation time.
! @option{-O} turns on the following optimization flags:
@gccoptlist{-fdefer-pop @gol
-fmerge-constants @gol
-fthread-jumps @gol
***************
*** 3512,3518 ****
@opindex fno-inline
Don't pay attention to the @code{inline} keyword. Normally this option
is used to keep the compiler from expanding any functions inline.
! Note that if you are not optimizing, no functions can be expanded inline.
@item -finline-functions
@opindex finline-functions
--- 3510,3516 ----
@opindex fno-inline
Don't pay attention to the @code{inline} keyword. Normally this option
is used to keep the compiler from expanding any functions inline.
! If you are not optimizing, no functions can be expanded inline.
@item -finline-functions
@opindex finline-functions
***************
*** 3532,3538 ****
allows the control of this limit for functions that are explicitly marked as
inline (i.e., marked with the inline keyword or defined within the class
definition in c++). @var{n} is the size of functions that can be inlined in
! number of pseudo instructions (not counting parameter handling). The
default
value of @var{n} is 600.
Increasing this value can result in more inlined code at
the cost of compilation time and memory consumption. Decreasing usually
makes
--- 3530,3536 ----
allows the control of this limit for functions that are explicitly marked as
inline (i.e., marked with the inline keyword or defined within the class
definition in c++). @var{n} is the size of functions that can be inlined in
! number of pseudo-instructions (not counting parameter handling). The
default
value of @var{n} is 600.
Increasing this value can result in more inlined code at
the cost of compilation time and memory consumption. Decreasing usually
makes
***************
*** 3542,3548 ****
Inlining is actually controlled by a number of parameters, which may be
specified individually by using @option{--param @address@hidden
! The @address@hidden option sets some of these parameters
as follows:
@table @gcctabopt
--- 3540,3546 ----
Inlining is actually controlled by a number of parameters, which may be
specified individually by using @option{--param @address@hidden
! The @address@hidden option sets some of these parameters
as follows:
@table @gcctabopt
***************
*** 3562,3571 ****
for these parameters. See below for a documentation of the individual
parameters controlling inlining.
! @emph{Note:} pseudo instruction represents, in this particular context, an
! abstract measurement of function's size. In no way, it represents a count
! of assembly instructions and as such its exact meaning might change from one
! release to an another.
@item -fkeep-inline-functions
@opindex fkeep-inline-functions
--- 3560,3569 ----
for these parameters. See below for a documentation of the individual
parameters controlling inlining.
! The pseudo-instruction represents, in this particular context, an
! abstract measurement of the function's size. It does @emph{not}
! represent a specific count of assembly instructions, so its exact
! meaning may change from one release to an another.
@item -fkeep-inline-functions
@opindex fkeep-inline-functions
***************
*** 3580,3586 ****
on, even if the variables aren't referenced.
GCC enables this option by default. If you want to force the compiler to
! check if the variable was referenced, regardless of whether or not
optimization is turned on, use the @option{-fno-keep-static-consts} option.
@item -fmerge-constants
--- 3578,3584 ----
on, even if the variables aren't referenced.
GCC enables this option by default. If you want to force the compiler to
! check if the variable was referenced, regardless of whether
optimization is turned on, use the @option{-fno-keep-static-consts} option.
@item -fmerge-constants
***************
*** 3693,3700 ****
Perform a global common subexpression elimination pass.
This pass also performs global constant and copy propagation.
! @emph{Note:} When compiling a program using computed gotos, a GCC
! extension, you may get better runtime performance if you disable
the global common subexpression elimination pass by adding
@option{-fno-gcse} to the command line.
--- 3691,3698 ----
Perform a global common subexpression elimination pass.
This pass also performs global constant and copy propagation.
! When compiling a program using computed gotos, a GCC
! extension, you may get better execution performance if you disable
the global common subexpression elimination pass by adding
@option{-fno-gcse} to the command line.
***************
*** 3735,3743 ****
@item -fif-conversion
@opindex if-conversion
! Attempt to transform conditional jumps into branch-less equivalents. This
! include use of conditional moves, min, max, set flags and abs
instructions, and
! some tricks doable by standard arithmetics. The use of conditional
execution
on chips where it is available is controlled by @code{if-conversion2}.
Enabled at levels @option{-O}, @option{-O2}, @option{-O3}, @option{-Os}.
--- 3733,3742 ----
@item -fif-conversion
@opindex if-conversion
! Attempt to transform conditional jumps into branchless equivalents.
! These may
! include conditional moves, min, max, set flags and abs instructions, or
! other tricks available in standard arithmetics. The use of conditional
execution
on chips where it is available is controlled by @code{if-conversion2}.
Enabled at levels @option{-O}, @option{-O2}, @option{-O3}, @option{-Os}.
***************
*** 3778,3784 ****
register tying. This is especially helpful on machines with two-operand
instructions.
! Note @option{-fregmove} and @option{-foptimize-register-move} are the same
optimization.
Enabled at levels @option{-O2}, @option{-O3}, @option{-Os}.
--- 3777,3783 ----
register tying. This is especially helpful on machines with two-operand
instructions.
! @option{-fregmove} and @option{-foptimize-register-move} are the same
optimization.
Enabled at levels @option{-O2}, @option{-O3}, @option{-Os}.
***************
*** 3856,3862 ****
Forces all general-induction variables in loops to be
strength-reduced.
! @emph{Note:} When compiling programs written in Fortran,
@option{-fmove-all-movables} and @option{-freduce-all-givs} are enabled
by default when you use the optimizer.
--- 3855,3861 ----
Forces all general-induction variables in loops to be
strength-reduced.
! When compiling programs written in Fortran,
@option{-fmove-all-movables} and @option{-freduce-all-givs} are enabled
by default when you use the optimizer.
***************
*** 4157,4165 ****
@item -fsingle-precision-constant
@opindex fsingle-precision-constant
! Treat floating point constant as single precision constant instead of
! implicitly converting it to double precision constant.
!
@end table
--- 4156,4163 ----
@item -fsingle-precision-constant
@opindex fsingle-precision-constant
! Treat a floating point constant as a single-precision constant instead of
! implicitly converting it to a double-precision constant.
@end table
***************
*** 4181,4187 ****
structure of the generated code, so you must use the same source code
and the same optimization options for both compilations.
! With @option{-fbranch-probabilities}, GCC puts a
@samp{REG_BR_PROB} note on each @samp{JUMP_INSN} and @samp{CALL_INSN}.
These can be used to improve optimization. Currently, they are only
used in one place: in @file{reorg.c}, instead of guessing which path a
--- 4179,4185 ----
structure of the generated code, so you must use the same source code
and the same optimization options for both compilations.
! With @option{-fbranch-probabilities}, GCC puts a
@samp{REG_BR_PROB} note on each @samp{JUMP_INSN} and @samp{CALL_INSN}.
These can be used to improve optimization. Currently, they are only
used in one place: in @file{reorg.c}, instead of guessing which path a
***************
*** 4236,4242 ****
linkers with such optimizations. AIX may have these optimizations in
the future.
-
Only use these options when there are significant benefits from doing
so. When you specify these options, the assembler and linker will
create larger object and executable files and will also be slower.
--- 4234,4239 ----
***************
*** 4261,4267 ****
Perform aggressive dead-code elimination in SSA form. Requires
@option{-fssa}.
Like @option{-fssa}, this is an experimental feature.
-
@item --param @address@hidden
@opindex param
In some places, GCC uses various constants to control the amount of
--- 4258,4263 ----
***************
*** 4315,4321 ****
@item max-inline-insns-single
Several parameters control the tree inliner used in gcc.
This number sets the maximum number of instructions (counted in gcc's
! internal representation) in a single function that the tree inliner
will consider for inlining. This only affects functions declared
inline and methods implemented in a class declaration (C++).
The default value is 300.
--- 4311,4317 ----
@item max-inline-insns-single
Several parameters control the tree inliner used in gcc.
This number sets the maximum number of instructions (counted in gcc's
! internal representation) in a single function that the tree inliner
will consider for inlining. This only affects functions declared
inline and methods implemented in a class declaration (C++).
The default value is 300.
***************
*** 4329,4337 ****
The default value is 300.
@item max-inline-insns
! The tree inliner does decrease the allowable size for single functions
to be inlined after we already inlined the number of instructions
! given here by repeated inlining. This number should be a factor of
two or more larger than the single function limit.
Higher numbers result in better runtime performance, but incur higher
compile-time resource (CPU time, memory) requirements and result in
--- 4325,4333 ----
The default value is 300.
@item max-inline-insns
! The tree inliner does decrease the allowable size for single functions
to be inlined after we already inlined the number of instructions
! given here by repeated inlining. This number should be a factor of
two or more larger than the single function limit.
Higher numbers result in better runtime performance, but incur higher
compile-time resource (CPU time, memory) requirements and result in
***************
*** 4355,4365 ****
@item max-inline-insns-rtl
For languages that use the RTL inliner (this happens at a later stage
! than tree inlining), you can set the maximum allowable size (counted
in RTL instructions) for the RTL inliner with this parameter.
The default value is 600.
-
@item max-unrolled-insns
The maximum number of instructions that a loop should have if that loop
is unrolled, and if the loop is unrolled, it determines how many times
--- 4351,4360 ----
@item max-inline-insns-rtl
For languages that use the RTL inliner (this happens at a later stage
! than tree inlining), you can set the maximum allowable size (counted
in RTL instructions) for the RTL inliner with this parameter.
The default value is 600.
@item max-unrolled-insns
The maximum number of instructions that a loop should have if that loop
is unrolled, and if the loop is unrolled, it determines how many times
***************
*** 4515,4521 ****
@itemx -l @var{library}
@opindex l
Search the library named @var{library} when linking. (The second
! alternative, naming the library as a separate argument, is only
provided for POSIX compliance and is @emph{not} recommended.)
It makes a difference where in the command you write this option; the
--- 4510,4516 ----
@itemx -l @var{library}
@opindex l
Search the library named @var{library} when linking. (The second
! alternative, naming the library as a separate argument, is only
provided for POSIX compliance and is @emph{not} recommended.)
It makes a difference where in the command you write this option; the
***************
*** 4525,4534 ****
to functions in @samp{z}, those functions may not be loaded.
The linker searches a standard list of directories for the library.
! First, it looks for a shared library, unless @option{-static} is
! supplied. If it finds a shared library, whose name is architecture
dependent, it links the object file with the shared library.
! Failing to find a shared library, it resorts to looking for a static
version,
which is actually a file named @address@hidden The linker
then uses this file as if it had been specified precisely by name.
--- 4520,4529 ----
to functions in @samp{z}, those functions may not be loaded.
The linker searches a standard list of directories for the library.
! First, it looks for a shared library, unless @option{-static} is
! supplied. If it finds a shared library, whose name is architecture
dependent, it links the object file with the shared library.
! Failing to find a shared library, it resorts to looking for a static
version,
which is actually a file named @address@hidden The linker
then uses this file as if it had been specified precisely by name.
***************
*** 4905,4911 ****
@end table
GCC has the following spec strings built into it. Spec files can
! override these strings or create their own. Note that individual
targets can also add their own spec strings to this list.
@smallexample
--- 4900,4906 ----
@end table
GCC has the following spec strings built into it. Spec files can
! override these strings or create their own. Individual
targets can also add their own spec strings to this list.
@smallexample
***************
*** 4946,4952 ****
it is possible to generate quite complex command lines.
Here is a table of all defined @samp{%}-sequences for spec
! strings. Note that spaces are not generated automatically around the
results of expanding these sequences. Therefore you can concatenate them
together or combine them with constant text in a single argument.
--- 4941,4947 ----
it is possible to generate quite complex command lines.
Here is a table of all defined @samp{%}-sequences for spec
! strings. Spaces are not generated automatically around the
results of expanding these sequences. Therefore you can concatenate them
together or combine them with constant text in a single argument.
***************
*** 5026,5032 ****
be linked.
@item %O
! Substitutes the suffix for object files. Note that this is
handled specially when it immediately follows @samp{%g, %u, or %U},
because of the need for those to form complete file names. The
handling is such that @samp{%O} is treated exactly as if it had already
--- 5021,5027 ----
be linked.
@item %O
! Substitutes the suffix for object files. This is
handled specially when it immediately follows @samp{%g, %u, or %U},
because of the need for those to form complete file names. The
handling is such that @samp{%O} is treated exactly as if it had already
***************
*** 5152,5158 ****
@item %*
Substitute the variable part of a matched option. See below.
! Note that each comma in the substituted string is replaced by
a single space.
@item %:@var{function}(@var{args})
--- 5147,5153 ----
@item %*
Substitute the variable part of a matched option. See below.
! Each comma in the substituted string is replaced by
a single space.
@item %:@var{function}(@var{args})
***************
*** 5183,5199 ****
This way, @code{if-exists-else} can be used to select one file or another,
based on the existence of the first. Here is a small example of its usage:
! @smallexample
*startfile:
crt0%O%s %:if-exists(crti%O%s) \
%:if-exists-else(crtbeginT%O%s crtbegin%O%s)
@end smallexample
! @end table
@item address@hidden@address@hidden
Substitutes the @code{-S} switch, if that switch was given to address@hidden
! If that switch was not specified, this substitutes nothing. Note that
! the leading dash is omitted when specifying this option, and it is
automatically inserted if the substitution is performed. Thus the spec
string @address@hidden@}} would match the command-line option @option{-foo}
and would output the command line option @option{-foo}.
--- 5178,5194 ----
This way, @code{if-exists-else} can be used to select one file or another,
based on the existence of the first. Here is a small example of its usage:
! @smallexample
*startfile:
crt0%O%s %:if-exists(crti%O%s) \
%:if-exists-else(crtbeginT%O%s crtbegin%O%s)
@end smallexample
! @end table
@item address@hidden@address@hidden
Substitutes the @code{-S} switch, if that switch was given to address@hidden
! If that switch was not specified, this substitutes nothing.
! The leading dash is omitted when specifying this option, and it is
automatically inserted if the substitution is performed. Thus the spec
string @address@hidden@}} would match the command-line option @option{-foo}
and would output the command line option @option{-foo}.
***************
*** 5221,5234 ****
wild card is optional. Useful for CPP as @address@hidden&U*&address@hidden
@item address@hidden<@address@hidden
! Remove all occurrences of @code{-S} from the command line. Note---this
! command is position dependent. @samp{%} commands in the spec string
before this option will see @code{-S}, @samp{%} commands in the spec
string after this option will not.
@item address@hidden@code{S}*:@address@hidden
Substitutes @var{x} if one or more switches whose names start with
! @code{-S} are specified to address@hidden Note that the tail part of the
@code{-S} option (i.e.@: the part matched by the @samp{*}) will be
substituted
for each occurrence of @samp{%*} within @var{x}.
--- 5216,5229 ----
wild card is optional. Useful for CPP as @address@hidden&U*&address@hidden
@item address@hidden<@address@hidden
! Remove all occurrences of @code{-S} from the command line. This
! command is position-dependent. @samp{%} commands in the spec string
before this option will see @code{-S}, @samp{%} commands in the spec
string after this option will not.
@item address@hidden@code{S}*:@address@hidden
Substitutes @var{x} if one or more switches whose names start with
! @code{-S} are specified to address@hidden The tail part of the
@code{-S} option (i.e.@: the part matched by the @samp{*}) will be
substituted
for each occurrence of @samp{%*} within @var{x}.
***************
*** 5382,5389 ****
* i386 and x86-64 Options::
* HPPA Options::
* Intel 960 Options::
! * DEC Alpha Options::
! * DEC Alpha/VMS Options::
* H8/300 Options::
* SH Options::
* System V Options::
--- 5377,5384 ----
* i386 and x86-64 Options::
* HPPA Options::
* Intel 960 Options::
! * HP Alpha Options::
! * HP Alpha/VMS Options::
* H8/300 Options::
* SH Options::
* System V Options::
***************
*** 5477,5483 ****
Use this option for microcontroller with a 5200 core, including
the MCF5202, MCF5203, MCF5204 and MCF5202.
-
@item -m68020-40
@opindex m68020-40
Generate output for a 68040, without using any of the new instructions.
--- 5472,5477 ----
***************
*** 5534,5546 ****
used on Unix, so you cannot use it if you need to call libraries
compiled with the Unix compiler.
! If you set this option, you must provide function prototypes for
! all functions that take variable numbers of arguments (such as
@code{printf}); otherwise those functions will not be called
correctly.
In addition, seriously incorrect code will result if you call a
! function with too many arguments. This is unlike the normal
convention, where extra arguments are harmlessly ignored.
The @code{rtd} instruction is supported by the 68010, 68020, 68030,
--- 5528,5540 ----
used on Unix, so you cannot use it if you need to call libraries
compiled with the Unix compiler.
! If you set this option, you must provide function prototypes for
! all functions that take variable numbers of arguments (such as
@code{printf}); otherwise those functions will not be called
correctly.
In addition, seriously incorrect code will result if you call a
! function with too many arguments. This is unlike the normal
convention, where extra arguments are harmlessly ignored.
The @code{rtd} instruction is supported by the 68010, 68020, 68030,
***************
*** 5572,5578 ****
@itemx -mstrict-align
@opindex mno-strict-align
@opindex mstrict-align
! Control whether GCC will use strict memory alignment.
@option{-mno-strict-align} assumes that unaligned memory references will be
handled by the system. @option{-mstrict-align} may be required if
the system cannot handle arbitrary memory references.
--- 5566,5572 ----
@itemx -mstrict-align
@opindex mno-strict-align
@opindex mstrict-align
! Control whether GCC will use strict memory alignment.
@option{-mno-strict-align} assumes that unaligned memory references will be
handled by the system. @option{-mstrict-align} may be required if
the system cannot handle arbitrary memory references.
***************
*** 5607,5613 ****
@itemx -m68hcs12
@opindex m68S12
@opindex m68hcs12
! Generate output for a 68HCS12.
@item -mauto-incdec
@opindex mauto-incdec
--- 5601,5607 ----
@itemx -m68hcs12
@opindex m68S12
@opindex m68hcs12
! Generate output for a 68HCS12.
@item -mauto-incdec
@opindex mauto-incdec
***************
*** 5618,5624 ****
@itemx -nominmax
@opindex minmax
@opindex mnominmax
! Enable (@option{-minmax}) or prevent (@option{-nominmax}) the use of 68HC12
min and max instructions.
@item -mlong-calls
--- 5612,5618 ----
@itemx -nominmax
@opindex minmax
@opindex mnominmax
! Enable (@option{-minmax}) or prevent (@option{-nominmax}) the use of 68HC12
min and max instructions.
@item -mlong-calls
***************
*** 5626,5632 ****
@opindex mlong-calls
@opindex mno-long-calls
Treat all calls as being far away (@option{-mlong-calls}) or generate mixed
! calls as the situation warrants (@option{-mno-long-calls}).
If calls are assumed to be
far away, the compiler will use the @code{call} instruction to
call a function and the @code{rtc} instruction for returning.
--- 5620,5626 ----
@opindex mlong-calls
@opindex mno-long-calls
Treat all calls as being far away (@option{-mlong-calls}) or generate mixed
! calls as the situation warrants (@option{-mno-long-calls}).
If calls are assumed to be
far away, the compiler will use the @code{call} instruction to
call a function and the @code{rtc} instruction for returning.
***************
*** 5745,5755 ****
@itemx -munaligned-doubles
@opindex mno-unaligned-doubles
@opindex munaligned-doubles
! Assume that doubles have 8 byte alignment. This is the default.
! With @option{-munaligned-doubles}, GCC assumes that doubles have 8 byte
alignment only if they are contained in another type, or if they have an
! absolute address. Otherwise, it assumes they have 4 byte alignment.
Specifying this option avoids some rare compatibility problems with code
generated by other compilers. It is not the default because it results
in a performance loss, especially for floating point code.
--- 5739,5749 ----
@itemx -munaligned-doubles
@opindex mno-unaligned-doubles
@opindex munaligned-doubles
! Assume that doubles have 8-byte alignment. This is the default.
! With @option{-munaligned-doubles}, GCC assumes that doubles have 8-byte
alignment only if they are contained in another type, or if they have an
! absolute address. Otherwise, it assumes they have 4-byte alignment.
Specifying this option avoids some rare compatibility problems with code
generated by other compilers. It is not the default because it results
in a performance loss, especially for floating point code.
***************
*** 5759,5765 ****
@opindex mno-faster-structs
@opindex mfaster-structs
With @option{-mfaster-structs}, the compiler assumes that structures
! should have 8 byte alignment. This enables the use of pairs of
@code{ldd} and @code{std} instructions for copies in structure
assignment, in place of twice as many @code{ld} and @code{st} pairs.
However, the use of this changed alignment directly violates the SPARC
--- 5753,5759 ----
@opindex mno-faster-structs
@opindex mfaster-structs
With @option{-mfaster-structs}, the compiler assumes that structures
! should have 8-byte alignment. This enables the use of pairs of
@code{ldd} and @code{std} instructions for copies in structure
assignment, in place of twice as many @code{ld} and @code{st} pairs.
However, the use of this changed alignment directly violates the SPARC
***************
*** 5988,5994 ****
@c not currently implemented
@item -mapcs-reentrant
@opindex mapcs-reentrant
! Generate reentrant, position independent code. The default is
@option{-mno-apcs-reentrant}.
@end ignore
--- 5982,5988 ----
@c not currently implemented
@item -mapcs-reentrant
@opindex mapcs-reentrant
! Generate reentrant, position-independent code. The default is
@option{-mno-apcs-reentrant}.
@end ignore
***************
*** 6044,6053 ****
@opindex mwords-little-endian
This option only applies when generating code for big-endian processors.
Generate code for a little-endian word order but a big-endian byte
! order. That is, a byte order of the form @samp{32107654}. Note: this
! option should only be used if you require compatibility with code for
! big-endian ARM processors generated by versions of the compiler prior to
! 2.8.
@item -malignment-traps
@opindex malignment-traps
--- 6038,6046 ----
@opindex mwords-little-endian
This option only applies when generating code for big-endian processors.
Generate code for a little-endian word order but a big-endian byte
! order. That is, a byte order of the form @samp{32107654}. Use this
! option only if you require compatibility with code for big-endian ARM
! processors generated by versions of the compiler prior to 2.8.
@item -malignment-traps
@opindex malignment-traps
***************
*** 6073,6079 ****
does not have half-word memory operations (i.e.@: implementations prior to
ARMv4).
! Note that you cannot use this option to access unaligned word objects,
since the processor will only fetch one 32-bit aligned object from
memory.
--- 6066,6072 ----
does not have half-word memory operations (i.e.@: implementations prior to
ARMv4).
! You cannot use this option to access unaligned word objects,
since the processor will only fetch one 32-bit aligned object from
memory.
***************
*** 6176,6182 ****
This feature is not enabled by default. Specifying
@option{-mno-long-calls} will restore the default behavior, as will
placing the function calls within the scope of a @samp{#pragma
! long_calls_off} directive. Note these switches have no effect on how
the compiler generates code to handle function calls via function
pointers.
--- 6169,6175 ----
This feature is not enabled by default. Specifying
@option{-mno-long-calls} will restore the default behavior, as will
placing the function calls within the scope of a @samp{#pragma
! long_calls_off} directive. These switches have no effect on how
the compiler generates code to handle function calls via function
pointers.
***************
*** 6279,6285 ****
@itemx -mno-mult-bug
@opindex mmult-bug
@opindex mno-mult-bug
! Generate (@option{-mmult-bug}) or do not generate (@option{-mno-mult-bug})
code to avoid bugs in the multiply instructions for the MN10300
processors. @option{-mmult-bug} is the default.
--- 6272,6278 ----
@itemx -mno-mult-bug
@opindex mmult-bug
@opindex mno-mult-bug
! Do (do not) generate
code to avoid bugs in the multiply instructions for the MN10300
processors. @option{-mmult-bug} is the default.
***************
*** 6287,6293 ****
@itemx -mam33
@opindex mno-am33
@opindex mam33
! Generate (@option{-mam33}) or do not generate (@option{-mno-am33}) code
which uses features specific to the AM33 processor. @option{-mno-am33} is
the default.
--- 6280,6286 ----
@itemx -mam33
@opindex mno-am33
@opindex mam33
! Do not (do) generate code
which uses features specific to the AM33 processor. @option{-mno-am33} is
the default.
***************
*** 6304,6310 ****
This option makes symbolic debugging impossible.
@end table
-
@node M32R/D Options
@subsection M32R/D Options
@cindex M32R/D options
--- 6297,6302 ----
***************
*** 6597,6603 ****
@option{-muse-div-instruction} is ignored, and the div instruction is used
for signed integer division.
! Note that the result of dividing @code{INT_MIN} by @minus{}1 is
undefined. In
particular, the behavior of such a division with and without
@option{-muse-div-instruction} may differ.
--- 6589,6595 ----
@option{-muse-div-instruction} is ignored, and the div instruction is used
for signed integer division.
! The result of dividing @code{INT_MIN} by @minus{}1 is undefined. In
particular, the behavior of such a division with and without
@option{-muse-div-instruction} may differ.
***************
*** 6898,6909 ****
@opindex mmultiple
@opindex mno-multiple
Generate code that uses (does not use) the load multiple word
! instructions and the store multiple word instructions. These
! instructions are generated by default on POWER systems, and not
! generated on PowerPC systems. Do not use @option{-mmultiple} on little
! endian PowerPC systems, since those instructions do not work when the
! processor is in little endian mode. The exceptions are PPC740 and
! PPC750 which permit the instructions usage in little endian mode.
@item -mstring
@itemx -mno-string
--- 6890,6901 ----
@opindex mmultiple
@opindex mno-multiple
Generate code that uses (does not use) the load multiple word
! instructions and the store multiple word instructions generated
! by default on POWER systems but not
! on PowerPC systems. Do not use @option{-mmultiple} on little-endian
! PowerPC systems, since those instructions do not work when the
! processor is in little-endian mode. The exceptions are PPC740 and
! PPC750, which permit the instructions to be used in little-endian mode.
@item -mstring
@itemx -mno-string
***************
*** 6912,6922 ****
Generate code that uses (does not use) the load string instructions
and the store string word instructions to save multiple registers and
do small block moves. These instructions are generated by default on
! POWER systems, and not generated on PowerPC systems. Do not use
! @option{-mstring} on little endian PowerPC systems, since those
! instructions do not work when the processor is in little endian mode.
! The exceptions are PPC740 and PPC750 which permit the instructions
! usage in little endian mode.
@item -mupdate
@itemx -mno-update
--- 6904,6914 ----
Generate code that uses (does not use) the load string instructions
and the store string word instructions to save multiple registers and
do small block moves. These instructions are generated by default on
! POWER systems but not on PowerPC systems. Do not use
! @option{-mstring} on little-endian PowerPC systems, since those
! instructions do not work when the processor is in little-endian mode.
! The exceptions are PPC740 and PPC750, which permit the instructions
! to be used in little-endian mode.
@item -mupdate
@itemx -mno-update
***************
*** 6924,6933 ****
@opindex mno-update
Generate code that uses (does not use) the load or store instructions
that update the base register to the address of the calculated memory
! location. These instructions are generated by default. If you use
! @option{-mno-update}, there is a small window between the time that the
! stack pointer is updated and the address of the previous frame is
! stored, which means code that walks the stack frame across interrupts or
signals may get corrupted data.
@item -mfused-madd
--- 6916,6925 ----
@opindex mno-update
Generate code that uses (does not use) the load or store instructions
that update the base register to the address of the calculated memory
! location. These instructions are generated by default. With
! @option{-mno-update}, there is a small window between when the
! stack pointer is updated and when the address of the previous frame is
! stored, which means that code that walks the stack frame across
interrupts or
signals may get corrupted data.
@item -mfused-madd
***************
*** 6935,6955 ****
@opindex mfused-madd
@opindex mno-fused-madd
Generate code that uses (does not use) the floating point multiply and
! accumulate instructions. These instructions are generated by default if
! hardware floating is used.
@item -mno-bit-align
@itemx -mbit-align
@opindex mno-bit-align
@opindex mbit-align
On System V.4 and embedded PowerPC systems do not (do) force structures
! and unions that contain bit-fields to be aligned to the base type of the
! bit-field.
For example, by default a structure containing nothing but 8
! @code{unsigned} bit-fields of length 1 would be aligned to a 4 byte
boundary and have a size of 4 bytes. By using @option{-mno-bit-align},
! the structure would be aligned to a 1 byte boundary and be one byte in
size.
@item -mno-strict-align
--- 6927,6947 ----
@opindex mfused-madd
@opindex mno-fused-madd
Generate code that uses (does not use) the floating point multiply and
! accumulate instructions. These instructions are generated by default for
! hardware floating point.
@item -mno-bit-align
@itemx -mbit-align
@opindex mno-bit-align
@opindex mbit-align
On System V.4 and embedded PowerPC systems do not (do) force structures
! and unions that contain bit fields to be aligned to the base type of the
! bit field.
For example, by default a structure containing nothing but 8
! @code{unsigned} bit fields of length 1 would be aligned to a 4-byte
boundary and have a size of 4 bytes. By using @option{-mno-bit-align},
! the structure would be aligned to a 1-byte boundary and be one byte in
size.
@item -mno-strict-align
***************
*** 6957,6963 ****
@opindex mno-strict-align
@opindex mstrict-align
On System V.4 and embedded PowerPC systems do not (do) assume that
! unaligned memory references will be handled by the system.
@item -mrelocatable
@itemx -mno-relocatable
--- 6949,6955 ----
@opindex mno-strict-align
@opindex mstrict-align
On System V.4 and embedded PowerPC systems do not (do) assume that
! the system handles unaligned memory references.
@item -mrelocatable
@itemx -mno-relocatable
***************
*** 6991,6997 ****
@opindex mlittle
@opindex mlittle-endian
On System V.4 and embedded PowerPC systems compile code for the
! processor in little endian mode. The @option{-mlittle-endian} option is
the same as @option{-mlittle}.
@item -mbig
--- 6983,6989 ----
@opindex mlittle
@opindex mlittle-endian
On System V.4 and embedded PowerPC systems compile code for the
! processor in little-endian mode. The @option{-mlittle-endian} option is
the same as @option{-mlittle}.
@item -mbig
***************
*** 6999,7011 ****
@opindex mbig
@opindex mbig-endian
On System V.4 and embedded PowerPC systems compile code for the
! processor in big endian mode. The @option{-mbig-endian} option is
the same as @option{-mbig}.
@item -mcall-sysv
@opindex mcall-sysv
On System V.4 and embedded PowerPC systems compile code using calling
! conventions that adheres to the March 1995 draft of the System V
Application Binary Interface, PowerPC processor supplement. This is the
default unless you configured GCC using @samp{powerpc-*-eabiaix}.
--- 6991,7003 ----
@opindex mbig
@opindex mbig-endian
On System V.4 and embedded PowerPC systems compile code for the
! processor in big-endian mode. The @option{-mbig-endian} option is
the same as @option{-mbig}.
@item -mcall-sysv
@opindex mcall-sysv
On System V.4 and embedded PowerPC systems compile code using calling
! conventions that adhere to the March 1995 draft of the System V
Application Binary Interface, PowerPC processor supplement. This is the
default unless you configured GCC using @samp{powerpc-*-eabiaix}.
***************
*** 7055,7061 ****
@item -mabi=altivec
@opindex mabi=altivec
Extend the current ABI with AltiVec ABI extensions. This does not
! change the default ABI, instead it adds the AltiVec ABI extensions to
the current address@hidden
@item -mabi=no-altivec
--- 7047,7053 ----
@item -mabi=altivec
@opindex mabi=altivec
Extend the current ABI with AltiVec ABI extensions. This does not
! change the default ABI; instead it adds the AltiVec ABI extensions to
the current address@hidden
@item -mabi=no-altivec
***************
*** 7067,7074 ****
@opindex mprototype
@opindex mno-prototype
On System V.4 and embedded PowerPC systems assume that all calls to
! variable argument functions are properly prototyped. Otherwise, the
! compiler must insert an instruction before every non prototyped call to
set or clear bit 6 of the condition code register (@var{CR}) to
indicate whether floating point values were passed in the floating point
registers in case the function takes a variable arguments. With
--- 7059,7066 ----
@opindex mprototype
@opindex mno-prototype
On System V.4 and embedded PowerPC systems assume that all calls to
! variable argument functions are properly prototyped. Otherwise the
! compiler must insert an instruction before every non-prototyped call to
set or clear bit 6 of the condition code register (@var{CR}) to
indicate whether floating point values were passed in the floating point
registers in case the function takes a variable arguments. With
***************
*** 7121,7131 ****
On System V.4 and embedded PowerPC systems do (do not) adhere to the
Embedded Applications Binary Interface (eabi) which is a set of
modifications to the System V.4 specifications. Selecting @option{-meabi}
! means that the stack is aligned to an 8 byte boundary, a function
@code{__eabi} is called to from @code{main} to set up the eabi
environment, and the @option{-msdata} option can use both @code{r2} and
@code{r13} to point to two separate small data areas. Selecting
! @option{-mno-eabi} means that the stack is aligned to a 16 byte boundary,
do not call an initialization function from @code{main}, and the
@option{-msdata} option will only use @code{r13} to point to a single
small data area. The @option{-meabi} option is on by default if you
--- 7113,7123 ----
On System V.4 and embedded PowerPC systems do (do not) adhere to the
Embedded Applications Binary Interface (eabi) which is a set of
modifications to the System V.4 specifications. Selecting @option{-meabi}
! means that the stack is aligned to an 8-byte boundary, a function
@code{__eabi} is called to from @code{main} to set up the eabi
environment, and the @option{-msdata} option can use both @code{r2} and
@code{r13} to point to two separate small data areas. Selecting
! @option{-mno-eabi} means that the stack is aligned to a 16-byte boundary,
do not call an initialization function from @code{main}, and the
@option{-msdata} option will only use @code{r13} to point to a single
small data area. The @option{-meabi} option is on by default if you
***************
*** 7136,7149 ****
@opindex msdata
@option{-msdata} is a synonym for @option{-msdata=default}.
! Specify where GCC should be small initalized global and static data.
! @var{area} may be one of the following values:
@table @gcctabopt
@item default
@opindex msdata=default
On System V.4 and embedded PowerPC systems, if @option{-meabi} is used,
! compile code the same as @option{-msdata=eabi}, otherwise compile code the
same as @option{-msdata=sysv}.
@item eabi
--- 7128,7141 ----
@opindex msdata
@option{-msdata} is a synonym for @option{-msdata=default}.
! Specify where GCC should put small initialized global and static data.
! @var{area} may be one of these values:
@table @gcctabopt
@item default
@opindex msdata=default
On System V.4 and embedded PowerPC systems, if @option{-meabi} is used,
! compile code the same as @option{-msdata=eabi}, and otherwise compile
code the
same as @option{-msdata=sysv}.
@item eabi
***************
*** 7172,7179 ****
On System V.4 and embedded PowerPC systems, put small global and static
data in the @samp{.sdata} section. Put small uninitialized global and
static data in the @samp{.sbss} section. Do not use register @code{r13}
! to address small data however. This is the default behavior unless
! other @option{-msdata} options are used.
@item none
@opindex msdata=none
--- 7164,7171 ----
On System V.4 and embedded PowerPC systems, put small global and static
data in the @samp{.sdata} section. Put small uninitialized global and
static data in the @samp{.sbss} section. Do not use register @code{r13}
! to address small data, however. Without other @option{-msdata} options,
! this is the default behavior.
@item none
@opindex msdata=none
***************
*** 7190,7197 ****
@opindex G
@cindex smaller data references (PowerPC)
@cindex .sdata/.sdata2 references (PowerPC)
! On embedded PowerPC systems, put global and static items less than or
! equal to @var{num} bytes into the small data or bss sections instead of
the normal data or bss section. By default, @var{num} is 8. The
@option{-G @var{num}} switch is also passed to the linker.
All modules should be compiled with the same @option{-G @var{num}} value.
--- 7182,7189 ----
@opindex G
@cindex smaller data references (PowerPC)
@cindex .sdata/.sdata2 references (PowerPC)
! On embedded PowerPC systems, put global and static items up
! to @var{num} bytes into the small data or bss sections instead of
the normal data or bss section. By default, @var{num} is 8. The
@option{-G @var{num}} switch is also passed to the linker.
All modules should be compiled with the same @option{-G @var{num}} value.
***************
*** 7212,7218 ****
current location can be called. This setting can be overridden by the
@code{shortcall} function attribute, or by @code{#pragma longcall(0)}.
! Some linkers are capable of detecting out-of-range calls and generating
glue code on the fly. On these systems, long calls are unnecessary and
generate slower code. As of this writing, the AIX linker can do this,
as can the GNU linker for PowerPC/64. It is planned to add this feature
--- 7204,7210 ----
current location can be called. This setting can be overridden by the
@code{shortcall} function attribute, or by @code{#pragma longcall(0)}.
! Some linkers can detect out-of-range calls and generate
glue code on the fly. On these systems, long calls are unnecessary and
generate slower code. As of this writing, the AIX linker can do this,
as can the GNU linker for PowerPC/64. It is planned to add this feature
***************
*** 7233,7257 ****
@cindex Darwin options
These options are defined for all architectures running the Darwin operating
! system. These are useful for compatibility with other Mac OS compilers.
@table @gcctabopt
! @item -all_load
! @opindex all_load
Loads all members of static archive libraries.
See man ld(1) for more information.
@item -arch_errors_fatal
@opindex arch_errors_fatal
! Cause the errors having to do with files that have the wrong architecture
! to be fatal.
@item -bind_at_load
@opindex bind_at_load
Causes the output file to be marked such that the dynamic linker will
bind all undefined references when the file is loaded or launched.
! @item -bundle
@opindex bundle
Produce a Mach-o bundle format file.
See man ld(1) for more information.
--- 7225,7249 ----
@cindex Darwin options
These options are defined for all architectures running the Darwin operating
! system. They are useful for compatibility with other Mac OS compilers.
@table @gcctabopt
! @item -all_load
! @opindex all_load
Loads all members of static archive libraries.
See man ld(1) for more information.
@item -arch_errors_fatal
@opindex arch_errors_fatal
! Cause to be fatal the errors related to files that have the
! wrong architecture.
@item -bind_at_load
@opindex bind_at_load
Causes the output file to be marked such that the dynamic linker will
bind all undefined references when the file is loaded or launched.
! @item -bundle
@opindex bundle
Produce a Mach-o bundle format file.
See man ld(1) for more information.
***************
*** 7262,7275 ****
output file being linked. See man ld(1) for more information.
@end table
! The following options are available for the Darwin linker. The Darwin
linker
man page, ld(1), describes them in detail.
@gccoptlist{-allowable_client @var{client_name} -arch_only @gol
-client_name -compatibility_version -current_version @gol
-dependency-file -dylib_file -dylinker_install_name @gol
-dynamic -dynamiclib -exported_symbols_list -filelist @gol
! -flat_namespace -force_cpusubtype_ALL -force_flat_namespace @gol
-headerpad_max_install_names -image_base -init -install_name @gol
-keep_private_externs -multi_module -multiply_defined @gol
-multiply_defined_unused -noall_load -nomultidefs @gol
--- 7254,7267 ----
output file being linked. See man ld(1) for more information.
@end table
! The following options are available for the Darwin linker. The Darwin linker
man page, ld(1), describes them in detail.
@gccoptlist{-allowable_client @var{client_name} -arch_only @gol
-client_name -compatibility_version -current_version @gol
-dependency-file -dylib_file -dylinker_install_name @gol
-dynamic -dynamiclib -exported_symbols_list -filelist @gol
! -flat_namespace -force_cpusubtype_ALL -force_flat_namespace @gol
-headerpad_max_install_names -image_base -init -install_name @gol
-keep_private_externs -multi_module -multiply_defined @gol
-multiply_defined_unused -noall_load -nomultidefs @gol
***************
*** 7283,7289 ****
-weak_reference_mismatches -whatsloaded -whyload}
@opindex allowable_client
! @opindex arch_only
@opindex client_name
@opindex compatibility_version
@opindex current_version
--- 7275,7281 ----
-weak_reference_mismatches -whatsloaded -whyload}
@opindex allowable_client
! @opindex arch_only
@opindex client_name
@opindex compatibility_version
@opindex current_version
***************
*** 7293,7324 ****
@opindex dynamic
@opindex dynamiclib
@opindex exported_symbols_list
! @opindex filelist
! @opindex flat_namespace
@opindex force_cpusubtype_ALL
@opindex force_flat_namespace
@opindex headerpad_max_install_names
@opindex image_base
! @opindex init
@opindex install_name
@opindex keep_private_externs
! @opindex multi_module
@opindex multiply_defined
! @opindex multiply_defined_unused
! @opindex noall_load
! @opindex nomultidefs
@opindex noprebind
! @opindex noseglinkedit
@opindex pagezero_size
@opindex prebind
@opindex prebind_all_twolevel_modules
! @opindex private_bundle
@opindex read_only_relocs
! @opindex sectalign
! @opindex sectobjectsymbols
! @opindex sectcreate
! @opindex sectobjectsymbols
! @opindex sectorder
@opindex seg1addr
@opindex seg_addr_table
@opindex seg_addr_table_filename
--- 7285,7316 ----
@opindex dynamic
@opindex dynamiclib
@opindex exported_symbols_list
! @opindex filelist
! @opindex flat_namespace
@opindex force_cpusubtype_ALL
@opindex force_flat_namespace
@opindex headerpad_max_install_names
@opindex image_base
! @opindex init
@opindex install_name
@opindex keep_private_externs
! @opindex multi_module
@opindex multiply_defined
! @opindex multiply_defined_unused
! @opindex noall_load
! @opindex nomultidefs
@opindex noprebind
! @opindex noseglinkedit
@opindex pagezero_size
@opindex prebind
@opindex prebind_all_twolevel_modules
! @opindex private_bundle
@opindex read_only_relocs
! @opindex sectalign
! @opindex sectobjectsymbols
! @opindex sectcreate
! @opindex sectobjectsymbols
! @opindex sectorder
@opindex seg1addr
@opindex seg_addr_table
@opindex seg_addr_table_filename
***************
*** 7336,7342 ****
@opindex unexported_symbols_list
@opindex weak_reference_mismatches
@opindex whatsloaded
! @opindex whyload
@node RT Options
@subsection IBM RT Options
--- 7328,7334 ----
@opindex unexported_symbols_list
@opindex weak_reference_mismatches
@opindex whatsloaded
! @opindex whyload
@node RT Options
@subsection IBM RT Options
***************
*** 7358,7369 ****
@item -mfull-fp-blocks
@opindex mfull-fp-blocks
Generate full-size floating point data blocks, including the minimum
! amount of scratch space recommended by address@hidden This is the default.
@item -mminimum-fp-blocks
@opindex mminimum-fp-blocks
! Do not include extra scratch space in floating point data blocks. This
! results in smaller code, but slower execution, since scratch space must
be allocated dynamically.
@cindex @file{stdarg.h} and RT PC
--- 7350,7361 ----
@item -mfull-fp-blocks
@opindex mfull-fp-blocks
Generate full-size floating point data blocks, including the minimum
! amount of scratch space IBM recommends. This is the default.
@item -mminimum-fp-blocks
@opindex mminimum-fp-blocks
! Include no extra scratch space in floating point data blocks. This
! results in smaller code but slower execution, since scratch space must
be allocated dynamically.
@cindex @file{stdarg.h} and RT PC
***************
*** 7371,7377 ****
@opindex mfp-arg-in-fpregs
Use a calling sequence incompatible with the IBM calling convention in
which floating point arguments are passed in floating point registers.
! Note that @code{stdarg.h} will not work with floating point operands
if this option is specified.
@item -mfp-arg-in-gregs
--- 7363,7369 ----
@opindex mfp-arg-in-fpregs
Use a calling sequence incompatible with the IBM calling convention in
which floating point arguments are passed in floating point registers.
! @Code{stdarg.h} will not work with floating point operands
if this option is specified.
@item -mfp-arg-in-gregs
***************
*** 7405,7413 ****
@item address@hidden
@opindex march
Generate code that will run on @var{arch}, which can be the name of a
! generic MIPS ISA, or the name of a particular processor. The ISA names
! are: @samp{mips1}, @samp{mips2}, @samp{mips3}, @samp{mips4}, @samp{mips32}
! and @samp{mips64}. The processor names are: @samp{r2000},
@samp{r3000}, @samp{r3900}, @samp{r4000}, @samp{vr4100}, @samp{vr4300},
@samp{r4400}, @samp{r4600}, @samp{r4650}, @samp{vr5000}, @samp{r6000},
@samp{r8000}, @samp{4kc}, @samp{4kp}, @samp{5kc}, @samp{20kc},
--- 7397,7405 ----
@item address@hidden
@opindex march
Generate code that will run on @var{arch}, which can be the name of a
! generic MIPS ISA or the name of a particular processor. The ISA names
! are @samp{mips1}, @samp{mips2}, @samp{mips3}, @samp{mips4}, @samp{mips32}
! and @samp{mips64}. The processor names are @samp{r2000},
@samp{r3000}, @samp{r3900}, @samp{r4000}, @samp{vr4100}, @samp{vr4300},
@samp{r4400}, @samp{r4600}, @samp{r4650}, @samp{vr5000}, @samp{r6000},
@samp{r8000}, @samp{4kc}, @samp{4kp}, @samp{5kc}, @samp{20kc},
***************
*** 7419,7432 ****
(for example, @samp{-march=r2k}). Prefixes are optional, and
@samp{vr} may be written @samp{r}.
! GCC defines two macros based on the value of this option. The first
! is @samp{_MIPS_ARCH}, which gives the name of target architecture, as
a string. The second has the form @address@hidden,
where @var{foo} is the capitalized value of @address@hidden
For example, @samp{-march=r2000} will set @samp{_MIPS_ARCH}
to @samp{"r2000"} and define the macro @samp{_MIPS_ARCH_R2000}.
! Note that the @samp{_MIPS_ARCH} macro uses the processor names given
above. In other words, it will have the full prefix and will not
abbreviate @samp{000} as @samp{k}. In the case of @samp{from-abi},
the macro names the resolved architecture (either @samp{"mips1"} or
--- 7411,7424 ----
(for example, @samp{-march=r2k}). Prefixes are optional, and
@samp{vr} may be written @samp{r}.
! GCC defines two macros based on the value of this option. The first,
! @samp{_MIPS_ARCH}, gives the name of target architecture as
a string. The second has the form @address@hidden,
where @var{foo} is the capitalized value of @address@hidden
For example, @samp{-march=r2000} will set @samp{_MIPS_ARCH}
to @samp{"r2000"} and define the macro @samp{_MIPS_ARCH_R2000}.
! The @samp{_MIPS_ARCH} macro uses the processor names
above. In other words, it will have the full prefix and will not
abbreviate @samp{000} as @samp{k}. In the case of @samp{from-abi},
the macro names the resolved architecture (either @samp{"mips1"} or
***************
*** 7479,7487 ****
@opindex mfused-madd
@opindex mno-fused-madd
Generate code that uses (does not use) the floating point multiply and
! accumulate instructions, when they are available. These instructions
are generated by default if they are available, but this may be
! undesirable if the extra precision causes problems or on certain chips
in the mode where denormals are rounded to zero where denormals
generated by multiply and accumulate instructions cause exceptions
anyway.
--- 7471,7479 ----
@opindex mfused-madd
@opindex mno-fused-madd
Generate code that uses (does not use) the floating point multiply and
! accumulate instructions when they are available. These instructions
are generated by default if they are available, but this may be
! undesirable if the extra precision causes problems, or on certain chips
in the mode where denormals are rounded to zero where denormals
generated by multiply and accumulate instructions cause exceptions
anyway.
***************
*** 7519,7525 ****
The default size of ints, longs and pointers depends on the address@hidden
All
the supported ABIs use 32-bit ints. The n64 ABI uses 64-bit longs, as
does the 64-bit Cygnus EABI; the others use 32-bit longs. Pointers
! are the same size as longs, or the same size as integer registers,
whichever is smaller.
@item -mabi=32
--- 7511,7517 ----
The default size of ints, longs and pointers depends on the address@hidden
All
the supported ABIs use 32-bit ints. The n64 ABI uses 64-bit longs, as
does the 64-bit Cygnus EABI; the others use 32-bit longs. Pointers
! are the same size as either longs or integer registers,
whichever is smaller.
@item -mabi=32
***************
*** 7536,7545 ****
@opindex mabi=meabi
Generate code for the given address@hidden
! Note that there are two embedded ABIs: @option{-mabi=eabi}
selects the one defined by Cygnus while @option{-meabi=meabi}
! selects the one defined by address@hidden Both these ABIs have
! 32-bit and 64-bit variants. Normally, GCC will generate
64-bit code when you select a 64-bit architecture, but you
can use @option{-mgp32} to get 32-bit code instead.
--- 7528,7537 ----
@opindex mabi=meabi
Generate code for the given address@hidden
! There are two embedded ABIs: @option{-mabi=eabi}
selects the one defined by Cygnus while @option{-meabi=meabi}
! selects the one defined by address@hidden Both ABIs have
! 32-bit and 64-bit variants. GCC normally generates
64-bit code when you select a 64-bit architecture, but you
can use @option{-mgp32} to get 32-bit code instead.
***************
*** 7548,7561 ****
Generate code for the MIPS assembler, and invoke @file{mips-tfile} to
add normal debug information. This is the default for all
platforms except for the OSF/1 reference platform, using the OSF/rose
! object format. If the either of the @option{-gstabs} or @option{-gstabs+}
! switches are used, the @file{mips-tfile} program will encapsulate the
stabs within MIPS address@hidden
@item -mgas
@opindex mgas
Generate code for the GNU assembler. This is the default on the OSF/1
! reference platform, using the OSF/rose object format. Also, this is
the default if the configure option @option{--with-gnu-as} is used.
@item -msplit-addresses
--- 7540,7553 ----
Generate code for the MIPS assembler, and invoke @file{mips-tfile} to
add normal debug information. This is the default for all
platforms except for the OSF/1 reference platform, using the OSF/rose
! object format. If either the @option{-gstabs} or the @option{-gstabs+}
! switch is used, the @file{mips-tfile} program will encapsulate the
stabs within MIPS address@hidden
@item -mgas
@opindex mgas
Generate code for the GNU assembler. This is the default on the OSF/1
! reference platform, using the OSF/rose object format. This is also
the default if the configure option @option{--with-gnu-as} is used.
@item -msplit-addresses
***************
*** 7563,7569 ****
@opindex msplit-addresses
@opindex mno-split-addresses
Generate code to load the high and low parts of address constants
separately.
! This allows GCC to optimize away redundant loads of the high order
bits of addresses. This optimization requires GNU as and GNU ld.
This optimization is enabled by default for some embedded targets where
GNU as and GNU ld are standard.
--- 7555,7561 ----
@opindex msplit-addresses
@opindex mno-split-addresses
Generate code to load the high and low parts of address constants
separately.
! This allows GCC to optimize away redundant loads of the high-order
bits of addresses. This optimization requires GNU as and GNU ld.
This optimization is enabled by default for some embedded targets where
GNU as and GNU ld are standard.
***************
*** 7572,7580 ****
@itemx -mno-rnames
@opindex mrnames
@opindex mno-rnames
! The @option{-mrnames} switch says to output code using the MIPS software
! names for the registers, instead of the hardware names (ie, @var{a0}
! instead of @var{$4}). The only known assembler that supports this option
is the Algorithmics assembler.
@item -mgpopt
--- 7564,7572 ----
@itemx -mno-rnames
@opindex mrnames
@opindex mno-rnames
! The @option{-mrnames} switch says to emit code using the MIPS software
! names for the registers, instead of the hardware names (e.g., @var{a0}
! instead of @var{$4}). The only assembler known to support this option
is the Algorithmics assembler.
@item -mgpopt
***************
*** 7582,7589 ****
@opindex mgpopt
@opindex mno-gpopt
The @option{-mgpopt} switch says to write all of the data declarations
! before the instructions in the text section, this allows the MIPS
! assembler to generate one word memory references instead of using two
words for short global or static data items. This is on by default if
optimization is selected.
--- 7574,7581 ----
@opindex mgpopt
@opindex mno-gpopt
The @option{-mgpopt} switch says to write all of the data declarations
! before the instructions in the text section. This allows the MIPS
! assembler to generate one-word memory references instead of using two
words for short global or static data items. This is on by default if
optimization is selected.
***************
*** 7608,7623 ****
@itemx -mno-mips-tfile
@opindex mmips-tfile
@opindex mno-mips-tfile
! The @option{-mno-mips-tfile} switch causes the compiler not
! postprocess the object file with the @file{mips-tfile} program,
! after the MIPS assembler has generated it to add debug support. If
! @file{mips-tfile} is not run, then no local variables will be
! available to the debugger. In addition, @file{stage2} and
@file{stage3} objects will have the temporary file names passed to the
assembler embedded in the object file, which means the objects will
! not compare the same. The @option{-mno-mips-tfile} switch should only
! be used when there are bugs in the @file{mips-tfile} program that
! prevents compilation.
@item -msoft-float
@opindex msoft-float
--- 7600,7615 ----
@itemx -mno-mips-tfile
@opindex mmips-tfile
@opindex mno-mips-tfile
! The @option{-mno-mips-tfile} switch causes the compiler not to
! postprocess the object file with the @file{mips-tfile} program
! after the MIPS assembler has generated it to add debugging support. If
! @file{mips-tfile} is not run, then local variables are
! unavailable to the debugger. In addition, @file{stage2} and
@file{stage3} objects will have the temporary file names passed to the
assembler embedded in the object file, which means the objects will
! not compare the same. The @option{-mno-mips-tfile} switch should be
! used only when bugs in the @file{mips-tfile} program
! prevent compilation.
@item -msoft-float
@opindex msoft-float
***************
*** 7637,7670 ****
@itemx -mno-abicalls
@opindex mabicalls
@opindex mno-abicalls
! Emit (or do not emit) the pseudo operations @samp{.abicalls},
@samp{.cpload}, and @samp{.cprestore} that some System V.4 ports use for
! position independent code.
@item -mlong-calls
@itemx -mno-long-calls
@opindex mlong-calls
@opindex mno-long-calls
! Do all calls with the @samp{JALR} instruction, which requires
! loading up a function's address into a register before the call.
! You need to use this switch, if you call outside of the current
512 megabyte segment to functions that are not through pointers.
@item -mhalf-pic
@itemx -mno-half-pic
@opindex mhalf-pic
@opindex mno-half-pic
! Put pointers to extern references into the data section and load them
! up, rather than put the references in the text section.
@item -membedded-pic
@itemx -mno-embedded-pic
@opindex membedded-pic
@opindex mno-embedded-pic
Generate PIC code suitable for some embedded systems. All calls are
! made using PC relative address, and all data is addressed using the $gp
register. No more than 65536 bytes of global data may be used. This
! requires GNU as and GNU ld which do most of the work. This currently
only works on targets which use ECOFF; it does not work with address@hidden
@item -membedded-data
--- 7629,7662 ----
@itemx -mno-abicalls
@opindex mabicalls
@opindex mno-abicalls
! Emit (do not emit) the pseudo-operations @samp{.abicalls},
@samp{.cpload}, and @samp{.cprestore} that some System V.4 ports use for
! position-independent code.
@item -mlong-calls
@itemx -mno-long-calls
@opindex mlong-calls
@opindex mno-long-calls
! Use the @samp{JALR} instruction for all calls, which requires
! loading a function's address into a register before the call.
! You need to use this switch if you call outside the current
512 megabyte segment to functions that are not through pointers.
@item -mhalf-pic
@itemx -mno-half-pic
@opindex mhalf-pic
@opindex mno-half-pic
! Put pointers to extern references into the data section and load them,
! rather than put the references in the text section.
@item -membedded-pic
@itemx -mno-embedded-pic
@opindex membedded-pic
@opindex mno-embedded-pic
Generate PIC code suitable for some embedded systems. All calls are
! made using PC relative address, and all data addressed using the $gp
register. No more than 65536 bytes of global data may be used. This
! requires GNU as and GNU ld, which do most of the work. This currently
only works on targets which use ECOFF; it does not work with address@hidden
@item -membedded-data
***************
*** 7674,7686 ****
Allocate variables to the read-only data section first if possible, then
next in the small data section if possible, otherwise in data. This gives
slightly slower code than the default, but reduces the amount of RAM
required
! when executing, and thus may be preferred for some embedded systems.
@item -muninit-const-in-rodata
@itemx -mno-uninit-const-in-rodata
@opindex muninit-const-in-rodata
@opindex mno-uninit-const-in-rodata
! When used together with @option{-membedded-data}, it will always store
uninitialized
const variables in the read-only data section.
@item -msingle-float
--- 7666,7678 ----
Allocate variables to the read-only data section first if possible, then
next in the small data section if possible, otherwise in data. This gives
slightly slower code than the default, but reduces the amount of RAM
required
! for execution, and thus may be preferred for some embedded systems.
@item -muninit-const-in-rodata
@itemx -mno-uninit-const-in-rodata
@opindex muninit-const-in-rodata
@opindex mno-uninit-const-in-rodata
! When used together with @option{-membedded-data}, always store (never
store) uninitialized
const variables in the read-only data section.
@item -msingle-float
***************
*** 7688,7696 ****
@opindex msingle-float
@opindex mdouble-float
The @option{-msingle-float} switch tells gcc to assume that the floating
! point coprocessor only supports single precision operations, as on the
@samp{r4650} chip. The @option{-mdouble-float} switch permits gcc to use
! double precision operations. This is the default.
@item -mmad
@itemx -mno-mad
--- 7680,7688 ----
@opindex msingle-float
@opindex mdouble-float
The @option{-msingle-float} switch tells gcc to assume that the floating
! point coprocessor supports only single-precision operations, as on the
@samp{r4650} chip. The @option{-mdouble-float} switch permits gcc to use
! double-precision operations. This is the default.
@item -mmad
@itemx -mno-mad
***************
*** 7712,7739 ****
@item -mentry
@opindex mentry
! Use the entry and exit pseudo ops. This option can only be used with
@option{-mips16}.
@item -EL
@opindex EL
! Compile code for the processor in little endian mode.
The requisite libraries are assumed to exist.
@item -EB
@opindex EB
! Compile code for the processor in big endian mode.
The requisite libraries are assumed to exist.
@item -G @var{num}
@opindex G
@cindex smaller data references (MIPS)
@cindex gp-relative references (MIPS)
! Put global and static items less than or equal to @var{num} bytes into
! the small data or bss sections instead of the normal data or bss
! section. This allows the assembler to emit one word memory reference
instructions based on the global pointer (@var{gp} or @var{$28}),
! instead of the normal two words used. By default, @var{num} is 8 when
the MIPS assembler is used, and 0 when the GNU assembler is used. The
@option{-G @var{num}} switch is also passed to the assembler and linker.
All modules should be compiled with the same @option{-G @var{num}}
--- 7704,7731 ----
@item -mentry
@opindex mentry
! Use the entry and exit pseudo-operations. This option can be used only with
@option{-mips16}.
@item -EL
@opindex EL
! Compile code for the processor in little-endian mode.
The requisite libraries are assumed to exist.
@item -EB
@opindex EB
! Compile code for the processor in big-endian mode.
The requisite libraries are assumed to exist.
@item -G @var{num}
@opindex G
@cindex smaller data references (MIPS)
@cindex gp-relative references (MIPS)
! Put global and static items up to @var{num} bytes into
! the small data or bss sections instead of into the normal data or bss
! section. This allows the assembler to emit one-word memory reference
instructions based on the global pointer (@var{gp} or @var{$28}),
! instead of the normal two words. By default, @var{num} is 8 when
the MIPS assembler is used, and 0 when the GNU assembler is used. The
@option{-G @var{num}} switch is also passed to the assembler and linker.
All modules should be compiled with the same @option{-G @var{num}}
***************
*** 7741,7752 ****
@item -nocpp
@opindex nocpp
! Tell the MIPS assembler to not run its preprocessor over user
assembler files (with a @samp{.s} suffix) when assembling them.
@item -mfix7000
@opindex mfix7000
! Pass an option to gas which will cause nops to be inserted if
the read of the destination register of an mfhi or mflo instruction
occurs in the following two instructions.
--- 7733,7744 ----
@item -nocpp
@opindex nocpp
! Tell the MIPS assembler not to run its preprocessor over user
assembler files (with a @samp{.s} suffix) when assembling them.
@item -mfix7000
@opindex mfix7000
! Pass an option to gas to cause nops to be inserted if
the read of the destination register of an mfhi or mflo instruction
occurs in the following two instructions.
***************
*** 7757,7768 ****
@item address@hidden
@itemx -mno-flush-func
@opindex mflush-func
! Specifies the function to call to flush the I and D caches, or to not
call any such function. If called, the function must take the same
arguments as the common @code{_flush_func()}, that is, the address of the
memory range for which the cache is being flushed, the size of the
memory range, and the number 3 (to flush both caches). The default
! depends on the target gcc was configured for, but commonly is either
@samp{_flush_func} or @samp{__cpu_flush}.
@item -mbranch-likely
--- 7749,7760 ----
@item address@hidden
@itemx -mno-flush-func
@opindex mflush-func
! Specifies the function to call to flush the I and D caches, or not to
call any such function. If called, the function must take the same
arguments as the common @code{_flush_func()}, that is, the address of the
memory range for which the cache is being flushed, the size of the
memory range, and the number 3 (to flush both caches). The default
! depends on the target for which gcc was configured, but commonly is either
@samp{_flush_func} or @samp{__cpu_flush}.
@item -mbranch-likely
***************
*** 7792,7810 ****
@item address@hidden
@opindex mcpu
Tune to @var{cpu-type} everything applicable about the generated code,
except
! for the ABI and the set of available instructions. The choices for
! @var{cpu-type} are @samp{i386}, @samp{i486}, @samp{i586}, @samp{i686},
@samp{pentium}, @samp{pentium-mmx}, @samp{pentiumpro}, @samp{pentium2},
@samp{pentium3}, @samp{pentium4}, @samp{k6}, @samp{k6-2}, @samp{k6-3},
@samp{athlon}, @samp{athlon-tbird}, @samp{athlon-4}, @samp{athlon-xp},
! @samp{athlon-mp}, @samp{winchip-c6}, @samp{winchip2} and @samp{c3}.
While picking a specific @var{cpu-type} will schedule things appropriately
! for that particular chip, the compiler will not generate any code that
! does not run on the i386 without the @address@hidden option
! being used. @samp{i586} is equivalent to @samp{pentium} and @samp{i686}
! is equivalent to @samp{pentiumpro}. @samp{k6} and @samp{athlon} are the
! AMD chips as opposed to the Intel ones.
@item address@hidden
@opindex march
--- 7784,7802 ----
@item address@hidden
@opindex mcpu
Tune to @var{cpu-type} everything applicable about the generated code,
except
! for the ABI and the set of available instructions.
! @var{cpu-type} may be @samp{i386}, @samp{i486}, @samp{i586}, @samp{i686},
@samp{pentium}, @samp{pentium-mmx}, @samp{pentiumpro}, @samp{pentium2},
@samp{pentium3}, @samp{pentium4}, @samp{k6}, @samp{k6-2}, @samp{k6-3},
@samp{athlon}, @samp{athlon-tbird}, @samp{athlon-4}, @samp{athlon-xp},
! @samp{athlon-mp}, @samp{winchip-c6}, @samp{winchip2}, or @samp{c3}.
While picking a specific @var{cpu-type} will schedule things appropriately
! for that particular chip, the compiler will not generate code that
! does not run on the i386 unless you also use the
@address@hidden option.
! @samp{i586} is equivalent to @samp{pentium} and @samp{i686}
! is equivalent to @samp{pentiumpro}. @samp{k6} and @samp{athlon} are
! AMD chips.
@item address@hidden
@opindex march
***************
*** 7826,7869 ****
@item address@hidden
@opindex march
! generate floating point arithmetics for selected unit @var{unit}. the
choices
! for @var{unit} are:
@table @samp
@item 387
! Use the standard 387 floating point coprocessor present majority of chips
and
emulated otherwise. Code compiled with this option will run almost
everywhere.
! The temporary results are computed in 80bit precision instead of precision
! specified by the type resulting in slightly different results compared to
most
! of other chips. See @option{-ffloat-store} for more detailed description.
! This is the default choice for i386 compiler.
@item sse
! Use scalar floating point instructions present in the SSE instruction set.
! This instruction set is supported by Pentium3 and newer chips, in the AMD
line
! by Athlon-4, Athlon-xp and Athlon-mp chips. The earlier version of SSE
! instruction set supports only single precision arithmetics, thus the
double and
! extended precision arithmetics is still done using 387. Later version,
present
! only in Pentium4 and the future AMD x86-64 chips supports double precision
! arithmetics too.
! For i387 you need to use @address@hidden, @option{-msse} or
@option{-msse2} switches to enable SSE extensions and make this option
! effective. For x86-64 compiler, these extensions are enabled by default.
! The resulting code should be considerably faster in majority of cases and
avoid
! the numerical instability problems of 387 code, but may break some existing
! code that expects temporaries to be 80bit.
! This is the default choice for x86-64 compiler.
@item sse,387
! Attempt to utilize both instruction sets at once. This effectively
double the
! amount of available registers and on chips with separate execution units for
! 387 and SSE the execution resources too. Use this option with care, as
it is
! still experimental, because gcc register allocator does not model separate
! functional units well resulting in instable performance.
@end table
@item address@hidden
--- 7818,7862 ----
@item address@hidden
@opindex march
! Generate floating point arithmetic for selected unit @var{unit},
! chosen from among:
@table @samp
@item 387
! Use the 387 floating point coprocessor present in most chips and
emulated otherwise. Code compiled with this option will run almost
everywhere.
! The temporary results are computed in 80-bit precision instead of the
precision
! specified by the type, resulting in slightly different results from most
! other chips. See @option{-ffloat-store} for a more detailed description.
! This is the default choice for the i386 compiler.
@item sse
! Use the scalar floating point instructions of the SSE instruction set.
! This instruction set is supported by Intel in the Pentium III and newer
! chips, and by AMD in the Athlon 4, Athlon XP and Athlon MP chips. The
! earlier version of the SSE instruction set supports only
! single-precision arithmetic, thus double- and extended-precision
! arithmetic is still done using 387. A later version found only in
! Pentium4 and the future AMD x86-64 chips supports double-precision
! arithmetic too.
! For i387 you must use the @address@hidden, @option{-msse} or
@option{-msse2} switches to enable SSE extensions and make this option
! effective. For the x86-64 compiler these extensions are enabled by default.
! The resulting code should be considerably faster in a majority of
! cases, and avoid the numerical instability problems of 387 code, but
! may break some existing code that expects temporaries to be 80 bits.
! This is the default choice for the x86-64 compiler.
@item sse,387
! Try to use both instruction sets. This effectively doubles the
! number of available registers and on chips with separate execution units for
! 387 and SSE instructions. Use this option with care, because it is
! still experimental: the gcc register allocator does not model separate
! functional units well, resulting in instable performance.
@end table
@item address@hidden
***************
*** 7875,7881 ****
@itemx -mno-ieee-fp
@opindex mieee-fp
@opindex mno-ieee-fp
! Control whether or not the compiler uses IEEE floating point
comparisons. These handle correctly the case where the result of a
comparison is unordered.
--- 7868,7874 ----
@itemx -mno-ieee-fp
@opindex mieee-fp
@opindex mno-ieee-fp
! Control whether the compiler uses IEEE floating-point
comparisons. These handle correctly the case where the result of a
comparison is unordered.
***************
*** 7894,7902 ****
@item -mno-fp-ret-in-387
@opindex mno-fp-ret-in-387
! Do not use the FPU registers for return values of functions.
! The usual calling convention has functions return values of types
@code{float} and @code{double} in an FPU register, even if there
is no address@hidden The idea is that the operating system should emulate
an address@hidden
--- 7887,7895 ----
@item -mno-fp-ret-in-387
@opindex mno-fp-ret-in-387
! Do not use the FPU registers to return the function values.
! With the usual calling convention, functions return values of types
@code{float} and @code{double} in an FPU register, even if there
is no address@hidden The idea is that the operating system should emulate
an address@hidden
***************
*** 7920,7946 ****
@opindex malign-double
@opindex mno-align-double
Control whether GCC aligns @code{double}, @code{long double}, and
! @code{long long} variables on a two word boundary or a one word
! boundary. Aligning @code{double} variables on a two word boundary will
! produce code that runs somewhat faster on a @samp{Pentium} at the
! expense of more memory.
@strong{Warning:} if you use the @option{-malign-double} switch,
! structures containing the above types will be aligned differently than
! the published application binary interface specifications for the 386
and will not be binary compatible with structures in code compiled
without that switch.
@item -m128bit-long-double
@opindex m128bit-long-double
! Control the size of @code{long double} type. i386 application binary
interface
! specify the size to be 12 bytes, while modern architectures (Pentium and
newer)
! prefer @code{long double} aligned to 8 or 16 byte boundary. This is
! impossible to reach with 12 byte long doubles in the array accesses.
!
! @strong{Warning:} if you use the @option{-m128bit-long-double} switch, the
! structures and arrays containing @code{long double} will change their
size as
! well as function calling convention for function taking @code{long double}
will be modified.
@item -m96bit-long-double
--- 7913,7940 ----
@opindex malign-double
@opindex mno-align-double
Control whether GCC aligns @code{double}, @code{long double}, and
! @code{long long} variables on a two-word or on a one-word
! boundary. Aligning @code{double} variables on a two-word boundary
! produces code that runs somewhat faster on a @samp{Pentium} at the
! expense of using more memory.
@strong{Warning:} if you use the @option{-malign-double} switch,
! structures containing the types above will be not be aligned according to
! the published application binary interface specifications for the 386,
and will not be binary compatible with structures in code compiled
without that switch.
@item -m128bit-long-double
@opindex m128bit-long-double
! Control the size of the @code{long double} type. The i386 application
! binary interface specifies this as 12 bytes, but modern architectures,
! beginning with the Pentium, prefer @code{long double} to be aligned to
! an 8- or 16-byte boundary. This is impossible to reach with 12-byte
! long doubles in the array accesses.
!
! @strong{Warning:} if you use the @option{-m128bit-long-double} switch,
! structures and arrays containing @code{long double} will change size and
! the calling convention for functions taking @code{long double}
will be modified.
@item -m96bit-long-double
***************
*** 7952,7985 ****
@itemx -mno-svr3-shlib
@opindex msvr3-shlib
@opindex mno-svr3-shlib
! Control whether GCC places uninitialized local variables into the
@code{bss} or @code{data} segments. @option{-msvr3-shlib} places them
! into @code{bss}. These options are meaningful only on System V Release 3.
@item -mrtd
@opindex mrtd
Use a different function-calling convention, in which functions that
take a fixed number of arguments return with the @code{ret} @var{num}
instruction, which pops their arguments while returning. This saves one
! instruction in the caller since there is no need to pop the arguments
there.
! You can specify that an individual function is called with this calling
! sequence with the function attribute @samp{stdcall}. You can also
! override the @option{-mrtd} option by using the function attribute
@samp{cdecl}. @xref{Function Attributes}.
@strong{Warning:} this calling convention is incompatible with the one
normally used on Unix, so you cannot use it if you need to call
libraries compiled with the Unix compiler.
! Also, you must provide function prototypes for all functions that
take variable numbers of arguments (including @code{printf});
! otherwise incorrect code will be generated for calls to those
functions.
! In addition, seriously incorrect code will result if you call a
! function with too many arguments. (Normally, extra arguments are
harmlessly ignored.)
@item address@hidden
--- 7946,7979 ----
@itemx -mno-svr3-shlib
@opindex msvr3-shlib
@opindex mno-svr3-shlib
! Control whether GCC places uninitialized local variables in the
@code{bss} or @code{data} segments. @option{-msvr3-shlib} places them
! in @code{bss}. These options are meaningful only on System V Release 3.
@item -mrtd
@opindex mrtd
Use a different function-calling convention, in which functions that
take a fixed number of arguments return with the @code{ret} @var{num}
instruction, which pops their arguments while returning. This saves one
! instruction in the caller, since there is no need to pop the arguments
there.
! You can use the function attribute @samp{stdcall} to specify this
! calling sequence for an individual function. You can also
! override the @option{-mrtd} option with the function attribute
@samp{cdecl}. @xref{Function Attributes}.
@strong{Warning:} this calling convention is incompatible with the one
normally used on Unix, so you cannot use it if you need to call
libraries compiled with the Unix compiler.
! Moreover, you must provide function prototypes for all functions that
take variable numbers of arguments (including @code{printf});
! otherwise gcc generates incorrect code for calls to those
functions.
! Finally, seriously incorrect code will result if you call a
! function with too many arguments. (Extra arguments are normally
harmlessly ignored.)
@item address@hidden
***************
*** 7990,8024 ****
function by using the function attribute @samp{regparm}.
@xref{Function Attributes}.
! @strong{Warning:} if you use this switch, and
@var{num} is nonzero, then you must build all modules with the same
value, including any libraries. This includes the system libraries and
startup modules.
@item address@hidden
@opindex mpreferred-stack-boundary
! Attempt to keep the stack boundary aligned to a 2 raised to @var{num}
! byte boundary. If @option{-mpreferred-stack-boundary} is not specified,
! the default is 4 (16 bytes or 128 bits), except when optimizing for code
size (@option{-Os}), in which case the default is the minimum correct
! alignment (4 bytes for x86, and 8 bytes for x86-64).
On Pentium and PentiumPro, @code{double} and @code{long double} values
! should be aligned to an 8 byte boundary (see @option{-malign-double}) or
! suffer significant run time performance penalties. On Pentium III, the
Streaming SIMD Extension (SSE) data type @code{__m128} suffers similar
! penalties if it is not 16 byte aligned.
! To ensure proper alignment of this values on the stack, the stack boundary
! must be as aligned as that required by any value stored on the stack.
Further, every function must be generated such that it keeps the stack
aligned. Thus calling a function compiled with a higher preferred
stack boundary from a function compiled with a lower preferred stack
! boundary will most likely misalign the stack. It is recommended that
libraries that use callbacks always use the default setting.
This extra alignment does consume extra stack space, and generally
! increases code size. Code that is sensitive to stack space usage, such
as embedded systems and operating system kernels, may want to reduce the
preferred alignment to @option{-mpreferred-stack-boundary=2}.
--- 7984,8018 ----
function by using the function attribute @samp{regparm}.
@xref{Function Attributes}.
! @strong{Warning:} if you use this switch and
@var{num} is nonzero, then you must build all modules with the same
value, including any libraries. This includes the system libraries and
startup modules.
@item address@hidden
@opindex mpreferred-stack-boundary
! Attempt to keep the stack boundary aligned to a 2 raised to @var{num}-byte
! boundary. If @option{-mpreferred-stack-boundary} is unspecified,
! the default is 4 (16-byte alignment), except when optimizing for code
size (@option{-Os}), in which case the default is the minimum correct
! alignment (4-byte alignment for x86 and 8-byte alignment for x86-64).
On Pentium and PentiumPro, @code{double} and @code{long double} values
! should be aligned to an 8-byte boundary (see @option{-malign-double}) to
! avoid significant performance penalties in execution. On Pentium III, the
Streaming SIMD Extension (SSE) data type @code{__m128} suffers similar
! penalties if it is not 16-byte aligned.
! To ensure proper alignment of these values on the stack, the stack boundary
! must be as aligned as strictly as is required by any value stored on the
stack.
Further, every function must be generated such that it keeps the stack
aligned. Thus calling a function compiled with a higher preferred
stack boundary from a function compiled with a lower preferred stack
! boundary will probably misalign the stack. It is recommended that
libraries that use callbacks always use the default setting.
This extra alignment does consume extra stack space, and generally
! increases code size. Code sensitive to stack space usage, such
as embedded systems and operating system kernels, may want to reduce the
preferred alignment to @option{-mpreferred-stack-boundary=2}.
***************
*** 8036,8048 ****
@opindex mno-sse
@opindex m3dnow
@opindex mno-3dnow
! These switches enable or disable the use of built-in functions that allow
! direct access to the MMX, SSE and 3Dnow extensions of the instruction set.
@xref{X86 Built-in Functions}, for details of the functions enabled
and disabled by these switches.
! To have SSE/SSE2 instructions generated automatically from floating-point
code, see @option{-mfpmath=sse}.
@item -mpush-args
--- 8030,8042 ----
@opindex mno-sse
@opindex m3dnow
@opindex mno-3dnow
! These switches enable (disable) using built-in functions that allow
! direct access to the MMX, SSE and 3Dnow instruction set extensions.
@xref{X86 Built-in Functions}, for details of the functions enabled
and disabled by these switches.
! To generate SSE or SSE2 automatically from floating-point
code, see @option{-mfpmath=sse}.
@item -mpush-args
***************
*** 8050,8065 ****
@opindex mpush-args
@opindex mno-push-args
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
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 is 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}.
@item -mthreads
--- 8044,8059 ----
@opindex mpush-args
@opindex mno-push-args
Use PUSH operations to store outgoing parameters. This method is shorter
! and usually as fast as the method using SUB/MOV operations, and is enabled
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 is
computed in the function prologue. This is faster on most modern CPUs
because of reduced dependencies, improved scheduling and reduced stack usage
! when the preferred stack boundary is not 2. The drawback is a marked
increase in code size. This switch implies @option{-mno-push-args}.
@item -mthreads
***************
*** 8068,8094 ****
on thread-safe exception handling must compile and link all code with the
@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
! 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
! size, but may improve performance of code that depends on fast memcpy,
strlen
! and memset for short lengths.
@item -momit-leaf-frame-pointer
@opindex momit-leaf-frame-pointer
Don't keep the frame pointer in a register for leaf functions. This
avoids the instructions to save, set up and restore frame pointers and
makes an extra register available in leaf functions. The option
! @option{-fomit-frame-pointer} removes the frame pointer for all functions
which might make debugging harder.
@end table
--- 8062,8088 ----
on thread-safe exception handling must compile and link all code with the
@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 the destinations of inlined string operations. This switch
reduces
! code size and improves performance when a destination is already aligned,
! but gcc doesn't know about it.
@item -minline-all-stringops
@opindex minline-all-stringops
! GCC inlines string operations by default only when the destination is
! known to be aligned to at least a 4-byte boundary. This enables more
! inlining and increases code size, but may improve the performance of
! code that depends on fast memcpy, strlen and memset for short lengths.
@item -momit-leaf-frame-pointer
@opindex momit-leaf-frame-pointer
Don't keep the frame pointer in a register for leaf functions. This
avoids the instructions to save, set up and restore frame pointers and
makes an extra register available in leaf functions. The option
! @option{-fomit-frame-pointer} removes the frame pointer for all functions,
which might make debugging harder.
@end table
***************
*** 8100,8148 ****
@itemx -m64
@opindex m32
@opindex m64
! Generate code for a 32-bit or 64-bit environment.
The 32-bit environment sets int, long and pointer to 32 bits and
generates code that runs on any i386 system.
The 64-bit environment sets int to 32 bits and long and pointer
! to 64 bits and generates code for AMD's x86-64 architecture.
@item -mno-red-zone
@opindex no-red-zone
! Do not use a so called red zone for x86-64 code. The red zone is mandated
! by the x86-64 ABI, it is a 128-byte area beyond the location of the
! stack pointer that will not be modified by signal or interrupt handlers
! and therefore can be used for temporary data without adjusting the stack
! pointer. The flag @option{-mno-red-zone} disables this red zone.
@table @gcctabopt
@item address@hidden
@opindex mcmodel
! Specify the code model to use.
! @var{model_type} may take one of the following values:
@item small
@opindex mcmodel=small
! Generate code for the small code model: the program and its symbols must
! be linked in the lower 2 GB of the address space. Pointers are 64 bits.
! Programs can be statically or dynamically linked. This is the default
! code model.
@item kernel
@opindex mcmodel=kernel
! Generate code for the kernel code model. The kernel runs in the
negative 2 GB of the address space.
! This model has to be used for Linux kernel code.
@item medium
@opindex mcmodel=medium
! Generate code for the medium model: The program is linked in the lower 2
GB of the address space but symbols can be located anywhere in the
! address space. Programs can be statically or dynamically linked, but
! building of shared libraries are not supported with the medium model.
@item large
@opindex mcmodel=large
! Generate code for the large model: This model makes no assumptions
about addresses and sizes of sections. Currently GCC does not implement
this model.
@end table
--- 8094,8142 ----
@itemx -m64
@opindex m32
@opindex m64
! Generate code for a 32-bit (64-bit) environment.
The 32-bit environment sets int, long and pointer to 32 bits and
generates code that runs on any i386 system.
The 64-bit environment sets int to 32 bits and long and pointer
! to 64 bits, and generates code for AMD's x86-64 architecture.
@item -mno-red-zone
@opindex no-red-zone
! Do not use a so-called red zone---mandated by the x86-64 ABI---for
! x86-64 code. The red zone is a 128-byte area beyond the location of
! the stack pointer that will not be modified by signal or interrupt
! handlers, and therefore can be used for temporary data without
! adjusting the stack pointer. The flag @option{-mno-red-zone} disables
! this red zone.
@table @gcctabopt
@item address@hidden
@opindex mcmodel
! Specify the code model to use, chosen from among these values:
@item small
@opindex mcmodel=small
! The default: generate code for the small code model: the program and
! its symbols must be linked in the lower 2 GB of the address space.
! Pointers are 64 bits. Programs can be statically or dynamically
! linked.
@item kernel
@opindex mcmodel=kernel
! Generate code for the kernel code model: the kernel runs in the
negative 2 GB of the address space.
! This model must be used for Linux kernel code.
@item medium
@opindex mcmodel=medium
! Generate code for the medium model: the program is linked in the lower 2
GB of the address space but symbols can be located anywhere in the
! address space. Programs can be linked statically or dynamically, but
! building shared libraries is not supported.
@item large
@opindex mcmodel=large
! Generate code for the large model: make no assumptions
about addresses and sizes of sections. Currently GCC does not implement
this model.
@end table
***************
*** 8157,8173 ****
@table @gcctabopt
@item address@hidden
@opindex march
! Generate code for the specified architecture. The choices for
! @var{architecture-type} are @samp{1.0} for PA 1.0, @samp{1.1} for PA
1.1, and @samp{2.0} for PA 2.0 processors. Refer to
@file{/usr/lib/sched.models} on an HP-UX system to determine the proper
! architecture option for your machine. Code compiled for lower numbered
! architectures will run on higher numbered architectures, but not the
other way around.
PA 2.0 support currently requires gas snapshot 19990413 or later. The
! next release of binutils (current is 2.9.1) will probably contain PA 2.0
! support.
@item -mpa-risc-1-0
@itemx -mpa-risc-1-1
--- 8151,8166 ----
@table @gcctabopt
@item address@hidden
@opindex march
! Generate code for the architecture specified, chosen from
! @samp{1.0} for PA 1.0, @samp{1.1} for PA
1.1, and @samp{2.0} for PA 2.0 processors. Refer to
@file{/usr/lib/sched.models} on an HP-UX system to determine the proper
! architecture option for your machine. Code compiled for lower-numbered
! architectures will run on higher-numbered architectures, but not the
other way around.
PA 2.0 support currently requires gas snapshot 19990413 or later. The
! release of binutils after 2.9.1 will probably contain PA 2.0 support.
@item -mpa-risc-1-0
@itemx -mpa-risc-1-1
***************
*** 8180,8205 ****
@item -mbig-switch
@opindex mbig-switch
Generate code suitable for big switch tables. Use this option only if
! the assembler/linker complain about out of range branches within a switch
table.
@item -mjump-in-delay
@opindex mjump-in-delay
! Fill delay slots of function calls with unconditional jump instructions
! by modifying the return pointer for the function call to be the target
! of the conditional jump.
@item -mdisable-fpregs
@opindex mdisable-fpregs
! Prevent floating point registers from being used in any manner. This is
! necessary for compiling kernels which perform lazy context switching of
floating point registers. If you use this option and attempt to perform
floating point operations, the compiler will abort.
@item -mdisable-indexing
@opindex mdisable-indexing
Prevent the compiler from using indexing address modes. This avoids some
! rather obscure problems when compiling MIG generated code under address@hidden
@item -mno-space-regs
@opindex mno-space-regs
--- 8173,8198 ----
@item -mbig-switch
@opindex mbig-switch
Generate code suitable for big switch tables. Use this option only if
! the assembler or linker complains about out-of-range branches within a
switch
table.
@item -mjump-in-delay
@opindex mjump-in-delay
! Fill the delay slots of function calls with unconditional jump instructions
! by modifying return pointers for function calls to be the targets
! of the conditional jumps.
@item -mdisable-fpregs
@opindex mdisable-fpregs
! Prevent floating point registers from being used in any way. This is
! necessary when compiling kernels which perform lazy context switching of
floating point registers. If you use this option and attempt to perform
floating point operations, the compiler will abort.
@item -mdisable-indexing
@opindex mdisable-indexing
Prevent the compiler from using indexing address modes. This avoids some
! rather obscure problems when compiling MIG-generated code under address@hidden
@item -mno-space-regs
@opindex mno-space-regs
***************
*** 8241,8249 ****
@item -mlinker-opt
@opindex mlinker-opt
! Enable the optimization pass in the HP-UX linker. Note this makes symbolic
debugging impossible. It also triggers a bug in the HP-UX 8 and HP-UX 9
! linkers in which they give bogus error messages when linking some programs.
@item -msoft-float
@opindex msoft-float
--- 8234,8242 ----
@item -mlinker-opt
@opindex mlinker-opt
! Enable the optimization pass in the HP-UX linker. This makes symbolic
debugging impossible. It also triggers a bug in the HP-UX 8 and HP-UX 9
! linkers which makes them emit bogus error messages when linking some
programs.
@item -msoft-float
@opindex msoft-float
***************
*** 8256,8318 ****
does provide software floating point support.
@option{-msoft-float} changes the calling convention in the output file;
! therefore, it is only useful if you compile @emph{all} of a program with
this option. In particular, you need to compile @file{libgcc.a}, the
library that comes with GCC, with @option{-msoft-float} in order for
this to work.
@item -msio
@opindex msio
! Generate the predefine, @code{_SIO}, for server IO. The default is
! @option{-mwsio}. This generates the predefines, @code{__hp9000s700},
! @code{__hp9000s700__} and @code{_WSIO}, for workstation IO. These
options are available under HP-UX and HI-UX.
@item -mgnu-ld
@opindex gnu-ld
! Use GNU ld specific options. This passes @option{-shared} to ld when
building a shared library. It is the default when GCC is configured,
! explicitly or implicitly, with the GNU linker. This option does not
! have any affect on which ld is called, it only changes what parameters
! are passed to that ld. The ld that is called is determined by the
@option{--with-ld} configure option, gcc's program search path, and
! finally by the user's @env{PATH}. The linker used by GCC can be printed
! using @samp{which `gcc -print-prog-name=ld`}.
@item -mhp-ld
@opindex hp-ld
! Use HP ld specific options. This passes @option{-b} to ld when building
a shared library and passes @option{+Accept TypeMismatch} to ld on all
links. It is the default when GCC is configured, explicitly or
! implicitly, with the HP linker. This option does not have any affect on
! which ld is called, it only changes what parameters are passed to that
! ld. The ld that is called is determined by the @option{--with-ld}
configure option, gcc's program search path, and finally by the user's
! @env{PATH}. The linker used by GCC can be printed using @samp{which
`gcc -print-prog-name=ld`}.
@item -mlong-calls
@opindex mno-long-calls
Generate code that uses long call sequences. This ensures that a call
! is always able to reach linker generated stubs. The default is to generate
long calls only when the distance from the call site to the beginning
of the function or translation unit, as the case may be, exceeds a
predefined limit set by the branch type being used. The limits for
! normal calls are 7,600,000 and 240,000 bytes, respectively for the
! PA 2.0 and PA 1.X architectures. Sibcalls are always limited at
240,000 bytes.
! Distances are measured from the beginning of functions when using the
@option{-ffunction-sections} option, or when using the @option{-mgas}
and @option{-mno-portable-runtime} options together under HP-UX with
the SOM linker.
! It is normally not desirable to use this option as it will degrade
performance. However, it may be useful in large applications,
! particularly when partial linking is used to build the application.
! The types of long calls used depends on the capabilities of the
! assembler and linker, and the type of code being generated. The
impact on systems that support long absolute calls, and long pic
symbol-difference or pc-relative calls should be relatively small.
However, an indirect call is used on 32-bit ELF systems in pic code
--- 8249,8311 ----
does provide software floating point support.
@option{-msoft-float} changes the calling convention in the output file;
! therefore, it is useful only if you compile @emph{all} of a program with
this option. In particular, you need to compile @file{libgcc.a}, the
library that comes with GCC, with @option{-msoft-float} in order for
this to work.
@item -msio
@opindex msio
! Generate the predefine @code{_SIO} for server IO; the default is
! @option{-mwsio}. @code{_SIO} generates the predefines @code{__hp9000s700},
! @code{__hp9000s700__} and @code{_WSIO} for workstation IO. These
options are available under HP-UX and HI-UX.
@item -mgnu-ld
@opindex gnu-ld
! Use GNU ld-specific options. This passes @option{-shared} to ld when
building a shared library. It is the default when GCC is configured,
! explicitly or implicitly, with the GNU linker. This option has no
! effect on which ld is called, but only changes what parameters
! are passed to that ld. The ld called is determined by the
@option{--with-ld} configure option, gcc's program search path, and
! finally by the user's @env{PATH}. The linker used by GCC can be displayed
! with @samp{which `gcc -print-prog-name=ld`}.
@item -mhp-ld
@opindex hp-ld
! Use HP ld-specific options. This passes @option{-b} to ld when building
a shared library and passes @option{+Accept TypeMismatch} to ld on all
links. It is the default when GCC is configured, explicitly or
! implicitly, with the HP linker. This option nas no effect on
! which ld is called, but only changes what parameters are passed to that
! ld. The ld called is determined by the @option{--with-ld}
configure option, gcc's program search path, and finally by the user's
! @env{PATH}. The linker used by GCC can be displayed with @samp{which
`gcc -print-prog-name=ld`}.
@item -mlong-calls
@opindex mno-long-calls
Generate code that uses long call sequences. This ensures that a call
! is always able to reach linker-generated stubs. The default is to generate
long calls only when the distance from the call site to the beginning
of the function or translation unit, as the case may be, exceeds a
predefined limit set by the branch type being used. The limits for
! normal calls are 7,600,000 bytes (PA 2.0 architecture) and 240,000
! bytes (PA 1.X architecture). Sibcalls are always limited to
240,000 bytes.
! Distances are measured from the beginnings of functions when using the
@option{-ffunction-sections} option, or when using the @option{-mgas}
and @option{-mno-portable-runtime} options together under HP-UX with
the SOM linker.
! It is normally not desirable to use this option, because it degrades
performance. However, it may be useful in large applications,
! particularly ones built with partial linking.
! The types of long calls used depend on the capabilities of the
! assembler and linker and the type of code being generated. The
impact on systems that support long absolute calls, and long pic
symbol-difference or pc-relative calls should be relatively small.
However, an indirect call is used on 32-bit ELF systems in pic code
***************
*** 8326,8338 ****
@item -static
@opindex static
The HP-UX implementation of setlocale in libc has a dependency on
! libdld.sl. There isn't an archive version of libdld.sl. Thus,
when the @option{-static} option is specified, special link options
are needed to resolve this dependency.
! On HP-UX 10 and later, the GCC driver adds the necessary options to
! link with libdld.sl when the @option{-static} option is specified.
! This causes the resulting binary to be dynamic. On the 64-bit port,
the linkers generate dynamic binaries by default in any case. The
@option{-nolibdld} option can be used to prevent the GCC driver from
adding these link options.
--- 8319,8331 ----
@item -static
@opindex static
The HP-UX implementation of setlocale in libc has a dependency on
! libdld.sl. There is no archive version of libdld.sl. Thus,
when the @option{-static} option is specified, special link options
are needed to resolve this dependency.
! On HP-UX 10 and later, the GCC driver adds the options necessary to
! link with libdld.sl when the @option{-static} option is specified,
! causing the resulting binary to be dynamic. In the 64-bit port,
the linkers generate dynamic binaries by default in any case. The
@option{-nolibdld} option can be used to prevent the GCC driver from
adding these link options.
***************
*** 8361,8370 ****
Assume the defaults for the machine type @var{cpu-type} for some of
the other options, including instruction scheduling, floating point
support, and addressing modes. The choices for @var{cpu-type} are
! @samp{ka}, @samp{kb}, @samp{mc}, @samp{ca}, @samp{cf},
@samp{sa}, and @samp{sb}.
- The default is
- @samp{kb}.
@item -mnumerics
@itemx -msoft-float
--- 8354,8361 ----
Assume the defaults for the machine type @var{cpu-type} for some of
the other options, including instruction scheduling, floating point
support, and addressing modes. The choices for @var{cpu-type} are
! @samp{ka}, @samp{kb} (default), @samp{mc}, @samp{ca}, @samp{cf},
@samp{sa}, and @samp{sb}.
@item -mnumerics
@itemx -msoft-float
***************
*** 8378,8385 ****
@itemx -mno-leaf-procedures
@opindex mleaf-procedures
@opindex mno-leaf-procedures
! Do (or do not) attempt to alter leaf procedures to be callable with the
! @code{bal} instruction as well as @code{call}. This will result in more
efficient code for explicit calls when the @code{bal} instruction can be
substituted by the assembler or linker, but less efficient code in other
cases, such as calls via function pointers, or using a linker that doesn't
--- 8369,8376 ----
@itemx -mno-leaf-procedures
@opindex mleaf-procedures
@opindex mno-leaf-procedures
! Do (do not) attempt to alter leaf procedures to be callable with the
! @code{bal} instruction as well as with @code{call}. This will result in
more
efficient code for explicit calls when the @code{bal} instruction can be
substituted by the assembler or linker, but less efficient code in other
cases, such as calls via function pointers, or using a linker that doesn't
***************
*** 8389,8409 ****
@itemx -mno-tail-call
@opindex mtail-call
@opindex mno-tail-call
! Do (or do not) make additional attempts (beyond those of the
machine-independent portions of the compiler) to optimize tail-recursive
! calls into branches. You may not want to do this because the detection of
! cases where this is not valid is not totally complete. The default is
! @option{-mno-tail-call}.
@item -mcomplex-addr
@itemx -mno-complex-addr
@opindex mcomplex-addr
@opindex mno-complex-addr
! Assume (or do not assume) that the use of a complex addressing mode is a
! win on this implementation of the i960. Complex addressing modes may not
! be worthwhile on the K-series, but they definitely are on the C-series.
! The default is currently @option{-mcomplex-addr} for all processors except
! the CB and address@hidden
@item -mcode-align
@itemx -mno-code-align
--- 8380,8399 ----
@itemx -mno-tail-call
@opindex mtail-call
@opindex mno-tail-call
! Do (do not) make additional attempts (beyond those of the
machine-independent portions of the compiler) to optimize tail-recursive
! calls into branches. You may not want to do this, because the detection of
! invalid cases not complete. The default is @option{-mno-tail-call}.
@item -mcomplex-addr
@itemx -mno-complex-addr
@opindex mcomplex-addr
@opindex mno-complex-addr
! Assume (do not assume) that the use of a complex addressing mode is
! advantageous on this implementation of the i960. Complex addressing
! modes may not be worthwhile on the K-series, but they definitely are
! worthwhile on the C-series. The default is currently
! @option{-mcomplex-addr} for all processors except the CB and address@hidden
@item -mcode-align
@itemx -mno-code-align
***************
*** 8438,8444 ****
@itemx -mno-strict-align
@opindex mstrict-align
@opindex mno-strict-align
! Do not permit (do permit) unaligned accesses.
@item -mold-align
@opindex mold-align
--- 8428,8434 ----
@itemx -mno-strict-align
@opindex mstrict-align
@opindex mno-strict-align
! Do not (do) permit unaligned accesses.
@item -mold-align
@opindex mold-align
***************
*** 8448,8465 ****
@item -mlong-double-64
@opindex mlong-double-64
Implement type @samp{long double} as 64-bit floating point numbers.
! Without the option @samp{long double} is implemented by 80-bit
! floating point numbers. The only reason we have it because there is
! no 128-bit @samp{long double} support in @samp{fp-bit.c} yet. So it
! is only useful for people using soft-float targets. Otherwise, we
! should recommend against use of it.
@end table
! @node DEC Alpha Options
! @subsection DEC Alpha Options
! These @samp{-m} options are defined for the DEC Alpha implementations:
@table @gcctabopt
@item -mno-soft-float
--- 8438,8455 ----
@item -mlong-double-64
@opindex mlong-double-64
Implement type @samp{long double} as 64-bit floating point numbers.
! Without the option, @samp{long double} is implemented as 80-bit
! floating point numbers. We have this option only because there is
! no 128-bit @samp{long double} support yet in @samp{fp-bit.c}. So it
! is useful only for people using soft-float targets, and otherwise we
! recommend against it.
@end table
! @node HP Alpha Options
! @subsection HP Alpha Options
! These @samp{-m} options are defined for the HP Alpha implementations:
@table @gcctabopt
@item -mno-soft-float
***************
*** 8470,8482 ****
floating-point operations. When @option{-msoft-float} is specified,
functions in @file{libgcc.a} will be used to perform floating-point
operations. Unless they are replaced by routines that emulate the
! floating-point operations, or compiled in such a way as to call such
emulations routines, these routines will issue floating-point
! operations. If you are compiling for an Alpha without floating-point
operations, you must ensure that the library is built so as not to call
them.
! Note that Alpha implementations without floating-point operations are
required to have floating-point registers.
@item -mfp-reg
--- 8460,8472 ----
floating-point operations. When @option{-msoft-float} is specified,
functions in @file{libgcc.a} will be used to perform floating-point
operations. Unless they are replaced by routines that emulate the
! floating-point operations, or compiled so as to call such
emulations routines, these routines will issue floating-point
! operations. If you are compiling for an Alpha without floating-point
operations, you must ensure that the library is built so as not to call
them.
! Alpha implementations without floating-point operations are
required to have floating-point registers.
@item -mfp-reg
***************
*** 8492,8516 ****
compiled with @option{-mno-fp-regs} must also be compiled with that
option.
! A typical use of this option is building a kernel that does not use,
! and hence need not save and restore, any floating-point registers.
@item -mieee
@opindex mieee
The Alpha architecture implements floating-point hardware optimized for
maximum performance. It is mostly compliant with the IEEE floating
point standard. However, for full compliance, software assistance is
! required. This option generates code fully IEEE compliant code
@emph{except} that the @var{inexact-flag} is not maintained (see below).
If this option is turned on, the preprocessor macro @code{_IEEE_FP} is
defined during compilation. The resulting code is less efficient but is
! able to correctly support denormalized numbers and exceptional IEEE
values such as not-a-number and plus/minus infinity. Other Alpha
compilers call this option @option{-ieee_with_no_inexact}.
@item -mieee-with-inexact
@opindex mieee-with-inexact
! This is like @option{-mieee} except the generated code also maintains
the IEEE @var{inexact-flag}. Turning on this option causes the
generated code to implement fully-compliant IEEE math. In addition to
@code{_IEEE_FP}, @code{_IEEE_FP_EXACT} is defined as a preprocessor
--- 8482,8506 ----
compiled with @option{-mno-fp-regs} must also be compiled with that
option.
! A typical use of this option is to build a kernel that does not use,
! and hence need not save and restore, floating-point registers.
@item -mieee
@opindex mieee
The Alpha architecture implements floating-point hardware optimized for
maximum performance. It is mostly compliant with the IEEE floating
point standard. However, for full compliance, software assistance is
! required. This option generates fully IEEE-compliant code
@emph{except} that the @var{inexact-flag} is not maintained (see below).
If this option is turned on, the preprocessor macro @code{_IEEE_FP} is
defined during compilation. The resulting code is less efficient but is
! able to support correctly denormalized numbers and exceptional IEEE
values such as not-a-number and plus/minus infinity. Other Alpha
compilers call this option @option{-ieee_with_no_inexact}.
@item -mieee-with-inexact
@opindex mieee-with-inexact
! This is like @option{-mieee} except that the generated code also maintains
the IEEE @var{inexact-flag}. Turning on this option causes the
generated code to implement fully-compliant IEEE math. In addition to
@code{_IEEE_FP}, @code{_IEEE_FP_EXACT} is defined as a preprocessor
***************
*** 8522,8547 ****
@item address@hidden
@opindex mfp-trap-mode
! This option controls what floating-point related traps are enabled.
Other Alpha compilers call this option @option{-fptm @var{trap-mode}}.
The trap mode can be set to one of four values:
@table @samp
@item n
! This is the default (normal) setting. The only traps that are enabled
! are the ones that cannot be disabled in software (e.g., division by zero
! trap).
@item u
! In addition to the traps enabled by @samp{n}, underflow traps are enabled
! as well.
@item su
Like @samp{su}, but the instructions are marked to be safe for software
! completion (see Alpha architecture manual for details).
@item sui
! Like @samp{su}, but inexact traps are enabled as well.
@end table
@item address@hidden
--- 8512,8535 ----
@item address@hidden
@opindex mfp-trap-mode
! This option controls what floating-point-related traps are enabled.
Other Alpha compilers call this option @option{-fptm @var{trap-mode}}.
The trap mode can be set to one of four values:
@table @samp
@item n
! This is the default (normal) setting. The only traps enabled
! are the ones that cannot be disabled in software (e.g., division by zero).
@item u
! Enable underflow traps in addition to the traps enabled by @samp{n}.
@item su
Like @samp{su}, but the instructions are marked to be safe for software
! completion (see the Alpha architecture manual for details).
@item sui
! Like @samp{su}, but inexact traps are also enabled.
@end table
@item address@hidden
***************
*** 8552,8617 ****
@table @samp
@item n
! Normal IEEE rounding mode. Floating point numbers are rounded towards
! the nearest machine number or towards the even machine number in case
of a tie.
@item m
Round towards minus infinity.
@item c
! Chopped rounding mode. Floating point numbers are rounded towards zero.
@item d
! Dynamic rounding mode. A field in the floating point control register
! (@var{fpcr}, see Alpha architecture reference manual) controls the
rounding mode in effect. The C library initializes this register for
rounding towards plus infinity. Thus, unless your program modifies the
! @var{fpcr}, @samp{d} corresponds to round towards plus infinity.
@end table
@item address@hidden
@opindex mtrap-precision
! In the Alpha architecture, floating point traps are imprecise. This
! means without software assistance it is impossible to recover from a
! floating trap and program execution normally needs to be terminated.
! GCC can generate code that can assist operating system trap handlers
! in determining the exact location that caused a floating point trap.
Depending on the requirements of an application, different levels of
! precisions can be selected:
@table @samp
@item p
! Program precision. This option is the default and means a trap handler
can only identify which program caused a floating point exception.
@item f
! Function precision. The trap handler can determine the function that
caused a floating point exception.
@item i
! Instruction precision. The trap handler can determine the exact
instruction that caused a floating point exception.
@end table
! Other Alpha compilers provide the equivalent options called
@option{-scope_safe} and @option{-resumption_safe}.
@item -mieee-conformant
@opindex mieee-conformant
! This option marks the generated code as IEEE conformant. You must not
! use this option unless you also specify @option{-mtrap-precision=i} and
either
! @option{-mfp-trap-mode=su} or @option{-mfp-trap-mode=sui}. Its only effect
! is to emit the line @samp{.eflag 48} in the function prologue of the
! generated assembly file. Under DEC Unix, this has the effect that
! IEEE-conformant math library routines will be linked in.
@item -mbuild-constants
@opindex mbuild-constants
! Normally GCC examines a 32- or 64-bit integer constant to
! see if it can construct it from smaller constants in two or three
! instructions. If it cannot, it will output the constant as a literal and
! generate code to load it from the data segment at runtime.
Use this option to require GCC to construct @emph{all} integer constants
using code, even if it takes more instructions (the maximum is six).
--- 8540,8606 ----
@table @samp
@item n
! Normal IEEE rounding mode: floating point numbers are rounded towards
! the nearest machine number, or in a tie, towards the even machine number.
of a tie.
@item m
Round towards minus infinity.
@item c
! Chopped rounding mode: floating point numbers are rounded towards zero.
@item d
! Dynamic rounding mode: a field in the floating point control register
! (@var{fpcr}, see the Alpha architecture reference manual) controls the
rounding mode in effect. The C library initializes this register for
rounding towards plus infinity. Thus, unless your program modifies the
! @var{fpcr}, @samp{d} corresponds to rounding towards plus infinity.
@end table
@item address@hidden
@opindex mtrap-precision
! In the Alpha architecture, floating point traps are imprecise, so
! it is impossible without software assistance to recover from a
! floating trap, and program execution normally needs to be terminated.
! GCC can generate code to assist operating system trap handlers
! to determine the exact location that caused a floating point trap.
Depending on the requirements of an application, different levels of
! precision can be selected:
@table @samp
@item p
! Program precision (the default): a trap handler
can only identify which program caused a floating point exception.
@item f
! Function precision: a trap handler can determine the function that
caused a floating point exception.
@item i
! Instruction precision: the trap handler can determine the exact
instruction that caused a floating point exception.
@end table
! Other Alpha compilers provide equivalent options called
@option{-scope_safe} and @option{-resumption_safe}.
@item -mieee-conformant
@opindex mieee-conformant
! This option marks the generated code as conforming to the IEEE
! standard by emitting the line @samp{.eflag 48} in the function
! prologue of the generated assembly file. You must not use this option
! unless you also specify @option{-mtrap-precision=i} and either
! @option{-mfp-trap-mode=su} or @option{-mfp-trap-mode=sui}. Under DEC
! Unix, this has the effect of linking in th IEEE-conformant math
! library routines.
@item -mbuild-constants
@opindex mbuild-constants
! GCC normally tests whether it can construct a 32-bit or 64-bit integer
! constant from smaller constants in two or three instructions. If it
! cannot, it creates the constant as a literal and generates code to
! load it from the data segment at runtime.
Use this option to require GCC to construct @emph{all} integer constants
using code, even if it takes more instructions (the maximum is six).
***************
*** 8645,8652 ****
@opindex mno-max
Indicate whether GCC should generate code to use the optional BWX,
CIX, FIX and MAX instruction sets. The default is to use the instruction
! sets supported by the CPU type specified via @option{-mcpu=} option or that
! of the CPU on which GCC was built if none was specified.
@item -mfloat-vax
@itemx -mfloat-ieee
--- 8634,8641 ----
@opindex mno-max
Indicate whether GCC should generate code to use the optional BWX,
CIX, FIX and MAX instruction sets. The default is to use the instruction
! sets supported by the CPU type specified via @option{-mcpu=}, by
! default the CPU on which GCC was itself built.
@item -mfloat-vax
@itemx -mfloat-ieee
***************
*** 8660,8670 ****
@opindex mexplicit-relocs
@opindex mno-explicit-relocs
Older Alpha assemblers provided no way to generate symbol relocations
! except via assembler macros. Use of these macros does not allow
optimal instruction scheduling. GNU binutils as of version 2.12
! supports a new syntax that allows the compiler to explicitly mark
which relocations should apply to which instructions. This option
! is mostly useful for debugging, as GCC detects the capabilities of
the assembler when it is built and sets the default accordingly.
@item -msmall-data
--- 8649,8659 ----
@opindex mexplicit-relocs
@opindex mno-explicit-relocs
Older Alpha assemblers provided no way to generate symbol relocations
! except via assembler macros. Using these macros prevents
optimal instruction scheduling. GNU binutils as of version 2.12
! supports a new syntax that allows the compiler to mark explicitly
which relocations should apply to which instructions. This option
! is mostly useful for debugging, since GCC detects the capabilities of
the assembler when it is built and sets the default accordingly.
@item -msmall-data
***************
*** 8673,8686 ****
@opindex mlarge-data
When @option{-mexplicit-relocs} is in effect, static data is
accessed via @dfn{gp-relative} relocations. When @option{-msmall-data}
! is used, objects 8 bytes long or smaller are placed in a @dfn{small data
area}
(the @code{.sdata} and @code{.sbss} sections) and are accessed via
! 16-bit relocations off of the @code{$gp} register. This limits the
size of the small data area to 64KB, but allows the variables to be
! directly accessed via a single instruction.
! The default is @option{-mlarge-data}. With this option the data area
! is limited to just below 2GB. Programs that require more than 2GB of
data must use @code{malloc} or @code{mmap} to allocate the data in the
heap instead of in the program's data segment.
--- 8662,8675 ----
@opindex mlarge-data
When @option{-mexplicit-relocs} is in effect, static data is
accessed via @dfn{gp-relative} relocations. When @option{-msmall-data}
! is used, objects up to 8 bytes long are placed in a @dfn{small data area}
(the @code{.sdata} and @code{.sbss} sections) and are accessed via
! 16-bit relocations off the @code{$gp} register. This limits the
size of the small data area to 64KB, but allows the variables to be
! accessed directly via single instructions.
! The default is @option{-mlarge-data}, which limits the data area
! to just below 2GB. Programs that require more than 2GB of
data must use @code{malloc} or @code{mmap} to allocate the data in the
heap instead of in the program's data segment.
***************
*** 8750,8772 ****
@itemx L3
@itemx main
The compiler contains estimates of the number of clock cycles for
! ``typical'' EV4 & EV5 hardware for the Level 1, 2 & 3 caches
(also called Dcache, Scache, and Bcache), as well as to main memory.
! Note that L3 is only valid for EV5.
@end table
@end table
! @node DEC Alpha/VMS Options
! @subsection DEC Alpha/VMS Options
! These @samp{-m} options are defined for the DEC Alpha/VMS implementations:
@table @gcctabopt
@item -mvms-return-codes
@opindex mvms-return-codes
Return VMS condition codes from main. The default is to return POSIX
! style condition (e.g.@ error) codes.
@end table
@node H8/300 Options
--- 8739,8761 ----
@itemx L3
@itemx main
The compiler contains estimates of the number of clock cycles for
! ``typical'' EV4 and EV5 hardware for the level 1, 2 & 3 caches
(also called Dcache, Scache, and Bcache), as well as to main memory.
! L3 is valid only for EV5.
@end table
@end table
! @node HP Alpha/VMS Options
! @subsection HP Alpha/VMS Options
! These @samp{-m} options are defined for the HP Alpha/VMS implementations:
@table @gcctabopt
@item -mvms-return-codes
@opindex mvms-return-codes
Return VMS condition codes from main. The default is to return POSIX
! style condition (i.e., error) codes.
@end table
@node H8/300 Options
***************
*** 8805,8813 ****
@item -malign-300
@opindex malign-300
On the H8/300H and H8S, use the same alignment rules as for the H8/300.
! The default for the H8/300H and H8S is to align longs and floats on 4
! byte boundaries.
! @option{-malign-300} causes them to be aligned on 2 byte boundaries.
This option has no effect on the H8/300.
@end table
--- 8794,8802 ----
@item -malign-300
@opindex malign-300
On the H8/300H and H8S, use the same alignment rules as for the H8/300.
! The default for the H8/300H and H8S is to align longs and floats on
! 4-byte boundaries.
! @option{-malign-300} causes them to be aligned on 2-byte boundaries.
This option has no effect on the H8/300.
@end table
***************
*** 8835,8846 ****
@item -m4-nofpu
@opindex m4-nofpu
! Generate code for the SH4 without a floating-point unit.
@item -m4-single-only
@opindex m4-single-only
! Generate code for the SH4 with a floating-point unit that only
! supports single-precision arithmetic.
@item -m4-single
@opindex m4-single
--- 8824,8835 ----
@item -m4-nofpu
@opindex m4-nofpu
! Generate code for the SH4 without floating-point unit.
@item -m4-single-only
@opindex m4-single-only
! Generate code for the SH4 with a floating-point unit that supports
! only single-precision arithmetic.
@item -m4-single
@opindex m4-single
***************
*** 8853,8867 ****
@item -mb
@opindex mb
! Compile code for the processor in big endian mode.
@item -ml
@opindex ml
! Compile code for the processor in little endian mode.
@item -mdalign
@opindex mdalign
! Align doubles at 64-bit boundaries. Note that this changes the calling
conventions, and thus some functions from the standard C library will
not work unless you recompile it first with @option{-mdalign}.
--- 8842,8856 ----
@item -mb
@opindex mb
! Compile code for the processor in big-endian mode.
@item -ml
@opindex ml
! Compile code for the processor in little-endian mode.
@item -mdalign
@opindex mdalign
! Align doubles at 64-bit boundaries. This changes the calling
conventions, and thus some functions from the standard C library will
not work unless you recompile it first with @option{-mdalign}.
***************
*** 8999,9009 ****
DBcond(D), instructions. This is enabled by default for the C4x. To be
on the safe side, this is disabled for the C3x, since the maximum
iteration count on the C3x is @math{2^{23} + 1} (but who iterates loops
more than
! @math{2^{23}} times on the C3x?). Note that GCC will try to reverse a
loop so
! that it can utilize the decrement and branch instruction, but will give
up if there is more than one memory reference in the loop. Thus a loop
where the loop counter is decremented can generate slightly more
! efficient code, in cases where the RPTB instruction cannot be utilized.
@item -mdp-isr-reload
@itemx -mparanoid
--- 8988,8998 ----
DBcond(D), instructions. This is enabled by default for the C4x. To be
on the safe side, this is disabled for the C3x, since the maximum
iteration count on the C3x is @math{2^{23} + 1} (but who iterates loops
more than
! @math{2^{23}} times on the C3x?). GCC tries to reverse a loop so
! that it can use the decrement and branch instruction, but gives
up if there is more than one memory reference in the loop. Thus a loop
where the loop counter is decremented can generate slightly more
! efficient code, in cases where the RPTB instruction cannot be used.
@item -mdp-isr-reload
@itemx -mparanoid
***************
*** 9020,9026 ****
@opindex mmpyi
@opindex mno-mpyi
For the C3x use the 24-bit MPYI instruction for integer multiplies
! instead of a library call to guarantee 32-bit results. Note that if one
of the operands is a constant, then the multiplication will be performed
using shifts and adds. If the @option{-mmpyi} option is not specified
for the C3x,
then squaring operations are performed inline instead of a library call.
--- 9009,9015 ----
@opindex mmpyi
@opindex mno-mpyi
For the C3x use the 24-bit MPYI instruction for integer multiplies
! instead of a library call to guarantee 32-bit results. If one
of the operands is a constant, then the multiplication will be performed
using shifts and adds. If the @option{-mmpyi} option is not specified
for the C3x,
then squaring operations are performed inline instead of a library call.
***************
*** 9057,9063 ****
count can be guaranteed to be less than the value @var{count}, GCC will
emit a RPTS instruction instead of a address@hidden If no value is specified,
then a RPTS will be emitted even if the loop count cannot be determined
! at compile time. Note that the repeated instruction following RPTS does
not have to be reloaded from memory each iteration, thus freeing up the
CPU buses for operands. However, since interrupts are blocked by this
instruction, it is disabled by default.
--- 9046,9052 ----
count can be guaranteed to be less than the value @var{count}, GCC will
emit a RPTS instruction instead of a address@hidden If no value is specified,
then a RPTS will be emitted even if the loop count cannot be determined
! at compile time. The repeated instruction following RPTS does
not have to be reloaded from memory each iteration, thus freeing up the
CPU buses for operands. However, since interrupts are blocked by this
instruction, it is disabled by default.
***************
*** 9179,9185 ****
@item -mno-app-regs
@opindex -mno-app-regs
This option will cause r2 and r5 to be treated as fixed registers.
!
@item -mv850e
@opindex -mv850e
Specify that the target processor is the V850E. The preprocessor
--- 9168,9174 ----
@item -mno-app-regs
@opindex -mno-app-regs
This option will cause r2 and r5 to be treated as fixed registers.
!
@item -mv850e
@opindex -mv850e
Specify that the target processor is the V850E. The preprocessor
***************
*** 9209,9219 ****
@table @gcctabopt
@item -EL
@opindex EL
! Compile code for little endian mode. This is the default.
@item -EB
@opindex EB
! Compile code for big endian mode.
@item -mmangle-cpu
@opindex mmangle-cpu
--- 9198,9208 ----
@table @gcctabopt
@item -EL
@opindex EL
! Compile code for little-endian mode. This is the default.
@item -EB
@opindex EB
! Compile code for big-endian mode.
@item -mmangle-cpu
@opindex mmangle-cpu
***************
*** 9308,9314 ****
@itemx -mno-ieee-compare
@opindex mieee-compare
@opindex mno-ieee-compare
! Control whether or not the compiler uses IEEE floating point
comparisons. These handle correctly the case where the result of a
comparison is unordered.
@strong{Warning:} the requisite kernel support may not be available.
--- 9297,9303 ----
@itemx -mno-ieee-compare
@opindex mieee-compare
@opindex mno-ieee-compare
! Control whether the compiler uses IEEE floating point
comparisons. These handle correctly the case where the result of a
comparison is unordered.
@strong{Warning:} the requisite kernel support may not be available.
***************
*** 9344,9350 ****
This option takes its name from the 680x0 @code{rtd} instruction.
-
@item -mregparam
@opindex mregparam
Use a different function-calling convention where the first two arguments
--- 9333,9338 ----
***************
*** 9383,9389 ****
Assume code will be loaded in the first 512MB of virtual address space.
This is the default for all platforms.
-
@end table
@node AVR Options
--- 9371,9376 ----
***************
*** 9476,9488 ****
@itemx -mno-wide-bitfields
@opindex mwide-bitfields
@opindex mno-wide-bitfields
! Always treat bit-fields as int-sized.
@item -m4byte-functions
@itemx -mno-4byte-functions
@opindex m4byte-functions
@opindex mno-4byte-functions
! Force all functions to be aligned to a four byte boundary.
@item -mcallgraph-data
@itemx -mno-callgraph-data
--- 9463,9475 ----
@itemx -mno-wide-bitfields
@opindex mwide-bitfields
@opindex mno-wide-bitfields
! Always treat bit fields as int-sized.
@item -m4byte-functions
@itemx -mno-4byte-functions
@opindex m4byte-functions
@opindex mno-4byte-functions
! Force all functions to be aligned to a 4-byte boundary.
@item -mcallgraph-data
@itemx -mno-callgraph-data
***************
*** 9500,9506 ****
@itemx -mbig-endian
@opindex mlittle-endian
@opindex mbig-endian
! Generate code for a little endian target.
@item -m210
@itemx -m340
--- 9487,9493 ----
@itemx -mbig-endian
@opindex mlittle-endian
@opindex mbig-endian
! Generate code for a little-endian target.
@item -m210
@itemx -m340
***************
*** 9518,9528 ****
@table @gcctabopt
@item -mbig-endian
@opindex mbig-endian
! Generate code for a big endian target. This is the default for address@hidden
@item -mlittle-endian
@opindex mlittle-endian
! Generate code for a little endian target. This is the default for AIX5
and Linux.
@item -mgnu-as
--- 9505,9515 ----
@table @gcctabopt
@item -mbig-endian
@opindex mbig-endian
! Generate code for a big-endian target. This is the default for address@hidden
@item -mlittle-endian
@opindex mlittle-endian
! Generate code for a little-endian target. This is the default for AIX5
and Linux.
@item -mgnu-as
***************
*** 9544,9550 ****
@item -mno-pic
@opindex mno-pic
Generate code that does not use a global pointer register. The result
! is not position independent code, and violates the IA-64 address@hidden
@item -mvolatile-asm-stop
@itemx -mno-volatile-asm-stop
--- 9531,9537 ----
@item -mno-pic
@opindex mno-pic
Generate code that does not use a global pointer register. The result
! is not position-independent code, and violates the IA-64 address@hidden
@item -mvolatile-asm-stop
@itemx -mno-volatile-asm-stop
***************
*** 9682,9688 ****
@itemx -mno-backchain
@opindex mbackchain
@opindex mno-backchain
! Generate (or do not generate) code which maintains an explicit
backchain within the stack frame that points to the caller's frame.
This is currently needed to allow debugging. The default is to
generate the backchain.
--- 9669,9675 ----
@itemx -mno-backchain
@opindex mbackchain
@opindex mno-backchain
! Generate (do not generate) code which maintains an explicit
backchain within the stack frame that points to the caller's frame.
This is currently needed to allow debugging. The default is to
generate the backchain.
***************
*** 9691,9697 ****
@itemx -mno-small-exec
@opindex msmall-exec
@opindex mno-small-exec
! Generate (or do not generate) code using the @code{bras} instruction
to do subroutine calls.
This only works reliably if the total executable size does not
exceed 64k. The default is to use the @code{basr} instruction instead,
--- 9678,9684 ----
@itemx -mno-small-exec
@opindex msmall-exec
@opindex mno-small-exec
! Generate (do not generate) code using the @code{bras} instruction
to do subroutine calls.
This only works reliably if the total executable size does not
exceed 64k. The default is to use the @code{basr} instruction instead,
***************
*** 9712,9718 ****
@itemx -mno-mvcle
@opindex mmvcle
@opindex mno-mvcle
! Generate (or do not generate) code using the @code{mvcle} instruction
to perform block moves. When @option{-mno-mvcle} is specified,
use a @code{mvc} loop instead. This is the default.
--- 9699,9705 ----
@itemx -mno-mvcle
@opindex mmvcle
@opindex mno-mvcle
! Generate (do not generate) code using the @code{mvcle} instruction
to perform block moves. When @option{-mno-mvcle} is specified,
use a @code{mvc} loop instead. This is the default.
***************
*** 9720,9726 ****
@itemx -mno-debug
@opindex mdebug
@opindex mno-debug
! Print (or do not print) additional debug information when compiling.
The default is to not print debug information.
@end table
--- 9707,9713 ----
@itemx -mno-debug
@opindex mdebug
@opindex mno-debug
! Print (do not print) additional debug information when compiling.
The default is to not print debug information.
@end table
***************
*** 9807,9815 ****
@opindex m32-bit
@opindex m16-bit
@opindex m8-bit
! Similar to the stack- data- and const-align options above, these options
! arrange for stack-frame, writable data and constants to all be 32-bit,
! 16-bit or 8-bit aligned. The default is 32-bit alignment.
@item -mno-prologue-epilogue
@itemx -mprologue-epilogue
--- 9794,9802 ----
@opindex m32-bit
@opindex m16-bit
@opindex m8-bit
! Similar to the stack-, data-, and const-align options above, these options
! arrange for the stack frame, writable data and constants all to be 32-bit
! (16-bit, 8-bit) aligned. The default is 32-bit alignment.
@item -mno-prologue-epilogue
@itemx -mprologue-epilogue
***************
*** 10182,10282 ****
Do not mark ABI switches in e_flags.
@item -mcond-move
- @opindex mcond-move
-
- Enable the use of conditional-move instructions (default).
-
- This switch is mainly for debugging the compiler and will likely be removed
- in a future version.
-
@item -mno-cond-move
@opindex mno-cond-move
! Disable the use of conditional-move instructions.
! This switch is mainly for debugging the compiler and will likely be removed
! in a future version.
@item -mscc
- @opindex mscc
-
- Enable the use of conditional set instructions (default).
-
- This switch is mainly for debugging the compiler and will likely be removed
- in a future version.
-
@item -mno-scc
@opindex mno-scc
! Disable the use of conditional set instructions.
! This switch is mainly for debugging the compiler and will likely be removed
! in a future version.
@item -mcond-exec
- @opindex mcond-exec
-
- Enable the use of conditional execution (default).
-
- This switch is mainly for debugging the compiler and will likely be removed
- in a future version.
-
@item -mno-cond-exec
@opindex mno-cond-exec
! Disable the use of conditional execution.
! This switch is mainly for debugging the compiler and will likely be removed
! in a future version.
@item -mvliw-branch
- @opindex mvliw-branch
-
- Run a pass to pack branches into VLIW instructions (default).
-
- This switch is mainly for debugging the compiler and will likely be removed
- in a future version.
-
@item -mno-vliw-branch
@opindex mno-vliw-branch
! Do not run a pass to pack branches into VLIW instructions.
! This switch is mainly for debugging the compiler and will likely be removed
! in a future version.
@item -mmulti-cond-exec
- @opindex mmulti-cond-exec
-
- Enable optimization of @code{&&} and @code{||} in conditional execution
- (default).
-
- This switch is mainly for debugging the compiler and will likely be removed
- in a future version.
-
@item -mno-multi-cond-exec
@opindex mno-multi-cond-exec
! Disable optimization of @code{&&} and @code{||} in conditional execution.
! This switch is mainly for debugging the compiler and will likely be removed
! in a future version.
@item -mnested-cond-exec
- @opindex mnested-cond-exec
-
- Enable nested conditional execution optimizations (default).
-
- This switch is mainly for debugging the compiler and will likely be removed
- in a future version.
-
@item -mno-nested-cond-exec
@opindex mno-nested-cond-exec
! Disable nested conditional execution optimizations.
! This switch is mainly for debugging the compiler and will likely be removed
! in a future version.
@item -mtomcat-stats
@opindex mtomcat-stats
--- 10169,10235 ----
Do not mark ABI switches in e_flags.
@item -mcond-move
@item -mno-cond-move
+ @opindex mcond-move
@opindex mno-cond-move
! Enable (disable) the use of conditional-move instructions; enable by
default.
! These switches are intended for debugging the compiler,
! and will probably be removed in a future version.
@item -mscc
@item -mno-scc
+ @opindex mscc
@opindex mno-scc
! Enable (disable) the use of conditional set instructions; enable by default.
! These switches are intended for debugging the compiler,
! and will probably be removed in a future version.
@item -mcond-exec
@item -mno-cond-exec
+ @opindex mcond-exec
@opindex mno-cond-exec
! Enable (disable) the use of conditional execution; enable by default.
! These switches are intended for debugging the compiler,
! and will probably be removed in a future version.
@item -mvliw-branch
@item -mno-vliw-branch
+ @opindex mvliw-branch
@opindex mno-vliw-branch
! Run (do not run) a pass to pack branches into VLIW instructions; run
! by default.
! These switches are intended for debugging the compiler,
! and will probably be removed in a future version.
@item -mmulti-cond-exec
@item -mno-multi-cond-exec
+ @opindex mmulti-cond-exec
@opindex mno-multi-cond-exec
! Enable (disable) optimization of @code{&&} and @code{||} in
! conditional execution; enable by default.
! These switches are intended for debugging the compiler,
! and will probably be removed in a future version.
@item -mnested-cond-exec
@item -mno-nested-cond-exec
+ @opindex mnested-cond-exec
@opindex mno-nested-cond-exec
! Enable (disable) nested conditional execution optimizations; enable by
! default.
! These switches are intended for debugging the compiler,
! and will probably be removed in a future version.
@item -mtomcat-stats
@opindex mtomcat-stats
***************
*** 10299,10305 ****
The Xtensa architecture is designed to support many different
configurations. The compiler's default options can be set to match a
particular Xtensa configuration by copying a configuration file into the
! GCC sources when building address@hidden The options below may be used to
override the default options.
@table @gcctabopt
--- 10252,10258 ----
The Xtensa architecture is designed to support many different
configurations. The compiler's default options can be set to match a
particular Xtensa configuration by copying a configuration file into the
! GCC sources when building address@hidden Use the options below to
override the default options.
@table @gcctabopt
***************
*** 10307,10326 ****
@itemx -mlittle-endian
@opindex mbig-endian
@opindex mlittle-endian
! Specify big-endian or little-endian byte ordering for the target Xtensa
processor.
@item -mdensity
@itemx -mno-density
@opindex mdensity
@opindex mno-density
! Enable or disable use of the optional Xtensa code density instructions.
@item -mmac16
@itemx -mno-mac16
@opindex mmac16
@opindex mno-mac16
! Enable or disable use of the Xtensa MAC16 option. When enabled, GCC
will generate MAC16 instructions from standard C code, with the
limitation that it will use neither the MR register file nor any
instruction that operates on the MR registers. When this option is
--- 10260,10279 ----
@itemx -mlittle-endian
@opindex mbig-endian
@opindex mlittle-endian
! Specify big-endian (little-endian) byte ordering for the target Xtensa
processor.
@item -mdensity
@itemx -mno-density
@opindex mdensity
@opindex mno-density
! Enable (disable) use of the optional Xtensa code density instructions.
@item -mmac16
@itemx -mno-mac16
@opindex mmac16
@opindex mno-mac16
! Enable (disable) use of the Xtensa MAC16 option. When MAC16 is enabled, GCC
will generate MAC16 instructions from standard C code, with the
limitation that it will use neither the MR register file nor any
instruction that operates on the MR registers. When this option is
***************
*** 10332,10349 ****
@itemx -mno-mul16
@opindex mmul16
@opindex mno-mul16
! Enable or disable use of the 16-bit integer multiplier option. When
enabled, the compiler will generate 16-bit multiply instructions for
multiplications of 16 bits or smaller in standard C code. When this
option is disabled, the compiler will either use 32-bit multiply or
! MAC16 instructions if they are available or generate library calls to
perform the multiply operations using shifts and adds.
@item -mmul32
@itemx -mno-mul32
@opindex mmul32
@opindex mno-mul32
! Enable or disable use of the 32-bit integer multiplier option. When
enabled, the compiler will generate 32-bit multiply instructions for
multiplications of 32 bits or smaller in standard C code. When this
option is disabled, the compiler will generate library calls to perform
--- 10285,10302 ----
@itemx -mno-mul16
@opindex mmul16
@opindex mno-mul16
! Enable (disable) use of the 16-bit integer multiplier option. When it is
enabled, the compiler will generate 16-bit multiply instructions for
multiplications of 16 bits or smaller in standard C code. When this
option is disabled, the compiler will either use 32-bit multiply or
! MAC16 instructions if they are available, or generate library calls to
perform the multiply operations using shifts and adds.
@item -mmul32
@itemx -mno-mul32
@opindex mmul32
@opindex mno-mul32
! Enable (disable) use of the 32-bit integer multiplier option. When it is
enabled, the compiler will generate 32-bit multiply instructions for
multiplications of 32 bits or smaller in standard C code. When this
option is disabled, the compiler will generate library calls to perform
***************
*** 10354,10390 ****
@itemx -mno-nsa
@opindex mnsa
@opindex mno-nsa
! Enable or disable use of the optional normalization shift amount
(@code{NSA}) instructions to implement the built-in @code{ffs} function.
@item -mminmax
@itemx -mno-minmax
@opindex mminmax
@opindex mno-minmax
! Enable or disable use of the optional minimum and maximum value
instructions.
@item -msext
@itemx -mno-sext
@opindex msext
@opindex mno-sext
! Enable or disable use of the optional sign extend (@code{SEXT})
instruction.
@item -mbooleans
@itemx -mno-booleans
@opindex mbooleans
@opindex mno-booleans
! Enable or disable support for the boolean register file used by Xtensa
! coprocessors. This is not typically useful by itself but may be
! required for other options that make use of the boolean registers (e.g.,
the floating-point option).
@item -mhard-float
@itemx -msoft-float
@opindex mhard-float
@opindex msoft-float
! Enable or disable use of the floating-point option. When enabled, GCC
generates floating-point instructions for 32-bit @code{float}
operations. When this option is disabled, GCC generates library calls
to emulate 32-bit floating-point operations using integer instructions.
--- 10307,10343 ----
@itemx -mno-nsa
@opindex mnsa
@opindex mno-nsa
! Enable (disable) use of the optional normalization shift amount
(@code{NSA}) instructions to implement the built-in @code{ffs} function.
@item -mminmax
@itemx -mno-minmax
@opindex mminmax
@opindex mno-minmax
! Enable (disable) use of the optional minimum and maximum value
instructions.
@item -msext
@itemx -mno-sext
@opindex msext
@opindex mno-sext
! Enable (disable) use of the optional sign extend (@code{SEXT})
instruction.
@item -mbooleans
@itemx -mno-booleans
@opindex mbooleans
@opindex mno-booleans
! Enable (disable) support for the boolean register file used by Xtensa
! coprocessors. This is not typically useful by itself, but may be
! required for other options that use the boolean registers (e.g.,
the floating-point option).
@item -mhard-float
@itemx -msoft-float
@opindex mhard-float
@opindex msoft-float
! Enable (disable) use of the floating-point option. When it is enabled, GCC
generates floating-point instructions for 32-bit @code{float}
operations. When this option is disabled, GCC generates library calls
to emulate 32-bit floating-point operations using integer instructions.
***************
*** 10395,10401 ****
@itemx -mno-fused-madd
@opindex mfused-madd
@opindex mno-fused-madd
! Enable or disable use of fused multiply/add and multiply/subtract
instructions in the floating-point option. This has no effect if the
floating-point option is not also enabled. Disabling fused multiply/add
and multiply/subtract instructions forces the compiler to use separate
--- 10348,10354 ----
@itemx -mno-fused-madd
@opindex mfused-madd
@opindex mno-fused-madd
! Enable (disable) use of fused multiply/add and multiply/subtract
instructions in the floating-point option. This has no effect if the
floating-point option is not also enabled. Disabling fused multiply/add
and multiply/subtract instructions forces the compiler to use separate
***************
*** 10404,10411 ****
required: the fused multiply add/subtract instructions do not round the
intermediate result, thereby producing results with @emph{more} bits of
precision than specified by the IEEE standard. Disabling fused multiply
! add/subtract instructions also ensures that the program output is not
! sensitive to the compiler's ability to combine multiply and add/subtract
operations.
@item -mserialize-volatile
--- 10357,10364 ----
required: the fused multiply add/subtract instructions do not round the
intermediate result, thereby producing results with @emph{more} bits of
precision than specified by the IEEE standard. Disabling fused multiply
! add/subtract instructions also ensures that results are
! insensitive to the compiler's ability to combine multiply and add/subtract
operations.
@item -mserialize-volatile
***************
*** 10421,10468 ****
@itemx -mno-text-section-literals
@opindex mtext-section-literals
@opindex mno-text-section-literals
! Control the treatment of literal pools. The default is
! @option{-mno-text-section-literals}, which places literals in a separate
! section in the output file. This allows the literal pool to be placed
! in a data RAM/ROM, and it also allows the linker to combine literal
! pools from separate object files to remove redundant literals and
! improve code size. With @option{-mtext-section-literals}, the literals
! are interspersed in the text section in order to keep them as close as
! possible to their references. This may be necessary for large assembly
! files.
@item -mtarget-align
@itemx -mno-target-align
@opindex mtarget-align
@opindex mno-target-align
! When this option is enabled, GCC instructs the assembler to
! automatically align instructions to reduce branch penalties at the
! expense of some code density. The assembler attempts to widen density
! instructions to align branch targets and the instructions following call
! instructions. If there are not enough preceding safe density
! instructions to align a target, no widening will be performed. The
! default is @option{-mtarget-align}. These options do not affect the
treatment of auto-aligned instructions like @code{LOOP}, which the
! assembler will always align, either by widening density instructions or
! by inserting no-op instructions.
@item -mlongcalls
@itemx -mno-longcalls
@opindex mlongcalls
@opindex mno-longcalls
! When this option is enabled, GCC instructs the assembler to translate
! direct calls to indirect calls unless it can determine that the target
! of a direct call is in the range allowed by the call instruction. This
! translation typically occurs for calls to functions in other source
! files. Specifically, the assembler translates a direct @code{CALL}
! instruction into an @code{L32R} followed by a @code{CALLX} instruction.
! The default is @option{-mno-longcalls}. This option should be used in
! programs where the call target can potentially be out of range. This
! option is implemented in the assembler, not the compiler, so the
! assembly code generated by GCC will still show direct call
! instructions---look at the disassembled object code to see the actual
! instructions. Note that the assembler will use an indirect call for
! every cross-file call, not just those that really will be out of range.
@end table
@node Code Gen Options
--- 10374,10424 ----
@itemx -mno-text-section-literals
@opindex mtext-section-literals
@opindex mno-text-section-literals
! Place (do not place) literals in a separate section in the output
! file; the default is @option{-mno-text-section-literals}. This allows
! the literal pool to be placed in a data RAM/ROM, and it also allows
! the linker to combine literal pools from separate object files to
! remove redundant literals and improve code size. With
! @option{-mtext-section-literals}, literals are interspersed in text
! sections to keep them as close as possible to their references. This
! may be necessary for large assembly files.
@item -mtarget-align
@itemx -mno-target-align
@opindex mtarget-align
@opindex mno-target-align
! GCC instructs (does not instruct) the assembler to align instructions
! to reduce branch penalties at the expense of some code density. The
! default is @option{-mtarget-align}.
!
! The assembler attempts to widen density instructions to align branch
! targets and the instructions following call instructions. If there
! are not enough preceding safe density instructions to align a target,
! no widening will be performed. These options do not affect the
treatment of auto-aligned instructions like @code{LOOP}, which the
! assembler will always align, either by widening density instructions
! or by inserting no-op instructions.
@item -mlongcalls
@itemx -mno-longcalls
@opindex mlongcalls
@opindex mno-longcalls
! GCC instructs (does not instruct) the assembler to translate direct
! calls to indirect calls unless it can determine that the target of a
! direct call is in the range allowed by the call instruction; the
! default is @option{-mno-longcalls}. This translation typically occurs
! for calls to functions in other source files. This option should be
! used in programs where the call target can potentially be out of
! range.
!
! Specifically, the assembler translates (does not translate) a direct
! @code{CALL} instruction into an @code{L32R} followed by a @code{CALLX}
! instruction. This option is implemented in the assembler, not the
! compiler, so the assembly code generated by GCC will still show direct
! call instructions---look at the disassembled object code to see the
! actual instructions. The assembler will use an indirect call for
! every cross-file call, not just those that really will be out of
! range.
@end table
@node Code Gen Options
***************
*** 10483,10531 ****
@table @gcctabopt
@item -fbounds-check
@opindex fbounds-check
! For front-ends that support it, generate additional code to check that
indices used to access arrays are within the declared range. This is
! currently only supported by the Java and Fortran 77 front-ends, where
! this option defaults to true and false respectively.
@item -ftrapv
@opindex ftrapv
! This option generates traps for signed overflow on addition, subtraction,
multiplication operations.
@item -fexceptions
@opindex fexceptions
! 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
! specify this option, GCC will enable it by default for languages like
! C++ which normally require exception handling, and disable it for
! languages like C that do not normally require it. However, you may need
! to enable this option when compiling C code that needs to interoperate
! properly with exception handlers written in C++. You may also wish to
! disable this option if you are compiling older C++ programs that don't
! use exception handling.
@item -fnon-call-exceptions
@opindex fnon-call-exceptions
! Generate code that allows trapping instructions to throw exceptions.
! Note that this requires platform-specific runtime support that does
! not exist everywhere. Moreover, it only allows @emph{trapping}
! instructions to throw exceptions, i.e.@: memory references or floating
point instructions. It does not allow exceptions to be thrown from
arbitrary signal handlers such as @code{SIGALRM}.
@item -funwind-tables
@opindex funwind-tables
Similar to @option{-fexceptions}, except that it will just generate any
needed
! static data, but will not affect the generated code in any other way.
You will normally not enable this option; instead, a language processor
that needs this handling would enable it on your behalf.
@item -fasynchronous-unwind-tables
@opindex funwind-tables
! Generate unwind table in dwarf2 format, if supported by target machine. The
table is exact at each instruction boundary, so it can be used for stack
unwinding from asynchronous events (such as debugger or garbage collector).
--- 10439,10488 ----
@table @gcctabopt
@item -fbounds-check
@opindex fbounds-check
! For front ends that support it, generate additional code to check that
indices used to access arrays are within the declared range. This is
! currently supported only by the Java and Fortran 77 front ends, where
! the option defaults to true and false respectively.
@item -ftrapv
@opindex ftrapv
! Generate traps for signed overflow on addition, subtraction, and
multiplication operations.
@item -fexceptions
@opindex fexceptions
! Enable exception handling; generates extra code needed to propagate
! exceptions. For some targets, this implies that GCC will generate
! frame-unwinding information for all functions, which can add
! significant to the size of data, although it has no effect on
! execution. If you do not specify this option, GCC will enable it by
! default for languages like C++ which normally require exception
! handling, and disable it for languages like C that do not normally
! require it. However, you may need to enable this option when
! compiling C code that needs to interoperate properly with exception
! handlers written in C++. You may also wish to disable this option if
! you are compiling older C++ programs that don't use exception
! handling.
@item -fnon-call-exceptions
@opindex fnon-call-exceptions
! Generate code to allow trapping instructions to throw exceptions.
! This requires platform-specific runtime support that does
! not exist everywhere. Moreover, it allows only @emph{trapping}
! instructions to throw exceptions, i.e.@, memory references or floating
point instructions. It does not allow exceptions to be thrown from
arbitrary signal handlers such as @code{SIGALRM}.
@item -funwind-tables
@opindex funwind-tables
Similar to @option{-fexceptions}, except that it will just generate any
needed
! static data without affecting the generated code in any other way.
You will normally not enable this option; instead, a language processor
that needs this handling would enable it on your behalf.
@item -fasynchronous-unwind-tables
@opindex funwind-tables
! Generate unwinding tables in dwarf2 format, if supported by target
machine. The
table is exact at each instruction boundary, so it can be used for stack
unwinding from asynchronous events (such as debugger or garbage collector).
***************
*** 10557,10568 ****
If you specify neither @option{-fpcc-struct-return} nor
@option{-freg-struct-return}, GCC defaults to whichever convention is
standard for the target. If there is no standard convention, GCC
! defaults to @option{-fpcc-struct-return}, except on targets where GCC is
! the principal compiler. In those cases, we can choose the standard, and
! we chose the more efficient register return alternative.
@strong{Warning:} code compiled with the @option{-freg-struct-return}
! switch is not binary compatible with code compiled with the
@option{-fpcc-struct-return} switch.
Use it to conform to a non-default application binary interface.
--- 10514,10525 ----
If you specify neither @option{-fpcc-struct-return} nor
@option{-freg-struct-return}, GCC defaults to whichever convention is
standard for the target. If there is no standard convention, GCC
! defaults to @option{-fpcc-struct-return} except on targets where GCC is
! the principal compiler. In those cases we can choose the standard, and
! we chose the more efficient register return.
@strong{Warning:} code compiled with the @option{-freg-struct-return}
! switch is incompatible with code compiled with the
@option{-fpcc-struct-return} switch.
Use it to conform to a non-default application binary interface.
***************
*** 10573,10579 ****
will be equivalent to the smallest integer type which has enough room.
@strong{Warning:} the @option{-fshort-enums} switch causes GCC to generate
! code that is not binary compatible with code generated without that switch.
Use it to conform to a non-default application binary interface.
@item -fshort-double
--- 10530,10536 ----
will be equivalent to the smallest integer type which has enough room.
@strong{Warning:} the @option{-fshort-enums} switch causes GCC to generate
! code incompatible with code generated without that switch.
Use it to conform to a non-default application binary interface.
@item -fshort-double
***************
*** 10581,10603 ****
Use the same size for @code{double} as for @code{float}.
@strong{Warning:} the @option{-fshort-double} switch causes GCC to generate
! code that is not binary compatible with code generated without that switch.
Use it to conform to a non-default application binary interface.
@item -fshort-wchar
@opindex fshort-wchar
! Override the underlying type for @samp{wchar_t} to be @samp{short
unsigned int} instead of the default for the target. This option is
useful for building programs to run under address@hidden
@strong{Warning:} the @option{-fshort-wchar} switch causes GCC to generate
! code that is not binary compatible with code generated without that switch.
Use it to conform to a non-default application binary interface.
@item -fshared-data
@opindex fshared-data
Requests that the data and address@hidden variables of this
! compilation be shared data rather than private data. The distinction
makes sense only on certain operating systems, where shared data is
shared between processes running the same program, while private data
exists in one copy per process.
--- 10538,10560 ----
Use the same size for @code{double} as for @code{float}.
@strong{Warning:} the @option{-fshort-double} switch causes GCC to generate
! code incompatible with code generated without that switch.
Use it to conform to a non-default application binary interface.
@item -fshort-wchar
@opindex fshort-wchar
! Force the underlying type for @samp{wchar_t} to be @samp{short
unsigned int} instead of the default for the target. This option is
useful for building programs to run under address@hidden
@strong{Warning:} the @option{-fshort-wchar} switch causes GCC to generate
! code incompatible with code generated without that switch.
Use it to conform to a non-default application binary interface.
@item -fshared-data
@opindex fshared-data
Requests that the data and address@hidden variables of this
! compilation be shared data rather than private. The distinction
makes sense only on certain operating systems, where shared data is
shared between processes running the same program, while private data
exists in one copy per process.
***************
*** 10642,10648 ****
debugging the compiler itself).
@option{-fno-verbose-asm}, the default, causes the
! extra information to be omitted and is useful when comparing two assembler
files.
@item -fvolatile
--- 10599,10605 ----
debugging the compiler itself).
@option{-fno-verbose-asm}, the default, causes the
! extra information to be omitted, making it useful when comparing two
assembler
files.
@item -fvolatile
***************
*** 10684,10690 ****
If supported for the target machine, emit position-independent code,
suitable for dynamic linking and avoiding any limit on the size of the
global offset table. This option makes a difference on the m68k, m88k,
! and the SPARC.
Position-independent code requires special support, and therefore works
only on certain machines.
--- 10641,10647 ----
If supported for the target machine, emit position-independent code,
suitable for dynamic linking and avoiding any limit on the size of the
global offset table. This option makes a difference on the m68k, m88k,
! and SPARC.
Position-independent code requires special support, and therefore works
only on certain machines.
***************
*** 10692,10736 ****
@item address@hidden
@opindex ffixed
Treat the register named @var{reg} as a fixed register; generated code
! should never refer to it (except perhaps as a stack pointer, frame
pointer or in some other fixed role).
@var{reg} must be the name of a register. The register names accepted
are machine-specific and are defined in the @code{REGISTER_NAMES}
macro in the machine description macro file.
! This flag does not have a negative form, because it specifies a
three-way choice.
@item address@hidden
@opindex fcall-used
Treat the register named @var{reg} as an allocable register that is
! clobbered by function calls. It may be allocated for temporaries or
! variables that do not live across a call. Functions compiled this way
will not save and restore the register @var{reg}.
It is an error to used this flag with the frame pointer or stack pointer.
Use of this flag for other registers that have fixed pervasive roles in
the machine's execution model will produce disastrous results.
! This flag does not have a negative form, because it specifies a
three-way choice.
@item address@hidden
@opindex fcall-saved
Treat the register named @var{reg} as an allocable register saved by
functions. It may be allocated even for temporaries or variables that
! live across a call. Functions compiled this way will save and restore
the register @var{reg} if they use it.
! It is an error to used this flag with the frame pointer or stack pointer.
! Use of this flag for other registers that have fixed pervasive roles in
! the machine's execution model will produce disastrous results.
!
! A different sort of disaster will result from the use of this flag for
! a register in which function values may be returned.
! This flag does not have a negative form, because it specifies a
three-way choice.
@item -fpack-struct
--- 10649,10693 ----
@item address@hidden
@opindex ffixed
Treat the register named @var{reg} as a fixed register; generated code
! should never refer to it (except perhaps as a stack pointer or frame
pointer or in some other fixed role).
@var{reg} must be the name of a register. The register names accepted
are machine-specific and are defined in the @code{REGISTER_NAMES}
macro in the machine description macro file.
! This flag has no negative form, because it specifies a
three-way choice.
@item address@hidden
@opindex fcall-used
Treat the register named @var{reg} as an allocable register that is
! written into by function calls. It may be allocated for temporaries or
! variables that do not persist across a call. Functions compiled this way
will not save and restore the register @var{reg}.
It is an error to used this flag with the frame pointer or stack pointer.
Use of this flag for other registers that have fixed pervasive roles in
the machine's execution model will produce disastrous results.
! This flag has no negative form, because it specifies a
three-way choice.
@item address@hidden
@opindex fcall-saved
Treat the register named @var{reg} as an allocable register saved by
functions. It may be allocated even for temporaries or variables that
! persist across a call. Functions compiled this way will save and restore
the register @var{reg} if they use it.
! It is an error to use this flag with the frame pointer or stack
! pointer. Use of this flag for other registers that have fixed
! pervasive roles in the machine's execution model will produce
! disastrous results. A different sort of disaster will result from
! using this flag for a register in which function values may be
! returned.
! This flag has no negative form, because it specifies a
three-way choice.
@item -fpack-struct
***************
*** 10738,10745 ****
Pack all structure members together without holes.
@strong{Warning:} the @option{-fpack-struct} switch causes GCC to generate
! code that is not binary compatible with code generated without that switch.
! Additionally, it makes the code suboptimal.
Use it to conform to a non-default application binary interface.
@item -finstrument-functions
--- 10695,10702 ----
Pack all structure members together without holes.
@strong{Warning:} the @option{-fpack-struct} switch causes GCC to generate
! code incompatible with code generated without that switch.
! Additionally, it may generate code that runs slower.
Use it to conform to a non-default application binary interface.
@item -finstrument-functions
***************
*** 10760,10766 ****
@end example
The first argument is the address of the start of the current function,
! which may be looked up exactly in the symbol table.
This instrumentation is also done for functions expanded inline in other
functions. The profiling calls will indicate where, conceptually, the
--- 10717,10723 ----
@end example
The first argument is the address of the start of the current function,
! which may be found exactly in the symbol table.
This instrumentation is also done for functions expanded inline in other
functions. The profiling calls will indicate where, conceptually, the
***************
*** 10769,10780 ****
function are expanded inline, this may mean an additional expansion of
code size. If you use @samp{extern inline} in your C code, an
addressable version of such functions must be provided. (This is
! normally the case anyways, but if you get lucky and the optimizer always
expands the functions inline, you might have gotten away without
providing static copies.)
A function may be given the attribute @code{no_instrument_function}, in
! which case this instrumentation will not be done. This can be used, for
example, for the profiling functions listed above, high-priority
interrupt routines, and any functions from which the profiling functions
cannot safely be called (perhaps signal handlers, if the profiling
--- 10726,10737 ----
function are expanded inline, this may mean an additional expansion of
code size. If you use @samp{extern inline} in your C code, an
addressable version of such functions must be provided. (This is
! normally the case anyway, but if you get lucky and the optimizer always
expands the functions inline, you might have gotten away without
providing static copies.)
A function may be given the attribute @code{no_instrument_function}, in
! which case this instrumentation will not be generated. This can be used,
for
example, for the profiling functions listed above, high-priority
interrupt routines, and any functions from which the profiling functions
cannot safely be called (perhaps signal handlers, if the profiling
***************
*** 10782,10794 ****
@item -fstack-check
@opindex fstack-check
! Generate code to verify that you do not go beyond the boundary of the
stack. You should specify this flag if you are running in an
! environment with multiple threads, but only rarely need to specify it in
! a single-threaded environment since stack overflow is automatically
detected on nearly all systems if there is only one stack.
! Note that this switch does not actually cause checking to be done; the
operating system must do that. The switch causes generation of code
to ensure that the operating system sees the stack being extended.
--- 10739,10751 ----
@item -fstack-check
@opindex fstack-check
! Generate code to verify that you remain within the boundary of the
stack. You should specify this flag if you are running in an
! environment with multiple threads, but you only rarely need specify it in
! a single-threaded environment, since stack overflow is automatically
detected on nearly all systems if there is only one stack.
! This switch does not actually cause checking to be done; the
operating system must do that. The switch causes generation of code
to ensure that the operating system sees the stack being extended.
***************
*** 10798,10814 ****
@opindex fstack-limit-register
@opindex fstack-limit-symbol
@opindex fno-stack-limit
! Generate code to ensure that the stack does not grow beyond a certain value,
! either the value of a register or the address of a symbol. If the stack
! would grow beyond the value, a signal is raised. For most targets,
! the signal is raised before the stack overruns the boundary, so
! it is possible to catch the signal without taking special precautions.
For instance, if the stack starts at absolute address @samp{0x80000000}
and grows downwards, you can use the flags
@option{-fstack-limit-symbol=__stack_limit} and
@option{-Wl,--defsym,__stack_limit=0x7ffe0000} to enforce a stack limit
! of address@hidden Note that this may only work with the GNU linker.
@cindex aliasing of parameters
@cindex parameters, aliased
--- 10755,10772 ----
@opindex fstack-limit-register
@opindex fstack-limit-symbol
@opindex fno-stack-limit
! Generate code to ensure that the stack does not grow beyond a certain
! value, either the value of a register or the address of a symbol. A
! signal is raised if the stack would grow beyond the value. For most
! targets the signal is raised before the stack overruns the boundary,
! so it is possible to catch the signal without taking special
! precautions.
For instance, if the stack starts at absolute address @samp{0x80000000}
and grows downwards, you can use the flags
@option{-fstack-limit-symbol=__stack_limit} and
@option{-Wl,--defsym,__stack_limit=0x7ffe0000} to enforce a stack limit
! of address@hidden This may only work with the GNU linker.
@cindex aliasing of parameters
@cindex parameters, aliased
***************
*** 10822,10832 ****
parameters and global data.
@option{-fargument-alias} specifies that arguments (parameters) may
! alias each other and may alias global address@hidden
@option{-fargument-noalias} specifies that arguments do not alias
each other, but may alias global address@hidden
! @option{-fargument-noalias-global} specifies that arguments do not
! alias each other and do not alias global storage.
Each language will automatically use whatever option is required by
the language standard. You should not need to use these options yourself.
--- 10780,10790 ----
parameters and global data.
@option{-fargument-alias} specifies that arguments (parameters) may
! alias each other and also global address@hidden
@option{-fargument-noalias} specifies that arguments do not alias
each other, but may alias global address@hidden
! @option{-fargument-noalias-global} specifies that arguments
! alias neither each other nor global storage.
Each language will automatically use whatever option is required by
the language standard. You should not need to use these options yourself.
***************
*** 10838,10850 ****
is to help link with legacy assembly code.
@strong{Warning:} the @option{-fleading-underscore} switch causes GCC to
! generate code that is not binary compatible with code generated without that
switch. Use it to conform to a non-default application binary interface.
Not all targets provide complete support for this switch.
@item address@hidden
! Alter the thread-local storage model to be used (@pxref{Thread-Local}).
! The @var{model} argument should be one of @code{global-dynamic},
@code{local-dynamic}, @code{initial-exec} or @code{local-exec}.
The default without @option{-fpic} is @code{initial-exec}; with
--- 10796,10808 ----
is to help link with legacy assembly code.
@strong{Warning:} the @option{-fleading-underscore} switch causes GCC to
! generate code incompatible with code generated without that
switch. Use it to conform to a non-default application binary interface.
Not all targets provide complete support for this switch.
@item address@hidden
! Alter which thread-local storage model to use (@pxref{Thread-Local});
! the @var{model} argument must be one of @code{global-dynamic},
@code{local-dynamic}, @code{initial-exec} or @code{local-exec}.
The default without @option{-fpic} is @code{initial-exec}; with
***************
*** 10860,10869 ****
@c man begin ENVIRONMENT
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
! aspects of the compilation environment.
! Note that you can also specify places to search using options such as
@option{-B}, @option{-I} and @option{-L} (@pxref{Directory Options}). These
take precedence over places specified using environment variables, which
in turn take precedence over those specified by the configuration of
address@hidden
--- 10818,10827 ----
@c man begin ENVIRONMENT
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 specify other
! elements of the compilation environment.
! You can also specify places to search using options such as
@option{-B}, @option{-I} and @option{-L} (@pxref{Directory Options}). These
take precedence over places specified using environment variables, which
in turn take precedence over those specified by the configuration of
address@hidden
***************
*** 10888,10895 ****
@c @findex LC_TIME
@findex LC_ALL
@cindex locale
! These environment variables control the way that GCC uses
! localization information that allow GCC to work with different
national conventions. GCC inspects the locale categories
@env{LC_CTYPE} and @env{LC_MESSAGES} if it has been configured to do
so. These locale categories can be set to any value supported by your
--- 10846,10853 ----
@c @findex LC_TIME
@findex LC_ALL
@cindex locale
! These environment variables control how GCC uses
! localization information to work with different
national conventions. GCC inspects the locale categories
@env{LC_CTYPE} and @env{LC_MESSAGES} if it has been configured to do
so. These locale categories can be set to any value supported by your
***************
*** 10908,10914 ****
If the @env{LC_ALL} environment variable is set, it overrides the value
of @env{LC_CTYPE} and @env{LC_MESSAGES}; otherwise, @env{LC_CTYPE}
and @env{LC_MESSAGES} default to the value of the @env{LANG}
! environment variable. If none of these variables are set, GCC
defaults to traditional C English behavior.
@item TMPDIR
--- 10866,10872 ----
If the @env{LC_ALL} environment variable is set, it overrides the value
of @env{LC_CTYPE} and @env{LC_MESSAGES}; otherwise, @env{LC_CTYPE}
and @env{LC_MESSAGES} default to the value of the @env{LANG}
! environment variable. If none of these variables is set, GCC
defaults to traditional C English behavior.
@item TMPDIR
***************
*** 10922,10928 ****
@item GCC_EXEC_PREFIX
@findex GCC_EXEC_PREFIX
If @env{GCC_EXEC_PREFIX} is set, it specifies a prefix to use in the
! names of the subprograms executed by the compiler. No slash is added
when this prefix is combined with the name of a subprogram, but you can
specify a prefix that ends with a slash if you wish.
--- 10880,10886 ----
@item GCC_EXEC_PREFIX
@findex GCC_EXEC_PREFIX
If @env{GCC_EXEC_PREFIX} is set, it specifies a prefix to use in the
! names of the subprograms executed by the compiler. No slash (``/'') is
added
when this prefix is combined with the name of a subprogram, but you can
specify a prefix that ends with a slash if you wish.
***************
*** 10953,10981 ****
@item COMPILER_PATH
@findex COMPILER_PATH
! The value of @env{COMPILER_PATH} is a colon-separated list of
! directories, much like @env{PATH}. GCC tries the directories thus
! specified when searching for subprograms, if it can't find the
! subprograms using @env{GCC_EXEC_PREFIX}.
@item LIBRARY_PATH
@findex LIBRARY_PATH
! The value of @env{LIBRARY_PATH} is a colon-separated list of
! directories, much like @env{PATH}. When configured as a native compiler,
! GCC tries the directories thus specified when searching for special
! linker files, if it can't find them using @env{GCC_EXEC_PREFIX}. Linking
! using GCC also uses these directories when searching for ordinary
! libraries for the @option{-l} option (but directories specified with
! @option{-L} come first).
@item LANG
@findex LANG
@cindex locale definition
! 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,
! the following values for @env{LANG} are recognized:
@table @samp
@item C-JIS
--- 10911,10939 ----
@item COMPILER_PATH
@findex COMPILER_PATH
! The value of @env{COMPILER_PATH} is a list of directories separated by
! colons (``:''), much like @env{PATH}. If it can't find subprograms
! using @env{GCC_EXEC_PREFIX}, GCC tries all these directories in order
! from left to right when searching for them.
@item LIBRARY_PATH
@findex LIBRARY_PATH
! The value of @env{COMPILER_PATH} is a list of directories separated by
! colons (``:''), much like @env{PATH}. If it can't find special linker
! files using @env{GCC_EXEC_PREFIX}, GCC tries all these directories in
! order from left to right when searching for them. Linking using GCC
! also uses these directories when searching for ordinary libraries for
! the @option{-l} option (but directories specified with @option{-L}
! come first).
@item LANG
@findex LANG
@cindex locale definition
! This variable is used to pass locale information to the
! compiler---used, for instance, 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, it recognizes these values for @env{LANG}:
@table @samp
@item C-JIS
***************
*** 10986,10998 ****
Recognize EUCJP characters.
@end table
! If @env{LANG} is not defined, or if it has some other value, then the
compiler will use mblen and mbtowc as defined by the default locale to
recognize and translate multibyte characters.
@end table
@noindent
! Some additional environments variables affect the behavior of the
preprocessor.
@include cppenv.texi
--- 10944,10956 ----
Recognize EUCJP characters.
@end table
! If @env{LANG} is undefined or if it has some other value, then the
compiler will use mblen and mbtowc as defined by the default locale to
recognize and translate multibyte characters.
@end table
@noindent
! Some additional environment variables affect the behavior of the
preprocessor.
@include cppenv.texi
***************
*** 11005,11029 ****
The program @code{protoize} is an optional part of address@hidden You can use
it to add prototypes to a program, thus converting the program to ISO
C in one respect. The companion program @code{unprotoize} does the
! reverse: it removes argument types from any prototypes that are found.
When you run these programs, you must specify a set of source files as
! command line arguments. The conversion programs start out by compiling
these files to see what functions they define. The information gathered
about a file @var{foo} is saved in a file named @address@hidden
! After scanning comes actual conversion. The specified files are all
! eligible to be converted; any files they include (whether sources or
! just headers) are eligible as well.
But not all the eligible files are converted. By default,
@code{protoize} and @code{unprotoize} convert only source and header
! files in the current directory. You can specify additional directories
! whose files should be converted with the @option{-d @var{directory}}
! option. You can also specify particular files to exclude with the
! @option{-x @var{file}} option. A file is converted if it is eligible, its
! directory name matches one of the specified directory names, and its
! name within the directory has not been excluded.
Basic conversion with @code{protoize} consists of rewriting most
function definitions and function declarations to specify the types of
--- 10963,10988 ----
The program @code{protoize} is an optional part of address@hidden You can use
it to add prototypes to a program, thus converting the program to ISO
C in one respect. The companion program @code{unprotoize} does the
! reverse: it removes argument types from any prototypes it finds.
When you run these programs, you must specify a set of source files as
! command line arguments. The conversion programs begin by compiling
these files to see what functions they define. The information gathered
about a file @var{foo} is saved in a file named @address@hidden
! After scanning comes the actual conversion. The specified files are
! all eligible to be converted, along with any files they include,
! whether sources or headers.
But not all the eligible files are converted. By default,
@code{protoize} and @code{unprotoize} convert only source and header
! files in the current directory, but using the @option{-d
! @var{directory}} option you can specify additional directories whose
! files should be converted. You can also specify particular files to
! exclude with the @option{-x @var{file}} option. A file is converted
! if it is eligible, its directory name matches one of the specified
! directory names, and its name within the directory has not been
! excluded.
Basic conversion with @code{protoize} consists of rewriting most
function definitions and function declarations to specify the types of
***************
*** 11031,11037 ****
functions.
@code{protoize} optionally inserts prototype declarations at the
! beginning of the source file, to make them available for any calls that
precede the function's definition. Or it can insert prototype
declarations with block scope in the blocks where undeclared functions
are called.
--- 10990,10996 ----
functions.
@code{protoize} optionally inserts prototype declarations at the
! beginning of the source file to make them available for any calls that
precede the function's definition. Or it can insert prototype
declarations with block scope in the blocks where undeclared functions
are called.
***************
*** 11040,11047 ****
function declarations to remove any argument types, and rewriting
function definitions to the old-style pre-ISO form.
! Both conversion programs print a warning for any function declaration or
! definition that they can't convert. You can suppress these warnings
with @option{-q}.
The output from @code{protoize} or @code{unprotoize} replaces the
--- 10999,11006 ----
function declarations to remove any argument types, and rewriting
function definitions to the old-style pre-ISO form.
! Both conversion programs print warnings for function declarations or
! definitions that they can't convert. You can suppress these warnings
with @option{-q}.
The output from @code{protoize} or @code{unprotoize} replaces the
***************
*** 11060,11066 ****
@table @code
@item -B @var{directory}
! Look for the file @file{SYSCALLS.c.X} in @var{directory}, instead of the
usual directory (normally @file{/usr/local/lib}). This file contains
prototype information about standard system functions. This option
applies only to @code{protoize}.
--- 11019,11025 ----
@table @code
@item -B @var{directory}
! Look for the file @file{SYSCALLS.c.X} in @var{directory}, instead of in the
usual directory (normally @file{/usr/local/lib}). This file contains
prototype information about standard system functions. This option
applies only to @code{protoize}.
***************
*** 11068,11083 ****
@item -c @var{compilation-options}
Use @var{compilation-options} as the options when running @command{gcc} to
produce the @samp{.X} files. The special option @option{-aux-info} is
! always passed in addition, to tell @command{gcc} to write a @samp{.X} file.
! Note that the compilation options must be given as a single argument to
! @code{protoize} or @code{unprotoize}. If you want to specify several
! @command{gcc} options, you must quote the entire set of compilation options
! to make them a single word in the shell.
! There are certain @command{gcc} arguments that you cannot use, because they
would produce the wrong kind of output. These include @option{-g},
! @option{-O}, @option{-c}, @option{-S}, and @option{-o} If you include
these in
the @var{compilation-options}, they are ignored.
@item -C
--- 11027,11043 ----
@item -c @var{compilation-options}
Use @var{compilation-options} as the options when running @command{gcc} to
produce the @samp{.X} files. The special option @option{-aux-info} is
! always automatically passed to tell @command{gcc} to write a @samp{.X} file.
! The compilation options must be given as a single argument to
! @code{protoize} or @code{unprotoize}, so to specify two or more
! @command{gcc} options, you must quote the entire set of compilation
! options using the appropriate command-line quoting technique to
! present them to @code{protoize} as a single parameter.
! You cannot use certain @command{gcc} arguments which
would produce the wrong kind of output. These include @option{-g},
! @option{-O}, @option{-c}, @option{-S}, and @option{-o}. If you include
these in
the @var{compilation-options}, they are ignored.
@item -C
***************
*** 11103,11109 ****
one space instead, use @option{-i " "}.
@item -k
! Keep the @samp{.X} files. Normally, they are deleted after conversion
is finished.
@item -l
--- 11063,11069 ----
one space instead, use @option{-i " "}.
@item -k
! Keep the @samp{.X} files. They are normally deleted after conversion
is finished.
@item -l
***************
*** 11125,11134 ****
@file{gcc} is used.
@item -q
! Work quietly. Most warnings are suppressed.
@item -v
! Print the version number, just like @option{-v} for @command{gcc}.
@end table
If you need special compiler options to compile one of your program's
--- 11085,11094 ----
@file{gcc} is used.
@item -q
! Work quietly, suppressing most warnings.
@item -v
! Display the version number, just like @option{-v} for @command{gcc}.
@end table
If you need special compiler options to compile one of your program's
***************
*** 11145,11152 ****
@end example
@noindent
! You need to include the special files along with the rest in the
! @code{protoize} command, even though their @samp{.X} files already
exist, because otherwise they won't get converted.
@xref{Protoize Caveats}, for more information on how to use
--- 11105,11112 ----
@end example
@noindent
! You must include the special files along with the rest in the
! @code{protoize} command even though their @samp{.X} files already
exist, because otherwise they won't get converted.
@xref{Protoize Caveats}, for more information on how to use
*** cppenv.texi.~1~ Thu Aug 15 00:34:50 2002
--- cppenv.texi Thu May 15 13:54:12 2003
***************
*** 20,27 ****
Each variable's value is a list of directories separated by a special
character, much like @env{PATH}, in which to look for header files.
The special character, @code{PATH_SEPARATOR}, is target-dependent and
! determined at GCC build time. For Windows-based targets it is a
! semicolon, and for almost all other targets it is a colon.
@env{CPATH} specifies a list of directories to be searched as if
specified with @option{-I}, but after any paths given with @option{-I}
--- 20,27 ----
Each variable's value is a list of directories separated by a special
character, much like @env{PATH}, in which to look for header files.
The special character, @code{PATH_SEPARATOR}, is target-dependent and
! determined when GCC is built. For Windows-based targets it is the
! semicolon (``;''), and for almost all other targets it is the colon (``:'').
@env{CPATH} specifies a list of directories to be searched as if
specified with @option{-I}, but after any paths given with @option{-I}
***************
*** 66,72 ****
@ifclear cppmanual
(@pxref{Preprocessor Options}),
@end ifclear
! with an optional @option{-MT} switch too.
@item SUNPRO_DEPENDENCIES
@cindex dependencies for make as output
--- 66,72 ----
@ifclear cppmanual
(@pxref{Preprocessor Options}),
@end ifclear
! along with an optional @option{-MT} switch.
@item SUNPRO_DEPENDENCIES
@cindex dependencies for make as output
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [Bug-gnupress] Context diffs for 007, 009 and 014,
Peter Kaiser <=