1 ; Options for the language- and target-independent parts of the compiler.
3 ; Copyright (C) 2003, 2004 Free Software Foundation, Inc.
5 ; This file is part of GCC.
7 ; GCC is free software; you can redistribute it and/or modify it under
8 ; the terms of the GNU General Public License as published by the Free
9 ; Software Foundation; either version 2, or (at your option) any later
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
17 ; You should have received a copy of the GNU General Public License
18 ; along with GCC; see the file COPYING. If not, write to the Free
19 ; Software Foundation, 59 Temple Place - Suite 330, Boston, MA
22 ; See c.opt for a description of this file's format.
24 ; Please try to keep this file in ASCII collating order.
28 Display this information
32 --param <param>=<value> Set paramter <param> to value. See below for a complete list of parameters
41 Common Joined Separate UInteger
42 -G<number> Put global and static data smaller than <number> bytes into a special section (on some targets)
45 Common JoinedOrMissing
46 -O<number> Set optimization level to <number>
50 Optimize for space rather than speed
54 This switch is deprecated; use -Wextra instead
57 Common Var(warn_aggregate_return)
58 Warn about returning structures, unions or arrays
61 Common Var(warn_cast_align)
62 Warn about pointer casts which increase alignment
64 Wdeprecated-declarations
65 Common Var(warn_deprecated_decl) Init(1)
66 Warn about uses of __attribute__((deprecated)) declarations
68 Wdisabled-optimization
69 Common Var(warn_disabled_optimization)
70 Warn when an optimization pass is disabled
73 Common Var(warnings_are_errors)
74 Treat all warnings as errors
78 Print extra (possibly unwanted) warnings
81 Common Var(flag_fatal_errors)
82 Exit on the first error occurred
85 Common Var(warn_inline)
86 Warn when an inlined function cannot be inlined
89 Common RejectNegative Joined UInteger
90 -Wlarger-than-<number> Warn if an object is larger than <number> bytes
93 Common Var(warn_missing_noreturn)
94 Warn about functions which might be candidates for __attribute__((noreturn))
97 Common Var(warn_packed)
98 Warn when the packed attribute has no effect on struct layout
101 Common Var(warn_padded)
102 Warn when padding is required to align structure members
105 Common Var(warn_shadow)
106 Warn when one local variable shadows another
110 Warn about code which might break strict aliasing rules
113 Common Joined UInteger
114 Warn about code which might break strict aliasing rules
117 Common Var(warn_switch)
118 Warn about enumerated switches, with no default, missing a case
121 Common Var(warn_switch_default)
122 Warn about enumerated switches missing a \"default:\" statement
125 Common Var(warn_switch_enum)
126 Warn about all enumerated switches missing a specific case
129 Common Var(warn_system_headers)
130 Do not suppress warnings from system headers
133 Common Var(warn_uninitialized)
134 Warn about uninitialized automatic variables
137 Common Var(warn_notreached)
138 Warn about code that will never be executed
142 Enable all -Wunused- warnings
145 Common Var(warn_unused_function)
146 Warn when a function is unused
149 Common Var(warn_unused_label)
150 Warn when a label is unused
153 Common Var(warn_unused_parameter)
154 Warn when a function parameter is unused
157 Common Var(warn_unused_value)
158 Warn when an expression value is unused
161 Common Var(warn_unused_variable)
162 Warn when a variable is unused
166 -aux-info <file> Emit declaration information into <file>
179 -d<letters> Enable dumps from specific passes of the compiler
183 -dumpbase <file> Set the file basename to be used for dumps
185 ; The version of the C++ ABI in use. The following values are allowed:
187 ; 0: The version of the ABI believed most conformant with the C++ ABI
188 ; specification. This ABI may change as bugs are discovered and fixed.
189 ; Therefore, 0 will not necessarily indicate the same ABI in different
192 ; 1: The version of the ABI first used in G++ 3.2.
194 ; Additional positive integers will be assigned as new versions of
195 ; the ABI become the default version of the ABI.
197 Common Joined UInteger Var(flag_abi_version) Init(2)
200 Common Report Var(align_functions,0)
201 Align the start of functions
204 Common RejectNegative Joined UInteger
207 Common Report Var(align_jumps,0)
208 Align labels which are only reached by jumping
211 Common RejectNegative Joined UInteger
214 Common Report Var(align_labels,0)
218 Common RejectNegative Joined UInteger
221 Common Report Var(align_loops)
222 Align the start of loops
225 Common RejectNegative Joined UInteger
227 ; This flag is only tested if alias checking is enabled.
228 ; 0 if pointer arguments may alias each other. True in C.
229 ; 1 if pointer arguments may not alias each other but may alias
231 ; 2 if pointer arguments may not alias each other and may not
232 ; alias global variables. True in Fortran.
233 ; The value is ignored if flag_alias_check is 0.
235 Common Report Var(flag_argument_noalias,0)
236 Specify that arguments may alias each other and globals
239 Common Report Var(flag_argument_noalias,1) VarExists
240 Assume arguments may alias globals but not each other
242 fargument-noalias-global
243 Common Report Var(flag_argument_noalias,2) VarExists
244 Assume arguments alias neither each other nor globals
246 fasynchronous-unwind-tables
247 Common Report Var(flag_asynchronous_unwind_tables)
248 Generate unwind tables that are exact at each instruction boundary
250 ; -fcheck-bounds causes gcc to generate array bounds checks.
251 ; For C, C++ and ObjC: defaults off.
252 ; For Java: defaults to on.
253 ; For Fortran: defaults to off.
255 Common Report Var(flag_bounds_check)
256 Generate code to check bounds before indexing arrays
259 Common Report Var(flag_branch_on_count_reg) Init(1)
260 Replace add, compare, branch with branch on count register
262 fbranch-probabilities
263 Common Report Var(flag_branch_probabilities)
264 Use profiling information for branch probabilities
266 fbranch-target-load-optimize
267 Common Report Var(flag_branch_target_load_optimize)
268 Perform branch target load optimization before prologue / epilogue threading
270 fbranch-target-load-optimize2
271 Common Report Var(flag_branch_target_load_optimize2)
272 Perform branch target load optimization after prologue / epilogue threading
275 Common Report Var(flag_btr_bb_exclusive)
276 Restrict target load migration not to re-use registers in any basic block
279 Common Joined RejectNegative
280 -fcall-saved-<register> Mark <register> as being preserved across functions
283 Common Joined RejectNegative
284 -fcall-used-<register> Mark <register> as being corrupted by function calls
286 ; Nonzero for -fcaller-saves: allocate values in regs that need to
287 ; be saved across function calls, if that produces overall better code.
288 ; Optional now, so people can test it.
290 Common Report Var(flag_caller_saves)
291 Save registers around function calls
294 Common Report Var(flag_no_common,0)
295 Do not put uninitialized globals in the common section
298 Common Report Var(flag_cprop_registers)
299 Perform a register copy-propagation optimization pass
302 Common Report Var(flag_crossjumping)
303 Perform cross-jumping optimization
306 Common Report Var(flag_cse_follow_jumps)
307 When running CSE, follow jumps to their targets
310 Common Report Var(flag_cse_skip_blocks)
311 When running CSE, follow conditional jumps
314 Common Report Var(flag_data_sections)
315 Place data items into their own section
317 ; Nonzero for -fdefer-pop: don't pop args after each function call
318 ; instead save them up to pop many calls' args with one insns.
320 Common Report Var(flag_defer_pop)
321 Defer popping functions args from stack until later
324 Common Report Var(flag_delayed_branch)
325 Attempt to fill delay slots of branch instructions
327 fdelete-null-pointer-checks
328 Common Report Var(flag_delete_null_pointer_checks)
329 Delete useless null pointer checks
331 fdiagnostics-show-location=
332 Common Joined RejectNegative
333 -fdiagnostics-show-location=[once|every-line] How often to emit source location at the beginning of line-wrapped diagnostics
336 Common Joined RejectNegative
337 -fdump-<type> Dump various compiler internals to a file
340 Common Report Var(flag_dump_unnumbered) VarExists
341 Suppress output of instruction numbers and line number notes in debugging dumps
343 feliminate-dwarf2-dups
344 Common Report Var(flag_eliminate_dwarf2_dups)
345 Perform DWARF2 duplicate elimination
347 feliminate-unused-debug-symbols
348 Common Report Var(flag_debug_only_used_symbols)
349 Perform unused type elimination in debug info
351 feliminate-unused-debug-types
352 Common Report Var(flag_eliminate_unused_debug_types) Init(1)
353 Perform unused type elimination in debug info
356 Common Report Var(flag_exceptions)
357 Enable exception handling
359 fexpensive-optimizations
360 Common Report Var(flag_expensive_optimizations)
361 Perform a number of minor, expensive optimizations
367 Common Report Var(flag_finite_math_only)
368 Assume no NaNs or infinities are generated
371 Common Joined RejectNegative
372 -ffixed-<register> Mark <register> as being unavailable to the compiler
375 Common Report Var(flag_float_store)
376 Don't allocate floats and doubles in extended-precision registers
378 ; Nonzero for -fforce-addr: load memory address into a register before
379 ; reference to memory. This makes better cse but slower compilation.
381 Common Report Var(flag_force_addr)
382 Copy memory address constants into registers before use
384 ; Nonzero for -fforce-mem: load memory value into a register
385 ; before arithmetic on it. This makes better cse but slower compilation.
387 Common Report Var(flag_force_mem)
388 Copy memory operands into registers before use
390 ; Nonzero means don't put addresses of constant functions in registers.
391 ; Used for compiling the Unix kernel, where strange substitutions are
392 ; done on the assembly output.
394 Common Report Var(flag_no_function_cse,0)
395 Allow function addresses to be held in registers
398 Common Report Var(flag_function_sections)
399 Place each function into its own section
402 Common Report Var(flag_gcse)
403 Perform global common subexpression elimination
406 Common Report Var(flag_gcse_lm) Init(1)
407 Perform enhanced load motion during global common subexpression elimination
410 Common Report Var(flag_gcse_sm) Init(1)
411 Perform store motion after global common subexpression elimination
414 Common Report Var(flag_gcse_las) Init(1)
415 Perform redundant load after store elimination in global common subexpression
419 Common Report Var(flag_gcse_after_reload)
420 Perform global common subexpression elimination after register allocation
423 fguess-branch-probability
424 Common Report Var(flag_guess_branch_prob)
425 Enable guessing of branch probabilities
427 ; Nonzero means ignore `#ident' directives. 0 means handle them.
428 ; Generate position-independent code for executables if possible
429 ; On SVR4 targets, it also controls whether or not to emit a
430 ; string identifying the compiler.
432 Common Report Var(flag_no_ident,0)
433 Process #ident directives
436 Common Report Var(flag_if_conversion)
437 Perform conversion of conditional jumps to branchless equivalents
440 Common Report Var(flag_if_conversion2)
441 Perform conversion of conditional jumps to conditional execution
443 ; -finhibit-size-directive inhibits output of .size for ELF.
444 ; This is used only for compiling crtstuff.c,
445 ; and it may be extended to other effects
446 ; needed for crtstuff.c on other systems.
447 finhibit-size-directive
448 Common Report Var(flag_inhibit_size_directive)
449 Do not generate .size directives
451 ; Nonzero means that functions declared `inline' will be treated
452 ; as `static'. Prevents generation of zillions of copies of unused
453 ; static inline functions; instead, `inlines' are written out
454 ; only when actually used. Used in conjunction with -g. Also
455 ; does the right thing with #pragma interface.
457 Common Report Var(flag_no_inline,0) Init(2)
458 Pay attention to the \"inline\" keyword
461 Common Report Var(flag_inline_functions)
462 Integrate simple functions into their callers
465 Common RejectNegative Joined UInteger
468 Common RejectNegative Joined UInteger
469 -finline-limit=<number> Limit the size of inlined functions to <number>
471 finstrument-functions
472 Common Report Var(flag_instrument_function_entry_exit)
473 Instrument function entry and exit with profiling calls
475 fkeep-inline-functions
476 Common Report Var(flag_keep_inline_functions)
477 Generate code for functions even if they are fully inlined
480 Common Report Var(flag_keep_static_consts) Init(1)
481 Emit static const variables even if they are not used
484 Common Report Var(flag_leading_underscore) Init(-1)
485 Give external symbols a leading underscore
488 Common Report Var(flag_loop_optimize)
489 Perform loop optimizations
492 Common Report Var(flag_loop_optimize2)
493 Perform loop optimizations using the new loop optimizer
496 Common Report Var(flag_errno_math) Init(1)
497 Set errno after built-in math functions
500 Common Report Var(mem_report)
501 Report on permanent memory allocation
503 ; This will attempt to merge constant section constants, if 1 only
504 ; string constants and constants from constant pool, if 2 also constant
507 Common Report Var(flag_merge_constants,2) Init(1)
508 Attempt to merge identical constants and constant variables
511 Common Report Var(flag_merge_constants,1) VarExists
512 Attempt to merge identical constants across compilation units
515 Common RejectNegative Joined UInteger
516 -fmessage-length=<number> Limit diagnostics to <number> characters per line. 0 suppresses line-wrapping
519 Common Report Var(flag_modulo_sched)
520 Perform SMS based modulo scheduling before the first scheduling pass
523 Common Report Var(flag_move_all_movables)
524 Force all loop invariant computations out of loops
526 fmove-loop-invariants
527 Common Report Var(flag_move_loop_invariants)
528 Move loop invariant computations out of loops
531 Common RejectNegative Report Var(flag_mudflap)
532 Add mudflap bounds-checking instrumentation for single-threaded program.
535 Common RejectNegative Report Var(flag_mudflap_threads)
536 Add mudflap bounds-checking instrumentation for multi-threaded program.
539 Common RejectNegative Report Var(flag_mudflap_ignore_reads)
540 Ignore read operations when inserting mudflap instrumentation.
543 Common Report Var(flag_new_regalloc)
544 Use graph-coloring register allocation
547 Common Report Var(flag_non_call_exceptions)
548 Support synchronous non-call exceptions
551 Common Report Var(flag_old_unroll_loops)
552 Perform loop unrolling when iteration count is known
554 fold-unroll-all-loops
555 Common Report Var(flag_old_unroll_all_loops)
556 Perform loop unrolling for all loops
559 Common Report Var(flag_omit_frame_pointer)
560 When possible do not generate stack frames
562 foptimize-register-move
563 Common Report Var(flag_regmove)
564 Do the full register move optimization pass
566 foptimize-sibling-calls
567 Common Report Var(flag_optimize_sibling_calls)
568 Optimize sibling and tail recursive calls
571 Common Report Var(flag_pack_struct)
572 Pack structure members together without holes
575 Common Report Var(flag_pcc_struct_return,1) VarExists
576 Return small aggregates in memory, not registers
579 Common Report Var(flag_peel_loops)
583 Common Report Var(flag_no_peephole,0)
584 Enable machine specific peephole optimizations
587 Common Report Var(flag_peephole2)
588 Enable an RTL peephole pass before sched2
591 Common Report Var(flag_pic,2)
592 Generate position-independent code if possible (large mode)
595 Common Report Var(flag_pie,2)
596 Generate position-independent code for executables if possible (large mode)
599 Common Report Var(flag_pic,1) VarExists
600 Generate position-independent code if possible (small mode)
603 Common Report Var(flag_pie,1) VarExists
604 Generate position-independent code for executables if possible (small mode)
606 fprefetch-loop-arrays
607 Common Report Var(flag_prefetch_loop_arrays)
608 Generate prefetch instructions, if available, for arrays in loops
611 Common Report Var(profile_flag)
612 Enable basic program profiling code
615 Common Report Var(profile_arc_flag)
616 Insert arc-based program profiling code
620 Enable common options for generating profile info for profile feedback directed optimizations
624 Enable common options for performing profile feedback directed optimizations
627 Common Report Var(flag_profile_values)
628 Insert code to profile values of expressions
634 Common Joined RejectNegative
635 -frandom-seed=<string> Make compile reproducible using <string>
638 Common Report Var(flag_reduce_all_givs)
639 Strength reduce all loop general induction variables
642 Common Report Var(flag_pcc_struct_return,0) VarExists
643 Return small aggregates in registers
646 Common Report Var(flag_regmove)
647 Enables a register move optimization
650 Common Report Var(flag_rename_registers)
651 Perform a register renaming optimization pass
654 Common Report Var(flag_reorder_blocks)
655 Reorder basic blocks to improve code placement
657 freorder-blocks-and-partition
658 Common Report Var(flag_reorder_blocks_and_partition)
659 Reorder basic blocks and partition into hot and cold sections
662 Common Report Var(flag_reorder_functions)
663 Reorder functions to improve code placement
665 frerun-cse-after-loop
666 Common Report Var(flag_rerun_cse_after_loop)
667 Add a common subexpression elimination pass after loop optimizations
670 Common Report Var(flag_rerun_loop_opt)
671 Run the loop optimizer twice
674 Common Report Var(flag_rounding_math)
675 Disable optimizations that assume default FP rounding behavior
678 Common Report Var(flag_schedule_interblock) Init(1)
679 Enable scheduling across basic blocks
682 Common Report Var(flag_schedule_speculative) Init(1)
683 Allow speculative motion of non-loads
686 Common Report Var(flag_schedule_speculative_load)
687 Allow speculative motion of some loads
689 fsched-spec-load-dangerous
690 Common Report Var(flag_schedule_speculative_load_dangerous)
691 Allow speculative motion of more loads
694 Common RejectNegative Joined
695 -fsched-verbose=<number> Set the verbosity level of the scheduler
697 fsched2-use-superblocks
698 Common Report Var(flag_sched2_use_superblocks)
699 If scheduling post reload, do superblock scheduling
702 Common Report Var(flag_sched2_use_traces)
703 If scheduling post reload, do trace scheduling
706 Common Report Var(flag_schedule_insns)
707 Reschedule instructions before register allocation
710 Common Report Var(flag_schedule_insns_after_reload)
711 Reschedule instructions after register allocation
713 ; sched_stalled_insns means that insns can be moved prematurely from the queue
714 ; of stalled insns into the ready list.
716 Common Report Var(flag_sched_stalled_insns)
717 Allow premature scheduling of queued insns
719 fsched-stalled-insns=
720 Common RejectNegative Joined UInteger
721 -fsched-stalled-insns=<number> Set number of queued insns that can be prematurely scheduled
723 ; sched_stalled_insns_dep controls how many recently scheduled cycles will
724 ; be examined for a dependency on a stalled insn that is candidate for
725 ; premature removal from the queue of stalled insns into the ready list (has
726 ; an effect only if the flag 'sched_stalled_insns' is set).
727 fsched-stalled-insns-dep
728 Common Report Var(flag_sched_stalled_insns_dep,1) Init(1)
729 Set dependence distance checking in premature scheduling of queued insns
731 fsched-stalled-insns-dep=
732 Common RejectNegative Joined UInteger
733 -fsched-stalled-insns-dep=<number> Set dependence distance checking in premature scheduling of queued insns
736 Common Report Var(flag_shared_data)
737 Mark data as shared rather than private
740 Common Report Var(flag_signaling_nans)
741 Disable optimizations observable by IEEE signaling NaNs
743 fsingle-precision-constant
744 Common Report Var(flag_single_precision_constant)
745 Convert floating point constants to single precision constants
747 ; Emit code to probe the stack, to help detect stack overflow; also
748 ; may cause large objects to be allocated dynamically.
750 Common Report Var(flag_stack_check)
751 Insert stack checking code into the program
756 fstack-limit-register=
757 Common RejectNegative Joined
758 -fstack-limit-register=<register> Trap if the stack goes past <register>
761 Common RejectNegative Joined
762 -fstack-limit-symbol=<name> Trap if the stack goes past symbol <name>
765 Common Report Var(flag_strength_reduce)
766 Perform strength reduction optimizations
768 ; Nonzero if we should do (language-dependent) alias analysis.
769 ; Typically, this analysis will assume that expressions of certain
770 ; types do not alias expressions of certain other types. Only used
771 ; if alias analysis (in general) is enabled.
773 Common Report Var(flag_strict_aliasing)
774 Assume strict aliasing rules apply
777 Common Report Var(flag_syntax_only)
778 Check for syntax errors, then stop
781 Common Report Var(flag_test_coverage)
782 Create data files needed by \"gcov\"
785 Common Report Var(flag_thread_jumps)
786 Perform jump threading optimizations
789 Common Report Var(time_report)
790 Report the time taken by each compiler pass
793 Common Joined RejectNegative
794 -ftls-model=[global-dynamic|local-dynamic|initial-exec|local-exec] Set the default thread-local storage code generation model
797 Common Report Var(flag_tracer)
798 Perform superblock formation via tail duplication
800 ; Zero means that floating-point math operations cannot generate a
801 ; (user-visible) trap. This is the case, for example, in nonstop
802 ; IEEE 754 arithmetic.
804 Common Report Var(flag_trapping_math)
805 Assume floating-point operations can trap
808 Common Report Var(flag_trapv)
809 Trap for signed overflow in addition, subtraction and multiplication
811 ftree-based-profiling
812 Common Report Var(flag_tree_based_profiling)
813 Use tree-ssa based implementation of profiling
816 Common Report Var(flag_tree_ccp)
817 Enable SSA-CCP optimization on trees
820 Common Report Var(flag_tree_ch)
821 Enable loop header copying on trees
824 Common Report Var(flag_tree_combine_temps)
825 Coalesce memory temporaries in the SSA->normal pass
828 Common Report Var(flag_tree_copyrename)
829 Replace SSA temporaries with better names in copies.
832 Common Report Var(flag_tree_dce)
833 Enable SSA dead code elimination optimization on trees
836 Common Report Var(flag_tree_dom)
837 Enable dominator optimizations
840 Common Report Var(flag_tree_dse)
841 Enable dead store elimination
844 Common Report Var(flag_tree_fre)
845 Enable Full Redundancy Elimination (FRE) on trees
848 Common Report Var(flag_tree_lim) Init(1)
849 Enable loop invariant motion on trees
852 Common Report Var(flag_tree_loop_optimize) Init(1)
853 Enable loop optimizations on tree level
856 Common Joined RejectNegative
859 Common Report Var(flag_tree_pre)
860 Enable SSA-PRE optimization on trees
863 Common Report Var(flag_tree_sra)
864 Perform scalar replacement of aggregates
867 Common Report Var(flag_tree_ter)
868 Replace temporary expressions in the SSA->normal pass
871 Common Report Var(flag_tree_live_range_split)
872 Perform live range splitting during the SSA->normal pass.
875 Common Report Var(flag_unit_at_a_time)
876 Compile whole compilation unit at a time
879 Common Report Var(flag_unroll_loops)
880 Perform loop unrolling when iteration count is known
883 Common Report Var(flag_unroll_all_loops)
884 Perform loop unrolling for all loops
886 ; Nonzero means that unsafe floating-point math optimizations are allowed
887 ; for the sake of speed. IEEE compliance is not guaranteed, and operations
888 ; are allowed to assume that their arguments and results are "normal"
889 ; (e.g., nonnegative for SQRT).
890 funsafe-math-optimizations
891 Common Report Var(flag_unsafe_math_optimizations)
892 Allow math optimizations that may violate IEEE or ISO standards
895 Common Report Var(flag_unswitch_loops)
896 Perform loop unswitching
899 Common Report Var(flag_unwind_tables)
900 Just generate unwind tables for exception handling
903 Common Report Var(flag_var_tracking) VarExists
904 Perform variable tracking
906 ; -fverbose-asm causes extra commentary information to be produced in
907 ; the generated assembly code (to make it more readable). This option
908 ; is generally only of use to those who actually need to read the
909 ; generated assembly code (perhaps while debugging the compiler itself).
910 ; -fno-verbose-asm, the default, causes the extra information
911 ; to not be added and is useful when comparing two assembler files.
913 Common Report Var(flag_verbose_asm)
914 Add extra commentary to assembler output
917 Common Joined RejectNegative
918 -fvisibility=[default|internal|hidden|protected] Set the default symbol visibility
922 Common Report Var(flag_value_profile_transformations)
923 Use expression value profiles in optimizations
926 Common Report Var(flag_web) VarExists
927 Construct webs and split unrelated uses of single variable
930 Common Report Var(flag_wrapv)
931 Assume signed arithmetic overflow wraps around
933 fzero-initialized-in-bss
934 Common Report Var(flag_zero_initialized_in_bss) Init(1)
935 Put zero initialized data in the bss section
938 Common JoinedOrMissing
939 Generate debug information in default format
942 Common JoinedOrMissing
943 Generate debug information in COFF format
946 Common JoinedOrMissing
947 Generate debug information in DWARF v2 format
950 Common JoinedOrMissing
951 Generate debug information in default extended format
954 Common JoinedOrMissing
955 Generate debug information in STABS format
958 Common JoinedOrMissing
959 Generate debug information in extended STABS format
962 Common JoinedOrMissing
963 Generate debug information in VMS format
966 Common JoinedOrMissing
967 Generate debug information in XCOFF format
970 Common JoinedOrMissing
971 Generate debug information in extended XCOFF format
977 Common Joined Separate
978 -o <file> Place output into <file>
981 Common Var(profile_flag)
982 Enable function profiling
986 Issue warnings needed for strict compliance to the standard
990 Like -pedantic but issue them as errors
993 Common Var(quiet_flag)
994 Do not display functions compiled or elapsed time
997 Common Var(version_flag)
998 Display the compiler's version
1001 Common Var(inhibit_warnings)
1004 ; This comment is to ensure we retain the blank line above.