Google Git
Sign in
gfiber / toolchains / windcharger / 8dac4adf4c86b092f9ec9fcfbf656e6a2ad876b7 / . / share / info / gcc.info
blob: 2aa75bbe9caf36f70cc9b7051c0493bd3cbf5a73 [file] [log] [blame]
This is gcc.info, produced by makeinfo version 5.2 from gcc.texi.
Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
Free Software Foundation, Inc.
Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.3 or
any later version published by the Free Software Foundation; with the
Invariant Sections being "Funding Free Software", the Front-Cover Texts
being (a) (see below), and with the Back-Cover Texts being (b) (see
below). A copy of the license is included in the section entitled "GNU
Free Documentation License".
(a) The FSF's Front-Cover Text is:
A GNU Manual
(b) The FSF's Back-Cover Text is:
You have freedom to copy and modify this GNU Manual, like GNU software.
Copies published by the Free Software Foundation raise funds for GNU
development.
INFO-DIR-SECTION Software development
START-INFO-DIR-ENTRY
* gcc: (gcc). The GNU Compiler Collection.
* g++: (gcc). The GNU C++ compiler.
END-INFO-DIR-ENTRY
This file documents the use of the GNU compilers.
Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
Free Software Foundation, Inc.
Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.3 or
any later version published by the Free Software Foundation; with the
Invariant Sections being "Funding Free Software", the Front-Cover Texts
being (a) (see below), and with the Back-Cover Texts being (b) (see
below). A copy of the license is included in the section entitled "GNU
Free Documentation License".
(a) The FSF's Front-Cover Text is:
A GNU Manual
(b) The FSF's Back-Cover Text is:
You have freedom to copy and modify this GNU Manual, like GNU software.
Copies published by the Free Software Foundation raise funds for GNU
development.

File: gcc.info, Node: Top, Next: G++ and GCC, Up: (DIR)
Introduction
************
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 (crosstool-NG 1.20.0) version 4.6.4. 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. *Note Introduction: (gccint)Top.
* Menu:
* G++ and GCC:: You can compile C or C++ programs.
* Standards:: Language standards supported by GCC.
* Invoking GCC:: Command options supported by 'gcc'.
* C Implementation:: How GCC implements the ISO C specification.
* C Extensions:: GNU extensions to the C language family.
* C++ Implementation:: How GCC implements the ISO C++ specification.
* C++ Extensions:: GNU extensions to the C++ language.
* Objective-C:: GNU Objective-C runtime features.
* Compatibility:: Binary Compatibility
* Gcov:: 'gcov'--a test coverage program.
* Trouble:: If you have trouble using GCC.
* Bugs:: How, why and where to report bugs.
* Service:: How to find suppliers of support for GCC.
* Contributing:: How to contribute to testing and developing GCC.
* Funding:: How to help assure funding for free software.
* GNU Project:: The GNU Project and GNU/Linux.
* Copying:: 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:: People who have contributed to GCC.
* Option Index:: Index to command line options.
* Keyword Index:: Index of concepts and symbol names.

File: gcc.info, Node: G++ and GCC, Next: Standards, Up: Top
1 Programming Languages Supported by GCC
****************************************
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, Ada, and Go.
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.

File: gcc.info, Node: Standards, Next: Invoking GCC, Prev: G++ and GCC, Up: Top
2 Language Standards Supported by GCC
*************************************
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.
2.1 C language
==============
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=c90' 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). *Note Options
Controlling C Dialect: C Dialect Options.
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/gcc-4.6/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.
A fourth version of the C standard, known as "C1X", is under
development; GCC has limited preliminary support for parts of this
standard, enabled with '-std=c1x'.
By default, GCC provides some extensions to the C language that on rare
occasions conflict with the C standard. *Note Extensions to the C
Language Family: C Extensions. 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=gnu90' (for C90 with GNU extensions),
'-std=gnu99' (for C99 with GNU extensions) or '-std=gnu1x' (for C1X with
GNU extensions). The default, if no C language dialect options are
given, is '-std=gnu90'; 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 C90 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.
*Note Options Controlling C Dialect: C Dialect Options.
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). *Note Standard Libraries: 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>
2.2 C++ language
================
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/projects/cxx0x.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; *Note
Options Controlling C++ Dialect: C++ Dialect Options. 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'.
2.3 Objective-C and Objective-C++ languages
===========================================
GCC supports "traditional" Objective-C (also known as "Objective-C 1.0")
and contains support for the Objective-C exception and synchronization
syntax. It has also support for a number of "Objective-C 2.0" language
extensions, including properties, fast enumeration (only for
Objective-C), method attributes and the @optional and @required keywords
in protocols. GCC supports Objective-C++ and features available in
Objective-C are also available in Objective-C++.
GCC by default uses the GNU Objective-C runtime library, which is part
of GCC and is not the same as the Apple/NeXT Objective-C runtime library
used on Apple systems. There are a number of differences documented in
this manual. The options '-fgnu-runtime' and '-fnext-runtime' allow you
to switch between producing output that works with the GNU Objective-C
runtime library and output that works with the Apple/NeXT Objective-C
runtime library.
There is no formal written standard for Objective-C or Objective-C++.
The authoritative manual on traditional Objective-C (1.0) is
"Object-Oriented Programming and the Objective-C Language", available at
a number of web sites:
* <http://www.gnustep.org/resources/documentation/ObjectivCBook.pdf>
is the original NeXTstep document;
* <http://objc.toodarkpark.net> is the same document in another
format;
*
<http://developer.apple.com/mac/library/documentation/Cocoa/Conceptual/ObjectiveC/>
has an updated version but make sure you search for "Object
Oriented Programming and the Objective-C Programming Language 1.0",
not documentation on the newer "Objective-C 2.0" language
The Objective-C exception and synchronization syntax (that is, the
keywords @try, @throw, @catch, @finally and @synchronized) is supported
by GCC and is enabled with the option '-fobjc-exceptions'. The syntax
is briefly documented in this manual and in the Objective-C 2.0 manuals
from Apple.
The Objective-C 2.0 language extensions and features are automatically
enabled; they include properties (via the @property, @synthesize and
@dynamic keywords), fast enumeration (not available in Objective-C++),
attributes for methods (such as deprecated, noreturn, sentinel, format),
the unused attribute for method arguments, the @package keyword for
instance variables and the @optional and @required keywords in
protocols. You can disable all these Objective-C 2.0 language
extensions with the option '-fobjc-std=objc1', which causes the compiler
to recognize the same Objective-C language syntax recognized by GCC 4.0,
and to produce an error if one of the new features is used.
GCC has currently no support for non-fragile instance variables.
The authoritative manual on Objective-C 2.0 is available from Apple:
*
<http://developer.apple.com/mac/library/documentation/Cocoa/Conceptual/ObjectiveC/>
For more information concerning the history of Objective-C that is
available online, see <http://gcc.gnu.org/readings.html>
2.4 Go language
===============
The Go language continues to evolve as of this writing; see the current
language specifications (http://golang.org/doc/go_spec.html). At
present there are no specific versions of Go, and there is no way to
describe the language supported by GCC in terms of a specific version.
In general GCC tracks the evolving specification closely, and any given
release will support the language as of the date that the release was
frozen.
2.5 References for other languages
==================================
*Note GNAT Reference Manual: (gnat_rm)Top, for information on standard
conformance and compatibility of the Ada compiler.
*Note Standards: (gfortran)Standards, for details of standards
supported by GNU Fortran.
*Note Compatibility with the Java Platform: (gcj)Compatibility, for
details of compatibility between 'gcj' and the Java Platform.

File: gcc.info, Node: Invoking GCC, Next: C Implementation, Prev: Standards, Up: Top
3 GCC Command Options
*********************
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.
*Note Compiling C++ Programs: Invoking G++, 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.
*Note Option Index::, for an index to GCC's options.
* Menu:
* Option Summary:: Brief list of all options, without explanations.
* Overall Options:: Controlling the kind of output:
an executable, object files, assembler files,
or preprocessed source.
* Invoking G++:: Compiling C++ programs.
* C Dialect Options:: Controlling the variant of C language compiled.
* C++ Dialect Options:: Variations on C++.
* Objective-C and Objective-C++ Dialect Options:: Variations on Objective-C
and Objective-C++.
* Language Independent Options:: Controlling how diagnostics should be
formatted.
* Warning Options:: How picky should the compiler be?
* Debugging Options:: Symbol tables, measurements, and debugging dumps.
* Optimize Options:: How much optimization?
* Preprocessor Options:: Controlling header files and macro definitions.
Also, getting dependency information for Make.
* Assembler Options:: Passing options to the assembler.
* Link Options:: Specifying libraries and so on.
* Directory Options:: Where to find header files and libraries.
Where to find the compiler executable files.
* Spec Files:: How to pass switches to sub-processes.
* Target Options:: Running a cross-compiler, or an old version of GCC.
* Submodel Options:: Specifying minor hardware or convention variations,
such as 68010 vs 68020.
* Code Gen Options:: Specifying conventions for function calls, data layout
and register usage.
* Environment Variables:: Env vars that affect GCC.
* Precompiled Headers:: Compiling a header once, and using it many times.

File: gcc.info, Node: Option Summary, Next: Overall Options, Up: Invoking GCC
3.1 Option Summary
==================
Here is a summary of all the options, grouped by type. Explanations are
in the following sections.
_Overall Options_
*Note Options Controlling the Kind of Output: Overall Options.
-c -S -E -o FILE -no-canonical-prefixes
-pipe -pass-exit-codes
-x LANGUAGE -v -### --help[=CLASS[,...]] --target-help
--version -wrapper @FILE -fplugin=FILE -fplugin-arg-NAME=ARG
-fdump-ada-spec[-slim] -fdump-go-spec=FILE
_C Language Options_
*Note Options Controlling C Dialect: C Dialect Options.
-ansi -std=STANDARD -fgnu89-inline
-aux-info FILENAME
-fno-asm -fno-builtin -fno-builtin-FUNCTION
-fhosted -ffreestanding -fopenmp -fms-extensions -fplan9-extensions
-trigraphs -no-integrated-cpp -traditional -traditional-cpp
-fallow-single-precision -fcond-mismatch -flax-vector-conversions
-fsigned-bitfields -fsigned-char
-funsigned-bitfields -funsigned-char
_C++ Language Options_
*Note Options Controlling C++ Dialect: C++ Dialect Options.
-fabi-version=N -fno-access-control -fcheck-new
-fconserve-space -fconstexpr-depth=N -ffriend-injection
-fno-elide-constructors
-fno-enforce-eh-specs
-ffor-scope -fno-for-scope -fno-gnu-keywords
-fno-implicit-templates
-fno-implicit-inline-templates
-fno-implement-inlines -fms-extensions
-fno-nonansi-builtins -fnothrow-opt -fno-operator-names
-fno-optional-diags -fpermissive
-fno-pretty-templates
-frepo -fno-rtti -fstats -ftemplate-depth=N
-fno-threadsafe-statics -fuse-cxa-atexit -fno-weak -nostdinc++
-fno-default-inline -fvisibility-inlines-hidden
-fvisibility-ms-compat
-Wabi -Wconversion-null -Wctor-dtor-privacy
-Wnoexcept -Wnon-virtual-dtor -Wreorder
-Weffc++ -Wstrict-null-sentinel
-Wno-non-template-friend -Wold-style-cast
-Woverloaded-virtual -Wno-pmf-conversions
-Wsign-promo
_Objective-C and Objective-C++ Language Options_
*Note Options Controlling Objective-C and Objective-C++ Dialects:
Objective-C and Objective-C++ Dialect Options.
-fconstant-string-class=CLASS-NAME
-fgnu-runtime -fnext-runtime
-fno-nil-receivers
-fobjc-abi-version=N
-fobjc-call-cxx-cdtors
-fobjc-direct-dispatch
-fobjc-exceptions
-fobjc-gc
-fobjc-nilcheck
-fobjc-std=objc1
-freplace-objc-classes
-fzero-link
-gen-decls
-Wassign-intercept
-Wno-protocol -Wselector
-Wstrict-selector-match
-Wundeclared-selector
_Language Independent Options_
*Note Options to Control Diagnostic Messages Formatting: Language
Independent Options.
-fmessage-length=N
-fdiagnostics-show-location=[once|every-line]
-fno-diagnostics-show-option
_Warning Options_
*Note Options to Request or Suppress Warnings: Warning Options.
-fsyntax-only -fmax-errors=N -pedantic
-pedantic-errors
-w -Wextra -Wall -Waddress -Waggregate-return -Warray-bounds
-Wno-attributes -Wno-builtin-macro-redefined
-Wc++-compat -Wc++0x-compat -Wcast-align -Wcast-qual
-Wchar-subscripts -Wclobbered -Wcomment
-Wconversion -Wcoverage-mismatch -Wno-cpp -Wno-deprecated
-Wno-deprecated-declarations -Wdisabled-optimization
-Wno-div-by-zero -Wdouble-promotion -Wempty-body -Wenum-compare
-Wno-endif-labels -Werror -Werror=*
-Wfatal-errors -Wfloat-equal -Wformat -Wformat=2
-Wno-format-contains-nul -Wno-format-extra-args -Wformat-nonliteral
-Wformat-security -Wformat-y2k
-Wframe-larger-than=LEN -Wjump-misses-init -Wignored-qualifiers
-Wimplicit -Wimplicit-function-declaration -Wimplicit-int
-Winit-self -Winline
-Wno-int-to-pointer-cast -Wno-invalid-offsetof
-Winvalid-pch -Wlarger-than=LEN -Wunsafe-loop-optimizations
-Wlogical-op -Wlong-long
-Wmain -Wmissing-braces -Wmissing-field-initializers
-Wmissing-format-attribute -Wmissing-include-dirs
-Wno-mudflap
-Wno-multichar -Wnonnull -Wno-overflow
-Woverlength-strings -Wpacked -Wpacked-bitfield-compat -Wpadded
-Wparentheses -Wpedantic-ms-format -Wno-pedantic-ms-format
-Wpointer-arith -Wno-pointer-to-int-cast
-Wredundant-decls
-Wreturn-type -Wsequence-point -Wshadow
-Wsign-compare -Wsign-conversion -Wstack-protector
-Wstrict-aliasing -Wstrict-aliasing=n
-Wstrict-overflow -Wstrict-overflow=N
-Wsuggest-attribute=[pure|const|noreturn]
-Wswitch -Wswitch-default -Wswitch-enum -Wsync-nand
-Wsystem-headers -Wtrampolines -Wtrigraphs -Wtype-limits -Wundef
-Wuninitialized -Wunknown-pragmas -Wno-pragmas
-Wunsuffixed-float-constants -Wunused -Wunused-function
-Wunused-label -Wunused-parameter -Wno-unused-result -Wunused-value
-Wunused-variable -Wunused-but-set-parameter -Wunused-but-set-variable
-Wvariadic-macros -Wvla -Wvolatile-register-var -Wwrite-strings
_C and Objective-C-only Warning Options_
-Wbad-function-cast -Wmissing-declarations
-Wmissing-parameter-type -Wmissing-prototypes -Wnested-externs
-Wold-style-declaration -Wold-style-definition
-Wstrict-prototypes -Wtraditional -Wtraditional-conversion
-Wdeclaration-after-statement -Wpointer-sign
_Debugging Options_
*Note Options for Debugging Your Program or GCC: Debugging Options.
-dLETTERS -dumpspecs -dumpmachine -dumpversion
-fdbg-cnt-list -fdbg-cnt=COUNTER-VALUE-LIST
-fdump-noaddr -fdump-unnumbered -fdump-unnumbered-links
-fdump-translation-unit[-N]
-fdump-class-hierarchy[-N]
-fdump-ipa-all -fdump-ipa-cgraph -fdump-ipa-inline
-fdump-statistics
-fdump-tree-all
-fdump-tree-original[-N]
-fdump-tree-optimized[-N]
-fdump-tree-cfg -fdump-tree-vcg -fdump-tree-alias
-fdump-tree-ch
-fdump-tree-ssa[-N] -fdump-tree-pre[-N]
-fdump-tree-ccp[-N] -fdump-tree-dce[-N]
-fdump-tree-gimple[-raw] -fdump-tree-mudflap[-N]
-fdump-tree-dom[-N]
-fdump-tree-dse[-N]
-fdump-tree-phiprop[-N]
-fdump-tree-phiopt[-N]
-fdump-tree-forwprop[-N]
-fdump-tree-copyrename[-N]
-fdump-tree-nrv -fdump-tree-vect
-fdump-tree-sink
-fdump-tree-sra[-N]
-fdump-tree-forwprop[-N]
-fdump-tree-fre[-N]
-fdump-tree-vrp[-N]
-ftree-vectorizer-verbose=N
-fdump-tree-storeccp[-N]
-fdump-final-insns=FILE
-fcompare-debug[=OPTS] -fcompare-debug-second
-feliminate-dwarf2-dups -feliminate-unused-debug-types
-feliminate-unused-debug-symbols -femit-class-debug-always
-fenable-icf-debug
-fmem-report -fpre-ipa-mem-report -fpost-ipa-mem-report -fprofile-arcs
-frandom-seed=STRING -fsched-verbose=N
-fsel-sched-verbose -fsel-sched-dump-cfg -fsel-sched-pipelining-verbose
-fstack-usage -ftest-coverage -ftime-report -fvar-tracking
-fvar-tracking-assignments -fvar-tracking-assignments-toggle
-g -gLEVEL -gtoggle -gcoff -gdwarf-VERSION
-ggdb -gstabs -gstabs+ -gstrict-dwarf -gno-strict-dwarf
-gvms -gxcoff -gxcoff+
-fno-merge-debug-strings -fno-dwarf2-cfi-asm
-fdebug-prefix-map=OLD=NEW
-femit-struct-debug-baseonly -femit-struct-debug-reduced
-femit-struct-debug-detailed[=SPEC-LIST]
-p -pg -print-file-name=LIBRARY -print-libgcc-file-name
-print-multi-directory -print-multi-lib -print-multi-os-directory
-print-prog-name=PROGRAM -print-search-dirs -Q
-print-sysroot -print-sysroot-headers-suffix
-save-temps -save-temps=cwd -save-temps=obj -time[=FILE]
_Optimization Options_
*Note Options that Control Optimization: Optimize Options.
-falign-functions[=N] -falign-jumps[=N]
-falign-labels[=N] -falign-loops[=N] -fassociative-math
-fauto-inc-dec -fbranch-probabilities -fbranch-target-load-optimize
-fbranch-target-load-optimize2 -fbtr-bb-exclusive -fcaller-saves
-fcheck-data-deps -fcombine-stack-adjustments -fconserve-stack
-fcompare-elim -fcprop-registers -fcrossjumping
-fcse-follow-jumps -fcse-skip-blocks -fcx-fortran-rules
-fcx-limited-range
-fdata-sections -fdce -fdce -fdelayed-branch
-fdelete-null-pointer-checks -fdse -fdevirtualize -fdse
-fearly-inlining -fipa-sra -fexpensive-optimizations -ffast-math
-ffinite-math-only -ffloat-store -fexcess-precision=STYLE
-fforward-propagate -ffp-contract=STYLE -ffunction-sections
-fgcse -fgcse-after-reload -fgcse-las -fgcse-lm -fgraphite-identity
-fgcse-sm -fif-conversion -fif-conversion2 -findirect-inlining
-finline-functions -finline-functions-called-once -finline-limit=N
-finline-small-functions -fipa-cp -fipa-cp-clone -fipa-matrix-reorg
-fipa-pta -fipa-profile -fipa-pure-const -fipa-reference
-fipa-struct-reorg -fira-algorithm=ALGORITHM
-fira-region=REGION
-fira-loop-pressure -fno-ira-share-save-slots
-fno-ira-share-spill-slots -fira-verbose=N
-fivopts -fkeep-inline-functions -fkeep-static-consts
-floop-block -floop-flatten -floop-interchange -floop-strip-mine
-floop-parallelize-all -flto -flto-compression-level
-flto-partition=ALG -flto-report -fmerge-all-constants
-fmerge-constants -fmodulo-sched -fmodulo-sched-allow-regmoves
-fmove-loop-invariants fmudflap -fmudflapir -fmudflapth -fno-branch-count-reg
-fno-default-inline
-fno-defer-pop -fno-function-cse -fno-guess-branch-probability
-fno-inline -fno-math-errno -fno-peephole -fno-peephole2
-fno-sched-interblock -fno-sched-spec -fno-signed-zeros
-fno-toplevel-reorder -fno-trapping-math -fno-zero-initialized-in-bss
-fomit-frame-pointer -foptimize-register-move -foptimize-sibling-calls
-fpartial-inlining -fpeel-loops -fpredictive-commoning
-fprefetch-loop-arrays
-fprofile-correction -fprofile-dir=PATH -fprofile-generate
-fprofile-generate=PATH
-fprofile-use -fprofile-use=PATH -fprofile-values
-freciprocal-math -fregmove -frename-registers -freorder-blocks
-freorder-blocks-and-partition -freorder-functions
-frerun-cse-after-loop -freschedule-modulo-scheduled-loops
-frounding-math -fsched2-use-superblocks -fsched-pressure
-fsched-spec-load -fsched-spec-load-dangerous
-fsched-stalled-insns-dep[=N] -fsched-stalled-insns[=N]
-fsched-group-heuristic -fsched-critical-path-heuristic
-fsched-spec-insn-heuristic -fsched-rank-heuristic
-fsched-last-insn-heuristic -fsched-dep-count-heuristic
-fschedule-insns -fschedule-insns2 -fsection-anchors
-fselective-scheduling -fselective-scheduling2
-fsel-sched-pipelining -fsel-sched-pipelining-outer-loops
-fsignaling-nans -fsingle-precision-constant -fsplit-ivs-in-unroller
-fsplit-wide-types -fstack-protector -fstack-protector-all
-fstrict-aliasing -fstrict-overflow -fthread-jumps -ftracer
-ftree-bit-ccp
-ftree-builtin-call-dce -ftree-ccp -ftree-ch -ftree-copy-prop
-ftree-copyrename -ftree-dce -ftree-dominator-opts -ftree-dse
-ftree-forwprop -ftree-fre -ftree-loop-if-convert
-ftree-loop-if-convert-stores -ftree-loop-im
-ftree-phiprop -ftree-loop-distribution -ftree-loop-distribute-patterns
-ftree-loop-ivcanon -ftree-loop-linear -ftree-loop-optimize
-ftree-parallelize-loops=N -ftree-pre -ftree-pta -ftree-reassoc
-ftree-sink -ftree-sra -ftree-switch-conversion
-ftree-ter -ftree-vect-loop-version -ftree-vectorize -ftree-vrp
-funit-at-a-time -funroll-all-loops -funroll-loops
-funsafe-loop-optimizations -funsafe-math-optimizations -funswitch-loops
-fvariable-expansion-in-unroller -fvect-cost-model -fvpt -fweb
-fwhole-program -fwpa -fuse-linker-plugin
--param NAME=VALUE
-O -O0 -O1 -O2 -O3 -Os -Ofast
_Preprocessor Options_
*Note Options Controlling the Preprocessor: Preprocessor Options.
-AQUESTION=ANSWER
-A-QUESTION[=ANSWER]
-C -dD -dI -dM -dN
-DMACRO[=DEFN] -E -H
-idirafter DIR
-include FILE -imacros FILE
-iprefix FILE -iwithprefix DIR
-iwithprefixbefore DIR -isystem DIR
-imultilib DIR -isysroot DIR
-M -MM -MF -MG -MP -MQ -MT -nostdinc
-P -fworking-directory -remap
-trigraphs -undef -UMACRO -Wp,OPTION
-Xpreprocessor OPTION
_Assembler Option_
*Note Passing Options to the Assembler: Assembler Options.
-Wa,OPTION -Xassembler OPTION
_Linker Options_
*Note Options for Linking: Link Options.
OBJECT-FILE-NAME -lLIBRARY
-nostartfiles -nodefaultlibs -nostdlib -pie -rdynamic
-s -static -static-libgcc -static-libstdc++ -shared
-shared-libgcc -symbolic
-T SCRIPT -Wl,OPTION -Xlinker OPTION
-u SYMBOL
_Directory Options_
*Note Options for Directory Search: Directory Options.
-BPREFIX -IDIR -iplugindir=DIR
-iquoteDIR -LDIR -specs=FILE -I- -sysroot=DIR
_Machine Dependent Options_
*Note Hardware Models and Configurations: Submodel Options.
_ARC Options_
-EB -EL
-mmangle-cpu -mcpu=CPU -mtext=TEXT-SECTION
-mdata=DATA-SECTION -mrodata=READONLY-DATA-SECTION
_ARM Options_
-mapcs-frame -mno-apcs-frame
-mabi=NAME
-mapcs-stack-check -mno-apcs-stack-check
-mapcs-float -mno-apcs-float
-mapcs-reentrant -mno-apcs-reentrant
-msched-prolog -mno-sched-prolog
-mlittle-endian -mbig-endian -mwords-little-endian
-mfloat-abi=NAME -msoft-float -mhard-float -mfpe
-mfp16-format=NAME
-mthumb-interwork -mno-thumb-interwork
-mcpu=NAME -march=NAME -mfpu=NAME
-mstructure-size-boundary=N
-mabort-on-noreturn
-mlong-calls -mno-long-calls
-msingle-pic-base -mno-single-pic-base
-mpic-register=REG
-mnop-fun-dllimport
-mcirrus-fix-invalid-insns -mno-cirrus-fix-invalid-insns
-mpoke-function-name
-mthumb -marm
-mtpcs-frame -mtpcs-leaf-frame
-mcaller-super-interworking -mcallee-super-interworking
-mtp=NAME
-mword-relocations
-mfix-cortex-m3-ldrd
_AVR Options_
-mmcu=MCU -mno-interrupts
-mcall-prologues -mtiny-stack -mint8
_Blackfin Options_
-mcpu=CPU[-SIREVISION]
-msim -momit-leaf-frame-pointer -mno-omit-leaf-frame-pointer
-mspecld-anomaly -mno-specld-anomaly -mcsync-anomaly -mno-csync-anomaly
-mlow-64k -mno-low64k -mstack-check-l1 -mid-shared-library
-mno-id-shared-library -mshared-library-id=N
-mleaf-id-shared-library -mno-leaf-id-shared-library
-msep-data -mno-sep-data -mlong-calls -mno-long-calls
-mfast-fp -minline-plt -mmulticore -mcorea -mcoreb -msdram
-micplb
_CRIS Options_
-mcpu=CPU -march=CPU -mtune=CPU
-mmax-stack-frame=N -melinux-stacksize=N
-metrax4 -metrax100 -mpdebug -mcc-init -mno-side-effects
-mstack-align -mdata-align -mconst-align
-m32-bit -m16-bit -m8-bit -mno-prologue-epilogue -mno-gotplt
-melf -maout -melinux -mlinux -sim -sim2
-mmul-bug-workaround -mno-mul-bug-workaround
_CRX Options_
-mmac -mpush-args
_Darwin Options_
-all_load -allowable_client -arch -arch_errors_fatal
-arch_only -bind_at_load -bundle -bundle_loader
-client_name -compatibility_version -current_version
-dead_strip
-dependency-file -dylib_file -dylinker_install_name
-dynamic -dynamiclib -exported_symbols_list
-filelist -flat_namespace -force_cpusubtype_ALL
-force_flat_namespace -headerpad_max_install_names
-iframework
-image_base -init -install_name -keep_private_externs
-multi_module -multiply_defined -multiply_defined_unused
-noall_load -no_dead_strip_inits_and_terms
-nofixprebinding -nomultidefs -noprebind -noseglinkedit
-pagezero_size -prebind -prebind_all_twolevel_modules
-private_bundle -read_only_relocs -sectalign
-sectobjectsymbols -whyload -seg1addr
-sectcreate -sectobjectsymbols -sectorder
-segaddr -segs_read_only_addr -segs_read_write_addr
-seg_addr_table -seg_addr_table_filename -seglinkedit
-segprot -segs_read_only_addr -segs_read_write_addr
-single_module -static -sub_library -sub_umbrella
-twolevel_namespace -umbrella -undefined
-unexported_symbols_list -weak_reference_mismatches
-whatsloaded -F -gused -gfull -mmacosx-version-min=VERSION
-mkernel -mone-byte-bool
_DEC Alpha Options_
-mno-fp-regs -msoft-float -malpha-as -mgas
-mieee -mieee-with-inexact -mieee-conformant
-mfp-trap-mode=MODE -mfp-rounding-mode=MODE
-mtrap-precision=MODE -mbuild-constants
-mcpu=CPU-TYPE -mtune=CPU-TYPE
-mbwx -mmax -mfix -mcix
-mfloat-vax -mfloat-ieee
-mexplicit-relocs -msmall-data -mlarge-data
-msmall-text -mlarge-text
-mmemory-latency=TIME
_DEC Alpha/VMS Options_
-mvms-return-codes -mdebug-main=PREFIX -mmalloc64
_FR30 Options_
-msmall-model -mno-lsim
_FRV Options_
-mgpr-32 -mgpr-64 -mfpr-32 -mfpr-64
-mhard-float -msoft-float
-malloc-cc -mfixed-cc -mdword -mno-dword
-mdouble -mno-double
-mmedia -mno-media -mmuladd -mno-muladd
-mfdpic -minline-plt -mgprel-ro -multilib-library-pic
-mlinked-fp -mlong-calls -malign-labels
-mlibrary-pic -macc-4 -macc-8
-mpack -mno-pack -mno-eflags -mcond-move -mno-cond-move
-moptimize-membar -mno-optimize-membar
-mscc -mno-scc -mcond-exec -mno-cond-exec
-mvliw-branch -mno-vliw-branch
-mmulti-cond-exec -mno-multi-cond-exec -mnested-cond-exec
-mno-nested-cond-exec -mtomcat-stats
-mTLS -mtls
-mcpu=CPU
_GNU/Linux Options_
-mglibc -muclibc -mbionic -mandroid
-tno-android-cc -tno-android-ld
_H8/300 Options_
-mrelax -mh -ms -mn -mint32 -malign-300
_HPPA Options_
-march=ARCHITECTURE-TYPE
-mbig-switch -mdisable-fpregs -mdisable-indexing
-mfast-indirect-calls -mgas -mgnu-ld -mhp-ld
-mfixed-range=REGISTER-RANGE
-mjump-in-delay -mlinker-opt -mlong-calls
-mlong-load-store -mno-big-switch -mno-disable-fpregs
-mno-disable-indexing -mno-fast-indirect-calls -mno-gas
-mno-jump-in-delay -mno-long-load-store
-mno-portable-runtime -mno-soft-float
-mno-space-regs -msoft-float -mpa-risc-1-0
-mpa-risc-1-1 -mpa-risc-2-0 -mportable-runtime
-mschedule=CPU-TYPE -mspace-regs -msio -mwsio
-munix=UNIX-STD -nolibdld -static -threads
_i386 and x86-64 Options_
-mtune=CPU-TYPE -march=CPU-TYPE
-mfpmath=UNIT
-masm=DIALECT -mno-fancy-math-387
-mno-fp-ret-in-387 -msoft-float
-mno-wide-multiply -mrtd -malign-double
-mpreferred-stack-boundary=NUM
-mincoming-stack-boundary=NUM
-mcld -mcx16 -msahf -mmovbe -mcrc32 -mrecip
-mvzeroupper -mprefer-avx128
-mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -msse4 -mavx
-maes -mpclmul -mfsgsbase -mrdrnd -mf16c -mfused-madd
-msse4a -m3dnow -mpopcnt -mabm -mbmi -mtbm -mfma4 -mxop -mlwp
-mthreads -mno-align-stringops -minline-all-stringops
-minline-stringops-dynamically -mstringop-strategy=ALG
-mpush-args -maccumulate-outgoing-args -m128bit-long-double
-m96bit-long-double -mregparm=NUM -msseregparm
-mveclibabi=TYPE -mvect8-ret-in-mem
-mpc32 -mpc64 -mpc80 -mstackrealign
-momit-leaf-frame-pointer -mno-red-zone -mno-tls-direct-seg-refs
-mcmodel=CODE-MODEL -mabi=NAME
-m32 -m64 -mlarge-data-threshold=NUM
-msse2avx -mfentry -m8bit-idiv
-mavx256-split-unaligned-load -mavx256-split-unaligned-store
_i386 and x86-64 Windows Options_
-mconsole -mcygwin -mno-cygwin -mdll
-mnop-fun-dllimport -mthread
-municode -mwin32 -mwindows -fno-set-stack-executable
_IA-64 Options_
-mbig-endian -mlittle-endian -mgnu-as -mgnu-ld -mno-pic
-mvolatile-asm-stop -mregister-names -msdata -mno-sdata
-mconstant-gp -mauto-pic -mfused-madd
-minline-float-divide-min-latency
-minline-float-divide-max-throughput
-mno-inline-float-divide
-minline-int-divide-min-latency
-minline-int-divide-max-throughput
-mno-inline-int-divide
-minline-sqrt-min-latency -minline-sqrt-max-throughput
-mno-inline-sqrt
-mdwarf2-asm -mearly-stop-bits
-mfixed-range=REGISTER-RANGE -mtls-size=TLS-SIZE
-mtune=CPU-TYPE -milp32 -mlp64
-msched-br-data-spec -msched-ar-data-spec -msched-control-spec
-msched-br-in-data-spec -msched-ar-in-data-spec -msched-in-control-spec
-msched-spec-ldc -msched-spec-control-ldc
-msched-prefer-non-data-spec-insns -msched-prefer-non-control-spec-insns
-msched-stop-bits-after-every-cycle -msched-count-spec-in-critical-path
-msel-sched-dont-check-control-spec -msched-fp-mem-deps-zero-cost
-msched-max-memory-insns-hard-limit -msched-max-memory-insns=MAX-INSNS
_IA-64/VMS Options_
-mvms-return-codes -mdebug-main=PREFIX -mmalloc64
_LM32 Options_
-mbarrel-shift-enabled -mdivide-enabled -mmultiply-enabled
-msign-extend-enabled -muser-enabled
_M32R/D Options_
-m32r2 -m32rx -m32r
-mdebug
-malign-loops -mno-align-loops
-missue-rate=NUMBER
-mbranch-cost=NUMBER
-mmodel=CODE-SIZE-MODEL-TYPE
-msdata=SDATA-TYPE
-mno-flush-func -mflush-func=NAME
-mno-flush-trap -mflush-trap=NUMBER
-G NUM
_M32C Options_
-mcpu=CPU -msim -memregs=NUMBER
_M680x0 Options_
-march=ARCH -mcpu=CPU -mtune=TUNE
-m68000 -m68020 -m68020-40 -m68020-60 -m68030 -m68040
-m68060 -mcpu32 -m5200 -m5206e -m528x -m5307 -m5407
-mcfv4e -mbitfield -mno-bitfield -mc68000 -mc68020
-mnobitfield -mrtd -mno-rtd -mdiv -mno-div -mshort
-mno-short -mhard-float -m68881 -msoft-float -mpcrel
-malign-int -mstrict-align -msep-data -mno-sep-data
-mshared-library-id=n -mid-shared-library -mno-id-shared-library
-mxgot -mno-xgot
_M68hc1x Options_
-m6811 -m6812 -m68hc11 -m68hc12 -m68hcs12
-mauto-incdec -minmax -mlong-calls -mshort
-msoft-reg-count=COUNT
_MCore Options_
-mhardlit -mno-hardlit -mdiv -mno-div -mrelax-immediates
-mno-relax-immediates -mwide-bitfields -mno-wide-bitfields
-m4byte-functions -mno-4byte-functions -mcallgraph-data
-mno-callgraph-data -mslow-bytes -mno-slow-bytes -mno-lsim
-mlittle-endian -mbig-endian -m210 -m340 -mstack-increment
_MeP Options_
-mabsdiff -mall-opts -maverage -mbased=N -mbitops
-mc=N -mclip -mconfig=NAME -mcop -mcop32 -mcop64 -mivc2
-mdc -mdiv -meb -mel -mio-volatile -ml -mleadz -mm -mminmax
-mmult -mno-opts -mrepeat -ms -msatur -msdram -msim -msimnovec -mtf
-mtiny=N
_MicroBlaze Options_
-msoft-float -mhard-float -msmall-divides -mcpu=CPU
-mmemcpy -mxl-soft-mul -mxl-soft-div -mxl-barrel-shift
-mxl-pattern-compare -mxl-stack-check -mxl-gp-opt -mno-clearbss
-mxl-multiply-high -mxl-float-convert -mxl-float-sqrt
-mxl-mode-APP-MODEL
_MIPS Options_
-EL -EB -march=ARCH -mtune=ARCH
-mips1 -mips2 -mips3 -mips4 -mips32 -mips32r2
-mips64 -mips64r2
-mips16 -mno-mips16 -mflip-mips16
-minterlink-mips16 -mno-interlink-mips16
-mabi=ABI -mabicalls -mno-abicalls
-mshared -mno-shared -mplt -mno-plt -mxgot -mno-xgot
-mgp32 -mgp64 -mfp32 -mfp64 -mhard-float -msoft-float
-msingle-float -mdouble-float -mdsp -mno-dsp -mdspr2 -mno-dspr2
-mfpu=FPU-TYPE
-msmartmips -mno-smartmips
-mpaired-single -mno-paired-single -mdmx -mno-mdmx
-mips3d -mno-mips3d -mmt -mno-mt -mllsc -mno-llsc
-mlong64 -mlong32 -msym32 -mno-sym32
-GNUM -mlocal-sdata -mno-local-sdata
-mextern-sdata -mno-extern-sdata -mgpopt -mno-gopt
-membedded-data -mno-embedded-data
-muninit-const-in-rodata -mno-uninit-const-in-rodata
-mcode-readable=SETTING
-msplit-addresses -mno-split-addresses
-mexplicit-relocs -mno-explicit-relocs
-mcheck-zero-division -mno-check-zero-division
-mdivide-traps -mdivide-breaks
-mmemcpy -mno-memcpy -mlong-calls -mno-long-calls
-mmad -mno-mad -mfused-madd -mno-fused-madd -nocpp
-mfix-r4000 -mno-fix-r4000 -mfix-r4400 -mno-fix-r4400
-mfix-r10000 -mno-fix-r10000 -mfix-vr4120 -mno-fix-vr4120
-mfix-vr4130 -mno-fix-vr4130 -mfix-sb1 -mno-fix-sb1
-mflush-func=FUNC -mno-flush-func
-mbranch-cost=NUM -mbranch-likely -mno-branch-likely
-mfp-exceptions -mno-fp-exceptions
-mvr4130-align -mno-vr4130-align -msynci -mno-synci
-mrelax-pic-calls -mno-relax-pic-calls -mmcount-ra-address
_MMIX Options_
-mlibfuncs -mno-libfuncs -mepsilon -mno-epsilon -mabi=gnu
-mabi=mmixware -mzero-extend -mknuthdiv -mtoplevel-symbols
-melf -mbranch-predict -mno-branch-predict -mbase-addresses
-mno-base-addresses -msingle-exit -mno-single-exit
_MN10300 Options_
-mmult-bug -mno-mult-bug
-mno-am33 -mam33 -mam33-2 -mam34
-mtune=CPU-TYPE
-mreturn-pointer-on-d0
-mno-crt0 -mrelax -mliw
_PDP-11 Options_
-mfpu -msoft-float -mac0 -mno-ac0 -m40 -m45 -m10
-mbcopy -mbcopy-builtin -mint32 -mno-int16
-mint16 -mno-int32 -mfloat32 -mno-float64
-mfloat64 -mno-float32 -mabshi -mno-abshi
-mbranch-expensive -mbranch-cheap
-munix-asm -mdec-asm
_picoChip Options_
-mae=AE_TYPE -mvliw-lookahead=N
-msymbol-as-address -mno-inefficient-warnings
_PowerPC Options_ See RS/6000 and PowerPC Options.
_RS/6000 and PowerPC Options_
-mcpu=CPU-TYPE
-mtune=CPU-TYPE
-mcmodel=CODE-MODEL
-mpower -mno-power -mpower2 -mno-power2
-mpowerpc -mpowerpc64 -mno-powerpc
-maltivec -mno-altivec
-mpowerpc-gpopt -mno-powerpc-gpopt
-mpowerpc-gfxopt -mno-powerpc-gfxopt
-mmfcrf -mno-mfcrf -mpopcntb -mno-popcntb -mpopcntd -mno-popcntd
-mfprnd -mno-fprnd
-mcmpb -mno-cmpb -mmfpgpr -mno-mfpgpr -mhard-dfp -mno-hard-dfp
-mnew-mnemonics -mold-mnemonics
-mfull-toc -mminimal-toc -mno-fp-in-toc -mno-sum-in-toc
-m64 -m32 -mxl-compat -mno-xl-compat -mpe
-malign-power -malign-natural
-msoft-float -mhard-float -mmultiple -mno-multiple
-msingle-float -mdouble-float -msimple-fpu
-mstring -mno-string -mupdate -mno-update
-mavoid-indexed-addresses -mno-avoid-indexed-addresses
-mfused-madd -mno-fused-madd -mbit-align -mno-bit-align
-mstrict-align -mno-strict-align -mrelocatable
-mno-relocatable -mrelocatable-lib -mno-relocatable-lib
-mtoc -mno-toc -mlittle -mlittle-endian -mbig -mbig-endian
-mdynamic-no-pic -maltivec -mswdiv -msingle-pic-base
-mprioritize-restricted-insns=PRIORITY
-msched-costly-dep=DEPENDENCE_TYPE
-minsert-sched-nops=SCHEME
-mcall-sysv -mcall-netbsd
-maix-struct-return -msvr4-struct-return
-mabi=ABI-TYPE -msecure-plt -mbss-plt
-mblock-move-inline-limit=NUM
-misel -mno-isel
-misel=yes -misel=no
-mspe -mno-spe
-mspe=yes -mspe=no
-mpaired
-mgen-cell-microcode -mwarn-cell-microcode
-mvrsave -mno-vrsave
-mmulhw -mno-mulhw
-mdlmzb -mno-dlmzb
-mfloat-gprs=yes -mfloat-gprs=no -mfloat-gprs=single -mfloat-gprs=double
-mprototype -mno-prototype
-msim -mmvme -mads -myellowknife -memb -msdata
-msdata=OPT -mvxworks -G NUM -pthread
-mrecip -mrecip=OPT -mno-recip -mrecip-precision
-mno-recip-precision
-mveclibabi=TYPE -mfriz -mno-friz
_RX Options_
-m64bit-doubles -m32bit-doubles -fpu -nofpu
-mcpu=
-mbig-endian-data -mlittle-endian-data
-msmall-data
-msim -mno-sim
-mas100-syntax -mno-as100-syntax
-mrelax
-mmax-constant-size=
-mint-register=
-msave-acc-in-interrupts
_S/390 and zSeries Options_
-mtune=CPU-TYPE -march=CPU-TYPE
-mhard-float -msoft-float -mhard-dfp -mno-hard-dfp
-mlong-double-64 -mlong-double-128
-mbackchain -mno-backchain -mpacked-stack -mno-packed-stack
-msmall-exec -mno-small-exec -mmvcle -mno-mvcle
-m64 -m31 -mdebug -mno-debug -mesa -mzarch
-mtpf-trace -mno-tpf-trace -mfused-madd -mno-fused-madd
-mwarn-framesize -mwarn-dynamicstack -mstack-size -mstack-guard
_Score Options_
-meb -mel
-mnhwloop
-muls
-mmac
-mscore5 -mscore5u -mscore7 -mscore7d
_SH Options_
-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
-m5-64media -m5-64media-nofpu
-m5-32media -m5-32media-nofpu
-m5-compact -m5-compact-nofpu
-mb -ml -mdalign -mrelax
-mbigtable -mfmovd -mhitachi -mrenesas -mno-renesas -mnomacsave
-mieee -mno-ieee -mbitops -misize -minline-ic_invalidate -mpadstruct
-mspace -mprefergot -musermode -multcost=NUMBER -mdiv=STRATEGY
-mdivsi3_libfunc=NAME -mfixed-range=REGISTER-RANGE
-madjust-unroll -mindexed-addressing -mgettrcost=NUMBER -mpt-fixed
-maccumulate-outgoing-args -minvalid-symbols
_Solaris 2 Options_
-mimpure-text -mno-impure-text
-threads -pthreads -pthread
_SPARC Options_
-mcpu=CPU-TYPE
-mtune=CPU-TYPE
-mcmodel=CODE-MODEL
-m32 -m64 -mapp-regs -mno-app-regs
-mfaster-structs -mno-faster-structs
-mfpu -mno-fpu -mhard-float -msoft-float
-mhard-quad-float -msoft-quad-float
-mlittle-endian
-mstack-bias -mno-stack-bias
-munaligned-doubles -mno-unaligned-doubles
-mv8plus -mno-v8plus -mvis -mno-vis
-mfix-at697f
_SPU Options_
-mwarn-reloc -merror-reloc
-msafe-dma -munsafe-dma
-mbranch-hints
-msmall-mem -mlarge-mem -mstdmain
-mfixed-range=REGISTER-RANGE
-mea32 -mea64
-maddress-space-conversion -mno-address-space-conversion
-mcache-size=CACHE-SIZE
-matomic-updates -mno-atomic-updates
_System V Options_
-Qy -Qn -YP,PATHS -Ym,DIR
_V850 Options_
-mlong-calls -mno-long-calls -mep -mno-ep
-mprolog-function -mno-prolog-function -mspace
-mtda=N -msda=N -mzda=N
-mapp-regs -mno-app-regs
-mdisable-callt -mno-disable-callt
-mv850e2v3
-mv850e2
-mv850e1 -mv850es
-mv850e
-mv850 -mbig-switch
_VAX Options_
-mg -mgnu -munix
_VxWorks Options_
-mrtp -non-static -Bstatic -Bdynamic
-Xbind-lazy -Xbind-now
_x86-64 Options_ See i386 and x86-64 Options.
_Xstormy16 Options_
-msim
_Xtensa Options_
-mconst16 -mno-const16
-mfused-madd -mno-fused-madd
-mforce-no-pic
-mserialize-volatile -mno-serialize-volatile
-mtext-section-literals -mno-text-section-literals
-mtarget-align -mno-target-align
-mlongcalls -mno-longcalls
_zSeries Options_ See S/390 and zSeries Options.
_Code Generation Options_
*Note Options for Code Generation Conventions: Code Gen Options.
-fcall-saved-REG -fcall-used-REG
-ffixed-REG -fexceptions
-fnon-call-exceptions -funwind-tables
-fasynchronous-unwind-tables
-finhibit-size-directive -finstrument-functions
-finstrument-functions-exclude-function-list=SYM,SYM,...
-finstrument-functions-exclude-file-list=FILE,FILE,...
-fno-common -fno-ident
-fpcc-struct-return -fpic -fPIC -fpie -fPIE
-fno-jump-tables
-frecord-gcc-switches
-freg-struct-return -fshort-enums
-fshort-double -fshort-wchar
-fverbose-asm -fpack-struct[=N] -fstack-check
-fstack-limit-register=REG -fstack-limit-symbol=SYM
-fno-stack-limit -fsplit-stack
-fleading-underscore -ftls-model=MODEL
-ftrapv -fwrapv -fbounds-check
-fvisibility -fstrict-volatile-bitfields
* Menu:
* Overall Options:: Controlling the kind of output:
an executable, object files, assembler files,
or preprocessed source.
* C Dialect Options:: Controlling the variant of C language compiled.
* C++ Dialect Options:: Variations on C++.
* Objective-C and Objective-C++ Dialect Options:: Variations on Objective-C
and Objective-C++.
* Language Independent Options:: Controlling how diagnostics should be
formatted.
* Warning Options:: How picky should the compiler be?
* Debugging Options:: Symbol tables, measurements, and debugging dumps.
* Optimize Options:: How much optimization?
* Preprocessor Options:: Controlling header files and macro definitions.
Also, getting dependency information for Make.
* Assembler Options:: Passing options to the assembler.
* Link Options:: Specifying libraries and so on.
* Directory Options:: Where to find header files and libraries.
Where to find the compiler executable files.
* Spec Files:: How to pass switches to sub-processes.
* Target Options:: Running a cross-compiler, or an old version of GCC.

File: gcc.info, Node: Overall Options, Next: Invoking G++, Prev: Option Summary, Up: Invoking GCC
3.2 Options Controlling the Kind of Output
==========================================
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'
C source code which must be preprocessed.
'FILE.i'
C source code which should not be preprocessed.
'FILE.ii'
C++ source code which should not be preprocessed.
'FILE.m'
Objective-C source code. Note that you must link with the
'libobjc' library to make an Objective-C program work.
'FILE.mi'
Objective-C source code which should not be preprocessed.
'FILE.mm'
'FILE.M'
Objective-C++ source code. Note that you must link with the
'libobjc' library to make an Objective-C++ program work. Note that
'.M' refers to a literal capital M.
'FILE.mii'
Objective-C++ source code which should not be preprocessed.
'FILE.h'
C, C++, Objective-C or Objective-C++ header file to be turned into
a precompiled header (default), or C, C++ header file to be turned
into an Ada spec (via the '-fdump-ada-spec' switch).
'FILE.cc'
'FILE.cp'
'FILE.cxx'
'FILE.cpp'
'FILE.CPP'
'FILE.c++'
'FILE.C'
C++ source code which must be preprocessed. Note that in '.cxx',
the last two letters must both be literally 'x'. Likewise, '.C'
refers to a literal capital C.
'FILE.mm'
'FILE.M'
Objective-C++ source code which must be preprocessed.
'FILE.mii'
Objective-C++ source code which should not be preprocessed.
'FILE.hh'
'FILE.H'
'FILE.hp'
'FILE.hxx'
'FILE.hpp'
'FILE.HPP'
'FILE.h++'
'FILE.tcc'
C++ header file to be turned into a precompiled header or Ada spec.
'FILE.f'
'FILE.for'
'FILE.ftn'
Fixed form Fortran source code which should not be preprocessed.
'FILE.F'
'FILE.FOR'
'FILE.fpp'
'FILE.FPP'
'FILE.FTN'
Fixed form Fortran source code which must be preprocessed (with the
traditional preprocessor).
'FILE.f90'
'FILE.f95'
'FILE.f03'
'FILE.f08'
Free form Fortran source code which should not be preprocessed.
'FILE.F90'
'FILE.F95'
'FILE.F03'
'FILE.F08'
Free form Fortran source code which must be preprocessed (with the
traditional preprocessor).
'FILE.go'
Go source code.
'FILE.ads'
Ada source code file which contains a library unit declaration (a
declaration of a package, subprogram, or generic, or a generic
instantiation), or a library unit renaming declaration (a package,
generic, or subprogram renaming declaration). Such files are also
called "specs".
'FILE.adb'
Ada source code file containing a library unit body (a subprogram
or package body). Such files are also called "bodies".
'FILE.s'
Assembler code.
'FILE.S'
'FILE.sx'
Assembler code which must be preprocessed.
'OTHER'
An object file to be fed straight into linking. Any file name with
no recognized suffix is treated this way.
You can specify the input language explicitly with the '-x' option:
'-x LANGUAGE'
Specify explicitly the LANGUAGE for the following input files
(rather than letting the compiler choose a default based on the
file name suffix). This option applies to all following input
files until the next '-x' option. Possible values for LANGUAGE
are:
c c-header 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
go
java
'-x none'
Turn off any specification of a language, so that subsequent files
are handled according to their file name suffixes (as they are if
'-x' has not been used at all).
'-pass-exit-codes'
Normally the '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'
Compile or assemble the source files, but do not link. The linking
stage simply is not done. The ultimate output is in the form of an
object file for each source file.
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'
Stop after the stage of compilation proper; do not assemble. The
output is in the form of an assembler code file for each
non-assembler input file specified.
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'
Stop after the preprocessing stage; do not run the compiler proper.
The output is in the form of preprocessed source code, which is
sent to the standard output.
Input files which don't require preprocessing are ignored.
'-o FILE'
Place output in file FILE. This applies regardless to whatever
sort of output is being produced, whether it be an executable file,
an object file, an assembler file or preprocessed C code.
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'
Print (on standard error output) the commands executed to run the
stages of compilation. Also print the version number of the
compiler driver program and of the preprocessor and the compiler
proper.
'-###'
Like '-v' except the commands are not executed and arguments are
quoted unless they contain only alphanumeric characters or './-_'.
This is useful for shell scripts to capture the driver-generated
command lines.
'-pipe'
Use pipes rather than temporary files for communication between the
various stages of compilation. This fails to work on some systems
where the assembler is unable to read from a pipe; but the GNU
assembler has no trouble.
'--help'
Print (on the standard output) a description of the command line
options understood by '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'
Print (on the standard output) a description of target-specific
command line options for each tool. For some targets extra
target-specific information may also be printed.
'--help={CLASS|[^]QUALIFIER}[,...]'
Print (on the standard output) a description of the command line
options understood by the compiler that fit into all specified
classes and qualifiers. These are the supported classes:
'optimizers'
This will display all of the optimization options supported by
the compiler.
'warnings'
This will display all of the options controlling warning
messages produced by the compiler.
'target'
This will display target-specific options. Unlike the
'--target-help' option however, target-specific options of the
linker and assembler will not be displayed. This is because
those tools do not currently support the extended '--help='
syntax.
'params'
This will display the values recognized by the '--param'
option.
LANGUAGE
This will display the options supported for LANGUAGE, where
LANGUAGE is the name of one of the languages supported in this
version of GCC.
'common'
This will display the options that are common to all
languages.
These are the supported qualifiers:
'undocumented'
Display only those options which are undocumented.
'joined'
Display options which take an argument that appears after an
equal sign in the same continuous piece of text, such as:
'--help=target'.
'separate'
Display options which take an argument that appears as a
separate word following the original option, such as: '-o
output-file'.
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'
Do not expand any symbolic links, resolve references to '/../' or
'/./', or make the path absolute when generating a relative prefix.
'--version'
Display the version number and copyrights of the invoked GCC.
'-wrapper'
Invoke all subcommands under a wrapper program. The name of the
wrapper program and its parameters are passed as a comma separated
list.
gcc -c t.c -wrapper gdb,--args
This will invoke all subprograms of 'gcc' under 'gdb --args', thus
the invocation of 'cc1' will be 'gdb --args cc1 ...'.
'-fplugin=NAME.so'
Load the plugin code in file NAME.so, assumed to be a shared object
to be dlopen'd by the compiler. The base name of the shared object
file is used to identify the plugin for the purposes of argument
parsing (See '-fplugin-arg-NAME-KEY=VALUE' below). Each plugin
should define the callback functions specified in the Plugins API.
'-fplugin-arg-NAME-KEY=VALUE'
Define an argument called KEY with a value of VALUE for the plugin
called NAME.
'-fdump-ada-spec[-slim]'
For C and C++ source and include files, generate corresponding Ada
specs. *Note (gnat_ugn)Generating Ada Bindings for C and C++
headers::, which provides detailed documentation on this feature.
'-fdump-go-spec=FILE'
For input files in any language, generate corresponding Go
declarations in FILE. This generates Go 'const', 'type', 'var',
and 'func' declarations which may be a useful way to start writing
a Go interface to code written in some other language.
'@FILE'
Read command-line options from FILE. The options read are inserted
in place of the original @FILE option. If FILE does not exist, or
cannot be read, then the option will be treated literally, and not
removed.
Options in FILE are separated by whitespace. A whitespace
character may be included in an option by surrounding the entire
option in either single or double quotes. Any character (including
a backslash) may be included by prefixing the character to be
included with a backslash. The FILE may itself contain additional
@FILE options; any such options will be processed recursively.

File: gcc.info, Node: Invoking G++, Next: C Dialect Options, Prev: Overall Options, Up: Invoking GCC
3.3 Compiling C++ Programs
==========================
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. *Note
Options Controlling C Dialect: C Dialect Options, for explanations of
options for languages related to C. *Note Options Controlling C++
Dialect: C++ Dialect Options, for explanations of options that are
meaningful only for C++ programs.

File: gcc.info, Node: C Dialect Options, Next: C++ Dialect Options, Prev: Invoking G++, Up: Invoking GCC
3.4 Options Controlling C Dialect
=================================
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'
In C mode, this is equivalent to '-std=c90'. In C++ mode, it is
equivalent to '-std=c++98'.
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'. *Note Warning Options::.
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. *Note Other built-in functions
provided by GCC: Other Builtins, for details of the functions
affected.
'-std='
Determine the language standard. *Note Language Standards
Supported by GCC: Standards, for details of these standard
versions. This option is currently only supported when compiling C
or C++.
The compiler can accept several base standards, such as 'c90' or
'c++98', and GNU dialects of those standards, such as 'gnu90' 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=c90' 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=gnu90 -pedantic' would warn about C++ style '//'
comments, while '-std=gnu99 -pedantic' would not.
A value for this option must be provided; possible values are
'c90'
'c89'
'iso9899:1990'
Support all ISO C90 programs (certain GNU extensions that
conflict with ISO C90 are disabled). Same as '-ansi' for C
code.
'iso9899:199409'
ISO C90 as modified in amendment 1.
'c99'
'c9x'
'iso9899:1999'
'iso9899:199x'
ISO C99. Note that this standard is not yet fully supported;
see <http://gcc.gnu.org/gcc-4.6/c99status.html> for more
information. The names 'c9x' and 'iso9899:199x' are
deprecated.
'c1x'
ISO C1X, the draft of the next revision of the ISO C standard.
Support is limited and experimental and features enabled by
this option may be changed or removed if changed in or removed
from the standard draft.
'gnu90'
'gnu89'
GNU dialect of ISO C90 (including some C99 features). This is
the default for C code.
'gnu99'
'gnu9x'
GNU dialect of ISO C99. When ISO C99 is fully implemented in
GCC, this will become the default. The name 'gnu9x' is
deprecated.
'gnu1x'
GNU dialect of ISO C1X. Support is limited and experimental
and features enabled by this option may be changed or removed
if changed in or removed from the standard draft.
'c++98'
The 1998 ISO C++ standard plus amendments. Same as '-ansi'
for C++ code.
'gnu++98'
GNU dialect of '-std=c++98'. This is the default for C++
code.
'c++0x'
The working draft of the upcoming ISO C++0x standard. This
option enables experimental features that are likely to be
included in C++0x. The working draft is constantly changing,
and any feature that is enabled by this flag may be removed
from future versions of GCC if it is not part of the C++0x
standard.
'gnu++0x'
GNU dialect of '-std=c++0x'. This option enables experimental
features that may be removed in future versions of GCC.
'-fgnu89-inline'
The option '-fgnu89-inline' tells GCC to use the traditional GNU
semantics for 'inline' functions when in C99 mode. *Note An Inline
Function is As Fast As a Macro: Inline. 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 (*note
Function Attributes::).
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 '-std=c90' or
'-std=gnu90' mode.
The preprocessor macros '__GNUC_GNU_INLINE__' and
'__GNUC_STDC_INLINE__' may be used to check which semantics are in
effect for 'inline' functions. *Note (cpp)Common Predefined
Macros::.
'-aux-info FILENAME'
Output to the given filename prototyped declarations for all
functions declared and/or defined in a translation unit, including
those in header files. This option is silently ignored in any
language other than C.
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'
Do not recognize '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'
Don't recognize built-in functions that do not begin with
'__builtin_' as prefix. *Note Other built-in functions provided by
GCC: Other Builtins, for details of the functions affected,
including those which are not built-in functions when '-ansi' or
'-std' options for strict ISO C conformance are used because they
do not have an ISO standard meaning.
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'.
*Note Language Standards Supported by GCC: Standards, for details
of freestanding and hosted environments.
'-fopenmp'
Enable handling of OpenMP directives '#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'
Accept some non-standard constructs used in Microsoft header files.
In C++ code, this allows member names in structures to be similar
to previous types declarations.
typedef int UOW;
struct ABC {
UOW UOW;
};
Some cases of unnamed fields in structures and unions are only
accepted with this option. *Note Unnamed struct/union fields
within structs/unions: Unnamed Fields, for details.
'-fplan9-extensions'
Accept some non-standard constructs used in Plan 9 code.
This enables '-fms-extensions', permits passing pointers to
structures with anonymous fields to functions which expect pointers
to elements of the type of the field, and permits referring to
anonymous fields declared using a typedef. *Note Unnamed
struct/union fields within structs/unions: Unnamed Fields, for
details. This is only supported for C, not C++.
'-trigraphs'
Support ISO C trigraphs. The '-ansi' option (and '-std' options
for strict ISO C conformance) implies '-trigraphs'.
'-no-integrated-cpp'
Performs a compilation in two passes: preprocessing and compiling.
This option allows a user supplied "cc1", "cc1plus", or "cc1obj"
via the '-B' option. The user supplied compilation step can then
add in an additional preprocessing step after normal preprocessing
but before compiling. The default is to use the integrated cpp
(internal cpp)
The semantics of this option will change if "cc1", "cc1plus", and
"cc1obj" are merged.
'-traditional'
'-traditional-cpp'
Formerly, these options caused GCC to attempt to emulate a
pre-standard C compiler. They are now only supported with the '-E'
switch. The preprocessor continues to support a pre-standard mode.
See the GNU CPP manual for details.
'-fcond-mismatch'
Allow conditional expressions with mismatched types in the second
and third arguments. The value of such an expression is void.
This option is not supported for C++.
'-flax-vector-conversions'
Allow implicit conversions between vectors with differing numbers
of elements and/or incompatible element types. This option should
not be used for new code.
'-funsigned-char'
Let the type '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'
Let the type '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'
These options control whether a bit-field is signed or unsigned,
when the declaration does not use either '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.

File: gcc.info, Node: C++ Dialect Options, Next: Objective-C and Objective-C++ Dialect Options, Prev: C Dialect Options, Up: Invoking GCC
3.5 Options Controlling C++ Dialect
===================================
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'
Use version N of the C++ ABI. Version 2 is the version of the C++
ABI that first appeared in G++ 3.4. Version 1 is the version of
the C++ ABI that first appeared in G++ 3.2. Version 0 will always
be the version that conforms most closely to the C++ ABI
specification. Therefore, the ABI obtained using version 0 will
change as ABI bugs are fixed.
The default is version 2.
Version 3 corrects an error in mangling a constant address as a
template argument.
Version 4 implements a standard mangling for vector types.
Version 5 corrects the mangling of attribute const/volatile on
function pointer types, decltype of a plain decl, and use of a
function parameter in the declaration of another parameter.
See also '-Wabi'.
'-fno-access-control'
Turn off all access checking. This switch is mainly useful for
working around bugs in the access control code.
'-fcheck-new'
Check that the pointer returned by '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'
Put uninitialized or runtime-initialized global variables into the
common segment, as C does. This saves space in the executable at
the cost of not diagnosing duplicate definitions. If you compile
with this flag and your program mysteriously crashes after '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.
'-fconstexpr-depth=N'
Set the maximum nested evaluation depth for C++0x constexpr
functions to N. A limit is needed to detect endless recursion
during constant expression evaluation. The minimum specified by
the standard is 512.
'-fno-deduce-init-list'
Disable deduction of a template type parameter as
std::initializer_list from a brace-enclosed initializer list, i.e.
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'
Inject friend functions into the enclosing namespace, so that they
are visible outside the scope of the class in which they are
declared. Friend functions were documented to work this way in the
old Annotated C++ Reference Manual, and versions of G++ before 4.1
always worked that way. However, in ISO C++ a friend function
which is not declared in an enclosing scope can only be found using
argument dependent lookup. This option causes friends to be
injected as they were in earlier releases.
This option is for compatibility, and may be removed in a future
release of G++.
'-fno-elide-constructors'
The C++ standard allows an implementation to omit creating a
temporary which is only used to initialize another object of the
same type. Specifying this option disables that optimization, and
forces G++ to call the copy constructor in all cases.
'-fno-enforce-eh-specs'
Don't generate code to check for violation of exception
specifications at runtime. This option violates the C++ standard,
but may be useful for reducing code size in production builds, much
like defining 'NDEBUG'. This does not give user code permission to
throw exceptions in violation of the exception specifications; the
compiler will still optimize based on the specifications, so
throwing an unexpected exception will result in undefined behavior.
'-ffor-scope'
'-fno-for-scope'
If '-ffor-scope' is specified, the scope of variables declared in a
for-init-statement is limited to the 'for' loop itself, as
specified by the C++ standard. If '-fno-for-scope' is specified,
the scope of variables declared in a for-init-statement extends to
the end of the enclosing scope, as was the case in old versions of
G++, and other (traditional) implementations of C++.
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'
Do not recognize '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'
Never emit code for non-inline templates which are instantiated
implicitly (i.e. by use); only emit code for explicit
instantiations. *Note Template Instantiation::, for more
information.
'-fno-implicit-inline-templates'
Don't emit code for implicit instantiations of inline templates,
either. The default is to handle inlines differently so that
compiles with and without optimization will need the same set of
explicit instantiations.
'-fno-implement-inlines'
To save space, do not emit out-of-line copies of inline functions
controlled by '#pragma implementation'. This will cause linker
errors if these functions are not inlined everywhere they are
called.
'-fms-extensions'
Disable pedantic warnings about constructs used in MFC, such as
implicit int and getting a pointer to member function via
non-standard syntax.
'-fno-nonansi-builtins'
Disable built-in declarations of functions that are not mandated by
ANSI/ISO C. These include 'ffs', 'alloca', '_exit', 'index',
'bzero', 'conjf', and other related functions.
'-fnothrow-opt'
Treat a 'throw()' exception specification as though it were a
'noexcept' specification to reduce or eliminate the text size
overhead relative to a function with no exception specification.
If the function has local variables of types with non-trivial
destructors, the exception specification will actually make the
function smaller because the EH cleanups for those variables can be
optimized away. The semantic effect is that an exception thrown
out of a function with such an exception specification will result
in a call to 'terminate' rather than 'unexpected'.
'-fno-operator-names'
Do not treat the operator name keywords 'and', 'bitand', 'bitor',
'compl', 'not', 'or' and 'xor' as synonyms as keywords.
'-fno-optional-diags'
Disable diagnostics that the standard says a compiler does not need
to issue. Currently, the only such diagnostic issued by G++ is the
one for a name having multiple meanings within a class.
'-fpermissive'
Downgrade some diagnostics about nonconformant code from errors to
warnings. Thus, using '-fpermissive' will allow some nonconforming
code to compile.
'-fno-pretty-templates'
When an error message refers to a specialization of a function
template, the compiler will normally print the signature of the
template followed by the template arguments and any typedefs or
typenames in the signature (e.g. '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'
Enable automatic template instantiation at link time. This option
also implies '-fno-implicit-templates'. *Note Template
Instantiation::, for more information.
'-fno-rtti'
Disable generation of information about every class with virtual
functions for use by the C++ runtime type identification features
('dynamic_cast' and 'typeid'). If you don't use those parts of the
language, you can save some space by using this flag. Note that
exception handling uses the same information, but it will generate
it as needed. The 'dynamic_cast' operator can still be used for
casts that do not require runtime type information, i.e. casts to
'void *' or to unambiguous base classes.
'-fstats'
Emit statistics about front-end processing at the end of the
compilation. This information is generally only useful to the G++
development team.
'-fstrict-enums'
Allow the compiler to optimize using the assumption that a value of
enumeration type can only be one of the values of the enumeration
(as defined in the C++ standard; basically, a value which can be
represented in the minimum number of bits needed to represent all
the enumerators). This assumption may not be valid if the program
uses a cast to convert an arbitrary integer value to the
enumeration type.
'-ftemplate-depth=N'
Set the maximum instantiation depth for template classes to N. A
limit on the template instantiation depth is needed to detect
endless recursions during template class instantiation. ANSI/ISO
C++ conforming programs must not rely on a maximum depth greater
than 17 (changed to 1024 in C++0x).
'-fno-threadsafe-statics'
Do not emit the extra code to use the routines specified in the C++
ABI for thread-safe initialization of local statics. You can use
this option to reduce code size slightly in code that doesn't need
to be thread-safe.
'-fuse-cxa-atexit'
Register destructors for objects with static storage duration with
the '__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'
Don't use the '__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'
This switch declares that the user does not attempt to compare
pointers to inline methods where the addresses of the two functions
were taken in different shared objects.
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. *Note Template Instantiation::.
'-fvisibility-ms-compat'
This flag attempts to use visibility settings to make GCC's C++
linkage model compatible with that of Microsoft Visual Studio.
The flag makes these changes to GCC's linkage model:
1. It sets the default visibility to 'hidden', like
'-fvisibility=hidden'.
2. Types, but not their members, are not hidden by default.
3. The One Definition Rule is relaxed for types without explicit
visibility specifications which are defined in more than one
different shared object: those declarations are permitted if
they would have been permitted when this option was not used.
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'
Do not use weak symbol support, even if it is provided by the
linker. By default, G++ will use weak symbols if they are
available. This option exists only for testing, and should not be
used by end-users; it will result in inferior code and has no
benefits. This option may be removed in a future release of G++.
'-nostdinc++'
Do not search for header files in the standard directories specific
to C++, but do still search the other standard directories. (This
option is used when building the C++ library.)
In addition, these optimization, warning, and code generation options
have meanings only for C++ programs:
'-fno-default-inline'
Do not assume 'inline' for functions defined inside a class scope.
*Note Options That Control Optimization: Optimize Options. Note
that these functions will have linkage like inline functions; they
just won't be inlined by default.
'-Wabi (C, Objective-C, C++ and Objective-C++ only)'
Warn when G++ generates code that is probably not compatible with
the vendor-neutral C++ ABI. Although an effort has been made to
warn about all such cases, there are probably some cases that are
not warned about, even though G++ is generating incompatible code.
There may also be cases where warnings are emitted even though the
code that is generated will be compatible.
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 in '-fabi-version=2' (the default)
include:
* A template with a non-type template parameter of reference
type is mangled incorrectly:
extern int N;
template <int &> struct S {};
void n (S<N>) {2}
This is fixed in '-fabi-version=3'.
* SIMD vector types declared using '__attribute ((vector_size))'
are mangled in a non-standard way that does not allow for
overloading of functions taking vectors of different sizes.
The mangling is changed in '-fabi-version=4'.
The known incompatibilities in '-fabi-version=1' include:
* Incorrect handling of tail-padding for bit-fields. G++ may
attempt to pack data into the same byte as a base class. For
example:
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
as'A::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.
* Incorrect handling of tail-padding for virtual bases. G++
does not use tail padding when laying out virtual bases. For
example:
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.
* Incorrect handling of bit-fields with declared widths greater
than that of their underlying types, when the bit-fields
appear in a union. For example:
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'.
* Empty classes can be placed at incorrect offsets. For
example:
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.
* Names of template functions whose types involve '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:
* For SYSV/x86-64, when passing union with long double, it is
changed to pass in memory as specified in psABI. For example:
union U {
long double ld;
int i;
};
'union U' will always be passed in memory.
'-Wctor-dtor-privacy (C++ and Objective-C++ only)'
Warn when a class seems unusable because all the constructors or
destructors in that class are private, and it has neither friends
nor public static member functions.
'-Wnoexcept (C++ and Objective-C++ only)'
Warn when a noexcept-expression evaluates to false because of a
call to a function that does not have a non-throwing exception
specification (i.e. 'throw()' or 'noexcept') but is known by the
compiler to never throw an exception.
'-Wnon-virtual-dtor (C++ and Objective-C++ only)'
Warn when a class has virtual functions and accessible non-virtual
destructor, in which case it would be possible but unsafe to delete
an instance of a derived class through a pointer to the base class.
This warning is also enabled if -Weffc++ is specified.
'-Wreorder (C++ and Objective-C++ only)'
Warn when the order of member initializers given in the code does
not match the order in which they must be executed. For instance:
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)'
Warn about violations of the following style guidelines from Scott
Meyers' 'Effective C++' book:
* Item 11: Define a copy constructor and an assignment operator
for classes with dynamically allocated memory.
* Item 12: Prefer initialization to assignment in constructors.
* Item 14: Make destructors virtual in base classes.
* Item 15: Have 'operator=' return a reference to '*this'.
* Item 23: Don't try to return a reference when you must return
an object.
Also warn about violations of the following style guidelines from
Scott Meyers' 'More Effective C++' book:
* Item 6: Distinguish between prefix and postfix forms of
increment and decrement operators.
* Item 7: Never overload '&&', '||', 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)'
Warn also about the use of an uncasted '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)'
Disable warnings when non-templatized friend functions are declared
within a template. Since the advent of explicit template
specification support in G++, if the name of the friend is an
unqualified-id (i.e., 'friend foo(int)'), the C++ language
specification demands that the friend declare or define an
ordinary, nontemplate function. (Section 14.5.3). Before G++
implemented explicit specification, unqualified-ids could be
interpreted as a particular specialization of a templatized
function. Because this non-conforming behavior is no longer the
default behavior for G++, '-Wnon-template-friend' allows the
compiler to check existing code for potential trouble spots and is
on by default. This new compiler behavior can be turned off with
'-Wno-non-template-friend' which keeps the conformant compiler code
but disables the helpful warning.
'-Wold-style-cast (C++ and Objective-C++ only)'
Warn if an old-style (C-style) cast to a non-void type is used
within a C++ program. The new-style casts ('dynamic_cast',
'static_cast', 'reinterpret_cast', and 'const_cast') are less
vulnerable to unintended effects and much easier to search for.
'-Woverloaded-virtual (C++ and Objective-C++ only)'
Warn when a function declaration hides virtual functions from a
base class. For example, in:
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)'
Disable the diagnostic for converting a bound pointer to member
function to a plain pointer.
'-Wsign-promo (C++ and Objective-C++ only)'
Warn when overload resolution chooses a promotion from unsigned or
enumerated type to a signed type, over a conversion to an unsigned
type of the same size. Previous versions of G++ would try to
preserve unsignedness, but the standard mandates the current
behavior.
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 ='.

File: gcc.info, Node: Objective-C and Objective-C++ Dialect Options, Next: Language Independent Options, Prev: C++ Dialect Options, Up: Invoking GCC
3.6 Options Controlling Objective-C and Objective-C++ Dialects
==============================================================
(NOTE: This manual does not describe the Objective-C and Objective-C++
languages themselves. *Note Language Standards Supported by GCC:
Standards, 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'
Use CLASS-NAME as the name of the class to instantiate for each
literal string specified with the syntax '@"..."'. 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'
Generate object code compatible with the standard GNU Objective-C
runtime. This is the default for most types of systems.
'-fnext-runtime'
Generate output compatible with the NeXT runtime. This is the
default for NeXT-based systems, including Darwin and Mac OS X. The
macro '__NEXT_RUNTIME__' is predefined if (and only if) this option
is used.
'-fno-nil-receivers'
Assume that all Objective-C message dispatches ('[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. This option is only available in conjunction
with the NeXT runtime and ABI version 0 or 1.
'-fobjc-abi-version=N'
Use version N of the Objective-C ABI for the selected runtime.
This option is currently supported only for the NeXT runtime. In
that case, Version 0 is the traditional (32-bit) ABI without
support for properties and other Objective-C 2.0 additions.
Version 1 is the traditional (32-bit) ABI with support for
properties and other Objective-C 2.0 additions. Version 2 is the
modern (64-bit) ABI. If nothing is specified, the default is
Version 0 on 32-bit target machines, and Version 2 on 64-bit target
machines.
'-fobjc-call-cxx-cdtors'
For each Objective-C class, check if any of its instance variables
is a C++ object with a non-trivial default constructor. If so,
synthesize a special '- (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 '- (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'
Allow fast jumps to the message dispatcher. On Darwin this is
accomplished via the comm page.
'-fobjc-exceptions'
Enable syntactic support for structured exception handling in
Objective-C, similar to what is offered by C++ and Java. This
option is required to use the Objective-C keywords '@try',
'@throw', '@catch', '@finally' and '@synchronized'. This option is
available with both the GNU runtime and the NeXT runtime (but not
available in conjunction with the NeXT runtime on Mac OS X 10.2 and
earlier).
'-fobjc-gc'
Enable garbage collection (GC) in Objective-C and Objective-C++
programs. This option is only available with the NeXT runtime; the
GNU runtime has a different garbage collection implementation that
does not require special compiler flags.
'-fobjc-nilcheck'
For the NeXT runtime with version 2 of the ABI, check for a nil
receiver in method invocations before doing the actual method call.
This is the default and can be disabled using '-fno-objc-nilcheck'.
Class methods and super calls are never checked for nil in this way
no matter what this flag is set to. Currently this flag does
nothing when the GNU runtime, or an older version of the NeXT
runtime ABI, is used.
'-fobjc-std=objc1'
Conform to the language syntax of Objective-C 1.0, the language
recognized by GCC 4.0. This only affects the Objective-C additions
to the C/C++ language; it does not affect conformance to C/C++
standards, which is controlled by the separate C/C++ dialect option
flags. When this option is used with the Objective-C or
Objective-C++ compiler, any Objective-C syntax that is not
recognized by GCC 4.0 is rejected. This is useful if you need to
make sure that your Objective-C code can be compiled with older
versions of GCC.
'-freplace-objc-classes'
Emit a special marker instructing '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'
When compiling for the NeXT runtime, the compiler ordinarily
replaces calls to '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. The
GNU runtime currently always retains calls to
'objc_get_class("...")' regardless of command line options.
'-gen-decls'
Dump interface declarations for all classes seen in the source file
to a file named 'SOURCENAME.decl'.
'-Wassign-intercept (Objective-C and Objective-C++ only)'
Warn whenever an Objective-C assignment is being intercepted by the
garbage collector.
'-Wno-protocol (Objective-C and Objective-C++ only)'
If a class is declared to implement a protocol, a warning is issued
for every method in the protocol that is not implemented by the
class. The default behavior is to issue a warning for every method
not explicitly implemented in the class, even if a method
implementation is inherited from the superclass. If you use the
'-Wno-protocol' option, then methods inherited from the superclass
are considered to be implemented, and no warning is issued for
them.
'-Wselector (Objective-C and Objective-C++ only)'
Warn if multiple methods of different types for the same selector
are found during compilation. The check is performed on the list
of methods in the final stage of compilation. Additionally, a
check is performed for each selector appearing in a
'@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)'
Warn if multiple methods with differing argument and/or return
types are found for a given selector when attempting to send a
message using this selector to a receiver of type '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)'
Warn if a '@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'
Generate C header describing the largest structure that is passed
by value, if any.

File: gcc.info, Node: Language Independent Options, Next: Warning Options, Prev: Objective-C and Objective-C++ Dialect Options, Up: Invoking GCC
3.7 Options to Control Diagnostic Messages Formatting
=====================================================
Traditionally, diagnostic messages have been formatted irrespective of
the output device's aspect (e.g. its width, ...). The options described
below can be used to control the diagnostic messages formatting
algorithm, e.g. how many characters per line, how often source location
information should be reported. Right now, only the C++ front end can
honor these options. However it is expected, in the near future, that
the remaining front ends would be able to digest them correctly.
'-fmessage-length=N'
Try to format error messages so that they fit on lines of about N
characters. The default is 72 characters for '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'
Only meaningful in line-wrapping mode. Instructs the diagnostic
messages reporter to emit _once_ source location information; that
is, in case the message is too long to fit on a single physical
line and has to be wrapped, the source location won't be emitted
(as prefix) again, over and over, in subsequent continuation lines.
This is the default behavior.
'-fdiagnostics-show-location=every-line'
Only meaningful in line-wrapping mode. Instructs the diagnostic
messages reporter to emit the same source location information (as
prefix) for physical lines that result from the process of breaking
a message which is too long to fit on a single line.
'-fno-diagnostics-show-option'
By default, each diagnostic emitted includes text which indicates
the command line option that directly controls the diagnostic (if
such an option is known to the diagnostic machinery). Specifying
the '-fno-diagnostics-show-option' flag suppresses that behavior.
'-Wcoverage-mismatch'
Warn if feedback profiles do not match when using the
'-fprofile-use' option. If a source file was changed between
'-fprofile-gen' and '-fprofile-use', the files with the profile
feedback can fail to match the source file and GCC can not use the
profile feedback information. By default, this warning is enabled
and is treated as an error. '-Wno-coverage-mismatch' can be used
to disable the warning or '-Wno-error=coverage-mismatch' can be
used to disable the error. Disable the error for this warning can
result in poorly optimized code, so disabling the error is useful
only in the case of very minor changes such as bug fixes to an
existing code-base. Completely disabling the warning is not
recommended.

File: gcc.info, Node: Warning Options, Next: Debugging Options, Prev: Language Independent Options, Up: Invoking GCC
3.8 Options to Request or Suppress Warnings
===========================================
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'
Check the code for syntax errors, but don't do anything beyond
that.
'-fmax-errors=N'
Limits the maximum number of error messages to N, at which point
GCC bails out rather than attempting to continue processing the
source code. If N is 0 (the default), there is no limit on the
number of error messages produced. If '-Wfatal-errors' is also
specified, then '-Wfatal-errors' takes precedence over this option.
'-w'
Inhibit all warning messages.
'-Werror'
Make all warnings into errors.
'-Werror='
Make the specified warning into an error. The specifier for a
warning is appended, for example '-Werror=switch' turns the
warnings controlled by '-Wswitch' into errors. This switch takes a
negative form, to be used to negate '-Werror' for specific
warnings, for example '-Wno-error=switch' makes '-Wswitch' warnings
not be errors, even when '-Werror' is in effect.
The warning message for each controllable warning includes the
option which controls the warning. That option can then be used
with '-Werror=' and '-Wno-error=' as described above. (Printing of
the option in the warning message can be disabled using the
'-fno-diagnostics-show-option' flag.)
Note that specifying '-Werror='FOO automatically implies '-W'FOO.
However, '-Wno-error='FOO does not imply anything.
'-Wfatal-errors'
This option causes the compiler to abort compilation on the first
error occurred rather than trying to keep going and printing
further error messages.
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 *note C++ Dialect
Options:: and *note Objective-C and Objective-C++ Dialect Options::.
When an unrecognized warning option is requested (e.g.,
'-Wunknown-warning'), GCC will emit a diagnostic stating that the option
is not recognized. However, if the '-Wno-' form is used, the behavior
is slightly different: No diagnostic will be produced for
'-Wno-unknown-warning' unless other diagnostics are being produced.
This allows the use of new '-Wno-' options with old compilers, but if
something goes wrong, the compiler will warn that an unrecognized option
was used.
'-pedantic'
Issue all the warnings demanded by strict ISO C and ISO C++; reject
all programs that use forbidden extensions, and some other programs
that do not follow ISO C and ISO C++. For ISO C, follows the
version of the ISO C standard specified by any '-std' option used.
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. *Note
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 'gnu90' 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'
Like '-pedantic', except that errors are produced rather than
warnings.
'-Wall'
This enables all the warnings about constructions that some users
consider questionable, and that are easy to avoid (or modify to
prevent the warning), even in conjunction with macros. This also
enables some language-specific warnings described in *note C++
Dialect Options:: and *note Objective-C and Objective-C++ Dialect
Options::.
'-Wall' turns on the following warning flags:
-Waddress
-Warray-bounds (only with -O2)
-Wc++0x-compat
-Wchar-subscripts
-Wenum-compare (in C/Objc; this is on by default in C++)
-Wimplicit-int (C and Objective-C only)
-Wimplicit-function-declaration (C and Objective-C only)
-Wcomment
-Wformat
-Wmain (only for C/ObjC and unless -ffreestanding)
-Wmissing-braces
-Wnonnull
-Wparentheses
-Wpointer-sign
-Wreorder
-Wreturn-type
-Wsequence-point
-Wsign-compare (only in C++)
-Wstrict-aliasing
-Wstrict-overflow=1
-Wswitch
-Wtrigraphs
-Wuninitialized
-Wunknown-pragmas
-Wunused-function
-Wunused-label
-Wunused-value
-Wunused-variable
-Wvolatile-register-var
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'
This enables some extra warning flags that are not enabled by
'-Wall'. (This option used to be called '-W'. The older name is
still supported, but the newer name is more descriptive.)
-Wclobbered
-Wempty-body
-Wignored-qualifiers
-Wmissing-field-initializers
-Wmissing-parameter-type (C only)
-Wold-style-declaration (C only)
-Woverride-init
-Wsign-compare
-Wtype-limits
-Wuninitialized
-Wunused-parameter (only with -Wunused or -Wall)
-Wunused-but-set-parameter (only with -Wunused or -Wall)
The option '-Wextra' also prints warning messages for the following
cases:
* A pointer is compared against integer zero with '<', '<=',
'>', or '>='.
* (C++ only) An enumerator and a non-enumerator both appear in a
conditional expression.
* (C++ only) Ambiguous virtual bases.
* (C++ only) Subscripting an array which has been declared
'register'.
* (C++ only) Taking the address of a variable which has been
declared 'register'.
* (C++ only) A base class is not initialized in a derived class'
copy constructor.
'-Wchar-subscripts'
Warn if an array subscript has type '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'
Warn whenever a comment-start sequence '/*' appears in a '/*'
comment, or whenever a Backslash-Newline appears in a '//' comment.
This warning is enabled by '-Wall'.
'-Wno-cpp'
(C, Objective-C, C++, Objective-C++ and Fortran only)
Suppress warning messages emitted by '#warning' directives.
'-Wdouble-promotion (C, C++, Objective-C and Objective-C++ only)'
Give a warning when a value of type 'float' is implicitly promoted
to 'double'. CPUs with a 32-bit "single-precision" floating-point
unit implement 'float' in hardware, but emulate 'double' in
software. On such a machine, doing computations using 'double'
values is much more expensive because of the overhead required for
software emulation.
It is easy to accidentally do computations with 'double' because
floating-point literals are implicitly of type 'double'. For
example, in:
float area(float radius)
{
return 3.14159 * radius * radius;
}
the compiler will perform the entire computation with 'double'
because the floating-point literal is a 'double'.
'-Wformat'
Check calls to '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 (*note Function Attributes::), 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). *Note Options Controlling C Dialect: C Dialect Options.
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'
If '-Wformat' is specified, also warn about 'strftime' formats
which may yield only a two-digit year.
'-Wno-format-contains-nul'
If '-Wformat' is specified, do not warn about format strings that
contain NUL bytes.
'-Wno-format-extra-args'
If '-Wformat' is specified, do not warn about excess arguments to a
'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)'
If '-Wformat' is specified, do not warn about zero-length formats.
The C standard specifies that zero-length formats are allowed.
'-Wformat-nonliteral'
If '-Wformat' is specified, also warn if the format string is not a
string literal and so cannot be checked, unless the format function
takes its format arguments as a 'va_list'.
'-Wformat-security'
If '-Wformat' is specified, also warn about uses of format
functions that represent possible security problems. At present,
this warns about calls to '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'
Enable '-Wformat' plus format checks not included in '-Wformat'.
Currently equivalent to '-Wformat -Wformat-nonliteral
-Wformat-security -Wformat-y2k'.
'-Wnonnull (C and Objective-C only)'
Warn about passing a null pointer for arguments marked as requiring
a non-null value by the '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)'
Warn about uninitialized variables which are initialized with
themselves. Note this option can only be used with the
'-Wuninitialized' option.
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)'
Warn when a declaration does not specify a type. This warning is
enabled by '-Wall'.
'-Wimplicit-function-declaration (C and Objective-C only)'
Give a warning whenever a function is used before being declared.
In C99 mode ('-std=c99' or '-std=gnu99'), this warning is enabled
by default and it is made into an error by '-pedantic-errors'.
This warning is also enabled by '-Wall'.
'-Wimplicit (C and Objective-C only)'
Same as '-Wimplicit-int' and '-Wimplicit-function-declaration'.
This warning is enabled by '-Wall'.
'-Wignored-qualifiers (C and C++ only)'
Warn if the return type of a function has a type qualifier such as
'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'
Warn if the type of 'main' is suspicious. 'main' should be a
function with external linkage, returning int, taking either zero
arguments, two, or three arguments of appropriate types. This
warning is enabled by default in C++ and is enabled by either
'-Wall' or '-pedantic'.
'-Wmissing-braces'
Warn if an aggregate or union initializer is not fully bracketed.
In the following example, the initializer for 'a' is not fully
bracketed, but that for 'b' is fully bracketed.
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)'
Warn if a user-supplied include directory does not exist.
'-Wparentheses'
Warn if parentheses are omitted in certain contexts, such as when
there is an assignment in a context where a truth value is
expected, or when operators are nested whose precedence people
often get confused about.
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 ();
}
}
Also warn for dangerous uses of the ?: with omitted middle operand
GNU extension. When the condition in the ?: operator is a boolean
expression the omitted value will be always 1. Often the user
expects it to be a value computed inside the conditional expression
instead.
This warning is enabled by '-Wall'.
'-Wsequence-point'
Warn about code that may have undefined semantics because of
violations of sequence point rules in the C and C++ standards.
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'
Warn whenever a function is defined with a return-type that
defaults to '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'
Warn whenever a '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'
Warn whenever a 'switch' statement does not have a 'default' case.
'-Wswitch-enum'
Warn whenever a '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)'
Warn when '__sync_fetch_and_nand' and '__sync_nand_and_fetch'
built-in functions are used. These functions changed semantics in
GCC 4.4.
'-Wtrigraphs'
Warn if any trigraphs are encountered that might change the meaning
of the program (trigraphs within comments are not warned about).
This warning is enabled by '-Wall'.
'-Wunused-but-set-parameter'
Warn whenever a function parameter is assigned to, but otherwise
unused (aside from its declaration).
To suppress this warning use the 'unused' attribute (*note Variable
Attributes::).
This warning is also enabled by '-Wunused' together with '-Wextra'.
'-Wunused-but-set-variable'
Warn whenever a local variable is assigned to, but otherwise unused
(aside from its declaration). This warning is enabled by '-Wall'.
To suppress this warning use the 'unused' attribute (*note Variable
Attributes::).
This warning is also enabled by '-Wunused', which is enabled by
'-Wall'.
'-Wunused-function'
Warn whenever a static function is declared but not defined or a
non-inline static function is unused. This warning is enabled by
'-Wall'.
'-Wunused-label'
Warn whenever a label is declared but not used. This warning is
enabled by '-Wall'.
To suppress this warning use the 'unused' attribute (*note Variable
Attributes::).
'-Wunused-parameter'
Warn whenever a function parameter is unused aside from its
declaration.
To suppress this warning use the 'unused' attribute (*note Variable
Attributes::).
'-Wno-unused-result'
Do not warn if a caller of a function marked with attribute
'warn_unused_result' (*note Variable Attributes::) does not use its
return value. The default is '-Wunused-result'.
'-Wunused-variable'
Warn whenever a local variable or non-constant static variable is
unused aside from its declaration. This warning is enabled by
'-Wall'.
To suppress this warning use the 'unused' attribute (*note Variable
Attributes::).
'-Wunused-value'
Warn whenever a statement computes a result that is explicitly not
used. To suppress this warning cast the unused expression to
'void'. This includes an expression-statement or the left-hand
side of a comma expression that contains no side effects. For
example, an expression such as 'x[i,j]' will cause a warning, while
'x[(void)i,j]' will not.
This warning is enabled by '-Wall'.
'-Wunused'
All the above '-Wunused' options combined.
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'
Warn if an automatic variable is used without first being
initialized or if a variable may be clobbered by a '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'. *Note Function
Attributes::.
This warning is enabled by '-Wall' or '-Wextra'.
'-Wunknown-pragmas'
Warn when a #pragma directive is encountered which is not
understood by GCC. If this command line option is used, warnings
will even be issued for unknown pragmas in system header files.
This is not the case if the warnings were only enabled by the
'-Wall' command line option.
'-Wno-pragmas'
Do not warn about misuses of pragmas, such as incorrect parameters,
invalid syntax, or conflicts between pragmas. See also
'-Wunknown-pragmas'.
'-Wstrict-aliasing'
This option is only active when '-fstrict-aliasing' is active. It
warns about code which might break the strict aliasing rules that
the compiler is using for optimization. The warning does not catch
all cases, but does attempt to catch the more common pitfalls. It
is included in '-Wall'. It is equivalent to '-Wstrict-aliasing=3'
'-Wstrict-aliasing=n'
This option is only active when '-fstrict-aliasing' is active. It
warns about code which might break the strict aliasing rules that
the compiler is using for optimization. Higher levels correspond
to higher accuracy (fewer false positives). Higher levels also
correspond to more effort, similar to the way -O works.
'-Wstrict-aliasing' is equivalent to '-Wstrict-aliasing=n', with
n=3.
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 pun+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'
This option is only active when '-fstrict-overflow' is active. It
warns about cases where the compiler optimizes based on the
assumption that signed overflow does not occur. Note that it does
not warn about all cases where the code might overflow: it only
warns about cases where the compiler implements some optimization.
Thus this warning depends on the optimization level.
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'
Warn about cases which are both questionable and easy to
avoid. For example: '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'
Also warn about other cases where a comparison is simplified
to a constant. For example: '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'
Also warn about other cases where a comparison is simplified.
For example: 'x + 1 > 1' will be simplified to 'x > 0'.
'-Wstrict-overflow=4'
Also warn about other simplifications not covered by the above
cases. For example: '(x * 10) / 5' will be simplified to 'x *
2'.
'-Wstrict-overflow=5'
Also warn about cases where the compiler reduces the magnitude
of a constant involved in a comparison. For example: '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.
'-Wsuggest-attribute=[pure|const|noreturn]'
Warn for cases where adding an attribute may be beneficial. The
attributes currently supported are listed below.
'-Wsuggest-attribute=pure'
'-Wsuggest-attribute=const'
'-Wsuggest-attribute=noreturn'
Warn about functions which might be candidates for attributes
'pure', 'const' or 'noreturn'. The compiler only warns for
functions visible in other compilation units or (in the case
of 'pure' and 'const') if it cannot prove that the function
returns normally. A function returns normally if it doesn't
contain an infinite loop nor returns abnormally by throwing,
calling 'abort()' or trapping. This analysis requires option
'-fipa-pure-const', which is enabled by default at '-O' and
higher. Higher optimization levels improve the accuracy of
the analysis.
'-Warray-bounds'
This option is only active when '-ftree-vrp' is active (default for
'-O2' and above). It warns about subscripts to arrays that are
always out of bounds. This warning is enabled by '-Wall'.
'-Wno-div-by-zero'
Do not warn about compile-time integer division by zero. Floating
point division by zero is not warned about, as it can be a
legitimate way of obtaining infinities and NaNs.
'-Wsystem-headers'
Print warning messages for constructs found in system header files.
Warnings from system headers are normally suppressed, on the
assumption that they usually do not indicate real problems and
would only make the compiler output harder to read. Using this
command line option tells GCC to emit warnings from system headers
as if they occurred in user code. However, note that using '-Wall'
in conjunction with this option will _not_ warn about unknown
pragmas in system headers--for that, '-Wunknown-pragmas' must also
be used.
'-Wtrampolines'
Warn about trampolines generated for pointers to nested functions.
A trampoline is a small piece of data or code that is created at
run time on the stack when the address of a nested function is
taken, and is used to call the nested function indirectly. For
some targets, it is made up of data only and thus requires no
special treatment. But, for most targets, it is made up of code
and thus requires the stack to be made executable in order for the
program to work properly.
'-Wfloat-equal'
Warn if floating point values are used in equality comparisons.
The idea behind this is that sometimes it is convenient (for the
programmer) to consider floating-point values as approximations to
infinitely precise real numbers. If you are doing this, then you
need to compute (by analyzing the code, or in some other way) the
maximum or likely maximum error that the computation introduces,
and allow for it when performing comparisons (and when producing
output, but that's a different problem). In particular, instead of
testing for equality, you would check to see whether the two values
have ranges that overlap; and this is done with the relational
operators, so equality comparisons are probably mistaken.
'-Wtraditional (C and Objective-C only)'
Warn about certain constructs that behave differently in
traditional and ISO C. Also warn about ISO C constructs that have
no traditional C equivalent, and/or problematic constructs which
should be avoided.
* Macro parameters that appear within string literals in the
macro body. In traditional C macro replacement takes place
within string literals, but does not in ISO C.
* In traditional C, some preprocessor directives did not exist.
Traditional preprocessors would only consider a line to be a
directive if the '#' appeared in column 1 on the line.
Therefore '-Wtraditional' warns about directives that
traditional C understands but would ignore because the '#'
does not appear as the first character on the line. It also
suggests you hide directives like '#pragma' not understood by
traditional C by indenting them. Some traditional
implementations would not recognize '#elif', so it suggests
avoiding it altogether.
* A function-like macro that appears without arguments.
* The unary plus operator.
* The 'U' integer constant suffix, or the 'F' or 'L' floating
point constant suffixes. (Traditional C does support the 'L'
suffix on integer constants.) Note, these suffixes appear in
macros defined in the system headers of most modern systems,
e.g. the '_MIN'/'_MAX' macros in '<limits.h>'. Use of these
macros in user code might normally lead to spurious warnings,
however GCC's integrated preprocessor has enough context to
avoid warning in these cases.
* A function declared external in one block and then used after
the end of the block.
* A 'switch' statement has an operand of type 'long'.
* A non-'static' function declaration follows a 'static' one.
This construct is not accepted by some traditional C
compilers.
* The ISO type of an integer constant has a different width or
signedness from its traditional type. This warning is only
issued if the base of the constant is ten. I.e. hexadecimal
or octal values, which typically represent bit patterns, are
not warned about.
* Usage of ISO string concatenation is detected.
* Initialization of automatic aggregates.
* Identifier conflicts with labels. Traditional C lacks a
separate namespace for labels.
* Initialization of unions. If the initializer is zero, the
warning is omitted. This is done under the assumption that
the zero initializer in user code appears conditioned on e.g.
'__STDC__' to avoid missing initializer warnings and relies on
default initialization to zero in the traditional C case.
* Conversions by prototypes between fixed/floating point values
and vice versa. The absence of these prototypes when
compiling with traditional C would cause serious problems.
This is a subset of the possible conversion warnings, for the
full set use '-Wtraditional-conversion'.
* Use of ISO C style function definitions. This warning
intentionally is _not_ issued for prototype declarations or
variadic functions because these ISO C features will appear in
your code when using libiberty's traditional C compatibility
macros, '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)'
Warn if a prototype causes a type conversion that is different from
what would happen to the same argument in the absence of a
prototype. This includes conversions of fixed point to floating
and vice versa, and conversions changing the width or signedness of
a fixed point argument except when the same as the default
promotion.
'-Wdeclaration-after-statement (C and Objective-C only)'
Warn when a declaration is found after a statement in a block.
This construct, known from C++, was introduced with ISO C99 and is
by default allowed in GCC. It is not supported by ISO C90 and was
not supported by GCC versions before GCC 3.0. *Note Mixed
Declarations::.
'-Wundef'
Warn if an undefined identifier is evaluated in an '#if' directive.
'-Wno-endif-labels'
Do not warn whenever an '#else' or an '#endif' are followed by
text.
'-Wshadow'
Warn whenever a local variable or type declaration shadows another
variable, parameter, type, or class member (in C++), or whenever a
built-in function is shadowed. Note that in C++, the compiler will
not warn if a local variable shadows a struct/class/enum, but will
warn if it shadows an explicit typedef.
'-Wlarger-than=LEN'
Warn whenever an object of larger than LEN bytes is defined.
'-Wframe-larger-than=LEN'
Warn if the size of a function frame is larger than LEN bytes. The
computation done to determine the stack frame size is approximate
and not conservative. The actual requirements may be somewhat
greater than LEN even if you do not get a warning. In addition,
any space allocated via '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'
Warn if the loop cannot be optimized because the compiler could not
assume anything on the bounds of the loop indices. With
'-funsafe-loop-optimizations' warn if the compiler made such
assumptions.
'-Wno-pedantic-ms-format (MinGW targets only)'
Disables the warnings about non-ISO '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'
Warn about anything that depends on the "size of" a function type
or of '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'
Warn if a comparison is always true or always false due to the
limited range of the data type, but do not warn for constant
expressions. For example, warn if an unsigned variable is compared
against zero with '<' or '>='. This warning is also enabled by
'-Wextra'.
'-Wbad-function-cast (C and Objective-C only)'
Warn whenever a function call is cast to a non-matching type. For
example, warn if 'int malloc()' is cast to 'anything *'.
'-Wc++-compat (C and Objective-C only)'
Warn about ISO C constructs that are outside of the common subset
of ISO C and ISO C++, e.g. request for implicit conversion from
'void *' to a pointer to non-'void' type.
'-Wc++0x-compat (C++ and Objective-C++ only)'
Warn about C++ constructs whose meaning differs between ISO C++
1998 and ISO C++ 200x, e.g., identifiers in ISO C++ 1998 that will
become keywords in ISO C++ 200x. This warning is enabled by
'-Wall'.
'-Wcast-qual'
Warn whenever a pointer is cast so as to remove a type qualifier
from the target type. For example, warn if a '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'
Warn whenever a pointer is cast such that the required alignment of
the target is increased. For example, warn if a 'char *' is cast
to an 'int *' on machines where integers can only be accessed at
two- or four-byte boundaries.
'-Wwrite-strings'
When compiling C, give string constants the type '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'
Warn for variables that might be changed by 'longjmp' or 'vfork'.
This warning is also enabled by '-Wextra'.
'-Wconversion'
Warn for implicit conversions that may alter a value. This
includes conversions between real and integer, like '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 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.
'-Wno-conversion-null (C++ and Objective-C++ only)'
Do not warn for conversions between 'NULL' and non-pointer types.
'-Wconversion-null' is enabled by default.
'-Wempty-body'
Warn if an empty body occurs in an 'if', 'else' or 'do while'
statement. This warning is also enabled by '-Wextra'.
'-Wenum-compare'
Warn about a comparison between values of different enum types. In
C++ this warning is enabled by default. In C this warning is
enabled by '-Wall'.
'-Wjump-misses-init (C, Objective-C only)'
Warn if a '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'
Warn when a comparison between signed and unsigned values could
produce an incorrect result when the signed value is converted to
unsigned. This warning is also enabled by '-Wextra'; to get the
other warnings of '-Wextra' without this warning, use '-Wextra
-Wno-sign-compare'.
'-Wsign-conversion'
Warn for implicit conversions that may change the sign of an
integer value, like assigning a signed integer expression to an
unsigned integer variable. An explicit cast silences the warning.
In C, this option is enabled also by '-Wconversion'.
'-Waddress'
Warn about suspicious uses of memory addresses. These include
using the address of a function in a conditional expression, such
as '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'
Warn about suspicious uses of logical operators in expressions.
This includes using logical operators in contexts where a bit-wise
operator is likely to be expected.
'-Waggregate-return'
Warn if any functions that return structures or unions are defined
or called. (In languages where you can return an array, this also
elicits a warning.)
'-Wno-attributes'
Do not warn if an unexpected '__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'
Do not warn if certain built-in macros are redefined. This
suppresses warnings for redefinition of '__TIMESTAMP__',
'__TIME__', '__DATE__', '__FILE__', and '__BASE_FILE__'.
'-Wstrict-prototypes (C and Objective-C only)'
Warn if a function is declared or defined without specifying the
argument types. (An old-style function definition is permitted
without a warning if preceded by a declaration which specifies the
argument types.)
'-Wold-style-declaration (C and Objective-C only)'
Warn for obsolescent usages, according to the C Standard, in a
declaration. For example, warn if storage-class specifiers like
'static' are not the first things in a declaration. This warning
is also enabled by '-Wextra'.
'-Wold-style-definition (C and Objective-C only)'
Warn if an old-style function definition is used. A warning is
given even if there is a previous prototype.
'-Wmissing-parameter-type (C and Objective-C only)'
A function parameter is declared without a type specifier in
K&R-style functions:
void foo(bar) { }
This warning is also enabled by '-Wextra'.
'-Wmissing-prototypes (C and Objective-C only)'
Warn if a global function is defined without a previous prototype
declaration. This warning is issued even if the definition itself
provides a prototype. The aim is to detect global functions that
fail to be declared in header files.
'-Wmissing-declarations'
Warn if a global function is defined without a previous
declaration. Do so even if the definition itself provides a
prototype. Use this option to detect global functions that are not
declared in header files. In C++, no warnings are issued for
function templates, or for inline functions, or for functions in
anonymous namespaces.
'-Wmissing-field-initializers'
Warn if a structure's initializer has some fields missing. For
example, the following code would cause such a warning, because
'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-format-attribute'
Warn about function pointers which might be candidates for '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'
Do not warn if a multicharacter constant (''FOOF'') is used.
Usually they indicate a typo in the user's code, as they have
implementation-defined values, and should not be used in portable
code.
'-Wnormalized=<none|id|nfc|nfkc>'
In ISO C and ISO C++, two identifiers are different if they are
different sequences of characters. However, sometimes when
characters outside the basic ASCII character set are used, you can
have two different character sequences that look the same. To
avoid confusion, the ISO 10646 standard sets out some
"normalization rules" which when applied ensure that two sequences
that look the same are turned into the same sequence. GCC can warn
you if you are using identifiers which have not been normalized;
this option controls that warning.
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'