Using the GNU Compiler Collection

For gcc version 7.5.0

(GCC)

Richard M. Stallman and the GCC Developer Community

Published by:
GNU Press Website: http://www.gnupress.org
a division of the General: [email protected]
Free Software Foundation Orders: [email protected]
51 Franklin Street, Fifth Floor Tel 617-542-5942
Boston, MA 02110-1301 USA Fax 617-542-2652

Last printed October 2003 for GCC 3.3.1.

Printed copies are available for $45 each.

Copyright c 1988-2017 Free Software Foundation, Inc.

Permission is granted to copy, distribute and/or modify this document under the terms of
the GNU Free Documentation License, Version 1.3 or any later version published by the
Free Software Foundation; with the Invariant Sections being “Funding Free Software”, the
Front-Cover Texts being (a) (see below), and with the Back-Cover Texts being (b) (see
below). A copy of the license is included in the section entitled “GNU Free Documentation
License”.
(a) The FSF’s Front-Cover Text is:
A GNU Manual
(b) The FSF’s Back-Cover Text is:
You have freedom to copy and modify this GNU Manual, like GNU software. Copies
published by the Free Software Foundation raise funds for GNU development.
 i

Short Contents
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1 Programming Languages Supported by GCC . . . . . . . . . . . . . . . 3
2 Language Standards Supported by GCC . . . . . . . . . . . . . . . . . . 5
3 GCC Command Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
4 C Implementation-Defined Behavior . . . . . . . . . . . . . . . . . . . . 395
5 C++ Implementation-Defined Behavior . . . . . . . . . . . . . . . . . 403
6 Extensions to the C Language Family . . . . . . . . . . . . . . . . . . . 405
7 Extensions to the C++ Language . . . . . . . . . . . . . . . . . . . . . . 737
8 GNU Objective-C Features . . . . . . . . . . . . . . . . . . . . . . . . . . . 751
9 Binary Compatibility . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 767
10 gcov—a Test Coverage Program . . . . . . . . . . . . . . . . . . . . . . . 771
11 gcov-tool—an Offline Gcda Profile Processing Tool . . . . . . . 781
12 gcov-dump—an Offline Gcda and Gcno Profile Dump Tool . . 785
13 Known Causes of Trouble with GCC . . . . . . . . . . . . . . . . . . . . 787
14 Reporting Bugs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 803
15 How To Get Help with GCC . . . . . . . . . . . . . . . . . . . . . . . . . . 805
16 Contributing to GCC Development . . . . . . . . . . . . . . . . . . . . . 807
Funding Free Software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 809
The GNU Project and GNU/Linux . . . . . . . . . . . . . . . . . . . . . . . . . 811
GNU General Public License . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 813
GNU Free Documentation License . . . . . . . . . . . . . . . . . . . . . . . . . 825
Contributors to GCC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 833
Option Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 851
Keyword Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 875
 iii

Table of Contents

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

1 Programming Languages Supported by GCC

................................................. 3

2 Language Standards Supported by GCC . . . . . 5

2.1 C Language . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.2 C++ Language . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.3 Objective-C and Objective-C++ Languages . . . . . . . . . . . . . . . . . . . . 7
2.4 Go Language . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.5 HSA Intermediate Language (HSAIL) . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.6 References for Other Languages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

3 GCC Command Options . . . . . . . . . . . . . . . . . . . . . . . 9

3.1 Option Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.2 Options Controlling the Kind of Output . . . . . . . . . . . . . . . . . . . . . . . 27
3.3 Compiling C++ Programs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.4 Options Controlling C Dialect . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.5 Options Controlling C++ Dialect . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
3.6 Options Controlling Objective-C and Objective-C++ Dialects . . 53
3.7 Options to Control Diagnostic Messages Formatting . . . . . . . . . . . 56
3.8 Options to Request or Suppress Warnings . . . . . . . . . . . . . . . . . . . . . 59
3.9 Options for Debugging Your Program . . . . . . . . . . . . . . . . . . . . . . . . 101
3.10 Options That Control Optimization . . . . . . . . . . . . . . . . . . . . . . . . . 106
3.11 Program Instrumentation Options . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
3.12 Options Controlling the Preprocessor. . . . . . . . . . . . . . . . . . . . . . . . 176
3.13 Passing Options to the Assembler . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
3.14 Options for Linking . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
3.15 Options for Directory Search . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
3.16 Options for Code Generation Conventions . . . . . . . . . . . . . . . . . . . 191
3.17 GCC Developer Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
3.18 Machine-Dependent Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
3.18.1 AArch64 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
3.18.1.1 ‘-march’ and ‘-mcpu’ Feature Modifiers . . . . . . . . . . . . 220
3.18.2 Adapteva Epiphany Options . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
3.18.3 ARC Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
3.18.4 ARM Options. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232
3.18.5 AVR Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238
3.18.5.1 EIND and Devices with More Than 128 Ki Bytes of
Flash. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243
3.18.5.2 Handling of the RAMPD, RAMPX, RAMPY and RAMPZ Special
Function Registers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244
iv Using the GNU Compiler Collection (GCC)

3.18.5.3 AVR Built-in Macros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245

3.18.6 Blackfin Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247
3.18.7 C6X Options. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250
3.18.8 CRIS Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250
3.18.9 CR16 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252
3.18.10 Darwin Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252
3.18.11 DEC Alpha Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256
3.18.12 FR30 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260
3.18.13 FT32 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261
3.18.14 FRV Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261
3.18.15 GNU/Linux Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265
3.18.16 H8/300 Options. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265
3.18.17 HPPA Options. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266
3.18.18 IA-64 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269
3.18.19 LM32 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272
3.18.20 M32C Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273
3.18.21 M32R/D Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273
3.18.22 M680x0 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275
3.18.23 MCore Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280
3.18.24 MeP Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281
3.18.25 MicroBlaze Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282
3.18.26 MIPS Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284
3.18.27 MMIX Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 298
3.18.28 MN10300 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299
3.18.29 Moxie Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300
3.18.30 MSP430 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300
3.18.31 NDS32 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302
3.18.32 Nios II Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303
3.18.33 Nvidia PTX Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307
3.18.34 PDP-11 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 308
3.18.35 picoChip Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309
3.18.36 PowerPC Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310
3.18.37 RISC-V Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310
3.18.38 RL78 Options. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312
3.18.39 IBM RS/6000 and PowerPC Options . . . . . . . . . . . . . . . . . . 313
3.18.40 RX Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330
3.18.41 S/390 and zSeries Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333
3.18.42 Score Options. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337
3.18.43 SH Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337
3.18.44 Solaris 2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343
3.18.45 SPARC Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344
3.18.46 SPU Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350
3.18.47 Options for System V . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352
3.18.48 TILE-Gx Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352
3.18.49 TILEPro Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353
3.18.50 V850 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353
3.18.51 VAX Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355
3.18.52 Visium Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356
 v

3.18.53 VMS Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357

3.18.54 VxWorks Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357
3.18.55 x86 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357
3.18.56 x86 Windows Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379
3.18.57 Xstormy16 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 380
3.18.58 Xtensa Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 380
3.18.59 zSeries Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 382
3.19 Specifying Subprocesses and the Switches to Pass to Them . . 382
3.20 Environment Variables Affecting GCC . . . . . . . . . . . . . . . . . . . . . . 389
3.21 Using Precompiled Headers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 392

4 C Implementation-Defined Behavior . . . . . . . 395

4.1 Translation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395
4.2 Environment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395
4.3 Identifiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395
4.4 Characters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396
4.5 Integers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 397
4.6 Floating Point . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 397
4.7 Arrays and Pointers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 398
4.8 Hints . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 399
4.9 Structures, Unions, Enumerations, and Bit-Fields . . . . . . . . . . . . . 399
4.10 Qualifiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 400
4.11 Declarators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401
4.12 Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401
4.13 Preprocessing Directives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401
4.14 Library Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 402
4.15 Architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 402
4.16 Locale-Specific Behavior . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 402

5 C++ Implementation-Defined Behavior . . . 403

5.1 Conditionally-Supported Behavior . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403
5.2 Exception Handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403

6 Extensions to the C Language Family . . . . . . 405

6.1 Statements and Declarations in Expressions . . . . . . . . . . . . . . . . . . 405
6.2 Locally Declared Labels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 406
6.3 Labels as Values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 407
6.4 Nested Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 408
6.5 Constructing Function Calls . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 410
6.6 Referring to a Type with typeof . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412
6.7 Conditionals with Omitted Operands . . . . . . . . . . . . . . . . . . . . . . . . . 413
6.8 128-bit Integers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 414
6.9 Double-Word Integers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 414
6.10 Complex Numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 414
6.11 Additional Floating Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415
6.12 Half-Precision Floating Point . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416
6.13 Decimal Floating Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417
vi Using the GNU Compiler Collection (GCC)

6.14 Hex Floats. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417

6.15 Fixed-Point Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 418
6.16 Named Address Spaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 419
6.16.1 AVR Named Address Spaces . . . . . . . . . . . . . . . . . . . . . . . . . . . 419
6.16.2 M32C Named Address Spaces . . . . . . . . . . . . . . . . . . . . . . . . . . 421
6.16.3 RL78 Named Address Spaces . . . . . . . . . . . . . . . . . . . . . . . . . . . 421
6.16.4 SPU Named Address Spaces . . . . . . . . . . . . . . . . . . . . . . . . . . . 421
6.16.5 x86 Named Address Spaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . 421
6.17 Arrays of Length Zero . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 421
6.18 Structures with No Members . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 423
6.19 Arrays of Variable Length . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 423
6.20 Macros with a Variable Number of Arguments. . . . . . . . . . . . . . . 424
6.21 Slightly Looser Rules for Escaped Newlines . . . . . . . . . . . . . . . . . . 425
6.22 Non-Lvalue Arrays May Have Subscripts . . . . . . . . . . . . . . . . . . . . 425
6.23 Arithmetic on void- and Function-Pointers . . . . . . . . . . . . . . . . . . 425
6.24 Pointers to Arrays with Qualifiers Work as Expected . . . . . . . . 425
6.25 Non-Constant Initializers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426
6.26 Compound Literals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426
6.27 Designated Initializers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 427
6.28 Case Ranges . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 428
6.29 Cast to a Union Type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 429
6.30 Mixed Declarations and Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 429
6.31 Declaring Attributes of Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . 429
6.31.1 Common Function Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . 430
6.31.2 AArch64 Function Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . 445
6.31.2.1 Inlining rules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 447
6.31.3 ARC Function Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 447
6.31.4 ARM Function Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 448
6.31.5 AVR Function Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 449
6.31.6 Blackfin Function Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . 450
6.31.7 CR16 Function Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 451
6.31.8 Epiphany Function Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . 451
6.31.9 H8/300 Function Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 452
6.31.10 IA-64 Function Attributes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 453
6.31.11 M32C Function Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 453
6.31.12 M32R/D Function Attributes . . . . . . . . . . . . . . . . . . . . . . . . . 454
6.31.13 m68k Function Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 454
6.31.14 MCORE Function Attributes . . . . . . . . . . . . . . . . . . . . . . . . . 455
6.31.15 MeP Function Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 455
6.31.16 MicroBlaze Function Attributes . . . . . . . . . . . . . . . . . . . . . . . 455
6.31.17 Microsoft Windows Function Attributes . . . . . . . . . . . . . . . 456
6.31.18 MIPS Function Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 457
6.31.19 MSP430 Function Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . 459
6.31.20 NDS32 Function Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . 460
6.31.21 Nios II Function Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . 461
6.31.22 Nvidia PTX Function Attributes . . . . . . . . . . . . . . . . . . . . . . 462
6.31.23 PowerPC Function Attributes . . . . . . . . . . . . . . . . . . . . . . . . . 462
6.31.24 RL78 Function Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 465
 vii

6.31.25 RX Function Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 466

6.31.26 S/390 Function Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 466
6.31.27 SH Function Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 467
6.31.28 SPU Function Attributes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 469
6.31.29 Symbian OS Function Attributes . . . . . . . . . . . . . . . . . . . . . . 469
6.31.30 V850 Function Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 469
6.31.31 Visium Function Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . 469
6.31.32 x86 Function Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 469
6.31.33 Xstormy16 Function Attributes . . . . . . . . . . . . . . . . . . . . . . . 474
6.32 Specifying Attributes of Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . 474
6.32.1 Common Variable Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . 475
6.32.2 AVR Variable Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 478
6.32.3 Blackfin Variable Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 480
6.32.4 H8/300 Variable Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 481
6.32.5 IA-64 Variable Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 481
6.32.6 M32R/D Variable Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . 481
6.32.7 MeP Variable Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 482
6.32.8 Microsoft Windows Variable Attributes . . . . . . . . . . . . . . . . . 482
6.32.9 MSP430 Variable Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . 483
6.32.10 Nvidia PTX Variable Attributes . . . . . . . . . . . . . . . . . . . . . . 484
6.32.11 PowerPC Variable Attributes . . . . . . . . . . . . . . . . . . . . . . . . . 484
6.32.12 RL78 Variable Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 484
6.32.13 SPU Variable Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 484
6.32.14 V850 Variable Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 484
6.32.15 x86 Variable Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 484
6.32.16 Xstormy16 Variable Attributes . . . . . . . . . . . . . . . . . . . . . . . . 485
6.33 Specifying Attributes of Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 485
6.33.1 Common Type Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 485
6.33.2 ARM Type Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 491
6.33.3 MeP Type Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 491
6.33.4 PowerPC Type Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 491
6.33.5 SPU Type Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 491
6.33.6 x86 Type Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 491
6.34 Label Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 492
6.35 Enumerator Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 493
6.36 Statement Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 493
6.37 Attribute Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 494
6.38 Prototypes and Old-Style Function Definitions . . . . . . . . . . . . . . 497
6.39 C++ Style Comments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 498
6.40 Dollar Signs in Identifier Names . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 498
6.41 The Character ESC in Constants . . . . . . . . . . . . . . . . . . . . . . . . . . . . 498
6.42 Inquiring on Alignment of Types or Variables . . . . . . . . . . . . . . . 498
6.43 An Inline Function is As Fast As a Macro . . . . . . . . . . . . . . . . . . . 499
6.44 When is a Volatile Object Accessed? . . . . . . . . . . . . . . . . . . . . . . . . 500
6.45 How to Use Inline Assembly Language in C Code . . . . . . . . . . . 501
6.45.1 Basic Asm — Assembler Instructions Without Operands
........................................................... 501
viii Using the GNU Compiler Collection (GCC)

6.45.2 Extended Asm - Assembler Instructions with C Expression

Operands. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 503
6.45.2.1 Volatile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 505
6.45.2.2 Assembler Template . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 507
6.45.2.3 Output Operands . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 508
6.45.2.4 Flag Output Operands . . . . . . . . . . . . . . . . . . . . . . . . . . . . 511
6.45.2.5 Input Operands . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 512
6.45.2.6 Clobbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 513
6.45.2.7 Goto Labels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 514
6.45.2.8 x86 Operand Modifiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . 516
6.45.2.9 x86 Floating-Point asm Operands . . . . . . . . . . . . . . . . . . 517
6.45.3 Constraints for asm Operands . . . . . . . . . . . . . . . . . . . . . . . . . . 518
6.45.3.1 Simple Constraints . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 518
6.45.3.2 Multiple Alternative Constraints . . . . . . . . . . . . . . . . . . 520
6.45.3.3 Constraint Modifier Characters . . . . . . . . . . . . . . . . . . . . 521
6.45.3.4 Constraints for Particular Machines . . . . . . . . . . . . . . . 521
6.45.4 Controlling Names Used in Assembler Code . . . . . . . . . . . . 550
6.45.5 Variables in Specified Registers . . . . . . . . . . . . . . . . . . . . . . . . . 550
6.45.5.1 Defining Global Register Variables . . . . . . . . . . . . . . . . . 550
6.45.5.2 Specifying Registers for Local Variables. . . . . . . . . . . . 552
6.45.6 Size of an asm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 553
6.46 Alternate Keywords . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 553
6.47 Incomplete enum Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 553
6.48 Function Names as Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 554
6.49 Getting the Return or Frame Address of a Function . . . . . . . . . 554
6.50 Using Vector Instructions through Built-in Functions . . . . . . . . 556
6.51 Support for offsetof . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 558
6.52 Legacy __sync Built-in Functions for Atomic Memory Access
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 558
6.53 Built-in Functions for Memory Model Aware Atomic Operations
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 560
6.54 Built-in Functions to Perform Arithmetic with Overflow Checking
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 565
6.55 x86-Specific Memory Model Extensions for Transactional Memory
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 567
6.56 Object Size Checking Built-in Functions . . . . . . . . . . . . . . . . . . . . . 567
6.57 Pointer Bounds Checker Built-in Functions . . . . . . . . . . . . . . . . . . 569
6.58 Cilk Plus C/C++ Language Extension Built-in Functions . . . 571
6.59 Other Built-in Functions Provided by GCC . . . . . . . . . . . . . . . . . 572
6.60 Built-in Functions Specific to Particular Target Machines . . . . 584
6.60.1 AArch64 Built-in Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 584
6.60.2 Alpha Built-in Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 584
6.60.3 Altera Nios II Built-in Functions . . . . . . . . . . . . . . . . . . . . . . . 585
6.60.4 ARC Built-in Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 587
6.60.5 ARC SIMD Built-in Functions . . . . . . . . . . . . . . . . . . . . . . . . . 589
6.60.6 ARM iWMMXt Built-in Functions . . . . . . . . . . . . . . . . . . . . . 593
6.60.7 ARM C Language Extensions (ACLE) . . . . . . . . . . . . . . . . . 595
6.60.8 ARM Floating Point Status and Control Intrinsics . . . . . . 596
 ix

6.60.9 ARM ARMv8-M Security Extensions . . . . . . . . . . . . . . . . . . . 596

6.60.10 AVR Built-in Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 596
6.60.11 Blackfin Built-in Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 597
6.60.12 FR-V Built-in Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 598
6.60.12.1 Argument Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 598
6.60.12.2 Directly-Mapped Integer Functions . . . . . . . . . . . . . . . 598
6.60.12.3 Directly-Mapped Media Functions . . . . . . . . . . . . . . . . 599
6.60.12.4 Raw Read/Write Functions . . . . . . . . . . . . . . . . . . . . . . 601
6.60.12.5 Other Built-in Functions . . . . . . . . . . . . . . . . . . . . . . . . . 601
6.60.13 MIPS DSP Built-in Functions . . . . . . . . . . . . . . . . . . . . . . . . . 601
6.60.14 MIPS Paired-Single Support . . . . . . . . . . . . . . . . . . . . . . . . . . 606
6.60.15 MIPS Loongson Built-in Functions . . . . . . . . . . . . . . . . . . . . 606
6.60.15.1 Paired-Single Arithmetic . . . . . . . . . . . . . . . . . . . . . . . . . 608
6.60.15.2 Paired-Single Built-in Functions . . . . . . . . . . . . . . . . . . 609
6.60.15.3 MIPS-3D Built-in Functions . . . . . . . . . . . . . . . . . . . . . . 610
6.60.16 MIPS SIMD Architecture (MSA) Support . . . . . . . . . . . . . 612
6.60.16.1 MIPS SIMD Architecture Built-in Functions . . . . . . 613
6.60.17 Other MIPS Built-in Functions. . . . . . . . . . . . . . . . . . . . . . . . 626
6.60.18 MSP430 Built-in Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . 626
6.60.19 NDS32 Built-in Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 626
6.60.20 picoChip Built-in Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . 627
6.60.21 PowerPC Built-in Functions. . . . . . . . . . . . . . . . . . . . . . . . . . . 627
6.60.22 PowerPC AltiVec Built-in Functions. . . . . . . . . . . . . . . . . . . 636
6.60.23 PowerPC Hardware Transactional Memory Built-in
Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 687
6.60.23.1 PowerPC HTM Low Level Built-in Functions . . . . . 687
6.60.23.2 PowerPC HTM High Level Inline Functions . . . . . . 689
6.60.24 RX Built-in Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 690
6.60.25 S/390 System z Built-in Functions . . . . . . . . . . . . . . . . . . . . 692
6.60.26 SH Built-in Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 693
6.60.27 SPARC VIS Built-in Functions . . . . . . . . . . . . . . . . . . . . . . . . 694
6.60.28 SPU Built-in Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 698
6.60.29 TI C6X Built-in Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 698
6.60.30 TILE-Gx Built-in Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . 699
6.60.31 TILEPro Built-in Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . 699
6.60.32 x86 Built-in Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 700
6.60.33 x86 Transactional Memory Intrinsics . . . . . . . . . . . . . . . . . . 722
6.61 Format Checks Specific to Particular Target Machines . . . . . . . 723
6.61.1 Solaris Format Checks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 723
6.61.2 Darwin Format Checks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 723
6.62 Pragmas Accepted by GCC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 724
6.62.1 AArch64 Pragmas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 724
6.62.2 ARM Pragmas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 724
6.62.3 M32C Pragmas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 724
6.62.4 MeP Pragmas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 725
6.62.5 RS/6000 and PowerPC Pragmas . . . . . . . . . . . . . . . . . . . . . . . 725
6.62.6 S/390 Pragmas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 726
6.62.7 Darwin Pragmas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 726
x Using the GNU Compiler Collection (GCC)

6.62.8 Solaris Pragmas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 726

6.62.9 Symbol-Renaming Pragmas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 727
6.62.10 Structure-Layout Pragmas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 727
6.62.11 Weak Pragmas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 728
6.62.12 Diagnostic Pragmas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 728
6.62.13 Visibility Pragmas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 729
6.62.14 Push/Pop Macro Pragmas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 729
6.62.15 Function Specific Option Pragmas. . . . . . . . . . . . . . . . . . . . . 730
6.62.16 Loop-Specific Pragmas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 731
6.63 Unnamed Structure and Union Fields . . . . . . . . . . . . . . . . . . . . . . . 731
6.64 Thread-Local Storage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 732
6.64.1 ISO/IEC 9899:1999 Edits for Thread-Local Storage . . . . . 733
6.64.2 ISO/IEC 14882:1998 Edits for Thread-Local Storage . . . . 733
6.65 Binary Constants using the ‘0b’ Prefix . . . . . . . . . . . . . . . . . . . . . . 735

7 Extensions to the C++ Language . . . . . . . . . . 737

7.1 When is a Volatile C++ Object Accessed? . . . . . . . . . . . . . . . . . . . 737
7.2 Restricting Pointer Aliasing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 737
7.3 Vague Linkage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 738
7.4 C++ Interface and Implementation Pragmas . . . . . . . . . . . . . . . . . 739
7.5 Where’s the Template? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 740
7.6 Extracting the Function Pointer from a Bound Pointer to Member
Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 743
7.7 C++-Specific Variable, Function, and Type Attributes . . . . . . . 743
7.8 Function Multiversioning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 744
7.9 Type Traits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 745
7.10 C++ Concepts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 747
7.11 Deprecated Features . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 748
7.12 Backwards Compatibility . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 749

8 GNU Objective-C Features. . . . . . . . . . . . . . . . . . 751

8.1 GNU Objective-C Runtime API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 751
8.1.1 Modern GNU Objective-C Runtime API. . . . . . . . . . . . . . . . . 751
8.1.2 Traditional GNU Objective-C Runtime API . . . . . . . . . . . . . 752
8.2 +load: Executing Code before main . . . . . . . . . . . . . . . . . . . . . . . . . . 752
8.2.1 What You Can and Cannot Do in +load . . . . . . . . . . . . . . . . 753
8.3 Type Encoding . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 754
8.3.1 Legacy Type Encoding . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 756
8.3.2 @encode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 756
8.3.3 Method Signatures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 757
8.4 Garbage Collection. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 757
8.5 Constant String Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 758
8.6 compatibility_alias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 759
8.7 Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 759
8.8 Synchronization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 761
8.9 Fast Enumeration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 761
8.9.1 Using Fast Enumeration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 761
8.9.2 C99-Like Fast Enumeration Syntax . . . . . . . . . . . . . . . . . . . . . . 761
 xi

8.9.3 Fast Enumeration Details . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 762

8.9.4 Fast Enumeration Protocol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 763
8.10 Messaging with the GNU Objective-C Runtime. . . . . . . . . . . . . . 764
8.10.1 Dynamically Registering Methods . . . . . . . . . . . . . . . . . . . . . . 764
8.10.2 Forwarding Hook . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 764

9 Binary Compatibility . . . . . . . . . . . . . . . . . . . . . . . . 767

10 gcov—a Test Coverage Program . . . . . . . . . . . 771

10.1 Introduction to gcov . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 771
10.2 Invoking gcov . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 771
10.3 Using gcov with GCC Optimization . . . . . . . . . . . . . . . . . . . . . . . . . 778
10.4 Brief Description of gcov Data Files. . . . . . . . . . . . . . . . . . . . . . . . . 779
10.5 Data File Relocation to Support Cross-Profiling . . . . . . . . . . . . . 779

11 gcov-tool—an Offline Gcda Profile Processing

Tool . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 781
11.1 Introduction to gcov-tool . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 781
11.2 Invoking gcov-tool . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 781

12 gcov-dump—an Offline Gcda and Gcno Profile

Dump Tool . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 785
12.1 Introduction to gcov-dump . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 785
12.2 Invoking gcov-dump . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 785

13 Known Causes of Trouble with GCC. . . . . . 787

13.1 Actual Bugs We Haven’t Fixed Yet . . . . . . . . . . . . . . . . . . . . . . . . . 787
13.2 Interoperation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 787
13.3 Incompatibilities of GCC. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 789
13.4 Fixed Header Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 792
13.5 Standard Libraries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 792
13.6 Disappointments and Misunderstandings . . . . . . . . . . . . . . . . . . . . 793
13.7 Common Misunderstandings with GNU C++ . . . . . . . . . . . . . . . 794
13.7.1 Declare and Define Static Members . . . . . . . . . . . . . . . . . . . . 794
13.7.2 Name Lookup, Templates, and Accessing Members of Base
Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 795
13.7.3 Temporaries May Vanish Before You Expect. . . . . . . . . . . . 796
13.7.4 Implicit Copy-Assignment for Virtual Bases . . . . . . . . . . . . 797
13.8 Certain Changes We Don’t Want to Make . . . . . . . . . . . . . . . . . . . 798
13.9 Warning Messages and Error Messages . . . . . . . . . . . . . . . . . . . . . . 801

14 Reporting Bugs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 803

14.1 Have You Found a Bug? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 803
14.2 How and Where to Report Bugs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 803
xii Using the GNU Compiler Collection (GCC)

15 How To Get Help with GCC . . . . . . . . . . . . . . 805

16 Contributing to GCC Development . . . . . . . 807

Funding Free Software . . . . . . . . . . . . . . . . . . . . . . . . . . . 809

The GNU Project and GNU/Linux . . . . . . . . . . . . 811

GNU General Public License . . . . . . . . . . . . . . . . . . . 813

GNU Free Documentation License . . . . . . . . . . . . . 825

ADDENDUM: How to use this License for your documents . . . . . . . . 832

Contributors to GCC . . . . . . . . . . . . . . . . . . . . . . . . . . . . 833

Option Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 851

Keyword Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 875

Introduction 1

Introduction
This manual documents how to use the GNU compilers, as well as their features and incom-
patibilities, and how to report bugs. It corresponds to the compilers (GCC) version 7.5.0.
The internals of the GNU compilers, including how to port them to new targets and some
information about how to write front ends for new languages, are documented in a separate
manual. See Section “Introduction” in GNU Compiler Collection (GCC) Internals.
Chapter 1: Programming Languages Supported by GCC 3

1 Programming Languages Supported by GCC

GCC stands for “GNU Compiler Collection”. GCC is an integrated distribution of compil-
ers for several major programming languages. These languages currently include C, C++,
Objective-C, Objective-C++, Fortran, Ada, Go, and BRIG (HSAIL).
The abbreviation GCC has multiple meanings in common use. The current official mean-
ing is “GNU Compiler Collection”, which refers generically to the complete suite of tools.
The name historically stood for “GNU C Compiler”, and this usage is still common when
the emphasis is on compiling C programs. Finally, the name is also used when speaking
of the language-independent component of GCC: code shared among the compilers for all
supported languages.
The language-independent component of GCC includes the majority of the optimizers,
as well as the “back ends” that generate machine code for various processors.
The part of a compiler that is specific to a particular language is called the “front end”.
In addition to the front ends that are integrated components of GCC, there are several
other front ends that are maintained separately. These support languages such as Pascal,
Mercury, and COBOL. To use these, they must be built together with GCC proper.
Most of the compilers for languages other than C have their own names. The C++ compiler
is G++, the Ada compiler is GNAT, and so on. When we talk about compiling one of those
languages, we might refer to that compiler by its own name, or as GCC. Either is correct.
Historically, compilers for many languages, including C++ and Fortran, have been im-
plemented as “preprocessors” which emit another high level language such as C. None of
the compilers included in GCC are implemented this way; they all generate machine code
directly. This sort of preprocessor should not be confused with the C preprocessor, which
is an integral feature of the C, C++, Objective-C and Objective-C++ languages.
Chapter 2: Language Standards Supported by GCC 5

2 Language Standards Supported by GCC

For each language compiled by GCC for which there is a standard, GCC attempts to follow
one or more versions of that standard, possibly with some exceptions, and possibly with
some extensions.

2.1 C Language
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. The ANSI standard,
but not the ISO standard, also came with a Rationale document. This standard, in both
its forms, is commonly known as C89, or occasionally as C90, from the dates of ratifi-
cation. To select this standard in GCC, use one of the options ‘-ansi’, ‘-std=c90’ or
‘-std=iso9899:1990’; to obtain all the diagnostics required by the standard, you should
also specify ‘-pedantic’ (or ‘-pedantic-errors’ if you want them to be errors rather than
warnings). See Section 3.4 [Options Controlling C Dialect], page 33.
Errors in the 1990 ISO C standard were corrected in two Technical Corrigenda published
in 1994 and 1996. GCC does not support the uncorrected version.
An amendment to the 1990 standard was published in 1995. This amendment added
digraphs and __STDC_VERSION__ to the language, but otherwise concerned the library. This
amendment is commonly known as AMD1; the amended standard is sometimes known as
C94 or C95. To select this standard in GCC, use the option ‘-std=iso9899:199409’ (with,
as for other standard versions, ‘-pedantic’ to receive all required diagnostics).
A new edition of the ISO C standard was published in 1999 as ISO/IEC 9899:1999, and
is commonly known as C99. (While in development, drafts of this standard version were
referred to as C9X.) GCC has substantially complete 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’.
Errors in the 1999 ISO C standard were corrected in three Technical Corrigenda published
in 2001, 2004 and 2007. GCC does not support the uncorrected version.
A fourth version of the C standard, known as C11, was published in 2011 as ISO/IEC
9899:2011. (While in development, drafts of this standard version were referred to as C1X.)
GCC has substantially complete support for this standard, enabled with ‘-std=c11’ or
‘-std=iso9899:2011’.
By default, GCC provides some extensions to the C language that, on rare occasions con-
flict with the C standard. See Chapter 6 [Extensions to the C Language Family], page 405.
Some features that are part of the C99 standard are accepted as extensions in C90 mode,
and some features that are part of the C11 standard are accepted as extensions in C90 and
C99 modes. Use of the ‘-std’ options listed above disables these extensions where they
conflict with the C standard version selected. You may also select an extended version of
the C language explicitly with ‘-std=gnu90’ (for C90 with GNU extensions), ‘-std=gnu99’
(for C99 with GNU extensions) or ‘-std=gnu11’ (for C11 with GNU extensions).
The default, if no C language dialect options are given, is ‘-std=gnu11’.
6 Using the GNU Compiler Collection (GCC)

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>; since C99, also those in <stdbool.h> and <stdint.h>;
and since C11, also those in <stdalign.h> and <stdnoreturn.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 ter-
mination 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 is an example of a program running
in a freestanding environment; a program using the facilities of an operating system is an
example of a program running in a hosted environment.
GCC aims towards being usable as a conforming freestanding implementation, or as the
compiler for a conforming hosted implementation. By default, it acts 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 then defines __STDC_HOSTED__ to 0 and does not make assumptions
about the meanings of function names from the standard library, with exceptions noted
below. To build an OS kernel, you may well still need to make your own arrangements for
linking and startup. See Section 3.4 [Options Controlling C Dialect], page 33.
GCC does not provide the library facilities required only of hosted implementations, nor
yet all the facilities required by C99 of freestanding implementations on all platforms. To
use the facilities of a hosted environment, you need to find them elsewhere (for example, in
the GNU C library). See Section 13.5 [Standard Libraries], page 792.
Most of the compiler support routines used by GCC are present in ‘libgcc’, but there
are a few exceptions. GCC requires the freestanding environment provide memcpy, memmove,
memset and memcmp. Finally, if __builtin_trap is used, and the target does not implement
the trap pattern, then GCC emits a call to abort.
For references to Technical Corrigenda, Rationale documents and information concerning
the history of C that is available online, see http://gcc.gnu.org/readings.html

2.2 C++ Language

GCC supports the original ISO C++ standard published in 1998, and the 2011 and 2014
revisions.
The original ISO C++ standard was published as the ISO standard (ISO/IEC 14882:1998)
and amended by a Technical Corrigenda published in 2003 (ISO/IEC 14882:2003). These
standards are referred to as C++98 and C++03, respectively. GCC implements the majority
of C++98 (export is a notable exception) and most of the changes in C++03. To select
this standard in GCC, use one of the options ‘-ansi’, ‘-std=c++98’, or ‘-std=c++03’; 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).
Chapter 2: Language Standards Supported by GCC 7

A revised ISO C++ standard was published in 2011 as ISO/IEC 14882:2011, and is referred
to as C++11; before its publication it was commonly referred to as C++0x. C++11 contains
several changes to the C++ language, all of which have been implemented in GCC. For
details see https://gcc.gnu.org/projects/cxx0x.html. To select this standard in GCC,
use the option ‘-std=c++11’.
Another revised ISO C++ standard was published in 2014 as ISO/IEC 14882:2014, and is
referred to as C++14; before its publication it was sometimes referred to as C++1y. C++14
contains several further changes to the C++ language, all of which have been implemented
in GCC. For details see https://gcc.gnu.org/projects/cxx1y.html. To select this
standard in GCC, use the option ‘-std=c++14’.
GCC also supports the C++ Concepts Technical Specification, ISO/IEC TS 19217:2015,
which allows constraints to be defined for templates, allowing template arguments to be
checked and for templates to be overloaded or specialized based on the constraints. Support
for C++ Concepts is included in an experimental C++1z mode that corresponds to the next
revision of the ISO C++ standard, expected to be published in 2017. To enable C++1z
support in GCC, use the option ‘-std=c++17’ or ‘-std=c++1z’.
More information about the C++ standards is available on the ISO C++ committee’s web
site at http://www.open-std.org/jtc1/sc22/wg21/.
To obtain all the diagnostics required by any of the standard versions described above
you should specify ‘-pedantic’ or ‘-pedantic-errors’, otherwise GCC will allow some
non-ISO C++ features as extensions. See Section 3.8 [Warning Options], page 59.
By default, GCC also provides some additional extensions to the C++ language that
on rare occasions conflict with the C++ standard. See Section 3.5 [C++ Dialect Options],
page 40. Use of the ‘-std’ options listed above disables these extensions where they they
conflict with the C++ standard version selected. You may also select an extended version
of the C++ language explicitly with ‘-std=gnu++98’ (for C++98 with GNU extensions), or
‘-std=gnu++11’ (for C++11 with GNU extensions), or ‘-std=gnu++14’ (for C++14 with GNU
extensions), or ‘-std=gnu++1z’ (for C++1z with GNU extensions).
The default, if no C++ language dialect options are given, is ‘-std=gnu++14’.

2.3 Objective-C and Objective-C++ Languages

GCC supports “traditional” Objective-C (also known as “Objective-C 1.0”) and contains
support for the Objective-C exception and synchronization syntax. It has also support for
a number of “Objective-C 2.0” language extensions, including properties, fast enumeration
(only for Objective-C), method attributes and the @optional and @required keywords in
protocols. GCC supports Objective-C++ and features available in Objective-C are also
available in Objective-C++.
GCC by default uses the GNU Objective-C runtime library, which is part of GCC and
is not the same as the Apple/NeXT Objective-C runtime library used on Apple systems.
There are a number of differences documented in this manual. The options ‘-fgnu-runtime’
and ‘-fnext-runtime’ allow you to switch between producing output that works with the
GNU Objective-C runtime library and output that works with the Apple/NeXT Objective-
C runtime library.
There is no formal written standard for Objective-C or Objective-C++. The author-
itative manual on traditional Objective-C (1.0) is “Object-Oriented Programming and
8 Using the GNU Compiler Collection (GCC)

the Objective-C Language”: http: / / www . gnustep . org / resources / documentation /

ObjectivCBook.pdf is the original NeXTstep document.
The Objective-C exception and synchronization syntax (that is, the keywords @try,
@throw, @catch, @finally and @synchronized) is supported by GCC and is enabled with
the option ‘-fobjc-exceptions’. The syntax is briefly documented in this manual and in
the Objective-C 2.0 manuals from Apple.
The Objective-C 2.0 language extensions and features are automatically enabled;
they include properties (via the @property, @synthesize and @dynamic keywords),
fast enumeration (not available in Objective-C++), attributes for methods (such as
deprecated, noreturn, sentinel, format), the unused attribute for method arguments,
the @package keyword for instance variables and the @optional and @required keywords
in protocols. You can disable all these Objective-C 2.0 language extensions with the
option ‘-fobjc-std=objc1’, which causes the compiler to recognize the same Objective-C
language syntax recognized by GCC 4.0, and to produce an error if one of the new features
is used.
GCC has currently no support for non-fragile instance variables.
The authoritative manual on Objective-C 2.0 is available from Apple:
• https: / / developer . apple . com / library / content / documentation / Cocoa /
Conceptual/ProgrammingWithObjectiveC/Introduction/Introduction.html
For more information concerning the history of Objective-C that is available online, see
http://gcc.gnu.org/readings.html

2.4 Go Language
As of the GCC 4.7.1 release, GCC supports the Go 1 language standard, described at
https://golang.org/doc/go1.

2.5 HSA Intermediate Language (HSAIL)

GCC can compile the binary representation (BRIG) of the HSAIL text format as described
in HSA Programmer’s Reference Manual version 1.0.1. This capability is typically utilized to
implement the HSA runtime API’s HSAIL finalization extension for a gcc supported proces-
sor. HSA standards are freely available at http://www.hsafoundation.com/standards/
.

2.6 References for Other Languages

See Section “About This Guide” in GNAT Reference Manual, for information on standard
conformance and compatibility of the Ada compiler.
See Section “Standards” in The GNU Fortran Compiler, for details of standards sup-
ported by GNU Fortran.
Chapter 3: GCC Command Options 9

3 GCC Command Options

When you invoke GCC, it normally does preprocessing, compilation, assembly and linking.
The “overall options” allow you to stop this process at an intermediate stage. For example,
the ‘-c’ option says not to run the linker. Then the output consists of object files output
by the assembler. See Section 3.2 [Options Controlling the Kind of Output], page 27.
Other options are passed on to one or more stages 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.
The usual way to run GCC is to run the executable called gcc, or machine-gcc when
cross-compiling, or machine-gcc-version to run a specific version of GCC. When you
compile C++ programs, you should invoke GCC as g++ instead. See Section 3.3 [Compiling
C++ Programs], page 33, for information about the differences in behavior between gcc and
g++ when compiling C++ programs.
The gcc program accepts options and file names as operands. Many options have multi-
letter names; therefore multiple single-letter options may not be grouped: ‘-dv’ is very
different from ‘-d -v’.
You can mix options and other arguments. For the most part, the order you use doesn’t
matter. Order does matter when you use several options of the same kind; for example, if
you specify ‘-L’ more than once, the directories are searched in the order specified. Also,
the placement of the ‘-l’ option is significant.
Many options have long names starting with ‘-f’ or with ‘-W’—for example,
‘-fmove-loop-invariants’, ‘-Wformat’ and so on. Most of these have both positive and
negative forms; the negative form of ‘-ffoo’ is ‘-fno-foo’. This manual documents only
one of these two forms, whichever one is not the default.
See [Option Index], page 851, for an index to GCC’s options.

3.1 Option Summary

Here is a summary of all the options, grouped by type. Explanations are in the following
sections.
Overall Options
See Section 3.2 [Options Controlling the Kind of Output], page 27.
-c -S -E -o file -x language
-v -### --help[=class[,...]] --target-help --version
-pass-exit-codes -pipe -specs=file -wrapper
@file -fplugin=file -fplugin-arg-name=arg
-fdump-ada-spec[-slim] -fada-spec-parent=unit -fdump-go-spec=file

C Language Options
See Section 3.4 [Options Controlling C Dialect], page 33.
10 Using the GNU Compiler Collection (GCC)

-ansi -std=standard -fgnu89-inline

-fpermitted-flt-eval-methods=standard
-aux-info filename -fallow-parameterless-variadic-functions
-fno-asm -fno-builtin -fno-builtin-function -fgimple
-fhosted -ffreestanding -fopenacc -fopenmp -fopenmp-simd
-fms-extensions -fplan9-extensions -fsso-struct=endianness
-fallow-single-precision -fcond-mismatch -flax-vector-conversions
-fsigned-bitfields -fsigned-char
-funsigned-bitfields -funsigned-char

C++ Language Options

See Section 3.5 [Options Controlling C++ Dialect], page 40.
-fabi-version=n -fno-access-control
-faligned-new=n -fargs-in-order=n -fcheck-new
-fconstexpr-depth=n -fconstexpr-loop-limit=n
-ffriend-injection
-fno-elide-constructors
-fno-enforce-eh-specs
-ffor-scope -fno-for-scope -fno-gnu-keywords
-fno-implicit-templates
-fno-implicit-inline-templates
-fno-implement-inlines -fms-extensions
-fnew-inheriting-ctors
-fnew-ttp-matching
-fno-nonansi-builtins -fnothrow-opt -fno-operator-names
-fno-optional-diags -fpermissive
-fno-pretty-templates
-frepo -fno-rtti -fsized-deallocation
-ftemplate-backtrace-limit=n
-ftemplate-depth=n
-fno-threadsafe-statics -fuse-cxa-atexit
-fno-weak -nostdinc++
-fvisibility-inlines-hidden
-fvisibility-ms-compat
-fext-numeric-literals
-Wabi=n -Wabi-tag -Wconversion-null -Wctor-dtor-privacy
-Wdelete-non-virtual-dtor -Wliteral-suffix -Wmultiple-inheritance
-Wnamespaces -Wnarrowing
-Wnoexcept -Wnoexcept-type -Wnon-virtual-dtor -Wreorder -Wregister
-Weffc++ -Wstrict-null-sentinel -Wtemplates
-Wno-non-template-friend -Wold-style-cast
-Woverloaded-virtual -Wno-pmf-conversions
-Wsign-promo -Wvirtual-inheritance

Objective-C and Objective-C++ Language Options

See Section 3.6 [Options Controlling Objective-C and Objective-C++ Dialects],
page 53.
-fconstant-string-class=class-name
-fgnu-runtime -fnext-runtime
-fno-nil-receivers
-fobjc-abi-version=n
-fobjc-call-cxx-cdtors
-fobjc-direct-dispatch
-fobjc-exceptions
-fobjc-gc
-fobjc-nilcheck
-fobjc-std=objc1
-fno-local-ivars
Chapter 3: GCC Command Options 11

-fivar-visibility=[public|protected|private|package]
-freplace-objc-classes
-fzero-link
-gen-decls
-Wassign-intercept
-Wno-protocol -Wselector
-Wstrict-selector-match
-Wundeclared-selector

Diagnostic Message Formatting Options

See Section 3.7 [Options to Control Diagnostic Messages Formatting], page 56.
-fmessage-length=n
-fdiagnostics-show-location=[once|every-line]
-fdiagnostics-color=[auto|never|always]
-fno-diagnostics-show-option -fno-diagnostics-show-caret
-fdiagnostics-parseable-fixits -fdiagnostics-generate-patch
-fno-show-column

Warning Options
See Section 3.8 [Options to Request or Suppress Warnings], page 59.
-fsyntax-only -fmax-errors=n -Wpedantic
-pedantic-errors
-w -Wextra -Wall -Waddress -Waggregate-return -Waligned-new
-Walloc-zero -Walloc-size-larger-than=n -Walloca -Walloca-larger-than=n
-Wno-aggressive-loop-optimizations -Warray-bounds -Warray-bounds=n
-Wno-attributes -Wbool-compare -Wbool-operation
-Wno-builtin-declaration-mismatch
-Wno-builtin-macro-redefined -Wc90-c99-compat -Wc99-c11-compat
-Wc++-compat -Wc++11-compat -Wc++14-compat -Wcast-align -Wcast-qual
-Wchar-subscripts -Wchkp -Wclobbered -Wcomment
-Wconditionally-supported
-Wconversion -Wcoverage-mismatch -Wno-cpp -Wdangling-else -Wdate-time
-Wdelete-incomplete
-Wno-deprecated -Wno-deprecated-declarations -Wno-designated-init
-Wdisabled-optimization
-Wno-discarded-qualifiers -Wno-discarded-array-qualifiers
-Wno-div-by-zero -Wdouble-promotion
-Wduplicated-branches -Wduplicated-cond
-Wempty-body -Wenum-compare -Wno-endif-labels -Wexpansion-to-defined
-Werror -Werror=* -Wfatal-errors -Wfloat-equal -Wformat -Wformat=2
-Wno-format-contains-nul -Wno-format-extra-args
-Wformat-nonliteral -Wformat-overflow=n
-Wformat-security -Wformat-signedness -Wformat-truncation=n
-Wformat-y2k -Wframe-address
-Wframe-larger-than=len -Wno-free-nonheap-object -Wjump-misses-init
-Wignored-qualifiers -Wignored-attributes -Wincompatible-pointer-types
-Wimplicit -Wimplicit-fallthrough -Wimplicit-fallthrough=n
-Wimplicit-function-declaration -Wimplicit-int
-Winit-self -Winline -Wno-int-conversion -Wint-in-bool-context
-Wno-int-to-pointer-cast -Winvalid-memory-model -Wno-invalid-offsetof
-Winvalid-pch -Wlarger-than=len
-Wlogical-op -Wlogical-not-parentheses -Wlong-long
-Wmain -Wmaybe-uninitialized -Wmemset-elt-size -Wmemset-transposed-args
-Wmisleading-indentation -Wmissing-braces
-Wmissing-field-initializers -Wmissing-include-dirs
-Wno-multichar -Wnonnull -Wnonnull-compare
-Wnormalized=[none|id|nfc|nfkc]
-Wnull-dereference -Wodr -Wno-overflow -Wopenmp-simd
12 Using the GNU Compiler Collection (GCC)

-Woverride-init-side-effects -Woverlength-strings
-Wpacked -Wpacked-bitfield-compat -Wpadded
-Wparentheses -Wno-pedantic-ms-format
-Wplacement-new -Wplacement-new=n
-Wpointer-arith -Wpointer-compare -Wno-pointer-to-int-cast
-Wno-pragmas -Wredundant-decls -Wrestrict -Wno-return-local-addr
-Wreturn-type -Wsequence-point -Wshadow -Wno-shadow-ivar
-Wshadow=global, -Wshadow=local, -Wshadow=compatible-local
-Wshift-overflow -Wshift-overflow=n
-Wshift-count-negative -Wshift-count-overflow -Wshift-negative-value
-Wsign-compare -Wsign-conversion -Wfloat-conversion
-Wno-scalar-storage-order
-Wsizeof-pointer-memaccess -Wsizeof-array-argument
-Wstack-protector -Wstack-usage=len -Wstrict-aliasing
-Wstrict-aliasing=n -Wstrict-overflow -Wstrict-overflow=n
-Wstringop-overflow=n
-Wsuggest-attribute=[pure|const|noreturn|format]
-Wsuggest-final-types
-Wsuggest-final-methods -Wsuggest-override
-Wmissing-format-attribute -Wsubobject-linkage
-Wswitch -Wswitch-bool -Wswitch-default -Wswitch-enum
-Wswitch-unreachable -Wsync-nand
-Wsystem-headers -Wtautological-compare -Wtrampolines -Wtrigraphs
-Wtype-limits -Wundef
-Wuninitialized -Wunknown-pragmas -Wunsafe-loop-optimizations
-Wunsuffixed-float-constants -Wunused -Wunused-function
-Wunused-label -Wunused-local-typedefs -Wunused-macros
-Wunused-parameter -Wno-unused-result
-Wunused-value -Wunused-variable
-Wunused-const-variable -Wunused-const-variable=n
-Wunused-but-set-parameter -Wunused-but-set-variable
-Wuseless-cast -Wvariadic-macros -Wvector-operation-performance
-Wvla -Wvla-larger-than=n -Wvolatile-register-var -Wwrite-strings
-Wzero-as-null-pointer-constant -Whsa
C and Objective-C-only Warning Options
-Wbad-function-cast -Wmissing-declarations
-Wmissing-parameter-type -Wmissing-prototypes -Wnested-externs
-Wold-style-declaration -Wold-style-definition
-Wstrict-prototypes -Wtraditional -Wtraditional-conversion
-Wdeclaration-after-statement -Wpointer-sign
Debugging Options
See Section 3.9 [Options for Debugging Your Program], page 101.
-g -glevel -gcoff -gdwarf -gdwarf-version
-ggdb -grecord-gcc-switches -gno-record-gcc-switches
-gstabs -gstabs+ -gstrict-dwarf -gno-strict-dwarf
-gcolumn-info -gno-column-info
-gvms -gxcoff -gxcoff+ -gz[=type]
-fdebug-prefix-map=old=new -fdebug-types-section
-feliminate-dwarf2-dups -fno-eliminate-unused-debug-types
-femit-struct-debug-baseonly -femit-struct-debug-reduced
-femit-struct-debug-detailed[=spec-list]
-feliminate-unused-debug-symbols -femit-class-debug-always
-fno-merge-debug-strings -fno-dwarf2-cfi-asm
-fvar-tracking -fvar-tracking-assignments
Optimization Options
See Section 3.10 [Options that Control Optimization], page 106.
Chapter 3: GCC Command Options 13

-faggressive-loop-optimizations -falign-functions[=n]
-falign-jumps[=n]
-falign-labels[=n] -falign-loops[=n]
-fassociative-math -fauto-profile -fauto-profile[=path]
-fauto-inc-dec -fbranch-probabilities
-fbranch-target-load-optimize -fbranch-target-load-optimize2
-fbtr-bb-exclusive -fcaller-saves
-fcombine-stack-adjustments -fconserve-stack
-fcompare-elim -fcprop-registers -fcrossjumping
-fcse-follow-jumps -fcse-skip-blocks -fcx-fortran-rules
-fcx-limited-range
-fdata-sections -fdce -fdelayed-branch
-fdelete-null-pointer-checks -fdevirtualize -fdevirtualize-speculatively
-fdevirtualize-at-ltrans -fdse
-fearly-inlining -fipa-sra -fexpensive-optimizations -ffat-lto-objects
-ffast-math -ffinite-math-only -ffloat-store -fexcess-precision=style
-fforward-propagate -ffp-contract=style -ffunction-sections
-fgcse -fgcse-after-reload -fgcse-las -fgcse-lm -fgraphite-identity
-fgcse-sm -fhoist-adjacent-loads -fif-conversion
-fif-conversion2 -findirect-inlining
-finline-functions -finline-functions-called-once -finline-limit=n
-finline-small-functions -fipa-cp -fipa-cp-clone
-fipa-bit-cp -fipa-vrp
-fipa-pta -fipa-profile -fipa-pure-const -fipa-reference -fipa-icf
-fira-algorithm=algorithm
-fira-region=region -fira-hoist-pressure
-fira-loop-pressure -fno-ira-share-save-slots
-fno-ira-share-spill-slots
-fisolate-erroneous-paths-dereference -fisolate-erroneous-paths-attribute
-fivopts -fkeep-inline-functions -fkeep-static-functions
-fkeep-static-consts -flimit-function-alignment -flive-range-shrinkage
-floop-block -floop-interchange -floop-strip-mine
-floop-unroll-and-jam -floop-nest-optimize
-floop-parallelize-all -flra-remat -flto -flto-compression-level
-flto-partition=alg -fmerge-all-constants
-fmerge-constants -fmodulo-sched -fmodulo-sched-allow-regmoves
-fmove-loop-invariants -fno-branch-count-reg
-fno-defer-pop -fno-fp-int-builtin-inexact -fno-function-cse
-fno-guess-branch-probability -fno-inline -fno-math-errno -fno-peephole
-fno-peephole2 -fno-printf-return-value -fno-sched-interblock
-fno-sched-spec -fno-signed-zeros
-fno-toplevel-reorder -fno-trapping-math -fno-zero-initialized-in-bss
-fomit-frame-pointer -foptimize-sibling-calls
-fpartial-inlining -fpeel-loops -fpredictive-commoning
-fprefetch-loop-arrays
-fprofile-correction
-fprofile-use -fprofile-use=path -fprofile-values
-fprofile-reorder-functions
-freciprocal-math -free -frename-registers -freorder-blocks
-freorder-blocks-algorithm=algorithm
-freorder-blocks-and-partition -freorder-functions
-frerun-cse-after-loop -freschedule-modulo-scheduled-loops
-frounding-math -fsched2-use-superblocks -fsched-pressure
-fsched-spec-load -fsched-spec-load-dangerous
-fsched-stalled-insns-dep[=n] -fsched-stalled-insns[=n]
-fsched-group-heuristic -fsched-critical-path-heuristic
-fsched-spec-insn-heuristic -fsched-rank-heuristic
-fsched-last-insn-heuristic -fsched-dep-count-heuristic
14 Using the GNU Compiler Collection (GCC)

-fschedule-fusion
-fschedule-insns -fschedule-insns2 -fsection-anchors
-fselective-scheduling -fselective-scheduling2
-fsel-sched-pipelining -fsel-sched-pipelining-outer-loops
-fsemantic-interposition -fshrink-wrap -fshrink-wrap-separate
-fsignaling-nans
-fsingle-precision-constant -fsplit-ivs-in-unroller -fsplit-loops
-fsplit-paths
-fsplit-wide-types -fssa-backprop -fssa-phiopt
-fstdarg-opt -fstore-merging -fstrict-aliasing
-fstrict-overflow -fthread-jumps -ftracer -ftree-bit-ccp
-ftree-builtin-call-dce -ftree-ccp -ftree-ch
-ftree-coalesce-vars -ftree-copy-prop -ftree-dce -ftree-dominator-opts
-ftree-dse -ftree-forwprop -ftree-fre -fcode-hoisting
-ftree-loop-if-convert -ftree-loop-im
-ftree-phiprop -ftree-loop-distribution -ftree-loop-distribute-patterns
-ftree-loop-ivcanon -ftree-loop-linear -ftree-loop-optimize
-ftree-loop-vectorize
-ftree-parallelize-loops=n -ftree-pre -ftree-partial-pre -ftree-pta
-ftree-reassoc -ftree-sink -ftree-slsr -ftree-sra
-ftree-switch-conversion -ftree-tail-merge
-ftree-ter -ftree-vectorize -ftree-vrp -funconstrained-commons
-funit-at-a-time -funroll-all-loops -funroll-loops
-funsafe-math-optimizations -funswitch-loops
-fipa-ra -fvariable-expansion-in-unroller -fvect-cost-model -fvpt
-fweb -fwhole-program -fwpa -fuse-linker-plugin
--param name=value -O -O0 -O1 -O2 -O3 -Os -Ofast -Og

Program Instrumentation Options

See Section 3.11 [Program Instrumentation Options], page 164.
-p -pg -fprofile-arcs --coverage -ftest-coverage
-fprofile-dir=path -fprofile-generate -fprofile-generate=path
-fsanitize=style -fsanitize-recover -fsanitize-recover=style
-fasan-shadow-offset=number -fsanitize-sections=s1,s2,...
-fsanitize-undefined-trap-on-error -fbounds-check
-fcheck-pointer-bounds -fchkp-check-incomplete-type
-fchkp-first-field-has-own-bounds -fchkp-narrow-bounds
-fchkp-narrow-to-innermost-array -fchkp-optimize
-fchkp-use-fast-string-functions -fchkp-use-nochk-string-functions
-fchkp-use-static-bounds -fchkp-use-static-const-bounds
-fchkp-treat-zero-dynamic-size-as-infinite -fchkp-check-read
-fchkp-check-read -fchkp-check-write -fchkp-store-bounds
-fchkp-instrument-calls -fchkp-instrument-marked-only
-fchkp-use-wrappers -fchkp-flexible-struct-trailing-arrays
-fstack-protector -fstack-protector-all -fstack-protector-strong
-fstack-protector-explicit -fstack-check
-fstack-limit-register=reg -fstack-limit-symbol=sym
-fno-stack-limit -fsplit-stack
-fvtable-verify=[std|preinit|none]
-fvtv-counts -fvtv-debug
-finstrument-functions
-finstrument-functions-exclude-function-list=sym,sym,...
-finstrument-functions-exclude-file-list=file,file,...

Preprocessor Options
See Section 3.12 [Options Controlling the Preprocessor], page 176.
-Aquestion=answer
-A-question[=answer]
Chapter 3: GCC Command Options 15

-C -CC -Dmacro[=defn]
-dD -dI -dM -dN -dU
-fdebug-cpp -fdirectives-only -fdollars-in-identifiers
-fexec-charset=charset -fextended-identifiers
-finput-charset=charset -fno-canonical-system-headers
-fpch-deps -fpch-preprocess -fpreprocessed
-ftabstop=width -ftrack-macro-expansion
-fwide-exec-charset=charset -fworking-directory
-H -imacros file -include file
-M -MD -MF -MG -MM -MMD -MP -MQ -MT
-no-integrated-cpp -P -pthread -remap
-traditional -traditional-cpp -trigraphs
-Umacro -undef
-Wp,option -Xpreprocessor option

Assembler Options
See Section 3.13 [Passing Options to the Assembler], page 183.
-Wa,option -Xassembler option

Linker Options
See Section 3.14 [Options for Linking], page 183.
object-file-name -fuse-ld=linker -llibrary
-nostartfiles -nodefaultlibs -nostdlib -pie -pthread -rdynamic
-s -static -static-libgcc -static-libstdc++
-static-libasan -static-libtsan -static-liblsan -static-libubsan
-static-libmpx -static-libmpxwrappers
-shared -shared-libgcc -symbolic
-T script -Wl,option -Xlinker option
-u symbol -z keyword

Directory Options
See Section 3.15 [Options for Directory Search], page 188.
-Bprefix -Idir -I-
-idirafter dir
-imacros file -imultilib dir
-iplugindir=dir -iprefix file
-iquote dir -isysroot dir -isystem dir
-iwithprefix dir -iwithprefixbefore dir
-Ldir -no-canonical-prefixes --no-sysroot-suffix
-nostdinc -nostdinc++ --sysroot=dir

Code Generation Options

See Section 3.16 [Options for Code Generation Conventions], page 191.
-fcall-saved-reg -fcall-used-reg
-ffixed-reg -fexceptions
-fnon-call-exceptions -fdelete-dead-exceptions -funwind-tables
-fasynchronous-unwind-tables
-fno-gnu-unique
-finhibit-size-directive -fno-common -fno-ident
-fpcc-struct-return -fpic -fPIC -fpie -fPIE -fno-plt
-fno-jump-tables
-frecord-gcc-switches
-freg-struct-return -fshort-enums -fshort-wchar
-fverbose-asm -fpack-struct[=n]
-fleading-underscore -ftls-model=model
-fstack-reuse=reuse_level
-ftrampolines -ftrapv -fwrapv
16 Using the GNU Compiler Collection (GCC)

-fvisibility=[default|internal|hidden|protected]
-fstrict-volatile-bitfields -fsync-libcalls
Developer Options
See Section 3.17 [GCC Developer Options], page 201.
-dletters -dumpspecs -dumpmachine -dumpversion
-dumpfullversion -fchecking -fchecking=n -fdbg-cnt-list
-fdbg-cnt=counter-value-list
-fdisable-ipa-pass_name
-fdisable-rtl-pass_name
-fdisable-rtl-pass-name=range-list
-fdisable-tree-pass_name
-fdisable-tree-pass-name=range-list
-fdump-noaddr -fdump-unnumbered -fdump-unnumbered-links
-fdump-translation-unit[-n]
-fdump-class-hierarchy[-n]
-fdump-ipa-all -fdump-ipa-cgraph -fdump-ipa-inline
-fdump-passes
-fdump-rtl-pass -fdump-rtl-pass=filename
-fdump-statistics
-fdump-final-insns[=file] -fdump-tree-all
-fdump-tree-switch
-fdump-tree-switch-options
-fdump-tree-switch-options=filename
-fcompare-debug[=opts] -fcompare-debug-second
-fenable-kind-pass
-fenable-kind-pass=range-list
-fira-verbose=n
-flto-report -flto-report-wpa -fmem-report-wpa
-fmem-report -fpre-ipa-mem-report -fpost-ipa-mem-report
-fopt-info -fopt-info-options[=file]
-fprofile-report
-frandom-seed=string -fsched-verbose=n
-fsel-sched-verbose -fsel-sched-dump-cfg -fsel-sched-pipelining-verbose
-fstats -fstack-usage -ftime-report -ftime-report-details
-fvar-tracking-assignments-toggle -gtoggle
-print-file-name=library -print-libgcc-file-name
-print-multi-directory -print-multi-lib -print-multi-os-directory
-print-prog-name=program -print-search-dirs -Q
-print-sysroot -print-sysroot-headers-suffix
-save-temps -save-temps=cwd -save-temps=obj -time[=file]
Machine-Dependent Options
See Section 3.18 [Machine-Dependent Options], page 217.
AArch64 Options
-mabi=name -mbig-endian -mlittle-endian
-mgeneral-regs-only
-mcmodel=tiny -mcmodel=small -mcmodel=large
-mstrict-align
-momit-leaf-frame-pointer -mno-omit-leaf-frame-pointer
-mtls-dialect=desc -mtls-dialect=traditional
-mtls-size=size
-mfix-cortex-a53-835769 -mno-fix-cortex-a53-835769
-mfix-cortex-a53-843419 -mno-fix-cortex-a53-843419
-mlow-precision-recip-sqrt -mno-low-precision-recip-sqrt
-mlow-precision-sqrt -mno-low-precision-sqrt
-mlow-precision-div -mno-low-precision-div
-march=name -mcpu=name -mtune=name
Chapter 3: GCC Command Options 17

Adapteva Epiphany Options

-mhalf-reg-file -mprefer-short-insn-regs
-mbranch-cost=num -mcmove -mnops=num -msoft-cmpsf
-msplit-lohi -mpost-inc -mpost-modify -mstack-offset=num
-mround-nearest -mlong-calls -mshort-calls -msmall16
-mfp-mode=mode -mvect-double -max-vect-align=num
-msplit-vecmove-early -m1reg-reg

ARC Options
-mbarrel-shifter
-mcpu=cpu -mA6 -mARC600 -mA7 -mARC700
-mdpfp -mdpfp-compact -mdpfp-fast -mno-dpfp-lrsr
-mea -mno-mpy -mmul32x16 -mmul64 -matomic
-mnorm -mspfp -mspfp-compact -mspfp-fast -msimd -msoft-float -mswap
-mcrc -mdsp-packa -mdvbf -mlock -mmac-d16 -mmac-24 -mrtsc -mswape
-mtelephony -mxy -misize -mannotate-align -marclinux -marclinux_prof
-mlong-calls -mmedium-calls -msdata
-mvolatile-cache -mtp-regno=regno
-malign-call -mauto-modify-reg -mbbit-peephole -mno-brcc
-mcase-vector-pcrel -mcompact-casesi -mno-cond-exec -mearly-cbranchsi
-mexpand-adddi -mindexed-loads -mlra -mlra-priority-none
-mlra-priority-compact mlra-priority-noncompact -mno-millicode
-mmixed-code -mq-class -mRcq -mRcw -msize-level=level
-mtune=cpu -mmultcost=num
-munalign-prob-threshold=probability -mmpy-option=multo
-mdiv-rem -mcode-density -mll64 -mfpu=fpu

ARM Options
-mapcs-frame -mno-apcs-frame
-mabi=name
-mapcs-stack-check -mno-apcs-stack-check
-mapcs-reentrant -mno-apcs-reentrant
-msched-prolog -mno-sched-prolog
-mlittle-endian -mbig-endian
-mfloat-abi=name
-mfp16-format=name -mthumb-interwork -mno-thumb-interwork
-mcpu=name -march=name -mfpu=name
-mtune=name -mprint-tune-info
-mstructure-size-boundary=n
-mabort-on-noreturn
-mlong-calls -mno-long-calls
-msingle-pic-base -mno-single-pic-base
-mpic-register=reg
-mnop-fun-dllimport
-mpoke-function-name
-mthumb -marm
-mtpcs-frame -mtpcs-leaf-frame
-mcaller-super-interworking -mcallee-super-interworking
-mtp=name -mtls-dialect=dialect
-mword-relocations
-mfix-cortex-m3-ldrd
-munaligned-access
-mneon-for-64bits
-mslow-flash-data
-masm-syntax-unified
-mrestrict-it
-mpure-code
-mcmse
18 Using the GNU Compiler Collection (GCC)

AVR Options
-mmcu=mcu -mabsdata -maccumulate-args
-mbranch-cost=cost
-mcall-prologues -mint8 -mn_flash=size -mno-interrupts
-mrelax -mrmw -mstrict-X -mtiny-stack -mfract-convert-truncate
-nodevicelib
-Waddr-space-convert -Wmisspelled-isr
Blackfin Options
-mcpu=cpu[-sirevision]
-msim -momit-leaf-frame-pointer -mno-omit-leaf-frame-pointer
-mspecld-anomaly -mno-specld-anomaly -mcsync-anomaly -mno-csync-anomaly
-mlow-64k -mno-low64k -mstack-check-l1 -mid-shared-library
-mno-id-shared-library -mshared-library-id=n
-mleaf-id-shared-library -mno-leaf-id-shared-library
-msep-data -mno-sep-data -mlong-calls -mno-long-calls
-mfast-fp -minline-plt -mmulticore -mcorea -mcoreb -msdram
-micplb
C6X Options
-mbig-endian -mlittle-endian -march=cpu
-msim -msdata=sdata-type
CRIS Options
-mcpu=cpu -march=cpu -mtune=cpu
-mmax-stack-frame=n -melinux-stacksize=n
-metrax4 -metrax100 -mpdebug -mcc-init -mno-side-effects
-mstack-align -mdata-align -mconst-align
-m32-bit -m16-bit -m8-bit -mno-prologue-epilogue -mno-gotplt
-melf -maout -melinux -mlinux -sim -sim2
-mmul-bug-workaround -mno-mul-bug-workaround
CR16 Options
-mmac
-mcr16cplus -mcr16c
-msim -mint32 -mbit-ops -mdata-model=model
Darwin Options
-all_load -allowable_client -arch -arch_errors_fatal
-arch_only -bind_at_load -bundle -bundle_loader
-client_name -compatibility_version -current_version
-dead_strip
-dependency-file -dylib_file -dylinker_install_name
-dynamic -dynamiclib -exported_symbols_list
-filelist -flat_namespace -force_cpusubtype_ALL
-force_flat_namespace -headerpad_max_install_names
-iframework
-image_base -init -install_name -keep_private_externs
-multi_module -multiply_defined -multiply_defined_unused
-noall_load -no_dead_strip_inits_and_terms
-nofixprebinding -nomultidefs -noprebind -noseglinkedit
-pagezero_size -prebind -prebind_all_twolevel_modules
-private_bundle -read_only_relocs -sectalign
-sectobjectsymbols -whyload -seg1addr
-sectcreate -sectobjectsymbols -sectorder
-segaddr -segs_read_only_addr -segs_read_write_addr
-seg_addr_table -seg_addr_table_filename -seglinkedit
-segprot -segs_read_only_addr -segs_read_write_addr
-single_module -static -sub_library -sub_umbrella
Chapter 3: GCC Command Options 19

-twolevel_namespace -umbrella -undefined

-unexported_symbols_list -weak_reference_mismatches
-whatsloaded -F -gused -gfull -mmacosx-version-min=version
-mkernel -mone-byte-bool
DEC Alpha Options
-mno-fp-regs -msoft-float
-mieee -mieee-with-inexact -mieee-conformant
-mfp-trap-mode=mode -mfp-rounding-mode=mode
-mtrap-precision=mode -mbuild-constants
-mcpu=cpu-type -mtune=cpu-type
-mbwx -mmax -mfix -mcix
-mfloat-vax -mfloat-ieee
-mexplicit-relocs -msmall-data -mlarge-data
-msmall-text -mlarge-text
-mmemory-latency=time
FR30 Options
-msmall-model -mno-lsim
FT32 Options
-msim -mlra -mnodiv
FRV Options
-mgpr-32 -mgpr-64 -mfpr-32 -mfpr-64
-mhard-float -msoft-float
-malloc-cc -mfixed-cc -mdword -mno-dword
-mdouble -mno-double
-mmedia -mno-media -mmuladd -mno-muladd
-mfdpic -minline-plt -mgprel-ro -multilib-library-pic
-mlinked-fp -mlong-calls -malign-labels
-mlibrary-pic -macc-4 -macc-8
-mpack -mno-pack -mno-eflags -mcond-move -mno-cond-move
-moptimize-membar -mno-optimize-membar
-mscc -mno-scc -mcond-exec -mno-cond-exec
-mvliw-branch -mno-vliw-branch
-mmulti-cond-exec -mno-multi-cond-exec -mnested-cond-exec
-mno-nested-cond-exec -mtomcat-stats
-mTLS -mtls
-mcpu=cpu
GNU/Linux Options
-mglibc -muclibc -mmusl -mbionic -mandroid
-tno-android-cc -tno-android-ld
H8/300 Options
-mrelax -mh -ms -mn -mexr -mno-exr -mint32 -malign-300
HPPA Options
-march=architecture-type
-mcaller-copies -mdisable-fpregs -mdisable-indexing
-mfast-indirect-calls -mgas -mgnu-ld -mhp-ld
-mfixed-range=register-range
-mjump-in-delay -mlinker-opt -mlong-calls
-mlong-load-store -mno-disable-fpregs
-mno-disable-indexing -mno-fast-indirect-calls -mno-gas
-mno-jump-in-delay -mno-long-load-store
-mno-portable-runtime -mno-soft-float
-mno-space-regs -msoft-float -mpa-risc-1-0
-mpa-risc-1-1 -mpa-risc-2-0 -mportable-runtime
20 Using the GNU Compiler Collection (GCC)

-mschedule=cpu-type -mspace-regs -msio -mwsio

-munix=unix-std -nolibdld -static -threads
IA-64 Options
-mbig-endian -mlittle-endian -mgnu-as -mgnu-ld -mno-pic
-mvolatile-asm-stop -mregister-names -msdata -mno-sdata
-mconstant-gp -mauto-pic -mfused-madd
-minline-float-divide-min-latency
-minline-float-divide-max-throughput
-mno-inline-float-divide
-minline-int-divide-min-latency
-minline-int-divide-max-throughput
-mno-inline-int-divide
-minline-sqrt-min-latency -minline-sqrt-max-throughput
-mno-inline-sqrt
-mdwarf2-asm -mearly-stop-bits
-mfixed-range=register-range -mtls-size=tls-size
-mtune=cpu-type -milp32 -mlp64
-msched-br-data-spec -msched-ar-data-spec -msched-control-spec
-msched-br-in-data-spec -msched-ar-in-data-spec -msched-in-control-spec
-msched-spec-ldc -msched-spec-control-ldc
-msched-prefer-non-data-spec-insns -msched-prefer-non-control-spec-insns
-msched-stop-bits-after-every-cycle -msched-count-spec-in-critical-path
-msel-sched-dont-check-control-spec -msched-fp-mem-deps-zero-cost
-msched-max-memory-insns-hard-limit -msched-max-memory-insns=max-insns
LM32 Options
-mbarrel-shift-enabled -mdivide-enabled -mmultiply-enabled
-msign-extend-enabled -muser-enabled
M32R/D Options
-m32r2 -m32rx -m32r
-mdebug
-malign-loops -mno-align-loops
-missue-rate=number
-mbranch-cost=number
-mmodel=code-size-model-type
-msdata=sdata-type
-mno-flush-func -mflush-func=name
-mno-flush-trap -mflush-trap=number
-G num
M32C Options
-mcpu=cpu -msim -memregs=number
M680x0 Options
-march=arch -mcpu=cpu -mtune=tune
-m68000 -m68020 -m68020-40 -m68020-60 -m68030 -m68040
-m68060 -mcpu32 -m5200 -m5206e -m528x -m5307 -m5407
-mcfv4e -mbitfield -mno-bitfield -mc68000 -mc68020
-mnobitfield -mrtd -mno-rtd -mdiv -mno-div -mshort
-mno-short -mhard-float -m68881 -msoft-float -mpcrel
-malign-int -mstrict-align -msep-data -mno-sep-data
-mshared-library-id=n -mid-shared-library -mno-id-shared-library
-mxgot -mno-xgot -mlong-jump-table-offsets
MCore Options
-mhardlit -mno-hardlit -mdiv -mno-div -mrelax-immediates
-mno-relax-immediates -mwide-bitfields -mno-wide-bitfields
-m4byte-functions -mno-4byte-functions -mcallgraph-data
Chapter 3: GCC Command Options 21

-mno-callgraph-data -mslow-bytes -mno-slow-bytes -mno-lsim

-mlittle-endian -mbig-endian -m210 -m340 -mstack-increment
MeP Options
-mabsdiff -mall-opts -maverage -mbased=n -mbitops
-mc=n -mclip -mconfig=name -mcop -mcop32 -mcop64 -mivc2
-mdc -mdiv -meb -mel -mio-volatile -ml -mleadz -mm -mminmax
-mmult -mno-opts -mrepeat -ms -msatur -msdram -msim -msimnovec -mtf
-mtiny=n
MicroBlaze Options
-msoft-float -mhard-float -msmall-divides -mcpu=cpu
-mmemcpy -mxl-soft-mul -mxl-soft-div -mxl-barrel-shift
-mxl-pattern-compare -mxl-stack-check -mxl-gp-opt -mno-clearbss
-mxl-multiply-high -mxl-float-convert -mxl-float-sqrt
-mbig-endian -mlittle-endian -mxl-reorder -mxl-mode-app-model
MIPS Options
-EL -EB -march=arch -mtune=arch
-mips1 -mips2 -mips3 -mips4 -mips32 -mips32r2 -mips32r3 -mips32r5
-mips32r6 -mips64 -mips64r2 -mips64r3 -mips64r5 -mips64r6
-mips16 -mno-mips16 -mflip-mips16
-minterlink-compressed -mno-interlink-compressed
-minterlink-mips16 -mno-interlink-mips16
-mabi=abi -mabicalls -mno-abicalls
-mshared -mno-shared -mplt -mno-plt -mxgot -mno-xgot
-mgp32 -mgp64 -mfp32 -mfpxx -mfp64 -mhard-float -msoft-float
-mno-float -msingle-float -mdouble-float
-modd-spreg -mno-odd-spreg
-mabs=mode -mnan=encoding
-mdsp -mno-dsp -mdspr2 -mno-dspr2
-mmcu -mmno-mcu
-meva -mno-eva
-mvirt -mno-virt
-mxpa -mno-xpa
-mmicromips -mno-micromips
-mmsa -mno-msa
-mfpu=fpu-type
-msmartmips -mno-smartmips
-mpaired-single -mno-paired-single -mdmx -mno-mdmx
-mips3d -mno-mips3d -mmt -mno-mt -mllsc -mno-llsc
-mlong64 -mlong32 -msym32 -mno-sym32
-Gnum -mlocal-sdata -mno-local-sdata
-mextern-sdata -mno-extern-sdata -mgpopt -mno-gopt
-membedded-data -mno-embedded-data
-muninit-const-in-rodata -mno-uninit-const-in-rodata
-mcode-readable=setting
-msplit-addresses -mno-split-addresses
-mexplicit-relocs -mno-explicit-relocs
-mcheck-zero-division -mno-check-zero-division
-mdivide-traps -mdivide-breaks
-mload-store-pairs -mno-load-store-pairs
-mmemcpy -mno-memcpy -mlong-calls -mno-long-calls
-mmad -mno-mad -mimadd -mno-imadd -mfused-madd -mno-fused-madd -nocpp
-mfix-24k -mno-fix-24k
-mfix-r4000 -mno-fix-r4000 -mfix-r4400 -mno-fix-r4400
-mfix-r10000 -mno-fix-r10000 -mfix-rm7000 -mno-fix-rm7000
-mfix-vr4120 -mno-fix-vr4120
-mfix-vr4130 -mno-fix-vr4130 -mfix-sb1 -mno-fix-sb1
22 Using the GNU Compiler Collection (GCC)

-mflush-func=func -mno-flush-func
-mbranch-cost=num -mbranch-likely -mno-branch-likely
-mcompact-branches=policy
-mfp-exceptions -mno-fp-exceptions
-mvr4130-align -mno-vr4130-align -msynci -mno-synci
-mlxc1-sxc1 -mno-lxc1-sxc1 -mmadd4 -mno-madd4
-mrelax-pic-calls -mno-relax-pic-calls -mmcount-ra-address
-mframe-header-opt -mno-frame-header-opt
MMIX Options
-mlibfuncs -mno-libfuncs -mepsilon -mno-epsilon -mabi=gnu
-mabi=mmixware -mzero-extend -mknuthdiv -mtoplevel-symbols
-melf -mbranch-predict -mno-branch-predict -mbase-addresses
-mno-base-addresses -msingle-exit -mno-single-exit
MN10300 Options
-mmult-bug -mno-mult-bug
-mno-am33 -mam33 -mam33-2 -mam34
-mtune=cpu-type
-mreturn-pointer-on-d0
-mno-crt0 -mrelax -mliw -msetlb
Moxie Options
-meb -mel -mmul.x -mno-crt0
MSP430 Options
-msim -masm-hex -mmcu= -mcpu= -mlarge -msmall -mrelax
-mwarn-mcu
-mcode-region= -mdata-region=
-msilicon-errata= -msilicon-errata-warn=
-mhwmult= -minrt
NDS32 Options
-mbig-endian -mlittle-endian
-mreduced-regs -mfull-regs
-mcmov -mno-cmov
-mperf-ext -mno-perf-ext
-mv3push -mno-v3push
-m16bit -mno-16bit
-misr-vector-size=num
-mcache-block-size=num
-march=arch
-mcmodel=code-model
-mctor-dtor -mrelax
Nios II Options
-G num -mgpopt=option -mgpopt -mno-gpopt
-mel -meb
-mno-bypass-cache -mbypass-cache
-mno-cache-volatile -mcache-volatile
-mno-fast-sw-div -mfast-sw-div
-mhw-mul -mno-hw-mul -mhw-mulx -mno-hw-mulx -mno-hw-div -mhw-div
-mcustom-insn=N -mno-custom-insn
-mcustom-fpu-cfg=name
-mhal -msmallc -msys-crt0=name -msys-lib=name
-march=arch -mbmx -mno-bmx -mcdx -mno-cdx
Nvidia PTX Options
-m32 -m64 -mmainkernel -moptimize
PDP-11 Options
Chapter 3: GCC Command Options 23

-mfpu -msoft-float -mac0 -mno-ac0 -m40 -m45 -m10

-mbcopy -mbcopy-builtin -mint32 -mno-int16
-mint16 -mno-int32 -mfloat32 -mno-float64
-mfloat64 -mno-float32 -mabshi -mno-abshi
-mbranch-expensive -mbranch-cheap
-munix-asm -mdec-asm
picoChip Options
-mae=ae_type -mvliw-lookahead=N
-msymbol-as-address -mno-inefficient-warnings
PowerPC Options See RS/6000 and PowerPC Options.
RISC-V Options
-mbranch-cost=N-instruction
-mplt -mno-plt
-mabi=ABI-string
-mfdiv -mno-fdiv
-mdiv -mno-div
-march=ISA-string
-mtune=processor-string
-msmall-data-limit=N-bytes
-msave-restore -mno-save-restore
-mstrict-align -mno-strict-align
-mcmodel=medlow -mcmodel=medany
-mexplicit-relocs -mno-explicit-relocs

RL78 Options
-msim -mmul=none -mmul=g13 -mmul=g14 -mallregs
-mcpu=g10 -mcpu=g13 -mcpu=g14 -mg10 -mg13 -mg14
-m64bit-doubles -m32bit-doubles -msave-mduc-in-interrupts
RS/6000 and PowerPC Options
-mcpu=cpu-type
-mtune=cpu-type
-mcmodel=code-model
-mpowerpc64
-maltivec -mno-altivec
-mpowerpc-gpopt -mno-powerpc-gpopt
-mpowerpc-gfxopt -mno-powerpc-gfxopt
-mmfcrf -mno-mfcrf -mpopcntb -mno-popcntb -mpopcntd -mno-popcntd
-mfprnd -mno-fprnd
-mcmpb -mno-cmpb -mmfpgpr -mno-mfpgpr -mhard-dfp -mno-hard-dfp
-mfull-toc -mminimal-toc -mno-fp-in-toc -mno-sum-in-toc
-m64 -m32 -mxl-compat -mno-xl-compat -mpe
-malign-power -malign-natural
-msoft-float -mhard-float -mmultiple -mno-multiple
-msingle-float -mdouble-float -msimple-fpu
-mstring -mno-string -mupdate -mno-update
-mavoid-indexed-addresses -mno-avoid-indexed-addresses
-mfused-madd -mno-fused-madd -mbit-align -mno-bit-align
-mstrict-align -mno-strict-align -mrelocatable
-mno-relocatable -mrelocatable-lib -mno-relocatable-lib
-mtoc -mno-toc -mlittle -mlittle-endian -mbig -mbig-endian
-mdynamic-no-pic -maltivec -mswdiv -msingle-pic-base
-mprioritize-restricted-insns=priority
-msched-costly-dep=dependence_type
-minsert-sched-nops=scheme
-mcall-sysv -mcall-netbsd
24 Using the GNU Compiler Collection (GCC)

-maix-struct-return -msvr4-struct-return
-mabi=abi-type -msecure-plt -mbss-plt
-mblock-move-inline-limit=num
-misel -mno-isel
-misel=yes -misel=no
-mspe -mno-spe
-mspe=yes -mspe=no
-mpaired
-mgen-cell-microcode -mwarn-cell-microcode
-mvrsave -mno-vrsave
-mmulhw -mno-mulhw
-mdlmzb -mno-dlmzb
-mfloat-gprs=yes -mfloat-gprs=no -mfloat-gprs=single -mfloat-gprs=double
-mprototype -mno-prototype
-msim -mmvme -mads -myellowknife -memb -msdata
-msdata=opt -mreadonly-in-sdata -mvxworks -G num
-mrecip -mrecip=opt -mno-recip -mrecip-precision
-mno-recip-precision
-mveclibabi=type -mfriz -mno-friz
-mpointers-to-nested-functions -mno-pointers-to-nested-functions
-msave-toc-indirect -mno-save-toc-indirect
-mpower8-fusion -mno-mpower8-fusion -mpower8-vector -mno-power8-vector
-mcrypto -mno-crypto -mhtm -mno-htm -mdirect-move -mno-direct-move
-mquad-memory -mno-quad-memory
-mquad-memory-atomic -mno-quad-memory-atomic
-mcompat-align-parm -mno-compat-align-parm
-mupper-regs-df -mno-upper-regs-df -mupper-regs-sf -mno-upper-regs-sf
-mupper-regs-di -mno-upper-regs-di
-mupper-regs -mno-upper-regs
-mfloat128 -mno-float128 -mfloat128-hardware -mno-float128-hardware
-mgnu-attribute -mno-gnu-attribute
-mstack-protector-guard=guard -mstack-protector-guard-reg=reg
-mstack-protector-guard-offset=offset
-mlra -mno-lra
RX Options
-m64bit-doubles -m32bit-doubles -fpu -nofpu
-mcpu=
-mbig-endian-data -mlittle-endian-data
-msmall-data
-msim -mno-sim
-mas100-syntax -mno-as100-syntax
-mrelax
-mmax-constant-size=
-mint-register=
-mpid
-mallow-string-insns -mno-allow-string-insns
-mjsr
-mno-warn-multiple-fast-interrupts
-msave-acc-in-interrupts
S/390 and zSeries Options
-mtune=cpu-type -march=cpu-type
-mhard-float -msoft-float -mhard-dfp -mno-hard-dfp
-mlong-double-64 -mlong-double-128
-mbackchain -mno-backchain -mpacked-stack -mno-packed-stack
-msmall-exec -mno-small-exec -mmvcle -mno-mvcle
-m64 -m31 -mdebug -mno-debug -mesa -mzarch
-mhtm -mvx -mzvector
Chapter 3: GCC Command Options 25

-mtpf-trace -mno-tpf-trace -mfused-madd -mno-fused-madd

-mwarn-framesize -mwarn-dynamicstack -mstack-size -mstack-guard
-mhotpatch=halfwords,halfwords
Score Options
-meb -mel
-mnhwloop
-muls
-mmac
-mscore5 -mscore5u -mscore7 -mscore7d
SH Options
-m1 -m2 -m2e
-m2a-nofpu -m2a-single-only -m2a-single -m2a
-m3 -m3e
-m4-nofpu -m4-single-only -m4-single -m4
-m4a-nofpu -m4a-single-only -m4a-single -m4a -m4al
-mb -ml -mdalign -mrelax
-mbigtable -mfmovd -mrenesas -mno-renesas -mnomacsave
-mieee -mno-ieee -mbitops -misize -minline-ic_invalidate -mpadstruct
-mprefergot -musermode -multcost=number -mdiv=strategy
-mdivsi3_libfunc=name -mfixed-range=register-range
-maccumulate-outgoing-args
-matomic-model=atomic-model
-mbranch-cost=num -mzdcbranch -mno-zdcbranch
-mcbranch-force-delay-slot
-mfused-madd -mno-fused-madd -mfsca -mno-fsca -mfsrra -mno-fsrra
-mpretend-cmove -mtas
Solaris 2 Options
-mclear-hwcap -mno-clear-hwcap -mimpure-text -mno-impure-text
-pthreads
SPARC Options
-mcpu=cpu-type
-mtune=cpu-type
-mcmodel=code-model
-mmemory-model=mem-model
-m32 -m64 -mapp-regs -mno-app-regs
-mfaster-structs -mno-faster-structs -mflat -mno-flat
-mfpu -mno-fpu -mhard-float -msoft-float
-mhard-quad-float -msoft-quad-float
-mstack-bias -mno-stack-bias
-mstd-struct-return -mno-std-struct-return
-munaligned-doubles -mno-unaligned-doubles
-muser-mode -mno-user-mode
-mv8plus -mno-v8plus -mvis -mno-vis
-mvis2 -mno-vis2 -mvis3 -mno-vis3
-mvis4 -mno-vis4 -mvis4b -mno-vis4b
-mcbcond -mno-cbcond -mfmaf -mno-fmaf -mfsmuld -mno-fsmuld
-mpopc -mno-popc -msubxc -mno-subxc
-mfix-at697f -mfix-ut699 -mfix-ut700 -mfix-gr712rc
-mlra -mno-lra
SPU Options
-mwarn-reloc -merror-reloc
-msafe-dma -munsafe-dma
-mbranch-hints
-msmall-mem -mlarge-mem -mstdmain
-mfixed-range=register-range
26 Using the GNU Compiler Collection (GCC)

-mea32 -mea64
-maddress-space-conversion -mno-address-space-conversion
-mcache-size=cache-size
-matomic-updates -mno-atomic-updates
System V Options
-Qy -Qn -YP,paths -Ym,dir
TILE-Gx Options
-mcpu=CPU -m32 -m64 -mbig-endian -mlittle-endian
-mcmodel=code-model
TILEPro Options
-mcpu=cpu -m32
V850 Options
-mlong-calls -mno-long-calls -mep -mno-ep
-mprolog-function -mno-prolog-function -mspace
-mtda=n -msda=n -mzda=n
-mapp-regs -mno-app-regs
-mdisable-callt -mno-disable-callt
-mv850e2v3 -mv850e2 -mv850e1 -mv850es
-mv850e -mv850 -mv850e3v5
-mloop
-mrelax
-mlong-jumps
-msoft-float
-mhard-float
-mgcc-abi
-mrh850-abi
-mbig-switch
VAX Options
-mg -mgnu -munix
Visium Options
-mdebug -msim -mfpu -mno-fpu -mhard-float -msoft-float
-mcpu=cpu-type -mtune=cpu-type -msv-mode -muser-mode
VMS Options
-mvms-return-codes -mdebug-main=prefix -mmalloc64
-mpointer-size=size
VxWorks Options
-mrtp -non-static -Bstatic -Bdynamic
-Xbind-lazy -Xbind-now
x86 Options
-mtune=cpu-type -march=cpu-type
-mtune-ctrl=feature-list -mdump-tune-features -mno-default
-mfpmath=unit
-masm=dialect -mno-fancy-math-387
-mno-fp-ret-in-387 -m80387 -mhard-float -msoft-float
-mno-wide-multiply -mrtd -malign-double
-mpreferred-stack-boundary=num
-mincoming-stack-boundary=num
-mcld -mcx16 -msahf -mmovbe -mcrc32
-mrecip -mrecip=opt
-mvzeroupper -mprefer-avx128
-mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -msse4 -mavx
Chapter 3: GCC Command Options 27

-mavx2 -mavx512f -mavx512pf -mavx512er -mavx512cd -mavx512vl

-mavx512bw -mavx512dq -mavx512ifma -mavx512vbmi -msha -maes
-mpclmul -mfsgsbase -mrdrnd -mf16c -mfma
-mprefetchwt1 -mclflushopt -mxsavec -mxsaves
-msse4a -m3dnow -m3dnowa -mpopcnt -mabm -mbmi -mtbm -mfma4 -mxop
-mlzcnt -mbmi2 -mfxsr -mxsave -mxsaveopt -mrtm -mlwp -mmpx
-mmwaitx -mclzero -mpku -mthreads
-mms-bitfields -mno-align-stringops -minline-all-stringops
-minline-stringops-dynamically -mstringop-strategy=alg
-mmemcpy-strategy=strategy -mmemset-strategy=strategy
-mpush-args -maccumulate-outgoing-args -m128bit-long-double
-m96bit-long-double -mlong-double-64 -mlong-double-80 -mlong-double-128
-mregparm=num -msseregparm
-mveclibabi=type -mvect8-ret-in-mem
-mpc32 -mpc64 -mpc80 -mstackrealign
-momit-leaf-frame-pointer -mno-red-zone -mno-tls-direct-seg-refs
-mcmodel=code-model -mabi=name -maddress-mode=mode
-m32 -m64 -mx32 -m16 -miamcu -mlarge-data-threshold=num
-msse2avx -mfentry -mrecord-mcount -mnop-mcount -m8bit-idiv
-mavx256-split-unaligned-load -mavx256-split-unaligned-store
-malign-data=type -mstack-protector-guard=guard
-mmitigate-rop -mgeneral-regs-only
-mindirect-branch=choice -mfunction-return=choice
-mindirect-branch-register
x86 Windows Options
-mconsole -mcygwin -mno-cygwin -mdll
-mnop-fun-dllimport -mthread
-municode -mwin32 -mwindows -fno-set-stack-executable
Xstormy16 Options
-msim
Xtensa Options
-mconst16 -mno-const16
-mfused-madd -mno-fused-madd
-mforce-no-pic
-mserialize-volatile -mno-serialize-volatile
-mtext-section-literals -mno-text-section-literals
-mauto-litpools -mno-auto-litpools
-mtarget-align -mno-target-align
-mlongcalls -mno-longcalls
zSeries Options See S/390 and zSeries Options.

3.2 Options Controlling the Kind of Output

Compilation can involve up to four stages: preprocessing, compilation proper, assembly
and linking, always in that order. GCC is capable of preprocessing and compiling several
files either into several assembler input files, or into one assembler input file; then each
assembler input file produces an object file, and linking combines all the object files (those
newly compiled, and those specified as input) into an executable file.
For any given input file, the file name suffix determines what kind of compilation is done:
file.c C source code that must be preprocessed.
file.i C source code that should not be preprocessed.
file.ii C++ source code that should not be preprocessed.
28 Using the GNU Compiler Collection (GCC)

file.m Objective-C source code. Note that you must link with the ‘libobjc’ library
to make an Objective-C program work.
file.mi Objective-C source code that should not be preprocessed.
file.mm
file.M Objective-C++ source code. Note that you must link with the ‘libobjc’ library
to make an Objective-C++ program work. Note that ‘.M’ refers to a literal
capital M.
file.mii Objective-C++ source code that should not be preprocessed.
file.h C, C++, Objective-C or Objective-C++ header file to be turned into a precom-
piled header (default), or C, C++ header file to be turned into an Ada spec (via
the ‘-fdump-ada-spec’ switch).
file.cc
file.cp
file.cxx
file.cpp
file.CPP
file.c++
file.C C++ source code that must be preprocessed. Note that in ‘.cxx’, the last two
letters must both be literally ‘x’. Likewise, ‘.C’ refers to a literal capital C.
file.mm
file.M Objective-C++ source code that must be preprocessed.
file.mii Objective-C++ source code that should not be preprocessed.
file.hh
file.H
file.hp
file.hxx
file.hpp
file.HPP
file.h++
file.tcc C++ header file to be turned into a precompiled header or Ada spec.
file.f
file.for
file.ftn Fixed form Fortran source code that should not be preprocessed.
file.F
file.FOR
file.fpp
file.FPP
file.FTN Fixed form Fortran source code that must be preprocessed (with the traditional
preprocessor).
file.f90
file.f95
file.f03
file.f08 Free form Fortran source code that should not be preprocessed.
Chapter 3: GCC Command Options 29

file.F90
file.F95
file.F03
file.F08 Free form Fortran source code that must be preprocessed (with the traditional
preprocessor).
file.go Go source code.
file.brig
BRIG files (binary representation of HSAIL).
file.ads Ada source code file that contains a library unit declaration (a declaration of a
package, subprogram, or generic, or a generic instantiation), or a library unit
renaming declaration (a package, generic, or subprogram renaming declaration).
Such files are also called specs.
file.adb Ada source code file containing a library unit body (a subprogram or package
body). Such files are also called bodies.
file.s Assembler code.
file.S
file.sx Assembler code that must be preprocessed.
other An object file to be fed straight into linking. Any file name with no recognized
suffix is treated this way.
You can specify the input language explicitly with the ‘-x’ option:
-x language
Specify explicitly the language for the following input files (rather than letting
the compiler choose a default based on the file name suffix). This option applies
to all following input files until the next ‘-x’ option. Possible values for language
are:
c c-header cpp-output
c++ c++-header c++-cpp-output
objective-c objective-c-header objective-c-cpp-output
objective-c++ objective-c++-header objective-c++-cpp-output
assembler assembler-with-cpp
ada
f77 f77-cpp-input f95 f95-cpp-input
go
brig

-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).
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.
30 Using the GNU Compiler Collection (GCC)

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 that don’t require preprocessing are ignored.
-o file Place output in file file. This applies to whatever sort of output is being pro-
duced, whether it be an executable file, an object file, an assembler file or
preprocessed C code.
If ‘-o’ is not specified, the default is to put an executable file in ‘a.out’, the
object file for ‘source.suffix’ in ‘source.o’, its assembler file in ‘source.s’, a
precompiled header file in ‘source.suffix.gch’, and all preprocessed C source
on standard output.
-v Print (on standard error output) the commands executed to run the stages of
compilation. Also print the version number of the compiler driver program and
of the preprocessor and the compiler proper.
-### Like ‘-v’ except the commands are not executed and arguments are quoted
unless they contain only alphanumeric characters or ./-_. This is useful for
shell scripts to capture the driver-generated command lines.
--help Print (on the standard output) a description of the command-line options under-
stood by gcc. If the ‘-v’ option is also specified then ‘--help’ is also passed on
to the various processes invoked by gcc, so that they can display the command-
line options they accept. If the ‘-Wextra’ option has also been specified (prior to
the ‘--help’ option), then command-line options that have no documentation
associated with them are also displayed.
--target-help
Print (on the standard output) a description of target-specific command-line
options for each tool. For some targets extra target-specific information may
also be printed.
--help={class|[^]qualifier}[,...]
Print (on the standard output) a description of the command-line options un-
derstood by the compiler that fit into all specified classes and qualifiers. These
are the supported classes:
‘optimizers’
Display all of the optimization options supported by the compiler.
‘warnings’
Display all of the options controlling warning messages produced
by the compiler.
Chapter 3: GCC Command Options 31

‘target’ Display target-specific options. Unlike the ‘--target-help’ option

however, target-specific options of the linker and assembler are not
displayed. This is because those tools do not currently support the
extended ‘--help=’ syntax.
‘params’ Display the values recognized by the ‘--param’ option.
language Display the options supported for language, where language is the
name of one of the languages supported in this version of GCC.
‘common’ Display the options that are common to all languages.
These are the supported qualifiers:
‘undocumented’
Display only those options that are undocumented.
‘joined’ Display options taking an argument that appears after an equal sign
in the same continuous piece of text, such as: ‘--help=target’.
‘separate’
Display options taking an argument that appears as a separate word
following the original option, such as: ‘-o output-file’.
Thus for example to display all the undocumented target-specific switches sup-
ported by the compiler, use:
--help=target,undocumented
The sense of a qualifier can be inverted by prefixing it with the ‘^’ character,
so for example to display all binary warning options (i.e., ones that are either
on or off and that do not take an argument) that have a description, use:
--help=warnings,^joined,^undocumented
The argument to ‘--help=’ should not consist solely of inverted qualifiers.
Combining several classes is possible, although this usually restricts the output
so much that there is nothing to display. One case where it does work, however,
is when one of the classes is target. For example, to display all the target-specific
optimization options, use:
--help=target,optimizers
The ‘--help=’ option can be repeated on the command line. Each successive
use displays its requested class of options, skipping those that have already been
displayed.
If the ‘-Q’ option appears on the command line before the ‘--help=’ option, then
the descriptive text displayed by ‘--help=’ is changed. Instead of describing
the displayed options, an indication is given as to whether the option is enabled,
disabled or set to a specific value (assuming that the compiler knows this at the
point where the ‘--help=’ option is used).
Here is a truncated example from the ARM port of gcc:
% gcc -Q -mabi=2 --help=target -c
The following options are target specific:
-mabi= 2
-mabort-on-noreturn [disabled]
-mapcs [disabled]
32 Using the GNU Compiler Collection (GCC)

The output is sensitive to the effects of previous command-line options, so for

example it is possible to find out which optimizations are enabled at ‘-O2’ by
using:
-Q -O2 --help=optimizers
Alternatively you can discover which binary optimizations are enabled by ‘-O3’
by using:
gcc -c -Q -O3 --help=optimizers > /tmp/O3-opts
gcc -c -Q -O2 --help=optimizers > /tmp/O2-opts
diff /tmp/O2-opts /tmp/O3-opts | grep enabled

--version
Display the version number and copyrights of the invoked GCC.
-pass-exit-codes
Normally the gcc program exits 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 instead returns with the numerically highest error produced by any
phase returning an error indication. The C, C++, and Fortran front ends return
4 if an internal compiler error is encountered.
-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.
-specs=file
Process file after the compiler reads in the standard ‘specs’ file, in order to
override the defaults which the gcc driver program uses when determining what
switches to pass to cc1, cc1plus, as, ld, etc. More than one ‘-specs=file’
can be specified on the command line, and they are processed in order, from
left to right. See Section 3.19 [Spec Files], page 382, for information about the
format of the file.
-wrapper Invoke all subcommands under a wrapper program. The name of the wrapper
program and its parameters are passed as a comma separated list.
gcc -c t.c -wrapper gdb,--args
This invokes all subprograms of gcc under ‘gdb --args’, thus the invocation of
cc1 is ‘gdb --args cc1 ...’.
-fplugin=name.so
Load the plugin code in file name.so, assumed to be a shared object to
be dlopen’d by the compiler. The base name of the shared object file
is used to identify the plugin for the purposes of argument parsing (See
‘-fplugin-arg-name-key=value’ below). Each plugin should define the
callback functions specified in the Plugins API.
-fplugin-arg-name-key=value
Define an argument called key with a value of value for the plugin called name.
-fdump-ada-spec[-slim]
For C and C++ source and include files, generate corresponding Ada specs. See
Section “Generating Ada Bindings for C and C++ headers” in GNAT User’s
Guide, which provides detailed documentation on this feature.
Chapter 3: GCC Command Options 33

-fada-spec-parent=unit
In conjunction with ‘-fdump-ada-spec[-slim]’ above, generate Ada specs as
child units of parent unit.
-fdump-go-spec=file
For input files in any language, generate corresponding Go declarations in file.
This generates Go const, type, var, and func declarations which may be
a useful way to start writing a Go interface to code written in some other
language.
@file Read command-line options from file. The options read are inserted in place
of the original @file option. If file does not exist, or cannot be read, then the
option will be treated literally, and not removed.
Options in file are separated by whitespace. A whitespace character may be
included in an option by surrounding the entire option in either single or double
quotes. Any character (including a backslash) may be included by prefixing the
character to be included with a backslash. The file may itself contain additional
@file options; any such options will be processed recursively.

3.3 Compiling C++ Programs

C++ source files conventionally use one of the suffixes ‘.C’, ‘.cc’, ‘.cpp’, ‘.CPP’, ‘.c++’,
‘.cp’, or ‘.cxx’; C++ header files often use ‘.hh’, ‘.hpp’, ‘.H’, or (for shared template code)
‘.tcc’; and preprocessed C++ files use the suffix ‘.ii’. GCC recognizes files with these
names and compiles them as C++ programs even if you call the compiler the same way as
for compiling C programs (usually with the name gcc).
However, the use of gcc does not add the C++ library. g++ is a program that calls GCC
and automatically specifies linking against the C++ library. It treats ‘.c’, ‘.h’ and ‘.i’ files
as C++ source files instead of C source files unless ‘-x’ is used. This program is also useful
when precompiling a C header file with a ‘.h’ extension for use in C++ compilations. On
many systems, g++ is also installed with the name c++.
When you compile C++ programs, you may specify many of the same command-line
options that you use for compiling programs in any language; or command-line options
meaningful for C and related languages; or options that are meaningful only for C++ pro-
grams. See Section 3.4 [Options Controlling C Dialect], page 33, for explanations of options
for languages related to C. See Section 3.5 [Options Controlling C++ Dialect], page 40, for
explanations of options that are meaningful only for C++ programs.

3.4 Options Controlling C Dialect

The following options control the dialect of C (or languages derived from C, such as C++,
Objective-C and Objective-C++) that the compiler accepts:
-ansi In C mode, this is equivalent to ‘-std=c90’. In C++ mode, it is equivalent to
‘-std=c++98’.
This turns off certain features of GCC that are incompatible with ISO C90
(when compiling C code), or of standard C++ (when compiling C++ code), such
as the asm and typeof keywords, and predefined macros such as unix and vax
that identify the type of system you are using. It also enables the undesirable
34 Using the GNU Compiler Collection (GCC)

and rarely used ISO trigraph feature. For the C compiler, it disables recognition
of C++ style ‘//’ comments as well as the inline keyword.
The alternate keywords __asm__, __extension__, __inline__ and __typeof_
_ continue to work despite ‘-ansi’. You would not want to use them in an ISO
C program, of course, but it is useful to put them in header files that might be
included in compilations done with ‘-ansi’. Alternate predefined macros such
as __unix__ and __vax__ are also available, with or without ‘-ansi’.
The ‘-ansi’ option does not cause non-ISO programs to be rejected
gratuitously. For that, ‘-Wpedantic’ is required in addition to ‘-ansi’. See
Section 3.8 [Warning Options], page 59.
The macro __STRICT_ANSI__ is predefined when the ‘-ansi’ option is used.
Some header files may notice this macro and refrain from declaring certain
functions or defining certain macros that the ISO standard doesn’t call for; this
is to avoid interfering with any programs that might use these names for other
things.
Functions that are normally built in but do not have semantics defined by ISO
C (such as alloca and ffs) are not built-in functions when ‘-ansi’ is used. See
Section 6.59 [Other built-in functions provided by GCC], page 572, for details
of the functions affected.
-std= Determine the language standard. See Chapter 2 [Language Standards Sup-
ported by GCC], page 5, for details of these standard versions. This option is
currently only supported when compiling C or C++.
The compiler can accept several base standards, such as ‘c90’ or ‘c++98’, and
GNU dialects of those standards, such as ‘gnu90’ or ‘gnu++98’. When a base
standard is specified, the compiler accepts all programs following that stan-
dard plus those using GNU extensions that do not contradict it. For example,
‘-std=c90’ turns off certain features of GCC that are incompatible with ISO
C90, such as the asm and typeof keywords, but not other GNU extensions that
do not have a meaning in ISO C90, such as omitting the middle term of a ?:
expression. On the other hand, when a GNU dialect of a standard is specified,
all features supported by the compiler are enabled, even when those features
change the meaning of the base standard. As a result, some strict-conforming
programs may be rejected. The particular standard is used by ‘-Wpedantic’ to
identify which features are GNU extensions given that version of the standard.
For example ‘-std=gnu90 -Wpedantic’ warns about C++ style ‘//’ comments,
while ‘-std=gnu99 -Wpedantic’ does not.
A value for this option must be provided; possible values are
‘c90’
‘c89’
‘iso9899:1990’
Support all ISO C90 programs (certain GNU extensions that con-
flict with ISO C90 are disabled). Same as ‘-ansi’ for C code.
‘iso9899:199409’
ISO C90 as modified in amendment 1.
Chapter 3: GCC Command Options 35

‘c99’
‘c9x’
‘iso9899:1999’
‘iso9899:199x’
ISO C99. This standard is substantially completely supported,
modulo bugs and floating-point issues (mainly but not entirely
relating to optional C99 features from Annexes F and G). See
http://gcc.gnu.org/c99status.html for more information. The
names ‘c9x’ and ‘iso9899:199x’ are deprecated.
‘c11’
‘c1x’
‘iso9899:2011’
ISO C11, the 2011 revision of the ISO C standard. This standard is
substantially completely supported, modulo bugs, floating-point is-
sues (mainly but not entirely relating to optional C11 features from
Annexes F and G) and the optional Annexes K (Bounds-checking
interfaces) and L (Analyzability). The name ‘c1x’ is deprecated.
‘gnu90’
‘gnu89’ GNU dialect of ISO C90 (including some C99 features).
‘gnu99’
‘gnu9x’ GNU dialect of ISO C99. The name ‘gnu9x’ is deprecated.
‘gnu11’
‘gnu1x’ GNU dialect of ISO C11. This is the default for C code. The name
‘gnu1x’ is deprecated.
‘c++98’
‘c++03’ The 1998 ISO C++ standard plus the 2003 technical corrigendum
and some additional defect reports. Same as ‘-ansi’ for C++ code.
‘gnu++98’
‘gnu++03’ GNU dialect of ‘-std=c++98’.
‘c++11’
‘c++0x’ The 2011 ISO C++ standard plus amendments. The name ‘c++0x’
is deprecated.
‘gnu++11’
‘gnu++0x’ GNU dialect of ‘-std=c++11’. The name ‘gnu++0x’ is deprecated.
‘c++14’
‘c++1y’ The 2014 ISO C++ standard plus amendments. The name ‘c++1y’
is deprecated.
‘gnu++14’
‘gnu++1y’ GNU dialect of ‘-std=c++14’. This is the default for C++ code.
The name ‘gnu++1y’ is deprecated.
‘c++1z’ The next revision of the ISO C++ standard, tentatively planned
for 2017. Support is highly experimental, and will almost certainly
change in incompatible ways in future releases.
36 Using the GNU Compiler Collection (GCC)

‘gnu++1z’ GNU dialect of ‘-std=c++1z’. Support is highly experimental, and

will almost certainly change in incompatible ways in future releases.

-fgnu89-inline
The option ‘-fgnu89-inline’ tells GCC to use the traditional GNU semantics
for inline functions when in C99 mode. See Section 6.43 [An Inline Func-
tion is As Fast As a Macro], page 499. Using this option is roughly equiva-
lent to adding the gnu_inline function attribute to all inline functions (see
Section 6.31 [Function Attributes], page 429).
The option ‘-fno-gnu89-inline’ explicitly tells GCC to use the C99 semantics
for inline when in C99 or gnu99 mode (i.e., it specifies the default behavior).
This option is not supported in ‘-std=c90’ or ‘-std=gnu90’ mode.
The preprocessor macros __GNUC_GNU_INLINE__ and __GNUC_STDC_INLINE__
may be used to check which semantics are in effect for inline functions. See
Section “Common Predefined Macros” in The C Preprocessor.

-fpermitted-flt-eval-methods=style
ISO/IEC TS 18661-3 defines new permissible values for FLT_EVAL_METHOD that
indicate that operations and constants with a semantic type that is an inter-
change or extended format should be evaluated to the precision and range of
that type. These new values are a superset of those permitted under C99/C11,
which does not specify the meaning of other positive values of FLT_EVAL_
METHOD. As such, code conforming to C11 may not have been written expecting
the possibility of the new values.
‘-fpermitted-flt-eval-methods’ specifies whether the compiler should allow
only the values of FLT_EVAL_METHOD specified in C99/C11, or the extended set
of values specified in ISO/IEC TS 18661-3.
style is either c11 or ts-18661-3 as appropriate.
The default when in a standards compliant mode (‘-std=c11’ or similar) is
‘-fpermitted-flt-eval-methods=c11’. The default when in a GNU dialect
(‘-std=gnu11’ or similar) is ‘-fpermitted-flt-eval-methods=ts-18661-3’.

-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 declara-
tion (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 decla-
rations is also provided, inside comments, after the declaration.

-fallow-parameterless-variadic-functions
Accept variadic functions without named parameters.
Chapter 3: GCC Command Options 37

Although it is possible to define such a function, this is not very useful as it

is not possible to read the arguments. This is only supported for C as this
construct is allowed by C++.
-fno-asm Do not recognize asm, inline or typeof as a keyword, so that code can use
these words as identifiers. You can use the keywords __asm__, __inline__ and
__typeof__ instead. ‘-ansi’ implies ‘-fno-asm’.
In C++, this switch only affects the typeof keyword, since asm and inline
are standard keywords. You may want to use the ‘-fno-gnu-keywords’ flag
instead, which has the same effect. In C99 mode (‘-std=c99’ or ‘-std=gnu99’),
this switch only affects the asm and typeof keywords, since inline is a standard
keyword in ISO C99.
-fno-builtin
-fno-builtin-function
Don’t recognize built-in functions that do not begin with ‘__builtin_’ as prefix.
See Section 6.59 [Other built-in functions provided by GCC], page 572, 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 which
adjust the stack directly, and calls to memcpy may become inline copy loops.
The resulting code is often both smaller and faster, but since the function
calls no longer appear as such, you cannot set a breakpoint on those calls,
nor can you change the behavior of the functions by linking with a different
library. In addition, when a function is recognized as a built-in function, GCC
may use information about that function to warn about problems with calls to
that function, or to generate more efficient code, even if the resulting code still
contains calls to that function. For example, warnings are given with ‘-Wformat’
for bad calls to printf when printf is built in and strlen is known not to
modify global memory.
With the ‘-fno-builtin-function’ option only the built-in function function
is disabled. function must not begin with ‘__builtin_’. If a function is named
that is not built-in in this version of GCC, this option is ignored. There is
no corresponding ‘-fbuiltin-function’ option; if you wish to enable built-in
functions selectively when using ‘-fno-builtin’ or ‘-ffreestanding’, you may
define macros such as:
#define abs(n) __builtin_abs ((n))
#define strcpy(d, s) __builtin_strcpy ((d), (s))

-fgimple
Enable parsing of function definitions marked with __GIMPLE. This is an ex-
perimental feature that allows unit testing of GIMPLE passes.
-fhosted
Assert that compilation targets a hosted environment. This implies
‘-fbuiltin’. A hosted environment is one in which the entire standard library
38 Using the GNU Compiler Collection (GCC)

is available, and in which main has a return type of int. Examples are nearly
everything except a kernel. This is equivalent to ‘-fno-freestanding’.

-ffreestanding
Assert that compilation targets a freestanding environment. This implies
‘-fno-builtin’. A freestanding environment is one in which the standard
library may not exist, and program startup may not necessarily be at
main. The most obvious example is an OS kernel. This is equivalent to
‘-fno-hosted’.
See Chapter 2 [Language Standards Supported by GCC], page 5, for details of
freestanding and hosted environments.

-fopenacc
Enable handling of OpenACC directives #pragma acc in C/C++ and !$acc
in Fortran. When ‘-fopenacc’ is specified, the compiler generates acceler-
ated code according to the OpenACC Application Programming Interface v2.0
http://www.openacc.org/. This option implies ‘-pthread’, and thus is only
supported on targets that have support for ‘-pthread’.

-fopenacc-dim=geom
Specify default compute dimensions for parallel offload regions that do not
explicitly specify. The geom value is a triple of ’:’-separated sizes, in order
’gang’, ’worker’ and, ’vector’. A size can be omitted, to use a target-specific
default value.

-fopenmp Enable handling of OpenMP directives #pragma omp in C/C++ and !$omp
in Fortran. When ‘-fopenmp’ is specified, the compiler generates parallel
code according to the OpenMP Application Program Interface v4.5
http://www.openmp.org/. This option implies ‘-pthread’, and thus is only
supported on targets that have support for ‘-pthread’. ‘-fopenmp’ implies
‘-fopenmp-simd’.

-fopenmp-simd
Enable handling of OpenMP’s SIMD directives with #pragma omp in C/C++
and !$omp in Fortran. Other OpenMP directives are ignored.

-fcilkplus
Enable the usage of Cilk Plus language extension features for C/C++. When the
option ‘-fcilkplus’ is specified, enable the usage of the Cilk Plus Language
extension features for C/C++. The present implementation follows ABI version
1.2. This is an experimental feature that is only partially complete, and whose
interface may change in future versions of GCC as the official specification
changes. Currently, all features but _Cilk_for have been implemented.

-fgnu-tm When the option ‘-fgnu-tm’ is specified, the compiler generates code for the
Linux variant of Intel’s current Transactional Memory ABI specification doc-
ument (Revision 1.1, May 6 2009). This is an experimental feature whose
interface may change in future versions of GCC, as the official specification
changes. Please note that not all architectures are supported for this feature.
Chapter 3: GCC Command Options 39

For more information on GCC’s support for transactional memory, See Section
“The GNU Transactional Memory Library” in GNU Transactional Memory
Library.
Note that the transactional memory feature is not supported with non-call
exceptions (‘-fnon-call-exceptions’).
-fms-extensions
Accept some non-standard constructs used in Microsoft header files.
In C++ code, this allows member names in structures to be similar to previous
types declarations.
typedef int UOW;
struct ABC {
UOW UOW;
};
Some cases of unnamed fields in structures and unions are only accepted
with this option. See Section 6.63 [Unnamed struct/union fields within
structs/unions], page 731, for details.
Note that this option is off for all targets but x86 targets using ms-abi.
-fplan9-extensions
Accept some non-standard constructs used in Plan 9 code.
This enables ‘-fms-extensions’, permits passing pointers to structures with
anonymous fields to functions that expect pointers to elements of the type of
the field, and permits referring to anonymous fields declared using a typedef.
See Section 6.63 [Unnamed struct/union fields within structs/unions], page 731,
for details. This is only supported for C, not C++.
-fcond-mismatch
Allow conditional expressions with mismatched types in the second and third
arguments. The value of such an expression is void. This option is not supported
for C++.
-flax-vector-conversions
Allow implicit conversions between vectors with differing numbers of elements
and/or incompatible element types. This option should not be used for new
code.
-funsigned-char
Let the type char be unsigned, like unsigned char.
Each kind of machine has a default for what char should be. It is either like
unsigned char by default or like signed char by default.
Ideally, a portable program should always use signed char or unsigned char
when it depends on the signedness of an object. But many programs have been
written to use plain char and expect it to be signed, or expect it to be unsigned,
depending on the machines they were written for. This option, and its inverse,
let you make such a program work with the opposite default.
The type char is always a distinct type from each of signed char or unsigned
char, even though its behavior is always just like one of those two.
40 Using the GNU Compiler Collection (GCC)

-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 equiv-
alent to ‘-funsigned-char’.
-fsigned-bitfields
-funsigned-bitfields
-fno-signed-bitfields
-fno-unsigned-bitfields
These options control whether a bit-field is signed or unsigned, when the dec-
laration 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.
-fsso-struct=endianness
Set the default scalar storage order of structures and unions to the specified en-
dianness. The accepted values are ‘big-endian’, ‘little-endian’ and ‘native’
for the native endianness of the target (the default). This option is not sup-
ported for C++.
Warning: the ‘-fsso-struct’ switch causes GCC to generate code that is not
binary compatible with code generated without it if the specified endianness is
not the native endianness of the target.

3.5 Options Controlling C++ Dialect

This section describes the command-line options that are only meaningful for C++ programs.
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 -fstrict-enums -O -c firstClass.C
In this example, only ‘-fstrict-enums’ is an option meant only for C++ programs; you can
use the other options with any language supported by GCC.
Some options for compiling C programs, such as ‘-std’, are also relevant for C++ pro-
grams. See Section 3.4 [Options Controlling C Dialect], page 33.
Here is a list of options that are only for compiling C++ programs:
-fabi-version=n
Use version n of the C++ ABI. The default is version 0.
Version 0 refers to the version conforming most closely to the C++ ABI spec-
ification. Therefore, the ABI obtained using version 0 will change in different
versions of G++ as ABI bugs are fixed.
Version 1 is the version of the C++ ABI that first appeared in G++ 3.2.
Version 2 is the version of the C++ ABI that first appeared in G++ 3.4, and was
the default through G++ 4.9.
Version 3 corrects an error in mangling a constant address as a template argu-
ment.
Chapter 3: GCC Command Options 41

Version 4, which first appeared in G++ 4.5, implements a standard mangling

for vector types.
Version 5, which first appeared in G++ 4.6, corrects the mangling of attribute
const/volatile on function pointer types, decltype of a plain decl, and use of a
function parameter in the declaration of another parameter.
Version 6, which first appeared in G++ 4.7, corrects the promotion behav-
ior of C++11 scoped enums and the mangling of template argument packs,
const/static cast, prefix ++ and –, and a class scope function used as a tem-
plate argument.
Version 7, which first appeared in G++ 4.8, that treats nullptr t as a builtin
type and corrects the mangling of lambdas in default argument scope.
Version 8, which first appeared in G++ 4.9, corrects the substitution behavior
of function types with function-cv-qualifiers.
Version 9, which first appeared in G++ 5.2, corrects the alignment of nullptr_t.
Version 10, which first appeared in G++ 6.1, adds mangling of attributes that
affect type identity, such as ia32 calling convention attributes (e.g. ‘stdcall’).
Version 11, which first appeared in G++ 7, corrects the mangling of sizeof... ex-
pressions and operator names. For multiple entities with the same name within
a function, that are declared in different scopes, the mangling now changes start-
ing with the twelfth occurrence. It also implies ‘-fnew-inheriting-ctors’.
See also ‘-Wabi’.
-fabi-compat-version=n
On targets that support strong aliases, G++ works around mangling changes by
creating an alias with the correct mangled name when defining a symbol with
an incorrect mangled name. This switch specifies which ABI version to use for
the alias.
With ‘-fabi-version=0’ (the default), this defaults to 8 (GCC 5 compatibil-
ity). If another ABI version is explicitly selected, this defaults to 0. For com-
patibility with GCC versions 3.2 through 4.9, use ‘-fabi-compat-version=2’.
If this option is not provided but ‘-Wabi=n’ is, that version is used for com-
patibility aliases. If this option is provided along with ‘-Wabi’ (without the
version), the version from this option is used for the warning.
-fno-access-control
Turn off all access checking. This switch is mainly useful for working around
bugs in the access control code.
-faligned-new
Enable support for C++17 new of types that require more alignment than
void* ::operator new(std::size_t) provides. A numeric argument such as
-faligned-new=32 can be used to specify how much alignment (in bytes) is
provided by that function, but few users will need to override the default of
alignof(std::max_align_t).
-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
42 Using the GNU Compiler Collection (GCC)

the C++ standard specifies that operator new only returns 0 if it is declared
throw(), in which case the compiler always checks 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)’.
-fconcepts
Enable support for the C++ Extensions for Concepts Technical Specification,
ISO 19217 (2015), which allows code like
template <class T> concept bool Addable = requires (T t) { t + t; };
template <Addable T> T add (T a, T b) { return a + b; }

-fconstexpr-depth=n
Set the maximum nested evaluation depth for C++11 constexpr functions to
n. A limit is needed to detect endless recursion during constant expression
evaluation. The minimum specified by the standard is 512.
-fconstexpr-loop-limit=n
Set the maximum number of iterations for a loop in C++14 constexpr functions
to n. A limit is needed to detect infinite loops during constant expression
evaluation. The default is 262144 (1<<18).
-fdeduce-init-list
Enable deduction of a template type parameter as std::initializer_list
from a brace-enclosed initializer list, i.e.
template <class T> auto forward(T t) -> decltype (realfn (t))
{
return realfn (t);
}

void f()
{
forward({1,2}); // call forward<std::initializer_list<int>>
}
This deduction was implemented as a possible extension to the originally pro-
posed semantics for the C++11 standard, but was not part of the final standard,
so it is disabled by default. This option is deprecated, and may be removed in
a future version of G++.
-ffriend-injection
Inject friend functions into the enclosing namespace, so that they are visible
outside the scope of the class in which they are declared. Friend functions were
documented to work this way in the old Annotated C++ Reference Manual.
However, in ISO C++ a friend function that is not declared in an enclosing
scope can only be found using argument dependent lookup. GCC defaults to
the standard behavior.
This option is for compatibility, and may be removed in a future release of G++.
-fno-elide-constructors
The C++ standard allows an implementation to omit creating a temporary that
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
Chapter 3: GCC Command Options 43

cases. This option also causes G++ to call trivial member functions which
otherwise would be expanded inline.
In C++17, the compiler is required to omit these temporaries, but this option
still affects trivial member functions.
-fno-enforce-eh-specs
Don’t generate code to check for violation of exception specifications at run
time. This option violates the C++ standard, but may be useful for reducing
code size in production builds, much like defining NDEBUG. This does not give
user code permission to throw exceptions in violation of the exception specifi-
cations; the compiler still optimizes based on the specifications, so throwing an
unexpected exception results in undefined behavior at run time.
-fextern-tls-init
-fno-extern-tls-init
The C++11 and OpenMP standards allow thread_local and threadprivate
variables to have dynamic (runtime) initialization. To support this, any use of
such a variable goes through a wrapper function that performs any necessary
initialization. When the use and definition of the variable are in the same
translation unit, this overhead can be optimized away, but when the use is in a
different translation unit there is significant overhead even if the variable doesn’t
actually need dynamic initialization. If the programmer can be sure that no
use of the variable in a non-defining TU needs to trigger dynamic initialization
(either because the variable is statically initialized, or a use of the variable in
the defining TU will be executed before any uses in another TU), they can avoid
this overhead with the ‘-fno-extern-tls-init’ option.
On targets that support symbol aliases, the default is ‘-fextern-tls-init’.
On targets that do not support symbol aliases, the default is
‘-fno-extern-tls-init’.
-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++.
If neither flag is given, the default is 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. This option is implied
by the strict ISO C++ dialects: ‘-ansi’, ‘-std=c++98’, ‘-std=c++11’, etc.
-fno-implicit-templates
Never emit code for non-inline templates that are instantiated implicitly (i.e.
by use); only emit code for explicit instantiations. See Section 7.5 [Template
Instantiation], page 740, for more information.
44 Using the GNU Compiler Collection (GCC)

-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 opti-
mization 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 causes linker errors if these functions are not
inlined everywhere they are called.
-fms-extensions
Disable Wpedantic warnings about constructs used in MFC, such as implicit
int and getting a pointer to member function via non-standard syntax.
-fnew-inheriting-ctors
Enable the P0136 adjustment to the semantics of C++11 constructor inheri-
tance. This is part of C++17 but also considered to be a Defect Report against
C++11 and C++14. This flag is enabled by default unless ‘-fabi-version=10’
or lower is specified.
-fnew-ttp-matching
Enable the P0522 resolution to Core issue 150, template template parameters
and default arguments: this allows a template with default template arguments
as an argument for a template template parameter with fewer template param-
eters. This flag is enabled by default for ‘-std=c++1z’.
-fno-nonansi-builtins
Disable built-in declarations of functions that are not mandated by ANSI/ISO
C. These include ffs, alloca, _exit, index, bzero, conjf, and other related
functions.
-fnothrow-opt
Treat a throw() exception specification as if it were a noexcept specification to
reduce or eliminate the text size overhead relative to a function with no excep-
tion specification. If the function has local variables of types with non-trivial
destructors, the exception specification actually makes the function smaller be-
cause the EH cleanups for those variables can be optimized away. The semantic
effect is that an exception thrown out of a function with such an exception spec-
ification results in a call to terminate rather than unexpected.
-fno-operator-names
Do not treat the operator name keywords and, bitand, bitor, compl, not, or
and xor as synonyms as keywords.
-fno-optional-diags
Disable diagnostics that the standard says a compiler does not need to issue.
Currently, the only such diagnostic issued by G++ is the one for a name having
multiple meanings within a class.
-fpermissive
Downgrade some diagnostics about nonconformant code from errors to warn-
ings. Thus, using ‘-fpermissive’ allows some nonconforming code to compile.
Chapter 3: GCC Command Options 45

-fno-pretty-templates
When an error message refers to a specialization of a function template, the com-
piler normally prints the signature of the template followed by the template ar-
guments and any typedefs or typenames in the signature (e.g. void f(T) [with
T = int] rather than void f(int)) so that it’s clear which template is involved.
When an error message refers to a specialization of a class template, the com-
piler omits any template arguments that match the default template arguments
for that template. If either of these behaviors make it harder to understand
the error message rather than easier, you can use ‘-fno-pretty-templates’ to
disable them.

-frepo Enable automatic template instantiation at link time. This option also im-
plies ‘-fno-implicit-templates’. See Section 7.5 [Template Instantiation],
page 740, for more information.

-fno-rtti
Disable generation of information about every class with virtual functions
for use by the C++ run-time 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 G++ generates it as needed. The dynamic_cast operator can still be used
for casts that do not require run-time type information, i.e. casts to void * or
to unambiguous base classes.

-fsized-deallocation
Enable the built-in global declarations
void operator delete (void *, std::size_t) noexcept;
void operator delete[] (void *, std::size_t) noexcept;

as introduced in C++14. This is useful for user-defined replacement dealloca-

tion functions that, for example, use the size of the object to make deallo-
cation faster. Enabled by default under ‘-std=c++14’ and above. The flag
‘-Wsized-deallocation’ warns about places that might want to add a defini-
tion.

-fstrict-enums
Allow the compiler to optimize using the assumption that a value of enumerated
type can only be one of the values of the enumeration (as defined in the C++
standard; basically, a value that can be represented in the minimum number
of bits needed to represent all the enumerators). This assumption may not be
valid if the program uses a cast to convert an arbitrary integer value to the
enumerated type.

-fstrong-eval-order
Evaluate member access, array subscripting, and shift expressions in left-to-
right order, and evaluate assignment in right-to-left order, as adopted for C++17.
Enabled by default with ‘-std=c++1z’. ‘-fstrong-eval-order=some’ enables
just the ordering of member access and shift expressions, and is the default
without ‘-std=c++1z’.
46 Using the GNU Compiler Collection (GCC)

-ftemplate-backtrace-limit=n
Set the maximum number of template instantiation notes for a single warning
or error to n. The default value is 10.
-ftemplate-depth=n
Set the maximum instantiation depth for template classes to n. A limit on
the template instantiation depth is needed to detect endless recursions during
template class instantiation. ANSI/ISO C++ conforming programs must not
rely on a maximum depth greater than 17 (changed to 1024 in C++11). The
default value is 900, as the compiler can run out of stack space before hitting
1024 in some situations.
-fno-threadsafe-statics
Do not emit the extra code to use the routines specified in the C++ ABI for
thread-safe initialization of local statics. You can use this option to reduce code
size slightly in code that doesn’t need to be thread-safe.
-fuse-cxa-atexit
Register destructors for objects with static storage duration with the __cxa_
atexit function rather than the atexit function. This option is required for
fully standards-compliant handling of static destructors, but only works if your
C library supports __cxa_atexit.
-fno-use-cxa-get-exception-ptr
Don’t use the __cxa_get_exception_ptr runtime routine. This causes
std::uncaught_exception to be incorrect, but is necessary if the runtime
routine is not available.
-fvisibility-inlines-hidden
This switch declares that the user does not attempt to compare pointers to
inline functions or methods where the addresses of the two functions are taken
in different shared objects.
The effect of this is that GCC may, effectively, mark inline methods with __
attribute__ ((visibility ("hidden"))) so that they do not appear in the
export table of a DSO and do not require a PLT indirection when used within
the DSO. Enabling this option can have a dramatic effect on load and link
times of a DSO as it massively reduces the size of the dynamic export table
when the library makes heavy use of templates.
The behavior of this switch is not quite the same as marking the methods as
hidden directly, because it does not affect static variables local to the function
or cause the compiler to deduce that the function is defined in only one shared
object.
You may mark a method as having a visibility explicitly to negate the effect of
the switch for that method. For example, if you do want to compare pointers
to a particular inline method, you might mark it as having default visibility.
Marking the enclosing class with explicit visibility has no effect.
Explicitly instantiated inline methods are unaffected by this option as their link-
age might otherwise cross a shared library boundary. See Section 7.5 [Template
Instantiation], page 740.
Chapter 3: GCC Command Options 47

-fvisibility-ms-compat
This flag attempts to use visibility settings to make GCC’s C++ linkage model
compatible with that of Microsoft Visual Studio.
The flag makes these changes to GCC’s linkage model:
1. It sets the default visibility to hidden, like ‘-fvisibility=hidden’.
2. Types, but not their members, are not hidden by default.
3. The One Definition Rule is relaxed for types without explicit visibility
specifications that are defined in more than one shared object: those dec-
larations are permitted if they are permitted when this option is not used.
In new code it is better to use ‘-fvisibility=hidden’ and export those classes
that are intended to be externally visible. Unfortunately it is possible for code
to rely, perhaps accidentally, on the Visual Studio behavior.
Among the consequences of these changes are that static data members of
the same type with the same name but defined in different shared objects are
different, so changing one does not change the other; and that pointers to
function members defined in different shared objects may not compare equal.
When this flag is given, it is a violation of the ODR to define types with the
same name differently.
-fno-weak
Do not use weak symbol support, even if it is provided by the linker. By
default, G++ uses weak symbols if they are available. This option exists only
for testing, and should not be used by end-users; it results 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:
-Wabi (C, Objective-C, C++ and Objective-C++ only)
Warn when G++ it generates code that is probably not compatible with the
vendor-neutral C++ ABI. Since G++ now defaults to updating the ABI with
each major release, normally ‘-Wabi’ will warn only if there is a check added
later in a release series for an ABI issue discovered since the initial release.
‘-Wabi’ will warn about more things if an older ABI version is selected (with
‘-fabi-version=n’).
‘-Wabi’ can also be used with an explicit version number to warn about compat-
ibility with a particular ‘-fabi-version’ level, e.g. ‘-Wabi=2’ to warn about
changes relative to ‘-fabi-version=2’.
If an explicit version number is provided and ‘-fabi-compat-version’ is
not specified, the version number from this option is used for compatibility
aliases. If no explicit version number is provided with this option, but
‘-fabi-compat-version’ is specified, that version number is used for ABI
warnings.
48 Using the GNU Compiler Collection (GCC)

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 is 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.
Known incompatibilities in ‘-fabi-version=2’ (which was the default from
GCC 3.4 to 4.9) include:
• A template with a non-type template parameter of reference type was
mangled incorrectly:
extern int N;
template <int &> struct S {};
void n (S<N>) {2}
This was fixed in ‘-fabi-version=3’.
• SIMD vector types declared using __attribute ((vector_size)) were
mangled in a non-standard way that does not allow for overloading of
functions taking vectors of different sizes.
The mangling was changed in ‘-fabi-version=4’.
• __attribute ((const)) and noreturn were mangled as type qualifiers,
and decltype of a plain declaration was folded away.
These mangling issues were fixed in ‘-fabi-version=5’.
• Scoped enumerators passed as arguments to a variadic function are pro-
moted like unscoped enumerators, causing va_arg to complain. On most
targets this does not actually affect the parameter passing ABI, as there is
no way to pass an argument smaller than int.
Also, the ABI changed the mangling of template argument packs, const_
cast, static_cast, prefix increment/decrement, and a class scope func-
tion used as a template argument.
These issues were corrected in ‘-fabi-version=6’.
• Lambdas in default argument scope were mangled incorrectly, and the ABI
changed the mangling of nullptr_t.
These issues were corrected in ‘-fabi-version=7’.
• When mangling a function type with function-cv-qualifiers, the un-qualified
function type was incorrectly treated as a substitution candidate.
This was fixed in ‘-fabi-version=8’, the default for GCC 5.1.
• decltype(nullptr) incorrectly had an alignment of 1, leading to un-
aligned accesses. Note that this did not affect the ABI of a function with
a nullptr_t parameter, as parameters have a minimum alignment.
This was fixed in ‘-fabi-version=9’, the default for GCC 5.2.
• Target-specific attributes that affect the identity of a type, such as ia32
calling conventions on a function type (stdcall, regparm, etc.), did not
affect the mangled name, leading to name collisions when function pointers
were used as template arguments.
Chapter 3: GCC Command Options 49

This was fixed in ‘-fabi-version=10’, the default for GCC 6.1.

It also warns about psABI-related changes. The known psABI changes at this
point include:
• For SysV/x86-64, unions with long double members are passed in memory
as specified in psABI. For example:
union U {
long double ld;
int i;
};
union U is always passed in memory.
-Wabi-tag (C++ and Objective-C++ only)
Warn when a type with an ABI tag is used in a context that does not have
that ABI tag. See Section 7.7 [C++ Attributes], page 743 for more information
about ABI tags.
-Wctor-dtor-privacy (C++ and Objective-C++ only)
Warn when a class seems unusable because all the constructors or destructors
in that class are private, and it has neither friends nor public static member
functions. Also warn if there are no non-private methods, and there’s at least
one private member function that isn’t a constructor or destructor.
-Wdelete-non-virtual-dtor (C++ and Objective-C++ only)
Warn when delete is used to destroy an instance of a class that has virtual
functions and non-virtual destructor. It is unsafe to delete an instance of a
derived class through a pointer to a base class if the base class does not have a
virtual destructor. This warning is enabled by ‘-Wall’.
-Wliteral-suffix (C++ and Objective-C++ only)
Warn when a string or character literal is followed by a ud-suffix which does not
begin with an underscore. As a conforming extension, GCC treats such suffixes
as separate preprocessing tokens in order to maintain backwards compatibility
with code that uses formatting macros from <inttypes.h>. For example:
#define __STDC_FORMAT_MACROS
#include <inttypes.h>
#include <stdio.h>

int main() {
int64_t i64 = 123;
printf("My int64: %" PRId64"\n", i64);
}
In this case, PRId64 is treated as a separate preprocessing token.
Additionally, warn when a user-defined literal operator is declared with a literal
suffix identifier that doesn’t begin with an underscore. Literal suffix identifiers
that don’t begin with an underscore are reserved for future standardization.
This warning is enabled by default.
-Wlto-type-mismatch
During the link-time optimization warn about type mismatches in global dec-
larations from different compilation units. Requires ‘-flto’ to be enabled.
Enabled by default.
50 Using the GNU Compiler Collection (GCC)

-Wno-narrowing (C++ and Objective-C++ only)

For C++11 and later standards, narrowing conversions are diagnosed by default,
as required by the standard. A narrowing conversion from a constant produces
an error, and a narrowing conversion from a non-constant produces a warning,
but ‘-Wno-narrowing’ suppresses the diagnostic. Note that this does not affect
the meaning of well-formed code; narrowing conversions are still considered
ill-formed in SFINAE contexts.
With ‘-Wnarrowing’ in C++98, warn when a narrowing conversion prohibited
by C++11 occurs within ‘{ }’, e.g.
int i = { 2.2 }; // error: narrowing from double to int
This flag is included in ‘-Wall’ and ‘-Wc++11-compat’.
-Wnoexcept (C++ and Objective-C++ only)
Warn when a noexcept-expression evaluates to false because of a call to a func-
tion that does not have a non-throwing exception specification (i.e. throw() or
noexcept) but is known by the compiler to never throw an exception.
-Wnoexcept-type (C++ and Objective-C++ only)
Warn if the C++1z feature making noexcept part of a function type changes
the mangled name of a symbol relative to C++14. Enabled by ‘-Wabi’ and
‘-Wc++1z-compat’.
template <class T> void f(T t) { t(); };
void g() noexcept;
void h() { f(g); } // in C++14 calls f<void(*)()>, in C++1z calls f<void(*)()noexcept>
-Wnon-virtual-dtor (C++ and Objective-C++ only)
Warn when a class has virtual functions and an accessible non-virtual destructor
itself or in an accessible polymorphic base class, in which case it is possible but
unsafe to delete an instance of a derived class through a pointer to the class itself
or base class. This warning is automatically enabled if ‘-Weffc++’ is specified.
-Wregister (C++ and Objective-C++ only)
Warn on uses of the register storage class specifier, except when it is part of
the GNU Section 6.45.5 [Explicit Register Variables], page 550 extension. The
use of the register keyword as storage class specifier has been deprecated in
C++11 and removed in C++17. Enabled by default with ‘-std=c++1z’.
-Wreorder (C++ and Objective-C++ only)
Warn when the order of member initializers given in the code does not match
the order in which they must be executed. For instance:
struct A {
int i;
int j;
A(): j (0), i (1) { }
};
The compiler rearranges the member initializers for i and j to match the dec-
laration order of the members, emitting a warning to that effect. This warning
is enabled by ‘-Wall’.
-fext-numeric-literals (C++ and Objective-C++ only)
Accept imaginary, fixed-point, or machine-defined literal number suffixes as
GNU extensions. When this option is turned off these suffixes are treated
Chapter 3: GCC Command Options 51

as C++11 user-defined literal numeric suffixes. This is on by default for all

pre-C++11 dialects and all GNU dialects: ‘-std=c++98’, ‘-std=gnu++98’,
‘-std=gnu++11’, ‘-std=gnu++14’. This option is off by default for ISO C++11
onwards (‘-std=c++11’, ...).
The following ‘-W...’ options are not affected by ‘-Wall’.
-Weffc++ (C++ and Objective-C++ only)
Warn about violations of the following style guidelines from Scott Meyers’ Ef-
fective C++ series of books:
• Define a copy constructor and an assignment operator for classes with
dynamically-allocated memory.
• Prefer initialization to assignment in constructors.
• Have operator= return a reference to *this.
• Don’t try to return a reference when you must return an object.
• Distinguish between prefix and postfix forms of increment and decrement
operators.
• Never overload &&, ||, or ,.
This option also enables ‘-Wnon-virtual-dtor’, which is also one of the effec-
tive C++ recommendations. However, the check is extended to warn about the
lack of virtual destructor in accessible non-polymorphic bases classes too.
When selecting this option, be aware that the standard library headers do not
obey all of these guidelines; use ‘grep -v’ to filter out those warnings.
-Wstrict-null-sentinel (C++ and Objective-C++ only)
Warn about the use of an uncasted NULL as sentinel. When compiling only with
GCC this is a valid sentinel, as NULL is defined to __null. Although it is a null
pointer constant rather than a null pointer, it is guaranteed to be of the same
size as a pointer. But this use is not portable across different compilers.
-Wno-non-template-friend (C++ and Objective-C++ only)
Disable warnings when non-template friend functions are declared within a
template. In very old versions of GCC that predate implementation of the ISO
standard, declarations such as ‘friend int foo(int)’, where the name of the
friend is an unqualified-id, could be interpreted as a particular specialization
of a template function; the warning exists to diagnose compatibility problems,
and is enabled by default.
-Wold-style-cast (C++ and Objective-C++ only)
Warn if an old-style (C-style) cast to a non-void type is used within a C++
program. The new-style casts (dynamic_cast, static_cast, reinterpret_
cast, and const_cast) are less vulnerable to unintended effects and much
easier to search for.
-Woverloaded-virtual (C++ and Objective-C++ only)
Warn when a function declaration hides virtual functions from a base class. For
example, in:
52 Using the GNU Compiler Collection (GCC)

struct A {
virtual void f();
};

struct B: public A {
void f(int);
};
the A class version of f is hidden in B, and code like:
B* b;
b->f();
fails to compile.

-Wno-pmf-conversions (C++ and Objective-C++ only)

Disable the diagnostic for converting a bound pointer to member function to a
plain pointer.

-Wsign-promo (C++ and Objective-C++ only)

Warn when overload resolution chooses a promotion from unsigned or enumer-
ated type to a signed type, over a conversion to an unsigned type of the same
size. Previous versions of G++ tried to preserve unsignedness, but the standard
mandates the current behavior.

-Wtemplates (C++ and Objective-C++ only)

Warn when a primary template declaration is encountered. Some coding rules
disallow templates, and this may be used to enforce that rule. The warning is
inactive inside a system header file, such as the STL, so one can still use the
STL. One may also instantiate or specialize templates.

-Wmultiple-inheritance (C++ and Objective-C++ only)

Warn when a class is defined with multiple direct base classes. Some coding
rules disallow multiple inheritance, and this may be used to enforce that rule.
The warning is inactive inside a system header file, such as the STL, so one
can still use the STL. One may also define classes that indirectly use multiple
inheritance.

-Wvirtual-inheritance
Warn when a class is defined with a virtual direct base class. Some coding rules
disallow multiple inheritance, and this may be used to enforce that rule. The
warning is inactive inside a system header file, such as the STL, so one can still
use the STL. One may also define classes that indirectly use virtual inheritance.

-Wnamespaces
Warn when a namespace definition is opened. Some coding rules disallow
namespaces, and this may be used to enforce that rule. The warning is in-
active inside a system header file, such as the STL, so one can still use the STL.
One may also use using directives and qualified names.

-Wno-terminate (C++ and Objective-C++ only)

Disable the warning about a throw-expression that will immediately result in a
call to terminate.
Chapter 3: GCC Command Options 53

3.6 Options Controlling Objective-C and Objective-C++

Dialects
(NOTE: This manual does not describe the Objective-C and Objective-C++ languages them-
selves. See Chapter 2 [Language Standards Supported by GCC], page 5, for references.)
This section describes the command-line options that are only meaningful for Objective-
C and Objective-C++ programs. You can also use most of the language-independent GNU
compiler options. For example, you might compile a file ‘some_class.m’ like this:
gcc -g -fgnu-runtime -O -c some_class.m
In this example, ‘-fgnu-runtime’ is an option meant only for Objective-C and Objective-
C++ programs; you can use the other options with any language supported by GCC.
Note that since Objective-C is an extension of the C language, Objective-C compila-
tions may also use options specific to the C front-end (e.g., ‘-Wtraditional’). Similarly,
Objective-C++ compilations may use C++-specific options (e.g., ‘-Wabi’).
Here is a list of options that are only for compiling Objective-C and Objective-C++
programs:
-fconstant-string-class=class-name
Use class-name as the name of the class to instantiate for each literal string
specified with the syntax @"...". The default class name is NXConstantString
if the GNU runtime is being used, and NSConstantString if the NeXT runtime
is being used (see below). The ‘-fconstant-cfstrings’ option, if also present,
overrides the ‘-fconstant-string-class’ setting and cause @"..." literals to
be laid out as constant CoreFoundation strings.
-fgnu-runtime
Generate object code compatible with the standard GNU Objective-C runtime.
This is the default for most types of systems.
-fnext-runtime
Generate output compatible with the NeXT runtime. This is the default for
NeXT-based systems, including Darwin and Mac OS X. The macro __NEXT_
RUNTIME__ is predefined if (and only if) this option is used.
-fno-nil-receivers
Assume that all Objective-C message dispatches ([receiver message:arg]) in
this translation unit ensure that the receiver is not nil. This allows for more
efficient entry points in the runtime to be used. This option is only available in
conjunction with the NeXT runtime and ABI version 0 or 1.
-fobjc-abi-version=n
Use version n of the Objective-C ABI for the selected runtime. This option is
currently supported only for the NeXT runtime. In that case, Version 0 is the
traditional (32-bit) ABI without support for properties and other Objective-
C 2.0 additions. Version 1 is the traditional (32-bit) ABI with support for
properties and other Objective-C 2.0 additions. Version 2 is the modern (64-bit)
ABI. If nothing is specified, the default is Version 0 on 32-bit target machines,
and Version 2 on 64-bit target machines.
-fobjc-call-cxx-cdtors
For each Objective-C class, check if any of its instance variables is a C++ ob-
ject with a non-trivial default constructor. If so, synthesize a special - (id)
54 Using the GNU Compiler Collection (GCC)

.cxx_construct instance method which runs non-trivial default constructors

on any such instance variables, in order, and then return self. Similarly, check
if any instance variable is a C++ object with a non-trivial destructor, and if
so, synthesize a special - (void) .cxx_destruct method which runs all such
default destructors, in reverse order.
The - (id) .cxx_construct and - (void) .cxx_destruct methods thusly
generated only operate on instance variables declared in the current
Objective-C class, and not those inherited from superclasses. It is the
responsibility of the Objective-C runtime to invoke all such methods in an
object’s inheritance hierarchy. The - (id) .cxx_construct methods are
invoked by the runtime immediately after a new object instance is allocated;
the - (void) .cxx_destruct methods are invoked immediately before the
runtime deallocates an object instance.
As of this writing, only the NeXT runtime on Mac OS X 10.4 and later has sup-
port for invoking the - (id) .cxx_construct and - (void) .cxx_destruct
methods.
-fobjc-direct-dispatch
Allow fast jumps to the message dispatcher. On Darwin this is accomplished
via the comm page.
-fobjc-exceptions
Enable syntactic support for structured exception handling in Objective-C, sim-
ilar to what is offered by C++. This option is required to use the Objective-C
keywords @try, @throw, @catch, @finally and @synchronized. This option is
available with both the GNU runtime and the NeXT runtime (but not available
in conjunction with the NeXT runtime on Mac OS X 10.2 and earlier).
-fobjc-gc
Enable garbage collection (GC) in Objective-C and Objective-C++ programs.
This option is only available with the NeXT runtime; the GNU runtime has a
different garbage collection implementation that does not require special com-
piler flags.
-fobjc-nilcheck
For the NeXT runtime with version 2 of the ABI, check for a nil receiver in
method invocations before doing the actual method call. This is the default
and can be disabled using ‘-fno-objc-nilcheck’. Class methods and super
calls are never checked for nil in this way no matter what this flag is set to.
Currently this flag does nothing when the GNU runtime, or an older version of
the NeXT runtime ABI, is used.
-fobjc-std=objc1
Conform to the language syntax of Objective-C 1.0, the language recognized by
GCC 4.0. This only affects the Objective-C additions to the C/C++ language;
it does not affect conformance to C/C++ standards, which is controlled by
the separate C/C++ dialect option flags. When this option is used with the
Objective-C or Objective-C++ compiler, any Objective-C syntax that is not
recognized by GCC 4.0 is rejected. This is useful if you need to make sure that
your Objective-C code can be compiled with older versions of GCC.
Chapter 3: GCC Command Options 55

-freplace-objc-classes
Emit a special marker instructing ld(1) not to statically link in the resulting
object file, and allow dyld(1) to load it in at run time instead. This is used
in conjunction with the Fix-and-Continue debugging mode, where the object
file in question may be recompiled and dynamically reloaded in the course of
program execution, without the need to restart the program itself. Currently,
Fix-and-Continue functionality is only available in conjunction with the NeXT
runtime on Mac OS X 10.3 and later.
-fzero-link
When compiling for the NeXT runtime, the compiler ordinarily replaces calls to
objc_getClass("...") (when the name of the class is known at compile time)
with static class references that get initialized at load time, which improves run-
time performance. Specifying the ‘-fzero-link’ flag suppresses this behavior
and causes calls to objc_getClass("...") to be retained. This is useful in
Zero-Link debugging mode, since it allows for individual class implementations
to be modified during program execution. The GNU runtime currently always
retains calls to objc_get_class("...") regardless of command-line options.
-fno-local-ivars
By default instance variables in Objective-C can be accessed as if they were
local variables from within the methods of the class they’re declared in. This
can lead to shadowing between instance variables and other variables declared
either locally inside a class method or globally with the same name. Specify-
ing the ‘-fno-local-ivars’ flag disables this behavior thus avoiding variable
shadowing issues.
-fivar-visibility=[public|protected|private|package]
Set the default instance variable visibility to the specified option so that instance
variables declared outside the scope of any access modifier directives default to
the specified visibility.
-gen-decls
Dump interface declarations for all classes seen in the source file to a file named
‘sourcename.decl’.
-Wassign-intercept (Objective-C and Objective-C++ only)
Warn whenever an Objective-C assignment is being intercepted by the garbage
collector.
-Wno-protocol (Objective-C and Objective-C++ only)
If a class is declared to implement a protocol, a warning is issued for every
method in the protocol that is not implemented by the class. The default
behavior is to issue a warning for every method not explicitly implemented in the
class, even if a method implementation is inherited from the superclass. If you
use the ‘-Wno-protocol’ option, then methods inherited from the superclass
are considered to be implemented, and no warning is issued for them.
-Wselector (Objective-C and Objective-C++ only)
Warn if multiple methods of different types for the same selector are found
during compilation. The check is performed on the list of methods in the
56 Using the GNU Compiler Collection (GCC)

final stage of compilation. Additionally, a check is performed for each selector

appearing in a @selector(...) expression, and a corresponding method for
that selector has been found during compilation. Because these checks scan the
method table only at the end of compilation, these warnings are not produced
if the final stage of compilation is not reached, for example because an error
is found during compilation, or because the ‘-fsyntax-only’ option is being
used.

-Wstrict-selector-match (Objective-C and Objective-C++ only)

Warn if multiple methods with differing argument and/or return types are found
for a given selector when attempting to send a message using this selector to
a receiver of type id or Class. When this flag is off (which is the default
behavior), the compiler omits such warnings if any differences found are confined
to types that share the same size and alignment.

-Wundeclared-selector (Objective-C and Objective-C++ only)

Warn if a @selector(...) expression referring to an undeclared selector is
found. A selector is considered undeclared if no method with that name has
been declared before the @selector(...) expression, either explicitly in an
@interface or @protocol declaration, or implicitly in an @implementation
section. This option always performs its checks as soon as a @selector(...)
expression is found, while ‘-Wselector’ only performs its checks in the final
stage of compilation. This also enforces the coding style convention that meth-
ods and selectors must be declared before being used.

-print-objc-runtime-info
Generate C header describing the largest structure that is passed by value, if
any.

3.7 Options to Control Diagnostic Messages Formatting

Traditionally, diagnostic messages have been formatted irrespective of the output device’s
aspect (e.g. its width, . . . ). You can use the options described below to control the for-
matting algorithm for diagnostic messages, e.g. how many characters per line, how often
source location information should be reported. Note that some language front ends may
not honor these options.

-fmessage-length=n
Try to format error messages so that they fit on lines of about n characters. If
n is zero, then no line-wrapping is done; each error message appears on a single
line. This is the default for all front ends.

-fdiagnostics-show-location=once
Only meaningful in line-wrapping mode. Instructs the diagnostic messages re-
porter to emit source location information once; that is, in case the message
is too long to fit on a single physical line and has to be wrapped, the source
location won’t be emitted (as prefix) again, over and over, in subsequent con-
tinuation lines. This is the default behavior.
Chapter 3: GCC Command Options 57

-fdiagnostics-show-location=every-line
Only meaningful in line-wrapping mode. Instructs the diagnostic messages
reporter to emit the same source location information (as prefix) for physical
lines that result from the process of breaking a message which is too long to fit
on a single line.
-fdiagnostics-color[=WHEN]
-fno-diagnostics-color
Use color in diagnostics. WHEN is ‘never’, ‘always’, or ‘auto’. The
default depends on how the compiler has been configured, it can be any
of the above WHEN options or also ‘never’ if GCC_COLORS environment
variable isn’t present in the environment, and ‘auto’ otherwise. ‘auto’
means to use color only when the standard error is a terminal. The
forms ‘-fdiagnostics-color’ and ‘-fno-diagnostics-color’ are aliases
for ‘-fdiagnostics-color=always’ and ‘-fdiagnostics-color=never’,
respectively.
The colors are defined by the environment variable GCC_COLORS. Its value is
a colon-separated list of capabilities and Select Graphic Rendition (SGR) sub-
strings. SGR commands are interpreted by the terminal or terminal emulator.
(See the section in the documentation of your text terminal for permitted values
and their meanings as character attributes.) These substring values are integers
in decimal representation and can be concatenated with semicolons. Common
values to concatenate include ‘1’ for bold, ‘4’ for underline, ‘5’ for blink, ‘7’ for
inverse, ‘39’ for default foreground color, ‘30’ to ‘37’ for foreground colors, ‘90’
to ‘97’ for 16-color mode foreground colors, ‘38;5;0’ to ‘38;5;255’ for 88-color
and 256-color modes foreground colors, ‘49’ for default background color, ‘40’
to ‘47’ for background colors, ‘100’ to ‘107’ for 16-color mode background col-
ors, and ‘48;5;0’ to ‘48;5;255’ for 88-color and 256-color modes background
colors.
The default GCC_COLORS is
error=01;31:warning=01;35:note=01;36:range1=32:range2=34:locus=01:\
quote=01:fixit-insert=32:fixit-delete=31:\
diff-filename=01:diff-hunk=32:diff-delete=31:diff-insert=32
where ‘01;31’ is bold red, ‘01;35’ is bold magenta, ‘01;36’ is bold cyan, ‘32’
is green, ‘34’ is blue, ‘01’ is bold, and ‘31’ is red. Setting GCC_COLORS to the
empty string disables colors. Supported capabilities are as follows.
error= SGR substring for error: markers.
warning= SGR substring for warning: markers.
note= SGR substring for note: markers.
range1= SGR substring for first additional range.
range2= SGR substring for second additional range.
locus= SGR substring for location information, ‘file:line’ or
‘file:line:column’ etc.
quote= SGR substring for information printed within quotes.
58 Using the GNU Compiler Collection (GCC)

fixit-insert=
SGR substring for fix-it hints suggesting text to be inserted or
replaced.
fixit-delete=
SGR substring for fix-it hints suggesting text to be deleted.
diff-filename=
SGR substring for filename headers within generated patches.
diff-hunk=
SGR substring for the starts of hunks within generated patches.
diff-delete=
SGR substring for deleted lines within generated patches.
diff-insert=
SGR substring for inserted lines within generated patches.
-fno-diagnostics-show-option
By default, each diagnostic emitted includes text indicating the command-line
option that directly controls the diagnostic (if such an option is known to the
diagnostic machinery). Specifying the ‘-fno-diagnostics-show-option’ flag
suppresses that behavior.
-fno-diagnostics-show-caret
By default, each diagnostic emitted includes the original source line and a caret
‘^’ indicating the column. This option suppresses this information. The source
line is truncated to n characters, if the ‘-fmessage-length=n’ option is given.
When the output is done to the terminal, the width is limited to the width
given by the COLUMNS environment variable or, if not set, to the terminal width.
-fdiagnostics-parseable-fixits
Emit fix-it hints in a machine-parseable format, suitable for consumption by
IDEs. For each fix-it, a line will be printed after the relevant diagnostic, starting
with the string “fix-it:”. For example:
fix-it:"test.c":{45:3-45:21}:"gtk_widget_show_all"
The location is expressed as a half-open range, expressed as a count of bytes,
starting at byte 1 for the initial column. In the above example, bytes 3 through
20 of line 45 of “test.c” are to be replaced with the given string:
00000000011111111112222222222
12345678901234567890123456789
gtk_widget_showall (dlg);
^^^^^^^^^^^^^^^^^^
gtk_widget_show_all
The filename and replacement string escape backslash as “\\", tab as “\t”,
newline as “\n”, double quotes as “\"”, non-printable characters as octal (e.g.
vertical tab as “\013”).
An empty replacement string indicates that the given range is to be removed.
An empty range (e.g. “45:3-45:3”) indicates that the string is to be inserted at
the given position.
Chapter 3: GCC Command Options 59

-fdiagnostics-generate-patch
Print fix-it hints to stderr in unified diff format, after any diagnostics are
printed. For example:
--- test.c
+++ test.c
@ -42,5 +42,5 @

void show_cb(GtkDialog *dlg)

{
- gtk_widget_showall(dlg);
+ gtk_widget_show_all(dlg);
}

The diff may or may not be colorized, following the same rules as for diagnostics
(see ‘-fdiagnostics-color’).
-fno-show-column
Do not print column numbers in diagnostics. This may be necessary if diag-
nostics are being scanned by a program that does not understand the column
numbers, such as dejagnu.

3.8 Options to Request or Suppress Warnings

Warnings are diagnostic messages that report constructions that are not inherently erro-
neous but that are risky or suggest there may have been an error.
The following language-independent options do not enable specific warnings but control
the kinds of diagnostics produced by GCC.
-fsyntax-only
Check the code for syntax errors, but don’t do anything beyond that.
-fmax-errors=n
Limits the maximum number of error messages to n, at which point GCC bails
out rather than attempting to continue processing the source code. If n is 0
(the default), there is no limit on the number of error messages produced. If
‘-Wfatal-errors’ is also specified, then ‘-Wfatal-errors’ takes precedence
over this option.
-w Inhibit all warning messages.
-Werror Make all warnings into errors.
-Werror= Make the specified warning into an error. The specifier for a warning is
appended; for example ‘-Werror=switch’ turns the warnings controlled by
‘-Wswitch’ into errors. This switch takes a negative form, to be used to negate
‘-Werror’ for specific warnings; for example ‘-Wno-error=switch’ makes
‘-Wswitch’ warnings not be errors, even when ‘-Werror’ is in effect.
The warning message for each controllable warning includes the option that
controls the warning. That option can then be used with ‘-Werror=’ and
‘-Wno-error=’ as described above. (Printing of the option in the warning mes-
sage can be disabled using the ‘-fno-diagnostics-show-option’ flag.)
60 Using the GNU Compiler Collection (GCC)

Note that specifying ‘-Werror=’foo automatically implies ‘-W’foo. However,

‘-Wno-error=’foo does not imply anything.
-Wfatal-errors
This option causes the compiler to abort compilation on the first error occurred
rather than trying to keep going and printing further error messages.
You can request many specific warnings with options beginning with ‘-W’, for example
‘-Wimplicit’ to request warnings on implicit declarations. Each of these specific warn-
ing options also has a negative form beginning ‘-Wno-’ to turn off warnings; for example,
‘-Wno-implicit’. This manual lists only one of the two forms, whichever is not the default.
For further language-specific options also refer to Section 3.5 [C++ Dialect Options], page 40
and Section 3.6 [Objective-C and Objective-C++ Dialect Options], page 53.
Some options, such as ‘-Wall’ and ‘-Wextra’, turn on other options, such as ‘-Wunused’,
which may turn on further options, such as ‘-Wunused-value’. The combined effect of
positive and negative forms is that more specific options have priority over less specific ones,
independently of their position in the command-line. For options of the same specificity,
the last one takes effect. Options enabled or disabled via pragmas (see Section 6.62.12
[Diagnostic Pragmas], page 728) take effect as if they appeared at the end of the command-
line.
When an unrecognized warning option is requested (e.g., ‘-Wunknown-warning’),
GCC emits a diagnostic stating that the option is not recognized. However, if the
‘-Wno-’ form is used, the behavior is slightly different: no diagnostic is produced for
‘-Wno-unknown-warning’ unless other diagnostics are being produced. This allows the
use of new ‘-Wno-’ options with old compilers, but if something goes wrong, the compiler
warns that an unrecognized option is present.
-Wpedantic
-pedantic
Issue all the warnings demanded by strict ISO C and ISO C++; reject all pro-
grams that use forbidden extensions, and some other programs that do not
follow ISO C and ISO C++. For ISO C, follows the version of the ISO C stan-
dard specified by any ‘-std’ option used.
Valid ISO C and ISO C++ programs should compile properly with or without
this option (though a rare few require ‘-ansi’ or a ‘-std’ option specifying
the required version of ISO C). However, without this option, certain GNU
extensions and traditional C and C++ features are supported as well. With this
option, they are rejected.
‘-Wpedantic’ does not cause warning messages for use of the alternate keywords
whose names begin and end with ‘__’. Pedantic warnings are also disabled in
the expression that follows __extension__. However, only system header files
should use these escape routes; application programs should avoid them. See
Section 6.46 [Alternate Keywords], page 553.
Some users try to use ‘-Wpedantic’ to check programs for strict ISO C con-
formance. They soon find that it does not do quite what they want: it finds
some non-ISO practices, but not all—only those for which ISO C requires a
diagnostic, and some others for which diagnostics have been added.
Chapter 3: GCC Command Options 61

A feature to report any failure to conform to ISO C might be useful in some

instances, but would require considerable additional work and would be quite
different from ‘-Wpedantic’. We don’t have plans to support such a feature in
the near future.
Where the standard specified with ‘-std’ represents a GNU extended dialect
of C, such as ‘gnu90’ or ‘gnu99’, there is a corresponding base standard, the
version of ISO C on which the GNU extended dialect is based. Warnings from
‘-Wpedantic’ are given where they are required by the base standard. (It
does not make sense for such warnings to be given only for features not in the
specified GNU C dialect, since by definition the GNU dialects of C include
all features the compiler supports with the given option, and there would be
nothing to warn about.)
-pedantic-errors
Give an error whenever the base standard (see ‘-Wpedantic’) requires a diag-
nostic, in some cases where there is undefined behavior at compile-time and in
some other cases that do not prevent compilation of programs that are valid
according to the standard. This is not equivalent to ‘-Werror=pedantic’, since
there are errors enabled by this option and not enabled by the latter and vice
versa.
-Wall This enables all the warnings about constructions that some users consider
questionable, and that are easy to avoid (or modify to prevent the warning),
even in conjunction with macros. This also enables some language-specific
warnings described in Section 3.5 [C++ Dialect Options], page 40 and Section 3.6
[Objective-C and Objective-C++ Dialect Options], page 53.
‘-Wall’ turns on the following warning flags:
-Waddress
-Warray-bounds=1 (only with ‘-O2’)
-Wbool-compare
-Wbool-operation
-Wc++11-compat -Wc++14-compat
-Wchar-subscripts
-Wcomment
-Wduplicate-decl-specifier (C and Objective-C only)
-Wenum-compare (in C/ObjC; this is on by default in C++)
-Wformat
-Wint-in-bool-context
-Wimplicit (C and Objective-C only)
-Wimplicit-int (C and Objective-C only)
-Wimplicit-function-declaration (C and Objective-C only)
-Winit-self (only for C++)
-Wlogical-not-parentheses
-Wmain (only for C/ObjC and unless ‘-ffreestanding’)
-Wmaybe-uninitialized
-Wmemset-elt-size
-Wmemset-transposed-args
-Wmisleading-indentation (only for C/C++)
-Wmissing-braces (only for C/ObjC)
-Wnarrowing (only for C++)
-Wnonnull
-Wnonnull-compare
-Wopenmp-simd
62 Using the GNU Compiler Collection (GCC)

-Wparentheses
-Wpointer-sign
-Wreorder
-Wreturn-type
-Wsequence-point
-Wsign-compare (only in C++)
-Wsizeof-pointer-memaccess
-Wstrict-aliasing
-Wstrict-overflow=1
-Wswitch
-Wtautological-compare
-Wtrigraphs
-Wuninitialized
-Wunknown-pragmas
-Wunused-function
-Wunused-label
-Wunused-value
-Wunused-variable
-Wvolatile-register-var

Note that some warning flags are not implied by ‘-Wall’. Some of them warn
about constructions that users generally do not consider questionable, but which
occasionally you might wish to check for; others warn about constructions that
are necessary or hard to avoid in some cases, and there is no simple way to mod-
ify the code to suppress the warning. Some of them are enabled by ‘-Wextra’
but many of them must be enabled individually.
-Wextra This enables some extra warning flags that are not enabled by ‘-Wall’. (This
option used to be called ‘-W’. The older name is still supported, but the newer
name is more descriptive.)
-Wclobbered
-Wempty-body
-Wignored-qualifiers
-Wimplicit-fallthrough=3
-Wmissing-field-initializers
-Wmissing-parameter-type (C only)
-Wold-style-declaration (C only)
-Woverride-init
-Wsign-compare (C only)
-Wtype-limits
-Wuninitialized
-Wshift-negative-value (in C++03 and in C99 and newer)
-Wunused-parameter (only with ‘-Wunused’ or ‘-Wall’)
-Wunused-but-set-parameter (only with ‘-Wunused’ or ‘-Wall’)

The option ‘-Wextra’ also prints warning messages for the following cases:
• A pointer is compared against integer zero with <, <=, >, or >=.
• (C++ only) An enumerator and a non-enumerator both appear in a condi-
tional expression.
• (C++ only) Ambiguous virtual bases.
• (C++ only) Subscripting an array that has been declared register.
• (C++ only) Taking the address of a variable that has been declared
register.
Chapter 3: GCC Command Options 63

• (C++ only) A base class is not initialized in the copy constructor of a derived
class.
-Wchar-subscripts
Warn if an array subscript has type char. This is a common cause of error,
as programmers often forget that this type is signed on some machines. This
warning is enabled by ‘-Wall’.
-Wchkp Warn about an invalid memory access that is found by Pointer Bounds Checker
(‘-fcheck-pointer-bounds’).
-Wno-coverage-mismatch
Warn if feedback profiles do not match when using the ‘-fprofile-use’ option.
If a source file is changed between compiling with ‘-fprofile-gen’ and with
‘-fprofile-use’, the files with the profile feedback can fail to match the source
file and GCC cannot use the profile feedback information. By default, this
warning is enabled and is treated as an error. ‘-Wno-coverage-mismatch’ can
be used to disable the warning or ‘-Wno-error=coverage-mismatch’ can be
used to disable the error. Disabling the error for this warning can result in
poorly optimized code and is useful only in the case of very minor changes such
as bug fixes to an existing code-base. Completely disabling the warning is not
recommended.
-Wno-cpp (C, Objective-C, C++, Objective-C++ and Fortran only)
Suppress warning messages emitted by #warning directives.
-Wdouble-promotion (C, C++, Objective-C and Objective-C++ only)
Give a warning when a value of type float is implicitly promoted to double.
CPUs with a 32-bit “single-precision” floating-point unit implement float in
hardware, but emulate double in software. On such a machine, doing compu-
tations using double values is much more expensive because of the overhead
required for software emulation.
It is easy to accidentally do computations with double because floating-point
literals are implicitly of type double. For example, in:
float area(float radius)
{
return 3.14159 * radius * radius;
}
the compiler performs the entire computation with double because the floating-
point literal is a double.
-Wduplicate-decl-specifier (C and Objective-C only)
Warn if a declaration has duplicate const, volatile, restrict or _Atomic
specifier. This warning is enabled by ‘-Wall’.
-Wformat
-Wformat=n
Check calls to printf and scanf, etc., to make sure that the arguments supplied
have types appropriate to the format string specified, and that the conversions
specified in the format string make sense. This includes standard functions, and
others specified by format attributes (see Section 6.31 [Function Attributes],
64 Using the GNU Compiler Collection (GCC)

page 429), in the printf, scanf, strftime and strfmon (an X/Open exten-
sion, not in the C standard) families (or other target-specific families). Which
functions are checked without format attributes having been specified depends
on the standard version selected, and such checks of functions without the at-
tribute specified are disabled by ‘-ffreestanding’ or ‘-fno-builtin’.
The formats are checked against the format features supported by GNU libc
version 2.2. These include all ISO C90 and C99 features, as well as features
from the Single Unix Specification and some BSD and GNU extensions. Other
library implementations may not support all these features; GCC does not sup-
port warning about features that go beyond a particular library’s limitations.
However, if ‘-Wpedantic’ is used with ‘-Wformat’, warnings are given about
format features not in the selected standard version (but not for strfmon for-
mats, since those are not in any version of the C standard). See Section 3.4
[Options Controlling C Dialect], page 33.
-Wformat=1
-Wformat Option ‘-Wformat’ is equivalent to ‘-Wformat=1’, and
‘-Wno-format’ is equivalent to ‘-Wformat=0’. Since ‘-Wformat’
also checks for null format arguments for several functions,
‘-Wformat’ also implies ‘-Wnonnull’. Some aspects of this
level of format checking can be disabled by the options:
‘-Wno-format-contains-nul’, ‘-Wno-format-extra-args’, and
‘-Wno-format-zero-length’. ‘-Wformat’ is enabled by ‘-Wall’.
-Wno-format-contains-nul
If ‘-Wformat’ is specified, do not warn about format strings that
contain NUL bytes.
-Wno-format-extra-args
If ‘-Wformat’ is specified, do not warn about excess arguments to
a printf or scanf format function. The C standard specifies that
such arguments are ignored.
Where the unused arguments lie between used arguments that are
specified with ‘$’ operand number specifications, normally warnings
are still given, since the implementation could not know what type
to pass to va_arg to skip the unused arguments. However, in the
case of scanf formats, this option suppresses the warning if the un-
used arguments are all pointers, since the Single Unix Specification
says that such unused arguments are allowed.
-Wformat-overflow
-Wformat-overflow=level
Warn about calls to formatted input/output functions such as
sprintf and vsprintf that might overflow the destination buffer.
When the exact number of bytes written by a format directive
cannot be determined at compile-time it is estimated based on
heuristics that depend on the level argument and on optimization.
While enabling optimization will in most cases improve the
accuracy of the warning, it may also result in false positives.
Chapter 3: GCC Command Options 65

-Wformat-overflow
-Wformat-overflow=1
Level 1 of ‘-Wformat-overflow’ enabled by ‘-Wformat’
employs a conservative approach that warns only about
calls that most likely overflow the buffer. At this level,
numeric arguments to format directives with unknown
values are assumed to have the value of one, and strings
of unknown length to be empty. Numeric arguments
that are known to be bounded to a subrange of their
type, or string arguments whose output is bounded ei-
ther by their directive’s precision or by a finite set of
string literals, are assumed to take on the value within
the range that results in the most bytes on output.
For example, the call to sprintf below is diagnosed
because even with both a and b equal to zero, the ter-
minating NUL character (’\0’) appended by the func-
tion to the destination buffer will be written past its
end. Increasing the size of the buffer by a single byte
is sufficient to avoid the warning, though it may not be
sufficient to avoid the overflow.
void f (int a, int b)
{
char buf [12];
sprintf (buf, "a = %i, b = %i\n", a, b);
}

-Wformat-overflow=2
Level 2 warns also about calls that might overflow
the destination buffer given an argument of sufficient
length or magnitude. At level 2, unknown numeric
arguments are assumed to have the minimum repre-
sentable value for signed types with a precision greater
than 1, and the maximum representable value other-
wise. Unknown string arguments whose length cannot
be assumed to be bounded either by the directive’s pre-
cision, or by a finite set of string literals they may eval-
uate to, or the character array they may point to, are
assumed to be 1 character long.
At level 2, the call in the example above is again diag-
nosed, but this time because with a equal to a 32-bit
INT_MIN the first %i directive will write some of its dig-
its beyond the end of the destination buffer. To make
the call safe regardless of the values of the two variables,
the size of the destination buffer must be increased to
at least 34 bytes. GCC includes the minimum size of
the buffer in an informational note following the warn-
ing.
66 Using the GNU Compiler Collection (GCC)

An alternative to increasing the size of the destina-

tion buffer is to constrain the range of formatted val-
ues. The maximum length of string arguments can be
bounded by specifying the precision in the format direc-
tive. When numeric arguments of format directives can
be assumed to be bounded by less than the precision
of their type, choosing an appropriate length modifier
to the format specifier will reduce the required buffer
size. For example, if a and b in the example above
can be assumed to be within the precision of the short
int type then using either the %hi format directive or
casting the argument to short reduces the maximum
required size of the buffer to 24 bytes.
void f (int a, int b)
{
char buf [23];
sprintf (buf, "a = %hi, b = %i\n", a, (short)b);
}
-Wno-format-zero-length
If ‘-Wformat’ is specified, do not warn about zero-length formats.
The C standard specifies that zero-length formats are allowed.
-Wformat=2
Enable ‘-Wformat’ plus additional format checks. Currently equiv-
alent to ‘-Wformat -Wformat-nonliteral -Wformat-security
-Wformat-y2k’.
-Wformat-nonliteral
If ‘-Wformat’ is specified, also warn if the format string is not a
string literal and so cannot be checked, unless the format function
takes its format arguments as a va_list.
-Wformat-security
If ‘-Wformat’ is specified, also warn about uses of format functions
that represent possible security problems. At present, this warns
about calls to printf and scanf functions where the format string
is not a string literal and there are no format arguments, as in
printf (foo);. This may be a security hole if the format string
came from untrusted input and contains ‘%n’. (This is currently
a subset of what ‘-Wformat-nonliteral’ warns about, but in fu-
ture warnings may be added to ‘-Wformat-security’ that are not
included in ‘-Wformat-nonliteral’.)
-Wformat-signedness
If ‘-Wformat’ is specified, also warn if the format string requires an
unsigned argument and the argument is signed and vice versa.
-Wformat-truncation
-Wformat-truncation=level
Warn about calls to formatted input/output functions such as
snprintf and vsnprintf that might result in output truncation.
Chapter 3: GCC Command Options 67

When the exact number of bytes written by a format directive

cannot be determined at compile-time it is estimated based on
heuristics that depend on the level argument and on optimization.
While enabling optimization will in most cases improve the
accuracy of the warning, it may also result in false positives.
Except as noted otherwise, the option uses the same logic
‘-Wformat-overflow’.
-Wformat-truncation
-Wformat-truncation=1
Level 1 of ‘-Wformat-truncation’ enabled by
‘-Wformat’ employs a conservative approach that
warns only about calls to bounded functions whose
return value is unused and that will most likely result
in output truncation.
-Wformat-truncation=2
Level 2 warns also about calls to bounded functions
whose return value is used and that might result in
truncation given an argument of sufficient length or
magnitude.
-Wformat-y2k
If ‘-Wformat’ is specified, also warn about strftime formats that
may yield only a two-digit year.
-Wnonnull
Warn about passing a null pointer for arguments marked as requiring a non-null
value by the nonnull function attribute.
‘-Wnonnull’ is included in ‘-Wall’ and ‘-Wformat’. It can be disabled with the
‘-Wno-nonnull’ option.
-Wnonnull-compare
Warn when comparing an argument marked with the nonnull function at-
tribute against null inside the function.
‘-Wnonnull-compare’ is included in ‘-Wall’. It can be disabled with the
‘-Wno-nonnull-compare’ option.
-Wnull-dereference
Warn if the compiler detects paths that trigger erroneous or undefined be-
havior due to dereferencing a null pointer. This option is only active when
‘-fdelete-null-pointer-checks’ is active, which is enabled by optimizations
in most targets. The precision of the warnings depends on the optimization
options used.
-Winit-self (C, C++, Objective-C and Objective-C++ only)
Warn about uninitialized variables that are initialized with themselves. Note
this option can only be used with the ‘-Wuninitialized’ option.
For example, GCC warns about i being uninitialized in the following snippet
only when ‘-Winit-self’ has been specified:
68 Using the GNU Compiler Collection (GCC)

int f()
{
int i = i;
return i;
}
This warning is enabled by ‘-Wall’ in C++.
-Wimplicit-int (C and Objective-C only)
Warn when a declaration does not specify a type. This warning is enabled by
‘-Wall’.
-Wimplicit-function-declaration (C and Objective-C only)
Give a warning whenever a function is used before being declared. In C99 mode
(‘-std=c99’ or ‘-std=gnu99’), this warning is enabled by default and it is made
into an error by ‘-pedantic-errors’. This warning is also enabled by ‘-Wall’.
-Wimplicit (C and Objective-C only)
Same as ‘-Wimplicit-int’ and ‘-Wimplicit-function-declaration’. This
warning is enabled by ‘-Wall’.
-Wimplicit-fallthrough
‘-Wimplicit-fallthrough’ is the same as ‘-Wimplicit-fallthrough=3’ and
‘-Wno-implicit-fallthrough’ is the same as ‘-Wimplicit-fallthrough=0’.
-Wimplicit-fallthrough=n
Warn when a switch case falls through. For example:
switch (cond)
{
case 1:
a = 1;
break;
case 2:
a = 2;
case 3:
a = 3;
break;
}
This warning does not warn when the last statement of a case cannot fall
through, e.g. when there is a return statement or a call to function declared with
the noreturn attribute. ‘-Wimplicit-fallthrough=’ also takes into account
control flow statements, such as ifs, and only warns when appropriate. E.g.
switch (cond)
{
case 1:
if (i > 3) {
bar (5);
break;
} else if (i < 1) {
bar (0);
} else
return;
default:
...
}
Chapter 3: GCC Command Options 69

Since there are occasions where a switch case fall through is desirable, GCC
provides an attribute, __attribute__ ((fallthrough)), that is to be used
along with a null statement to suppress this warning that would normally occur:
switch (cond)
{
case 1:
bar (0);
__attribute__ ((fallthrough));
default:
...
}
C++17 provides a standard way to suppress the ‘-Wimplicit-fallthrough’
warning using [[fallthrough]]; instead of the GNU attribute. In C++11
or C++14 users can use [[gnu::fallthrough]];, which is a GNU extension.
Instead of the these attributes, it is also possible to add a fallthrough com-
ment to silence the warning. The whole body of the C or C++ style comment
should match the given regular expressions listed below. The option argument
n specifies what kind of comments are accepted:
• ‘-Wimplicit-fallthrough=0’ disables the warning altogether.
• ‘-Wimplicit-fallthrough=1’ matches .* regular expression, any com-
ment is used as fallthrough comment.
• ‘-Wimplicit-fallthrough=2’ case insensitively matches .*falls?[ \t-
]*thr(ough|u).* regular expression.
• ‘-Wimplicit-fallthrough=3’ case sensitively matches one of the following
regular expressions:
• -fallthrough
• @fallthrough@
• lint -fallthrough[ \t]*
• [ \t.!]*(ELSE,? |INTENTIONAL(LY)? )?
FALL(S | |-)?THR(OUGH|U)[ \t.!]*(-[^\n\r]*)?
• [ \t.!]*(Else,? |Intentional(ly)? )?
Fall((s | |-)[Tt]|t)hr(ough|u)[ \t.!]*(-[^\n\r]*)?
• [ \t.!]*([Ee]lse,? |[Ii]ntentional(ly)? )?
fall(s | |-)?thr(ough|u)[ \t.!]*(-[^\n\r]*)?
• ‘-Wimplicit-fallthrough=4’ case sensitively matches one of the following
regular expressions:
• -fallthrough
• @fallthrough@
• lint -fallthrough[ \t]*
• [ \t]*FALLTHR(OUGH|U)[ \t]*
• ‘-Wimplicit-fallthrough=5’ doesn’t recognize any comments as
fallthrough comments, only attributes disable the warning.
The comment needs to be followed after optional whitespace and other com-
ments by case or default keywords or by a user label that precedes some case
or default label.
70 Using the GNU Compiler Collection (GCC)

switch (cond)
{
case 1:
bar (0);
/* FALLTHRU */
default:
...
}
The ‘-Wimplicit-fallthrough=3’ warning is enabled by ‘-Wextra’.

-Wignored-qualifiers (C and C++ only)

Warn if the return type of a function has a type qualifier such as const. For
ISO C such a type qualifier has no effect, since the value returned by a function
is not an lvalue. For C++, the warning is only emitted for scalar types or void.
ISO C prohibits qualified void return types on function definitions, so such
return types always receive a warning even without this option.
This warning is also enabled by ‘-Wextra’.

-Wignored-attributes (C and C++ only)

Warn when an attribute is ignored. This is different from the ‘-Wattributes’
option in that it warns whenever the compiler decides to drop an attribute, not
that the attribute is either unknown, used in a wrong place, etc. This warning
is enabled by default.

-Wmain Warn if the type of main is suspicious. main should be a function with external
linkage, returning int, taking either zero arguments, two, or three arguments of
appropriate types. This warning is enabled by default in C++ and is enabled
by either ‘-Wall’ or ‘-Wpedantic’.

-Wmisleading-indentation (C and C++ only)

Warn when the indentation of the code does not reflect the block structure.
Specifically, a warning is issued for if, else, while, and for clauses with a
guarded statement that does not use braces, followed by an unguarded state-
ment with the same indentation.
In the following example, the call to “bar” is misleadingly indented as if it were
guarded by the “if” conditional.
if (some_condition ())
foo ();
bar (); /* Gotcha: this is not guarded by the "if". */
In the case of mixed tabs and spaces, the warning uses the ‘-ftabstop=’ option
to determine if the statements line up (defaulting to 8).
The warning is not issued for code involving multiline preprocessor logic such
as the following example.
if (flagA)
foo (0);
#if SOME_CONDITION_THAT_DOES_NOT_HOLD
if (flagB)
#endif
foo (1);
Chapter 3: GCC Command Options 71

The warning is not issued after a #line directive, since this typically indicates
autogenerated code, and no assumptions can be made about the layout of the
file that the directive references.
This warning is enabled by ‘-Wall’ in C and C++.
-Wmissing-braces
Warn if an aggregate or union initializer is not fully bracketed. In the following
example, the initializer for a is not fully bracketed, but that for b is fully
bracketed. This warning is enabled by ‘-Wall’ in C.
int a[2][2] = { 0, 1, 2, 3 };
int b[2][2] = { { 0, 1 }, { 2, 3 } };
This warning is enabled by ‘-Wall’.
-Wmissing-include-dirs (C, C++, Objective-C and Objective-C++ only)
Warn if a user-supplied include directory does not exist.
-Wparentheses
Warn if parentheses are omitted in certain contexts, such as when there is an
assignment in a context where a truth value is expected, or when operators are
nested whose precedence people often get confused about.
Also warn if a comparison like x<=y<=z appears; this is equivalent to (x<=y ? 1
: 0) <= z, which is a different interpretation from that of ordinary mathemat-
ical notation.
Also warn for dangerous uses of the GNU extension to ?: with omitted middle
operand. When the condition in the ?: operator is a boolean expression, the
omitted value is always 1. Often programmers expect it to be a value computed
inside the conditional expression instead.
This warning is enabled by ‘-Wall’.
-Wsequence-point
Warn about code that may have undefined semantics because of violations of
sequence point rules in the C and C++ standards.
The C and C++ standards define the order in which expressions in a C/C++
program are evaluated in terms of sequence points, which represent a partial
ordering between the execution of parts of the program: those executed before
the sequence point, and those executed after it. These occur after the evalua-
tion of a full expression (one which is not part of a larger expression), after the
evaluation of the first operand of a &&, ||, ? : or , (comma) operator, before a
function is called (but after the evaluation of its arguments and the expression
denoting the called function), and in certain other places. Other than as ex-
pressed by the sequence point rules, the order of evaluation of subexpressions
of an expression is not specified. All these rules describe only a partial order
rather than a total order, since, for example, if two functions are called within
one expression with no sequence point between them, the order in which the
functions are called is not specified. However, the standards committee have
ruled that function calls do not overlap.
It is not specified when between sequence points modifications to the values of
objects take effect. Programs whose behavior depends on this have undefined
72 Using the GNU Compiler Collection (GCC)

behavior; the C and C++ standards specify that “Between the previous and
next sequence point an object shall have its stored value modified at most once
by the evaluation of an expression. Furthermore, the prior value shall be read
only to determine the value to be stored.”. If a program breaks these rules, the
results on any particular implementation are entirely unpredictable.
Examples of code with undefined behavior are a = a++;, a[n] = b[n++] and
a[i++] = i;. Some more complicated cases are not diagnosed by this option,
and it may give an occasional false positive result, but in general it has been
found fairly effective at detecting this sort of problem in programs.
The C++17 standard will define the order of evaluation of operands in more
cases: in particular it requires that the right-hand side of an assignment be
evaluated before the left-hand side, so the above examples are no longer unde-
fined. But this warning will still warn about them, to help people avoid writing
code that is undefined in C and earlier revisions of C++.
The standard is worded confusingly, therefore there is some debate over the
precise meaning of the sequence point rules in subtle cases. Links to discussions
of the problem, including proposed formal definitions, may be found on the GCC
readings page, at http://gcc.gnu.org/readings.html.
This warning is enabled by ‘-Wall’ for C and C++.
-Wno-return-local-addr
Do not warn about returning a pointer (or in C++, a reference) to a variable
that goes out of scope after the function returns.
-Wreturn-type
Warn whenever a function is defined with a return type that defaults to int.
Also warn about any return statement with no return value in a function whose
return type is not void (falling off the end of the function body is considered
returning without a value).
For C only, warn about a return statement with an expression in a function
whose return type is void, unless the expression type is also void. As a GNU
extension, the latter case is accepted without a warning unless ‘-Wpedantic’ is
used.
For C++, a function without return type always produces a diagnostic message,
even when ‘-Wno-return-type’ is specified. The only exceptions are main and
functions defined in system headers.
This warning is enabled by ‘-Wall’.
-Wshift-count-negative
Warn if shift count is negative. This warning is enabled by default.
-Wshift-count-overflow
Warn if shift count >= width of type. This warning is enabled by default.
-Wshift-negative-value
Warn if left shifting a negative value. This warning is enabled by ‘-Wextra’ in
C99 and C++11 modes (and newer).
Chapter 3: GCC Command Options 73

-Wshift-overflow
-Wshift-overflow=n
Warn about left shift overflows. This warning is enabled by default in C99 and
C++11 modes (and newer).
-Wshift-overflow=1
This is the warning level of ‘-Wshift-overflow’ and is enabled by
default in C99 and C++11 modes (and newer). This warning level
does not warn about left-shifting 1 into the sign bit. (However, in
C, such an overflow is still rejected in contexts where an integer
constant expression is required.)
-Wshift-overflow=2
This warning level also warns about left-shifting 1 into the sign bit,
unless C++14 mode is active.
-Wswitch Warn whenever a switch statement has an index of enumerated type and lacks
a case for one or more of the named codes of that enumeration. (The presence
of a default label prevents this warning.) case labels outside the enumeration
range also provoke warnings when this option is used (even if there is a default
label). This warning is enabled by ‘-Wall’.
-Wswitch-default
Warn whenever a switch statement does not have a default case.
-Wswitch-enum
Warn whenever a switch statement has an index of enumerated type and lacks
a case for one or more of the named codes of that enumeration. case labels
outside the enumeration range also provoke warnings when this option is used.
The only difference between ‘-Wswitch’ and this option is that this option gives
a warning about an omitted enumeration code even if there is a default label.
-Wswitch-bool
Warn whenever a switch statement has an index of boolean type and the case
values are outside the range of a boolean type. It is possible to suppress this
warning by casting the controlling expression to a type other than bool. For
example:
switch ((int) (a == 4))
{
...
}
This warning is enabled by default for C and C++ programs.
-Wswitch-unreachable
Warn whenever a switch statement contains statements between the controlling
expression and the first case label, which will never be executed. For example:
switch (cond)
{
i = 15;
...
case 5:
...
}
74 Using the GNU Compiler Collection (GCC)

‘-Wswitch-unreachable’ does not warn if the statement between the control-

ling expression and the first case label is just a declaration:
switch (cond)
{
int i;
...
case 5:
i = 5;
...
}
This warning is enabled by default for C and C++ programs.
-Wsync-nand (C and C++ only)
Warn when __sync_fetch_and_nand and __sync_nand_and_fetch built-in
functions are used. These functions changed semantics in GCC 4.4.
-Wunused-but-set-parameter
Warn whenever a function parameter is assigned to, but otherwise unused (aside
from its declaration).
To suppress this warning use the unused attribute (see Section 6.32 [Variable
Attributes], page 474).
This warning is also enabled by ‘-Wunused’ together with ‘-Wextra’.
-Wunused-but-set-variable
Warn whenever a local variable is assigned to, but otherwise unused (aside from
its declaration). This warning is enabled by ‘-Wall’.
To suppress this warning use the unused attribute (see Section 6.32 [Variable
Attributes], page 474).
This warning is also enabled by ‘-Wunused’, which is enabled by ‘-Wall’.
-Wunused-function
Warn whenever a static function is declared but not defined or a non-inline
static function is unused. This warning is enabled by ‘-Wall’.
-Wunused-label
Warn whenever a label is declared but not used. This warning is enabled by
‘-Wall’.
To suppress this warning use the unused attribute (see Section 6.32 [Variable
Attributes], page 474).
-Wunused-local-typedefs (C, Objective-C, C++ and Objective-C++ only)
Warn when a typedef locally defined in a function is not used. This warning is
enabled by ‘-Wall’.
-Wunused-parameter
Warn whenever a function parameter is unused aside from its declaration.
To suppress this warning use the unused attribute (see Section 6.32 [Variable
Attributes], page 474).
-Wno-unused-result
Do not warn if a caller of a function marked with attribute warn_unused_
result (see Section 6.31 [Function Attributes], page 429) does not use its return
value. The default is ‘-Wunused-result’.
Chapter 3: GCC Command Options 75

-Wunused-variable
Warn whenever a local or static variable is unused aside from its declaration.
This option implies ‘-Wunused-const-variable=1’ for C, but not for C++. This
warning is enabled by ‘-Wall’.
To suppress this warning use the unused attribute (see Section 6.32 [Variable
Attributes], page 474).
-Wunused-const-variable
-Wunused-const-variable=n
Warn whenever a constant static variable is unused aside from its declaration.
‘-Wunused-const-variable=1’ is enabled by ‘-Wunused-variable’ for C, but
not for C++. In C this declares variable storage, but in C++ this is not an error
since const variables take the place of #defines.
To suppress this warning use the unused attribute (see Section 6.32 [Variable
Attributes], page 474).
-Wunused-const-variable=1
This is the warning level that is enabled by ‘-Wunused-variable’
for C. It warns only about unused static const variables defined
in the main compilation unit, but not about static const variables
declared in any header included.
-Wunused-const-variable=2
This warning level also warns for unused constant static variables
in headers (excluding system headers). This is the warning level
of ‘-Wunused-const-variable’ and must be explicitly requested
since in C++ this isn’t an error and in C it might be harder to clean
up all headers included.
-Wunused-value
Warn whenever a statement computes a result that is explicitly not used. To
suppress this warning cast the unused expression to void. This includes an
expression-statement or the left-hand side of a comma expression that contains
no side effects. For example, an expression such as x[i,j] causes a warning,
while x[(void)i,j] does not.
This warning is enabled by ‘-Wall’.
-Wunused All the above ‘-Wunused’ options combined.
In order to get a warning about an unused function parameter, you must either
specify ‘-Wextra -Wunused’ (note that ‘-Wall’ implies ‘-Wunused’), or sepa-
rately specify ‘-Wunused-parameter’.
-Wuninitialized
Warn if an automatic variable is used without first being initialized or if a
variable may be clobbered by a setjmp call. In C++, warn if a non-static
reference or non-static const member appears in a class without constructors.
If you want to warn about code that uses the uninitialized value of the variable
in its own initializer, use the ‘-Winit-self’ option.
These warnings occur for individual uninitialized or clobbered elements of struc-
ture, union or array variables as well as for variables that are uninitialized or
76 Using the GNU Compiler Collection (GCC)

clobbered as a whole. They do not occur for variables or elements declared

volatile. Because these warnings depend on optimization, the exact variables
or elements for which there are warnings depends on the precise optimization
options and version of GCC used.
Note that there may be no warning about a variable that is used only to compute
a value that itself is never used, because such computations may be deleted by
data flow analysis before the warnings are printed.
-Winvalid-memory-model
Warn for invocations of Section 6.53 [ atomic Builtins], page 560, Section 6.52
[ sync Builtins], page 558, and the C11 atomic generic functions with a memory
consistency argument that is either invalid for the operation or outside the range
of values of the memory_order enumeration. For example, since the __atomic_
store and __atomic_store_n built-ins are only defined for the relaxed, release,
and sequentially consistent memory orders the following code is diagnosed:
void store (int *i)
{
__atomic_store_n (i, 0, memory_order_consume);
}
‘-Winvalid-memory-model’ is enabled by default.
-Wmaybe-uninitialized
For an automatic variable, if there exists a path from the function entry to a
use of the variable that is initialized, but there exist some other paths for which
the variable is not initialized, the compiler emits a warning if it cannot prove
the uninitialized paths are not executed at run time. These warnings are made
optional because GCC is not smart enough to see all the reasons why the code
might be correct in spite of appearing to have an error. Here is one example of
how this can happen:
{
int x;
switch (y)
{
case 1: x = 1;
break;
case 2: x = 4;
break;
case 3: x = 5;
}
foo (x);
}
If the value of y is always 1, 2 or 3, then x is always initialized, but GCC doesn’t
know this. To suppress the warning, you need to provide a default case with
assert(0) or similar code.
This option also warns when a non-volatile automatic variable might be changed
by a call to longjmp. These warnings as well are possible only in optimizing
compilation.
The compiler sees only the calls to setjmp. It cannot know where longjmp will
be called; in fact, a signal handler could call it at any point in the code. As a
Chapter 3: GCC Command Options 77

result, you may get a warning even when there is in fact no problem because
longjmp cannot in fact be called at the place that would cause a problem.
Some spurious warnings can be avoided if you declare all the functions you
use that never return as noreturn. See Section 6.31 [Function Attributes],
page 429.
This warning is enabled by ‘-Wall’ or ‘-Wextra’.

-Wunknown-pragmas
Warn when a #pragma directive is encountered that is not understood by GCC.
If this command-line option is used, warnings are even issued for unknown
pragmas in system header files. This is not the case if the warnings are only
enabled by the ‘-Wall’ command-line option.

-Wno-pragmas
Do not warn about misuses of pragmas, such as incorrect parameters, invalid
syntax, or conflicts between pragmas. See also ‘-Wunknown-pragmas’.

-Wstrict-aliasing
This option is only active when ‘-fstrict-aliasing’ is active. It warns about
code that might break the strict aliasing rules that the compiler is using for
optimization. The warning does not catch all cases, but does attempt to
catch the more common pitfalls. It is included in ‘-Wall’. It is equivalent
to ‘-Wstrict-aliasing=3’

-Wstrict-aliasing=n
This option is only active when ‘-fstrict-aliasing’ is active. It warns about
code that might break the strict aliasing rules that the compiler is using for op-
timization. Higher levels correspond to higher accuracy (fewer false positives).
Higher levels also correspond to more effort, similar to the way ‘-O’ works.
‘-Wstrict-aliasing’ is equivalent to ‘-Wstrict-aliasing=3’.
Level 1: Most aggressive, quick, least accurate. Possibly useful when higher
levels do not warn but ‘-fstrict-aliasing’ still breaks the code, as it has very
few false negatives. However, it has many false positives. Warns for all pointer
conversions between possibly incompatible types, even if never dereferenced.
Runs in the front end only.
Level 2: Aggressive, quick, not too precise. May still have many false positives
(not as many as level 1 though), and few false negatives (but possibly more
than level 1). Unlike level 1, it only warns when an address is taken. Warns
about incomplete types. Runs in the front end only.
Level 3 (default for ‘-Wstrict-aliasing’): Should have very few false positives
and few false negatives. Slightly slower than levels 1 or 2 when optimization
is enabled. Takes care of the common pun+dereference pattern in the front
end: *(int*)&some_float. If optimization is enabled, it also runs in the back
end, where it deals with multiple statement cases using flow-sensitive points-to
information. Only warns when the converted pointer is dereferenced. Does not
warn about incomplete types.
78 Using the GNU Compiler Collection (GCC)

-Wstrict-overflow
-Wstrict-overflow=n
This option is only active when ‘-fstrict-overflow’ is active. It warns about
cases where the compiler optimizes based on the assumption that signed over-
flow does not occur. Note that it does not warn about all cases where the code
might overflow: it only warns about cases where the compiler implements some
optimization. Thus this warning depends on the optimization level.
An optimization that assumes that signed overflow does not occur is perfectly
safe if the values of the variables involved are such that overflow never does, in
fact, occur. Therefore this warning can easily give a false positive: a warning
about code that is not actually a problem. To help focus on important issues,
several warning levels are defined. No warnings are issued for the use of unde-
fined signed overflow when estimating how many iterations a loop requires, in
particular when determining whether a loop will be executed at all.
-Wstrict-overflow=1
Warn about cases that are both questionable and easy to avoid. For
example, with ‘-fstrict-overflow’, the compiler simplifies x + 1
> x to 1. This level of ‘-Wstrict-overflow’ is enabled by ‘-Wall’;
higher levels are not, and must be explicitly requested.
-Wstrict-overflow=2
Also warn about other cases where a comparison is simplified to
a constant. For example: abs (x) >= 0. This can only be simpli-
fied when ‘-fstrict-overflow’ is in effect, because abs (INT_MIN)
overflows to INT_MIN, which is less than zero. ‘-Wstrict-overflow’
(with no level) is the same as ‘-Wstrict-overflow=2’.
-Wstrict-overflow=3
Also warn about other cases where a comparison is simplified. For
example: x + 1 > 1 is simplified to x > 0.
-Wstrict-overflow=4
Also warn about other simplifications not covered by the above
cases. For example: (x * 10) / 5 is simplified to x * 2.
-Wstrict-overflow=5
Also warn about cases where the compiler reduces the magnitude
of a constant involved in a comparison. For example: x + 2 > y is
simplified to x + 1 >= y. This is reported only at the highest warn-
ing level because this simplification applies to many comparisons,
so this warning level gives a very large number of false positives.
-Wstringop-overflow
-Wstringop-overflow=type
Warn for calls to string manipulation functions such as memcpy and strcpy
that are determined to overflow the destination buffer. The optional argument
is one greater than the type of Object Size Checking to perform to determine
the size of the destination. See Section 6.56 [Object Size Checking], page 567.
The argument is meaningful only for functions that operate on character arrays
Chapter 3: GCC Command Options 79

but not for raw memory functions like memcpy which always make use of Object
Size type-0. The option also warns for calls that specify a size in excess of the
largest possible object or at most SIZE_MAX / 2 bytes. The option produces
the best results with optimization enabled but can detect a small subset of
simple buffer overflows even without optimization in calls to the GCC built-in
functions like __builtin_memcpy that correspond to the standard functions.
In any case, the option warns about just a subset of buffer overflows detected
by the corresponding overflow checking built-ins. For example, the option will
issue a warning for the strcpy call below because it copies at least 5 characters
(the string "blue" including the terminating NUL) into the buffer of size 4.
enum Color { blue, purple, yellow };
const char* f (enum Color clr)
{
static char buf [4];
const char *str;
switch (clr)
{
case blue: str = "blue"; break;
case purple: str = "purple"; break;
case yellow: str = "yellow"; break;
}

return strcpy (buf, str); // warning here

}
Option ‘-Wstringop-overflow=2’ is enabled by default.
-Wstringop-overflow
-Wstringop-overflow=1
The ‘-Wstringop-overflow=1’ option uses type-zero Object Size
Checking to determine the sizes of destination objects. This is
the default setting of the option. At this setting the option will
not warn for writes past the end of subobjects of larger objects
accessed by pointers unless the size of the largest surrounding object
is known. When the destination may be one of several objects it is
assumed to be the largest one of them. On Linux systems, when
optimization is enabled at this setting the option warns for the same
code as when the _FORTIFY_SOURCE macro is defined to a non-zero
value.
-Wstringop-overflow=2
The ‘-Wstringop-overflow=2’ option uses type-one Object Size
Checking to determine the sizes of destination objects. At this
setting the option will warn about overflows when writing to mem-
bers of the largest complete objects whose exact size is known. It
will, however, not warn for excessive writes to the same members
of unknown objects referenced by pointers since they may point to
arrays containing unknown numbers of elements.
-Wstringop-overflow=3
The ‘-Wstringop-overflow=3’ option uses type-two Object Size
Checking to determine the sizes of destination objects. At this
80 Using the GNU Compiler Collection (GCC)

setting the option warns about overflowing the smallest object or

data member. This is the most restrictive setting of the option that
may result in warnings for safe code.

-Wstringop-overflow=4
The ‘-Wstringop-overflow=4’ option uses type-three Object Size
Checking to determine the sizes of destination objects. At this
setting the option will warn about overflowing any data members,
and when the destination is one of several objects it uses the size of
the largest of them to decide whether to issue a warning. Similarly
to ‘-Wstringop-overflow=3’ this setting of the option may result
in warnings for benign code.

-Wsuggest-attribute=[pure|const|noreturn|format]
Warn for cases where adding an attribute may be beneficial. The attributes
currently supported are listed below.

-Wsuggest-attribute=pure
-Wsuggest-attribute=const
-Wsuggest-attribute=noreturn
Warn about functions that might be candidates for attributes pure,
const or noreturn. The compiler only warns for functions visible
in other compilation units or (in the case of pure and const) if
it cannot prove that the function returns normally. A function
returns normally if it doesn’t contain an infinite loop or return
abnormally by throwing, calling abort or trapping. This analysis
requires option ‘-fipa-pure-const’, which is enabled by default at
‘-O’ and higher. Higher optimization levels improve the accuracy
of the analysis.

-Wsuggest-attribute=format
-Wmissing-format-attribute
Warn about function pointers that might be candidates for format
attributes. Note these are only possible candidates, not absolute
ones. GCC guesses that function pointers with format attributes
that are used in assignment, initialization, parameter passing or
return statements should have a corresponding format attribute
in the resulting type. I.e. the left-hand side of the assignment or
initialization, the type of the parameter variable, or the return type
of the containing function respectively should also have a format
attribute to avoid the warning.
GCC also warns about function definitions that might be candi-
dates for format attributes. Again, these are only possible candi-
dates. GCC guesses that format attributes might be appropriate
for any function that calls a function like vprintf or vscanf, but
this might not always be the case, and some functions for which
format attributes are appropriate may not be detected.
Chapter 3: GCC Command Options 81

-Wsuggest-final-types
Warn about types with virtual methods where code quality would be improved
if the type were declared with the C++11 final specifier, or, if possible, de-
clared in an anonymous namespace. This allows GCC to more aggressively
devirtualize the polymorphic calls. This warning is more effective with link
time optimization, where the information about the class hierarchy graph is
more complete.
-Wsuggest-final-methods
Warn about virtual methods where code quality would be improved if the
method were declared with the C++11 final specifier, or, if possible, its type
were declared in an anonymous namespace or with the final specifier. This
warning is more effective with link-time optimization, where the information
about the class hierarchy graph is more complete. It is recommended to first
consider suggestions of ‘-Wsuggest-final-types’ and then rebuild with new
annotations.
-Wsuggest-override
Warn about overriding virtual functions that are not marked with the override
keyword.
-Walloc-zero
Warn about calls to allocation functions decorated with attribute alloc_size
that specify zero bytes, including those to the built-in forms of the functions
aligned_alloc, alloca, calloc, malloc, and realloc. Because the behavior
of these functions when called with a zero size differs among implementations
(and in the case of realloc has been deprecated) relying on it may result in
subtle portability bugs and should be avoided.
-Walloc-size-larger-than=n
Warn about calls to functions decorated with attribute alloc_size that at-
tempt to allocate objects larger than the specified number of bytes, or where
the result of the size computation in an integer type with infinite precision
would exceed SIZE_MAX / 2. The option argument n may end in one of the
standard suffixes designating a multiple of bytes such as kB and KiB for kilobyte
and kibibyte, respectively, MB and MiB for megabyte and mebibyte, and so on.
‘-Walloc-size-larger-than=’PTRDIFF MAX is enabled by default. Warn-
ings controlled by the option can be disabled by specifying n of SIZE MAX or
more. See Section 6.31 [Function Attributes], page 429.
-Walloca This option warns on all uses of alloca in the source.
-Walloca-larger-than=n
This option warns on calls to alloca that are not bounded by a controlling
predicate limiting its argument of integer type to at most n bytes, or calls
to alloca where the bound is unknown. Arguments of non-integer types are
considered unbounded even if they appear to be constrained to the expected
range.
For example, a bounded case of alloca could be:
void func (size_t n)
82 Using the GNU Compiler Collection (GCC)

{
void *p;
if (n <= 1000)
p = alloca (n);
else
p = malloc (n);
f (p);
}
In the above example, passing -Walloca-larger-than=1000 would not issue a
warning because the call to alloca is known to be at most 1000 bytes. However,
if -Walloca-larger-than=500 were passed, the compiler would emit a warning.
Unbounded uses, on the other hand, are uses of alloca with no controlling
predicate constraining its integer argument. For example:
void func ()
{
void *p = alloca (n);
f (p);
}
If -Walloca-larger-than=500 were passed, the above would trigger a warning,
but this time because of the lack of bounds checking.
Note, that even seemingly correct code involving signed integers could cause a
warning:
void func (signed int n)
{
if (n < 500)
{
p = alloca (n);
f (p);
}
}
In the above example, n could be negative, causing a larger than expected
argument to be implicitly cast into the alloca call.
This option also warns when alloca is used in a loop.
This warning is not enabled by ‘-Wall’, and is only active when ‘-ftree-vrp’
is active (default for ‘-O2’ and above).
See also ‘-Wvla-larger-than=n’.
-Warray-bounds
-Warray-bounds=n
This option is only active when ‘-ftree-vrp’ is active (default for ‘-O2’ and
above). It warns about subscripts to arrays that are always out of bounds. This
warning is enabled by ‘-Wall’.
-Warray-bounds=1
This is the warning level of ‘-Warray-bounds’ and is enabled by
‘-Wall’; higher levels are not, and must be explicitly requested.
-Warray-bounds=2
This warning level also warns about out of bounds access for arrays
at the end of a struct and for arrays accessed through pointers.
Chapter 3: GCC Command Options 83

This warning level may give a larger number of false positives and
is deactivated by default.
-Wbool-compare
Warn about boolean expression compared with an integer value different from
true/false. For instance, the following comparison is always false:
int n = 5;
...
if ((n > 1) == 2) { ... }
This warning is enabled by ‘-Wall’.
-Wbool-operation
Warn about suspicious operations on expressions of a boolean type. For in-
stance, bitwise negation of a boolean is very likely a bug in the program. For
C, this warning also warns about incrementing or decrementing a boolean,
which rarely makes sense. (In C++, decrementing a boolean is always invalid.
Incrementing a boolean is invalid in C++1z, and deprecated otherwise.)
This warning is enabled by ‘-Wall’.
-Wduplicated-branches
Warn when an if-else has identical branches. This warning detects cases like
if (p != NULL)
return 0;
else
return 0;
It doesn’t warn when both branches contain just a null statement. This warning
also warn for conditional operators:
int i = x ? *p : *p;

-Wduplicated-cond
Warn about duplicated conditions in an if-else-if chain. For instance, warn for
the following code:
if (p->q != NULL) { ... }
else if (p->q != NULL) { ... }

-Wframe-address
Warn when the ‘__builtin_frame_address’ or ‘__builtin_return_address’
is called with an argument greater than 0. Such calls may return indeterminate
values or crash the program. The warning is included in ‘-Wall’.
-Wno-discarded-qualifiers (C and Objective-C only)
Do not warn if type qualifiers on pointers are being discarded. Typically, the
compiler warns if a const char * variable is passed to a function that takes a
char * parameter. This option can be used to suppress such a warning.
-Wno-discarded-array-qualifiers (C and Objective-C only)
Do not warn if type qualifiers on arrays which are pointer targets are being
discarded. Typically, the compiler warns if a const int (*)[] variable is passed
to a function that takes a int (*)[] parameter. This option can be used to
suppress such a warning.
84 Using the GNU Compiler Collection (GCC)

-Wno-incompatible-pointer-types (C and Objective-C only)

Do not warn when there is a conversion between pointers that have incompatible
types. This warning is for cases not covered by ‘-Wno-pointer-sign’, which
warns for pointer argument passing or assignment with different signedness.
-Wno-int-conversion (C and Objective-C only)
Do not warn about incompatible integer to pointer and pointer to integer con-
versions. This warning is about implicit conversions; for explicit conversions
the warnings ‘-Wno-int-to-pointer-cast’ and ‘-Wno-pointer-to-int-cast’
may be used.
-Wno-div-by-zero
Do not warn about compile-time integer division by zero. Floating-point divi-
sion by zero is not warned about, as it can be a legitimate way of obtaining
infinities and NaNs.
-Wsystem-headers
Print warning messages for constructs found in system header files. Warnings
from system headers are normally suppressed, on the assumption that they
usually do not indicate real problems and would only make the compiler output
harder to read. Using this command-line option tells GCC to emit warnings
from system headers as if they occurred in user code. However, note that using
‘-Wall’ in conjunction with this option does not warn about unknown pragmas
in system headers—for that, ‘-Wunknown-pragmas’ must also be used.
-Wtautological-compare
Warn if a self-comparison always evaluates to true or false. This warning detects
various mistakes such as:
int i = 1;
...
if (i > i) { ... }
This warning is enabled by ‘-Wall’.
-Wtrampolines
Warn about trampolines generated for pointers to nested functions. A tram-
poline is a small piece of data or code that is created at run time on the stack
when the address of a nested function is taken, and is used to call the nested
function indirectly. For some targets, it is made up of data only and thus re-
quires no special treatment. But, for most targets, it is made up of code and
thus requires the stack to be made executable in order for the program to work
properly.
-Wfloat-equal
Warn if floating-point values are used in equality comparisons.
The idea behind this is that sometimes it is convenient (for the programmer)
to consider floating-point values as approximations to infinitely precise real
numbers. If you are doing this, then you need to compute (by analyzing the
code, or in some other way) the maximum or likely maximum error that the
computation introduces, and allow for it when performing comparisons (and
when producing output, but that’s a different problem). In particular, instead
Chapter 3: GCC Command Options 85

of testing for equality, you should check to see whether the two values have
ranges that overlap; and this is done with the relational operators, so equality
comparisons are probably mistaken.
-Wtraditional (C and Objective-C only)
Warn about certain constructs that behave differently in traditional and ISO
C. Also warn about ISO C constructs that have no traditional C equivalent,
and/or problematic constructs that should be avoided.
• Macro parameters that appear within string literals in the macro body. In
traditional C macro replacement takes place within string literals, but in
ISO C it does not.
• In traditional C, some preprocessor directives did not exist. Traditional
preprocessors only considered a line to be a directive if the ‘#’ appeared in
column 1 on the line. Therefore ‘-Wtraditional’ warns about directives
that traditional C understands but ignores because the ‘#’ does not appear
as the first character on the line. It also suggests you hide directives like
#pragma not understood by traditional C by indenting them. Some tra-
ditional implementations do not recognize #elif, so this option suggests
avoiding it altogether.
• A function-like macro that appears without arguments.
• The unary plus operator.
• The ‘U’ integer constant suffix, or the ‘F’ or ‘L’ floating-point constant
suffixes. (Traditional C does support the ‘L’ suffix on integer constants.)
Note, these suffixes appear in macros defined in the system headers of most
modern systems, e.g. the ‘_MIN’/‘_MAX’ macros in <limits.h>. Use of these
macros in user code might normally lead to spurious warnings, however
GCC’s integrated preprocessor has enough context to avoid warning in
these cases.
• A function declared external in one block and then used after the end of
the block.
• A switch statement has an operand of type long.
• A non-static function declaration follows a static one. This construct
is not accepted by some traditional C compilers.
• The ISO type of an integer constant has a different width or signedness
from its traditional type. This warning is only issued if the base of the
constant is ten. I.e. hexadecimal or octal values, which typically represent
bit patterns, are not warned about.
• Usage of ISO string concatenation is detected.
• Initialization of automatic aggregates.
• Identifier conflicts with labels. Traditional C lacks a separate namespace
for labels.
• Initialization of unions. If the initializer is zero, the warning is omitted.
This is done under the assumption that the zero initializer in user code
appears conditioned on e.g. __STDC__ to avoid missing initializer warnings
and relies on default initialization to zero in the traditional C case.
86 Using the GNU Compiler Collection (GCC)

• Conversions by prototypes between fixed/floating-point values and vice

versa. The absence of these prototypes when compiling with traditional
C causes serious problems. This is a subset of the possible conversion
warnings; for the full set use ‘-Wtraditional-conversion’.
• Use of ISO C style function definitions. This warning intentionally is not
issued for prototype declarations or variadic functions because these ISO
C features appear in your code when using libiberty’s traditional C com-
patibility macros, PARAMS and VPARAMS. This warning is also bypassed for
nested functions because that feature is already a GCC extension and thus
not relevant to traditional C compatibility.

-Wtraditional-conversion (C and Objective-C only)

Warn if a prototype causes a type conversion that is different from what would
happen to the same argument in the absence of a prototype. This includes
conversions of fixed point to floating and vice versa, and conversions changing
the width or signedness of a fixed-point argument except when the same as the
default promotion.

-Wdeclaration-after-statement (C and Objective-C only)

Warn when a declaration is found after a statement in a block. This construct,
known from C++, was introduced with ISO C99 and is by default allowed in
GCC. It is not supported by ISO C90. See Section 6.30 [Mixed Declarations],
page 429.

-Wshadow Warn whenever a local variable or type declaration shadows another variable,
parameter, type, class member (in C++), or instance variable (in Objective-C)
or whenever a built-in function is shadowed. Note that in C++, the compiler
warns if a local variable shadows an explicit typedef, but not if it shadows a
struct/class/enum. Same as ‘-Wshadow=global’.

-Wno-shadow-ivar (Objective-C only)

Do not warn whenever a local variable shadows an instance variable in an
Objective-C method.

-Wshadow=global
The default for ‘-Wshadow’. Warns for any (global) shadowing.

-Wshadow=local
Warn when a local variable shadows another local variable or parameter. This
warning is enabled by ‘-Wshadow=global’.

-Wshadow=compatible-local
Warn when a local variable shadows another local variable or parameter whose
type is compatible with that of the shadowing variable. In C++, type compatibil-
ity here means the type of the shadowing variable can be converted to that of the
shadowed variable. The creation of this flag (in addition to ‘-Wshadow=local’)
is based on the idea that when a local variable shadows another one of incom-
patible type, it is most likely intentional, not a bug or typo, as shown in the
following example:
Chapter 3: GCC Command Options 87

for (SomeIterator i = SomeObj.begin(); i != SomeObj.end(); ++i)

{
for (int i = 0; i < N; ++i)
{
...
}
...
}
Since the two variable i in the example above have incompatible types, enabling
only ‘-Wshadow=compatible-local’ will not emit a warning. Because their
types are incompatible, if a programmer accidentally uses one in place of the
other, type checking will catch that and emit an error or warning. So not
warning (about shadowing) in this case will not lead to undetected bugs. Use
of this flag instead of ‘-Wshadow=local’ can possibly reduce the number of
warnings triggered by intentional shadowing.
This warning is enabled by ‘-Wshadow=local’.
-Wlarger-than=len
Warn whenever an object of larger than len bytes is defined.
-Wframe-larger-than=len
Warn if the size of a function frame is larger than len bytes. The computation
done to determine the stack frame size is approximate and not conservative.
The actual requirements may be somewhat greater than len even if you do not
get a warning. In addition, any space allocated via alloca, variable-length
arrays, or related constructs is not included by the compiler when determining
whether or not to issue a warning.
-Wno-free-nonheap-object
Do not warn when attempting to free an object that was not allocated on the
heap.
-Wstack-usage=len
Warn if the stack usage of a function might be larger than len bytes. The
computation done to determine the stack usage is conservative. Any space
allocated via alloca, variable-length arrays, or related constructs is included
by the compiler when determining whether or not to issue a warning.
The message is in keeping with the output of ‘-fstack-usage’.
• If the stack usage is fully static but exceeds the specified amount, it’s:
warning: stack usage is 1120 bytes
• If the stack usage is (partly) dynamic but bounded, it’s:
warning: stack usage might be 1648 bytes
• If the stack usage is (partly) dynamic and not bounded, it’s:
warning: stack usage might be unbounded

-Wunsafe-loop-optimizations
Warn if the loop cannot be optimized because the compiler cannot assume any-
thing on the bounds of the loop indices. With ‘-funsafe-loop-optimizations’
warn if the compiler makes such assumptions.
88 Using the GNU Compiler Collection (GCC)

-Wno-pedantic-ms-format (MinGW targets only)

When used in combination with ‘-Wformat’ and ‘-pedantic’ without GNU
extensions, this option disables the warnings about non-ISO printf / scanf
format width specifiers I32, I64, and I used on Windows targets, which depend
on the MS runtime.
-Waligned-new
Warn about a new-expression of a type that requires greater alignment than
the alignof(std::max_align_t) but uses an allocation function without an
explicit alignment parameter. This option is enabled by ‘-Wall’.
Normally this only warns about global allocation functions, but
‘-Waligned-new=all’ also warns about class member allocation functions.
-Wplacement-new
-Wplacement-new=n
Warn about placement new expressions with undefined behavior, such as con-
structing an object in a buffer that is smaller than the type of the object. For
example, the placement new expression below is diagnosed because it attempts
to construct an array of 64 integers in a buffer only 64 bytes large.
char buf [64];
new (buf) int[64];
This warning is enabled by default.
-Wplacement-new=1
This is the default warning level of ‘-Wplacement-new’. At this
level the warning is not issued for some strictly undefined constructs
that GCC allows as extensions for compatibility with legacy code.
For example, the following new expression is not diagnosed at this
level even though it has undefined behavior according to the C++
standard because it writes past the end of the one-element array.
struct S { int n, a[1]; };
S *s = (S *)malloc (sizeof *s + 31 * sizeof s->a[0]);
new (s->a)int [32]();
-Wplacement-new=2
At this level, in addition to diagnosing all the same constructs as
at level 1, a diagnostic is also issued for placement new expressions
that construct an object in the last member of structure whose type
is an array of a single element and whose size is less than the size of
the object being constructed. While the previous example would be
diagnosed, the following construct makes use of the flexible member
array extension to avoid the warning at level 2.
struct S { int n, a[]; };
S *s = (S *)malloc (sizeof *s + 32 * sizeof s->a[0]);
new (s->a)int [32]();
-Wpointer-arith
Warn about anything that depends on the “size of” a function type or of void.
GNU C assigns these types a size of 1, for convenience in calculations with void
* pointers and pointers to functions. In C++, warn also when an arithmetic
operation involves NULL. This warning is also enabled by ‘-Wpedantic’.
Chapter 3: GCC Command Options 89

-Wpointer-compare
Warn if a pointer is compared with a zero character constant. This usually
means that the pointer was meant to be dereferenced. For example:
const char *p = foo ();
if (p == ’\0’)
return 42;
Note that the code above is invalid in C++11.
This warning is enabled by default.
-Wtype-limits
Warn if a comparison is always true or always false due to the limited range of
the data type, but do not warn for constant expressions. For example, warn if
an unsigned variable is compared against zero with < or >=. This warning is
also enabled by ‘-Wextra’.
-Wcomment
-Wcomments
Warn whenever a comment-start sequence ‘/*’ appears in a ‘/*’ comment, or
whenever a backslash-newline appears in a ‘//’ comment. This warning is
enabled by ‘-Wall’.
-Wtrigraphs
Warn if any trigraphs are encountered that might change the meaning of the
program. Trigraphs within comments are not warned about, except those that
would form escaped newlines.
This option is implied by ‘-Wall’. If ‘-Wall’ is not given, this option
is still enabled unless trigraphs are enabled. To get trigraph conversion
without warnings, but get the other ‘-Wall’ warnings, use ‘-trigraphs -Wall
-Wno-trigraphs’.
-Wundef Warn if an undefined identifier is evaluated in an #if directive. Such identifiers
are replaced with zero.
-Wexpansion-to-defined
Warn whenever ‘defined’ is encountered in the expansion of a macro (including
the case where the macro is expanded by an ‘#if’ directive). Such usage is not
portable. This warning is also enabled by ‘-Wpedantic’ and ‘-Wextra’.
-Wunused-macros
Warn about macros defined in the main file that are unused. A macro is used
if it is expanded or tested for existence at least once. The preprocessor also
warns if the macro has not been used at the time it is redefined or undefined.
Built-in macros, macros defined on the command line, and macros defined in
include files are not warned about.
Note: If a macro is actually used, but only used in skipped conditional blocks,
then the preprocessor reports it as unused. To avoid the warning in such a case,
you might improve the scope of the macro’s definition by, for example, moving
it into the first skipped block. Alternatively, you could provide a dummy use
with something like:
90 Using the GNU Compiler Collection (GCC)

#if defined the_macro_causing_the_warning

#endif

-Wno-endif-labels
Do not warn whenever an #else or an #endif are followed by text. This
sometimes happens in older programs with code of the form
#if FOO
...
#else FOO
...
#endif FOO
The second and third FOO should be in comments. This warning is on by default.
-Wbad-function-cast (C and Objective-C only)
Warn when a function call is cast to a non-matching type. For example, warn
if a call to a function returning an integer type is cast to a pointer type.
-Wc90-c99-compat (C and Objective-C only)
Warn about features not present in ISO C90, but present in ISO C99. For
instance, warn about use of variable length arrays, long long type, bool type,
compound literals, designated initializers, and so on. This option is independent
of the standards mode. Warnings are disabled in the expression that follows
__extension__.
-Wc99-c11-compat (C and Objective-C only)
Warn about features not present in ISO C99, but present in ISO C11. For in-
stance, warn about use of anonymous structures and unions, _Atomic type qual-
ifier, _Thread_local storage-class specifier, _Alignas specifier, Alignof opera-
tor, _Generic keyword, and so on. This option is independent of the standards
mode. Warnings are disabled in the expression that follows __extension__.
-Wc++-compat (C and Objective-C only)
Warn about ISO C constructs that are outside of the common subset of ISO C
and ISO C++, e.g. request for implicit conversion from void * to a pointer to
non-void type.
-Wc++11-compat (C++ and Objective-C++ only)
Warn about C++ constructs whose meaning differs between ISO C++ 1998 and
ISO C++ 2011, e.g., identifiers in ISO C++ 1998 that are keywords in ISO C++
2011. This warning turns on ‘-Wnarrowing’ and is enabled by ‘-Wall’.
-Wc++14-compat (C++ and Objective-C++ only)
Warn about C++ constructs whose meaning differs between ISO C++ 2011 and
ISO C++ 2014. This warning is enabled by ‘-Wall’.
-Wc++1z-compat (C++ and Objective-C++ only)
Warn about C++ constructs whose meaning differs between ISO C++ 2014 and
the forthoming ISO C++ 2017(?). This warning is enabled by ‘-Wall’.
-Wcast-qual
Warn whenever a pointer is cast so as to remove a type qualifier from the target
type. For example, warn if a const char * is cast to an ordinary char *.
Chapter 3: GCC Command Options 91

Also warn when making a cast that introduces a type qualifier in an unsafe way.
For example, casting char ** to const char ** is unsafe, as in this example:
/* p is char ** value. */
const char **q = (const char **) p;
/* Assignment of readonly string to const char * is OK. */
*q = "string";
/* Now char** pointer points to read-only memory. */
**p = ’b’;

-Wcast-align
Warn whenever a pointer is cast such that the required alignment of the target
is increased. For example, warn if a char * is cast to an int * on machines
where integers can only be accessed at two- or four-byte boundaries.
-Wwrite-strings
When compiling C, give string constants the type const char[length] so that
copying the address of one into a non-const char * pointer produces a warning.
These warnings help you find at compile time code that can try to write into
a string constant, but only if you have been very careful about using const in
declarations and prototypes. Otherwise, it is just a nuisance. This is why we
did not make ‘-Wall’ request these warnings.
When compiling C++, warn about the deprecated conversion from string literals
to char *. This warning is enabled by default for C++ programs.
-Wclobbered
Warn for variables that might be changed by longjmp or vfork. This warning
is also enabled by ‘-Wextra’.
-Wconditionally-supported (C++ and Objective-C++ only)
Warn for conditionally-supported (C++11 [intro.defs]) constructs.
-Wconversion
Warn for implicit conversions that may alter a value. This includes conversions
between real and integer, like abs (x) when x is double; conversions between
signed and unsigned, like unsigned ui = -1; and conversions to smaller types,
like sqrtf (M_PI). Do not warn for explicit casts like abs ((int) x) and ui
= (unsigned) -1, or if the value is not changed by the conversion like in abs
(2.0). Warnings about conversions between signed and unsigned integers can
be disabled by using ‘-Wno-sign-conversion’.
For C++, also warn for confusing overload resolution for user-defined conver-
sions; and conversions that never use a type conversion operator: conversions
to void, the same type, a base class or a reference to them. Warnings about
conversions between signed and unsigned integers are disabled by default in
C++ unless ‘-Wsign-conversion’ is explicitly enabled.
-Wno-conversion-null (C++ and Objective-C++ only)
Do not warn for conversions between NULL and non-pointer types.
‘-Wconversion-null’ is enabled by default.
-Wzero-as-null-pointer-constant (C++ and Objective-C++ only)
Warn when a literal ‘0’ is used as null pointer constant. This can be useful to
facilitate the conversion to nullptr in C++11.
92 Using the GNU Compiler Collection (GCC)

-Wsubobject-linkage (C++ and Objective-C++ only)

Warn if a class type has a base or a field whose type uses the anonymous
namespace or depends on a type with no linkage. If a type A depends on a type
B with no or internal linkage, defining it in multiple translation units would
be an ODR violation because the meaning of B is different in each translation
unit. If A only appears in a single translation unit, the best way to silence the
warning is to give it internal linkage by putting it in an anonymous namespace
as well. The compiler doesn’t give this warning for types defined in the main .C
file, as those are unlikely to have multiple definitions. ‘-Wsubobject-linkage’
is enabled by default.
-Wdangling-else
Warn about constructions where there may be confusion to which if statement
an else branch belongs. Here is an example of such a case:
{
if (a)
if (b)
foo ();
else
bar ();
}
In C/C++, every else branch belongs to the innermost possible if statement,
which in this example is if (b). This is often not what the programmer ex-
pected, as illustrated in the above example by indentation the programmer
chose. When there is the potential for this confusion, GCC issues a warn-
ing when this flag is specified. To eliminate the warning, add explicit braces
around the innermost if statement so there is no way the else can belong to
the enclosing if. The resulting code looks like this:
{
if (a)
{
if (b)
foo ();
else
bar ();
}
}
This warning is enabled by ‘-Wparentheses’.
-Wdate-time
Warn when macros __TIME__, __DATE__ or __TIMESTAMP__ are encountered as
they might prevent bit-wise-identical reproducible compilations.
-Wdelete-incomplete (C++ and Objective-C++ only)
Warn when deleting a pointer to incomplete type, which may cause undefined
behavior at runtime. This warning is enabled by default.
-Wuseless-cast (C++ and Objective-C++ only)
Warn when an expression is casted to its own type.
-Wempty-body
Warn if an empty body occurs in an if, else or do while statement. This
warning is also enabled by ‘-Wextra’.
Chapter 3: GCC Command Options 93

-Wenum-compare
Warn about a comparison between values of different enumerated types. In
C++ enumerated type mismatches in conditional expressions are also diagnosed
and the warning is enabled by default. In C this warning is enabled by ‘-Wall’.
-Wjump-misses-init (C, Objective-C only)
Warn if a goto statement or a switch statement jumps forward across the
initialization of a variable, or jumps backward to a label after the variable has
been initialized. This only warns about variables that are initialized when they
are declared. This warning is only supported for C and Objective-C; in C++
this sort of branch is an error in any case.
‘-Wjump-misses-init’ is included in ‘-Wc++-compat’. It can be disabled with
the ‘-Wno-jump-misses-init’ option.
-Wsign-compare
Warn when a comparison between signed and unsigned values could produce
an incorrect result when the signed value is converted to unsigned. In C++, this
warning is also enabled by ‘-Wall’. In C, it is also enabled by ‘-Wextra’.
-Wsign-conversion
Warn for implicit conversions that may change the sign of an integer value, like
assigning a signed integer expression to an unsigned integer variable. An explicit
cast silences the warning. In C, this option is enabled also by ‘-Wconversion’.
-Wfloat-conversion
Warn for implicit conversions that reduce the precision of a real value. This
includes conversions from real to integer, and from higher precision real to lower
precision real values. This option is also enabled by ‘-Wconversion’.
-Wno-scalar-storage-order
Do not warn on suspicious constructs involving reverse scalar storage order.
-Wsized-deallocation (C++ and Objective-C++ only)
Warn about a definition of an unsized deallocation function
void operator delete (void *) noexcept;
void operator delete[] (void *) noexcept;
without a definition of the corresponding sized deallocation function
void operator delete (void *, std::size_t) noexcept;
void operator delete[] (void *, std::size_t) noexcept;
or vice versa. Enabled by ‘-Wextra’ along with ‘-fsized-deallocation’.
-Wsizeof-pointer-memaccess
Warn for suspicious length parameters to certain string and memory built-in
functions if the argument uses sizeof. This warning warns e.g. about memset
(ptr, 0, sizeof (ptr)); if ptr is not an array, but a pointer, and suggests a
possible fix, or about memcpy (&foo, ptr, sizeof (&foo));. This warning is
enabled by ‘-Wall’.
-Wsizeof-array-argument
Warn when the sizeof operator is applied to a parameter that is declared as
an array in a function definition. This warning is enabled by default for C and
C++ programs.
94 Using the GNU Compiler Collection (GCC)

-Wmemset-elt-size
Warn for suspicious calls to the memset built-in function, if the first argument
references an array, and the third argument is a number equal to the number
of elements, but not equal to the size of the array in memory. This indicates
that the user has omitted a multiplication by the element size. This warning is
enabled by ‘-Wall’.

-Wmemset-transposed-args
Warn for suspicious calls to the memset built-in function, if the second ar-
gument is not zero and the third argument is zero. This warns e.g. about
memset (buf, sizeof buf, 0) where most probably memset (buf, 0, sizeof
buf) was meant instead. The diagnostics is only emitted if the third argument
is literal zero. If it is some expression that is folded to zero, a cast of zero to
some type, etc., it is far less likely that the user has mistakenly exchanged the
arguments and no warning is emitted. This warning is enabled by ‘-Wall’.

-Waddress
Warn about suspicious uses of memory addresses. These include using the
address of a function in a conditional expression, such as void func(void);
if (func), and comparisons against the memory address of a string literal,
such as if (x == "abc"). Such uses typically indicate a programmer error: the
address of a function always evaluates to true, so their use in a conditional
usually indicate that the programmer forgot the parentheses in a function call;
and comparisons against string literals result in unspecified behavior and are
not portable in C, so they usually indicate that the programmer intended to
use strcmp. This warning is enabled by ‘-Wall’.

-Wlogical-op
Warn about suspicious uses of logical operators in expressions. This includes
using logical operators in contexts where a bit-wise operator is likely to be
expected. Also warns when the operands of a logical operator are the same:
extern int a;
if (a < 0 && a < 0) { ... }

-Wlogical-not-parentheses
Warn about logical not used on the left hand side operand of a comparison.
This option does not warn if the right operand is considered to be a boolean
expression. Its purpose is to detect suspicious code like the following:
int a;
...
if (!a > 1) { ... }
It is possible to suppress the warning by wrapping the LHS into parentheses:
if ((!a) > 1) { ... }
This warning is enabled by ‘-Wall’.

-Waggregate-return
Warn if any functions that return structures or unions are defined or called. (In
languages where you can return an array, this also elicits a warning.)
Chapter 3: GCC Command Options 95

-Wno-aggressive-loop-optimizations
Warn if in a loop with constant number of iterations the compiler detects un-
defined behavior in some statement during one or more of the iterations.
-Wno-attributes
Do not warn if an unexpected __attribute__ is used, such as unrecognized
attributes, function attributes applied to variables, etc. This does not stop
errors for incorrect use of supported attributes.
-Wno-builtin-declaration-mismatch
Warn if a built-in function is declared with the wrong signature. This warning
is enabled by default.
-Wno-builtin-macro-redefined
Do not warn if certain built-in macros are redefined. This suppresses warn-
ings for redefinition of __TIMESTAMP__, __TIME__, __DATE__, __FILE__, and
__BASE_FILE__.
-Wstrict-prototypes (C and Objective-C only)
Warn if a function is declared or defined without specifying the argument types.
(An old-style function definition is permitted without a warning if preceded by
a declaration that specifies the argument types.)
-Wold-style-declaration (C and Objective-C only)
Warn for obsolescent usages, according to the C Standard, in a declaration. For
example, warn if storage-class specifiers like static are not the first things in
a declaration. This warning is also enabled by ‘-Wextra’.
-Wold-style-definition (C and Objective-C only)
Warn if an old-style function definition is used. A warning is given even if there
is a previous prototype.
-Wmissing-parameter-type (C and Objective-C only)
A function parameter is declared without a type specifier in K&R-style func-
tions:
void foo(bar) { }
This warning is also enabled by ‘-Wextra’.
-Wmissing-prototypes (C and Objective-C only)
Warn if a global function is defined without a previous prototype declara-
tion. This warning is issued even if the definition itself provides a proto-
type. Use this option to detect global functions that do not have a match-
ing prototype declaration in a header file. This option is not valid for C++
because all function declarations provide prototypes and a non-matching dec-
laration declares an overload rather than conflict with an earlier declaration.
Use ‘-Wmissing-declarations’ to detect missing declarations in C++.
-Wmissing-declarations
Warn if a global function is defined without a previous declaration. Do so even if
the definition itself provides a prototype. Use this option to detect global func-
tions that are not declared in header files. In C, no warnings are issued for func-
tions with previous non-prototype declarations; use ‘-Wmissing-prototypes’
96 Using the GNU Compiler Collection (GCC)

to detect missing prototypes. In C++, no warnings are issued for function tem-
plates, or for inline functions, or for functions in anonymous namespaces.
-Wmissing-field-initializers
Warn if a structure’s initializer has some fields missing. For example, the fol-
lowing code causes such a warning, because x.h is implicitly zero:
struct s { int f, g, h; };
struct s x = { 3, 4 };
This option does not warn about designated initializers, so the following mod-
ification does not trigger a warning:
struct s { int f, g, h; };
struct s x = { .f = 3, .g = 4 };
In C++ this option does not warn either about the empty { } initializer, for
example:
struct s { int f, g, h; };
s x = { };
This warning is included in ‘-Wextra’. To get other ‘-Wextra’ warnings without
this one, use ‘-Wextra -Wno-missing-field-initializers’.
-Wno-multichar
Do not warn if a multicharacter constant (‘’FOOF’’) is used. Usually they
indicate a typo in the user’s code, as they have implementation-defined values,
and should not be used in portable code.
-Wnormalized=[none|id|nfc|nfkc]
In ISO C and ISO C++, two identifiers are different if they are different sequences
of characters. However, sometimes when characters outside the basic ASCII
character set are used, you can have two different character sequences that
look the same. To avoid confusion, the ISO 10646 standard sets out some
normalization rules which when applied ensure that two sequences that look the
same are turned into the same sequence. GCC can warn you if you are using
identifiers that have not been normalized; this option controls that warning.
There are four levels of warning supported by GCC. The default is
‘-Wnormalized=nfc’, which warns about any identifier that is not in the ISO
10646 “C” normalized form, NFC. NFC is the recommended form for most
uses. It is equivalent to ‘-Wnormalized’.
Unfortunately, there are some characters allowed in identifiers by ISO C and
ISO C++ that, when turned into NFC, are not allowed in identifiers. That is,
there’s no way to use these symbols in portable ISO C or C++ and have all
your identifiers in NFC. ‘-Wnormalized=id’ suppresses the warning for these
characters. It is hoped that future versions of the standards involved will correct
this, which is why this option is not the default.
You can switch the warning off for all characters by writing
‘-Wnormalized=none’ or ‘-Wno-normalized’. You should only do
this if you are using some other normalization scheme (like “D”), because
otherwise you can easily create bugs that are literally impossible to see.
Some characters in ISO 10646 have distinct meanings but look identical in some
fonts or display methodologies, especially once formatting has been applied. For
Chapter 3: GCC Command Options 97

instance \u207F, “SUPERSCRIPT LATIN SMALL LETTER N”, displays just

like a regular n that has been placed in a superscript. ISO 10646 defines the
NFKC normalization scheme to convert all these into a standard form as well,
and GCC warns if your code is not in NFKC if you use ‘-Wnormalized=nfkc’.
This warning is comparable to warning about every identifier that contains the
letter O because it might be confused with the digit 0, and so is not the default,
but may be useful as a local coding convention if the programming environment
cannot be fixed to display these characters distinctly.
-Wno-deprecated
Do not warn about usage of deprecated features. See Section 7.11 [Deprecated
Features], page 748.
-Wno-deprecated-declarations
Do not warn about uses of functions (see Section 6.31 [Function Attributes],
page 429), variables (see Section 6.32 [Variable Attributes], page 474), and types
(see Section 6.33 [Type Attributes], page 485) marked as deprecated by using
the deprecated attribute.
-Wno-overflow
Do not warn about compile-time overflow in constant expressions.
-Wno-odr Warn about One Definition Rule violations during link-time optimization. Re-
quires ‘-flto-odr-type-merging’ to be enabled. Enabled by default.
-Wopenmp-simd
Warn if the vectorizer cost model overrides the OpenMP or the Cilk Plus simd
directive set by user. The ‘-fsimd-cost-model=unlimited’ option can be used
to relax the cost model.
-Woverride-init (C and Objective-C only)
Warn if an initialized field without side effects is overridden when using desig-
nated initializers (see Section 6.27 [Designated Initializers], page 427).
This warning is included in ‘-Wextra’. To get other ‘-Wextra’ warnings without
this one, use ‘-Wextra -Wno-override-init’.
-Woverride-init-side-effects (C and Objective-C only)
Warn if an initialized field with side effects is overridden when using designated
initializers (see Section 6.27 [Designated Initializers], page 427). This warning
is enabled by default.
-Wpacked Warn if a structure is given the packed attribute, but the packed attribute has no
effect on the layout or size of the structure. Such structures may be mis-aligned
for little benefit. For instance, in this code, the variable f.x in struct bar is
misaligned even though struct bar does not itself have the packed attribute:
struct foo {
int x;
char a, b, c, d;
} __attribute__((packed));
struct bar {
char z;
struct foo f;
};
98 Using the GNU Compiler Collection (GCC)

-Wpacked-bitfield-compat
The 4.1, 4.2 and 4.3 series of GCC ignore the packed attribute on bit-fields
of type char. This has been fixed in GCC 4.4 but the change can lead to
differences in the structure layout. GCC informs you when the offset of such a
field has changed in GCC 4.4. For example there is no longer a 4-bit padding
between field a and b in this structure:
struct foo
{
char a:4;
char b:8;
} __attribute__ ((packed));
This warning is enabled by default. Use ‘-Wno-packed-bitfield-compat’ to
disable this warning.
-Wpadded Warn if padding is included in a structure, either to align an element of the
structure or to align the whole structure. Sometimes when this happens it is
possible to rearrange the fields of the structure to reduce the padding and so
make the structure smaller.
-Wredundant-decls
Warn if anything is declared more than once in the same scope, even in cases
where multiple declaration is valid and changes nothing.
-Wrestrict
Warn when an argument passed to a restrict-qualified parameter aliases with
another argument.
-Wnested-externs (C and Objective-C only)
Warn if an extern declaration is encountered within a function.
-Wno-inherited-variadic-ctor
Suppress warnings about use of C++11 inheriting constructors when the base
class inherited from has a C variadic constructor; the warning is on by default
because the ellipsis is not inherited.
-Winline Warn if a function that is declared as inline cannot be inlined. Even with this
option, the compiler does not warn about failures to inline functions declared
in system headers.
The compiler uses a variety of heuristics to determine whether or not to inline a
function. For example, the compiler takes into account the size of the function
being inlined and the amount of inlining that has already been done in the cur-
rent function. Therefore, seemingly insignificant changes in the source program
can cause the warnings produced by ‘-Winline’ to appear or disappear.
-Wno-invalid-offsetof (C++ and Objective-C++ only)
Suppress warnings from applying the offsetof macro to a non-POD type.
According to the 2014 ISO C++ standard, applying offsetof to a non-standard-
layout type is undefined. In existing C++ implementations, however, offsetof
typically gives meaningful results. This flag is for users who are aware that
they are writing nonportable code and who have deliberately chosen to ignore
the warning about it.
Chapter 3: GCC Command Options 99

The restrictions on offsetof may be relaxed in a future version of the C++

standard.
-Wint-in-bool-context
Warn for suspicious use of integer values where boolean values are expected,
such as conditional expressions (?:) using non-boolean integer constants in
boolean context, like if (a <= b ? 2 : 3). Or left shifting of signed integers
in boolean context, like for (a = 0; 1 << a; a++);. Likewise for all kinds of
multiplications regardless of the data type. This warning is enabled by ‘-Wall’.
-Wno-int-to-pointer-cast
Suppress warnings from casts to pointer type of an integer of a different
size. In C++, casting to a pointer type of smaller size is an error.
‘Wint-to-pointer-cast’ is enabled by default.
-Wno-pointer-to-int-cast (C and Objective-C only)
Suppress warnings from casts from a pointer to an integer type of a different
size.
-Winvalid-pch
Warn if a precompiled header (see Section 3.21 [Precompiled Headers],
page 392) is found in the search path but cannot be used.
-Wlong-long
Warn if long long type is used. This is enabled by either ‘-Wpedantic’ or
‘-Wtraditional’ in ISO C90 and C++98 modes. To inhibit the warning mes-
sages, use ‘-Wno-long-long’.
-Wvariadic-macros
Warn if variadic macros are used in ISO C90 mode, or if the GNU
alternate syntax is used in ISO C99 mode. This is enabled by either
‘-Wpedantic’ or ‘-Wtraditional’. To inhibit the warning messages, use
‘-Wno-variadic-macros’.
-Wvarargs
Warn upon questionable usage of the macros used to handle variable argu-
ments like va_start. This is default. To inhibit the warning messages, use
‘-Wno-varargs’.
-Wvector-operation-performance
Warn if vector operation is not implemented via SIMD capabilities of the ar-
chitecture. Mainly useful for the performance tuning. Vector operation can be
implemented piecewise, which means that the scalar operation is performed
on every vector element; in parallel, which means that the vector operation
is implemented using scalars of wider type, which normally is more performance
efficient; and as a single scalar, which means that vector fits into a scalar
type.
-Wno-virtual-move-assign
Suppress warnings about inheriting from a virtual base with a non-trivial C++11
move assignment operator. This is dangerous because if the virtual base is
reachable along more than one path, it is moved multiple times, which can
100 Using the GNU Compiler Collection (GCC)

mean both objects end up in the moved-from state. If the move assignment
operator is written to avoid moving from a moved-from object, this warning
can be disabled.
-Wvla Warn if a variable-length array is used in the code. ‘-Wno-vla’ prevents the
‘-Wpedantic’ warning of the variable-length array.
-Wvla-larger-than=n
If this option is used, the compiler will warn on uses of variable-length arrays
where the size is either unbounded, or bounded by an argument that can be
larger than n bytes. This is similar to how ‘-Walloca-larger-than=n’ works,
but with variable-length arrays.
Note that GCC may optimize small variable-length arrays of a known value
into plain arrays, so this warning may not get triggered for such arrays.
This warning is not enabled by ‘-Wall’, and is only active when ‘-ftree-vrp’
is active (default for ‘-O2’ and above).
See also ‘-Walloca-larger-than=n’.
-Wvolatile-register-var
Warn if a register variable is declared volatile. The volatile modifier does not
inhibit all optimizations that may eliminate reads and/or writes to register
variables. This warning is enabled by ‘-Wall’.
-Wdisabled-optimization
Warn if a requested optimization pass is disabled. This warning does not gen-
erally indicate that there is anything wrong with your code; it merely indicates
that GCC’s optimizers are unable to handle the code effectively. Often, the
problem is that your code is too big or too complex; GCC refuses to optimize
programs when the optimization itself is likely to take inordinate amounts of
time.
-Wpointer-sign (C and Objective-C only)
Warn for pointer argument passing or assignment with different signedness.
This option is only supported for C and Objective-C. It is implied by ‘-Wall’
and by ‘-Wpedantic’, which can be disabled with ‘-Wno-pointer-sign’.
-Wstack-protector
This option is only active when ‘-fstack-protector’ is active. It warns about
functions that are not protected against stack smashing.
-Woverlength-strings
Warn about string constants that are longer than the “minimum maximum”
length specified in the C standard. Modern compilers generally allow string
constants that are much longer than the standard’s minimum limit, but very
portable programs should avoid using longer strings.
The limit applies after string constant concatenation, and does not count the
trailing NUL. In C90, the limit was 509 characters; in C99, it was raised to
4095. C++98 does not specify a normative minimum maximum, so we do not
diagnose overlength strings in C++.
This option is implied by ‘-Wpedantic’, and can be disabled with
‘-Wno-overlength-strings’.
Chapter 3: GCC Command Options 101

-Wunsuffixed-float-constants (C and Objective-C only)

Issue a warning for any floating constant that does not have a suffix. When
used together with ‘-Wsystem-headers’ it warns about such constants in system
header files. This can be useful when preparing code to use with the FLOAT_
CONST_DECIMAL64 pragma from the decimal floating-point extension to C99.
-Wno-designated-init (C and Objective-C only)
Suppress warnings when a positional initializer is used to initialize a structure
that has been marked with the designated_init attribute.
-Whsa Issue a warning when HSAIL cannot be emitted for the compiled function or
OpenMP construct.

3.9 Options for Debugging Your Program

To tell GCC to emit extra information for use by a debugger, in almost all cases you need
only to add ‘-g’ to your other options.
GCC allows you to use ‘-g’ with ‘-O’. The shortcuts taken by optimized code may
occasionally be surprising: some variables you declared may not exist at all; flow of control
may briefly move where you did not expect it; some statements may not be executed because
they compute constant results or their values are already at hand; some statements may
execute in different places because they have been moved out of loops. Nevertheless it
is possible to debug optimized output. This makes it reasonable to use the optimizer for
programs that might have bugs.
If you are not using some other optimization option, consider using ‘-Og’ (see Section 3.10
[Optimize Options], page 106) with ‘-g’. With no ‘-O’ option at all, some compiler passes
that collect information useful for debugging do not run at all, so that ‘-Og’ may result in
a better debugging experience.
-g Produce debugging information in the operating system’s native format (stabs,
COFF, XCOFF, or DWARF). GDB can work with this debugging information.
On most systems that use stabs format, ‘-g’ enables use of extra debugging
information that only GDB can use; this extra information makes debugging
work better in GDB but probably makes other debuggers crash or refuse to read
the program. If you want to control for certain whether to generate the extra
information, use ‘-gstabs+’, ‘-gstabs’, ‘-gxcoff+’, ‘-gxcoff’, or ‘-gvms’ (see
below).
-ggdb Produce debugging information for use by GDB. This means to use the most
expressive format available (DWARF, stabs, or the native format if neither of
those are supported), including GDB extensions if at all possible.
-gdwarf
-gdwarf-version
Produce debugging information in DWARF format (if that is supported). The
value of version may be either 2, 3, 4 or 5; the default version for most targets
is 4. DWARF Version 5 is only experimental.
Note that with DWARF Version 2, some ports require and always use some
non-conflicting DWARF 3 extensions in the unwind tables.
102 Using the GNU Compiler Collection (GCC)

Version 4 may require GDB 7.0 and ‘-fvar-tracking-assignments’ for max-

imum benefit.
GCC no longer supports DWARF Version 1, which is substantially different
than Version 2 and later. For historical reasons, some other DWARF-related op-
tions (including ‘-feliminate-dwarf2-dups’ and ‘-fno-dwarf2-cfi-asm’) re-
tain a reference to DWARF Version 2 in their names, but apply to all currently-
supported versions of DWARF.
-gstabs Produce debugging information in stabs format (if that is supported), without
GDB extensions. This is the format used by DBX on most BSD systems.
On MIPS, Alpha and System V Release 4 systems this option produces stabs
debugging output that is not understood by DBX or SDB. On System V Release
4 systems this option requires the GNU assembler.
-gstabs+ Produce debugging information in stabs format (if that is supported), using
GNU extensions understood only by the GNU debugger (GDB). The use of
these extensions is likely to make other debuggers crash or refuse to read the
program.
-gcoff Produce debugging information in COFF format (if that is supported). This is
the format used by SDB on most System V systems prior to System V Release
4.
-gxcoff Produce debugging information in XCOFF format (if that is supported). This
is the format used by the DBX debugger on IBM RS/6000 systems.
-gxcoff+ Produce debugging information in XCOFF format (if that is supported), using
GNU extensions understood only by the GNU debugger (GDB). The use of
these extensions is likely to make other debuggers crash or refuse to read the
program, and may cause assemblers other than the GNU assembler (GAS) to
fail with an error.
-gvms Produce debugging information in Alpha/VMS debug format (if that is sup-
ported). This is the format used by DEBUG on Alpha/VMS systems.
-glevel
-ggdblevel
-gstabslevel
-gcofflevel
-gxcofflevel
-gvmslevel
Request debugging information and also use level to specify how much infor-
mation. The default level is 2.
Level 0 produces no debug information at all. Thus, ‘-g0’ negates ‘-g’.
Level 1 produces minimal information, enough for making backtraces in parts
of the program that you don’t plan to debug. This includes descriptions of
functions and external variables, and line number tables, but no information
about local variables.
Level 3 includes extra information, such as all the macro definitions present in
the program. Some debuggers support macro expansion when you use ‘-g3’.
Chapter 3: GCC Command Options 103

‘-gdwarf’ does not accept a concatenated debug level, to avoid confusion with
‘-gdwarf-level’. Instead use an additional ‘-glevel’ option to change the
debug level for DWARF.
-feliminate-unused-debug-symbols
Produce debugging information in stabs format (if that is supported), for only
symbols that are actually used.
-femit-class-debug-always
Instead of emitting debugging information for a C++ class in only one object file,
emit it in all object files using the class. This option should be used only with
debuggers that are unable to handle the way GCC normally emits debugging
information for classes because using this option increases the size of debugging
information by as much as a factor of two.
-fno-merge-debug-strings
Direct the linker to not merge together strings in the debugging information
that are identical in different object files. Merging is not supported by all
assemblers or linkers. Merging decreases the size of the debug information in
the output file at the cost of increasing link processing time. Merging is enabled
by default.
-fdebug-prefix-map=old=new
When compiling files in directory ‘old’, record debugging information describing
them as in ‘new’ instead.
-fvar-tracking
Run variable tracking pass. It computes where variables are stored at each posi-
tion in code. Better debugging information is then generated (if the debugging
information format supports this information).
It is enabled by default when compiling with optimization (‘-Os’, ‘-O’, ‘-O2’,
. . . ), debugging information (‘-g’) and the debug info format supports it.
-fvar-tracking-assignments
Annotate assignments to user variables early in the compilation and attempt to
carry the annotations over throughout the compilation all the way to the end, in
an attempt to improve debug information while optimizing. Use of ‘-gdwarf-4’
is recommended along with it.
It can be enabled even if var-tracking is disabled, in which case annotations
are created and maintained, but discarded at the end. By default, this flag is
enabled together with ‘-fvar-tracking’, except when selective scheduling is
enabled.
-gsplit-dwarf
Separate as much DWARF debugging information as possible into a separate
output file with the extension ‘.dwo’. This option allows the build system to
avoid linking files with debug information. To be useful, this option requires a
debugger capable of reading ‘.dwo’ files.
-gpubnames
Generate DWARF .debug_pubnames and .debug_pubtypes sections.
104 Using the GNU Compiler Collection (GCC)

-ggnu-pubnames
Generate .debug_pubnames and .debug_pubtypes sections in a format suitable
for conversion into a GDB index. This option is only useful with a linker that
can produce GDB index version 7.

-fdebug-types-section
When using DWARF Version 4 or higher, type DIEs can be put into their own
.debug_types section instead of making them part of the .debug_info section.
It is more efficient to put them in a separate comdat sections since the linker
can then remove duplicates. But not all DWARF consumers support .debug_
types sections yet and on some objects .debug_types produces larger instead
of smaller debugging information.

-grecord-gcc-switches
-gno-record-gcc-switches
This switch causes the command-line options used to invoke the compiler that
may affect code generation to be appended to the DW AT producer attribute
in DWARF debugging information. The options are concatenated with spaces
separating them from each other and from the compiler version. It is enabled by
default. See also ‘-frecord-gcc-switches’ for another way of storing compiler
options into the object file.

-gstrict-dwarf
Disallow using extensions of later DWARF standard version than selected with
‘-gdwarf-version’. On most targets using non-conflicting DWARF extensions
from later standard versions is allowed.

-gno-strict-dwarf
Allow using extensions of later DWARF standard version than selected with
‘-gdwarf-version’.

-gcolumn-info
-gno-column-info
Emit location column information into DWARF debugging information, rather
than just file and line. This option is disabled by default.

-gz[=type]
Produce compressed debug sections in DWARF format, if that is supported. If
type is not given, the default type depends on the capabilities of the assembler
and linker used. type may be one of ‘none’ (don’t compress debug sections),
‘zlib’ (use zlib compression in ELF gABI format), or ‘zlib-gnu’ (use zlib
compression in traditional GNU format). If the linker doesn’t support writing
compressed debug sections, the option is rejected. Otherwise, if the assembler
does not support them, ‘-gz’ is silently ignored when producing object files.

-feliminate-dwarf2-dups
Compress DWARF debugging information by eliminating duplicated informa-
tion about each symbol. This option only makes sense when generating DWARF
debugging information.
Chapter 3: GCC Command Options 105

-femit-struct-debug-baseonly
Emit debug information for struct-like types only when the base name of the
compilation source file matches the base name of file in which the struct is
defined.
This option substantially reduces the size of debugging information,
but at significant potential loss in type information to the debugger.
See ‘-femit-struct-debug-reduced’ for a less aggressive option. See
‘-femit-struct-debug-detailed’ for more detailed control.
This option works only with DWARF debug output.
-femit-struct-debug-reduced
Emit debug information for struct-like types only when the base name of the
compilation source file matches the base name of file in which the type is defined,
unless the struct is a template or defined in a system header.
This option significantly reduces the size of debugging information,
with some potential loss in type information to the debugger. See
‘-femit-struct-debug-baseonly’ for a more aggressive option. See
‘-femit-struct-debug-detailed’ for more detailed control.
This option works only with DWARF debug output.
-femit-struct-debug-detailed[=spec-list]
Specify the struct-like types for which the compiler generates debug informa-
tion. The intent is to reduce duplicate struct debug information between dif-
ferent object files within the same program.
This option is a detailed version of ‘-femit-struct-debug-reduced’ and
‘-femit-struct-debug-baseonly’, which serves for most needs.
A specification has the syntax
[‘dir:’|‘ind:’][‘ord:’|‘gen:’](‘any’|‘sys’|‘base’|‘none’)
The optional first word limits the specification to structs that are used directly
(‘dir:’) or used indirectly (‘ind:’). A struct type is used directly when it is
the type of a variable, member. Indirect uses arise through pointers to structs.
That is, when use of an incomplete struct is valid, the use is indirect. An
example is ‘struct one direct; struct two * indirect;’.
The optional second word limits the specification to ordinary structs (‘ord:’) or
generic structs (‘gen:’). Generic structs are a bit complicated to explain. For
C++, these are non-explicit specializations of template classes, or non-template
classes within the above. Other programming languages have generics, but
‘-femit-struct-debug-detailed’ does not yet implement them.
The third word specifies the source files for those structs for which the compiler
should emit debug information. The values ‘none’ and ‘any’ have the normal
meaning. The value ‘base’ means that the base of name of the file in which
the type declaration appears must match the base of the name of the main
compilation file. In practice, this means that when compiling ‘foo.c’, debug
information is generated for types declared in that file and ‘foo.h’, but not other
header files. The value ‘sys’ means those types satisfying ‘base’ or declared in
system or compiler headers.
106 Using the GNU Compiler Collection (GCC)

You may need to experiment to determine the best settings for your application.
The default is ‘-femit-struct-debug-detailed=all’.
This option works only with DWARF debug output.
-fno-dwarf2-cfi-asm
Emit DWARF unwind info as compiler generated .eh_frame section instead of
using GAS .cfi_* directives.
-fno-eliminate-unused-debug-types
Normally, when producing DWARF output, GCC avoids producing debug sym-
bol output for types that are nowhere used in the source file being compiled.
Sometimes it is useful to have GCC emit debugging information for all types
declared in a compilation unit, regardless of whether or not they are actually
used in that compilation unit, for example if, in the debugger, you want to cast
a value to a type that is not actually used in your program (but is declared).
More often, however, this results in a significant amount of wasted space.

3.10 Options That Control Optimization

These options control various sorts of optimizations.
Without any optimization option, the compiler’s goal is to reduce the cost of compilation
and to make debugging produce the expected results. Statements are independent: if you
stop the program with a breakpoint between statements, you can then assign a new value
to any variable or change the program counter to any other statement in the function and
get exactly the results you expect from the source code.
Turning on optimization flags makes the compiler attempt to improve the performance
and/or code size at the expense of compilation time and possibly the ability to debug the
program.
The compiler performs optimization based on the knowledge it has of the program. Com-
piling multiple files at once to a single output file mode allows the compiler to use informa-
tion gained from all of the files when compiling each of them.
Not all optimizations are controlled directly by a flag. Only optimizations that have a
flag are listed in this section.
Most optimizations are only enabled if an ‘-O’ level is set on the command line. Otherwise
they are disabled, even if individual optimization flags are specified.
Depending on the target and how GCC was configured, a slightly different set of opti-
mizations may be enabled at each ‘-O’ level than those listed here. You can invoke GCC
with ‘-Q --help=optimizers’ to find out the exact set of optimizations that are enabled
at each level. See Section 3.2 [Overall Options], page 27, for examples.
-O
-O1 Optimize. Optimizing compilation takes somewhat more time, and a lot more
memory for a large function.
With ‘-O’, the compiler tries to reduce code size and execution time, without
performing any optimizations that take a great deal of compilation time.
‘-O’ turns on the following optimization flags:
Chapter 3: GCC Command Options 107

-fauto-inc-dec
-fbranch-count-reg
-fcombine-stack-adjustments
-fcompare-elim
-fcprop-registers
-fdce
-fdefer-pop
-fdelayed-branch
-fdse
-fforward-propagate
-fguess-branch-probability
-fif-conversion2
-fif-conversion
-finline-functions-called-once
-fipa-pure-const
-fipa-profile
-fipa-reference
-fmerge-constants
-fmove-loop-invariants
-freorder-blocks
-fshrink-wrap
-fshrink-wrap-separate
-fsplit-wide-types
-fssa-backprop
-fssa-phiopt
-ftree-bit-ccp
-ftree-ccp
-ftree-ch
-ftree-coalesce-vars
-ftree-copy-prop
-ftree-dce
-ftree-dominator-opts
-ftree-dse
-ftree-forwprop
-ftree-fre
-ftree-phiprop
-ftree-sink
-ftree-slsr
-ftree-sra
-ftree-pta
-ftree-ter
-funit-at-a-time
‘-O’ also turns on ‘-fomit-frame-pointer’ on machines where doing so does
not interfere with debugging.
-O2 Optimize even more. GCC performs nearly all supported optimizations that do
not involve a space-speed tradeoff. As compared to ‘-O’, this option increases
both compilation time and the performance of the generated code.
‘-O2’ turns on all optimization flags specified by ‘-O’. It also turns on the
following optimization flags:
-fthread-jumps
-falign-functions -falign-jumps
-falign-loops -falign-labels
-fcaller-saves
-fcrossjumping
-fcse-follow-jumps -fcse-skip-blocks
-fdelete-null-pointer-checks
108 Using the GNU Compiler Collection (GCC)

-fdevirtualize -fdevirtualize-speculatively
-fexpensive-optimizations
-fgcse -fgcse-lm
-fhoist-adjacent-loads
-finline-small-functions
-findirect-inlining
-fipa-cp
-fipa-bit-cp
-fipa-vrp
-fipa-sra
-fipa-icf
-fisolate-erroneous-paths-dereference
-flra-remat
-foptimize-sibling-calls
-foptimize-strlen
-fpartial-inlining
-fpeephole2
-freorder-blocks-algorithm=stc
-freorder-blocks-and-partition -freorder-functions
-frerun-cse-after-loop
-fsched-interblock -fsched-spec
-fschedule-insns -fschedule-insns2
-fstore-merging
-fstrict-aliasing -fstrict-overflow
-ftree-builtin-call-dce
-ftree-switch-conversion -ftree-tail-merge
-fcode-hoisting
-ftree-pre
-ftree-vrp
-fipa-ra
Please note the warning under ‘-fgcse’ about invoking ‘-O2’ on programs that
use computed gotos.
-O3 Optimize yet more. ‘-O3’ turns on all optimizations spec-
ified by ‘-O2’ and also turns on the ‘-finline-functions’,
‘-funswitch-loops’, ‘-fpredictive-commoning’, ‘-fgcse-after-reload’,
‘-ftree-loop-vectorize’, ‘-ftree-loop-distribute-patterns’,
‘-fsplit-paths’ ‘-ftree-slp-vectorize’, ‘-fvect-cost-model’,
‘-ftree-partial-pre’, ‘-fpeel-loops’ and ‘-fipa-cp-clone’ options.
-O0 Reduce compilation time and make debugging produce the expected results.
This is the default.
-Os Optimize for size. ‘-Os’ enables all ‘-O2’ optimizations that do not typically
increase code size.
‘-Os’ disables the following optimization flags:
-falign-functions -falign-jumps -falign-loops
-falign-labels -fprefetch-loop-arrays
It also enables ‘-finline-functions’, causes the compiler to tune for code
size rather than execution speed, and performs further optimizations designed
to reduce code size.
-Ofast Disregard strict standards compliance. ‘-Ofast’ enables all ‘-O3’
optimizations. It also enables optimizations that are not valid for all standard-
Chapter 3: GCC Command Options 109

compliant programs. It turns on ‘-ffast-math’ and the Fortran-specific

‘-fno-protect-parens’ and ‘-fstack-arrays’.
-Og Optimize debugging experience. ‘-Og’ enables optimizations that do not in-
terfere with debugging. It should be the optimization level of choice for the
standard edit-compile-debug cycle, offering a reasonable level of optimization
while maintaining fast compilation and a good debugging experience.
If you use multiple ‘-O’ options, with or without level numbers, the last such option is
the one that is effective.
Options of the form ‘-fflag’ specify machine-independent flags. Most flags have both
positive and negative forms; the negative form of ‘-ffoo’ is ‘-fno-foo’. In the table below,
only one of the forms is listed—the one you typically use. You can figure out the other form
by either removing ‘no-’ or adding it.
The following options control specific optimizations. They are either activated by ‘-O’
options or are related to ones that are. You can use the following flags in the rare cases
when “fine-tuning” of optimizations to be performed is desired.
-fno-defer-pop
Always pop the arguments to each function call as soon as that function re-
turns. For machines that must pop arguments after a function call, the compiler
normally lets arguments accumulate on the stack for several function calls and
pops them all at once.
Disabled at levels ‘-O’, ‘-O2’, ‘-O3’, ‘-Os’.
-fforward-propagate
Perform a forward propagation pass on RTL. The pass tries to combine two
instructions and checks if the result can be simplified. If loop unrolling is active,
two passes are performed and the second is scheduled after loop unrolling.
This option is enabled by default at optimization levels ‘-O’, ‘-O2’, ‘-O3’, ‘-Os’.
-ffp-contract=style
‘-ffp-contract=off’ disables floating-point expression contraction.
‘-ffp-contract=fast’ enables floating-point expression contraction such as
forming of fused multiply-add operations if the target has native support for
them. ‘-ffp-contract=on’ enables floating-point expression contraction if
allowed by the language standard. This is currently not implemented and
treated equal to ‘-ffp-contract=off’.
The default is ‘-ffp-contract=fast’.
-fomit-frame-pointer
Don’t keep the frame pointer in a register for functions that don’t need one.
This avoids the instructions to save, set up and restore frame pointers; it also
makes an extra register available in many functions. It also makes debugging
impossible on some machines.
On some machines, such as the VAX, this flag has no effect, because the stan-
dard calling sequence automatically handles the frame pointer and nothing is
saved by pretending it doesn’t exist. The machine-description macro FRAME_
POINTER_REQUIRED controls whether a target machine supports this flag. See
Section “Register Usage” in GNU Compiler Collection (GCC) Internals.
110 Using the GNU Compiler Collection (GCC)

The default setting (when not optimizing for size) for 32-bit GNU/Linux x86
and 32-bit Darwin x86 targets is ‘-fomit-frame-pointer’. You can config-
ure GCC with the ‘--enable-frame-pointer’ configure option to change the
default.
Enabled at levels ‘-O’, ‘-O2’, ‘-O3’, ‘-Os’.
-foptimize-sibling-calls
Optimize sibling and tail recursive calls.
Enabled at levels ‘-O2’, ‘-O3’, ‘-Os’.
-foptimize-strlen
Optimize various standard C string functions (e.g. strlen, strchr or strcpy)
and their _FORTIFY_SOURCE counterparts into faster alternatives.
Enabled at levels ‘-O2’, ‘-O3’.
-fno-inline
Do not expand any functions inline apart from those marked with the always_
inline attribute. This is the default when not optimizing.
Single functions can be exempted from inlining by marking them with the
noinline attribute.
-finline-small-functions
Integrate functions into their callers when their body is smaller than expected
function call code (so overall size of program gets smaller). The compiler heuris-
tically decides which functions are simple enough to be worth integrating in this
way. This inlining applies to all functions, even those not declared inline.
Enabled at level ‘-O2’, ‘-O3’, ‘-Os’.
-findirect-inlining
Inline also indirect calls that are discovered to be known at compile time thanks
to previous inlining. This option has any effect only when inlining itself is turned
on by the ‘-finline-functions’ or ‘-finline-small-functions’ options.
Enabled at level ‘-O2’, ‘-O3’, ‘-Os’.
-finline-functions
Consider all functions for inlining, even if they are not declared inline. The
compiler heuristically decides which functions are worth integrating in this way.
If all calls to a given function are integrated, and the function is declared
static, then the function is normally not output as assembler code in its own
right.
Enabled at levels ‘-O3’, ‘-Os’. Also enabled by ‘-fprofile-use’ and
‘-fauto-profile’.
-finline-functions-called-once
Consider all static functions called once for inlining into their caller even if
they are not marked inline. If a call to a given function is integrated, then
the function is not output as assembler code in its own right.
Enabled at levels ‘-O1’, ‘-O2’, ‘-O3’ and ‘-Os’.
Chapter 3: GCC Command Options 111

-fearly-inlining
Inline functions marked by always_inline and functions whose body
seems smaller than the function call overhead early before doing
‘-fprofile-generate’ instrumentation and real inlining pass. Doing so makes
profiling significantly cheaper and usually inlining faster on programs having
large chains of nested wrapper functions.
Enabled by default.
-fipa-sra
Perform interprocedural scalar replacement of aggregates, removal of unused
parameters and replacement of parameters passed by reference by parameters
passed by value.
Enabled at levels ‘-O2’, ‘-O3’ and ‘-Os’.
-finline-limit=n
By default, GCC limits the size of functions that can be inlined. This flag
allows coarse control of this limit. n is the size of functions that can be inlined
in number of pseudo instructions.
Inlining is actually controlled by a number of parameters, which may be spec-
ified individually by using ‘--param name=value’. The ‘-finline-limit=n’
option sets some of these parameters as follows:
max-inline-insns-single
is set to n/2.
max-inline-insns-auto
is set to n/2.
See below for a documentation of the individual parameters controlling inlining
and for the defaults of these parameters.
Note: there may be no value to ‘-finline-limit’ that results in default be-
havior.
Note: pseudo instruction represents, in this particular context, an abstract
measurement of function’s size. In no way does it represent a count of assembly
instructions and as such its exact meaning might change from one release to an
another.
-fno-keep-inline-dllexport
This is a more fine-grained version of ‘-fkeep-inline-functions’, which ap-
plies only to functions that are declared using the dllexport attribute or de-
clspec. See Section 6.31 [Declaring Attributes of Functions], page 429.
-fkeep-inline-functions
In C, emit static functions that are declared inline into the object file, even
if the function has been inlined into all of its callers. This switch does not affect
functions using the extern inline extension in GNU C90. In C++, emit any
and all inline functions into the object file.
-fkeep-static-functions
Emit static functions into the object file, even if the function is never used.
112 Using the GNU Compiler Collection (GCC)

-fkeep-static-consts
Emit variables declared static const when optimization isn’t turned on, even
if the variables aren’t referenced.
GCC enables this option by default. If you want to force the compiler to check
if a variable is referenced, regardless of whether or not optimization is turned
on, use the ‘-fno-keep-static-consts’ option.
-fmerge-constants
Attempt to merge identical constants (string constants and floating-point con-
stants) across compilation units.
This option is the default for optimized compilation if the assembler and linker
support it. Use ‘-fno-merge-constants’ to inhibit this behavior.
Enabled at levels ‘-O’, ‘-O2’, ‘-O3’, ‘-Os’.
-fmerge-all-constants
Attempt to merge identical constants and identical variables.
This option implies ‘-fmerge-constants’. In addition to ‘-fmerge-constants’
this considers e.g. even constant initialized arrays or initialized constant vari-
ables with integral or floating-point types. Languages like C or C++ require each
variable, including multiple instances of the same variable in recursive calls, to
have distinct locations, so using this option results in non-conforming behavior.
-fmodulo-sched
Perform swing modulo scheduling immediately before the first scheduling pass.
This pass looks at innermost loops and reorders their instructions by overlap-
ping different iterations.
-fmodulo-sched-allow-regmoves
Perform more aggressive SMS-based modulo scheduling with register moves
allowed. By setting this flag certain anti-dependences edges are deleted, which
triggers the generation of reg-moves based on the life-range analysis. This
option is effective only with ‘-fmodulo-sched’ enabled.
-fno-branch-count-reg
Avoid running a pass scanning for opportunities to use “decrement and branch”
instructions on a count register instead of generating sequences of instructions
that decrement a register, compare it against zero, and then branch based upon
the result. This option is only meaningful on architectures that support such
instructions, which include x86, PowerPC, IA-64 and S/390. Note that the
‘-fno-branch-count-reg’ option doesn’t remove the decrement and branch
instructions from the generated instruction stream introduced by other opti-
mization passes.
Enabled by default at ‘-O1’ and higher.
The default is ‘-fbranch-count-reg’.
-fno-function-cse
Do not put function addresses in registers; make each instruction that calls a
constant function contain the function’s address explicitly.
Chapter 3: GCC Command Options 113

This option results in less efficient code, but some strange hacks that alter the
assembler output may be confused by the optimizations performed when this
option is not used.
The default is ‘-ffunction-cse’
-fno-zero-initialized-in-bss
If the target supports a BSS section, GCC by default puts variables that are
initialized to zero into BSS. This can save space in the resulting code.
This option turns off this behavior because some programs explicitly rely on
variables going to the data section—e.g., so that the resulting executable can
find the beginning of that section and/or make assumptions based on that.
The default is ‘-fzero-initialized-in-bss’.
-fthread-jumps
Perform optimizations that check to see if a jump branches to a location where
another comparison subsumed by the first is found. If so, the first branch is
redirected to either the destination of the second branch or a point immediately
following it, depending on whether the condition is known to be true or false.
Enabled at levels ‘-O2’, ‘-O3’, ‘-Os’.
-fsplit-wide-types
When using a type that occupies multiple registers, such as long long on a
32-bit system, split the registers apart and allocate them independently. This
normally generates better code for those types, but may make debugging more
difficult.
Enabled at levels ‘-O’, ‘-O2’, ‘-O3’, ‘-Os’.
-fcse-follow-jumps
In common subexpression elimination (CSE), scan through jump instructions
when the target of the jump is not reached by any other path. For example,
when CSE encounters an if statement with an else clause, CSE follows the
jump when the condition tested is false.
Enabled at levels ‘-O2’, ‘-O3’, ‘-Os’.
-fcse-skip-blocks
This is similar to ‘-fcse-follow-jumps’, but causes CSE to follow jumps that
conditionally skip over blocks. When CSE encounters a simple if statement
with no else clause, ‘-fcse-skip-blocks’ causes CSE to follow the jump around
the body of the if.
Enabled at levels ‘-O2’, ‘-O3’, ‘-Os’.
-frerun-cse-after-loop
Re-run common subexpression elimination after loop optimizations are per-
formed.
Enabled at levels ‘-O2’, ‘-O3’, ‘-Os’.
-fgcse Perform a global common subexpression elimination pass. This pass also per-
forms global constant and copy propagation.
114 Using the GNU Compiler Collection (GCC)

Note: When compiling a program using computed gotos, a GCC extension,

you may get better run-time performance if you disable the global common
subexpression elimination pass by adding ‘-fno-gcse’ to the command line.
Enabled at levels ‘-O2’, ‘-O3’, ‘-Os’.
-fgcse-lm
When ‘-fgcse-lm’ is enabled, global common subexpression elimination at-
tempts to move loads that are only killed by stores into themselves. This
allows a loop containing a load/store sequence to be changed to a load outside
the loop, and a copy/store within the loop.
Enabled by default when ‘-fgcse’ is enabled.
-fgcse-sm
When ‘-fgcse-sm’ is enabled, a store motion pass is run after global common
subexpression elimination. This pass attempts to move stores out of loops.
When used in conjunction with ‘-fgcse-lm’, loops containing a load/store se-
quence can be changed to a load before the loop and a store after the loop.
Not enabled at any optimization level.
-fgcse-las
When ‘-fgcse-las’ is enabled, the global common subexpression elimination
pass eliminates redundant loads that come after stores to the same memory
location (both partial and full redundancies).
Not enabled at any optimization level.
-fgcse-after-reload
When ‘-fgcse-after-reload’ is enabled, a redundant load elimination pass
is performed after reload. The purpose of this pass is to clean up redundant
spilling.
-faggressive-loop-optimizations
This option tells the loop optimizer to use language constraints to derive bounds
for the number of iterations of a loop. This assumes that loop code does not
invoke undefined behavior by for example causing signed integer overflows or
out-of-bound array accesses. The bounds for the number of iterations of a loop
are used to guide loop unrolling and peeling and loop exit test optimizations.
This option is enabled by default.
-funconstrained-commons
This option tells the compiler that variables declared in common blocks (e.g.
Fortran) may later be overridden with longer trailing arrays. This prevents
certain optimizations that depend on knowing the array bounds.
-fcrossjumping
Perform cross-jumping transformation. This transformation unifies equivalent
code and saves code size. The resulting code may or may not perform better
than without cross-jumping.
Enabled at levels ‘-O2’, ‘-O3’, ‘-Os’.
Chapter 3: GCC Command Options 115

-fauto-inc-dec
Combine increments or decrements of addresses with memory accesses. This
pass is always skipped on architectures that do not have instructions to support
this. Enabled by default at ‘-O’ and higher on architectures that support this.

-fdce Perform dead code elimination (DCE) on RTL. Enabled by default at ‘-O’ and
higher.

-fdse Perform dead store elimination (DSE) on RTL. Enabled by default at ‘-O’ and
higher.

-fif-conversion
Attempt to transform conditional jumps into branch-less equivalents. This
includes use of conditional moves, min, max, set flags and abs instructions, and
some tricks doable by standard arithmetics. The use of conditional execution
on chips where it is available is controlled by ‘-fif-conversion2’.
Enabled at levels ‘-O’, ‘-O2’, ‘-O3’, ‘-Os’.

-fif-conversion2
Use conditional execution (where available) to transform conditional jumps into
branch-less equivalents.
Enabled at levels ‘-O’, ‘-O2’, ‘-O3’, ‘-Os’.

-fdeclone-ctor-dtor
The C++ ABI requires multiple entry points for constructors and destructors:
one for a base subobject, one for a complete object, and one for a virtual
destructor that calls operator delete afterwards. For a hierarchy with virtual
bases, the base and complete variants are clones, which means two copies of the
function. With this option, the base and complete variants are changed to be
thunks that call a common implementation.
Enabled by ‘-Os’.

-fdelete-null-pointer-checks
Assume that programs cannot safely dereference null pointers, and that no code
or data element resides at address zero. This option enables simple constant
folding optimizations at all optimization levels. In addition, other optimization
passes in GCC use this flag to control global dataflow analyses that eliminate
useless checks for null pointers; these assume that a memory access to address
zero always results in a trap, so that if a pointer is checked after it has already
been dereferenced, it cannot be null.
Note however that in some environments this assumption is not true.
Use ‘-fno-delete-null-pointer-checks’ to disable this optimization for
programs that depend on that behavior.
This option is enabled by default on most targets. On Nios II ELF, it defaults
to off. On AVR and CR16, this option is completely disabled.
Passes that use the dataflow information are enabled independently at different
optimization levels.
116 Using the GNU Compiler Collection (GCC)

-fdevirtualize
Attempt to convert calls to virtual functions to direct calls. This is
done both within a procedure and interprocedurally as part of indirect
inlining (‘-findirect-inlining’) and interprocedural constant propagation
(‘-fipa-cp’). Enabled at levels ‘-O2’, ‘-O3’, ‘-Os’.
-fdevirtualize-speculatively
Attempt to convert calls to virtual functions to speculative direct calls. Based
on the analysis of the type inheritance graph, determine for a given call the
set of likely targets. If the set is small, preferably of size 1, change the call
into a conditional deciding between direct and indirect calls. The speculative
calls enable more optimizations, such as inlining. When they seem useless after
further optimization, they are converted back into original form.
-fdevirtualize-at-ltrans
Stream extra information needed for aggressive devirtualization when running
the link-time optimizer in local transformation mode. This option enables more
devirtualization but significantly increases the size of streamed data. For this
reason it is disabled by default.
-fexpensive-optimizations
Perform a number of minor optimizations that are relatively expensive.
Enabled at levels ‘-O2’, ‘-O3’, ‘-Os’.
-free Attempt to remove redundant extension instructions. This is especially helpful
for the x86-64 architecture, which implicitly zero-extends in 64-bit registers
after writing to their lower 32-bit half.
Enabled for Alpha, AArch64 and x86 at levels ‘-O2’, ‘-O3’, ‘-Os’.
-fno-lifetime-dse
In C++ the value of an object is only affected by changes within its lifetime:
when the constructor begins, the object has an indeterminate value, and any
changes during the lifetime of the object are dead when the object is de-
stroyed. Normally dead store elimination will take advantage of this; if your
code relies on the value of the object storage persisting beyond the lifetime
of the object, you can use this flag to disable this optimization. To pre-
serve stores before the constructor starts (e.g. because your operator new
clears the object storage) but still treat the object as dead after the destruc-
tor you, can use ‘-flifetime-dse=1’. The default behavior can be explic-
itly selected with ‘-flifetime-dse=2’. ‘-flifetime-dse=0’ is equivalent to
‘-fno-lifetime-dse’.
-flive-range-shrinkage
Attempt to decrease register pressure through register live range shrinkage.
This is helpful for fast processors with small or moderate size register sets.
-fira-algorithm=algorithm
Use the specified coloring algorithm for the integrated register allocator. The
algorithm argument can be ‘priority’, which specifies Chow’s priority coloring,
or ‘CB’, which specifies Chaitin-Briggs coloring. Chaitin-Briggs coloring is not
Chapter 3: GCC Command Options 117

implemented for all architectures, but for those targets that do support it, it is
the default because it generates better code.
-fira-region=region
Use specified regions for the integrated register allocator. The region argument
should be one of the following:
‘all’ Use all loops as register allocation regions. This can give the best
results for machines with a small and/or irregular register set.
‘mixed’ Use all loops except for loops with small register pressure as the
regions. This value usually gives the best results in most cases and
for most architectures, and is enabled by default when compiling
with optimization for speed (‘-O’, ‘-O2’, . . . ).
‘one’ Use all functions as a single region. This typically results in the
smallest code size, and is enabled by default for ‘-Os’ or ‘-O0’.
-fira-hoist-pressure
Use IRA to evaluate register pressure in the code hoisting pass for decisions to
hoist expressions. This option usually results in smaller code, but it can slow
the compiler down.
This option is enabled at level ‘-Os’ for all targets.
-fira-loop-pressure
Use IRA to evaluate register pressure in loops for decisions to move loop in-
variants. This option usually results in generation of faster and smaller code on
machines with large register files (>= 32 registers), but it can slow the compiler
down.
This option is enabled at level ‘-O3’ for some targets.
-fno-ira-share-save-slots
Disable sharing of stack slots used for saving call-used hard registers living
through a call. Each hard register gets a separate stack slot, and as a result
function stack frames are larger.
-fno-ira-share-spill-slots
Disable sharing of stack slots allocated for pseudo-registers. Each pseudo-
register that does not get a hard register gets a separate stack slot, and as
a result function stack frames are larger.
-flra-remat
Enable CFG-sensitive rematerialization in LRA. Instead of loading values of
spilled pseudos, LRA tries to rematerialize (recalculate) values if it is profitable.
Enabled at levels ‘-O2’, ‘-O3’, ‘-Os’.
-fdelayed-branch
If supported for the target machine, attempt to reorder instructions to exploit
instruction slots available after delayed branch instructions.
Enabled at levels ‘-O’, ‘-O2’, ‘-O3’, ‘-Os’.
118 Using the GNU Compiler Collection (GCC)

-fschedule-insns
If supported for the target machine, attempt to reorder instructions to eliminate
execution stalls due to required data being unavailable. This helps machines
that have slow floating point or memory load instructions by allowing other
instructions to be issued until the result of the load or floating-point instruction
is required.
Enabled at levels ‘-O2’, ‘-O3’.
-fschedule-insns2
Similar to ‘-fschedule-insns’, but requests an additional pass of instruction
scheduling after register allocation has been done. This is especially useful on
machines with a relatively small number of registers and where memory load
instructions take more than one cycle.
Enabled at levels ‘-O2’, ‘-O3’, ‘-Os’.
-fno-sched-interblock
Don’t schedule instructions across basic blocks. This is normally enabled by
default when scheduling before register allocation, i.e. with ‘-fschedule-insns’
or at ‘-O2’ or higher.
-fno-sched-spec
Don’t allow speculative motion of non-load instructions. This is normally
enabled by default when scheduling before register allocation, i.e. with
‘-fschedule-insns’ or at ‘-O2’ or higher.
-fsched-pressure
Enable register pressure sensitive insn scheduling before register allocation.
This only makes sense when scheduling before register allocation is enabled,
i.e. with ‘-fschedule-insns’ or at ‘-O2’ or higher. Usage of this option can
improve the generated code and decrease its size by preventing register pressure
increase above the number of available hard registers and subsequent spills in
register allocation.
-fsched-spec-load
Allow speculative motion of some load instructions. This only makes sense
when scheduling before register allocation, i.e. with ‘-fschedule-insns’ or at
‘-O2’ or higher.
-fsched-spec-load-dangerous
Allow speculative motion of more load instructions. This only makes sense
when scheduling before register allocation, i.e. with ‘-fschedule-insns’ or at
‘-O2’ or higher.
-fsched-stalled-insns
-fsched-stalled-insns=n
Define how many insns (if any) can be moved prematurely from the queue
of stalled insns into the ready list during the second scheduling pass.
‘-fno-sched-stalled-insns’ means that no insns are moved prematurely,
‘-fsched-stalled-insns=0’ means there is no limit on how many queued
insns can be moved prematurely. ‘-fsched-stalled-insns’ without a value
is equivalent to ‘-fsched-stalled-insns=1’.
Chapter 3: GCC Command Options 119

-fsched-stalled-insns-dep
-fsched-stalled-insns-dep=n
Define how many insn groups (cycles) are examined for a depen-
dency on a stalled insn that is a candidate for premature removal
from the queue of stalled insns. This has an effect only during
the second scheduling pass, and only if ‘-fsched-stalled-insns’
is used. ‘-fno-sched-stalled-insns-dep’ is equivalent to
‘-fsched-stalled-insns-dep=0’. ‘-fsched-stalled-insns-dep’
without a value is equivalent to ‘-fsched-stalled-insns-dep=1’.
-fsched2-use-superblocks
When scheduling after register allocation, use superblock scheduling. This al-
lows motion across basic block boundaries, resulting in faster schedules. This
option is experimental, as not all machine descriptions used by GCC model the
CPU closely enough to avoid unreliable results from the algorithm.
This only makes sense when scheduling after register allocation, i.e. with
‘-fschedule-insns2’ or at ‘-O2’ or higher.
-fsched-group-heuristic
Enable the group heuristic in the scheduler. This heuristic favors the instruction
that belongs to a schedule group. This is enabled by default when scheduling
is enabled, i.e. with ‘-fschedule-insns’ or ‘-fschedule-insns2’ or at ‘-O2’
or higher.
-fsched-critical-path-heuristic
Enable the critical-path heuristic in the scheduler. This heuristic favors in-
structions on the critical path. This is enabled by default when scheduling is
enabled, i.e. with ‘-fschedule-insns’ or ‘-fschedule-insns2’ or at ‘-O2’ or
higher.
-fsched-spec-insn-heuristic
Enable the speculative instruction heuristic in the scheduler. This heuristic
favors speculative instructions with greater dependency weakness. This is en-
abled by default when scheduling is enabled, i.e. with ‘-fschedule-insns’ or
‘-fschedule-insns2’ or at ‘-O2’ or higher.
-fsched-rank-heuristic
Enable the rank heuristic in the scheduler. This heuristic favors the instruc-
tion belonging to a basic block with greater size or frequency. This is en-
abled by default when scheduling is enabled, i.e. with ‘-fschedule-insns’ or
‘-fschedule-insns2’ or at ‘-O2’ or higher.
-fsched-last-insn-heuristic
Enable the last-instruction heuristic in the scheduler. This heuristic favors the
instruction that is less dependent on the last instruction scheduled. This is
enabled by default when scheduling is enabled, i.e. with ‘-fschedule-insns’
or ‘-fschedule-insns2’ or at ‘-O2’ or higher.
-fsched-dep-count-heuristic
Enable the dependent-count heuristic in the scheduler. This heuristic favors
the instruction that has more instructions depending on it. This is enabled
120 Using the GNU Compiler Collection (GCC)

by default when scheduling is enabled, i.e. with ‘-fschedule-insns’ or

‘-fschedule-insns2’ or at ‘-O2’ or higher.

-freschedule-modulo-scheduled-loops
Modulo scheduling is performed before traditional scheduling. If a loop is mod-
ulo scheduled, later scheduling passes may change its schedule. Use this option
to control that behavior.

-fselective-scheduling
Schedule instructions using selective scheduling algorithm. Selective scheduling
runs instead of the first scheduler pass.

-fselective-scheduling2
Schedule instructions using selective scheduling algorithm. Selective scheduling
runs instead of the second scheduler pass.

-fsel-sched-pipelining
Enable software pipelining of innermost loops during selective scheduling.
This option has no effect unless one of ‘-fselective-scheduling’ or
‘-fselective-scheduling2’ is turned on.

-fsel-sched-pipelining-outer-loops
When pipelining loops during selective scheduling, also pipeline outer loops.
This option has no effect unless ‘-fsel-sched-pipelining’ is turned on.

-fsemantic-interposition
Some object formats, like ELF, allow interposing of symbols by the dynamic
linker. This means that for symbols exported from the DSO, the compiler can-
not perform interprocedural propagation, inlining and other optimizations in
anticipation that the function or variable in question may change. While this
feature is useful, for example, to rewrite memory allocation functions by a de-
bugging implementation, it is expensive in the terms of code quality. With
‘-fno-semantic-interposition’ the compiler assumes that if interposition
happens for functions the overwriting function will have precisely the same
semantics (and side effects). Similarly if interposition happens for variables,
the constructor of the variable will be the same. The flag has no effect for
functions explicitly declared inline (where it is never allowed for interposition
to change semantics) and for symbols explicitly declared weak.

-fshrink-wrap
Emit function prologues only before parts of the function that need it, rather
than at the top of the function. This flag is enabled by default at ‘-O’ and
higher.

-fshrink-wrap-separate
Shrink-wrap separate parts of the prologue and epilogue separately, so that
those parts are only executed when needed. This option is on by default, but
has no effect unless ‘-fshrink-wrap’ is also turned on and the target supports
this.
Chapter 3: GCC Command Options 121

-fcaller-saves
Enable allocation of values to registers that are clobbered by function calls, by
emitting extra instructions to save and restore the registers around such calls.
Such allocation is done only when it seems to result in better code.
This option is always enabled by default on certain machines, usually those
which have no call-preserved registers to use instead.
Enabled at levels ‘-O2’, ‘-O3’, ‘-Os’.
-fcombine-stack-adjustments
Tracks stack adjustments (pushes and pops) and stack memory references and
then tries to find ways to combine them.
Enabled by default at ‘-O1’ and higher.
-fipa-ra Use caller save registers for allocation if those registers are not used by any called
function. In that case it is not necessary to save and restore them around calls.
This is only possible if called functions are part of same compilation unit as
current function and they are compiled before it.
Enabled at levels ‘-O2’, ‘-O3’, ‘-Os’, however the option is disabled if generated
code will be instrumented for profiling (‘-p’, or ‘-pg’) or if callee’s register usage
cannot be known exactly (this happens on targets that do not expose prologues
and epilogues in RTL).
-fconserve-stack
Attempt to minimize stack usage. The compiler attempts to use less stack
space, even if that makes the program slower. This option implies setting the
‘large-stack-frame’ parameter to 100 and the ‘large-stack-frame-growth’
parameter to 400.
-ftree-reassoc
Perform reassociation on trees. This flag is enabled by default at ‘-O’ and
higher.
-fcode-hoisting
Perform code hoisting. Code hoisting tries to move the evaluation of expressions
executed on all paths to the function exit as early as possible. This is especially
useful as a code size optimization, but it often helps for code speed as well.
This flag is enabled by default at ‘-O2’ and higher.
-ftree-pre
Perform partial redundancy elimination (PRE) on trees. This flag is enabled
by default at ‘-O2’ and ‘-O3’.
-ftree-partial-pre
Make partial redundancy elimination (PRE) more aggressive. This flag is en-
abled by default at ‘-O3’.
-ftree-forwprop
Perform forward propagation on trees. This flag is enabled by default at ‘-O’
and higher.
122 Using the GNU Compiler Collection (GCC)

-ftree-fre
Perform full redundancy elimination (FRE) on trees. The difference between
FRE and PRE is that FRE only considers expressions that are computed on
all paths leading to the redundant computation. This analysis is faster than
PRE, though it exposes fewer redundancies. This flag is enabled by default at
‘-O’ and higher.
-ftree-phiprop
Perform hoisting of loads from conditional pointers on trees. This pass is en-
abled by default at ‘-O’ and higher.
-fhoist-adjacent-loads
Speculatively hoist loads from both branches of an if-then-else if the loads are
from adjacent locations in the same structure and the target architecture has
a conditional move instruction. This flag is enabled by default at ‘-O2’ and
higher.
-ftree-copy-prop
Perform copy propagation on trees. This pass eliminates unnecessary copy
operations. This flag is enabled by default at ‘-O’ and higher.
-fipa-pure-const
Discover which functions are pure or constant. Enabled by default at ‘-O’ and
higher.
-fipa-reference
Discover which static variables do not escape the compilation unit. Enabled by
default at ‘-O’ and higher.
-fipa-pta
Perform interprocedural pointer analysis and interprocedural modification and
reference analysis. This option can cause excessive memory and compile-time
usage on large compilation units. It is not enabled by default at any optimiza-
tion level.
-fipa-profile
Perform interprocedural profile propagation. The functions called only from
cold functions are marked as cold. Also functions executed once (such as cold,
noreturn, static constructors or destructors) are identified. Cold functions and
loop less parts of functions executed once are then optimized for size. Enabled
by default at ‘-O’ and higher.
-fipa-cp Perform interprocedural constant propagation. This optimization analyzes the
program to determine when values passed to functions are constants and then
optimizes accordingly. This optimization can substantially increase perfor-
mance if the application has constants passed to functions. This flag is enabled
by default at ‘-O2’, ‘-Os’ and ‘-O3’.
-fipa-cp-clone
Perform function cloning to make interprocedural constant propagation
stronger. When enabled, interprocedural constant propagation performs
function cloning when externally visible function can be called with constant
Chapter 3: GCC Command Options 123

arguments. Because this optimization can create multiple copies of functions, it

may significantly increase code size (see ‘--param ipcp-unit-growth=value’).
This flag is enabled by default at ‘-O3’.
-fipa-bit-cp
When enabled, perform interprocedural bitwise constant propagation. This flag
is enabled by default at ‘-O2’. It requires that ‘-fipa-cp’ is enabled.
-fipa-vrp
When enabled, perform interprocedural propagation of value ranges. This flag
is enabled by default at ‘-O2’. It requires that ‘-fipa-cp’ is enabled.
-fipa-icf
Perform Identical Code Folding for functions and read-only variables. The
optimization reduces code size and may disturb unwind stacks by replacing a
function by equivalent one with a different name. The optimization works more
effectively with link-time optimization enabled.
Nevertheless the behavior is similar to Gold Linker ICF optimization, GCC ICF
works on different levels and thus the optimizations are not same - there are
equivalences that are found only by GCC and equivalences found only by Gold.
This flag is enabled by default at ‘-O2’ and ‘-Os’.
-fisolate-erroneous-paths-dereference
Detect paths that trigger erroneous or undefined behavior due to dereferencing
a null pointer. Isolate those paths from the main control flow and turn the state-
ment with erroneous or undefined behavior into a trap. This flag is enabled by
default at ‘-O2’ and higher and depends on ‘-fdelete-null-pointer-checks’
also being enabled.
-fisolate-erroneous-paths-attribute
Detect paths that trigger erroneous or undefined behavior due to a null value
being used in a way forbidden by a returns_nonnull or nonnull attribute.
Isolate those paths from the main control flow and turn the statement with
erroneous or undefined behavior into a trap. This is not currently enabled, but
may be enabled by ‘-O2’ in the future.
-ftree-sink
Perform forward store motion on trees. This flag is enabled by default at ‘-O’
and higher.
-ftree-bit-ccp
Perform sparse conditional bit constant propagation on trees and propagate
pointer alignment information. This pass only operates on local scalar variables
and is enabled by default at ‘-O’ and higher. It requires that ‘-ftree-ccp’ is
enabled.
-ftree-ccp
Perform sparse conditional constant propagation (CCP) on trees. This pass
only operates on local scalar variables and is enabled by default at ‘-O’ and
higher.
124 Using the GNU Compiler Collection (GCC)

-fssa-backprop
Propagate information about uses of a value up the definition chain in order to
simplify the definitions. For example, this pass strips sign operations if the sign
of a value never matters. The flag is enabled by default at ‘-O’ and higher.

-fssa-phiopt
Perform pattern matching on SSA PHI nodes to optimize conditional code.
This pass is enabled by default at ‘-O’ and higher.

-ftree-switch-conversion
Perform conversion of simple initializations in a switch to initializations from a
scalar array. This flag is enabled by default at ‘-O2’ and higher.

-ftree-tail-merge
Look for identical code sequences. When found, replace one with a jump
to the other. This optimization is known as tail merging or cross jumping.
This flag is enabled by default at ‘-O2’ and higher. The compilation time in
this pass can be limited using ‘max-tail-merge-comparisons’ parameter and
‘max-tail-merge-iterations’ parameter.

-ftree-dce
Perform dead code elimination (DCE) on trees. This flag is enabled by default
at ‘-O’ and higher.

-ftree-builtin-call-dce
Perform conditional dead code elimination (DCE) for calls to built-in functions
that may set errno but are otherwise side-effect free. This flag is enabled by
default at ‘-O2’ and higher if ‘-Os’ is not also specified.

-ftree-dominator-opts
Perform a variety of simple scalar cleanups (constant/copy propagation, redun-
dancy elimination, range propagation and expression simplification) based on a
dominator tree traversal. This also performs jump threading (to reduce jumps
to jumps). This flag is enabled by default at ‘-O’ and higher.

-ftree-dse
Perform dead store elimination (DSE) on trees. A dead store is a store into a
memory location that is later overwritten by another store without any inter-
vening loads. In this case the earlier store can be deleted. This flag is enabled
by default at ‘-O’ and higher.

-ftree-ch
Perform loop header copying on trees. This is beneficial since it increases ef-
fectiveness of code motion optimizations. It also saves one jump. This flag is
enabled by default at ‘-O’ and higher. It is not enabled for ‘-Os’, since it usually
increases code size.

-ftree-loop-optimize
Perform loop optimizations on trees. This flag is enabled by default at ‘-O’ and
higher.
Chapter 3: GCC Command Options 125

-ftree-loop-linear
-floop-interchange
-floop-strip-mine
-floop-block
-floop-unroll-and-jam
Perform loop nest optimizations. Same as ‘-floop-nest-optimize’. To use
this code transformation, GCC has to be configured with ‘--with-isl’ to en-
able the Graphite loop transformation infrastructure.
-fgraphite-identity
Enable the identity transformation for graphite. For every SCoP we gener-
ate the polyhedral representation and transform it back to gimple. Using
‘-fgraphite-identity’ we can check the costs or benefits of the GIMPLE
-> GRAPHITE -> GIMPLE transformation. Some minimal optimizations are
also performed by the code generator isl, like index splitting and dead code
elimination in loops.
-floop-nest-optimize
Enable the isl based loop nest optimizer. This is a generic loop nest optimizer
based on the Pluto optimization algorithms. It calculates a loop structure
optimized for data-locality and parallelism. This option is experimental.
-floop-parallelize-all
Use the Graphite data dependence analysis to identify loops that can be paral-
lelized. Parallelize all the loops that can be analyzed to not contain loop carried
dependences without checking that it is profitable to parallelize the loops.
-ftree-coalesce-vars
While transforming the program out of the SSA representation, attempt to
reduce copying by coalescing versions of different user-defined variables, instead
of just compiler temporaries. This may severely limit the ability to debug an
optimized program compiled with ‘-fno-var-tracking-assignments’. In the
negated form, this flag prevents SSA coalescing of user variables. This option is
enabled by default if optimization is enabled, and it does very little otherwise.
-ftree-loop-if-convert
Attempt to transform conditional jumps in the innermost loops to branch-less
equivalents. The intent is to remove control-flow from the innermost loops in
order to improve the ability of the vectorization pass to handle these loops.
This is enabled by default if vectorization is enabled.
-ftree-loop-distribution
Perform loop distribution. This flag can improve cache performance on big loop
bodies and allow further loop optimizations, like parallelization or vectorization,
to take place. For example, the loop
DO I = 1, N
A(I) = B(I) + C
D(I) = E(I) * F
ENDDO
is transformed to
126 Using the GNU Compiler Collection (GCC)

DO I = 1, N
A(I) = B(I) + C
ENDDO
DO I = 1, N
D(I) = E(I) * F
ENDDO

-ftree-loop-distribute-patterns
Perform loop distribution of patterns that can be code generated with calls to
a library. This flag is enabled by default at ‘-O3’.
This pass distributes the initialization loops and generates a call to memset
zero. For example, the loop
DO I = 1, N
A(I) = 0
B(I) = A(I) + I
ENDDO
is transformed to
DO I = 1, N
A(I) = 0
ENDDO
DO I = 1, N
B(I) = A(I) + I
ENDDO
and the initialization loop is transformed into a call to memset zero.
-ftree-loop-im
Perform loop invariant motion on trees. This pass moves only invariants that
are hard to handle at RTL level (function calls, operations that expand to non-
trivial sequences of insns). With ‘-funswitch-loops’ it also moves operands
of conditions that are invariant out of the loop, so that we can use just trivial
invariantness analysis in loop unswitching. The pass also includes store motion.
-ftree-loop-ivcanon
Create a canonical counter for number of iterations in loops for which deter-
mining number of iterations requires complicated analysis. Later optimizations
then may determine the number easily. Useful especially in connection with
unrolling.
-fivopts Perform induction variable optimizations (strength reduction, induction vari-
able merging and induction variable elimination) on trees.
-ftree-parallelize-loops=n
Parallelize loops, i.e., split their iteration space to run in n threads. This is
only possible for loops whose iterations are independent and can be arbitrarily
reordered. The optimization is only profitable on multiprocessor machines, for
loops that are CPU-intensive, rather than constrained e.g. by memory band-
width. This option implies ‘-pthread’, and thus is only supported on targets
that have support for ‘-pthread’.
-ftree-pta
Perform function-local points-to analysis on trees. This flag is enabled by de-
fault at ‘-O’ and higher.
Chapter 3: GCC Command Options 127

-ftree-sra
Perform scalar replacement of aggregates. This pass replaces structure refer-
ences with scalars to prevent committing structures to memory too early. This
flag is enabled by default at ‘-O’ and higher.
-fstore-merging
Perform merging of narrow stores to consecutive memory addresses. This pass
merges contiguous stores of immediate values narrower than a word into fewer
wider stores to reduce the number of instructions. This is enabled by default
at ‘-O2’ and higher as well as ‘-Os’.
-ftree-ter
Perform temporary expression replacement during the SSA->normal phase. Sin-
gle use/single def temporaries are replaced at their use location with their defin-
ing expression. This results in non-GIMPLE code, but gives the expanders
much more complex trees to work on resulting in better RTL generation. This
is enabled by default at ‘-O’ and higher.
-ftree-slsr
Perform straight-line strength reduction on trees. This recognizes related ex-
pressions involving multiplications and replaces them by less expensive calcu-
lations when possible. This is enabled by default at ‘-O’ and higher.
-ftree-vectorize
Perform vectorization on trees. This flag enables ‘-ftree-loop-vectorize’
and ‘-ftree-slp-vectorize’ if not explicitly specified.
-ftree-loop-vectorize
Perform loop vectorization on trees. This flag is enabled by default at ‘-O3’
and when ‘-ftree-vectorize’ is enabled.
-ftree-slp-vectorize
Perform basic block vectorization on trees. This flag is enabled by default at
‘-O3’ and when ‘-ftree-vectorize’ is enabled.
-fvect-cost-model=model
Alter the cost model used for vectorization. The model argument should be
one of ‘unlimited’, ‘dynamic’ or ‘cheap’. With the ‘unlimited’ model the
vectorized code-path is assumed to be profitable while with the ‘dynamic’ model
a runtime check guards the vectorized code-path to enable it only for iteration
counts that will likely execute faster than when executing the original scalar
loop. The ‘cheap’ model disables vectorization of loops where doing so would be
cost prohibitive for example due to required runtime checks for data dependence
or alignment but otherwise is equal to the ‘dynamic’ model. The default cost
model depends on other optimization flags and is either ‘dynamic’ or ‘cheap’.
-fsimd-cost-model=model
Alter the cost model used for vectorization of loops marked with the
OpenMP or Cilk Plus simd directive. The model argument should be one of
‘unlimited’, ‘dynamic’, ‘cheap’. All values of model have the same meaning
as described in ‘-fvect-cost-model’ and by default a cost model defined with
‘-fvect-cost-model’ is used.
128 Using the GNU Compiler Collection (GCC)

-ftree-vrp
Perform Value Range Propagation on trees. This is similar to the constant prop-
agation pass, but instead of values, ranges of values are propagated. This allows
the optimizers to remove unnecessary range checks like array bound checks and
null pointer checks. This is enabled by default at ‘-O2’ and higher. Null pointer
check elimination is only done if ‘-fdelete-null-pointer-checks’ is enabled.
-fsplit-paths
Split paths leading to loop backedges. This can improve dead code elimination
and common subexpression elimination. This is enabled by default at ‘-O2’ and
above.
-fsplit-ivs-in-unroller
Enables expression of values of induction variables in later iterations of the
unrolled loop using the value in the first iteration. This breaks long dependency
chains, thus improving efficiency of the scheduling passes.
A combination of ‘-fweb’ and CSE is often sufficient to obtain the same effect.
However, that is not reliable in cases where the loop body is more complicated
than a single basic block. It also does not work at all on some architectures
due to restrictions in the CSE pass.
This optimization is enabled by default.
-fvariable-expansion-in-unroller
With this option, the compiler creates multiple copies of some local variables
when unrolling a loop, which can result in superior code.
-fpartial-inlining
Inline parts of functions. This option has any effect only when inlining itself
is turned on by the ‘-finline-functions’ or ‘-finline-small-functions’
options.
Enabled at level ‘-O2’.
-fpredictive-commoning
Perform predictive commoning optimization, i.e., reusing computations (espe-
cially memory loads and stores) performed in previous iterations of loops.
This option is enabled at level ‘-O3’.
-fprefetch-loop-arrays
If supported by the target machine, generate instructions to prefetch memory
to improve the performance of loops that access large arrays.
This option may generate better or worse code; results are highly dependent on
the structure of loops within the source code.
Disabled at level ‘-Os’.
-fno-printf-return-value
Do not substitute constants for known return value of formatted output func-
tions such as sprintf, snprintf, vsprintf, and vsnprintf (but not printf
of fprintf). This transformation allows GCC to optimize or even eliminate
branches based on the known return value of these functions called with ar-
guments that are either constant, or whose values are known to be in a range
Chapter 3: GCC Command Options 129

that makes determining the exact return value possible. For example, when
‘-fprintf-return-value’ is in effect, both the branch and the body of the if
statement (but not the call to snprint) can be optimized away when i is a
32-bit or smaller integer because the return value is guaranteed to be at most
8.
char buf[9];
if (snprintf (buf, "%08x", i) >= sizeof buf)
...
The ‘-fprintf-return-value’ option relies on other optimizations and yields
best results with ‘-O2’. It works in tandem with the ‘-Wformat-overflow’
and ‘-Wformat-truncation’ options. The ‘-fprintf-return-value’ option is
enabled by default.
-fno-peephole
-fno-peephole2
Disable any machine-specific peephole optimizations. The difference between
‘-fno-peephole’ and ‘-fno-peephole2’ is in how they are implemented in the
compiler; some targets use one, some use the other, a few use both.
‘-fpeephole’ is enabled by default. ‘-fpeephole2’ enabled at levels ‘-O2’,
‘-O3’, ‘-Os’.
-fno-guess-branch-probability
Do not guess branch probabilities using heuristics.
GCC uses heuristics to guess branch probabilities if they are not provided
by profiling feedback (‘-fprofile-arcs’). These heuristics are based on the
control flow graph. If some branch probabilities are specified by __builtin_
expect, then the heuristics are used to guess branch probabilities for the rest
of the control flow graph, taking the __builtin_expect info into account. The
interactions between the heuristics and __builtin_expect can be complex,
and in some cases, it may be useful to disable the heuristics so that the effects
of __builtin_expect are easier to understand.
The default is ‘-fguess-branch-probability’ at levels ‘-O’, ‘-O2’, ‘-O3’, ‘-Os’.
-freorder-blocks
Reorder basic blocks in the compiled function in order to reduce number of
taken branches and improve code locality.
Enabled at levels ‘-O’, ‘-O2’, ‘-O3’, ‘-Os’.
-freorder-blocks-algorithm=algorithm
Use the specified algorithm for basic block reordering. The algorithm argument
can be ‘simple’, which does not increase code size (except sometimes due to
secondary effects like alignment), or ‘stc’, the “software trace cache” algorithm,
which tries to put all often executed code together, minimizing the number of
branches executed by making extra copies of code.
The default is ‘simple’ at levels ‘-O’, ‘-Os’, and ‘stc’ at levels ‘-O2’, ‘-O3’.
-freorder-blocks-and-partition
In addition to reordering basic blocks in the compiled function, in order to
reduce number of taken branches, partitions hot and cold basic blocks into
130 Using the GNU Compiler Collection (GCC)

separate sections of the assembly and ‘.o’ files, to improve paging and cache
locality performance.
This optimization is automatically turned off in the presence of exception han-
dling, for linkonce sections, for functions with a user-defined section attribute
and on any architecture that does not support named sections.
Enabled for x86 at levels ‘-O2’, ‘-O3’.

-freorder-functions
Reorder functions in the object file in order to improve code locality. This is im-
plemented by using special subsections .text.hot for most frequently executed
functions and .text.unlikely for unlikely executed functions. Reordering is
done by the linker so object file format must support named sections and linker
must place them in a reasonable way.
Also profile feedback must be available to make this option effective. See
‘-fprofile-arcs’ for details.
Enabled at levels ‘-O2’, ‘-O3’, ‘-Os’.

-fstrict-aliasing
Allow the compiler to assume the strictest aliasing rules applicable to the lan-
guage being compiled. For C (and C++), this activates optimizations based on
the type of expressions. In particular, an object of one type is assumed never
to reside at the same address as an object of a different type, unless the types
are almost the same. For example, an unsigned int can alias an int, but not
a void* or a double. A character type may alias any other type.
Pay special attention to code like this:
union a_union {
int i;
double d;
};

int f() {
union a_union t;
t.d = 3.0;
return t.i;
}

The practice of reading from a different union member than the one
most recently written to (called “type-punning”) is common. Even with
‘-fstrict-aliasing’, type-punning is allowed, provided the memory is
accessed through the union type. So, the code above works as expected. See
Section 4.9 [Structures unions enumerations and bit-fields implementation],
page 399. However, this code might not:
int f() {
union a_union t;
int* ip;
t.d = 3.0;
ip = &t.i;
return *ip;
}
Chapter 3: GCC Command Options 131

Similarly, access by taking the address, casting the resulting pointer and deref-
erencing the result has undefined behavior, even if the cast uses a union type,
e.g.:
int f() {
double d = 3.0;
return ((union a_union *) &d)->i;
}
The ‘-fstrict-aliasing’ option is enabled at levels ‘-O2’, ‘-O3’, ‘-Os’.
-fstrict-overflow
Allow the compiler to assume strict signed overflow rules, depending on the
language being compiled. For C (and C++) this means that overflow when doing
arithmetic with signed numbers is undefined, which means that the compiler
may assume that it does not happen. This permits various optimizations. For
example, the compiler assumes that an expression like i + 10 > i is always true
for signed i. This assumption is only valid if signed overflow is undefined, as the
expression is false if i + 10 overflows when using twos complement arithmetic.
When this option is in effect any attempt to determine whether an operation
on signed numbers overflows must be written carefully to not actually involve
overflow.
This option also allows the compiler to assume strict pointer semantics: given
a pointer to an object, if adding an offset to that pointer does not produce a
pointer to the same object, the addition is undefined. This permits the compiler
to conclude that p + u > p is always true for a pointer p and unsigned integer
u. This assumption is only valid because pointer wraparound is undefined, as
the expression is false if p + u overflows using twos complement arithmetic.
See also the ‘-fwrapv’ option. Using ‘-fwrapv’ means that integer signed over-
flow is fully defined: it wraps. When ‘-fwrapv’ is used, there is no difference
between ‘-fstrict-overflow’ and ‘-fno-strict-overflow’ for integers. With
‘-fwrapv’ certain types of overflow are permitted. For example, if the compiler
gets an overflow when doing arithmetic on constants, the overflowed value can
still be used with ‘-fwrapv’, but not otherwise.
The ‘-fstrict-overflow’ option is enabled at levels ‘-O2’, ‘-O3’, ‘-Os’.
-falign-functions
-falign-functions=n
Align the start of functions to the next power-of-two greater than n, skipping
up to n bytes. For instance, ‘-falign-functions=32’ aligns functions to the
next 32-byte boundary, but ‘-falign-functions=24’ aligns to the next 32-byte
boundary only if this can be done by skipping 23 bytes or less.
‘-fno-align-functions’ and ‘-falign-functions=1’ are equivalent and mean
that functions are not aligned.
Some assemblers only support this flag when n is a power of two; in that case,
it is rounded up.
If n is not specified or is zero, use a machine-dependent default. The maximum
allowed n option value is 65536.
Enabled at levels ‘-O2’, ‘-O3’.
132 Using the GNU Compiler Collection (GCC)

-flimit-function-alignment
If this option is enabled, the compiler tries to avoid unnecessarily overaligning
functions. It attempts to instruct the assembler to align by the amount speci-
fied by ‘-falign-functions’, but not to skip more bytes than the size of the
function.
-falign-labels
-falign-labels=n
Align all branch targets to a power-of-two boundary, skipping up to n bytes
like ‘-falign-functions’. This option can easily make code slower, because
it must insert dummy operations for when the branch target is reached in the
usual flow of the code.
‘-fno-align-labels’ and ‘-falign-labels=1’ are equivalent and mean that
labels are not aligned.
If ‘-falign-loops’ or ‘-falign-jumps’ are applicable and are greater than this
value, then their values are used instead.
If n is not specified or is zero, use a machine-dependent default which is very
likely to be ‘1’, meaning no alignment. The maximum allowed n option value
is 65536.
Enabled at levels ‘-O2’, ‘-O3’.
-falign-loops
-falign-loops=n
Align loops to a power-of-two boundary, skipping up to n bytes like
‘-falign-functions’. If the loops are executed many times, this makes up
for any execution of the dummy operations.
‘-fno-align-loops’ and ‘-falign-loops=1’ are equivalent and mean that
loops are not aligned. The maximum allowed n option value is 65536.
If n is not specified or is zero, use a machine-dependent default.
Enabled at levels ‘-O2’, ‘-O3’.
-falign-jumps
-falign-jumps=n
Align branch targets to a power-of-two boundary, for branch targets where
the targets can only be reached by jumping, skipping up to n bytes like
‘-falign-functions’. In this case, no dummy operations need be executed.
‘-fno-align-jumps’ and ‘-falign-jumps=1’ are equivalent and mean that
loops are not aligned.
If n is not specified or is zero, use a machine-dependent default. The maximum
allowed n option value is 65536.
Enabled at levels ‘-O2’, ‘-O3’.
-funit-at-a-time
This option is left for compatibility reasons. ‘-funit-at-a-time’ has no
effect, while ‘-fno-unit-at-a-time’ implies ‘-fno-toplevel-reorder’ and
‘-fno-section-anchors’.
Enabled by default.
Chapter 3: GCC Command Options 133

-fno-toplevel-reorder
Do not reorder top-level functions, variables, and asm statements. Output them
in the same order that they appear in the input file. When this option is
used, unreferenced static variables are not removed. This option is intended to
support existing code that relies on a particular ordering. For new code, it is
better to use attributes when possible.
Enabled at level ‘-O0’. When disabled explicitly, it also implies
‘-fno-section-anchors’, which is otherwise enabled at ‘-O0’ on some targets.
-fweb Constructs webs as commonly used for register allocation purposes and assign
each web individual pseudo register. This allows the register allocation pass
to operate on pseudos directly, but also strengthens several other optimization
passes, such as CSE, loop optimizer and trivial dead code remover. It can,
however, make debugging impossible, since variables no longer stay in a “home
register”.
Enabled by default with ‘-funroll-loops’.
-fwhole-program
Assume that the current compilation unit represents the whole program being
compiled. All public functions and variables with the exception of main and
those merged by attribute externally_visible become static functions and
in effect are optimized more aggressively by interprocedural optimizers.
This option should not be used in combination with ‘-flto’. Instead relying
on a linker plugin should provide safer and more precise information.
-flto[=n]
This option runs the standard link-time optimizer. When invoked with source
code, it generates GIMPLE (one of GCC’s internal representations) and writes
it to special ELF sections in the object file. When the object files are linked
together, all the function bodies are read from these ELF sections and instan-
tiated as if they had been part of the same translation unit.
To use the link-time optimizer, ‘-flto’ and optimization options should be
specified at compile time and during the final link. It is recommended that you
compile all the files participating in the same link with the same options and
also specify those options at link time. For example:
gcc -c -O2 -flto foo.c
gcc -c -O2 -flto bar.c
gcc -o myprog -flto -O2 foo.o bar.o
The first two invocations to GCC save a bytecode representation of GIMPLE
into special ELF sections inside ‘foo.o’ and ‘bar.o’. The final invocation reads
the GIMPLE bytecode from ‘foo.o’ and ‘bar.o’, merges the two files into a
single internal image, and compiles the result as usual. Since both ‘foo.o’
and ‘bar.o’ are merged into a single image, this causes all the interprocedural
analyses and optimizations in GCC to work across the two files as if they were a
single one. This means, for example, that the inliner is able to inline functions
in ‘bar.o’ into functions in ‘foo.o’ and vice-versa.
Another (simpler) way to enable link-time optimization is:
134 Using the GNU Compiler Collection (GCC)

gcc -o myprog -flto -O2 foo.c bar.c

The above generates bytecode for ‘foo.c’ and ‘bar.c’, merges them together
into a single GIMPLE representation and optimizes them as usual to produce
‘myprog’.
The only important thing to keep in mind is that to enable link-time optimiza-
tions you need to use the GCC driver to perform the link step. GCC then
automatically performs link-time optimization if any of the objects involved
were compiled with the ‘-flto’ command-line option. You generally should
specify the optimization options to be used for link-time optimization though
GCC tries to be clever at guessing an optimization level to use from the options
used at compile time if you fail to specify one at link time. You can always over-
ride the automatic decision to do link-time optimization by passing ‘-fno-lto’
to the link command.
To make whole program optimization effective, it is necessary to make
certain whole program assumptions. The compiler needs to know what
functions and variables can be accessed by libraries and runtime outside
of the link-time optimized unit. When supported by the linker, the linker
plugin (see ‘-fuse-linker-plugin’) passes information to the compiler about
used and externally visible symbols. When the linker plugin is not available,
‘-fwhole-program’ should be used to allow the compiler to make these
assumptions, which leads to more aggressive optimization decisions.
When ‘-fuse-linker-plugin’ is not enabled, when a file is compiled
with ‘-flto’, the generated object file is larger than a regular object
file because it contains GIMPLE bytecodes and the usual final code (see
‘-ffat-lto-objects’. This means that object files with LTO information
can be linked as normal object files; if ‘-fno-lto’ is passed to the
linker, no interprocedural optimizations are applied. Note that when
‘-fno-fat-lto-objects’ is enabled the compile stage is faster but you cannot
perform a regular, non-LTO link on them.
Additionally, the optimization flags used to compile individual files are not
necessarily related to those used at link time. For instance,
gcc -c -O0 -ffat-lto-objects -flto foo.c
gcc -c -O0 -ffat-lto-objects -flto bar.c
gcc -o myprog -O3 foo.o bar.o
This produces individual object files with unoptimized assembler code, but the
resulting binary ‘myprog’ is optimized at ‘-O3’. If, instead, the final binary is
generated with ‘-fno-lto’, then ‘myprog’ is not optimized.
When producing the final binary, GCC only applies link-time optimizations to
those files that contain bytecode. Therefore, you can mix and match object
files and libraries with GIMPLE bytecodes and final object code. GCC auto-
matically selects which files to optimize in LTO mode and which files to link
without further processing.
There are some code generation flags preserved by GCC when generating byte-
codes, as they need to be used during the final link stage. Generally options
specified at link time override those specified at compile time.
Chapter 3: GCC Command Options 135

If you do not specify an optimization level option ‘-O’ at link time, then GCC
uses the highest optimization level used when compiling the object files.
Currently, the following options and their settings are taken from the first ob-
ject file that explicitly specifies them: ‘-fPIC’, ‘-fpic’, ‘-fpie’, ‘-fcommon’,
‘-fexceptions’, ‘-fnon-call-exceptions’, ‘-fgnu-tm’ and all the ‘-m’ target
flags.
Certain ABI-changing flags are required to match in all compilation units, and
trying to override this at link time with a conflicting value is ignored. This
includes options such as ‘-freg-struct-return’ and ‘-fpcc-struct-return’.
Other options such as ‘-ffp-contract’, ‘-fno-strict-overflow’, ‘-fwrapv’,
‘-fno-trapv’ or ‘-fno-strict-aliasing’ are passed through to the
link stage and merged conservatively for conflicting translation units.
Specifically ‘-fno-strict-overflow’, ‘-fwrapv’ and ‘-fno-trapv’ take
precedence; and for example ‘-ffp-contract=off’ takes precedence over
‘-ffp-contract=fast’. You can override them at link time.
If LTO encounters objects with C linkage declared with incompatible types in
separate translation units to be linked together (undefined behavior according
to ISO C99 6.2.7), a non-fatal diagnostic may be issued. The behavior is still
undefined at run time. Similar diagnostics may be raised for other languages.
Another feature of LTO is that it is possible to apply interprocedural optimiza-
tions on files written in different languages:
gcc -c -flto foo.c
g++ -c -flto bar.cc
gfortran -c -flto baz.f90
g++ -o myprog -flto -O3 foo.o bar.o baz.o -lgfortran
Notice that the final link is done with g++ to get the C++ runtime libraries and
‘-lgfortran’ is added to get the Fortran runtime libraries. In general, when
mixing languages in LTO mode, you should use the same link command options
as when mixing languages in a regular (non-LTO) compilation.
If object files containing GIMPLE bytecode are stored in a library archive, say
‘libfoo.a’, it is possible to extract and use them in an LTO link if you are
using a linker with plugin support. To create static libraries suitable for LTO,
use gcc-ar and gcc-ranlib instead of ar and ranlib; to show the symbols
of object files with GIMPLE bytecode, use gcc-nm. Those commands require
that ar, ranlib and nm have been compiled with plugin support. At link time,
use the the flag ‘-fuse-linker-plugin’ to ensure that the library participates
in the LTO optimization process:
gcc -o myprog -O2 -flto -fuse-linker-plugin a.o b.o -lfoo
With the linker plugin enabled, the linker extracts the needed GIMPLE files
from ‘libfoo.a’ and passes them on to the running GCC to make them part
of the aggregated GIMPLE image to be optimized.
If you are not using a linker with plugin support and/or do not enable the linker
plugin, then the objects inside ‘libfoo.a’ are extracted and linked as usual,
but they do not participate in the LTO optimization process. In order to make
a static library suitable for both LTO optimization and usual linkage, compile
its object files with ‘-flto’ ‘-ffat-lto-objects’.
136 Using the GNU Compiler Collection (GCC)

Link-time optimizations do not require the presence of the whole program to

operate. If the program does not require any symbols to be exported, it is pos-
sible to combine ‘-flto’ and ‘-fwhole-program’ to allow the interprocedural
optimizers to use more aggressive assumptions which may lead to improved op-
timization opportunities. Use of ‘-fwhole-program’ is not needed when linker
plugin is active (see ‘-fuse-linker-plugin’).
The current implementation of LTO makes no attempt to generate bytecode
that is portable between different types of hosts. The bytecode files are ver-
sioned and there is a strict version check, so bytecode files generated in one
version of GCC do not work with an older or newer version of GCC.
Link-time optimization does not work well with generation of debugging infor-
mation. Combining ‘-flto’ with ‘-g’ is currently experimental and expected
to produce unexpected results.
If you specify the optional n, the optimization and code generation done at link
time is executed in parallel using n parallel jobs by utilizing an installed make
program. The environment variable MAKE may be used to override the program
used. The default value for n is 1.
You can also specify ‘-flto=jobserver’ to use GNU make’s job server mode to
determine the number of parallel jobs. This is useful when the Makefile calling
GCC is already executing in parallel. You must prepend a ‘+’ to the command
recipe in the parent Makefile for this to work. This option likely only works if
MAKE is GNU make.

-flto-partition=alg
Specify the partitioning algorithm used by the link-time optimizer. The value
is either ‘1to1’ to specify a partitioning mirroring the original source files or
‘balanced’ to specify partitioning into equally sized chunks (whenever possi-
ble) or ‘max’ to create new partition for every symbol where possible. Specifying
‘none’ as an algorithm disables partitioning and streaming completely. The de-
fault value is ‘balanced’. While ‘1to1’ can be used as an workaround for various
code ordering issues, the ‘max’ partitioning is intended for internal testing only.
The value ‘one’ specifies that exactly one partition should be used while the
value ‘none’ bypasses partitioning and executes the link-time optimization step
directly from the WPA phase.

-flto-odr-type-merging
Enable streaming of mangled types names of C++ types and their unification at
link time. This increases size of LTO object files, but enables diagnostics about
One Definition Rule violations.

-flto-compression-level=n
This option specifies the level of compression used for intermediate language
written to LTO object files, and is only meaningful in conjunction with LTO
mode (‘-flto’). Valid values are 0 (no compression) to 9 (maximum compres-
sion). Values outside this range are clamped to either 0 or 9. If the option is
not given, a default balanced compression setting is used.
Chapter 3: GCC Command Options 137

-fuse-linker-plugin
Enables the use of a linker plugin during link-time optimization. This option
relies on plugin support in the linker, which is available in gold or in GNU ld
2.21 or newer.
This option enables the extraction of object files with GIMPLE bytecode out
of library archives. This improves the quality of optimization by exposing more
code to the link-time optimizer. This information specifies what symbols can be
accessed externally (by non-LTO object or during dynamic linking). Resulting
code quality improvements on binaries (and shared libraries that use hidden
visibility) are similar to ‘-fwhole-program’. See ‘-flto’ for a description of
the effect of this flag and how to use it.
This option is enabled by default when LTO support in GCC is enabled and
GCC was configured for use with a linker supporting plugins (GNU ld 2.21 or
newer or gold).
-ffat-lto-objects
Fat LTO objects are object files that contain both the intermediate language
and the object code. This makes them usable for both LTO linking and normal
linking. This option is effective only when compiling with ‘-flto’ and is ignored
at link time.
‘-fno-fat-lto-objects’ improves compilation time over plain LTO, but re-
quires the complete toolchain to be aware of LTO. It requires a linker with linker
plugin support for basic functionality. Additionally, nm, ar and ranlib need
to support linker plugins to allow a full-featured build environment (capable of
building static libraries etc). GCC provides the gcc-ar, gcc-nm, gcc-ranlib
wrappers to pass the right options to these tools. With non fat LTO makefiles
need to be modified to use them.
The default is ‘-fno-fat-lto-objects’ on targets with linker plugin support.
-fcompare-elim
After register allocation and post-register allocation instruction splitting, iden-
tify arithmetic instructions that compute processor flags similar to a comparison
operation based on that arithmetic. If possible, eliminate the explicit compar-
ison operation.
This pass only applies to certain targets that cannot explicitly represent the
comparison operation before register allocation is complete.
Enabled at levels ‘-O’, ‘-O2’, ‘-O3’, ‘-Os’.
-fcprop-registers
After register allocation and post-register allocation instruction splitting, per-
form a copy-propagation pass to try to reduce scheduling dependencies and
occasionally eliminate the copy.
Enabled at levels ‘-O’, ‘-O2’, ‘-O3’, ‘-Os’.
-fprofile-correction
Profiles collected using an instrumented binary for multi-threaded programs
may be inconsistent due to missed counter updates. When this option is spec-
138 Using the GNU Compiler Collection (GCC)

ified, GCC uses heuristics to correct or smooth out such inconsistencies. By

default, GCC emits an error message when an inconsistent profile is detected.
-fprofile-use
-fprofile-use=path
Enable profile feedback-directed optimizations, and the following optimizations
which are generally profitable only with profile feedback available:
‘-fbranch-probabilities’, ‘-fvpt’, ‘-funroll-loops’, ‘-fpeel-loops’,
‘-ftracer’, ‘-ftree-vectorize’, and ‘ftree-loop-distribute-patterns’.
Before you can use this option, you must first generate profiling information.
See Section 3.11 [Instrumentation Options], page 164, for information about
the ‘-fprofile-generate’ option.
By default, GCC emits an error message if the feedback profiles do not
match the source code. This error can be turned into a warning by using
‘-Wcoverage-mismatch’. Note this may result in poorly optimized code.
If path is specified, GCC looks at the path to find the profile feedback data
files. See ‘-fprofile-dir’.
-fauto-profile
-fauto-profile=path
Enable sampling-based feedback-directed optimizations, and the following op-
timizations which are generally profitable only with profile feedback available:
‘-fbranch-probabilities’, ‘-fvpt’, ‘-funroll-loops’, ‘-fpeel-loops’,
‘-ftracer’, ‘-ftree-vectorize’, ‘-finline-functions’, ‘-fipa-cp’,
‘-fipa-cp-clone’, ‘-fpredictive-commoning’, ‘-funswitch-loops’,
‘-fgcse-after-reload’, and ‘-ftree-loop-distribute-patterns’.
path is the name of a file containing AutoFDO profile information. If omitted,
it defaults to ‘fbdata.afdo’ in the current directory.
Producing an AutoFDO profile data file requires running your program with the
perf utility on a supported GNU/Linux target system. For more information,
see https://perf.wiki.kernel.org/.
E.g.
perf record -e br_inst_retired:near_taken -b -o perf.data \
-- your_program
Then use the create_gcov tool to convert the raw profile data to a format
that can be used by GCC. You must also supply the unstripped binary for your
program to this tool. See https://github.com/google/autofdo.
E.g.
create_gcov --binary=your_program.unstripped --profile=perf.data \
--gcov=profile.afdo

The following options control compiler behavior regarding floating-point arithmetic.

These options trade off between speed and correctness. All must be specifically enabled.
-ffloat-store
Do not store floating-point variables in registers, and inhibit other options that
might change whether a floating-point value is taken from a register or memory.
Chapter 3: GCC Command Options 139

This option prevents undesirable excess precision on machines such as the 68000
where the floating registers (of the 68881) keep more precision than a double
is supposed to have. Similarly for the x86 architecture. For most programs,
the excess precision does only good, but a few programs rely on the precise
definition of IEEE floating point. Use ‘-ffloat-store’ for such programs, after
modifying them to store all pertinent intermediate computations into variables.
-fexcess-precision=style
This option allows further control over excess precision on machines where
floating-point operations occur in a format with more precision or range
than the IEEE standard and interchange floating-point types. By default,
‘-fexcess-precision=fast’ is in effect; this means that operations may
be carried out in a wider precision than the types specified in the source
if that would result in faster code, and it is unpredictable when rounding
to the types specified in the source code takes place. When compiling C, if
‘-fexcess-precision=standard’ is specified then excess precision follows
the rules specified in ISO C99; in particular, both casts and assignments
cause values to be rounded to their semantic types (whereas ‘-ffloat-store’
only affects assignments). This option is enabled by default for C if a strict
conformance option such as ‘-std=c99’ is used. ‘-ffast-math’ enables
‘-fexcess-precision=fast’ by default regardless of whether a strict
conformance option is used.
‘-fexcess-precision=standard’ is not implemented for languages other than
C. On the x86, it has no effect if ‘-mfpmath=sse’ or ‘-mfpmath=sse+387’ is
specified; in the former case, IEEE semantics apply without excess precision,
and in the latter, rounding is unpredictable.
-ffast-math
Sets the options ‘-fno-math-errno’, ‘-funsafe-math-optimizations’,
‘-ffinite-math-only’, ‘-fno-rounding-math’, ‘-fno-signaling-nans’,
‘-fcx-limited-range’ and ‘-fexcess-precision=fast’.
This option causes the preprocessor macro __FAST_MATH__ to be defined.
This option is not turned on by any ‘-O’ option besides ‘-Ofast’ since it can
result in incorrect output for programs that depend on an exact implementation
of IEEE or ISO rules/specifications for math functions. It may, however, yield
faster code for programs that do not require the guarantees of these specifica-
tions.
-fno-math-errno
Do not set errno after calling math functions that are executed with a single
instruction, e.g., sqrt. A program that relies on IEEE exceptions for math
error handling may want to use this flag for speed while maintaining IEEE
arithmetic compatibility.
This option is not turned on by any ‘-O’ option since it can result in incorrect
output for programs that depend on an exact implementation of IEEE or ISO
rules/specifications for math functions. It may, however, yield faster code for
programs that do not require the guarantees of these specifications.
The default is ‘-fmath-errno’.
140 Using the GNU Compiler Collection (GCC)

On Darwin systems, the math library never sets errno. There is therefore
no reason for the compiler to consider the possibility that it might, and
‘-fno-math-errno’ is the default.

-funsafe-math-optimizations
Allow optimizations for floating-point arithmetic that (a) assume that argu-
ments and results are valid and (b) may violate IEEE or ANSI standards.
When used at link time, it may include libraries or startup files that change the
default FPU control word or other similar optimizations.
This option is not turned on by any ‘-O’ option since it can result in incor-
rect output for programs that depend on an exact implementation of IEEE
or ISO rules/specifications for math functions. It may, however, yield faster
code for programs that do not require the guarantees of these specifications.
Enables ‘-fno-signed-zeros’, ‘-fno-trapping-math’, ‘-fassociative-math’
and ‘-freciprocal-math’.
The default is ‘-fno-unsafe-math-optimizations’.

-fassociative-math
Allow re-association of operands in series of floating-point operations. This vi-
olates the ISO C and C++ language standard by possibly changing computation
result. NOTE: re-ordering may change the sign of zero as well as ignore NaNs
and inhibit or create underflow or overflow (and thus cannot be used on code
that relies on rounding behavior like (x + 2**52) - 2**52. May also reorder
floating-point comparisons and thus may not be used when ordered compar-
isons are required. This option requires that both ‘-fno-signed-zeros’ and
‘-fno-trapping-math’ be in effect. Moreover, it doesn’t make much sense with
‘-frounding-math’. For Fortran the option is automatically enabled when both
‘-fno-signed-zeros’ and ‘-fno-trapping-math’ are in effect.
The default is ‘-fno-associative-math’.

-freciprocal-math
Allow the reciprocal of a value to be used instead of dividing by the value if
this enables optimizations. For example x / y can be replaced with x * (1/y),
which is useful if (1/y) is subject to common subexpression elimination. Note
that this loses precision and increases the number of flops operating on the
value.
The default is ‘-fno-reciprocal-math’.

-ffinite-math-only
Allow optimizations for floating-point arithmetic that assume that arguments
and results are not NaNs or +-Infs.
This option is not turned on by any ‘-O’ option since it can result in incorrect
output for programs that depend on an exact implementation of IEEE or ISO
rules/specifications for math functions. It may, however, yield faster code for
programs that do not require the guarantees of these specifications.
The default is ‘-fno-finite-math-only’.
Chapter 3: GCC Command Options 141

-fno-signed-zeros
Allow optimizations for floating-point arithmetic that ignore the signedness of
zero. IEEE arithmetic specifies the behavior of distinct +0.0 and −0.0 values,
which then prohibits simplification of expressions such as x+0.0 or 0.0*x (even
with ‘-ffinite-math-only’). This option implies that the sign of a zero result
isn’t significant.
The default is ‘-fsigned-zeros’.
-fno-trapping-math
Compile code assuming that floating-point operations cannot generate user-
visible traps. These traps include division by zero, overflow, underflow, inexact
result and invalid operation. This option requires that ‘-fno-signaling-nans’
be in effect. Setting this option may allow faster code if one relies on “non-stop”
IEEE arithmetic, for example.
This option should never be turned on by any ‘-O’ option since it can result
in incorrect output for programs that depend on an exact implementation of
IEEE or ISO rules/specifications for math functions.
The default is ‘-ftrapping-math’.
-frounding-math
Disable transformations and optimizations that assume default floating-point
rounding behavior. This is round-to-zero for all floating point to integer con-
versions, and round-to-nearest for all other arithmetic truncations. This option
should be specified for programs that change the FP rounding mode dynami-
cally, or that may be executed with a non-default rounding mode. This option
disables constant folding of floating-point expressions at compile time (which
may be affected by rounding mode) and arithmetic transformations that are
unsafe in the presence of sign-dependent rounding modes.
The default is ‘-fno-rounding-math’.
This option is experimental and does not currently guarantee to disable all GCC
optimizations that are affected by rounding mode. Future versions of GCC may
provide finer control of this setting using C99’s FENV_ACCESS pragma. This
command-line option will be used to specify the default state for FENV_ACCESS.
-fsignaling-nans
Compile code assuming that IEEE signaling NaNs may generate user-visible
traps during floating-point operations. Setting this option disables optimiza-
tions that may change the number of exceptions visible with signaling NaNs.
This option implies ‘-ftrapping-math’.
This option causes the preprocessor macro __SUPPORT_SNAN__ to be defined.
The default is ‘-fno-signaling-nans’.
This option is experimental and does not currently guarantee to disable all
GCC optimizations that affect signaling NaN behavior.
-fno-fp-int-builtin-inexact
Do not allow the built-in functions ceil, floor, round and trunc, and their
float and long double variants, to generate code that raises the “inexact”
142 Using the GNU Compiler Collection (GCC)

floating-point exception for noninteger arguments. ISO C99 and C11 allow
these functions to raise the “inexact” exception, but ISO/IEC TS 18661-1:2014,
the C bindings to IEEE 754-2008, does not allow these functions to do so.
The default is ‘-ffp-int-builtin-inexact’, allowing the exception to be
raised. This option does nothing unless ‘-ftrapping-math’ is in effect.
Even if ‘-fno-fp-int-builtin-inexact’ is used, if the functions generate a
call to a library function then the “inexact” exception may be raised if the
library implementation does not follow TS 18661.
-fsingle-precision-constant
Treat floating-point constants as single precision instead of implicitly converting
them to double-precision constants.
-fcx-limited-range
When enabled, this option states that a range reduction step is not needed when
performing complex division. Also, there is no checking whether the result of
a complex multiplication or division is NaN + I*NaN, with an attempt to rescue
the situation in that case. The default is ‘-fno-cx-limited-range’, but is
enabled by ‘-ffast-math’.
This option controls the default setting of the ISO C99 CX_LIMITED_RANGE
pragma. Nevertheless, the option applies to all languages.
-fcx-fortran-rules
Complex multiplication and division follow Fortran rules. Range reduction is
done as part of complex division, but there is no checking whether the result of
a complex multiplication or division is NaN + I*NaN, with an attempt to rescue
the situation in that case.
The default is ‘-fno-cx-fortran-rules’.

The following options control optimizations that may improve performance, but are not
enabled by any ‘-O’ options. This section includes experimental options that may produce
broken code.

-fbranch-probabilities
After running a program compiled with ‘-fprofile-arcs’ (see Section 3.11
[Instrumentation Options], page 164), you can compile it a second time
using ‘-fbranch-probabilities’, to improve optimizations based on
the number of times each branch was taken. When a program compiled
with ‘-fprofile-arcs’ exits, it saves arc execution counts to a file called
‘sourcename.gcda’ for each source file. The information in this data file is
very dependent on the structure of the generated code, so you must use the
same source code and the same optimization options for both compilations.
With ‘-fbranch-probabilities’, GCC puts a ‘REG_BR_PROB’ note on each
‘JUMP_INSN’ and ‘CALL_INSN’. These can be used to improve optimization.
Currently, they are only used in one place: in ‘reorg.c’, instead of guessing
which path a branch is most likely to take, the ‘REG_BR_PROB’ values are used
to exactly determine which path is taken more often.
Chapter 3: GCC Command Options 143

-fprofile-values
If combined with ‘-fprofile-arcs’, it adds code so that some data about
values of expressions in the program is gathered.
With ‘-fbranch-probabilities’, it reads back the data gathered from profil-
ing values of expressions for usage in optimizations.
Enabled with ‘-fprofile-generate’ and ‘-fprofile-use’.
-fprofile-reorder-functions
Function reordering based on profile instrumentation collects first time of exe-
cution of a function and orders these functions in ascending order.
Enabled with ‘-fprofile-use’.
-fvpt If combined with ‘-fprofile-arcs’, this option instructs the compiler to add
code to gather information about values of expressions.
With ‘-fbranch-probabilities’, it reads back the data gathered and actually
performs the optimizations based on them. Currently the optimizations include
specialization of division operations using the knowledge about the value of the
denominator.
-frename-registers
Attempt to avoid false dependencies in scheduled code by making use of registers
left over after register allocation. This optimization most benefits processors
with lots of registers. Depending on the debug information format adopted by
the target, however, it can make debugging impossible, since variables no longer
stay in a “home register”.
Enabled by default with ‘-funroll-loops’.
-fschedule-fusion
Performs a target dependent pass over the instruction stream to schedule in-
structions of same type together because target machine can execute them more
efficiently if they are adjacent to each other in the instruction flow.
Enabled at levels ‘-O2’, ‘-O3’, ‘-Os’.
-ftracer Perform tail duplication to enlarge superblock size. This transformation simpli-
fies the control flow of the function allowing other optimizations to do a better
job.
Enabled with ‘-fprofile-use’.
-funroll-loops
Unroll loops whose number of iterations can be determined at compile time or
upon entry to the loop. ‘-funroll-loops’ implies ‘-frerun-cse-after-loop’,
‘-fweb’ and ‘-frename-registers’. It also turns on complete loop peeling (i.e.
complete removal of loops with a small constant number of iterations). This
option makes code larger, and may or may not make it run faster.
Enabled with ‘-fprofile-use’.
-funroll-all-loops
Unroll all loops, even if their number of iterations is uncertain when the loop is
entered. This usually makes programs run more slowly. ‘-funroll-all-loops’
implies the same options as ‘-funroll-loops’.
144 Using the GNU Compiler Collection (GCC)

-fpeel-loops
Peels loops for which there is enough information that they do not roll much
(from profile feedback or static analysis). It also turns on complete loop peeling
(i.e. complete removal of loops with small constant number of iterations).
Enabled with ‘-O3’ and/or ‘-fprofile-use’.
-fmove-loop-invariants
Enables the loop invariant motion pass in the RTL loop optimizer. Enabled at
level ‘-O1’
-fsplit-loops
Split a loop into two if it contains a condition that’s always true for one side of
the iteration space and false for the other.
-funswitch-loops
Move branches with loop invariant conditions out of the loop, with duplicates
of the loop on both branches (modified according to result of the condition).
-ffunction-sections
-fdata-sections
Place each function or data item into its own section in the output file if the
target supports arbitrary sections. The name of the function or the name of
the data item determines the section’s name in the output file.
Use these options on systems where the linker can perform optimizations to
improve locality of reference in the instruction space. Most systems using the
ELF object format and SPARC processors running Solaris 2 have linkers with
such optimizations. AIX may have these optimizations in the future.
Only use these options when there are significant benefits from doing so. When
you specify these options, the assembler and linker create larger object and
executable files and are also slower. You cannot use gprof on all systems if you
specify this option, and you may have problems with debugging if you specify
both this option and ‘-g’.
-fbranch-target-load-optimize
Perform branch target register load optimization before prologue / epilogue
threading. The use of target registers can typically be exposed only during
reload, thus hoisting loads out of loops and doing inter-block scheduling needs
a separate optimization pass.
-fbranch-target-load-optimize2
Perform branch target register load optimization after prologue / epilogue
threading.
-fbtr-bb-exclusive
When performing branch target register load optimization, don’t reuse branch
target registers within any basic block.
-fstdarg-opt
Optimize the prologue of variadic argument functions with respect to usage of
those arguments.
Chapter 3: GCC Command Options 145

-fsection-anchors
Try to reduce the number of symbolic address calculations by using shared
“anchor” symbols to address nearby objects. This transformation can help to
reduce the number of GOT entries and GOT accesses on some targets.
For example, the implementation of the following function foo:
static int a, b, c;
int foo (void) { return a + b + c; }
usually calculates the addresses of all three variables, but if you compile it with
‘-fsection-anchors’, it accesses the variables from a common anchor point
instead. The effect is similar to the following pseudocode (which isn’t valid C):
int foo (void)
{
register int *xr = &x;
return xr[&a - &x] + xr[&b - &x] + xr[&c - &x];
}
Not all targets support this option.
--param name=value
In some places, GCC uses various constants to control the amount of optimiza-
tion that is done. For example, GCC does not inline functions that contain
more than a certain number of instructions. You can control some of these
constants on the command line using the ‘--param’ option.
The names of specific parameters, and the meaning of the values, are tied to
the internals of the compiler, and are subject to change without notice in future
releases.
In each case, the value is an integer. The allowable choices for name are:
predictable-branch-outcome
When branch is predicted to be taken with probability lower than
this threshold (in percent), then it is considered well predictable.
The default is 10.
max-rtl-if-conversion-insns
RTL if-conversion tries to remove conditional branches around a
block and replace them with conditionally executed instructions.
This parameter gives the maximum number of instructions in a
block which should be considered for if-conversion. The default
is 10, though the compiler will also use other heuristics to decide
whether if-conversion is likely to be profitable.
max-rtl-if-conversion-predictable-cost
max-rtl-if-conversion-unpredictable-cost
RTL if-conversion will try to remove conditional branches around
a block and replace them with conditionally executed instructions.
These parameters give the maximum permissible cost for the
sequence that would be generated by if-conversion depending on
whether the branch is statically determined to be predictable or
not. The units for this parameter are the same as those for the
GCC internal seq cost metric. The compiler will try to provide a
146 Using the GNU Compiler Collection (GCC)

reasonable default for this parameter using the BRANCH COST

target macro.
max-crossjump-edges
The maximum number of incoming edges to consider for cross-
jumping. The algorithm used by ‘-fcrossjumping’ is O(N 2 ) in
the number of edges incoming to each block. Increasing values
mean more aggressive optimization, making the compilation time
increase with probably small improvement in executable size.
min-crossjump-insns
The minimum number of instructions that must be matched at the
end of two blocks before cross-jumping is performed on them. This
value is ignored in the case where all instructions in the block being
cross-jumped from are matched. The default value is 5.
max-grow-copy-bb-insns
The maximum code size expansion factor when copying basic blocks
instead of jumping. The expansion is relative to a jump instruction.
The default value is 8.
max-goto-duplication-insns
The maximum number of instructions to duplicate to a block that
jumps to a computed goto. To avoid O(N 2 ) behavior in a number
of passes, GCC factors computed gotos early in the compilation
process, and unfactors them as late as possible. Only computed
jumps at the end of a basic blocks with no more than max-goto-
duplication-insns are unfactored. The default value is 8.
max-delay-slot-insn-search
The maximum number of instructions to consider when looking for
an instruction to fill a delay slot. If more than this arbitrary number
of instructions are searched, the time savings from filling the delay
slot are minimal, so stop searching. Increasing values mean more
aggressive optimization, making the compilation time increase with
probably small improvement in execution time.
max-delay-slot-live-search
When trying to fill delay slots, the maximum number of instruc-
tions to consider when searching for a block with valid live register
information. Increasing this arbitrarily chosen value means more
aggressive optimization, increasing the compilation time. This pa-
rameter should be removed when the delay slot code is rewritten
to maintain the control-flow graph.
max-gcse-memory
The approximate maximum amount of memory that can be allo-
cated in order to perform the global common subexpression elim-
ination optimization. If more memory than specified is required,
the optimization is not done.
Chapter 3: GCC Command Options 147

max-gcse-insertion-ratio
If the ratio of expression insertions to deletions is larger than this
value for any expression, then RTL PRE inserts or removes the
expression and thus leaves partially redundant computations in the
instruction stream. The default value is 20.

max-pending-list-length
The maximum number of pending dependencies scheduling allows
before flushing the current state and starting over. Large functions
with few branches or calls can create excessively large lists which
needlessly consume memory and resources.

max-modulo-backtrack-attempts
The maximum number of backtrack attempts the scheduler should
make when modulo scheduling a loop. Larger values can exponen-
tially increase compilation time.

max-inline-insns-single
Several parameters control the tree inliner used in GCC. This num-
ber sets the maximum number of instructions (counted in GCC’s
internal representation) in a single function that the tree inliner
considers for inlining. This only affects functions declared inline
and methods implemented in a class declaration (C++). The de-
fault value is 400.

max-inline-insns-auto
When you use ‘-finline-functions’ (included in ‘-O3’), a lot of
functions that would otherwise not be considered for inlining by
the compiler are investigated. To those functions, a different (more
restrictive) limit compared to functions declared inline can be ap-
plied. The default value is 40.

inline-min-speedup
When estimated performance improvement of caller + callee run-
time exceeds this threshold (in percent), the function can be inlined
regardless of the limit on ‘--param max-inline-insns-single’
and ‘--param max-inline-insns-auto’.

large-function-insns
The limit specifying really large functions. For functions larger
than this limit after inlining, inlining is constrained by ‘--param
large-function-growth’. This parameter is useful primarily to
avoid extreme compilation time caused by non-linear algorithms
used by the back end. The default value is 2700.

large-function-growth
Specifies maximal growth of large function caused by inlining in per-
cents. The default value is 100 which limits large function growth
to 2.0 times the original size.
148 Using the GNU Compiler Collection (GCC)

large-unit-insns
The limit specifying large translation unit. Growth caused by
inlining of units larger than this limit is limited by ‘--param
inline-unit-growth’. For small units this might be too tight.
For example, consider a unit consisting of function A that is
inline and B that just calls A three times. If B is small relative
to A, the growth of unit is 300\% and yet such inlining is
very sane. For very large units consisting of small inlineable
functions, however, the overall unit growth limit is needed to avoid
exponential explosion of code size. Thus for smaller units, the
size is increased to ‘--param large-unit-insns’ before applying
‘--param inline-unit-growth’. The default is 10000.
inline-unit-growth
Specifies maximal overall growth of the compilation unit caused by
inlining. The default value is 20 which limits unit growth to 1.2
times the original size. Cold functions (either marked cold via an
attribute or by profile feedback) are not accounted into the unit
size.
ipcp-unit-growth
Specifies maximal overall growth of the compilation unit caused
by interprocedural constant propagation. The default value is 10
which limits unit growth to 1.1 times the original size.
large-stack-frame
The limit specifying large stack frames. While inlining the algo-
rithm is trying to not grow past this limit too much. The default
value is 256 bytes.
large-stack-frame-growth
Specifies maximal growth of large stack frames caused by inlining in
percents. The default value is 1000 which limits large stack frame
growth to 11 times the original size.
max-inline-insns-recursive
max-inline-insns-recursive-auto
Specifies the maximum number of instructions an out-of-line copy of
a self-recursive inline function can grow into by performing recursive
inlining.
‘--param max-inline-insns-recursive’ applies to functions de-
clared inline. For functions not declared inline, recursive inlin-
ing happens only when ‘-finline-functions’ (included in ‘-O3’)
is enabled; ‘--param max-inline-insns-recursive-auto’ applies
instead. The default value is 450.
max-inline-recursive-depth
max-inline-recursive-depth-auto
Specifies the maximum recursion depth used for recursive inlining.
Chapter 3: GCC Command Options 149

‘--param max-inline-recursive-depth’ applies to functions de-

clared inline. For functions not declared inline, recursive inlin-
ing happens only when ‘-finline-functions’ (included in ‘-O3’)
is enabled; ‘--param max-inline-recursive-depth-auto’ applies
instead. The default value is 8.
min-inline-recursive-probability
Recursive inlining is profitable only for function having deep re-
cursion in average and can hurt for function having little recursion
depth by increasing the prologue size or complexity of function
body to other optimizers.
When profile feedback is available (see ‘-fprofile-generate’) the
actual recursion depth can be guessed from the probability that
function recurses via a given call expression. This parameter limits
inlining only to call expressions whose probability exceeds the given
threshold (in percents). The default value is 10.
early-inlining-insns
Specify growth that the early inliner can make. In effect it increases
the amount of inlining for code having a large abstraction penalty.
The default value is 14.
max-early-inliner-iterations
Limit of iterations of the early inliner. This basically bounds the
number of nested indirect calls the early inliner can resolve. Deeper
chains are still handled by late inlining.
comdat-sharing-probability
Probability (in percent) that C++ inline function with comdat vis-
ibility are shared across multiple compilation units. The default
value is 20.
profile-func-internal-id
A parameter to control whether to use function internal id in profile
database lookup. If the value is 0, the compiler uses an id that
is based on function assembler name and filename, which makes
old profile data more tolerant to source changes such as function
reordering etc. The default value is 0.
min-vect-loop-bound
The minimum number of iterations under which loops are not vec-
torized when ‘-ftree-vectorize’ is used. The number of itera-
tions after vectorization needs to be greater than the value specified
by this option to allow vectorization. The default value is 0.
gcse-cost-distance-ratio
Scaling factor in calculation of maximum distance an expression can
be moved by GCSE optimizations. This is currently supported only
in the code hoisting pass. The bigger the ratio, the more aggres-
sive code hoisting is with simple expressions, i.e., the expressions
150 Using the GNU Compiler Collection (GCC)

that have cost less than ‘gcse-unrestricted-cost’. Specifying 0

disables hoisting of simple expressions. The default value is 10.

gcse-unrestricted-cost
Cost, roughly measured as the cost of a single typical machine
instruction, at which GCSE optimizations do not constrain the dis-
tance an expression can travel. This is currently supported only
in the code hoisting pass. The lesser the cost, the more aggres-
sive code hoisting is. Specifying 0 allows all expressions to travel
unrestricted distances. The default value is 3.

max-hoist-depth
The depth of search in the dominator tree for expressions to hoist.
This is used to avoid quadratic behavior in hoisting algorithm. The
value of 0 does not limit on the search, but may slow down compi-
lation of huge functions. The default value is 30.

max-tail-merge-comparisons
The maximum amount of similar bbs to compare a bb with. This is
used to avoid quadratic behavior in tree tail merging. The default
value is 10.

max-tail-merge-iterations
The maximum amount of iterations of the pass over the function.
This is used to limit compilation time in tree tail merging. The
default value is 2.

store-merging-allow-unaligned
Allow the store merging pass to introduce unaligned stores if it is
legal to do so. The default value is 1.

max-stores-to-merge
The maximum number of stores to attempt to merge into wider
stores in the store merging pass. The minimum value is 2 and the
default is 64.

max-unrolled-insns
The maximum number of instructions that a loop may have to be
unrolled. If a loop is unrolled, this parameter also determines how
many times the loop code is unrolled.

max-average-unrolled-insns
The maximum number of instructions biased by probabilities of
their execution that a loop may have to be unrolled. If a loop is
unrolled, this parameter also determines how many times the loop
code is unrolled.

max-unroll-times
The maximum number of unrollings of a single loop.
Chapter 3: GCC Command Options 151

max-peeled-insns
The maximum number of instructions that a loop may have to be
peeled. If a loop is peeled, this parameter also determines how
many times the loop code is peeled.
max-peel-times
The maximum number of peelings of a single loop.
max-peel-branches
The maximum number of branches on the hot path through the
peeled sequence.
max-completely-peeled-insns
The maximum number of insns of a completely peeled loop.
max-completely-peel-times
The maximum number of iterations of a loop to be suitable for
complete peeling.
max-completely-peel-loop-nest-depth
The maximum depth of a loop nest suitable for complete peeling.
max-unswitch-insns
The maximum number of insns of an unswitched loop.
max-unswitch-level
The maximum number of branches unswitched in a single loop.
max-loop-headers-insns
The maximum number of insns in loop header duplicated by the
copy loop headers pass.
lim-expensive
The minimum cost of an expensive expression in the loop invariant
motion.
iv-consider-all-candidates-bound
Bound on number of candidates for induction variables, below
which all candidates are considered for each use in induction
variable optimizations. If there are more candidates than this,
only the most relevant ones are considered to avoid quadratic time
complexity.
iv-max-considered-uses
The induction variable optimizations give up on loops that contain
more induction variable uses.
iv-always-prune-cand-set-bound
If the number of candidates in the set is smaller than this value,
always try to remove unnecessary ivs from the set when adding a
new one.
avg-loop-niter
Average number of iterations of a loop.
152 Using the GNU Compiler Collection (GCC)

dse-max-object-size
Maximum size (in bytes) of objects tracked bytewise by dead store
elimination. Larger values may result in larger compilation times.
scev-max-expr-size
Bound on size of expressions used in the scalar evolutions analyzer.
Large expressions slow the analyzer.
scev-max-expr-complexity
Bound on the complexity of the expressions in the scalar evolutions
analyzer. Complex expressions slow the analyzer.
max-tree-if-conversion-phi-args
Maximum number of arguments in a PHI supported by TREE if
conversion unless the loop is marked with simd pragma.
vect-max-version-for-alignment-checks
The maximum number of run-time checks that can be performed
when doing loop versioning for alignment in the vectorizer.
vect-max-version-for-alias-checks
The maximum number of run-time checks that can be performed
when doing loop versioning for alias in the vectorizer.
vect-max-peeling-for-alignment
The maximum number of loop peels to enhance access alignment
for vectorizer. Value -1 means no limit.
max-iterations-to-track
The maximum number of iterations of a loop the brute-force algo-
rithm for analysis of the number of iterations of the loop tries to
evaluate.
hot-bb-count-ws-permille
A basic block profile count is considered hot if it contributes to the
given permillage (i.e. 0...1000) of the entire profiled execution.
hot-bb-frequency-fraction
Select fraction of the entry block frequency of executions of basic
block in function given basic block needs to have to be considered
hot.
max-predicted-iterations
The maximum number of loop iterations we predict statically. This
is useful in cases where a function contains a single loop with known
bound and another loop with unknown bound. The known number
of iterations is predicted correctly, while the unknown number of
iterations average to roughly 10. This means that the loop without
bounds appears artificially cold relative to the other one.
builtin-expect-probability
Control the probability of the expression having the specified value.
This parameter takes a percentage (i.e. 0 ... 100) as input. The
default probability of 90 is obtained empirically.
Chapter 3: GCC Command Options 153

align-threshold
Select fraction of the maximal frequency of executions of a basic
block in a function to align the basic block.
align-loop-iterations
A loop expected to iterate at least the selected number of iterations
is aligned.
tracer-dynamic-coverage
tracer-dynamic-coverage-feedback
This value is used to limit superblock formation once the given per-
centage of executed instructions is covered. This limits unnecessary
code size expansion.
The ‘tracer-dynamic-coverage-feedback’ parameter is used
only when profile feedback is available. The real profiles (as
opposed to statically estimated ones) are much less balanced
allowing the threshold to be larger value.
tracer-max-code-growth
Stop tail duplication once code growth has reached given percent-
age. This is a rather artificial limit, as most of the duplicates are
eliminated later in cross jumping, so it may be set to much higher
values than is the desired code growth.
tracer-min-branch-ratio
Stop reverse growth when the reverse probability of best edge is
less than this threshold (in percent).
tracer-min-branch-probability
tracer-min-branch-probability-feedback
Stop forward growth if the best edge has probability lower than
this threshold.
Similarly to ‘tracer-dynamic-coverage’ two parameters are
provided. ‘tracer-min-branch-probability-feedback’
is used for compilation with profile feedback and
‘tracer-min-branch-probability’ compilation without.
The value for compilation with profile feedback needs to be more
conservative (higher) in order to make tracer effective.
max-cse-path-length
The maximum number of basic blocks on path that CSE considers.
The default is 10.
max-cse-insns
The maximum number of instructions CSE processes before flush-
ing. The default is 1000.
ggc-min-expand
GCC uses a garbage collector to manage its own memory alloca-
tion. This parameter specifies the minimum percentage by which
the garbage collector’s heap should be allowed to expand between
154 Using the GNU Compiler Collection (GCC)

collections. Tuning this may improve compilation speed; it has no

effect on code generation.
The default is 30% + 70% * (RAM/1GB) with an upper bound
of 100% when RAM >= 1GB. If getrlimit is available, the no-
tion of “RAM” is the smallest of actual RAM and RLIMIT_DATA or
RLIMIT_AS. If GCC is not able to calculate RAM on a particular
platform, the lower bound of 30% is used. Setting this parameter
and ‘ggc-min-heapsize’ to zero causes a full collection to occur
at every opportunity. This is extremely slow, but can be useful for
debugging.

ggc-min-heapsize
Minimum size of the garbage collector’s heap before it begins
bothering to collect garbage. The first collection occurs after the
heap expands by ‘ggc-min-expand’% beyond ‘ggc-min-heapsize’.
Again, tuning this may improve compilation speed, and has no
effect on code generation.
The default is the smaller of RAM/8, RLIMIT RSS, or a limit
that tries to ensure that RLIMIT DATA or RLIMIT AS are not
exceeded, but with a lower bound of 4096 (four megabytes) and
an upper bound of 131072 (128 megabytes). If GCC is not able
to calculate RAM on a particular platform, the lower bound is
used. Setting this parameter very large effectively disables garbage
collection. Setting this parameter and ‘ggc-min-expand’ to zero
causes a full collection to occur at every opportunity.

max-reload-search-insns
The maximum number of instruction reload should look backward
for equivalent register. Increasing values mean more aggressive op-
timization, making the compilation time increase with probably
slightly better performance. The default value is 100.

max-cselib-memory-locations
The maximum number of memory locations cselib should take into
account. Increasing values mean more aggressive optimization,
making the compilation time increase with probably slightly better
performance. The default value is 500.

max-sched-ready-insns
The maximum number of instructions ready to be issued the sched-
uler should consider at any given time during the first scheduling
pass. Increasing values mean more thorough searches, making the
compilation time increase with probably little benefit. The default
value is 100.

max-sched-region-blocks
The maximum number of blocks in a region to be considered for
interblock scheduling. The default value is 10.
Chapter 3: GCC Command Options 155

max-pipeline-region-blocks
The maximum number of blocks in a region to be considered for
pipelining in the selective scheduler. The default value is 15.
max-sched-region-insns
The maximum number of insns in a region to be considered for
interblock scheduling. The default value is 100.
max-pipeline-region-insns
The maximum number of insns in a region to be considered for
pipelining in the selective scheduler. The default value is 200.
min-spec-prob
The minimum probability (in percents) of reaching a source block
for interblock speculative scheduling. The default value is 40.
max-sched-extend-regions-iters
The maximum number of iterations through CFG to extend regions.
A value of 0 (the default) disables region extensions.
max-sched-insn-conflict-delay
The maximum conflict delay for an insn to be considered for spec-
ulative motion. The default value is 3.
sched-spec-prob-cutoff
The minimal probability of speculation success (in percents), so
that speculative insns are scheduled. The default value is 40.
sched-state-edge-prob-cutoff
The minimum probability an edge must have for the scheduler to
save its state across it. The default value is 10.
sched-mem-true-dep-cost
Minimal distance (in CPU cycles) between store and load targeting
same memory locations. The default value is 1.
selsched-max-lookahead
The maximum size of the lookahead window of selective scheduling.
It is a depth of search for available instructions. The default value
is 50.
selsched-max-sched-times
The maximum number of times that an instruction is scheduled
during selective scheduling. This is the limit on the number of
iterations through which the instruction may be pipelined. The
default value is 2.
selsched-insns-to-rename
The maximum number of best instructions in the ready list that
are considered for renaming in the selective scheduler. The default
value is 2.
sms-min-sc
The minimum value of stage count that swing modulo scheduler
generates. The default value is 2.
156 Using the GNU Compiler Collection (GCC)

max-last-value-rtl
The maximum size measured as number of RTLs that can be
recorded in an expression in combiner for a pseudo register as last
known value of that register. The default is 10000.
max-combine-insns
The maximum number of instructions the RTL combiner tries to
combine. The default value is 2 at ‘-Og’ and 4 otherwise.
integer-share-limit
Small integer constants can use a shared data structure, reducing
the compiler’s memory usage and increasing its speed. This sets
the maximum value of a shared integer constant. The default value
is 256.
ssp-buffer-size
The minimum size of buffers (i.e. arrays) that receive stack smash-
ing protection when ‘-fstack-protection’ is used.
min-size-for-stack-sharing
The minimum size of variables taking part in stack slot sharing
when not optimizing. The default value is 32.
max-jump-thread-duplication-stmts
Maximum number of statements allowed in a block that needs to
be duplicated when threading jumps.
max-fields-for-field-sensitive
Maximum number of fields in a structure treated in a field sensitive
manner during pointer analysis. The default is zero for ‘-O0’ and
‘-O1’, and 100 for ‘-Os’, ‘-O2’, and ‘-O3’.
prefetch-latency
Estimate on average number of instructions that are executed be-
fore prefetch finishes. The distance prefetched ahead is propor-
tional to this constant. Increasing this number may also lead to
less streams being prefetched (see ‘simultaneous-prefetches’).
simultaneous-prefetches
Maximum number of prefetches that can run at the same time.
l1-cache-line-size
The size of cache line in L1 cache, in bytes.
l1-cache-size
The size of L1 cache, in kilobytes.
l2-cache-size
The size of L2 cache, in kilobytes.
min-insn-to-prefetch-ratio
The minimum ratio between the number of instructions and the
number of prefetches to enable prefetching in a loop.
Chapter 3: GCC Command Options 157

prefetch-min-insn-to-mem-ratio
The minimum ratio between the number of instructions and the
number of memory references to enable prefetching in a loop.
use-canonical-types
Whether the compiler should use the “canonical” type system. By
default, this should always be 1, which uses a more efficient internal
mechanism for comparing types in C++ and Objective-C++. How-
ever, if bugs in the canonical type system are causing compilation
failures, set this value to 0 to disable canonical types.
switch-conversion-max-branch-ratio
Switch initialization conversion refuses to create arrays that are big-
ger than ‘switch-conversion-max-branch-ratio’ times the num-
ber of branches in the switch.
max-partial-antic-length
Maximum length of the partial antic set computed during the tree
partial redundancy elimination optimization (‘-ftree-pre’) when
optimizing at ‘-O3’ and above. For some sorts of source code the en-
hanced partial redundancy elimination optimization can run away,
consuming all of the memory available on the host machine. This
parameter sets a limit on the length of the sets that are computed,
which prevents the runaway behavior. Setting a value of 0 for this
parameter allows an unlimited set length.
sccvn-max-scc-size
Maximum size of a strongly connected component (SCC) during
SCCVN processing. If this limit is hit, SCCVN processing for the
whole function is not done and optimizations depending on it are
disabled. The default maximum SCC size is 10000.
sccvn-max-alias-queries-per-access
Maximum number of alias-oracle queries we perform when looking
for redundancies for loads and stores. If this limit is hit the search
is aborted and the load or store is not considered redundant. The
number of queries is algorithmically limited to the number of stores
on all paths from the load to the function entry. The default max-
imum number of queries is 1000.
ira-max-loops-num
IRA uses regional register allocation by default. If a function con-
tains more loops than the number given by this parameter, only at
most the given number of the most frequently-executed loops form
regions for regional register allocation. The default value of the
parameter is 100.
ira-max-conflict-table-size
Although IRA uses a sophisticated algorithm to compress the con-
flict table, the table can still require excessive amounts of memory
for huge functions. If the conflict table for a function could be more
158 Using the GNU Compiler Collection (GCC)

than the size in MB given by this parameter, the register allocator

instead uses a faster, simpler, and lower-quality algorithm that does
not require building a pseudo-register conflict table. The default
value of the parameter is 2000.
ira-loop-reserved-regs
IRA can be used to evaluate more accurate register pressure in
loops for decisions to move loop invariants (see ‘-O3’). The number
of available registers reserved for some other purposes is given by
this parameter. The default value of the parameter is 2, which
is the minimal number of registers needed by typical instructions.
This value is the best found from numerous experiments.
lra-inheritance-ebb-probability-cutoff
LRA tries to reuse values reloaded in registers in subsequent insns.
This optimization is called inheritance. EBB is used as a region to
do this optimization. The parameter defines a minimal fall-through
edge probability in percentage used to add BB to inheritance EBB
in LRA. The default value of the parameter is 40. The value was
chosen from numerous runs of SPEC2000 on x86-64.
loop-invariant-max-bbs-in-loop
Loop invariant motion can be very expensive, both in compilation
time and in amount of needed compile-time memory, with very
large loops. Loops with more basic blocks than this parameter
won’t have loop invariant motion optimization performed on them.
The default value of the parameter is 1000 for ‘-O1’ and 10000 for
‘-O2’ and above.
loop-max-datarefs-for-datadeps
Building data dependencies is expensive for very large loops. This
parameter limits the number of data references in loops that are
considered for data dependence analysis. These large loops are no
handled by the optimizations using loop data dependencies. The
default value is 1000.
max-vartrack-size
Sets a maximum number of hash table slots to use during variable
tracking dataflow analysis of any function. If this limit is exceeded
with variable tracking at assignments enabled, analysis for that
function is retried without it, after removing all debug insns from
the function. If the limit is exceeded even without debug insns, var
tracking analysis is completely disabled for the function. Setting
the parameter to zero makes it unlimited.
max-vartrack-expr-depth
Sets a maximum number of recursion levels when attempting to
map variable names or debug temporaries to value expressions.
This trades compilation time for more complete debug information.
If this is set too low, value expressions that are available and could
Chapter 3: GCC Command Options 159

be represented in debug information may end up not being used;

setting this higher may enable the compiler to find more complex
debug expressions, but compile time and memory use may grow.
The default is 12.
min-nondebug-insn-uid
Use uids starting at this parameter for nondebug insns. The range
below the parameter is reserved exclusively for debug insns created
by ‘-fvar-tracking-assignments’, but debug insns may get (non-
overlapping) uids above it if the reserved range is exhausted.
ipa-sra-ptr-growth-factor
IPA-SRA replaces a pointer to an aggregate with one or more
new parameters only when their cumulative size is less or equal
to ‘ipa-sra-ptr-growth-factor’ times the size of the original
pointer parameter.
sra-max-scalarization-size-Ospeed
sra-max-scalarization-size-Osize
The two Scalar Reduction of Aggregates passes (SRA and
IPA-SRA) aim to replace scalar parts of aggregates with
uses of independent scalar variables. These parameters
control the maximum size, in storage units, of aggregate
which is considered for replacement when compiling for
speed (‘sra-max-scalarization-size-Ospeed’) or size
(‘sra-max-scalarization-size-Osize’) respectively.
tm-max-aggregate-size
When making copies of thread-local variables in a transaction, this
parameter specifies the size in bytes after which variables are saved
with the logging functions as opposed to save/restore code sequence
pairs. This option only applies when using ‘-fgnu-tm’.
graphite-max-nb-scop-params
To avoid exponential effects in the Graphite loop transforms, the
number of parameters in a Static Control Part (SCoP) is bounded.
The default value is 10 parameters. A variable whose value is un-
known at compilation time and defined outside a SCoP is a param-
eter of the SCoP.
graphite-max-bbs-per-function
To avoid exponential effects in the detection of SCoPs, the size of
the functions analyzed by Graphite is bounded. The default value
is 100 basic blocks.
loop-block-tile-size
Loop blocking or strip mining transforms, enabled with
‘-floop-block’ or ‘-floop-strip-mine’, strip mine each loop in
the loop nest by a given number of iterations. The strip length
can be changed using the ‘loop-block-tile-size’ parameter.
The default value is 51 iterations.
160 Using the GNU Compiler Collection (GCC)

loop-unroll-jam-size
Specify the unroll factor for the ‘-floop-unroll-and-jam’ option.
The default value is 4.

loop-unroll-jam-depth
Specify the dimension to be unrolled (counting from the most inner
loop) for the ‘-floop-unroll-and-jam’. The default value is 2.

ipa-cp-value-list-size
IPA-CP attempts to track all possible values and types passed to a
function’s parameter in order to propagate them and perform devir-
tualization. ‘ipa-cp-value-list-size’ is the maximum number
of values and types it stores per one formal parameter of a function.

ipa-cp-eval-threshold
IPA-CP calculates its own score of cloning profitability heuristics
and performs those cloning opportunities with scores that exceed
‘ipa-cp-eval-threshold’.

ipa-cp-recursion-penalty
Percentage penalty the recursive functions will receive when they
are evaluated for cloning.

ipa-cp-single-call-penalty
Percentage penalty functions containing a single call to another
function will receive when they are evaluated for cloning.

ipa-max-agg-items
IPA-CP is also capable to propagate a number of scalar values
passed in an aggregate. ‘ipa-max-agg-items’ controls the maxi-
mum number of such values per one parameter.

ipa-cp-loop-hint-bonus
When IPA-CP determines that a cloning candidate would make
the number of iterations of a loop known, it adds a bonus of
‘ipa-cp-loop-hint-bonus’ to the profitability score of the
candidate.

ipa-cp-array-index-hint-bonus
When IPA-CP determines that a cloning candidate would
make the index of an array access known, it adds a bonus of
‘ipa-cp-array-index-hint-bonus’ to the profitability score of
the candidate.

ipa-max-aa-steps
During its analysis of function bodies, IPA-CP employs alias
analysis in order to track values pointed to by function parameters.
In order not spend too much time analyzing huge functions, it
gives up and consider all memory clobbered after examining
‘ipa-max-aa-steps’ statements modifying memory.
Chapter 3: GCC Command Options 161

lto-partitions
Specify desired number of partitions produced during WHOPR
compilation. The number of partitions should exceed the number
of CPUs used for compilation. The default value is 32.
lto-min-partition
Size of minimal partition for WHOPR (in estimated instructions).
This prevents expenses of splitting very small programs into too
many partitions.
lto-max-partition
Size of max partition for WHOPR (in estimated instructions). to
provide an upper bound for individual size of partition. Meant to
be used only with balanced partitioning.
cxx-max-namespaces-for-diagnostic-help
The maximum number of namespaces to consult for suggestions
when C++ name lookup fails for an identifier. The default is 1000.
sink-frequency-threshold
The maximum relative execution frequency (in percents) of the tar-
get block relative to a statement’s original block to allow statement
sinking of a statement. Larger numbers result in more aggressive
statement sinking. The default value is 75. A small positive ad-
justment is applied for statements with memory operands as those
are even more profitable so sink.
max-stores-to-sink
The maximum number of conditional store pairs that can be
sunk. Set to 0 if either vectorization (‘-ftree-vectorize’)
or if-conversion (‘-ftree-loop-if-convert’) is disabled. The
default is 2.
allow-store-data-races
Allow optimizers to introduce new data races on stores. Set to
1 to allow, otherwise to 0. This option is enabled by default at
optimization level ‘-Ofast’.
case-values-threshold
The smallest number of different values for which it is best to use
a jump-table instead of a tree of conditional branches. If the value
is 0, use the default for the machine. The default is 0.
tree-reassoc-width
Set the maximum number of instructions executed in parallel in re-
associated tree. This parameter overrides target dependent heuris-
tics used by default if has non zero value.
sched-pressure-algorithm
Choose between the two available implementations of
‘-fsched-pressure’. Algorithm 1 is the original implementation
and is the more likely to prevent instructions from being reordered.
162 Using the GNU Compiler Collection (GCC)

Algorithm 2 was designed to be a compromise between the

relatively conservative approach taken by algorithm 1 and the
rather aggressive approach taken by the default scheduler. It relies
more heavily on having a regular register file and accurate register
pressure classes. See ‘haifa-sched.c’ in the GCC sources for
more details.
The default choice depends on the target.
max-slsr-cand-scan
Set the maximum number of existing candidates that are consid-
ered when seeking a basis for a new straight-line strength reduction
candidate.
asan-globals
Enable buffer overflow detection for global objects. This
kind of protection is enabled by default if you are using
‘-fsanitize=address’ option. To disable global objects
protection use ‘--param asan-globals=0’.
asan-stack
Enable buffer overflow detection for stack objects. This kind of
protection is enabled by default when using ‘-fsanitize=address’.
To disable stack protection use ‘--param asan-stack=0’ option.
asan-instrument-reads
Enable buffer overflow detection for memory reads. This
kind of protection is enabled by default when using
‘-fsanitize=address’. To disable memory reads protection use
‘--param asan-instrument-reads=0’.
asan-instrument-writes
Enable buffer overflow detection for memory writes. This
kind of protection is enabled by default when using
‘-fsanitize=address’. To disable memory writes protection use
‘--param asan-instrument-writes=0’ option.
asan-memintrin
Enable detection for built-in functions. This kind of protection is
enabled by default when using ‘-fsanitize=address’. To disable
built-in functions protection use ‘--param asan-memintrin=0’.
asan-use-after-return
Enable detection of use-after-return. This kind of protection is
enabled by default when using the ‘-fsanitize=address’ option.
To disable it use ‘--param asan-use-after-return=0’.
Note: By default the check is disabled at run time. To enable it, add
detect_stack_use_after_return=1 to the environment variable
ASAN_OPTIONS.
asan-instrumentation-with-call-threshold
If number of memory accesses in function being instrumented
is greater or equal to this number, use callbacks instead
Chapter 3: GCC Command Options 163

of inline checks. E.g. to disable inline code use ‘--param

asan-instrumentation-with-call-threshold=0’.
use-after-scope-direct-emission-threshold
If the size of a local variable in bytes is smaller or equal to this
number, directly poison (or unpoison) shadow memory instead of
using run-time callbacks. The default value is 256.
chkp-max-ctor-size
Static constructors generated by Pointer Bounds Checker may be-
come very large and significantly increase compile time at optimiza-
tion level ‘-O1’ and higher. This parameter is a maximum number
of statements in a single generated constructor. Default value is
5000.
max-fsm-thread-path-insns
Maximum number of instructions to copy when duplicating blocks
on a finite state automaton jump thread path. The default is 100.
max-fsm-thread-length
Maximum number of basic blocks on a finite state automaton jump
thread path. The default is 10.
max-fsm-thread-paths
Maximum number of new jump thread paths to create for a finite
state automaton. The default is 50.
parloops-chunk-size
Chunk size of omp schedule for loops parallelized by parloops. The
default is 0.
parloops-schedule
Schedule type of omp schedule for loops parallelized by parloops
(static, dynamic, guided, auto, runtime). The default is static.
max-ssa-name-query-depth
Maximum depth of recursion when querying properties of SSA
names in things like fold routines. One level of recursion corre-
sponds to following a use-def chain.
hsa-gen-debug-stores
Enable emission of special debug stores within HSA kernels
which are then read and reported by libgomp plugin. Gen-
eration of these stores is disabled by default, use ‘--param
hsa-gen-debug-stores=1’ to enable it.
max-speculative-devirt-maydefs
The maximum number of may-defs we analyze when looking for a
must-def specifying the dynamic type of an object that invokes a
virtual call we may be able to devirtualize speculatively.
max-vrp-switch-assertions
The maximum number of assertions to add along the default edge
of a switch statement during VRP. The default is 10.
164 Using the GNU Compiler Collection (GCC)

3.11 Program Instrumentation Options

GCC supports a number of command-line options that control adding run-time instrumen-
tation to the code it normally generates. For example, one purpose of instrumentation is
collect profiling statistics for use in finding program hot spots, code coverage analysis, or
profile-guided optimizations. Another class of program instrumentation is adding run-time
checking to detect programming errors like invalid pointer dereferences or out-of-bounds
array accesses, as well as deliberately hostile attacks such as stack smashing or C++ vtable
hijacking. There is also a general hook which can be used to implement other forms of
tracing or function-level instrumentation for debug or program analysis purposes.
-p Generate extra code to write profile information suitable for the analysis pro-
gram prof. You must use this option when compiling the source files you want
data about, and you must also use it when linking.
-pg Generate extra code to write profile information suitable for the analysis pro-
gram gprof. You must use this option when compiling the source files you want
data about, and you must also use it when linking.
-fprofile-arcs
Add code so that program flow arcs are instrumented. During execution the
program records how many times each branch and call is executed and how
many times it is taken or returns. On targets that support constructors with
priority support, profiling properly handles constructors, destructors and C++
constructors (and destructors) of classes which are used as a type of a global
variable.
When the compiled program exits it saves this data to a file called
‘auxname.gcda’ for each source file. The data may be used for profile-directed
optimizations (‘-fbranch-probabilities’), or for test coverage analysis
(‘-ftest-coverage’). Each object file’s auxname is generated from the name
of the output file, if explicitly specified and it is not the final executable,
otherwise it is the basename of the source file. In both cases any suffix is
removed (e.g. ‘foo.gcda’ for input file ‘dir/foo.c’, or ‘dir/foo.gcda’ for
output file specified as ‘-o dir/foo.o’). See Section 10.5 [Cross-profiling],
page 779.
--coverage
This option is used to compile and link code instrumented for coverage analysis.
The option is a synonym for ‘-fprofile-arcs’ ‘-ftest-coverage’ (when com-
piling) and ‘-lgcov’ (when linking). See the documentation for those options
for more details.
• Compile the source files with ‘-fprofile-arcs’ plus optimization and
code generation options. For test coverage analysis, use the additional
‘-ftest-coverage’ option. You do not need to profile every source file in
a program.
• Link your object files with ‘-lgcov’ or ‘-fprofile-arcs’ (the latter implies
the former).
• Run the program on a representative workload to generate the arc profile
information. This may be repeated any number of times. You can run
Chapter 3: GCC Command Options 165

concurrent instances of your program, and provided that the file system
supports locking, the data files will be correctly updated. Unless a strict
ISO C dialect option is in effect, fork calls are detected and correctly
handled without double counting.
• For profile-directed optimizations, compile the source files again
with the same optimization and code generation options plus
‘-fbranch-probabilities’ (see Section 3.10 [Options that Control
Optimization], page 106).
• For test coverage analysis, use gcov to produce human readable information
from the ‘.gcno’ and ‘.gcda’ files. Refer to the gcov documentation for
further information.
With ‘-fprofile-arcs’, for each function of your program GCC creates a
program flow graph, then finds a spanning tree for the graph. Only arcs that
are not on the spanning tree have to be instrumented: the compiler adds code
to count the number of times that these arcs are executed. When an arc is
the only exit or only entrance to a block, the instrumentation code can be
added to the block; otherwise, a new basic block must be created to hold the
instrumentation code.
-ftest-coverage
Produce a notes file that the gcov code-coverage utility (see Chapter 10 [gcov—
a Test Coverage Program], page 771) can use to show program coverage. Each
source file’s note file is called ‘auxname.gcno’. Refer to the ‘-fprofile-arcs’
option above for a description of auxname and instructions on how to generate
test coverage data. Coverage data matches the source files more closely if you
do not optimize.
-fprofile-dir=path
Set the directory to search for the profile data files in to path. This
option affects only the profile data generated by ‘-fprofile-generate’,
‘-ftest-coverage’, ‘-fprofile-arcs’ and used by ‘-fprofile-use’ and
‘-fbranch-probabilities’ and its related options. Both absolute and relative
paths can be used. By default, GCC uses the current directory as path, thus
the profile data file appears in the same directory as the object file.
-fprofile-generate
-fprofile-generate=path
Enable options usually used for instrumenting application to produce profile
useful for later recompilation with profile feedback based optimization. You
must use ‘-fprofile-generate’ both when compiling and when linking your
program.
The following options are enabled: ‘-fprofile-arcs’, ‘-fprofile-values’,
‘-fvpt’.
If path is specified, GCC looks at the path to find the profile feedback data
files. See ‘-fprofile-dir’.
To optimize the program based on the collected profile information, use
‘-fprofile-use’. See Section 3.10 [Optimize Options], page 106, for more
information.
166 Using the GNU Compiler Collection (GCC)

-fprofile-update=method
Alter the update method for an application instrumented for profile feedback
based optimization. The method argument should be one of ‘single’, ‘atomic’
or ‘prefer-atomic’. The first one is useful for single-threaded applications,
while the second one prevents profile corruption by emitting thread-safe code.
Warning: When an application does not properly join all threads (or creates
an detached thread), a profile file can be still corrupted.
Using ‘prefer-atomic’ would be transformed either to ‘atomic’, when sup-
ported by a target, or to ‘single’ otherwise. The GCC driver automatically
selects ‘prefer-atomic’ when ‘-pthread’ is present in the command line.
-fsanitize=address
Enable AddressSanitizer, a fast memory error detector. Memory access
instructions are instrumented to detect out-of-bounds and use-after-free bugs.
The option enables ‘-fsanitize-address-use-after-scope’. See https://
github.com/google/sanitizers/wiki/AddressSanitizer for more details.
The run-time behavior can be influenced using the ASAN_OPTIONS environment
variable. When set to help=1, the available options are shown at startup of
the instrumented program. See https://github.com/google/sanitizers/
wiki / AddressSanitizerFlags # run-time-flags for a list of supported
options. The option cannot be combined with ‘-fsanitize=thread’ and/or
‘-fcheck-pointer-bounds’.
-fsanitize=kernel-address
Enable AddressSanitizer for Linux kernel. See https: / / github . com /
google/kasan/wiki for more details. The option cannot be combined with
‘-fcheck-pointer-bounds’.
-fsanitize=thread
Enable ThreadSanitizer, a fast data race detector. Memory access
instructions are instrumented to detect data race bugs. See https: / /
github . com / google / sanitizers / wiki # threadsanitizer for more
details. The run-time behavior can be influenced using the TSAN_OPTIONS
environment variable; see https: / / github . com / google / sanitizers /
wiki / ThreadSanitizerFlags for a list of supported options. The option
cannot be combined with ‘-fsanitize=address’, ‘-fsanitize=leak’ and/or
‘-fcheck-pointer-bounds’.
Note that sanitized atomic builtins cannot throw exceptions when
operating on invalid memory addresses with non-call exceptions
(‘-fnon-call-exceptions’).
-fsanitize=leak
Enable LeakSanitizer, a memory leak detector. This option only matters for
linking of executables and the executable is linked against a library that over-
rides malloc and other allocator functions. See https://github.com/google/
sanitizers/wiki/AddressSanitizerLeakSanitizer for more details. The
run-time behavior can be influenced using the LSAN_OPTIONS environment vari-
able. The option cannot be combined with ‘-fsanitize=thread’.
Chapter 3: GCC Command Options 167

-fsanitize=undefined
Enable UndefinedBehaviorSanitizer, a fast undefined behavior detector. Var-
ious computations are instrumented to detect undefined behavior at runtime.
Current suboptions are:
-fsanitize=shift
This option enables checking that the result of a shift operation
is not undefined. Note that what exactly is considered
undefined differs slightly between C and C++, as well as between
ISO C90 and C99, etc. This option has two suboptions,
‘-fsanitize=shift-base’ and ‘-fsanitize=shift-exponent’.
-fsanitize=shift-exponent
This option enables checking that the second argument of a shift
operation is not negative and is smaller than the precision of the
promoted first argument.
-fsanitize=shift-base
If the second argument of a shift operation is within range, check
that the result of a shift operation is not undefined. Note that what
exactly is considered undefined differs slightly between C and C++,
as well as between ISO C90 and C99, etc.
-fsanitize=integer-divide-by-zero
Detect integer division by zero as well as INT_MIN / -1 division.
-fsanitize=unreachable
With this option, the compiler turns the __builtin_unreachable
call into a diagnostics message call instead. When reaching the
__builtin_unreachable call, the behavior is undefined.
-fsanitize=vla-bound
This option instructs the compiler to check that the size of a vari-
able length array is positive.
-fsanitize=null
This option enables pointer checking. Particularly, the application
built with this option turned on will issue an error message when
it tries to dereference a NULL pointer, or if a reference (possibly
an rvalue reference) is bound to a NULL pointer, or if a method is
invoked on an object pointed by a NULL pointer.
-fsanitize=return
This option enables return statement checking. Programs built
with this option turned on will issue an error message when the
end of a non-void function is reached without actually returning a
value. This option works in C++ only.
-fsanitize=signed-integer-overflow
This option enables signed integer overflow checking. We check that
the result of +, *, and both unary and binary - does not overflow
in the signed arithmetics. Note, integer promotion rules must be
taken into account. That is, the following is not an overflow:
168 Using the GNU Compiler Collection (GCC)

signed char a = SCHAR_MAX;

a++;

-fsanitize=bounds
This option enables instrumentation of array bounds. Various out
of bounds accesses are detected. Flexible array members, flexible
array member-like arrays, and initializers of variables with static
storage are not instrumented. The option cannot be combined with
‘-fcheck-pointer-bounds’.
-fsanitize=bounds-strict
This option enables strict instrumentation of array bounds. Most
out of bounds accesses are detected, including flexible array mem-
bers and flexible array member-like arrays. Initializers of variables
with static storage are not instrumented. The option cannot be
combined with ‘-fcheck-pointer-bounds’.
-fsanitize=alignment
This option enables checking of alignment of pointers when they are
dereferenced, or when a reference is bound to insufficiently aligned
target, or when a method or constructor is invoked on insufficiently
aligned object.
-fsanitize=object-size
This option enables instrumentation of memory references using the
__builtin_object_size function. Various out of bounds pointer
accesses are detected.
-fsanitize=float-divide-by-zero
Detect floating-point division by zero. Unlike other similar
options, ‘-fsanitize=float-divide-by-zero’ is not enabled by
‘-fsanitize=undefined’, since floating-point division by zero can
be a legitimate way of obtaining infinities and NaNs.
-fsanitize=float-cast-overflow
This option enables floating-point type to integer conversion check-
ing. We check that the result of the conversion does not overflow.
Unlike other similar options, ‘-fsanitize=float-cast-overflow’
is not enabled by ‘-fsanitize=undefined’. This option does not
work well with FE_INVALID exceptions enabled.
-fsanitize=nonnull-attribute
This option enables instrumentation of calls, checking whether null
values are not passed to arguments marked as requiring a non-null
value by the nonnull function attribute.
-fsanitize=returns-nonnull-attribute
This option enables instrumentation of return statements in func-
tions marked with returns_nonnull function attribute, to detect
returning of null values from such functions.
Chapter 3: GCC Command Options 169

-fsanitize=bool
This option enables instrumentation of loads from bool. If a value
other than 0/1 is loaded, a run-time error is issued.
-fsanitize=enum
This option enables instrumentation of loads from an enum type.
If a value outside the range of values for the enum type is loaded,
a run-time error is issued.
-fsanitize=vptr
This option enables instrumentation of C++ member function calls,
member accesses and some conversions between pointers to base
and derived classes, to verify the referenced object has the correct
dynamic type.
While ‘-ftrapv’ causes traps for signed overflows to be emitted,
‘-fsanitize=undefined’ gives a diagnostic message. This currently works
only for the C family of languages.
-fno-sanitize=all
This option disables all previously enabled sanitizers. ‘-fsanitize=all’ is not
allowed, as some sanitizers cannot be used together.
-fasan-shadow-offset=number
This option forces GCC to use custom shadow offset in AddressSanitizer checks.
It is useful for experimenting with different shadow memory layouts in Kernel
AddressSanitizer.
-fsanitize-sections=s1,s2,...
Sanitize global variables in selected user-defined sections. si may contain wild-
cards.
-fsanitize-recover[=opts]
‘-fsanitize-recover=’ controls error recovery mode for sanitizers mentioned
in comma-separated list of opts. Enabling this option for a sanitizer component
causes it to attempt to continue running the program as if no error happened.
This means multiple runtime errors can be reported in a single program run,
and the exit code of the program may indicate success even when errors have
been reported. The ‘-fno-sanitize-recover=’ option can be used to alter
this behavior: only the first detected error is reported and program then exits
with a non-zero exit code.
Currently this feature only works for ‘-fsanitize=undefined’ (and its
suboptions except for ‘-fsanitize=unreachable’ and ‘-fsanitize=return’),
‘-fsanitize=float-cast-overflow’, ‘-fsanitize=float-divide-by-zero’,
‘-fsanitize=bounds-strict’, ‘-fsanitize=kernel-address’ and
‘-fsanitize=address’. For these sanitizers error recovery is turned on by
default, except ‘-fsanitize=address’, for which this feature is experimental.
‘-fsanitize-recover=all’ and ‘-fno-sanitize-recover=all’ is also
accepted, the former enables recovery for all sanitizers that support it, the
latter disables recovery for all sanitizers that support it.
170 Using the GNU Compiler Collection (GCC)

Even if a recovery mode is turned on the compiler side, it needs to be also

enabled on the runtime library side, otherwise the failures are still fatal. The
runtime library defaults to halt_on_error=0 for ThreadSanitizer and Unde-
finedBehaviorSanitizer, while default value for AddressSanitizer is halt_on_
error=1. This can be overridden through setting the halt_on_error flag in
the corresponding environment variable.
Syntax without an explicit opts parameter is deprecated. It is equivalent to
specifying an opts list of:
undefined,float-cast-overflow,float-divide-by-zero,bounds-strict

-fsanitize-address-use-after-scope
Enable sanitization of local variables to detect use-after-scope bugs. The option
sets ‘-fstack-reuse’ to ‘none’.
-fsanitize-undefined-trap-on-error
The ‘-fsanitize-undefined-trap-on-error’ option instructs the compiler to
report undefined behavior using __builtin_trap rather than a libubsan li-
brary routine. The advantage of this is that the libubsan library is not needed
and is not linked in, so this is usable even in freestanding environments.
-fsanitize-coverage=trace-pc
Enable coverage-guided fuzzing code instrumentation. Inserts a call to __
sanitizer_cov_trace_pc into every basic block.
-fbounds-check
For front ends that support it, generate additional code to check that indices
used to access array