summaryrefslogtreecommitdiff
path: root/gcc/common.opt
blob: 7b6aee109243a74dc3ccb06276af72015ca60f9d (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
; Options for the language- and target-independent parts of the compiler.

; Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
;
; This file is part of GCC.
;
; GCC is free software; you can redistribute it and/or modify it under
; the terms of the GNU General Public License as published by the Free
; Software Foundation; either version 2, or (at your option) any later
; version.
; 
; GCC is distributed in the hope that it will be useful, but WITHOUT ANY
; WARRANTY; without even the implied warranty of MERCHANTABILITY or
; FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
; for more details.
; 
; You should have received a copy of the GNU General Public License
; along with GCC; see the file COPYING.  If not, write to the Free
; Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
; 02110-1301, USA.

; See the GCC internals manual for a description of this file's format.

; Please try to keep this file in ASCII collating order.

-help
Common
Display this information

-param
Common Separate
--param <param>=<value>	Set parameter <param> to value.  See below for a complete list of parameters

-target-help
Common

-version
Common

G
Common Joined Separate UInteger
-G<number>	Put global and static data smaller than <number> bytes into a special section (on some targets)

O
Common JoinedOrMissing
-O<number>	Set optimization level to <number>

Os
Common
Optimize for space rather than speed

W
Common RejectNegative
This switch is deprecated; use -Wextra instead

Waggregate-return
Common Var(warn_aggregate_return)
Warn about returning structures, unions or arrays

Wattributes
Common Var(warn_attributes) Init(1)
Warn about inappropriate attribute usage

Wcast-align
Common Var(warn_cast_align)
Warn about pointer casts which increase alignment

Wdeprecated-declarations
Common Var(warn_deprecated_decl) Init(1)
Warn about uses of __attribute__((deprecated)) declarations

Wdisabled-optimization
Common Var(warn_disabled_optimization)
Warn when an optimization pass is disabled

Werror
Common Var(warnings_are_errors)
Treat all warnings as errors

Wextra
Common
Print extra (possibly unwanted) warnings

Wfatal-errors
Common Var(flag_fatal_errors)
Exit on the first error occurred

Winline
Common Var(warn_inline)
Warn when an inlined function cannot be inlined

Wlarger-than-
Common RejectNegative Joined UInteger
-Wlarger-than-<number>	Warn if an object is larger than <number> bytes

Wmissing-noreturn
Common Var(warn_missing_noreturn)
Warn about functions which might be candidates for __attribute__((noreturn))

Wpacked
Common Var(warn_packed)
Warn when the packed attribute has no effect on struct layout

Wpadded
Common Var(warn_padded)
Warn when padding is required to align structure members

Wshadow
Common Var(warn_shadow)
Warn when one local variable shadows another

Wstrict-aliasing
Common
Warn about code which might break strict aliasing rules

Wstrict-aliasing=
Common Joined UInteger
Warn about code which might break strict aliasing rules

Wswitch
Common Var(warn_switch)
Warn about enumerated switches, with no default, missing a case

Wswitch-default
Common Var(warn_switch_default)
Warn about enumerated switches missing a \"default:\" statement

Wswitch-enum
Common Var(warn_switch_enum)
Warn about all enumerated switches missing a specific case

Wsystem-headers
Common Var(warn_system_headers)
Do not suppress warnings from system headers

Wuninitialized
Common Var(warn_uninitialized)
Warn about uninitialized automatic variables

Wunreachable-code
Common Var(warn_notreached)
Warn about code that will never be executed

Wunused
Common
Enable all -Wunused- warnings

Wunused-function
Common Var(warn_unused_function)
Warn when a function is unused

Wunused-label
Common Var(warn_unused_label)
Warn when a label is unused

Wunused-parameter
Common Var(warn_unused_parameter)
Warn when a function parameter is unused

Wunused-value
Common Var(warn_unused_value)
Warn when an expression value is unused

Wunused-variable
Common Var(warn_unused_variable)
Warn when a variable is unused

aux-info
Common Separate
-aux-info <file>	Emit declaration information into <file>

aux-info=
Common Joined

auxbase
Common Separate

auxbase-strip
Common Separate

d
Common Joined
-d<letters>	Enable dumps from specific passes of the compiler

dumpbase
Common Separate
-dumpbase <file>	Set the file basename to be used for dumps

; The version of the C++ ABI in use.  The following values are allowed:
;
; 0: The version of the ABI believed most conformant with the C++ ABI
;    specification.  This ABI may change as bugs are discovered and fixed.
;    Therefore, 0 will not necessarily indicate the same ABI in different
;    versions of G++.
;
; 1: The version of the ABI first used in G++ 3.2.
;
; Additional positive integers will be assigned as new versions of
; the ABI become the default version of the ABI.
fabi-version=
Common Joined UInteger Var(flag_abi_version) Init(2)

falign-functions
Common Report Var(align_functions,0)
Align the start of functions

falign-functions=
Common RejectNegative Joined UInteger

falign-jumps
Common Report Var(align_jumps,0)
Align labels which are only reached by jumping

falign-jumps=
Common RejectNegative Joined UInteger

falign-labels
Common Report Var(align_labels,0)
Align all labels

falign-labels=
Common RejectNegative Joined UInteger

falign-loops
Common Report Var(align_loops)
Align the start of loops

falign-loops=
Common RejectNegative Joined UInteger

; This flag is only tested if alias checking is enabled.
; 0 if pointer arguments may alias each other.  True in C.
; 1 if pointer arguments may not alias each other but may alias
;   global variables.
; 2 if pointer arguments may not alias each other and may not
;   alias global variables.  True in Fortran.
fargument-alias
Common Report Var(flag_argument_noalias,0)
Specify that arguments may alias each other and globals

fargument-noalias
Common Report Var(flag_argument_noalias,1) VarExists
Assume arguments may alias globals but not each other

fargument-noalias-global
Common Report Var(flag_argument_noalias,2) VarExists
Assume arguments alias neither each other nor globals

fasynchronous-unwind-tables
Common Report Var(flag_asynchronous_unwind_tables)
Generate unwind tables that are exact at each instruction boundary

; -fcheck-bounds causes gcc to generate array bounds checks.
; For C, C++ and ObjC: defaults off.
; For Java: defaults to on.
; For Fortran: defaults to off.
fbounds-check
Common Report Var(flag_bounds_check)
Generate code to check bounds before indexing arrays

fbranch-count-reg
Common Report Var(flag_branch_on_count_reg) Init(1)
Replace add, compare, branch with branch on count register

fbranch-probabilities
Common Report Var(flag_branch_probabilities)
Use profiling information for branch probabilities

fbranch-target-load-optimize
Common Report Var(flag_branch_target_load_optimize)
Perform branch target load optimization before prologue / epilogue threading

fbranch-target-load-optimize2
Common Report Var(flag_branch_target_load_optimize2)
Perform branch target load optimization after prologue / epilogue threading

fbtr-bb-exclusive
Common Report Var(flag_btr_bb_exclusive)
Restrict target load migration not to re-use registers in any basic block

fcall-saved-
Common Joined RejectNegative
-fcall-saved-<register>	Mark <register> as being preserved across functions

fcall-used-
Common Joined RejectNegative
-fcall-used-<register>	Mark <register> as being corrupted by function calls

; Nonzero for -fcaller-saves: allocate values in regs that need to
; be saved across function calls, if that produces overall better code.
; Optional now, so people can test it.
fcaller-saves
Common Report Var(flag_caller_saves)
Save registers around function calls

fcommon
Common Report Var(flag_no_common,0)
Do not put uninitialized globals in the common section

fcprop-registers
Common Report Var(flag_cprop_registers)
Perform a register copy-propagation optimization pass

fcrossjumping
Common Report Var(flag_crossjumping)
Perform cross-jumping optimization

fcse-follow-jumps
Common Report Var(flag_cse_follow_jumps)
When running CSE, follow jumps to their targets

fcse-skip-blocks
Common Report Var(flag_cse_skip_blocks)
When running CSE, follow conditional jumps

fcx-limited-range
Common Report Var(flag_cx_limited_range)
Omit range reduction step when performing complex division

fdata-sections
Common Report Var(flag_data_sections)
Place data items into their own section

; Nonzero for -fdefer-pop: don't pop args after each function call
; instead save them up to pop many calls' args with one insns.
fdefer-pop
Common Report Var(flag_defer_pop)
Defer popping functions args from stack until later

fdelayed-branch
Common Report Var(flag_delayed_branch)
Attempt to fill delay slots of branch instructions

fdelete-null-pointer-checks
Common Report Var(flag_delete_null_pointer_checks)
Delete useless null pointer checks

fdiagnostics-show-location=
Common Joined RejectNegative
-fdiagnostics-show-location=[once|every-line]	How often to emit source location at the beginning of line-wrapped diagnostics

fdiagnostics-show-option
Common
Amend appropriate diagnostic messages with the command line option that controls them.

fdump-
Common Joined RejectNegative
-fdump-<type>	Dump various compiler internals to a file

fdump-unnumbered
Common Report Var(flag_dump_unnumbered) VarExists
Suppress output of instruction numbers and line number notes in debugging dumps

feliminate-dwarf2-dups
Common Report Var(flag_eliminate_dwarf2_dups)
Perform DWARF2 duplicate elimination

feliminate-unused-debug-symbols
Common Report Var(flag_debug_only_used_symbols)
Perform unused type elimination in debug info

feliminate-unused-debug-types
Common Report Var(flag_eliminate_unused_debug_types) Init(1)
Perform unused type elimination in debug info

fexceptions
Common Report Var(flag_exceptions)
Enable exception handling

fexpensive-optimizations
Common Report Var(flag_expensive_optimizations)
Perform a number of minor, expensive optimizations

ffast-math
Common

ffinite-math-only
Common Report Var(flag_finite_math_only)
Assume no NaNs or infinities are generated

ffixed-
Common Joined RejectNegative
-ffixed-<register>	Mark <register> as being unavailable to the compiler

ffloat-store
Common Report Var(flag_float_store)
Don't allocate floats and doubles in extended-precision registers

; Nonzero for -fforce-addr: load memory address into a register before
; reference to memory.  This makes better cse but slower compilation.
fforce-addr
Common Report Var(flag_force_addr)
Copy memory address constants into registers before use

; Nonzero for -fforce-mem: load memory value into a register
; before arithmetic on it.  This makes better cse but slower compilation.
fforce-mem
Common Report Var(flag_force_mem)
Copy memory operands into registers before use

; Nonzero means don't put addresses of constant functions in registers.
; Used for compiling the Unix kernel, where strange substitutions are
; done on the assembly output.
ffunction-cse
Common Report Var(flag_no_function_cse,0)
Allow function addresses to be held in registers

ffunction-sections
Common Report Var(flag_function_sections)
Place each function into its own section

fgcse
Common Report Var(flag_gcse)
Perform global common subexpression elimination

fgcse-lm
Common Report Var(flag_gcse_lm) Init(1)
Perform enhanced load motion during global common subexpression elimination

fgcse-sm
Common Report Var(flag_gcse_sm) Init(0)
Perform store motion after global common subexpression elimination

fgcse-las
Common Report Var(flag_gcse_las) Init(0)
Perform redundant load after store elimination in global common subexpression
elimination

fgcse-after-reload
Common Report Var(flag_gcse_after_reload)
Perform global common subexpression elimination after register allocation
has finished.

fguess-branch-probability
Common Report Var(flag_guess_branch_prob)
Enable guessing of branch probabilities

; Nonzero means ignore `#ident' directives.  0 means handle them.
; Generate position-independent code for executables if possible
; On SVR4 targets, it also controls whether or not to emit a
; string identifying the compiler.
fident
Common Report Var(flag_no_ident,0)
Process #ident directives

fif-conversion
Common Report Var(flag_if_conversion)
Perform conversion of conditional jumps to branchless equivalents

fif-conversion2
Common Report Var(flag_if_conversion2)
Perform conversion of conditional jumps to conditional execution

; -finhibit-size-directive inhibits output of .size for ELF.
; This is used only for compiling crtstuff.c,
; and it may be extended to other effects
; needed for crtstuff.c on other systems.
finhibit-size-directive
Common Report Var(flag_inhibit_size_directive)
Do not generate .size directives

; Nonzero means that functions declared `inline' will be treated
; as `static'.  Prevents generation of zillions of copies of unused
; static inline functions; instead, `inlines' are written out
; only when actually used.  Used in conjunction with -g.  Also
; does the right thing with #pragma interface.
finline
Common Report Var(flag_no_inline,0) Init(2)
Pay attention to the \"inline\" keyword

finline-functions
Common Report Var(flag_inline_functions)
Integrate simple functions into their callers

finline-limit-
Common RejectNegative Joined UInteger

finline-limit=
Common RejectNegative Joined UInteger
-finline-limit=<number>	Limit the size of inlined functions to <number>

finstrument-functions
Common Report Var(flag_instrument_function_entry_exit)
Instrument function entry and exit with profiling calls

fivopts
Common Report Var(flag_ivopts) Init(1)
Optimize induction variables on trees

fjump-tables
Common Var(flag_jump_tables) Init(1)
Use jump tables for sufficiently large switch statements

fkeep-inline-functions
Common Report Var(flag_keep_inline_functions)
Generate code for functions even if they are fully inlined

fkeep-static-consts
Common Report Var(flag_keep_static_consts) Init(1)
Emit static const variables even if they are not used

fleading-underscore
Common Report Var(flag_leading_underscore) Init(-1)
Give external symbols a leading underscore

floop-optimize
Common Report Var(flag_loop_optimize)
Perform loop optimizations

floop-optimize2
Common Report Var(flag_loop_optimize2)
Perform loop optimizations using the new loop optimizer

fmath-errno
Common Report Var(flag_errno_math) Init(1)
Set errno after built-in math functions

fmem-report
Common Report Var(mem_report)
Report on permanent memory allocation

; This will attempt to merge constant section constants, if 1 only
; string constants and constants from constant pool, if 2 also constant
; variables.
fmerge-all-constants
Common Report Var(flag_merge_constants,2) Init(1)
Attempt to merge identical constants and constant variables

fmerge-constants
Common Report Var(flag_merge_constants,1) VarExists
Attempt to merge identical constants across compilation units

fmessage-length=
Common RejectNegative Joined UInteger
-fmessage-length=<number>	Limit diagnostics to <number> characters per line.  0 suppresses line-wrapping

fmodulo-sched
Common Report Var(flag_modulo_sched)
Perform SMS based modulo scheduling before the first scheduling pass

fmove-loop-invariants
Common Report Var(flag_move_loop_invariants)
Move loop invariant computations out of loops

fmudflap
Common RejectNegative Report Var(flag_mudflap)
Add mudflap bounds-checking instrumentation for single-threaded program.

fmudflapth
Common RejectNegative Report Var(flag_mudflap_threads)
Add mudflap bounds-checking instrumentation for multi-threaded program.

fmudflapir
Common RejectNegative Report Var(flag_mudflap_ignore_reads)
Ignore read operations when inserting mudflap instrumentation.

freschedule-modulo-scheduled-loops
Common Report Var(flag_resched_modulo_sched)
Enable/Disable the traditional scheduling in loops that already passed modulo scheduling

fnon-call-exceptions
Common Report Var(flag_non_call_exceptions)
Support synchronous non-call exceptions

fomit-frame-pointer
Common Report Var(flag_omit_frame_pointer)
When possible do not generate stack frames

foptimize-register-move
Common Report Var(flag_regmove)
Do the full register move optimization pass

foptimize-sibling-calls
Common Report Var(flag_optimize_sibling_calls)
Optimize sibling and tail recursive calls

fpack-struct
Common Report Var(flag_pack_struct)
Pack structure members together without holes

fpack-struct=
Common RejectNegative Joined UInteger
-fpack-struct=<number>	Set initial maximum structure member alignment

fpcc-struct-return
Common Report Var(flag_pcc_struct_return,1) VarExists
Return small aggregates in memory, not registers

fpeel-loops
Common Report Var(flag_peel_loops)
Perform loop peeling

fpeephole
Common Report Var(flag_no_peephole,0)
Enable machine specific peephole optimizations

fpeephole2
Common Report Var(flag_peephole2)
Enable an RTL peephole pass before sched2

fPIC
Common Report Var(flag_pic,2)
Generate position-independent code if possible (large mode)

fPIE
Common Report Var(flag_pie,2)
Generate position-independent code for executables if possible (large mode)

fpic
Common Report Var(flag_pic,1) VarExists
Generate position-independent code if possible (small mode)

fpie
Common Report Var(flag_pie,1) VarExists
Generate position-independent code for executables if possible (small mode)

fprefetch-loop-arrays
Common Report Var(flag_prefetch_loop_arrays)
Generate prefetch instructions, if available, for arrays in loops

fprofile
Common Report Var(profile_flag)
Enable basic program profiling code

fprofile-arcs
Common Report Var(profile_arc_flag)
Insert arc-based program profiling code

fprofile-generate
Common
Enable common options for generating profile info for profile feedback directed optimizations

fprofile-use
Common
Enable common options for performing profile feedback directed optimizations

fprofile-values
Common Report Var(flag_profile_values)
Insert code to profile values of expressions

frandom-seed
Common

frandom-seed=
Common Joined RejectNegative
-frandom-seed=<string>	Make compile reproducible using <string>

freg-struct-return
Common Report Var(flag_pcc_struct_return,0) VarExists
Return small aggregates in registers

fregmove
Common Report Var(flag_regmove)
Enables a register move optimization

frename-registers
Common Report Var(flag_rename_registers)
Perform a register renaming optimization pass

freorder-blocks
Common Report Var(flag_reorder_blocks)
Reorder basic blocks to improve code placement

freorder-blocks-and-partition
Common Report Var(flag_reorder_blocks_and_partition)
Reorder basic blocks and partition into hot and cold sections

freorder-functions
Common Report Var(flag_reorder_functions)
Reorder functions to improve code placement

frerun-cse-after-loop
Common Report Var(flag_rerun_cse_after_loop)
Add a common subexpression elimination pass after loop optimizations

frerun-loop-opt
Common Report Var(flag_rerun_loop_opt)
Run the loop optimizer twice

frounding-math
Common Report Var(flag_rounding_math)
Disable optimizations that assume default FP rounding behavior

fsched-interblock
Common Report Var(flag_schedule_interblock) Init(1)
Enable scheduling across basic blocks

fsched-spec
Common Report Var(flag_schedule_speculative) Init(1)
Allow speculative motion of non-loads

fsched-spec-load
Common Report Var(flag_schedule_speculative_load)
Allow speculative motion of some loads

fsched-spec-load-dangerous
Common Report Var(flag_schedule_speculative_load_dangerous)
Allow speculative motion of more loads

fsched-verbose=
Common RejectNegative Joined
-fsched-verbose=<number>	Set the verbosity level of the scheduler

fsched2-use-superblocks
Common Report Var(flag_sched2_use_superblocks)
If scheduling post reload, do superblock scheduling

fsched2-use-traces
Common Report Var(flag_sched2_use_traces)
If scheduling post reload, do trace scheduling

fschedule-insns
Common Report Var(flag_schedule_insns)
Reschedule instructions before register allocation

fschedule-insns2
Common Report Var(flag_schedule_insns_after_reload)
Reschedule instructions after register allocation

; sched_stalled_insns means that insns can be moved prematurely from the queue
; of stalled insns into the ready list.
fsched-stalled-insns
Common Report Var(flag_sched_stalled_insns)
Allow premature scheduling of queued insns

fsched-stalled-insns=
Common RejectNegative Joined UInteger 
-fsched-stalled-insns=<number>	Set number of queued insns that can be prematurely scheduled

; sched_stalled_insns_dep controls how many recently scheduled cycles will
; be examined for a dependency on a stalled insn that is candidate for
; premature removal from the queue of stalled insns into the ready list (has
; an effect only if the flag 'sched_stalled_insns' is set).
fsched-stalled-insns-dep
Common Report Var(flag_sched_stalled_insns_dep,1) Init(1)
Set dependence distance checking in premature scheduling of queued insns

fsched-stalled-insns-dep=
Common RejectNegative Joined UInteger
-fsched-stalled-insns-dep=<number>	Set dependence distance checking in premature scheduling of queued insns

fshared-data
Common Report Var(flag_shared_data)
Mark data as shared rather than private

fshow-column
Common C ObjC C++ ObjC++ Report Var(flag_show_column) Init(1)
Show column numbers in diagnostics, when available.  Default on.

fsignaling-nans
Common Report Var(flag_signaling_nans)
Disable optimizations observable by IEEE signaling NaNs

fsingle-precision-constant
Common Report Var(flag_single_precision_constant)
Convert floating point constants to single precision constants

fspeculative-prefetching
Common Report Var(flag_speculative_prefetching)
Use value profiling for speculative prefetching

fsplit-ivs-in-unroller
Common Report Var(flag_split_ivs_in_unroller) Init(1)
Split lifetimes of induction variables when loops are unrolled.

fvariable-expansion-in-unroller
Common Report Var(flag_variable_expansion_in_unroller) 
Apply variable expansion when loops are unrolled.

; Emit code to probe the stack, to help detect stack overflow; also
; may cause large objects to be allocated dynamically.
fstack-check
Common Report Var(flag_stack_check)
Insert stack checking code into the program

fstack-limit
Common

fstack-limit-register=
Common RejectNegative Joined
-fstack-limit-register=<register>	Trap if the stack goes past <register>

fstack-limit-symbol=
Common RejectNegative Joined
-fstack-limit-symbol=<name>	Trap if the stack goes past symbol <name>

fstrength-reduce
Common Report Var(flag_strength_reduce)
Perform strength reduction optimizations

; Nonzero if we should do (language-dependent) alias analysis.
; Typically, this analysis will assume that expressions of certain
; types do not alias expressions of certain other types.  Only used
; if alias analysis (in general) is enabled.
fstrict-aliasing
Common Report Var(flag_strict_aliasing)
Assume strict aliasing rules apply

fsyntax-only
Common Report Var(flag_syntax_only)
Check for syntax errors, then stop

ftest-coverage
Common Report Var(flag_test_coverage)
Create data files needed by \"gcov\"

fthread-jumps
Common Report Var(flag_thread_jumps)
Perform jump threading optimizations

ftime-report
Common Report Var(time_report)
Report the time taken by each compiler pass

ftls-model=
Common Joined RejectNegative
-ftls-model=[global-dynamic|local-dynamic|initial-exec|local-exec]	Set the default thread-local storage code generation model

ftracer
Common Report Var(flag_tracer)
Perform superblock formation via tail duplication

; Zero means that floating-point math operations cannot generate a
; (user-visible) trap.  This is the case, for example, in nonstop
; IEEE 754 arithmetic.
ftrapping-math
Common Report Var(flag_trapping_math) Init(1)
Assume floating-point operations can trap

ftrapv
Common Report Var(flag_trapv)
Trap for signed overflow in addition, subtraction and multiplication

ftree-based-profiling
Common Report Var(flag_tree_based_profiling)
Use tree-ssa based implementation of profiling

ftree-ccp
Common Report Var(flag_tree_ccp)
Enable SSA-CCP optimization on trees

ftree-store-ccp
Common Report Var(flag_tree_store_ccp)
Enable SSA-CCP optimization for stores and loads

ftree-ch
Common Report Var(flag_tree_ch)
Enable loop header copying on trees

ftree-combine-temps
Common Report Var(flag_tree_combine_temps)
Coalesce memory temporaries in the SSA->normal pass

ftree-copyrename
Common Report Var(flag_tree_copyrename)
Replace SSA temporaries with better names in copies.

ftree-copy-prop
Common Report Var(flag_tree_copy_prop)
Enable copy propagation on trees

ftree-store-copy-prop
Common Report Var(flag_tree_store_copy_prop)
Enable copy propagation for stores and loads

ftree-dce
Common Report Var(flag_tree_dce)
Enable SSA dead code elimination optimization on trees

ftree-dominator-opts
Common Report Var(flag_tree_dom)
Enable dominator optimizations

ftree-dse
Common Report Var(flag_tree_dse)
Enable dead store elimination

ftree-fre
Common Report Var(flag_tree_fre)
Enable Full Redundancy Elimination (FRE) on trees

ftree-loop-im
Common Report Var(flag_tree_loop_im) Init(1)
Enable loop invariant motion on trees

ftree-loop-linear
Common Report Var(flag_tree_loop_linear)
Enable linear loop transforms on trees

ftree-loop-ivcanon
Common Report Var(flag_tree_loop_ivcanon) Init(1)
Create canonical induction variables in loops

ftree-loop-optimize
Common Report Var(flag_tree_loop_optimize) Init(1)
Enable loop optimizations on tree level

ftree-pre
Common Report Var(flag_tree_pre)
Enable SSA-PRE optimization on trees

ftree-salias
Common Report Var(flag_tree_salias)
Perform structural alias analysis

ftree-sink
Common Report Var(flag_tree_sink)
Enable SSA code sinking on trees

ftree-sra
Common Report Var(flag_tree_sra)
Perform scalar replacement of aggregates

ftree-ter
Common Report Var(flag_tree_ter)
Replace temporary expressions in the SSA->normal pass

ftree-lrs
Common Report Var(flag_tree_live_range_split)
Perform live range splitting during the SSA->normal pass.

ftree-vrp
Common Report Var(flag_tree_vrp) Init(0)
Perform Value Range Propagation on trees

funit-at-a-time
Common Report Var(flag_unit_at_a_time)
Compile whole compilation unit at a time

funroll-loops
Common Report Var(flag_unroll_loops)
Perform loop unrolling when iteration count is known

funroll-all-loops
Common Report Var(flag_unroll_all_loops)
Perform loop unrolling for all loops

; Nonzero means that unsafe floating-point math optimizations are allowed
; for the sake of speed.  IEEE compliance is not guaranteed, and operations
; are allowed to assume that their arguments and results are "normal"
; (e.g., nonnegative for SQRT).
funsafe-math-optimizations
Common Report Var(flag_unsafe_math_optimizations)
Allow math optimizations that may violate IEEE or ISO standards

funswitch-loops
Common Report Var(flag_unswitch_loops)
Perform loop unswitching

funwind-tables
Common Report Var(flag_unwind_tables)
Just generate unwind tables for exception handling

fvar-tracking
Common Report Var(flag_var_tracking) VarExists
Perform variable tracking

ftree-vectorize
Common Report Var(flag_tree_vectorize)
Enable loop vectorization on trees

ftree-vectorizer-verbose=
Common RejectNegative Joined
-ftree-vectorizer-verbose=<number>	Set the verbosity level of the vectorizer

; -fverbose-asm causes extra commentary information to be produced in
; the generated assembly code (to make it more readable).  This option
; is generally only of use to those who actually need to read the
; generated assembly code (perhaps while debugging the compiler itself).
; -fno-verbose-asm, the default, causes the extra information
; to not be added and is useful when comparing two assembler files.
fverbose-asm
Common Report Var(flag_verbose_asm)
Add extra commentary to assembler output

fvisibility=
Common Joined RejectNegative
-fvisibility=[default|internal|hidden|protected]	Set the default symbol visibility


fvpt
Common Report Var(flag_value_profile_transformations)
Use expression value profiles in optimizations

fweb
Common Report Var(flag_web) Init(0)
Construct webs and split unrelated uses of single variable

fwhole-program
Common Report Var(flag_whole_program) Init(0)
Perform whole program optimizations

fwrapv
Common Report Var(flag_wrapv)
Assume signed arithmetic overflow wraps around

fzero-initialized-in-bss
Common Report Var(flag_zero_initialized_in_bss) Init(1)
Put zero initialized data in the bss section

g
Common JoinedOrMissing
Generate debug information in default format

gcoff
Common JoinedOrMissing
Generate debug information in COFF format

gdwarf-2
Common JoinedOrMissing
Generate debug information in DWARF v2 format

ggdb
Common JoinedOrMissing
Generate debug information in default extended format

gstabs
Common JoinedOrMissing
Generate debug information in STABS format

gstabs+
Common JoinedOrMissing
Generate debug information in extended STABS format

gvms
Common JoinedOrMissing
Generate debug information in VMS format

gxcoff
Common JoinedOrMissing
Generate debug information in XCOFF format

gxcoff+
Common JoinedOrMissing
Generate debug information in extended XCOFF format

o
Common Joined Separate
-o <file>	Place output into <file>

p
Common Var(profile_flag)
Enable function profiling

pedantic
Common Var(pedantic)
Issue warnings needed for strict compliance to the standard

pedantic-errors
Common
Like -pedantic but issue them as errors

quiet
Common Var(quiet_flag)
Do not display functions compiled or elapsed time

version
Common Var(version_flag)
Display the compiler's version

w
Common Var(inhibit_warnings)
Suppress warnings

; This comment is to ensure we retain the blank line above.