OSDN Git Service

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