@cindex grouping options
@cindex options, grouping
The @code{gcc} program accepts options and file names as operands. Many
-options have multiletter names; therefore multiple single-letter options
+options have multi-letter names; therefore multiple single-letter options
may @emph{not} be grouped: @samp{-dr} is very different from @w{@samp{-d
-r}}.
* Invoking G++:: Compiling C++ programs.
* C Dialect Options:: Controlling the variant of C language compiled.
* C++ Dialect Options:: Variations on C++.
+* Language Independent Options:: Controlling how diagnostics should be
+ formatted.
* Warning Options:: How picky should the compiler be?
* Debugging Options:: Symbol tables, measurements, and debugging dumps.
* Optimize Options:: How much optimization?
@item Overall Options
@xref{Overall Options,,Options Controlling the Kind of Output}.
@smallexample
--c -S -E -o @var{file} -pipe -pass-exit-codes -v --help -x @var{language}
+-c -S -E -o @var{file} -pipe -pass-exit-codes -v --target-help --help -x @var{language}
@end smallexample
@item C Language Options
@xref{C Dialect Options,,Options Controlling C Dialect}.
@smallexample
--ansi -fstd -fallow-single-precision -fcond-mismatch -fno-asm
+-ansi -std -fallow-single-precision -fcond-mismatch -fno-asm
-fno-builtin -ffreestanding -fhosted -fsigned-bitfields -fsigned-char
-funsigned-bitfields -funsigned-char -fwritable-strings
--traditional -traditional-cpp -trigraphs
+-traditional -traditional-cpp -trigraphs -fsingle-precision-constant
@end smallexample
@item C++ Language Options
@smallexample
-fno-access-control -fcheck-new -fconserve-space
-fdollars-in-identifiers -fno-elide-constructors -fexternal-templates
--ffor-scope -fno-for-scope -fno-gnu-keywords -fguiding-decls -fhonor-std
+-ffor-scope -fno-for-scope -fno-gnu-keywords -fhonor-std
-fhuge-objects -fno-implicit-templates -finit-priority
-fno-implement-inlines -fname-mangling-version-@var{n}
-fno-default-inline -fno-operator-names -fno-optional-diags -fpermissive
--frepo -fstrict-prototype -fsquangle -ftemplate-depth-@var{n}
+-frepo -fsquangle -ftemplate-depth-@var{n}
-fuse-cxa-atexit -fvtable-thunks -nostdinc++ -Wctor-dtor-privacy
-Wno-deprecated -Weffc++ -Wno-non-template-friend -Wnon-virtual-dtor
-Wold-style-cast -Woverloaded-virtual -Wno-pmf-conversions -Wreorder
-Wsign-promo -Wsynth
@end smallexample
+@item Language Independent Options
+@xref{Language Independent Options,,Options to Control Diagnostic Messages Formatting}.
+@smallexample
+-fmessage-length=@var{n}
+-fdiagnostics-show-location=@r{[}once@r{|}every-line@r{]}
+@end smallexample
+
@item Warning Options
@xref{Warning Options,,Options to Request or Suppress Warnings}.
@smallexample
-fsyntax-only -pedantic -pedantic-errors
-w -W -Wall -Waggregate-return
-Wcast-align -Wcast-qual -Wchar-subscripts -Wcomment
--Wconversion -Werror -Wformat
+-Wconversion -Wdisabled-optimization -Werror -Wformat
-Wid-clash-@var{len} -Wimplicit -Wimplicit-int
-Wimplicit-function-declaration -Wimport
-Werror-implicit-function-declaration -Wfloat-equal -Winline
-Wmain -Wmissing-declarations -Wmissing-noreturn
-Wmultichar -Wno-import -Wpacked -Wpadded
-Wparentheses -Wpointer-arith -Wredundant-decls
--Wreturn-type -Wshadow -Wsign-compare -Wswitch
+-Wreturn-type -Wshadow -Wsign-compare -Wswitch -Wsystem-headers
-Wtrigraphs -Wundef -Wuninitialized -Wunknown-pragmas -Wunreachable-code
--Wunused -Wwrite-strings
+-Wunused -Wunused-function -Wunused-label -Wunused-parameter
+-Wunused-variable -Wunused-value -Wwrite-strings
@end smallexample
@item C-only Warning Options
-falign-functions=@var{n} -falign-labels=@var{n} -falign-loops=@var{n}
-falign-jumps=@var{n} -fbranch-probabilities
-fcaller-saves -fcse-follow-jumps -fcse-skip-blocks
--fdelayed-branch -fdelete-null-pointer-checks -fexpensive-optimizations
+-fdce -fdelayed-branch -fdelete-null-pointer-checks -fexpensive-optimizations
-ffast-math -ffloat-store -fforce-addr -fforce-mem -fno-math-errno
-fdata-sections -ffunction-sections -fgcse
-finline-functions -finline-limit=@var{n} -fkeep-inline-functions
-fmove-all-movables -fno-default-inline -fno-defer-pop
--fno-function-cse -fno-inline -fno-peephole
+-fno-function-cse -fno-inline -fno-peephole -ftrapv
-fomit-frame-pointer -foptimize-register-moves -foptimize-sibling-calls
--fregmove -frerun-cse-after-loop -frerun-loop-opt -freduce-all-givs
--fschedule-insns -fschedule-insns2 -fstrength-reduce
--fstrict-aliasing -fthread-jumps -funroll-all-loops
--funroll-loops
+-fregmove -frename-registers -frerun-cse-after-loop -frerun-loop-opt
+-freduce-all-givs -fschedule-insns -fschedule-insns2 -fssa
+-fstrength-reduce -fstrict-aliasing -fthread-jumps -funroll-all-loops
+-funroll-loops
-O -O0 -O1 -O2 -O3 -Os
@end smallexample
-mfpa -mnobitfield -mrtd -mshort -msoft-float -mpcrel
-malign-int -mstrict-align
+@emph{M68hc1x Options}
+-m6811 -m6812 -m68hc11 -m68hc12
+-mauto-incdec -mshort -msoft-reg-count=@var{count}
+
@emph{VAX Options}
-mg -mgnu -munix
-mtoc -mno-toc -mlittle -mlittle-endian -mbig -mbig-endian
-mcall-aix -mcall-sysv -mprototype -mno-prototype
-msim -mmvme -mads -myellowknife -memb -msdata
--msdata=@var{opt} -G @var{num}
+-msdata=@var{opt} -mvxworks -G @var{num}
@emph{RT Options}
-mcall-lib-mul -mfp-arg-in-fpregs -mfp-arg-in-gregs
-mfix7000 -mno-crt0
@emph{i386 Options}
--mcpu=@var{cpu type}
--march=@var{cpu type}
--mieee-fp -mno-fancy-math-387
+-mcpu=@var{cpu type} -march=@var{cpu type}
+-mintel-syntax -mieee-fp -mno-fancy-math-387
-mno-fp-ret-in-387 -msoft-float -msvr3-shlib
-mno-wide-multiply -mrtd -malign-double
-mreg-alloc=@var{list} -mregparm=@var{num}
-mrelax -mh -ms -mint32 -malign-300
@emph{SH Options}
--m1 -m2 -m3 -m3e -mb -ml -mdalign -mrelax
+-m1 -m2 -m3 -m3e
+-m4-nofpu -m4-single-only -m4-single -m4
+-mb -ml -mdalign -mrelax
+-mbigtable -mfmovd -mhitachi -mnomacsave
+-misize -mpadstruct -mspace
+-mprefergot
+-musermode
@emph{System V Options}
-Qy -Qn -YP,@var{paths} -Ym,@var{dir}
or preprocessed source.
* C Dialect Options:: Controlling the variant of C language compiled.
* C++ Dialect Options:: Variations on C++.
+* Language Independent Options:: Controlling how diagnostics should be
+ formatted.
* Warning Options:: How picky should the compiler be?
* Debugging Options:: Symbol tables, measurements, and debugging dumps.
* Optimize Options:: How much optimization?
they accept. If the @code{-W} option is also specified then command
line options which have no documentation associated with them will also
be displayed.
+
+@item --target-help
+Print (on the standard output) a description of target specific command
+line options for each tool.
@end table
@node Invoking G++
or otherwise without a suffix that flags them as C++ programs.
@code{g++} is a program that calls GCC with the default language
set to C++, and automatically specifies linking against the C++
-library. On many systems, the script @code{g++} is also
+library. On many systems, @code{g++} is also
installed with the name @code{c++}.
@cindex invoking @code{g++}
The functions @code{alloca}, @code{abort}, @code{exit}, and
@code{_exit} are not builtin functions when @samp{-ansi} is used.
-@item -fstd=
+@item -std=
Determine the language standard. A value for this option must be provided;
possible values are
@item iso9899:199409
ISO C as modified in amend. 1
-@item iso9899:199x
-ISO C 9x
+@item iso9899:1999
+ISO C99. Note that this standard is not yet fully supported; see
+@uref{http://gcc.gnu.org/c99status.html} for more information.
@item c89
same as -std=iso9899:1990
-@item c9x
-same as -std=iso9899:199x
+@item c99
+same as -std=iso9899:1999
@item gnu89
default, iso9899:1990 + gnu extensions
+@item gnu99
+iso9899:1999 + gnu extensions
+
+@item iso9899:199x
+same as -std=iso9899:1999, deprecated
+
+@item c9x
+same as -std=iso9899:1999, deprecated
+
@item gnu9x
-iso9899:199x + gnu extensions
+same as -std=gnu99, deprecated
+
@end itemize
Even when this option is not specified, you can still use some of the
features of newer standards in so far as they do not conflict with
previous C standards. For example, you may use @code{__restrict__} even
-when -fstd=c9x is not specified.
+when -std=c99 is not specified.
@item -fno-asm
Do not recognize @code{asm}, @code{inline} or @code{typeof} as a
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, as it also disables the
-other, C++-specific, extension keywords such as @code{headof}.
+use the @samp{-fno-gnu-keywords} flag instead, which has the same effect.
@item -fno-builtin
@cindex builtin functions
otherwise be invalid, or have different behavior.
@item -fno-gnu-keywords
-Do not recognize @code{typeof} as a keyword, so that code can use these
-words as identifiers. You can use the keywords @code{__typeof__}
-instead. @samp{-ansi} implies @samp{-fno-gnu-keywords}.
-
-@item -fguiding-decls
-Treat a function declaration with the same type as a potential function
-template instantiation as though it declares that instantiation, not a
-normal function. If a definition is given for the function later in the
-translation unit (or another translation unit if the target supports
-weak symbols), that definition will be used; otherwise the template will
-be instantiated. This behavior reflects the C++ language prior to
-September 1996, when guiding declarations were removed.
-
-This option implies @samp{-fname-mangling-version-0}, and will not work
-with other name mangling versions. Like all options that change the
-ABI, all C++ code, @emph{including libgcc.a} must be built with the same
-setting of this option.
+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}.
@item -fhonor-std
Treat the @code{namespace std} as a namespace, instead of ignoring
Like all options that change the ABI, all C++ code, @emph{including
libgcc} must be built with the same setting of this option.
-@item -fmessage-length=@var{n}
-Try to format error messages so that they fit on lines of about @var{n}
-characters. The default is 72 characters. If @var{n} is zero, then no
-line-wrapping will be done; each error message will appear on a single
-line.
-
@item -fno-implicit-templates
Never emit code for non-inline templates which are instantiated
implicitly (i.e. by use); only emit code for explicit instantiations.
exception handling uses the same information, but it will generate it as
needed.
-@item -fstrict-prototype
-Within an @samp{extern "C"} linkage specification, treat a function
-declaration with no arguments, such as @samp{int foo ();}, as declaring
-the function to take no arguments. Normally, such a declaration means
-that the function @code{foo} can take any combination of arguments, as
-in C. @samp{-pedantic} implies @samp{-fstrict-prototype} unless
-overridden with @samp{-fno-strict-prototype}.
-
-Specifying this option will also suppress implicit declarations of
-functions.
-
-This flag no longer affects declarations with C++ linkage.
-
@item -fsquangle
@itemx -fno-squangle
@samp{-fsquangle} will enable a compressed form of name mangling for
function. Because this non-conforming behavior is no longer the default
behavior for g++, @samp{-Wnon-template-friend} allows the compiler to
check existing code for potential trouble spots, and is on by default.
-This new compiler behavior can also be turned off with the flag
-@samp{-fguiding-decls}, which activates the older, non-specification
-compiler code, or with @samp{-Wno-non-template-friend} which keeps the
-conformant compiler code but disables the helpful warning.
+This new compiler behavior can be turned off with
+@samp{-Wno-non-template-friend} which keeps the conformant compiler code
+but disables the helpful warning.
@item -Wold-style-cast (C++ only)
Warn if an old-style (C-style) cast is used within a C++ program. The
(const A&);}, while cfront will use the user-defined @samp{operator =}.
@end table
+@node Language Independent Options
+@section Options to Control Diagnostic Messages Formatting
+@cindex options to control diagnostics formatting
+@cindex diagnostic messages
+@cindex message formatting
+
+Traditionally, diagnostic messages have been formatted irrespective of
+the output device's aspect (e.g. its width, ...). The options described
+below can be used to control the diagnostic messages formatting
+algorithm, e.g. how many characters per line, how often source location
+information should be reported. Right now, only the C++ front-end can
+honor these options. However it is expected, in the near future, that
+the remaining front-ends would be able to digest them correctly.
+
+@table @code
+@item -fmessage-length=@var{n}
+Try to format error messages so that they fit on lines of about @var{n}
+characters. The default is 72 characters for g++ and 0 for the rest of
+the front-ends supported by GCC. If @var{n} is zero, then no
+line-wrapping will be done; each error message will appear on a single
+line.
+
+@item -fdiagnostics-show-location=once
+Only meaningful in line-wrapping mode. Instructs the diagnostic messages
+reporter to emit @emph{once} source location information; that is, in
+case the message is too long to fit on a single physical line and has to
+be wrapped, the source location won't be emitted (as prefix) again,
+over and over, in subsequent continuation lines. This is the default
+behaviour.
+
+@item -fdiagnostics-show-location=every-line
+Only meaningful in line-wrapping mode. Instructs the diagnostic
+messages reporter to emit the same source location information (as
+prefix) for physical lines that result from the process of breaking a
+a message which is too long to fit on a single line.
+
+@end table
+
@node Warning Options
@section Options to Request or Suppress Warnings
@cindex options to control warnings
Check the code for syntax errors, but don't do anything beyond that.
@item -pedantic
-Issue all the warnings demanded by strict ANSI C and ISO C++;
-reject all programs that use forbidden extensions.
+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.
-Valid ANSI C and ISO C++ programs should compile properly with or without
+Valid ISO C and ISO C++ programs should compile properly with or without
this option (though a rare few will require @samp{-ansi}). However,
without this option, certain GNU extensions and traditional C and C++
features are supported as well. With this option, they are rejected.
these escape routes; application programs should avoid them.
@xref{Alternate Keywords}.
-This option is not intended to be @i{useful}; it exists only to satisfy
-pedants who would otherwise claim that GCC fails to support the ANSI
-standard.
-
-Some users try to use @samp{-pedantic} to check programs for strict ANSI
+Some users try to use @samp{-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-ANSI practices, but not all---only those for which
-ANSI C @emph{requires} a diagnostic.
+ISO C @emph{requires} a diagnostic, and some others for which
+diagnostics have been added.
-A feature to report any failure to conform to ANSI C might be useful in
+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
support such a feature in the near future.
@}
@end smallexample
+@item -Wsequence-point
+Warn about code that may have undefined semantics because of violations
+of sequence point rules in the C standard.
+
+The C standard defines the order in which expressions in a C program are
+evaluated in terms of @dfn{sequence points}, which represent a partial
+ordering between the execution of parts of the program: those executed
+before the sequence point, and those executed after it. These occur
+after the evaluation of a full expression (one which is not part of a
+larger expression), after the evaluation of the first operand of a
+@code{&&}, @code{||}, @code{? :} or @code{,} (comma) operator, before a
+function is called (but after the evaluation of its arguments and the
+expression denoting the called function), and in certain other places.
+Other than as expressed by the sequence point rules, the order of
+evaluation of subexpressions of an expression is not specified. All
+these rules describe only a partial order rather than a total order,
+since, for example, if two functions are called within one expression
+with no sequence point between them, the order in which the functions
+are called is not specified. However, the standards committee have
+ruled that function calls do not overlap.
+
+It is not specified when between sequence points modifications to the
+values of objects take effect. Programs whose behavior depends on this
+have undefined behavior; the C standard specifies that ``Between the
+previous and next sequence point an object shall have its stored value
+modified at most once by the evaluation of an expression. Furthermore,
+the prior value shall be read only to determine the value to be
+stored.''. If a program breaks these rules, the results on any
+particular implementation are entirely unpredictable.
+
+Examples of code with undefined behavior are @code{a = a++;}, @code{a[n]
+= b[n++]} and @code{a[i++] = i;}. Some more complicated cases are not
+diagnosed by this option, and it may give an occasional false positive
+result, but in general it has been found fairly effective at detecting
+this sort of problem in programs.
+
+The present implementation of this option only works for C programs. A
+future implementation may also work for C++ programs.
+
+There is some controversy over the precise meaning of the sequence point
+rules in subtle cases. Alternative formal definitions may be found in
+Clive Feather's ``Annex S''
+@uref{http://wwwold.dkuug.dk/JTC1/SC22/WG14/www/docs/n908.htm} and in
+Michael Norrish's thesis
+@uref{http://www.cl.cam.ac.uk/users/mn200/PhD/thesis-report.ps.gz}.
+
@item -Wreturn-type
-Warn whenever a function is defined with a return-type that defaults
-to @code{int}. Also warn about any @code{return} statement with no
-return-value in a function whose return-type is not @code{void}.
+Warn whenever a function is defined with a return-type that defaults to
+@code{int}. Also warn about any @code{return} statement with no
+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
+exceptions are @samp{main} and functions defined in system headers.
@item -Wswitch
Warn whenever a @code{switch} statement has an index of enumeral type
@item -Wtrigraphs
Warn if any trigraphs are encountered (assuming they are enabled).
-@item -Wunused
-Warn whenever a variable is unused aside from its declaration,
-whenever a function is declared static but never defined, whenever a
-label is declared but not used, and whenever a statement computes a
-result that is explicitly not used.
+@item -Wunused-function
+Warn whenever a static function is declared but not defined or a
+non\-inline static function is unused.
-In order to get a warning about an unused function parameter, you must
-specify both @samp{-W} and @samp{-Wunused}.
+@item -Wunused-label
+Warn whenever a label is declared but not used.
-To suppress this warning for an expression, simply cast it to void. For
-unused variables, parameters and labels, use the @samp{unused} attribute
+To suppress this warning use the @samp{unused} attribute
(@pxref{Variable Attributes}).
+@item -Wunused-parameter
+Warn whenever a function parameter is unused aside from its declaration.
+
+To suppress this warning use the @samp{unused} attribute
+(@pxref{Variable Attributes}).
+
+@item -Wunused-variable
+Warn whenever a local variable or non-constant static variable is unused
+aside from its declaration
+
+To suppress this warning use the @samp{unused} attribute
+(@pxref{Variable Attributes}).
+
+@item -Wunused-value
+Warn whenever a statement computes a result that is explicitly not used.
+
+To suppress this warning cast the expression to @samp{void}.
+
+@item -Wunused
+All all the above @samp{-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}.
+
@item -Wuninitialized
Warn if an automatic variable is used without first being initialized or
if a variable may be clobbered by a @code{setjmp} call.
This has no bug because @code{save_y} is used only if it is set.
@cindex @code{longjmp} warnings
-This option also warns when a nonvolatile automatic variable might be
+This option also warns when a non-volatile automatic variable might be
changed by a call to @code{longjmp}. These warnings as well are possible
only in optimizing compilation.
warnings about constructions that some users consider questionable, and
that are easy to avoid (or modify to prevent the warning), even in
conjunction with macros.
+
+@item -Wsystem-headers
+@cindex warnings from system headers
+@cindex system headers, warnings from
+Print warning messages for constructs found in system header files.
+Warnings from system headers are normally suppressed, on the assumption
+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
+option will @emph{not} warn about unknown pragmas in system
+headers---for that, @samp{-Wunknown-pragmas} must also be used.
@end table
The following @samp{-W@dots{}} options are not implied by @samp{-Wall}.
a declaration. According to the C Standard, this usage is obsolescent.
@item
+The return type of a function has a type qualifier such as @code{const}.
+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.)
+
+@item
If @samp{-Wall} or @samp{-Wunused} is also specified, warn about unused
arguments.
@item
Usage of ANSI string concatenation is detected.
+
+@item
+A function macro appears without arguments.
+
+@item
+The unary plus operator.
+
+@item
+Initialization of automatic aggregates.
+
+@item
+Identifier conflicts with labels. Traditional C lacks a separate
+namespace for labels.
+
+@item
+Initialization of unions. If the initializer is zero, the warning is
+omitted. This is done under the assumption that the zero initializer in
+user code appears conditioned on e.g. @code{__STDC__} to avoid missing
+initializer warnings and relies on default initialization to zero in the
+traditional C case.
+
+@item
+The `U' integer constant suffix, or the `F' or `L' floating point
+constant suffixes. (Traditonal C does support the `L' suffix on integer
+constants.) Note, these suffixes appear in macros defined in the system
+headers of most modern systems, e.g. the _MIN/_MAX macros in limits.h.
+Use of these macros can lead to spurious warnings as they do not
+necessarily reflect whether the code in question is any less portable to
+traditional C given that suitable backup definitions are provided.
@end itemize
@item -Wundef
adding the @code{noreturn} attribute, otherwise subtle code generation
bugs could be introduced.
+@item -Wmissing-format-attribute
+If @samp{-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}).
+
@item -Wpacked
Warn if a structure is given the packed attribute, but the packed
attribute has no effect on the layout or size of the structure.
@samp{-Wlong-long} and @samp{-Wno-long-long} are taken into account
only when @samp{-pedantic} flag is used.
+@item -Wdisabled-optimization
+Warn if a requested optimization pass is disabled. This warning does
+not generally indicate that there is anything wrong with your code; it
+merely indicates that GCC's optimizers were unable to handle the code
+effectively. Often, the problem is that your code is too big or too
+complex; GCC will refuse to optimize programs when the optimization
+itself is likely to take inordinate amounts of time.
+
@item -Werror
Make all warnings into errors.
@end table
Says to make debugging dumps during compilation at times specified by
@var{letters}. This is used for debugging the compiler. The file names
for most of the dumps are made by appending a pass number and a word to
-the source file name (e.g. @file{foo.c.00.rtl} or @file{foo.c.01.jump}).
+the source file name (e.g. @file{foo.c.00.rtl} or @file{foo.c.01.sibling}).
Here are the possible letters for use in @var{letters}, and their meanings:
@table @samp
@item A
Annotate the assembler output with miscellaneous debugging information.
@item b
-Dump after computing branch probabilities, to @file{@var{file}.07.bp}.
+Dump after computing branch probabilities, to @file{@var{file}.11.bp}.
+@item B
+Dump after block reordering, to @file{@var{file}.26.bbro}.
@item c
-Dump after instruction combination, to the file @file{@var{file}.09.combine}.
+Dump after instruction combination, to the file @file{@var{file}.14.combine}.
+@item C
+Dump after the first if conversion, to the file @file{@var{file}.15.ce}.
@item d
-Dump after delayed branch scheduling, to @file{@var{file}.19.dbr}.
+Dump after delayed branch scheduling, to @file{@var{file}.29.dbr}.
@item D
Dump all macro definitions, at the end of preprocessing, in addition to
normal output.
-@item F
-Dump after purging ADDRESSOF, to @file{@var{file}.03.addressof}.
+@item e
+Dump after SSA optimizations, to @file{@var{file}.05.ssa} and
+@file{@var{file}.06.ussa}.
+@item E
+Dump after the second if conversion, to @file{@var{file}.24.ce2}.
@item f
-Dump after flow analysis, to @file{@var{file}.08.flow}.
+Dump after life analysis, to @file{@var{file}.13.life}.
+@item F
+Dump after purging @code{ADDRESSOF} codes, to @file{@var{file}.04.addressof}.
@item g
-Dump after global register allocation, to @file{@var{file}.13.greg}.
+Dump after global register allocation, to @file{@var{file}.19.greg}.
+@item o
+Dump after post-reload CSE and other optimizations, to @file{@var{file}.20.postreload}.
@item G
-Dump after GCSE, to @file{@var{file}.04.gcse}.
+Dump after GCSE, to @file{@var{file}.08.gcse}.
+@item i
+Dump after sibling call optimizations, to @file{@var{file}.01.sibling}.
@item j
-Dump after first jump optimization, to @file{@var{file}.01.jump}.
+Dump after the first jump optimization, to @file{@var{file}.02.jump}.
@item J
-Dump after last jump optimization, to @file{@var{file}.17.jump2}.
+Dump after the last jump optimization, to @file{@var{file}.27.jump2}.
@item k
-Dump after conversion from registers to stack, to @file{@var{file}.20.stack}.
+Dump after conversion from registers to stack, to @file{@var{file}.29.stack}.
@item l
-Dump after local register allocation, to @file{@var{file}.12.lreg}.
+Dump after local register allocation, to @file{@var{file}.18.lreg}.
@item L
-Dump after loop optimization, to @file{@var{file}.05.loop}.
+Dump after loop optimization, to @file{@var{file}.09.loop}.
@item M
Dump after performing the machine dependent reorganisation pass, to
-@file{@var{file}.18.mach}.
+@file{@var{file}.28.mach}.
+@item n
+Dump after register renumbering, to @file{@var{file}.23.rnreg}.
@item N
-Dump after the register move pass, to @file{@var{file}.10.regmove}.
+Dump after the register move pass, to @file{@var{file}.16.regmove}.
@item r
Dump after RTL generation, to @file{@var{file}.00.rtl}.
@item R
Dump after the second instruction scheduling pass, to
-@file{@var{file}.16.sched2}.
+@file{@var{file}.25.sched2}.
@item s
Dump after CSE (including the jump optimization that sometimes follows
-CSE), to @file{@var{file}.02.cse}.
+CSE), to @file{@var{file}.03.cse}.
@item S
Dump after the first instruction scheduling pass, to
-@file{@var{file}.11.sched}.
+@file{@var{file}.17.sched}.
@item t
Dump after the second CSE pass (including the jump optimization that
-sometimes follows CSE), to @file{@var{file}.06.cse2}.
+sometimes follows CSE), to @file{@var{file}.10.cse2}.
+@item w
+Dump after the second flow pass, to @file{@var{file}.21.flow2}.
+@item X
+Dump after dead code elimination, to @file{@var{file}.06.dce}.
+@item z
+Dump after the peephole pass, to @file{@var{file}.22.peephole2}.
@item a
Produce all the dumps listed above.
@item m
Annotate the assembler output with a comment indicating which
pattern and alternative was used. The length of each instruction is
also printed.
+@item P
+Dump the RTL in the assembler output as a comment before each instruction.
+Also turns on @samp{-dp} annotation.
@item v
For each of the other indicated dump files (except for
@file{@var{file}.00.rtl}), dump a representation of the control flow graph
-suitible for viewing with VCG to @file{@var{file}.@var{pass}.vcg}.
-@item w
-Dump after the second flow pass to @file{@var{file}.14.flow2}.
+suitable for viewing with VCG to @file{@var{file}.@var{pass}.vcg}.
@item x
Just generate RTL for a function instead of compiling it. Usually used
with @samp{r}.
@item y
Dump debugging information during parsing, to standard error.
-@item z
-Dump after the peephole2 pass to @file{@var{file}.15.peephole2}.
@end table
@item -fdump-unnumbered
When doing debugging dumps (see -d option above), suppress instruction
numbers and line number note output. This makes it more feasible to
-use diff on debugging dumps for compiler invokations with different
+use diff on debugging dumps for compiler invocations with different
options, in particular with and without -g.
@item -fdump-translation-unit-@var{file} (C++ only)
As compared to @samp{-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
-and function inlining. It also turns on the @samp{-fforce-mem} option
-on all machines and frame pointer elimination on machines where doing so
-does not interfere with debugging.
+@samp{-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
+on machines where doing so does not interfere with debugging.
@item -O3
Optimize yet more. @samp{-O3} turns on all optimizations specified by
-@samp{-O2} and also turns on the @samp{inline-functions} option.
+@samp{-O2} and also turns on the @samp{-finline-functions} and
+@samp{-frename-registers} options.
@item -O0
Do not optimize.
in many functions. @strong{It also makes debugging impossible on
some machines.}
-@item -foptimize-sibling-calls
-Optimize sibling and tail recursive calls.
-
@ifset INTERNALS
On some machines, such as the Vax, this flag has no effect, because
the standard calling sequence automatically handles the frame pointer
Usage, gcc.info, Using and Porting GCC}.@refill
@end ifclear
+@item -foptimize-sibling-calls
+Optimize sibling and tail recursive calls.
+
+@item -ftrapv
+This option generates traps for signed overflow on addition, subtraction,
+multiplication operations.
+
@item -fno-inline
Don't pay attention to the @code{inline} keyword. Normally this option
is used to keep the compiler from expanding any functions inline.
-fno-delete-null-pointer-checks to disable this optimizing for programs
which depend on that behavior.
-
@item -fexpensive-optimizations
Perform a number of minor optimizations that are relatively expensive.
they have helped determine the efficacy of various
approaches to improving loop optimizations.
-Please let us (@code{gcc@@gcc.gnu.org} and @code{fortran@@gnu.org})
+Please let us (@email{gcc@@gcc.gnu.org} and @email{fortran@@gnu.org})
know how use of these options affects
the performance of your production code.
We're very interested in code that runs @emph{slower}
If @var{n} is not specified, use a machine-dependent default.
+@item -fssa
+Perform optimizations in static single assignment form. Each function's
+flow graph is translated into SSA form, optimizations are performed, and
+the flow graph is translated back from SSA form. User's should not
+specify this option, since it is not yet ready for production use.
+
+@item -fdce
+Perform dead-code elimination in SSA form. Requires @samp{-fssa}. Like
+@samp{-fssa}, this is an experimental feature.
+
+@item -fsingle-precision-constant
+Treat floating point constant as single precision constant instead of
+implicitly converting it to double precision constant.
+
+@item -frename-registers
+Attempt to avoid false dependancies in scheduled code by making use
+of registers left over after register allocation. This optimization
+will most benefit processors with lots of registers. It can, however,
+make debugging impossible, since variables will no longer stay in
+a ``home register''.
@end table
@node Preprocessor Options
@item -shared
Produce a shared object which can then be linked with other objects to
-form an executable. Not all systems support this option. You must
-also specify @samp{-fpic} or @samp{-fPIC} on some systems when
-you specify this option.
+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)
+when you specify this option.@footnote{On some systems, @code{gcc -shared}
+needs to build supplementary stub code for constructors to work. On
+multi-libbed systems, @code{gcc -shared} must select the correct support
+libraries to link against. Failing to supply the correct flags may lead
+to subtle defects. Supplying them in cases where they are not necessary
+is innocuous.}
@item -symbolic
Bind references to global symbols when building a shared object. Warn
argument. Thus %@{^o*@} would only generate one argument, not two.
@item %@{<@code{S}@}
-Remove all occurences of @code{S} from the command line. Note - this
+Remove all occurrences of @code{-S} from the command line. Note - this
command is position dependent. @samp{%} commands in the spec string
-before this option will see @code{S}, @samp{%} commands in the spec
+before this option will see @code{-S}, @samp{%} commands in the spec
string after this option will not.
@item %@{@code{S}*:@code{X}@}
executables (preprocessor, compiler per se, assembler and linker)
that do the real work. However, since no real work is done in the
driver program, it usually does not matter that the driver program
-in use is not the one for the specified target and version.
+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.
The only way that the driver program depends on the target machine is
in the parsing and handling of special machine-specific options.
However, this is controlled by a file which is found, along with the
other executables, in the directory for the specified version and
target machine. As a result, a single installed driver program adapts
-to any specified target machine and compiler version.
+to any specified target machine, and sufficiently similar compiler
+versions.
The driver program executable does control one significant thing,
however: the default version and target machine. Therefore, you can
@menu
* M680x0 Options::
+* M68hc1x Options::
* VAX Options::
* SPARC Options::
* Convex Options::
* NS32K Options::
* AVR Options::
* MCore Options::
+* D30V Options::
@end menu
@node M680x0 Options
@end table
+@node M68hc1x Options
+@subsection M68hc1x Options
+@cindex M68hc1x options
+
+These are the @samp{-m} options defined for the 68hc11 and 68hc12
+microcontrollers. The default values for these options depends on
+which style of microcontroller was selected when the compiler was configured;
+the defaults for the most common choices are given below.
+
+@table @code
+@item -m6811
+@itemx -m68hc11
+Generate output for a 68HC11. This is the default
+when the compiler is configured for 68HC11-based systems.
+
+@item -m6812
+@itemx -m68hc12
+Generate output for a 68HC12. This is the default
+when the compiler is configured for 68HC12-based systems.
+
+@item -mauto-incdec
+Enable the use of 68HC12 pre and post auto-increment and auto-decrement
+addressing modes.
+
+@item -mshort
+Consider type @code{int} to be 16 bits wide, like @code{short int}.
+
+@item -msoft-reg-count=@var{count}
+Specify the number of pseudo-soft registers which are used for the
+code generation. The maximum number is 32. Using more pseudo-soft
+register may or may not result in better code depending on the program.
+The default is 4 for 68HC11 and 2 for 68HC12.
+
+@end table
+
@node VAX Options
@subsection VAX Options
@cindex VAX options
@itemx -mfp=<number>
@kindex -mfpe=
@kindex -mfp=
-This specifes the version of the floating point emulation available on
+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=} to support older versions of GCC.
the scope of a @samp{#pragma no_long_calls} directive and functions whose
definitions have already been compiled within the current compilation
unit, will not be turned into long calls. The exception to this rule is
-that weak function defintions, functions with the @samp{long-call}
+that weak function definitions, functions with the @samp{long-call}
attribute or the @samp{section} attribute, and functions that are within
the scope of a @samp{#pragma long_calls} directive, will always be
turned into long calls.
uses extremely little TOC space. You may wish to use this option
only on files that contain less frequently executed code. @refill
-@item -m64
-@itemx -m32
-@kindex -m64
-@kindex -m32
-Enable 64-bit PowerPC ABI and calling convention: 64-bit pointers, 64-bit
+@item -maix64
+@itemx -maix32
+@kindex -maix64
+@kindex -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{-m64} implies @samp{-mpowerpc64} and
-@samp{-mpowerpc}, while @samp{-m32} disables the 64-bit ABI and
-implies @samp{-mno-powerpc64}. GCC defaults to @samp{-m32}.
+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}.
@item -mxl-call
@itemx -mno-xl-call
@file{crt0.o} and the standard C libraries are @file{libyk.a} and
@file{libc.a}.
+@item -mvxworks
+On System V.4 and embedded PowerPC systems, specify that you are
+compiling for a VxWorks system.
+
@item -memb
On embedded PowerPC systems, set the @var{PPC_EMB} bit in the ELF flags
header to indicate that @samp{eabi} extended relocations are used.
Force long, int, and pointer types to be 32 bits wide.
If none of @samp{-mlong32}, @samp{-mlong64}, or @samp{-mint64} are set,
-the size of ints, longs, and pointers depends on the ABI and ISA choosen.
+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
@multitable @columnfractions .20 .20 .20 .20
@item @samp{i386} @tab @samp{i486} @tab @samp{i586} @tab @samp{i686}
-@item @samp{pentium} @tab @samp{pentiumpro} @tab @samp{k6}
+@item @samp{pentium} @tab @samp{pentiumpro} @tab @samp{k6} @tab @samp{athlon}
@end multitable
While picking a specific @var{cpu type} will schedule things appropriately
Synonyms for -mcpu=i386, -mcpu=i486, -mcpu=pentium, and -mcpu=pentiumpro
respectively. These synonyms are deprecated.
+@item -mintel-syntax
+Emit assembly using Intel syntax opcodes instead of AT&T syntax.
+
@item -mieee-fp
@itemx -mno-ieee-fp
Control whether or not the compiler uses IEEE floating point
and PentiumPro, @code{double} and @code{long double} values should be
aligned to an 8 byte boundary (see @samp{-malign-double}) or suffer
significant run time performance penalties. On Pentium III, the
-Streaming SIMD Extention (SSE) data type @code{__m128} suffers similar
+Streaming SIMD Extension (SSE) data type @code{__m128} suffers similar
penalties if it is not 16 byte aligned.
To ensure proper alignment of this values on the stack, the stack boundary
@kindex -maccumulate-outgoing-args
If enabled, the maximum amount of space required for outgoing arguments will be
computed in the function prologue. This in faster on most modern CPUs
-because of reduced dependecies, improved scheduling and reduced stack usage
+because of reduced dependencies, improved scheduling and reduced stack usage
when preferred stack boundary is not equal to 2. The drawback is a notable
increase in code size. This switch implies -mno-push-args.
Generate code that assumes calls never cross space boundaries. This
allows GCC to emit code which performs faster indirect calls.
-This option will not work in the presense of shared libraries or nested
+This option will not work in the presence of shared libraries or nested
functions.
@item -mlong-load-store
@item -mmemory-latency=@var{time}
Sets the latency the scheduler should assume for typical memory
references as seen by the application. This number is highly
-dependant on the memory access patterns used by the application
+dependent on the memory access patterns used by the application
and the size of the external cache on the machine.
Valid options for @var{time} are
@item -ms
Generate code for the H8/S.
+@item -ms2600
+Generate code for the H8/S2600. This switch must be used with -ms.
+
@item -mint32
Make @code{int} data 32 bits by default.
@item -malign-300
-On the h8/300h, use the same alignment rules as for the h8/300.
-The default for the h8/300h is to align longs and floats on 4 byte boundaries.
+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.
-This option has no effect on the h8/300.
+This option has no effect on the H8/300.
@end table
@node SH Options
@item -m3e
Generate code for the SH3e.
+@item -m4-nofpu
+Generate code for the SH4 without a floating-point unit.
+
+@item -m4-single-only
+Generate code for the SH4 with a floating-point unit that only
+supports single-precision arithmentic.
+
+@item -m4-single
+Generate code for the SH4 assuming the floating-point unit is in
+single-precision mode by default.
+
+@item -m4
+Generate code for the SH4.
+
@item -mb
Compile code for the processor in big endian mode.
@item -mrelax
Shorten some address references at link time, when possible; uses the
linker option @samp{-relax}.
+
+@item -mbigtable
+Use 32-bit offsets in @code{switch} tables. The default is to use
+16-bit offsets.
+
+@item -mfmovd
+Enable the use of the instruction @code{fmovd}.
+
+@item -mhitachi
+Comply with the calling conventions defined by Hitachi.
+
+@item -mnomacsave
+Mark the @code{MAC} register as call-clobbered, even if
+@code{-mhitachi} is given.
+
+@item -misize
+Dump instruction size and location in the assembly code.
+
+@item -mpadstruct
+This option is deprecated. It pads structures to multiple of 4 bytes,
+which is incompatible with the SH ABI.
+
+@item -mspace
+Optimize for space instead of speed. Implied by @code{-Os}.
+
+@item -mprefergot
+When generating position-independent code, emit function calls using
+the Global Offset Table instead of the Procedure Linkage Table.
+
+@item -musermode
+Generate a library function call to invalidate instruction cache
+entries, after fixing up a trampoline. This library function call
+doesn't assume it can write to the whole memory address space. This
+is the default when the target is @code{sh-*-linux*}.
@end table
@node System V Options
then a RPTS will be emitted even if the loop count cannot be determined
at compile time. Note that the repeated instruction following RPTS does
not have to be reloaded from memory each iteration, thus freeing up the
-CPU buses for oeprands. However, since interrupts are blocked by this
+CPU buses for operands. However, since interrupts are blocked by this
instruction, it is disabled by default.
@item -mloop-unsigned
@item -mrelax-immediate
@itemx -mrelax-immediate
@itemx -mno-relax-immediate
-Allow arbitary sized immediated in bit operations.
+Allow arbitrary sized immediates in bit operations.
@item -mwide-bitfields
@itemx -mwide-bitfields
@item -m4byte-functions
@itemx -m4byte-functions
@itemx -mno-4byte-functions
-Force all functions to be aligfned to a four byte boundary.
+Force all functions to be aligned to a four byte boundary.
@item -mcallgraph-data
@itemx -mcallgraph-data
@item -mlittle-endian
@itemx -mlittle-endian
@itemx -mbig-endian
-Genreate code for a little endian target.
+Generate code for a little endian target.
@item -m210
@itemx -m210
@itemx -m340
Generate code for the 210 processor.
-
@end table
+@node D30V Options
+@subsection D30V Options
+@cindex D30V Options
+
+These @samp{-m} options are defined for D30V implementations:
+
+@table @code
+@item -mextmem
+Link the @samp{.text}, @samp{.data}, @samp{.bss}, @samp{.strings},
+@samp{.rodata}, @samp{.rodata1}, @samp{.data1} sections into external
+memory, which starts at location @code{0x80000000}.
+
+@item -mextmemory
+Same as the @samp{-mextmem} switch.
+
+@item -monchip
+Link the @samp{.text} section into onchip text memory, which starts at
+location @code{0x0}. Also link @samp{.data}, @samp{.bss},
+@samp{.strings}, @samp{.rodata}, @samp{.rodata1}, @samp{.data1} sections
+into onchip data memory, which starts at location @code{0x20000000}.
+
+@item -mno-asm-optimize
+@itemx -masm-optimize
+Disable (enable) passing @samp{-O} to the assembler when optimizing.
+The assembler uses the @samp{-O} option to automatically parallelize
+adjacent short instructions where possible.
+
+@item -mbranch-cost=@var{n}
+Increase the internal costs of branches to @var{n}. Higher costs means
+that the compiler will issue more instructions to avoid doing a branch.
+The default is 2.
+
+@item -mcond-exec=@var{n}
+Specify the maximum number of conditionally executed instructions that
+replace a branch. The default is 4.
+@end table
@node Code Gen Options
@section Options for Code Generation Conventions
OSDN Git Service
