OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gcc-4.2.2/] [gcc/] [common.opt] - Blame information for rev 841

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.