OpenE2K/gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

toplev.c (flag_dummy): Remove.

Browse Source 
* toplev.c (flag_dummy): Remove.
	(f_options): Restore flag pointers.

From-SVN: r68661
This commit is contained in:
Neil Booth 2003-06-29 08:18:17 +00:00 committed by Neil Booth
parent 7177e7205a
commit dfb827711d
2 changed files with 122 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
gcc/ChangeLog
View File

@ -1,3 +1,8 @@
2003-06-29 Neil Booth <neil@daikokuya.co.uk>
* toplev.c (flag_dummy): Remove.
(f_options): Restore flag pointers.
2003-06-29 David Edelsohn <edelsohn@gnu.org> 2003-06-29 David Edelsohn <edelsohn@gnu.org>
* config/rs6000/rs6000.c (processor_target_table): Add 970. * config/rs6000/rs6000.c (processor_target_table): Add 970.

239
gcc/toplev.c
View File

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