forked from illumos/gcc
/
common.opt
1157 lines (886 loc) · 31.8 KB
/
common.opt
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
; Options for the language- and target-independent parts of the compiler.
; Copyright (C) 2003, 2004, 2005, 2006, 2007 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 3, 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 COPYING3. If not see
; <http://www.gnu.org/licenses/>.
; 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
Werror=
Common Joined
Treat specified warning as error
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
Wunsafe-loop-optimizations
Common Var(warn_unsafe_loop_optimizations)
Warn if the loop cannot be optimized due to nontrivial assumptions.
Wmissing-noreturn
Common Var(warn_missing_noreturn)
Warn about functions which might be candidates for __attribute__((noreturn))
Woverflow
Common Var(warn_overflow) Init(1)
Warn about overflow in arithmetic expressions
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
Wstack-protector
Common Var(warn_stack_protect)
Warn when not issuing stack smashing protection for some reason
Wstrict-aliasing
Common
Warn about code which might break strict aliasing rules
Wstrict-aliasing=
Common Joined UInteger Var(warn_strict_aliasing) Init(-1)
Warn about code which might break strict aliasing rules
Wstrict-overflow
Common
Warn about optimizations that assume that signed overflow is undefined
Wstrict-overflow=
Common Joined UInteger Var(warn_strict_overflow) Init(-1)
Warn about optimizations that assume that signed overflow is undefined
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
Wvolatile-register-var
Common Var(warn_register_var)
Warn when a register variable is declared volatile
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.
; 3 if pointer arguments may not alias anything. True in Fortran.
; Set by the front end.
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
fargument-noalias-anything
Common Report Var(flag_argument_noalias,3) VarExists
Assume arguments alias no other storage
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-noaddr
Common Report Var(flag_dump_noaddr)
Suppress output of addresses in debugging dumps
fdump-unnumbered
Common Report Var(flag_dump_unnumbered) VarExists
Suppress output of instruction numbers, line number notes and addresses in debugging dumps
fearly-inlining
Common Report Var(flag_early_inlining) Init(1)
Perform early inlining
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
femit-class-debug-always
Common Report Var(flag_emit_class_debug_always) Init(0)
Do not suppress C++ class debug information.
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-functions-called-once
Common Report Var(flag_inline_functions_called_once) Init(1)
Integrate functions called once 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
fipa-cp
Common Report Var(flag_ipa_cp)
Perform Interprocedural constant propagation
fipa-pure-const
Common Report Var(flag_ipa_pure_const) Init(0)
Discover pure and const functions
fipa-pta
Common Report Var(flag_ipa_pta) Init(0)
Perform interprocedural points-to analysis
fipa-reference
Common Report Var(flag_ipa_reference) Init(0)
Discover readonly and non addressable static variables
fipa-type-escape
Common Report Var(flag_ipa_type_escape) Init(0)
Type based escape and alias analysis
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
Does nothing. Preserved for backward compatibility.
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) Init(1)
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 VarExists Var(flag_mudflap,2)
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) Init(2)
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) Init(2)
Add a common subexpression elimination pass after loop optimizations
frerun-loop-opt
Common
Does nothing. Preserved for backward compatibility.
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
fsection-anchors
Common Report Var(flag_section_anchors)
Access data in the same section from shared anchor points
frtl-abstract-sequences
Common Report Var(flag_rtl_seqabstr)
Perform sequence abstraction optimization on RTL
fsee
Common Report Var(flag_see) Init(0)
Eliminate redundant sign extensions using LCM.
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
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>
fstack-protector
Common Report Var(flag_stack_protect, 1)
Use propolice as a stack protection method
fstack-protector-all
Common Report RejectNegative Var(flag_stack_protect, 2) VarExists
Use a stack protection method for every function
fstrength-reduce
Common
Does nothing. Preserved for backward compatibility.
; 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
fstrict-overflow
Common Report Var(flag_strict_overflow)
Treat signed overflow as undefined
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
ftoplevel-reorder
Common Report Var(flag_toplevel_reorder) Init(1)
Reorder top level functions, variables, and asms
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-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)