* common.opt: More --help messages.

	* opts.c (print_help): Use puts().
	* toplev.c (f_options): Remove help text.
	(display_help): Don't dump f_options.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@69217 138bc75d-0d04-0410-961f-82ee72b054a4

gcc/ChangeLog

+2003-07-11  Neil Booth  <neil@daikokuya.co.uk>
+
+	* common.opt: More --help messages.
+	* opts.c (print_help): Use puts().
+	* toplev.c (f_options): Remove help text.
+	(display_help): Don't dump f_options.
+
 2003-07-11  Nathanael Nerode  <neroden@gcc.gnu.org>
 	* fixinc/mkfixinc.sh: Drop reference to unsupported alpha-*-interix*.

gcc/common.opt

@@ -117,7 +117,7 @@ Warn about all enumerated switches missing a specific case
 
 Wsystem-headers
 Common
-Suppress warnings from system headers
+Do not suppress warnings from system headers
 
 Wuninitialized
 Common
@@ -180,54 +180,67 @@ Common
 
 falign-functions
 Common
+Align the start of functions
 
 falign-functions=
 Common RejectNegative Joined UInteger
 
 falign-jumps
 Common
+Align labels which are only reached by jumping
 
 falign-jumps=
 Common RejectNegative Joined UInteger
 
 falign-labels
 Common
+Align all labels
 
 falign-labels=
 Common RejectNegative Joined UInteger
 
 falign-loops
 Common
+Align the start of loops
 
 falign-loops=
 Common RejectNegative Joined UInteger
 
 fargument-alias
 Common
+Specify that arguments may alias each other and globals
 
 fargument-noalias
 Common
+Assume arguments may alias globals but not each other
 
 fargument-noalias-global
 Common
+Assume arguments alias neither each other nor globals
 
 fasynchronous-unwind-tables
 Common
+Generate unwind tables that are exact at each instruction boundary
 
 fbounds-check
 Common
+Generate code to check bounds before indexing arrays
 
 fbranch-count-reg
 Common
+Replace add, compare, branch with branch on count register
 
 fbranch-probabilities
 Common
+Use profiling information for branch probabilities
 
 fbranch-target-load-optimize
 Common
+Perform branch target load optimization before prologue / epilogue threading
 
 fbranch-target-load-optimize2
 Common
+Perform branch target load optimization after prologue / epilogue threading
 
 fcall-saved-
 Common Joined RejectNegative
@@ -239,33 +252,43 @@ Common Joined RejectNegative
 
 fcaller-saves
 Common
+Save registers around function calls
 
 fcommon
 Common
+Do not put uninitialized globals in the common section
 
 fcprop-registers
 Common
+Perform a register copy-propagation optimization pass
 
 fcrossjumping
 Common
+Perform cross-jumping optimization
 
 fcse-follow-jumps
 Common
+When running CSE, follow jumps to their targets
 
 fcse-skip-blocks
 Common
+When running CSE, follow conditional jumps
 
 fdata-sections
 Common
+Place data items into their own section
 
 fdefer-pop
 Common
+Defer popping functions args from stack until later
 
 fdelayed-branch
 Common
+Attempt to fill delay slots of branch instructions
 
 fdelete-null-pointer-checks
 Common
+Delete useless null pointer checks
 
 fdiagnostics-show-location=
 Common Joined RejectNegative
@@ -273,27 +296,34 @@ Common Joined RejectNegative
 
 fdump-unnumbered
 Common
+Suppress output of instruction numbers and line number notes in debugging dumps
 
 feliminate-dwarf2-dups
 Common
+Perform DWARF2 duplicate elimination
 
 feliminate-unused-debug-symbols
 Common
+Perform unused type elimination in debug info
 
 feliminate-unused-debug-types
 Common
+Perform unused type elimination in debug info
 
 fexceptions
 Common
+Enable exception handling
 
 fexpensive-optimizations
 Common
+Perform a number of minor, expensive optimizations
 
 ffast-math
 Common
 
 ffinite-math-only
 Common
+Assume no NaNs or infinities are generated
 
 ffixed-
 Common Joined RejectNegative
@@ -301,51 +331,67 @@ Common Joined RejectNegative
 
 ffloat-store
 Common
+Do not store floats in registers
 
 fforce-addr
 Common
+Copy memory address constants into registers before use
 
 fforce-mem
 Common
+Copy memory operands into registers before use
 
 ffunction-cse
 Common
+Allow function addresses to be held in registers
 
 ffunction-sections
 Common
+Place each function into its own section
 
 fgcse
 Common
+Perform global common subexpression elimination
 
 fgcse-lm
 Common
+Perform enhanced load motion during global common subexpression elimination
 
 fgcse-sm
 Common
+Perform store motion after global common subexpression elimination
 
 fgnu-linker
 Common
+Output GNU ld formatted global initializers
 
 fguess-branch-probability
 Common
+Enable guessing of branch probabilities
 
 fident
 Common
+Process #ident directives
 
 fif-conversion
 Common
+Perform conversion of conditional jumps to branchless equivalents
 
 fif-conversion2
 Common
+Perform conversion of conditional jumps to conditional execution
 
 finhibit-size-directive
 Common
+Do not generate .size directives
 
 finline
 Common
+Pay attention to the \"inline\" keyword
 
 finline-functions
 Common
+Integrate simple functions into their callers
 
 finline-limit-
 Common RejectNegative Joined UInteger
@@ -356,30 +402,39 @@ Common RejectNegative Joined UInteger
 
 finstrument-functions
 Common
+Instrument function entry and exit with profiling calls
 
 fkeep-inline-functions
 Common
+Generate code for functions even if they are fully inlined
 
 fkeep-static-consts
 Common
+Emit static const variables even if they are not used
 
 fleading-underscore
 Common
+Give external symbols a leading underscore
 
 floop-optimize
 Common
+Perform loop optimizations
 
 fmath-errno
 Common
+Set errno after built-in math functions
 
 fmem-report
 Common
+Report on permanent memory allocation
 
 fmerge-all-constants
 Common
+Attempt to merge identical constants and constant variables
 
 fmerge-constants
 Common
+Attempt to merge identical constants across compilation units
 
 fmessage-length=
 Common RejectNegative Joined UInteger
@@ -387,57 +442,75 @@ Common RejectNegative Joined UInteger
 
 fmove-all-movables
 Common
+Force all loop invariant computations out of loops
 
 fnew-ra
 Common
+Use graph-coloring register allocation
 
 fnon-call-exceptions
 Common
+Support synchronous non-call exceptions
 
 fold-unroll-loops
 Common
+Perform loop unrolling when iteration count is known
 
 fold-unroll-all-loops
 Common
+Perform loop unrolling for all loops
 
 fomit-frame-pointer
 Common
+When possible do not generate stack frames
 
 foptimize-register-move
 Common
+Do the full register move optimization pass
 
 foptimize-sibling-calls
 Common
+Optimize sibling and tail recursive calls
 
 fpack-struct
 Common
+Pack structure members together without holes
 
 fpcc-struct-return
 Common
+Return small aggregates in memory, not registers
 
 fpeel-loops
 Common
+Perform loop peeling
 
 fpeephole
 Common
+Enable machine specific peephole optimizations
 
 fpeephole2
 Common
+Enable an RTL peephole pass before sched2
 
 fpic
 Common
+Generate position-independent code if possible
 
 fpie
 Common
+Generate position-independent code for executables if possible
 
 fprefetch-loop-arrays
 Common
+Generate prefetch instructions, if available, for arrays in loops
 
 fprofile
 Common
+Enable basic program profiling code
 
 fprofile-arcs
 Common
+Insert arc-based program profiling code
 
 frandom-seed
 Common
@@ -448,39 +521,51 @@ Common Joined RejectNegative
 
 freduce-all-givs
 Common
+Strength reduce all loop general induction variables
 
 freg-struct-return
 Common
+Return small aggregates in registers
 
 fregmove
 Common
+Enables a register move optimization
 
 frename-registers
 Common
+Perform a register renaming optimization pass
 
 freorder-blocks
 Common
+Reorder basic blocks to improve code placement
 
 freorder-functions
 Common
+Reorder functions to improve code placement
 
 frerun-cse-after-loop
 Common
+Add a common subexpression elimination pass after loop optimizations
 
 frerun-loop-opt
 Common
+Run the loop optimizer twice
 
 fsched-interblock
 Common
+Enable scheduling across basic blocks
 
 fsched-spec
 Common
+Allow speculative motion of non-loads
 
 fsched-spec-load
 Common
+Allow speculative motion of some loads
 
 fsched-spec-load-dangerous
 Common
+Allow speculative motion of more loads
 
 fsched-verbose=
 Common RejectNegative Joined
@@ -488,36 +573,47 @@ Common RejectNegative Joined
 
 fsched2-use-superblocks
 Common
+If scheduling post reload, do superblock scheduling
 
 fsched2-use-traces
 Common
+If scheduling post reload, do trace scheduling
 
 fschedule-insns
 Common
+Reschedule instructions before register allocation
 
 fschedule-insns2
 Common
+Reschedule instructions after register allocation
 
 fshared-data
 Common
+Mark data as shared rather than private
 
 fsignaling-nans
 Common
+Disable optimizations observable by IEEE signaling NaNs
 
 fsingle-precision-constant
 Common
+Convert floating point constants to single precision constants
 
 fssa
 Common
+Enable static single assignment optimizations
 
 fssa-ccp
 Common
+Enable SSA conditional constant propagation
 
 fssa-dce
 Common
+Enable aggressive SSA dead code elimination
 
 fstack-check
 Common
+Insert stack checking code into the program
 
 fstack-limit
 Common
@@ -532,21 +628,27 @@ Common RejectNegative Joined
 
 fstrength-reduce
 Common
+Perform strength reduction optimizations
 
 fstrict-aliasing
 Common
+Assume strict aliasing rules apply
 
 fsyntax-only
 Common
+Check for syntax errors, then stop
 
 ftest-coverage
 Common
+Create data files needed by \"gcov\"
 
 fthread-jumps
 Common
+Perform jump threading optimizations
 
 ftime-report
 Common
+Report the time taken by each compiler pass
 
 ftls-model=
 Common Joined RejectNegative
@@ -554,42 +656,55 @@ Common Joined RejectNegative
 
 ftracer
 Common
+Perform superblock formation via tail duplication
 
 ftrapping-math
 Common
+Assume floating-point operations can trap
 
 ftrapv
 Common
+Trap for signed overflow in addition, subtraction and multiplication
 
 funit-at-a-time
 Common
+Compile whole compilation unit at a time
 
 funroll-loops
 Common
+Perform loop unrolling when iteration count is known
 
 funroll-all-loops
 Common
+Perform loop unrolling for all loops
 
 funsafe-math-optimizations
 Common
+Allow math optimizations that may violate IEEE or ISO standards
 
 funswitch-loops
 Common
+Perform loop unswitching
 
 funwind-tables
 Common
+Just generate unwind tables for exception handling
 
 fverbose-asm
 Common
+Add extra commentary to assembler output
 
 fwrapv
 Common
+Assume signed arithmetic overflow wraps around
 
 fwritable-strings
 Common
+Store strings in writable data section
 
 fzero-initialized-in-bss
 Common
+Put zero initialized data in the bss section
 
 g
 Common JoinedOrMissing

gcc/opts.c

@@ -1487,7 +1487,7 @@ print_help (void)
 {
   size_t i, len;
 
-  printf (_("\nThe following options are language-independent:\n"));
+  puts (_("\nThe following options are language-independent:\n"));
 
   for (i = 0; i < cl_options_count; i++)
     {

gcc/toplev.c

@@ -1029,7 +1029,6 @@ typedef struct
   const char *const string;
   int *const variable;
   const int on_value;
-  const char *const description;
 }
 lang_independent_options;
 
@@ -1061,238 +1060,123 @@ static const param_info lang_independent_params[] = {
 
 static const lang_independent_options f_options[] =
 {
-  {"eliminate-dwarf2-dups", &flag_eliminate_dwarf2_dups, 1,
-   N_("Perform DWARF2 duplicate elimination") },
-  {"eliminate-unused-debug-symbols", &flag_debug_only_used_symbols, 1,
-   N_("Perform unused type elimination in debug info") },
-  {"eliminate-unused-debug-types", &flag_eliminate_unused_debug_types, 1,
-   N_("Perform unused type elimination in debug info") },
-  {"float-store", &flag_float_store, 1,
-   N_("Do not store floats in registers") },
-  {"defer-pop", &flag_defer_pop, 1,
-   N_("Defer popping functions args from stack until later") },
-  {"omit-frame-pointer", &flag_omit_frame_pointer, 1,
-   N_("When possible do not generate stack frames") },
-  {"optimize-sibling-calls", &flag_optimize_sibling_calls, 1,
-   N_("Optimize sibling and tail recursive calls") },
-  {"tracer", &flag_tracer, 1,
-   N_("Perform superblock formation via tail duplication") },
-  {"unit-at-a-time", &flag_unit_at_a_time, 1,
-   N_("Compile whole compilation unit at a time") },
-  {"cse-follow-jumps", &flag_cse_follow_jumps, 1,
-   N_("When running CSE, follow jumps to their targets") },
-  {"cse-skip-blocks", &flag_cse_skip_blocks, 1,
-   N_("When running CSE, follow conditional jumps") },
-  {"expensive-optimizations", &flag_expensive_optimizations, 1,
-   N_("Perform a number of minor, expensive optimizations") },
-  {"thread-jumps", &flag_thread_jumps, 1,
-   N_("Perform jump threading optimizations") },
-  {"strength-reduce", &flag_strength_reduce, 1,
-   N_("Perform strength reduction optimizations") },
-  {"unroll-loops", &flag_unroll_loops, 1,
-   N_("Perform loop unrolling when iteration count is known") },
-  {"unroll-all-loops", &flag_unroll_all_loops, 1,
-   N_("Perform loop unrolling for all loops") },
-  {"old-unroll-loops", &flag_old_unroll_loops, 1,
-   N_("Perform loop unrolling when iteration count is known") },
-  {"old-unroll-all-loops", &flag_old_unroll_all_loops, 1,
-   N_("Perform loop unrolling for all loops") },
-  {"peel-loops", &flag_peel_loops, 1,
-   N_("Perform loop peeling") },
-  {"unswitch-loops", &flag_unswitch_loops, 1,
-   N_("Perform loop unswitching") },
-  {"prefetch-loop-arrays", &flag_prefetch_loop_arrays, 1,
-   N_("Generate prefetch instructions, if available, for arrays in loops") },
-  {"move-all-movables", &flag_move_all_movables, 1,
-   N_("Force all loop invariant computations out of loops") },
-  {"reduce-all-givs", &flag_reduce_all_givs, 1,
-   N_("Strength reduce all loop general induction variables") },
-  {"writable-strings", &flag_writable_strings, 1,
-   N_("Store strings in writable data section") },
-  {"peephole", &flag_no_peephole, 0,
-   N_("Enable machine specific peephole optimizations") },
-  {"force-mem", &flag_force_mem, 1,
-   N_("Copy memory operands into registers before using") },
-  {"force-addr", &flag_force_addr, 1,
-   N_("Copy memory address constants into regs before using") },
-  {"function-cse", &flag_no_function_cse, 0,
-   N_("Allow function addresses to be held in registers") },
-  {"inline-functions", &flag_inline_functions, 1,
-   N_("Integrate simple functions into their callers") },
-  {"keep-inline-functions", &flag_keep_inline_functions, 1,
-   N_("Generate code for funcs even if they are fully inlined") },
-  {"inline", &flag_no_inline, 0,
-   N_("Pay attention to the 'inline' keyword") },
-  {"keep-static-consts", &flag_keep_static_consts, 1,
-   N_("Emit static const variables even if they are not used") },
-  {"syntax-only", &flag_syntax_only, 1,
-   N_("Check for syntax errors, then stop") },
-  {"shared-data", &flag_shared_data, 1,
-   N_("Mark data as shared rather than private") },
-  {"caller-saves", &flag_caller_saves, 1,
-   N_("Enable saving registers around function calls") },
-  {"pcc-struct-return", &flag_pcc_struct_return, 1,
-   N_("Return 'short' aggregates in memory, not registers") },
-  {"reg-struct-return", &flag_pcc_struct_return, 0,
-   N_("Return 'short' aggregates in registers") },
-  {"delayed-branch", &flag_delayed_branch, 1,
-   N_("Attempt to fill delay slots of branch instructions") },
-  {"gcse", &flag_gcse, 1,
-   N_("Perform the global common subexpression elimination") },
-  {"gcse-lm", &flag_gcse_lm, 1,
-   N_("Perform enhanced load motion during global subexpression elimination") },
-  {"gcse-sm", &flag_gcse_sm, 1,
-   N_("Perform store motion after global subexpression elimination") },
-  {"branch-target-load-optimize", &flag_branch_target_load_optimize, 1,
-   N_("Perform branch target load optimization before prologue / epilogue threading") },
-  {"branch-target-load-optimize2", &flag_branch_target_load_optimize2, 1,
-   N_("Perform branch target load optimization after prologue / epilogue threading") },
-  {"loop-optimize", &flag_loop_optimize, 1,
-   N_("Perform the loop optimizations") },
-  {"crossjumping", &flag_crossjumping, 1,
-   N_("Perform cross-jumping optimization") },
-  {"if-conversion", &flag_if_conversion, 1,
-   N_("Perform conversion of conditional jumps to branchless equivalents") },
-  {"if-conversion2", &flag_if_conversion2, 1,
-   N_("Perform conversion of conditional jumps to conditional execution") },
-  {"rerun-cse-after-loop", &flag_rerun_cse_after_loop, 1,
-   N_("Run CSE pass after loop optimizations") },
-  {"rerun-loop-opt", &flag_rerun_loop_opt, 1,
-   N_("Run the loop optimizer twice") },
-  {"delete-null-pointer-checks", &flag_delete_null_pointer_checks, 1,
-   N_("Delete useless null pointer checks") },
-  {"schedule-insns", &flag_schedule_insns, 1,
-   N_("Reschedule instructions before register allocation") },
-  {"schedule-insns2", &flag_schedule_insns_after_reload, 1,
-   N_("Reschedule instructions after register allocation") },
-  {"sched-interblock",&flag_schedule_interblock, 1,
-   N_("Enable scheduling across basic blocks") },
-  {"sched-spec",&flag_schedule_speculative, 1,
-   N_("Allow speculative motion of non-loads") },
-  {"sched-spec-load",&flag_schedule_speculative_load, 1,
-   N_("Allow speculative motion of some loads") },
-  {"sched-spec-load-dangerous",&flag_schedule_speculative_load_dangerous, 1,
-   N_("Allow speculative motion of more loads") },
-  {"sched2-use-superblocks", &flag_sched2_use_superblocks, 1,
-   N_("If scheduling post reload, do superblock scheduling") },
-  {"sched2-use-traces", &flag_sched2_use_traces, 1,
-   N_("If scheduling post reload, do trace scheduling") },
-  {"branch-count-reg",&flag_branch_on_count_reg, 1,
-   N_("Replace add,compare,branch with branch on count reg") },
-  {"pic", &flag_pic, 1,
-   N_("Generate position independent code, if possible") },
-  {"PIC", &flag_pic, 2, ""},
-  {"pie", &flag_pie, 1,
-   N_("Generate position independent code for executables, if possible") },
-  {"PIE", &flag_pie, 2, ""},
-  {"exceptions", &flag_exceptions, 1,
-   N_("Enable exception handling") },
-  {"unwind-tables", &flag_unwind_tables, 1,
-   N_("Just generate unwind tables for exception handling") },
-  {"asynchronous-unwind-tables", &flag_asynchronous_unwind_tables, 1,
-   N_("Generate unwind tables exact at each instruction boundary") },
-  {"non-call-exceptions", &flag_non_call_exceptions, 1,
-   N_("Support synchronous non-call exceptions") },
-  {"profile-arcs", &profile_arc_flag, 1,
-   N_("Insert arc based program profiling code") },
-  {"test-coverage", &flag_test_coverage, 1,
-   N_("Create data files needed by gcov") },
-  {"branch-probabilities", &flag_branch_probabilities, 1,
-   N_("Use profiling information for branch probabilities") },
-  {"profile", &profile_flag, 1,
-   N_("Enable basic program profiling code") },
-  {"reorder-blocks", &flag_reorder_blocks, 1,
-   N_("Reorder basic blocks to improve code placement") },
-  {"reorder-functions", &flag_reorder_functions, 1,
-   N_("Reorder functions to improve code placement") },
-  {"rename-registers", &flag_rename_registers, 1,
-   N_("Do the register renaming optimization pass") },
-  {"cprop-registers", &flag_cprop_registers, 1,
-   N_("Do the register copy-propagation optimization pass") },
-  {"common", &flag_no_common, 0,
-   N_("Do not put uninitialized globals in the common section") },
-  {"inhibit-size-directive", &flag_inhibit_size_directive, 1,
-   N_("Do not generate .size directives") },
-  {"function-sections", &flag_function_sections, 1,
-   N_("place each function into its own section") },
-  {"data-sections", &flag_data_sections, 1,
-   N_("place data items into their own section") },
-  {"verbose-asm", &flag_verbose_asm, 1,
-   N_("Add extra commentary to assembler output") },
-  {"gnu-linker", &flag_gnu_linker, 1,
-   N_("Output GNU ld formatted global initializers") },
-  {"regmove", &flag_regmove, 1,
-   N_("Enables a register move optimization") },
-  {"optimize-register-move", &flag_regmove, 1,
-   N_("Do the full regmove optimization pass") },
-  {"pack-struct", &flag_pack_struct, 1,
-   N_("Pack structure members together without holes") },
-  {"stack-check", &flag_stack_check, 1,
-   N_("Insert stack checking code into the program") },
-  {"argument-alias", &flag_argument_noalias, 0,
-   N_("Specify that arguments may alias each other & globals") },
-  {"argument-noalias", &flag_argument_noalias, 1,
-   N_("Assume arguments may alias globals but not each other") },
-  {"argument-noalias-global", &flag_argument_noalias, 2,
-   N_("Assume arguments do not alias each other or globals") },
-  {"strict-aliasing", &flag_strict_aliasing, 1,
-   N_("Assume strict aliasing rules apply") },
-  {"align-loops", &align_loops, 0,
-   N_("Align the start of loops") },
-  {"align-jumps", &align_jumps, 0,
-   N_("Align labels which are only reached by jumping") },
-  {"align-labels", &align_labels, 0,
-   N_("Align all labels") },
-  {"align-functions", &align_functions, 0,
-   N_("Align the start of functions") },
-  {"merge-constants", &flag_merge_constants, 1,
-   N_("Attempt to merge identical constants across compilation units") },
-  {"merge-all-constants", &flag_merge_constants, 2,
-   N_("Attempt to merge identical constants and constant variables") },
-  {"dump-unnumbered", &flag_dump_unnumbered, 1,
-   N_("Suppress output of instruction numbers and line number notes in debugging dumps") },
-  {"instrument-functions", &flag_instrument_function_entry_exit, 1,
-   N_("Instrument function entry/exit with profiling calls") },
-  {"zero-initialized-in-bss", &flag_zero_initialized_in_bss, 1,
-   N_("Put zero initialized data in the bss section") },
-  {"ssa", &flag_ssa, 1,
-   N_("Enable SSA optimizations") },
-  {"ssa-ccp", &flag_ssa_ccp, 1,
-   N_("Enable SSA conditional constant propagation") },
-  {"ssa-dce", &flag_ssa_dce, 1,
-   N_("Enable aggressive SSA dead code elimination") },
-  {"leading-underscore", &flag_leading_underscore, 1,
-   N_("External symbols have a leading underscore") },
-  {"ident", &flag_no_ident, 0,
-   N_("Process #ident directives") },
-  { "peephole2", &flag_peephole2, 1,
-   N_("Enables an rtl peephole pass run before sched2") },
-  {"finite-math-only", &flag_finite_math_only, 1,
-   N_("Assume no NaNs or +-Infs are generated") },
-  { "guess-branch-probability", &flag_guess_branch_prob, 1,
-   N_("Enables guessing of branch probabilities") },
-  {"math-errno", &flag_errno_math, 1,
-   N_("Set errno after built-in math functions") },
-  {"trapping-math", &flag_trapping_math, 1,
-   N_("Floating-point operations can trap") },
-  {"unsafe-math-optimizations", &flag_unsafe_math_optimizations, 1,
-   N_("Allow math optimizations that may violate IEEE or ANSI standards") },
-  {"signaling-nans", &flag_signaling_nans, 1,
-   N_("Disable optimizations observable by IEEE signaling NaNs") },
-  {"bounds-check", &flag_bounds_check, 1,
-   N_("Generate code to check bounds before indexing arrays") },
-  {"single-precision-constant", &flag_single_precision_constant, 1,
-   N_("Convert floating point constant to single precision constant") },
-  {"time-report", &time_report, 1,
-   N_("Report time taken by each compiler pass at end of run") },
-  {"mem-report", &mem_report, 1,
-   N_("Report on permanent memory allocation at end of run") },
-  { "trapv", &flag_trapv, 1,
-   N_("Trap for signed overflow in addition / subtraction / multiplication") },
-  { "wrapv", &flag_wrapv, 1,
-   N_("Assume signed arithmetic overflow wraps around") },
-  { "new-ra", &flag_new_regalloc, 1,
-   N_("Use graph coloring register allocation.") },
+  {"eliminate-dwarf2-dups", &flag_eliminate_dwarf2_dups, 1 },
+  {"eliminate-unused-debug-symbols", &flag_debug_only_used_symbols, 1 },
+  {"eliminate-unused-debug-types", &flag_eliminate_unused_debug_types, 1 },
+  {"float-store", &flag_float_store, 1 },
+  {"defer-pop", &flag_defer_pop, 1 },
+  {"omit-frame-pointer", &flag_omit_frame_pointer, 1 },
+  {"optimize-sibling-calls", &flag_optimize_sibling_calls, 1 },
+  {"tracer", &flag_tracer, 1 },
+  {"unit-at-a-time", &flag_unit_at_a_time, 1 },
+  {"cse-follow-jumps", &flag_cse_follow_jumps, 1 },
+  {"cse-skip-blocks", &flag_cse_skip_blocks, 1 },
+  {"expensive-optimizations", &flag_expensive_optimizations, 1 },
+  {"thread-jumps", &flag_thread_jumps, 1 },
+  {"strength-reduce", &flag_strength_reduce, 1 },
+  {"unroll-loops", &flag_unroll_loops, 1 },
+  {"unroll-all-loops", &flag_unroll_all_loops, 1 },
+  {"old-unroll-loops", &flag_old_unroll_loops, 1 },
+  {"old-unroll-all-loops", &flag_old_unroll_all_loops, 1 },
+  {"peel-loops", &flag_peel_loops, 1 },
+  {"unswitch-loops", &flag_unswitch_loops, 1 },
+  {"prefetch-loop-arrays", &flag_prefetch_loop_arrays, 1 },
+  {"move-all-movables", &flag_move_all_movables, 1 },
+  {"reduce-all-givs", &flag_reduce_all_givs, 1 },
+  {"writable-strings", &flag_writable_strings, 1 },
+  {"peephole", &flag_no_peephole, 0 },
+  {"force-mem", &flag_force_mem, 1 },
+  {"force-addr", &flag_force_addr, 1 },
+  {"function-cse", &flag_no_function_cse, 0 },
+  {"inline-functions", &flag_inline_functions, 1 },
+  {"keep-inline-functions", &flag_keep_inline_functions, 1 },
+  {"inline", &flag_no_inline, 0 },
+  {"keep-static-consts", &flag_keep_static_consts, 1 },
+  {"syntax-only", &flag_syntax_only, 1 },
+  {"shared-data", &flag_shared_data, 1 },
+  {"caller-saves", &flag_caller_saves, 1 },
+  {"pcc-struct-return", &flag_pcc_struct_return, 1 },
+  {"reg-struct-return", &flag_pcc_struct_return, 0 },
+  {"delayed-branch", &flag_delayed_branch, 1 },
+  {"gcse", &flag_gcse, 1 },
+  {"gcse-lm", &flag_gcse_lm, 1 },
+  {"gcse-sm", &flag_gcse_sm, 1 },
+  {"branch-target-load-optimize", &flag_branch_target_load_optimize, 1 },
+  {"branch-target-load-optimize2", &flag_branch_target_load_optimize2, 1 },
+  {"loop-optimize", &flag_loop_optimize, 1 },
+  {"crossjumping", &flag_crossjumping, 1 },
+  {"if-conversion", &flag_if_conversion, 1 },
+  {"if-conversion2", &flag_if_conversion2, 1 },
+  {"rerun-cse-after-loop", &flag_rerun_cse_after_loop, 1 },
+  {"rerun-loop-opt", &flag_rerun_loop_opt, 1 },
+  {"delete-null-pointer-checks", &flag_delete_null_pointer_checks, 1 },
+  {"schedule-insns", &flag_schedule_insns, 1 },
+  {"schedule-insns2", &flag_schedule_insns_after_reload, 1 },
+  {"sched-interblock",&flag_schedule_interblock, 1 },
+  {"sched-spec",&flag_schedule_speculative, 1 },
+  {"sched-spec-load",&flag_schedule_speculative_load, 1 },
+  {"sched-spec-load-dangerous",&flag_schedule_speculative_load_dangerous, 1 },
+  {"sched2-use-superblocks", &flag_sched2_use_superblocks, 1 },
+  {"sched2-use-traces", &flag_sched2_use_traces, 1 },
+  {"branch-count-reg",&flag_branch_on_count_reg, 1 },
+  {"pic", &flag_pic, 1 },
+  {"PIC", &flag_pic, 2 },
+  {"pie", &flag_pie, 1 },
+  {"PIE", &flag_pie, 2 },
+  {"exceptions", &flag_exceptions, 1 },
+  {"unwind-tables", &flag_unwind_tables, 1 },
+  {"asynchronous-unwind-tables", &flag_asynchronous_unwind_tables, 1 },
+  {"non-call-exceptions", &flag_non_call_exceptions, 1 },
+  {"profile-arcs", &profile_arc_flag, 1 },
+  {"test-coverage", &flag_test_coverage, 1 },
+  {"branch-probabilities", &flag_branch_probabilities, 1 },
+  {"profile", &profile_flag, 1 },
+  {"reorder-blocks", &flag_reorder_blocks, 1 },
+  {"reorder-functions", &flag_reorder_functions, 1 },
+  {"rename-registers", &flag_rename_registers, 1 },
+  {"cprop-registers", &flag_cprop_registers, 1 },
+  {"common", &flag_no_common, 0 },
+  {"inhibit-size-directive", &flag_inhibit_size_directive, 1 },
+  {"function-sections", &flag_function_sections, 1 },
+  {"data-sections", &flag_data_sections, 1 },
+  {"verbose-asm", &flag_verbose_asm, 1 },
+  {"gnu-linker", &flag_gnu_linker, 1 },
+  {"regmove", &flag_regmove, 1 },
+  {"optimize-register-move", &flag_regmove, 1 },
+  {"pack-struct", &flag_pack_struct, 1 },
+  {"stack-check", &flag_stack_check, 1 },
+  {"argument-alias", &flag_argument_noalias, 0 },
+  {"argument-noalias", &flag_argument_noalias, 1 },
+  {"argument-noalias-global", &flag_argument_noalias, 2 },
+  {"strict-aliasing", &flag_strict_aliasing, 1 },
+  {"align-loops", &align_loops, 0 },
+  {"align-jumps", &align_jumps, 0 },
+  {"align-labels", &align_labels, 0 },
+  {"align-functions", &align_functions, 0 },
+  {"merge-constants", &flag_merge_constants, 1 },
+  {"merge-all-constants", &flag_merge_constants, 2 },
+  {"dump-unnumbered", &flag_dump_unnumbered, 1 },
+  {"instrument-functions", &flag_instrument_function_entry_exit, 1 },
+  {"zero-initialized-in-bss", &flag_zero_initialized_in_bss, 1 },
+  {"ssa", &flag_ssa, 1 },
+  {"ssa-ccp", &flag_ssa_ccp, 1 },
+  {"ssa-dce", &flag_ssa_dce, 1 },
+  {"leading-underscore", &flag_leading_underscore, 1 },
+  {"ident", &flag_no_ident, 0 },
+  { "peephole2", &flag_peephole2, 1 },
+  {"finite-math-only", &flag_finite_math_only, 1 },
+  { "guess-branch-probability", &flag_guess_branch_prob, 1 },
+  {"math-errno", &flag_errno_math, 1 },
+  {"trapping-math", &flag_trapping_math, 1 },
+  {"unsafe-math-optimizations", &flag_unsafe_math_optimizations, 1 },
+  {"signaling-nans", &flag_signaling_nans, 1 },
+  {"bounds-check", &flag_bounds_check, 1 },
+  {"single-precision-constant", &flag_single_precision_constant, 1 },
+  {"time-report", &time_report, 1 },
+  {"mem-report", &mem_report, 1 },
+  { "trapv", &flag_trapv, 1 },
+  { "wrapv", &flag_wrapv, 1 },
+  { "new-ra", &flag_new_regalloc, 1 }
 };
 
 /* Table of language-specific options.  */
@@ -3890,15 +3774,6 @@ display_help (void)
   unsigned long i;
   const char *lang;
 
-  for (i = ARRAY_SIZE (f_options); i--;)
-    {
-      const char *description = f_options[i].description;
-
-      if (description != NULL && *description != 0)
-	printf ("  -f%-21s %s\n",
-		f_options[i].string, _(description));
-    }
-
   for (i = LAST_PARAM; i--;)
     {
       const char *description = compiler_params[i].help;