Red Hat ENTERPRISE LINUX 3 - USING GCC, Enterprise Linux 3 Using Instructions
Red Hat Enterprise Linux 3
Using the GNU Compiler
Collection (GCC)
Red Hat Enterprise Linux 3: Using the GNU Compiler Collection (GCC)
Copyright © 1987, 1989, 1991-2003 by Free Software Foundation, Inc.
Copyright © 2003 by Red Hat, Inc.
Copyright © 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
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.2 or any later version published by the Free Software Foundation;
with the Invariant Sections being "GNU General Public License" and "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".
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.
This documentation has been prepared by Red Hat, Inc.
1801 Varsity Drive
Raleigh NC 27606-2072 USA
Phone: +1 919 754 3700
Phone: 888 733 4281
Fax: +1 919 754 3701
PO Box 13588
Research Triangle Park NC
27709 USA
Manual identifier:
• PDF: rhds-gcc-EN-3-PDF-RHI (2003-09-24T01:08)
• HTML: rhds-gcc-EN-3-HTML-RHI (2003-09-24T01:08)
Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation
License, Version 1.1 or any later version published by the Free Software Foundation; with no Invariant Sections, with no
Front-Cover Texts, and with no Back-Cover Texts. A copy of the license is included in the section entitled “GNU Free
Documentation License”.
Red Hat, Inc. is not granting permission to any redistributorto use the Red Hat name.
Red Hat is a registered trademark and the Red Hat Shadow Man logo, RPM, and the RPM logo are trademarks of Red Hat, Inc.
Linux is a registered trademark of Linus Torvalds.
All other trademarks and copyrights referred to are the property of their respective owners.
HTML, PDF, and RPM versions of the manuals are available on the Documentation CD and online at
http://www.redhat.com/docs/.
The GPG fingerprint of the security@redhat.com key is:
CA 20 86 86 2B D6 9D FC 65 F6 EC C4 21 91 80 CD DB 42 A6 0E
Table of Contents
1. Introduction..................................................................................................................................... 1
2. Compile C, C++, Objective-C, Ada, Fortran, Java, or treelang ................................................. 3
3. Language Standards Supported by GCC ..................................................................................... 5
4. GCC Command Options ................................................................................................................7
4.1. Option Summary................................................................................................................ 7
4.2. Options Controlling the Kind of Output ..........................................................................12
4.3. Compiling C++ Programs ................................................................................................ 15
4.4. Options Controlling C Dialect .........................................................................................15
4.5. Options Controlling C++ Dialect..................................................................................... 19
4.6. Options Controlling Objective-C Dialect ........................................................................25
4.7. Options to Control Diagnostic Messages Formatting ...................................................... 26
4.8. Options to Request or Suppress Warnings....................................................................... 26
4.9. Options for Debugging Your Program or GCC ...............................................................38
4.10. Options That Control Optimization ...............................................................................47
4.11. Options Controlling the Preprocessor............................................................................64
4.12. Passing Options to the Assembler.................................................................................. 72
4.13. Options for Linking........................................................................................................ 72
4.14. Options for Directory Search.........................................................................................75
4.15. Specifying subprocesses and the switches to pass to them............................................76
4.16. Specifying Target Machine and Compiler Version ........................................................83
4.17. Hardware Models and Configurations ........................................................................... 83
4.17.1. SPARC Options............................................................................................... 84
4.17.2. IBM RS/6000 and PowerPC Options .............................................................87
4.17.3. Intel 386 and AMD x86-64 Options ............................................................... 95
4.17.4. IA-64 Options ...............................................................................................100
4.17.5. S/390 and zSeries Options ............................................................................102
4.18. Options for Code Generation Conventions.................................................................. 103
4.19. Environment Variables Affecting GCC ....................................................................... 108
4.20. Using Precompiled Headers......................................................................................... 110
4.21. Running Protoize .........................................................................................................111
5. C Implementation-defined behavior ......................................................................................... 115
5.1. Translation .....................................................................................................................115
5.2. Environment................................................................................................................... 115
5.3. Identifiers .......................................................................................................................115
5.4. Characters ...................................................................................................................... 115
5.5. Integers........................................................................................................................... 116
5.6. Floating point ................................................................................................................. 116
5.7. Arrays and pointers ........................................................................................................117
5.8. Hints...............................................................................................................................117
5.9. Structures, unions, enumerations, and bit-fields ............................................................117
5.10. Qualifiers...................................................................................................................... 118
5.11. Preprocessing directives............................................................................................... 118
5.12. Library functions.......................................................................................................... 118
5.13. Architecture.................................................................................................................. 118
5.14. Locale-specific behavior .............................................................................................. 119
6. Extensions to the C Language Family....................................................................................... 121
6.1. Statements and Declarations in Expressions..................................................................121
6.2. Locally Declared Labels ................................................................................................122
6.3. Labels as Values............................................................................................................. 122
6.4. Nested Functions............................................................................................................ 123
6.5. Constructing Function Calls .......................................................................................... 125
6.6. Referring to a Type with typeof .................................................................................. 125
6.7. Generalized Lvalues.......................................................................................................127
6.8. Conditionals with Omitted Operands............................................................................. 128
6.9. Double-Word Integers.................................................................................................... 128
6.10. Complex Numbers .......................................................................................................128
6.11. Hex Floats ....................................................................................................................129
6.12. Arrays of Length Zero ................................................................................................. 129
6.13. Structures With No Members ...................................................................................... 130
6.14. Arrays of Variable Length............................................................................................ 130
6.15. Macros with a Variable Number of Arguments. ..........................................................131
6.16. Slightly Looser Rules for Escaped Newlines...............................................................132
6.17. String Literals with Embedded Newlines ....................................................................132
6.18. Non-Lvalue Arrays May Have Subscripts ................................................................... 133
6.19. Arithmetic on void- and Function-Pointers ................................................................133
6.20. Non-Constant Initializers ............................................................................................. 133
6.21. Compound Literals....................................................................................................... 133
6.22. Designated Initializers ................................................................................................. 134
6.23. Case Ranges.................................................................................................................136
6.24. Cast to a Union Type....................................................................................................136
6.25. Mixed Declarations and Code......................................................................................137
6.26. Declaring Attributes of Functions................................................................................137
6.27. Attribute Syntax ...........................................................................................................143
6.28. Prototypes and Old-Style Function Definitions ........................................................... 146
6.29. C++ Style Comments...................................................................................................147
6.30. Dollar Signs in Identifier Names.................................................................................. 147
6.31. The Character [ESC] in Constants ............................................................................... 147
6.32. Inquiring on Alignment of Types or Variables ............................................................ 147
6.33. Specifying Attributes of Variables............................................................................... 147
6.33.1. i386 Variable Attributes ................................................................................ 151
6.34. Specifying Attributes of Types ....................................................................................151
6.35. Type Attributes.............................................................................................................154
6.35.1. i386 Type Attributes......................................................................................155
6.36. An Inline Function is As Fast As a Macro................................................................... 155
6.37. Assembler Instructions with C Expression Operands.................................................. 156
6.37.1. i386 floating point asm operands .................................................................. 160
6.38. Constraints for asmOperands .......................................................................................161
6.38.1. Simple Constraints........................................................................................ 161
6.38.2. Multiple Alternative Constraints...................................................................163
6.38.3. Constraint Modifier Characters.....................................................................164
6.38.4. Constraints for Particular Machines..............................................................165
6.39. Controlling Names Used in Assembler Code ..............................................................173
6.40. Variables in Specified Registers................................................................................... 174
6.40.1. Defining Global Register Variables ..............................................................174
6.40.2. Specifying Registers for Local Variables......................................................175
6.41. Alternate Keywords ..................................................................................................... 176
6.42. Incomplete enumTypes ................................................................................................ 176
6.43. Function Names as Strings........................................................................................... 176
6.44. Getting the Return or Frame Address of a Function....................................................177
6.45. Using vector instructions through built-in functions ................................................... 178
6.46. Other built-in functions provided by GCC ..................................................................179
6.47. Built-in Functions Specific to Particular Target Machines ..........................................184
6.47.1. X86 Built-in Functions ................................................................................. 184
6.47.2. PowerPC AltiVec Built-in Functions ............................................................ 188
6.48. Pragmas Accepted by GCC ......................................................................................... 205
6.48.1. RS/6000 and PowerPC Pragmas ...................................................................205
6.48.2. Solaris Pragmas............................................................................................. 205
6.48.3. Tru64 Pragmas.............................................................................................. 206
6.49. Unnamed struct/union fields within structs/unions......................................................206
6.50. Thread-Local Storage...................................................................................................206
6.50.1. ISO/IEC 9899:1999 Edits for Thread-Local Storage.................................... 207
6.50.2. ISO/IEC 14882:1998 Edits for Thread-Local Storage.................................. 208
7. Extensions to the C++ Language ...............................................................................................211
7.1. Minimum and Maximum Operators in C++..................................................................211
7.2. When is a Volatile Object Accessed?............................................................................. 211
7.3. Restricting Pointer Aliasing........................................................................................... 212
7.4. Vague Linkage ............................................................................................................... 213
7.5. Declarations and Definitions in One Header ................................................................. 214
7.6. Where’s the Template?...................................................................................................215
7.7. Extracting the function pointer from a bound pointer to member function ................... 217
7.8. C++-Specific Variable, Function, and Type Attributes.................................................. 217
7.9. Java Exceptions..............................................................................................................218
7.10. Deprecated Features.....................................................................................................218
7.11. Backwards Compatibility.............................................................................................219
8. GNU Objective-C runtime features........................................................................................... 221
8.1. +load: Executing code before main.............................................................................. 221
8.1.1. What you can and what you cannot do in +load ...........................................222
8.2. Type encoding................................................................................................................222
8.3. Garbage Collection ........................................................................................................224
8.4. Constant string objects ................................................................................................... 225
8.5. compatibility_alias.........................................................................................................226
9. Binary Compatibility .................................................................................................................. 227
10. gcov--a Test Coverage Program..............................................................................................231
10.1. Introduction to gcov .................................................................................................... 231
10.2. Invoking gcov...............................................................................................................231
10.3. Using gcovwith GCC Optimization............................................................................ 236
10.4. Brief description of gcovdata files ..............................................................................236
11. Known Causes of Trouble with GCC...................................................................................... 237
11.1. Actual Bugs We Haven’t Fixed Yet ............................................................................. 237
11.2. Cross-Compiler Problems ............................................................................................ 237
11.3. Interoperation...............................................................................................................237
11.4. Problems Compiling Certain Programs ....................................................................... 240
11.5. Incompatibilities of GCC.............................................................................................240
11.6. Fixed Header Files ....................................................................................................... 243
11.7. Standard Libraries........................................................................................................ 243
11.8. Disappointments and Misunderstandings ....................................................................244
11.9. Common Misunderstandings with GNU C++ ............................................................. 245
11.9.1. Declare andDefine Static Members .............................................................. 245
11.9.2. Name lookup, templates, and accessing members of base classes ...............245
11.9.3. Temporaries May Vanish Before You Expect............................................... 246
11.9.4. Implicit Copy-Assignment for Virtual Bases................................................247
11.10. Caveats of using protoize.......................................................................................248
11.11. Certain Changes We Don’t Want to Make................................................................. 249
11.12. Warning Messages and Error Messages..................................................................... 251
12. Reporting Bugs.......................................................................................................................... 253
12.1. Have You Found a Bug? .............................................................................................. 253
12.2. How and where to Report Bugs ................................................................................... 253
13. How To Get Help with GCC ....................................................................................................255
14. Contributing to GCC Development......................................................................................... 257
15. Funding Free Software ............................................................................................................. 259
16. The GNU Project and GNU/Linux .......................................................................................... 261
17. GNU GENERAL PUBLIC LICENSE ....................................................................................263
17.1. Preamble ...................................................................................................................... 263
17.2. How to Apply These Terms to Your New Programs.................................................... 266
18. GNU Free Documentation License..........................................................................................269
18.1. ADDENDUM: How to use this License for your documents ..................................... 273
19. Contributors to GCC................................................................................................................ 275
Option Index....................................................................................................................................287
Keyword Index ................................................................................................................................ 301
Chapter 1.
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 GCC version 3.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. .
2 Chapter 1. Introduction
Chapter 2.
Compile C, C++, Objective-C, Ada, Fortran,
Java, or treelang
Several versions of the compiler (C, C++, Objective-C, Ada, Fortran, Java and treelang) are integrated;
this is why we use the name "GNU Compiler Collection". GCC can compile programs written in any
of these languages. The Ada, Fortran, Java and treelang compilers are described in separate manuals.
"GCC" is a common shorthand term for the GNU Compiler Collection. This is both the most general
name for the compiler, and the name used when the emphasis is on compiling C programs (as the
abbreviation formerly stood for "GNU C Compiler").
When referring to C++ compilation, it is usual to call the compiler "G++". Since there is only one
compiler, it is also accurate to call it "GCC" no matter what the language context; however, the term
"G++" is more useful when the emphasis is on compiling C++ programs.
Similarly, when we talk about Ada compilation, we usually call the compiler "GNAT", for the same
reasons.
We use the name "GCC" to refer to the compilation system as a whole, and more specifically to
the language-independent part of the compiler. For example, we refer to the optimization options as
affecting the behavior of "GCC" or sometimes just "the compiler".
Front ends for other languages, such as Mercury and Pascal exist but have not yet been integrated into
GCC. These front ends, like that for C++, are built in subdirectories of GCC and link to it. The result
is an integrated compiler that can compile programs written in C, C++, Objective-C, or any of the
languages for which you have installed front ends.
In this manual, we only discuss the options for the C, Objective-C, and C++ compilers and those of the
GCC core. Consult the documentation of the other front ends for the options to use when compiling
programs written in other languages.
G++ is a compiler, not merely a preprocessor. G++ builds object code directly from your C++ program source. There is no intermediate C version of the program. (By contrast, for example, some
other implementations use a program that generates a C program from your C++ source.) Avoiding
an intermediate C representation of the program means that you get better object code, and better
debugging information. The GNU debugger, GDB, works with this information in the object code to
give you comprehensive C++ source-level editing capabilities ().
4 Chapter 2. Compile C, C++, Objective-C, Ada, Fortran, Java, or treelang
Chapter 3.
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.
GCC supports three versions of the C standard, although support for the most recent version is not yet
complete.
The original ANSI C standard (X3.159-1989) was ratified in 1989 and published in 1990. This standard was ratified as an ISO standard (ISO/IEC 9899:1990) later in 1990. There were no technical
differences between these publications, although the sections of the ANSI standard were renumbered
and became clauses in the ISO standard. This standard, in both its forms, is commonly known as
C89, or occasionally as C90, from the dates of ratification. The ANSI standard, but not the ISO standard, also came with a Rationale document. To select this standard in GCC, use one of the options
-ansi, -std=c89 or -std=iso9899:1990; to obtain all the diagnostics required by the standard,
you should also specify -pedantic (or -pedantic-errors if you want them to be errors rather
than warnings). Refer to Section 4.4 Options Controlling C Dialect.
Errors in the 1990 ISO C standard were corrected in two Technical Corrigenda published in 1994 and
1996. GCC does not support the uncorrected version.
An amendment to the 1990 standard was published in 1995. This amendment added digraphs and
__STDC_VERSION__ to the language, but otherwise concerned the library. This amendment is com-
monly known as AMD1; the amended standard is sometimes known as C94 or C95. To select this
standard in GCC, use the option -std=iso9899:199409 (with, as for other standard versions,
-pedantic to receive all required diagnostics).
A new edition of the ISO C standard was published in 1999 as ISO/IEC 9899:1999, and
is commonly known as C99. GCC has incomplete support for this standard version; see
http://gcc.gnu.org/c99status.html for details. To select this standard, use -std=c99 or
-std=iso9899:1999. (While in development, drafts of this standard version were referred to as
C9X.)
Errors in the 1999 ISO C standard were corrected in a Technical Corrigendum published in 2001.
GCC does not support the uncorrected version.
By default, GCC provides some extensions to the C language that on rare occasions conflict with the
C standard. Refer to Chapter 6 Extensions to the C Language Family. Use of the -std options listed
above will disable these extensions where they conflict with the C standard version selected. You may
also select an extended version of the C language explicitly with -std=gnu89 (for C89 with GNU
extensions) or -std=gnu99 (for C99 with GNU extensions). The default, if no C language dialect
options are given, is -std=gnu89; this will change to -std=gnu99 in some future release when the
C99 support is complete. Some features that are part of the C99 standard are accepted as extensions
in C89 mode.
The ISO C standard defines (in clause 4) two classes of conforming implementation. A conforming
hosted implementation supports the whole standard including all the library facilities; a conforming
freestanding implementation is only required to provide certain library facilities: those in
float.h
,
limits.h
,
stdarg.h
, and
stddef.h
; since AMD1, also those in
iso646.h
; and in C99, also those in
stdbool.h
and
stdint.h
. In addition, complex
types, added in C99, are not required for freestanding implementations. The standard also defines
two environments for programs, a freestanding environment, required of all implementations and
which may not have library facilities beyond those required of freestanding implementations,
where the handling of program startup and termination are implementation-defined, and a hosted
environment, which is not required, in which all the library facilities are provided and startup is
through a function int main (void) or int main (int, char *[]). An OS kernel would be
6 Chapter 3. Language Standards Supported by GCC
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. Refer to Section 4.4 Options Controlling C Dialect.
GCC does not provide the library facilities required only of hosted implementations, nor yet all the
facilities required by C99 of freestanding implementations; to use the facilities of a hosted environment, you will need to find them elsewhere (for example, in the GNU C library). Refer to Section 11.7
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.
Some older ports of GCC are configured to use the BSD bcopy, bzero and bcmp functions instead,
but this is deprecated for new ports. 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
There is no formal written standard for Objective-C. The most authoritative manual is
"Object-Oriented Programming and the Objective-C Language", available at a number of web sites
• http://developer.apple.com/techpubs/macosx/Cocoa/ObjectiveC/ is a recent version
• http://www.toodarkpark.org/computers/objc/ is an older example
• http://www.gnustep.org has additional useful information
There is no standard for treelang, which is a sample language front end for GCC. Its only purpose
is as a sample for people wishing to write a new language for GCC. The language is documented in
gcc/treelang/treelang.texi which can be turned into info or HTML format.
, for information on standard conformance and compatibility of the Ada compiler.
, for details of the Fortran language supported by GCC.
, for details of compatibility between gcj and the Java Platform.
Chapter 4.
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.
Section 4.3 Compiling C++ Programs, for a summary of special options for compiling C++ programs.
The gcc program accepts options and file names as operands. Many options have multi-letter names;
therefore multiple single-letter options may not be grouped: -dr is very different from -d -r.
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.
Many options have long names starting with -f or with -W--for example, -fforce-mem,
-fstrength-reduce, -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.
Option Index, for an index to GCC’s options.
4.1. Option Summary
Here is a summary of all the options, grouped by type. Explanations are in the following sections.
Overall Options
Refer to Section 4.2 Options Controlling the Kind of Output.
-c -S -E -o file -pipe -pass-exit-codes
-x language -v -### --help --target-help --version
C Language Options
Refer to Section 4.4 Options Controlling C Dialect.
-ansi -std=standard -aux-info filename
-fno-asm -fno-builtin -fno-builtin-function
-fhosted -ffreestanding -fms-extensions
-trigraphs -no-integrated-cpp -traditional -traditional-cpp
-fallow-single-precision -fcond-mismatch
-fsigned-bitfields -fsigned-char
-funsigned-bitfields -funsigned-char
-fwritable-strings
8 Chapter 4. GCC Command Options
C++ Language Options
Refer to Section 4.5 Options Controlling C++ Dialect.
-fabi-version=n -fno-access-control -fcheck-new
-fconserve-space -fno-const-strings
-fno-elide-constructors
-fno-enforce-eh-specs -fexternal-templates
-falt-external-templates
-ffor-scope -fno-for-scope -fno-gnu-keywords
-fno-implicit-templates
-fno-implicit-inline-templates
-fno-implement-inlines -fms-extensions
-fno-nonansi-builtins -fno-operator-names
-fno-optional-diags -fpermissive
-frepo -fno-rtti -fstats -ftemplate-depth-n
-fuse-cxa-atexit -fvtable-gc -fno-weak -nostdinc++
-fno-default-inline -Wabi -Wctor-dtor-privacy
-Wnon-virtual-dtor -Wreorder
-Weffc++ -Wno-deprecated
-Wno-non-template-friend -Wold-style-cast
-Woverloaded-virtual -Wno-pmf-conversions
-Wsign-promo -Wsynth
Objective-C Language Options
Refer to Section 4.6 Options Controlling Objective-C Dialect.
-fconstant-string-class=class-name
-fgnu-runtime -fnext-runtime -gen-decls
-Wno-protocol -Wselector -Wundeclared-selector
Language Independent Options
Refer to Section 4.7 Options to Control Diagnostic Messages Formatting.
-fmessage-length=n
-fdiagnostics-show-location=[once|every-line]
Warning Options
Refer to Section 4.8 Options to Request or Suppress Warnings.
-fsyntax-only -pedantic -pedantic-errors
-w -Wextra -Wall -Waggregate-return
-Wcast-align -Wcast-qual -Wchar-subscripts -Wcomment
-Wconversion -Wno-deprecated-declarations
-Wdisabled-optimization -Wno-div-by-zero -Werror
-Wfloat-equal -Wformat -Wformat=2
-Wformat-nonliteral -Wformat-security
-Wimplicit -Wimplicit-int
-Wimplicit-function-declaration
-Werror-implicit-function-declaration
-Wimport -Winline -Winvalid-pch -Wno-endif-labels
-Wno-invalid-offsetof
-Wlarger-than-len -Wlong-long
-Wmain -Wmissing-braces
-Wmissing-format-attribute -Wmissing-noreturn
-Wno-multichar -Wno-format-extra-args -Wno-format-y2k
-Wno-import -Wnonnull -Wpacked -Wpadded
-Wparentheses -Wpointer-arith -Wredundant-decls
-Wreturn-type -Wsequence-point -Wshadow
-Wsign-compare -Wstrict-aliasing
-Wswitch -Wswitch-default -Wswitch-enum
-Wsystem-headers -Wtrigraphs -Wundef -Wuninitialized
-Wunknown-pragmas -Wunreachable-code
-Wunused -Wunused-function -Wunused-label -Wunused-parameter
Chapter 4. GCC Command Options 9
-Wunused-value -Wunused-variable -Wwrite-strings
C-only Warning Options
-Wbad-function-cast -Wmissing-declarations
-Wmissing-prototypes -Wnested-externs
-Wstrict-prototypes -Wtraditional
Debugging Options
Refer to Section 4.9 Options for Debugging Your Program or GCC.
-dletters -dumpspecs -dumpmachine -dumpversion
-fdump-unnumbered -fdump-translation-unit[-n]
-fdump-class-hierarchy[-n]
-fdump-tree-original[-n]
-fdump-tree-optimized[-n]
-fdump-tree-inlined[-n]
-feliminate-dwarf2-dups -feliminate-unused-debug-types
-fmem-report -fprofile-arcs
-frandom-seed=string -fsched-verbose=n
-ftest-coverage -ftime-report
-g -glevel -gcoff -gdwarf -gdwarf-1 -gdwarf-1+ -gdwarf-2
-ggdb -gstabs -gstabs+ -gvms -gxcoff -gxcoff+
-p -pg -print-file-name=library -print-libgcc-file-name
-print-multi-directory -print-multi-lib
-print-prog-name=program -print-search-dirs -Q
-save-temps -time
Optimization Options
Refer to Section 4.10 Options That Control Optimization.
-falign-functions=n -falign-jumps=n
-falign-labels=n -falign-loops=n
-fbranch-probabilities -fcaller-saves -fcprop-registers
-fcse-follow-jumps -fcse-skip-blocks -fdata-sections
-fdelayed-branch -fdelete-null-pointer-checks
-fexpensive-optimizations -ffast-math -ffloat-store
-fforce-addr -fforce-mem -ffunction-sections
-fgcse -fgcse-lm -fgcse-sm -floop-optimize -fcrossjumping
-fif-conversion -fif-conversion2
-finline-functions -finline-limit=n -fkeep-inline-functions
-fkeep-static-consts -fmerge-constants -fmerge-all-constants
-fmove-all-movables -fnew-ra -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
-funsafe-math-optimizations -ffinite-math-only
-fno-trapping-math -fno-zero-initialized-in-bss
-fomit-frame-pointer -foptimize-register-move
-foptimize-sibling-calls -fprefetch-loop-arrays
-freduce-all-givs -fregmove -frename-registers
-freorder-blocks -freorder-functions
-frerun-cse-after-loop -frerun-loop-opt
-fschedule-insns -fschedule-insns2
-fno-sched-interblock -fno-sched-spec -fsched-spec-load
-fsched-spec-load-dangerous -fsched2-use-superblocks
-fsched2-use-traces -fsignaling-nans
-fsingle-precision-constant -fssa -fssa-ccp -fssa-dce
-fstrength-reduce -fstrict-aliasing -ftracer -fthread-jumps
-funroll-all-loops -funroll-loops -fpeel-loops
-funswitch-loops -fold-unroll-loops -fold-unroll-all-loops
--param name=value
-O -O0 -O1 -O2 -O3 -Os
10 Chapter 4. GCC Command Options
Preprocessor Options
Refer to Section 4.11 Options Controlling the Preprocessor.
-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
-M -MM -MF -MG -MP -MQ -MT -nostdinc -P -remap
-trigraphs -undef -Umacro -Wp,option
-Xpreprocessor option
Assembler Option
Refer to Section 4.12 Passing Options to the Assembler.
-Wa,option -Xassembler option
Linker Options
Refer to Section 4.13 Options for Linking.
object-file-name -llibrary
-nostartfiles -nodefaultlibs -nostdlib -pie
-s -static -static-libgcc -shared -shared-libgcc -symbolic
-Wl,option -Xlinker option
-u symbol
Directory Options
Refer to Section 4.14 Options for Directory Search.
-Bprefix -Idir -I- -Ldir -specs=file
Target Options
Refer to Section 4.16 Specifying Target Machine and Compiler Version.
-V version -b machine
Machine Dependent Options
Refer to Section 4.17 Hardware Models and Configurations.
SPARC Options
-mcpu=cpu-type
-mtune=cpu-type
-mcmodel=code-model
-m32 -m64
-mapp-regs -mbroken-saverestore -mcypress
-mfaster-structs -mflat
-mfpu -mhard-float -mhard-quad-float
-mimpure-text -mlive-g0 -mno-app-regs
-mno-faster-structs -mno-flat -mno-fpu
-mno-impure-text -mno-stack-bias -mno-unaligned-doubles
-msoft-float -msoft-quad-float -msparclite -mstack-bias
-msupersparc -munaligned-doubles -mv8
RS/6000 and PowerPC Options
-mcpu=cpu-type
-mtune=cpu-type
-mpower -mno-power -mpower2 -mno-power2
-mpowerpc -mpowerpc64 -mno-powerpc
-maltivec -mno-altivec
-mpowerpc-gpopt -mno-powerpc-gpopt
Chapter 4. GCC Command Options 11
-mpowerpc-gfxopt -mno-powerpc-gfxopt
-mnew-mnemonics -mold-mnemonics
-mfull-toc -mminimal-toc -mno-fp-in-toc -mno-sum-in-toc
-m64 -m32 -mxl-call -mno-xl-call -mpe
-malign-power -malign-natural
-msoft-float -mhard-float -mmultiple -mno-multiple
-mstring -mno-string -mupdate -mno-update
-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
-mcall-sysv -mcall-netbsd
-maix-struct-return -msvr4-struct-return
-mabi=altivec -mabi=no-altivec
-mabi=spe -mabi=no-spe
-misel=yes -misel=no
-mspe=yes -mspe=no
-mfloat-gprs=yes -mfloat-gprs=no
-mprototype -mno-prototype
-msim -mmvme -mads -myellowknife -memb -msdata
-msdata=opt -mvxworks -mwindiss -G num -pthread
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 -msvr3-shlib
-mno-wide-multiply -mrtd -malign-double
-mpreferred-stack-boundary=num
-mmmx -msse -msse2 -m3dnow
-mthreads -mno-align-stringops -minline-all-stringops
-mpush-args -maccumulate-outgoing-args -m128bit-long-double
-m96bit-long-double -mregparm=num -momit-leaf-frame-pointer
-mno-red-zone -mno-tls-direct-seg-refs
-mcmodel=code-model
-m32 -m64
IA-64 Options
-mbig-endian -mlittle-endian -mgnu-as -mgnu-ld -mno-pic
-mvolatile-asm-stop -mb-step -mregister-names -mno-sdata
-mconstant-gp -mauto-pic -minline-float-divide-min-latency
-minline-float-divide-max-throughput
-minline-int-divide-min-latency
-minline-int-divide-max-throughput -mno-dwarf2-asm
-mfixed-range=register-range
S/390 and zSeries Options
-mtune=cpu-type -march=cpu-type
-mhard-float -msoft-float -mbackchain -mno-backchain
-msmall-exec -mno-small-exec -mmvcle -mno-mvcle
-m64 -m31 -mdebug -mno-debug -mesa -mzarch
Code Generation Options
Refer to Section 4.18 Options for Code Generation Conventions.
-fcall-saved-reg -fcall-used-reg
-ffixed-reg -fexceptions
-fnon-call-exceptions -funwind-tables
-fasynchronous-unwind-tables
-finhibit-size-directive -finstrument-functions
-fno-common -fno-ident -fno-gnu-linker
-fpcc-struct-return -fpic -fPIC -fpie -fPIE
12 Chapter 4. GCC Command Options
-freg-struct-return -fshared-data -fshort-enums
-fshort-double -fshort-wchar
-fverbose-asm -fpack-struct -fstack-check
-fstack-limit-register=reg -fstack-limit-symbol=sym
-fargument-alias -fargument-noalias
-fargument-noalias-global -fleading-underscore
-ftls-model=model
-ftrapv -fwrapv -fbounds-check
4.2. Options Controlling the Kind of Output
Compilation can involve up to four stages: preprocessing, compilation proper, assembly and linking,
always in that order. The first three stages apply to an individual source file, and end by producing an
object file; 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 library libobjc.a to make an
Objective-C program work.
file.mi
Objective-C source code which should not be preprocessed.
file.h
C or C++ header file to be turned into a precompiled header.
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.hh
file.H
C++ header file to be turned into a precompiled header.
Chapter 4. GCC Command Options 13
file.f
file.for
file.FOR
Fortran source code which should not be preprocessed.
file.F
file.fpp
file.FPP
Fortran source code which must be preprocessed (with the traditional preprocessor).
file.r
Fortran source code which must be preprocessed with a RATFOR preprocessor (not included
with GCC).
, for more details of the handling of Fortran input files.
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
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 objc-cpp-output
assembler assembler-with-cpp
ada
f77 f77-cpp-input ratfor
java
treelang
-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).
14 Chapter 4. GCC Command Options
-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.
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.
Since only one output file can be specified, it does not make sense to use -o when compiling
more than one input file, unless you are producing an executable file as output.
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, 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 all command arguments are quoted. This is
useful for shell scripts to capture the driver-generated command lines.
Chapter 4. GCC Command Options 15
-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
is also specified 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.
-version
Display the version number and copyrights of the invoked GCC.
4.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 or .H; 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, C++ programs often require class libraries as well as a compiler that understands the C++
language--and under some circumstances, you might want to compile programs or header files from
standard input, or otherwise without a suffix that flags them as C++ programs. You might also like to
precompile a C header file with a .h extension to be used in C++ compilations. g++ is a program that
calls GCC with the default language set to C++, and automatically specifies linking against the C++
library. On many systems, 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. Section 4.4 Options Controlling C
Dialect, for explanations of options for languages related to C. Section 4.5 Options Controlling C++
Dialect, for explanations of options that are meaningful only for C++ programs.
4.4. Options Controlling C Dialect
The following options control the dialect of C (or languages derived from C, such as C++ and
Objective-C) that the compiler accepts:
-ansi
In C mode, support all ISO C90 programs. In C++ mode, remove GNU extensions that conflict
with ISO C++.
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.
16 Chapter 4. GCC Command Options
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. Refer to Section 4.8 Options to Request or
Suppress Warnings.
The macro __STRICT_ANSI__ is predefined when the -ansi option is used. Some header files
may notice this macro and refrain from declaring certain functions or defining certain macros
that the ISO standard doesn’t call for; this is to avoid interfering with any programs that might
use these names for other things.
Functions which would normally be built in but do not have semantics defined by ISO C (such
as alloca and ffs) are not built-in functions with -ansi is used. Refer to Section 6.46 Other
built-in functions provided by GCC, for details of the functions affected.
-std=
Determine the language standard. This option is currently only supported when compiling C or
C++. A value for this option must be provided; possible values are
c89
iso9899:1990
ISO C90 (same as -ansi).
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/c99status.html for more information. The names c9x and
iso9899:199x are deprecated.
gnu89
Default, ISO C90 plus GNU extensions (including some C99 features).
gnu99
gnu9x
ISO C99 plus GNU extensions. When ISO C99 is fully implemented in GCC, this will
become the default. The name gnu9x is deprecated.
c++98
The 1998 ISO C++ standard plus amendments.
gnu++98
The same as -std=c++98 plus GNU extensions. This is the default for C++ code.
Even when this option is not specified, you can still use some of the features of newer standards in so far as they do not conflict with previous C standards. For example, you may use
__restrict__ even when -std=c99 is not specified.
Chapter 4. GCC Command Options 17
The -std options specifying some version of ISO C have the same effects as -ansi, except that
features that were not in ISO C90 but are in the specified version (for example, // comments and
the inline keyword in ISO C99) are not disabled.
Chapter 3 Language Standards Supported by GCC, for details of these standard versions.
-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
Do not recognize built-in functions that do not begin with __builtin_ as prefix. Refer to Section 6.46 Other built-in functions provided by GCC, 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.
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 this 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.
18 Chapter 4. GCC Command Options
-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.
Chapter 3 Language Standards Supported by GCC, for details of freestanding and hosted environments.
-fms-extensions
Accept some non-standard constructs used in Microsoft header files.
-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++.
-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.
Chapter 4. GCC Command Options 19
-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.
-fwritable-strings
Store string constants in the writable data segment and don’t uniquize them. This is for compatibility with old programs which assume they can write into string constants.
Writing into string constants is a very bad idea; "constants" should be constant.
4.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 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 1.
-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.
20 Chapter 4. GCC Command Options
This option is no longer useful on most targets, now that support has been added for putting
variables into BSS without making them common.
-fno-const-strings
Give string constants type char * instead of type const char *. By default, G++ uses type
const char * as required by the standard. Even if you use -fno-const-strings,you cannot
actually modify the value of a string constant, unless you also use -fwritable-strings.
This option might be removed in a future release of G++. For maximum portability, you should
structure your code so that it works with string constants that have type const char *.
-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
Do not 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. The compiler will still optimize based on the exception specifications.
-fexternal-templates
Cause #pragma interface and implementation to apply to template instantiation; template
instances are emitted or not according to the location of the template definition. Refer to Section
7.6 Where’s the Template?, for more information.
This option is deprecated.
-falt-external-templates
Similar to -fexternal-templates, but template instances are emitted or not according to the
place where they are first instantiated. Section 7.6 Where’s the Template?, for more information.
This option is deprecated.
-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 (that is, by use); only
emit code for explicit instantiations. Section 7.6 Where’s the Template?, for more information.
Chapter 4. GCC Command Options 21
-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.
-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 messages about nonconformant code from errors to warnings. By default, G++ effectively sets -pedantic-errors without -pedantic; this option reverses that. This behavior
and this option are superseded by -pedantic, which works as it does for GNU C.
-frepo
Enable automatic template instantiation at link time. This option also implies
-fno-implicit-templates. Refer to Section 7.6 Where’s the Template?, 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.
-fstats
Emit statistics about front-end processing at the end of the compilation. This information is
generally only useful to the G++ development team.
-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.
22 Chapter 4. GCC Command Options
-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.
-fvtable-gc
Emit special relocations for vtables and virtual function references so that the linker can identify unused virtual functions and zero out vtable slots that refer to them. This is most useful
with -ffunction-sections and -Wl,-gc-sections, in order to also discard the functions
themselves.
This optimization requires GNU as and GNU ld. Not all systems support this option.
-Wl,-gc-sections is ignored without -static.
-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. Section 4.10 Options That
Control Optimization. Note that these functions will have linkage like inline functions; they just
won’t be inlined by default.
-Wabi (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 at this point 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 asA::f1; other compilers will not. You
can avoid this problem by explicitly padding A so that its size is a multiple of the byte size on
your platform; that will cause G++ and other compilers to layout B identically.
• 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; };
Chapter 4. GCC Command Options 23
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) {}
templatetemplatetypenameclass Q
void f(typename Qint::X) {}
Instantiations of these templates may be mangled incorrectly.
-Wctor-dtor-privacy (C++ only)
Warn when a class seems unusable, because all the constructors or destructors in a class are
private and the class has no friends or public static member functions.
-Wnon-virtual-dtor (C++ only)
Warn when a class declares a non-virtual destructor that should probably be virtual, because it
looks like the class will be used polymorphically. This warning is enabled by -Wall.
-Wreorder (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) { }
};
Here the compiler will warn that the member initializers for i and j will be rearranged to match
the declaration order of the members. This warning is enabled by -Wall.
The following -W... options are not affected by -Wall.
24 Chapter 4. GCC Command Options
-Weffc++ (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.
and 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 ,.
If you use this option, you should be aware that the standard library headers do not obey all of
these guidelines; you can use grep -v to filter out those warnings.
-Wno-deprecated (C++ only)
Do not warn about usage of deprecated features. Refer to Section 7.10 Deprecated Features.
-Wno-non-template-friend (C++ only)
Disable warnings when non-templatized friend functions are declared within a template. With
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++ only)
Warn if an old-style (C-style) cast to a non-void type is used within a C++ program. The newstyle casts (static_cast, reinterpret_cast, and const_cast) are less vulnerable to unintended effects, and much easier to grep for.
-Woverloaded-virtual (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 this:
B* b;
b-
f();
will fail to compile.
Loading...