| [Top] | [Contents] | [Index] | [ ? ] |
This manual documents how to use the GNU compilers, as well as their features and incompatibilities, and how to report bugs. It corresponds to the compilers GCC version 4.5-20091105. The internals of the GNU compilers, including how to port them to new targets and some information about how to write front ends for new languages, are documented in a separate manual. See section `Introduction' in GNU Compiler Collection (GCC) Internals.
1. Programming Languages Supported by GCC You can compile C or C++ programs. 2. Language Standards Supported by GCC Language standards supported by GCC. 3. GCC Command Options Command options supported by `gcc'. 4. C Implementation-defined behavior How GCC implements the ISO C specification. 5. Extensions to the C Language Family GNU extensions to the C language family. 6. Extensions to the C++ Language GNU extensions to the C++ language. 7. GNU Objective-C runtime features 8. Binary Compatibility 9. gcov---a Test Coverage Programgcov---a test coverage program.10. Known Causes of Trouble with GCC If you have trouble using GCC. 11. Reporting Bugs How, why and where to report bugs. 12. How To Get Help with GCC How to find suppliers of support for GCC. 13. Contributing to GCC Development How to contribute to testing and developing GCC.
Funding Free Software How to help assure funding for free software. The GNU Project and GNU/Linux
GNU General Public License GNU General Public License says how you can copy and share GCC. GNU Free Documentation License How you can copy and share this manual. Contributors to GCC People who have contributed to GCC.
Option Index Index to command line options. Keyword Index Index of concepts and symbol names.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
GCC stands for "GNU Compiler Collection". GCC is an integrated distribution of compilers for several major programming languages. These languages currently include C, C++, Objective-C, Objective-C++, Java, Fortran, and Ada.
The abbreviation GCC has multiple meanings in common use. The current official meaning is "GNU Compiler Collection", which refers generically to the complete suite of tools. The name historically stood for "GNU C Compiler", and this usage is still common when the emphasis is on compiling C programs. Finally, the name is also used when speaking of the language-independent component of GCC: code shared among the compilers for all supported languages.
The language-independent component of GCC includes the majority of the optimizers, as well as the "back ends" that generate machine code for various processors.
The part of a compiler that is specific to a particular language is called the "front end". In addition to the front ends that are integrated components of GCC, there are several other front ends that are maintained separately. These support languages such as Pascal, Mercury, and COBOL. To use these, they must be built together with GCC proper.
Most of the compilers for languages other than C have their own names. The C++ compiler is G++, the Ada compiler is GNAT, and so on. When we talk about compiling one of those languages, we might refer to that compiler by its own name, or as GCC. Either is correct.
Historically, compilers for many languages, including C++ and Fortran, have been implemented as "preprocessors" which emit another high level language such as C. None of the compilers included in GCC are implemented this way; they all generate machine code directly. This sort of preprocessor should not be confused with the C preprocessor, which is an integral feature of the C, C++, Objective-C and Objective-C++ languages.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
For each language compiled by GCC for which there is a standard, GCC attempts to follow one or more versions of that standard, possibly with some exceptions, and possibly with some extensions.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
GCC supports three versions of the C standard, although support for the most recent version is not yet complete.
The original ANSI C standard (X3.159-1989) was ratified in 1989 and published in 1990. This standard was ratified as an ISO standard (ISO/IEC 9899:1990) later in 1990. There were no technical differences between these publications, although the sections of the ANSI standard were renumbered and became clauses in the ISO standard. This standard, in both its forms, is commonly known as C89, or occasionally as C90, from the dates of ratification. The ANSI standard, but not the ISO standard, also came with a Rationale document. To select this standard in GCC, use one of the options `-ansi', `-std=c89' or `-std=iso9899:1990'; to obtain all the diagnostics required by the standard, you should also specify `-pedantic' (or `-pedantic-errors' if you want them to be errors rather than warnings). See section Options Controlling C Dialect.
Errors in the 1990 ISO C standard were corrected in two Technical Corrigenda published in 1994 and 1996. GCC does not support the uncorrected version.
An amendment to the 1990 standard was published in 1995. This
amendment added digraphs and __STDC_VERSION__ to the language,
but otherwise concerned the library. This amendment is commonly known
as AMD1; the amended standard is sometimes known as C94 or
C95. To select this standard in GCC, use the option
`-std=iso9899:199409' (with, as for other standard versions,
`-pedantic' to receive all required diagnostics).
A new edition of the ISO C standard was published in 1999 as ISO/IEC 9899:1999, and is commonly known as C99. GCC has incomplete support for this standard version; see http://gcc.gnu.org/c99status.html for details. To select this standard, use `-std=c99' or `-std=iso9899:1999'. (While in development, drafts of this standard version were referred to as C9X.)
Errors in the 1999 ISO C standard were corrected in three Technical Corrigenda published in 2001, 2004 and 2007. GCC does not support the uncorrected version.
By default, GCC provides some extensions to the C language that on rare occasions conflict with the C standard. See section Extensions to the C Language Family. Use of the `-std' options listed above will disable these extensions where they conflict with the C standard version selected. You may also select an extended version of the C language explicitly with `-std=gnu89' (for C89 with GNU extensions) or `-std=gnu99' (for C99 with GNU extensions). The default, if no C language dialect options are given, is `-std=gnu89'; this will change to `-std=gnu99' in some future release when the C99 support is complete. Some features that are part of the C99 standard are accepted as extensions in C89 mode.
The ISO C standard defines (in clause 4) two classes of conforming
implementation. A conforming hosted implementation supports the
whole standard including all the library facilities; a conforming
freestanding implementation is only required to provide certain
library facilities: those in <float.h>, <limits.h>,
<stdarg.h>, and <stddef.h>; since AMD1, also those in
<iso646.h>; and in C99, also those in <stdbool.h> and
<stdint.h>. In addition, complex types, added in C99, are not
required for freestanding implementations. The standard also defines
two environments for programs, a freestanding environment,
required of all implementations and which may not have library
facilities beyond those required of freestanding implementations,
where the handling of program startup and termination are
implementation-defined, and a hosted environment, which is not
required, in which all the library facilities are provided and startup
is through a function int main (void) or int main (int,
char *[]). An OS kernel would be a freestanding environment; a
program using the facilities of an operating system would normally be
in a hosted implementation.
GCC aims towards being usable as a conforming freestanding
implementation, or as the compiler for a conforming hosted
implementation. By default, it will act as the compiler for a hosted
implementation, defining __STDC_HOSTED__ as 1 and
presuming that when the names of ISO C functions are used, they have
the semantics defined in the standard. To make it act as a conforming
freestanding implementation for a freestanding environment, use the
option `-ffreestanding'; it will then define
__STDC_HOSTED__ to 0 and not make assumptions about the
meanings of function names from the standard library, with exceptions
noted below. To build an OS kernel, you may well still need to make
your own arrangements for linking and startup.
See section Options Controlling C Dialect.
GCC does not provide the library facilities required only of hosted implementations, nor yet all the facilities required by C99 of freestanding implementations; to use the facilities of a hosted environment, you will need to find them elsewhere (for example, in the GNU C library). See section Standard Libraries.
Most of the compiler support routines used by GCC are present in
`libgcc', but there are a few exceptions. GCC requires the
freestanding environment provide memcpy, memmove,
memset and memcmp.
Finally, if __builtin_trap is used, and the target does
not implement the trap pattern, then GCC will emit a call
to abort.
For references to Technical Corrigenda, Rationale documents and information concerning the history of C that is available online, see http://gcc.gnu.org/readings.html
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
GCC supports the ISO C++ standard (1998) and contains experimental support for the upcoming ISO C++ standard (200x).
The original ISO C++ standard was published as the ISO standard (ISO/IEC
14882:1998) and amended by a Technical Corrigenda published in 2003
(ISO/IEC 14882:2003). These standards are referred to as C++98 and
C++03, respectively. GCC implements the majority of C++98 (export
is a notable exception) and most of the changes in C++03. To select
this standard in GCC, use one of the options `-ansi' or
`-std=c++98'; to obtain all the diagnostics required by the
standard, you should also specify `-pedantic' (or
`-pedantic-errors' if you want them to be errors rather than
warnings).
The ISO C++ committee is working on a new ISO C++ standard, dubbed C++0x, that is intended to be published by 2009. C++0x contains several changes to the C++ language, some of which have been implemented in an experimental C++0x mode in GCC. The C++0x mode in GCC tracks the draft working paper for the C++0x standard; the latest working paper is available on the ISO C++ committee's web site at http://www.open-std.org/jtc1/sc22/wg21/. For information regarding the C++0x features available in the experimental C++0x mode, see http://gcc.gnu.org/gcc-4.3/cxx0x_status.html. To select this standard in GCC, use the option `-std=c++0x'; to obtain all the diagnostics required by the standard, you should also specify `-pedantic' (or `-pedantic-errors' if you want them to be errors rather than warnings).
By default, GCC provides some extensions to the C++ language; See section Options Controlling C++ Dialect. Use of the `-std' option listed above will disable these extensions. You may also select an extended version of the C++ language explicitly with `-std=gnu++98' (for C++98 with GNU extensions) or `-std=gnu++0x' (for C++0x with GNU extensions). The default, if no C++ language dialect options are given, is `-std=gnu++98'.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
There is no formal written standard for Objective-C or Objective-C++. The most authoritative manual is "Object-Oriented Programming and the Objective-C Language", available at a number of web sites:
See section `About This Guide' in GNAT Reference Manual, for information on standard conformance and compatibility of the Ada compiler.
See section `Standards' in The GNU Fortran Compiler, for details of standards supported by GNU Fortran.
See section `Compatibility with the Java Platform' in GNU gcj,
for details of compatibility between gcj and the Java Platform.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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 `-c' option says not to run the linker. Then the output consists of object files output by the assembler.
Other options are passed on to one stage of processing. Some options control the preprocessor and others the compiler itself. Yet other options control the assembler and linker; most of these are not documented here, since you rarely need to use any of them.
Most of the command line options that you can use with GCC are useful for C programs; when an option is only useful with another language (usually C++), the explanation says so explicitly. If the description for a particular option does not mention a source language, you can use that option with all supported languages.
See section Compiling C++ Programs, for a summary of special options for compiling C++ programs.
The gcc program accepts options and file names as operands. Many
options have multi-letter names; therefore multiple single-letter options
may not be grouped: `-dv' is very different from `-d
-v'.
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 `-L' more than once, the directories are searched in the order specified. Also, the placement of the `-l' option is significant.
Many options have long names starting with `-f' or with `-W'---for example, `-fmove-loop-invariants', `-Wformat' and so on. Most of these have both positive and negative forms; the negative form of `-ffoo' would be `-fno-foo'. This manual documents only one of these two forms, whichever one is not the default.
See section Option Index, for an index to GCC's options.
3.1 Option Summary Brief list of all options, without explanations. 3.2 Options Controlling the Kind of Output Controlling the kind of output: an executable, object files, assembler files, or preprocessed source. 3.3 Compiling C++ Programs Compiling C++ programs. 3.4 Options Controlling C Dialect Controlling the variant of C language compiled. 3.5 Options Controlling C++ Dialect Variations on C++. 3.6 Options Controlling Objective-C and Objective-C++ Dialects Variations on Objective-C and Objective-C++. 3.7 Options to Control Diagnostic Messages Formatting Controlling how diagnostics should be formatted. 3.8 Options to Request or Suppress Warnings How picky should the compiler be? 3.9 Options for Debugging Your Program or GCC Symbol tables, measurements, and debugging dumps. 3.10 Options That Control Optimization How much optimization? 3.11 Options Controlling the Preprocessor Controlling header files and macro definitions. Also, getting dependency information for Make. 3.12 Passing Options to the Assembler Passing options to the assembler. 3.13 Options for Linking Specifying libraries and so on. 3.14 Options for Directory Search Where to find header files and libraries. Where to find the compiler executable files. 3.15 Specifying subprocesses and the switches to pass to them How to pass switches to sub-processes. 3.16 Specifying Target Machine and Compiler Version Running a cross-compiler, or an old version of GCC. 3.17 Hardware Models and Configurations Specifying minor hardware or convention variations, such as 68010 vs 68020. 3.18 Options for Code Generation Conventions Specifying conventions for function calls, data layout and register usage. 3.19 Environment Variables Affecting GCC Env vars that affect GCC. 3.20 Using Precompiled Headers Compiling a header once, and using it many times.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Here is a summary of all the options, grouped by type. Explanations are in the following sections.
-c -S -E -o file |
-ansi -std=standard |
-fabi-version=n |
-fconstant-string-class=class-name |
-fmessage-length=n |
{-fsyntax-only -pedantic -pedantic-errors
|
{-Wbad-function-cast -Wmissing-declarations
|
-dletters |
{
|
-Aquestion |
-Wa,option |
object-file-name |
-Bprefix |
-V version |
H8/300 Options
-mrelax -mh -ms -mn -mint32 -malign-300 |
M32C Options
-mcpu=cpu |
RX Options
{-m64bit-doubles -m32bit-doubles -fpu -nofpu
|
SH Options
{-m1 -m2 -m2e
|
-fcall-saved-reg |
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Compilation can involve up to four stages: preprocessing, compilation proper, assembly and linking, always in that order. GCC is capable of preprocessing and compiling several files either into several assembler input files, or into one assembler input file; then each assembler input file produces an object file, and linking combines all the object files (those newly compiled, and those specified as input) into an executable file.
For any given input file, the file name suffix determines what kind of compilation is done:
file.c
file.i
file.ii
file.m
file.mi
file.mm
file.M
file.mii
file.h
file.cc
file.cp
file.cxx
file.cpp
file.CPP
file.c++
file.C
file.mm
file.M
file.mii
file.hh
file.H
file.hp
file.hxx
file.hpp
file.HPP
file.h++
file.tcc
file.f
file.for
file.ftn
file.F
file.FOR
file.fpp
file.FPP
file.FTN
file.f90
file.f95
file.f03
file.f08
file.F90
file.F95
file.F03
file.F08
file.ads
file.adb
file.s
file.S
file.sx
other
You can specify the input language explicitly with the `-x' option:
-x language
c c-header c-cpp-output c++ c++-header c++-cpp-output objective-c objective-c-header objective-c-cpp-output objective-c++ objective-c++-header objective-c++-cpp-output assembler assembler-with-cpp ada f77 f77-cpp-input f95 f95-cpp-input java |
-x none
-pass-exit-codes
gcc program will exit with the code of 1 if any
phase of the compiler returns a non-success return code. If you specify
`-pass-exit-codes', the gcc program will instead return with
numerically highest error produced by any phase that returned an error
indication. The C, C++, and Fortran frontends return 4, if an internal
compiler error is encountered.
If you only want some of the stages of compilation, you can use
`-x' (or filename suffixes) to tell gcc where to start, and
one of the options `-c', `-S', or `-E' to say where
gcc is to stop. Note that some combinations (for example,
`-x cpp-output -E') instruct gcc to do nothing at all.
-c
By default, the object file name for a source file is made by replacing the suffix `.c', `.i', `.s', etc., with `.o'.
Unrecognized input files, not requiring compilation or assembly, are ignored.
-S
By default, the assembler file name for a source file is made by replacing the suffix `.c', `.i', etc., with `.s'.
Input files that don't require compilation are ignored.
-E
Input files which don't require preprocessing are ignored.
-o file
If `-o' is not specified, the default is to put an executable file in `a.out', the object file for `source.suffix' in `source.o', its assembler file in `source.s', a precompiled header file in `source.suffix.gch', and all preprocessed C source on standard output.
-v
-###
-pipe
-combine
--help
gcc. If the `-v' option is also specified
then `--help' will also be passed on to the various processes
invoked by gcc, so that they can display the command line options
they accept. If the `-Wextra' option has also been specified
(prior to the `--help' option), then command line options which
have no documentation associated with them will also be displayed.
--target-help
--help={class|[^]qualifier}[,...]
These are the supported qualifiers:
Thus for example to display all the undocumented target-specific switches supported by the compiler the following can be used:
--help=target,undocumented |
The sense of a qualifier can be inverted by prefixing it with the `^' character, so for example to display all binary warning options (i.e., ones that are either on or off and that do not take an argument), which have a description the following can be used:
--help=warnings,^joined,^undocumented |
The argument to `--help=' should not consist solely of inverted qualifiers.
Combining several classes is possible, although this usually restricts the output by so much that there is nothing to display. One case where it does work however is when one of the classes is target. So for example to display all the target-specific optimization options the following can be used:
--help=target,optimizers |
The `--help=' option can be repeated on the command line. Each successive use will display its requested class of options, skipping those that have already been displayed.
If the `-Q' option appears on the command line before the `--help=' option, then the descriptive text displayed by `--help=' is changed. Instead of describing the displayed options, an indication is given as to whether the option is enabled, disabled or set to a specific value (assuming that the compiler knows this at the point where the `--help=' option is used).
Here is a truncated example from the ARM port of gcc:
% gcc -Q -mabi=2 --help=target -c The following options are target specific: -mabi= 2 -mabort-on-noreturn [disabled] -mapcs [disabled] |
The output is sensitive to the effects of previous command line options, so for example it is possible to find out which optimizations are enabled at `-O2' by using:
-Q -O2 --help=optimizers |
Alternatively you can discover which binary optimizations are enabled by `-O3' by using:
gcc -c -Q -O3 --help=optimizers > /tmp/O3-opts gcc -c -Q -O2 --help=optimizers > /tmp/O2-opts diff /tmp/O2-opts /tmp/O3-opts | grep enabled |
-no-canonical-prefixes
--version
-wrapper
gcc -c t.c -wrapper gdb,--args |
This will invoke all subprograms of gcc under "gdb --args", thus cc1 invocation will be "gdb --args cc1 ...".
-fplugin=name.so
-fplugin-arg-name-key=value
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
C++ source files conventionally use one of the suffixes `.C',
`.cc', `.cpp', `.CPP', `.c++', `.cp', or
`.cxx'; C++ header files often use `.hh', `.hpp',
`.H', or (for shared template code) `.tcc'; and
preprocessed C++ files use the suffix `.ii'. GCC recognizes
files with these names and compiles them as C++ programs even if you
call the compiler the same way as for compiling C programs (usually
with the name gcc).
However, the use of gcc does not add the C++ library.
g++ is a program that calls GCC and treats `.c',
`.h' and `.i' files as C++ source files instead of C source
files unless `-x' is used, and automatically specifies linking
against the C++ library. This program is also useful when
precompiling a C header file with a `.h' extension for use in C++
compilations. On many systems, g++ is also installed with
the name c++.
When you compile C++ programs, you may specify many of the same command-line options that you use for compiling programs in any language; or command-line options meaningful for C and related languages; or options that are meaningful only for C++ programs. See section Options Controlling C Dialect, for explanations of options for languages related to C. See section Options Controlling C++ Dialect, for explanations of options that are meaningful only for C++ programs.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The following options control the dialect of C (or languages derived from C, such as C++, Objective-C and Objective-C++) that the compiler accepts:
-ansi
This turns off certain features of GCC that are incompatible with ISO
C90 (when compiling C code), or of standard C++ (when compiling C++ code),
such as the asm and typeof keywords, and
predefined macros such as unix and vax that identify the
type of system you are using. It also enables the undesirable and
rarely used ISO trigraph feature. For the C compiler,
it disables recognition of C++ style `//' comments as well as
the inline keyword.
The alternate keywords __asm__, __extension__,
__inline__ and __typeof__ continue to work despite
`-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 `-ansi'. Alternate predefined macros
such as __unix__ and __vax__ are also available, with or
without `-ansi'.
The `-ansi' option does not cause non-ISO programs to be rejected gratuitously. For that, `-pedantic' is required in addition to `-ansi'. See section 3.8 Options to Request or Suppress Warnings.
The macro __STRICT_ANSI__ is predefined when the `-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
programs that might use these names for other things.
Functions that would normally be built in but do not have semantics
defined by ISO C (such as alloca and ffs) are not built-in
functions when `-ansi' is used. See section Other built-in functions provided by GCC, for details of the functions
affected.
-std=
The compiler can accept several base standards, such as `c89' or
`c++98', and GNU dialects of those standards, such as
`gnu89' or `gnu++98'. By specifying a base standard, the
compiler will accept all programs following that standard and those
using GNU extensions that do not contradict it. For example,
`-std=c89' turns off certain features of GCC that are
incompatible with ISO C90, such as the asm and typeof
keywords, but not other GNU extensions that do not have a meaning in
ISO C90, such as omitting the middle term of a ?:
expression. On the other hand, by specifying a GNU dialect of a
standard, all features the compiler support are enabled, even when
those features change the meaning of the base standard and some
strict-conforming programs may be rejected. The particular standard
is used by `-pedantic' to identify which features are GNU
extensions given that version of the standard. For example
`-std=gnu89 -pedantic' would warn about C++ style `//'
comments, while `-std=gnu99 -pedantic' would not.
A value for this option must be provided; possible values are
-fgnu89-inline
inline functions when in C99 mode.
See section An Inline Function is As Fast As a Macro. This option
is accepted and ignored by GCC versions 4.1.3 up to but not including
4.3. In GCC versions 4.3 and later it changes the behavior of GCC in
C99 mode. Using this option is roughly equivalent to adding the
gnu_inline function attribute to all inline functions
(see section 5.29 Declaring Attributes of Functions).
The option `-fno-gnu89-inline' explicitly tells GCC to use the
C99 semantics for inline when in C99 or gnu99 mode (i.e., it
specifies the default behavior). This option was first supported in
GCC 4.3. This option is not supported in C89 or gnu89 mode.
The preprocessor macros __GNUC_GNU_INLINE__ and
__GNUC_STDC_INLINE__ may be used to check which semantics are
in effect for inline functions. See section `Common Predefined Macros' in The C Preprocessor.
-aux-info filename
Besides declarations, the file indicates, in comments, the origin of each declaration (source file and line), whether the declaration was implicit, prototyped or unprototyped (`I', `N' for new or `O' for old, respectively, in the first character after the line number and the colon), and whether it came from a declaration or a definition (`C' or `F', respectively, in the following character). In the case of function definitions, a K&R-style list of arguments followed by their declarations is also provided, inside comments, after the declaration.
-fno-asm
asm, inline or typeof as a
keyword, so that code can use these words as identifiers. You can use
the keywords __asm__, __inline__ and __typeof__
instead. `-ansi' implies `-fno-asm'.
In C++, this switch only affects the typeof keyword, since
asm and inline are standard keywords. You may want to
use the `-fno-gnu-keywords' flag instead, which has the same
effect. In C99 mode (`-std=c99' or `-std=gnu99'), this
switch only affects the asm and typeof keywords, since
inline is a standard keyword in ISO C99.
-fno-builtin
-fno-builtin-function
GCC normally generates special code to handle certain built-in functions
more efficiently; for instance, calls to alloca may become single
instructions that adjust the stack directly, and calls to memcpy
may become inline copy loops. The resulting code is often both smaller
and faster, but since the function calls no longer appear as such, you
cannot set a breakpoint on those calls, nor can you change the behavior
of the functions by linking with a different library. In addition,
when a function is recognized as a built-in function, GCC may use
information about that function to warn about problems with calls to
that function, or to generate more efficient code, even if the
resulting code still contains calls to that function. For example,
warnings are given with `-Wformat' for bad calls to
printf, when printf is built in, and strlen is
known not to modify global memory.
With the `-fno-builtin-function' option only the built-in function function is disabled. function must not begin with `__builtin_'. If a function is named that is not built-in in this version of GCC, this option is ignored. There is no corresponding `-fbuiltin-function' option; if you wish to enable built-in functions selectively when using `-fno-builtin' or `-ffreestanding', you may define macros such as:
#define abs(n) __builtin_abs ((n)) #define strcpy(d, s) __builtin_strcpy ((d), (s)) |
-fhosted
Assert that compilation takes place in a hosted environment. This implies
`-fbuiltin'. A hosted environment is one in which the
entire standard library is available, and in which main has a return
type of int. Examples are nearly everything except a kernel.
This is equivalent to `-fno-freestanding'.
-ffreestanding
Assert that compilation takes place in a freestanding environment. This
implies `-fno-builtin'. A freestanding environment
is one in which the standard library may not exist, and program startup may
not necessarily be at main. The most obvious example is an OS kernel.
This is equivalent to `-fno-hosted'.
See section Language Standards Supported by GCC, for details of freestanding and hosted environments.
-fopenmp
#pragma omp in C/C++ and
!$omp in Fortran. When `-fopenmp' is specified, the
compiler generates parallel code according to the OpenMP Application
Program Interface v3.0 http://www.openmp.org/. This option
implies `-pthread', and thus is only supported on targets that
have support for `-pthread'.
-fms-extensions
Some cases of unnamed fields in structures and unions are only accepted with this option. See section Unnamed struct/union fields within structs/unions, for details.
-trigraphs
-no-integrated-cpp
The semantics of this option will change if "cc1", "cc1plus", and "cc1obj" are merged.
-traditional
-traditional-cpp
-fcond-mismatch
-flax-vector-conversions
-funsigned-char
char be unsigned, like unsigned char.
Each kind of machine has a default for what char should
be. It is either like unsigned char by default or like
signed char by default.
Ideally, a portable program should always use signed char or
unsigned char when it depends on the signedness of an object.
But many programs have been written to use plain char and
expect it to be signed, or expect it to be unsigned, depending on the
machines they were written for. This option, and its inverse, let you
make such a program work with the opposite default.
The type char is always a distinct type from each of
signed char or unsigned char, even though its behavior
is always just like one of those two.
-fsigned-char
char be signed, like signed char.
Note that this is equivalent to `-fno-unsigned-char', which is the negative form of `-funsigned-char'. Likewise, the option `-fno-signed-char' is equivalent to `-funsigned-char'.
-fsigned-bitfields
-funsigned-bitfields
-fno-signed-bitfields
-fno-unsigned-bitfields
signed or unsigned. By
default, such a bit-field is signed, because this is consistent: the
basic integer types such as int are signed types.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
This section describes the command-line options that are only meaningful
for C++ programs; but you can also use most of the GNU compiler options
regardless of what language your program is in. For example, you
might compile a file firstClass.C like this:
g++ -g -frepo -O -c firstClass.C |
In this example, only `-frepo' is an option meant only for C++ programs; you can use the other options with any language supported by GCC.
Here is a list of options that are only for compiling C++ programs:
-fabi-version=n
The default is version 2.
-fno-access-control
-fcheck-new
operator new is non-null
before attempting to modify the storage allocated. This check is
normally unnecessary because the C++ standard specifies that
operator new will only return 0 if it is declared
`throw()', in which case the compiler will always check the
return value even without this option. In all other cases, when
operator new has a non-empty exception specification, memory
exhaustion is signalled by throwing std::bad_alloc. See also
`new (nothrow)'.
-fconserve-space
main() has
completed, you may have an object that is being destroyed twice because
two definitions were merged.
This option is no longer useful on most targets, now that support has been added for putting variables into BSS without making them common.
-fno-deduce-init-list
template <class T> auto forward(T t) -> decltype (realfn (t))
{
return realfn (t);
}
void f()
{
forward({1,2}); // call forward<std::initializer_list<int>>
}
|
This option is present because this deduction is an extension to the current specification in the C++0x working draft, and there was some concern about potential overload resolution problems.
-ffriend-injection
This option is for compatibility, and may be removed in a future release of G++.
-fno-elide-constructors
-fno-enforce-eh-specs
-ffor-scope
-fno-for-scope
The default if neither flag is given to follow the standard, but to allow and give a warning for old-style code that would otherwise be invalid, or have different behavior.
-fno-gnu-keywords
typeof as a keyword, so that code can use this
word as an identifier. You can use the keyword __typeof__ instead.
`-ansi' implies `-fno-gnu-keywords'.
-fno-implicit-templates
-fno-implicit-inline-templates
-fno-implement-inlines
-fms-extensions
-fno-nonansi-builtins
ffs, alloca, _exit,
index, bzero, conjf, and other related functions.
-fno-operator-names
and, bitand,
bitor, compl, not, or and xor as
synonyms as keywords.
-fno-optional-diags
-fpermissive
-fno-pretty-templates
void f(T) [with T = int]
rather than void f(int)) so that it's clear which template is
involved. When an error message refers to a specialization of a class
template, the compiler will omit any template arguments which match
the default template arguments for that template. If either of these
behaviors make it harder to understand the error message rather than
easier, using `-fno-pretty-templates' will disable them.
-frepo
-fno-rtti
void * or to
unambiguous base classes.
-fstats
-ftemplate-depth-n
-fno-threadsafe-statics
-fuse-cxa-atexit
__cxa_atexit function rather than the atexit function.
This option is required for fully standards-compliant handling of static
destructors, but will only work if your C library supports
__cxa_atexit.
-fno-use-cxa-get-exception-ptr
__cxa_get_exception_ptr runtime routine. This
will cause std::uncaught_exception to be incorrect, but is necessary
if the runtime routine is not available.
-fvisibility-inlines-hidden
The effect of this is that GCC may, effectively, mark inline methods with
__attribute__ ((visibility ("hidden"))) so that they do not
appear in the export table of a DSO and do not require a PLT indirection
when used within the DSO. Enabling this option can have a dramatic effect
on load and link times of a DSO as it massively reduces the size of the
dynamic export table when the library makes heavy use of templates.
The behavior of this switch is not quite the same as marking the methods as hidden directly, because it does not affect static variables local to the function or cause the compiler to deduce that the function is defined in only one shared object.
You may mark a method as having a visibility explicitly to negate the effect of the switch for that method. For example, if you do want to compare pointers to a particular inline method, you might mark it as having default visibility. Marking the enclosing class with explicit visibility will have no effect.
Explicitly instantiated inline methods are unaffected by this option as their linkage might otherwise cross a shared library boundary. See section 6.5 Where's the Template?.
-fvisibility-ms-compat
The flag makes these changes to GCC's linkage model:
hidden, like
`-fvisibility=hidden'.
In new code it is better to use `-fvisibility=hidden' and export those classes which are intended to be externally visible. Unfortunately it is possible for code to rely, perhaps accidentally, on the Visual Studio behavior.
Among the consequences of these changes are that static data members of the same type with the same name but defined in different shared objects will be different, so changing one will not change the other; and that pointers to function members defined in different shared objects may not compare equal. When this flag is given, it is a violation of the ODR to define types with the same name differently.
-fno-weak
-nostdinc++
In addition, these optimization, warning, and code generation options have meanings only for C++ programs:
-fno-default-inline
-Wabi (C, Objective-C, C++ and Objective-C++ only)
You should rewrite your code to avoid these warnings if you are concerned about the fact that code generated by G++ may not be binary compatible with code generated by other compilers.
The known incompatibilities at this point include:
struct A { virtual void f(); int f1 : 1; };
struct B : public A { int f2 : 1; };
|
In this case, G++ will place B::f2 into the same byte
asA::f1; other compilers will not. You can avoid this problem
by explicitly padding A so that its size is a multiple of the
byte size on your platform; that will cause G++ and other compilers to
layout B identically.
struct A { virtual void f(); char c1; };
struct B { B(); char c2; };
struct C : public A, public virtual B {};
|
In this case, G++ will not place B into the tail-padding for
A; other compilers will. You can avoid this problem by
explicitly padding A so that its size is a multiple of its
alignment (ignoring virtual base classes); that will cause G++ and other
compilers to layout C identically.
union U { int i : 4096; };
|
Assuming that an int does not have 4096 bits, G++ will make the
union too small by the number of bits in an int.
struct A {};
struct B {
A a;
virtual void f ();
};
struct C : public B, public A {};
|
G++ will place the A base class of C at a nonzero offset;
it should be placed at offset zero. G++ mistakenly believes that the
A data member of B is already at offset zero.
typename or
template template parameters can be mangled incorrectly.
template <typename Q>
void f(typename Q::X) {}
template <template <typename> class Q>
void f(typename Q<int>::X) {}
|
Instantiations of these templates may be mangled incorrectly.
It also warns psABI related changes. The known psABI changes at this point include:
union U {
long double ld;
int i;
};
|
union U will always be passed in memory.
-Wctor-dtor-privacy (C++ and Objective-C++ only)
-Wnon-virtual-dtor (C++ and Objective-C++ only)
-Wreorder (C++ and Objective-C++ only)
struct A {
int i;
int j;
A(): j (0), i (1) { }
};
|
The compiler will rearrange the member initializers for `i' and `j' to match the declaration order of the members, emitting a warning to that effect. This warning is enabled by `-Wall'.
The following `-W...' options are not affected by `-Wall'.
-Weffc++ (C++ and Objective-C++ only)
operator= return a reference to *this.
Also warn about violations of the following style guidelines from Scott Meyers' More Effective C++ book:
&&, ||, or ,.
When selecting this option, be aware that the standard library headers do not obey all of these guidelines; use `grep -v' to filter out those warnings.
-Wstrict-null-sentinel (C++ and Objective-C++ only)
NULL as sentinel. When
compiling only with GCC this is a valid sentinel, as NULL is defined
to __null. Although it is a null pointer constant not a null pointer,
it is guaranteed to be of the same size as a pointer. But this use is
not portable across different compilers.
-Wno-non-template-friend (C++ and Objective-C++ only)
-Wold-style-cast (C++ and Objective-C++ only)
-Woverloaded-virtual (C++ and Objective-C++ only)
struct A {
virtual void f();
};
struct B: public A {
void f(int);
};
|
the A class version of f is hidden in B, and code
like:
B* b; b->f(); |
will fail to compile.
-Wno-pmf-conversions (C++ and Objective-C++ only)
-Wsign-promo (C++ and Objective-C++ only)
struct A {
operator int ();
A& operator = (int);
};
main ()
{
A a,b;
a = b;
}
|
In this example, G++ will synthesize a default `A& operator = (const A&);', while cfront will use the user-defined `operator ='.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
(NOTE: This manual does not describe the Objective-C and Objective-C++ languages themselves. See See section Language Standards Supported by GCC, for references.)
This section describes the command-line options that are only meaningful
for Objective-C and Objective-C++ programs, but you can also use most of
the language-independent GNU compiler options.
For example, you might compile a file some_class.m like this:
gcc -g -fgnu-runtime -O -c some_class.m |
In this example, `-fgnu-runtime' is an option meant only for Objective-C and Objective-C++ programs; you can use the other options with any language supported by GCC.
Note that since Objective-C is an extension of the C language, Objective-C compilations may also use options specific to the C front-end (e.g., `-Wtraditional'). Similarly, Objective-C++ compilations may use C++-specific options (e.g., `-Wabi').
Here is a list of options that are only for compiling Objective-C and Objective-C++ programs:
-fconstant-string-class=class-name
@"...". The default
class name is NXConstantString if the GNU runtime is being used, and
NSConstantString if the NeXT runtime is being used (see below). The
`-fconstant-cfstrings' option, if also present, will override the
`-fconstant-string-class' setting and cause @"..." literals
to be laid out as constant CoreFoundation strings.
-fgnu-runtime
-fnext-runtime
__NEXT_RUNTIME__ is predefined if (and only if) this option is
used.
-fno-nil-receivers
[receiver message:arg]) in this translation unit ensure that the receiver
is not nil. This allows for more efficient entry points in the runtime
to be used. Currently, this option is only available in conjunction with
the NeXT runtime on Mac OS X 10.3 and later.
-fobjc-call-cxx-cdtors
- (id) .cxx_construct instance method that will run
non-trivial default constructors on any such instance variables, in order,
and then return self. Similarly, check if any instance variable
is a C++ object with a non-trivial destructor, and if so, synthesize a
special - (void) .cxx_destruct method that will run
all such default destructors, in reverse order.
The - (id) .cxx_construct and/or - (void) .cxx_destruct methods
thusly generated will only operate on instance variables declared in the
current Objective-C class, and not those inherited from superclasses. It
is the responsibility of the Objective-C runtime to invoke all such methods
in an object's inheritance hierarchy. The - (id) .cxx_construct methods
will be invoked by the runtime immediately after a new object
instance is allocated; the - (void) .cxx_destruct methods will
be invoked immediately before the runtime deallocates an object instance.
As of this writing, only the NeXT runtime on Mac OS X 10.4 and later has
support for invoking the - (id) .cxx_construct and
- (void) .cxx_destruct methods.
-fobjc-direct-dispatch
-fobjc-exceptions
@try {
...
@throw expr;
...
}
@catch (AnObjCClass *exc) {
...
@throw expr;
...
@throw;
...
}
@catch (AnotherClass *exc) {
...
}
@catch (id allOthers) {
...
}
@finally {
...
@throw expr;
...
}
|
The @throw statement may appear anywhere in an Objective-C or
Objective-C++ program; when used inside of a @catch block, the
@throw may appear without an argument (as shown above), in which case
the object caught by the @catch will be rethrown.
Note that only (pointers to) Objective-C objects may be thrown and
caught using this scheme. When an object is thrown, it will be caught
by the nearest @catch clause capable of handling objects of that type,
analogously to how catch blocks work in C++ and Java. A
@catch(id ...) clause (as shown above) may also be provided to catch
any and all Objective-C exceptions not caught by previous @catch
clauses (if any).
The @finally clause, if present, will be executed upon exit from the
immediately preceding @try ... @catch section. This will happen
regardless of whether any exceptions are thrown, caught or rethrown
inside the @try ... @catch section, analogously to the behavior
of the finally clause in Java.
There are several caveats to using the new exception mechanism:
NS_HANDLER-style
idioms provided by the NSException class, the new
exceptions can only be used on Mac OS X 10.3 (Panther) and later
systems, due to additional functionality needed in the (NeXT) Objective-C
runtime.
@throw an exception
from Objective-C and catch it in C++, or vice versa
(i.e., throw ... @catch).
The `-fobjc-exceptions' switch also enables the use of synchronization blocks for thread-safe execution:
@synchronized (ObjCClass *guard) {
...
}
|
Upon entering the @synchronized block, a thread of execution shall
first check whether a lock has been placed on the corresponding guard
object by another thread. If it has, the current thread shall wait until
the other thread relinquishes its lock. Once guard becomes available,
the current thread will place its own lock on it, execute the code contained in
the @synchronized block, and finally relinquish the lock (thereby
making guard available to other threads).
Unlike Java, Objective-C does not allow for entire methods to be marked
@synchronized. Note that throwing exceptions out of
@synchronized blocks is allowed, and will cause the guarding object
to be unlocked properly.
-fobjc-gc
-freplace-objc-classes
ld(1) not to statically link in
the resulting object file, and allow dyld(1) to load it in at
run time instead. This is used in conjunction with the Fix-and-Continue
debugging mode, where the object file in question may be recompiled and
dynamically reloaded in the course of program execution, without the need
to restart the program itself. Currently, Fix-and-Continue functionality
is only available in conjunction with the NeXT runtime on Mac OS X 10.3
and later.
-fzero-link
objc_getClass("...") (when the name of the class is known at
compile time) with static class references that get initialized at load time,
which improves run-time performance. Specifying the `-fzero-link' flag
suppresses this behavior and causes calls to objc_getClass("...")
to be retained. This is useful in Zero-Link debugging mode, since it allows
for individual class implementations to be modified during program execution.
-gen-decls
-Wassign-intercept (Objective-C and Objective-C++ only)
-Wno-protocol (Objective-C and Objective-C++ only)
-Wselector (Objective-C and Objective-C++ only)
@selector(...)
expression, and a corresponding method for that selector has been found
during compilation. Because these checks scan the method table only at
the end of compilation, these warnings are not produced if the final
stage of compilation is not reached, for example because an error is
found during compilation, or because the `-fsyntax-only' option is
being used.
-Wstrict-selector-match (Objective-C and Objective-C++ only)
id or Class. When this flag
is off (which is the default behavior), the compiler will omit such warnings
if any differences found are confined to types which share the same size
and alignment.
-Wundeclared-selector (Objective-C and Objective-C++ only)
@selector(...) expression referring to an
undeclared selector is found. A selector is considered undeclared if no
method with that name has been declared before the
@selector(...) expression, either explicitly in an
@interface or @protocol declaration, or implicitly in
an @implementation section. This option always performs its
checks as soon as a @selector(...) expression is found,
while `-Wselector' only performs its checks in the final stage of
compilation. This also enforces the coding style convention
that methods and selectors must be declared before being used.
-print-objc-runtime-info
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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.
-fmessage-length=n
g++ and 0 for the rest of
the front ends supported by GCC. If n is zero, then no
line-wrapping will be done; each error message will appear on a single
line.
-fdiagnostics-show-location=once
-fdiagnostics-show-location=every-line
-fdiagnostics-show-option
-Wcoverage-mismatch
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Warnings are diagnostic messages that report constructions which are not inherently erroneous but which are risky or suggest there may have been an error.
The following language-independent options do not enable specific warnings but control the kinds of diagnostics produced by GCC.
-fsyntax-only
-w
-Werror
-Werror=
Note that specifying `-Werror='foo automatically implies `-W'foo. However, `-Wno-error='foo does not imply anything.
-Wfatal-errors
You can request many specific warnings with options beginning `-W', for example `-Wimplicit' to request warnings on implicit declarations. Each of these specific warning options also has a negative form beginning `-Wno-' to turn off warnings; for example, `-Wno-implicit'. This manual lists only one of the two forms, whichever is not the default. For further, language-specific options also refer to 3.5 Options Controlling C++ Dialect and 3.6 Options Controlling Objective-C and Objective-C++ Dialects.
-pedantic
Valid ISO C and ISO C++ programs should compile properly with or without this option (though a rare few will require `-ansi' or a `-std' option specifying the required version of ISO C). However, without this option, certain GNU extensions and traditional C and C++ features are supported as well. With this option, they are rejected.
`-pedantic' does not cause warning messages for use of the
alternate keywords whose names begin and end with `__'. Pedantic
warnings are also disabled in the expression that follows
__extension__. However, only system header files should use
these escape routes; application programs should avoid them.
See section 5.43 Alternate Keywords.
Some users try to use `-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 requires a diagnostic, and some others for which diagnostics have been added.
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 `-pedantic'. We don't have plans to support such a feature in the near future.
Where the standard specified with `-std' represents a GNU extended dialect of C, such as `gnu89' or `gnu99', there is a corresponding base standard, the version of ISO C on which the GNU extended dialect is based. Warnings from `-pedantic' are given where they are required by the base standard. (It would not make sense for such warnings to be given only for features not in the specified GNU C dialect, since by definition the GNU dialects of C include all features the compiler supports with the given option, and there would be nothing to warn about.)
-pedantic-errors
-Wall
`-Wall' turns on the following warning flags:
{-Waddress
|
Note that some warning flags are not implied by `-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 in some cases, and there is no simple way to modify the code to suppress the warning. Some of them are enabled by `-Wextra' but many of them must be enabled individually.
-Wextra
{-Wclobbered
|
The option `-Wextra' also prints warning messages for the following cases:
-Wchar-subscripts
char. This is a common cause
of error, as programmers often forget that this type is signed on some
machines.
This warning is enabled by `-Wall'.
-Wcomment
-Wformat
printf and scanf, etc., to make sure that
the arguments supplied have types appropriate to the format string
specified, and that the conversions specified in the format string make
sense. This includes standard functions, and others specified by format
attributes (see section 5.29 Declaring Attributes of Functions), in the printf,
scanf, strftime and strfmon (an X/Open extension,
not in the C standard) families (or other target-specific families).
Which functions are checked without format attributes having been
specified depends on the standard version selected, and such checks of
functions without the attribute specified are disabled by
`-ffreestanding' or `-fno-builtin'.
The formats are checked against the format features supported by GNU
libc version 2.2. These include all ISO C90 and C99 features, as well
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 `-pedantic' is used
with `-Wformat', warnings will be given about format features not
in the selected standard version (but not for strfmon formats,
since those are not in any version of the C standard). See section Options Controlling C Dialect.
Since `-Wformat' also checks for null format arguments for several functions, `-Wformat' also implies `-Wnonnull'.
`-Wformat' is included in `-Wall'. For more control over some aspects of format checking, the options `-Wformat-y2k', `-Wno-format-extra-args', `-Wno-format-zero-length', `-Wformat-nonliteral', `-Wformat-security', and `-Wformat=2' are available, but are not included in `-Wall'.
-Wformat-y2k
strftime
formats which may yield only a two-digit year.
-Wno-format-contains-nul
-Wno-format-extra-args
printf or scanf format function. The C standard specifies
that such arguments are ignored.
Where the unused arguments lie between used arguments that are
specified with `$' operand number specifications, normally
warnings are still given, since the implementation could not know what
type to pass to va_arg to skip the unused arguments. However,
in the case of scanf formats, this option will suppress the
warning if the unused arguments are all pointers, since the Single
Unix Specification says that such unused arguments are allowed.
-Wno-format-zero-length (C and Objective-C only)
-Wformat-nonliteral
va_list.
-Wformat-security
printf and scanf functions where the
format string is not a string literal and there are no format arguments,
as in printf (foo);. This may be a security hole if the format
string came from untrusted input and contains `%n'. (This is
currently a subset of what `-Wformat-nonliteral' warns about, but
in future warnings may be added to `-Wformat-security' that are not
included in `-Wformat-nonliteral'.)
-Wformat=2
-Wnonnull (C and Objective-C only)
nonnull function attribute.
`-Wnonnull' is included in `-Wall' and `-Wformat'. It can be disabled with the `-Wno-nonnull' option.
-Winit-self (C, C++, Objective-C and Objective-C++ only)
For example, GCC will warn about i being uninitialized in the
following snippet only when `-Winit-self' has been specified:
int f()
{
int i = i;
return i;
}
|
-Wimplicit-int (C and Objective-C only)
-Wimplicit-function-declaration (C and Objective-C only)
-Wimplicit
-Wignored-qualifiers (C and C++ only)
const. For ISO C such a type qualifier has no effect,
since the value returned by a function is not an lvalue.
For C++, the warning is only emitted for scalar types or void.
ISO C prohibits qualified void return types on function
definitions, so such return types always receive a warning
even without this option.
This warning is also enabled by `-Wextra'.
-Wmain
-Wmissing-braces
int a[2][2] = { 0, 1, 2, 3 };
int b[2][2] = { { 0, 1 }, { 2, 3 } };
|
This warning is enabled by `-Wall'.
-Wmissing-include-dirs (C, C++, Objective-C and Objective-C++ only)
-Wparentheses
Also warn if a comparison like `x<=y<=z' appears; this is equivalent to `(x<=y ? 1 : 0) <= z', which is a different interpretation from that of ordinary mathematical notation.
Also warn about constructions where there may be confusion to which
if statement an else branch belongs. Here is an example of
such a case:
{
if (a)
if (b)
foo ();
else
bar ();
}
|
In C/C++, every else branch belongs to the innermost possible
if statement, which in this example is if (b). This is
often not what the programmer expected, as illustrated in the above
example by indentation the programmer chose. When there is the
potential for this confusion, GCC will issue a warning when this flag
is specified. To eliminate the warning, add explicit braces around
the innermost if statement so there is no way the else
could belong to the enclosing if. The resulting code would
look like this:
{
if (a)
{
if (b)
foo ();
else
bar ();
}
}
|
This warning is enabled by `-Wall'.
-Wsequence-point
The C and C++ standards defines the order in which expressions in a C/C++
program are evaluated in terms of 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
&&, ||, ? : or , (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 and C++ standards specify 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 a = a++;, a[n]
= b[n++] and 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 standard is worded confusingly, therefore there is some debate over the precise meaning of the sequence point rules in subtle cases. Links to discussions of the problem, including proposed formal definitions, may be found on the GCC readings page, at http://gcc.gnu.org/readings.html.
This warning is enabled by `-Wall' for C and C++.
-Wreturn-type
int. Also warn about any return statement with no
return-value in a function whose return-type is not void
(falling off the end of the function body is considered returning
without a value), and about a return statement with an
expression in a function whose return-type is void.
For C++, a function without return type always produces a diagnostic message, even when `-Wno-return-type' is specified. The only exceptions are `main' and functions defined in system headers.
This warning is enabled by `-Wall'.
-Wswitch
switch statement has an index of enumerated type
and lacks a case for one or more of the named codes of that
enumeration. (The presence of a default label prevents this
warning.) case labels outside the enumeration range also
provoke warnings when this option is used (even if there is a
default label).
This warning is enabled by `-Wall'.
-Wswitch-default
switch statement does not have a default
case.
-Wswitch-enum
switch statement has an index of enumerated type
and lacks a case for one or more of the named codes of that
enumeration. case labels outside the enumeration range also
provoke warnings when this option is used. The only difference
between `-Wswitch' and this option is that this option gives a
warning about an omitted enumeration code even if there is a
default label.
-Wsync-nand (C and C++ only)
__sync_fetch_and_nand and __sync_nand_and_fetch
built-in functions are used. These functions changed semantics in GCC 4.4.
-Wtrigraphs
-Wunused-function
-Wunused-label
To suppress this warning use the `unused' attribute (see section 5.36 Specifying Attributes of Variables).
-Wunused-parameter
To suppress this warning use the `unused' attribute (see section 5.36 Specifying Attributes of Variables).
-Wno-unused-result
warn_unused_result (see section 5.36 Specifying Attributes of Variables) does not use
its return value. The default is `-Wunused-result'.
-Wunused-variable
To suppress this warning use the `unused' attribute (see section 5.36 Specifying Attributes of Variables).
-Wunused-value
This warning is enabled by `-Wall'.
-Wunused
In order to get a warning about an unused function parameter, you must either specify `-Wextra -Wunused' (note that `-Wall' implies `-Wunused'), or separately specify `-Wunused-parameter'.
-Wuninitialized
setjmp call. In C++,
warn if a non-static reference or non-static `const' member
appears in a class without constructors.
If you want to warn about code which uses the uninitialized value of the variable in its own initializer, use the `-Winit-self' option.
These warnings occur for individual uninitialized or clobbered
elements of structure, union or array variables as well as for
variables which are uninitialized or clobbered as a whole. They do
not occur for variables or elements declared volatile. Because
these warnings depend on optimization, the exact variables or elements
for which there are warnings will depend on the precise optimization
options and version of GCC used.
Note that there may be no warning about a variable that is used only to compute a value that itself is never used, because such computations may be deleted by data flow analysis before the warnings are printed.
These warnings are made optional because GCC is not smart enough to see all the reasons why the code might be correct despite appearing to have an error. Here is one example of how this can happen:
{
int x;
switch (y)
{
case 1: x = 1;
break;
case 2: x = 4;
break;
case 3: x = 5;
}
foo (x);
}
|
If the value of y is always 1, 2 or 3, then x is
always initialized, but GCC doesn't know this. Here is
another common case:
{
int save_y;
if (change_y) save_y = y, y = new_y;
...
if (change_y) y = save_y;
}
|
This has no bug because save_y is used only if it is set.
This option also warns when a non-volatile automatic variable might be
changed by a call to longjmp. These warnings as well are possible
only in optimizing compilation.
The compiler sees only the calls to setjmp. It cannot know
where longjmp will be called; in fact, a signal handler could
call it at any point in the code. As a result, you may get a warning
even when there is in fact no problem because longjmp cannot
in fact be called at the place which would cause a problem.
Some spurious warnings can be avoided if you declare all the functions
you use that never return as noreturn. See section 5.29 Declaring Attributes of Functions.
This warning is enabled by `-Wall' or `-Wextra'.
-Wunknown-pragmas
-Wno-pragmas
-Wstrict-aliasing
-Wstrict-aliasing=n
Level 1: Most aggressive, quick, least accurate. Possibly useful when higher levels do not warn but -fstrict-aliasing still breaks the code, as it has very few false negatives. However, it has many false positives. Warns for all pointer conversions between possibly incompatible types, even if never dereferenced. Runs in the frontend only.
Level 2: Aggressive, quick, not too precise. May still have many false positives (not as many as level 1 though), and few false negatives (but possibly more than level 1). Unlike level 1, it only warns when an address is taken. Warns about incomplete types. Runs in the frontend only.
Level 3 (default for `-Wstrict-aliasing'):
Should have very few false positives and few false
negatives. Slightly slower than levels 1 or 2 when optimization is enabled.
Takes care of the common punn+dereference pattern in the frontend:
*(int*)&some_float.
If optimization is enabled, it also runs in the backend, where it deals
with multiple statement cases using flow-sensitive points-to information.
Only warns when the converted pointer is dereferenced.
Does not warn about incomplete types.
-Wstrict-overflow
-Wstrict-overflow=n
An optimization which assumes that signed overflow does not occur is perfectly safe if the values of the variables involved are such that overflow never does, in fact, occur. Therefore this warning can easily give a false positive: a warning about code which is not actually a problem. To help focus on important issues, several warning levels are defined. No warnings are issued for the use of undefined signed overflow when estimating how many iterations a loop will require, in particular when determining whether a loop will be executed at all.
-Wstrict-overflow=1
x + 1 > x; with `-fstrict-overflow', the
compiler will simplify this to 1. This level of
`-Wstrict-overflow' is enabled by `-Wall'; higher levels
are not, and must be explicitly requested.
-Wstrict-overflow=2
abs (x) >= 0. This can only be
simplified when `-fstrict-overflow' is in effect, because
abs (INT_MIN) overflows to INT_MIN, which is less than
zero. `-Wstrict-overflow' (with no level) is the same as
`-Wstrict-overflow=2'.
-Wstrict-overflow=3
x + 1 > 1 will be simplified to x > 0.
-Wstrict-overflow=4
(x * 10) / 5 will be simplified to x * 2.
-Wstrict-overflow=5
x + 2 > y will
be simplified to x + 1 >= y. This is reported only at the
highest warning level because this simplification applies to many
comparisons, so this warning level will give a very large number of
false positives.
-Warray-bounds
-Wno-div-by-zero
-Wsystem-headers
-Wfloat-equal
The idea behind this is that sometimes it is convenient (for the programmer) to consider floating-point values as approximations to infinitely precise real numbers. If you are doing this, then you need to compute (by analyzing the code, or in some other way) the maximum or likely maximum error that the computation introduces, and allow for it when performing comparisons (and when producing output, but that's a different problem). In particular, instead of testing for equality, you would check to see whether the two values have ranges that overlap; and this is done with the relational operators, so equality comparisons are probably mistaken.
-Wtraditional (C and Objective-C only)
<limits.h>.
Use of these macros in user code might normally lead to spurious
warnings, however GCC's integrated preprocessor has enough context to
avoid warning in these cases.
switch statement has an operand of type long.
static function declaration follows a static one.
This construct is not accepted by some traditional C compilers.
__STDC__ to avoid missing
initializer warnings and relies on default initialization to zero in the
traditional C case.
PARAMS and
VPARAMS. This warning is also bypassed for nested functions
because that feature is already a GCC extension and thus not relevant to
traditional C compatibility.
-Wtraditional-conversion (C and Objective-C only)
-Wdeclaration-after-statement (C and Objective-C only)
-Wundef
-Wno-endif-labels
-Wshadow
-Wlarger-than=len
-Wframe-larger-than=len
alloca, variable-length arrays, or related constructs
is not included by the compiler when determining
whether or not to issue a warning.
-Wunsafe-loop-optimizations
-Wno-pedantic-ms-format (MinGW targets only)
printf / scanf format
width specifiers I32, I64, and I used on Windows targets
depending on the MS runtime, when you are using the options `-Wformat'
and `-pedantic' without gnu-extensions.
-Wpointer-arith
void. GNU C assigns these types a size of 1, for
convenience in calculations with void * pointers and pointers
to functions. In C++, warn also when an arithmetic operation involves
NULL. This warning is also enabled by `-pedantic'.
-Wtype-limits
-Wbad-function-cast (C and Objective-C only)
int malloc() is cast to anything *.
-Wc++-compat (C and Objective-C only)
void * to a pointer to non-void type.
-Wc++0x-compat (C++ and Objective-C++ only)
-Wcast-qual
const char * is cast
to an ordinary char *.
Also warn when making a cast which introduces a type qualifier in an
unsafe way. For example, casting char ** to const char **
is unsafe, as in this example:
/* p is char ** value. */ const char **q = (const char **) p; /* Assignment of readonly string to const char * is OK. */ *q = "string"; /* Now char** pointer points to read-only memory. */ **p = 'b'; |
-Wcast-align
char * is cast to
an int * on machines where integers can only be accessed at
two- or four-byte boundaries.
-Wwrite-strings
const
char[length] so that copying the address of one into a
non-const char * pointer will get a warning. These
warnings will help you find at compile time code that can try to write
into a string constant, but only if you have been very careful about
using const in declarations and prototypes. Otherwise, it will
just be a nuisance. This is why we did not make `-Wall' request
these warnings.
When compiling C++, warn about the deprecated conversion from string
literals to char *. This warning is enabled by default for C++
programs.
-Wclobbered
-Wconversion
abs (x) when
x is double; conversions between signed and unsigned,
like unsigned ui = -1; and conversions to smaller types, like
sqrtf (M_PI). Do not warn for explicit casts like abs
((int) x) and ui = (unsigned) -1, or if the value is not
changed by the conversion like in abs (2.0). Warnings about
conversions between signed and unsigned integers can be disabled by
using `-Wno-sign-conversion'.
For C++, also warn for conversions between NULL and non-pointer
types; confusing overload resolution for user-defined conversions; and
conversions that will never use a type conversion operator:
conversions to void, the same type, a base class or a reference
to them. Warnings about conversions between signed and unsigned
integers are disabled by default in C++ unless
`-Wsign-conversion' is explicitly enabled.
-Wempty-body
-Wenum-compare
-Wjump-misses-init (C, Objective-C only)
goto statement or a switch statement jumps
forward across the initialization of a variable, or jumps backward to a
label after the variable has been initialized. This only warns about
variables which are initialized when they are declared. This warning is
only supported for C and Objective C; in C++ this sort of branch is an
error in any case.
`-Wjump-misses-init' is included in `-Wc++-compat'. It can be disabled with the `-Wno-jump-misses-init' option.
-Wsign-compare
-Wsign-conversion
-Waddress
void func(void); if (func), and comparisons against the memory
address of a string literal, such as if (x == "abc"). Such
uses typically indicate a programmer error: the address of a function
always evaluates to true, so their use in a conditional usually
indicate that the programmer forgot the parentheses in a function
call; and comparisons against string literals result in unspecified
behavior and are not portable in C, so they usually indicate that the
programmer intended to use strcmp. This warning is enabled by
`-Wall'.
-Wlogical-op
-Waggregate-return
-Wno-attributes
__attribute__ is used, such as
unrecognized attributes, function attributes applied to variables,
etc. This will not stop errors for incorrect use of supported
attributes.
-Wno-builtin-macro-redefined
__TIMESTAMP__, __TIME__,
__DATE__, __FILE__, and __BASE_FILE__.
-Wstrict-prototypes (C and Objective-C only)
-Wold-style-declaration (C and Objective-C only)
static are not the first things in a declaration. This warning
is also enabled by `-Wextra'.
-Wold-style-definition (C and Objective-C only)
-Wmissing-parameter-type (C and Objective-C only)
void foo(bar) { }
|
This warning is also enabled by `-Wextra'.
-Wmissing-prototypes (C and Objective-C only)
-Wmissing-declarations
-Wmissing-field-initializers
x.h is implicitly zero:
struct s { int f, g, h; };
struct s x = { 3, 4 };
|
This option does not warn about designated initializers, so the following modification would not trigger a warning:
struct s { int f, g, h; };
struct s x = { .f = 3, .g = 4 };
|
This warning is included in `-Wextra'. To get other `-Wextra' warnings without this one, use `-Wextra -Wno-missing-field-initializers'.
-Wmissing-noreturn
noreturn.
Note these are only possible candidates, not absolute ones. Care should
be taken to manually verify functions actually do not ever return before
adding the noreturn attribute, otherwise subtle code generation
bugs could be introduced. You will not get a warning for main in
hosted C environments.
-Wmissing-format-attribute
format
attributes. Note these are only possible candidates, not absolute ones.
GCC will guess that function pointers with format attributes that
are used in assignment, initialization, parameter passing or return
statements should have a corresponding format attribute in the
resulting type. I.e. the left-hand side of the assignment or
initialization, the type of the parameter variable, or the return type
of the containing function respectively should also have a format
attribute to avoid the warning.
GCC will also warn about function definitions which might be
candidates for format attributes. Again, these are only
possible candidates. GCC will guess that format attributes
might be appropriate for any function that calls a function like
vprintf or vscanf, but this might not always be the
case, and some functions for which format attributes are
appropriate may not be detected.
-Wno-multichar
-Wnormalized=<none|id|nfc|nfkc>
There are four levels of warning that GCC supports. The default is `-Wnormalized=nfc', which warns about any identifier which is not in the ISO 10646 "C" normalized form, NFC. NFC is the recommended form for most uses.
Unfortunately, there are some characters which ISO C and ISO C++ allow in identifiers that when turned into NFC aren't allowable as identifiers. That is, there's no way to use these symbols in portable ISO C or C++ and have all your identifiers in NFC. `-Wnormalized=id' suppresses the warning for these characters. It is hoped that future versions of the standards involved will correct this, which is why this option is not the default.
You can switch the warning off for all characters by writing `-Wnormalized=none'. You would only want to do this if you were using some other normalization scheme (like "D"), because otherwise you can easily create bugs that are literally impossible to see.
Some characters in ISO 10646 have distinct meanings but look identical
in some fonts or display methodologies, especially once formatting has
been applied. For instance \u207F, "SUPERSCRIPT LATIN SMALL
LETTER N", will display just like a regular n which has been
placed in a superscript. ISO 10646 defines the NFKC
normalization scheme to convert all these into a standard form as
well, and GCC will warn if your code is not in NFKC if you use
`-Wnormalized=nfkc'. This warning is comparable to warning
about every identifier that contains the letter O because it might be
confused with the digit 0, and so is not the default, but may be
useful as a local coding convention if the programming environment is
unable to be fixed to display these characters distinctly.
-Wno-deprecated
-Wno-deprecated-declarations
deprecated
attribute.
-Wno-overflow
-Woverride-init (C and Objective-C only)
This warning is included in `-Wextra'. To get other `-Wextra' warnings without this one, use `-Wextra -Wno-override-init'.
-Wpacked
f.x in struct bar
will be misaligned even though struct bar does not itself
have the packed attribute:
struct foo {
int x;
char a, b, c, d;
} __attribute__((packed));
struct bar {
char z;
struct foo f;
};
|
-Wpacked-bitfield-compat
packed attribute
on bit-fields of type char. This has been fixed in GCC 4.4 but
the change can lead to differences in the structure layout. GCC
informs you when the offset of such a field has changed in GCC 4.4.
For example there is no longer a 4-bit padding between field a
and b in this structure:
struct foo
{
char a:4;
char b:8;
} __attribute__ ((packed));
|
This warning is enabled by default. Use `-Wno-packed-bitfield-compat' to disable this warning.
-Wpadded
-Wredundant-decls
-Wnested-externs (C and Objective-C only)
extern declaration is encountered within a function.
-Wunreachable-code
This option is intended to warn when the compiler detects that at least a whole line of source code will never be executed, because some condition is never satisfied or because it is after a procedure that never returns.
It is possible for this option to produce a warning even though there are circumstances under which part of the affected line can be executed, so care should be taken when removing apparently-unreachable code.
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 `-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 code is to provide behavior which is selectable at compile-time.
-Winline
The compiler uses a variety of heuristics to determine whether or not to inline a function. For example, the compiler takes into account the size of the function being inlined and the amount of inlining that has already been done in the current function. Therefore, seemingly insignificant changes in the source program can cause the warnings produced by `-Winline' to appear or disappear.
-Wno-invalid-offsetof (C++ and Objective-C++ only)
The restrictions on `offsetof' may be relaxed in a future version of the C++ standard.
-Wno-int-to-pointer-cast (C and Objective-C only)
-Wno-pointer-to-int-cast (C and Objective-C only)
-Winvalid-pch
-Wlong-long
-Wvariadic-macros
-Wvla
-Wvolatile-register-var
-Wdisabled-optimization
-Wpointer-sign (C and Objective-C only)
-Wstack-protector
-Wno-mudflap
-Woverlength-strings
The limit applies after string constant concatenation, and does not count the trailing NUL. In C89, the limit was 509 characters; in C99, it was raised to 4095. C++98 does not specify a normative minimum maximum, so we do not diagnose overlength strings in C++.
This option is implied by `-pedantic', and can be disabled with `-Wno-overlength-strings'.
-Wunsuffixed-float-constants (C and Objective-C only)
GCC will issue a warning for any floating constant that does not have
a suffix. When used together with `-Wsystem-headers' it will
warn about such constants in system header files. This can be useful
when preparing code to use with the FLOAT_CONST_DECIMAL64 pragma
from the decimal floating-point extension to C99.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
GCC has various special options that are used for debugging either your program or GCC:
-g
On most systems that use stabs format, `-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 `-gstabs+', `-gstabs', `-gxcoff+', `-gxcoff', or `-gvms' (see below).
GCC allows you to use `-g' with `-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 results or their values were already at hand; some statements may execute in different places because they were moved out of loops.
Nevertheless it proves possible to debug optimized output. This makes it reasonable to use the optimizer for programs that might have bugs.
The following options are useful when GCC is generated with the capability for more than one debugging format.
-ggdb
-gstabs
-feliminate-unused-debug-symbols
-femit-class-debug-always
-gstabs+
-gcoff
-gxcoff
-gxcoff+
-gdwarf-version
Note that with DWARF version 2 some ports require, and will always use, some non-conflicting DWARF 3 extensions in the unwind tables.
Version 4 may require GDB 7.0 and `-fvar-tracking-assignments' for maximum benefit.
-gstrict-dwarf
-gno-strict-dwarf
-gvms
-glevel
-ggdblevel
-gstabslevel
-gcofflevel
-gxcofflevel
-gvmslevel
Level 0 produces no debug information at all. Thus, `-g0' negates `-g'.
Level 1 produces minimal information, enough for making backtraces in parts of the program that you don't plan to debug. This includes descriptions of functions and external variables, but no information about local variables and no line numbers.
Level 3 includes extra information, such as all the macro definitions present in the program. Some debuggers support macro expansion when you use `-g3'.
`-gdwarf-2' does not accept a concatenated debug level, because GCC used to support an option `-gdwarf' that meant to generate debug information in version 1 of the DWARF format (which is very different from version 2), and it would have been too confusing. That debug format is long obsolete, but the option cannot be changed now. Instead use an additional `-glevel' option to change the debug level for DWARF.
-gtoggle
-fdump-final-insns[=file]
.), the name
of the dump file will be determined by appending .gkd to the
compilation output file name.
-fcompare-debug[=opts]
If the equal sign is omitted, the default `-gtoggle' is used.
The environment variable GCC_COMPARE_DEBUG, if defined, non-empty
and nonzero, implicitly enables `-fcompare-debug'. If
GCC_COMPARE_DEBUG is defined to a string starting with a dash,
then it is used for opts, otherwise the default `-gtoggle'
is used.
`-fcompare-debug=', with the equal sign but without opts,
is equivalent to `-fno-compare-debug', which disables the dumping
of the final representation and the second compilation, preventing even
GCC_COMPARE_DEBUG from taking effect.
To verify full coverage during `-fcompare-debug' testing, set
GCC_COMPARE_DEBUG to say `-fcompare-debug-not-overridden',
which GCC will reject as an invalid option in any actual compilation
(rather than preprocessing, assembly or linking). To get just a
warning, setting GCC_COMPARE_DEBUG to `-w%n-fcompare-debug
not overridden' will do.
-fcompare-debug-second
.gk additional extension during the second compilation, to avoid
overwriting those generated by the first.
When this option is passed to the compiler driver, it causes the first compilation to be skipped, which makes it useful for little other than debugging the compiler proper.
-feliminate-dwarf2-dups
-femit-struct-debug-baseonly
This option substantially reduces the size of debugging information, but at significant potential loss in type information to the debugger. See `-femit-struct-debug-reduced' for a less aggressive option. See `-femit-struct-debug-detailed' for more detailed control.
This option works only with DWARF 2.
-femit-struct-debug-reduced
This option significantly reduces the size of debugging information, with some potential loss in type information to the debugger. See `-femit-struct-debug-baseonly' for a more aggressive option. See `-femit-struct-debug-detailed' for more detailed control.
This option works only with DWARF 2.
-femit-struct-debug-detailed[=spec-list]
This option is a detailed version of `-femit-struct-debug-reduced' and `-femit-struct-debug-baseonly', which will serve for most needs.
A specification has the syntax [`dir:'|`ind:'][`ord:'|`gen:'](`any'|`sys'|`base'|`none')
The optional first word limits the specification to structs that are used directly (`dir:') or used indirectly (`ind:'). A struct type is used directly when it is the type of a variable, member. Indirect uses arise through pointers to structs. That is, when use of an incomplete struct would be legal, the use is indirect. An example is `struct one direct; struct two * indirect;'.
The optional second word limits the specification to ordinary structs (`ord:') or generic structs (`gen:'). Generic structs are a bit complicated to explain. For C++, these are non-explicit specializations of template classes, or non-template classes within the above. Other programming languages have generics, but `-femit-struct-debug-detailed' does not yet implement them.
The third word specifies the source files for those structs for which the compiler will emit debug information. The values `none' and `any' have the normal meaning. The value `base' means that the base of name of the file in which the type declaration appears must match the base of the name of the main compilation file. In practice, this means that types declared in `foo.c' and `foo.h' will have debug information, but types declared in other header will not. The value `sys' means those types satisfying `base' or declared in system or compiler headers.
You may need to experiment to determine the best settings for your application.
The default is `-femit-struct-debug-detailed=all'.
This option works only with DWARF 2.
-fenable-icf-debug
-fno-merge-debug-strings
-fdebug-prefix-map=old=new
-fno-dwarf2-cfi-asm
.eh_frame section
instead of using GAS .cfi_* directives.
-p
prof. You must use this option when compiling
the source files you want data about, and you must also use it when
linking.
-pg
gprof. You must use this option when compiling
the source files you want data about, and you must also use it when
linking.
-Q
-ftime-report
-fmem-report
-fpre-ipa-mem-report
-fpost-ipa-mem-report
-fprofile-arcs
--coverage
This option is used to compile and link code instrumented for coverage analysis. The option is a synonym for `-fprofile-arcs' `-ftest-coverage' (when compiling) and `-lgcov' (when linking). See the documentation for those options for more details.
fork calls are detected and correctly handled (double counting
will not happen).
gcov to produce human readable
information from the `.gcno' and `.gcda' files. Refer to the
gcov documentation for further information.
With `-fprofile-arcs', for each function of your program GCC creates a program flow graph, then finds a spanning tree for the graph. Only arcs that are not on the spanning tree have to be instrumented: the compiler adds code to count the number of times that these arcs are executed. When an arc is the only exit or only entrance to a block, the instrumentation code can be added to the block; otherwise, a new basic block must be created to hold the instrumentation code.
-ftest-coverage
gcov code-coverage utility
(see section gcov---a Test Coverage Program) can use to
show program coverage. Each source file's note file is called
`auxname.gcno'. Refer to the `-fprofile-arcs' option
above for a description of auxname and instructions on how to
generate test coverage data. Coverage data will match the source files
more closely, if you do not optimize.
-fdbg-cnt-list
-fdbg-cnt=counter-value-list
-dletters
-fdump-rtl-pass
Debug dumps can be enabled with a `-fdump-rtl' switch or some `-d' option letters. Here are the possible letters for use in pass and letters, and their meanings:
-fdump-rtl-alignments
-fdump-rtl-asmcons
-fdump-rtl-auto_inc_dec
-fdump-rtl-barriers
-fdump-rtl-bbpart
-fdump-rtl-bbro
-fdump-rtl-btl1
-fdump-rtl-btl2
-fdump-rtl-bypass
-fdump-rtl-combine
-fdump-rtl-compgotos
-fdump-rtl-ce1
-fdump-rtl-ce2
-fdump-rtl-ce3
-fdump-rtl-cprop_hardreg
-fdump-rtl-csa
-fdump-rtl-cse1
-fdump-rtl-cse2
-fdump-rtl-dce
-fdump-rtl-dbr
-fdump-rtl-dce1
-fdump-rtl-dce2
-fdump-rtl-eh
-fdump-rtl-eh_ranges
-fdump-rtl-expand
-fdump-rtl-fwprop1
-fdump-rtl-fwprop2
-fdump-rtl-gcse1
-fdump-rtl-gcse2
-fdump-rtl-init-regs
-fdump-rtl-initvals
-fdump-rtl-into_cfglayout
-fdump-rtl-ira
-fdump-rtl-jump
-fdump-rtl-loop2
-fdump-rtl-mach
-fdump-rtl-mode_sw
-fdump-rtl-rnreg
-fdump-rtl-outof_cfglayout
-fdump-rtl-peephole2
-fdump-rtl-postreload
-fdump-rtl-pro_and_epilogue
-fdump-rtl-regmove
-fdump-rtl-sched1
-fdump-rtl-sched2
-fdump-rtl-see
-fdump-rtl-seqabstr
-fdump-rtl-shorten
-fdump-rtl-sibling
-fdump-rtl-split1
-fdump-rtl-split2
-fdump-rtl-split3
-fdump-rtl-split4
-fdump-rtl-split5
-fdump-rtl-sms
-fdump-rtl-stack
-fdump-rtl-subreg1
-fdump-rtl-subreg2
-fdump-rtl-unshare
-fdump-rtl-vartrack
-fdump-rtl-vregs
-fdump-rtl-web
-fdump-rtl-regclass
-fdump-rtl-subregs_of_mode_init
-fdump-rtl-subregs_of_mode_finish
-fdump-rtl-dfinit
-fdump-rtl-dfinish
-fdump-rtl-all
-dA
-dD
-dH
-dm
-dp
-dP
-dv
-dx
-dy
-fdump-noaddr
-fdump-unnumbered
-fdump-unnumbered-links
-fdump-translation-unit (C++ only)
-fdump-translation-unit-options (C++ only)
-fdump-class-hierarchy (C++ only)
-fdump-class-hierarchy-options (C++ only)
-fdump-ipa-switch
-fdump-statistics-option
-fdump-tree-switch
-fdump-tree-switch-options
DECL_ASSEMBLER_NAME has been set for a given decl, use that
in the dump instead of DECL_NAME. Its primary use is ease of
use working backward from mangled names in the assembly file.
DECL_UID) for each variable.
The following tree dumps are possible:
-ftree-vectorizer-verbose=n
-frandom-seed=string
The string should be different for every file you compile.
-fsched-verbose=n
For n greater than zero, `-fsched-verbose' outputs the same information as `-fdump-rtl-sched1' and `-fdump-rtl-sched2'. For n greater than one, it also output basic block probabilities, detailed ready list information and unit/insn info. For n greater than two, it includes RTL at abort point, control-flow and regions info. And for n over four, `-fsched-verbose' also includes dependence info.
-save-temps
-save-temps=cwd
When used in combination with the `-x' command line option, `-save-temps' is sensible enough to avoid over writing an input source file with the same extension as an intermediate file. The corresponding intermediate file may be obtained by renaming the source file before using `-save-temps'.
If you invoke GCC in parallel, compiling several different source files that share a common base name in different subdirectories or the same source file compiled for multiple output destinations, it is likely that the different parallel compilers will interfere with each other, and overwrite the temporary files. For instance:
gcc -save-temps -o outdir1/foo.o indir1/foo.c& gcc -save-temps -o outdir2/foo.o indir2/foo.c& |
may result in `foo.i' and `foo.o' being written to simultaneously by both compilers.
-save-temps=obj
For example:
gcc -save-temps=obj -c foo.c gcc -save-temps=obj -c bar.c -o dir/xbar.o gcc -save-temps=obj foobar.c -o dir2/yfoobar |
would create `foo.i', `foo.s', `dir/xbar.i', `dir/xbar.s', `dir2/yfoobar.i', `dir2/yfoobar.s', and `dir2/yfoobar.o'.
-time[=file]
Without the specification of an output file, the output looks like this:
# cc1 0.12 0.01 # as 0.00 0.01 |
The first number on each line is the "user time", that is time spent executing the program itself. The second number is "system time", time spent executing operating system routines on behalf of the program. Both numbers are in seconds.
With the specification of an output file, the output is appended to the named file, and it looks like this:
0.12 0.01 cc1 options 0.00 0.01 as options |
The "user time" and the "system time" are moved before the program name, and the options passed to the program are displayed, so that one can later tell what file was being compiled, and with which options.
-fvar-tracking
It is enabled by default when compiling with optimization (`-Os', `-O', `-O2', ...), debugging information (`-g') and the debug info format supports it.
-fvar-tracking-assignments
It can be enabled even if var-tracking is disabled, in which case annotations will be created and maintained, but discarded at the end.
-fvar-tracking-assignments-toggle
-print-file-name=library
-print-multi-directory
GCC_EXEC_PREFIX.
-print-multi-lib
-print-multi-os-directory
-print-prog-name=program
-print-libgcc-file-name
This is useful when you use `-nostdlib' or `-nodefaultlibs' but you do want to link with `libgcc.a'. You can do
gcc -nostdlib files... `gcc -print-libgcc-file-name` |
-print-search-dirs
gcc will search--and don't do anything else.
This is useful when gcc prints the error message
`installation problem, cannot exec cpp0: No such file or directory'.
To resolve this you either need to put `cpp0' and the other compiler
components where gcc expects to find them, or you can set the environment
variable GCC_EXEC_PREFIX to the directory where you installed them.
Don't forget the trailing `/'.
See section 3.19 Environment Variables Affecting GCC.
-print-sysroot
-print-sysroot-headers-suffix
-dumpmachine
-dumpversion
-dumpspecs
-feliminate-unused-debug-types
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
These options control various sorts of optimizations.
Without any optimization option, 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.
Turning on optimization flags makes the compiler attempt to improve the performance and/or code size at the expense of compilation time and possibly the ability to debug the program.
The compiler performs optimization based on the knowledge it has of the program. Compiling multiple files at once to a single output file mode allows the compiler to use information gained from all of the files when compiling each of them.
Not all optimizations are controlled directly by a flag. Only optimizations that have a flag are listed in this section.
Most of the optimizations are not enabled if a `-O' level is not set on the command line, even if individual optimization flags are specified.
Depending on the target and how GCC was configured, a slightly different set of optimizations may be enabled at each `-O' level than those listed here. You can invoke GCC with `-Q --help=optimizers' to find out the exact set of optimizations that are enabled at each level. See section 3.2 Options Controlling the Kind of Output, for examples.
-O
-O1
With `-O', the compiler tries to reduce code size and execution time, without performing any optimizations that take a great deal of compilation time.
`-O' turns on the following optimization flags:
{
|
`-O' also turns on `-fomit-frame-pointer' on machines where doing so does not interfere with debugging.
-O2
`-O2' turns on all optimization flags specified by `-O'. It also turns on the following optimization flags:
{-fthread-jumps
|
Please note the warning under `-fgcse' about invoking `-O2' on programs that use computed gotos.
-O3
-O0
-Os
`-Os' disables the following optimization flags:
{-falign-functions -falign-jumps -falign-loops
|
If you use multiple `-O' options, with or without level numbers, the last such option is the one that is effective.
Options of the form `-fflag' specify machine-independent flags. Most flags have both positive and negative forms; the negative form of `-ffoo' would be `-fno-foo'. In the table below, only one of the forms is listed--the one you typically will use. You can figure out the other form by either removing `no-' or adding it.
The following options control specific optimizations. They are either activated by `-O' options or are related to ones that are. You can use the following flags in the rare cases when "fine-tuning" of optimizations to be performed is desired.
-fno-default-inline
-fno-defer-pop
Disabled at levels `-O', `-O2', `-O3', `-Os'.
-fforward-propagate
This option is enabled by default at optimization levels `-O', `-O2', `-O3', `-Os'.
-fomit-frame-pointer
On some machines, such as the VAX, this flag has no effect, because
the standard calling sequence automatically handles the frame pointer
and nothing is saved by pretending it doesn't exist. The
machine-description macro FRAME_POINTER_REQUIRED controls
whether a target machine supports this flag. See section `Register Usage' in GNU Compiler Collection (GCC) Internals.
Enabled at levels `-O', `-O2', `-O3', `-Os'.
-foptimize-sibling-calls
Enabled at levels `-O2', `-O3', `-Os'.
-fno-inline
inline keyword. Normally this option
is used to keep the compiler from expanding any functions inline.
Note that if you are not optimizing, no functions can be expanded inline.
-finline-small-functions
Enabled at level `-O2'.
-findirect-inlining
Enabled at level `-O2'.
-finline-functions
If all calls to a given function are integrated, and the function is
declared static, then the function is normally not output as
assembler code in its own right.
Enabled at level `-O3'.
-finline-functions-called-once
static functions called once for inlining into their
caller even if they are not marked inline. If a call to a given
function is integrated, then the function is not output as assembler code
in its own right.
Enabled at levels `-O1', `-O2', `-O3' and `-Os'.
-fearly-inlining
always_inline and functions whose body seems
smaller than the function call overhead early before doing
`-fprofile-generate' instrumentation and real inlining pass. Doing so
makes profiling significantly cheaper and usually inlining faster on programs
having large chains of nested wrapper functions.
Enabled by default.
-fipa-sra
Enabled at levels `-O2', `-O3' and `-Os'.
-finline-limit=n
Inlining is actually controlled by a number of parameters, which may be specified individually by using `--param name=value'. The `-finline-limit=n' option sets some of these parameters as follows:
max-inline-insns-single
max-inline-insns-auto
See below for a documentation of the individual parameters controlling inlining and for the defaults of these parameters.
Note: there may be no value to `-finline-limit' that results in default behavior.
Note: pseudo instruction represents, in this particular context, an abstract measurement of function's size. In no way does it represent a count of assembly instructions and as such its exact meaning might change from one release to an another.
-fkeep-inline-functions
static functions that are declared inline
into the object file, even if the function has been inlined into all
of its callers. This switch does not affect functions using the
extern inline extension in GNU C89. In C++, emit any and all
inline functions into the object file.
-fkeep-static-consts
static const when optimization isn't turned
on, even if the variables aren't referenced.
GCC enables this option by default. If you want to force the compiler to check if the variable was referenced, regardless of whether or not optimization is turned on, use the `-fno-keep-static-consts' option.
-fmerge-constants
This option is the default for optimized compilation if the assembler and linker support it. Use `-fno-merge-constants' to inhibit this behavior.
Enabled at levels `-O', `-O2', `-O3', `-Os'.
-fmerge-all-constants
This option implies `-fmerge-constants'. In addition to `-fmerge-constants' this considers e.g. even constant initialized arrays or initialized constant variables with integral or floating point types. Languages like C or C++ require each variable, including multiple instances of the same variable in recursive calls, to have distinct locations, so using this option will result in non-conforming behavior.
-fmodulo-sched
-fmodulo-sched-allow-regmoves
-fno-branch-count-reg
The default is `-fbranch-count-reg'.
-fno-function-cse
This option results in less efficient code, but some strange hacks that alter the assembler output may be confused by the optimizations performed when this option is not used.
The default is `-ffunction-cse'
-fno-zero-initialized-in-bss
This option turns off this behavior because some programs explicitly rely on variables going to the data section. E.g., so that the resulting executable can find the beginning of that section and/or make assumptions based on that.
The default is `-fzero-initialized-in-bss'.
-fmudflap -fmudflapth -fmudflapir
MUDFLAP_OPTIONS
environment variable. See env MUDFLAP_OPTIONS=-help a.out
for its options.
Use `-fmudflapth' instead of `-fmudflap' to compile and to link if your program is multi-threaded. Use `-fmudflapir', in addition to `-fmudflap' or `-fmudflapth', if instrumentation should ignore pointer reads. This produces less instrumentation (and therefore faster execution) and still provides some protection against outright memory corrupting writes, but allows erroneously read data to propagate within a program.
-fthread-jumps
Enabled at levels `-O2', `-O3', `-Os'.
-fsplit-wide-types
long
long on a 32-bit system, split the registers apart and allocate them
independently. This normally generates better code for those types,
but may make debugging more difficult.
Enabled at levels `-O', `-O2', `-O3', `-Os'.
-fcse-follow-jumps
if statement with an
else clause, CSE will follow the jump when the condition
tested is false.
Enabled at levels `-O2', `-O3', `-Os'.
-fcse-skip-blocks
if statement with no else clause,
`-fcse-skip-blocks' causes CSE to follow the jump around the
body of the if.
Enabled at levels `-O2', `-O3', `-Os'.
-frerun-cse-after-loop
Enabled at levels `-O2', `-O3', `-Os'.
-fgcse
Note: When compiling a program using computed gotos, a GCC extension, you may get better runtime performance if you disable the global common subexpression elimination pass by adding `-fno-gcse' to the command line.
Enabled at levels `-O2', `-O3', `-Os'.
-fgcse-lm
Enabled by default when gcse is enabled.
-fgcse-sm
Not enabled at any optimization level.
-fgcse-las
Not enabled at any optimization level.
-fgcse-after-reload
-funsafe-loop-optimizations
-fcrossjumping
Enabled at levels `-O2', `-O3', `-Os'.
-fauto-inc-dec
-fdce
-fdse
-fif-conversion
if-conversion2.
Enabled at levels `-O', `-O2', `-O3', `-Os'.
-fif-conversion2
Enabled at levels `-O', `-O2', `-O3', `-Os'.
-fdelete-null-pointer-checks
Note however that in some environments this assumption is not true. Use `-fno-delete-null-pointer-checks' to disable this optimization for programs which depend on that behavior.
Some targets, especially embedded ones, disable this option at all levels. Otherwise it is enabled at all levels: `-O0', `-O1', `-O2', `-O3', `-Os'. Passes that use the information are enabled independently at different optimization levels.
-fexpensive-optimizations
Enabled at levels `-O2', `-O3', `-Os'.
-foptimize-register-move
-fregmove
Note `-fregmove' and `-foptimize-register-move' are the same optimization.
Enabled at levels `-O2', `-O3', `-Os'.
-fira-algorithm=algorithm
priority or
CB. The first algorithm specifies Chow's priority coloring,
the second one specifies Chaitin-Briggs coloring. The second
algorithm can be unimplemented for some architectures. If it is
implemented, it is the default because Chaitin-Briggs coloring as a
rule generates a better code.
-fira-region=region
all, mixed, or
one. The first value means using all loops as register
allocation regions, the second value which is the default means using
all loops except for loops with small register pressure as the
regions, and third one means using all function as a single region.
The first value can give best result for machines with small size and
irregular register set, the third one results in faster and generates
decent code and the smallest size code, and the default value usually
give the best results in most cases and for most architectures.
-fira-coalesce
-fira-loop-pressure
This option is enabled at level `-O3' for some targets.
-fno-ira-share-save-slots
-fno-ira-share-spill-slots
-fira-verbose=n
-fdelayed-branch
Enabled at levels `-O', `-O2', `-O3', `-Os'.
-fschedule-insns
Enabled at levels `-O2', `-O3', `-Os'.
-fschedule-insns2
Enabled at levels `-O2', `-O3', `-Os'.
-fno-sched-interblock
-fno-sched-spec
-fsched-pressure
-fsched-spec-load
-fsched-spec-load-dangerous
-fsched-stalled-insns
-fsched-stalled-insns=n
-fsched-stalled-insns-dep
-fsched-stalled-insns-dep=n
-fsched2-use-superblocks
This only makes sense when scheduling after register allocation, i.e. with `-fschedule-insns2' or at `-O2' or higher.
-fsched-group-heuristic
-fsched-critical-path-heuristic
-fsched-spec-insn-heuristic
-fsched-rank-heuristic
-fsched-last-insn-heuristic
-fsched-dep-count-heuristic
-fsched2-use-traces
This mode should produce faster but significantly longer programs. Also without `-fbranch-probabilities' the traces constructed may not match the reality and hurt the performance. This only makes sense when scheduling after register allocation, i.e. with `-fschedule-insns2' or at `-O2' or higher.
-freschedule-modulo-scheduled-loops
-fselective-scheduling
-fselective-scheduling2
-fsel-sched-pipelining
-fsel-sched-pipelining-outer-loops
-fcaller-saves
This option is always enabled by default on certain machines, usually those which have no call-preserved registers to use instead.
Enabled at levels `-O2', `-O3', `-Os'.
-fconserve-stack
-ftree-reassoc
-ftree-pre
-ftree-forwprop
-ftree-fre
-ftree-phiprop
-ftree-copy-prop
-fipa-pure-const
-fipa-reference
-fipa-struct-reorg
With this flag, the program debug info reflects a new structure layout.
-fipa-pta
-fipa-cp
-fipa-cp-clone
-fipa-matrix-reorg
-ftree-sink
-ftree-ccp
-ftree-switch-conversion
-ftree-dce
-ftree-builtin-call-dce
errno but are otherwise side-effect free. This flag is
enabled by default at `-O2' and higher if `-Os' is not also
specified.
-ftree-dominator-opts
-ftree-dse
-ftree-ch
-ftree-loop-optimize
-ftree-loop-linear
-floop-interchange
DO J = 1, M
DO I = 1, N
A(J, I) = A(J, I) * C
ENDDO
ENDDO
|
DO I = 1, N
DO J = 1, M
A(J, I) = A(J, I) * C
ENDDO
ENDDO
|
N is larger than the caches,
because in Fortran, the elements of an array are stored in memory
contiguously by column, and the original loop iterates over rows,
potentially creating at each access a cache miss. This optimization
applies to all the languages supported by GCC and is not limited to
Fortran. To use this code transformation, GCC has to be configured
with `--with-ppl' and `--with-cloog' to enable the
Graphite loop transformation infrastructure.
-floop-strip-mine
DO I = 1, N A(I) = A(I) + C ENDDO |
DO II = 1, N, 4
DO I = II, min (II + 3, N)
A(I) = A(I) + C
ENDDO
ENDDO
|
-floop-block
DO I = 1, N
DO J = 1, M
A(J, I) = B(I) + C(J)
ENDDO
ENDDO
|
DO II = 1, N, 64
DO JJ = 1, M, 64
DO I = II, min (II + 63, N)
DO J = JJ, min (JJ + 63, M)
A(J, I) = B(I) + C(J)
ENDDO
ENDDO
ENDDO
ENDDO
|
M is larger than the caches,
because the innermost loop will iterate over a smaller amount of data
that can be kept in the caches. This optimization applies to all the
languages supported by GCC and is not limited to Fortran. To use this
code transformation, GCC has to be configured with `--with-ppl'
and `--with-cloog' to enable the Graphite loop transformation
infrastructure.
-fgraphite-identity
-floop-parallelize-all
-fcheck-data-deps
-ftree-loop-distribution
DO I = 1, N A(I) = B(I) + C D(I) = E(I) * F ENDDO |
DO I = 1, N A(I) = B(I) + C ENDDO DO I = 1, N D(I) = E(I) * F ENDDO |
-ftree-loop-im
-ftree-loop-ivcanon
-fivopts
-ftree-parallelize-loops=n
-ftree-pta
-ftree-sra
-ftree-copyrename
-ftree-ter
-ftree-vectorize
-ftree-vect-loop-version
-fvect-cost-model
-ftree-vrp
-ftracer
-funroll-loops
-funroll-all-loops
-fsplit-ivs-in-unroller
Combination of `-fweb' and CSE is often sufficient to obtain the same effect. However in cases the loop body is more complicated than a single basic block, this is not reliable. It also does not work at all on some of the architectures due to restrictions in the CSE pass.
This optimization is enabled by default.
-fvariable-expansion-in-unroller
-fpredictive-commoning
This option is enabled at level `-O3'.
-fprefetch-loop-arrays
This option may generate better or worse code; results are highly dependent on the structure of loops within the source code.
Disabled at level `-Os'.
-fno-peephole
-fno-peephole2
`-fpeephole' is enabled by default. `-fpeephole2' enabled at levels `-O2', `-O3', `-Os'.
-fno-guess-branch-probability
GCC will use heuristics to guess branch probabilities if they are not provided by profiling feedback (`-fprofile-arcs'). These heuristics are based on the control flow graph. If some branch probabilities are specified by `__builtin_expect', then the heuristics will be used to guess branch probabilities for the rest of the control flow graph, taking the `__builtin_expect' info into account. The interactions between the heuristics and `__builtin_expect' can be complex, and in some cases, it may be useful to disable the heuristics so that the effects of `__builtin_expect' are easier to understand.
The default is `-fguess-branch-probability' at levels `-O', `-O2', `-O3', `-Os'.
-freorder-blocks
Enabled at levels `-O2', `-O3'.
-freorder-blocks-and-partition
This optimization is automatically turned off in the presence of exception handling, for linkonce sections, for functions with a user-defined section attribute and on any architecture that does not support named sections.
-freorder-functions
.text.hot for most frequently executed functions and
.text.unlikely for unlikely executed functions. Reordering is done by
the linker so object file format must support named sections and linker must
place them in a reasonable way.
Also profile feedback must be available in to make this option effective. See `-fprofile-arcs' for details.
Enabled at levels `-O2', `-O3', `-Os'.
-fstrict-aliasing
unsigned int can alias an int, but not a
void* or a double. A character type may alias any other
type.
Pay special attention to code like this:
union a_union {
int i;
double d;
};
int f() {
union a_union t;
t.d = 3.0;
return t.i;
}
|
int f() {
union a_union t;
int* ip;
t.d = 3.0;
ip = &t.i;
return *ip;
}
|
Similarly, access by taking the address, casting the resulting pointer and dereferencing the result has undefined behavior, even if the cast uses a union type, e.g.:
int f() {
double d = 3.0;
return ((union a_union *) &d)->i;
}
|
The `-fstrict-aliasing' option is enabled at levels `-O2', `-O3', `-Os'.
-fstrict-overflow
i + 10 > i will always be true for
signed i. This assumption is only valid if signed overflow is
undefined, as the expression is false if i + 10 overflows when
using twos complement arithmetic. When this option is in effect any
attempt to determine whether an operation on signed numbers will
overflow must be written carefully to not actually involve overflow.
This option also allows the compiler to assume strict pointer
semantics: given a pointer to an object, if adding an offset to that
pointer does not produce a pointer to the same object, the addition is
undefined. This permits the compiler to conclude that p + u >
p is always true for a pointer p and unsigned integer
u. This assumption is only valid because pointer wraparound is
undefined, as the expression is false if p + u overflows using
twos complement arithmetic.
See also the `-fwrapv' option. Using `-fwrapv' means that integer signed overflow is fully defined: it wraps. When `-fwrapv' is used, there is no difference between `-fstrict-overflow' and `-fno-strict-overflow' for integers. With `-fwrapv' certain types of overflow are permitted. For example, if the compiler gets an overflow when doing arithmetic on constants, the overflowed value can still be used with `-fwrapv', but not otherwise.
The `-fstrict-overflow' option is enabled at levels `-O2', `-O3', `-Os'.
-falign-functions
-falign-functions=n
`-fno-align-functions' and `-falign-functions=1' are equivalent and mean that functions will not be aligned.
Some assemblers only support this flag when n is a power of two; in that case, it is rounded up.
If n is not specified or is zero, use a machine-dependent default.
Enabled at levels `-O2', `-O3'.
-falign-labels
-falign-labels=n
`-fno-align-labels' and `-falign-labels=1' are equivalent and mean that labels will not be aligned.
If `-falign-loops' or `-falign-jumps' are applicable and are greater than this value, then their values are used instead.
If n is not specified or is zero, use a machine-dependent default which is very likely to be `1', meaning no alignment.
Enabled at levels `-O2', `-O3'.
-falign-loops
-falign-loops=n
`-fno-align-loops' and `-falign-loops=1' are equivalent and mean that loops will not be aligned.
If n is not specified or is zero, use a machine-dependent default.
Enabled at levels `-O2', `-O3'.
-falign-jumps
-falign-jumps=n
`-fno-align-jumps' and `-falign-jumps=1' are equivalent and mean that loops will not be aligned.
If n is not specified or is zero, use a machine-dependent default.
Enabled at levels `-O2', `-O3'.
-funit-at-a-time
Enabled by default.
-fno-toplevel-reorder
asm
statements. Output them in the same order that they appear in the
input file. When this option is used, unreferenced static variables
will not be removed. This option is intended to support existing code
which relies on a particular ordering. For new code, it is better to
use attributes.
Enabled at level `-O0'. When disabled explicitly, it also imply `-fno-section-anchors' that is otherwise enabled at `-O0' on some targets.
-fweb
Enabled by default with `-funroll-loops'.
-fwhole-program
main
and those merged by attribute externally_visible become static functions
and in effect are optimized more aggressively by interprocedural optimizers.
While this option is equivalent to proper use of the static keyword for
programs consisting of a single file, in combination with option
`-combine', `-flto' or `-fwhopr' this flag can be used to
compile many smaller scale programs since the functions and variables become
local for the whole combined compilation unit, not for the single source file
itself.
This option implies `-fwhole-file' for Fortran programs.
-flto
To use the link-timer optimizer, `-flto' needs to be specified at compile time and during the final link. For example,
gcc -c -O2 -flto foo.c gcc -c -O2 -flto bar.c gcc -o myprog -flto -O2 foo.o bar.o |
The first two invocations to GCC will save a bytecode representation of GIMPLE into special ELF sections inside `foo.o' and `bar.o'. The final invocation will read the GIMPLE bytecode from `foo.o' and `bar.o', merge the two files into a single internal image, and compile the result as usual. Since both `foo.o' and `bar.o' are merged into a single image, this causes all the inter-procedural analyses and optimizations in GCC to work across the two files as if they were a single one. This means, for example, that the inliner will be able to inline functions in `bar.o' into functions in `foo.o' and vice-versa.
Another (simpler) way to enable link-time optimization is,
gcc -o myprog -flto -O2 foo.c bar.c |
The above will generate bytecode for `foo.c' and `bar.c', merge them together into a single GIMPLE representation and optimize them as usual to produce `myprog'.
The only important thing to keep in mind is that to enable link-time optimizations the `-flto' flag needs to be passed to both the compile and the link commands.
Note that when a file is compiled with `-flto', the generated object file will be larger than a regular object file because it will contain GIMPLE bytecodes and the usual final code. This means that object files with LTO information can be linked as a normal object file. So, in the previous example, if the final link is done with
gcc -o myprog foo.o bar.o |
The only difference will be that no inter-procedural optimizations will be applied to produce `myprog'. The two object files `foo.o' and `bar.o' will be simply sent to the regular linker.
Additionally, the optimization flags used to compile individual files are not necessarily related to those used at link-time. For instance,
gcc -c -O0 -flto foo.c gcc -c -O0 -flto bar.c gcc -o myprog -flto -O3 foo.o bar.o |
This will produce individual object files with unoptimized assembler code, but the resulting binary `myprog' will be optimized at `-O3'. Now, if the final binary is generated without `-flto', then `myprog' will not be optimized.
When producing the final binary with `-flto', GCC will only apply link-time optimizations to those files that contain bytecode. Therefore, you can mix and match object files and libraries with GIMPLE bytecodes and final object code. GCC will automatically select which files to optimize in LTO mode and which files to link without further processing.
There are some code generation flags that GCC will preserve when generating bytecodes, as they need to be used during the final link stage. Currently, the following options are saved into the GIMPLE bytecode files: `-fPIC', `-fcommon' and all the `-m' target flags.
At link time, these options are read-in and reapplied. Note that the current implementation makes no attempt at recognizing conflicting values for these options. If two or more files have a conflicting value (e.g., one file is compiled with `-fPIC' and another isn't), the compiler will simply use the last value read from the bytecode files. It is recommended, then, that all the files participating in the same link be compiled with the same options.
Another feature of LTO is that it is possible to apply interprocedural optimizations on files written in different languages. This requires some support in the language front end. Currently, the C, C++ and Fortran front ends are capable of emitting GIMPLE bytecodes, so something like this should work
gcc -c -flto foo.c g++ -c -flto bar.cc gfortran -c -flto baz.f90 g++ -o myprog -flto -O3 foo.o bar.o baz.o -lgfortran |
Notice that the final link is done with g++ to get the C++
runtime libraries and `-lgfortran' is added to get the Fortran
runtime libraries. In general, when mixing languages in LTO mode, you
should use the same link command used when mixing languages in a
regular (non-LTO) compilation. This means that if your build process
was mixing languages before, all you need to add is `-flto' to
all the compile and link commands.
If object files containing GIMPLE bytecode are stored in a library
archive, say `libfoo.a', it is possible to extract and use them
in an LTO link if you are using gold as the linker (which,
in turn requires GCC to be configured with `--enable-gold').
To enable this feature, use the flag `-fuse-linker-plugin' at
link-time:
gcc -o myprog -O2 -flto -fuse-linker-plugin a.o b.o -lfoo |
With the linker plugin enabled, gold will extract the needed
GIMPLE files from `libfoo.a' and pass them on to the running GCC
to make them part of the aggregated GIMPLE image to be optimized.
If you are not using gold and/or do not specify
`-fuse-linker-plugin' then the objects inside `libfoo.a'
will be extracted and linked as usual, but they will not participate
in the LTO optimization process.
Link time optimizations do not require the presence of the whole program to operate. If the program does not require any symbols to be exported, it is possible to combine `-flto' and `-fwhopr' with `-fwhole-program' to allow the interprocedural optimizers to use more aggressive assumptions which may lead to improved optimization opportunities.
Regarding portability: the current implementation of LTO makes no attempt at generating bytecode that can be ported between different types of hosts. The bytecode files are versioned and there is a strict version check, so bytecode files generated in one version of GCC will not work with an older/newer version of GCC.
This option is disabled by default.
-fwhopr
Disabled by default.
-fwpa
This option runs the link-time optimizer in the whole-program-analysis (WPA) mode, which reads in summary information from all inputs and performs a whole-program analysis based on summary information only. It generates object files for subsequent runs of the link-time optimizer where individual object files are optimized using both summary information from the WPA mode and the actual function bodies. It then drives the LTRANS phase.
Disabled by default.
-fltrans
This option runs the link-time optimizer in the local-transformation (LTRANS) mode, which reads in output from a previous run of the LTO in WPA mode. In the LTRANS mode, LTO optimizes an object and produces the final assembly.
Disabled by default.
-fltrans-output-list=file
This option specifies a file to which the names of LTRANS output files are written. This option is only meaningful in conjunction with `-fwpa'.
Disabled by default.
-flto-compression-level=n
-flto-report
Disabled by default.
-fuse-linker-plugin
gold, so to use this you must configure GCC with
`--enable-gold'. See `-flto' for a description on the
effect of this flag and how to use it.
Disabled by default.
-fcprop-registers
Enabled at levels `-O', `-O2', `-O3', `-Os'.
-fprofile-correction
-fprofile-dir=path
Set the directory to search the profile data files in to path. This option affects only the profile data generated by `-fprofile-generate', `-ftest-coverage', `-fprofile-arcs' and used by `-fprofile-use' and `-fbranch-probabilities' and its related options. By default, GCC will use the current directory as path thus the profile data file will appear in the same directory as the object file.
-fprofile-generate
-fprofile-generate=path
Enable options usually used for instrumenting application to produce profile useful for later recompilation with profile feedback based optimization. You must use `-fprofile-generate' both when compiling and when linking your program.
The following options are enabled: -fprofile-arcs, -fprofile-values, -fvpt.
If path is specified, GCC will look at the path to find the profile feedback data files. See `-fprofile-dir'.
-fprofile-use
-fprofile-use=path
The following options are enabled: -fbranch-probabilities, -fvpt,
-funroll-loops, -fpeel-loops, -ftracer
By default, GCC emits an error message if the feedback profiles do not match the source code. This error can be turned into a warning by using `-Wcoverage-mismatch'. Note this may result in poorly optimized code.
If path is specified, GCC will look at the path to find the profile feedback data files. See `-fprofile-dir'.
The following options control compiler behavior regarding floating point arithmetic. These options trade off between speed and correctness. All must be specifically enabled.
-ffloat-store
This option prevents undesirable excess precision on machines such as
the 68000 where the floating registers (of the 68881) keep more
precision than a 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 `-ffloat-store' for such programs, after modifying
them to store all pertinent intermediate computations into variables.
-fexcess-precision=style
float and double types and the processor does not
support operations rounding to those types. By default,
`-fexcess-precision=fast' is in effect; this means that
operations are carried out in the precision of the registers and that
it is unpredictable when rounding to the types specified in the source
code takes place. When compiling C, if
`-fexcess-precision=standard' is specified then excess
precision will follow the rules specified in ISO C99; in particular,
both casts and assignments cause values to be rounded to their
semantic types (whereas `-ffloat-store' only affects
assignments). This option is enabled by default for C if a strict
conformance option such as `-std=c99' is used.
`-fexcess-precision=standard' is not implemented for languages other than C, and has no effect if `-funsafe-math-optimizations' or `-ffast-math' is specified. On the x86, it also has no effect if `-mfpmath=sse' or `-mfpmath=sse+387' is specified; in the former case, IEEE semantics apply without excess precision, and in the latter, rounding is unpredictable.
-ffast-math
This option causes the preprocessor macro __FAST_MATH__ to be defined.
This option is not turned on by any `-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. It may, however, yield faster code for programs that do not require the guarantees of these specifications.
-fno-math-errno
This option is not turned on by any `-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. It may, however, yield faster code for programs that do not require the guarantees of these specifications.
The default is `-fmath-errno'.
On Darwin systems, the math library never sets errno. There is
therefore no reason for the compiler to consider the possibility that
it might, and `-fno-math-errno' is the default.
-funsafe-math-optimizations
Allow optimizations for floating-point arithmetic that (a) assume that arguments and results are valid and (b) may violate IEEE or ANSI standards. When used at link-time, it may include libraries or startup files that change the default FPU control word or other similar optimizations.
This option is not turned on by any `-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. It may, however, yield faster code for programs that do not require the guarantees of these specifications. Enables `-fno-signed-zeros', `-fno-trapping-math', `-fassociative-math' and `-freciprocal-math'.
The default is `-fno-unsafe-math-optimizations'.
-fassociative-math
Allow re-association of operands in series of floating-point operations.
This violates the ISO C and C++ language standard by possibly changing
computation result. NOTE: re-ordering may change the sign of zero as
well as ignore NaNs and inhibit or create underflow or overflow (and
thus cannot be used on a code which relies on rounding behavior like
(x + 2**52) - 2**52). May also reorder floating-point comparisons
and thus may not be used when ordered comparisons are required.
This option requires that both `-fno-signed-zeros' and
`-fno-trapping-math' be in effect. Moreover, it doesn't make
much sense with `-frounding-math'.
The default is `-fno-associative-math'.
-freciprocal-math
Allow the reciprocal of a value to be used instead of dividing by
the value if this enables optimizations. For example x / y
can be replaced with x * (1/y) which is useful if (1/y)
is subject to common subexpression elimination. Note that this loses
precision and increases the number of flops operating on the value.
The default is `-fno-reciprocal-math'.
-ffinite-math-only
This option is not turned on by any `-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. It may, however, yield faster code for programs that do not require the guarantees of these specifications.
The default is `-fno-finite-math-only'.
-fno-signed-zeros
The default is `-fsigned-zeros'.
-fno-trapping-math
This option should never be turned on by any `-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 `-ftrapping-math'.
-frounding-math
The default is `-fno-rounding-math'.
This option is experimental and does not currently guarantee to
disable all GCC optimizations that are affected by rounding mode.
Future versions of GCC may provide finer control of this setting
using C99's FENV_ACCESS pragma. This command line option
will be used to specify the default state for FENV_ACCESS.
-fsignaling-nans
This option causes the preprocessor macro __SUPPORT_SNAN__ to
be defined.
The default is `-fno-signaling-nans'.
This option is experimental and does not currently guarantee to disable all GCC optimizations that affect signaling NaN behavior.
-fsingle-precision-constant
-fcx-limited-range
NaN
+ I*NaN, with an attempt to rescue the situation in that case. The
default is `-fno-cx-limited-range', but is enabled by
`-ffast-math'.
This option controls the default setting of the ISO C99
CX_LIMITED_RANGE pragma. Nevertheless, the option applies to
all languages.
-fcx-fortran-rules
NaN
+ I*NaN, with an attempt to rescue the situation in that case.
The default is `-fno-cx-fortran-rules'.
The following options control optimizations that may improve performance, but are not enabled by any `-O' options. This section includes experimental options that may produce broken code.
-fbranch-probabilities
gcc), you can compile it a second time using
`-fbranch-probabilities', to improve optimizations based on
the number of times each branch was taken. When the program
compiled with `-fprofile-arcs' exits it saves arc execution
counts to a file called `sourcename.gcda' for each source
file. The information in this data file is very dependent on the
structure of the generated code, so you must use the same source code
and the same optimization options for both compilations.
With `-fbranch-probabilities', GCC puts a `REG_BR_PROB' note on each `JUMP_INSN' and `CALL_INSN'. These can be used to improve optimization. Currently, they are only used in one place: in `reorg.c', instead of guessing which path a branch is mostly to take, the `REG_BR_PROB' values are used to exactly determine which path is taken more often.
-fprofile-values
With `-fbranch-probabilities', it reads back the data gathered from profiling values of expressions and adds `REG_VALUE_PROFILE' notes to instructions for their later usage in optimizations.
Enabled with `-fprofile-generate' and `-fprofile-use'.
-fvpt
With `-fbranch-probabilities', it reads back the data gathered and actually performs the optimizations based on them. Currently the optimizations include specialization of division operation using the knowledge about the value of the denominator.
-frename-registers
Enabled by default with `-funroll-loops'.
-ftracer
Enabled with `-fprofile-use'.
-funroll-loops
Enabled with `-fprofile-use'.
-funroll-all-loops
-fpeel-loops
Enabled with `-fprofile-use'.
-fmove-loop-invariants
-funswitch-loops
-ffunction-sections
-fdata-sections
Use these options on systems where the linker can perform optimizations to improve locality of reference in the instruction space. Most systems using the ELF object format and SPARC processors running Solaris 2 have linkers with such optimizations. AIX may have these optimizations in the future.
Only use these options when there are significant benefits from doing
so. When you specify these options, the assembler and linker will
create larger object and executable files and will also be slower.
You will not be able to use gprof on all systems if you
specify this option and you may have problems with debugging if
you specify both this option and `-g'.
-fbranch-target-load-optimize
-fbranch-target-load-optimize2
-fbtr-bb-exclusive
-fstack-protector
-fstack-protector-all
-fsection-anchors
For example, the implementation of the following function foo:
static int a, b, c;
int foo (void) { return a + b + c; }
|
would usually calculate the addresses of all three variables, but if you compile it with `-fsection-anchors', it will access the variables from a common anchor point instead. The effect is similar to the following pseudocode (which isn't valid C):
int foo (void)
{
register int *xr = &x;
return xr[&a - &x] + xr[&b - &x] + xr[&c - &x];
}
|
Not all targets support this option.
--param name=value
The names of specific parameters, and the meaning of the values, are tied to the internals of the compiler, and are subject to change without notice in future releases.
In each case, the value is an integer. The allowable choices for name are given in the following table:
struct-reorg-cold-struct-ratio
predictable-branch-cost-outcome
max-crossjump-edges
min-crossjump-insns
max-grow-copy-bb-insns
max-goto-duplication-insns
max-delay-slot-insn-search
max-delay-slot-live-search
max-gcse-memory
max-pending-list-length
max-inline-insns-single
max-inline-insns-auto
large-function-insns
large-function-growth
large-unit-insns
inline-unit-growth
ipcp-unit-growth
large-stack-frame
large-stack-frame-growth
max-inline-insns-recursive
max-inline-insns-recursive-auto
For functions declared inline `--param max-inline-insns-recursive' is taken into account. For function not declared inline, recursive inlining happens only when `-finline-functions' (included in `-O3') is enabled and `--param max-inline-insns-recursive-auto' is used. The default value is 450.
max-inline-recursive-depth
max-inline-recursive-depth-auto
For functions declared inline `--param max-inline-recursive-depth' is taken into account. For function not declared inline, recursive inlining happens only when `-finline-functions' (included in `-O3') is enabled and `--param max-inline-recursive-depth-auto' is used. The default value is 8.
min-inline-recursive-probability
When profile feedback is available (see `-fprofile-generate') the actual recursion depth can be guessed from probability that function will recurse via given call expression. This parameter limits inlining only to call expression whose probability exceeds given threshold (in percents). The default value is 10.
early-inlining-insns
max-early-inliner-iterations
max-early-inliner-iterations
min-vect-loop-bound
max-unrolled-insns
max-average-unrolled-insns
max-unroll-times
max-peeled-insns
max-peel-times
max-completely-peeled-insns
max-completely-peel-times
max-unswitch-insns
max-unswitch-level
lim-expensive
iv-consider-all-candidates-bound
iv-max-considered-uses
iv-always-prune-cand-set-bound
scev-max-expr-size
omega-max-vars
omega-max-geqs
omega-max-eqs
omega-max-wild-cards
omega-hash-table-size
omega-max-keys
omega-eliminate-redundant-constraints
vect-max-version-for-alignment-checks
vect-max-version-for-alias-checks
max-iterations-to-track
The maximum number of iterations of a loop the brute force algorithm for analysis of # of iterations of the loop tries to evaluate.
hot-bb-count-fraction
hot-bb-frequency-fraction
max-predicted-iterations
align-threshold
Select fraction of the maximal frequency of executions of basic block in function given basic block will get aligned.
align-loop-iterations
A loop expected to iterate at lest the selected number of iterations will get aligned.
tracer-dynamic-coverage
tracer-dynamic-coverage-feedback
This value is used to limit superblock formation once the given percentage of executed instructions is covered. This limits unnecessary code size expansion.
The `tracer-dynamic-coverage-feedback' is used only when profile feedback is available. The real profiles (as opposed to statically estimated ones) are much less balanced allowing the threshold to be larger value.
tracer-max-code-growth
tracer-min-branch-ratio
Stop reverse growth when the reverse probability of best edge is less than this threshold (in percent).
tracer-min-branch-ratio
tracer-min-branch-ratio-feedback
Stop forward growth if the best edge do have probability lower than this threshold.
Similarly to `tracer-dynamic-coverage' two values are present, one for compilation for profile feedback and one for compilation without. The value for compilation with profile feedback needs to be more conservative (higher) in order to make tracer effective.
max-cse-path-length
Maximum number of basic blocks on path that cse considers. The default is 10.
max-cse-insns
ggc-min-expand
GCC uses a garbage collector to manage its own memory allocation. This parameter specifies the minimum percentage by which the garbage collector's heap should be allowed to expand between collections. Tuning this may improve compilation speed; it has no effect on code generation.
The default is 30% + 70% * (RAM/1GB) with an upper bound of 100% when
RAM >= 1GB. If getrlimit is available, the notion of "RAM" is
the smallest of actual RAM and RLIMIT_DATA or RLIMIT_AS. If
GCC is not able to calculate RAM on a particular platform, the lower
bound of 30% is used. Setting this parameter and
`ggc-min-heapsize' to zero causes a full collection to occur at
every opportunity. This is extremely slow, but can be useful for
debugging.
ggc-min-heapsize
Minimum size of the garbage collector's heap before it begins bothering to collect garbage. The first collection occurs after the heap expands by `ggc-min-expand'% beyond `ggc-min-heapsize'. Again, tuning this may improve compilation speed, and has no effect on code generation.
The default is the smaller of RAM/8, RLIMIT_RSS, or a limit which tries to ensure that RLIMIT_DATA or RLIMIT_AS are not exceeded, but with a lower bound of 4096 (four megabytes) and an upper bound of 131072 (128 megabytes). If GCC is not able to calculate RAM on a particular platform, the lower bound is used. Setting this parameter very large effectively disables garbage collection. Setting this parameter and `ggc-min-expand' to zero causes a full collection to occur at every opportunity.
max-reload-search-insns
max-cselib-memory-locations
reorder-blocks-duplicate
reorder-blocks-duplicate-feedback
Used by basic block reordering pass to decide whether to use unconditional branch or duplicate the code on its destination. Code is duplicated when its estimated size is smaller than this value multiplied by the estimated size of unconditional jump in the hot spots of the program.
The `reorder-block-duplicate-feedback' is used only when profile feedback is available and may be set to higher values than `reorder-block-duplicate' since information about the hot spots is more accurate.
max-sched-ready-insns
max-sched-region-blocks
max-pipeline-region-blocks
max-sched-region-insns
max-pipeline-region-insns
min-spec-prob
max-sched-extend-regions-iters
max-sched-insn-conflict-delay
sched-spec-prob-cutoff
sched-mem-true-dep-cost
selsched-max-lookahead
selsched-max-sched-times
selsched-max-insns-to-rename
max-last-value-rtl
integer-share-limit
min-virtual-mappings
virtual-mappings-ratio
ssp-buffer-size
max-jump-thread-duplication-stmts
max-fields-for-field-sensitive
prefetch-latency
simultaneous-prefetches
l1-cache-line-size
l1-cache-size
l2-cache-size
min-insn-to-prefetch-ratio
prefetch-min-insn-to-mem-ratio
use-canonical-types
switch-conversion-max-branch-ratio
max-partial-antic-length
sccvn-max-scc-size
ira-max-loops-num
ira-max-conflict-table-size
ira-loop-reserved-regs
loop-invariant-max-bbs-in-loop
min-nondebug-insn-uid
ipa-sra-ptr-growth-factor
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
These options control the C preprocessor, which is run on each C source file before actual compilation.
If you use the `-E' option, nothing is done except preprocessing. Some of these options make sense only together with `-E' because they cause the preprocessor output to be unsuitable for actual compilation.
-Wp,option
-Xpreprocessor option
If you want to pass an option that takes an argument, you must use `-Xpreprocessor' twice, once for the option and once for the argument.
-D name
1.
-D name=definition
If you are invoking the preprocessor from a shell or shell-like program you may need to use the shell's quoting syntax to protect characters such as spaces that have a meaning in the shell syntax.
If you wish to define a function-like macro on the command line, write
its argument list with surrounding parentheses before the equals sign
(if any). Parentheses are meaningful to most shells, so you will need
to quote the option. With sh and csh,
`-D'name(args...)=definition'' works.
`-D' and `-U' options are processed in the order they are given on the command line. All `-imacros file' and `-include file' options are processed after all `-D' and `-U' options.
-U name
-undef
-I dir
=, then the = will be replaced
by the sysroot prefix; see `--sysroot' and `-isysroot'.
-o file
cpp. gcc has a
different interpretation of a second non-option argument, so you must
use `-o' to specify the output file.
-Wall
#if expressions. Note that many of the
preprocessor's warnings are on by default and have no options to
control them.
-Wcomment
-Wcomments
-Wtrigraphs
This option is implied by `-Wall'. If `-Wall' is not given, this option is still enabled unless trigraphs are enabled. To get trigraph conversion without warnings, but get the other `-Wall' warnings, use `-trigraphs -Wall -Wno-trigraphs'.
-Wtraditional
-Wundef
-Wunused-macros
Built-in macros, macros defined on the command line, and macros defined in include files are not warned about.
Note: If a macro is actually used, but only used in skipped conditional blocks, then CPP will report it as unused. To avoid the warning in such a case, you might improve the scope of the macro's definition by, for example, moving it into the first skipped block. Alternatively, you could provide a dummy use with something like:
#if defined the_macro_causing_the_warning #endif |
-Wendif-labels
#if FOO ... #else FOO ... #endif FOO |
The second and third FOO should be in comments, but often are not
in older programs. This warning is on by default.
-Werror
-Wsystem-headers
-w
-pedantic
-pedantic-errors
-M
make describing the dependencies of the main
source file. The preprocessor outputs one make rule containing
the object file name for that source file, a colon, and the names of all
the included files, including those coming from `-include' or
`-imacros' command line options.
Unless specified explicitly (with `-MT' or `-MQ'), the object file name consists of the name of the source file with any suffix replaced with object file suffix and with any leading directory parts removed. If there are many included files then the rule is split into several lines using `\'-newline. The rule has no commands.
This option does not suppress the preprocessor's debug output, such as
`-dM'. To avoid mixing such debug output with the dependency
rules you should explicitly specify the dependency output file with
`-MF', or use an environment variable like
DEPENDENCIES_OUTPUT (see section 3.19 Environment Variables Affecting GCC). Debug output
will still be sent to the regular output stream as normal.
Passing `-M' to the driver implies `-E', and suppresses warnings with an implicit `-w'.
-MM
This implies that the choice of angle brackets or double quotes in an `#include' directive does not in itself determine whether that header will appear in `-MM' dependency output. This is a slight change in semantics from GCC versions 3.0 and earlier.
-MF file
When used with the driver options `-MD' or `-MMD', `-MF' overrides the default dependency output file.
-MG
#include directive without prepending any path. `-MG'
also suppresses preprocessed output, as a missing header file renders
this useless.
This feature is used in automatic updating of makefiles.
-MP
make gives if you remove header
files without updating the `Makefile' to match.
This is typical output:
test.o: test.c test.h test.h: |
-MT target
Change the target of the rule emitted by dependency generation. By default CPP takes the name of the main input file, deletes any directory components and any file suffix such as `.c', and appends the platform's usual object suffix. The result is the target.
An `-MT' option will set the target to be exactly the string you specify. If you want multiple targets, you can specify them as a single argument to `-MT', or use multiple `-MT' options.
For example, `-MT '$(objpfx)foo.o'' might give
$(objpfx)foo.o: foo.c |
-MQ target
Same as `-MT', but it quotes any characters which are special to Make. `-MQ '$(objpfx)foo.o'' gives
$$(objpfx)foo.o: foo.c |
The default target is automatically quoted, as if it were given with `-MQ'.
-MD
If `-MD' is used in conjunction with `-E', any `-o' switch is understood to specify the dependency output file (see section -MF), but if used without `-E', each `-o' is understood to specify a target object file.
Since `-E' is not implied, `-MD' can be used to generate a dependency output file as a side-effect of the compilation process.
-MMD
-fpch-deps
-fpch-preprocess
#pragma,
#pragma GCC pch_preprocess "<filename>" in the output to mark
the place where the precompiled header was found, and its filename. When
`-fpreprocessed' is in use, GCC recognizes this #pragma and
loads the PCH.
This option is off by default, because the resulting preprocessed output is only really suitable as input to GCC. It is switched on by `-save-temps'.
You should not write this #pragma in your own code, but it is
safe to edit the filename if the PCH file is available in a different
location. The filename may be absolute or it may be relative to GCC's
current directory.
-x c
-x c++
-x objective-c
-x assembler-with-cpp
Note: Previous versions of cpp accepted a `-lang' option which selected both the language and the standards conformance level. This option has been removed, because it conflicts with the `-l' option.
-std=standard
-ansi
standard may be one of:
iso9899:1990
c89
The `-ansi' option is equivalent to `-std=c89'.
iso9899:199409
iso9899:1999
c99
iso9899:199x
c9x
gnu89
gnu99
gnu9x
c++98
gnu++98
-I-
#include "file"; they are not searched for
#include <file>. If additional directories are
specified with `-I' options after the `-I-', those
directories are searched for all `#include' directives.
In addition, `-I-' inhibits the use of the directory of the current
file directory as the first search directory for #include
"file".
This option has been deprecated.
-nostdinc
-nostdinc++
-include file
#include "file" appeared as the first
line of the primary source file. However, the first directory searched
for file is the preprocessor's working directory instead of
the directory containing the main source file. If not found there, it
is searched for in the remainder of the #include "..." search
chain as normal.
If multiple `-include' options are given, the files are included in the order they appear on the command line.
-imacros file
All files specified by `-imacros' are processed before all files specified by `-include'.
-idirafter dir
=, then the = will be replaced
by the sysroot prefix; see `--sysroot' and `-isysroot'.
-iprefix prefix
-iwithprefix dir
-iwithprefixbefore dir
-isysroot dir
-imultilib dir
-isystem dir
=, then the = will be replaced
by the sysroot prefix; see `--sysroot' and `-isysroot'.
-iquote dir
#include "file"; they are not searched for
#include <file>, before all directories specified by
`-I' and before the standard system directories.
If dir begins with =, then the = will be replaced
by the sysroot prefix; see `--sysroot' and `-isysroot'.
-fdirectives-only
The option's behavior depends on the `-E' and `-fpreprocessed' options.
With `-E', preprocessing is limited to the handling of directives
such as #define, #ifdef, and #error. Other
preprocessor operations, such as macro expansion and trigraph
conversion are not performed. In addition, the `-dD' option is
implicitly enabled.
With `-fpreprocessed', predefinition of command line and most
builtin macros is disabled. Macros such as __LINE__, which are
contextually dependent, are handled normally. This enables compilation of
files previously preprocessed with -E -fdirectives-only.
With both `-E' and `-fpreprocessed', the rules for
`-fpreprocessed' take precedence. This enables full preprocessing of
files previously preprocessed with -E -fdirectives-only.
-fdollars-in-identifiers
-fextended-identifiers
-fpreprocessed
`-fpreprocessed' is implicit if the input file has one of the extensions `.i', `.ii' or `.mi'. These are the extensions that GCC uses for preprocessed files created by `-save-temps'.
-ftabstop=width
-fexec-charset=charset
iconv library routine.
-fwide-exec-charset=charset
wchar_t. As with
`-fexec-charset', charset can be any encoding supported
by the system's iconv library routine; however, you will have
problems with encodings that do not fit exactly in wchar_t.
-finput-charset=charset
iconv library routine.
-fworking-directory
#line directives are emitted whatsoever.
-fno-show-column
dejagnu.
-A predicate=answer
-A -predicate=answer
-dCHARS
touch foo.h; cpp -dM foo.h |
will show all the predefined macros.
If you use `-dM' without the `-E' option, `-dM' is interpreted as a synonym for `-fdump-rtl-mach'. See section 3.9 Options for Debugging Your Program or GCC.
-P
-C
You should be prepared for side effects when using `-C'; it causes the preprocessor to treat comments as tokens in their own right. For example, comments appearing at the start of what would be a directive line have the effect of turning that line into an ordinary source line, since the first token on the line is no longer a `#'.
-CC
In addition to the side-effects of the `-C' option, the `-CC' option causes all C++-style comments inside a macro to be converted to C-style comments. This is to prevent later use of that macro from inadvertently commenting out the remainder of the source line.
The `-CC' option is generally used to support lint comments.
-traditional-cpp
-trigraphs
The nine trigraphs and their replacements are
Trigraph: ??( ??) ??< ??> ??= ??/ ??' ??! ??-
Replacement: [ ] { } # \ ^ | ~
|
-remap
--help
--target-help
-v
-H
-version
--version
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
You can pass options to the assembler.
-Wa,option
-Xassembler option
If you want to pass an option that takes an argument, you must use `-Xassembler' twice, once for the option and once for the argument.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
These options come into play when the compiler links object files into an executable output file. They are meaningless if the compiler is not doing a link step.
object-file-name
-c
-S
-E
-llibrary
-l library
It makes a difference where in the command you write this option; the linker searches and processes libraries and object files in the order they are specified. Thus, `foo.o -lz bar.o' searches library `z' after file `foo.o' but before `bar.o'. If `bar.o' refers to functions in `z', those functions may not be loaded.
The linker searches a standard list of directories for the library, which is actually a file named `liblibrary.a'. The linker 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 `-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 `-l' option and specifying a file name is that `-l' surrounds library with `lib' and `.a' and searches several directories.
-lobjc
-nostartfiles
-nodefaultlibs
-static-libgcc
or -shared-libgcc, will be ignored.
The standard startup files are used normally, unless `-nostartfiles'
is used. The compiler may generate calls to memcmp,
memset, memcpy and memmove.
These entries are usually resolved by entries in
libc. These entry points should be supplied through some other
mechanism when this option is specified.
-nostdlib
-static-libgcc or -shared-libgcc, will be ignored.
The compiler may generate calls to memcmp, memset,
memcpy and memmove.
These entries are usually resolved by entries in
libc. These entry points should be supplied through some other
mechanism when this option is specified.
One of the standard libraries bypassed by `-nostdlib' and
`-nodefaultlibs' is `libgcc.a', a library of internal subroutines
that GCC uses to overcome shortcomings of particular machines, or special
needs for some languages.
(See section `Interfacing to GCC Output' in GNU Compiler Collection (GCC) Internals,
for more discussion of `libgcc.a'.)
In most cases, you need `libgcc.a' even when you want to avoid
other standard libraries. In other words, when you specify `-nostdlib'
or `-nodefaultlibs' you should usually specify `-lgcc' as well.
This ensures that you have no unresolved references to internal GCC
library subroutines. (For example, `__main', used to ensure C++
constructors will be called; see section `collect2' in GNU Compiler Collection (GCC) Internals.)
-pie
-rdynamic
dlopen or to allow obtaining backtraces
from within a program.
-s
-static
-shared
-shared-libgcc
-static-libgcc
There are several situations in which an application should use the shared `libgcc' instead of the static version. The most common of these is when the application wishes to throw and catch exceptions across different shared libraries. In that case, each of the libraries as well as the application itself should use the shared `libgcc'.
Therefore, the G++ and GCJ drivers automatically add `-shared-libgcc' whenever you build a shared library or a main executable, because C++ and Java programs typically use exceptions, so this is the right thing to do.
If, instead, you use the GCC driver to create shared libraries, you may find that they will not always be linked with the shared `libgcc'. If GCC finds, at its configuration time, that you have a non-GNU linker or a GNU linker that does not support option `--eh-frame-hdr', it will link the shared version of `libgcc' into shared libraries by default. Otherwise, it will take advantage of the linker and optimize away the linking with the shared version of `libgcc', linking with the static version of libgcc by default. This allows exceptions to propagate through such shared libraries, without incurring relocation costs at library load time.
However, if a library or main executable is supposed to throw or catch exceptions, you must link it using the G++ or GCJ driver, as appropriate for the languages used in the program, or using the option `-shared-libgcc', such that it is linked with the shared `libgcc'.
-static-libstdc++
g++ program is used to link a C++ program, it will
normally automatically link against `libstdc++'. If
`libstdc++' is available as a shared library, and the
`-static' option is not used, then this will link against the
shared version of `libstdc++'. That is normally fine. However, it
is sometimes useful to freeze the version of `libstdc++' used by
the program without going all the way to a fully static link. The
`-static-libstdc++' option directs the g++ driver to
link `libstdc++' statically, without necessarily linking other
libraries statically.
-symbolic
-T script
-Xlinker option
If you want to pass an option that takes a separate argument, you must use `-Xlinker' twice, once for the option and once for the argument. For example, to pass `-assert definitions', you must write `-Xlinker -assert -Xlinker definitions'. It does not work to write `-Xlinker "-assert definitions"', because this passes the entire string as a single argument, which is not what the linker expects.
When using the GNU linker, it is usually more convenient to pass arguments to linker options using the `option=value' syntax than as separate arguments. For example, you can specify `-Xlinker -Map=output.map' rather than `-Xlinker -Map -Xlinker output.map'. Other linkers may not support this syntax for command-line options.
-Wl,option
-u symbol
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
These options specify directories to search for header files, for libraries and for parts of the compiler:
-Idir
If a standard system include directory, or a directory specified with `-isystem', is also specified with `-I', the `-I' option will be ignored. The directory will still be searched but as a system directory at its normal position in the system include chain. This is to ensure that GCC's procedure to fix buggy system headers and the ordering for the include_next directive are not inadvertently changed. If you really need to change the search order for system directories, use the `-nostdinc' and/or `-isystem' options.
-iquotedir
-Ldir
-Bprefix
The compiler driver program runs one or more of the subprograms `cpp', `cc1', `as' and `ld'. It tries prefix as a prefix for each program it tries to run, both with and without `machine/version/' (see section 3.16 Specifying Target Machine and Compiler Version).
For each subprogram to be run, the compiler driver first tries the
`-B' prefix, if any. If that name is not found, or if `-B'
was not specified, the driver tries two standard prefixes, which are
`/usr/lib/gcc/' and `/usr/local/lib/gcc/'. 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
PATH environment variable.
The compiler will check to see if the path provided by the `-B' refers to a directory, and if necessary it will add a directory separator character at the end of the path.
`-B' prefixes that effectively specify directory names also apply to libraries in the linker, because the compiler translates these options into `-L' options for the linker. They also apply to includes files in the preprocessor, because the compiler translates these options into `-isystem' options for the preprocessor. In this case, the compiler appends `include' to the prefix.
The run-time support file `libgcc.a' can also be searched for using the `-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 `-B' prefix is to use
the environment variable GCC_EXEC_PREFIX. See section 3.19 Environment Variables Affecting GCC.
As a special kludge, if the path provided by `-B' is `[dir/]stageN/', where N is a number in the range 0 to 9, then it will be replaced by `[dir/]include'. This is to help with boot-strapping the compiler.
-specs=file
--sysroot=dir
If you use both this option and the `-isysroot' option, then the `--sysroot' option will apply to libraries, but the `-isysroot' option will apply to header files.
The GNU linker (beginning with version 2.16) has the necessary support for this option. If your linker does not support this option, the header file aspect of `--sysroot' will still work, but the library aspect will not.
-I-
If additional directories are specified with `-I' options after the `-I-', these directories are searched for all `#include' directives. (Ordinarily all `-I' directories are used this way.)
In addition, the `-I-' option inhibits the use of the current directory (where the current input file came from) as the first search directory for `#include "file"'. There is no way to override this effect of `-I-'. With `-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.
`-I-' does not inhibit the use of the standard system directories for header files. Thus, `-I-' and `-nostdinc' are independent.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
gcc is a driver program. It performs its job by invoking a
sequence of other programs to do the work of compiling, assembling and
linking. GCC interprets its command-line parameters and uses these to
deduce which programs it should invoke, and which command-line options
it ought to place on their command lines. This behavior is controlled
by 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 behavior. The spec strings built into GCC can
be overridden by using the `-specs=' command-line switch to specify
a spec file.
Spec files are plaintext files that are used to construct spec strings. They consist of a sequence of directives separated by blank lines. The type of directive is determined by the first non-whitespace character on the line and it can be one of the following:
%command
%include <file>
%include_noerr <file>
%rename old_name new_name
*[spec_name]:
[suffix]:
.ZZ: z-compile -input %i |
This says that any input file whose name ends in `.ZZ' should be passed to the program `z-compile', which should be invoked with the command-line switch `-input' and with the result of performing the `%i' substitution. (See below.)
As an alternative to providing a spec string, the text that follows a suffix directive can be one of the following:
@language
.ZZ: @c++ |
Says that .ZZ files are, in fact, C++ source files.
#name
name compiler not installed on this system. |
GCC already has an extensive list of suffixes built into it. This directive will add an entry to the end of the list of suffixes, but since the list is searched from the end backwards, it is effectively possible to override earlier entries using this technique.
GCC has the following spec strings built into it. Spec files can override these strings or create their own. Note that individual targets can also add their own spec strings to this list.
asm Options to pass to the assembler
asm_final Options to pass to the assembler post-processor
cpp Options to pass to the C preprocessor
cc1 Options to pass to the C compiler
cc1plus Options to pass to the C++ compiler
endfile Object files to include at the end of the link
link Options to pass to the linker
lib Libraries to include on the command line to the linker
libgcc Decides which GCC support library to pass to the linker
linker Sets the name of the linker
predefines Defines to be passed to the C preprocessor
signed_char Defines to pass to CPP to say whether |
Here is a small example of a spec file:
%rename lib old_lib *lib: --start-group -lgcc -lc -leval1 --end-group %(old_lib) |
This example renames the spec called `lib' to `old_lib' and then overrides the previous definition of `lib' with a new one. The new definition adds in some extra command-line options before including the text of the old definition.
Spec strings are a list of command-line options to be passed to their corresponding program. In addition, the spec strings can contain `%'-prefixed sequences to substitute variable text or to conditionally insert text into the command line. Using these constructs it is possible to generate quite complex command lines.
Here is a table of all defined `%'-sequences for spec strings. Note that spaces are not generated automatically around the results of expanding these sequences. Therefore you can concatenate them together or combine them with constant text in a single argument.
%%
%i
%b
%B
%d
%gsuffix
%usuffix
%Usuffix
%jsuffix
HOST_BIT_BUCKET, if any, and if it is
writable, and if save-temps is off; otherwise, substitute the name
of a temporary file, just like `%u'. This temporary file is not
meant for communication between processes, but rather as a junk
disposal mechanism.
%|suffix
%msuffix
X}'
construct: see for example `f/lang-specs.h'.
%.SUFFIX
%w
%o
%O
%p
cpp.
%P
%I
GCC_EXEC_PREFIX),
`-isysroot' (made from TARGET_SYSTEM_ROOT),
`-isystem' (made from COMPILER_PATH and `-B' options)
and `-imultilib' as necessary.
%s
%T
%estr
%(name)
%[name]
%x{option}
%X
%Y
%Z
%a
asm spec. This is used to compute the
switches to be passed to the assembler.
%A
asm_final spec. This is a spec string for
passing switches to an assembler post-processor, if such a program is
needed.
%l
link spec. This is the spec for computing the
command line passed to the linker. Typically it will make use of the
`%L %G %S %D and %E' sequences.
%D
%L
lib spec. This is a spec string for deciding which
libraries should be included on the command line to the linker.
%G
libgcc spec. This is a spec string for deciding
which GCC support library should be included on the command line to the linker.
%S
startfile spec. This is a spec for deciding which
object files should be the first ones passed to the linker. Typically
this might be a file named `crt0.o'.
%E
endfile spec. This is a spec string that specifies
the last object files that will be passed to the linker.
%C
cpp spec. This is used to construct the arguments
to be passed to the C preprocessor.
%1
cc1 spec. This is used to construct the options to be
passed to the actual C compiler (`cc1').
%2
cc1plus spec. This is used to construct the options to be
passed to the actual C++ compiler (`cc1plus').
%*
%<S
-S from the command line. Note--this
command is position dependent. `%' commands in the spec string
before this one will see -S, `%' commands in the spec string
after this one will not.
%:function(args)
The following built-in spec functions are provided:
getenvgetenv spec function takes two arguments: an environment
variable name and a string. If the environment variable is not
defined, a fatal error is issued. Otherwise, the return value is the
value of the environment variable concatenated with the string. For
example, if TOPDIR is defined as `/path/to/top', then:
%:getenv(TOPDIR /include) |
expands to `/path/to/top/include'.
if-existsif-exists spec function takes one argument, an absolute
pathname to a file. If the file exists, if-exists returns the
pathname. Here is a small example of its usage:
*startfile: crt0%O%s %:if-exists(crti%O%s) crtbegin%O%s |
if-exists-elseif-exists-else spec function is similar to the if-exists
spec function, except that it takes two arguments. The first argument is
an absolute pathname to a file. If the file exists, if-exists-else
returns the pathname. If it does not exist, it returns the second argument.
This way, if-exists-else can be used to select one file or another,
based on the existence of the first. Here is a small example of its usage:
*startfile: crt0%O%s %:if-exists(crti%O%s) \ %:if-exists-else(crtbeginT%O%s crtbegin%O%s) |
replace-outfilereplace-outfile spec function takes two arguments. It looks for the
first argument in the outfiles array and replaces it with the second argument. Here
is a small example of its usage:
%{fgnu-runtime:%:replace-outfile(-lobjc -lobjc-gnu)}
|
print-asm-headerprint-asm-header function takes no arguments and simply
prints a banner like:
Assembler options ================= Use "-Wa,OPTION" to pass "OPTION" to the assembler. |
It is used to separate compiler options from assembler options in the `--target-help' output.
%{S}
-S switch, if that switch was given to GCC.
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 `%{foo}' would match the command-line option `-foo'
and would output the command line option `-foo'.
%W{S}
S} but mark last argument supplied within as a file to be
deleted on failure.
%{S*}
-S, but which also take an argument. This is used for
switches like `-o', `-D', `-I', etc.
GCC considers `-o foo' as being
one switch whose names starts with `o'. %{o*} would substitute this
text, including the space. Thus two arguments would be generated.
%{S*&T*}
S*}, but preserve order of S and T options
(the order of S and T in the spec is not significant).
There can be any number of ampersand-separated variables; for each the
wild card is optional. Useful for CPP as `%{D*&U*&A*}'.
%{S:X}
X, if the `-S' switch was given to GCC.
%{!S:X}
X, if the `-S' switch was not given to GCC.
%{S*:X}
X if one or more switches whose names start with
-S are specified to GCC. Normally X is substituted only
once, no matter how many such switches appeared. However, if %*
appears somewhere in X, then X will be substituted once
for each matching switch, with the %* replaced by the part of
that switch that matched the *.
%{.S:X}
X, if processing a file with suffix S.
%{!.S:X}
X, if not processing a file with suffix S.
%{,S:X}
X, if processing a file for language S.
%{!,S:X}
X, if not processing a file for language S.
%{S|P:X}
X if either -S or -P was given to
GCC. This may be combined with `!', `.', `,', and
* sequences as well, although they have a stronger binding than
the `|'. If %* appears in X, all of the
alternatives must be starred, and only the first matching alternative
is substituted.
For example, a spec string like this:
%{.c:-foo} %{!.c:-bar} %{.c|d:-baz} %{!.c|d:-boggle}
|
will output the following command-line options from the following input command-line options:
fred.c -foo -baz jim.d -bar -boggle -d fred.c -foo -baz -boggle -d jim.d -bar -baz -boggle |
%{S:X; T:Y; :D}
If S was given to GCC, substitutes X; else if T was
given to GCC, substitutes Y; else substitutes D. There can
be as many clauses as you need. This may be combined with .,
,, !, |, and * as needed.
The conditional text X in a %{S:X} or similar
construct may contain other nested `%' constructs or spaces, or
even newlines. They are processed as usual, as described above.
Trailing white space in X is ignored. White space may also
appear anywhere on the left side of the colon in these constructs,
except between . or * and the corresponding word.
The `-O', `-f', `-m', and `-W' switches are
handled specifically in these constructs. If another value of
`-O' or the negated form of a `-f', `-m', or
`-W' switch is found later in the command line, the earlier
switch value is ignored, except with {S*} where S is
just one letter, which passes all matching options.
The character `|' at the beginning of the predicate text is used to indicate that a command should be piped to the following command, but only if `-pipe' is specified.
It is built into GCC which switches take arguments and which do not. (You might think it would be useful to generalize this to allow each compiler's spec to say which switches take arguments. But this cannot be done in a consistent fashion. GCC cannot even decide which input files have been specified without knowing which switches take arguments, 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 `-l' are to be treated as compiler output files, and passed to the linker in their proper position among the other output files.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The usual way to run GCC is to run the executable called `gcc', or `<machine>-gcc' when cross-compiling, or `<machine>-gcc-<version>' to run a version other than the one that was installed last. Sometimes this is inconvenient, so GCC provides options that will switch to another cross-compiler or version.
-b machine
The value to use for machine is the same as was specified as the machine type when configuring GCC as a cross-compiler. For example, if a cross-compiler was configured with `configure arm-elf', meaning to compile for an arm processor with elf binaries, then you would specify `-b arm-elf' to run that cross compiler. Because there are other options beginning with `-b', the configuration must contain a hyphen, or `-b' alone should be one argument followed by the configuration in the next argument.
-V version
The `-V' and `-b' options work by running the `<machine>-gcc-<version>' executable, so there's no real reason to use them if you can just run that directly.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Earlier we discussed the standard option `-b' which chooses among different installed compilers for completely different target machines, such as VAX vs. 68000 vs. 80386.
In addition, each of these target machine types can have its own special options, starting with `-m', to choose among various hardware models or configurations--for example, 68010 vs 68020, floating coprocessor or none. A single installed version of the compiler can compile for any model or configuration, according to the options specified.
Some configurations of the compiler also support additional special options, usually for compatibility with other compilers on the same platform.
3.17.1 H8/300 Options 3.17.2 M32C Options 3.17.3 RX Options 3.17.4 SH Options
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
These `-m' options are defined for the H8/300 implementations:
-mrelax
ld and the H8/300' in Using ld, for a fuller description.
-mh
-ms
-mn
-ms2600
-mint32
int data 32 bits by default.
-malign-300
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
-mcpu=name
-msim
-memregs=number
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
These command line options are defined for RX targets:
-m64bit-doubles
-m32bit-doubles
double data type be 64-bits (`-m64bit-doubles')
or 32-bits (`-m32bit-doubles') in size. The default is
`-m32bit-doubles'. Note RX floating point hardware only
works on 32-bit values, which is why the default is
`-m32bit-doubles'.
-fpu
-nofpu
Floating point instructions will only be generated for 32-bit floating point values however, so if the `-m64bit-doubles' option is in use then the FPU hardware will not be used for doubles.
Note If the `-fpu' option is enabled then `-funsafe-math-optimizations' is also enabled automatically. This is because the RX FPU instructions are themselves unsafe.
-mcpu=name
-patch=name
The only difference between RX600 and RX610 is that the
RX610 does not support the MVTIPL instruction.
The RX200 series does not have a hardware floating point unit and so `-nofpu' is enabled by default when this type is selected.
-mbig-endian-data
-mlittle-endian-data
-msmall-data-limit=N
r13) is reserved for use pointing to this area, so
it is no longer available for use by the compiler. This could result
in slower and/or larger code if variables which once could have been
held in r13 are now pushed onto the stack.
Note, common variables (variables which have not been initialised) and constants are not placed into the small data area as they are assigned to other sections in the output executeable.
The default value is zero, which disables this feature. Note, this
feature is not enabled by default with higher optimization levels
(`-O2' etc) because of the potentially deterimental effects of
reserving register r13. It is up to the programmer to
experiment and discover whether this feature is of benefit to their
program.
-msim
-mno-sim
-mas100-syntax
-mno-as100-syntax
-mmax-constant-size=N
The value N can be between 0 and 4. A value of 0 (the default) or 4 means that constants of any size are allowed.
-mrelax
-mint-register=N
r13 will be reserved for ther exclusive use
of fast interrupt handlers. A value of 2 reserves r13 and
r12. A value of 3 reserves r13, r12 and
r11, and a value of 4 reserves r13 through r10.
A value of 0, the default, does not reserve any registers.
-msave-acc-in-interrupts
Note: The generic GCC command line `-ffixed-reg'
has special significance to the RX port when used with the
interrupt function attribute. This attribute indicates a
function intended to process fast interrupts. GCC will will ensure
that it only uses the registers r10, r11, r12
and/or r13 and only provided that the normal use of the
corresponding registers have been restricted via the
`-ffixed-reg' or `-mint-register' command line
options.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
These `-m' options are defined for the SH implementations:
-m1
-m2
-m2e
-m2a-nofpu
-m2a-single-only
-m2a-single
-m2a
-m3
-m3e
-m4-nofpu
-m4-single-only
-m4-single
-m4
-m4a-nofpu
-m4a-single-only
-m4a-single
-m4a
-m4al
-mb
-ml
-mdalign
-mrelax
-mbigtable
switch tables. The default is to use
16-bit offsets.
-mbitops
-mfmovd
fmovd. Check `-mdalign' for
alignment constraints.
-mhitachi
-mrenesas
-mno-renesas
-mnomacsave
MAC register as call-clobbered, even if
`-mhitachi' is given.
-mieee
-minline-ic_invalidate
-misize
-mpadstruct
-mspace
-mprefergot
-musermode
sh-*-linux*.
-multcost=number
-mdiv=strategy
-mdivsi3_libfunc=name
-mfixed-range=register-range
-madjust-unroll
-mindexed-addressing
-mgettrcost=number
-mpt-fixed
-minvalid-symbols
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
These machine-independent options control the interface conventions used in code generation.
Most of them have both positive and negative forms; the negative form of `-ffoo' would be `-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 `no-' or adding it.
-fbounds-check
-ftrapv
-fwrapv
-fexceptions
-fnon-call-exceptions
SIGALRM.
-funwind-tables
-fasynchronous-unwind-tables
-fpcc-struct-return
struct and union values in memory like
longer ones, rather than in registers. This convention is less
efficient, but it has the advantage of allowing intercallability between
GCC-compiled files and files compiled with other compilers, particularly
the Portable C Compiler (pcc).
The precise convention for returning structures in memory depends on the target configuration macros.
Short structures and unions are those whose size and alignment match that of some integer type.
Warning: code compiled with the `-fpcc-struct-return' switch is not binary compatible with code compiled with the `-freg-struct-return' switch. Use it to conform to a non-default application binary interface.
-freg-struct-return
struct and union values in registers when possible.
This is more efficient for small structures than
`-fpcc-struct-return'.
If you specify neither `-fpcc-struct-return' nor `-freg-struct-return', GCC defaults to whichever convention is standard for the target. If there is no standard convention, GCC defaults to `-fpcc-struct-return'