Red Hat ENTERPRISE LINUX 3 - USING BINUTILS Manual

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: [phone]
Phone: [phone]
Fax: [phone]
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 redistributor to 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 [email protected] 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++ pro-
gram 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 stan-
dard 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 stan-
dard, 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 implemen-
tation, defining __STDC_HOSTED__ as 1and 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 0and 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 environ-
ment, 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 excep-
tions. 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 op-
tion 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, sub-
program, 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.