OSDN Git Service

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