From f3fdaec48d8cd520d5b7c70136ea551155a10257 Mon Sep 17 00:00:00 2001 From: Neil Booth Date: Fri, 11 Jul 2003 05:35:06 +0000 Subject: [PATCH] common.opt: More --help messages. * 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. From-SVN: r69217 --- gcc/ChangeLog | 7 + gcc/common.opt | 117 +++++++++++++++- gcc/opts.c | 2 +- gcc/toplev.c | 359 ++++++++++++++++--------------------------------- 4 files changed, 241 insertions(+), 244 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index fd9ae8c8f35..928de65804b 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,10 @@ +2003-07-11 Neil Booth + + * 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 * fixinc/mkfixinc.sh: Drop reference to unsupported alpha-*-interix*. diff --git a/gcc/common.opt b/gcc/common.opt index 44d8381a1ee..7f1e995c30b 100644 --- a/gcc/common.opt +++ b/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 diff --git a/gcc/opts.c b/gcc/opts.c index f9951a6a3cc..64f5ec6cda3 100644 --- a/gcc/opts.c +++ b/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++) { diff --git a/gcc/toplev.c b/gcc/toplev.c index bfc7bb1ea9a..0369489ec54 100644 --- a/gcc/toplev.c +++ b/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;