@setfilename gcc
@settitle GNU project C and C++ compiler
@c man begin SYNOPSIS
-gcc [@samp{-c}|@samp{-S}|@samp{-E}] [@samp{-std=}@var{standard}]
- [@samp{-g}] [@samp{-pg}] [@samp{-O}@var{level}]
- [@samp{-W}@var{warn}...] [@samp{-pedantic}]
- [@samp{-I}@var{dir}...] [@samp{-L}@var{dir}...]
- [@samp{-D}@var{macro}[=@var{defn}]...] [@samp{-U}@var{macro}]
- [@samp{-f}@var{option}...] [@samp{-m}@var{machine-option}...]
- [@samp{-o} @var{outfile}] @var{infile}...
+gcc [@option{-c}|@option{-S}|@option{-E}] [@option{-std=}@var{standard}]
+ [@option{-g}] [@option{-pg}] [@option{-O}@var{level}]
+ [@option{-W}@var{warn}@dots{}] [@option{-pedantic}]
+ [@option{-I}@var{dir}@dots{}] [@option{-L}@var{dir}@dots{}]
+ [@option{-D}@var{macro}[=@var{defn}]@dots{}] [@option{-U}@var{macro}]
+ [@option{-f}@var{option}@dots{}] [@option{-m}@var{machine-option}@dots{}]
+ [@option{-o} @var{outfile}] @var{infile}@dots{}
Only the most useful options are listed here; see below for the
remainder. @samp{g++} accepts mostly the same options as @samp{gcc}.
When you invoke GCC, it normally does preprocessing, compilation,
assembly and linking. The ``overall options'' allow you to stop this
-process at an intermediate stage. For example, the @samp{-c} option
+process at an intermediate stage. For example, the @option{-c} option
says not to run the linker. Then the output consists of object files
output by the assembler.
@cindex options, grouping
The @command{gcc} program accepts options and file names as operands. Many
options have multi-letter names; therefore multiple single-letter options
-may @emph{not} be grouped: @samp{-dr} is very different from @w{@samp{-d
+may @emph{not} be grouped: @option{-dr} is very different from @w{@samp{-d
-r}}.
@cindex order of options
@cindex options, order
You can mix options and other arguments. For the most part, the order
you use doesn't matter. Order does matter when you use several options
-of the same kind; for example, if you specify @samp{-L} more than once,
+of the same kind; for example, if you specify @option{-L} more than once,
the directories are searched in the order specified.
Many options have long names starting with @samp{-f} or with
-@samp{-W}---for example, @samp{-fforce-mem},
-@samp{-fstrength-reduce}, @samp{-Wformat} and so on. Most of
+@samp{-W}---for example, @option{-fforce-mem},
+@option{-fstrength-reduce}, @option{-Wformat} and so on. Most of
these have both positive and negative forms; the negative form of
-@samp{-ffoo} would be @samp{-fno-foo}. This manual documents
+@option{-ffoo} would be @option{-fno-foo}. This manual documents
only one of these two forms, whichever one is not the default.
@c man end
@item Objective-C Language Options
@xref{Objective-C Dialect Options,,Options Controlling Objective-C Dialect}.
@gccoptlist{
--fconstant-string-class=@var{class name} @gol
+-fconstant-string-class=@var{class-name} @gol
-fgnu-runtime -fnext-runtime -gen-decls @gol
-Wno-protocol -Wselector}
@emph{SPARC Options}
@gccoptlist{
--mcpu=@var{cpu type} @gol
--mtune=@var{cpu type} @gol
--mcmodel=@var{code model} @gol
+-mcpu=@var{cpu-type} @gol
+-mtune=@var{cpu-type} @gol
+-mcmodel=@var{code-model} @gol
-m32 -m64 @gol
-mapp-regs -mbroken-saverestore -mcypress @gol
-mepilogue -mfaster-structs -mflat @gol
@emph{M32R/D Options}
@gccoptlist{
--mcode-model=@var{model type} -msdata=@var{sdata type} @gol
+-mcode-model=@var{model-type} -msdata=@var{sdata-type} @gol
-G @var{num}}
@emph{M88K Options}
@emph{RS/6000 and PowerPC Options}
@gccoptlist{
--mcpu=@var{cpu type} @gol
--mtune=@var{cpu type} @gol
+-mcpu=@var{cpu-type} @gol
+-mtune=@var{cpu-type} @gol
-mpower -mno-power -mpower2 -mno-power2 @gol
-mpowerpc -mpowerpc64 -mno-powerpc @gol
-mpowerpc-gpopt -mno-powerpc-gpopt @gol
@emph{MIPS Options}
@gccoptlist{
--mabicalls -mcpu=@var{cpu type} @gol
+-mabicalls -mcpu=@var{cpu-type} @gol
-membedded-data -muninit-const-in-rodata @gol
-membedded-pic -mfp32 -mfp64 -mgas -mgp32 -mgp64 @gol
-mgpopt -mhalf-pic -mhard-float -mint64 -mips1 @gol
@emph{i386 Options}
@gccoptlist{
--mcpu=@var{cpu type} -march=@var{cpu type} @gol
+-mcpu=@var{cpu-type} -march=@var{cpu-type} @gol
-mintel-syntax -mieee-fp -mno-fancy-math-387 @gol
-mno-fp-ret-in-387 -msoft-float -msvr3-shlib @gol
-mno-wide-multiply -mrtd -malign-double @gol
@emph{HPPA Options}
@gccoptlist{
--march=@var{architecture type} @gol
+-march=@var{architecture-type} @gol
-mbig-switch -mdisable-fpregs -mdisable-indexing @gol
-mfast-indirect-calls -mgas -mjump-in-delay @gol
-mlong-load-store -mno-big-switch -mno-disable-fpregs @gol
-mno-portable-runtime -mno-soft-float @gol
-mno-space-regs -msoft-float -mpa-risc-1-0 @gol
-mpa-risc-1-1 -mpa-risc-2-0 -mportable-runtime @gol
--mschedule=@var{cpu type} -mspace-regs}
+-mschedule=@var{cpu-type} -mspace-regs}
@emph{Intel 960 Options}
@gccoptlist{
--m@var{cpu type} -masm-compat -mclean-linkage @gol
+-m@var{cpu-type} -masm-compat -mclean-linkage @gol
-mcode-align -mcomplex-addr -mleaf-procedures @gol
-mic-compat -mic2.0-compat -mic3.0-compat @gol
-mintel-asm -mno-clean-linkage -mno-code-align @gol
-mieee -mieee-with-inexact -mieee-conformant @gol
-mfp-trap-mode=@var{mode} -mfp-rounding-mode=@var{mode} @gol
-mtrap-precision=@var{mode} -mbuild-constants @gol
--mcpu=@var{cpu type} @gol
+-mcpu=@var{cpu-type} @gol
-mbwx -mno-bwx -mcix -mno-cix -mmax -mno-max @gol
-mmemory-latency=@var{time}}
@emph{ARC Options}
@gccoptlist{
-EB -EL @gol
--mmangle-cpu -mcpu=@var{cpu} -mtext=@var{text section} @gol
--mdata=@var{data section} -mrodata=@var{readonly data section}}
+-mmangle-cpu -mcpu=@var{cpu} -mtext=@var{text-section} @gol
+-mdata=@var{data-section} -mrodata=@var{readonly-data-section}}
@emph{TMS320C3x/C4x Options}
@gccoptlist{
-mvolatile-asm-stop -mb-step -mregister-names -mno-sdata @gol
-mconstant-gp -mauto-pic -minline-divide-min-latency @gol
-minline-divide-max-throughput -mno-dwarf2-asm @gol
--mfixed-range=@var{register range}}
+-mfixed-range=@var{register-range}}
@item Code Generation Options
@xref{Code Gen Options,,Options for Code Generation Conventions}.
@end table
@opindex x
-You can specify the input language explicitly with the @samp{-x} option:
+You can specify the input language explicitly with the @option{-x} option:
@table @gcctabopt
@item -x @var{language}
Specify explicitly the @var{language} for the following input files
(rather than letting the compiler choose a default based on the file
name suffix). This option applies to all following input files until
-the next @samp{-x} option. Possible values for @var{language} are:
+the next @option{-x} option. Possible values for @var{language} are:
@example
c c-header cpp-output
c++ c++-cpp-output
@item -x none
Turn off any specification of a language, so that subsequent files are
-handled according to their file name suffixes (as they are if @samp{-x}
+handled according to their file name suffixes (as they are if @option{-x}
has not been used at all).
@item -pass-exit-codes
@opindex pass-exit-codes
Normally the @command{gcc} program will exit with the code of 1 if any
phase of the compiler returns a non-success return code. If you specify
-@samp{-pass-exit-codes}, the @command{gcc} program will instead return with
+@option{-pass-exit-codes}, the @command{gcc} program will instead return with
numerically highest error produced by any phase that returned an error
indication.
@end table
If you only want some of the stages of compilation, you can use
-@samp{-x} (or filename suffixes) to tell @command{gcc} where to start, and
-one of the options @samp{-c}, @samp{-S}, or @samp{-E} to say where
+@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.
an object file, an assembler file or preprocessed C code.
Since only one output file can be specified, it does not make sense to
-use @samp{-o} when compiling more than one input file, unless you are
+use @option{-o} when compiling more than one input file, unless you are
producing an executable file as output.
-If @samp{-o} is not specified, the default is to put an executable file
+If @option{-o} is not specified, the default is to put an executable file
in @file{a.out}, the object file for @file{@var{source}.@var{suffix}} in
@file{@var{source}.o}, its assembler file in @file{@var{source}.s}, and
all preprocessed C source on standard output.@refill
The alternate keywords @code{__asm__}, @code{__extension__},
@code{__inline__} and @code{__typeof__} continue to work despite
-@samp{-ansi}. You would not want to use them in an ISO C program, of
+@option{-ansi}. You would not want to use them in an ISO C program, of
course, but it is useful to put them in header files that might be included
-in compilations done with @samp{-ansi}. Alternate predefined macros
+in compilations done with @option{-ansi}. Alternate predefined macros
such as @code{__unix__} and @code{__vax__} are also available, with or
-without @samp{-ansi}.
+without @option{-ansi}.
-The @samp{-ansi} option does not cause non-ISO programs to be
-rejected gratuitously. For that, @samp{-pedantic} is required in
-addition to @samp{-ansi}. @xref{Warning Options}.
+The @option{-ansi} option does not cause non-ISO programs to be
+rejected gratuitously. For that, @option{-pedantic} is required in
+addition to @option{-ansi}. @xref{Warning Options}.
-The macro @code{__STRICT_ANSI__} is predefined when the @samp{-ansi}
+The macro @code{__STRICT_ANSI__} is predefined when the @option{-ansi}
option is used. Some header files may notice this macro and refrain
from declaring certain functions or defining certain macros that the
ISO standard doesn't call for; this is to avoid interfering with any
Functions which would normally be builtin but do not have semantics
defined by ISO C (such as @code{alloca} and @code{ffs}) are not builtin
-functions with @samp{-ansi} is used. @xref{Other Builtins,,Other
+functions with @option{-ansi} is used. @xref{Other Builtins,,Other
built-in functions provided by GNU CC}, for details of the functions
affected.
Do not recognize @code{asm}, @code{inline} or @code{typeof} as a
keyword, so that code can use these words as identifiers. You can use
the keywords @code{__asm__}, @code{__inline__} and @code{__typeof__}
-instead. @samp{-ansi} implies @samp{-fno-asm}.
+instead. @option{-ansi} implies @option{-fno-asm}.
In C++, this switch only affects the @code{typeof} keyword, since
@code{asm} and @code{inline} are standard keywords. You may want to
-use the @samp{-fno-gnu-keywords} flag instead, which has the same
+use the @option{-fno-gnu-keywords} flag instead, which has the same
effect. In C99 mode (@option{-std=c99} or @option{-std=gnu99}), this
switch only affects the @code{asm} and @code{typeof} keywords, since
@code{inline} is a standard keyword in ISO C99.
cannot set a breakpoint on those calls, nor can you change the behavior
of the functions by linking with a different library.
-In C++, @samp{-fno-builtin} is always in effect. The @samp{-fbuiltin}
+In C++, @option{-fno-builtin} is always in effect. The @option{-fbuiltin}
option has no effect. Therefore, in C++, the only way to get the
optimization benefits of builtin functions is to call the function
using the @samp{__builtin_} prefix. The GNU C++ Standard Library uses
@cindex hosted environment
Assert that compilation takes place in a hosted environment. This implies
-@samp{-fbuiltin}. A hosted environment is one in which the
+@option{-fbuiltin}. A hosted environment is one in which the
entire standard library is available, and in which @code{main} has a return
type of @code{int}. Examples are nearly everything except a kernel.
-This is equivalent to @samp{-fno-freestanding}.
+This is equivalent to @option{-fno-freestanding}.
@item -ffreestanding
@opindex ffreestanding
@cindex hosted environment
Assert that compilation takes place in a freestanding environment. This
-implies @samp{-fno-builtin}. A freestanding environment
+implies @option{-fno-builtin}. A freestanding environment
is one in which the standard library may not exist, and program startup may
not necessarily be at @code{main}. The most obvious example is an OS kernel.
-This is equivalent to @samp{-fno-hosted}.
+This is equivalent to @option{-fno-hosted}.
@xref{Standards,,Language Standards Supported by GCC}, for details of
freestanding and hosted environments.
String ``constants'' are not necessarily constant; they are stored in
writable space, and identical looking constants are allocated
separately. (This is the same as the effect of
-@samp{-fwritable-strings}.)
+@option{-fwritable-strings}.)
@cindex @code{longjmp} and automatic variables
@item
@cindex escape sequences, traditional
The character escape sequences @samp{\x} and @samp{\a} evaluate as the
literal characters @samp{x} and @samp{a} respectively. Without
-@w{@samp{-traditional}}, @samp{\x} is a prefix for the hexadecimal
+@w{@option{-traditional}}, @samp{\x} is a prefix for the hexadecimal
representation of a character, and @samp{\a} produces a bell.
@end itemize
-You may wish to use @samp{-fno-builtin} as well as @samp{-traditional}
+You may wish to use @option{-fno-builtin} as well as @option{-traditional}
if your program uses names that are normally GNU C builtin functions for
other purposes of its own.
-You cannot use @samp{-traditional} if you include any header files that
+You cannot use @option{-traditional} if you include any header files that
rely on ISO C features. Some vendors are starting to ship systems with
-ISO C header files and you cannot use @samp{-traditional} on such
+ISO C header files and you cannot use @option{-traditional} on such
systems to compile files that include any system headers.
-The @samp{-traditional} option also enables @samp{-traditional-cpp},
+The @option{-traditional} option also enables @option{-traditional-cpp},
which is described next.
@item -traditional-cpp
always considers a string constant to end at a newline.
@item
-@cindex detecting @w{@samp{-traditional}}
+@cindex detecting @w{@option{-traditional}}
The predefined macro @code{__STDC__} is not defined when you use
-@samp{-traditional}, but @code{__GNUC__} is (since the GNU extensions
+@option{-traditional}, but @code{__GNUC__} is (since the GNU extensions
which @code{__GNUC__} indicates are not affected by
-@samp{-traditional}). If you need to write header files that work
-differently depending on whether @samp{-traditional} is in use, by
+@option{-traditional}). If you need to write header files that work
+differently depending on whether @option{-traditional} is in use, by
testing both of these predefined macros you can distinguish four
situations: GNU C, traditional GNU C, other ISO C compilers, and other
old C compilers. The predefined macro @code{__STDC_VERSION__} is also
-not defined when you use @samp{-traditional}. @xref{Standard
+not defined when you use @option{-traditional}. @xref{Standard
Predefined,,Standard Predefined Macros,cpp.info,The C Preprocessor},
for more discussion of these and other predefined macros.
@cindex string constants vs newline
@cindex newline vs string constants
The preprocessor considers a string constant to end at a newline (unless
-the newline is escaped with @samp{\}). (Without @w{@samp{-traditional}},
+the newline is escaped with @samp{\}). (Without @w{@option{-traditional}},
string constants can contain the newline character as typed.)
@end itemize
@opindex fsigned-char
Let the type @code{char} be signed, like @code{signed char}.
-Note that this is equivalent to @samp{-fno-unsigned-char}, which is
-the negative form of @samp{-funsigned-char}. Likewise, the option
-@samp{-fno-signed-char} is equivalent to @samp{-funsigned-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}.
@item -fsigned-bitfields
@itemx -funsigned-bitfields
default, such a bitfield is signed, because this is consistent: the
basic integer types such as @code{int} are signed types.
-However, when @samp{-traditional} is used, bitfields are all unsigned
+However, when @option{-traditional} is used, bitfields are all unsigned
no matter what.
@item -fwritable-strings
@opindex fwritable-strings
Store string constants in the writable data segment and don't uniquize
them. This is for compatibility with old programs which assume they can
-write into string constants. The option @samp{-traditional} also has
+write into string constants. The option @option{-traditional} also has
this effect.
Writing into string constants is a very bad idea; ``constants'' should
@item -fallow-single-precision
@opindex fallow-single-precision
Do not promote single precision math operations to double precision,
-even when compiling with @samp{-traditional}.
+even when compiling with @option{-traditional}.
Traditional K&R C promotes all floating point operations to double
precision, regardless of the sizes of the operands. On the
architecture for which you are compiling, single precision may be faster
-than double precision. If you must use @samp{-traditional}, but want
+than double precision. If you must use @option{-traditional}, but want
to use single precision operations when the operands are single
precision, use this option. This option has no effect when compiling
with ISO or GNU C conventions (the default).
@end example
@noindent
-In this example, only @samp{-frepo} is an option meant
+In this example, only @option{-frepo} is an option meant
only for C++ programs; you can use the other options with any
language supported by GCC.
@opindex fno-const-strings
Give string constants type @code{char *} instead of type @code{const
char *}. By default, G++ uses type @code{const char *} as required by
-the standard. Even if you use @samp{-fno-const-strings}, you cannot
+the standard. Even if you use @option{-fno-const-strings}, you cannot
actually modify the value of a string constant, unless you also use
-@samp{-fwritable-strings}.
+@option{-fwritable-strings}.
This option might be removed in a future release of G++. For maximum
portability, you should structure your code so that it works with
@item -fdollars-in-identifiers
@opindex fdollars-in-identifiers
Accept @samp{$} in identifiers. You can also explicitly prohibit use of
-@samp{$} with the option @samp{-fno-dollars-in-identifiers}. (GNU C allows
+@samp{$} with the option @option{-fno-dollars-in-identifiers}. (GNU C allows
@samp{$} by default on most target systems, but there are a few exceptions.)
Traditional C allowed the character @samp{$} to form part of
identifiers. However, ISO C and C++ forbid @samp{$} in identifiers.
@opindex fno-gnu-keywords
Do not recognize @code{typeof} as a keyword, so that code can use this
word as an identifier. You can use the keyword @code{__typeof__} instead.
-@samp{-ansi} implies @samp{-fno-gnu-keywords}.
+@option{-ansi} implies @option{-fno-gnu-keywords}.
@item -fno-honor-std
@opindex fno-honor-std
@item -fpermissive
@opindex fpermissive
Downgrade messages about nonconformant code from errors to warnings. By
-default, g++ effectively sets @samp{-pedantic-errors} without
-@samp{-pedantic}; this option reverses that. This behavior and this
-option are superseded by @samp{-pedantic}, which works as it does for GNU C.
+default, g++ effectively sets @option{-pedantic-errors} without
+@option{-pedantic}; this option reverses that. This behavior and this
+option are superseded by @option{-pedantic}, which works as it does for GNU C.
@item -frepo
@opindex frepo
Enable automatic template instantiation. This option also implies
-@samp{-fno-implicit-templates}. @xref{Template Instantiation}, for more
+@option{-fno-implicit-templates}. @xref{Template Instantiation}, for more
information.
@item -fno-rtti
Emit special relocations for vtables and virtual function references
so that the linker can identify unused virtual functions and zero out
vtable slots that refer to them. This is most useful with
-@samp{-ffunction-sections} and @samp{-Wl,--gc-sections}, in order to
+@option{-ffunction-sections} and @option{-Wl,--gc-sections}, in order to
also discard the functions themselves.
This optimization requires GNU as and GNU ld. Not all systems support
-this option. @samp{-Wl,--gc-sections} is ignored without @samp{-static}.
+this option. @option{-Wl,--gc-sections} is ignored without @option{-static}.
@item -fno-weak
@opindex fno-weak
members.
@end table
-The following @samp{-W@dots{}} options are not affected by @samp{-Wall}.
+The following @option{-W@dots{}} options are not affected by @option{-Wall}.
@table @gcctabopt
@item -Weffc++ (C++ only)
14.5.3). Before g++ implemented explicit specification, unqualified-ids
could be interpreted as a particular specialization of a templatized
function. Because this non-conforming behavior is no longer the default
-behavior for g++, @samp{-Wnon-template-friend} allows the compiler to
+behavior for g++, @option{-Wnon-template-friend} allows the compiler to
check existing code for potential trouble spots, and is on by default.
This new compiler behavior can be turned off with
-@samp{-Wno-non-template-friend} which keeps the conformant compiler code
+@option{-Wno-non-template-friend} which keeps the conformant compiler code
but disables the helpful warning.
@item -Wold-style-cast (C++ only)
@end example
@noindent
-In this example, only @samp{-fgnu-runtime} is an option meant only for
+In this example, only @option{-fgnu-runtime} is an option meant only for
Objective-C programs; you can use the other options with any language
supported by GCC.
programs:
@table @gcctabopt
-@item -fconstant-string-class=@var{class name}
+@item -fconstant-string-class=@var{class-name}
@opindex fconstant-string-class
-Use @var{class name} as the name of the class to instantiate for each
+Use @var{class-name} as the name of the class to instantiate for each
literal string specified with the syntax @code{@@"@dots{}"}. The default
class name is @code{NXConstantString}.
may have been an error.
You can request many specific warnings with options beginning @samp{-W},
-for example @samp{-Wimplicit} to request warnings on implicit
+for example @option{-Wimplicit} to request warnings on implicit
declarations. Each of these specific warning options also has a
negative form beginning @samp{-Wno-} to turn off warnings;
-for example, @samp{-Wno-implicit}. This manual lists only one of the
+for example, @option{-Wno-implicit}. This manual lists only one of the
two forms, whichever is not the default.
These options control the amount and kinds of warnings produced by GCC:
Issue all the warnings demanded by strict ISO C and ISO C++;
reject all programs that use forbidden extensions, and some other
programs that do not follow ISO C and ISO C++. For ISO C, follows the
-version of the ISO C standard specified by any @samp{-std} option used.
+version of the ISO C standard specified by any @option{-std} option used.
Valid ISO C and ISO C++ programs should compile properly with or without
this option (though a rare few will require @option{-ansi} or a
without this option, certain GNU extensions and traditional C and C++
features are supported as well. With this option, they are rejected.
-@samp{-pedantic} does not cause warning messages for use of the
+@option{-pedantic} does not cause warning messages for use of the
alternate keywords whose names begin and end with @samp{__}. Pedantic
warnings are also disabled in the expression that follows
@code{__extension__}. However, only system header files should use
these escape routes; application programs should avoid them.
@xref{Alternate Keywords}.
-Some users try to use @samp{-pedantic} to check programs for strict ISO
+Some users try to use @option{-pedantic} to check programs for strict ISO
C conformance. They soon find that it does not do quite what they want:
it finds some non-ISO practices, but not all---only those for which
ISO C @emph{requires} a diagnostic, and some others for which
A feature to report any failure to conform to ISO C might be useful in
some instances, but would require considerable additional work and would
-be quite different from @samp{-pedantic}. We don't have plans to
+be quite different from @option{-pedantic}. We don't have plans to
support such a feature in the near future.
Where the standard specified with @option{-std} represents a GNU
@item -pedantic-errors
@opindex pedantic-errors
-Like @samp{-pedantic}, except that errors are produced rather than
+Like @option{-pedantic}, except that errors are produced rather than
warnings.
@item -w
as features from the Single Unix Specification and some BSD and GNU
extensions. Other library implementations may not support all these
features; GCC does not support warning about features that go beyond a
-particular library's limitations. However, if @samp{-pedantic} is used
-with @samp{-Wformat}, warnings will be given about format features not
+particular library's limitations. However, if @option{-pedantic} is used
+with @option{-Wformat}, warnings will be given about format features not
in the selected standard version (but not for @code{strfmon} formats,
since those are not in any version of the C standard). @xref{C Dialect
Options,,Options Controlling C Dialect}.
-@samp{-Wformat} is included in @samp{-Wall}. For more control over some
-aspects of format checking, the options @samp{-Wno-format-y2k},
-@samp{-Wno-format-extra-args}, @samp{-Wformat-nonliteral},
-@samp{-Wformat-security} and @samp{-Wformat=2} are available, but are
-not included in @samp{-Wall}.
+@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{-Wformat-nonliteral},
+@option{-Wformat-security} and @option{-Wformat=2} are available, but are
+not included in @option{-Wall}.
@item -Wno-format-y2k
@opindex Wno-format-y2k
-If @samp{-Wformat} is specified, do not warn about @code{strftime}
+If @option{-Wformat} is specified, do not warn about @code{strftime}
formats which may yield only a two-digit year.
@item -Wno-format-extra-args
@opindex Wno-format-extra-args
-If @samp{-Wformat} is specified, do not warn about excess arguments to a
+If @option{-Wformat} is specified, do not warn about excess arguments to a
@code{printf} or @code{scanf} format function. The C standard specifies
that such arguments are ignored.
@item -Wformat-nonliteral
@opindex Wformat-nonliteral
-If @samp{-Wformat} is specified, also warn if the format string is not a
+If @option{-Wformat} is specified, also warn if the format string is not a
string literal and so cannot be checked, unless the format function
takes its format arguments as a @code{va_list}.
@item -Wformat-security
@opindex Wformat-security
-If @samp{-Wformat} is specified, also warn about uses of format
+If @option{-Wformat} is specified, also warn about uses of format
functions that represent possible security problems. At present, this
warns about calls to @code{printf} and @code{scanf} functions where the
format string is not a string literal and there are no format arguments,
as in @code{printf (foo);}. This may be a security hole if the format
string came from untrusted input and contains @samp{%n}. (This is
-currently a subset of what @samp{-Wformat-nonliteral} warns about, but
-in future warnings may be added to @samp{-Wformat-security} that are not
-included in @samp{-Wformat-nonliteral}.)
+currently a subset of what @option{-Wformat-nonliteral} warns about, but
+in future warnings may be added to @option{-Wformat-security} that are not
+included in @option{-Wformat-nonliteral}.)
@item -Wformat=2
@opindex Wformat=2
-Enable @samp{-Wformat} plus format checks not included in
-@samp{-Wformat}. Currently equivalent to @samp{-Wformat
+Enable @option{-Wformat} plus format checks not included in
+@option{-Wformat}. Currently equivalent to @samp{-Wformat
-Wformat-nonliteral -Wformat-security}.
@item -Wimplicit-int
@item -Wimplicit
@opindex Wimplicit
-Same as @samp{-Wimplicit-int} and @samp{-Wimplicit-function-}@*
-@samp{declaration}.
+Same as @option{-Wimplicit-int} and @option{-Wimplicit-function-declaration}.
@item -Wmain
@opindex Wmain
return-value in a function whose return-type is not @code{void}.
For C++, a function without return type always produces a diagnostic
-message, even when @samp{-Wno-return-type} is specified. The only
+message, even when @option{-Wno-return-type} is specified. The only
exceptions are @samp{main} and functions defined in system headers.
@item -Wswitch
@item -Wunused
@opindex Wunused
-All all the above @samp{-Wunused} options combined.
+All all the above @option{-Wunused} options combined.
In order to get a warning about an unused function parameter, you must
either specify @samp{-W -Wunused} or separately specify
-@samp{-Wunused-parameter}.
+@option{-Wunused-parameter}.
@item -Wuninitialized
@opindex Wuninitialized
These warnings are possible only in optimizing compilation,
because they require data flow information that is computed only
-when optimizing. If you don't specify @samp{-O}, you simply won't
+when optimizing. If you don't specify @option{-O}, you simply won't
get these warnings.
These warnings occur only for variables that are candidates for
Warn when a #pragma directive is encountered which is not understood by
GCC. If this command line option is used, warnings will even be issued
for unknown pragmas in system header files. This is not the case if
-the warnings were only enabled by the @samp{-Wall} command line option.
+the warnings were only enabled by the @option{-Wall} command line option.
@item -Wall
@opindex Wall
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 @samp{-Wall} in conjunction with this
+code. However, note that using @option{-Wall} in conjunction with this
option will @emph{not} warn about unknown pragmas in system
-headers---for that, @samp{-Wunknown-pragmas} must also be used.
+headers---for that, @option{-Wunknown-pragmas} must also be used.
@end table
-The following @samp{-W@dots{}} options are not implied by @samp{-Wall}.
+The following @option{-W@dots{}} options are not implied by @option{-Wall}.
Some of them warn about constructions that users generally do not
consider questionable, but which occasionally you might wish to check
for; others warn about constructions that are necessary or hard to avoid
Such a type qualifier has no effect, since the value returned by a
function is not an lvalue. (But don't warn about the GNU extension of
@code{volatile void} return types. That extension will be warned about
-if @samp{-pedantic} is specified.)
+if @option{-pedantic} is specified.)
@item
-If @samp{-Wall} or @samp{-Wunused} is also specified, warn about unused
+If @option{-Wall} or @option{-Wunused} is also specified, warn about unused
arguments.
@item
A comparison between signed and unsigned values could produce an
incorrect result when the signed value is converted to unsigned.
-(But don't warn if @samp{-Wno-sign-compare} is also specified.)
+(But don't warn if @option{-Wno-sign-compare} is also specified.)
@item
An aggregate has a partly bracketed initializer.
In traditional C, some preprocessor directives did not exist.
Traditional preprocessors would only consider a line to be a directive
if the @samp{#} appeared in column 1 on the line. Therefore
-@samp{-Wtraditional} warns about directives that traditional C
+@option{-Wtraditional} warns about directives that traditional C
understands but would ignore because the @samp{#} does not appear as the
first character on the line. It also suggests you hide directives like
@samp{#pragma} not understood by traditional C by indenting them. Some
Conversions by prototypes between fixed/floating point values and vice
versa. The absence of these prototypes when compiling with traditional
C would cause serious problems. This is a subset of the possible
-conversion warnings, for the full set use @samp{-Wconversion}.
+conversion warnings, for the full set use @option{-Wconversion}.
@end itemize
@item -Wundef
compile time code that can try to write into a string constant, but
only if you have been very careful about using @code{const} in
declarations and prototypes. Otherwise, it will just be a nuisance;
-this is why we did not make @samp{-Wall} request these warnings.
+this is why we did not make @option{-Wall} request these warnings.
@item -Wconversion
@opindex Wconversion
@cindex signed and unsigned values, comparison warning
Warn when a comparison between signed and unsigned values could produce
an incorrect result when the signed value is converted to unsigned.
-This warning is also enabled by @samp{-W}; to get the other warnings
-of @samp{-W} without this warning, use @samp{-W -Wno-sign-compare}.
+This warning is also enabled by @option{-W}; to get the other warnings
+of @option{-W} without this warning, use @samp{-W -Wno-sign-compare}.
@item -Waggregate-return
@opindex Waggregate-return
@item -Wmissing-format-attribute
@opindex Wmissing-format-attribute
@opindex Wformat
-If @samp{-Wformat} is enabled, also warn about functions which might be
+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
case, and some functions for which @code{format} attributes are
appropriate may not be detected. This option has no effect unless
-@samp{-Wformat} is enabled (possibly by @samp{-Wall}).
+@option{-Wformat} is enabled (possibly by @option{-Wall}).
@item -Wpacked
@opindex Wpacked
For instance, when a function is inlined, a warning may mean that the
line is unreachable in only one inlined copy of the function.
-This option is not made part of @samp{-Wall} because in a debugging
+This option is not made part of @option{-Wall} because in a debugging
version of a program there is often substantial code which checks
correct functioning of the program and is, hopefully, unreachable
because the program does work. Another common use of unreachable
@opindex Wlong-long
@opindex Wno-long-long
Warn if @samp{long long} type is used. This is default. To inhibit
-the warning messages, use @samp{-Wno-long-long}. Flags
-@samp{-Wlong-long} and @samp{-Wno-long-long} are taken into account
-only when @samp{-pedantic} flag is used.
+the warning messages, use @option{-Wno-long-long}. Flags
+@option{-Wlong-long} and @option{-Wno-long-long} are taken into account
+only when @option{-pedantic} flag is used.
@item -Wdisabled-optimization
@opindex Wdisabled-optimization
(stabs, COFF, XCOFF, or DWARF). GDB can work with this debugging
information.
-On most systems that use stabs format, @samp{-g} enables use of extra
+On most systems that use stabs format, @option{-g} enables use of extra
debugging information that only GDB can use; this extra information
makes debugging work better in GDB but will probably make other debuggers
crash or
refuse to read the program. If you want to control for certain whether
-to generate the extra information, use @samp{-gstabs+}, @samp{-gstabs},
-@samp{-gxcoff+}, @samp{-gxcoff}, @samp{-gdwarf-1+}, or @samp{-gdwarf-1}
+to generate the extra information, use @option{-gstabs+}, @option{-gstabs},
+@option{-gxcoff+}, @option{-gxcoff}, @option{-gdwarf-1+}, or @option{-gdwarf-1}
(see below).
-Unlike most other C compilers, GCC allows you to use @samp{-g} with
-@samp{-O}. The shortcuts taken by optimized code may occasionally
+Unlike most other C compilers, GCC allows you to use @option{-g} with
+@option{-O}. The shortcuts taken by optimized code may occasionally
produce surprising results: some variables you declared may not exist
at all; flow of control may briefly move where you did not expect it;
some statements may not be executed because they compute constant
Level 3 includes extra information, such as all the macro definitions
present in the program. Some debuggers support macro expansion when
-you use @samp{-g3}.
+you use @option{-g3}.
@cindex @code{prof}
@item -p
@opindex a
Generate extra code to write profile information for basic blocks, which will
record the number of times each basic block is executed, the basic block start
-address, and the function name containing the basic block. If @samp{-g} is
+address, and the function name containing the basic block. If @option{-g} is
used, the line number and filename of the start of the basic block will also be
recorded. If not overridden by the machine description, the default action is
to append to the text file @file{bb.out}.
@item -ax
@opindex ax
Generate extra code to profile basic blocks. Your executable will
-produce output that is a superset of that produced when @samp{-a} is
+produce output that is a superset of that produced when @option{-a} is
used. Additional output is the source and target address of the basic
blocks where a jump takes place, the number of times a jump is executed,
and (optionally) the complete sequence of basic blocks being executed.
Since not every arc in the program must be instrumented, programs
compiled with this option run faster than programs compiled with
-@samp{-a}, which adds instrumentation code to every basic block in the
+@option{-a}, which adds instrumentation code to every basic block in the
program. The tradeoff: since @code{gcov} does not have
execution counts for all branches, it must start with the execution
counts for the instrumented branches, and then iterate over the program
flow graph until the entire graph has been solved. Hence, @code{gcov}
runs a little more slowly than a program which uses information from
-@samp{-a}.
+@option{-a}.
-@samp{-fprofile-arcs} also makes it possible to estimate branch
+@option{-fprofile-arcs} also makes it possible to estimate branch
probabilities, and to calculate basic block execution counts. In
general, basic block execution counts do not give enough information to
estimate all branch probabilities. When the compiled program exits, it
saves the arc execution counts to a file called
@file{@var{sourcename}.da}. Use the compiler option
-@samp{-fbranch-probabilities} (@pxref{Optimize Options,,Options that
+@option{-fbranch-probabilities} (@pxref{Optimize Options,,Options that
Control Optimization}) when recompiling, to optimize using estimated
branch probabilities.
to reconstruct the program flow graph, so that it can compute all basic
block and arc execution counts from the information in the
@code{@var{sourcename}.da} file (this last file is the output from
-@samp{-fprofile-arcs}).
+@option{-fprofile-arcs}).
@end table
@item -d@var{letters}
@item P
@opindex dP
Dump the RTL in the assembler output as a comment before each instruction.
-Also turns on @samp{-dp} annotation.
+Also turns on @option{-dp} annotation.
@item v
@opindex dv
For each of the other indicated dump files (except for
@item -print-prog-name=@var{program}
@opindex print-prog-name
-Like @samp{-print-file-name}, but searches for a program such as @samp{cpp}.
+Like @option{-print-file-name}, but searches for a program such as @samp{cpp}.
@item -print-libgcc-file-name
@opindex print-libgcc-file-name
-Same as @samp{-print-file-name=libgcc.a}.
+Same as @option{-print-file-name=libgcc.a}.
-This is useful when you use @samp{-nostdlib} or @samp{-nodefaultlibs}
+This is useful when you use @option{-nostdlib} or @option{-nodefaultlibs}
but you do want to link with @file{libgcc.a}. You can do
@example
Optimize. Optimizing compilation takes somewhat more time, and a lot
more memory for a large function.
-Without @samp{-O}, the compiler's goal is to reduce the cost of
+Without @option{-O}, the compiler's goal is to reduce the cost of
compilation and to make debugging produce the expected results.
Statements are independent: if you stop the program with a breakpoint
between statements, you can then assign a new value to any variable or
change the program counter to any other statement in the function and
get exactly the results you would expect from the source code.
-Without @samp{-O}, the compiler only allocates variables declared
+Without @option{-O}, the compiler only allocates variables declared
@code{register} in registers. The resulting compiled code is a little
-worse than produced by PCC without @samp{-O}.
+worse than produced by PCC without @option{-O}.
-With @samp{-O}, the compiler tries to reduce code size and execution
+With @option{-O}, the compiler tries to reduce code size and execution
time.
-When you specify @samp{-O}, the compiler turns on @samp{-fthread-jumps}
-and @samp{-fdefer-pop} on all machines. The compiler turns on
-@samp{-fdelayed-branch} on machines that have delay slots, and
-@samp{-fomit-frame-pointer} on machines that can support debugging even
+When you specify @option{-O}, the compiler turns on @option{-fthread-jumps}
+and @option{-fdefer-pop} on all machines. The compiler turns on
+@option{-fdelayed-branch} on machines that have delay slots, and
+@option{-fomit-frame-pointer} on machines that can support debugging even
without a frame pointer. On some machines the compiler also turns
on other flags.@refill
@opindex O2
Optimize even more. GCC performs nearly all supported optimizations
that do not involve a space-speed tradeoff. The compiler does not
-perform loop unrolling or function inlining when you specify @samp{-O2}.
-As compared to @samp{-O}, this option increases both compilation time
+perform loop unrolling or function inlining when you specify @option{-O2}.
+As compared to @option{-O}, this option increases both compilation time
and the performance of the generated code.
-@samp{-O2} turns on all optional optimizations except for loop unrolling,
+@option{-O2} turns on all optional optimizations except for loop unrolling,
function inlining, and register renaming. It also turns on the
-@samp{-fforce-mem} option on all machines and frame pointer elimination
+@option{-fforce-mem} option on all machines and frame pointer elimination
on machines where doing so does not interfere with debugging.
@item -O3
@opindex O3
-Optimize yet more. @samp{-O3} turns on all optimizations specified by
-@samp{-O2} and also turns on the @samp{-finline-functions} and
-@samp{-frename-registers} options.
+Optimize yet more. @option{-O3} turns on all optimizations specified by
+@option{-O2} and also turns on the @option{-finline-functions} and
+@option{-frename-registers} options.
@item -O0
@opindex O0
@item -Os
@opindex Os
-Optimize for size. @samp{-Os} enables all @samp{-O2} optimizations that
+Optimize for size. @option{-Os} enables all @option{-O2} optimizations that
do not typically increase code size. It also performs further
optimizations designed to reduce code size.
-If you use multiple @samp{-O} options, with or without level numbers,
+If you use multiple @option{-O} options, with or without level numbers,
the last such option is the one that is effective.
@end table
-Options of the form @samp{-f@var{flag}} specify machine-independent
+Options of the form @option{-f@var{flag}} specify machine-independent
flags. Most flags have both positive and negative forms; the negative
-form of @samp{-ffoo} would be @samp{-fno-foo}. In the table below,
+form of @option{-ffoo} would be @option{-fno-foo}. In the table below,
only one of the forms is listed---the one which is not the default.
You can figure out the other form by either removing @samp{no-} or
adding it.
precision than a @code{double} is supposed to have. Similarly for the
x86 architecture. For most programs, the excess precision does only
good, but a few programs rely on the precise definition of IEEE floating
-point. Use @samp{-ffloat-store} for such programs, after modifying
+point. Use @option{-ffloat-store} for such programs, after modifying
them to store all pertinent intermediate computations into variables.
@item -fno-default-inline
@opindex fno-default-inline
Do not make member functions inline by default merely because they are
defined inside the class scope (C++ only). Otherwise, when you specify
-@w{@samp{-O}}, member functions defined inside class scope are compiled
+@w{@option{-O}}, member functions defined inside class scope are compiled
inline by default; i.e., you don't need to add @samp{inline} in front of
the member function name.
arithmetic on them. This produces better code by making all memory
references potential common subexpressions. When they are not common
subexpressions, instruction combination should eliminate the separate
-register-load. The @samp{-O2} option turns on this option.
+register-load. The @option{-O2} option turns on this option.
@item -fforce-addr
@opindex fforce-addr
Force memory address constants to be copied into registers before
doing arithmetic on them. This may produce better code just as
-@samp{-fforce-mem} may.
+@option{-fforce-mem} may.
@item -fomit-frame-pointer
@opindex fomit-frame-pointer
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 @samp{-fno-keep-static-consts} option.
+optimization is turned on, use the @option{-fno-keep-static-consts} option.
@item -fno-function-cse
@opindex fno-function-cse
@item -ffast-math
@opindex ffast-math
-Sets @samp{-fno-math-errno}, @samp{-funsafe-math-optimizations},
-and @samp{-fno-trapping-math}.
+Sets @option{-fno-math-errno}, @option{-funsafe-math-optimizations},
+and @option{-fno-trapping-math}.
-This option causes the preprocessor macro __FAST_MATH__ to be defined.
+This option causes the preprocessor macro @code{__FAST_MATH__} to be defined.
-This option should never be turned on by any @samp{-O} option since
+This option should never be turned on by any @option{-O} option since
it can result in incorrect output for programs which depend on
an exact implementation of IEEE or ISO rules/specifications for
math functions.
IEEE exceptions for math error handling may want to use this flag
for speed while maintaining IEEE arithmetic compatibility.
-This option should never be turned on by any @samp{-O} option since
+This option should never be turned on by any @option{-O} option since
it can result in incorrect output for programs which depend on
an exact implementation of IEEE or ISO rules/specifications for
math functions.
-The default is @samp{-fmath-errno}. The @samp{-ffast-math} option
-sets @samp{-fno-math-errno}.
+The default is @option{-fmath-errno}. The @option{-ffast-math} option
+sets @option{-fno-math-errno}.
@item -funsafe-math-optimizations
@opindex funsafe-math-optimizations
that arguments and results are valid and (b) may violate IEEE or
ANSI standards.
-This option should never be turned on by any @samp{-O} option since
+This option should never be turned on by any @option{-O} option since
it can result in incorrect output for programs which depend on
an exact implementation of IEEE or ISO rules/specifications for
math functions.
-The default is @samp{-fno-unsafe-math-optimizations}. The
-@samp{-ffast-math} option sets @samp{-funsafe-math-optimizations}.
+The default is @option{-fno-unsafe-math-optimizations}. The
+@option{-ffast-math} option sets @option{-funsafe-math-optimizations}.
@item -fno-trapping-math
@opindex fno-trapping-math
user-visible traps. Setting this option may allow faster code
if one relies on ``non-stop'' IEEE arithmetic, for example.
-This option should never be turned on by any @samp{-O} option since
+This option should never be turned on by any @option{-O} option since
it can result in incorrect output for programs which depend on
an exact implementation of IEEE or ISO rules/specifications for
math functions.
-The default is @samp{-ftrapping-math}. The @samp{-ffast-math}
-option sets @samp{-fno-trapping-math}.
+The default is @option{-ftrapping-math}. The @option{-ffast-math}
+option sets @option{-fno-trapping-math}.
@end table
@c following causes underfulls.. they don't look great, but we deal.
@c --mew 26jan93
-The following options control specific optimizations. The @samp{-O2}
-option turns on all of these optimizations except @samp{-funroll-loops}
-and @samp{-funroll-all-loops}. On most machines, the @samp{-O} option
-turns on the @samp{-fthread-jumps} and @samp{-fdelayed-branch} options,
+The following options control specific optimizations. The @option{-O2}
+option turns on all of these optimizations except @option{-funroll-loops}
+and @option{-funroll-all-loops}. On most machines, the @option{-O} option
+turns on the @option{-fthread-jumps} and @option{-fdelayed-branch} options,
but specific machines may handle it differently.
You can use the following flags in the rare cases when ``fine-tuning''
@item -fcse-skip-blocks
@opindex fcse-skip-blocks
-This is similar to @samp{-fcse-follow-jumps}, but causes CSE to
+This is similar to @option{-fcse-follow-jumps}, but causes CSE to
follow jumps which conditionally skip over blocks. When CSE
encounters a simple @code{if} statement with no else clause,
-@samp{-fcse-skip-blocks} causes CSE to follow the jump around the
+@option{-fcse-skip-blocks} causes CSE to follow the jump around the
body of the @code{if}.
@item -frerun-cse-after-loop
Attempt to reassign register numbers in move instructions and as
operands of other simple instructions in order to maximize the amount of
register tying. This is especially helpful on machines with two-operand
-instructions. GCC enables this optimization by default with @samp{-O2}
+instructions. GCC enables this optimization by default with @option{-O2}
or higher.
Note @option{-fregmove} and @option{-foptimize-register-move} are the same
@item -fschedule-insns2
@opindex fschedule-insns2
-Similar to @samp{-fschedule-insns}, but requests an additional pass of
+Similar to @option{-fschedule-insns}, but requests an additional pass of
instruction scheduling after register allocation has been done. This is
especially useful on machines with a relatively small number of
registers and where memory load instructions take more than one cycle.
create larger object and executable files and will also be slower.
You will not be able to use @code{gprof} on all systems if you
specify this option and you may have problems with debugging if
-you specify both this option and @samp{-g}.
+you specify both this option and @option{-g}.
@item -fcaller-saves
@opindex fcaller-saves
@opindex funroll-loops
Perform the optimization of loop unrolling. This is only done for loops
whose number of iterations can be determined at compile time or run time.
-@samp{-funroll-loops} implies both @samp{-fstrength-reduce} and
-@samp{-frerun-cse-after-loop}.
+@option{-funroll-loops} implies both @option{-fstrength-reduce} and
+@option{-frerun-cse-after-loop}.
@item -funroll-all-loops
@opindex funroll-all-loops
Perform the optimization of loop unrolling. This is done for all loops
-and usually makes programs run more slowly. @samp{-funroll-all-loops}
-implies @samp{-fstrength-reduce} as well as @samp{-frerun-cse-after-loop}.
+and usually makes programs run more slowly. @option{-funroll-all-loops}
+implies @option{-fstrength-reduce} as well as @option{-frerun-cse-after-loop}.
@item -fmove-all-movables
@opindex fmove-all-movables
strength-reduced.
@emph{Note:} When compiling programs written in Fortran,
-@samp{-fmove-all-movables} and @samp{-freduce-all-givs} are enabled
+@option{-fmove-all-movables} and @option{-freduce-all-givs} are enabled
by default when you use the optimizer.
These options may generate better or worse code; results are highly
@opindex fno-peephole
@opindex fno-peephole2
Disable any machine-specific peephole optimizations. The difference
-between @samp{-fno-peephole} and @samp{-fno-peephole2} is in how they
+between @option{-fno-peephole} and @option{-fno-peephole2} is in how they
are implemented in the compiler; some targets use one, some use the
other, a few use both.
@item -fbranch-probabilities
@opindex fbranch-probabilities
-After running a program compiled with @samp{-fprofile-arcs}
+After running a program compiled with @option{-fprofile-arcs}
(@pxref{Debugging Options,, Options for Debugging Your Program or
@command{gcc}}), you can compile it a second time using
-@samp{-fbranch-probabilities}, to improve optimizations based on
+@option{-fbranch-probabilities}, to improve optimizations based on
guessing the path a branch might take.
@ifset INTERNALS
-With @samp{-fbranch-probabilities}, GCC puts a @samp{REG_EXEC_COUNT}
+With @option{-fbranch-probabilities}, GCC puts a @samp{REG_EXEC_COUNT}
note on the first instruction of each basic block, and 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
@item -fno-guess-branch-probability
@opindex fno-guess-branch-probability
Sometimes gcc will opt to guess branch probabilities when none are
-available from either profile directed feedback (@samp{-fprofile-arcs})
+available from either profile directed feedback (@option{-fprofile-arcs})
or @samp{__builtin_expect}. In a hard real-time system, people don't
want different runs of the compiler to produce code that has different
behavior; minimizing non-determinism is of paramount import. This
@end example
The practice of reading from a different union member than the one most
recently written to (called ``type-punning'') is common. Even with
-@samp{-fstrict-aliasing}, type-punning is allowed, provided the memory
+@option{-fstrict-aliasing}, type-punning is allowed, provided the memory
is accessed through the union type. So, the code above will work as
expected. However, this code might not:
@example
@opindex falign-functions
Align the start of functions to the next power-of-two greater than
@var{n}, skipping up to @var{n} bytes. For instance,
-@samp{-falign-functions=32} aligns functions to the next 32-byte
-boundary, but @samp{-falign-functions=24} would align to the next
+@option{-falign-functions=32} aligns functions to the next 32-byte
+boundary, but @option{-falign-functions=24} would align to the next
32-byte boundary only if this can be done by skipping 23 bytes or less.
-@samp{-fno-align-functions} and @samp{-falign-functions=1} are
+@option{-fno-align-functions} and @option{-falign-functions=1} are
equivalent and mean that functions will not be aligned.
Some assemblers only support this flag when @var{n} is a power of two;
@itemx -falign-labels=@var{n}
@opindex falign-labels
Align all branch targets to a power-of-two boundary, skipping up to
-@var{n} bytes like @samp{-falign-functions}. This option can easily
+@var{n} bytes like @option{-falign-functions}. This option can easily
make code slower, because it must insert dummy operations for when the
branch target is reached in the usual flow of the code.
-If @samp{-falign-loops} or @samp{-falign-jumps} are applicable and
+If @option{-falign-loops} or @option{-falign-jumps} are applicable and
are greater than this value, then their values are used instead.
If @var{n} is not specified, use a machine-dependent default which is
@itemx -falign-loops=@var{n}
@opindex falign-loops
Align loops to a power-of-two boundary, skipping up to @var{n} bytes
-like @samp{-falign-functions}. The hope is that the loop will be
+like @option{-falign-functions}. The hope is that the loop will be
executed many times, which will make up for any execution of the dummy
operations.
@opindex falign-jumps
Align branch targets to a power-of-two boundary, for branch targets
where the targets can only be reached by jumping, skipping up to @var{n}
-bytes like @samp{-falign-functions}. In this case, no dummy operations
+bytes like @option{-falign-functions}. In this case, no dummy operations
need be executed.
If @var{n} is not specified, use a machine-dependent default.
@item -fdce
@opindex fdce
-Perform dead-code elimination in SSA form. Requires @samp{-fssa}. Like
-@samp{-fssa}, this is an experimental feature.
+Perform dead-code elimination in SSA form. Requires @option{-fssa}. Like
+@option{-fssa}, this is an experimental feature.
@item -fsingle-precision-constant
@opindex fsingle-precision-constant
optimization that is done. For example, GCC will not inline functions
that contain more that a certain number of instructions. You can
control some of these constants on the command-line using the
-@samp{--param} option.
+@option{--param} option.
In each case, the @var{value} is a integer. The allowable choices for
@var{name} are given in the following table:
@item max-inline-insns
If an function contains more than this many instructions, it
will not be inlined. This option is precisely equivalent to
-@samp{-finline-limit}.
+@option{-finline-limit}.
@end table
@end table
These options control the C preprocessor, which is run on each C source
file before actual compilation.
-If you use the @samp{-E} option, nothing is done except preprocessing.
-Some of these options make sense only together with @samp{-E} because
+If you use the @option{-E} option, nothing is done except preprocessing.
+Some of these options make sense only together with @option{-E} because
they cause the preprocessor output to be unsuitable for actual
compilation.
@item -include @var{file}
@opindex include
Process @var{file} as input before processing the regular input file.
-In effect, the contents of @var{file} are compiled first. Any @samp{-D}
-and @samp{-U} options on the command line are always processed before
-@samp{-include @var{file}}, regardless of the order in which they are
-written. All the @samp{-include} and @samp{-imacros} options are
+In effect, the contents of @var{file} are compiled first. Any @option{-D}
+and @option{-U} options on the command line are always processed before
+@option{-include @var{file}}, regardless of the order in which they are
+written. All the @option{-include} and @option{-imacros} options are
processed in the order in which they are written.
@item -imacros @var{file}
@opindex imacros
Process @var{file} as input, discarding the resulting output, before
processing the regular input file. Because the output generated from
-@var{file} is discarded, the only effect of @samp{-imacros @var{file}}
+@var{file} is discarded, the only effect of @option{-imacros @var{file}}
is to make the macros defined in @var{file} available for use in the
-main input. All the @samp{-include} and @samp{-imacros} options are
+main input. All the @option{-include} and @option{-imacros} options are
processed in the order in which they are written.
@item -idirafter @var{dir}
Add the directory @var{dir} to the second include path. The directories
on the second include path are searched when a header file is not found
in any of the directories in the main include path (the one that
-@samp{-I} adds to).
+@option{-I} adds to).
@item -iprefix @var{prefix}
@opindex iprefix
-Specify @var{prefix} as the prefix for subsequent @samp{-iwithprefix}
+Specify @var{prefix} as the prefix for subsequent @option{-iwithprefix}
options.
@item -iwithprefix @var{dir}
@opindex iwithprefix
Add a directory to the second include path. The directory's name is
made by concatenating @var{prefix} and @var{dir}, where @var{prefix} was
-specified previously with @samp{-iprefix}. If you have not specified a
+specified previously with @option{-iprefix}. If you have not specified a
prefix yet, the directory containing the installed passes of the
compiler is used as the default.
@opindex iwithprefixbefore
Add a directory to the main include path. The directory's name is made
by concatenating @var{prefix} and @var{dir}, as in the case of
-@samp{-iwithprefix}.
+@option{-iwithprefix}.
@item -isystem @var{dir}
@opindex isystem
@item -nostdinc
@opindex nostdinc
Do not search the standard system directories for header files. Only
-the directories you have specified with @samp{-I} options (and the
+the directories you have specified with @option{-I} options (and the
current directory, if appropriate) are searched. @xref{Directory
-Options}, for information on @samp{-I}.
+Options}, for information on @option{-I}.
-By using both @samp{-nostdinc} and @samp{-I-}, you can limit the include-file
+By using both @option{-nostdinc} and @option{-I-}, you can limit the include-file
search path to only those directories you specify explicitly.
@item -remap
@item -C
@opindex C
Tell the preprocessor not to discard comments. Used with the
-@samp{-E} option.
+@option{-E} option.
@item -P
@opindex P
Tell the preprocessor not to generate @samp{#line} directives.
-Used with the @samp{-E} option.
+Used with the @option{-E} option.
@cindex make
@cindex dependencies, make
object file suffix. If there are many included files then the
rule is split into several lines using @samp{\}-newline.
-@samp{-M} implies @samp{-E}.
+@option{-M} implies @option{-E}.
@item -MM
@opindex MM
-Like @samp{-M}, but mention only the files included with @samp{#include
+Like @option{-M}, but mention only the files included with @samp{#include
"@var{file}"}. System header files included with @samp{#include
<@var{file}>} are omitted.
@item -MD
@opindex MD
-Like @samp{-M} but the dependency information is written to a file
+Like @option{-M} but the dependency information is written to a file
rather than stdout. @code{gcc} will use the same file name and
directory as the object file, but with the suffix @file{.d} instead.
-This is in addition to compiling the main file as specified---@samp{-MD}
-does not inhibit ordinary compilation the way @samp{-M} does,
-unless you also specify @samp{-MG}.
+This is in addition to compiling the main file as specified---@option{-MD}
+does not inhibit ordinary compilation the way @option{-M} does,
+unless you also specify @option{-MG}.
With Mach, you can use the utility @code{md} to merge multiple
dependency files into a single dependency file suitable for using with
@item -MMD
@opindex MMD
-Like @samp{-MD} except mention only user header files, not system
+Like @option{-MD} except mention only user header files, not system
-header files.
@item -MF @var{file}
@opindex MF
-When used with @samp{-M} or @samp{-MM}, specifies a file to write the
+When used with @option{-M} or @option{-MM}, specifies a file to write the
dependencies to. This allows the preprocessor to write the preprocessed
-file to stdout normally. If no @samp{-MF} switch is given, CPP sends
+file to stdout normally. If no @option{-MF} switch is given, CPP sends
the rules to stdout and suppresses normal preprocessed output.
Another way to specify output of a @code{make} rule is by setting
@item -MG
@opindex MG
-When used with @samp{-M} or @samp{-MM}, @samp{-MG} says to treat missing
+When used with @option{-M} or @option{-MM}, @option{-MG} says to treat missing
header files as generated files and assume they live in the same
directory as the source file. It suppresses preprocessed output, as a
missing header file is ordinarily an error.
@opindex MT
By default CPP uses the main file name, including any path, and appends
the object suffix, normally ``.o'', to it to obtain the name of the
-target for dependency generation. With @samp{-MT} you can specify a
+target for dependency generation. With @option{-MT} you can specify a
target yourself, overriding the default one.
If you want multiple targets, you can specify them as a single argument
-to @samp{-MT}, or use multiple @samp{-MT} options.
+to @option{-MT}, or use multiple @option{-MT} options.
The targets you specify are output in the order they appear on the
-command line. @samp{-MQ} is identical to @samp{-MT}, except that the
-target name is quoted for Make, but with @samp{-MT} it isn't. For
-example, @samp{-MT '$(objpfx)foo.o'} gives
+command line. @option{-MQ} is identical to @option{-MT}, except that the
+target name is quoted for Make, but with @option{-MT} it isn't. For
+example, @option{-MT '$(objpfx)foo.o'} gives
@smallexample
$(objpfx)foo.o: /tmp/foo.c
@end smallexample
-but @samp{-MQ '$(objpfx)foo.o'} gives
+but @option{-MQ '$(objpfx)foo.o'} gives
@smallexample
$$(objpfx)foo.o: /tmp/foo.c
@end smallexample
The default target is automatically quoted, as if it were given with
-@samp{-MQ}.
+@option{-MQ}.
@item -H
@opindex H
@opindex A
Assert the answer @var{answer} for @var{question}, in case it is tested
with a preprocessing conditional such as @samp{#if
-#@var{question}(@var{answer})}. @samp{-A-} disables the standard
+#@var{question}(@var{answer})}. @option{-A-} disables the standard
assertions that normally describe the target machine.
@item -D@var{macro}
Define macro @var{macro} with the string @samp{1} as its definition.
@item -D@var{macro}=@var{defn}
-Define macro @var{macro} as @var{defn}. All instances of @samp{-D} on
-the command line are processed before any @samp{-U} options.
+Define macro @var{macro} as @var{defn}. All instances of @option{-D} on
+the command line are processed before any @option{-U} options.
-Any @samp{-D} and @samp{-U} options on the command line are processed in
-order, and always before @samp{-imacros @var{file}}, regardless of the
+Any @option{-D} and @option{-U} options on the command line are processed in
+order, and always before @option{-imacros @var{file}}, regardless of the
order in which they are written.
@item -U@var{macro}
@opindex U
-Undefine macro @var{macro}. @samp{-U} options are evaluated after all
-@samp{-D} options, but before any @samp{-include} and @samp{-imacros}
+Undefine macro @var{macro}. @option{-U} options are evaluated after all
+@option{-D} options, but before any @option{-include} and @option{-imacros}
options.
-Any @samp{-D} and @samp{-U} options on the command line are processed in
-order, and always before @samp{-imacros @var{file}}, regardless of the
+Any @option{-D} and @option{-U} options on the command line are processed in
+order, and always before @option{-imacros @var{file}}, regardless of the
order in which they are written.
@item -dM
@opindex dM
Tell the preprocessor to output only a list of the macro definitions
-that are in effect at the end of preprocessing. Used with the @samp{-E}
+that are in effect at the end of preprocessing. Used with the @option{-E}
option.
@item -dD
@item -dN
@opindex dN
-Like @samp{-dD} except that the macro arguments and contents are omitted.
+Like @option{-dD} except that the macro arguments and contents are omitted.
Only @samp{#define @var{name}} is included in the output.
@item -dI
In this mode the integrated preprocessor is little more than a tokenizer
for the front ends.
-@samp{-fpreprocessed} is implicit if the input file has one of the
+@option{-fpreprocessed} is implicit if the input file has one of the
extensions @samp{i}, @samp{ii} or @samp{mi} indicating it has already
been preprocessed.
stand for single characters. For example, @samp{??/} stands for
@samp{\}, so @samp{'??/n'} is a character constant for a newline. By
default, GCC ignores trigraphs, but in standard-conforming modes it
-converts them. See the @samp{-std} and @samp{-ansi} options.
+converts them. See the @option{-std} and @option{-ansi} options.
The nine trigraph sequences are
@table @samp
then uses this file as if it had been specified precisely by name.
The directories searched include several standard system directories
-plus any that you specify with @samp{-L}.
+plus any that you specify with @option{-L}.
Normally the files found this way are library files---archive files
whose members are object files. The linker handles an archive file by
scanning through it for members which define symbols that have so far
been referenced but not defined. But if the file that is found is an
ordinary object file, it is linked in the usual fashion. The only
-difference between using an @samp{-l} option and specifying a file name
-is that @samp{-l} surrounds @var{library} with @samp{lib} and @samp{.a}
+difference between using an @option{-l} option and specifying a file name
+is that @option{-l} surrounds @var{library} with @samp{lib} and @samp{.a}
and searches several directories.
@item -lobjc
@opindex lobjc
-You need this special case of the @samp{-l} option in order to
+You need this special case of the @option{-l} option in order to
link an Objective C program.
@item -nostartfiles
libc. These entry points should be supplied through some other
mechanism when this option is specified.
-@cindex @code{-lgcc}, use with @code{-nostdlib}
-@cindex @code{-nostdlib} and unresolved references
-@cindex unresolved references and @code{-nostdlib}
-@cindex @code{-lgcc}, use with @code{-nodefaultlibs}
-@cindex @code{-nodefaultlibs} and unresolved references
-@cindex unresolved references and @code{-nodefaultlibs}
-One of the standard libraries bypassed by @samp{-nostdlib} and
-@samp{-nodefaultlibs} is @file{libgcc.a}, a library of internal subroutines
+@cindex @option{-lgcc}, use with @option{-nostdlib}
+@cindex @option{-nostdlib} and unresolved references
+@cindex unresolved references and @option{-nostdlib}
+@cindex @option{-lgcc}, use with @option{-nodefaultlibs}
+@cindex @option{-nodefaultlibs} and unresolved references
+@cindex unresolved references and @option{-nodefaultlibs}
+One of the standard libraries bypassed by @option{-nostdlib} and
+@option{-nodefaultlibs} is @file{libgcc.a}, a library of internal subroutines
that GCC uses to overcome shortcomings of particular machines, or special
needs for some languages.
@ifset INTERNALS
for more discussion of @file{libgcc.a}.)
@end ifclear
In most cases, you need @file{libgcc.a} even when you want to avoid
-other standard libraries. In other words, when you specify @samp{-nostdlib}
-or @samp{-nodefaultlibs} you should usually specify @samp{-lgcc} as well.
+other standard libraries. In other words, when you specify @option{-nostdlib}
+or @option{-nodefaultlibs} you should usually specify @option{-lgcc} as well.
This ensures that you have no unresolved references to internal GCC
library subroutines. (For example, @samp{__main}, used to ensure C++
constructors will be called; @pxref{Collect2,,@command{collect2}}.)
Produce a shared object which can then be linked with other objects to
form an executable. Not all systems support this option. For predictable
results, you must also specify the same set of options that were used to
-generate code (@samp{-fpic}, @samp{-fPIC}, or model suboptions)
+generate code (@option{-fpic}, @option{-fPIC}, or model suboptions)
when you specify this option.@footnote{On some systems, @samp{gcc -shared}
needs to build supplementary stub code for constructors to work. On
multi-libbed systems, @samp{gcc -shared} must select the correct support
across different shared libraries. In that case, each of the libraries
as well as the application itself should use the shared @file{libgcc}.
-Therefore, whenever you specify the @samp{-shared} option, the GCC
-driver automatically adds @samp{-shared-libgcc}, unless you explicitly
-specify @samp{-static-libgcc}. The G++ driver automatically adds
-@samp{-shared-libgcc} when you build a main executable as well because
+Therefore, whenever you specify the @option{-shared} option, the GCC
+driver automatically adds @option{-shared-libgcc}, unless you explicitly
+specify @option{-static-libgcc}. The G++ driver automatically adds
+@option{-shared-libgcc} when you build a main executable as well because
for C++ programs that is typically the right thing to do.
(Exception-handling will not work reliably otherwise.)
However, when linking a main executable written in C, you must
-explicitly say @samp{-shared-libgcc} if you want to use the shared
+explicitly say @option{-shared-libgcc} if you want to use the shared
@file{libgcc}.
@item -symbolic
recognize.
If you want to pass an option that takes an argument, you must use
-@samp{-Xlinker} twice, once for the option and once for the argument.
-For example, to pass @samp{-assert definitions}, you must write
+@option{-Xlinker} twice, once for the option and once for the argument.
+For example, to pass @option{-assert definitions}, you must write
@samp{-Xlinker -assert -Xlinker definitions}. It does not work to write
-@samp{-Xlinker "-assert definitions"}, because this passes the entire
+@option{-Xlinker "-assert definitions"}, because this passes the entire
string as a single argument, which is not what the linker expects.
@item -Wl\,@var{option}
@item -u @var{symbol}
@opindex u
Pretend the symbol @var{symbol} is undefined, to force linking of
-library modules to define it. You can use @samp{-u} multiple times with
+library modules to define it. You can use @option{-u} multiple times with
different symbols to force loading of additional library modules.
@end table
file, substituting your own version, since these directories are
searched before the system header file directories. However, you should
not use this option to add directories that contain vendor-supplied
-system header files (use @samp{-isystem} for that). If you use more than
-one @samp{-I} option, the directories are scanned in left-to-right
+system header files (use @option{-isystem} for that). If you use more than
+one @option{-I} option, the directories are scanned in left-to-right
order; the standard system directories come after.
@item -I-
@opindex I-
-Any directories you specify with @samp{-I} options before the @samp{-I-}
+Any directories you specify with @option{-I} options before the @option{-I-}
option are searched only for the case of @samp{#include "@var{file}"};
they are not searched for @samp{#include <@var{file}>}.
-If additional directories are specified with @samp{-I} options after
-the @samp{-I-}, these directories are searched for all @samp{#include}
-directives. (Ordinarily @emph{all} @samp{-I} directories are used
+If additional directories are specified with @option{-I} options after
+the @option{-I-}, these directories are searched for all @samp{#include}
+directives. (Ordinarily @emph{all} @option{-I} directories are used
this way.)
-In addition, the @samp{-I-} option inhibits the use of the current
+In addition, the @option{-I-} option inhibits the use of the current
directory (where the current input file came from) as the first search
directory for @samp{#include "@var{file}"}. There is no way to
-override this effect of @samp{-I-}. With @samp{-I.} you can specify
+override this effect of @option{-I-}. With @option{-I.} you can specify
searching the directory which was current when the compiler was
invoked. That is not exactly the same as what the preprocessor does
by default, but it is often satisfactory.
-@samp{-I-} does not inhibit the use of the standard system directories
-for header files. Thus, @samp{-I-} and @samp{-nostdinc} are
+@option{-I-} does not inhibit the use of the standard system directories
+for header files. Thus, @option{-I-} and @option{-nostdinc} are
independent.
@item -L@var{dir}
@opindex L
Add directory @var{dir} to the list of directories to be searched
-for @samp{-l}.
+for @option{-l}.
@item -B@var{prefix}
@opindex B
without @samp{@var{machine}/@var{version}/} (@pxref{Target Options}).
For each subprogram to be run, the compiler driver first tries the
-@samp{-B} prefix, if any. If that name is not found, or if @samp{-B}
+@option{-B} prefix, if any. If that name is not found, or if @option{-B}
was not specified, the driver tries two standard prefixes, which are
@file{/usr/lib/gcc/} and @file{/usr/local/lib/gcc-lib/}. If neither of
those results in a file name that is found, the unmodified program
name is searched for using the directories specified in your
@env{PATH} environment variable.
-@samp{-B} prefixes that effectively specify directory names also apply
+@option{-B} prefixes that effectively specify directory names also apply
to libraries in the linker, because the compiler translates these
-options into @samp{-L} options for the linker. They also apply to
+options into @option{-L} options for the linker. They also apply to
includes files in the preprocessor, because the compiler translates these
-options into @samp{-isystem} options for the preprocessor. In this case,
+options into @option{-isystem} options for the preprocessor. In this case,
the compiler appends @samp{include} to the prefix.
The run-time support file @file{libgcc.a} can also be searched for using
-the @samp{-B} prefix, if needed. If it is not found there, the two
+the @option{-B} prefix, if needed. If it is not found there, the two
standard prefixes above are tried, and that is all. The file is left
out of the link if it is not found by those means.
-Another way to specify a prefix much like the @samp{-B} prefix is to use
+Another way to specify a prefix much like the @option{-B} prefix is to use
the environment variable @env{GCC_EXEC_PREFIX}. @xref{Environment
Variables}.
file, in order to override the defaults that the @file{gcc} driver
program uses when determining what switches to pass to @file{cc1},
@file{cc1plus}, @file{as}, @file{ld}, etc. More than one
-@samp{-specs=}@var{file} can be specified on the command line, and they
+@option{-specs=@var{file}} can be specified on the command line, and they
are processed in order, from left to right.
@end table
by @dfn{spec strings}. In most cases there is one spec string for each
program that GCC can invoke, but a few programs have multiple spec
strings to control their behaviour. The spec strings built into GCC can
-be overridden by using the @samp{-specs=} command-line switch to specify
+be overridden by using the @option{-specs=} command-line switch to specify
a spec file.
@dfn{Spec files} are plaintext files that are used to construct spec
This says that any input file whose name ends in @samp{.ZZ} should be
passed to the program @samp{z-compile}, which should be invoked with the
-command-line switch @samp{-input} and with the result of performing the
+command-line switch @option{-input} and with the result of performing the
@samp{%i} substitution. (See below.)
As an alternative to providing a spec string, the text that follows a
C.
@item %I
-Substitute a @samp{-iprefix} option made from GCC_EXEC_PREFIX.
+Substitute a @option{-iprefix} option made from GCC_EXEC_PREFIX.
@item %s
Current argument is the name of a library or startup file of some sort.
Substitute the contents of spec string @var{name} at this point.
@item %[@var{name}]
-Like @samp{%(@dots{})} but put @samp{__} around @samp{-D} arguments.
+Like @samp{%(@dots{})} but put @samp{__} around @option{-D} arguments.
@item %x@{@var{option}@}
Accumulate an option for @samp{%X}.
@item %X
-Output the accumulated linker options specified by @samp{-Wl} or a @samp{%x}
+Output the accumulated linker options specified by @option{-Wl} or a @samp{%x}
spec string.
@item %Y
-Output the accumulated assembler options specified by @samp{-Wa}.
+Output the accumulated assembler options specified by @option{-Wa}.
@item %Z
-Output the accumulated preprocessor options specified by @samp{-Wp}.
+Output the accumulated preprocessor options specified by @option{-Wp}.
@item %v1
Substitute the major version number of GCC.
@samp{%L %G %S %D and %E} sequences.
@item %D
-Dump out a @samp{-L} option for each directory that GCC believes might
+Dump out a @option{-L} option for each directory that GCC believes might
contain startup files. If the target supports multilibs then the
current multilib directory will be prepended to each of these paths.
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 @samp{%@{foo@}} would match the command-line option @samp{-foo}
-and would output the command line option @samp{-foo}.
+string @samp{%@{foo@}} would match the command-line option @option{-foo}
+and would output the command line option @option{-foo}.
@item %W@{@code{S}@}
Like %@{@code{S}@} but mark last argument supplied within as a file to be
Substitutes all the switches specified to GCC whose names start
with @code{-S}, but which also take an argument. This is used for
switches like @option{-o}, @option{-D}, @option{-I}, etc.
-GCC considers @samp{-o foo} as being
+GCC considers @option{-o foo} as being
one switch whose names starts with @samp{o}. %@{o*@} would substitute this
text, including the space. Thus two arguments would be generated.
The @option{-O}, @option{-f}, @option{-m}, and @option{-W}
switches are handled specifically in these
-constructs. If another value of @samp{-O} or the negated form of a @samp{-f, -m, or
--W} switch is found later in the command line, the earlier switch
+constructs. If another value of @option{-O} or the negated form of a @option{-f}, @option{-m}, or
+@option{-W} switch is found later in the command line, the earlier switch
value is ignored, except with @{@code{S}*@} where @code{S} is just one
letter, which passes all matching options.
The character @samp{|} at the beginning of the predicate text is used to indicate
-that a command should be piped to the following command, but only if @samp{-pipe}
+that a command should be piped to the following command, but only if @option{-pipe}
is specified.
It is built into GCC which switches take arguments and which do not.
and it must know which input files to compile in order to tell which
compilers to run).
-GCC also knows implicitly that arguments starting in @samp{-l} are to be
+GCC also knows implicitly that arguments starting in @option{-l} are to be
treated as compiler output files, and passed to the linker in their
proper position among the other output files.
compile for some other type of machine. In fact, several different
configurations of GCC, for different target machines, can be
installed side by side. Then you specify which one to use with the
-@samp{-b} option.
+@option{-b} option.
In addition, older and newer versions of GCC can be installed side
by side. One of them (probably the newest) will be the default, but
machine type when configuring GCC as a cross-compiler. For
example, if a cross-compiler was configured with @samp{configure
i386v}, meaning to compile for an 80386 running System V, then you
-would specify @samp{-b i386v} to run that cross compiler.
+would specify @option{-b i386v} to run that cross compiler.
-When you do not specify @samp{-b}, it normally means to compile for
+When you do not specify @option{-b}, it normally means to compile for
the same type of machine that you are using.
@item -V @var{version}
This is useful when multiple versions are installed. For example,
@var{version} might be @samp{2.0}, meaning to run GCC version 2.0.
-The default version, when you do not specify @samp{-V}, is the last
+The default version, when you do not specify @option{-V}, is the last
version of GCC that you installed.
@end table
-The @samp{-b} and @samp{-V} options actually work by controlling part of
+The @option{-b} and @option{-V} options actually work by controlling part of
the file name used for the executable files and libraries used for
compilation. A given version of GCC, for a given target machine, is
normally kept in the directory @file{/usr/local/lib/gcc-lib/@var{machine}/@var{version}}.@refill
-Thus, sites can customize the effect of @samp{-b} or @samp{-V} either by
+Thus, sites can customize the effect of @option{-b} or @option{-V} either by
changing the names of these directories or adding alternate names (or
symbolic links). If in directory @file{/usr/local/lib/gcc-lib/} the
-file @file{80386} is a link to the file @file{i386v}, then @samp{-b
-80386} becomes an alias for @samp{-b i386v}.
+file @file{80386} is a link to the file @file{i386v}, then @option{-b
+80386} becomes an alias for @option{-b i386v}.
-In one respect, the @samp{-b} or @samp{-V} do not completely change
+In one respect, the @option{-b} or @option{-V} do not completely change
to a different compiler: the top-level driver program @command{gcc}
that you originally invoked continues to run and invoke the other
executables (preprocessor, compiler per se, assembler and linker)
in use is not the one for the specified target. It is common for the
interface to the other executables to change incompatibly between
compiler versions, so unless the version specified is very close to that
-of the driver (for example, @samp{-V 3.0} with a driver program from GCC
-version 3.0.1), use of @samp{-V} may not work; for example, using
-@samp{-V 2.95.2} will not work with a driver program from GCC 3.0.
+of the driver (for example, @option{-V 3.0} with a driver program from GCC
+version 3.0.1), use of @option{-V} may not work; for example, using
+@option{-V 2.95.2} will not work with a driver program from GCC 3.0.
The only way that the driver program depends on the target machine is
in the parsing and handling of special machine-specific options.
and that for version 2.1 is installed as @command{gcc}, then the command
@command{gcc} will use version 2.1 by default, while @command{ogcc} will use
2.0 by default. However, you can choose either version with either
-command with the @samp{-V} option.
+command with the @option{-V} option.
@node Submodel Options
@section Hardware Models and Configurations
@cindex hardware models and configurations, specifying
@cindex machine dependent options
-Earlier we discussed the standard option @samp{-b} which chooses among
+Earlier we discussed the standard option @option{-b} which chooses among
different installed compilers for completely different target
machines, such as Vax vs. 68000 vs. 80386.
@item -m68881
@opindex m68881
Generate output containing 68881 instructions for floating point.
-This is the default for most 68020 systems unless @samp{-nfp} was
+This is the default for most 68020 systems unless @option{--nfp} was
specified when the compiler was configured.
@item -m68030
@item -mnobitfield
@opindex mnobitfield
-Do not use the bit-field instructions. The @samp{-m68000}, @samp{-mcpu32}
-and @samp{-m5200} options imply @w{@samp{-mnobitfield}}.
+Do not use the bit-field instructions. The @option{-m68000}, @option{-mcpu32}
+and @option{-m5200} options imply @w{@option{-mnobitfield}}.
@item -mbitfield
@opindex mbitfield
-Do use the bit-field instructions. The @samp{-m68020} option implies
-@samp{-mbitfield}. This is the default if you use a configuration
+Do use the bit-field instructions. The @option{-m68020} option implies
+@option{-mbitfield}. This is the default if you use a configuration
designed for a 68020.
@item -mrtd
@opindex mno-align-int
Control whether GCC aligns @code{int}, @code{long}, @code{long long},
@code{float}, @code{double}, and @code{long double} variables on a 32-bit
-boundary (@samp{-malign-int}) or a 16-bit boundary (@samp{-mno-align-int}).
+boundary (@option{-malign-int}) or a 16-bit boundary (@option{-mno-align-int}).
Aligning variables on 32-bit boundaries produces code that runs somewhat
faster on processors with 32-bit busses at the expense of more memory.
-@strong{Warning:} if you use the @samp{-malign-int} switch, GCC will
+@strong{Warning:} if you use the @option{-malign-int} switch, GCC will
align structures containing the above types differently than
most published application binary interface specifications for the m68k.
@itemx -mapp-regs
@opindex mno-app-regs
@opindex mapp-regs
-Specify @samp{-mapp-regs} to generate output using the global registers
+Specify @option{-mapp-regs} to generate output using the global registers
2 through 4, which the SPARC SVR4 ABI reserves for applications. This
is the default.
To be fully SVR4 ABI compliant at the cost of some performance loss,
-specify @samp{-mno-app-regs}. You should compile libraries and system
+specify @option{-mno-app-regs}. You should compile libraries and system
software with this option.
@item -mfpu
cross-compilation. The embedded targets @samp{sparc-*-aout} and
@samp{sparclite-*-*} do provide software floating point support.
-@samp{-msoft-float} changes the calling convention in the output file;
+@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 @samp{-msoft-float} in order for
+library that comes with GCC, with @option{-msoft-float} in order for
this to work.
@item -mhard-quad-float
a trap handler for one of these instructions, and then the trap handler
emulates the effect of the instruction. Because of the trap handler overhead,
this is much slower than calling the ABI library routines. Thus the
-@samp{-msoft-quad-float} option is the default.
+@option{-msoft-quad-float} option is the default.
@item -mno-epilogue
@itemx -mepilogue
@opindex mno-epilogue
@opindex mepilogue
-With @samp{-mepilogue} (the default), the compiler always emits code for
+With @option{-mepilogue} (the default), the compiler always emits code for
function exit at the end of each function. Any function exit in
the middle of the function (such as a return statement in C) will
generate a jump to the exit code at the end of the function.
-With @samp{-mno-epilogue}, the compiler tries to emit exit code inline
+With @option{-mno-epilogue}, the compiler tries to emit exit code inline
at every function exit.
@item -mno-flat
@itemx -mflat
@opindex mno-flat
@opindex mflat
-With @samp{-mflat}, the compiler does not generate save/restore instructions
+With @option{-mflat}, the compiler does not generate save/restore instructions
and will use a ``flat'' or single register window calling convention.
This model uses %i7 as the frame pointer and is compatible with the normal
register window model. Code from either may be intermixed.
The local registers and the input registers (0-5) are still treated as
``call saved'' registers and will be saved on the stack as necessary.
-With @samp{-mno-flat} (the default), the compiler emits save/restore
+With @option{-mno-flat} (the default), the compiler emits save/restore
instructions (except for leaf functions) and is the normal mode of operation.
@item -mno-unaligned-doubles
@opindex munaligned-doubles
Assume that doubles have 8 byte alignment. This is the default.
-With @samp{-munaligned-doubles}, GCC assumes that doubles have 8 byte
+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
@itemx -mfaster-structs
@opindex mno-faster-structs
@opindex mfaster-structs
-With @samp{-mfaster-structs}, the compiler assumes that structures
+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.
By default (unless specifically configured for the Fujitsu SPARClite),
GCC generates code for the v7 variant of the SPARC architecture.
-@samp{-mv8} will give you SPARC v8 code. The only difference from v7
+@option{-mv8} will give you SPARC v8 code. The only difference from v7
code is that the compiler emits the integer multiply and integer
divide instructions which exist in SPARC v8 but not in SPARC v7.
-@samp{-msparclite} will give you SPARClite code. This adds the integer
+@option{-msparclite} will give you SPARClite code. This adds the integer
multiply, integer divide step and scan (@code{ffs}) instructions which
exist in SPARClite but not in SPARC v7.
These options are deprecated and will be deleted in a future GCC release.
-They have been replaced with @samp{-mcpu=xxx}.
+They have been replaced with @option{-mcpu=xxx}.
@item -mcypress
@itemx -msupersparc
@opindex msupersparc
These two options select the processor for which the code is optimised.
-With @samp{-mcypress} (the default), the compiler optimizes code for the
+With @option{-mcypress} (the default), the compiler optimizes code for the
Cypress CY7C602 chip, as used in the SparcStation/SparcServer 3xx series.
This is also appropriate for the older SparcStation 1, 2, IPX etc.
-With @samp{-msupersparc} the compiler optimizes code for the SuperSparc cpu, as
+With @option{-msupersparc} the compiler optimizes code for the SuperSparc cpu, as
used in the SparcStation 10, 1000 and 2000 series. This flag also enables use
of the full SPARC v8 instruction set.
These options are deprecated and will be deleted in a future GCC release.
-They have been replaced with @samp{-mcpu=xxx}.
+They have been replaced with @option{-mcpu=xxx}.
@item -mcpu=@var{cpu_type}
@opindex mcpu
@opindex mtune
Set the instruction scheduling parameters for machine type
@var{cpu_type}, but do not set the instruction set or register set that the
-option @samp{-mcpu=}@var{cpu_type} would.
+option @option{-mcpu=@var{cpu_type}} would.
-The same values for @samp{-mcpu=}@var{cpu_type} are used for
-@samp{-mtune=}@*@var{cpu_type}, though the only useful values are those that
+The same values for @option{-mcpu=@var{cpu_type}} are used for
+@option{-mtune=@var{cpu_type}}, though the only useful values are those that
select a particular cpu implementation: @samp{cypress}, @samp{supersparc},
@samp{hypersparc}, @samp{f930}, @samp{f934}, @samp{sparclite86x},
@samp{tsc701}, @samp{ultrasparc}.
@itemx -mno-stack-bias
@opindex mstack-bias
@opindex mno-stack-bias
-With @samp{-mstack-bias}, GCC assumes that the stack pointer, and
-frame pointer if present, are offset by -2047 which must be added back
+With @option{-mstack-bias}, GCC assumes that the stack pointer, and
+frame pointer if present, are offset by @minus{}2047 which must be added back
when making stack frame references.
Otherwise, assume no such offset is present.
@end table
@item -mnbw
@opindex mnbw
Generate code that assumes the systems does not support byte and
-halfword write operations. @samp{-mnbw} implies @samp{-mndw}.
+halfword write operations. @option{-mnbw} implies @option{-mndw}.
@item -msmall
@opindex msmall
@opindex mstorem-bug
@opindex mno-storem-bug
@cindex storem bug (29k)
-@samp{-mstorem-bug} handles 29k processors which cannot handle the
+@option{-mstorem-bug} handles 29k processors which cannot handle the
separation of a mtsrim insn and a storem instruction (most 29000 chips
to date, but not the 29050).
@itemx -mreuse-arg-regs
@opindex mno-reuse-arg-regs
@opindex mreuse-arg-regs
-@samp{-mno-reuse-arg-regs} tells the compiler to only use incoming argument
+@option{-mno-reuse-arg-regs} tells the compiler to only use incoming argument
registers for copying out arguments. This helps detect calling a function
with fewer arguments than it was declared with.
@itemx -mimpure-text
@opindex mno-impure-text
@opindex mimpure-text
-@samp{-mimpure-text}, used in addition to @samp{-shared}, tells the compiler to
-not pass @samp{-assert pure-text} to the linker when linking a shared object.
+@option{-mimpure-text}, used in addition to @option{-shared}, tells the compiler to
+not pass @option{-assert pure-text} to the linker when linking a shared object.
@item -msoft-float
@opindex msoft-float
@opindex mapcs-frame
Generate a stack frame that is compliant with the ARM Procedure Call
Standard for all functions, even if this is not strictly necessary for
-correct execution of the code. Specifying @samp{-fomit-frame-pointer}
+correct execution of the code. Specifying @option{-fomit-frame-pointer}
with this option will cause the stack frames not to be generated for
-leaf functions. The default is @samp{-mno-apcs-frame}.
+leaf functions. The default is @option{-mno-apcs-frame}.
@item -mapcs
@opindex mapcs
-This is a synonym for @samp{-mapcs-frame}.
+This is a synonym for @option{-mapcs-frame}.
@item -mapcs-26
@opindex mapcs-26
Generate code for a processor running with a 26-bit program counter,
and conforming to the function calling standards for the APCS 26-bit
-option. This option replaces the @samp{-m2} and @samp{-m3} options
+option. This option replaces the @option{-m2} and @option{-m3} options
of previous releases of the compiler.
@item -mapcs-32
@opindex mapcs-32
Generate code for a processor running with a 32-bit program counter,
and conforming to the function calling standards for the APCS 32-bit
-option. This option replaces the @samp{-m6} option of previous releases
+option. This option replaces the @option{-m6} option of previous releases
of the compiler.
@ignore
@samp{__rt_stkovf_split_small} or @samp{__rt_stkovf_split_big} will be
called, depending upon the amount of stack space required. The run time
system is required to provide these functions. The default is
-@samp{-mno-apcs-stack-check}, since this produces smaller code.
+@option{-mno-apcs-stack-check}, since this produces smaller code.
@c not currently implemented
@item -mapcs-float
one of the variants of the APCS. This option is recommended if the
target hardware has a floating point unit or if a lot of floating point
arithmetic is going to be performed by the code. The default is
-@samp{-mno-apcs-float}, since integer only code is slightly increased in
-size if @samp{-mapcs-float} is used.
+@option{-mno-apcs-float}, since integer only code is slightly increased in
+size if @option{-mapcs-float} is used.
@c not currently implemented
@item -mapcs-reentrant
@opindex mapcs-reentrant
Generate reentrant, position independent code. The default is
-@samp{-mno-apcs-reentrant}.
+@option{-mno-apcs-reentrant}.
@end ignore
@item -mthumb-interwork
Generate code which supports calling between the ARM and Thumb
instruction sets. Without this option the two instruction sets cannot
be reliably used inside one program. The default is
-@samp{-mno-thumb-interwork}, since slightly larger code is generated
-when @samp{-mthumb-interwork} is specified.
+@option{-mno-thumb-interwork}, since slightly larger code is generated
+when @option{-mthumb-interwork} is specified.
@item -mno-sched-prolog
@opindex mno-sched-prolog
of instructions (or in fact one of a choice from a small set of
different function prologues), and this information can be used to
locate the start if functions inside an executable piece of code. The
-default is @samp{-msched-prolog}.
+default is @option{-msched-prolog}.
@item -mhard-float
@opindex mhard-float
your own arrangements to provide suitable library functions for
cross-compilation.
-@samp{-msoft-float} changes the calling convention in the output file;
+@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 @samp{-msoft-float} in order for
+library that comes with GCC, with @option{-msoft-float} in order for
this to work.
@item -mlittle-endian
@itemx -mno-short-load-words
@opindex mshort-load-bytes
@opindex mno-short-load-words
-These are deprecated aliases for @samp{-malignment-traps}.
+These are deprecated aliases for @option{-malignment-traps}.
@item -mno-short-load-bytes
@itemx -mshort-load-words
@opindex mno-short-load-bytes
@opindex mshort-load-words
-This are deprecated aliases for @samp{-mno-alignment-traps}.
+This are deprecated aliases for @option{-mno-alignment-traps}.
@item -mbsd
@opindex mbsd
This option only applies to RISC iX. Emulate the native BSD-mode
-compiler. This is the default if @samp{-ansi} is not specified.
+compiler. This is the default if @option{-ansi} is not specified.
@item -mxopen
@opindex mxopen
@itemx -mtune=@var{name}
@opindex mtune
-This option is very similar to the @samp{-mcpu=} option, except that
+This option is very similar to the @option{-mcpu=} option, except that
instead of specifying the actual target processor type, and hence
restricting which instructions can be used, it specifies that GCC should
tune the performance of the code as if the target were of the type
specified in this option, but still choosing the instructions that it
-will generate based on the cpu specified by a @samp{-mcpu=} option.
+will generate based on the cpu specified by a @option{-mcpu=} option.
For some ARM implementations better performance can be obtained by using
this option.
This specifies the name of the target ARM architecture. GCC uses this
name to determine what kind of instructions it can emit when generating
assembly code. This option can be used in conjunction with or instead
-of the @samp{-mcpu=} option. Permissible names are: armv2, armv2a,
+of the @option{-mcpu=} option. Permissible names are: armv2, armv2a,
armv3, armv3m, armv4, armv4t, armv5, armv5t, armv5te.
@item -mfpe=@var{number}
@opindex mfpe
@opindex mfp
This specifies the version of the floating point emulation available on
-the target. Permissible values are 2 and 3. @samp{-mfp=} is a synonym
-for @samp{-mfpe=}, for compatibility with older versions of GCC.
+the target. Permissible values are 2 and 3. @option{-mfp=} is a synonym
+for @option{-mfpe=}, for compatibility with older versions of GCC.
@item -mstructure-size-boundary=@var{n}
@opindex mstructure-size-boundary
turned into long calls.
This feature is not enabled by default. Specifying
-@samp{-mno-long-calls} will restore the default behaviour, as will
+@option{-mno-long-calls} will restore the default behaviour, 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
@opindex mtpcs-frame
Generate a stack frame that is compliant with the Thumb Procedure Call
Standard for all non-leaf functions. (A leaf function is one that does
-not call any other functions.) The default is @samp{-mno-tpcs-frame}.
+not call any other functions.) The default is @option{-mno-tpcs-frame}.
@item -mtpcs-leaf-frame
@opindex mtpcs-leaf-frame
Generate a stack frame that is compliant with the Thumb Procedure Call
Standard for all leaf functions. (A leaf function is one that does
-not call any other functions.) The default is @samp{-mno-apcs-leaf-frame}.
+not call any other functions.) The default is @option{-mno-apcs-leaf-frame}.
@item -mcallee-super-interworking
@opindex mcallee-super-interworking
@node MN10200 Options
@subsection MN10200 Options
@cindex MN10200 options
-These @samp{-m} options are defined for Matsushita MN10200 architectures:
+These @option{-m} options are defined for Matsushita MN10200 architectures:
@table @gcctabopt
@item -mrelax
@node MN10300 Options
@subsection MN10300 Options
@cindex MN10300 options
-These @samp{-m} options are defined for Matsushita MN10300 architectures:
+These @option{-m} options are defined for Matsushita MN10300 architectures:
@table @gcctabopt
@item -mmult-bug
@subsection M32R/D Options
@cindex M32R/D options
-These @samp{-m} options are defined for Mitsubishi M32R/D architectures:
+These @option{-m} options are defined for Mitsubishi M32R/D architectures:
@table @gcctabopt
@item -mcode-model=small
Put global and static objects less than or equal to @var{num} bytes
into the small data or bss sections instead of the normal data or bss
sections. The default value of @var{num} is 8.
-The @samp{-msdata} option must be set to one of @samp{sdata} or @samp{use}
+The @option{-msdata} option must be set to one of @samp{sdata} or @samp{use}
for this option to have any effect.
-All modules should be compiled with the same @samp{-G @var{num}} value.
+All modules should be compiled with the same @option{-G @var{num}} value.
Compiling with different values of @var{num} may or may not work; if it
doesn't the linker will give an error message---incorrect code will not be
generated.
@item -mbig-pic
@opindex mbig-pic
Obsolete option to be removed from the next revision.
-Use @samp{-fPIC}.
+Use @option{-fPIC}.
@item -midentify-revision
@opindex midentify-revision
parameters stored on the stack, use the offset from the canonical frame
address, which is the stack pointer (register 31) on entry to the
function. The DG/UX, SVr4, Delta88 SVr3.2, and BCS configurations use
-@samp{-mocs-frame-position}; other 88k configurations have the default
-@samp{-mno-ocs-frame-position}.
+@option{-mocs-frame-position}; other 88k configurations have the default
+@option{-mno-ocs-frame-position}.
@item -mno-ocs-frame-position
@opindex mno-ocs-frame-position
@opindex mno-optimize-arg-area
@cindex arguments in frame (88k)
Control how function arguments are stored in stack frames.
-@samp{-moptimize-arg-area} saves space by optimizing them, but this
+@option{-moptimize-arg-area} saves space by optimizing them, but this
conflicts with the 88open specifications. The opposite alternative,
-@samp{-mno-optimize-arg-area}, agrees with 88open standards. By default
+@option{-mno-optimize-arg-area}, agrees with 88open standards. By default
GCC does not optimize the argument area.
@item -mshort-data-@var{num}
which allows loading a value using a single instruction (rather than the
usual two). You control which data references are affected by
specifying @var{num} with this option. For example, if you specify
-@samp{-mshort-data-512}, then the data references affected are those
+@option{-mshort-data-512}, then the data references affected are those
involving displacements of less than 512 bytes.
-@samp{-mshort-data-@var{num}} is not effective for @var{num} greater
+@option{-mshort-data-@var{num}} is not effective for @var{num} greater
than 64k.
@item -mserialize-volatile
The MC88100 processor does not reorder memory references and so
always provides sequential consistency. However, by default, GNU
C generates the special instructions to guarantee consistency
-even when you use @samp{-m88100}, so that the code may be run on an
+even when you use @option{-m88100}, so that the code may be run on an
MC88110 processor. If you intend to run your code only on the
-MC88100 processor, you may use @samp{-mno-serialize-volatile}.
+MC88100 processor, you may use @option{-mno-serialize-volatile}.
The extra code generated to guarantee consistency may affect the
performance of your application. If you know that you can safely
-forgo this guarantee, you may use @samp{-mno-serialize-volatile}.
+forgo this guarantee, you may use @option{-mno-serialize-volatile}.
@item -msvr4
@itemx -msvr3
@opindex msvr3
@cindex assembler syntax, 88k
@cindex SVr4
-Turn on (@samp{-msvr4}) or off (@samp{-msvr3}) compiler extensions
+Turn on (@option{-msvr4}) or off (@option{-msvr3}) compiler extensions
related to System V release 4 (SVr4). This controls the following:
@enumerate
@item
Which variant of the assembler syntax to emit.
@item
-@samp{-msvr4} makes the C preprocessor recognize @samp{#pragma weak}
+@option{-msvr4} makes the C preprocessor recognize @samp{#pragma weak}
that is used on System V release 4.
@item
-@samp{-msvr4} makes GCC issue additional declaration directives used in
+@option{-msvr4} makes GCC issue additional declaration directives used in
SVr4.
@end enumerate
-@samp{-msvr4} is the default for the m88k-motorola-sysv4 and
-m88k-dg-dgux m88k configurations. @samp{-msvr3} is the default for all
+@option{-msvr4} is the default for the m88k-motorola-sysv4 and
+m88k-dg-dgux m88k configurations. @option{-msvr3} is the default for all
other m88k configurations.
@item -mversion-03.00
generated to run on an MC88100 processor.
GNU C assumes that the MC88110 processor correctly detects all
-instances of integer division by zero. When @samp{-m88110} is
-specified, both @samp{-mcheck-zero-division} and
-@samp{-mno-check-zero-division} are ignored, and no explicit checks for
+instances of integer division by zero. When @option{-m88110} is
+specified, both @option{-mcheck-zero-division} and
+@option{-mno-check-zero-division} are ignored, and no explicit checks for
zero-valued divisors are generated.
@item -muse-div-instruction
On the MC88110 processor the div instruction (also known as the
divs instruction) processes negative operands without trapping to
-the operating system. When @samp{-m88110} is specified,
-@samp{-muse-div-instruction} is ignored, and the div instruction is used
+the operating system. When @option{-m88110} is specified,
+@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 -1 is undefined. In
+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
-@samp{-muse-div-instruction} may differ.
+@option{-muse-div-instruction} may differ.
@item -mtrap-large-shift
@itemx -mhandle-large-shift
You use these options to specify which instructions are available on the
processor you are using. The default value of these options is
determined when configuring GCC. Specifying the
-@samp{-mcpu=@var{cpu_type}} overrides the specification of these
-options. We recommend you use the @samp{-mcpu=@var{cpu_type}} option
+@option{-mcpu=@var{cpu_type}} overrides the specification of these
+options. We recommend you use the @option{-mcpu=@var{cpu_type}} option
rather than the options listed above.
-The @samp{-mpower} option allows GCC to generate instructions that
+The @option{-mpower} option allows GCC to generate instructions that
are found only in the POWER architecture and to use the MQ register.
-Specifying @samp{-mpower2} implies @samp{-power} and also allows GCC
+Specifying @option{-mpower2} implies @option{-power} and also allows GCC
to generate instructions that are present in the POWER2 architecture but
not the original POWER architecture.
-The @samp{-mpowerpc} option allows GCC to generate instructions that
+The @option{-mpowerpc} option allows GCC to generate instructions that
are found only in the 32-bit subset of the PowerPC architecture.
-Specifying @samp{-mpowerpc-gpopt} implies @samp{-mpowerpc} and also allows
+Specifying @option{-mpowerpc-gpopt} implies @option{-mpowerpc} and also allows
GCC to use the optional PowerPC architecture instructions in the
General Purpose group, including floating-point square root. Specifying
-@samp{-mpowerpc-gfxopt} implies @samp{-mpowerpc} and also allows GCC to
+@option{-mpowerpc-gfxopt} implies @option{-mpowerpc} and also allows GCC to
use the optional PowerPC architecture instructions in the Graphics
group, including floating-point select.
-The @samp{-mpowerpc64} option allows GCC to generate the additional
+The @option{-mpowerpc64} option allows GCC to generate the additional
64-bit instructions that are found in the full PowerPC64 architecture
and to treat GPRs as 64-bit, doubleword quantities. GCC defaults to
-@samp{-mno-powerpc64}.
+@option{-mno-powerpc64}.
-If you specify both @samp{-mno-power} and @samp{-mno-powerpc}, GCC
+If you specify both @option{-mno-power} and @option{-mno-powerpc}, GCC
will use only the instructions in the common subset of both
architectures plus some special AIX common-mode calls, and will not use
-the MQ register. Specifying both @samp{-mpower} and @samp{-mpowerpc}
+the MQ register. Specifying both @option{-mpower} and @option{-mpowerpc}
permits GCC to use any instruction from either architecture and to
allow use of the MQ register; specify this for the Motorola MPC601.
@opindex mnew-mnemonics
@opindex mold-mnemonics
Select which mnemonics to use in the generated assembler code.
-@samp{-mnew-mnemonics} requests output that uses the assembler mnemonics
-defined for the PowerPC architecture, while @samp{-mold-mnemonics}
+@option{-mnew-mnemonics} requests output that uses the assembler mnemonics
+defined for the PowerPC architecture, while @option{-mold-mnemonics}
requests the assembler mnemonics defined for the POWER architecture.
Instructions defined in only one architecture have only one mnemonic;
GCC uses that mnemonic irrespective of which of these options is
specified.
GCC defaults to the mnemonics appropriate for the architecture in
-use. Specifying @samp{-mcpu=@var{cpu_type}} sometimes overrides the
+use. Specifying @option{-mcpu=@var{cpu_type}} sometimes overrides the
value of these option. Unless you are building a cross-compiler, you
-should normally not specify either @samp{-mnew-mnemonics} or
-@samp{-mold-mnemonics}, but should instead accept the default.
+should normally not specify either @option{-mnew-mnemonics} or
+@option{-mold-mnemonics}, but should instead accept the default.
@item -mcpu=@var{cpu_type}
@opindex mcpu
@samp{603}, @samp{603e}, @samp{604}, @samp{604e}, @samp{620},
@samp{630}, @samp{740}, @samp{750}, @samp{power}, @samp{power2},
@samp{powerpc}, @samp{403}, @samp{505}, @samp{801}, @samp{821},
-@samp{823}, and @samp{860} and @samp{common}. @samp{-mcpu=power},
-@samp{-mcpu=power2}, @samp{-mcpu=powerpc}, and @samp{-mcpu=powerpc64}
+@samp{823}, and @samp{860} and @samp{common}. @option{-mcpu=power},
+@option{-mcpu=power2}, @option{-mcpu=powerpc}, and @option{-mcpu=powerpc64}
specify generic POWER, POWER2, pure 32-bit PowerPC (i.e., not MPC601),
and 64-bit PowerPC architecture machine types, with an appropriate,
generic processor model assumed for scheduling purposes.@refill
Specifying any of the following options:
-@samp{-mcpu=rios1}, @samp{-mcpu=rios2}, @samp{-mcpu=rsc},
-@samp{-mcpu=power}, or @samp{-mcpu=power2}
-enables the @samp{-mpower} option and disables the @samp{-mpowerpc} option;
-@samp{-mcpu=601} enables both the @samp{-mpower} and @samp{-mpowerpc} options.
-All of @samp{-mcpu=rs64a}, @samp{-mcpu=602}, @samp{-mcpu=603},
-@samp{-mcpu=603e}, @samp{-mcpu=604}, @samp{-mcpu=620}, @samp{-mcpu=630},
-@samp{-mcpu=740}, and @samp{-mcpu=750}
-enable the @samp{-mpowerpc} option and disable the @samp{-mpower} option.
-Exactly similarly, all of @samp{-mcpu=403},
-@samp{-mcpu=505}, @samp{-mcpu=821}, @samp{-mcpu=860} and @samp{-mcpu=powerpc}
-enable the @samp{-mpowerpc} option and disable the @samp{-mpower} option.
-@samp{-mcpu=common} disables both the
-@samp{-mpower} and @samp{-mpowerpc} options.@refill
-
-AIX versions 4 or greater selects @samp{-mcpu=common} by default, so
+@option{-mcpu=rios1}, @option{-mcpu=rios2}, @option{-mcpu=rsc},
+@option{-mcpu=power}, or @option{-mcpu=power2}
+enables the @option{-mpower} option and disables the @option{-mpowerpc} option;
+@option{-mcpu=601} enables both the @option{-mpower} and @option{-mpowerpc} options.
+All of @option{-mcpu=rs64a}, @option{-mcpu=602}, @option{-mcpu=603},
+@option{-mcpu=603e}, @option{-mcpu=604}, @option{-mcpu=620}, @option{-mcpu=630},
+@option{-mcpu=740}, and @option{-mcpu=750}
+enable the @option{-mpowerpc} option and disable the @option{-mpower} option.
+Exactly similarly, all of @option{-mcpu=403},
+@option{-mcpu=505}, @option{-mcpu=821}, @option{-mcpu=860} and @option{-mcpu=powerpc}
+enable the @option{-mpowerpc} option and disable the @option{-mpower} option.
+@option{-mcpu=common} disables both the
+@option{-mpower} and @option{-mpowerpc} options.@refill
+
+AIX versions 4 or greater selects @option{-mcpu=common} by default, so
that code will operate on all members of the RS/6000 POWER and PowerPC
families. In that case, GCC will use only the instructions in the
common subset of both architectures plus some special AIX common-mode
calls, and will not use the MQ register. GCC assumes a generic
processor model for scheduling purposes.
-Specifying any of the options @samp{-mcpu=rios1}, @samp{-mcpu=rios2},
-@samp{-mcpu=rsc}, @samp{-mcpu=power}, or @samp{-mcpu=power2} also
-disables the @samp{new-mnemonics} option. Specifying @samp{-mcpu=601},
-@samp{-mcpu=602}, @samp{-mcpu=603}, @samp{-mcpu=603e}, @samp{-mcpu=604},
-@samp{-mcpu=620}, @samp{-mcpu=630}, @samp{-mcpu=403}, @samp{-mcpu=505},
-@samp{-mcpu=821}, @samp{-mcpu=860} or @samp{-mcpu=powerpc} also enables
+Specifying any of the options @option{-mcpu=rios1}, @option{-mcpu=rios2},
+@option{-mcpu=rsc}, @option{-mcpu=power}, or @option{-mcpu=power2} also
+disables the @samp{new-mnemonics} option. Specifying @option{-mcpu=601},
+@option{-mcpu=602}, @option{-mcpu=603}, @option{-mcpu=603e}, @option{-mcpu=604},
+@option{-mcpu=620}, @option{-mcpu=630}, @option{-mcpu=403}, @option{-mcpu=505},
+@option{-mcpu=821}, @option{-mcpu=860} or @option{-mcpu=powerpc} also enables
the @samp{new-mnemonics} option.@refill
-Specifying @samp{-mcpu=403}, @samp{-mcpu=821}, or @samp{-mcpu=860} also
-enables the @samp{-msoft-float} option.
+Specifying @option{-mcpu=403}, @option{-mcpu=821}, or @option{-mcpu=860} also
+enables the @option{-msoft-float} option.
@item -mtune=@var{cpu_type}
@opindex mtune
Set the instruction scheduling parameters for machine type
@var{cpu_type}, but do not set the architecture type, register usage,
-choice of mnemonics like @samp{-mcpu=}@var{cpu_type} would. The same
-values for @var{cpu_type} are used for @samp{-mtune=}@var{cpu_type} as
-for @samp{-mcpu=}@var{cpu_type}. The @samp{-mtune=}@var{cpu_type}
-option overrides the @samp{-mcpu=}@var{cpu_type} option in terms of
+choice of mnemonics like @option{-mcpu=@var{cpu_type}} would. The same
+values for @var{cpu_type} are used for @option{-mtune=@var{cpu_type}} as
+for @option{-mcpu=@var{cpu_type}}. The @option{-mtune=@var{cpu_type}}
+option overrides the @option{-mcpu=@var{cpu_type}} option in terms of
instruction scheduling parameters.
@item -mfull-toc
@opindex mno-sum-in-toc
@opindex mminimal-toc
Modify generation of the TOC (Table Of Contents), which is created for
-every executable file. The @samp{-mfull-toc} option is selected by
+every executable file. The @option{-mfull-toc} option is selected by
default. In that case, GCC will allocate at least one TOC entry for
each unique non-automatic variable reference in your program. GCC
will also place floating-point constants in the TOC. However, only
If you receive a linker error message that saying you have overflowed
the available TOC space, you can reduce the amount of TOC space used
-with the @samp{-mno-fp-in-toc} and @samp{-mno-sum-in-toc} options.
-@samp{-mno-fp-in-toc} prevents GCC from putting floating-point
-constants in the TOC and @samp{-mno-sum-in-toc} forces GCC to
+with the @option{-mno-fp-in-toc} and @option{-mno-sum-in-toc} options.
+@option{-mno-fp-in-toc} prevents GCC from putting floating-point
+constants in the TOC and @option{-mno-sum-in-toc} forces GCC to
generate code to calculate the sum of an address and a constant at
run-time instead of putting that sum into the TOC. You may specify one
or both of these options. Each causes GCC to produce very slightly
slower and larger code at the expense of conserving TOC space.
If you still run out of space in the TOC even when you specify both of
-these options, specify @samp{-mminimal-toc} instead. This option causes
+these options, specify @option{-mminimal-toc} instead. This option causes
GCC to make only one TOC entry for every file. When you specify this
option, GCC will produce code that is slower and larger but which
uses extremely little TOC space. You may wish to use this option
@opindex maix32
Enable 64-bit AIX ABI and calling convention: 64-bit pointers, 64-bit
@code{long} type, and the infrastructure needed to support them.
-Specifying @samp{-maix64} implies @samp{-mpowerpc64} and
-@samp{-mpowerpc}, while @samp{-maix32} disables the 64-bit ABI and
-implies @samp{-mno-powerpc64}. GCC defaults to @samp{-maix32}.
+Specifying @option{-maix64} implies @option{-mpowerpc64} and
+@option{-mpowerpc}, while @option{-maix32} disables the 64-bit ABI and
+implies @option{-mno-powerpc64}. GCC defaults to @option{-maix32}.
@item -mxl-call
@itemx -mno-xl-call
application written to use message passing with special startup code to
enable the application to run. The system must have PE installed in the
standard location (@file{/usr/lpp/ppe.poe/}), or the @file{specs} file
-must be overridden with the @samp{-specs=} option to specify the
+must be overridden with the @option{-specs=} option to specify the
appropriate directory location. The Parallel Environment does not
-support threads, so the @samp{-mpe} option and the @samp{-mthreads}
+support threads, so the @option{-mpe} option and the @option{-mthreads}
option are incompatible.
@item -msoft-float
@opindex mhard-float
Generate code that does not use (uses) the floating-point register set.
Software floating point emulation is provided if you use the
-@samp{-msoft-float} option, and pass the option to GCC when linking.
+@option{-msoft-float} option, and pass the option to GCC when linking.
@item -mmultiple
@itemx -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 @samp{-mmultiple} on little
+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.
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
-@samp{-mstring} on little endian PowerPC systems, since those
+@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.
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
-@samp{-mno-update}, there is a small window between the time that the
+@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.
For example, by default a structure containing nothing but 8
@code{unsigned} bitfields of length 1 would be aligned to a 4 byte
-boundary and have a size of 4 bytes. By using @samp{-mno-bit-align},
+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.
@opindex mno-relocatable
On embedded PowerPC systems generate code that allows (does not allow)
the program to be relocated to a different address at runtime. If you
-use @samp{-mrelocatable} on any module, all objects linked together must
-be compiled with @samp{-mrelocatable} or @samp{-mrelocatable-lib}.
+use @option{-mrelocatable} on any module, all objects linked together must
+be compiled with @option{-mrelocatable} or @option{-mrelocatable-lib}.
@item -mrelocatable-lib
@itemx -mno-relocatable-lib
@opindex mno-relocatable-lib
On embedded PowerPC systems generate code that allows (does not allow)
the program to be relocated to a different address at runtime. Modules
-compiled with @samp{-mrelocatable-lib} can be linked with either modules
-compiled without @samp{-mrelocatable} and @samp{-mrelocatable-lib} or
-with modules compiled with the @samp{-mrelocatable} options.
+compiled with @option{-mrelocatable-lib} can be linked with either modules
+compiled without @option{-mrelocatable} and @option{-mrelocatable-lib} or
+with modules compiled with the @option{-mrelocatable} options.
@item -mno-toc
@itemx -mtoc
@opindex mlittle
@opindex mlittle-endian
On System V.4 and embedded PowerPC systems compile code for the
-processor in little endian mode. The @samp{-mlittle-endian} option is
-the same as @samp{-mlittle}.
+processor in little endian mode. The @option{-mlittle-endian} option is
+the same as @option{-mlittle}.
@item -mbig
@itemx -mbig-endian
@opindex mbig
@opindex mbig-endian
On System V.4 and embedded PowerPC systems compile code for the
-processor in big endian mode. The @samp{-mbig-endian} option is
-the same as @samp{-mbig}.
+processor in big endian mode. The @option{-mbig-endian} option is
+the same as @option{-mbig}.
@item -mcall-sysv
@opindex mcall-sysv
@item -mcall-sysv-eabi
@opindex mcall-sysv-eabi
-Specify both @samp{-mcall-sysv} and @samp{-meabi} options.
+Specify both @option{-mcall-sysv} and @option{-meabi} options.
@item -mcall-sysv-noeabi
@opindex mcall-sysv-noeabi
-Specify both @samp{-mcall-sysv} and @samp{-mno-eabi} options.
+Specify both @option{-mcall-sysv} and @option{-mno-eabi} options.
@item -mcall-aix
@opindex mcall-aix
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
-@samp{-mprototype}, only calls to prototyped variable argument functions
+@option{-mprototype}, only calls to prototyped variable argument functions
will set or clear the bit.
@item -msim
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 @samp{-msdata} option can use both @code{r2} and
+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
-@samp{-msdata} option will only use @code{r13} to point to a single
-small data area. The @samp{-meabi} option is on by default if you
+@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
configured GCC using one of the @samp{powerpc*-*-eabi*} options.
@item -msdata=eabi
non-@code{const} global and static data in the @samp{.sdata} section,
which is pointed to by register @code{r13}. Put small uninitialized
global and static data in the @samp{.sbss} section, which is adjacent to
-the @samp{.sdata} section. The @samp{-msdata=eabi} option is
-incompatible with the @samp{-mrelocatable} option. The
-@samp{-msdata=eabi} option also sets the @samp{-memb} option.
+the @samp{.sdata} section. The @option{-msdata=eabi} option is
+incompatible with the @option{-mrelocatable} option. The
+@option{-msdata=eabi} option also sets the @option{-memb} option.
@item -msdata=sysv
@opindex msdata=sysv
data in the @samp{.sdata} section, which is pointed to by register
@code{r13}. Put small uninitialized global and static data in the
@samp{.sbss} section, which is adjacent to the @samp{.sdata} section.
-The @samp{-msdata=sysv} option is incompatible with the
-@samp{-mrelocatable} option.
+The @option{-msdata=sysv} option is incompatible with the
+@option{-mrelocatable} option.
@item -msdata=default
@itemx -msdata
@opindex msdata=default
@opindex msdata
-On System V.4 and embedded PowerPC systems, if @samp{-meabi} is used,
-compile code the same as @samp{-msdata=eabi}, otherwise compile code the
-same as @samp{-msdata=sysv}.
+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 -msdata-data
@opindex msdata-data
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 @samp{-msdata} options are used.
+other @option{-msdata} options are used.
@item -msdata=none
@itemx -mno-sdata
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
-@samp{-G @var{num}} switch is also passed to the linker.
-All modules should be compiled with the same @samp{-G @var{num}} value.
+@option{-G @var{num}} switch is also passed to the linker.
+All modules should be compiled with the same @option{-G @var{num}} value.
@item -mregnames
@itemx -mno-regnames
@opindex mhc-struct-return
Return structures of more than one word in memory, rather than in a
register. This provides compatibility with the MetaWare HighC (hc)
-compiler. Use the option @samp{-fpcc-struct-return} for compatibility
+compiler. Use the option @option{-fpcc-struct-return} for compatibility
with the Portable C Compiler (pcc).
@item -mnohc-struct-return
@opindex mnohc-struct-return
Return some structures of more than one word in registers, when
convenient. This is the default. For compatibility with the
-IBM-supplied compilers, use the option @samp{-fpcc-struct-return} or the
-option @samp{-mhc-struct-return}.
+IBM-supplied compilers, use the option @option{-fpcc-struct-return} or the
+option @option{-mhc-struct-return}.
@end table
@node MIPS Options
These @samp{-m} options are defined for the MIPS family of computers:
@table @gcctabopt
-@item -mcpu=@var{cpu type}
+@item -mcpu=@var{cpu-type}
@opindex mcpu
-Assume the defaults for the machine type @var{cpu type} when scheduling
-instructions. The choices for @var{cpu type} are @samp{r2000}, @samp{r3000},
+Assume the defaults for the machine type @var{cpu-type} when scheduling
+instructions. The choices for @var{cpu-type} are @samp{r2000}, @samp{r3000},
@samp{r3900}, @samp{r4000}, @samp{r4100}, @samp{r4300}, @samp{r4400},
@samp{r4600}, @samp{r4650}, @samp{r5000}, @samp{r6000}, @samp{r8000},
and @samp{orion}. Additionally, the @samp{r2000}, @samp{r3000},
@samp{r4000}, @samp{r5000}, and @samp{r6000} can be abbreviated as
@samp{r2k} (or @samp{r2K}), @samp{r3k}, etc. While picking a specific
-@var{cpu type} will schedule things appropriately for that particular
+@var{cpu-type} will schedule things appropriately for that particular
chip, the compiler will not generate any code that does not meet level 1
-of the MIPS ISA (instruction set architecture) without a @samp{-mipsX}
-or @samp{-mabi} switch being used.
+of the MIPS ISA (instruction set architecture) without a @option{-mipsX}
+or @option{-mabi} switch being used.
@item -mips1
@opindex mips1
Issue instructions from level 1 of the MIPS ISA. This is the default.
-@samp{r3000} is the default @var{cpu type} at this ISA level.
+@samp{r3000} is the default @var{cpu-type} at this ISA level.
@item -mips2
@opindex mips2
Issue instructions from level 2 of the MIPS ISA (branch likely, square
-root instructions). @samp{r6000} is the default @var{cpu type} at this
+root instructions). @samp{r6000} is the default @var{cpu-type} at this
ISA level.
@item -mips3
@opindex mips3
Issue instructions from level 3 of the MIPS ISA (64-bit instructions).
-@samp{r4000} is the default @var{cpu type} at this ISA level.
+@samp{r4000} is the default @var{cpu-type} at this ISA level.
@item -mips4
@opindex mips4
Issue instructions from level 4 of the MIPS ISA (conditional move,
prefetch, enhanced FPU instructions). @samp{r8000} is the default
-@var{cpu type} at this ISA level.
+@var{cpu-type} at this ISA level.
@item -mfp32
@opindex mfp32
@item -mfp64
@opindex mfp64
Assume that 32 64-bit floating point registers are available. This is
-the default when the @samp{-mips3} option is used.
+the default when the @option{-mips3} option is used.
@item -mgp32
@opindex mgp32
@item -mgp64
@opindex mgp64
Assume that 32 64-bit general purpose registers are available. This is
-the default when the @samp{-mips3} option is used.
+the default when the @option{-mips3} option is used.
@item -mint64
@opindex mint64
-Force int and long types to be 64 bits wide. See @samp{-mlong32} for an
+Force int and long types to be 64 bits wide. See @option{-mlong32} for an
explanation of the default, and the width of pointers.
@item -mlong64
@opindex mlong64
-Force long types to be 64 bits wide. See @samp{-mlong32} for an
+Force long types to be 64 bits wide. See @option{-mlong32} for an
explanation of the default, and the width of pointers.
@item -mlong32
@opindex mlong32
Force long, int, and pointer types to be 32 bits wide.
-If none of @samp{-mlong32}, @samp{-mlong64}, or @samp{-mint64} are set,
+If none of @option{-mlong32}, @option{-mlong64}, or @option{-mint64} are set,
the size of ints, longs, and pointers depends on the ABI and ISA chosen.
-For @samp{-mabi=32}, and @samp{-mabi=n32}, ints and longs are 32 bits
-wide. For @samp{-mabi=64}, ints are 32 bits, and longs are 64 bits wide.
-For @samp{-mabi=eabi} and either @samp{-mips1} or @samp{-mips2}, ints
-and longs are 32 bits wide. For @samp{-mabi=eabi} and higher ISAs, ints
+For @option{-mabi=32}, and @option{-mabi=n32}, ints and longs are 32 bits
+wide. For @option{-mabi=64}, ints are 32 bits, and longs are 64 bits wide.
+For @option{-mabi=eabi} and either @option{-mips1} or @option{-mips2}, ints
+and longs are 32 bits wide. For @option{-mabi=eabi} and higher ISAs, ints
are 32 bits, and longs are 64 bits wide. The width of pointer types is
the smaller of the width of longs or the width of general purpose
registers (which in turn depends on the ISA).
@opindex mabi=64
@opindex mabi=eabi
Generate code for the indicated ABI. The default instruction level is
-@samp{-mips1} for @samp{32}, @samp{-mips3} for @samp{n32}, and
-@samp{-mips4} otherwise. Conversely, with @samp{-mips1} or
-@samp{-mips2}, the default ABI is @samp{32}; otherwise, the default ABI
+@option{-mips1} for @samp{32}, @option{-mips3} for @samp{n32}, and
+@option{-mips4} otherwise. Conversely, with @option{-mips1} or
+@option{-mips2}, the default ABI is @samp{32}; otherwise, the default ABI
is @samp{64}.
@item -mmips-as
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 @samp{-gstabs} or @samp{-gstabs+}
+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 ECOFF.
@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 @samp{--with-gnu-as} is used.
+the default if the configure option @option{--with-gnu-as} is used.
@item -msplit-addresses
@itemx -mno-split-addresses
@itemx -mno-rnames
@opindex mrnames
@opindex mno-rnames
-The @samp{-mrnames} switch says to output code using the MIPS software
+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.
@itemx -mno-gpopt
@opindex mgpopt
@opindex mno-gpopt
-The @samp{-mgpopt} switch says to write all of the data declarations
+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
@itemx -mno-stats
@opindex mstats
@opindex mno-stats
-For each non-inline function processed, the @samp{-mstats} switch
+For each non-inline function processed, the @option{-mstats} switch
causes the compiler to emit one line to the standard error file to
print statistics about the program (number of registers saved, stack
size, etc.).
@itemx -mno-memcpy
@opindex mmemcpy
@opindex mno-memcpy
-The @samp{-mmemcpy} switch makes all block moves call the appropriate
+The @option{-mmemcpy} switch makes all block moves call the appropriate
string function (@samp{memcpy} or @samp{bcopy}) instead of possibly
generating inline code.
@itemx -mno-mips-tfile
@opindex mmips-tfile
@opindex mno-mips-tfile
-The @samp{-mno-mips-tfile} switch causes the compiler not
+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 @samp{-mno-mips-tfile} switch should only
+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.
@itemx -mdouble-float
@opindex msingle-float
@opindex mdouble-float
-The @samp{-msingle-float} switch tells gcc to assume that the floating
+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 @samp{-mdouble-float} switch permits gcc to use
+@samp{r4650} chip. The @option{-mdouble-float} switch permits gcc to use
double precision operations. This is the default.
@item -mmad
@item -m4650
@opindex m4650
-Turns on @samp{-msingle-float}, @samp{-mmad}, and, at least for now,
-@samp{-mcpu=r4650}.
+Turns on @option{-msingle-float}, @option{-mmad}, and, at least for now,
+@option{-mcpu=r4650}.
@item -mips16
@itemx -mno-mips16
@item -mentry
@opindex mentry
Use the entry and exit pseudo ops. This option can only be used with
-@samp{-mips16}.
+@option{-mips16}.
@item -EL
@opindex EL
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
-@samp{-G @var{num}} switch is also passed to the assembler and linker.
-All modules should be compiled with the same @samp{-G @var{num}}
+@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}}
value.
@item -nocpp
These @samp{-m} options are defined for the i386 family of computers:
@table @gcctabopt
-@item -mcpu=@var{cpu type}
+@item -mcpu=@var{cpu-type}
@opindex mcpu
-Assume the defaults for the machine type @var{cpu type} when scheduling
-instructions. The choices for @var{cpu type} are @samp{i386},
+Assume the defaults for the machine type @var{cpu-type} when scheduling
+instructions. The choices for @var{cpu-type} are @samp{i386},
@samp{i486}, @samp{i586}, @samp{i686}, @samp{pentium},
@samp{pentiumpro}, @samp{pentium4}, @samp{k6}, and @samp{athlon}
-While picking a specific @var{cpu type} will schedule things appropriately
+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 @samp{-march=@var{cpu type}} option
+does not run on the i386 without the @option{-march=@var{cpu-type}} 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 -march=@var{cpu type}
+@item -march=@var{cpu-type}
@opindex march
-Generate instructions for the machine type @var{cpu type}. The choices
-for @var{cpu type} are the same as for @samp{-mcpu}. Moreover,
-specifying @samp{-march=@var{cpu type}} implies @samp{-mcpu=@var{cpu type}}.
+Generate instructions for the machine type @var{cpu-type}. The choices
+for @var{cpu-type} are the same as for @option{-mcpu}. Moreover,
+specifying @option{-march=@var{cpu-type}} implies @option{-mcpu=@var{cpu-type}}.
@item -m386
@itemx -m486
On machines where a function returns floating point results in the 80387
register stack, some floating point opcodes may be emitted even if
-@samp{-msoft-float} is used.
+@option{-msoft-float} is used.
@item -mno-fp-ret-in-387
@opindex mno-fp-ret-in-387
is no FPU. The idea is that the operating system should emulate
an FPU.
-The option @samp{-mno-fp-ret-in-387} causes such values to be returned
+The option @option{-mno-fp-ret-in-387} causes such values to be returned
in ordinary CPU registers instead.
@item -mno-fancy-math-387
@code{sqrt} instructions for the 387. Specify this option to avoid
generating those instructions. This option is the default on FreeBSD.
As of revision 2.6.1, these instructions are not generated unless you
-also use the @samp{-funsafe-math-optimizations} switch.
+also use the @option{-funsafe-math-optimizations} switch.
@item -malign-double
@itemx -mno-align-double
preffer @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 @samp{-m128bit-long-double} switch, the
+@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.
@opindex msvr3-shlib
@opindex mno-svr3-shlib
Control whether GCC places uninitialized locals into @code{bss} or
-@code{data}. @samp{-msvr3-shlib} places these locals into @code{bss}.
+@code{data}. @option{-msvr3-shlib} places these locals into @code{bss}.
These options are meaningful only on System V Release 3.
@item -mno-wide-multiply
You can specify that an individual function is called with this calling
sequence with the function attribute @samp{stdcall}. You can also
-override the @samp{-mrtd} option by using the function attribute
+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
@item -mpreferred-stack-boundary=@var{num}
@opindex mpreferred-stack-boundary
Attempt to keep the stack boundary aligned to a 2 raised to @var{num}
-byte boundary. If @samp{-mpreferred-stack-boundary} is not specified,
+byte boundary. If @option{-mpreferred-stack-boundary} is not specified,
the default is 4 (16 bytes or 128 bits).
The stack is required to be aligned on a 4 byte boundary. On Pentium
and PentiumPro, @code{double} and @code{long double} values should be
-aligned to an 8 byte boundary (see @samp{-malign-double}) or suffer
+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.
This extra alignment does consume extra stack space. Code that is sensitive
to stack space usage, such as embedded systems and operating system kernels,
may want to reduce the preferred alignment to
-@samp{-mpreferred-stack-boundary=2}.
+@option{-mpreferred-stack-boundary=2}.
@item -mpush-args
@opindex mpush-args
@opindex mthreads
Support thread-safe exception handling on @samp{Mingw32}. Code that relies
on thread-safe exception handling must compile and link all code with the
-@samp{-mthreads} option. When compiling, @samp{-mthreads} defines
-@samp{-D_MT}; when linking, it links in a special thread helper library
-@samp{-lmingwthrd} which cleans up per thread exception handling data.
+@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
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
-@samp{-fomit-frame-pointer} removes the frame pointer for all functions
+@option{-fomit-frame-pointer} removes the frame pointer for all functions
which might make debugging harder.
@end table
These @samp{-m} options are defined for the HPPA family of computers:
@table @gcctabopt
-@item -march=@var{architecture type}
+@item -march=@var{architecture-type}
@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
+@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
@opindex mgas
Enable the use of assembler directives only GAS understands.
-@item -mschedule=@var{cpu type}
+@item -mschedule=@var{cpu-type}
@opindex mschedule
Schedule code according to the constraints for the machine type
-@var{cpu type}. The choices for @var{cpu type} are @samp{700}
+@var{cpu-type}. The choices for @var{cpu-type} are @samp{700}
@samp{7100}, @samp{7100LC}, @samp{7200}, and @samp{8000}. Refer to
@file{/usr/lib/sched.models} on an HP-UX system to determine the
proper scheduling option for your machine.
cross-compilation. The embedded target @samp{hppa1.1-*-pro}
does provide software floating point support.
-@samp{-msoft-float} changes the calling convention in the output file;
+@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 @samp{-msoft-float} in order for
+library that comes with GCC, with @option{-msoft-float} in order for
this to work.
@end table
@itemx -msoft-float
@opindex mnumerics
@opindex msoft-float
-The @samp{-mnumerics} option indicates that the processor does support
-floating-point instructions. The @samp{-msoft-float} option indicates
+The @option{-mnumerics} option indicates that the processor does support
+floating-point instructions. The @option{-msoft-float} option indicates
that floating-point support should not be assumed.
@item -mleaf-procedures
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
-@samp{-mno-tail-call}.
+@option{-mno-tail-call}.
@item -mcomplex-addr
@itemx -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 @samp{-mcomplex-addr} for all processors except
+The default is currently @option{-mcomplex-addr} for all processors except
the CB and CC.
@item -mcode-align
@item -mold-align
@opindex mold-align
Enable structure-alignment compatibility with Intel's gcc release version
-1.3 (based on gcc 1.37). This option implies @samp{-mstrict-align}.
+1.3 (based on gcc 1.37). This option implies @option{-mstrict-align}.
@item -mlong-double-64
@opindex mlong-double-64
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).
+@emph{except} that the @var{inexact-flag} is not maintained (see below).
If this option is turned on, the CPP macro @code{_IEEE_FP} is defined
-during compilation. The option is a shorthand for: @samp{-D_IEEE_FP
+during compilation. The option is a shorthand for: @option{-D_IEEE_FP
-mfp-trap-mode=su -mtrap-precision=i -mieee-conformant}. 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
@c overfull hbox here --bob 22 jul96
@c original text between ignore ... end ignore
@ignore
-This is like @samp{-mieee} except the generated code also maintains the
-IEEE @var{inexact flag}. Turning on this option causes the generated
+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. The option is a shorthand
-for @samp{-D_IEEE_FP -D_IEEE_FP_INEXACT} plus @samp{-mieee-conformant},
-@samp{-mfp-trap-mode=sui}, and @samp{-mtrap-precision=i}. On some Alpha
+for @option{-D_IEEE_FP -D_IEEE_FP_INEXACT} plus @option{-mieee-conformant},
+@option{-mfp-trap-mode=sui}, and @option{-mtrap-precision=i}. On some Alpha
implementations the resulting code may execute significantly slower than
the code generated by default. Since there is very little code that
-depends on the @var{inexact flag}, you should normally not specify this
+depends on the @var{inexact-flag}, you should normally not specify this
option. Other Alpha compilers call this option
-@samp{-ieee_with_inexact}.
+@option{-ieee_with_inexact}.
@end ignore
@c changed paragraph
-This is like @samp{-mieee} except the generated code also maintains the
-IEEE @var{inexact flag}. Turning on this option causes the generated
+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. The option is a shorthand
-for @samp{-D_IEEE_FP -D_IEEE_FP_INEXACT} plus the three following:
-@samp{-mieee-conformant},
-@samp{-mfp-trap-mode=sui},
-and @samp{-mtrap-precision=i}.
+for @option{-D_IEEE_FP -D_IEEE_FP_INEXACT} plus the three following:
+@option{-mieee-conformant},
+@option{-mfp-trap-mode=sui},
+and @option{-mtrap-precision=i}.
On some Alpha implementations the resulting code may execute
significantly slower than the code generated by default. Since there
-is very little code that depends on the @var{inexact flag}, you should
+is very little code that depends on the @var{inexact-flag}, you should
normally not specify this option. Other Alpha compilers call this
-option @samp{-ieee_with_inexact}.
+option @option{-ieee_with_inexact}.
@c end changes to prevent overfull hboxes
-@item -mfp-trap-mode=@var{trap mode}
+@item -mfp-trap-mode=@var{trap-mode}
@opindex mfp-trap-mode
This option controls what floating-point related traps are enabled.
-Other Alpha compilers call this option @samp{-fptm }@var{trap mode}.
+Other Alpha compilers call this option @option{-fptm @var{trap-mode}}.
The trap mode can be set to one of four values:
@table @samp
Like @samp{su}, but inexact traps are enabled as well.
@end table
-@item -mfp-rounding-mode=@var{rounding mode}
+@item -mfp-rounding-mode=@var{rounding-mode}
@opindex mfp-rounding-mode
Selects the IEEE rounding mode. Other Alpha compilers call this option
-@samp{-fprm }@var{rounding mode}. The @var{rounding mode} can be one
+@option{-fprm @var{rounding-mode}}. The @var{rounding-mode} can be one
of:
@table @samp
@var{fpcr}, @samp{d} corresponds to round towards plus infinity.
@end table
-@item -mtrap-precision=@var{trap precision}
+@item -mtrap-precision=@var{trap-precision}
@opindex mtrap-precision
In the Alpha architecture, floating point traps are imprecise. This
means without software assistance it is impossible to recover from a
@end table
Other Alpha compilers provide the equivalent options called
-@samp{-scope_safe} and @samp{-resumption_safe}.
+@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 @samp{-mtrap-precision=i} and either
-@samp{-mfp-trap-mode=su} or @samp{-mfp-trap-mode=sui}. Its only effect
+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.
@opindex malpha-as
@opindex mgas
Select whether to generate code to be assembled by the vendor-supplied
-assembler (@samp{-malpha-as}) or by the GNU assembler @samp{-mgas}.
+assembler (@option{-malpha-as}) or by the GNU assembler @option{-mgas}.
@item -mbwx
@itemx -mno-bwx
@opindex mno-max
Indicate whether GCC should generate code to use the optional BWX,
CIX, and MAX instruction sets. The default is to use the instruction sets
-supported by the CPU type specified via @samp{-mcpu=} option or that
+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 -mcpu=@var{cpu_type}
@item -mc400
@opindex mc400
Produce code for a C400 Clipper processor i.e. use floating point
-registers f8..f15.
+registers f8---f15.
@end table
@node H8/300 Options
@item -mrelax
@opindex mrelax
Shorten some address references at link time, when possible; uses the
-linker option @samp{-relax}. @xref{H8/300,, @code{ld} and the H8/300,
+linker option @option{-relax}. @xref{H8/300,, @code{ld} and the H8/300,
ld.info, Using ld}, for a fuller description.
@item -mh
On the H8/300H and H8/S, use the same alignment rules as for the H8/300.
The default for the H8/300H and H8/S is to align longs and floats on 4
byte boundaries.
-@samp{-malign-300} causes them to be aligned on 2 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
@item -mrelax
@opindex mrelax
Shorten some address references at link time, when possible; uses the
-linker option @samp{-relax}.
+linker option @option{-relax}.
@item -mbigtable
@opindex mbigtable
@item -G
@opindex G
Create a shared object.
-It is recommended that @samp{-symbolic} or @samp{-shared} be used instead.
+It is recommended that @option{-symbolic} or @option{-shared} be used instead.
@item -Qy
@opindex Qy
@item -YP\,@var{dirs}
@opindex YP
Search the directories @var{dirs}, and no others, for libraries
-specified with @samp{-l}.
+specified with @option{-l}.
@item -Ym\,@var{dir}
@opindex Ym
@opindex mep
Do not optimize (do optimize) basic blocks that use the same index
pointer 4 or more times to copy pointer into the @code{ep} register, and
-use the shorter @code{sld} and @code{sst} instructions. The @samp{-mep}
+use the shorter @code{sld} and @code{sst} instructions. The @option{-mep}
option is on by default if you optimize.
@item -mno-prolog-function
Do not use (do use) external functions to save and restore registers at
the prolog and epilog of a function. The external functions are slower,
but use less code space if more than one function saves the same number
-of registers. The @samp{-mprolog-function} option is on by default if
+of registers. The @option{-mprolog-function} option is on by default if
you optimize.
@item -mspace
@opindex mspace
Try to make the code as small as possible. At present, this just turns
-on the @samp{-mep} and @samp{-mprolog-function} options.
+on the @option{-mep} and @option{-mprolog-function} options.
@item -mtda=@var{n}
@opindex mtda
@opindex mcpu
Compile code for ARC variant @var{cpu}.
Which variants are supported depend on the configuration.
-All variants support @samp{-mcpu=base}, this is the default.
+All variants support @option{-mcpu=base}, this is the default.
-@item -mtext=@var{text section}
-@itemx -mdata=@var{data section}
-@itemx -mrodata=@var{readonly data section}
+@item -mtext=@var{text-section}
+@itemx -mdata=@var{data-section}
+@itemx -mrodata=@var{readonly-data-section}
@opindex mtext
@opindex mdata
@opindex mrodata
-Put functions, data, and readonly data in @var{text section},
-@var{data section}, and @var{readonly data section} respectively
+Put functions, data, and readonly data in @var{text-section},
+@var{data-section}, and @var{readonly-data-section} respectively
by default. This can be overridden with the @code{section} attribute.
@xref{Variable Attributes}.
@item -m32381
@opindex m32381
Generate output containing 32381 instructions for floating point. This
-also implies @samp{-m32081}. The 32381 is only compatible with the 32332
+also implies @option{-m32081}. The 32381 is only compatible with the 32332
and 32532 cpus. This is the default for the pc532-netbsd configuration.
@item -mmulti-add
@opindex mmulti-add
Try and generate multiply-add floating point instructions @code{polyF}
-and @code{dotF}. This option is only available if the @samp{-m32381}
+and @code{dotF}. This option is only available if the @option{-m32381}
option is in effect. Using these instructions requires changes to to
register allocation which generally has a negative impact on
performance. This option should only be enabled when compiling code
@opindex mnosb
The sb register is not available for use or has not been initialized to
zero by the run time system. This is the default for all targets except
-the pc532-netbsd. It is also implied whenever @samp{-mhimem} or
-@samp{-fpic} is set.
+the pc532-netbsd. It is also implied whenever @option{-mhimem} or
+@option{-fpic} is set.
@item -mhimem
@opindex mhimem
@opindex mgnu-as
@opindex mno-gnu-as
Generate (or don't) code for the GNU assembler. This is the default.
-@c Also, this is the default if the configure option @samp{--with-gnu-as}
+@c Also, this is the default if the configure option @option{--with-gnu-as}
@c is used.
@item -mgnu-ld
@opindex mgnu-ld
@opindex mno-gnu-ld
Generate (or don't) code for the GNU linker. This is the default.
-@c Also, this is the default if the configure option @samp{--with-gnu-ld}
+@c Also, this is the default if the configure option @option{--with-gnu-ld}
@c is used.
@item -mno-pic
@item -mauto-pic
@opindex mauto-pic
-Generate code that is self-relocatable. This implies @samp{-mconstant-gp}.
+Generate code that is self-relocatable. This implies @option{-mconstant-gp}.
This is useful when compiling firmware code.
@item -minline-divide-min-latency
Don't (or do) generate assembler code for the DWARF2 line number debugging
info. This may be useful when not using the GNU assembler.
-@item -mfixed-range=@var{register range}
+@item -mfixed-range=@var{register-range}
@opindex mfixed-range
Generate code treating the given register range as fixed registers.
A fixed register is one that the register allocator can not use. This is
@item -mextmemory
@opindex mextmemory
-Same as the @samp{-mextmem} switch.
+Same as the @option{-mextmem} switch.
@item -monchip
@opindex monchip
@itemx -masm-optimize
@opindex mno-asm-optimize
@opindex masm-optimize
-Disable (enable) passing @samp{-O} to the assembler when optimizing.
-The assembler uses the @samp{-O} option to automatically parallelize
+Disable (enable) passing @option{-O} to the assembler when optimizing.
+The assembler uses the @option{-O} option to automatically parallelize
adjacent short instructions where possible.
@item -mbranch-cost=@var{n}
used in code generation.
Most of them have both positive and negative forms; the negative form
-of @samp{-ffoo} would be @samp{-fno-foo}. In the table below, only
+of @option{-ffoo} would be @option{-fno-foo}. In the table below, only
one of the forms is listed---the one which is not the default. You
can figure out the other form by either removing @samp{no-} or adding
it.
@opindex freg-struct-return
Use the convention that @code{struct} and @code{union} values are
returned in registers when possible. This is more efficient for small
-structures than @samp{-fpcc-struct-return}.
+structures than @option{-fpcc-struct-return}.
-If you specify neither @samp{-fpcc-struct-return} nor its contrary
-@samp{-freg-struct-return}, GCC defaults to whichever convention is
+If you specify neither @option{-fpcc-struct-return} nor its contrary
+@option{-freg-struct-return}, GCC defaults to whichever convention is
standard for the target. If there is no standard convention, GCC
-defaults to @samp{-fpcc-struct-return}, except on targets where 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.
who actually need to read the generated assembly code (perhaps while
debugging the compiler itself).
-@samp{-fno-verbose-asm}, the default, causes the
+@option{-fno-verbose-asm}, the default, causes the
extra information to be omitted and is useful when comparing two assembler
files.
loader is not part of GCC; it is part of the operating system). If
the GOT size for the linked executable exceeds a machine-specific
maximum size, you get an error message from the linker indicating that
-@samp{-fpic} does not work; in that case, recompile with @samp{-fPIC}
+@option{-fpic} does not work; in that case, recompile with @option{-fPIC}
instead. (These maximums are 16k on the m88k, 8k on the Sparc, and 32k
on the m68k and RS/6000. The 386 has no such limit.)
If you use functions from a library that have side-effects (such as
@code{read}), you might not be able to recompile the library and
specify this option. In that case, you can enable the
-@samp{-fprefix-function-name} option, which requests GCC to encapsulate
+@option{-fprefix-function-name} option, which requests GCC to encapsulate
your code and make other functions look as if they were compiled with
-@samp{-fcheck-memory-usage}. This is done by calling ``stubs'',
+@option{-fcheck-memory-usage}. This is done by calling ``stubs'',
which are provided by the detector. If you cannot find or build
stubs for every function you call, you might have to specify
-@samp{-fcheck-memory-usage} without @samp{-fprefix-function-name}.
+@option{-fcheck-memory-usage} without @option{-fprefix-function-name}.
If you specify this option, you can not use the @code{asm} or
@code{__asm__} keywords in functions with memory checking enabled. GNU
functions called. Code compiled with this option and code compiled
without the option can't be linked together, unless stubs are used.
-If you compile the following code with @samp{-fprefix-function-name}
+If you compile the following code with @option{-fprefix-function-name}
@example
extern void bar (int);
void
return prefix_bar (a + 5);
@}
@end example
-This option is designed to be used with @samp{-fcheck-memory-usage}.
+This option is designed to be used with @option{-fcheck-memory-usage}.
@item -finstrument-functions
@opindex finstrument-functions
For instance, if the stack starts at address @samp{0x80000000} and grows
downwards you can use the flags
-@samp{-fstack-limit-symbol=__stack_limit}
-@samp{-Wl,--defsym,__stack_limit=0x7ffe0000} which will enforce a stack
+@samp{-fstack-limit-symbol=__stack_limit
+-Wl,--defsym,__stack_limit=0x7ffe0000} which will enforce a stack
limit of 128K.
@cindex aliasing of parameters
Specify the possible relationships among parameters and between
parameters and global data.
-@samp{-fargument-alias} specifies that arguments (parameters) may
+@option{-fargument-alias} specifies that arguments (parameters) may
alias each other and may alias global storage.
-@samp{-fargument-noalias} specifies that arguments do not alias
+@option{-fargument-noalias} specifies that arguments do not alias
each other, but may alias global storage.
-@samp{-fargument-noalias-global} specifies that arguments do not
+@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
@ifclear INTERNALS
Note that you can also specify places to search using options such as
-@samp{-B}, @samp{-I} and @samp{-L} (@pxref{Directory Options}). These
+@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 GCC.
@end ifclear
@ifset INTERNALS
Note that you can also specify places to search using options such as
-@samp{-B}, @samp{-I} and @samp{-L} (@pxref{Directory Options}). These
+@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 GCC.
@xref{Driver}.
@file{@var{prefix}/lib/gcc-lib/} where @var{prefix} is the value
of @code{prefix} when you ran the @file{configure} script.
-Other prefixes specified with @samp{-B} take precedence over this prefix.
+Other prefixes specified with @option{-B} take precedence over this prefix.
This prefix is also used for finding files such as @file{crt0.o} that are
used for linking.
directories whose name normally begins with @samp{/usr/local/lib/gcc-lib}
(more precisely, with the value of @env{GCC_INCLUDE_DIR}), GCC tries
replacing that beginning with the specified prefix to produce an
-alternate directory name. Thus, with @samp{-Bfoo/}, GCC will search
+alternate directory name. Thus, with @option{-Bfoo/}, GCC will search
@file{foo/bar} where it would normally search @file{/usr/local/lib/bar}.
These alternate directories are searched first; the standard directories
come next.
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 @samp{-l} option (but directories specified with
-@samp{-L} come first).
+libraries for the @option{-l} option (but directories specified with
+@option{-L} come first).
@item C_INCLUDE_PATH
@itemx CPLUS_INCLUDE_PATH
variable's value is a colon-separated list of directories, much like
@env{PATH}. When GCC searches for header files, it tries the
directories listed in the variable for the language you are using, after
-the directories specified with @samp{-I} but before the standard header
+the directories specified with @option{-I} but before the standard header
file directories.
@item DEPENDENCIES_OUTPUT
@cindex dependencies for make as output
If this variable is set, its value specifies how to output dependencies
for Make based on the header files processed by the compiler. This
-output looks much like the output from the @samp{-M} option
+output looks much like the output from the @option{-M} option
(@pxref{Preprocessor Options}), but it goes to a separate file, and is
in addition to the usual results of compilation.
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 @samp{-d @var{directory}}
+whose files should be converted with the @option{-d @var{directory}}
option. You can also specify particular files to exclude with the
-@samp{-x @var{file}} option. A file is converted if it is eligible, its
+@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.
Both conversion programs print a warning for any function declaration or
definition that they can't convert. You can suppress these warnings
-with @samp{-q}.
+with @option{-q}.
The output from @code{protoize} or @code{unprotoize} replaces the
original source file. The original file is renamed to a name ending
@item -c @var{compilation-options}
Use @var{compilation-options} as the options when running @code{gcc} to
-produce the @samp{.X} files. The special option @samp{-aux-info} is
+produce the @samp{.X} files. The special option @option{-aux-info} is
always passed in addition, to tell @code{gcc} to write a @samp{.X} file.
Note that the compilation options must be given as a single argument to
to make them a single word in the shell.
There are certain @code{gcc} arguments that you cannot use, because they
-would produce the wrong kind of output. These include @samp{-g},
-@samp{-O}, @samp{-c}, @samp{-S}, and @samp{-o} If you include these in
+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
function definitions, where the arguments are declared between the
argument list and the initial @samp{@{}. By default, @code{unprotoize}
uses five spaces as the indentation. If you want to indent with just
-one space instead, use @samp{-i " "}.
+one space instead, use @option{-i " "}.
@item -k
Keep the @samp{.X} files. Normally, they are deleted after conversion
is finished.
@item -l
-Add explicit local declarations. @code{protoize} with @samp{-l} inserts
+Add explicit local declarations. @code{protoize} with @option{-l} inserts
a prototype declaration for each function in each block which calls the
function without any declaration. This option applies only to
@code{protoize}.
@item -n
Make no real changes. This mode just prints information about the conversions
-that would have been done without @samp{-n}.
+that would have been done without @option{-n}.
@item -N
Make no @samp{.save} files. The original files are simply deleted.
Work quietly. Most warnings are suppressed.
@item -v
-Print the version number, just like @samp{-v} for @code{gcc}.
+Print the version number, just like @option{-v} for @code{gcc}.
@end table
If you need special compiler options to compile one of your program's
source files, then you should generate that file's @samp{.X} file
specially, by running @code{gcc} on that source file with the
-appropriate options and the option @samp{-aux-info}. Then run
+appropriate options and the option @option{-aux-info}. Then run
@code{protoize} on the entire set of files. @code{protoize} will use
the existing @samp{.X} file because it is newer than the source file.
For example:
projects / gcc.git / commitdiff