Using the GNU Compiler Collection

For gcc version 4.8.2 (GCC)

Richard M. Stallman and the GCC Developer Community

Published by: GNU Press a division of the Free Software Foundation 51 Franklin Street, Fifth Floor Boston, MA 02110-1301 USA

Website: [Link] General: press@[Link] Orders: sales@[Link] Tel 617-542-5942 Fax 617-542-2652

Last printed October 2003 for GCC 3.3.1. Printed copies are available for $45 each. Copyright c 1988-2013 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 FSFs Front-Cover Text is: A GNU Manual (b) The FSFs 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.

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-dened behavior . . . . . . . . . . . . . . . . . . . . . 315 5 C++ Implementation-dened behavior . . . . . . . . . . . . . . . . . . 323 6 Extensions to the C Language Family . . . . . . . . . . . . . . . . . . . 325 7 Extensions to the C++ Language . . . . . . . . . . . . . . . . . . . . . . 647 8 GNU Objective-C features . . . . . . . . . . . . . . . . . . . . . . . . . . . . 661 9 Binary Compatibility . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 677 10 gcova Test Coverage Program . . . . . . . . . . . . . . . . . . . . . . . 681 11 Known Causes of Trouble with GCC . . . . . . . . . . . . . . . . . . . . 689 12 Reporting Bugs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 705 13 How To Get Help with GCC . . . . . . . . . . . . . . . . . . . . . . . . . . 707 14 Contributing to GCC Development . . . . . . . . . . . . . . . . . . . . . 709 Funding Free Software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 711 The GNU Project and GNU/Linux . . . . . . . . . . . . . . . . . . . . . . . . . 713 GNU General Public License . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 715 GNU Free Documentation License . . . . . . . . . . . . . . . . . . . . . . . . . 727 Contributors to GCC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 735 Option Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 751 Keyword Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 769

iii

Table of Contents
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 1 2 Programming Languages Supported by GCC ................................................. 3 Language Standards Supported by GCC . . . . . 5
2.1 2.2 2.3 2.4 2.5 C language . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . C++ language . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Objective-C and Objective-C++ languages . . . . . . . . . . . . . . . . . . . . . Go language . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . References for other languages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 6 7 8 8

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

3.1 Option Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 3.2 Options Controlling the Kind of Output . . . . . . . . . . . . . . . . . . . . . . . 24 3.3 Compiling C++ Programs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 3.4 Options Controlling C Dialect . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 3.5 Options Controlling C++ Dialect . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35 3.6 Options Controlling Objective-C and Objective-C++ Dialects . . 46 3.7 Options to Control Diagnostic Messages Formatting . . . . . . . . . . . 49 3.8 Options to Request or Suppress Warnings . . . . . . . . . . . . . . . . . . . . . 50 3.9 Options for Debugging Your Program or GCC . . . . . . . . . . . . . . . . . 74 3.10 Options That Control Optimization . . . . . . . . . . . . . . . . . . . . . . . . . . 97 3.11 Options Controlling the Preprocessor . . . . . . . . . . . . . . . . . . . . . . . . 148 3.12 Passing Options to the Assembler . . . . . . . . . . . . . . . . . . . . . . . . . . . 159 3.13 Options for Linking . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160 3.14 Options for Directory Search . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163 3.15 Specifying subprocesses and the switches to pass to them . . . . 165 3.16 Specifying Target Machine and Compiler Version . . . . . . . . . . . . 173 3.17 Hardware Models and Congurations . . . . . . . . . . . . . . . . . . . . . . . 173 3.17.1 AArch64 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173 [Link] -march and -mcpu feature modiers . . . . . . . . . . . . . 174 3.17.2 Adapteva Epiphany Options . . . . . . . . . . . . . . . . . . . . . . . . . . . 175 3.17.3 ARM Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177 3.17.4 AVR Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182 [Link] EIND and Devices with more than 128 Ki Bytes of Flash . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186 [Link] Handling of the RAMPD, RAMPX, RAMPY and RAMPZ Special Function Registers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188 [Link] AVR Built-in Macros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188 3.17.5 Blackn Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190 3.17.6 C6X Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193

iv

Using the GNU Compiler Collection (GCC) 3.17.7 CRIS Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.8 CR16 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.9 Darwin Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.10 DEC Alpha Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.11 FR30 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.12 FRV Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.13 GNU/Linux Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.14 H8/300 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.15 HPPA Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.16 Intel 386 and AMD x86-64 Options . . . . . . . . . . . . . . . . . . . 3.17.17 i386 and x86-64 Windows Options . . . . . . . . . . . . . . . . . . . . 3.17.18 IA-64 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.19 LM32 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.20 M32C Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.21 M32R/D Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.22 M680x0 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.23 MCore Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.24 MeP Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.25 MicroBlaze Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.26 MIPS Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.27 MMIX Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.28 MN10300 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.29 Moxie Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.30 PDP-11 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.31 picoChip Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.32 PowerPC Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.33 RL78 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.34 IBM RS/6000 and PowerPC Options . . . . . . . . . . . . . . . . . . 3.17.35 RX Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.36 S/390 and zSeries Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.37 Score Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.38 SH Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.39 Solaris 2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.40 SPARC Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.41 SPU Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.42 Options for System V . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.43 TILE-Gx Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.44 TILEPro Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.45 V850 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.46 VAX Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.47 VMS Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.48 VxWorks Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.49 x86-64 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.50 Xstormy16 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.51 Xtensa Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.17.52 zSeries Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.18 Options for Code Generation Conventions . . . . . . . . . . . . . . . . . . . 3.19 Environment Variables Aecting GCC . . . . . . . . . . . . . . . . . . . . . . 193 195 195 199 203 204 207 208 208 211 226 227 231 231 232 233 238 239 241 242 254 255 256 256 257 258 258 258 272 274 277 278 285 285 290 292 292 293 293 296 296 296 297 297 297 298 298 309

v 3.20 Using Precompiled Headers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311

C Implementation-dened behavior . . . . . . . . 315

4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10 4.11 4.12 4.13 4.14 4.15 4.16 Translation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Environment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Identiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Characters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Integers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Floating point . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Arrays and pointers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Hints . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Structures, unions, enumerations, and bit-elds . . . . . . . . . . . . . . . Qualiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Declarators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Preprocessing directives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Library functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Locale-specic behavior . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315 315 315 316 316 317 318 319 319 320 320 320 320 321 321 321

C++ Implementation-dened behavior . . . . 323

5.1 5.2 Conditionally-supported behavior . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323 Exception handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323

Extensions to the C Language Family . . . . . . 325

6.1 Statements and Declarations in Expressions . . . . . . . . . . . . . . . . . . 6.2 Locally Declared Labels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.3 Labels as Values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.4 Nested Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.5 Constructing Function Calls . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.6 Referring to a Type with typeof . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.7 Conditionals with Omitted Operands . . . . . . . . . . . . . . . . . . . . . . . . . 6.8 128-bit integers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.9 Double-Word Integers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.10 Complex Numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.11 Additional Floating Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.12 Half-Precision Floating Point . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.13 Decimal Floating Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.14 Hex Floats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.15 Fixed-Point Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.16 Named Address Spaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.16.1 AVR Named Address Spaces . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.16.2 M32C Named Address Spaces . . . . . . . . . . . . . . . . . . . . . . . . . . 6.16.3 RL78 Named Address Spaces . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.16.4 SPU Named Address Spaces . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.17 Arrays of Length Zero . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.18 Structures With No Members . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325 326 327 328 330 332 333 334 334 334 335 335 336 336 337 338 338 340 340 340 340 341

vi

Using the GNU Compiler Collection (GCC) 6.19 Arrays of Variable Length . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.20 Macros with a Variable Number of Arguments. . . . . . . . . . . . . . . 6.21 Slightly Looser Rules for Escaped Newlines . . . . . . . . . . . . . . . . . . 6.22 Non-Lvalue Arrays May Have Subscripts . . . . . . . . . . . . . . . . . . . . 6.23 Arithmetic on void- and Function-Pointers . . . . . . . . . . . . . . . . . . 6.24 Non-Constant Initializers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.25 Compound Literals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.26 Designated Initializers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.27 Case Ranges . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.28 Cast to a Union Type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.29 Mixed Declarations and Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.30 Declaring Attributes of Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.31 Attribute Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.32 Prototypes and Old-Style Function Denitions . . . . . . . . . . . . . . 6.33 C++ Style Comments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.34 Dollar Signs in Identier Names . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.35 The Character ESC in Constants . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.36 Specifying Attributes of Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.36.1 AVR Variable Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.36.2 Blackn Variable Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.36.3 M32R/D Variable Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.36.4 MeP Variable Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.36.5 i386 Variable Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.36.6 PowerPC Variable Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.36.7 SPU Variable Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.36.8 Xstormy16 Variable Attributes . . . . . . . . . . . . . . . . . . . . . . . . . 6.37 Specifying Attributes of Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.37.1 ARM Type Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.37.2 MeP Type Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.37.3 i386 Type Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.37.4 PowerPC Type Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.37.5 SPU Type Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.38 Inquiring on Alignment of Types or Variables . . . . . . . . . . . . . . . 6.39 An Inline Function is As Fast As a Macro . . . . . . . . . . . . . . . . . . . 6.40 When is a Volatile Object Accessed? . . . . . . . . . . . . . . . . . . . . . . . . 6.41 Assembler Instructions with C Expression Operands . . . . . . . . . 6.41.1 Size of an asm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.41.2 i386 oating-point asm operands . . . . . . . . . . . . . . . . . . . . . . . 6.42 Constraints for asm Operands . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.42.1 Simple Constraints . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.42.2 Multiple Alternative Constraints . . . . . . . . . . . . . . . . . . . . . . . 6.42.3 Constraint Modier Characters . . . . . . . . . . . . . . . . . . . . . . . . . 6.42.4 Constraints for Particular Machines . . . . . . . . . . . . . . . . . . . . 6.43 Controlling Names Used in Assembler Code . . . . . . . . . . . . . . . . . 6.44 Variables in Specied Registers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.44.1 Dening Global Register Variables . . . . . . . . . . . . . . . . . . . . . 6.44.2 Specifying Registers for Local Variables . . . . . . . . . . . . . . . . 6.45 Alternate Keywords . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342 343 343 344 344 344 344 345 347 347 348 348 378 381 382 382 382 382 387 387 387 388 388 390 390 390 391 395 395 395 396 396 396 397 398 399 405 405 407 407 409 410 411 435 435 436 437 438

vii 6.46 6.47 6.48 6.49 6.50 6.51 Incomplete enum Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 438 Function Names as Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 438 Getting the Return or Frame Address of a Function . . . . . . . . . 439 Using Vector Instructions through Built-in Functions . . . . . . . . 440 Osetof . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 442 Legacy sync Built-in Functions for Atomic Memory Access . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 443 6.52 Built-in functions for memory model aware atomic operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 445 6.53 x86 specic memory model extensions for transactional memory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 449 6.54 Object Size Checking Built-in Functions . . . . . . . . . . . . . . . . . . . . . 449 6.55 Other Built-in Functions Provided by GCC . . . . . . . . . . . . . . . . . 451 6.56 Built-in Functions Specic to Particular Target Machines . . . . 460 6.56.1 Alpha Built-in Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 460 6.56.2 ARM iWMMXt Built-in Functions . . . . . . . . . . . . . . . . . . . . . 461 6.56.3 ARM NEON Intrinsics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464 [Link] Addition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464 [Link] Multiplication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 468 [Link] Multiply-accumulate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 469 [Link] Multiply-subtract . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 470 [Link] Fused-multiply-accumulate . . . . . . . . . . . . . . . . . . . . . . . . 472 [Link] Fused-multiply-subtract . . . . . . . . . . . . . . . . . . . . . . . . . . . 472 [Link] Round to integral (to nearest, ties to even) . . . . . . . . 472 [Link] Round to integral (to nearest, ties away from zero) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 472 [Link] Round to integral (towards +Inf) . . . . . . . . . . . . . . . . . . 472 [Link] Round to integral (towards -Inf) . . . . . . . . . . . . . . . . . 472 [Link] Round to integral (towards 0) . . . . . . . . . . . . . . . . . . . . 472 [Link] Subtraction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 472 [Link] Comparison (equal-to) . . . . . . . . . . . . . . . . . . . . . . . . . . . 476 [Link] Comparison (greater-than-or-equal-to) . . . . . . . . . . . . 477 [Link] Comparison (less-than-or-equal-to) . . . . . . . . . . . . . . . 477 [Link] Comparison (greater-than) . . . . . . . . . . . . . . . . . . . . . . . 478 [Link] Comparison (less-than) . . . . . . . . . . . . . . . . . . . . . . . . . . . 479 [Link] Comparison (absolute greater-than-or-equal-to) . . . 479 [Link] Comparison (absolute less-than-or-equal-to) . . . . . . 480 [Link] Comparison (absolute greater-than) . . . . . . . . . . . . . . 480 [Link] Comparison (absolute less-than) . . . . . . . . . . . . . . . . . . 480 [Link] Test bits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 480 [Link] Absolute dierence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 481 [Link] Absolute dierence and accumulate . . . . . . . . . . . . . . . 482 [Link] Maximum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 483 [Link] Minimum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 483 [Link] Pairwise add . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 484 [Link] Pairwise add, single opcode widen and accumulate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 485 [Link] Folding maximum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 485

viii

Using the GNU Compiler Collection (GCC) [Link] Folding minimum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . [Link] Reciprocal step . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . [Link] Vector shift left . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . [Link] Vector shift left by constant . . . . . . . . . . . . . . . . . . . . . . [Link] Vector shift right by constant . . . . . . . . . . . . . . . . . . . . [Link] Vector shift right by constant and accumulate . . . . [Link] Vector shift right and insert . . . . . . . . . . . . . . . . . . . . . . [Link] Vector shift left and insert . . . . . . . . . . . . . . . . . . . . . . . [Link] Absolute value . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . [Link] Negation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . [Link] Bitwise not . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . [Link] Count leading sign bits . . . . . . . . . . . . . . . . . . . . . . . . . . . [Link] Count leading zeros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . [Link] Count number of set bits . . . . . . . . . . . . . . . . . . . . . . . . . [Link] Reciprocal estimate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . [Link] Reciprocal square-root estimate . . . . . . . . . . . . . . . . . . [Link] Get lanes from a vector . . . . . . . . . . . . . . . . . . . . . . . . . . [Link] Set lanes in a vector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . [Link] Create vector from literal bit pattern . . . . . . . . . . . . . [Link] Set all lanes to the same value . . . . . . . . . . . . . . . . . . . . [Link] Combining vectors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . [Link] Splitting vectors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . [Link] Conversions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . [Link] Move, single opcode narrowing . . . . . . . . . . . . . . . . . . . [Link] Move, single opcode long . . . . . . . . . . . . . . . . . . . . . . . . . [Link] Table lookup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . [Link] Extended table lookup . . . . . . . . . . . . . . . . . . . . . . . . . . . [Link] Multiply, lane . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . [Link] Long multiply, lane . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . [Link] Saturating doubling long multiply, lane . . . . . . . . . . . [Link] Saturating doubling multiply high, lane . . . . . . . . . . [Link] Multiply-accumulate, lane . . . . . . . . . . . . . . . . . . . . . . . . [Link] Multiply-subtract, lane . . . . . . . . . . . . . . . . . . . . . . . . . . . [Link] Vector multiply by scalar . . . . . . . . . . . . . . . . . . . . . . . . . [Link] Vector long multiply by scalar . . . . . . . . . . . . . . . . . . . . [Link] Vector saturating doubling long multiply by scalar ........................................................ [Link] Vector saturating doubling multiply high by scalar ........................................................ [Link] Vector multiply-accumulate by scalar . . . . . . . . . . . . . [Link] Vector multiply-subtract by scalar . . . . . . . . . . . . . . . . [Link] Vector extract . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . [Link] Reverse elements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . [Link] Bit selection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . [Link] Transpose elements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . [Link] Zip elements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . [Link] Unzip elements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . [Link] Element/structure loads, VLD1 variants . . . . . . . . . . 486 486 486 490 492 495 496 497 498 499 500 500 501 501 502 502 502 503 504 505 508 508 509 509 510 511 511 512 512 512 513 513 514 515 515 515 516 516 517 518 519 520 522 523 524 525

ix [Link] Element/structure stores, VST1 variants . . . . . . . . . [Link] Element/structure loads, VLD2 variants . . . . . . . . . . [Link] Element/structure stores, VST2 variants . . . . . . . . . [Link] Element/structure loads, VLD3 variants . . . . . . . . . . [Link] Element/structure stores, VST3 variants . . . . . . . . . [Link] Element/structure loads, VLD4 variants . . . . . . . . . . [Link] Element/structure stores, VST4 variants . . . . . . . . . [Link] Logical operations (AND) . . . . . . . . . . . . . . . . . . . . . . . . [Link] Logical operations (OR) . . . . . . . . . . . . . . . . . . . . . . . . . . [Link] Logical operations (exclusive OR) . . . . . . . . . . . . . . . . [Link] Logical operations (AND-NOT) . . . . . . . . . . . . . . . . . . [Link] Logical operations (OR-NOT) . . . . . . . . . . . . . . . . . . . . [Link] Reinterpret casts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.56.4 AVR Built-in Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.56.5 Blackn Built-in Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.56.6 FR-V Built-in Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . [Link] Argument Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . [Link] Directly-mapped Integer Functions . . . . . . . . . . . . . . . . [Link] Directly-mapped Media Functions . . . . . . . . . . . . . . . . . [Link] Raw read/write Functions . . . . . . . . . . . . . . . . . . . . . . . . . [Link] Other Built-in Functions . . . . . . . . . . . . . . . . . . . . . . . . . . 6.56.7 X86 Built-in Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.56.8 X86 transaction memory intrinsics . . . . . . . . . . . . . . . . . . . . . 6.56.9 MIPS DSP Built-in Functions . . . . . . . . . . . . . . . . . . . . . . . . . . 6.56.10 MIPS Paired-Single Support . . . . . . . . . . . . . . . . . . . . . . . . . . 6.56.11 MIPS Loongson Built-in Functions . . . . . . . . . . . . . . . . . . . . [Link] Paired-Single Arithmetic . . . . . . . . . . . . . . . . . . . . . . . . . [Link] Paired-Single Built-in Functions . . . . . . . . . . . . . . . . . . [Link] MIPS-3D Built-in Functions . . . . . . . . . . . . . . . . . . . . . . 6.56.12 Other MIPS Built-in Functions . . . . . . . . . . . . . . . . . . . . . . . . 6.56.13 picoChip Built-in Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.56.14 PowerPC Built-in Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.56.15 PowerPC AltiVec Built-in Functions . . . . . . . . . . . . . . . . . . . 6.56.16 RX Built-in Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.56.17 S/390 System z Built-in Functions . . . . . . . . . . . . . . . . . . . . 6.56.18 SH Built-in Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.56.19 SPARC VIS Built-in Functions . . . . . . . . . . . . . . . . . . . . . . . . 6.56.20 SPU Built-in Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.56.21 TI C6X Built-in Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.56.22 TILE-Gx Built-in Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.56.23 TILEPro Built-in Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.57 Format Checks Specic to Particular Target Machines . . . . . . . 6.57.1 Solaris Format Checks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.57.2 Darwin Format Checks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.58 Pragmas Accepted by GCC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.58.1 ARM Pragmas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.58.2 M32C Pragmas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.58.3 MeP Pragmas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 528 530 532 534 536 538 540 542 543 543 544 545 546 551 552 553 553 553 554 556 556 556 578 579 584 584 586 587 588 590 590 591 591 626 628 629 630 632 633 633 634 634 634 634 635 635 635 635

Using the GNU Compiler Collection (GCC) 6.58.4 RS/6000 and PowerPC Pragmas . . . . . . . . . . . . . . . . . . . . . . . 6.58.5 Darwin Pragmas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.58.6 Solaris Pragmas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.58.7 Symbol-Renaming Pragmas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.58.8 Structure-Packing Pragmas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.58.9 Weak Pragmas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.58.10 Diagnostic Pragmas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.58.11 Visibility Pragmas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.58.12 Push/Pop Macro Pragmas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.58.13 Function Specic Option Pragmas . . . . . . . . . . . . . . . . . . . . . 6.59 Unnamed struct/union elds within structs/unions . . . . . . . . . . 6.60 Thread-Local Storage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.60.1 ISO/IEC 9899:1999 Edits for Thread-Local Storage . . . . . 6.60.2 ISO/IEC 14882:1998 Edits for Thread-Local Storage . . . . 6.61 Binary constants using the 0b prex . . . . . . . . . . . . . . . . . . . . . . . 636 636 637 637 638 638 639 640 640 640 641 642 643 643 645

Extensions to the C++ Language . . . . . . . . . . 647

7.1 7.2 7.3 7.4 7.5 7.6 When is a Volatile C++ Object Accessed? . . . . . . . . . . . . . . . . . . . 647 Restricting Pointer Aliasing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 647 Vague Linkage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 648 #pragma interface and implementation . . . . . . . . . . . . . . . . . . . . . . . 649 Wheres the Template? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 650 Extracting the function pointer from a bound pointer to member function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 652 7.7 C++-Specic Variable, Function, and Type Attributes . . . . . . . 653 7.8 Function Multiversioning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 654 7.9 Namespace Association . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 655 7.10 Type Traits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 655 7.11 Java Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 658 7.12 Deprecated Features . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 658 7.13 Backwards Compatibility . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 659

GNU Objective-C features . . . . . . . . . . . . . . . . . . 661

8.1 GNU Objective-C runtime API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.1.1 Modern GNU Objective-C runtime API . . . . . . . . . . . . . . . . . 8.1.2 Traditional GNU Objective-C runtime API . . . . . . . . . . . . . . 8.2 +load: Executing code before main . . . . . . . . . . . . . . . . . . . . . . . . . . 8.2.1 What you can and what you cannot do in +load . . . . . . . . . 8.3 Type encoding . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.3.1 Legacy type encoding . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.3.2 @encode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.3.3 Method signatures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.4 Garbage Collection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.5 Constant string objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.6 compatibility alias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.7 Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.8 Synchronization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.9 Fast enumeration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 661 661 662 662 663 664 666 666 667 667 668 669 669 671 671

xi 8.9.1 Using fast enumeration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.9.2 c99-like fast enumeration syntax . . . . . . . . . . . . . . . . . . . . . . . . . 8.9.3 Fast enumeration details . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.9.4 Fast enumeration protocol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.10 Messaging with the GNU Objective-C runtime . . . . . . . . . . . . . . 8.10.1 Dynamically registering methods . . . . . . . . . . . . . . . . . . . . . . . 8.10.2 Forwarding hook . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 671 671 672 673 674 674 674

9 10

Binary Compatibility . . . . . . . . . . . . . . . . . . . . . . . . 677 gcova Test Coverage Program . . . . . . . . . . . 681

Introduction to gcov . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Invoking gcov . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Using gcov with GCC Optimization . . . . . . . . . . . . . . . . . . . . . . . . . Brief description of gcov data les . . . . . . . . . . . . . . . . . . . . . . . . . . Data le relocation to support cross-proling . . . . . . . . . . . . . . . . 681 681 687 688 688

10.1 10.2 10.3 10.4 10.5

11

Known Causes of Trouble with GCC . . . . . . 689

689 689 691 694 694 695 696 696 697 698 699 700 703

11.1 Actual Bugs We Havent Fixed Yet . . . . . . . . . . . . . . . . . . . . . . . . . 11.2 Interoperation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.3 Incompatibilities of GCC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.4 Fixed Header Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.5 Standard Libraries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.6 Disappointments and Misunderstandings . . . . . . . . . . . . . . . . . . . . 11.7 Common Misunderstandings with GNU C++ . . . . . . . . . . . . . . . 11.7.1 Declare and Dene Static Members . . . . . . . . . . . . . . . . . . . . 11.7.2 Name lookup, templates, and accessing members of base classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.7.3 Temporaries May Vanish Before You Expect . . . . . . . . . . . . 11.7.4 Implicit Copy-Assignment for Virtual Bases . . . . . . . . . . . . 11.8 Certain Changes We Dont Want to Make . . . . . . . . . . . . . . . . . . . 11.9 Warning Messages and Error Messages . . . . . . . . . . . . . . . . . . . . . .

12

Reporting Bugs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 705

Have You Found a Bug? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 705 How and where to Report Bugs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 705

12.1 12.2

13 14

How To Get Help with GCC . . . . . . . . . . . . . . 707 Contributing to GCC Development . . . . . . . 709

Funding Free Software . . . . . . . . . . . . . . . . . . . . . . . . . . . 711 The GNU Project and GNU/Linux . . . . . . . . . . . . 713

xii

Using the GNU Compiler Collection (GCC)

GNU General Public License . . . . . . . . . . . . . . . . . . . 715 GNU Free Documentation License . . . . . . . . . . . . . 727
ADDENDUM: How to use this License for your documents . . . . . . . . 734

Contributors to GCC . . . . . . . . . . . . . . . . . . . . . . . . . . . . 735 Option Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 751 Keyword Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 769

Introduction

Introduction
This manual documents how to use the GNU compilers, as well as their features and incompatibilities, and how to report bugs. It corresponds to the compilers (GCC) version 4.8.2. 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

1 Programming Languages Supported by GCC

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

Chapter 2: Language Standards Supported by GCC

2 Language Standards Supported by GCC

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

2.1 C language
GCC supports three versions of the C standard, although support for the most recent version is not yet complete. The original ANSI C standard (X3.159-1989) was ratied in 1989 and published in 1990. This standard was ratied as an ISO standard (ISO/IEC 9899:1990) later in 1990. There were no technical dierences between these publications, although the sections of the ANSI standard were renumbered and became clauses in the ISO standard. This standard, in both its forms, is commonly known as C89, or occasionally as C90, from the dates of ratication. The ANSI standard, but not the ISO standard, also came with a Rationale document. To select this standard in GCC, use one of the options -ansi, -std=c90 or -std=iso9899:1990; to obtain all the diagnostics required by the standard, you should also specify -pedantic (or -pedantic-errors if you want them to be errors rather than warnings). See Section 3.4 [Options Controlling C Dialect], page 30. Errors in the 1990 ISO C standard were corrected in two Technical Corrigenda published in 1994 and 1996. GCC does not support the uncorrected version. An amendment to the 1990 standard was published in 1995. This amendment added digraphs and __STDC_VERSION__ to the language, but otherwise concerned the library. This amendment is commonly known as AMD1 ; the amended standard is sometimes known as C94 or C95. To select this standard in GCC, use the option -std=iso9899:199409 (with, as for other standard versions, -pedantic to receive all required diagnostics). A new edition of the ISO C standard was published in 1999 as ISO/IEC 9899:1999, and is commonly known as C99. GCC has incomplete support for this standard version; see [Link] for details. To select this standard, use -std=c99 or -std=iso9899:1999. (While in development, drafts of this standard version were referred to as C9X.) Errors in the 1999 ISO C standard were corrected in three Technical Corrigenda published in 2001, 2004 and 2007. GCC does not support the uncorrected version. A fourth version of the C standard, known as C11, was published in 2011 as ISO/IEC 9899:2011. GCC has limited incomplete support for parts of this standard, enabled with -std=c11 or -std=iso9899:2011. (While in development, drafts of this standard version were referred to as C1X.) By default, GCC provides some extensions to the C language that on rare occasions conict with the C standard. See Chapter 6 [Extensions to the C Language Family], page 325. Use of the -std options listed above will disable these extensions where they conict 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=gnu90; this will change to -std=gnu99 or -std=gnu11 in some future release when the C99 or C11 support is complete. Some

Using the GNU Compiler Collection (GCC)

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. The ISO C standard denes (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 denes two environments for programs, a freestanding environment, required of all implementations and which may not have library facilities beyond those required of freestanding implementations, where the handling of program startup and termination are implementation-dened, and a hosted environment, which is not required, in which all the library facilities are provided and startup is through a function int main (void) or int main (int, char *[]). An OS kernel would be a freestanding environment; a program using the facilities of an operating system would normally be in a hosted implementation. GCC aims towards being usable as a conforming freestanding implementation, or as the compiler for a conforming hosted implementation. By default, it will act as the compiler for a hosted implementation, dening __STDC_HOSTED__ as 1 and presuming that when the names of ISO C functions are used, they have the semantics dened in the standard. To make it act as a conforming freestanding implementation for a freestanding environment, use the option -ffreestanding; it will then dene __STDC_HOSTED__ to 0 and not make assumptions about the meanings of function names from the standard library, with exceptions noted below. To build an OS kernel, you may well still need to make your own arrangements for linking and startup. See Section 3.4 [Options Controlling C Dialect], page 30. GCC does not provide the library facilities required only of hosted implementations, nor yet all the facilities required by C99 of freestanding implementations; to use the facilities of a hosted environment, you will need to nd them elsewhere (for example, in the GNU C library). See Section 11.5 [Standard Libraries], page 694. Most of the compiler support routines used by GCC are present in libgcc, but there are a few exceptions. GCC requires the freestanding environment provide memcpy, memmove, memset and memcmp. Finally, if __builtin_trap is used, and the target does not implement the trap pattern, then GCC will emit a call to abort. For references to Technical Corrigenda, Rationale documents and information concerning the history of C that is available online, see [Link]

2.2 C++ language

GCC supports the original ISO C++ standard (1998) and contains experimental support for the second ISO C++ standard (2011). 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

Chapter 2: Language Standards Supported by GCC

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). 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, most of which have been implemented in an experimental C++11 mode in GCC. For information regarding the C++11 features available in the experimental C++11 mode, see [Link] To select this standard in GCC, use the option -std=c++11; 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). More information about the C++ standards is available on the ISO C++ committees web site at [Link] By default, GCC provides some extensions to the C++ language; See Section 3.5 [C++ Dialect Options], page 35. Use of the -std option listed above will disable these extensions. You may also select an extended version of the C++ language explicitly with -std=gnu++98 (for C++98 with GNU extensions) or -std=gnu++11 (for C++11 with GNU extensions). The default, if no C++ language dialect options are given, is -std=gnu++98.

2.3 Objective-C and Objective-C++ languages

GCC supports traditional Objective-C (also known as Objective-C 1.0) and contains support for the Objective-C exception and synchronization syntax. It has also support for a number of Objective-C 2.0 language extensions, including properties, fast enumeration (only for Objective-C), method attributes and the @optional and @required keywords in protocols. GCC supports Objective-C++ and features available in Objective-C are also available in Objective-C++. GCC by default uses the GNU Objective-C runtime library, which is part of GCC and is not the same as the Apple/NeXT Objective-C runtime library used on Apple systems. There are a number of dierences 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 ObjectiveC runtime library. There is no formal written standard for Objective-C or Objective-C++. The authoritative manual on traditional Objective-C (1.0) is Object-Oriented Programming and the Objective-C Language, available at a number of web sites: [Link] is the original NeXTstep document; [Link] is the same document in another format; [Link] ObjectiveC/ has an updated version but make sure you search for Object Oriented Programming and the Objective-C Programming Language 1.0, not documentation on the newer Objective-C 2.0 language The Objective-C exception and synchronization syntax (that is, the keywords @try, @throw, @catch, @nally and @synchronized) is supported by GCC and is enabled with

Using the GNU Compiler Collection (GCC)

the option -fobjc-exceptions. The syntax is briey 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: [Link] ObjectiveC/ For more information concerning the history of Objective-C that is available online, see [Link]

2.4 Go language
As of the GCC 4.7.1 release, GCC supports the Go 1 language standard, described at [Link]

2.5 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 supported by GNU Fortran. See Section Compatibility with the Java Platform in GNU gcj , for details of compatibility between gcj and the Java Platform.

Chapter 3: GCC Command Options

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 les output by the assembler. Other options are passed on to one stage of processing. Some options control the preprocessor and others the compiler itself. Yet other options control the assembler and linker; most of these are not documented here, since you rarely need to use any of them. Most of the command-line options that you can use with GCC are useful for C programs; when an option is only useful with another language (usually C++), the explanation says so explicitly. If the description for a particular option does not mention a source language, you can use that option with all supported languages. See Section 3.3 [Compiling C++ Programs], page 29, for a summary of special options for compiling C++ programs. The gcc program accepts options and le names as operands. Many options have multiletter names; therefore multiple single-letter options may not be grouped: -dv is very dierent from -d -v. You can mix options and other arguments. For the most part, the order you use doesnt 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 specied. Also, the placement of the -l option is signicant. Many options have long names starting with -f or with -Wfor 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 751, for an index to GCCs 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 24.
-c -S -E -o file -no-canonical-prefixes -pipe -pass-exit-codes -x language -v -### --help[=class[,...]] --target-help --version -wrapper @file -fplugin=file -fplugin-arg-name=arg -fdump-ada-spec[-slim] -fada-spec-parent=arg -fdump-go-spec=file

C Language Options See Section 3.4 [Options Controlling C Dialect], page 30.
-ansi -std=standard -fgnu89-inline -aux-info filename -fallow-parameterless-variadic-functions -fno-asm -fno-builtin -fno-builtin-function -fhosted -ffreestanding -fopenmp -fms-extensions -fplan9-extensions -trigraphs -traditional -traditional-cpp

10

Using the GNU Compiler Collection (GCC)

-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 35.
-fabi-version=n -fno-access-control -fcheck-new -fconstexpr-depth=n -ffriend-injection -fno-elide-constructors -fno-enforce-eh-specs -ffor-scope -fno-for-scope -fno-gnu-keywords -fno-implicit-templates -fno-implicit-inline-templates -fno-implement-inlines -fms-extensions -fno-nonansi-builtins -fnothrow-opt -fno-operator-names -fno-optional-diags -fpermissive -fno-pretty-templates -frepo -fno-rtti -fstats -ftemplate-backtrace-limit=n -ftemplate-depth=n -fno-threadsafe-statics -fuse-cxa-atexit -fno-weak -nostdinc++ -fno-default-inline -fvisibility-inlines-hidden -fvisibility-ms-compat -fext-numeric-literals -Wabi -Wconversion-null -Wctor-dtor-privacy -Wdelete-non-virtual-dtor -Wliteral-suffix -Wnarrowing -Wnoexcept -Wnon-virtual-dtor -Wreorder -Weffc++ -Wstrict-null-sentinel -Wno-non-template-friend -Wold-style-cast -Woverloaded-virtual -Wno-pmf-conversions -Wsign-promo

Objective-C and Objective-C++ Language Options See Section 3.6 [Options Controlling Objective-C and Objective-C++ Dialects], page 46.
-fconstant-string-class=class-name -fgnu-runtime -fnext-runtime -fno-nil-receivers -fobjc-abi-version=n -fobjc-call-cxx-cdtors -fobjc-direct-dispatch -fobjc-exceptions -fobjc-gc -fobjc-nilcheck -fobjc-std=objc1 -freplace-objc-classes -fzero-link -gen-decls -Wassign-intercept -Wno-protocol -Wselector -Wstrict-selector-match -Wundeclared-selector

Language Independent Options See Section 3.7 [Options to Control Diagnostic Messages Formatting], page 49.
-fmessage-length=n -fdiagnostics-show-location=[once|every-line] -fno-diagnostics-show-option -fno-diagnostics-show-caret

Chapter 3: GCC Command Options

11

Warning Options See Section 3.8 [Options to Request or Suppress Warnings], page 50.
-fsyntax-only -fmax-errors=n -Wpedantic -pedantic-errors -w -Wextra -Wall -Waddress -Waggregate-return -Waggressive-loop-optimizations -Warray-bounds -Wno-attributes -Wno-builtin-macro-redefined -Wc++-compat -Wc++11-compat -Wcast-align -Wcast-qual -Wchar-subscripts -Wclobbered -Wcomment -Wconversion -Wcoverage-mismatch -Wno-cpp -Wno-deprecated -Wno-deprecated-declarations -Wdisabled-optimization -Wno-div-by-zero -Wdouble-promotion -Wempty-body -Wenum-compare -Wno-endif-labels -Werror -Werror=* -Wfatal-errors -Wfloat-equal -Wformat -Wformat=2 -Wno-format-contains-nul -Wno-format-extra-args -Wformat-nonliteral -Wformat-security -Wformat-y2k -Wframe-larger-than=len -Wno-free-nonheap-object -Wjump-misses-init -Wignored-qualifiers -Wimplicit -Wimplicit-function-declaration -Wimplicit-int -Winit-self -Winline -Wmaybe-uninitialized -Wno-int-to-pointer-cast -Wno-invalid-offsetof -Winvalid-pch -Wlarger-than=len -Wunsafe-loop-optimizations -Wlogical-op -Wlong-long -Wmain -Wmaybe-uninitialized -Wmissing-braces -Wmissing-field-initializers -Wmissing-include-dirs -Wno-mudflap -Wno-multichar -Wnonnull -Wno-overflow -Woverlength-strings -Wpacked -Wpacked-bitfield-compat -Wpadded -Wparentheses -Wpedantic-ms-format -Wno-pedantic-ms-format -Wpointer-arith -Wno-pointer-to-int-cast -Wredundant-decls -Wno-return-local-addr -Wreturn-type -Wsequence-point -Wshadow -Wsign-compare -Wsign-conversion -Wsizeof-pointer-memaccess -Wstack-protector -Wstack-usage=len -Wstrict-aliasing -Wstrict-aliasing=n -Wstrict-overflow -Wstrict-overflow=n -Wsuggest-attribute=[pure|const|noreturn|format] -Wmissing-format-attribute -Wswitch -Wswitch-default -Wswitch-enum -Wsync-nand -Wsystem-headers -Wtrampolines -Wtrigraphs -Wtype-limits -Wundef -Wuninitialized -Wunknown-pragmas -Wno-pragmas -Wunsuffixed-float-constants -Wunused -Wunused-function -Wunused-label -Wunused-local-typedefs -Wunused-parameter -Wno-unused-result -Wunused-value -Wunused-variable -Wunused-but-set-parameter -Wunused-but-set-variable -Wuseless-cast -Wvariadic-macros -Wvector-operation-performance -Wvla -Wvolatile-register-var -Wwrite-strings -Wzero-as-null-pointer-constant

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 or GCC], page 74.

12

Using the GNU Compiler Collection (GCC)

-dletters -dumpspecs -dumpmachine -dumpversion -fsanitize=style -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-statistics -fdump-tree-all -fdump-tree-original[-n] -fdump-tree-optimized[-n] -fdump-tree-cfg -fdump-tree-alias -fdump-tree-ch -fdump-tree-ssa[-n] -fdump-tree-pre[-n] -fdump-tree-ccp[-n] -fdump-tree-dce[-n] -fdump-tree-gimple[-raw] -fdump-tree-mudflap[-n] -fdump-tree-dom[-n] -fdump-tree-dse[-n] -fdump-tree-phiprop[-n] -fdump-tree-phiopt[-n] -fdump-tree-forwprop[-n] -fdump-tree-copyrename[-n] -fdump-tree-nrv -fdump-tree-vect -fdump-tree-sink -fdump-tree-sra[-n] -fdump-tree-forwprop[-n] -fdump-tree-fre[-n] -fdump-tree-vrp[-n] -ftree-vectorizer-verbose=n -fdump-tree-storeccp[-n] -fdump-final-insns=file -fcompare-debug[=opts] -fcompare-debug-second -feliminate-dwarf2-dups -fno-eliminate-unused-debug-types -feliminate-unused-debug-symbols -femit-class-debug-always -fenable-kind-pass -fenable-kind-pass=range-list -fdebug-types-section -fmem-report-wpa -fmem-report -fpre-ipa-mem-report -fpost-ipa-mem-report -fprofile-arcs -fopt-info -fopt-info-options[=file] -frandom-seed=string -fsched-verbose=n -fsel-sched-verbose -fsel-sched-dump-cfg -fsel-sched-pipelining-verbose -fstack-usage -ftest-coverage -ftime-report -fvar-tracking -fvar-tracking-assignments -fvar-tracking-assignments-toggle -g -glevel -gtoggle -gcoff -gdwarf-version -ggdb -grecord-gcc-switches -gno-record-gcc-switches -gstabs -gstabs+ -gstrict-dwarf -gno-strict-dwarf -gvms -gxcoff -gxcoff+ -fno-merge-debug-strings -fno-dwarf2-cfi-asm -fdebug-prefix-map=old=new -femit-struct-debug-baseonly -femit-struct-debug-reduced -femit-struct-debug-detailed[=spec-list]

Chapter 3: GCC Command Options

13

-p -pg -print-file-name=library -print-libgcc-file-name -print-multi-directory -print-multi-lib -print-multi-os-directory -print-prog-name=program -print-search-dirs -Q -print-sysroot -print-sysroot-headers-suffix -save-temps -save-temps=cwd -save-temps=obj -time[=file]

Optimization Options See Section 3.10 [Options that Control Optimization], page 97.
-faggressive-loop-optimizations -falign-functions[=n] -falign-jumps[=n] -falign-labels[=n] -falign-loops[=n] -fassociative-math -fauto-inc-dec -fbranch-probabilities -fbranch-target-load-optimize -fbranch-target-load-optimize2 -fbtr-bb-exclusive -fcaller-saves -fcheck-data-deps -fcombine-stack-adjustments -fconserve-stack -fcompare-elim -fcprop-registers -fcrossjumping -fcse-follow-jumps -fcse-skip-blocks -fcx-fortran-rules -fcx-limited-range -fdata-sections -fdce -fdelayed-branch -fdelete-null-pointer-checks -fdevirtualize -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-pta -fipa-profile -fipa-pure-const -fipa-reference -fira-algorithm=algorithm -fira-region=region -fira-hoist-pressure -fira-loop-pressure -fno-ira-share-save-slots -fno-ira-share-spill-slots -fira-verbose=n -fivopts -fkeep-inline-functions -fkeep-static-consts -floop-block -floop-interchange -floop-strip-mine -floop-nest-optimize -floop-parallelize-all -flto -flto-compression-level -flto-partition=alg -flto-report -fmerge-all-constants -fmerge-constants -fmodulo-sched -fmodulo-sched-allow-regmoves -fmove-loop-invariants fmudflap -fmudflapir -fmudflapth -fno-branch-countreg -fno-default-inline -fno-defer-pop -fno-function-cse -fno-guess-branch-probability -fno-inline -fno-math-errno -fno-peephole -fno-peephole2 -fno-sched-interblock -fno-sched-spec -fno-signed-zeros -fno-toplevel-reorder -fno-trapping-math -fno-zero-initialized-in-bss -fomit-frame-pointer -foptimize-register-move -foptimize-sibling-calls -fpartial-inlining -fpeel-loops -fpredictive-commoning -fprefetch-loop-arrays -fprofile-report -fprofile-correction -fprofile-dir=path -fprofile-generate -fprofile-generate=path -fprofile-use -fprofile-use=path -fprofile-values -freciprocal-math -free -fregmove -frename-registers -freorder-blocks -freorder-blocks-and-partition -freorder-functions -frerun-cse-after-loop -freschedule-modulo-scheduled-loops -frounding-math -fsched2-use-superblocks -fsched-pressure -fsched-spec-load -fsched-spec-load-dangerous -fsched-stalled-insns-dep[=n] -fsched-stalled-insns[=n] -fsched-group-heuristic -fsched-critical-path-heuristic

14

Using the GNU Compiler Collection (GCC)

-fsched-spec-insn-heuristic -fsched-rank-heuristic -fsched-last-insn-heuristic -fsched-dep-count-heuristic -fschedule-insns -fschedule-insns2 -fsection-anchors -fselective-scheduling -fselective-scheduling2 -fsel-sched-pipelining -fsel-sched-pipelining-outer-loops -fshrink-wrap -fsignaling-nans -fsingle-precision-constant -fsplit-ivs-in-unroller -fsplit-wide-types -fstack-protector -fstack-protector-all -fstrict-aliasing -fstrict-overflow -fthread-jumps -ftracer -ftree-bit-ccp -ftree-builtin-call-dce -ftree-ccp -ftree-ch -ftree-coalesce-inline-vars -ftree-coalesce-vars -ftree-copy-prop -ftree-copyrename -ftree-dce -ftree-dominator-opts -ftree-dse -ftree-forwprop -ftree-fre -ftree-loop-if-convert -ftree-loop-if-convert-stores -ftree-loop-im -ftree-phiprop -ftree-loop-distribution -ftree-loop-distribute-patterns -ftree-loop-ivcanon -ftree-loop-linear -ftree-loop-optimize -ftree-parallelize-loops=n -ftree-pre -ftree-partial-pre -ftree-pta -ftree-reassoc -ftree-sink -ftree-slsr -ftree-sra -ftree-switch-conversion -ftree-tail-merge -ftree-ter -ftree-vect-loop-version -ftree-vectorize -ftree-vrp -funit-at-a-time -funroll-all-loops -funroll-loops -funsafe-loop-optimizations -funsafe-math-optimizations -funswitch-loops -fvariable-expansion-in-unroller -fvect-cost-model -fvpt -fweb -fwhole-program -fwpa -fuse-ld=linker -fuse-linker-plugin --param name=value -O -O0 -O1 -O2 -O3 -Os -Ofast -Og

Preprocessor Options See Section 3.11 [Options Controlling the Preprocessor], page 148.
-Aquestion=answer -A-question[=answer] -C -dD -dI -dM -dN -Dmacro[=defn] -E -H -idirafter dir -include file -imacros file -iprefix file -iwithprefix dir -iwithprefixbefore dir -isystem dir -imultilib dir -isysroot dir -M -MM -MF -MG -MP -MQ -MT -nostdinc -P -fdebug-cpp -ftrack-macro-expansion -fworking-directory -remap -trigraphs -undef -Umacro -Wp,option -Xpreprocessor option -no-integrated-cpp

Assembler Option See Section 3.12 [Passing Options to the Assembler], page 159.
-Wa,option -Xassembler option

Linker Options See Section 3.13 [Options for Linking], page 160.
object-file-name -llibrary -nostartfiles -nodefaultlibs -nostdlib -pie -rdynamic -s -static -static-libgcc -static-libstdc++ -static-libasan -static-libtsan -shared -shared-libgcc -symbolic -T script -Wl,option -Xlinker option -u symbol

Directory Options See Section 3.14 [Options for Directory Search], page 163.

Chapter 3: GCC Command Options

15

-Bprefix -Idir -iplugindir=dir -iquotedir -Ldir -specs=file -I--sysroot=dir --no-sysroot-suffix

Machine Dependent Options See Section 3.17 [Hardware Models and Congurations], page 173. AArch64 Options
-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 -march=name -mcpu=name -mtune=name

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

ARM Options
-mapcs-frame -mno-apcs-frame -mabi=name -mapcs-stack-check -mno-apcs-stack-check -mapcs-float -mno-apcs-float -mapcs-reentrant -mno-apcs-reentrant -msched-prolog -mno-sched-prolog -mlittle-endian -mbig-endian -mwords-little-endian -mfloat-abi=name -mfp16-format=name -mthumb-interwork -mno-thumb-interwork -mcpu=name -march=name -mfpu=name -mstructure-size-boundary=n -mabort-on-noreturn -mlong-calls -mno-long-calls -msingle-pic-base -mno-single-pic-base -mpic-register=reg -mnop-fun-dllimport -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

AVR Options
-mmcu=mcu -maccumulate-args -mbranch-cost=cost -mcall-prologues -mint8 -mno-interrupts -mrelax -mstrict-X -mtiny-stack -Waddr-space-convert

Blackn 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

16

Using the GNU Compiler Collection (GCC)

-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 -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

Chapter 3: GCC Command Options

17

-msmall-text -mlarge-text -mmemory-latency=time

FR30 Options
-msmall-model -mno-lsim

FRV Options
-mgpr-32 -mgpr-64 -mfpr-32 -mfpr-64 -mhard-float -msoft-float -malloc-cc -mfixed-cc -mdword -mno-dword -mdouble -mno-double -mmedia -mno-media -mmuladd -mno-muladd -mfdpic -minline-plt -mgprel-ro -multilib-library-pic -mlinked-fp -mlong-calls -malign-labels -mlibrary-pic -macc-4 -macc-8 -mpack -mno-pack -mno-eflags -mcond-move -mno-cond-move -moptimize-membar -mno-optimize-membar -mscc -mno-scc -mcond-exec -mno-cond-exec -mvliw-branch -mno-vliw-branch -mmulti-cond-exec -mno-multi-cond-exec -mnested-cond-exec -mno-nested-cond-exec -mtomcat-stats -mTLS -mtls -mcpu=cpu

GNU/Linux Options
-mglibc -muclibc -mbionic -mandroid -tno-android-cc -tno-android-ld

H8/300 Options
-mrelax -mh -ms -mn -mexr -mno-exr -mint32 -malign-300

HPPA Options
-march=architecture-type -mbig-switch -mdisable-fpregs -mdisable-indexing -mfast-indirect-calls -mgas -mgnu-ld -mhp-ld -mfixed-range=register-range -mjump-in-delay -mlinker-opt -mlong-calls -mlong-load-store -mno-big-switch -mno-disable-fpregs -mno-disable-indexing -mno-fast-indirect-calls -mno-gas -mno-jump-in-delay -mno-long-load-store -mno-portable-runtime -mno-soft-float -mno-space-regs -msoft-float -mpa-risc-1-0 -mpa-risc-1-1 -mpa-risc-2-0 -mportable-runtime -mschedule=cpu-type -mspace-regs -msio -mwsio -munix=unix-std -nolibdld -static -threads

i386 and x86-64 Options

-mtune=cpu-type -march=cpu-type -mfpmath=unit -masm=dialect -mno-fancy-math-387 -mno-fp-ret-in-387 -msoft-float -mno-wide-multiply -mrtd -malign-double -mpreferred-stack-boundary=num -mincoming-stack-boundary=num -mcld -mcx16 -msahf -mmovbe -mcrc32 -mrecip -mrecip=opt -mvzeroupper -mprefer-avx128 -mmmx -msse -msse2 -msse3 -mssse3 -msse4.1 -msse4.2 -msse4 -mavx -mavx2 -maes -mpclmul -mfsgsbase -mrdrnd -mf16c -mfma -msse4a -m3dnow -mpopcnt -mabm -mbmi -mtbm -mfma4 -mxop -mlzcnt

18

Using the GNU Compiler Collection (GCC)

-mbmi2 -mrtm -mlwp -mthreads -mno-align-stringops -minline-all-stringops -minline-stringops-dynamically -mstringop-strategy=alg -mpush-args -maccumulate-outgoing-args -m128bit-long-double -m96bit-long-double -mlong-double-64 -mlong-double-80 -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 -mlarge-data-threshold=num -msse2avx -mfentry -m8bit-idiv -mavx256-split-unaligned-load -mavx256-split-unaligned-store

i386 and x86-64 Windows Options

-mconsole -mcygwin -mno-cygwin -mdll -mnop-fun-dllimport -mthread -municode -mwin32 -mwindows -fno-set-stack-executable

IA-64 Options
-mbig-endian -mlittle-endian -mgnu-as -mgnu-ld -mno-pic -mvolatile-asm-stop -mregister-names -msdata -mno-sdata -mconstant-gp -mauto-pic -mfused-madd -minline-float-divide-min-latency -minline-float-divide-max-throughput -mno-inline-float-divide -minline-int-divide-min-latency -minline-int-divide-max-throughput -mno-inline-int-divide -minline-sqrt-min-latency -minline-sqrt-max-throughput -mno-inline-sqrt -mdwarf2-asm -mearly-stop-bits -mfixed-range=register-range -mtls-size=tls-size -mtune=cpu-type -milp32 -mlp64 -msched-br-data-spec -msched-ar-data-spec -msched-control-spec -msched-br-in-data-spec -msched-ar-in-data-spec -msched-in-control-spec -msched-spec-ldc -msched-spec-control-ldc -msched-prefer-non-data-spec-insns -msched-prefer-non-control-spec-insns -msched-stop-bits-after-every-cycle -msched-count-spec-in-critical-path -msel-sched-dont-check-control-spec -msched-fp-mem-deps-zero-cost -msched-max-memory-insns-hard-limit -msched-max-memory-insns=max-insns

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

Chapter 3: GCC Command Options

19

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

MCore Options
-mhardlit -mno-hardlit -mdiv -mno-div -mrelax-immediates -mno-relax-immediates -mwide-bitfields -mno-wide-bitfields -m4byte-functions -mno-4byte-functions -mcallgraph-data -mno-callgraph-data -mslow-bytes -mno-slow-bytes -mno-lsim -mlittle-endian -mbig-endian -m210 -m340 -mstack-increment

MeP Options
-mabsdiff -mall-opts -maverage -mbased=n -mbitops -mc=n -mclip -mconfig=name -mcop -mcop32 -mcop64 -mivc2 -mdc -mdiv -meb -mel -mio-volatile -ml -mleadz -mm -mminmax -mmult -mno-opts -mrepeat -ms -msatur -msdram -msim -msimnovec -mtf -mtiny=n

MicroBlaze Options
-msoft-float -mhard-float -msmall-divides -mcpu=cpu -mmemcpy -mxl-soft-mul -mxl-soft-div -mxl-barrel-shift -mxl-pattern-compare -mxl-stack-check -mxl-gp-opt -mno-clearbss -mxl-multiply-high -mxl-float-convert -mxl-float-sqrt -mbig-endian -mlittle-endian -mxl-reorder -mxl-mode-app-model

MIPS Options
-EL -EB -march=arch -mtune=arch -mips1 -mips2 -mips3 -mips4 -mips32 -mips32r2 -mips64 -mips64r2 -mips16 -mno-mips16 -mflip-mips16 -minterlink-mips16 -mno-interlink-mips16 -mabi=abi -mabicalls -mno-abicalls -mshared -mno-shared -mplt -mno-plt -mxgot -mno-xgot -mgp32 -mgp64 -mfp32 -mfp64 -mhard-float -msoft-float -mno-float -msingle-float -mdouble-float -mdsp -mno-dsp -mdspr2 -mno-dspr2 -mmcu -mmno-mcu -mfpu=fpu-type -msmartmips -mno-smartmips -mpaired-single -mno-paired-single -mdmx -mno-mdmx -mips3d -mno-mips3d -mmt -mno-mt -mllsc -mno-llsc -mlong64 -mlong32 -msym32 -mno-sym32 -Gnum -mlocal-sdata -mno-local-sdata -mextern-sdata -mno-extern-sdata -mgpopt -mno-gopt -membedded-data -mno-embedded-data -muninit-const-in-rodata -mno-uninit-const-in-rodata -mcode-readable=setting -msplit-addresses -mno-split-addresses -mexplicit-relocs -mno-explicit-relocs -mcheck-zero-division -mno-check-zero-division -mdivide-traps -mdivide-breaks -mmemcpy -mno-memcpy -mlong-calls -mno-long-calls

20

Using the GNU Compiler Collection (GCC)

-mmad -mno-mad -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-vr4120 -mno-fix-vr4120 -mfix-vr4130 -mno-fix-vr4130 -mfix-sb1 -mno-fix-sb1 -mflush-func=func -mno-flush-func -mbranch-cost=num -mbranch-likely -mno-branch-likely -mfp-exceptions -mno-fp-exceptions -mvr4130-align -mno-vr4130-align -msynci -mno-synci -mrelax-pic-calls -mno-relax-pic-calls -mmcount-ra-address

MMIX Options
-mlibfuncs -mno-libfuncs -mepsilon -mno-epsilon -mabi=gnu -mabi=mmixware -mzero-extend -mknuthdiv -mtoplevel-symbols -melf -mbranch-predict -mno-branch-predict -mbase-addresses -mno-base-addresses -msingle-exit -mno-single-exit

MN10300 Options
-mmult-bug -mno-mult-bug -mno-am33 -mam33 -mam33-2 -mam34 -mtune=cpu-type -mreturn-pointer-on-d0 -mno-crt0 -mrelax -mliw -msetlb

Moxie Options
-meb -mel -mno-crt0

PDP-11 Options
-mfpu -msoft-float -mac0 -mno-ac0 -m40 -m45 -m10 -mbcopy -mbcopy-builtin -mint32 -mno-int16 -mint16 -mno-int32 -mfloat32 -mno-float64 -mfloat64 -mno-float32 -mabshi -mno-abshi -mbranch-expensive -mbranch-cheap -munix-asm -mdec-asm

picoChip Options
-mae=ae_type -mvliw-lookahead=N -msymbol-as-address -mno-inefficient-warnings

PowerPC Options See RS/6000 and PowerPC Options. RL78 Options

-msim -mmul=none -mmul=g13 -mmul=rl78

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

Chapter 3: GCC Command Options

21

-mstring -mno-string -mupdate -mno-update -mavoid-indexed-addresses -mno-avoid-indexed-addresses -mfused-madd -mno-fused-madd -mbit-align -mno-bit-align -mstrict-align -mno-strict-align -mrelocatable -mno-relocatable -mrelocatable-lib -mno-relocatable-lib -mtoc -mno-toc -mlittle -mlittle-endian -mbig -mbig-endian -mdynamic-no-pic -maltivec -mswdiv -msingle-pic-base -mprioritize-restricted-insns=priority -msched-costly-dep=dependence_type -minsert-sched-nops=scheme -mcall-sysv -mcall-netbsd -maix-struct-return -msvr4-struct-return -mabi=abi-type -msecure-plt -mbss-plt -mblock-move-inline-limit=num -misel -mno-isel -misel=yes -misel=no -mspe -mno-spe -mspe=yes -mspe=no -mpaired -mgen-cell-microcode -mwarn-cell-microcode -mvrsave -mno-vrsave -mmulhw -mno-mulhw -mdlmzb -mno-dlmzb -mfloat-gprs=yes -mfloat-gprs=no -mfloat-gprs=single -mfloat-gprs=double -mprototype -mno-prototype -msim -mmvme -mads -myellowknife -memb -msdata -msdata=opt -mvxworks -G num -pthread -mrecip -mrecip=opt -mno-recip -mrecip-precision -mno-recip-precision -mveclibabi=type -mfriz -mno-friz -mpointers-to-nested-functions -mno-pointers-to-nested-functions -msave-toc-indirect -mno-save-toc-indirect

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 -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 -mtpf-trace -mno-tpf-trace -mfused-madd -mno-fused-madd -mwarn-framesize -mwarn-dynamicstack -mstack-size -mstack-guard

Score Options

22

Using the GNU Compiler Collection (GCC)

-meb -mel -mnhwloop -muls -mmac -mscore5 -mscore5u -mscore7 -mscore7d

SH Options
-m1 -m2 -m2e -m2a-nofpu -m2a-single-only -m2a-single -m2a -m3 -m3e -m4-nofpu -m4-single-only -m4-single -m4 -m4a-nofpu -m4a-single-only -m4a-single -m4a -m4al -m5-64media -m5-64media-nofpu -m5-32media -m5-32media-nofpu -m5-compact -m5-compact-nofpu -mb -ml -mdalign -mrelax -mbigtable -mfmovd -mhitachi -mrenesas -mno-renesas -mnomacsave -mieee -mno-ieee -mbitops -misize -minline-ic_invalidate -mpadstruct -mspace -mprefergot -musermode -multcost=number -mdiv=strategy -mdivsi3_libfunc=name -mfixed-range=register-range -mindexed-addressing -mgettrcost=number -mpt-fixed -maccumulate-outgoing-args -minvalid-symbols -matomic-model=atomic-model -mbranch-cost=num -mzdcbranch -mno-zdcbranch -mcbranchdi -mcmpeqdi -mfused-madd -mno-fused-madd -mfsca -mno-fsca -mfsrra -mno-fsrra -mpretend-cmove -mtas

Solaris 2 Options
-mimpure-text -mno-impure-text -pthreads -pthread

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 -munaligned-doubles -mno-unaligned-doubles -mv8plus -mno-v8plus -mvis -mno-vis -mvis2 -mno-vis2 -mvis3 -mno-vis3 -mcbcond -mno-cbcond -mfmaf -mno-fmaf -mpopc -mno-popc -mfix-at697f

SPU Options
-mwarn-reloc -merror-reloc -msafe-dma -munsafe-dma -mbranch-hints -msmall-mem -mlarge-mem -mstdmain -mfixed-range=register-range -mea32 -mea64 -maddress-space-conversion -mno-address-space-conversion -mcache-size=cache-size -matomic-updates -mno-atomic-updates

System V Options

Chapter 3: GCC Command Options

23

-Qy -Qn -YP,paths -Ym,dir

TILE-Gx Options
-mcpu=cpu -m32 -m64 -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

VMS Options
-mvms-return-codes -mdebug-main=prefix -mmalloc64 -mpointer-size=size

VxWorks Options
-mrtp -non-static -Bstatic -Bdynamic -Xbind-lazy -Xbind-now

x86-64 Options See i386 and x86-64 Options. Xstormy16 Options

-msim

Xtensa Options
-mconst16 -mno-const16 -mfused-madd -mno-fused-madd -mforce-no-pic -mserialize-volatile -mno-serialize-volatile -mtext-section-literals -mno-text-section-literals -mtarget-align -mno-target-align -mlongcalls -mno-longcalls

zSeries Options See S/390 and zSeries Options. Code Generation Options See Section 3.18 [Options for Code Generation Conventions], page 298.
-fcall-saved-reg -fcall-used-reg -ffixed-reg -fexceptions -fnon-call-exceptions -fdelete-dead-exceptions -funwind-tables -fasynchronous-unwind-tables -finhibit-size-directive -finstrument-functions -finstrument-functions-exclude-function-list=sym,sym,... -finstrument-functions-exclude-file-list=file,file,...

24

Using the GNU Compiler Collection (GCC)

-fno-common -fno-ident -fpcc-struct-return -fpic -fPIC -fpie -fPIE -fno-jump-tables -frecord-gcc-switches -freg-struct-return -fshort-enums -fshort-double -fshort-wchar -fverbose-asm -fpack-struct[=n] -fstack-check -fstack-limit-register=reg -fstack-limit-symbol=sym -fno-stack-limit -fsplit-stack -fleading-underscore -ftls-model=model -fstack-reuse=reuse_level -ftrapv -fwrapv -fbounds-check -fvisibility -fstrict-volatile-bitfields -fsync-libcalls

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 les either into several assembler input les, or into one assembler input le; then each assembler input le produces an object le, and linking combines all the object les (those newly compiled, and those specied as input) into an executable le. For any given input le, the le name sux determines what kind of compilation is done: file.c file.i [Link] file.m [Link] [Link] file.M C source code that must be preprocessed. C source code that should not be preprocessed. C++ source code that should not be preprocessed. Objective-C source code. Note that you must link with the libobjc library to make an Objective-C program work. Objective-C source code that should not be preprocessed. 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. Objective-C++ source code that should not be preprocessed. C, C++, Objective-C or Objective-C++ header le to be turned into a precompiled header (default), or C, C++ header le to be turned into an Ada spec (via the -fdump-ada-spec switch).

[Link] file.h

[Link] [Link] [Link] [Link] [Link] file.c++ file.C [Link] file.M

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. Objective-C++ source code that must be preprocessed.

Chapter 3: GCC Command Options

25

[Link] [Link] file.H [Link] [Link] [Link] [Link] file.h++ [Link] file.f [Link] [Link] file.F [Link] [Link] [Link] [Link] file.f90 file.f95 file.f03 file.f08 file.F90 file.F95 file.F03 file.F08 [Link] [Link]

Objective-C++ source code that should not be preprocessed.

C++ header le to be turned into a precompiled header or Ada spec.

Fixed form Fortran source code that should not be preprocessed.

Fixed form Fortran source code that must be preprocessed (with the traditional preprocessor).

Free form Fortran source code that should not be preprocessed.

Free form Fortran source code that must be preprocessed (with the traditional preprocessor). Go source code. Ada source code le 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 les are also called specs. Ada source code le containing a library unit body (a subprogram or package body). Such les are also called bodies. Assembler code. Assembler code that must be preprocessed. An object le to be fed straight into linking. Any le name with no recognized sux is treated this way.

[Link] file.s file.S [Link] other

You can specify the input language explicitly with the -x option:

26

Using the GNU Compiler Collection (GCC)

-x language Specify explicitly the language for the following input les (rather than letting the compiler choose a default based on the le name sux). This option applies to all following input les until the next -x option. Possible values for language are:
c c-header cpp-output c++ c++-header c++-cpp-output objective-c objective-c-header objective-c-cpp-output objective-c++ objective-c++-header objective-c++-cpp-output assembler assembler-with-cpp ada f77 f77-cpp-input f95 f95-cpp-input go java

-x none

Turn o any specication of a language, so that subsequent les are handled according to their le name suxes (as they are if -x has not been used at all).

-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. If you only want some of the stages of compilation, you can use -x (or lename suxes) 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 les, but do not link. The linking stage simply is not done. The ultimate output is in the form of an object le for each source le. By default, the object le name for a source le is made by replacing the sux .c, .i, .s, etc., with .o. Unrecognized input les, not requiring compilation or assembly, are ignored. Stop after the stage of compilation proper; do not assemble. The output is in the form of an assembler code le for each non-assembler input le specied. By default, the assembler le name for a source le is made by replacing the sux .c, .i, etc., with .s. Input les that dont require compilation are ignored. 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 les that dont require preprocessing are ignored. Place output in le le. This applies to whatever sort of output is being produced, whether it be an executable le, an object le, an assembler le or preprocessed C code.

-S

-E

-o file

Chapter 3: GCC Command Options

27

If -o is not specied, the default is to put an executable le in [Link], the object le for [Link] in source.o, its assembler le in source.s, a precompiled header le in [Link], 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. Use pipes rather than temporary les 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. Print (on the standard output) a description of the command-line options understood by gcc. If the -v option is also specied then --help is also passed on to the various processes invoked by gcc, so that they can display the commandline options they accept. If the -Wextra option has also been specied (prior to the --help option), then command-line options that have no documentation associated with them are also displayed.

-###

-pipe

--help

--target-help Print (on the standard output) a description of target-specic command-line options for each tool. For some targets extra target-specic information may also be printed. --help={class|[^]qualifier}[,...] Print (on the standard output) a description of the command-line options understood by the compiler that t into all specied classes and qualiers. 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. target Display target-specic options. Unlike the --target-help option however, target-specic options of the linker and assembler are not displayed. This is because those tools do not currently support the extended --help= syntax. Display the values recognized by the --param option. Display the options supported for language, where language is the name of one of the languages supported in this version of GCC. Display the options that are common to all languages.

params language common

These are the supported qualiers:

28

Using the GNU Compiler Collection (GCC)

undocumented Display only those options that are undocumented. joined 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-specic switches supported by the compiler, use:
--help=target,undocumented

Display options taking an argument that appears after an equal sign in the same continuous piece of text, such as: --help=target.

The sense of a qualier can be inverted by prexing it with the ^ character, so for example to display all binary warning options (i.e., ones that are either on or o 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 qualiers. 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-specic 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 specic value (assuming that the compiler knows this at the point where the --help= option is used). Here is a truncated example from the ARM port of gcc:
% gcc -Q -mabi=2 --help=target -c The following options are target specific: -mabi= 2 -mabort-on-noreturn [disabled] -mapcs [disabled]

The output is sensitive to the eects of previous command-line options, so for example it is possible to nd out which optimizations are enabled at -O2 by using:
-Q -O2 --help=optimizers

Alternatively you can discover which binary optimizations are enabled by -O3 by using:
gcc -c -Q -O3 --help=optimizers > /tmp/O3-opts gcc -c -Q -O2 --help=optimizers > /tmp/O2-opts diff /tmp/O2-opts /tmp/O3-opts | grep enabled

-no-canonical-prefixes Do not expand any symbolic links, resolve references to /../ or /./, or make the path absolute when generating a relative prex.

Chapter 3: GCC Command Options

29

--version Display the version number and copyrights of the invoked GCC. -wrapper Invoke all subcommands under a wrapper program. The name of the wrapper program and its parameters are passed as a comma separated list.
gcc -c t.c -wrapper gdb,--args

This invokes all subprograms of gcc under gdb --args, thus the invocation of cc1 is gdb --args cc1 .... -fplugin=[Link] Load the plugin code in le [Link], assumed be dlopend by the compiler. The base name is used to identify the plugin for the purposes -fplugin-arg-name-key=value below). Each callback functions specied in the Plugins API. to be a shared object to of the shared object le of argument parsing (See plugin should dene the

-fplugin-arg-name-key=value Dene 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 les, generate corresponding Ada specs. See Section Generating Ada Bindings for C and C++ headers in GNAT Users Guide , which provides detailed documentation on this feature. -fdump-go-spec=file For input les in any language, generate corresponding Go declarations in le. 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 le. The options read are inserted in place of the original @le option. If le does not exist, or cannot be read, then the option will be treated literally, and not removed. Options in le 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 prexing the character to be included with a backslash. The le may itself contain additional @le options; any such options will be processed recursively.

3.3 Compiling C++ Programs

C++ source les conventionally use one of the suxes .C, .cc, .cpp, .CPP, .c++, .cp, or .cxx; C++ header les often use .hh, .hpp, .H, or (for shared template code) .tcc; and preprocessed C++ les use the sux .ii. GCC recognizes les 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 species linking against the C++ library. It treats .c, .h and .i les as C++ source les instead of C source les unless -x is used. This program is also useful

30

Using the GNU Compiler Collection (GCC)

when precompiling a C header le with a .h extension for use in C++ compilations. On many systems, g++ is also installed with the name c++. When you compile C++ programs, you may specify many of the same command-line options that you use for compiling programs in any language; or command-line options meaningful for C and related languages; or options that are meaningful only for C++ programs. See Section 3.4 [Options Controlling C Dialect], page 30, for explanations of options for languages related to C. See Section 3.5 [Options Controlling C++ Dialect], page 35, 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 o 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 predened macros such as unix and vax that identify the type of system you are using. It also enables the undesirable and rarely used ISO trigraph feature. For the C compiler, it disables recognition of C++ style // comments as well as the inline keyword. The alternate keywords __asm__, __extension__, __inline__ and __typeof_ _ continue to work despite -ansi. You would not want to use them in an ISO C program, of course, but it is useful to put them in header les that might be included in compilations done with -ansi. Alternate predened 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 50. The macro __STRICT_ANSI__ is predened when the -ansi option is used. Some header les may notice this macro and refrain from declaring certain functions or dening certain macros that the ISO standard doesnt 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 dened by ISO C (such as alloca and ffs) are not built-in functions when -ansi is used. See Section 6.55 [Other built-in functions provided by GCC], page 451, for details of the functions aected. Determine the language standard. See Chapter 2 [Language Standards Supported 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 specied, the compiler accepts all programs following that standard plus those using GNU extensions that do not contradict it. For example,

-std=

Chapter 3: GCC Command Options

31

-std=c90 turns o 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 specied, 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 conict with ISO C90 are disabled). Same as -ansi for C code. iso9899:199409 ISO C90 as modied in amendment 1. c99 c9x iso9899:1999 iso9899:199x ISO C99. Note that this standard is not yet fully supported; see [Link] 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. Support is incomplete and experimental. The name c1x is deprecated. gnu90 gnu89 gnu99 gnu9x gnu11 gnu1x c++98 c++03 GNU dialect of ISO C90 (including some C99 features). This is the default for C code. GNU dialect of ISO C99. When ISO C99 is fully implemented in GCC, this will become the default. The name gnu9x is deprecated. GNU dialect of ISO C11. Support is incomplete and experimental. The name gnu1x is deprecated. The 1998 ISO C++ standard plus the 2003 technical corrigendum and some additional defect reports. Same as -ansi for C++ code.

32

Using the GNU Compiler Collection (GCC)

gnu++98 gnu++03 c++11 c++0x

GNU dialect of -std=c++98. This is the default for C++ code. The 2011 ISO C++ standard plus amendments. Support for C++11 is still experimental, and may change in incompatible ways in future releases. The name c++0x is deprecated. GNU dialect of -std=c++11. Support for C++11 is still experimental, and may change in incompatible ways in future releases. The name gnu++0x is deprecated. 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. GNU dialect of -std=c++1y. Support is highly experimental, and will almost certainly change in incompatible ways in future releases.

gnu++11 gnu++0x

c++1y

gnu++1y

-fgnu89-inline The option -fgnu89-inline tells GCC to use the traditional GNU semantics for inline functions when in C99 mode. See Section 6.39 [An Inline Function is As Fast As a Macro], page 397. This option is accepted and ignored by GCC versions 4.1.3 up to but not including 4.3. In GCC versions 4.3 and later it changes the behavior of GCC in C99 mode. Using this option is roughly equivalent to adding the gnu_inline function attribute to all inline functions (see Section 6.30 [Function Attributes], page 348). The option -fno-gnu89-inline explicitly tells GCC to use the C99 semantics for inline when in C99 or gnu99 mode (i.e., it species the default behavior). This option was rst supported in GCC 4.3. This option is not supported in -std=c90 or -std=gnu90 mode. The preprocessor macros __GNUC_GNU_INLINE__ and __GNUC_STDC_INLINE__ may be used to check which semantics are in eect for inline functions. See Section Common Predened Macros in The C Preprocessor . -aux-info filename Output to the given lename prototyped declarations for all functions declared and/or dened in a translation unit, including those in header les. This option is silently ignored in any language other than C. Besides declarations, the le indicates, in comments, the origin of each declaration (source le and line), whether the declaration was implicit, prototyped or unprototyped (I, N for new or O for old, respectively, in the rst character after the line number and the colon), and whether it came from a declaration or a denition (C or F, respectively, in the following character). In the case of function denitions, a K&R-style list of arguments followed by their declarations is also provided, inside comments, after the declaration. -fallow-parameterless-variadic-functions Accept variadic functions without named parameters.

Chapter 3: GCC Command Options

33

Although it is possible to dene 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 identiers. You can use the keywords __asm__, __inline__ and __typeof__ instead. -ansi implies -fno-asm. In C++, this switch only aects the typeof keyword, since asm and inline are standard keywords. You may want to use the -fno-gnu-keywords ag instead, which has the same eect. In C99 mode (-std=c99 or -std=gnu99), this switch only aects the asm and typeof keywords, since inline is a standard keyword in ISO C99. -fno-builtin -fno-builtin-function Dont recognize built-in functions that do not begin with __builtin_ as prex. See Section 6.55 [Other built-in functions provided by GCC], page 451, for details of the functions aected, 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 eciently; 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 dierent 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 ecient 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 dene macros such as:
#define abs(n) #define strcpy(d, s) __builtin_abs ((n)) __builtin_strcpy ((d), (s))

-fhosted Assert that compilation targets a hosted environment. This implies -fbuiltin. A hosted environment is one in which the entire standard library is available, and in which main has a return type of int. Examples are nearly everything except a kernel. This is equivalent to -fno-freestanding.

34

Using the GNU Compiler Collection (GCC)

-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. -fopenmp Enable handling of OpenMP directives #pragma omp in C/C++ and !$omp in Fortran. When -fopenmp is specied, the compiler generates parallel code according to the OpenMP Application Program Interface v3.0 [Link] This option implies -pthread, and thus is only supported on targets that have support for -pthread. When the option -fgnu-tm is specied, the compiler generates code for the Linux variant of Intels current Transactional Memory ABI specication document (Revision 1.1, May 6 2009). This is an experimental feature whose interface may change in future versions of GCC, as the ocial specication changes. Please note that not all architectures are supported for this feature. For more information on GCCs 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).

-fgnu-tm

-fms-extensions Accept some non-standard constructs used in Microsoft header les. 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 elds in structures and unions are only accepted with this option. See Section 6.59 [Unnamed struct/union elds within structs/unions], page 641, for details. -fplan9-extensions Accept some non-standard constructs used in Plan 9 code. This enables -fms-extensions, permits passing pointers to structures with anonymous elds to functions that expect pointers to elements of the type of the eld, and permits referring to anonymous elds declared using a typedef. See Section 6.59 [Unnamed struct/union elds within structs/unions], page 641, for details. This is only supported for C, not C++. -trigraphs Support ISO C trigraphs. The -ansi option (and -std options for strict ISO C conformance) implies -trigraphs.

Chapter 3: GCC Command Options

35

-traditional -traditional-cpp Formerly, these options caused GCC to attempt to emulate a pre-standard C compiler. They are now only supported with the -E switch. The preprocessor continues to support a pre-standard mode. See the GNU CPP manual for details. -fcond-mismatch Allow conditional expressions with mismatched types in the second and third arguments. The value of such an expression is void. This option is not supported for C++. -flax-vector-conversions Allow implicit conversions between vectors with diering numbers of elements and/or incompatible element types. This option should not be used for new code. -funsigned-char Let the type char be unsigned, like unsigned char. Each kind of machine has a default for what char should be. It is either like unsigned char by default or like signed char by default. Ideally, a portable program should always use signed char or unsigned char when it depends on the signedness of an object. But many programs have been written to use plain char and expect it to be signed, or expect it to be unsigned, depending on the machines they were written for. This option, and its inverse, let you make such a program work with the opposite default. The type char is always a distinct type from each of signed char or unsigned char, even though its behavior is always just like one of those two. -fsigned-char Let the type char be signed, like signed char. Note that this is equivalent to -fno-unsigned-char, which is the negative form of -funsigned-char. Likewise, the option -fno-signed-char is equivalent to -funsigned-char. -fsigned-bitfields -funsigned-bitfields -fno-signed-bitfields -fno-unsigned-bitfields These options control whether a bit-eld is signed or unsigned, when the declaration does not use either signed or unsigned. By default, such a bit-eld is signed, because this is consistent: the basic integer types such as int are signed types.

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 le firstClass.C like this:

36

Using the GNU Compiler Collection (GCC)

g++ -g -frepo -O -c firstClass.C

In this example, only -frepo is an option meant only for C++ programs; you can use the other options with any language supported by GCC. Here is a list of options that are only for compiling C++ programs: -fabi-version=n Use version n of the C++ ABI. The default is version 2. Version 0 refers to the version conforming most closely to the C++ ABI specication. Therefore, the ABI obtained using version 0 will change in dierent versions of G++ as ABI bugs are xed. Version 1 is the version of the C++ ABI that rst appeared in G++ 3.2. Version 2 is the version of the C++ ABI that rst appeared in G++ 3.4. Version 3 corrects an error in mangling a constant address as a template argument. Version 4, which rst appeared in G++ 4.5, implements a standard mangling for vector types. Version 5, which rst 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 rst appeared in G++ 4.7, corrects the promotion behavior of C++11 scoped enums and the mangling of template argument packs, const/static cast, prex ++ and , and a class scope function used as a template argument. See also -Wabi. -fno-access-control Turn o all access checking. This switch is mainly useful for working around bugs in the access control code. -fcheck-new Check that the pointer returned by operator new is non-null before attempting to modify the storage allocated. This check is normally unnecessary because the C++ standard species 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 specication, memory exhaustion is signalled by throwing std::bad_ alloc. See also new (nothrow). -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 specied by the standard is 512. -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)) {

Chapter 3: GCC Command Options

37

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 proposed semantics for the C++11 standard, but was not part of the nal 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, and versions of G++ before 4.1 always worked that way. However, in ISO C++ a friend function that is not declared in an enclosing scope can only be found using argument dependent lookup. This option causes friends to be injected as they were in earlier releases. This option is for compatibility, and may be removed in a future release of G++. -fno-elide-constructors The C++ standard allows an implementation to omit creating a temporary 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 cases. -fno-enforce-eh-specs Dont generate code to check for violation of exception specications at run time. This option violates the C++ standard, but may be useful for reducing code size in production builds, much like dening NDEBUG. This does not give user code permission to throw exceptions in violation of the exception specications; the compiler still optimizes based on the specications, so throwing an unexpected exception results in undened 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 denition of the variable are in the same translation unit, this overhead can be optimized away, but when the use is in a dierent translation unit there is signicant overhead even if the variable doesnt actually need dynamic initialization. If the programmer can be sure that no use of the variable in a non-dening TU needs to trigger dynamic initialization (either because the variable is statically initialized, or a use of the variable in the dening TU will be executed before any uses in another TU), they can avoid this overhead with the -fno-extern-tls-init option.

38

Using the GNU Compiler Collection (GCC)

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 specied, the scope of variables declared in a for-initstatement is limited to the for loop itself, as specied by the C++ standard. If -fno-for-scope is specied, the scope of variables declared in a for-initstatement 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 ag 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 dierent behavior. -fno-gnu-keywords Do not recognize typeof as a keyword, so that code can use this word as an identier. You can use the keyword __typeof__ instead. -ansi implies -fno-gnu-keywords. -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 650, for more information. -fno-implicit-inline-templates Dont emit code for implicit instantiations of inline templates, either. The default is to handle inlines dierently so that compiles with and without optimization 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. -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 specication as if it were a noexcept specication to reduce or eliminate the text size overhead relative to a function with no exception specication. If the function has local variables of types with non-trivial destructors, the exception specication actually makes the function smaller because the EH cleanups for those variables can be optimized away. The semantic eect is that an exception thrown out of a function with such an exception specication results in a call to terminate rather than unexpected.

Chapter 3: GCC Command Options

39

-fno-operator-names Do not treat the operator name keywords and, bitand, bitor, compl, not, or and xor as synonyms as keywords. -fno-optional-diags Disable diagnostics that the standard says a compiler does not need to issue. Currently, the only such diagnostic issued by G++ is the one for a name having multiple meanings within a class. -fpermissive Downgrade some diagnostics about nonconformant code from errors to warnings. Thus, using -fpermissive allows some nonconforming code to compile. -fno-pretty-templates When an error message refers to a specialization of a function template, the compiler normally prints the signature of the template followed by the template arguments and any typedefs or typenames in the signature (e.g. void f(T) [with T = int] rather than void f(int)) so that its clear which template is involved. When an error message refers to a specialization of a class template, the compiler 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 implies -fno-implicit-templates. See Section 7.5 [Template Instantiation], page 650, for more information. Disable generation of information about every class with virtual functions for use by the C++ run-time type identication features (dynamic_cast and typeid). If you dont use those parts of the language, you can save some space by using this ag. 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. -fstats Emit statistics about front-end processing at the end of the compilation. This information is generally only useful to the G++ development team.

-fno-rtti

-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 dened 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. -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.

40

Using the GNU Compiler Collection (GCC)

-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 specied in the C++ ABI for thread-safe initialization of local statics. You can use this option to reduce code size slightly in code that doesnt 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 Dont 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 dierent shared objects. The eect of this is that GCC may, eectively, 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 eect 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 aect static variables local to the function or cause the compiler to deduce that the function is dened in only one shared object. You may mark a method as having a visibility explicitly to negate the eect 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 eect. Explicitly instantiated inline methods are unaected by this option as their linkage might otherwise cross a shared library boundary. See Section 7.5 [Template Instantiation], page 650. -fvisibility-ms-compat This ag attempts to use visibility settings to make GCCs C++ linkage model compatible with that of Microsoft Visual Studio.

Chapter 3: GCC Command Options

41

The ag makes these changes to GCCs 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 Denition Rule is relaxed for types without explicit visibility specications that are dened in more than one shared object: those declarations 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 dened in dierent shared objects are dierent, so changing one does not change the other; and that pointers to function members dened in dierent shared objects may not compare equal. When this ag is given, it is a violation of the ODR to dene types with the same name dierently. -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 benets. This option may be removed in a future release of G++. -nostdinc++ Do not search for header les in the standard directories specic to C++, but do still search the other standard directories. (This option is used when building the C++ library.) In addition, these optimization, warning, and code generation options have meanings only for C++ programs: -fno-default-inline Do not assume inline for functions dened inside a class scope. See Section 3.10 [Options That Control Optimization], page 97. Note that these functions have linkage like inline functions; they just arent inlined by default. -Wabi (C, Objective-C, C++ and Objective-C++ only) Warn when G++ generates code that is probably not compatible with the vendor-neutral C++ ABI. Although an eort 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. The known incompatibilities in -fabi-version=2 (the default) include: A template with a non-type template parameter of reference type is mangled incorrectly:

42

Using the GNU Compiler Collection (GCC)

extern int N; template <int &> struct S {}; void n (S<N>) {2}

This is xed in -fabi-version=3. SIMD vector types declared using __attribute ((vector_size)) are mangled in a non-standard way that does not allow for overloading of functions taking vectors of dierent sizes. The mangling is changed in -fabi-version=4. The known incompatibilities in -fabi-version=1 include: Incorrect handling of tail-padding for bit-elds. G++ may attempt to pack data into the same byte as a base class. For example:
struct A { virtual void f(); int f1 : 1; }; struct B : public A { int f2 : 1; };

In this case, G++ places B::f2 into the same byte as A::f1; other compilers do not. You can avoid this problem by explicitly padding A so that its size is a multiple of the byte size on your platform; that causes G++ and other compilers to lay out B identically. Incorrect handling of tail-padding for virtual bases. G++ does not use tail padding when laying out virtual bases. For example:
struct A { virtual void f(); char c1; }; struct B { B(); char c2; }; struct C : public A, public virtual B {};

In this case, G++ does not place B into the tail-padding for A; other compilers do. You can avoid this problem by explicitly padding A so that its size is a multiple of its alignment (ignoring virtual base classes); that causes G++ and other compilers to lay out C identically. Incorrect handling of bit-elds with declared widths greater than that of their underlying types, when the bit-elds appear in a union. For example:
union U { int i : 4096; };

Assuming that an int does not have 4096 bits, G++ makes the union too small by the number of bits in an int. Empty classes can be placed at incorrect osets. For example:
struct A {}; struct B { A a; virtual void f (); }; struct C : public B, public A {};

G++ places the A base class of C at a nonzero oset; it should be placed at oset zero. G++ mistakenly believes that the A data member of B is already at oset zero. Names of template functions whose types involve typename or template template parameters can be mangled incorrectly.
template <typename Q>

Chapter 3: GCC Command Options

43

void f(typename Q::X) {} template <template <typename> class Q> void f(typename Q<int>::X) {}

Instantiations of these templates may be mangled incorrectly. It also warns 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 specied in psABI. For example:
union U { long double ld; int i; };

union U is always passed in memory. -Wctor-dtor-privacy (C++ and Objective-C++ only) Warn when a class seems unusable because all the constructors or destructors in that class are private, and it has neither friends nor public static member functions. Also warn if there are no non-private methods, and theres at least one private member function that isnt 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-sux which does not begin with an underscore. As a conforming extension, GCC treats such suxes 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. This warning is enabled by default. -Wnarrowing (C++ and Objective-C++ only) Warn when a narrowing conversion prohibited by C++11 occurs within { }, e.g.
int i = { 2.2 }; // error: narrowing from double to int

This ag is included in -Wall and -Wc++11-compat. With -std=c++11, -Wno-narrowing suppresses the diagnostic required by the standard. Note that this does not aect the meaning of well-formed code; narrowing conversions are still considered ill-formed in SFINAE context.

44

Using the GNU Compiler Collection (GCC)

-Wnoexcept (C++ and Objective-C++ only) Warn when a noexcept-expression evaluates to false because of a call to a function that does not have a non-throwing exception specication (i.e. throw() or noexcept) but is known by the compiler to never throw an exception. -Wnon-virtual-dtor (C++ and Objective-C++ only) Warn when a class has virtual functions and an accessible non-virtual destructor, in which case it is possible but unsafe to delete an instance of a derived class through a pointer to the base class. This warning is also enabled if -Weffc++ is specied. -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 declaration order of the members, emitting a warning to that eect. This warning is enabled by -Wall. -fext-numeric-literals (C++ and Objective-C++ only) Accept imaginary, xed-point, or machine-dened literal number suxes as GNU extensions. When this option is turned o these suxes are treated as C++11 user-dened literal numeric suxes. 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++1y. This option is o by default for ISO C++11 onwards (-std=c++11, ...). The following -W... options are not aected by -Wall. -Weffc++ (C++ and Objective-C++ only) Warn about violations of the following style guidelines from Scott Meyers Effective C++, Second Edition book: Item 11: Dene a copy constructor and an assignment operator for classes with dynamically-allocated memory. Item 12: Prefer initialization to assignment in constructors. Item 14: Make destructors virtual in base classes. Item 15: Have operator= return a reference to *this. Item 23: Dont try to return a reference when you must return an object. Also warn about violations of the following style guidelines from Scott Meyers More Eective C++ book: Item 6: Distinguish between prex and postx forms of increment and decrement operators. Item 7: Never overload &&, ||, or ,. When selecting this option, be aware that the standard library headers do not obey all of these guidelines; use grep -v to lter out those warnings.

Chapter 3: GCC Command Options

45

-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 dened 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 dierent compilers. -Wno-non-template-friend (C++ and Objective-C++ only) Disable warnings when non-templatized friend functions are declared within a template. Since the advent of explicit template specication support in G++, if the name of the friend is an unqualied-id (i.e., friend foo(int)), the C++ language specication demands that the friend declare or dene an ordinary, nontemplate function. (Section 14.5.3). Before G++ implemented explicit specication, unqualied-ids could be interpreted as a particular specialization of a templatized function. Because this non-conforming behavior is no longer the default behavior for G++, -Wnon-template-friend allows the compiler to check existing code for potential trouble spots and is on by default. This new compiler behavior can be turned o with -Wno-non-template-friend, which keeps the conformant compiler code but disables the helpful warning. -Wold-style-cast (C++ and Objective-C++ only) Warn if an old-style (C-style) cast to a non-void type is used within a C++ program. The new-style casts (dynamic_cast, static_cast, reinterpret_cast, and const_cast) are less vulnerable to unintended eects and much easier to search for. -Woverloaded-virtual (C++ and Objective-C++ only) Warn when a function declaration hides virtual functions from a base class. For example, in:
struct A { virtual void f(); }; struct B: public A { void f(int); };

the A class version of f is hidden in B, and code like:

B* b; b->f();

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 enumerated 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.

46

Using the GNU Compiler Collection (GCC)

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

(NOTE: This manual does not describe the Objective-C and Objective-C++ languages themselves. See Chapter 2 [Language Standards Supported by GCC], page 5, for references.) This section describes the command-line options that are only meaningful for ObjectiveC and Objective-C++ programs. You can also use most of the language-independent GNU compiler options. For example, you might compile a le 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 ObjectiveC++ programs; you can use the other options with any language supported by GCC. Note that since Objective-C is an extension of the C language, Objective-C compilations may also use options specic to the C front-end (e.g., -Wtraditional). Similarly, Objective-C++ compilations may use C++-specic 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 specied 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 predened 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 ecient 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 ObjectiveC 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 specied, the default is Version 0 on 32-bit target machines, and Version 2 on 64-bit target machines. -fobjc-call-cxx-cdtors For each Objective-C class, check if any of its instance variables is a C++ object with a non-trivial default constructor. If so, synthesize a special - (id)

Chapter 3: GCC Command Options

47

.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 objects 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 support for invoking the - (id) .cxx_construct and - (void) .cxx_destruct methods. -fobjc-direct-dispatch Allow fast jumps to the message dispatcher. On Darwin this is accomplished via the comm page. -fobjc-exceptions Enable syntactic support for structured exception handling in Objective-C, similar to what is oered by C++ and Java. This option is required to use the Objective-C keywords @try, @throw, @catch, @finally and @synchronized. This option is available with both the GNU runtime and the NeXT runtime (but not available in conjunction with the NeXT runtime on Mac OS X 10.2 and earlier). -fobjc-gc Enable garbage collection (GC) in Objective-C and Objective-C++ programs. This option is only available with the NeXT runtime; the GNU runtime has a dierent garbage collection implementation that does not require special compiler ags. -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 ag is set to. Currently this ag 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 aects the Objective-C additions to the C/C++ language; it does not aect conformance to C/C++ standards, which is controlled by the separate C/C++ dialect option ags. When this option is used with the Objective-C or Objective-C++ compiler, any Objective-C syntax that is not

48

Using the GNU Compiler Collection (GCC)

recognized by GCC 4.0 is rejected. This is useful if you need to make sure that your Objective-C code can be compiled with older versions of GCC. -freplace-objc-classes Emit a special marker instructing ld(1) not to statically link in the resulting object le, 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 le 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 runtime performance. Specifying the -fzero-link ag 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 modied during program execution. The GNU runtime currently always retains calls to objc_get_class("...") regardless of command-line options. -gen-decls Dump interface declarations for all classes seen in the source le to a le named [Link]. -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 dierent types for the same selector are found during compilation. The check is performed on the list of methods in the nal 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 nal stage of compilation is not reached, for example because an error is found during compilation, or because the -fsyntax-only option is being used.

Chapter 3: GCC Command Options

49

-Wstrict-selector-match (Objective-C and Objective-C++ only) Warn if multiple methods with diering 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 ag is o (which is the default behavior), the compiler omits such warnings if any dierences found are conned 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 nal stage of compilation. This also enforces the coding style convention that methods and selectors must be declared before being used. -print-objc-runtime-info Generate C header describing the largest structure that is passed by value, if any.

3.7 Options to Control Diagnostic Messages Formatting

Traditionally, diagnostic messages have been formatted irrespective of the output devices aspect (e.g. its width, . . . ). You can use the options described below to control the formatting 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 t on lines of about n characters. The default is 72 characters for g++ and 0 for the rest of the front ends supported by GCC. If n is zero, then no line-wrapping is done; each error message appears on a single line. -fdiagnostics-show-location=once Only meaningful in line-wrapping mode. Instructs the diagnostic messages reporter to emit source location information once ; that is, in case the message is too long to t on a single physical line and has to be wrapped, the source location wont be emitted (as prex) again, over and over, in subsequent continuation lines. This is the default behavior. -fdiagnostics-show-location=every-line Only meaningful in line-wrapping mode. Instructs the diagnostic messages reporter to emit the same source location information (as prex) for physical lines that result from the process of breaking a message which is too long to t on a single line. -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

50

Using the GNU Compiler Collection (GCC)

diagnostic machinery). Specifying the -fno-diagnostics-show-option ag 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.

3.8 Options to Request or Suppress Warnings

Warnings are diagnostic messages that report constructions that are not inherently erroneous but that are risky or suggest there may have been an error. The following language-independent options do not enable specic warnings but control the kinds of diagnostics produced by GCC. -fsyntax-only Check the code for syntax errors, but dont 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 specied, then -Wfatal-errors takes precedence over this option. -w -Werror -Werror= Inhibit all warning messages. Make all warnings into errors. Make the specied warning into an error. The specier 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 specic warnings; for example -Wno-error=switch makes -Wswitch warnings not be errors, even when -Werror is in eect. 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 message can be disabled using the -fno-diagnostics-show-option ag.) Note that specifying -Werror=foo automatically implies -Wfoo. However, -Wno-error=foo does not imply anything. -Wfatal-errors This option causes the compiler to abort compilation on the rst error occurred rather than trying to keep going and printing further error messages. You can request many specic warnings with options beginning with -W, for example -Wimplicit to request warnings on implicit declarations. Each of these specic warning options also has a negative form beginning -Wno- to turn o warnings; for example, -Wno-implicit. This manual lists only one of the two forms, whichever is not the default. For further language-specic options also refer to Section 3.5 [C++ Dialect Options], page 35 and Section 3.6 [Objective-C and Objective-C++ Dialect Options], page 46.

Chapter 3: GCC Command Options

51

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 dierent: 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 programs that use forbidden extensions, and some other programs that do not follow ISO C and ISO C++. For ISO C, follows the version of the ISO C standard specied 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 les should use these escape routes; application programs should avoid them. See Section 6.45 [Alternate Keywords], page 438. Some users try to use -Wpedantic to check programs for strict ISO C conformance. They soon nd that it does not do quite what they want: it nds some non-ISO practices, but not allonly those for which ISO C requires a diagnostic, and some others for which diagnostics have been added. A feature to report any failure to conform to ISO C might be useful in some instances, but would require considerable additional work and would be quite dierent from -Wpedantic. We dont have plans to support such a feature in the near future. Where the standard specied 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 specied GNU C dialect, since by denition the GNU dialects of C include all features the compiler supports with the given option, and there would be nothing to warn about.) -pedantic-errors Like -Wpedantic, except that errors are produced rather than warnings. -Wall This enables all the warnings about constructions that some users consider questionable, and that are easy to avoid (or modify to prevent the warning), even in conjunction with macros. This also enables some language-specic warnings described in Section 3.5 [C++ Dialect Options], page 35 and Section 3.6 [Objective-C and Objective-C++ Dialect Options], page 46.

52

Using the GNU Compiler Collection (GCC)

-Wall turns on the following warning ags:

-Waddress -Warray-bounds (only with -O2) -Wc++11-compat -Wchar-subscripts -Wenum-compare (in C/ObjC; this is on by default in C++) -Wimplicit-int (C and Objective-C only) -Wimplicit-function-declaration (C and Objective-C only) -Wcomment -Wformat -Wmain (only for C/ObjC and unless -ffreestanding) -Wmaybe-uninitialized -Wmissing-braces (only for C/ObjC) -Wnonnull -Wparentheses -Wpointer-sign -Wreorder -Wreturn-type -Wsequence-point -Wsign-compare (only in C++) -Wstrict-aliasing -Wstrict-overflow=1 -Wswitch -Wtrigraphs -Wuninitialized -Wunknown-pragmas -Wunused-function -Wunused-label -Wunused-value -Wunused-variable -Wvolatile-register-var

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

The option -Wextra also prints warning messages for the following cases:

Chapter 3: GCC Command Options

53

A pointer is compared against integer zero with <, <=, >, or >=. (C++ only) An enumerator and a non-enumerator both appear in a conditional expression. (C++ only) Ambiguous virtual bases. (C++ only) Subscripting an array that has been declared register. (C++ only) Taking the address of a variable that has been declared register. (C++ only) A base class is not initialized in a derived classs copy constructor. -Wchar-subscripts Warn if an array subscript has type char. This is a common cause of error, as programmers often forget that this type is signed on some machines. This warning is enabled by -Wall. -Wcomment Warn whenever a comment-start sequence /* appears in a /* comment, or whenever a Backslash-Newline appears in a // comment. This warning is enabled by -Wall. -Wno-coverage-mismatch Warn if feedback proles do not match when using the -fprofile-use option. If a source le is changed between compiling with -fprofile-gen and with -fprofile-use, the les with the prole feedback can fail to match the source le and GCC cannot use the prole 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 xes 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 oating-point unit implement float in hardware, but emulate double in software. On such a machine, doing computations using double values is much more expensive because of the overhead required for software emulation. It is easy to accidentally do computations with double because oating-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 oatingpoint literal is a double.

54

Using the GNU Compiler Collection (GCC)

-Wformat -Wformat=n Check calls to printf and scanf, etc., to make sure that the arguments supplied have types appropriate to the format string specied, and that the conversions specied in the format string make sense. This includes standard functions, and others specied by format attributes (see Section 6.30 [Function Attributes], page 348), in the printf, scanf, strftime and strfmon (an X/Open extension, not in the C standard) families (or other target-specic families). Which functions are checked without format attributes having been specied depends on the standard version selected, and such checks of functions without the attribute specied 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 Specication and some BSD and GNU extensions. Other library implementations may not support all these features; GCC does not support warning about features that go beyond a particular librarys limitations. However, if -Wpedantic is used with -Wformat, warnings are given about format features not in the selected standard version (but not for strfmon formats, since those are not in any version of the C standard). See Section 3.4 [Options Controlling C Dialect], page 30. -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 specied, do not warn about format strings that contain NUL bytes. -Wno-format-extra-args If -Wformat is specied, do not warn about excess arguments to a printf or scanf format function. The C standard species that such arguments are ignored. Where the unused arguments lie between used arguments that are specied with $ operand number specications, 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 unused arguments are all pointers, since the Single Unix Specication says that such unused arguments are allowed. -Wno-format-zero-length If -Wformat is specied, do not warn about zero-length formats. The C standard species that zero-length formats are allowed.

Chapter 3: GCC Command Options

55

-Wformat=2 Enable -Wformat plus additional format checks. Currently equivalent to -Wformat -Wformat-nonliteral -Wformat-security -Wformat-y2k. -Wformat-nonliteral If -Wformat is specied, 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 specied, also warn about uses of format functions that represent possible security problems. At present, this warns about calls to printf and scanf functions where the format string is not a string literal and there are no format arguments, as in printf (foo);. This may be a security hole if the format string came from untrusted input and contains %n. (This is currently a subset of what -Wformat-nonliteral warns about, but in future warnings may be added to -Wformat-security that are not included in -Wformat-nonliteral.) -Wformat-y2k If -Wformat is specied, 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. -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 specied:
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.

56

Using the GNU Compiler Collection (GCC)

-Wimplicit (C and Objective-C only) Same as -Wimplicit-int and -Wimplicit-function-declaration. This warning is enabled by -Wall. -Wignored-qualifiers (C and C++ only) Warn if the return type of a function has a type qualier such as const. For ISO C such a type qualier has no eect, 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 qualied void return types on function denitions, so such return types always receive a warning even without this option. This warning is also enabled by -Wextra. -Wmain Warn if the type of main is suspicious. main should be a function with external linkage, returning int, taking either zero arguments, two, or three arguments of appropriate types. This warning is enabled by default in C++ and is enabled by either -Wall or -Wpedantic.

-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 dierent interpretation from that of ordinary mathematical notation. Also warn about constructions where there may be confusion to which if statement an else branch belongs. Here is an example of such a case:
{ if (a) if (b) foo (); else bar (); }

In C/C++, every else branch belongs to the innermost possible if statement, which in this example is if (b). This is often not what the programmer expected, as illustrated in the above example by indentation the programmer chose. When there is the potential for this confusion, GCC issues a warning when this ag is specied. 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:

Chapter 3: GCC Command Options

57

{ if (a) { if (b) foo (); else bar (); } }

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 undened semantics because of violations of sequence point rules in the C and C++ standards. The C and C++ standards dene the order in which expressions in a C/C++ program are evaluated in terms of sequence points, which represent a partial ordering between the execution of parts of the program: those executed before the sequence point, and those executed after it. These occur after the evaluation of a full expression (one which is not part of a larger expression), after the evaluation of the rst operand of a &&, ||, ? : or , (comma) operator, before a function is called (but after the evaluation of its arguments and the expression denoting the called function), and in certain other places. Other than as expressed by the sequence point rules, the order of evaluation of subexpressions of an expression is not specied. 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 specied. However, the standards committee have ruled that function calls do not overlap. It is not specied when between sequence points modications to the values of objects take eect. Programs whose behavior depends on this have undened behavior; the C and C++ standards specify that Between the previous and next sequence point an object shall have its stored value modied 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 undened 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 eective at detecting this sort of problem in programs. The standard is worded confusingly, therefore there is some debate over the precise meaning of the sequence point rules in subtle cases. Links to discussions of the problem, including proposed formal denitions, may be found on the GCC readings page, at [Link] This warning is enabled by -Wall for C and C++.

58

Using the GNU Compiler Collection (GCC)

-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 dened 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 o the end of the function body is considered returning without a value), and about a return statement with an expression in a function whose return type is void. For C++, a function without return type always produces a diagnostic message, even when -Wno-return-type is specied. The only exceptions are main and functions dened in system headers. This warning is enabled by -Wall. -Wswitch Warn whenever a switch statement has an index of enumerated type and lacks a case for one or more of the named codes of that enumeration. (The presence of a default label prevents this warning.) case labels outside the enumeration range also provoke warnings when this option is used (even if there is a default label). This warning is enabled by -Wall.

-Wswitch-default Warn whenever a switch statement does not have a default case. -Wswitch-enum Warn whenever a switch statement has an index of enumerated type and lacks a case for one or more of the named codes of that enumeration. case labels outside the enumeration range also provoke warnings when this option is used. The only dierence between -Wswitch and this option is that this option gives a warning about an omitted enumeration code even if there is a default label. -Wsync-nand (C and C++ only) Warn when __sync_fetch_and_nand and __sync_nand_and_fetch built-in functions are used. These functions changed semantics in GCC 4.4. -Wtrigraphs Warn if any trigraphs are encountered that might change the meaning of the program (trigraphs within comments are not warned about). This warning is enabled by -Wall. -Wunused-but-set-parameter Warn whenever a function parameter is assigned to, but otherwise unused (aside from its declaration). To suppress this warning use the unused attribute (see Section 6.36 [Variable Attributes], page 382). 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.

Chapter 3: GCC Command Options

59

To suppress this warning use the unused attribute (see Section 6.36 [Variable Attributes], page 382). This warning is also enabled by -Wunused, which is enabled by -Wall. -Wunused-function Warn whenever a static function is declared but not dened 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.36 [Variable Attributes], page 382). -Wunused-local-typedefs (C, Objective-C, C++ and Objective-C++ only) Warn when a typedef locally dened 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.36 [Variable Attributes], page 382). -Wno-unused-result Do not warn if a caller of a function marked with attribute warn_unused_ result (see Section 6.30 [Function Attributes], page 348) does not use its return value. The default is -Wunused-result. -Wunused-variable Warn whenever a local variable or non-constant static variable is unused aside from its declaration. This warning is enabled by -Wall. To suppress this warning use the unused attribute (see Section 6.36 [Variable Attributes], page 382). -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 eects. 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 separately specify -Wunused-parameter.

-Wuninitialized Warn if an automatic variable is used without rst 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.

60

Using the GNU Compiler Collection (GCC)

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 structure, union or array variables as well as for variables that are uninitialized or clobbered as a whole. They do not occur for variables or elements declared volatile. Because these warnings depend on optimization, the exact variables or elements for which there are warnings 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 ow analysis before the warnings are printed. -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 doesnt 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 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.30 [Function Attributes], page 348. This warning is enabled by -Wall or -Wextra.

Chapter 3: GCC Command Options

61

-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 les. 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 conicts 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 optimization. Higher levels correspond to higher accuracy (fewer false positives). Higher levels also correspond to more eort, 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 ow-sensitive points-to information. Only warns when the converted pointer is dereferenced. Does not warn about incomplete types. -Wstrict-overflow -Wstrict-overflow=n This option is only active when -fstrict-overflow is active. It warns about cases where the compiler optimizes based on the assumption that signed overow does not occur. Note that it does not warn about all cases where the code might overow: 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 overow does not occur is perfectly safe if the values of the variables involved are such that overow never does, in

62

Using the GNU Compiler Collection (GCC)

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 dened. No warnings are issued for the use of undened signed overow 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 simplies 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 simplied to a constant. For example: abs (x) >= 0. This can only be simplied when -fstrict-overflow is in eect, because abs (INT_MIN) overows 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 simplied. For example: x + 1 > 1 is simplied to x > 0. -Wstrict-overflow=4 Also warn about other simplications not covered by the above cases. For example: (x * 10) / 5 is simplied 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 simplied to x + 1 >= y. This is reported only at the highest warning level because this simplication applies to many comparisons, so this warning level gives a very large number of false positives. -Wsuggest-attribute=[pure|const|noreturn|format] Warn for cases where adding an attribute may be benecial. 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 doesnt contain an innite 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.

Chapter 3: GCC Command Options

63

-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 denitions that might be candidates for format attributes. Again, these are only possible candidates. 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. -Warray-bounds This option is only active when -ftree-vrp is active (default for -O2 and above). It warns about subscripts to arrays that are always out of bounds. This warning is enabled by -Wall. -Wno-div-by-zero Do not warn about compile-time integer division by zero. Floating-point division by zero is not warned about, as it can be a legitimate way of obtaining innities and NaNs. -Wsystem-headers Print warning messages for constructs found in system header les. 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 headersfor that, -Wunknown-pragmas must also be used. -Wtrampolines Warn about trampolines generated for pointers to nested functions. A trampoline is a small piece of data or code that is created at run time on the stack when the address of a nested function is taken, and is used to call the nested function indirectly. For some targets, it is made up of data only and thus requires no special treatment. But, for most targets, it is made up of code and thus requires the stack to be made executable in order for the program to work properly. -Wfloat-equal Warn if oating-point values are used in equality comparisons. The idea behind this is that sometimes it is convenient (for the programmer) to consider oating-point values as approximations to innitely precise real

64

Using the GNU Compiler Collection (GCC)

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 thats a dierent problem). In particular, instead 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 dierently 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 rst character on the line. It also suggests you hide directives like #pragma not understood by traditional C by indenting them. Some traditional 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 sux, or the F or L oating-point constant suxes. (Traditional C does support the L sux on integer constants.) Note, these suxes appear in macros dened 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 GCCs 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 dierent 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. Identier conicts with labels. Traditional C lacks a separate namespace for labels.

Chapter 3: GCC Command Options

65

Initialization of unions. If the initializer is zero, the warning is omitted. This is done under the assumption that the zero initializer in user code appears conditioned on e.g. __STDC__ to avoid missing initializer warnings and relies on default initialization to zero in the traditional C case. Conversions by prototypes between xed/oating-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 denitions. This warning intentionally is not issued for prototype declarations or variadic functions because these ISO C features appear in your code when using libibertys traditional C compatibility macros, PARAMS and VPARAMS. This warning is also bypassed for nested functions because that feature is already a GCC extension and thus not relevant to traditional C compatibility. -Wtraditional-conversion (C and Objective-C only) Warn if a prototype causes a type conversion that is dierent from what would happen to the same argument in the absence of a prototype. This includes conversions of xed point to oating and vice versa, and conversions changing the width or signedness of a xed-point argument except when the same as the default promotion. -Wdeclaration-after-statement (C and Objective-C only) Warn when a declaration is found after a statement in a block. This construct, known from C++, was introduced with ISO C99 and is by default allowed in GCC. It is not supported by ISO C90 and was not supported by GCC versions before GCC 3.0. See Section 6.29 [Mixed Declarations], page 348. -Wundef Warn if an undened identier is evaluated in an #if directive. -Wno-endif-labels Do not warn whenever an #else or an #endif are followed by text. -Wshadow Warn whenever a local variable or type declaration shadows another variable, parameter, type, or class member (in C++), or whenever a built-in function is shadowed. Note that in C++, the compiler warns if a local variable shadows an explicit typedef, but not if it shadows a struct/class/enum.

-Wlarger-than=len Warn whenever an object of larger than len bytes is dened. -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.

66

Using the GNU Compiler Collection (GCC)

-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 specied amount, its:
warning: stack usage is 1120 bytes

If the stack usage is (partly) dynamic but bounded, its:

warning: stack usage might be 1648 bytes

If the stack usage is (partly) dynamic and not bounded, its:

warning: stack usage might be unbounded

-Wunsafe-loop-optimizations Warn if the loop cannot be optimized because the compiler cannot assume anything on the bounds of the loop indices. With -funsafe-loop-optimizations warn if the compiler makes such assumptions. -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 speciers I32, I64, and I used on Windows targets, which depend on the MS runtime. -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. -Wtype-limits Warn if a comparison is always true or always false due to the limited range of the data type, but do not warn for constant expressions. For example, warn if an unsigned variable is compared against zero with < or >=. This warning is also enabled by -Wextra. -Wbad-function-cast (C and Objective-C only) Warn whenever a function call is cast to a non-matching type. For example, warn if int malloc() is cast to anything *. -Wc++-compat (C and Objective-C only) Warn about ISO C constructs that are outside of the common subset of ISO C and ISO C++, e.g. request for implicit conversion from void * to a pointer to non-void type. -Wc++11-compat (C++ and Objective-C++ only) Warn about C++ constructs whose meaning diers between ISO C++ 1998 and ISO C++ 2011, e.g., identiers in ISO C++ 1998 that are keywords in ISO C++ 2011. This warning turns on -Wnarrowing and is enabled by -Wall.

Chapter 3: GCC Command Options

67

-Wcast-qual Warn whenever a pointer is cast so as to remove a type qualier from the target type. For example, warn if a const char * is cast to an ordinary char *. Also warn when making a cast that introduces a type qualier 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 nd 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. -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-dened conversions; 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.

68

Using the GNU Compiler Collection (GCC)

-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. -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. -Wenum-compare Warn about a comparison between values of dierent enumerated types. In C++ enumeral 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. This warning is also enabled by -Wextra; to get the other warnings of -Wextra without this warning, use -Wextra -Wno-sign-compare. -Wsign-conversion Warn for implicit conversions that may change the sign of an integer value, like assigning a signed integer expression to an unsigned integer variable. An explicit cast silences the warning. In C, this option is enabled also by -Wconversion. -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 x, or about memcpy (&foo, ptr, sizeof (&foo));. 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 unspecied behavior and are

Chapter 3: GCC Command Options

69

not portable in C, so they usually indicate that the programmer intended to use strcmp. This warning is enabled by -Wall. -Wlogical-op Warn about suspicious uses of logical operators in expressions. This includes using logical operators in contexts where a bit-wise operator is likely to be expected. -Waggregate-return Warn if any functions that return structures or unions are dened or called. (In languages where you can return an array, this also elicits a warning.) -Wno-aggressive-loop-optimizations Warn if in a loop with constant number of iterations the compiler detects undened 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-macro-redefined Do not warn if certain built-in macros are redened. This suppresses warnings for redenition of __TIMESTAMP__, __TIME__, __DATE__, __FILE__, and __BASE_FILE__. -Wstrict-prototypes (C and Objective-C only) Warn if a function is declared or dened without specifying the argument types. (An old-style function denition is permitted without a warning if preceded by a declaration that species 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 speciers like static are not the rst 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 denition 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 specier in K&R-style functions:
void foo(bar) { }

This warning is also enabled by -Wextra. -Wmissing-prototypes (C and Objective-C only) Warn if a global function is dened without a previous prototype declaration. This warning is issued even if the denition itself provides a prototype. Use this option to detect global functions that do not have a matching prototype declaration in a header le. This option is not valid for C++ because all function declarations provide prototypes and a non-matching declaration

70

Using the GNU Compiler Collection (GCC)

will declare an overload rather than conict with an earlier declaration. Use -Wmissing-declarations to detect missing declarations in C++. -Wmissing-declarations Warn if a global function is dened without a previous declaration. Do so even if the denition itself provides a prototype. Use this option to detect global functions that are not declared in header les. In C, no warnings are issued for functions with previous non-prototype declarations; use -Wmissing-prototype to detect missing prototypes. In C++, no warnings are issued for function templates, or for inline functions, or for functions in anonymous namespaces. -Wmissing-field-initializers Warn if a structures initializer has some elds missing. For example, the following 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 modication does not trigger a warning:
struct s { int f, g, h; }; struct s x = { .f = 3, .g = 4 };

This warning is included in -Wextra. To get other -Wextra warnings without this one, use -Wextra -Wno-missing-field-initializers. -Wno-multichar Do not warn if a multicharacter constant (FOOF) is used. Usually they indicate a typo in the users code, as they have implementation-dened values, and should not be used in portable code. -Wnormalized=<none|id|nfc|nfkc> In ISO C and ISO C++, two identiers are dierent if they are dierent sequences of characters. However, sometimes when characters outside the basic ASCII character set are used, you can have two dierent 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 identiers 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 identier that is not in the ISO 10646 C normalized form, NFC. NFC is the recommended form for most uses. Unfortunately, there are some characters allowed in identiers by ISO C and ISO C++ that, when turned into NFC, are not allowed in identiers. That is, theres no way to use these symbols in portable ISO C or C++ and have all your identiers 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 o for all characters by writing -Wnormalized=none. You should only do this if you are using some

Chapter 3: GCC Command Options

71

other normalization scheme (like D), because otherwise you can easily create bugs that are literally impossible to see. Some characters in ISO 10646 have distinct meanings but look identical in some fonts or display methodologies, especially once formatting has been applied. For instance \u207F, SUPERSCRIPT LATIN SMALL LETTER N, displays just like a regular n that has been placed in a superscript. ISO 10646 denes 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 identier 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 xed to display these characters distinctly. -Wno-deprecated Do not warn about usage of deprecated features. See Section 7.12 [Deprecated Features], page 658. -Wno-deprecated-declarations Do not warn about uses of functions (see Section 6.30 [Function Attributes], page 348), variables (see Section 6.36 [Variable Attributes], page 382), and types (see Section 6.37 [Type Attributes], page 391) marked as deprecated by using the deprecated attribute. -Wno-overflow Do not warn about compile-time overow in constant expressions. -Woverride-init (C and Objective-C only) Warn if an initialized eld without side eects is overridden when using designated initializers (see Section 6.26 [Designated Initializers], page 345). This warning is included in -Wextra. To get other -Wextra warnings without this one, use -Wextra -Wno-override-init. -Wpacked Warn if a structure is given the packed attribute, but the packed attribute has no eect on the layout or size of the structure. Such structures may be mis-aligned for little benet. 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; };

-Wpacked-bitfield-compat The 4.1, 4.2 and 4.3 series of GCC ignore the packed attribute on bit-elds of type char. This has been xed in GCC 4.4 but the change can lead to dierences in the structure layout. GCC informs you when the oset of such a eld has changed in GCC 4.4. For example there is no longer a 4-bit padding between eld a and b in this structure:

72

Using the GNU Compiler Collection (GCC)

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 elds 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. -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 current function. Therefore, seemingly insignicant 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 1998 ISO C++ standard, applying offsetof to a non-POD type is undened. In existing C++ implementations, however, offsetof typically gives meaningful results even when applied to certain kinds of non-POD types (such as a simple struct that fails to be a POD type only by virtue of having a constructor). This ag is for users who are aware that they are writing nonportable code and who have deliberately chosen to ignore the warning about it. The restrictions on offsetof may be relaxed in a future version of the C++ standard. -Wno-int-to-pointer-cast Suppress warnings from casts to pointer type of an integer of a dierent size. In C++, casting to a pointer type of smaller size is an error. Wint-to-pointer-cast is enabled by default.

Chapter 3: GCC Command Options

73

-Wno-pointer-to-int-cast (C and Objective-C only) Suppress warnings from casts from a pointer to an integer type of a dierent size. -Winvalid-pch Warn if a precompiled header (see Section 3.20 [Precompiled Headers], page 311) is found in the search path but cant 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 messages, use -Wno-long-long. -Wvariadic-macros Warn if variadic macros are used in pedantic ISO C90 mode, or the GNU alternate syntax when in pedantic ISO C99 mode. This is default. To inhibit the warning messages, use -Wno-variadic-macros. -Wvarargs Warn upon questionable usage of the macros used to handle variable arguments 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 architecture. 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 ecient; and as a single scalar, which means that vector ts 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 will be moved multiple times, which can 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 variable length array is used in the code. -Wno-vla prevents the -Wpedantic warning of the variable length array.

-Wvolatile-register-var Warn if a register variable is declared volatile. The volatile modier 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 generally indicate that there is anything wrong with your code; it merely indicates that GCCs optimizers are unable to handle the code eectively. Often, the

74

Using the GNU Compiler Collection (GCC)

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 dierent 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. -Wno-mudflap Suppress warnings about constructs that cannot be instrumented by -fmudflap. -Woverlength-strings Warn about string constants that are longer than the minimum maximum length specied in the C standard. Modern compilers generally allow string constants that are much longer than the standards 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. -Wunsuffixed-float-constants (C and Objective-C only) Issue a warning for any oating constant that does not have a sux. When used together with -Wsystem-headers it warns about such constants in system header les. This can be useful when preparing code to use with the FLOAT_ CONST_DECIMAL64 pragma from the decimal oating-point extension to C99.

3.9 Options for Debugging Your Program or GCC

GCC has various special options that are used for debugging either your program or GCC: -g Produce debugging information in the operating systems native format (stabs, COFF, XCOFF, or DWARF 2). 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). GCC allows you to use -g with -O. The shortcuts taken by optimized code may occasionally produce surprising results: some variables you declared may

Chapter 3: GCC Command Options

75

not exist at all; ow of control may briey 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 dierent places because they have been moved out of loops. Nevertheless it proves possible to debug optimized output. This makes it reasonable to use the optimizer for programs that might have bugs. The following options are useful when GCC is generated with the capability for more than one debugging format. -gsplit-dwarf Separate as much dwarf debugging information as possible into a separate output le with the extension .dwo. This option allows the build system to avoid linking les with debug information. To be useful, this option requires a debugger capable of reading .dwo les. -ggdb Produce debugging information for use by GDB. This means to use the most expressive format available (DWARF 2, stabs, or the native format if neither of those are supported), including GDB extensions if at all possible. Generate dwarf .debug pubnames and .debug pubtypes sections. -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.

-gpubnames

-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 le, emit it in all object les 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. -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 ecient 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. -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.

76

Using the GNU Compiler Collection (GCC)

-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. Produce debugging information in XCOFF format (if that is supported). This is the format used by the DBX debugger on IBM RS/6000 systems. 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.

-gxcoff

-gxcoff+

-gdwarf-version Produce debugging information in DWARF format (if that is supported). The value of version may be either 2, 3 or 4; the default version for most targets is 4. Note that with DWARF Version 2, some ports require and always use some non-conicting DWARF 3 extensions in the unwind tables. Version 4 may require GDB 7.0 and -fvar-tracking-assignments for maximum benet. -grecord-gcc-switches This switch causes the command-line options used to invoke the compiler that may aect 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. See also -frecord-gcc-switches for another way of storing compiler options into the object le. This is the default. -gno-record-gcc-switches Disallow appending command-line options to the DW AT producer attribute in DWARF debugging information. -gstrict-dwarf Disallow using extensions of later DWARF standard version than selected with -gdwarf-version. On most targets using non-conicting DWARF extensions from later standard versions is allowed. -gno-strict-dwarf Allow using extensions of later DWARF standard version than selected with -gdwarf-version. -gvms Produce debugging information in Alpha/VMS debug format (if that is supported). This is the format used by DEBUG on Alpha/VMS systems.

Chapter 3: GCC Command Options

77

-glevel -ggdblevel -gstabslevel -gcofflevel -gxcofflevel -gvmslevel Request debugging information and also use level to specify how much information. 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 dont plan to debug. This includes descriptions of functions and external variables, but no information about local variables and no line numbers. Level 3 includes extra information, such as all the macro denitions present in the program. Some debuggers support macro expansion when you use -g3. -gdwarf-2 does not accept a concatenated debug level, because GCC used to support an option -gdwarf that meant to generate debug information in version 1 of the DWARF format (which is very dierent from version 2), and it would have been too confusing. That debug format is long obsolete, but the option cannot be changed now. Instead use an additional -glevel option to change the debug level for DWARF. -gtoggle Turn o generation of debug info, if leaving out this option generates it, or turn it on at level 2 otherwise. The position of this argument in the command line does not matter; it takes eect after all other options are processed, and it does so only once, no matter how many times it is given. This is mainly intended to be used with -fcompare-debug.

-fsanitize=address Enable AddressSanitizer, a fast memory error detector. Memory access instructions will be instrumented to detect out-of-bounds and use-after-free bugs. See [Link] for more details. -fsanitize=thread Enable ThreadSanitizer, a fast data race detector. Memory access instructions will be instrumented to detect data race bugs. See [Link] p/data-race-test/wiki/ThreadSanitizer for more details. -fdump-final-insns[=file] Dump the nal internal representation (RTL) to le. If the optional argument is omitted (or if le is .), the name of the dump le is determined by appending .gkd to the compilation output le name. -fcompare-debug[=opts] If no error occurs during compilation, run the compiler a second time, adding opts and -fcompare-debug-second to the arguments passed to the second compilation. Dump the nal internal representation in both compilations, and print an error if they dier. If the equal sign is omitted, the default -gtoggle is used.

78

Using the GNU Compiler Collection (GCC)

The environment variable GCC_COMPARE_DEBUG, if dened, non-empty and nonzero, implicitly enables -fcompare-debug. If GCC_COMPARE_DEBUG is dened to a string starting with a dash, then it is used for opts, otherwise the default -gtoggle is used. -fcompare-debug=, with the equal sign but without opts, is equivalent to -fno-compare-debug, which disables the dumping of the nal representation and the second compilation, preventing even GCC_COMPARE_DEBUG from taking eect. To verify full coverage during -fcompare-debug testing, set GCC_COMPARE_ DEBUG to say -fcompare-debug-not-overridden, which GCC rejects as an invalid option in any actual compilation (rather than preprocessing, assembly or linking). To get just a warning, setting GCC_COMPARE_DEBUG to -w%n-fcompare-debug not overridden will do. -fcompare-debug-second This option is implicitly passed to the compiler for the second compilation requested by -fcompare-debug, along with options to silence warnings, and omitting other options that would cause side-eect compiler outputs to les or to the standard output. Dump les and preserved temporary les are renamed so as to contain the .gk additional extension during the second compilation, to avoid overwriting those generated by the rst. When this option is passed to the compiler driver, it causes the rst compilation to be skipped, which makes it useful for little other than debugging the compiler proper. -feliminate-dwarf2-dups Compress DWARF 2 debugging information by eliminating duplicated information about each symbol. This option only makes sense when generating DWARF 2 debugging information with -gdwarf-2. -femit-struct-debug-baseonly Emit debug information for struct-like types only when the base name of the compilation source le matches the base name of le in which the struct is dened. This option substantially reduces the size of debugging information, but at signicant potential loss in type information to the debugger. See -femit-struct-debug-reduced for a less aggressive option. See -femit-struct-debug-detailed for more detailed control. This option works only with DWARF 2. -femit-struct-debug-reduced Emit debug information for struct-like types only when the base name of the compilation source le matches the base name of le in which the type is dened, unless the struct is a template or dened in a system header. This option signicantly 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.

Chapter 3: GCC Command Options

79

This option works only with DWARF 2. -femit-struct-debug-detailed[=spec-list] Specify the struct-like types for which the compiler generates debug information. The intent is to reduce duplicate struct debug information between different object les 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 specication has the syntax [dir:|ind:][ord:|gen:](any|sys|base|none) The optional rst word limits the specication 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 specication 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 species the source les 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 le in which the type declaration appears must match the base of the name of the main compilation le. In practice, this means that when compiling foo.c, debug information is generated for types declared in that le and foo.h, but not other header les. The value sys means those types satisfying base or declared in system or compiler headers. You may need to experiment to determine the best settings for your application. The default is -femit-struct-debug-detailed=all. This option works only with DWARF 2. -fno-merge-debug-strings Direct the linker to not merge together strings in the debugging information that are identical in dierent object les. Merging is not supported by all assemblers or linkers. Merging decreases the size of the debug information in the output le at the cost of increasing link processing time. Merging is enabled by default. -fdebug-prefix-map=old=new When compiling les in directory old, record debugging information describing them as in new instead. -fno-dwarf2-cfi-asm Emit DWARF 2 unwind info as compiler generated .eh_frame section instead of using GAS .cfi_* directives.

80

Using the GNU Compiler Collection (GCC)

-p

Generate extra code to write prole information suitable for the analysis program prof. You must use this option when compiling the source les you want data about, and you must also use it when linking. Generate extra code to write prole information suitable for the analysis program gprof. You must use this option when compiling the source les you want data about, and you must also use it when linking. Makes the compiler print out each function name as it is compiled, and print some statistics about each pass when it nishes.

-pg

-Q

-ftime-report Makes the compiler print some statistics about the time consumed by each pass when it nishes. -fmem-report Makes the compiler print some statistics about permanent memory allocation when it nishes. -fmem-report-wpa Makes the compiler print some statistics about permanent memory allocation for the WPA phase only. -fpre-ipa-mem-report -fpost-ipa-mem-report Makes the compiler print some statistics about permanent memory allocation before or after interprocedural optimization. -fprofile-report Makes the compiler print some statistics about consistency of the (estimated) prole and eect of individual passes. -fstack-usage Makes the compiler output stack usage information for the program, on a perfunction basis. The lename for the dump is made by appending .su to the auxname. auxname is generated from the name of the output le, if explicitly specied and it is not an executable, otherwise it is the basename of the source le. An entry is made up of three elds: The name of the function. A number of bytes. One or more qualiers: static, dynamic, bounded. The qualier static means that the function manipulates the stack statically: a xed number of bytes are allocated for the frame on function entry and released on function exit; no stack adjustments are otherwise made in the function. The second eld is this xed number of bytes. The qualier dynamic means that the function manipulates the stack dynamically: in addition to the static allocation described above, stack adjustments are made in the body of the function, for example to push/pop arguments around function calls. If the qualier bounded is also present, the amount of these adjustments is bounded at compile time and the second eld is an upper bound of

Chapter 3: GCC Command Options

81

the total amount of stack used by the function. If it is not present, the amount of these adjustments is not bounded at compile time and the second eld only represents the bounded part. -fprofile-arcs Add code so that program ow 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. When the compiled program exits it saves this data to a le called [Link] for each source le. The data may be used for prole-directed optimizations (-fbranch-probabilities), or for test coverage analysis (-ftest-coverage). Each object les auxname is generated from the name of the output le, if explicitly specied and it is not the nal executable, otherwise it is the basename of the source le. In both cases any sux is removed (e.g. [Link] for input le dir/foo.c, or dir/[Link] for output le specied as -o dir/foo.o). See Section 10.5 [Cross-proling], page 688. --coverage This option is used to compile and link code instrumented for coverage analysis. The option is a synonym for -fprofile-arcs -ftest-coverage (when compiling) and -lgcov (when linking). See the documentation for those options for more details. Compile the source les with -fprofile-arcs plus optimization and code generation options. For test coverage analysis, use the additional -ftest-coverage option. You do not need to prole every source le in a program. Link your object les with -lgcov or -fprofile-arcs (the latter implies the former). Run the program on a representative workload to generate the arc prole information. This may be repeated any number of times. You can run concurrent instances of your program, and provided that the le system supports locking, the data les will be correctly updated. Also fork calls are detected and correctly handled (double counting will not happen). For prole-directed optimizations, compile the source les again with the same optimization and code generation options plus -fbranch-probabilities (see Section 3.10 [Options that Control Optimization], page 97). For test coverage analysis, use gcov to produce human readable information from the .gcno and .gcda les. Refer to the gcov documentation for further information. With -fprofile-arcs, for each function of your program GCC creates a program ow graph, then nds 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.

82

Using the GNU Compiler Collection (GCC)

-ftest-coverage Produce a notes le that the gcov code-coverage utility (see Chapter 10 [gcov a Test Coverage Program], page 681) can use to show program coverage. Each source les note le is called [Link]. 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 les more closely if you do not optimize. -fdbg-cnt-list Print the name and the counter upper bound for all debug counters. -fdbg-cnt=counter-value-list Set the internal debug counter upper bound. counter-value-list is a commaseparated list of name :value pairs which sets the upper bound of each debug counter name to value. All debug counters have the initial upper bound of UINT_MAX; thus dbg_cnt() returns true always unless the upper bound is set by this option. For example, with -fdbg-cnt=dce:10,tail_call:0, dbg_ cnt(dce) returns true only for rst 10 invocations. -fenable-kind-pass -fdisable-kind-pass=range-list This is a set of options that are used to explicitly disable/enable optimization passes. These options are intended for use for debugging GCC. Compiler users should use regular options for enabling/disabling passes instead. -fdisable-ipa-pass Disable IPA pass pass. pass is the pass name. If the same pass is statically invoked in the compiler multiple times, the pass name should be appended with a sequential number starting from 1. -fdisable-rtl-pass -fdisable-rtl-pass=range-list Disable RTL pass pass. pass is the pass name. If the same pass is statically invoked in the compiler multiple times, the pass name should be appended with a sequential number starting from 1. range-list is a comma-separated list of function ranges or assembler names. Each range is a number pair separated by a colon. The range is inclusive in both ends. If the range is trivial, the number pair can be simplied as a single number. If the functions call graph nodes uid falls within one of the specied ranges, the pass is disabled for that function. The uid is shown in the function header of a dump le, and the pass names can be dumped by using option -fdump-passes. -fdisable-tree-pass -fdisable-tree-pass=range-list Disable tree pass pass. See -fdisable-rtl for the description of option arguments.

Chapter 3: GCC Command Options

83

-fenable-ipa-pass Enable IPA pass pass. pass is the pass name. If the same pass is statically invoked in the compiler multiple times, the pass name should be appended with a sequential number starting from 1. -fenable-rtl-pass -fenable-rtl-pass=range-list Enable RTL pass pass. See -fdisable-rtl for option argument description and examples. -fenable-tree-pass -fenable-tree-pass=range-list Enable tree pass pass. See -fdisable-rtl for the description of option arguments. Here are some examples showing uses of these options.
# disable ccp1 for all functions -fdisable-tree-ccp1 # disable complete unroll for function whose cgraph node uid is 1 -fenable-tree-cunroll=1 # disable gcse2 for functions at the following ranges [1,1], # [300,400], and [400,1000] # disable gcse2 for functions foo and foo2 -fdisable-rtl-gcse2=foo,foo2 # disable early inlining -fdisable-tree-einline # disable ipa inlining -fdisable-ipa-inline # enable tree full unroll -fenable-tree-unroll

-dletters -fdump-rtl-pass -fdump-rtl-pass=filename Says to make debugging dumps during compilation at times specied by letters. This is used for debugging the RTL-based passes of the compiler. The le names for most of the dumps are made by appending a pass number and a word to the dumpname, and the les are created in the directory of the output le. In case of =filename option, the dump is output on the given le instead of the pass numbered dump les. Note that the pass number is computed statically as passes get registered into the pass manager. Thus the numbering is not related to the dynamic order of execution of passes. In particular, a pass installed by a plugin could have a number over 200 even if it executed quite early. dumpname is generated from the name of the output le, if explicitly specied and it is not an executable, otherwise it is the basename of the source le. These switches may have dierent eects when -E is used for preprocessing. Debug dumps can be enabled with a -fdump-rtl switch or some -d option letters. Here are the possible letters for use in pass and letters, and their meanings:

84

Using the GNU Compiler Collection (GCC)

-fdump-rtl-alignments Dump after branch alignments have been computed. -fdump-rtl-asmcons Dump after xing rtl statements that have unsatised in/out constraints. -fdump-rtl-auto_inc_dec Dump after auto-inc-dec discovery. This pass is only run on architectures that have auto inc or auto dec instructions. -fdump-rtl-barriers Dump after cleaning up the barrier instructions. -fdump-rtl-bbpart Dump after partitioning hot and cold basic blocks. -fdump-rtl-bbro Dump after block reordering. -fdump-rtl-btl1 -fdump-rtl-btl2 -fdump-rtl-btl1 and -fdump-rtl-btl2 enable dumping after the two branch target load optimization passes. -fdump-rtl-bypass Dump after jump bypassing and control ow optimizations. -fdump-rtl-combine Dump after the RTL instruction combination pass. -fdump-rtl-compgotos Dump after duplicating the computed gotos. -fdump-rtl-ce1 -fdump-rtl-ce2 -fdump-rtl-ce3 -fdump-rtl-ce1, -fdump-rtl-ce2, and -fdump-rtl-ce3 enable dumping after the three if conversion passes. -fdump-rtl-cprop_hardreg Dump after hard register copy propagation. -fdump-rtl-csa Dump after combining stack adjustments. -fdump-rtl-cse1 -fdump-rtl-cse2 -fdump-rtl-cse1 and -fdump-rtl-cse2 enable dumping after the two common subexpression elimination passes. -fdump-rtl-dce Dump after the standalone dead code elimination passes. -fdump-rtl-dbr Dump after delayed branch scheduling.

Chapter 3: GCC Command Options

85

-fdump-rtl-dce1 -fdump-rtl-dce2 -fdump-rtl-dce1 and -fdump-rtl-dce2 enable dumping after the two dead store elimination passes. -fdump-rtl-eh Dump after nalization of EH handling code. -fdump-rtl-eh_ranges Dump after conversion of EH handling range regions. -fdump-rtl-expand Dump after RTL generation. -fdump-rtl-fwprop1 -fdump-rtl-fwprop2 -fdump-rtl-fwprop1 and -fdump-rtl-fwprop2 enable dumping after the two forward propagation passes. -fdump-rtl-gcse1 -fdump-rtl-gcse2 -fdump-rtl-gcse1 and -fdump-rtl-gcse2 enable dumping after global common subexpression elimination. -fdump-rtl-init-regs Dump after the initialization of the registers. -fdump-rtl-initvals Dump after the computation of the initial value sets. -fdump-rtl-into_cfglayout Dump after converting to cfglayout mode. -fdump-rtl-ira Dump after iterated register allocation. -fdump-rtl-jump Dump after the second jump optimization. -fdump-rtl-loop2 -fdump-rtl-loop2 enables dumping after the rtl loop optimization passes. -fdump-rtl-mach Dump after performing the machine dependent reorganization pass, if that pass exists. -fdump-rtl-mode_sw Dump after removing redundant mode switches. -fdump-rtl-rnreg Dump after register renumbering. -fdump-rtl-outof_cfglayout Dump after converting from cfglayout mode.

86

Using the GNU Compiler Collection (GCC)

-fdump-rtl-peephole2 Dump after the peephole pass. -fdump-rtl-postreload Dump after post-reload optimizations. -fdump-rtl-pro_and_epilogue Dump after generating the function prologues and epilogues. -fdump-rtl-regmove Dump after the register move pass. -fdump-rtl-sched1 -fdump-rtl-sched2 -fdump-rtl-sched1 and -fdump-rtl-sched2 enable dumping after the basic block scheduling passes. -fdump-rtl-see Dump after sign extension elimination. -fdump-rtl-seqabstr Dump after common sequence discovery. -fdump-rtl-shorten Dump after shortening branches. -fdump-rtl-sibling Dump after sibling call optimizations. -fdump-rtl-split1 -fdump-rtl-split2 -fdump-rtl-split3 -fdump-rtl-split4 -fdump-rtl-split5 -fdump-rtl-split1, -fdump-rtl-split2, -fdump-rtl-split3, -fdump-rtl-split4 and -fdump-rtl-split5 enable dumping after ve rounds of instruction splitting. -fdump-rtl-sms Dump after modulo scheduling. This pass is only run on some architectures. -fdump-rtl-stack Dump after conversion from GCCs at register le registers to the x87s stack-like registers. This pass is only run on x86 variants. -fdump-rtl-subreg1 -fdump-rtl-subreg2 -fdump-rtl-subreg1 and -fdump-rtl-subreg2 enable dumping after the two subreg expansion passes. -fdump-rtl-unshare Dump after all rtl has been unshared.

Chapter 3: GCC Command Options

87

-fdump-rtl-vartrack Dump after variable tracking. -fdump-rtl-vregs Dump after converting virtual registers to hard registers. -fdump-rtl-web Dump after live range splitting. -fdump-rtl-regclass -fdump-rtl-subregs_of_mode_init -fdump-rtl-subregs_of_mode_finish -fdump-rtl-dfinit -fdump-rtl-dfinish These dumps are dened but always produce empty les. -da -fdump-rtl-all Produce all the dumps listed above. -dA -dD -dH -dp Annotate the assembler output with miscellaneous debugging information. Dump all macro denitions, at the end of preprocessing, in addition to normal output. Produce a core dump whenever an error occurs. Annotate the assembler output with a comment indicating which pattern and alternative is used. The length of each instruction is also printed. Dump the RTL in the assembler output as a comment before each instruction. Also turns on -dp annotation. Just generate RTL for a function instead of compiling it. Usually used with -fdump-rtl-expand.

-dP -dx

-fdump-noaddr When doing debugging dumps, suppress address output. This makes it more feasible to use di on debugging dumps for compiler invocations with dierent compiler binaries and/or dierent text / bss / data / heap / stack / dso start locations. -fdump-unnumbered When doing debugging dumps, suppress instruction numbers and address output. This makes it more feasible to use di on debugging dumps for compiler invocations with dierent options, in particular with and without -g. -fdump-unnumbered-links When doing debugging dumps (see -d option above), suppress instruction numbers for the links to the previous and next instructions in a sequence.

88

Using the GNU Compiler Collection (GCC)

-fdump-translation-unit (C++ only) -fdump-translation-unit-options (C++ only) Dump a representation of the tree structure for the entire translation unit to a le. The le name is made by appending .tu to the source le name, and the le is created in the same directory as the output le. If the -options form is used, options controls the details of the dump as described for the -fdump-tree options. -fdump-class-hierarchy (C++ only) -fdump-class-hierarchy-options (C++ only) Dump a representation of each classs hierarchy and virtual function table layout to a le. The le name is made by appending .class to the source le name, and the le is created in the same directory as the output le. If the -options form is used, options controls the details of the dump as described for the -fdump-tree options. -fdump-ipa-switch Control the dumping at various stages of inter-procedural analysis language tree to a le. The le name is generated by appending a switch specic sux to the source le name, and the le is created in the same directory as the output le. The following dumps are possible: all cgraph inline Enables all inter-procedural analysis dumps. Dumps information about call-graph optimization, unused function removal, and inlining decisions. Dump after function inlining.

-fdump-passes Dump the list of optimization passes that are turned on and o by the current command-line options. -fdump-statistics-option Enable and control dumping of pass statistics in a separate le. The le name is generated by appending a sux ending in .statistics to the source le name, and the le is created in the same directory as the output le. If the -option form is used, -stats causes counters to be summed over the whole compilation unit while -details dumps every event as the passes generate them. The default with no option is to sum counters for each function compiled. -fdump-tree-switch -fdump-tree-switch-options -fdump-tree-switch-options=filename Control the dumping at various stages of processing the intermediate language tree to a le. The le name is generated by appending a switch-specic sux to the source le name, and the le is created in the same directory as the output le. In case of =filename option, the dump is output on the given le instead of the auto named dump les. If the -options form is used, options is a list of - separated options which control the details of the dump. Not all options are applicable to all dumps; those that are not meaningful are ignored. The following options are available

Chapter 3: GCC Command Options

89

address

Print the address of each node. Usually this is not meaningful as it changes according to the environment and source le. Its primary use is for tying up a dump le with a debug environment. If DECL_ASSEMBLER_NAME has been set for a given decl, use that in the dump instead of DECL_NAME. Its primary use is ease of use working backward from mangled names in the assembly le. When dumping front-end intermediate representations, inhibit dumping of members of a scope or body of a function merely because that scope has been reached. Only dump such items when they are directly reachable by some other path. When dumping pretty-printed trees, this option inhibits dumping the bodies of control structures. When dumping RTL, print the RTL in slim (condensed) form instead of the default LISP-like representation. Print a raw representation of the tree. By default, trees are prettyprinted into a C-like representation. Enable more detailed dumps (not honored by every dump option). Also include information from the optimization passes. Enable dumping various statistics about the pass (not honored by every dump option). Enable showing basic block boundaries (disabled in raw dumps). For each of the other indicated dump les (-fdump-rtl-pass), dump a representation of the control ow graph suitable for viewing with GraphViz to [Link]. Each function in the le is pretty-printed as a subgraph, so that GraphViz can render them all in a single plot. This option currently only works for RTL dumps, and the RTL is always dumped in slim form. Enable showing virtual operands for every statement. Enable showing line numbers for statements. Enable showing the unique ID (DECL_UID) for each variable. Enable showing the tree dump for each statement. Enable showing the EH region number holding each statement. Enable showing scalar evolution analysis details.

asmname

slim

raw details stats blocks graph

vops lineno uid verbose eh scev

optimized Enable showing optimization information (only available in certain passes). missed Enable showing missed optimization information (only available in certain passes).

90

Using the GNU Compiler Collection (GCC)

notes

Enable other detailed optimization information (only available in certain passes).

=filename Instead of an auto named dump le, output into the given le name. The le names stdout and stderr are treated specially and are considered already open standard streams. For example,
gcc -O2 -ftree-vectorize -fdump-tree-vect-blocks=[Link] -fdump-tree-pre=stderr file.c

outputs vectorizer dump into [Link], while the PRE dump is output on to stderr. If two conicting dump lenames are given for the same pass, then the latter option overrides the earlier one. all optall Turn on all options, except raw, slim, verbose and lineno. Turn on all optimization options, i.e., optimized, missed, and note.

The following tree dumps are possible: original Dump before any tree based optimization, to [Link]. optimized Dump after all tree based optimization, to [Link]. gimple Dump each function before and after the gimplication pass to a le. The le name is made by appending .gimple to the source le name. Dump the control ow graph of each function to a le. The le name is made by appending .cfg to the source le name. Dump each function after copying loop headers. The le name is made by appending .ch to the source le name. Dump SSA related information to a le. The le name is made by appending .ssa to the source le name. Dump aliasing information for each function. The le name is made by appending .alias to the source le name. Dump each function after CCP. The le name is made by appending .ccp to the source le name. Dump each function after STORE-CCP. The le name is made by appending .storeccp to the source le name. pre fre Dump trees after partial redundancy elimination. The le name is made by appending .pre to the source le name. Dump trees after full redundancy elimination. The le name is made by appending .fre to the source le name.

cfg ch ssa alias ccp storeccp

Chapter 3: GCC Command Options

91

copyprop Dump trees after copy propagation. The le name is made by appending .copyprop to the source le name. store_copyprop Dump trees after store copy-propagation. The le name is made by appending .store_copyprop to the source le name. dce mudflap sra Dump each function after dead code elimination. The le name is made by appending .dce to the source le name. Dump each function after adding mudap instrumentation. The le name is made by appending .mudflap to the source le name. Dump each function after performing scalar replacement of aggregates. The le name is made by appending .sra to the source le name. Dump each function after performing code sinking. The le name is made by appending .sink to the source le name. Dump each function after applying dominator tree optimizations. The le name is made by appending .dom to the source le name. Dump each function after applying dead store elimination. The le name is made by appending .dse to the source le name. Dump each function after optimizing PHI nodes into straightline code. The le name is made by appending .phiopt to the source le name. Dump each function after forward propagating single use variables. The le name is made by appending .forwprop to the source le name. copyrename Dump each function after applying the copy rename optimization. The le name is made by appending .copyrename to the source le name. nrv Dump each function after applying the named return value optimization on generic trees. The le name is made by appending .nrv to the source le name. Dump each function after applying vectorization of loops. The le name is made by appending .vect to the source le name. Dump each function after applying vectorization of basic blocks. The le name is made by appending .slp to the source le name. Dump each function after Value Range Propagation (VRP). The le name is made by appending .vrp to the source le name. Enable all the available tree dumps with the ags provided in this option.

sink dom dse phiopt

forwprop

vect slp vrp all

92

Using the GNU Compiler Collection (GCC)

-fopt-info -fopt-info-options -fopt-info-options=filename Controls optimization dumps from various optimization passes. If the -options form is used, options is a list of - separated options to select the dump details and optimizations. If options is not specied, it defaults to all for details and optall for optimization groups. If the lename is not specied, it defaults to stderr. Note that the output lename will be overwritten in case of multiple translation units. If a combined output from multiple translation units is desired, stderr should be used instead. The options can be divided into two groups, 1) options describing the verbosity of the dump, and 2) options describing which optimizations should be included. The options from both the groups can be freely mixed as they are non-overlapping. However, in case of any conicts, the latter options override the earlier options on the command line. Though multiple -fopt-info options are accepted, only one of them can have =filename. If other lenames are provided then all but the rst one are ignored. The dump verbosity has the following options optimized Print information when an optimization is successfully applied. It is up to a pass to decide which information is relevant. For example, the vectorizer passes print the source location of loops which got successfully vectorized. missed Print information about missed optimizations. Individual passes control which information to include in the output. For example,
gcc -O2 -ftree-vectorize -fopt-info-vec-missed

will print information about missed optimization opportunities from vectorization passes on stderr. note all Print verbose information about optimizations, such as certain transformations, more detailed messages about decisions etc. Print detailed optimization information. This includes optimized, missed, and note.

The second set of options describes a group of optimizations and may include one or more of the following. ipa loop inline vec Enable dumps from all interprocedural optimizations. Enable dumps from all loop optimizations. Enable dumps from all inlining optimizations. Enable dumps from all vectorization optimizations.
gcc -O3 -fopt-info-missed=[Link]

For example, outputs missed optimization report from all the passes into [Link]. As another example,

Chapter 3: GCC Command Options

93

gcc -O3 -fopt-info-inline-optimized-missed=[Link]

will output information about missed optimizations as well as optimized locations from all the inlining passes into [Link]. If the lename is provided, then the dumps from all the applicable optimizations are concatenated into the filename. Otherwise the dump is output onto stderr. If options is omitted, it defaults to all-optall, which means dump all available optimization info from all the passes. In the following example, all optimization info is output on to stderr.
gcc -O3 -fopt-info

Note that -fopt-info-vec-missed behaves the same as -fopt-info-missed-vec. As another example, consider
gcc -fopt-info-vec-missed=[Link] -fopt-info-loop-optimized=[Link]

Here the two output lenames [Link] and [Link] are in conict since only one output le is allowed. In this case, only the rst option takes eect and the subsequent options are ignored. Thus only the [Link] is produced which cotaints dumps from the vectorizer about missed opportunities. -ftree-vectorizer-verbose=n This option is deprecated and is implemented in terms of -fopt-info. Please use -fopt-info-kind form instead, where kind is one of the valid opt-info options. It prints additional optimization information. For n=0 no diagnostic information is reported. If n=1 the vectorizer reports each loop that got vectorized, and the total number of loops that got vectorized. If n=2 the vectorizer reports locations which could not be vectorized and the reasons for those. For any higher verbosity levels all the analysis and transformation information from the vectorizer is reported. Note that the information output by -ftree-vectorizer-verbose option is sent to stderr. If the equivalent form -fopt-info-options=filename is used then the output is sent into lename instead. -frandom-seed=string This option provides a seed that GCC uses in place of random numbers in generating certain symbol names that have to be dierent in every compiled le. It is also used to place unique stamps in coverage data les and the object les that produce them. You can use the -frandom-seed option to produce reproducibly identical object les. The string should be dierent for every le you compile. -fsched-verbose=n On targets that use instruction scheduling, this option controls the amount of debugging output the scheduler prints. This information is written to standard error, unless -fdump-rtl-sched1 or -fdump-rtl-sched2 is specied, in which case it is output to the usual dump listing le, .sched1 or .sched2 respectively. However for n greater than nine, the output is always printed to standard error. For n greater than zero, -fsched-verbose outputs the same information as -fdump-rtl-sched1 and -fdump-rtl-sched2. For n greater than one, it also

94

Using the GNU Compiler Collection (GCC)

output basic block probabilities, detailed ready list information and unit/insn info. For n greater than two, it includes RTL at abort point, control-ow and regions info. And for n over four, -fsched-verbose also includes dependence info. -save-temps -save-temps=cwd Store the usual temporary intermediate les permanently; place them in the current directory and name them based on the source le. Thus, compiling foo.c with -c -save-temps produces les foo.i and foo.s, as well as foo.o. This creates a preprocessed foo.i output le even though the compiler now normally uses an integrated preprocessor. When used in combination with the -x command-line option, -save-temps is sensible enough to avoid over writing an input source le with the same extension as an intermediate le. The corresponding intermediate le may be obtained by renaming the source le before using -save-temps. If you invoke GCC in parallel, compiling several dierent source les that share a common base name in dierent subdirectories or the same source le compiled for multiple output destinations, it is likely that the dierent parallel compilers will interfere with each other, and overwrite the temporary les. For instance:
gcc -save-temps -o outdir1/foo.o indir1/foo.c& gcc -save-temps -o outdir2/foo.o indir2/foo.c&

may result in foo.i and foo.o being written to simultaneously by both compilers. -save-temps=obj Store the usual temporary intermediate les permanently. If the -o option is used, the temporary les are based on the object le. If the -o option is not used, the -save-temps=obj switch behaves like -save-temps. For example:
gcc -save-temps=obj -c foo.c gcc -save-temps=obj -c bar.c -o dir/xbar.o gcc -save-temps=obj foobar.c -o dir2/yfoobar

creates foo.i, foo.s, dir/xbar.i, dir/xbar.s, dir2/yfoobar.i, dir2/yfoobar.s, and dir2/yfoobar.o. -time[=file] Report the CPU time taken by each subprocess in the compilation sequence. For C source les, this is the compiler proper and assembler (plus the linker if linking is done). Without the specication of an output le, the output looks like this:
# cc1 0.12 0.01 # as 0.00 0.01

The rst number on each line is the user time, that is time spent executing the program itself. The second number is system time, time spent executing operating system routines on behalf of the program. Both numbers are in seconds.

Chapter 3: GCC Command Options

95

With the specication of an output le, the output is appended to the named le, and it looks like this:
0.12 0.01 cc1 options 0.00 0.01 as options

The user time and the system time are moved before the program name, and the options passed to the program are displayed, so that one can later tell what le was being compiled, and with which options. -fvar-tracking Run variable tracking pass. It computes where variables are stored at each position 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. -fvar-tracking-assignments-toggle Toggle -fvar-tracking-assignments, in the same way that -gtoggle toggles -g. -print-file-name=library Print the full absolute name of the library le library that would be used when linkingand dont do anything else. With this option, GCC does not compile or link anything; it just prints the le name. -print-multi-directory Print the directory name corresponding to the multilib selected by any other switches present in the command line. This directory is supposed to exist in GCC_EXEC_PREFIX. -print-multi-lib Print the mapping from multilib directory names to compiler switches that enable them. The directory name is separated from the switches by ;, and each switch starts with an @ instead of the -, without spaces between multiple switches. This is supposed to ease shell processing. -print-multi-os-directory Print the path to OS libraries for the selected multilib, relative to some lib subdirectory. If OS libraries are present in the lib subdirectory and no multilibs are used, this is usually just ., if OS libraries are present in libsuffix sibling directories this prints e.g. ../lib64, ../lib or ../lib32, or if OS libraries are present in lib/subdir subdirectories it prints e.g. amd64, sparcv9 or ev6.

96

Using the GNU Compiler Collection (GCC)

-print-multiarch Print the path to OS libraries for the selected multiarch, relative to some lib subdirectory. -print-prog-name=program Like -print-file-name, but searches for a program such as cpp. -print-libgcc-file-name Same as -print-file-name=libgcc.a. This is useful when you use -nostdlib or -nodefaultlibs but you do want to link with libgcc.a. You can do:
gcc -nostdlib files... gcc -print-libgcc-file-name

-print-search-dirs Print the name of the congured installation directory and a list of program and library directories gcc searchesand dont do anything else. This is useful when gcc prints the error message installation problem, cannot exec cpp0: No such file or directory. To resolve this you either need to put cpp0 and the other compiler components where gcc expects to nd them, or you can set the environment variable GCC_EXEC_PREFIX to the directory where you installed them. Dont forget the trailing /. See Section 3.19 [Environment Variables], page 309. -print-sysroot Print the target sysroot directory that is used during compilation. This is the target sysroot specied either at congure time or using the --sysroot option, possibly with an extra sux that depends on compilation options. If no target sysroot is specied, the option prints nothing. -print-sysroot-headers-suffix Print the sux added to the target sysroot when searching for headers, or give an error if the compiler is not congured with such a suxand dont do anything else. -dumpmachine Print the compilers target machine (for example, i686-pc-linux-gnu)and dont do anything else. -dumpversion Print the compiler version (for example, 3.0)and dont do anything else. -dumpspecs Print the compilers built-in specsand dont do anything else. (This is used when GCC itself is being built.) See Section 3.15 [Spec Files], page 165. -fno-eliminate-unused-debug-types Normally, when producing DWARF 2 output, GCC avoids producing debug symbol output for types that are nowhere used in the source le 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

Chapter 3: GCC Command Options

97

a value to a type that is not actually used in your program (but is declared). More often, however, this results in a signicant amount of wasted space.

3.10 Options That Control Optimization

These options control various sorts of optimizations. Without any optimization option, the compilers 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 ags makes the compiler attempt to improve the performance and/or code size at the expense of compilation time and possibly the ability to debug the program. The compiler performs optimization based on the knowledge it has of the program. Compiling multiple les at once to a single output le mode allows the compiler to use information gained from all of the les when compiling each of them. Not all optimizations are controlled directly by a ag. Only optimizations that have a ag 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 ags are specied. Depending on the target and how GCC was congured, a slightly dierent set of optimizations may be enabled at each -O level than those listed here. You can invoke GCC with -Q --help=optimizers to nd out the exact set of optimizations that are enabled at each level. See Section 3.2 [Overall Options], page 24, 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 ags:
-fauto-inc-dec -fcompare-elim -fcprop-registers -fdce -fdefer-pop -fdelayed-branch -fdse -fguess-branch-probability -fif-conversion2 -fif-conversion -fipa-pure-const -fipa-profile -fipa-reference -fmerge-constants -fsplit-wide-types -ftree-bit-ccp -ftree-builtin-call-dce -ftree-ccp

98

Using the GNU Compiler Collection (GCC)

-ftree-ch -ftree-copyrename -ftree-dce -ftree-dominator-opts -ftree-dse -ftree-forwprop -ftree-fre -ftree-phiprop -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 tradeo. As compared to -O, this option increases both compilation time and the performance of the generated code. -O2 turns on all optimization ags specied by -O. It also turns on the following optimization ags:
-fthread-jumps -falign-functions -falign-jumps -falign-loops -falign-labels -fcaller-saves -fcrossjumping -fcse-follow-jumps -fcse-skip-blocks -fdelete-null-pointer-checks -fdevirtualize -fexpensive-optimizations -fgcse -fgcse-lm -fhoist-adjacent-loads -finline-small-functions -findirect-inlining -fipa-sra -foptimize-sibling-calls -fpartial-inlining -fpeephole2 -fregmove -freorder-blocks -freorder-functions -frerun-cse-after-loop -fsched-interblock -fsched-spec -fschedule-insns -fschedule-insns2 -fstrict-aliasing -fstrict-overflow -ftree-switch-conversion -ftree-tail-merge -ftree-pre -ftree-vrp

Please note the warning under -fgcse about invoking -O2 on programs that use computed gotos. -O3 Optimize yet more. -O3 turns on all optimizations specied by -O2 and also turns on the -finline-functions, -funswitch-loops, -fpredictive-commoning, -fgcse-after-reload, -ftree-vectorize, -fvect-cost-model, -ftree-partial-pre and -fipa-cp-clone options.

Chapter 3: GCC Command Options

99

-O0 -Os

Reduce compilation time and make debugging produce the expected results. This is the default. Optimize for size. -Os enables all -O2 optimizations that do not typically increase code size. It also performs further optimizations designed to reduce code size. -Os disables the following optimization ags:
-falign-functions -falign-jumps -falign-loops -falign-labels -freorder-blocks -freorder-blocks-and-partition -fprefetch-loop-arrays -ftree-vect-loop-version

-Ofast

Disregard strict standards compliance. -Ofast enables all -O3 optimizations. It also enables optimizations that are not valid for all standardcompliant programs. It turns on -ffast-math and the Fortran-specic -fno-protect-parens and -fstack-arrays. Optimize debugging experience. -Og enables optimizations that do not interfere with debugging. It should be the optimization level of choice for the standard edit-compile-debug cycle, oering 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 eective.

-Og

Options of the form -fflag specify machine-independent ags. Most ags have both positive and negative forms; the negative form of -ffoo is -fno-foo. In the table below, only one of the forms is listedthe one you typically use. You can gure out the other form by either removing no- or adding it. The following options control specic optimizations. They are either activated by -O options or are related to ones that are. You can use the following ags in the rare cases when ne-tuning of optimizations to be performed is desired. -fno-default-inline Do not make member functions inline by default merely because they are dened inside the class scope (C++ only). Otherwise, when you specify -O, member functions dened inside class scope are compiled inline by default; i.e., you dont need to add inline in front of the member function name. -fno-defer-pop Always pop the arguments to each function call as soon as that function returns. 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 simplied. 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.

100

Using the GNU Compiler Collection (GCC)

-ffp-contract=style -ffp-contract=off disables oating-point expression contraction. -ffp-contract=fast enables oating-point expression contraction such as forming of fused multiply-add operations if the target has native support for them. -ffp-contract=on enables oating-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 Dont keep the frame pointer in a register for functions that dont 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 ag has no eect, because the standard calling sequence automatically handles the frame pointer and nothing is saved by pretending it doesnt exist. The machine-description macro FRAME_ POINTER_REQUIRED controls whether a target machine supports this ag. See Section Register Usage in GNU Compiler Collection (GCC) Internals . Starting with GCC version 4.6, the default setting (when not optimizing for size) for 32-bit GNU/Linux x86 and 32-bit Darwin x86 targets has been changed to -fomit-frame-pointer. The default can be reverted to -fno-omit-frame-pointer by conguring GCC with the --enable-frame-pointer congure option. Enabled at levels -O, -O2, -O3, -Os. -foptimize-sibling-calls Optimize sibling and tail recursive calls. Enabled at levels -O2, -O3, -Os. -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 heuristically 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. -findirect-inlining Inline also indirect calls that are discovered to be known at compile time thanks to previous inlining. This option has any eect only when inlining itself is turned on by the -finline-functions or -finline-small-functions options. Enabled at level -O2.

Chapter 3: GCC Command Options

101

-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 level -O3. -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. -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 proling signicantly 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 ag 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 specied 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 behavior. Note: pseudo instruction represents, in this particular context, an abstract measurement of functions 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.

102

Using the GNU Compiler Collection (GCC)

-fno-keep-inline-dllexport This is a more ne-grained version of -fkeep-inline-functions, which applies only to functions that are declared using the dllexport attribute or declspec (See Section 6.30 [Declaring Attributes of Functions], page 348.) -fkeep-inline-functions In C, emit static functions that are declared inline into the object le, even if the function has been inlined into all of its callers. This switch does not aect functions using the extern inline extension in GNU C90. In C++, emit any and all inline functions into the object le. -fkeep-static-consts Emit variables declared static const when optimization isnt turned on, even if the variables arent 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 oating-point constants) 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 variables with integral or oating-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 rst scheduling pass. This pass looks at innermost loops and reorders their instructions by overlapping dierent iterations. -fmodulo-sched-allow-regmoves Perform more aggressive SMS-based modulo scheduling with register moves allowed. By setting this ag certain anti-dependences edges are deleted, which triggers the generation of reg-moves based on the life-range analysis. This option is eective only with -fmodulo-sched enabled. -fno-branch-count-reg Do not use decrement and branch instructions on a count register, but instead generate a sequence of instructions that decrement a register, compare it against zero, then branch based upon the result. This option is only meaningful on architectures that support such instructions, which include x86, PowerPC, IA64 and S/390.

Chapter 3: GCC Command Options

103

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 functions address explicitly. This option results in less ecient 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 o this behavior because some programs explicitly rely on variables going to the data sectione.g., so that the resulting executable can nd the beginning of that section and/or make assumptions based on that. The default is -fzero-initialized-in-bss. -fmudflap -fmudflapth -fmudflapir For front-ends that support it (C and C++), instrument all risky pointer/array dereferencing operations, some standard library string/heap functions, and some other associated constructs with range/validity tests. Modules so instrumented should be immune to buer overows, invalid heap use, and some other classes of C/C++ programming errors. The instrumentation relies on a separate runtime library (libmudflap), which is linked into a program if -fmudflap is given at link time. Run-time behavior of the instrumented program is controlled by the MUDFLAP_OPTIONS environment variable. See env MUDFLAP_OPTIONS=help [Link] for its options. Use -fmudflapth instead of -fmudflap to compile and to link if your program is multi-threaded. Use -fmudflapir, in addition to -fmudflap or -fmudflapth, if instrumentation should ignore pointer reads. This produces less instrumentation (and therefore faster execution) and still provides some protection against outright memory corrupting writes, but allows erroneously read data to propagate within a program. -fthread-jumps Perform optimizations that check to see if a jump branches to a location where another comparison subsumed by the rst is found. If so, the rst 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 dicult. Enabled at levels -O, -O2, -O3, -Os.

104

Using the GNU Compiler Collection (GCC)

-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 performed. Enabled at levels -O2, -O3, -Os. -fgcse Perform a global common subexpression elimination pass. This pass also performs global constant and copy propagation. 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. When -fgcse-lm is enabled, global common subexpression elimination attempts 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 sequence 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.

-fgcse-lm

Chapter 3: GCC Command Options

105

-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 undened behavior by for example causing signed integer overows 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. -funsafe-loop-optimizations This option tells the loop optimizer to assume that loop indices do not overow, and that loops with nontrivial exit condition are not innite. This enables a wider range of loop optimizations even if the loop optimizer itself cannot prove that these assumptions are valid. If you use -Wunsafe-loop-optimizations, the compiler warns you if it nds this kind of loop. -fcrossjumping Perform cross-jumping transformation. This transformation unies 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. -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 -fdse Perform dead code elimination (DCE) on RTL. Enabled by default at -O and higher. 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 ags and abs instructions, and some tricks doable by standard arithmetics. The use of conditional execution on chips where it is available is controlled by if-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. -fdelete-null-pointer-checks Assume that programs cannot safely dereference null pointers, and that no code or data element resides there. This enables simple constant folding optimizations at all optimization levels. In addition, other optimization passes in GCC use this ag to control global dataow analyses that eliminate useless checks for null pointers; these assume that if a pointer is checked after it has already been dereferenced, it cannot be null.

106

Using the GNU Compiler Collection (GCC)

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. Some targets, especially embedded ones, disable this option at all levels. Otherwise it is enabled at all levels: -O0, -O1, -O2, -O3, -Os. Passes that use the information are enabled independently at dierent optimization levels. -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. -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 x86 at levels -O2, -O3.

-foptimize-register-move -fregmove Attempt to reassign register numbers in move instructions and as operands of other simple instructions in order to maximize the amount of register tying. This is especially helpful on machines with two-operand instructions. Note -fregmove and -foptimize-register-move are the same optimization. Enabled at levels -O2, -O3, -Os. -fira-algorithm=algorithm Use the specied coloring algorithm for the integrated register allocator. The algorithm argument can be priority, which species Chows priority coloring, or CB, which species Chaitin-Briggs coloring. Chaitin-Briggs coloring is not 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 specied regions for the integrated register allocator. The region argument should be one of the following: all mixed Use all loops as register allocation regions. This can give the best results for machines with a small and/or irregular register set. 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, . . . ). Use all functions as a single region. This typically results in the smallest code size, and is enabled by default for -Os or -O0.

one

Chapter 3: GCC Command Options

107

-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 invariants. This option usually results in generation of faster and smaller code on machines with large register les (>= 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 pseudoregister that does not get a hard register gets a separate stack slot, and as a result function stack frames are larger. -fira-verbose=n Control the verbosity of the dump le for the integrated register allocator. The default value is 5. If the value n is greater or equal to 10, the dump output is sent to stderr using the same format as n minus 10. -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. -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 oating point or memory load instructions by allowing other instructions to be issued until the result of the load or oating-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.

108

Using the GNU Compiler Collection (GCC)

-fno-sched-interblock Dont 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 Dont 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 Dene 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. -fsched-stalled-insns-dep -fsched-stalled-insns-dep=n Dene how many insn groups (cycles) are examined for a dependency on a stalled insn that is a candidate for premature removal from the queue of stalled insns. This has an eect 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 allows motion across basic block boundaries, resulting in faster schedules. This

Chapter 3: GCC Command Options

109

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 instructions 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 enabled 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 instruction belonging to a basic block with greater size or frequency. This is enabled 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 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 modulo 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 rst scheduler pass. -fselective-scheduling2 Schedule instructions using selective scheduling algorithm. Selective scheduling runs instead of the second scheduler pass.

110

Using the GNU Compiler Collection (GCC)

-fsel-sched-pipelining Enable software pipelining of innermost loops during selective scheduling. This option has no eect 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 eect unless -fsel-sched-pipelining is turned on. -fshrink-wrap Emit function prologues only before parts of the function that need it, rather than at the top of the function. This ag is enabled by default at -O and higher. -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 nd ways to combine them. Enabled by default at -O1 and higher. -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 ag is enabled by default at -O and higher. -ftree-pre Perform partial redundancy elimination (PRE) on trees. This ag is enabled by default at -O2 and -O3. -ftree-partial-pre Make partial redundancy elimination (PRE) more aggressive. This ag is enabled by default at -O3. -ftree-forwprop Perform forward propagation on trees. This ag is enabled by default at -O and higher. -ftree-fre Perform full redundancy elimination (FRE) on trees. The dierence between FRE and PRE is that FRE only considers expressions that are computed on

Chapter 3: GCC Command Options

111

all paths leading to the redundant computation. This analysis is faster than PRE, though it exposes fewer redundancies. This ag is enabled by default at -O and higher. -ftree-phiprop Perform hoisting of loads from conditional pointers on trees. This pass is enabled 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 ag is enabled by default at -O2 and higher. -ftree-copy-prop Perform copy propagation on trees. This pass eliminates unnecessary copy operations. This ag 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 modication 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 optimization level. -fipa-profile Perform interprocedural prole 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 identied. 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 performance if the application has constants passed to functions. This ag 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 arguments. Because this optimization can create multiple copies of functions, it may signicantly increase code size (see --param ipcp-unit-growth=value). This ag is enabled by default at -O3.

112

Using the GNU Compiler Collection (GCC)

-ftree-sink Perform forward store motion on trees. This ag 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. -ftree-switch-conversion Perform conversion of simple initializations in a switch to initializations from a scalar array. This ag 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 ag 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 ag 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-eect free. This ag is enabled by default at -O2 and higher if -Os is not also specied. -ftree-dominator-opts Perform a variety of simple scalar cleanups (constant/copy propagation, redundancy elimination, range propagation and expression simplication) based on a dominator tree traversal. This also performs jump threading (to reduce jumps to jumps). This ag 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 intervening loads. In this case the earlier store can be deleted. This ag is enabled by default at -O and higher. -ftree-ch Perform loop header copying on trees. This is benecial since it increases effectiveness of code motion optimizations. It also saves one jump. This ag is enabled by default at -O and higher. It is not enabled for -Os, since it usually increases code size.

Chapter 3: GCC Command Options

113

-ftree-loop-optimize Perform loop optimizations on trees. This ag is enabled by default at -O and higher. -ftree-loop-linear Perform loop interchange transformations on tree. Same as -floop-interchange. To use this code transformation, GCC has to be congured with --with-ppl and --with-cloog to enable the Graphite loop transformation infrastructure. -floop-interchange Perform loop interchange transformations on loops. Interchanging two nested loops switches the inner and outer loops. For example, given a loop like:
DO J = 1, M DO I = 1, N A(J, I) = A(J, I) * C ENDDO ENDDO

loop interchange transforms the loop as if it were written:

DO I = 1, N DO J = 1, M A(J, I) = A(J, I) * C ENDDO ENDDO

which can be benecial when N is larger than the caches, because in Fortran, the elements of an array are stored in memory contiguously by column, and the original loop iterates over rows, potentially creating at each access a cache miss. This optimization applies to all the languages supported by GCC and is not limited to Fortran. To use this code transformation, GCC has to be congured with --with-ppl and --with-cloog to enable the Graphite loop transformation infrastructure. -floop-strip-mine Perform loop strip mining transformations on loops. Strip mining splits a loop into two nested loops. The outer loop has strides equal to the strip size and the inner loop has strides of the original loop within a strip. The strip length can be changed using the loop-block-tile-size parameter. For example, given a loop like:
DO I = 1, N A(I) = A(I) + C ENDDO

loop strip mining transforms the loop as if it were written:

DO II = 1, N, 51 DO I = II, min (II + 50, N) A(I) = A(I) + C ENDDO ENDDO

This optimization applies to all the languages supported by GCC and is not limited to Fortran. To use this code transformation, GCC has to be congured with --with-ppl and --with-cloog to enable the Graphite loop transformation infrastructure.

114

Using the GNU Compiler Collection (GCC)

-floop-block Perform loop blocking transformations on loops. Blocking strip mines each loop in the loop nest such that the memory accesses of the element loops t inside caches. The strip length can be changed using the loop-block-tile-size parameter. For example, given a loop like:
DO I = 1, N DO J = 1, M A(J, I) = B(I) + C(J) ENDDO ENDDO

loop blocking transforms the loop as if it were written:

DO II = 1, N, 51 DO JJ = 1, M, 51 DO I = II, min (II + 50, N) DO J = JJ, min (JJ + 50, M) A(J, I) = B(I) + C(J) ENDDO ENDDO ENDDO ENDDO

which can be benecial when M is larger than the caches, because the innermost loop iterates over a smaller amount of data which can be kept in the caches. This optimization applies to all the languages supported by GCC and is not limited to Fortran. To use this code transformation, GCC has to be congured with --with-ppl and --with-cloog to enable the Graphite loop transformation infrastructure. -fgraphite-identity Enable the identity transformation for graphite. For every SCoP we generate the polyhedral representation and transform it back to gimple. Using -fgraphite-identity we can check the costs or benets of the GIMPLE -> GRAPHITE -> GIMPLE transformation. Some minimal optimizations are also performed by the code generator CLooG, 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 parallelized. Parallelize all the loops that can be analyzed to not contain loop carried dependences without checking that it is protable to parallelize the loops. -fcheck-data-deps Compare the results of several data dependence analyzers. This option is used for debugging the data dependence analyzers. -ftree-loop-if-convert Attempt to transform conditional jumps in the innermost loops to branch-less equivalents. The intent is to remove control-ow from the innermost loops in

Chapter 3: GCC Command Options

115

order to improve the ability of the vectorization pass to handle these loops. This is enabled by default if vectorization is enabled. -ftree-loop-if-convert-stores Attempt to also if-convert conditional jumps containing memory writes. This transformation can be unsafe for multi-threaded programs as it transforms conditional memory writes into unconditional memory writes. For example,
for (i = 0; i < N; i++) if (cond) A[i] = expr;

is transformed to
for (i = 0; i < N; i++) A[i] = cond ? expr : A[i];

potentially producing data races. -ftree-loop-distribution Perform loop distribution. This ag 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
DO I = 1, A(I) = ENDDO DO I = 1, D(I) = ENDDO N B(I) + C N E(I) * F

-ftree-loop-distribute-patterns Perform loop distribution of patterns that can be code generated with calls to a library. This ag 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, A(I) = ENDDO DO I = 1, B(I) = ENDDO N 0 N A(I) + I

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 nontrivial sequences of insns). With -funswitch-loops it also moves operands

116

Using the GNU Compiler Collection (GCC)

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 determining 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 variable 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 protable on multiprocessor machines, for loops that are CPU-intensive, rather than constrained e.g. by memory bandwidth. 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 ag is enabled by default at -O and higher. -ftree-sra Perform scalar replacement of aggregates. This pass replaces structure references with scalars to prevent committing structures to memory too early. This ag is enabled by default at -O and higher. -ftree-copyrename Perform copy renaming on trees. This pass attempts to rename compiler temporaries to other variables at copy locations, usually resulting in variable names which more closely resemble the original variables. This ag is enabled by default at -O and higher. -ftree-coalesce-inlined-vars Tell the copyrename pass (see -ftree-copyrename) to attempt to combine small user-dened variables too, but only if they were inlined from other functions. It is a more limited form of -ftree-coalesce-vars. This may harm debug information of such inlined variables, but it will keep variables of the inlined-into function apart from each other, such that they are more likely to contain the expected values in a debugging session. This was the default in GCC versions older than 4.7. -ftree-coalesce-vars Tell the copyrename pass (see -ftree-copyrename) to attempt to combine small user-dened variables too, 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 ag prevents SSA coalescing of user variables, including inlined ones. This option is enabled by default.

Chapter 3: GCC Command Options

117

-ftree-ter Perform temporary expression replacement during the SSA->normal phase. Single use/single def temporaries are replaced at their use location with their dening 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 expressions involving multiplications and replaces them by less expensive calculations when possible. This is enabled by default at -O and higher. -ftree-vectorize Perform loop vectorization on trees. This ag is enabled by default at -O3. -ftree-slp-vectorize Perform basic block vectorization on trees. This ag is enabled by default at -O3 and when -ftree-vectorize is enabled. -ftree-vect-loop-version Perform loop versioning when doing loop vectorization on trees. When a loop appears to be vectorizable except that data alignment or data dependence cannot be determined at compile time, then vectorized and non-vectorized versions of the loop are generated along with run-time checks for alignment or dependence to control which version is executed. This option is enabled by default except at level -Os where it is disabled. -fvect-cost-model Enable cost model for vectorization. This option is enabled by default at -O3. -ftree-vrp Perform Value Range Propagation on trees. This is similar to the constant propagation 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. -ftracer Perform tail duplication to enlarge superblock size. This transformation simplies the control ow of the function allowing other optimizations to do a better job.

-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. This option makes code larger, and may or may not make it run faster. -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,

118

Using the GNU Compiler Collection (GCC)

-fsplit-ivs-in-unroller Enables expression of values of induction variables in later iterations of the unrolled loop using the value in the rst iteration. This breaks long dependency chains, thus improving eciency of the scheduling passes. A combination of -fweb and CSE is often sucient to obtain the same eect. 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 eect 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 (especially 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-peephole -fno-peephole2 Disable any machine-specic peephole optimizations. The dierence 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 proling feedback (-fprofile-arcs). These heuristics are based on the control ow graph. If some branch probabilities are specied by __builtin_expect, then the heuristics are used to guess branch probabilities for the rest of the control ow graph, taking the __builtin_expect info into account. The interactions between the heuristics and __builtin_expect can

Chapter 3: GCC Command Options

119

be complex, and in some cases, it may be useful to disable the heuristics so that the eects 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 -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 separate sections of the assembly and .o les, to improve paging and cache locality performance. This optimization is automatically turned o in the presence of exception handling, for linkonce sections, for functions with a user-dened section attribute and on any architecture that does not support named sections. -freorder-functions Reorder functions in the object le in order to improve code locality. This is implemented by using special subsections .[Link] for most frequently executed functions and .[Link] for unlikely executed functions. Reordering is done by the linker so object le format must support named sections and linker must place them in a reasonable way. Also prole feedback must be available to make this option eective. 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 language 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 dierent 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 dierent 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

120

Using the GNU Compiler Collection (GCC)

accessed through the union type. So, the code above works as expected. See Section 4.9 [Structures unions enumerations and bit-elds implementation], page 319. However, this code might not:
int f() { union a_union t; int* ip; t.d = 3.0; ip = &t.i; return *ip; }

Similarly, access by taking the address, casting the resulting pointer and dereferencing the result has undened 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 overow rules, depending on the language being compiled. For C (and C++) this means that overow when doing arithmetic with signed numbers is undened, 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 overow is undened, as the expression is false if i + 10 overows when using twos complement arithmetic. When this option is in eect any attempt to determine whether an operation on signed numbers overows must be written carefully to not actually involve overow. This option also allows the compiler to assume strict pointer semantics: given a pointer to an object, if adding an oset to that pointer does not produce a pointer to the same object, the addition is undened. 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 undened, as the expression is false if p + u overows using twos complement arithmetic. See also the -fwrapv option. Using -fwrapv means that integer signed overow is fully dened: it wraps. When -fwrapv is used, there is no dierence between -fstrict-overflow and -fno-strict-overflow for integers. With -fwrapv certain types of overow are permitted. For example, if the compiler gets an overow when doing arithmetic on constants, the overowed 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

Chapter 3: GCC Command Options

121

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 ag when n is a power of two; in that case, it is rounded up. If n is not specied or is zero, use a machine-dependent default. Enabled at levels -O2, -O3. -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 ow 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 specied or is zero, use a machine-dependent default which is very likely to be 1, meaning no alignment. Enabled at levels -O2, -O3. -falign-loops -falign-loops=n 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. If n is not specied 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 specied or is zero, use a machine-dependent default. Enabled at levels -O2, -O3. -funit-at-a-time This option is left for compatibility reasons. -funit-at-a-time has no eect, while -fno-unit-at-a-time implies -fno-toplevel-reorder and -fno-section-anchors.

122

Using the GNU Compiler Collection (GCC)

Enabled by default. -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 le. 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. 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 eect 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 GCCs internal representations) and writes it to special ELF sections in the object le. When the object les are linked together, all the function bodies are read from these ELF sections and instantiated as if they had been part of the same translation unit. To use the link-time optimizer, -flto needs to be specied at compile time and during the nal link. For example:
gcc -c -O2 -flto foo.c gcc -c -O2 -flto bar.c gcc -o myprog -flto -O2 foo.o bar.o

The rst two invocations to GCC save a bytecode representation of GIMPLE into special ELF sections inside foo.o and bar.o. The nal invocation reads the GIMPLE bytecode from foo.o and bar.o, merges the two les 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 les 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:
gcc -o myprog -flto -O2 foo.c bar.c

Chapter 3: GCC Command Options

123

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 optimizations the -flto ag needs to be passed to both the compile and the link commands. To make whole program optimization eective, 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. Note that when a le is compiled with -flto, the generated object le is larger than a regular object le because it contains GIMPLE bytecodes and the usual nal code. This means that object les with LTO information can be linked as normal object les; if -flto is not passed to the linker, no interprocedural optimizations are applied. Additionally, the optimization ags used to compile individual les are not necessarily related to those used at link time. For instance,
gcc -c -O0 -flto foo.c gcc -c -O0 -flto bar.c gcc -o myprog -flto -O3 foo.o bar.o

This produces individual object les with unoptimized assembler code, but the resulting binary myprog is optimized at -O3. If, instead, the nal binary is generated without -flto, then myprog is not optimized. When producing the nal binary with -flto, GCC only applies link-time optimizations to those les that contain bytecode. Therefore, you can mix and match object les and libraries with GIMPLE bytecodes and nal object code. GCC automatically selects which les to optimize in LTO mode and which les to link without further processing. There are some code generation ags preserved by GCC when generating bytecodes, as they need to be used during the nal link stage. Currently, the following options are saved into the GIMPLE bytecode les: -fPIC, -fcommon and all the -m target ags. At link time, these options are read in and reapplied. Note that the current implementation makes no attempt to recognize conicting values for these options. If dierent les have conicting option values (e.g., one le is compiled with -fPIC and another isnt), the compiler simply uses the last value read from the bytecode les. It is recommended, then, that you compile all the les participating in the same link with the same options. If LTO encounters objects with C linkage declared with incompatible types in separate translation units to be linked together (undened behavior according to ISO C99 6.2.7), a non-fatal diagnostic may be issued. The behavior is still undened at run time.

124

Using the GNU Compiler Collection (GCC)

Another feature of LTO is that it is possible to apply interprocedural optimizations on les written in dierent languages. This requires support in the language front end. Currently, the C, C++ and Fortran front ends are capable of emitting GIMPLE bytecodes, so something like this should work:
gcc -c -flto foo.c g++ -c -flto [Link] gfortran -c -flto baz.f90 g++ -o myprog -flto -O3 foo.o bar.o baz.o -lgfortran

Notice that the nal 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; all you need to add is -flto to all the compile and link commands. If object les 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 enable this feature, use the ag -fuse-linker-plugin at link time:
gcc -o myprog -O2 -flto -fuse-linker-plugin a.o b.o -lfoo

With the linker plugin enabled, the linker extracts the needed GIMPLE les 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. Link-time optimizations do not require the presence of the whole program to operate. If the program does not require any symbols to be exported, it is possible to combine -flto and -fwhole-program to allow the interprocedural optimizers to use more aggressive assumptions which may lead to improved optimization 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 dierent types of hosts. The bytecode les are versioned and there is a strict version check, so bytecode les generated in one version of GCC will not work with an older/newer version of GCC. Link-time optimization does not work well with generation of debugging information. Combining -flto with -g is currently experimental and expected to produce wrong 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 makes job server mode to determine the number of parallel jobs. This is useful when the Makele calling GCC is already executing in parallel. You must prepend a + to the command recipe in the parent Makele for this to work. This option likely only works if MAKE is GNU make.

Chapter 3: GCC Command Options

125

This option is disabled by default. -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 les or balanced to specify partitioning into equally sized chunks (whenever possible) or max to create new partition for every symbol where possible. Specifying none as an algorithm disables partitioning and streaming completely. The default 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. -flto-compression-level=n This option species the level of compression used for intermediate language written to LTO object les, and is only meaningful in conjunction with LTO mode (-flto). Valid values are 0 (no compression) to 9 (maximum compression). Values outside this range are clamped to either 0 or 9. If the option is not given, a default balanced compression setting is used. -flto-report Prints a report with internal details on the workings of the link-time optimizer. The contents of this report vary from version to version. It is meant to be useful to GCC developers when processing object les in LTO mode (via -flto). Disabled by default. -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 les with GIMPLE bytecode out of library archives. This improves the quality of optimization by exposing more code to the link-time optimizer. This information species 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 eect of this ag and how to use it. This option is enabled by default when LTO support in GCC is enabled and GCC was congured for use with a linker supporting plugins (GNU ld 2.21 or newer or gold). -ffat-lto-objects Fat LTO objects are object les that contain both the intermediate language and the object code. This makes them usable for both LTO linking and normal linking. This option is eective only when compiling with -flto and is ignored at link time. -fno-fat-lto-objects improves compilation time over plain LTO, but requires 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

126

Using the GNU Compiler Collection (GCC)

wrappers to pass the right options to these tools. With non fat LTO makeles need to be modied to use them. The default is -ffat-lto-objects but this default is intended to change in future releases when linker plugin enabled environments become more common. -fcompare-elim After register allocation and post-register allocation instruction splitting, identify arithmetic instructions that compute processor ags similar to a comparison operation based on that arithmetic. If possible, eliminate the explicit comparison 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. -fuse-ld=bfd Use the bfd linker instead of the default linker. -fuse-ld=gold Use the gold linker instead of the default linker. -fcprop-registers After register allocation and post-register allocation instruction splitting, perform a copy-propagation pass to try to reduce scheduling dependencies and occasionally eliminate the copy. Enabled at levels -O, -O2, -O3, -Os. -fprofile-correction Proles collected using an instrumented binary for multi-threaded programs may be inconsistent due to missed counter updates. When this option is specied, GCC uses heuristics to correct or smooth out such inconsistencies. By default, GCC emits an error message when an inconsistent prole is detected. -fprofile-dir=path Set the directory to search for the prole data les in to path. This option aects only the prole 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 prole data le appears in the same directory as the object le. -fprofile-generate -fprofile-generate=path Enable options usually used for instrumenting application to produce prole useful for later recompilation with prole 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 specied, GCC looks at the path to nd the prole feedback data les. See -fprofile-dir.

Chapter 3: GCC Command Options

127

-fprofile-use -fprofile-use=path Enable prole feedback directed optimizations, and optimizations generally protable only with prole feedback available. The following options are enabled: -fbranch-probabilities, -fvpt, -funroll-loops, -fpeel-loops, -ftracer, -ftree-vectorize, ftree-loop-distribute-patterns By default, GCC emits an error message if the feedback proles 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 specied, GCC looks at the path to nd the prole feedback data les. See -fprofile-dir. The following options control compiler behavior regarding oating-point arithmetic. These options trade o between speed and correctness. All must be specically enabled. -ffloat-store Do not store oating-point variables in registers, and inhibit other options that might change whether a oating-point value is taken from a register or memory. This option prevents undesirable excess precision on machines such as the 68000 where the oating 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 denition of IEEE oating 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 oating-point registers have more precision than the IEEE float and double types and the processor does not support operations rounding to those types. By default, -fexcess-precision=fast is in eect; this means that operations are carried out in the precision of the registers and that it is unpredictable when rounding to the types specied in the source code takes place. When compiling C, if -fexcess-precision=standard is specied then excess precision follows the rules specied in ISO C99; in particular, both casts and assignments cause values to be rounded to their semantic types (whereas -ffloat-store only aects assignments). This option is enabled by default for C if a strict conformance option such as -std=c99 is used. -fexcess-precision=standard is not implemented for languages other than C, and has no eect if -funsafe-math-optimizations or -ffast-math is specied. On the x86, it also has no eect if -mfpmath=sse or -mfpmath=sse+387 is specied; in the former case, IEEE semantics apply without excess precision, and in the latter, rounding is unpredictable. -ffast-math Sets -fno-math-errno, -funsafe-math-optimizations, -ffinite-math-only, -fno-rounding-math, -fno-signaling-nans and -fcx-limited-range. This option causes the preprocessor macro __FAST_MATH__ to be dened.

128

Using the GNU Compiler Collection (GCC)

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/specications for math functions. It may, however, yield faster code for programs that do not require the guarantees of these specications. -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 ag 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/specications for math functions. It may, however, yield faster code for programs that do not require the guarantees of these specications. The default is -fmath-errno. On Darwin systems, the math library never sets errno. There is therefore no reason for the compiler to consider the possibility that it might, and -fno-math-errno is the default. -funsafe-math-optimizations Allow optimizations for oating-point arithmetic that (a) assume that arguments and results are valid and (b) may violate IEEE or ANSI standards. When used at link-time, it may include libraries or startup les that change the default FPU control word or other similar optimizations. This option is not turned on by any -O option since it can result in incorrect output for programs that depend on an exact implementation of IEEE or ISO rules/specications for math functions. It may, however, yield faster code for programs that do not require the guarantees of these specications. 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 oating-point operations. This violates the ISO C and C++ language standard by possibly changing computation result. NOTE: re-ordering may change the sign of zero as well as ignore NaNs and inhibit or create underow or overow (and thus cannot be used on code that relies on rounding behavior like (x + 2**52) - 2**52. May also reorder oating-point comparisons and thus may not be used when ordered comparisons are required. This option requires that both -fno-signed-zeros and -fno-trapping-math be in eect. Moreover, it doesnt make much sense with -frounding-math. For Fortran the option is automatically enabled when both -fno-signed-zeros and -fno-trapping-math are in eect. The default is -fno-associative-math.

Chapter 3: GCC Command Options

129

-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 ops operating on the value. The default is -fno-reciprocal-math. -ffinite-math-only Allow optimizations for oating-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/specications for math functions. It may, however, yield faster code for programs that do not require the guarantees of these specications. The default is -fno-finite-math-only. -fno-signed-zeros Allow optimizations for oating-point arithmetic that ignore the signedness of zero. IEEE arithmetic species the behavior of distinct +0.0 and 0.0 values, which then prohibits simplication 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 isnt signicant. The default is -fsigned-zeros. -fno-trapping-math Compile code assuming that oating-point operations cannot generate uservisible traps. These traps include division by zero, overow, underow, inexact result and invalid operation. This option requires that -fno-signaling-nans be in eect. 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/specications for math functions. The default is -ftrapping-math. -frounding-math Disable transformations and optimizations that assume default oating-point rounding behavior. This is round-to-zero for all oating point to integer conversions, and round-to-nearest for all other arithmetic truncations. This option should be specied for programs that change the FP rounding mode dynamically, or that may be executed with a non-default rounding mode. This option disables constant folding of oating-point expressions at compile time (which may be aected 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 aected by rounding mode. Future versions of GCC may

130

Using the GNU Compiler Collection (GCC)

provide ner control of this setting using C99s 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 oating-point operations. Setting this option disables optimizations 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 dened. The default is -fno-signaling-nans. This option is experimental and does not currently guarantee to disable all GCC optimizations that aect signaling NaN behavior. -fsingle-precision-constant Treat oating-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.9 [Options for Debugging Your Program or gcc], page 74), 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 le called [Link] for each source le. The information in this data le 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

Chapter 3: GCC Command Options

131

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. -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 proling values of expressions for usage in optimizations. Enabled with -fprofile-generate and -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 benets 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 and -fpeel-loops. -ftracer Perform tail duplication to enlarge superblock size. This transformation simplies the control ow 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. -fpeel-loops Peels loops for which there is enough information that they do not roll much (from prole feedback). It also turns on complete loop peeling (i.e. complete removal of loops with small constant number of iterations). Enabled with -fprofile-use.

132

Using the GNU Compiler Collection (GCC)

-fmove-loop-invariants Enables the loop invariant motion pass in the RTL loop optimizer. Enabled at level -O1 -funswitch-loops Move branches with loop invariant conditions out of the loop, with duplicates of the loop on both branches (modied according to result of the condition). -ffunction-sections -fdata-sections Place each function or data item into its own section in the output le if the target supports arbitrary sections. The name of the function or the name of the data item determines the sections name in the output le. 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 signicant benets from doing so. When you specify these options, the assembler and linker create larger object and executable les 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, dont reuse branch target registers within any basic block. -fstack-protector Emit extra code to check for buer overows, such as stack smashing attacks. This is done by adding a guard variable to functions with vulnerable objects. This includes functions that call alloca, and functions with buers larger than 8 bytes. The guards are initialized when a function is entered and then checked when the function exits. If a guard check fails, an error message is printed and the program exits. -fstack-protector-all Like -fstack-protector except that all functions are protected. -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.

Chapter 3: GCC Command Options

133

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 eect is similar to the following pseudocode (which isnt 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 optimization 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 specic 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-crossjump-edges The maximum number of incoming edges to consider for crossjumping. 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

134

Using the GNU Compiler Collection (GCC)

process, and unfactors them as late as possible. Only computed jumps at the end of a basic blocks with no more than max-gotoduplication-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 ll a delay slot. If more than this arbitrary number of instructions are searched, the time savings from lling 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 ll delay slots, the maximum number of instructions 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 parameter should be removed when the delay slot code is rewritten to maintain the control-ow graph. max-gcse-memory The approximate maximum amount of memory that can be allocated in order to perform the global common subexpression elimination optimization. If more memory than specied is required, the optimization is not done. 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 ushing 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 exponentially increase compilation time. max-inline-insns-single Several parameters control the tree inliner used in GCC. This number sets the maximum number of instructions (counted in GCCs internal representation) in a single function that the tree inliner considers for inlining. This only aects functions declared inline and methods implemented in a class declaration (C++). The default value is 400.

Chapter 3: GCC Command Options

135

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 dierent (more restrictive) limit compared to functions declared inline can be applied. The default value is 40. inline-min-speedup When estimated performance improvement of caller + callee runtime exceeds this threshold (in precent), the function can be inlined regardless 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 Species maximal growth of large function caused by inlining in percents. The default value is 100 which limits large function growth to 2.0 times the original size. 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 Species maximal overall growth of the compilation unit caused by inlining. The default value is 30 which limits unit growth to 1.3 times the original size. ipcp-unit-growth Species 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.

136

Using the GNU Compiler Collection (GCC)

large-stack-frame The limit specifying large stack frames. While inlining the algorithm is trying to not grow past this limit too much. The default value is 256 bytes. large-stack-frame-growth Species 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 Species the maximum number of instructions an out-of-line copy of a self-recursive inline function can grow into by performing recursive inlining. For functions declared inline, --param max-inline-insns-recursive is taken into account. For functions not declared inline, recursive inlining happens only when -finline-functions (included in -O3) is enabled and --param max-inline-insns-recursive-auto is used. The default value is 450. max-inline-recursive-depth max-inline-recursive-depth-auto Species the maximum recursion depth used for recursive inlining. For functions declared inline, --param max-inline-recursive-depth is taken into account. For functions not declared inline, recursive inlining happens only when -finline-functions (included in -O3) is enabled and --param max-inline-recursive-depth-auto is used. The default value is 8. min-inline-recursive-probability Recursive inlining is protable only for function having deep recursion 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 prole feedback is available (see -fprofile-generate) the actual recursion depth can be guessed from 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 eect it increases the amount of inlining for code having a large abstraction penalty. The default value is 10.

Chapter 3: GCC Command Options

137

max-early-inliner-iterations 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 comdat-sharing-probability Probability (in percent) that C++ inline function with comdat visibility are shared across multiple compilation units. The default value is 20. min-vect-loop-bound The minimum number of iterations under which loops are not vectorized when -ftree-vectorize is used. The number of iterations after vectorization needs to be greater than the value specied 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 aggressive code hoisting is with simple expressions, i.e., the expressions 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 distance an expression can travel. This is currently supported only in the code hoisting pass. The lesser the cost, the more aggressive 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 compilation 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.

138

Using the GNU Compiler Collection (GCC)

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. 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. 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.

Chapter 3: GCC Command Options

139

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. 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. omega-max-vars The maximum number of variables in an Omega constraint system. The default value is 128. omega-max-geqs The maximum number of inequalities in an Omega constraint system. The default value is 256. omega-max-eqs The maximum number of equalities in an Omega constraint system. The default value is 128. omega-max-wild-cards The maximum number of wildcard variables that the Omega solver is able to insert. The default value is 18. omega-hash-table-size The size of the hash table in the Omega solver. The default value is 550. omega-max-keys The maximal number of keys used by the Omega solver. The default value is 500. omega-eliminate-redundant-constraints When set to 1, use expensive methods to eliminate all redundant constraints. The default value is 0. 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. See option -ftree-vect-loop-version for more information. 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. See option -ftree-vect-loop-version for more information.

140

Using the GNU Compiler Collection (GCC)

max-iterations-to-track The maximum number of iterations of a loop the brute-force algorithm for analysis of the number of iterations of the loop tries to evaluate. hot-bb-count-ws-permille A basic block prole count is considered hot if it contributes to the given permillage (i.e. 0...1000) of the entire proled 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 articially cold relative to the other one. 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 percentage of executed instructions is covered. This limits unnecessary code size expansion. The tracer-dynamic-coverage-feedback is used only when prole feedback is available. The real proles (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 percentage. This is a rather articial 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).

Chapter 3: GCC Command Options

141

tracer-min-branch-ratio tracer-min-branch-ratio-feedback Stop forward growth if the best edge has probability lower than this threshold. Similarly to tracer-dynamic-coverage two values are present, one for compilation for prole feedback and one for compilation without. The value for compilation with prole feedback needs to be more conservative (higher) in order to make tracer eective. 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 ushing. The default is 1000. ggc-min-expand GCC uses a garbage collector to manage its own memory allocation. This parameter species the minimum percentage by which the garbage collectors heap should be allowed to expand between collections. Tuning this may improve compilation speed; it has no eect on code generation. The default is 30% + 70% * (RAM/1GB) with an upper bound of 100% when RAM >= 1GB. If getrlimit is available, the notion of RAM is the smallest of actual RAM and RLIMIT_DATA or RLIMIT_AS. If GCC is not able to calculate RAM on a particular platform, the lower bound of 30% is used. Setting this parameter and ggc-min-heapsize to zero causes a full collection to occur at every opportunity. This is extremely slow, but can be useful for debugging. ggc-min-heapsize Minimum size of the garbage collectors heap before it begins bothering to collect garbage. The rst collection occurs after the heap expands by ggc-min-expand% beyond ggc-min-heapsize. Again, tuning this may improve compilation speed, and has no eect 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 eectively 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-

142

Using the GNU Compiler Collection (GCC)

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. reorder-blocks-duplicate reorder-blocks-duplicate-feedback Used by the basic block reordering pass to decide whether to use unconditional branch or duplicate the code on its destination. Code is duplicated when its estimated size is smaller than this value multiplied by the estimated size of unconditional jump in the hot spots of the program. The reorder-block-duplicate-feedback is used only when prole feedback is available. It may be set to higher values than reorder-block-duplicate since information about the hot spots is more accurate. max-sched-ready-insns The maximum number of instructions ready to be issued the scheduler should consider at any given time during the rst scheduling pass. Increasing values mean more thorough searches, making the compilation time increase with probably little benet. 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. 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.

Chapter 3: GCC Command Options

143

max-sched-insn-conflict-delay The maximum conict delay for an insn to be considered for speculative 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-spec-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-max-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. 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. integer-share-limit Small integer constants can use a shared data structure, reducing the compilers 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 buers (i.e. arrays) that receive stack smashing protection when -fstack-protection is used. max-jump-thread-duplication-stmts Maximum number of statements allowed in a block that needs to be duplicated when threading jumps.

144

Using the GNU Compiler Collection (GCC)

max-fields-for-field-sensitive Maximum number of elds in a structure treated in a eld 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 before prefetch nishes. The distance prefetched ahead is proportional 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. 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 ecient internal mechanism for comparing types in C++ and Objective-C++. However, 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 bigger than switch-conversion-max-branch-ratio times the number 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 enhanced 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.

Chapter 3: GCC Command Options

145

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 maxmimum number of queries is 1000. ira-max-loops-num IRA uses regional register allocation by default. If a function contains 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 conict table, the table can still require excessive amounts of memory for huge functions. If the conict table for a function could be more 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 conict 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. 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 wont 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 dapendencies 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

146

Using the GNU Compiler Collection (GCC)

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 dataow 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 be represented in debug information may end up not being used; setting this higher may enable the compiler to nd 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 (nonoverlapping) 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. tm-max-aggregate-size When making copies of thread-local variables in a transaction, this parameter species 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 eects 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 unknown at compilation time and dened outside a SCoP is a parameter of the SCoP. graphite-max-bbs-per-function To avoid exponential eects in the detection of SCoPs, the size of the functions analyzed by Graphite is bounded. The default value is 100 basic blocks.

Chapter 3: GCC Command Options

147

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. ipa-cp-value-list-size IPA-CP attempts to track all possible values and types passed to a functions parameter in order to propagate them and perform devirtualization. ipa-cp-value-list-size is the maximum number of values and types it stores per one formal parameter of a function. 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-minpartition Size of minimal partition for WHOPR (in estimated instructions). This prevents expenses of splitting very small programs into too many partitions. cxx-max-namespaces-for-diagnostic-help The maximum number of namespaces to consult for suggestions when C++ name lookup fails for an identier. The default is 1000. sink-frequency-threshold The maximum relative execution frequency (in percents) of the target block relative to a statements 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 adjustment is applied for statements with memory operands as those are even more protable so sink. max-stores-to-sink The maximum number of conditional stores paires that can be sunk. Set to 0 if either vectorization (-ftree-vectorize) or ifconversion (-ftree-loop-if-convert) is disabled. The default is 2. allow-load-data-races Allow optimizers to introduce new data races on loads. Set to 1 to allow, otherwise to 0. This option is enabled by default unless implicitly set by the -fmemory-model= option. 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 unless implicitly set by the -fmemory-model= option.

148

Using the GNU Compiler Collection (GCC)

allow-packed-load-data-races Allow optimizers to introduce new data races on packed data loads. Set to 1 to allow, otherwise to 0. This option is enabled by default unless implicitly set by the -fmemory-model= option. allow-packed-store-data-races Allow optimizers to introduce new data races on packed data stores. Set to 1 to allow, otherwise to 0. This option is enabled by default unless implicitly set by the -fmemory-model= option. case-values-threshold The smallest number of dierent 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 reassociated tree. This parameter overrides target dependent heuristics 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. 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 le 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 will be considered when seeking a basis for a new straight-line strength reduction candidate.

3.11 Options Controlling the Preprocessor

These options control the C preprocessor, which is run on each C source le before actual compilation. If you use the -E option, nothing is done except preprocessing. Some of these options make sense only together with -E because they cause the preprocessor output to be unsuitable for actual compilation. -Wp,option You can use -Wp,option to bypass the compiler driver and pass option directly through to the preprocessor. If option contains commas, it is split into multiple options at the commas. However, many options are modied, translated or interpreted by the compiler driver before being passed to the preprocessor,

Chapter 3: GCC Command Options

149

and -Wp forcibly bypasses this phase. The preprocessors direct interface is undocumented and subject to change, so whenever possible you should avoid using -Wp and let the driver handle the options instead. -Xpreprocessor option Pass option as an option to the preprocessor. You can use this to supply system-specic preprocessor options that GCC does not recognize. If you want to pass an option that takes an argument, you must use -Xpreprocessor twice, once for the option and once for the argument. -no-integrated-cpp Perform preprocessing as a separate pass before compilation. By default, GCC performs preprocessing as an integrated part of input tokenization and parsing. If this option is provided, the appropriate language front end (cc1, cc1plus, or cc1obj for C, C++, and Objective-C, respectively) is instead invoked twice, once for preprocessing only and once for actual compilation of the preprocessed input. This option may be useful in conjunction with the -B or -wrapper options to specify an alternate preprocessor or perform additional processing of the program source between normal preprocessing and compilation. -D name Predene name as a macro, with denition 1.

-D name=definition The contents of denition are tokenized and processed as if they appeared during translation phase three in a #define directive. In particular, the denition will be truncated by embedded newline characters. If you are invoking the preprocessor from a shell or shell-like program you may need to use the shells quoting syntax to protect characters such as spaces that have a meaning in the shell syntax. If you wish to dene a function-like macro on the command line, write its argument list with surrounding parentheses before the equals sign (if any). Parentheses are meaningful to most shells, so you will need to quote the option. With sh and csh, -Dname(args...)=definition works. -D and -U options are processed in the order they are given on the command line. All -imacros file and -include file options are processed after all -D and -U options. -U name -undef -I dir Cancel any previous denition of name, either built in or provided with a -D option. Do not predene any system-specic or GCC-specic macros. The standard predened macros remain dened. Add the directory dir to the list of directories to be searched for header les. Directories named by -I are searched before the standard system include directories. If the directory dir is a standard system include directory, the option is ignored to ensure that the default search order for system directories and the special treatment of system headers are not defeated . If dir begins with =, then the = will be replaced by the sysroot prex; see --sysroot and -isysroot.

150

Using the GNU Compiler Collection (GCC)

-o file

Write output to le. This is the same as specifying le as the second non-option argument to cpp. gcc has a dierent interpretation of a second non-option argument, so you must use -o to specify the output le. Turns on all optional warnings which are desirable for normal code. At present this is -Wcomment, -Wtrigraphs, -Wmultichar and a warning about integer promotion causing a change of sign in #if expressions. Note that many of the preprocessors warnings are on by default and have no options to control them.

-Wall

-Wcomment -Wcomments Warn whenever a comment-start sequence /* appears in a /* comment, or whenever a backslash-newline appears in a // comment. (Both forms have the same eect.) -Wtrigraphs Most trigraphs in comments cannot aect the meaning of the program. However, a trigraph that would form an escaped newline (??/ at the end of a line) can, by changing where the comment begins or ends. Therefore, only trigraphs that would form escaped newlines produce warnings inside a comment. This option is implied by -Wall. If -Wall is not given, this option is still enabled unless trigraphs are enabled. To get trigraph conversion without warnings, but get the other -Wall warnings, use -trigraphs -Wall -Wno-trigraphs. -Wtraditional Warn about certain constructs that behave dierently in traditional and ISO C. Also warn about ISO C constructs that have no traditional C equivalent, and problematic constructs which should be avoided. -Wundef Warn whenever an identier which is not a macro is encountered in an #if directive, outside of defined. Such identiers are replaced with zero.

-Wunused-macros Warn about macros dened in the main le that are unused. A macro is used if it is expanded or tested for existence at least once. The preprocessor will also warn if the macro has not been used at the time it is redened or undened. Built-in macros, macros dened on the command line, and macros dened in include les are not warned about. Note: If a macro is actually used, but only used in skipped conditional blocks, then CPP will report it as unused. To avoid the warning in such a case, you might improve the scope of the macros denition by, for example, moving it into the rst skipped block. Alternatively, you could provide a dummy use with something like:
#if defined the_macro_causing_the_warning #endif

-Wendif-labels Warn whenever an #else or an #endif are followed by text. This usually happens in code of the form

Chapter 3: GCC Command Options

151

#if FOO ... #else FOO ... #endif FOO

The second and third FOO should be in comments, but often are not in older programs. This warning is on by default. -Werror Make all warnings into hard errors. Source code which triggers warnings will be rejected.

-Wsystem-headers Issue warnings for code in system headers. These are normally unhelpful in nding bugs in your own code, therefore suppressed. If you are responsible for the system library, you may want to see them. -w -pedantic Issue all the mandatory diagnostics listed in the C standard. Some of them are left out by default, since they trigger frequently on harmless code. -pedantic-errors Issue all the mandatory diagnostics, and make all mandatory diagnostics into errors. This includes mandatory diagnostics that GCC issues without -pedantic but treats as warnings. -M Instead of outputting the result of preprocessing, output a rule suitable for make describing the dependencies of the main source le. The preprocessor outputs one make rule containing the object le name for that source le, a colon, and the names of all the included les, including those coming from -include or -imacros command line options. Unless specied explicitly (with -MT or -MQ), the object le name consists of the name of the source le with any sux replaced with object le sux and with any leading directory parts removed. If there are many included les then the rule is split into several lines using \-newline. The rule has no commands. This option does not suppress the preprocessors debug output, such as -dM. To avoid mixing such debug output with the dependency rules you should explicitly specify the dependency output le with -MF, or use an environment variable like DEPENDENCIES_OUTPUT (see Section 3.19 [Environment Variables], page 309). Debug output will still be sent to the regular output stream as normal. Passing -M to the driver implies -E, and suppresses warnings with an implicit -w. -MM Like -M but do not mention header les that are found in system header directories, nor header les that are included, directly or indirectly, from such a header. This implies that the choice of angle brackets or double quotes in an #include directive does not in itself determine whether that header will appear in -MM Suppress all warnings, including those which GNU CPP issues by default.

152

Using the GNU Compiler Collection (GCC)

dependency output. This is a slight change in semantics from GCC versions 3.0 and earlier. -MF file When used with -M or -MM, species a le to write the dependencies to. If no -MF switch is given the preprocessor sends the rules to the same place it would have sent preprocessed output. When used with the driver options -MD or -MMD, -MF overrides the default dependency output le. In conjunction with an option such as -M requesting dependency generation, -MG assumes missing header les are generated les and adds them to the dependency list without raising an error. The dependency lename is taken directly from the #include directive without prepending any path. -MG also suppresses preprocessed output, as a missing header le renders this useless. This feature is used in automatic updating of makeles. This option instructs CPP to add a phony target for each dependency other than the main le, causing each to depend on nothing. These dummy rules work around errors make gives if you remove header les without updating the Makefile to match. This is typical output:
test.o: test.c test.h test.h:

-MG

-MP

-MT target Change the target of the rule emitted by dependency generation. By default CPP takes the name of the main input le, deletes any directory components and any le sux such as .c, and appends the platforms usual object sux. The result is the target. An -MT option will set the target to be exactly the string you specify. If you want multiple targets, you can specify them as a single argument to -MT, or use multiple -MT options. For example, -MT $(objpfx)foo.o might give
$(objpfx)foo.o: foo.c

-MQ target Same as -MT, but it quotes any characters which are special to Make. -MQ $(objpfx)foo.o gives
$$(objpfx)foo.o: foo.c

The default target is automatically quoted, as if it were given with -MQ. -MD -MD is equivalent to -M -MF file, except that -E is not implied. The driver determines le based on whether an -o option is given. If it is, the driver uses its argument but with a sux of .d, otherwise it takes the name of the input le, removes any directory components and sux, and applies a .d sux. If -MD is used in conjunction with -E, any -o switch is understood to specify the dependency output le (see [-MF], page 152), but if used without -E, each -o is understood to specify a target object le.

Chapter 3: GCC Command Options

153

Since -E is not implied, -MD can be used to generate a dependency output le as a side-eect of the compilation process. -MMD -fpch-deps When using precompiled headers (see Section 3.20 [Precompiled Headers], page 311), this ag will cause the dependency-output ags to also list the les from the precompiled headers dependencies. If not specied only the precompiled header would be listed and not the les that were used to create it because those les are not consulted when a precompiled header is used. -fpch-preprocess This option allows use of a precompiled header (see Section 3.20 [Precompiled Headers], page 311) together with -E. It inserts a special #pragma, #pragma GCC pch_preprocess "filename" in the output to mark the place where the precompiled header was found, and its lename. When -fpreprocessed is in use, GCC recognizes this #pragma and loads the PCH. This option is o by default, because the resulting preprocessed output is only really suitable as input to GCC. It is switched on by -save-temps. You should not write this #pragma in your own code, but it is safe to edit the lename if the PCH le is available in a dierent location. The lename may be absolute or it may be relative to GCCs current directory. -x -x -x -x c c++ objective-c assembler-with-cpp Specify the source language: C, C++, Objective-C, or assembly. This has nothing to do with standards conformance or extensions; it merely selects which base syntax to expect. If you give none of these options, cpp will deduce the language from the extension of the source le: .c, .cc, .m, or .S. Some other common extensions for C++ and assembly are also recognized. If cpp does not recognize the extension, it will treat the le as C; this is the most generic mode. Note: Previous versions of cpp accepted a -lang option which selected both the language and the standards conformance level. This option has been removed, because it conicts with the -l option. Like -MD except mention only user header les, not system header les.

-std=standard -ansi Specify the standard to which the code should conform. Currently CPP knows about C and C++ standards; others may be added in the future. standard may be one of: c90 c89 iso9899:1990 The ISO C standard from 1990. c90 is the customary shorthand for this version of the standard. The -ansi option is equivalent to -std=c90.

154

Using the GNU Compiler Collection (GCC)

iso9899:199409 The 1990 C standard, as amended in 1994. iso9899:1999 c99 iso9899:199x c9x The revised ISO C standard, published in December 1999. Before publication, this was known as C9X. iso9899:2011 c11 c1x The revised ISO C standard, published in December 2011. Before publication, this was known as C1X. gnu90 gnu89 gnu99 gnu9x gnu11 gnu1x c++98 gnu++98 -IThe 1990 C standard plus GNU extensions. This is the default. The 1999 C standard plus GNU extensions. The 2011 C standard plus GNU extensions. The 1998 ISO C++ standard plus amendments. The same as -std=c++98 plus GNU extensions. This is the default for C++ code.

Split the include path. Any directories specied with -I options before -I- are searched only for headers requested with #include "file"; they are not searched for #include <file>. If additional directories are specied with -I options after the -I-, those directories are searched for all #include directives. In addition, -I- inhibits the use of the directory of the current le directory as the rst search directory for #include "file". This option has been deprecated. Do not search the standard system directories for header les. Only the directories you have specied with -I options (and the directory of the current le, if appropriate) are searched.

-nostdinc

-nostdinc++ Do not search for header les in the C++-specic standard directories, but do still search the other standard directories. (This option is used when building the C++ library.) -include file Process le as if #include "file" appeared as the rst line of the primary source le. However, the rst directory searched for le is the preprocessors working directory instead of the directory containing the main source le. If not found there, it is searched for in the remainder of the #include "..." search chain as normal.

Chapter 3: GCC Command Options

155

If multiple -include options are given, the les are included in the order they appear on the command line. -imacros file Exactly like -include, except that any output produced by scanning le is thrown away. Macros it denes remain dened. This allows you to acquire all the macros from a header without also processing its declarations. All les specied by -imacros are processed before all les specied by -include. -idirafter dir Search dir for header les, but do it after all directories specied with -I and the standard system directories have been exhausted. dir is treated as a system include directory. If dir begins with =, then the = will be replaced by the sysroot prex; see --sysroot and -isysroot. -iprefix prefix Specify prex as the prex for subsequent -iwithprefix options. If the prex represents a directory, you should include the nal /. -iwithprefix dir -iwithprefixbefore dir Append dir to the prex specied previously with -iprefix, and add the resulting directory to the include search path. -iwithprefixbefore puts it in the same place -I would; -iwithprefix puts it where -idirafter would. -isysroot dir This option is like the --sysroot option, but applies only to header les (except for Darwin targets, where it applies to both header les and libraries). See the --sysroot option for more information. -imultilib dir Use dir as a subdirectory of the directory containing target-specic C++ headers. -isystem dir Search dir for header les, after all directories specied by -I but before the standard system directories. Mark it as a system directory, so that it gets the same special treatment as is applied to the standard system directories. If dir begins with =, then the = will be replaced by the sysroot prex; see --sysroot and -isysroot. -iquote dir Search dir only for header les requested with #include "file"; they are not searched for #include <file>, before all directories specied by -I and before the standard system directories. If dir begins with =, then the = will be replaced by the sysroot prex; see --sysroot and -isysroot. -fdirectives-only When preprocessing, handle directives, but do not expand macros. The options behavior depends on the -E and -fpreprocessed options. With -E, preprocessing is limited to the handling of directives such as #define, #ifdef, and #error. Other preprocessor operations, such as macro expansion

156

Using the GNU Compiler Collection (GCC)

and trigraph conversion are not performed. In addition, the -dD option is implicitly enabled. With -fpreprocessed, predenition of command line and most builtin macros is disabled. Macros such as __LINE__, which are contextually dependent, are handled normally. This enables compilation of les previously preprocessed with -E -fdirectives-only. With both -E and -fpreprocessed, the rules for -fpreprocessed take precedence. This enables full preprocessing of les previously preprocessed with -E -fdirectives-only. -fdollars-in-identifiers Accept $ in identiers. -fextended-identifiers Accept universal character names in identiers. This option is experimental; in a future version of GCC, it will be enabled by default for C99 and C++. -fno-canonical-system-headers When preprocessing, do not shorten system header paths with canonicalization. -fpreprocessed Indicate to the preprocessor that the input le has already been preprocessed. This suppresses things like macro expansion, trigraph conversion, escaped newline splicing, and processing of most directives. The preprocessor still recognizes and removes comments, so that you can pass a le preprocessed with -C to the compiler without problems. In this mode the integrated preprocessor is little more than a tokenizer for the front ends. -fpreprocessed is implicit if the input le has one of the extensions .i, .ii or .mi. These are the extensions that GCC uses for preprocessed les created by -save-temps. -ftabstop=width Set the distance between tab stops. This helps the preprocessor report correct column numbers in warnings or errors, even if tabs appear on the line. If the value is less than 1 or greater than 100, the option is ignored. The default is 8. -fdebug-cpp This option is only useful for debugging GCC. When used with -E, dumps debugging information about location maps. Every token in the output is preceded by the dump of the map its location belongs to. The dump of the map holding the location of a token would be: When used without -E, this option has no eect. -ftrack-macro-expansion[=level] Track locations of tokens across macro expansions. This allows the compiler to emit diagnostic about the current macro expansion stack when a compilation error occurs in a macro expansion. Using this option makes the preprocessor and the compiler consume more memory. The level parameter can be used to choose the level of precision of token location tracking thus decreasing the

{P:/file/path;F:/includer/path;L:line_num;C:col_num;S:system_header_p;M:map_a

Chapter 3: GCC Command Options

157

memory consumption if necessary. Value 0 of level de-activates this option just as if no -ftrack-macro-expansion was present on the command line. Value 1 tracks tokens locations in a degraded mode for the sake of minimal memory overhead. In this mode all tokens resulting from the expansion of an argument of a function-like macro have the same location. Value 2 tracks tokens locations completely. This value is the most memory hungry. When this option is given no argument, the default parameter value is 2. Note that -ftrack-macro-expansion=2 is activated by default. -fexec-charset=charset Set the execution character set, used for string and character constants. The default is UTF-8. charset can be any encoding supported by the systems iconv library routine. -fwide-exec-charset=charset Set the wide execution character set, used for wide string and character constants. The default is UTF-32 or UTF-16, whichever corresponds to the width of wchar_t. As with -fexec-charset, charset can be any encoding supported by the systems iconv library routine; however, you will have problems with encodings that do not t exactly in wchar_t. -finput-charset=charset Set the input character set, used for translation from the character set of the input le to the source character set used by GCC. If the locale does not specify, or GCC cannot get this information from the locale, the default is UTF-8. This can be overridden by either the locale or this command line option. Currently the command line option takes precedence if theres a conict. charset can be any encoding supported by the systems iconv library routine. -fworking-directory Enable generation of linemarkers in the preprocessor output that will let the compiler know the current working directory at the time of preprocessing. When this option is enabled, the preprocessor will emit, after the initial linemarker, a second linemarker with the current working directory followed by two slashes. GCC will use this directory, when its present in the preprocessed input, as the directory emitted as the current working directory in some debugging information formats. This option is implicitly enabled if debugging information is enabled, but this can be inhibited with the negated form -fno-working-directory. If the -P ag is present in the command line, this option has no eect, since no #line directives are emitted whatsoever. -fno-show-column Do not print column numbers in diagnostics. This may be necessary if diagnostics are being scanned by a program that does not understand the column numbers, such as dejagnu. -A predicate=answer Make an assertion with the predicate predicate and answer answer. This form is preferred to the older form -A predicate(answer), which is still supported, because it does not use shell special characters.

158

Using the GNU Compiler Collection (GCC)

-A -predicate=answer Cancel an assertion with the predicate predicate and answer answer. -dCHARS CHARS is a sequence of one or more of the following characters, and must not be preceded by a space. Other characters are interpreted by the compiler proper, or reserved for future versions of GCC, and so are silently ignored. If you specify characters whose behavior conicts, the result is undened. M Instead of the normal output, generate a list of #define directives for all the macros dened during the execution of the preprocessor, including predened macros. This gives you a way of nding out what is predened in your version of the preprocessor. Assuming you have no le foo.h, the command
touch foo.h; cpp -dM foo.h

will show all the predened macros. If you use -dM without the -E option, -dM is interpreted as a synonym for -fdump-rtl-mach. See Section Debugging Options in gcc. D Like M except in two respects: it does not include the predened macros, and it outputs both the #define directives and the result of preprocessing. Both kinds of output go to the standard output le. Like D, but emit only the macro names, not their expansions. Output #include directives in addition to the result of preprocessing. Like D except that only macros that are expanded, or whose denedness is tested in preprocessor directives, are output; the output is delayed until the use or test of the macro; and #undef directives are also output for macros tested but undened at the time.

N I U

-P

Inhibit generation of linemarkers in the output from the preprocessor. This might be useful when running the preprocessor on something that is not C code, and will be sent to a program which might be confused by the linemarkers. Do not discard comments. All comments are passed through to the output le, except for comments in processed directives, which are deleted along with the directive. You should be prepared for side eects when using -C; it causes the preprocessor to treat comments as tokens in their own right. For example, comments appearing at the start of what would be a directive line have the eect of turning that line into an ordinary source line, since the rst token on the line is no longer a #. Do not discard comments, including during macro expansion. This is like -C, except that comments contained within macros are also passed through to the output le where the macro is expanded. In addition to the side-eects of the -C option, the -CC option causes all C++-style comments inside a macro to be converted to C-style comments. This

-C

-CC

Chapter 3: GCC Command Options

159

is to prevent later use of that macro from inadvertently commenting out the remainder of the source line. The -CC option is generally used to support lint comments. -traditional-cpp Try to imitate the behavior of old-fashioned C preprocessors, as opposed to ISO C preprocessors. -trigraphs Process trigraph sequences. These are three-character sequences, all starting with ??, that are dened by ISO C to stand for single characters. For example, ??/ stands for \, so ??/n is a character constant for a newline. By default, GCC ignores trigraphs, but in standard-conforming modes it converts them. See the -std and -ansi options. The nine trigraphs and their replacements are
Trigraph: Replacement: ??( [ ??) ] ??< { ??> } ??= # ??/ \ ?? ^ ??! | ??~

-remap

Enable special code to work around le systems which only permit very short le names, such as MS-DOS.

--help --target-help Print text describing all the command line options instead of preprocessing anything. -v -H Verbose mode. Print out GNU CPPs version number at the beginning of execution, and report the nal form of the include path. Print the name of each header le used, in addition to other normal activities. Each name is indented to show how deep in the #include stack it is. Precompiled header les are also printed, even if they are found to be invalid; an invalid precompiled header le is printed with ...x and a valid one with ...! .

-version --version Print out GNU CPPs version number. With one dash, proceed to preprocess as normal. With two dashes, exit immediately.

3.12 Passing Options to the Assembler

You can pass options to the assembler. -Wa,option Pass option as an option to the assembler. If option contains commas, it is split into multiple options at the commas. -Xassembler option Pass option as an option to the assembler. You can use this to supply systemspecic assembler options that GCC does not recognize. If you want to pass an option that takes an argument, you must use -Xassembler twice, once for the option and once for the argument.

160

Using the GNU Compiler Collection (GCC)

3.13 Options for Linking

These options come into play when the compiler links object les into an executable output le. They are meaningless if the compiler is not doing a link step. object-file-name A le name that does not end in a special recognized sux is considered to name an object le or library. (Object les are distinguished from libraries by the linker according to the le contents.) If linking is done, these object les are used as input to the linker. -c -S -E -llibrary -l library Search the library named library when linking. (The second alternative with the library as a separate argument is only for POSIX compliance and is not recommended.) It makes a dierence where in the command you write this option; the linker searches and processes libraries and object les in the order they are specied. Thus, foo.o -lz bar.o searches library z after le foo.o but before bar.o. If bar.o refers to functions in z, those functions may not be loaded. The linker searches a standard list of directories for the library, which is actually a le named liblibrary.a. The linker then uses this le as if it had been specied precisely by name. The directories searched include several standard system directories plus any that you specify with -L. Normally the les found this way are library lesarchive les whose members are object les. The linker handles an archive le by scanning through it for members which dene symbols that have so far been referenced but not dened. But if the le that is found is an ordinary object le, it is linked in the usual fashion. The only dierence between using an -l option and specifying a le name is that -l surrounds library with lib and .a and searches several directories. -lobjc You need this special case of the -l option in order to link an Objective-C or Objective-C++ program.

If any of these options is used, then the linker is not run, and object le names should not be used as arguments. See Section 3.2 [Overall Options], page 24.

-nostartfiles Do not use the standard system startup les when linking. The standard system libraries are used normally, unless -nostdlib or -nodefaultlibs is used. -nodefaultlibs Do not use the standard system libraries when linking. Only the libraries you specify are passed to the linker, and options specifying linkage of the system libraries, such as -static-libgcc or -shared-libgcc, are ignored. The standard startup les are used normally, unless -nostartfiles is used.

Chapter 3: GCC Command Options

161

The compiler may generate calls to memcmp, memset, memcpy and memmove. These entries are usually resolved by entries in libc. These entry points should be supplied through some other mechanism when this option is specied. -nostdlib Do not use the standard system startup les or libraries when linking. No startup les and only the libraries you specify are passed to the linker, and options specifying linkage of the system libraries, such as -static-libgcc or -shared-libgcc, are ignored. The compiler may generate calls to memcmp, memset, memcpy and memmove. These entries are usually resolved by entries in libc. These entry points should be supplied through some other mechanism when this option is specied. One of the standard libraries bypassed by -nostdlib and -nodefaultlibs is libgcc.a, a library of internal subroutines which GCC uses to overcome shortcomings of particular machines, or special needs for some languages. (See Section Interfacing to GCC Output in GNU Compiler Collection (GCC) Internals , for more discussion of libgcc.a.) In most cases, you need libgcc.a even when you want to avoid other standard libraries. In other words, when you specify -nostdlib or -nodefaultlibs you should usually specify -lgcc as well. This ensures that you have no unresolved references to internal GCC library subroutines. (An example of such an internal subroutine is __main, used to ensure C++ constructors are called; see Section collect2 in GNU Compiler Collection (GCC) Internals .) -pie Produce a position independent executable on targets that support it. For predictable results, you must also specify the same set of options used for compilation (-fpie, -fPIE, or model suboptions) when you specify this linker option. Pass the ag -export-dynamic to the ELF linker, on targets that support it. This instructs the linker to add all symbols, not only used ones, to the dynamic symbol table. This option is needed for some uses of dlopen or to allow obtaining backtraces from within a program. -s -static -shared Remove all symbol table and relocation information from the executable. On systems that support dynamic linking, this prevents linking with the shared libraries. On other systems, this option has no eect. Produce a shared object which can then be linked with other objects to form an executable. Not all systems support this option. For predictable results, you must also specify the same set of options used for compilation (-fpic, -fPIC, or model suboptions) when you specify this linker option.1

-rdynamic

On some systems, gcc -shared needs to build supplementary stub code for constructors to work. On multi-libbed systems, gcc -shared must select the correct support libraries to link against. Failing to supply the correct ags may lead to subtle defects. Supplying them in cases where they are not necessary is innocuous.

162

Using the GNU Compiler Collection (GCC)

-shared-libgcc -static-libgcc On systems that provide libgcc as a shared library, these options force the use of either the shared or static version, respectively. If no shared version of libgcc was built when the compiler was congured, these options have no eect. There are several situations in which an application should use the shared libgcc instead of the static version. The most common of these is when the application wishes to throw and catch exceptions across dierent shared libraries. In that case, each of the libraries as well as the application itself should use the shared libgcc. Therefore, the G++ and GCJ drivers automatically add -shared-libgcc whenever you build a shared library or a main executable, because C++ and Java programs typically use exceptions, so this is the right thing to do. If, instead, you use the GCC driver to create shared libraries, you may nd that they are not always linked with the shared libgcc. If GCC nds, at its conguration time, that you have a non-GNU linker or a GNU linker that does not support option --eh-frame-hdr, it links the shared version of libgcc into shared libraries by default. Otherwise, it takes advantage of the linker and optimizes away the linking with the shared version of libgcc, linking with the static version of libgcc by default. This allows exceptions to propagate through such shared libraries, without incurring relocation costs at library load time. However, if a library or main executable is supposed to throw or catch exceptions, you must link it using the G++ or GCJ driver, as appropriate for the languages used in the program, or using the option -shared-libgcc, such that it is linked with the shared libgcc. -static-libasan When the -fsanitize=address option is used to link a program, the GCC driver automatically links against libasan. If libasan is available as a shared library, and the -static option is not used, then this links against the shared version of libasan. The -static-libasan option directs the GCC driver to link libasan statically, without necessarily linking other libraries statically. -static-libtsan When the -fsanitize=thread option is used to link a program, the GCC driver automatically links against libtsan. If libtsan is available as a shared library, and the -static option is not used, then this links against the shared version of libtsan. The -static-libtsan option directs the GCC driver to link libtsan statically, without necessarily linking other libraries statically. -static-libstdc++ When the g++ program is used to link a C++ program, it normally automatically links against libstdc++. If libstdc++ is available as a shared library, and the -static option is not used, then this links against the shared version of libstdc++. That is normally ne. However, it is sometimes useful to freeze

Chapter 3: GCC Command Options

163

the version of libstdc++ used by the program without going all the way to a fully static link. The -static-libstdc++ option directs the g++ driver to link libstdc++ statically, without necessarily linking other libraries statically. -symbolic Bind references to global symbols when building a shared object. Warn about any unresolved references (unless overridden by the link editor option -Xlinker -z -Xlinker defs). Only a few systems support this option. -T script Use script as the linker script. This option is supported by most systems using the GNU linker. On some targets, such as bare-board targets without an operating system, the -T option may be required when linking to avoid references to undened symbols. -Xlinker option Pass option as an option to the linker. You can use this to supply system-specic linker options that GCC does not recognize. If you want to pass an option that takes a separate argument, you must use -Xlinker twice, once for the option and once for the argument. For example, to pass -assert definitions, you must write -Xlinker -assert -Xlinker definitions. It does not work to write -Xlinker "-assert definitions", because this passes the entire string as a single argument, which is not what the linker expects. When using the GNU linker, it is usually more convenient to pass arguments to linker options using the option=value syntax than as separate arguments. For example, you can specify -Xlinker -Map=[Link] rather than -Xlinker -Map -Xlinker [Link]. Other linkers may not support this syntax for command-line options. -Wl,option Pass option as an option to the linker. If option contains commas, it is split into multiple options at the commas. You can use this syntax to pass an argument to the option. For example, -Wl,-Map,[Link] passes -Map [Link] to the linker. When using the GNU linker, you can also get the same eect with -Wl,-Map=[Link]. -u symbol Pretend the symbol symbol is undened, to force linking of library modules to dene it. You can use -u multiple times with dierent symbols to force loading of additional library modules.

3.14 Options for Directory Search

These options specify directories to search for header les, for libraries and for parts of the compiler: -Idir Add the directory dir to the head of the list of directories to be searched for header les. This can be used to override a system header le, substituting your own version, since these directories are searched before the system header le directories. However, you should not use this option to add directories that contain vendor-supplied system header les (use -isystem for that). If you

164

Using the GNU Compiler Collection (GCC)

use more than one -I option, the directories are scanned in left-to-right order; the standard system directories come after. If a standard system include directory, or a directory specied with -isystem, is also specied with -I, the -I option is ignored. The directory is still searched but as a system directory at its normal position in the system include chain. This is to ensure that GCCs procedure to x buggy system headers and the ordering for the include_next directive are not inadvertently changed. If you really need to change the search order for system directories, use the -nostdinc and/or -isystem options. -iplugindir=dir Set the directory to search for plugins that are passed by -fplugin=name instead of -fplugin=path/[Link]. This option is not meant to be used by the user, but only passed by the driver. -iquotedir Add the directory dir to the head of the list of directories to be searched for header les only for the case of #include "file"; they are not searched for #include <file>, otherwise just like -I. -Ldir -Bprefix Add directory dir to the list of directories to be searched for -l. This option species where to nd the executables, libraries, include les, and data les of the compiler itself. The compiler driver program runs one or more of the subprograms cpp, cc1, as and ld. It tries prex as a prex for each program it tries to run, both with and without machine/version/ (see Section 3.16 [Target Options], page 173). For each subprogram to be run, the compiler driver rst tries the -B prex, if any. If that name is not found, or if -B is not specied, the driver tries two standard prexes, /usr/lib/gcc/ and /usr/local/lib/gcc/. If neither of those results in a le name that is found, the unmodied program name is searched for using the directories specied in your PATH environment variable. The compiler checks to see if the path provided by the -B refers to a directory, and if necessary it adds a directory separator character at the end of the path. -B prexes that eectively specify directory names also apply to libraries in the linker, because the compiler translates these options into -L options for the linker. They also apply to includes les in the preprocessor, because the compiler translates these options into -isystem options for the preprocessor. In this case, the compiler appends include to the prex. The runtime support le libgcc.a can also be searched for using the -B prex, if needed. If it is not found there, the two standard prexes above are tried, and that is all. The le is left out of the link if it is not found by those means. Another way to specify a prex much like the -B prex is to use the environment variable GCC_EXEC_PREFIX. See Section 3.19 [Environment Variables], page 309.

Chapter 3: GCC Command Options

165

As a special kludge, if the path provided by -B is [dir/]stageN/, where N is a number in the range 0 to 9, then it is replaced by [dir/]include. This is to help with boot-strapping the compiler. -specs=file Process le after the compiler reads in the standard specs le, 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 specied on the command line, and they are processed in order, from left to right. --sysroot=dir Use dir as the logical root directory for headers and libraries. For example, if the compiler normally searches for headers in /usr/include and libraries in /usr/lib, it instead searches dir/usr/include and dir/usr/lib. If you use both this option and the -isysroot option, then the --sysroot option applies to libraries, but the -isysroot option applies to header les. The GNU linker (beginning with version 2.16) has the necessary support for this option. If your linker does not support this option, the header le aspect of --sysroot still works, but the library aspect does not. --no-sysroot-suffix For some targets, a sux is added to the root directory specied with --sysroot, depending on the other options used, so that headers may for example be found in dir/suffix/usr/include instead of dir/usr/include. This option disables the addition of such a sux. -IThis option has been deprecated. Please use -iquote instead for -I directories before the -I- and remove the -I-. Any directories you specify with -I options before the -I- option are searched only for the case of #include "file"; they are not searched for #include <file>. If additional directories are specied with -I options after the -I-, these directories are searched for all #include directives. (Ordinarily all -I directories are used this way.) In addition, the -I- option inhibits the use of the current directory (where the current input le came from) as the rst search directory for #include "file". There is no way to override this eect of -I-. With -I. you can specify searching the directory that is current when the compiler is invoked. That is not exactly the same as what the preprocessor does by default, but it is often satisfactory. -I- does not inhibit the use of the standard system directories for header les. Thus, -I- and -nostdinc are independent.

3.15 Specifying subprocesses and the switches to pass to them

gcc is a driver program. It performs its job by invoking a sequence of other programs to do the work of compiling, assembling and linking. GCC interprets its command-line parameters

166

Using the GNU Compiler Collection (GCC)

and uses these to deduce which programs it should invoke, and which command-line options it ought to place on their command lines. This behavior is controlled by spec strings. In most cases there is one spec string for each program that GCC can invoke, but a few programs have multiple spec strings to control their behavior. The spec strings built into GCC can be overridden by using the -specs= command-line switch to specify a spec le. Spec les are plaintext les that are used to construct spec strings. They consist of a sequence of directives separated by blank lines. The type of directive is determined by the rst non-whitespace character on the line, which can be one of the following: %command Issues a command to the spec le processor. The commands that can appear here are: %include <file> Search for le and insert its text at the current point in the specs le. %include_noerr <file> Just like %include, but do not generate an error message if the include le cannot be found. %rename old_name new_name Rename the spec string old name to new name. *[spec_name]: This tells the compiler to create, override or delete the named spec string. All lines after this directive up to the next directive or blank line are considered to be the text for the spec string. If this results in an empty string then the spec is deleted. (Or, if the spec did not exist, then nothing happens.) Otherwise, if the spec does not currently exist a new spec is created. If the spec does exist then its contents are overridden by the text of this directive, unless the rst character of that text is the + character, in which case the text is appended to the spec. [suffix]: Creates a new [suffix] spec pair. All lines after this directive and up to the next directive or blank line are considered to make up the spec string for the indicated sux. When the compiler encounters an input le with the named sux, it processes the spec string in order to work out how to compile that le. For example:
.ZZ: z-compile -input %i

This says that any input le whose name ends in .ZZ should be passed to the program z-compile, which should be invoked with the command-line switch -input and with the result of performing the %i substitution. (See below.) As an alternative to providing a spec string, the text following a sux directive can be one of the following: @language This says that the sux is an alias for a known language. This is similar to using the -x command-line switch to GCC to specify a language explicitly. For example:

Chapter 3: GCC Command Options

167

.ZZ: @c++

Says that .ZZ les are, in fact, C++ source les. #name This causes an error messages saying:
name compiler not installed on this system.

GCC already has an extensive list of suxes built into it. This directive adds an entry to the end of the list of suxes, but since the list is searched from the end backwards, it is eectively possible to override earlier entries using this technique. GCC has the following spec strings built into it. Spec les can override these strings or create their own. Note that individual targets can also add their own spec strings to this list.
asm asm_final cpp cc1 cc1plus endfile link lib libgcc linker predefines signed_char startfile %rename lib Options to pass to the assembler Options to pass to the assembler post-processor Options to pass to the C preprocessor Options to pass to the C compiler Options to pass to the C++ compiler Object files to include at the end of the link Options to pass to the linker Libraries to include on the command line to the linker Decides which GCC support library to pass to the linker Sets the name of the linker Defines to be passed to the C preprocessor Defines to pass to CPP to say whether char is signed by default Object files to include at the start of the link old_lib

Here is a small example of a spec le:

*lib: --start-group -lgcc -lc -leval1 --end-group %(old_lib)

This example renames the spec called lib to old_lib and then overrides the previous denition of lib with a new one. The new denition adds in some extra command-line options before including the text of the old denition. Spec strings are a list of command-line options to be passed to their corresponding program. In addition, the spec strings can contain %-prexed sequences to substitute variable text or to conditionally insert text into the command line. Using these constructs it is possible to generate quite complex command lines. Here is a table of all dened %-sequences for spec strings. Note that spaces are not generated automatically around the results of expanding these sequences. Therefore you can concatenate them together or combine them with constant text in a single argument. %% %i %b %B Substitute one % into the program name or argument. Substitute the name of the input le being processed. Substitute the basename of the input le being processed. This is the substring up to (and not including) the last period and not including the directory. This is the same as %b, but include the le sux (text after the last period).

168

Using the GNU Compiler Collection (GCC)

%d

Marks the argument containing or following the %d as a temporary le name, so that that le is deleted if GCC exits successfully. Unlike %g, this contributes no text to the argument. Substitute a le name that has sux sux and is chosen once per compilation, and mark the argument in the same way as %d. To reduce exposure to denialof-service attacks, the le name is now chosen in a way that is hard to predict even when previously chosen le names are known. For example, %g.s ... %g.o ... %g.s might turn into ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s. sux matches the regexp [.A-Za-z]* or the special string %O, which is treated exactly as if %O had been preprocessed. Previously, %g was simply substituted with a le name chosen once per compilation, without regard to any appended sux (which was therefore treated just like ordinary text), making such attacks more likely to succeed. Like %g, but generates a new temporary le name each time it appears instead of once per compilation. Substitutes the last le name generated with %usuffix, generating a new one if there is no such last le name. In the absence of any %usuffix, this is just like %gsuffix, except they dont share the same sux space, so %g.s ... %U.s ... %g.s ... %U.s involves the generation of two distinct le names, one for each %g.s and another for each %U.s. Previously, %U was simply substituted with a le name chosen for the previous %u, without regard to any appended sux. Substitutes the name of the HOST_BIT_BUCKET, if any, and if it is writable, and if -save-temps is not used; otherwise, substitute the name of a temporary le, just like %u. This temporary le is not meant for communication between processes, but rather as a junk disposal mechanism. Like %g, except if -pipe is in eect. In that case %| substitutes a single dash and %m substitutes nothing at all. These are the two most common ways to instruct a program that it should read from standard input or write to standard output. If you need something more elaborate you can use an %{pipe:X} construct: see for example f/lang-specs.h. Substitutes .SUFFIX for the suxes of a matched switchs args when it is subsequently output with %*. SUFFIX is terminated by the next space or %. Marks the argument containing or following the %w as the designated output le of this compilation. This puts the argument into the sequence of arguments that %o substitutes. Substitutes the names of all the output les, with spaces automatically placed around them. You should write spaces around the %o as well or the results are undened. %o is for use in the specs for running the linker. Input les whose names have no recognized sux are not compiled at all, but they are included among the output les, so they are linked. Substitutes the sux for object les. Note that this is handled specially when it immediately follows %g, %u, or %U, because of the need for those to form

%gsuffix

%usuffix %Usuffix

%jsuffix

%|suffix %msuffix

%.SUFFIX %w

%o

%O

Chapter 3: GCC Command Options

169

complete le names. The handling is such that %O is treated exactly as if it had already been substituted, except that %g, %u, and %U do not currently support additional sux characters following %O as they do following, for example, .o. %p %P Substitutes the standard macro predenitions for the current target machine. Use this when running cpp. Like %p, but puts __ before and after the name of each predened macro, except for macros that start with __ or with _L, where L is an uppercase letter. This is for ISO C. Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot (made from TARGET_SYSTEM_ROOT), -isystem (made from COMPILER_PATH and -B options) and -imultilib as necessary. Current argument is the name of a library or startup le of some sort. Search for that le in a standard list of directories and substitute the full name found. The current working directory is included in the list of directories scanned. Current argument is the name of a linker script. Search for that le in the current list of directories to scan for libraries. If the le is located insert a --script option into the command line followed by the full path name found. If the le is not found then generate an error message. Note: the current working directory is not searched. Print str as an error message. str is terminated by a newline. Use this when inconsistent options are detected. Substitute the contents of spec string name at this point. Accumulate an option for %X. %X %Y %Z %a %A %l %D Output the accumulated linker options specied by -Wl or a %x spec string. Output the accumulated assembler options specied by -Wa. Output the accumulated preprocessor options specied by -Wp. Process the asm spec. This is used to compute the switches to be passed to the assembler. Process the asm_final spec. This is a spec string for passing switches to an assembler post-processor, if such a program is needed. Process the link spec. This is the spec for computing the command line passed to the linker. Typically it makes use of the %L %G %S %D and %E sequences. Dump out a -L option for each directory that GCC believes might contain startup les. If the target supports multilibs then the current multilib directory is prepended to each of these paths. Process the lib spec. This is a spec string for deciding which libraries are included on the command line to the linker.

%I

%s

%T

%estr %(name) %x{option}

%L

170

Using the GNU Compiler Collection (GCC)

%G %S %E %C %1 %2 %* %<S

Process the libgcc spec. This is a spec string for deciding which GCC support library is included on the command line to the linker. Process the startfile spec. This is a spec for deciding which object les are the rst ones passed to the linker. Typically this might be a le named crt0.o. Process the endfile spec. This is a spec string that species the last object les that are passed to the linker. Process the cpp spec. This is used to construct the arguments to be passed to the C preprocessor. Process the cc1 spec. This is used to construct the options to be passed to the actual C compiler (cc1). Process the cc1plus spec. This is used to construct the options to be passed to the actual C++ compiler (cc1plus). Substitute the variable part of a matched option. See below. Note that each comma in the substituted string is replaced by a single space. Remove all occurrences of -S from the command line. Notethis command is position dependent. % commands in the spec string before this one see -S, % commands in the spec string after this one do not.

%:function(args) Call the named function function, passing it args. args is rst processed as a nested spec string, then split into an argument vector in the usual fashion. The function returns a string which is processed as if it had appeared literally as part of the current spec. The following built-in spec functions are provided: getenv The getenv spec function takes two arguments: an environment variable name and a string. If the environment variable is not dened, a fatal error is issued. Otherwise, the return value is the value of the environment variable concatenated with the string. For example, if TOPDIR is dened as /path/to/top, then:
%:getenv(TOPDIR /include)

expands to /path/to/top/include. if-exists The if-exists spec function takes one argument, an absolute pathname to a le. If the le exists, if-exists returns the pathname. Here is a small example of its usage:
*startfile: crt0%O%s %:if-exists(crti%O%s) crtbegin%O%s

if-exists-else The if-exists-else spec function is similar to the if-exists spec function, except that it takes two arguments. The rst argument is an absolute pathname to a le. If the le exists, if-exists-else returns the pathname. If it does not exist, it returns the second argument. This way, if-exists-else can be used to select one

Chapter 3: GCC Command Options

171

le or another, based on the existence of the rst. Here is a small example of its usage:
*startfile: crt0%O%s %:if-exists(crti%O%s) \ %:if-exists-else(crtbeginT%O%s crtbegin%O%s)

replace-outfile The replace-outfile spec function takes two arguments. It looks for the rst argument in the outles array and replaces it with the second argument. Here is a small example of its usage:
%{fgnu-runtime:%:replace-outfile(-lobjc -lobjc-gnu)}

remove-outfile The remove-outfile spec function takes one argument. It looks for the rst argument in the outles array and removes it. Here is a small example its usage:
%:remove-outfile(-lm)

pass-through-libs The pass-through-libs spec function takes any number of arguments. It nds any -l options and any non-options ending in .a (which it assumes are the names of linker input library archive les) and returns a result containing all the found arguments each prepended by -plugin-opt=-pass-through= and joined by spaces. This list is intended to be passed to the LTO linker plugin.
%:pass-through-libs(%G %L %G)

print-asm-header The print-asm-header function takes no arguments and simply prints a banner like:
Assembler options ================= Use "-Wa,OPTION" to pass "OPTION" to the assembler.

It is used to separate compiler options from assembler options in the --target-help output. %{S} Substitutes the -S switch, if that switch is given to GCC. If that switch is not specied, this substitutes nothing. Note that the leading dash is omitted when specifying this option, and it is automatically inserted if the substitution is performed. Thus the spec string %{foo} matches the command-line option -foo and outputs the command-line option -foo. Like %S} but mark last argument supplied within as a le to be deleted on failure. Substitutes all the switches specied to GCC whose names start with -S, but which also take an argument. This is used for switches like -o, -D, -I, etc. GCC considers -o foo as being one switch whose name starts with o. %o* substitutes this text, including the space. Thus two arguments are generated.

%W{S} %{S*}

172

Using the GNU Compiler Collection (GCC)

%{S*&T*}

Like %S*, but preserve order of S and T options (the order of S and T in the spec is not signicant). There can be any number of ampersand-separated variables; for each the wild card is optional. Useful for CPP as %{D*&U*&A*}. Substitutes X, if the -S switch is given to GCC. Substitutes X, if the -S switch is not given to GCC. Substitutes X if one or more switches whose names start with -S are specied to GCC. Normally X is substituted only once, no matter how many such switches appeared. However, if %* appears somewhere in X, then X is substituted once for each matching switch, with the %* replaced by the part of that switch matching the *. Substitutes X, if processing a le with sux S. Substitutes X, if not processing a le with sux S. Substitutes X, if processing a le for language S. Substitutes X, if not processing a le for language S. Substitutes X if either -S or -P is given to GCC. This may be combined with !, ., ,, and * sequences as well, although they have a stronger binding than the |. If %* appears in X, all of the alternatives must be starred, and only the rst matching alternative is substituted. For example, a spec string like this:
%{.c:-foo} %{!.c:-bar} %{.c|d:-baz} %{!.c|d:-boggle}

%{S:X} %{!S:X} %{S*:X}

%{.S:X} %{!.S:X} %{,S:X} %{!,S:X} %{S|P:X}

outputs the following command-line options from the following input commandline options:
fred.c jim.d -d fred.c -d jim.d -foo -bar -foo -bar -baz -boggle -baz -boggle -baz -boggle

%{S:X; T:Y; :D} If S is given to GCC, substitutes X; else if T is given to GCC, substitutes Y; else substitutes D. There can be as many clauses as you need. This may be combined with ., ,, !, |, and * as needed. The conditional text X in a %S:X} or similar construct may contain other nested % constructs or spaces, or even newlines. They are processed as usual, as described above. Trailing white space in X is ignored. White space may also appear anywhere on the left side of the colon in these constructs, except between . or * and the corresponding word. The -O, -f, -m, and -W switches are handled specically in these constructs. If another value of -O or the negated form of a -f, -m, or -W switch is found later in the command line, the earlier switch value is ignored, except with S* where S is just one letter, which passes all matching options. The character | at the beginning of the predicate text is used to indicate that a command should be piped to the following command, but only if -pipe is specied. It is built into GCC which switches take arguments and which do not. (You might think it would be useful to generalize this to allow each compilers spec to say which switches

Chapter 3: GCC Command Options

173

take arguments. But this cannot be done in a consistent fashion. GCC cannot even decide which input les have been specied without knowing which switches take arguments, and it must know which input les to compile in order to tell which compilers to run). GCC also knows implicitly that arguments starting in -l are to be treated as compiler output les, and passed to the linker in their proper position among the other output les.

3.16 Specifying Target Machine and Compiler Version

The usual way to run GCC is to run the executable called gcc, or machine-gcc when crosscompiling, or machine-gcc-version to run a version other than the one that was installed last.

3.17 Hardware Models and Congurations

Each target machine types can have its own special options, starting with -m, to choose among various hardware models or congurationsfor example, 68010 vs 68020, oating coprocessor or none. A single installed version of the compiler can compile for any model or conguration, according to the options specied. Some congurations of the compiler also support additional special options, usually for compatibility with other compilers on the same platform.

3.17.1 AArch64 Options

These options are dened for AArch64 implementations: -mbig-endian Generate big-endian code. This is the default when GCC is congured for an aarch64_be-*-* target. -mgeneral-regs-only Generate code which uses only the general registers. -mlittle-endian Generate little-endian code. This is the default when GCC is congured for an aarch64-*-* but not an aarch64_be-*-* target. -mcmodel=tiny Generate code for the tiny code model. The program and its statically dened symbols must be within 1GB of each other. Pointers are 64 bits. Programs can be statically or dynamically linked. This model is not fully implemented and mostly treated as small. -mcmodel=small Generate code for the small code model. The program and its statically dened symbols must be within 4GB of each other. Pointers are 64 bits. Programs can be statically or dynamically linked. This is the default code model. -mcmodel=large Generate code for the large code model. This makes no assumptions about addresses and sizes of sections. Pointers are 64 bits. Programs can be statically linked only.

174

Using the GNU Compiler Collection (GCC)

-mstrict-align Do not assume that unaligned memory references will be handled by the system. -momit-leaf-frame-pointer -mno-omit-leaf-frame-pointer Omit or keep the frame pointer in leaf functions. The former behaviour is the default. -mtls-dialect=desc Use TLS descriptors as the thread-local storage mechanism for dynamic accesses of TLS variables. This is the default. -mtls-dialect=traditional Use traditional TLS as the thread-local storage mechanism for dynamic accesses of TLS variables. -march=name Specify the name of the target architecture, optionally suxed by one or more feature modiers. This option has the form -march=arch{ +[no]feature} *, where the only value for arch is armv8-a. The possible values for feature are documented in the sub-section below. Where conicting feature modiers are specied, the right-most feature is used. GCC uses this name to determine what kind of instructions it can emit when generating assembly code. This option can be used in conjunction with or instead of the -mcpu= option. -mcpu=name Specify the name of the target processor, optionally suxed by one or more feature modiers. This option has the form -mcpu=cpu{ +[no]feature} *, where the possible values for cpu are generic, large. The possible values for feature are documented in the sub-section below. Where conicting feature modiers are specied, the right-most feature is used. GCC uses this name to determine what kind of instructions it can emit when generating assembly code. -mtune=name Specify the name of the processor to tune the performance for. The code will be tuned as if the target processor were of the type specied in this option, but still using instructions compatible with the target processor specied by a -mcpu= option. This option cannot be suxed by feature modiers.

[Link] -march and -mcpu feature modiers

Feature modiers used with -march and -mcpu can be one the following: crypto fp simd Enable Crypto extension. This implies Advanced SIMD is enabled. Enable oating-point instructions. Enable Advanced SIMD instructions. This implies oating-point instructions are enabled. This is the default for all current possible values for options -march and -mcpu=.

Chapter 3: GCC Command Options

175

3.17.2 Adapteva Epiphany Options

These -m options are dened for Adapteva Epiphany: -mhalf-reg-file Dont allocate any register in the range r32 . . . r63. That allows code to run on hardware variants that lack these registers. -mprefer-short-insn-regs Preferrentially allocate registers that allow short instruction generation. This can result in increased instruction count, so this may either reduce or increase overall code size. -mbranch-cost=num Set the cost of branches to roughly num simple instructions. This cost is only a heuristic and is not guaranteed to produce consistent results across releases. -mcmove -mnops=num Emit num NOPs before every other generated instruction. -mno-soft-cmpsf For single-precision oating-point comparisons, emit an fsub instruction and test the ags. This is faster than a software comparison, but can get incorrect results in the presence of NaNs, or when two dierent small numbers are compared such that their dierence is calculated as zero. The default is -msoft-cmpsf, which uses slower, but IEEE-compliant, software comparisons. -mstack-offset=num Set the oset between the top of the stack and the stack pointer. E.g., a value of 8 means that the eight bytes in the range sp+0...sp+7 can be used by leaf functions without stack allocation. Values other than 8 or 16 are untested and unlikely to work. Note also that this option changes the ABI; compiling a program with a dierent stack oset than the libraries have been compiled with generally does not work. This option can be useful if you want to evaluate if a dierent stack oset would give you better code, but to actually use a dierent stack oset to build working programs, it is recommended to congure the toolchain with the appropriate --with-stack-offset=num option. -mno-round-nearest Make the scheduler assume that the rounding mode has been set to truncating. The default is -mround-nearest. -mlong-calls If not otherwise specied by an attribute, assume all calls might be beyond the oset range of the b / bl instructions, and therefore load the function address into a register before performing a (otherwise direct) call. This is the default. -mshort-calls If not otherwise specied by an attribute, assume all direct calls are in the range of the b / bl instructions, so use these instructions for direct calls. The default is -mlong-calls. Enable the generation of conditional moves.

176

Using the GNU Compiler Collection (GCC)

-msmall16 Assume addresses can be loaded as 16-bit unsigned values. This does not apply to function addresses for which -mlong-calls semantics are in eect. -mfp-mode=mode Set the prevailing mode of the oating-point unit. This determines the oatingpoint mode that is provided and expected at function call and return time. Making this mode match the mode you predominantly need at function start can make your programs smaller and faster by avoiding unnecessary mode switches. mode can be set to one the following values: caller Any mode at function entry is valid, and retained or restored when the function returns, and when it calls other functions. This mode is useful for compiling libraries or other compilation units you might want to incorporate into dierent programs with dierent prevailing FPU modes, and the convenience of being able to use a single object le outweighs the size and speed overhead for any extra mode switching that might be needed, compared with what would be needed with a more specic choice of prevailing FPU mode. This is the mode used for oating-point calculations with truncating (i.e. round towards zero) rounding mode. That includes conversion from oating point to integer. round-nearest This is the mode used for oating-point calculations with roundto-nearest-or-even rounding mode. int This is the mode used to perform integer calculations in the FPU, e.g. integer multiply, or integer multiply-and-accumulate.

truncate

The default is -mfp-mode=caller -mnosplit-lohi -mno-postinc -mno-postmodify Code generation tweaks that disable, respectively, splitting of 32-bit loads, generation of post-increment addresses, and generation of post-modify addresses. The defaults are msplit-lohi, -mpost-inc, and -mpost-modify. -mnovect-double Change the preferred SIMD mode to SImode. The default is -mvect-double, which uses DImode as preferred SIMD mode. -max-vect-align=num The maximum alignment for SIMD vector mode types. num may be 4 or 8. The default is 8. Note that this is an ABI change, even though many library function interfaces are unaected if they dont use SIMD vector modes in places that aect size and/or alignment of relevant types.

Chapter 3: GCC Command Options

177

-msplit-vecmove-early Split vector moves into single word moves before reload. In theory this can give better register allocation, but so far the reverse seems to be generally the case. -m1reg-reg Specify a register to hold the constant 1, which makes loading small negative constants and certain bitmasks faster. Allowable values for reg are r43 and r63, which specify use of that register as a xed register, and none, which means that no register is used for this purpose. The default is -m1reg-none.

3.17.3 ARM Options

These -m options are dened for Advanced RISC Machines (ARM) architectures: -mabi=name Generate code for the specied ABI. Permissible values are: apcs-gnu, atpcs, aapcs, aapcs-linux and iwmmxt. -mapcs-frame Generate a stack frame that is compliant with the ARM Procedure Call Standard for all functions, even if this is not strictly necessary for correct execution of the code. Specifying -fomit-frame-pointer with this option causes the stack frames not to be generated for leaf functions. The default is -mno-apcs-frame. -mapcs This is a synonym for -mapcs-frame.

-mthumb-interwork Generate code that supports calling between the ARM and Thumb instruction sets. Without this option, on pre-v5 architectures, the two instruction sets cannot be reliably used inside one program. The default is -mno-thumb-interwork, since slightly larger code is generated when -mthumb-interwork is specied. In AAPCS congurations this option is meaningless. -mno-sched-prolog Prevent the reordering of instructions in the function prologue, or the merging of those instruction with the instructions in the functions body. This means that all functions start with a recognizable set of instructions (or in fact one of a choice from a small set of dierent function prologues), and this information can be used to locate the start of functions inside an executable piece of code. The default is -msched-prolog. -mfloat-abi=name Species which oating-point ABI to use. softfp and hard. Permissible values are: soft,

Specifying soft causes GCC to generate output containing library calls for oating-point operations. softfp allows the generation of code using hardware oating-point instructions, but still uses the soft-oat calling conventions. hard allows generation of oating-point instructions and uses FPU-specic calling conventions.

178

Using the GNU Compiler Collection (GCC)

The default depends on the specic target conguration. Note that the hardoat and soft-oat ABIs are not link-compatible; you must compile your entire program with the same ABI, and link with a compatible set of libraries. -mlittle-endian Generate code for a processor running in little-endian mode. This is the default for all standard congurations. -mbig-endian Generate code for a processor running in big-endian mode; the default is to compile code for a little-endian processor. -mwords-little-endian This option only applies when generating code for big-endian processors. Generate code for a little-endian word order but a big-endian byte order. That is, a byte order of the form 32107654. Note: this option should only be used if you require compatibility with code for big-endian ARM processors generated by versions of the compiler prior to 2.8. This option is now deprecated. -mcpu=name This species the name of the target ARM processor. GCC uses this name to determine what kind of instructions it can emit when generating assembly code. Permissible names are: arm2, arm250, arm3, arm6, arm60, arm600, arm610, arm620, arm7, arm7m, arm7d, arm7dm, arm7di, arm7dmi, arm70, arm700, arm700i, arm710, arm710c, arm7100, arm720, arm7500, arm7500fe, arm7tdmi, arm7tdmi-s, arm710t, arm720t, arm740t, strongarm, strongarm110, strongarm1100, strongarm1110, arm8, arm810, arm9, arm9e, arm920, arm920t, arm922t, arm946e-s, arm966e-s, arm968e-s, arm926ej-s, arm940t, arm9tdmi, arm10tdmi, arm1020t, arm1026ej-s, arm10e, arm1020e, arm1022e, arm1136j-s, arm1136jf-s, mpcore, mpcorenovfp, arm1156t2-s, arm1156t2f-s, arm1176jz-s, arm1176jzf-s, cortex-a5, cortex-a7, cortex-a8, cortex-a9, cortex-a15, cortex-r4, cortex-r4f, cortex-r5, cortex-m4, cortex-m3, cortex-m1, cortex-m0, cortex-m0plus, marvell-pj4, xscale, iwmmxt, iwmmxt2, ep9312, fa526, fa626, fa606te, fa626te, fmp626, fa726te. -mcpu=generic-arch is also permissible, and is equivalent to -march=arch -mtune=generic-arch. See -mtune for more information. -mcpu=native causes the compiler to auto-detect the CPU of the build computer. At present, this feature is only supported on Linux, and not all architectures are recognized. If the auto-detect is unsuccessful the option has no eect. -mtune=name This option is very similar to the -mcpu= option, except that instead of specifying the actual target processor type, and hence restricting which instructions can be used, it species that GCC should tune the performance of the code as if the target were of the type specied in this option, but still choosing the instructions it generates based on the CPU specied by a -mcpu= option. For

Chapter 3: GCC Command Options

179

some ARM implementations better performance can be obtained by using this option. -mtune=generic-arch species that GCC should tune the performance for a blend of processors within architecture arch. The aim is to generate code that run well on the current most popular processors, balancing between optimizations that benet some CPUs in the range, and avoiding performance pitfalls of other CPUs. The eects of this option may change in future GCC versions as CPU models come and go. -mtune=native causes the compiler to auto-detect the CPU of the build computer. At present, this feature is only supported on Linux, and not all architectures are recognized. If the auto-detect is unsuccessful the option has no eect. -march=name This species the name of the target ARM architecture. GCC uses this name to determine what kind of instructions it can emit when generating assembly code. This option can be used in conjunction with or instead of the -mcpu= option. Permissible names are: armv2, armv2a, armv3, armv3m, armv4, armv4t, armv5, armv5t, armv5e, armv5te, armv6, armv6j, armv6t2, armv6z, armv6zk, armv6-m, armv7, armv7-a, armv7-r, armv7-m, armv8-a, iwmmxt, iwmmxt2, ep9312. -march=native causes the compiler to auto-detect the architecture of the build computer. At present, this feature is only supported on Linux, and not all architectures are recognized. If the auto-detect is unsuccessful the option has no eect. -mfpu=name This species what oating-point hardware (or hardware emulation) is available on the target. Permissible names are: vfp, vfpv3, vfpv3-fp16, vfpv3-d16, vfpv3-d16-fp16, vfpv3xd, vfpv3xd-fp16, neon, neon-fp16, vfpv4, vfpv4-d16, fpv4-sp-d16, neon-vfpv4, fp-armv8, neon-fp-armv8, and crypto-neon-fp-armv8. If -msoft-float is specied this species the format of oating-point values. If the selected oating-point hardware includes the NEON extension (e.g. -mfpu=neon), note that oating-point operations are not generated by GCCs auto-vectorization pass unless -funsafe-math-optimizations is also specied. This is because NEON hardware does not fully implement the IEEE 754 standard for oating-point arithmetic (in particular denormal values are treated as zero), so the use of NEON instructions may lead to a loss of precision. -mfp16-format=name Specify the format of the __fp16 half-precision oating-point type. Permissible names are none, ieee, and alternative; the default is none, in which case the __fp16 type is not dened. See Section 6.12 [Half-Precision], page 335, for more information.

180

Using the GNU Compiler Collection (GCC)

-mstructure-size-boundary=n The sizes of all structures and unions are rounded up to a multiple of the number of bits set by this option. Permissible values are 8, 32 and 64. The default value varies for dierent toolchains. For the COFF targeted toolchain the default value is 8. A value of 64 is only allowed if the underlying ABI supports it. Specifying a larger number can produce faster, more ecient code, but can also increase the size of the program. Dierent values are potentially incompatible. Code compiled with one value cannot necessarily expect to work with code or libraries compiled with another value, if they exchange information using structures or unions. -mabort-on-noreturn Generate a call to the function abort at the end of a noreturn function. It is executed if the function tries to return. -mlong-calls -mno-long-calls Tells the compiler to perform function calls by rst loading the address of the function into a register and then performing a subroutine call on this register. This switch is needed if the target function lies outside of the 64-megabyte addressing range of the oset-based version of subroutine call instruction. Even if this switch is enabled, not all function calls are turned into long calls. The heuristic is that static functions, functions that have the short-call attribute, functions that are inside the scope of a #pragma no_long_calls directive, and functions whose denitions have already been compiled within the current compilation unit are not turned into long calls. The exceptions to this rule are that weak function denitions, functions with the long-call attribute or the section attribute, and functions that are within the scope of a #pragma long_calls directive are always turned into long calls. This feature is not enabled by default. Specifying -mno-long-calls restores the default behavior, as does placing the function calls within the scope of a #pragma long_calls_off directive. Note these switches have no eect on how the compiler generates code to handle function calls via function pointers. -msingle-pic-base Treat the register used for PIC addressing as read-only, rather than loading it in the prologue for each function. The runtime system is responsible for initializing this register with an appropriate value before execution begins. -mpic-register=reg Specify the register to be used for PIC addressing. The default is R10 unless stack-checking is enabled, when R9 is used. -mpoke-function-name Write the name of each function into the text section, directly preceding the function prologue. The generated code is similar to this:
t0 .ascii "arm_poke_function_name", 0

Chapter 3: GCC Command Options

181

.align t1 .word 0xff000000 + (t1 - t0) arm_poke_function_name mov ip, sp stmfd sp!, {fp, ip, lr, pc} sub fp, ip, #4

When performing a stack backtrace, code can inspect the value of pc stored at fp + 0. If the trace function then looks at location pc - 12 and the top 8 bits are set, then we know that there is a function name embedded immediately preceding this location and has length ((pc[-3]) & 0xff000000). -mthumb -marm Select between generating code that executes in ARM and Thumb states. The default for most congurations is to generate code that executes in ARM state, but the default can be changed by conguring GCC with the --with-mode=state congure option. -mtpcs-frame Generate a stack frame that is compliant with the Thumb Procedure Call Standard for all non-leaf functions. (A leaf function is one that does not call any other functions.) The default is -mno-tpcs-frame. -mtpcs-leaf-frame Generate a stack frame that is compliant with the Thumb Procedure Call Standard for all leaf functions. (A leaf function is one that does not call any other functions.) The default is -mno-apcs-leaf-frame. -mcallee-super-interworking Gives all externally visible functions in the le being compiled an ARM instruction set header which switches to Thumb mode before executing the rest of the function. This allows these functions to be called from non-interworking code. This option is not valid in AAPCS congurations because interworking is enabled by default. -mcaller-super-interworking Allows calls via function pointers (including virtual functions) to execute correctly regardless of whether the target code has been compiled for interworking or not. There is a small overhead in the cost of executing a function pointer if this option is enabled. This option is not valid in AAPCS congurations because interworking is enabled by default. -mtp=name Specify the access model for the thread local storage pointer. The valid models are soft, which generates calls to __aeabi_read_tp, cp15, which fetches the thread pointer from cp15 directly (supported in the arm6k architecture), and auto, which uses the best available method for the selected processor. The default setting is auto.

182

Using the GNU Compiler Collection (GCC)

-mtls-dialect=dialect Specify the dialect to use for accessing thread local storage. Two dialects are supportedgnu and gnu2. The gnu dialect selects the original GNU scheme for supporting local and global dynamic TLS models. The gnu2 dialect selects the GNU descriptor scheme, which provides better performance for shared libraries. The GNU descriptor scheme is compatible with the original scheme, but does require new assembler, linker and library support. Initial and local exec TLS models are unaected by this option and always use the original scheme. -mword-relocations Only generate absolute relocations on word-sized values (i.e. R ARM ABS32). This is enabled by default on targets (uClinux, SymbianOS) where the runtime loader imposes this restriction, and when -fpic or -fPIC is specied. -mfix-cortex-m3-ldrd Some Cortex-M3 cores can cause data corruption when ldrd instructions with overlapping destination and base registers are used. This option avoids generating these instructions. This option is enabled by default when -mcpu=cortex-m3 is specied. -munaligned-access -mno-unaligned-access Enables (or disables) reading and writing of 16- and 32- bit values from addresses that are not 16- or 32- bit aligned. By default unaligned access is disabled for all pre-ARMv6 and all ARMv6-M architectures, and enabled for all other architectures. If unaligned access is not enabled then words in packed data structures will be accessed a byte at a time. The ARM attribute Tag_CPU_unaligned_access will be set in the generated object le to either true or false, depending upon the setting of this option. If unaligned access is enabled then the preprocessor symbol __ARM_FEATURE_ UNALIGNED will also be dened.

3.17.4 AVR Options

These options are dened for AVR implementations: -mmcu=mcu Specify Atmel AVR instruction set architectures (ISA) or MCU type. The default for this option is avr2. GCC supports the following AVR devices and ISAs: avr2 Classic devices with up to 8 KiB of program memory. mcu = attiny22, attiny26, at90c8534, at90s2313, at90s2323, at90s2333, at90s2343, at90s4414, at90s4433, at90s4434, at90s8515, at90s8535. Classic devices with up to 8 KiB of program memory and with the MOVW instruction. mcu = ata5272, ata6289, attiny13, attiny13a, attiny2313,

avr25

Chapter 3: GCC Command Options

183

attiny2313a, attiny24, attiny24a, attiny25, attiny261, attiny261a, attiny43u, attiny4313, attiny44, attiny44a, attiny45, attiny461, attiny461a, attiny48, attiny84, attiny84a, attiny85, attiny861, attiny861a, attiny87, attiny88, at86rf401. avr3 avr31 avr35 Classic devices with 16 KiB up to 64 KiB of program memory. mcu = at43usb355, at76c711. Classic devices with 128 KiB of program memory. mcu = atmega103, at43usb320. Classic devices with 16 KiB up to 64 KiB of program memory and with the MOVW instruction. mcu = ata5505, atmega16u2, atmega32u2, atmega8u2, attiny1634, attiny167, at90usb162, at90usb82. Enhanced devices with up to 8 KiB of program memory. mcu = ata6285, ata6286, atmega48, atmega48a, atmega48p, atmega48pa, atmega8, atmega8a, atmega8hva, atmega8515, atmega8535, atmega88, atmega88a, atmega88p, atmega88pa, at90pwm1, at90pwm2, at90pwm2b, at90pwm3, at90pwm3b, at90pwm81. Enhanced devices with 16 KiB up to 64 KiB of program memory. mcu = ata5790, ata5790n, ata5795, atmega16, atmega16a, atmega16hva, atmega16hva2, atmega16hvb, atmega16hvbrevb, atmega16m1, atmega16u4, atmega161, atmega162, atmega163, atmega164a, atmega164p, atmega164pa, atmega165, atmega165a, atmega165p, atmega165pa, atmega168, atmega168a, atmega168p, atmega168pa, atmega169, atmega169a, atmega169p, atmega169pa, atmega26hvg, atmega32, atmega32a, atmega32c1, atmega32hvb, atmega32hvbrevb, atmega32m1, atmega32u4, atmega32u6, atmega323, atmega324a, atmega324p, atmega324pa, atmega325, atmega325a, atmega325p, atmega3250, atmega3250a, atmega3250p, atmega3250pa, atmega328, atmega328p, atmega329, atmega329a, atmega329p, atmega329pa, atmega3290, atmega3290a, atmega3290p, atmega3290pa, atmega406, atmega48hvf, atmega64, atmega64a, atmega64c1, atmega64hve, atmega64m1, atmega64rfa2, atmega64rfr2, atmega640, atmega644, atmega644a, atmega644p, atmega644pa, atmega645, atmega645a, atmega645p, atmega6450, atmega6450a, atmega6450p, atmega649, atmega649a, atmega649p, atmega6490, atmega6490a, atmega6490p, at90can32, at90can64, at90pwm161, at90pwm216, at90pwm316, at90scr100, at90usb646, at90usb647, at94k, m3000. Enhanced devices with 128 KiB of program memory. mcu = atmega128, atmega128a, atmega128rfa1, atmega1280,

avr4

avr5

avr51

184

Using the GNU Compiler Collection (GCC)

atmega1281, atmega1284, at90usb1286, at90usb1287. avr6

atmega1284p,

at90can128,

Enhanced devices with 3-byte PC, i.e. with more than 128 KiB of program memory. mcu = atmega2560, atmega2561. XMEGA devices with more than 8 KiB and up to 64 KiB of program memory. mcu = atmxt112sl, atmxt224, atmxt224e, atmxt336s, atxmega16a4, atxmega16a4u, atxmega16c4, atxmega16d4, atxmega16x1, atxmega32a4, atxmega32a4u, atxmega32c4, atxmega32d4, atxmega32e5, atxmega32x1.

avrxmega2

avrxmega4 XMEGA devices with more than 64 KiB and up to 128 KiB of program memory. mcu = atxmega64a3, atxmega64a3u, atxmega64a4u, atxmega64b1, atxmega64b3, atxmega64c3, atxmega64d3, atxmega64d4. avrxmega5 XMEGA devices with more than 64 KiB and up to 128 KiB of program memory and more than 64 KiB of RAM. mcu = atxmega64a1, atxmega64a1u. avrxmega6 XMEGA devices with more than 128 KiB of program memory. mcu = atmxt540s, atmxt540sreva, atxmega128a3, atxmega128a3u, atxmega128b1, atxmega128b3, atxmega128c3, atxmega128d3, atxmega128d4, atxmega192a3, atxmega192a3u, atxmega192c3, atxmega192d3, atxmega256a3, atxmega256a3b, atxmega256a3bu, atxmega256a3u, atxmega256c3, atxmega256d3, atxmega384c3, atxmega384d3. avrxmega7 XMEGA devices with more than 128 KiB of program memory and more than 64 KiB of RAM. mcu = atxmega128a1, atxmega128a1u, atxmega128a4u. avr1 This ISA is implemented by the minimal AVR core and supported for assembler only. mcu = attiny11, attiny12, attiny15, attiny28, at90s1200.

-maccumulate-args Accumulate outgoing function arguments and acquire/release the needed stack space for outgoing function arguments once in function prologue/epilogue. Without this option, outgoing arguments are pushed before calling a function and popped afterwards.

Chapter 3: GCC Command Options

185

Popping the arguments after the function call can be expensive on AVR so that accumulating the stack space might lead to smaller executables because arguments need not to be removed from the stack after such a function call. This option can lead to reduced code size for functions that perform several calls to functions that get their arguments on the stack like calls to printf-like functions. -mbranch-cost=cost Set the branch costs for conditional branch instructions to cost. Reasonable values for cost are small, non-negative integers. The default branch cost is 0. -mcall-prologues Functions prologues/epilogues are expanded as calls to appropriate subroutines. Code size is smaller. -mint8 Assume int to be 8-bit integer. This aects the sizes of all types: a char is 1 byte, an int is 1 byte, a long is 2 bytes, and long long is 4 bytes. Please note that this option does not conform to the C standards, but it results in smaller code size. Code size is

-mno-interrupts Generated code is not compatible with hardware interrupts. smaller. -mrelax

Try to replace CALL resp. JMP instruction by the shorter RCALL resp. RJMP instruction if applicable. Setting -mrelax just adds the --relax option to the linker command line when the linker is called. Jump relaxing is performed by the linker because jump osets are not known before code is located. Therefore, the assembler code generated by the compiler is the same, but the instructions in the executable may dier from instructions in the assembler code. Relaxing must be turned on if linker stubs are needed, see the section on EIND and linker stubs below. Treat the stack pointer register as an 8-bit register, i.e. assume the high byte of the stack pointer is zero. In general, you dont need to set this option by hand. This option is used internally by the compiler to select and build multilibs for architectures avr2 and avr25. These architectures mix devices with and without SPH. For any setting other than -mmcu=avr2 or -mmcu=avr25 the compiler driver will add or remove this option from the compiler propers command line, because the compiler then knows if the device or architecture has an 8-bit stack pointer and thus no SPH register or not. Use address register X in a way proposed by the hardware. This means that X is only used in indirect, post-increment or pre-decrement addressing. Without this option, the X register may be used in the same way as Y or Z which then is emulated by additional instructions. For example, loading a value with X+const addressing with a small non-negative const < 64 to a register Rn is performed as

-msp8

-mstrict-X

186

Using the GNU Compiler Collection (GCC)

adiw r26, const ld Rn, X sbiw r26, const

; X += const ; Rn = *X ; X -= const

-mtiny-stack Only change the lower 8 bits of the stack pointer. -Waddr-space-convert Warn about conversions between address spaces in the case where the resulting address space is not contained in the incoming address space.

[Link] EIND and Devices with more than 128 Ki Bytes of Flash
Pointers in the implementation are 16 bits wide. The address of a function or label is represented as word address so that indirect jumps and calls can target any code address in the range of 64 Ki words. In order to facilitate indirect jump on devices with more than 128 Ki bytes of program memory space, there is a special function register called EIND that serves as most signicant part of the target address when EICALL or EIJMP instructions are used. Indirect jumps and calls on these devices are handled as follows by the compiler and are subject to some limitations: The compiler never sets EIND. The compiler uses EIND implicitely in EICALL/EIJMP instructions or might read EIND directly in order to emulate an indirect call/jump by means of a RET instruction. The compiler assumes that EIND never changes during the startup code or during the application. In particular, EIND is not saved/restored in function or interrupt service routine prologue/epilogue. For indirect calls to functions and computed goto, the linker generates stubs. Stubs are jump pads sometimes also called trampolines. Thus, the indirect call/jump jumps to such a stub. The stub contains a direct jump to the desired address. Linker relaxation must be turned on so that the linker will generate the stubs correctly an all situaltion. See the compiler option -mrelax and the linler option --relax. There are corner cases where the linker is supposed to generate stubs but aborts without relaxation and without a helpful error message. The default linker script is arranged for code with EIND = 0. If code is supposed to work for a setup with EIND != 0, a custom linker script has to be used in order to place the sections whose name start with .trampolines into the segment where EIND points to. The startup code from libgcc never sets EIND. Notice that startup code is a blend of code from libgcc and AVR-LibC. For the impact of AVR-LibC on EIND, see the AVR-LibC user manual. It is legitimate for user-specic startup code to set up EIND early, for example by means of initialization code located in section .init3. Such code runs prior to general startup code that initializes RAM and calls constructors, but after the bit of startup code from AVR-LibC that sets EIND to the segment where the vector table is located. #include <avr/io.h>

Chapter 3: GCC Command Options

187

static void __attribute__((section(".init3"),naked,used,no_instrument_function)) init3_set_eind (void) { __asm volatile ("ldi r24,pm_hh8(__trampolines_start)\n\t" "out %i0,r24" :: "n" (&EIND) : "r24","memory"); } The __trampolines_start symbol is dened in the linker script. Stubs are generated automatically by the linker if the following two conditions are met: The address of a label is taken by means of the gs modier (short for generate stubs ) like so: LDI r24, lo8(gs(func)) LDI r25, hi8(gs(func)) The nal location of that label is in a code segment outside the segment where the stubs are located. The compiler emits such gs modiers for code labels in the following situations: Taking address of a function or code label. Computed goto. If prologue-save function is used, see -mcall-prologues command-line option. Switch/case dispatch tables. If you do not want such dispatch tables you can specify the -fno-jump-tables command-line option. C and C++ constructors/destructors called during startup/shutdown. If the tools hit a gs() modier explained above. Jumping to non-symbolic addresses like so is not supported: int main (void) { /* Call function at word address 0x2 */ return ((int(*)(void)) 0x2)(); } Instead, a stub has to be set up, i.e. the function has to be called through a symbol (func_4 in the example): int main (void) { extern int func_4 (void); /* Call function at byte address 0x4 */ return func_4(); } and the application be linked with -Wl,--defsym,func_4=0x4. Alternatively, func_4 can be dened in the linker script.

188

Using the GNU Compiler Collection (GCC)

[Link] Handling of the RAMPD, RAMPX, RAMPY and RAMPZ Special Function Registers
Some AVR devices support memories larger than the 64 KiB range that can be accessed with 16-bit pointers. To access memory locations outside this 64 KiB range, the contentent of a RAMP register is used as high part of the address: The X, Y, Z address register is concatenated with the RAMPX, RAMPY, RAMPZ special function register, respectively, to get a wide address. Similarly, RAMPD is used together with direct addressing. The startup code initializes the RAMP special function registers with zero. If a [AVR Named Address Spaces], page 338 other than generic or __flash is used, then RAMPZ is set as needed before the operation. If the device supports RAM larger than 64 KiB and the compiler needs to change RAMPZ to accomplish an operation, RAMPZ is reset to zero after the operation. If the device comes with a specic RAMP register, the ISR prologue/epilogue saves/restores that SFR and initializes it with zero in case the ISR code might (implicitly) use it. RAM larger than 64 KiB is not supported by GCC for AVR targets. If you use inline assembler to read from locations outside the 16-bit address range and change one of the RAMP registers, you must reset it to zero after the access.

[Link] AVR Built-in Macros

GCC denes several built-in macros so that the user code can test for the presence or absence of features. Almost any of the following built-in macros are deduced from device capabilities and thus triggered by the -mmcu= command-line option. For even more AVR-specic built-in macros see [AVR Named Address Spaces], page 338 and Section 6.56.4 [AVR Built-in Functions], page 551. __AVR_ARCH__ Build-in macro that resolves to a decimal number that identies the architecture and depends on the -mmcu=mcu option. Possible values are: 2, 25, 3, 31, 35, 4, 5, 51, 6, 102, 104, 105, 106, 107 for mcu=avr2, avr25, avr3, avr31, avr35, avr4, avr5, avr51, avr6, avrxmega2, avrxmega4, avrxmega5, avrxmega6, avrxmega7, respectively. If mcu species a device, this built-in macro is set accordingly. For example, with -mmcu=atmega8 the macro will be dened to 4. __AVR_Device__ Setting -mmcu=device denes this built-in macro which reects the devices name. For example, -mmcu=atmega8 denes the built-in macro __AVR_ATmega8__, -mmcu=attiny261a denes __AVR_ATtiny261A__, etc. The built-in macros names follow the scheme __AVR_Device__ where Device is the device name as from the AVR user manual. The dierence between Device in the built-in macro and device in -mmcu=device is that the latter is always lowercase. If device is not a device but only a core architecture like avr51, this macro will not be dened. __AVR_XMEGA__ The device / architecture belongs to the XMEGA family of devices.

Chapter 3: GCC Command Options

189

__AVR_HAVE_ELPM__ The device has the the ELPM instruction. __AVR_HAVE_ELPMX__ The device has the ELPM Rn,Z and ELPM Rn,Z+ instructions. __AVR_HAVE_MOVW__ The device has the MOVW instruction to perform 16-bit register-register moves. __AVR_HAVE_LPMX__ The device has the LPM Rn,Z and LPM Rn,Z+ instructions. __AVR_HAVE_MUL__ The device has a hardware multiplier. __AVR_HAVE_JMP_CALL__ The device has the JMP and CALL instructions. This is the case for devices with at least 16 KiB of program memory. __AVR_HAVE_EIJMP_EICALL__ __AVR_3_BYTE_PC__ The device has the EIJMP and EICALL instructions. This is the case for devices with more than 128 KiB of program memory. This also means that the program counter (PC) is 3 bytes wide. __AVR_2_BYTE_PC__ The program counter (PC) is 2 bytes wide. This is the case for devices with up to 128 KiB of program memory. __AVR_HAVE_8BIT_SP__ __AVR_HAVE_16BIT_SP__ The stack pointer (SP) register is treated as 8-bit respectively 16-bit register by the compiler. The denition of these macros is aected by -mtiny-stack. __AVR_HAVE_SPH__ __AVR_SP8__ The device has the SPH (high part of stack pointer) special function register or has an 8-bit stack pointer, respectively. The denition of these macros is aected by -mmcu= and in the cases of -mmcu=avr2 and -mmcu=avr25 also by -msp8. __AVR_HAVE_RAMPD__ __AVR_HAVE_RAMPX__ __AVR_HAVE_RAMPY__ __AVR_HAVE_RAMPZ__ The device has the RAMPD, RAMPX, RAMPY, RAMPZ special function register, respectively. __NO_INTERRUPTS__ This macro reects the -mno-interrupts command line option. __AVR_ERRATA_SKIP__ __AVR_ERRATA_SKIP_JMP_CALL__ Some AVR devices (AT90S8515, ATmega103) must not skip 32-bit instructions because of a hardware erratum. Skip instructions are SBRS, SBRC, SBIS, SBIC

190

Using the GNU Compiler Collection (GCC)

and CPSE. The second macro is only dened if __AVR_HAVE_JMP_CALL__ is also set. __AVR_SFR_OFFSET__=offset Instructions that can address I/O special function registers directly like IN, OUT, SBI, etc. may use a dierent address as if addressed by an instruction to access RAM like LD or STS. This oset depends on the device architecture and has to be subtracted from the RAM address in order to get the respective I/O address. __WITH_AVRLIBC__ The compiler is congured to be used together with AVR-Libc. See the -with-avrlibc congure option.

3.17.5 Blackn Options

-mcpu=cpu[-sirevision] Species the name of the target Blackn processor. Currently, cpu can be one of bf512, bf514, bf516, bf518, bf522, bf523, bf524, bf525, bf526, bf527, bf531, bf532, bf533, bf534, bf536, bf537, bf538, bf539, bf542, bf544, bf547, bf548, bf549, bf542m, bf544m, bf547m, bf548m, bf549m, bf561, bf592. The optional sirevision species the silicon revision of the target Blackn processor. Any workarounds available for the targeted silicon revision are enabled. If sirevision is none, no workarounds are enabled. If sirevision is any, all workarounds for the targeted processor are enabled. The __SILICON_ REVISION__ macro is dened to two hexadecimal digits representing the major and minor numbers in the silicon revision. If sirevision is none, the __SILICON_ REVISION__ is not dened. If sirevision is any, the __SILICON_REVISION__ is dened to be 0xffff. If this optional sirevision is not used, GCC assumes the latest known silicon revision of the targeted Blackn processor. GCC denes a preprocessor macro for the specied cpu. For the bfin-elf toolchain, this option causes the hardware BSP provided by libgloss to be linked in if -msim is not given. Without this option, bf532 is used as the processor by default. Note that support for bf561 is incomplete. For bf561, only the preprocessor macro is dened. -msim Species that the program will be run on the simulator. This causes the simulator BSP provided by libgloss to be linked in. This option has eect only for bfin-elf toolchain. Certain other options, such as -mid-shared-library and -mfdpic, imply -msim.

-momit-leaf-frame-pointer Dont keep the frame pointer in a register for leaf functions. This avoids the instructions to save, set up and restore frame pointers and makes an extra register available in leaf functions. The option -fomit-frame-pointer removes the frame pointer for all functions, which might make debugging harder.

Chapter 3: GCC Command Options

191

-mspecld-anomaly When enabled, the compiler ensures that the generated code does not contain speculative loads after jump instructions. If this option is used, __WORKAROUND_ SPECULATIVE_LOADS is dened. -mno-specld-anomaly Dont generate extra code to prevent speculative loads from occurring. -mcsync-anomaly When enabled, the compiler ensures that the generated code does not contain CSYNC or SSYNC instructions too soon after conditional branches. If this option is used, __WORKAROUND_SPECULATIVE_SYNCS is dened. -mno-csync-anomaly Dont generate extra code to prevent CSYNC or SSYNC instructions from occurring too soon after a conditional branch. -mlow-64k When enabled, the compiler is free to take advantage of the knowledge that the entire program ts into the low 64k of memory. -mno-low-64k Assume that the program is arbitrarily large. This is the default. -mstack-check-l1 Do stack checking using information placed into L1 scratchpad memory by the uClinux kernel. -mid-shared-library Generate code that supports shared libraries via the library ID method. This allows for execute in place and shared libraries in an environment without virtual memory management. This option implies -fPIC. With a bfin-elf target, this option implies -msim. -mno-id-shared-library Generate code that doesnt assume ID-based shared libraries are being used. This is the default. -mleaf-id-shared-library Generate code that supports shared libraries via the library ID method, but assumes that this library or executable wont link against any other ID shared libraries. That allows the compiler to use faster code for jumps and calls. -mno-leaf-id-shared-library Do not assume that the code being compiled wont link against any ID shared libraries. Slower code is generated for jump and call insns. -mshared-library-id=n Species the identication number of the ID-based shared library being compiled. Specifying a value of 0 generates more compact code; specifying other values forces the allocation of that number to the current library but is no more space- or time-ecient than omitting this option.

192

Using the GNU Compiler Collection (GCC)

-msep-data Generate code that allows the data segment to be located in a dierent area of memory from the text segment. This allows for execute in place in an environment without virtual memory management by eliminating relocations against the text section. -mno-sep-data Generate code that assumes that the data segment follows the text segment. This is the default. -mlong-calls -mno-long-calls Tells the compiler to perform function calls by rst loading the address of the function into a register and then performing a subroutine call on this register. This switch is needed if the target function lies outside of the 24-bit addressing range of the oset-based version of subroutine call instruction. This feature is not enabled by default. Specifying -mno-long-calls restores the default behavior. Note these switches have no eect on how the compiler generates code to handle function calls via function pointers. -mfast-fp Link with the fast oating-point library. This library relaxes some of the IEEE oating-point standards rules for checking inputs against Not-a-Number (NAN), in the interest of performance. -minline-plt Enable inlining of PLT entries in function calls to functions that are not known to bind locally. It has no eect without -mfdpic. -mmulticore Build a standalone application for multicore Blackn processors. This option causes proper start les and link scripts supporting multicore to be used, and denes the macro __BFIN_MULTICORE. It can only be used with -mcpu=bf561[-sirevision]. This option can be used with -mcorea or -mcoreb, which selects the oneapplication-per-core programming model. Without -mcorea or -mcoreb, the single-application/dual-core programming model is used. In this model, the main function of Core B should be named as coreb_main. If this option is not used, the single-core application programming model is used. -mcorea Build a standalone application for Core A of BF561 when using the oneapplication-per-core programming model. Proper start les and link scripts are used to support Core A, and the macro __BFIN_COREA is dened. This option can only be used in conjunction with -mmulticore. Build a standalone application for Core B of BF561 when using the one-application-per-core programming model. Proper start les and link scripts are used to support Core B, and the macro __BFIN_COREB is dened. When this option is used, coreb_main should be used instead of main. This option can only be used in conjunction with -mmulticore.

-mcoreb

Chapter 3: GCC Command Options

193

-msdram

Build a standalone application for SDRAM. Proper start les and link scripts are used to put the application into SDRAM, and the macro __BFIN_SDRAM is dened. The loader should initialize SDRAM before loading the application. Assume that ICPLBs are enabled at run time. This has an eect on certain anomaly workarounds. For Linux targets, the default is to assume ICPLBs are enabled; for standalone applications the default is o.

-micplb

3.17.6 C6X Options

-march=name This species the name of the target architecture. GCC uses this name to determine what kind of instructions it can emit when generating assembly code. Permissible names are: c62x, c64x, c64x+, c67x, c67x+, c674x. -mbig-endian Generate code for a big-endian target. -mlittle-endian Generate code for a little-endian target. This is the default. -msim Choose startup les and linker script suitable for the simulator. -msdata=default Put small global and static data in the .neardata section, which is pointed to by register B14. Put small uninitialized global and static data in the .bss section, which is adjacent to the .neardata section. Put small read-only data into the .rodata section. The corresponding sections used for large pieces of data are .fardata, .far and .const. -msdata=all Put all data, not just small objects, into the sections reserved for small data, and use addressing relative to the B14 register to access them. -msdata=none Make no use of the sections reserved for small data, and use absolute addresses to access all data. Put all initialized global and static data in the .fardata section, and all uninitialized data in the .far section. Put all constant data into the .const section.

3.17.7 CRIS Options

These options are dened specically for the CRIS ports. -march=architecture-type -mcpu=architecture-type Generate code for the specied architecture. The choices for architecturetype are v3, v8 and v10 for respectively ETRAX 4, ETRAX 100, and ETRAX 100 LX. Default is v0 except for cris-axis-linux-gnu, where the default is v10. -mtune=architecture-type Tune to architecture-type everything applicable about the generated code, except for the ABI and the set of available instructions. The choices for architecture-type are the same as for -march=architecture-type.

194

Using the GNU Compiler Collection (GCC)

-mmax-stack-frame=n Warn when the stack frame of a function exceeds n bytes. -metrax4 -metrax100 The options -metrax4 and -metrax100 are synonyms for -march=v3 and -march=v8 respectively. -mmul-bug-workaround -mno-mul-bug-workaround Work around a bug in the muls and mulu instructions for CPU models where it applies. This option is active by default. -mpdebug Enable CRIS-specic verbose debug-related information in the assembly code. This option also has the eect of turning o the #NO_APP formatted-code indicator to the assembler at the beginning of the assembly le. Do not use condition-code results from previous instruction; always emit compare and test instructions before use of condition codes. -mno-side-effects Do not emit instructions with side eects in addressing modes other than postincrement. -mstack-align -mno-stack-align -mdata-align -mno-data-align -mconst-align -mno-const-align These options (no- options) arrange (eliminate arrangements) for the stack frame, individual data and constants to be aligned for the maximum single data access size for the chosen CPU model. The default is to arrange for 32bit alignment. ABI details such as structure layout are not aected by these options. -m32-bit -m16-bit -m8-bit

-mcc-init

Similar to the stack- data- and const-align options above, these options arrange for stack frame, writable data and constants to all be 32-bit, 16-bit or 8-bit aligned. The default is 32-bit alignment.

-mno-prologue-epilogue -mprologue-epilogue With -mno-prologue-epilogue, the normal function prologue and epilogue which set up the stack frame are omitted and no return instructions or return sequences are generated in the code. Use this option only together with visual inspection of the compiled code: no warnings or errors are generated when call-saved registers must be saved, or storage for local variables needs to be allocated.

Chapter 3: GCC Command Options

195

-mno-gotplt -mgotplt With -fpic and -fPIC, dont generate (do generate) instruction sequences that load addresses for functions from the PLT part of the GOT rather than (traditional on other architectures) calls to the PLT. The default is -mgotplt. -melf -mlinux -sim Legacy no-op option only recognized with the cris-axis-elf and cris-axis-linuxgnu targets. Legacy no-op option only recognized with the cris-axis-linux-gnu target. This option, recognized for the cris-axis-elf, arranges to link with input-output functions from a simulator library. Code, initialized data and zero-initialized data are allocated consecutively. Like -sim, but pass linker options to locate initialized data at 0x40000000 and zero-initialized data at 0x80000000.

-sim2

3.17.8 CR16 Options

These options are dened specically for the CR16 ports. -mmac Enable the use of multiply-accumulate instructions. Disabled by default.

-mcr16cplus -mcr16c Generate code for CR16C or CR16C+ architecture. CR16C+ architecture is default. -msim -mint32 -mbit-ops Generates sbit/cbit instructions for bit manipulations. -mdata-model=model Choose a data model. The choices for model are near, far or medium. medium is default. However, far is not valid with -mcr16c, as the CR16C architecture does not support the far data model. Links the library libsim.a which is in compatible with simulator. Applicable to ELF compiler only. Choose integer type as 32-bit wide.

3.17.9 Darwin Options

These options are dened for all architectures running the Darwin operating system. FSF GCC on Darwin does not create fat object les; it creates an object le for the single architecture that GCC was built to target. Apples GCC on Darwin does create fat les if multiple -arch options are used; it does so by running the compiler or linker multiple times and joining the results together with lipo. The subtype of the le created (like ppc7400 or ppc970 or i686) is determined by the ags that specify the ISA that GCC is targeting, like -mcpu or -march. The -force_cpusubtype_ALL option can be used to override this. The Darwin tools vary in their behavior when presented with an ISA mismatch. The assembler, as, only permits instructions to be used that are valid for the subtype of the le it is generating, so you cannot put 64-bit instructions in a ppc750 object le. The

196

Using the GNU Compiler Collection (GCC)

linker for shared libraries, /usr/bin/libtool, fails and prints an error if asked to create a shared library with a less restrictive subtype than its input les (for instance, trying to put a ppc970 object le in a ppc7400 library). The linker for executables, ld, quietly gives the executable the most restrictive subtype of any of its input les. -Fdir Add the framework directory dir to the head of the list of directories to be searched for header les. These directories are interleaved with those specied by -I options and are scanned in a left-to-right order. A framework directory is a directory with frameworks in it. A framework is a directory with a Headers and/or PrivateHeaders directory contained directly in it that ends in .framework. The name of a framework is the name of this directory excluding the .framework. Headers associated with the framework are found in one of those two directories, with Headers being searched rst. A subframework is a framework directory that is in a frameworks Frameworks directory. Includes of subframework headers can only appear in a header of a framework that contains the subframework, or in a sibling subframework header. Two subframeworks are siblings if they occur in the same framework. A subframework should not have the same name as a framework; a warning is issued if this is violated. Currently a subframework cannot have subframeworks; in the future, the mechanism may be extended to support this. The standard frameworks can be found in /System/Library/Frameworks and /Library/Frameworks. An example include looks like #include <Framework/header.h>, where Framework denotes the name of the framework and header.h is found in the PrivateHeaders or Headers directory. -iframeworkdir Like -F except the directory is a treated as a system directory. The main dierence between this -iframework and -F is that with -iframework the compiler does not warn about constructs contained within header les found via dir. This option is valid only for the C family of languages. -gused Emit debugging information for symbols that are used. For stabs debugging format, this enables -feliminate-unused-debug-symbols. This is by default ON. Emit debugging information for all symbols and types.

-gfull

-mmacosx-version-min=version The earliest version of MacOS X that this executable will run on is version. Typical values of version include 10.1, 10.2, and 10.3.9. If the compiler was built to use the systems headers by default, then the default for this option is the system version on which the compiler is running, otherwise the default is to make choices that are compatible with as many systems and code bases as possible. -mkernel Enable kernel development mode. The -mkernel option sets -static, -fno-common, -fno-cxa-atexit, -fno-exceptions, -fno-non-call-exceptions, -fapple-kext, -fno-weak and -fno-rtti

Chapter 3: GCC Command Options

197

where applicable. This mode also sets -mno-altivec, -msoft-float, -fno-builtin and -mlong-branch for PowerPC targets. -mone-byte-bool Override the defaults for bool so that sizeof(bool)==1. By default sizeof(bool) is 4 when compiling for Darwin/PowerPC and 1 when compiling for Darwin/x86, so this option has no eect on x86. Warning: The -mone-byte-bool switch causes GCC to generate code that is not binary compatible with code generated without that switch. Using this switch may require recompiling all other modules in a program, including system libraries. Use this switch to conform to a non-default data model. -mfix-and-continue -ffix-and-continue -findirect-data Generate code suitable for fast turnaround development, such as to allow GDB to dynamically load .o les into already-running programs. -findirect-data and -ffix-and-continue are provided for backwards compatibility. -all_load Loads all members of static archive libraries. See man ld(1) for more information. -arch_errors_fatal Cause the errors having to do with les that have the wrong architecture to be fatal. -bind_at_load Causes the output le to be marked such that the dynamic linker will bind all undened references when the le is loaded or launched. -bundle Produce a Mach-o bundle format le. See man ld(1) for more information.

-bundle_loader executable This option species the executable that will load the build output le being linked. See man ld(1) for more information. -dynamiclib When passed this option, GCC produces a dynamic library instead of an executable when linking, using the Darwin libtool command. -force_cpusubtype_ALL This causes GCCs output le to have the ALL subtype, instead of one controlled by the -mcpu or -march option.

198

Using the GNU Compiler Collection (GCC)

-allowable_client client_name -client_name -compatibility_version -current_version -dead_strip -dependency-file -dylib_file -dylinker_install_name -dynamic -exported_symbols_list -filelist -flat_namespace -force_flat_namespace -headerpad_max_install_names -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

Chapter 3: GCC Command Options

199

-segs_read_write_addr -seg_addr_table -seg_addr_table_filename -seglinkedit -segprot -segs_read_only_addr -segs_read_write_addr -single_module -static -sub_library -sub_umbrella -twolevel_namespace -umbrella -undefined -unexported_symbols_list -weak_reference_mismatches -whatsloaded These options are passed to the Darwin linker. The Darwin linker man page describes them in detail.

3.17.10 DEC Alpha Options

These -m options are dened for the DEC Alpha implementations: -mno-soft-float -msoft-float Use (do not use) the hardware oating-point instructions for oating-point operations. When -msoft-float is specied, functions in libgcc.a are used to perform oating-point operations. Unless they are replaced by routines that emulate the oating-point operations, or compiled in such a way as to call such emulations routines, these routines issue oating-point operations. If you are compiling for an Alpha without oating-point operations, you must ensure that the library is built so as not to call them. Note that Alpha implementations without oating-point operations are required to have oating-point registers. -mfp-reg -mno-fp-regs Generate code that uses (does not use) the oating-point register set. -mno-fp-regs implies -msoft-float. If the oating-point register set is not used, oating-point operands are passed in integer registers as if they were integers and oating-point results are passed in $0 instead of $f0. This is a non-standard calling sequence, so any function with a oating-point argument or return value called by code compiled with -mno-fp-regs must also be compiled with that option. A typical use of this option is building a kernel that does not use, and hence need not save and restore, any oating-point registers.

200

Using the GNU Compiler Collection (GCC)

-mieee

The Alpha architecture implements oating-point hardware optimized for maximum performance. It is mostly compliant with the IEEE oating-point standard. However, for full compliance, software assistance is required. This option generates code fully IEEE-compliant code except that the inexact-ag is not maintained (see below). If this option is turned on, the preprocessor macro _IEEE_FP is dened during compilation. The resulting code is less ecient but is able to correctly support denormalized numbers and exceptional IEEE values such as not-a-number and plus/minus innity. Other Alpha compilers call this option -ieee_with_no_inexact.

-mieee-with-inexact This is like -mieee except the generated code also maintains the IEEE inexactag. Turning on this option causes the generated code to implement fullycompliant IEEE math. In addition to _IEEE_FP, _IEEE_FP_EXACT is dened as a preprocessor macro. On some Alpha implementations the resulting code may execute signicantly slower than the code generated by default. Since there is very little code that depends on the inexact-ag, you should normally not specify this option. Other Alpha compilers call this option -ieee_with_inexact. -mfp-trap-mode=trap-mode This option controls what oating-point related traps are enabled. Other Alpha compilers call this option -fptm trap-mode. The trap mode can be set to one of four values: n This is the default (normal) setting. The only traps that are enabled are the ones that cannot be disabled in software (e.g., division by zero trap). In addition to the traps enabled by n, underow traps are enabled as well. Like u, but the instructions are marked to be safe for software completion (see Alpha architecture manual for details). Like su, but inexact traps are enabled as well.

u su sui

-mfp-rounding-mode=rounding-mode Selects the IEEE rounding mode. Other Alpha compilers call this option -fprm rounding-mode. The rounding-mode can be one of: n Normal IEEE rounding mode. Floating-point numbers are rounded towards the nearest machine number or towards the even machine number in case of a tie. Round towards minus innity. Chopped rounding mode. Floating-point numbers are rounded towards zero. Dynamic rounding mode. A eld in the oating-point control register (fpcr, see Alpha architecture reference manual) controls the rounding mode in eect. The C library initializes this register for rounding towards plus innity. Thus, unless your program modies the fpcr, d corresponds to round towards plus innity.

m c d

Chapter 3: GCC Command Options

201

-mtrap-precision=trap-precision In the Alpha architecture, oating-point traps are imprecise. This means without software assistance it is impossible to recover from a oating trap and program execution normally needs to be terminated. GCC can generate code that can assist operating system trap handlers in determining the exact location that caused a oating-point trap. Depending on the requirements of an application, dierent levels of precisions can be selected: p Program precision. This option is the default and means a trap handler can only identify which program caused a oating-point exception. Function precision. The trap handler can determine the function that caused a oating-point exception. Instruction precision. The trap handler can determine the exact instruction that caused a oating-point exception.

f i

Other Alpha compilers provide the equivalent options called -scope_safe and -resumption_safe. -mieee-conformant This option marks the generated code as IEEE conformant. You must not use this option unless you also specify -mtrap-precision=i and either -mfp-trap-mode=su or -mfp-trap-mode=sui. Its only eect is to emit the line .eflag 48 in the function prologue of the generated assembly le. -mbuild-constants Normally GCC examines a 32- or 64-bit integer constant to see if it can construct it from smaller constants in two or three instructions. If it cannot, it outputs the constant as a literal and generates code to load it from the data segment at run time. Use this option to require GCC to construct all integer constants using code, even if it takes more instructions (the maximum is six). You typically use this option to build a shared library dynamic loader. Itself a shared library, it must relocate itself in memory before it can nd the variables and constants in its own data segment. -mbwx -mno-bwx -mcix -mno-cix -mfix -mno-fix -mmax -mno-max

Indicate whether GCC should generate code to use the optional BWX, CIX, FIX and MAX instruction sets. The default is to use th