gcc/common.opt

   1 ; Options for the language- and target-independent parts of the compiler.
   2
   3 ; Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008
   4 ; Free Software Foundation, Inc.
   5 ;
   6 ; This file is part of GCC.
   7 ;
   8 ; GCC is free software; you can redistribute it and/or modify it under
   9 ; the terms of the GNU General Public License as published by the Free
  10 ; Software Foundation; either version 3, or (at your option) any later
  11 ; version.
  12 ;
  13 ; GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 ; WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 ; FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 ; for more details.
  17 ;
  18 ; You should have received a copy of the GNU General Public License
  19 ; along with GCC; see the file COPYING3.  If not see
  20 ; <http://www.gnu.org/licenses/>.
  21
  22 ; See the GCC internals manual (options.texi) for a description of this file's format.
  23
  24 ; Please try to keep this file in ASCII collating order.
  25
  26 -help
  27 Common
  28 Display this information
  29
  30 -help=
  31 Common Report Joined
  32 --help=<class>  Display descriptions of a specific class of options.  <class> is one or more of optimizers, target, warnings, undocumented, params
  33
  34 -target-help
  35 Common
  36 Alias for --help=target
  37
  38 ;; The following three entries are to work around the gcc driver
  39 ;; program's insatiable desire to turn options starting with a
  40 ;; double dash (--) into options starting with a dash f (-f).
  41 fhelp
  42 Common
  43
  44 fhelp=
  45 Common Joined
  46
  47 ftarget-help
  48 Common
  49
  50 -param
  51 Common Separate
  52 --param <param>=<value> Set parameter <param> to value.  See below for a complete list of parameters
  53
  54 -version
  55 Common
  56
  57 G
  58 Common Joined Separate UInteger
  59 -G<number>      Put global and static data smaller than <number> bytes into a special section (on some targets)
  60
  61 O
  62 Common JoinedOrMissing
  63 -O<number>      Set optimization level to <number>
  64
  65 Os
  66 Common
  67 Optimize for space rather than speed
  68
  69 W
  70 Common RejectNegative
  71 This switch is deprecated; use -Wextra instead
  72
  73 Waggregate-return
  74 Common Var(warn_aggregate_return) Warning
  75 Warn about returning structures, unions or arrays
  76
  77 Warray-bounds
  78 Common Var(warn_array_bounds) Warning
  79 Warn if an array is accessed out of bounds
  80
  81 Wattributes
  82 Common Var(warn_attributes) Init(1) Warning
  83 Warn about inappropriate attribute usage
  84
  85 Wcast-align
  86 Common Var(warn_cast_align) Warning
  87 Warn about pointer casts which increase alignment
  88
  89 Wdeprecated-declarations
  90 Common Var(warn_deprecated_decl) Init(1) Warning
  91 Warn about uses of __attribute__((deprecated)) declarations
  92
  93 Wdisabled-optimization
  94 Common Var(warn_disabled_optimization) Warning
  95 Warn when an optimization pass is disabled
  96
  97 Werror
  98 Common Var(warnings_are_errors)
  99 Treat all warnings as errors
 100
 101 Werror=
 102 Common Joined
 103 Treat specified warning as error
 104
 105 Wextra
 106 Common Warning
 107 Print extra (possibly unwanted) warnings
 108
 109 Wfatal-errors
 110 Common Var(flag_fatal_errors)
 111 Exit on the first error occurred
 112
 113 Winline
 114 Common Var(warn_inline) Warning
 115 Warn when an inlined function cannot be inlined
 116
 117 Wlarger-than-
 118 Common RejectNegative Joined UInteger Warning
 119 -Wlarger-than-<number>  Warn if an object is larger than <number> bytes
 120
 121 Wlogical-op
 122 Common Warning Var(warn_logical_op)
 123 Warn when a logical operator is suspicously always evaluating to true or false
 124
 125 Wunsafe-loop-optimizations
 126 Common Var(warn_unsafe_loop_optimizations) Warning
 127 Warn if the loop cannot be optimized due to nontrivial assumptions.
 128
 129 Wmissing-noreturn
 130 Common Var(warn_missing_noreturn) Warning
 131 Warn about functions which might be candidates for __attribute__((noreturn))
 132
 133 Woverflow
 134 Common Var(warn_overflow) Init(1) Warning
 135 Warn about overflow in arithmetic expressions
 136
 137 Wpacked
 138 Common Var(warn_packed) Warning
 139 Warn when the packed attribute has no effect on struct layout
 140
 141 Wpadded
 142 Common Var(warn_padded) Warning
 143 Warn when padding is required to align structure members
 144
 145 Wshadow
 146 Common Var(warn_shadow) Warning
 147 Warn when one local variable shadows another
 148
 149 Wstack-protector
 150 Common Var(warn_stack_protect) Warning
 151 Warn when not issuing stack smashing protection for some reason
 152
 153 Wstrict-aliasing
 154 Common Warning
 155 Warn about code which might break strict aliasing rules
 156
 157 Wstrict-aliasing=
 158 Common Joined UInteger Warning
 159 Warn about code which might break strict aliasing rules
 160
 161 Wstrict-overflow
 162 Common Warning
 163 Warn about optimizations that assume that signed overflow is undefined
 164
 165 Wstrict-overflow=
 166 Common Joined UInteger Warning
 167 Warn about optimizations that assume that signed overflow is undefined
 168
 169 Wswitch
 170 Common Var(warn_switch) Warning
 171 Warn about enumerated switches, with no default, missing a case
 172
 173 Wswitch-default
 174 Common Var(warn_switch_default) Warning
 175 Warn about enumerated switches missing a \"default:\" statement
 176
 177 Wswitch-enum
 178 Common Var(warn_switch_enum) Warning
 179 Warn about all enumerated switches missing a specific case
 180
 181 Wsystem-headers
 182 Common Var(warn_system_headers) Warning
 183 Do not suppress warnings from system headers
 184
 185 Wuninitialized
 186 Common Var(warn_uninitialized) Warning
 187 Warn about uninitialized automatic variables
 188
 189 Wunreachable-code
 190 Common Var(warn_notreached) Warning
 191 Warn about code that will never be executed
 192
 193 Wunused
 194 Common Warning
 195 Enable all -Wunused- warnings
 196
 197 Wunused-function
 198 Common Var(warn_unused_function) Warning
 199 Warn when a function is unused
 200
 201 Wunused-label
 202 Common Var(warn_unused_label) Warning
 203 Warn when a label is unused
 204
 205 Wunused-parameter
 206 Common Var(warn_unused_parameter) Warning
 207 Warn when a function parameter is unused
 208
 209 Wunused-value
 210 Common Var(warn_unused_value) Warning
 211 Warn when an expression value is unused
 212
 213 Wunused-variable
 214 Common Var(warn_unused_variable) Warning
 215 Warn when a variable is unused
 216
 217 Wvolatile-register-var
 218 Common Var(warn_register_var) Warning
 219 Warn when a register variable is declared volatile
 220
 221 Wcoverage-mismatch
 222 Common RejectNegative Var(warn_coverage_mismatch) Warning
 223 Warn instead of error in case profiles in -fprofile-use do not match
 224
 225 aux-info
 226 Common Separate
 227 -aux-info <file>        Emit declaration information into <file>
 228
 229 aux-info=
 230 Common Joined
 231
 232 auxbase
 233 Common Separate
 234
 235 auxbase-strip
 236 Common Separate
 237
 238 d
 239 Common Joined
 240 -d<letters>     Enable dumps from specific passes of the compiler
 241
 242 dumpbase
 243 Common Separate
 244 -dumpbase <file>        Set the file basename to be used for dumps
 245
 246 ; The version of the C++ ABI in use.  The following values are allowed:
 247 ;
 248 ; 0: The version of the ABI believed most conformant with the C++ ABI
 249 ;    specification.  This ABI may change as bugs are discovered and fixed.
 250 ;    Therefore, 0 will not necessarily indicate the same ABI in different
 251 ;    versions of G++.
 252 ;
 253 ; 1: The version of the ABI first used in G++ 3.2.
 254 ;
 255 ; 2: The version of the ABI first used in G++ 3.4.
 256 ;
 257 ; Additional positive integers will be assigned as new versions of
 258 ; the ABI become the default version of the ABI.
 259 fabi-version=
 260 Common Joined UInteger Var(flag_abi_version) Init(2)
 261
 262 falign-functions
 263 Common Report Var(align_functions,0)
 264 Align the start of functions
 265
 266 falign-functions=
 267 Common RejectNegative Joined UInteger
 268
 269 falign-jumps
 270 Common Report Var(align_jumps,0) Optimization
 271 Align labels which are only reached by jumping
 272
 273 falign-jumps=
 274 Common RejectNegative Joined UInteger
 275
 276 falign-labels
 277 Common Report Var(align_labels,0) Optimization
 278 Align all labels
 279
 280 falign-labels=
 281 Common RejectNegative Joined UInteger
 282
 283 falign-loops
 284 Common Report Var(align_loops) Optimization
 285 Align the start of loops
 286
 287 falign-loops=
 288 Common RejectNegative Joined UInteger
 289
 290 ; This flag is only tested if alias checking is enabled.
 291 ; 0 if pointer arguments may alias each other.  True in C.
 292 ; 1 if pointer arguments may not alias each other but may alias
 293 ;   global variables.
 294 ; 2 if pointer arguments may not alias each other and may not
 295 ;   alias global variables.
 296 ; 3 if pointer arguments may not alias anything.  True in Fortran.
 297 ;   Set by the front end.
 298 fargument-alias
 299 Common Report Var(flag_argument_noalias,0) Optimization
 300 Specify that arguments may alias each other and globals
 301
 302 fargument-noalias
 303 Common Report Var(flag_argument_noalias,1) VarExists Optimization
 304 Assume arguments may alias globals but not each other
 305
 306 fargument-noalias-global
 307 Common Report Var(flag_argument_noalias,2) VarExists Optimization
 308 Assume arguments alias neither each other nor globals
 309
 310 fargument-noalias-anything
 311 Common Report Var(flag_argument_noalias,3) VarExists Optimization
 312 Assume arguments alias no other storage
 313
 314 fasynchronous-unwind-tables
 315 Common Report Var(flag_asynchronous_unwind_tables) Optimization
 316 Generate unwind tables that are exact at each instruction boundary
 317
 318 fauto-inc-dec
 319 Common Report Var(flag_auto_inc_dec) Init(1)
 320 Generate auto-inc/dec instructions
 321
 322 ; -fcheck-bounds causes gcc to generate array bounds checks.
 323 ; For C, C++ and ObjC: defaults off.
 324 ; For Java: defaults to on.
 325 ; For Fortran: defaults to off.
 326 fbounds-check
 327 Common Report Var(flag_bounds_check)
 328 Generate code to check bounds before indexing arrays
 329
 330 fbranch-count-reg
 331 Common Report Var(flag_branch_on_count_reg) Init(1) Optimization
 332 Replace add, compare, branch with branch on count register
 333
 334 fbranch-probabilities
 335 Common Report Var(flag_branch_probabilities) Optimization
 336 Use profiling information for branch probabilities
 337
 338 fbranch-target-load-optimize
 339 Common Report Var(flag_branch_target_load_optimize) Optimization
 340 Perform branch target load optimization before prologue / epilogue threading
 341
 342 fbranch-target-load-optimize2
 343 Common Report Var(flag_branch_target_load_optimize2) Optimization
 344 Perform branch target load optimization after prologue / epilogue threading
 345
 346 fbtr-bb-exclusive
 347 Common Report Var(flag_btr_bb_exclusive) Optimization
 348 Restrict target load migration not to re-use registers in any basic block
 349
 350 fcall-saved-
 351 Common Joined RejectNegative
 352 -fcall-saved-<register> Mark <register> as being preserved across functions
 353
 354 fcall-used-
 355 Common Joined RejectNegative
 356 -fcall-used-<register>  Mark <register> as being corrupted by function calls
 357
 358 ; Nonzero for -fcaller-saves: allocate values in regs that need to
 359 ; be saved across function calls, if that produces overall better code.
 360 ; Optional now, so people can test it.
 361 fcaller-saves
 362 Common Report Var(flag_caller_saves) Optimization
 363 Save registers around function calls
 364
 365 fcheck-data-deps
 366 Common Report Var(flag_check_data_deps)
 367 Compare the results of several data dependence analyzers.
 368
 369 fcommon
 370 Common Report Var(flag_no_common,0) Optimization
 371 Do not put uninitialized globals in the common section
 372
 373 fcprop-registers
 374 Common Report Var(flag_cprop_registers) Optimization
 375 Perform a register copy-propagation optimization pass
 376
 377 fcrossjumping
 378 Common Report Var(flag_crossjumping) Optimization
 379 Perform cross-jumping optimization
 380
 381 fcse-follow-jumps
 382 Common Report Var(flag_cse_follow_jumps) Optimization
 383 When running CSE, follow jumps to their targets
 384
 385 fcse-skip-blocks
 386 Common Report Var(flag_cse_skip_blocks) Optimization
 387 When running CSE, follow conditional jumps
 388
 389 fcx-limited-range
 390 Common Report Var(flag_cx_limited_range) Optimization
 391 Omit range reduction step when performing complex division
 392
 393 fdata-sections
 394 Common Report Var(flag_data_sections) Optimization
 395 Place data items into their own section
 396
 397 fdbg-cnt-list
 398 Common Report
 399 List all available debugging counters with their limits and counts.
 400
 401 fdbg-cnt=
 402 Common RejectNegative Joined
 403 -fdbg-cnt=<counter>:<limit>[,<counter>:<limit>,...]    Set the debug counter limit.
 404
 405 fdebug-prefix-map=
 406 Common Joined RejectNegative
 407 Map one directory name to another in debug information
 408
 409 ; Nonzero for -fdefer-pop: don't pop args after each function call
 410 ; instead save them up to pop many calls' args with one insns.
 411 fdefer-pop
 412 Common Report Var(flag_defer_pop) Optimization
 413 Defer popping functions args from stack until later
 414
 415 fdelayed-branch
 416 Common Report Var(flag_delayed_branch) Optimization
 417 Attempt to fill delay slots of branch instructions
 418
 419 fdelete-null-pointer-checks
 420 Common Report Var(flag_delete_null_pointer_checks) Optimization
 421 Delete useless null pointer checks
 422
 423 fdiagnostics-show-location=
 424 Common Joined RejectNegative
 425 -fdiagnostics-show-location=[once|every-line]   How often to emit source location at the beginning of line-wrapped diagnostics
 426
 427 fdiagnostics-show-option
 428 Common
 429 Amend appropriate diagnostic messages with the command line option that controls them
 430
 431 fdump-
 432 Common Joined RejectNegative
 433 -fdump-<type>   Dump various compiler internals to a file
 434
 435 fdump-noaddr
 436 Common Report Var(flag_dump_noaddr)
 437 Suppress output of addresses in debugging dumps
 438
 439 fdump-unnumbered
 440 Common Report Var(flag_dump_unnumbered) VarExists
 441 Suppress output of instruction numbers, line number notes and addresses in debugging dumps
 442
 443 fearly-inlining
 444 Common Report Var(flag_early_inlining) Init(1) Optimization
 445 Perform early inlining
 446
 447 feliminate-dwarf2-dups
 448 Common Report Var(flag_eliminate_dwarf2_dups)
 449 Perform DWARF2 duplicate elimination
 450
 451 feliminate-unused-debug-symbols
 452 Common Report Var(flag_debug_only_used_symbols)
 453 Perform unused type elimination in debug info
 454
 455 feliminate-unused-debug-types
 456 Common Report Var(flag_eliminate_unused_debug_types) Init(1)
 457 Perform unused type elimination in debug info
 458
 459 femit-class-debug-always
 460 Common Report Var(flag_emit_class_debug_always) Init(0)
 461 Do not suppress C++ class debug information.
 462
 463 fexceptions
 464 Common Report Var(flag_exceptions) Optimization
 465 Enable exception handling
 466
 467 fexpensive-optimizations
 468 Common Report Var(flag_expensive_optimizations) Optimization
 469 Perform a number of minor, expensive optimizations
 470
 471 ffast-math
 472 Common
 473
 474 ffinite-math-only
 475 Common Report Var(flag_finite_math_only) Optimization
 476 Assume no NaNs or infinities are generated
 477
 478 ffixed-
 479 Common Joined RejectNegative
 480 -ffixed-<register>      Mark <register> as being unavailable to the compiler
 481
 482 ffloat-store
 483 Common Report Var(flag_float_store) Optimization
 484 Don't allocate floats and doubles in extended-precision registers
 485
 486 fforce-addr
 487 Common
 488 Does nothing.  Preserved for backward compatibility.
 489
 490 fforward-propagate
 491 Common Report Var(flag_forward_propagate) Optimization
 492 Perform a forward propagation pass on RTL
 493
 494 ; Nonzero means don't put addresses of constant functions in registers.
 495 ; Used for compiling the Unix kernel, where strange substitutions are
 496 ; done on the assembly output.
 497 ffunction-cse
 498 Common Report Var(flag_no_function_cse,0)
 499 Allow function addresses to be held in registers
 500
 501 ffunction-sections
 502 Common Report Var(flag_function_sections)
 503 Place each function into its own section
 504
 505 fgcse
 506 Common Report Var(flag_gcse) Optimization
 507 Perform global common subexpression elimination
 508
 509 fgcse-lm
 510 Common Report Var(flag_gcse_lm) Init(1) Optimization
 511 Perform enhanced load motion during global common subexpression elimination
 512
 513 fgcse-sm
 514 Common Report Var(flag_gcse_sm) Init(0) Optimization
 515 Perform store motion after global common subexpression elimination
 516
 517 fgcse-las
 518 Common Report Var(flag_gcse_las) Init(0) Optimization
 519 Perform redundant load after store elimination in global common subexpression
 520 elimination
 521
 522 fgcse-after-reload
 523 Common Report Var(flag_gcse_after_reload) Optimization
 524 Perform global common subexpression elimination after register allocation
 525 has finished
 526
 527 fguess-branch-probability
 528 Common Report Var(flag_guess_branch_prob) Optimization
 529 Enable guessing of branch probabilities
 530
 531 ; Nonzero means ignore `#ident' directives.  0 means handle them.
 532 ; Generate position-independent code for executables if possible
 533 ; On SVR4 targets, it also controls whether or not to emit a
 534 ; string identifying the compiler.
 535 fident
 536 Common Report Var(flag_no_ident,0)
 537 Process #ident directives
 538
 539 fif-conversion
 540 Common Report Var(flag_if_conversion) Optimization
 541 Perform conversion of conditional jumps to branchless equivalents
 542
 543 fif-conversion2
 544 Common Report Var(flag_if_conversion2) Optimization
 545 Perform conversion of conditional jumps to conditional execution
 546
 547 ; -finhibit-size-directive inhibits output of .size for ELF.
 548 ; This is used only for compiling crtstuff.c,
 549 ; and it may be extended to other effects
 550 ; needed for crtstuff.c on other systems.
 551 finhibit-size-directive
 552 Common Report Var(flag_inhibit_size_directive)
 553 Do not generate .size directives
 554
 555 ; Nonzero means that functions declared `inline' will be treated
 556 ; as `static'.  Prevents generation of zillions of copies of unused
 557 ; static inline functions; instead, `inlines' are written out
 558 ; only when actually used.  Used in conjunction with -g.  Also
 559 ; does the right thing with #pragma interface.
 560 finline
 561 Common Report Var(flag_no_inline,0) Init(2)
 562 Pay attention to the \"inline\" keyword
 563
 564 finline-small-functions
 565 Common Report Var(flag_inline_small_functions) Optimization
 566 Integrate simple functions into their callers when code size is known to not growth
 567
 568 finline-functions
 569 Common Report Var(flag_inline_functions) Optimization
 570 Integrate simple functions into their callers
 571
 572 finline-functions-called-once
 573 Common Report Var(flag_inline_functions_called_once) Init(1) Optimization
 574 Integrate functions called once into their callers
 575
 576 finline-limit-
 577 Common RejectNegative Joined UInteger
 578
 579 finline-limit=
 580 Common RejectNegative Joined UInteger
 581 -finline-limit=<number> Limit the size of inlined functions to <number>
 582
 583 finstrument-functions
 584 Common Report Var(flag_instrument_function_entry_exit)
 585 Instrument function entry and exit with profiling calls
 586
 587 finstrument-functions-exclude-function-list=
 588 Common RejectNegative Joined
 589 -finstrument-functions-exclude-function-list=name,...  Do not instrument listed functions
 590
 591 finstrument-functions-exclude-file-list=
 592 Common RejectNegative Joined
 593 -finstrument-functions-exclude-file-list=filename,...  Do not instrument functions listed in files
 594
 595 fipa-cp
 596 Common Report Var(flag_ipa_cp) Optimization
 597 Perform Interprocedural constant propagation
 598
 599 fipa-pure-const
 600 Common Report Var(flag_ipa_pure_const) Init(0) Optimization
 601 Discover pure and const functions
 602
 603 fipa-pta
 604 Common Report Var(flag_ipa_pta) Init(0) Optimization
 605 Perform interprocedural points-to analysis
 606
 607 fipa-reference
 608 Common Report Var(flag_ipa_reference) Init(0) Optimization
 609 Discover readonly and non addressable static variables
 610
 611 fipa-type-escape
 612 Common Report Var(flag_ipa_type_escape) Init(0) Optimization
 613 Type based escape and alias analysis
 614
 615 fipa-matrix-reorg
 616 Common Report Var(flag_ipa_matrix_reorg) Optimization
 617 Perform matrix layout flattening and transposing based
 618 on profiling information.
 619
 620 fipa-struct-reorg
 621 Common Report Var(flag_ipa_struct_reorg)
 622 Perform structure layout optimizations based
 623 on profiling information.
 624
 625 fivopts
 626 Common Report Var(flag_ivopts) Init(1) Optimization
 627 Optimize induction variables on trees
 628
 629 fjump-tables
 630 Common Var(flag_jump_tables) Init(1) Optimization
 631 Use jump tables for sufficiently large switch statements
 632
 633 fkeep-inline-functions
 634 Common Report Var(flag_keep_inline_functions)
 635 Generate code for functions even if they are fully inlined
 636
 637 fkeep-static-consts
 638 Common Report Var(flag_keep_static_consts) Init(1)
 639 Emit static const variables even if they are not used
 640
 641 fleading-underscore
 642 Common Report Var(flag_leading_underscore) Init(-1)
 643 Give external symbols a leading underscore
 644
 645 floop-optimize
 646 Common
 647 Does nothing.  Preserved for backward compatibility.
 648
 649 fmath-errno
 650 Common Report Var(flag_errno_math) Init(1)
 651 Set errno after built-in math functions
 652
 653 fmem-report
 654 Common Report Var(mem_report)
 655 Report on permanent memory allocation
 656
 657 ; This will attempt to merge constant section constants, if 1 only
 658 ; string constants and constants from constant pool, if 2 also constant
 659 ; variables.
 660 fmerge-all-constants
 661 Common Report Var(flag_merge_constants,2) Init(1) Optimization
 662 Attempt to merge identical constants and constant variables
 663
 664 fmerge-constants
 665 Common Report Var(flag_merge_constants,1) VarExists Optimization
 666 Attempt to merge identical constants across compilation units
 667
 668 fmerge-debug-strings
 669 Common Report Var(flag_merge_debug_strings) Init(1)
 670 Attempt to merge identical debug strings across compilation units
 671
 672 fmessage-length=
 673 Common RejectNegative Joined UInteger
 674 -fmessage-length=<number>       Limit diagnostics to <number> characters per line.  0 suppresses line-wrapping
 675
 676 fmodulo-sched
 677 Common Report Var(flag_modulo_sched) Optimization
 678 Perform SMS based modulo scheduling before the first scheduling pass
 679
 680 fmodulo-sched-allow-regmoves
 681 Common Report Var(flag_modulo_sched_allow_regmoves)
 682 Perform SMS based modulo scheduling with register moves allowed
 683
 684 fmove-loop-invariants
 685 Common Report Var(flag_move_loop_invariants) Init(1) Optimization
 686 Move loop invariant computations out of loops
 687
 688 fmudflap
 689 Common RejectNegative Report Var(flag_mudflap)
 690 Add mudflap bounds-checking instrumentation for single-threaded program
 691
 692 fmudflapth
 693 Common RejectNegative Report VarExists Var(flag_mudflap,2)
 694 Add mudflap bounds-checking instrumentation for multi-threaded program
 695
 696 fmudflapir
 697 Common RejectNegative Report Var(flag_mudflap_ignore_reads)
 698 Ignore read operations when inserting mudflap instrumentation
 699
 700 fdce
 701 Common Var(flag_dce) Init(1) Optimization
 702 Use the RTL dead code elimination pass
 703
 704 fdse
 705 Common Var(flag_dse) Init(1) Optimization
 706 Use the RTL dead store elimination pass
 707
 708 freschedule-modulo-scheduled-loops
 709 Common Report Var(flag_resched_modulo_sched) Optimization
 710 Enable/Disable the traditional scheduling in loops that already passed modulo scheduling
 711
 712 fnon-call-exceptions
 713 Common Report Var(flag_non_call_exceptions) Optimization
 714 Support synchronous non-call exceptions
 715
 716 fomit-frame-pointer
 717 Common Report Var(flag_omit_frame_pointer) Optimization
 718 When possible do not generate stack frames
 719
 720 fopenmp-ssa
 721 Common Report Var(flag_openmp_ssa)
 722 Expand OpenMP operations on SSA form
 723
 724 foptimize-register-move
 725 Common Report Var(flag_regmove) Optimization
 726 Do the full register move optimization pass
 727
 728 foptimize-sibling-calls
 729 Common Report Var(flag_optimize_sibling_calls) Optimization
 730 Optimize sibling and tail recursive calls
 731
 732 fpre-ipa-mem-report
 733 Common Report Var(pre_ipa_mem_report)
 734 Report on memory allocation before interprocedural optimization
 735
 736 fpost-ipa-mem-report
 737 Common Report Var(post_ipa_mem_report)
 738 Report on memory allocation before interprocedural optimization
 739
 740 fpack-struct
 741 Common Report Var(flag_pack_struct) Optimization
 742 Pack structure members together without holes
 743
 744 fpack-struct=
 745 Common RejectNegative Joined UInteger Optimization
 746 -fpack-struct=<number>  Set initial maximum structure member alignment
 747
 748 fpcc-struct-return
 749 Common Report Var(flag_pcc_struct_return,1) VarExists
 750 Return small aggregates in memory, not registers
 751
 752 fpeel-loops
 753 Common Report Var(flag_peel_loops) Optimization
 754 Perform loop peeling
 755
 756 fpeephole
 757 Common Report Var(flag_no_peephole,0) Optimization
 758 Enable machine specific peephole optimizations
 759
 760 fpeephole2
 761 Common Report Var(flag_peephole2) Optimization
 762 Enable an RTL peephole pass before sched2
 763
 764 fPIC
 765 Common Report Var(flag_pic,2)
 766 Generate position-independent code if possible (large mode)
 767
 768 fPIE
 769 Common Report Var(flag_pie,2)
 770 Generate position-independent code for executables if possible (large mode)
 771
 772 fpic
 773 Common Report Var(flag_pic,1) VarExists
 774 Generate position-independent code if possible (small mode)
 775
 776 fpie
 777 Common Report Var(flag_pie,1) VarExists
 778 Generate position-independent code for executables if possible (small mode)
 779
 780 fpredictive-commoning
 781 Common Report Var(flag_predictive_commoning) Optimization
 782 Run predictive commoning optimization.
 783
 784 fprefetch-loop-arrays
 785 Common Report Var(flag_prefetch_loop_arrays) Optimization
 786 Generate prefetch instructions, if available, for arrays in loops
 787
 788 fprofile
 789 Common Report Var(profile_flag)
 790 Enable basic program profiling code
 791
 792 fprofile-arcs
 793 Common Report Var(profile_arc_flag)
 794 Insert arc-based program profiling code
 795
 796 fprofile-generate
 797 Common
 798 Enable common options for generating profile info for profile feedback directed optimizations
 799
 800 fprofile-use
 801 Common
 802 Enable common options for performing profile feedback directed optimizations
 803
 804 fprofile-values
 805 Common Report Var(flag_profile_values)
 806 Insert code to profile values of expressions
 807
 808 frandom-seed
 809 Common
 810
 811 frandom-seed=
 812 Common Joined RejectNegative
 813 -frandom-seed=<string>  Make compile reproducible using <string>
 814
 815 ; This switch causes the command line that was used to create an
 816 ; object file to be recorded into the object file.  The exact format
 817 ; of this recording is target and binary file format dependent.
 818 ; It is related to the -fverbose-asm switch, but that switch only
 819 ; records information in the assembler output file as comments, so
 820 ; they never reach the object file.
 821 frecord-gcc-switches
 822 Common Report Var(flag_record_gcc_switches)
 823 Record gcc command line switches in the object file.
 824
 825 freg-struct-return
 826 Common Report Var(flag_pcc_struct_return,0) VarExists Optimization
 827 Return small aggregates in registers
 828
 829 fregmove
 830 Common Report Var(flag_regmove) Optimization
 831 Enables a register move optimization
 832
 833 frename-registers
 834 Common Report Var(flag_rename_registers) Init(2) Optimization
 835 Perform a register renaming optimization pass
 836
 837 freorder-blocks
 838 Common Report Var(flag_reorder_blocks) Optimization
 839 Reorder basic blocks to improve code placement
 840
 841 freorder-blocks-and-partition
 842 Common Report Var(flag_reorder_blocks_and_partition) Optimization
 843 Reorder basic blocks and partition into hot and cold sections
 844
 845 freorder-functions
 846 Common Report Var(flag_reorder_functions) Optimization
 847 Reorder functions to improve code placement
 848
 849 frerun-cse-after-loop
 850 Common Report Var(flag_rerun_cse_after_loop) Init(2) Optimization
 851 Add a common subexpression elimination pass after loop optimizations
 852
 853 frerun-loop-opt
 854 Common
 855 Does nothing.  Preserved for backward compatibility.
 856
 857 frounding-math
 858 Common Report Var(flag_rounding_math) Optimization
 859 Disable optimizations that assume default FP rounding behavior
 860
 861 fsched-interblock
 862 Common Report Var(flag_schedule_interblock) Init(1) Optimization
 863 Enable scheduling across basic blocks
 864
 865 fsched-spec
 866 Common Report Var(flag_schedule_speculative) Init(1) Optimization
 867 Allow speculative motion of non-loads
 868
 869 fsched-spec-load
 870 Common Report Var(flag_schedule_speculative_load) Optimization
 871 Allow speculative motion of some loads
 872
 873 fsched-spec-load-dangerous
 874 Common Report Var(flag_schedule_speculative_load_dangerous) Optimization
 875 Allow speculative motion of more loads
 876
 877 fsched-verbose=
 878 Common RejectNegative Joined
 879 -fsched-verbose=<number>        Set the verbosity level of the scheduler
 880
 881 fsched2-use-superblocks
 882 Common Report Var(flag_sched2_use_superblocks) Optimization
 883 If scheduling post reload, do superblock scheduling
 884
 885 fsched2-use-traces
 886 Common Report Var(flag_sched2_use_traces) Optimization
 887 If scheduling post reload, do trace scheduling
 888
 889 fschedule-insns
 890 Common Report Var(flag_schedule_insns) Optimization
 891 Reschedule instructions before register allocation
 892
 893 fschedule-insns2
 894 Common Report Var(flag_schedule_insns_after_reload) Optimization
 895 Reschedule instructions after register allocation
 896
 897 ; sched_stalled_insns means that insns can be moved prematurely from the queue
 898 ; of stalled insns into the ready list.
 899 fsched-stalled-insns
 900 Common Report Var(flag_sched_stalled_insns) Optimization
 901 Allow premature scheduling of queued insns
 902
 903 fsched-stalled-insns=
 904 Common RejectNegative Joined UInteger
 905 -fsched-stalled-insns=<number>  Set number of queued insns that can be prematurely scheduled
 906
 907 ; sched_stalled_insns_dep controls how many recently scheduled cycles will
 908 ; be examined for a dependency on a stalled insn that is candidate for
 909 ; premature removal from the queue of stalled insns into the ready list (has
 910 ; an effect only if the flag 'sched_stalled_insns' is set).
 911 fsched-stalled-insns-dep
 912 Common Report Var(flag_sched_stalled_insns_dep,1) Init(1) Optimization
 913 Set dependence distance checking in premature scheduling of queued insns
 914
 915 fsched-stalled-insns-dep=
 916 Common RejectNegative Joined UInteger
 917 -fsched-stalled-insns-dep=<number>      Set dependence distance checking in premature scheduling of queued insns
 918
 919 fsection-anchors
 920 Common Report Var(flag_section_anchors) Optimization
 921 Access data in the same section from shared anchor points
 922
 923 frtl-abstract-sequences
 924 Common Report Var(flag_rtl_seqabstr) Optimization
 925 Perform sequence abstraction optimization on RTL
 926
 927 fsee
 928 Common Report Var(flag_see) Init(0)
 929 Eliminate redundant sign extensions using LCM.
 930
 931 fshow-column
 932 Common C ObjC C++ ObjC++ Report Var(flag_show_column) Init(0)
 933 Show column numbers in diagnostics, when available.  Default off
 934
 935 fsignaling-nans
 936 Common Report Var(flag_signaling_nans) Optimization
 937 Disable optimizations observable by IEEE signaling NaNs
 938
 939 fsigned-zeros
 940 Common Report Var(flag_signed_zeros) Init(1) Optimization
 941 Disable floating point optimizations that ignore the IEEE signedness of zero
 942
 943 fsingle-precision-constant
 944 Common Report Var(flag_single_precision_constant) Optimization
 945 Convert floating point constants to single precision constants
 946
 947 fsplit-ivs-in-unroller
 948 Common Report Var(flag_split_ivs_in_unroller) Init(1) Optimization
 949 Split lifetimes of induction variables when loops are unrolled
 950
 951 fsplit-wide-types
 952 Common Report Var(flag_split_wide_types) Optimization
 953 Split wide types into independent registers
 954
 955 fvariable-expansion-in-unroller
 956 Common Report Var(flag_variable_expansion_in_unroller) Optimization
 957 Apply variable expansion when loops are unrolled
 958
 959 ; Emit code to probe the stack, to help detect stack overflow; also
 960 ; may cause large objects to be allocated dynamically.
 961 fstack-check
 962 Common Report Var(flag_stack_check)
 963 Insert stack checking code into the program
 964
 965 fstack-limit
 966 Common
 967
 968 fstack-limit-register=
 969 Common RejectNegative Joined
 970 -fstack-limit-register=<register>       Trap if the stack goes past <register>
 971
 972 fstack-limit-symbol=
 973 Common RejectNegative Joined
 974 -fstack-limit-symbol=<name>     Trap if the stack goes past symbol <name>
 975
 976 fstack-protector
 977 Common Report Var(flag_stack_protect, 1)
 978 Use propolice as a stack protection method
 979
 980 fstack-protector-all
 981 Common Report RejectNegative Var(flag_stack_protect, 2) VarExists
 982 Use a stack protection method for every function
 983
 984 fstrength-reduce
 985 Common
 986 Does nothing.  Preserved for backward compatibility.
 987
 988 ; Nonzero if we should do (language-dependent) alias analysis.
 989 ; Typically, this analysis will assume that expressions of certain
 990 ; types do not alias expressions of certain other types.  Only used
 991 ; if alias analysis (in general) is enabled.
 992 fstrict-aliasing
 993 Common Report Var(flag_strict_aliasing) Optimization
 994 Assume strict aliasing rules apply
 995
 996 fstrict-overflow
 997 Common Report Var(flag_strict_overflow)
 998 Treat signed overflow as undefined
 999
1000 fsyntax-only
1001 Common Report Var(flag_syntax_only)
1002 Check for syntax errors, then stop
1003
1004 ftest-coverage
1005 Common Report Var(flag_test_coverage)
1006 Create data files needed by \"gcov\"
1007
1008 fthread-jumps
1009 Common Report Var(flag_thread_jumps) Optimization
1010 Perform jump threading optimizations
1011
1012 ftime-report
1013 Common Report Var(time_report)
1014 Report the time taken by each compiler pass
1015
1016 ftls-model=
1017 Common Joined RejectNegative
1018 -ftls-model=[global-dynamic|local-dynamic|initial-exec|local-exec]      Set the default thread-local storage code generation model
1019
1020 ftoplevel-reorder
1021 Common Report Var(flag_toplevel_reorder) Init(1) Optimization
1022 Reorder top level functions, variables, and asms
1023
1024 ftracer
1025 Common Report Var(flag_tracer)
1026 Perform superblock formation via tail duplication
1027
1028 ; Zero means that floating-point math operations cannot generate a
1029 ; (user-visible) trap.  This is the case, for example, in nonstop
1030 ; IEEE 754 arithmetic.
1031 ftrapping-math
1032 Common Report Var(flag_trapping_math) Init(1) Optimization
1033 Assume floating-point operations can trap
1034
1035 ftrapv
1036 Common Report Var(flag_trapv) Optimization
1037 Trap for signed overflow in addition, subtraction and multiplication
1038
1039 ftree-ccp
1040 Common Report Var(flag_tree_ccp) Optimization
1041 Enable SSA-CCP optimization on trees
1042
1043 ftree-store-ccp
1044 Common Report Var(flag_tree_store_ccp) Optimization
1045 Enable SSA-CCP optimization for stores and loads
1046
1047 ftree-ch
1048 Common Report Var(flag_tree_ch) Optimization
1049 Enable loop header copying on trees
1050
1051 ftree-copyrename
1052 Common Report Var(flag_tree_copyrename) Optimization
1053 Replace SSA temporaries with better names in copies
1054
1055 ftree-copy-prop
1056 Common Report Var(flag_tree_copy_prop) Optimization
1057 Enable copy propagation on trees
1058
1059 ftree-store-copy-prop
1060 Common
1061 Does nothing.  Preserved for backward compatibility.
1062
1063 ftree-cselim
1064 Common Report Var(flag_tree_cselim) Init(2) Optimization
1065 Transform condition stores into unconditional ones
1066
1067 ftree-dce
1068 Common Report Var(flag_tree_dce) Optimization
1069 Enable SSA dead code elimination optimization on trees
1070
1071 ftree-dominator-opts
1072 Common Report Var(flag_tree_dom) Optimization
1073 Enable dominator optimizations
1074
1075 ftree-dse
1076 Common Report Var(flag_tree_dse) Optimization
1077 Enable dead store elimination
1078
1079 ftree-fre
1080 Common Report Var(flag_tree_fre) Optimization
1081 Enable Full Redundancy Elimination (FRE) on trees
1082
1083 ftree-loop-im
1084 Common Report Var(flag_tree_loop_im) Init(1) Optimization
1085 Enable loop invariant motion on trees
1086
1087 ftree-loop-linear
1088 Common Report Var(flag_tree_loop_linear) Optimization
1089 Enable linear loop transforms on trees
1090
1091 ftree-loop-ivcanon
1092 Common Report Var(flag_tree_loop_ivcanon) Init(1) Optimization
1093 Create canonical induction variables in loops
1094
1095 ftree-loop-optimize
1096 Common Report Var(flag_tree_loop_optimize) Init(1) Optimization
1097 Enable loop optimizations on tree level
1098
1099 ftree-parallelize-loops=
1100 Common Report Joined UInteger Var(flag_tree_parallelize_loops) Init(1)
1101 Enable automatic parallelization of loops
1102
1103 ftree-pre
1104 Common Report Var(flag_tree_pre) Optimization
1105 Enable SSA-PRE optimization on trees
1106
1107 ftree-reassoc
1108 Common Report Var(flag_tree_reassoc) Init(1) Optimization
1109 Enable reassociation on tree level
1110
1111 ftree-salias
1112 Common Report Var(flag_tree_salias) Optimization
1113 Perform structural alias analysis
1114
1115 ftree-sink
1116 Common Report Var(flag_tree_sink) Optimization
1117 Enable SSA code sinking on trees
1118
1119 ftree-sra
1120 Common Report Var(flag_tree_sra) Optimization
1121 Perform scalar replacement of aggregates
1122
1123 ftree-ter
1124 Common Report Var(flag_tree_ter) Optimization
1125 Replace temporary expressions in the SSA->normal pass
1126
1127 ftree-lrs
1128 Common Report Var(flag_tree_live_range_split) Optimization
1129 Perform live range splitting during the SSA->normal pass
1130
1131 ftree-vrp
1132 Common Report Var(flag_tree_vrp) Init(0) Optimization
1133 Perform Value Range Propagation on trees
1134
1135 funit-at-a-time
1136 Common Report Var(flag_unit_at_a_time) Optimization
1137 Compile whole compilation unit at a time
1138
1139 funroll-loops
1140 Common Report Var(flag_unroll_loops) Optimization
1141 Perform loop unrolling when iteration count is known
1142
1143 funroll-all-loops
1144 Common Report Var(flag_unroll_all_loops) Optimization
1145 Perform loop unrolling for all loops
1146
1147 ; Nonzero means that loop optimizer may assume that the induction variables
1148 ; that control loops do not overflow and that the loops with nontrivial
1149 ; exit condition are not infinite
1150 funsafe-loop-optimizations
1151 Common Report Var(flag_unsafe_loop_optimizations) Optimization
1152 Allow loop optimizations to assume that the loops behave in normal way
1153
1154 fassociative-math
1155 Common Report Var(flag_associative_math)
1156 Allow optimization for floating-point arithmetic which may change the
1157 result of the operation due to rounding.
1158
1159 freciprocal-math
1160 Common Report Var(flag_reciprocal_math)
1161 Same as -fassociative-math for expressions which include division.
1162
1163 ; Nonzero means that unsafe floating-point math optimizations are allowed
1164 ; for the sake of speed.  IEEE compliance is not guaranteed, and operations
1165 ; are allowed to assume that their arguments and results are "normal"
1166 ; (e.g., nonnegative for SQRT).
1167 funsafe-math-optimizations
1168 Common Report Var(flag_unsafe_math_optimizations) Optimization
1169 Allow math optimizations that may violate IEEE or ISO standards
1170
1171 funswitch-loops
1172 Common Report Var(flag_unswitch_loops) Optimization
1173 Perform loop unswitching
1174
1175 funwind-tables
1176 Common Report Var(flag_unwind_tables) Optimization
1177 Just generate unwind tables for exception handling
1178
1179 fvar-tracking
1180 Common Report Var(flag_var_tracking) VarExists Optimization
1181 Perform variable tracking
1182
1183 fvar-tracking-uninit
1184 Common Report Var(flag_var_tracking_uninit) Optimization
1185 Perform variable tracking and also tag variables that are uninitialized
1186
1187 ftree-vectorize
1188 Common Report Var(flag_tree_vectorize) Optimization
1189 Enable loop vectorization on trees
1190
1191 fvect-cost-model
1192 Common Report Var(flag_vect_cost_model) Optimization
1193 Enable use of cost model in vectorization
1194
1195 ftree-vect-loop-version
1196 Common Report Var(flag_tree_vect_loop_version) Init(1) Optimization
1197 Enable loop versioning when doing loop vectorization on trees
1198
1199 ftree-vectorizer-verbose=
1200 Common RejectNegative Joined
1201 -ftree-vectorizer-verbose=<number>      Set the verbosity level of the vectorizer
1202
1203 ftree-scev-cprop
1204 Common Report Var(flag_tree_scev_cprop) Init(1) Optimization
1205 Enable copy propagation of scalar-evolution information.
1206
1207 ; -fverbose-asm causes extra commentary information to be produced in
1208 ; the generated assembly code (to make it more readable).  This option
1209 ; is generally only of use to those who actually need to read the
1210 ; generated assembly code (perhaps while debugging the compiler itself).
1211 ; -fno-verbose-asm, the default, causes the extra information
1212 ; to not be added and is useful when comparing two assembler files.
1213 fverbose-asm
1214 Common Report Var(flag_verbose_asm)
1215 Add extra commentary to assembler output
1216
1217 fvisibility=
1218 Common Joined RejectNegative
1219 -fvisibility=[default|internal|hidden|protected]        Set the default symbol visibility
1220
1221
1222 fvpt
1223 Common Report Var(flag_value_profile_transformations) Optimization
1224 Use expression value profiles in optimizations
1225
1226 fweb
1227 Common Report Var(flag_web) Init(2) Optimization
1228 Construct webs and split unrelated uses of single variable
1229
1230 fwhole-program
1231 Common Report Var(flag_whole_program) Init(0) Optimization
1232 Perform whole program optimizations
1233
1234 fwrapv
1235 Common Report Var(flag_wrapv) Optimization
1236 Assume signed arithmetic overflow wraps around
1237
1238 fzero-initialized-in-bss
1239 Common Report Var(flag_zero_initialized_in_bss) Init(1)
1240 Put zero initialized data in the bss section
1241
1242 g
1243 Common JoinedOrMissing
1244 Generate debug information in default format
1245
1246 gcoff
1247 Common JoinedOrMissing Negative(gdwarf-2)
1248 Generate debug information in COFF format
1249
1250 gdwarf-2
1251 Common JoinedOrMissing Negative(gstabs)
1252 Generate debug information in DWARF v2 format
1253
1254 ggdb
1255 Common JoinedOrMissing
1256 Generate debug information in default extended format
1257
1258 gstabs
1259 Common JoinedOrMissing Negative(gstabs+)
1260 Generate debug information in STABS format
1261
1262 gstabs+
1263 Common JoinedOrMissing Negative(gvms)
1264 Generate debug information in extended STABS format
1265
1266 gvms
1267 Common JoinedOrMissing Negative(gxcoff)
1268 Generate debug information in VMS format
1269
1270 gxcoff
1271 Common JoinedOrMissing Negative(gxcoff+)
1272 Generate debug information in XCOFF format
1273
1274 gxcoff+
1275 Common JoinedOrMissing Negative(gcoff)
1276 Generate debug information in extended XCOFF format
1277
1278 o
1279 Common Joined Separate
1280 -o <file>       Place output into <file>
1281
1282 p
1283 Common Var(profile_flag)
1284 Enable function profiling
1285
1286 pedantic
1287 Common Var(pedantic)
1288 Issue warnings needed for strict compliance to the standard
1289
1290 pedantic-errors
1291 Common
1292 Like -pedantic but issue them as errors
1293
1294 quiet
1295 Common Var(quiet_flag)
1296 Do not display functions compiled or elapsed time
1297
1298 version
1299 Common Var(version_flag)
1300 Display the compiler's version
1301
1302 w
1303 Common Var(inhibit_warnings)
1304 Suppress warnings
1305
1306 shared
1307 Common RejectNegative Negative(pie)
1308 Create a shared library
1309
1310 pie
1311 Common RejectNegative Negative(shared)
1312 Create a position independent executable
1313
1314 ; This comment is to ensure we retain the blank line above.