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