dump_base_name = arg;
break;
+ case OPT_fPIC:
+ flag_pic = value + value;
+ break;
+
+ case OPT_fPIE:
+ flag_pie = value + value;
+ break;
+
+ case OPT_falign_functions:
case OPT_falign_functions_:
align_functions = value;
break;
+ case OPT_falign_jumps:
case OPT_falign_jumps_:
align_jumps = value;
break;
+ case OPT_falign_labels:
case OPT_falign_labels_:
align_labels = value;
break;
+ case OPT_falign_loops:
case OPT_falign_loops_:
align_loops = value;
break;
+ case OPT_fargument_alias:
+ flag_argument_noalias = !value;
+ break;
+
+ case OPT_fargument_noalias:
+ flag_argument_noalias = value;
+ break;
+
+ case OPT_fargument_noalias_global:
+ flag_argument_noalias = value + value;
+ break;
+
+ case OPT_fasynchronous_unwind_tables:
+ flag_asynchronous_unwind_tables = value;
+ break;
+
+ case OPT_fbounds_check:
+ flag_bounds_check = value;
+ break;
+
+ case OPT_fbranch_count_reg:
+ flag_branch_on_count_reg = value;
+ break;
+
+ case OPT_fbranch_probabilities:
+ flag_branch_probabilities = value;
+ break;
+
case OPT_fbranch_target_load_optimize:
flag_branch_target_load_optimize = value;
break;
flag_caller_saves = value;
break;
+ case OPT_fcommon:
+ flag_no_common = !value;
+ break;
+
+ case OPT_fcprop_registers:
+ flag_cprop_registers = value;
+ break;
+
case OPT_fcrossjumping:
flag_crossjumping = value;
break;
flag_cse_skip_blocks = value;
break;
+ case OPT_fdata_sections:
+ flag_data_sections = value;
+ break;
+
case OPT_fdefer_pop:
flag_defer_pop = value;
break;
return 0;
break;
+ case OPT_fdump_unnumbered:
+ flag_dump_unnumbered = value;
+ break;
+
case OPT_feliminate_dwarf2_dups:
flag_eliminate_dwarf2_dups = value;
break;
flag_eliminate_unused_debug_types = value;
break;
+ case OPT_fexceptions:
+ flag_exceptions = value;
+ break;
+
case OPT_fexpensive_optimizations:
flag_expensive_optimizations = value;
break;
set_fast_math_flags (value);
break;
+ case OPT_ffinite_math_only:
+ flag_finite_math_only = value;
+ break;
+
case OPT_ffixed_:
fix_register (arg, 1, 1);
break;
flag_force_mem = value;
break;
+ case OPT_ffunction_sections:
+ flag_function_sections = value;
+ break;
+
case OPT_fgcse:
flag_gcse = value;
break;
flag_gcse_sm = value;
break;
+ case OPT_fgnu_linker:
+ flag_gnu_linker = value;
+ break;
+
+ case OPT_fguess_branch_probability:
+ flag_guess_branch_prob = value;
+ break;
+
+ case OPT_fident:
+ flag_no_ident = !value;
+ break;
+
case OPT_fif_conversion:
flag_if_conversion = value;
break;
flag_if_conversion2 = value;
break;
+ case OPT_finhibit_size_directive:
+ flag_inhibit_size_directive = value;
+ break;
+
case OPT_finline:
flag_no_inline = !value;
break;
flag_inline_functions = value;
break;
+ case OPT_finstrument_functions:
+ flag_instrument_function_entry_exit = value;
+ break;
+
case OPT_fkeep_inline_functions:
flag_keep_inline_functions =value;
break;
flag_keep_static_consts = value;
break;
+ case OPT_fleading_underscore:
+ flag_leading_underscore = value;
+ break;
+
case OPT_floop_optimize:
flag_loop_optimize = value;
break;
+ case OPT_fmath_errno:
+ flag_errno_math = value;
+ break;
+
+ case OPT_fmem_report:
+ mem_report = value;
+ break;
+
+ case OPT_fmerge_all_constants:
+ flag_merge_constants = value + value;
+ break;
+
+ case OPT_fmerge_constants:
+ flag_merge_constants = value;
+ break;
+
case OPT_fmessage_length_:
output_set_maximum_length (&global_dc->buffer, value);
break;
flag_move_all_movables = value;
break;
+ case OPT_fnew_ra:
+ flag_new_regalloc = value;
+ break;
+
+ case OPT_fnon_call_exceptions:
+ flag_non_call_exceptions = value;
+ break;
+
case OPT_fold_unroll_all_loops:
flag_old_unroll_all_loops = value;
break;
flag_omit_frame_pointer = value;
break;
+ case OPT_foptimize_register_move:
+ flag_regmove = value;
+ break;
+
case OPT_foptimize_sibling_calls:
flag_optimize_sibling_calls = value;
break;
+ case OPT_fpack_struct:
+ flag_pack_struct = value;
+ break;
+
case OPT_fpeel_loops:
flag_peel_loops = value;
break;
flag_no_peephole = !value;
break;
+ case OPT_fpeephole2:
+ flag_peephole2 = value;
+ break;
+
+ case OPT_fpic:
+ flag_pic = value;
+ break;
+
+ case OPT_fpie:
+ flag_pie = value;
+ break;
+
case OPT_fprefetch_loop_arrays:
flag_prefetch_loop_arrays = value;
break;
+ case OPT_fprofile:
+ profile_flag = value;
+ break;
+
+ case OPT_fprofile_arcs:
+ profile_arc_flag = value;
+ break;
+
case OPT_frandom_seed:
/* The real switch is -fno-random-seed. */
if (value)
flag_pcc_struct_return = !value;
break;
+ case OPT_fregmove:
+ flag_regmove = value;
+ break;
+
+ case OPT_frename_registers:
+ flag_rename_registers = value;
+ break;
+
+ case OPT_freorder_blocks:
+ flag_reorder_blocks = value;
+ break;
+
+ case OPT_freorder_functions:
+ flag_reorder_functions = value;
+ break;
+
case OPT_frerun_cse_after_loop:
flag_rerun_cse_after_loop = value;
break;
flag_rerun_loop_opt = value;
break;
+ case OPT_fsched_interblock:
+ flag_schedule_interblock= value;
+ break;
+
+ case OPT_fsched_spec:
+ flag_schedule_speculative = value;
+ break;
+
+ case OPT_fsched_spec_load:
+ flag_schedule_speculative_load = value;
+ break;
+
+ case OPT_fsched_spec_load_dangerous:
+ flag_schedule_speculative_load_dangerous = value;
+ break;
+
case OPT_fsched_verbose_:
#ifdef INSN_SCHEDULING
fix_sched_param ("verbose", arg);
return 0;
#endif
+ case OPT_fsched2_use_superblocks:
+ flag_sched2_use_superblocks = value;
+ break;
+
+ case OPT_fsched2_use_traces:
+ flag_sched2_use_traces = value;
+ break;
+
case OPT_fschedule_insns:
flag_schedule_insns = value;
break;
flag_shared_data = value;
break;
+ case OPT_fsignaling_nans:
+ flag_signaling_nans = value;
+ break;
+
+ case OPT_fsingle_precision_constant:
+ flag_single_precision_constant = value;
+ break;
+
+ case OPT_fssa:
+ flag_ssa = value;
+ break;
+
+ case OPT_fssa_ccp:
+ flag_ssa_ccp = value;
+ break;
+
+ case OPT_fssa_dce:
+ flag_ssa_dce = value;
+ break;
+
+ case OPT_fstack_check:
+ flag_stack_check = value;
+ break;
+
case OPT_fstack_limit:
/* The real switch is -fno-stack-limit. */
if (value)
flag_strength_reduce = value;
break;
+ case OPT_fstrict_aliasing:
+ flag_strict_aliasing = value;
+ break;
+
case OPT_fsyntax_only:
flag_syntax_only = value;
break;
+ case OPT_ftest_coverage:
+ flag_test_coverage = value;
+ break;
+
case OPT_fthread_jumps:
flag_thread_jumps = value;
break;
+ case OPT_ftime_report:
+ time_report = value;
+
case OPT_ftls_model_:
if (!strcmp (arg, "global-dynamic"))
flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
flag_tracer = value;
break;
+ case OPT_ftrapping_math:
+ flag_trapping_math = value;
+ break;
+
+ case OPT_ftrapv:
+ flag_trapv = value;
+ break;
+
case OPT_funit_at_a_time:
flag_unit_at_a_time = value;
break;
flag_unroll_loops = value;
break;
+ case OPT_funsafe_math_optimizations:
+ flag_unsafe_math_optimizations = value;
+ break;
+
case OPT_funswitch_loops:
flag_unswitch_loops = value;
break;
+ case OPT_funwind_tables:
+ flag_unwind_tables = value;
+ break;
+
+ case OPT_fverbose_asm:
+ flag_verbose_asm = value;
+ break;
+
+ case OPT_fwrapv:
+ flag_wrapv = value;
+ break;
+
case OPT_fwritable_strings:
flag_writable_strings = value;
break;
+ case OPT_fzero_initialized_in_bss:
+ flag_zero_initialized_in_bss = value;
+ break;
+
case OPT_g:
decode_g_option (arg);
break;
/* Print times taken by the various passes. -ftime-report. */
-static int time_report = 0;
+int time_report = 0;
/* Print memory still in use at end of compilation (which may have little
to do with peak memory consumption). -fmem-report. */
N_("Reschedule instructions before register allocation") },
{"schedule-insns2", &flag_dummy, 1,
N_("Reschedule instructions after register allocation") },
- {"sched-interblock",&flag_schedule_interblock, 1,
+ {"sched-interblock",&flag_dummy, 1,
N_("Enable scheduling across basic blocks") },
- {"sched-spec",&flag_schedule_speculative, 1,
+ {"sched-spec",&flag_dummy, 1,
N_("Allow speculative motion of non-loads") },
- {"sched-spec-load",&flag_schedule_speculative_load, 1,
+ {"sched-spec-load",&flag_dummy, 1,
N_("Allow speculative motion of some loads") },
- {"sched-spec-load-dangerous",&flag_schedule_speculative_load_dangerous, 1,
+ {"sched-spec-load-dangerous",&flag_dummy, 1,
N_("Allow speculative motion of more loads") },
- {"sched2-use-superblocks", &flag_sched2_use_superblocks, 1,
+ {"sched2-use-superblocks", &flag_dummy, 1,
N_("If scheduling post reload, do superblock scheduling") },
- {"sched2-use-traces", &flag_sched2_use_traces, 1,
+ {"sched2-use-traces", &flag_dummy, 1,
N_("If scheduling post reload, do trace scheduling") },
- {"branch-count-reg",&flag_branch_on_count_reg, 1,
+ {"branch-count-reg",&flag_dummy, 1,
N_("Replace add,compare,branch with branch on count reg") },
- {"pic", &flag_pic, 1,
+ {"pic", &flag_dummy, 1,
N_("Generate position independent code, if possible") },
- {"PIC", &flag_pic, 2, ""},
- {"pie", &flag_pie, 1,
+ {"PIC", &flag_dummy, 2, ""},
+ {"pie", &flag_dummy, 1,
N_("Generate position independent code for executables, if possible") },
- {"PIE", &flag_pie, 2, ""},
- {"exceptions", &flag_exceptions, 1,
+ {"PIE", &flag_dummy, 2, ""},
+ {"exceptions", &flag_dummy, 1,
N_("Enable exception handling") },
- {"unwind-tables", &flag_unwind_tables, 1,
+ {"unwind-tables", &flag_dummy, 1,
N_("Just generate unwind tables for exception handling") },
- {"asynchronous-unwind-tables", &flag_asynchronous_unwind_tables, 1,
+ {"asynchronous-unwind-tables", &flag_dummy, 1,
N_("Generate unwind tables exact at each instruction boundary") },
- {"non-call-exceptions", &flag_non_call_exceptions, 1,
+ {"non-call-exceptions", &flag_dummy, 1,
N_("Support synchronous non-call exceptions") },
- {"profile-arcs", &profile_arc_flag, 1,
+ {"profile-arcs", &flag_dummy, 1,
N_("Insert arc based program profiling code") },
- {"test-coverage", &flag_test_coverage, 1,
+ {"test-coverage", &flag_dummy, 1,
N_("Create data files needed by gcov") },
- {"branch-probabilities", &flag_branch_probabilities, 1,
+ {"branch-probabilities", &flag_dummy, 1,
N_("Use profiling information for branch probabilities") },
- {"profile", &profile_flag, 1,
+ {"profile", &flag_dummy, 1,
N_("Enable basic program profiling code") },
- {"reorder-blocks", &flag_reorder_blocks, 1,
+ {"reorder-blocks", &flag_dummy, 1,
N_("Reorder basic blocks to improve code placement") },
- {"reorder-functions", &flag_reorder_functions, 1,
+ {"reorder-functions", &flag_dummy, 1,
N_("Reorder functions to improve code placement") },
- {"rename-registers", &flag_rename_registers, 1,
+ {"rename-registers", &flag_dummy, 1,
N_("Do the register renaming optimization pass") },
- {"cprop-registers", &flag_cprop_registers, 1,
+ {"cprop-registers", &flag_dummy, 1,
N_("Do the register copy-propagation optimization pass") },
- {"common", &flag_no_common, 0,
+ {"common", &flag_dummy, 0,
N_("Do not put uninitialized globals in the common section") },
- {"inhibit-size-directive", &flag_inhibit_size_directive, 1,
+ {"inhibit-size-directive", &flag_dummy, 1,
N_("Do not generate .size directives") },
- {"function-sections", &flag_function_sections, 1,
+ {"function-sections", &flag_dummy, 1,
N_("place each function into its own section") },
- {"data-sections", &flag_data_sections, 1,
+ {"data-sections", &flag_dummy, 1,
N_("place data items into their own section") },
- {"verbose-asm", &flag_verbose_asm, 1,
+ {"verbose-asm", &flag_dummy, 1,
N_("Add extra commentary to assembler output") },
- {"gnu-linker", &flag_gnu_linker, 1,
+ {"gnu-linker", &flag_dummy, 1,
N_("Output GNU ld formatted global initializers") },
- {"regmove", &flag_regmove, 1,
+ {"regmove", &flag_dummy, 1,
N_("Enables a register move optimization") },
- {"optimize-register-move", &flag_regmove, 1,
+ {"optimize-register-move", &flag_dummy, 1,
N_("Do the full regmove optimization pass") },
- {"pack-struct", &flag_pack_struct, 1,
+ {"pack-struct", &flag_dummy, 1,
N_("Pack structure members together without holes") },
- {"stack-check", &flag_stack_check, 1,
+ {"stack-check", &flag_dummy, 1,
N_("Insert stack checking code into the program") },
- {"argument-alias", &flag_argument_noalias, 0,
+ {"argument-alias", &flag_dummy, 0,
N_("Specify that arguments may alias each other & globals") },
- {"argument-noalias", &flag_argument_noalias, 1,
+ {"argument-noalias", &flag_dummy, 1,
N_("Assume arguments may alias globals but not each other") },
- {"argument-noalias-global", &flag_argument_noalias, 2,
+ {"argument-noalias-global", &flag_dummy, 2,
N_("Assume arguments do not alias each other or globals") },
- {"strict-aliasing", &flag_strict_aliasing, 1,
+ {"strict-aliasing", &flag_dummy, 1,
N_("Assume strict aliasing rules apply") },
- {"align-loops", &align_loops, 0,
+ {"align-loops", &flag_dummy, 0,
N_("Align the start of loops") },
- {"align-jumps", &align_jumps, 0,
+ {"align-jumps", &flag_dummy, 0,
N_("Align labels which are only reached by jumping") },
- {"align-labels", &align_labels, 0,
+ {"align-labels", &flag_dummy, 0,
N_("Align all labels") },
- {"align-functions", &align_functions, 0,
+ {"align-functions", &flag_dummy, 0,
N_("Align the start of functions") },
- {"merge-constants", &flag_merge_constants, 1,
+ {"merge-constants", &flag_dummy, 1,
N_("Attempt to merge identical constants across compilation units") },
- {"merge-all-constants", &flag_merge_constants, 2,
+ {"merge-all-constants", &flag_dummy, 2,
N_("Attempt to merge identical constants and constant variables") },
- {"dump-unnumbered", &flag_dump_unnumbered, 1,
+ {"dump-unnumbered", &flag_dummy, 1,
N_("Suppress output of instruction numbers and line number notes in debugging dumps") },
- {"instrument-functions", &flag_instrument_function_entry_exit, 1,
+ {"instrument-functions", &flag_dummy, 1,
N_("Instrument function entry/exit with profiling calls") },
- {"zero-initialized-in-bss", &flag_zero_initialized_in_bss, 1,
+ {"zero-initialized-in-bss", &flag_dummy, 1,
N_("Put zero initialized data in the bss section") },
- {"ssa", &flag_ssa, 1,
+ {"ssa", &flag_dummy, 1,
N_("Enable SSA optimizations") },
- {"ssa-ccp", &flag_ssa_ccp, 1,
+ {"ssa-ccp", &flag_dummy, 1,
N_("Enable SSA conditional constant propagation") },
- {"ssa-dce", &flag_ssa_dce, 1,
+ {"ssa-dce", &flag_dummy, 1,
N_("Enable aggressive SSA dead code elimination") },
- {"leading-underscore", &flag_leading_underscore, 1,
+ {"leading-underscore", &flag_dummy, 1,
N_("External symbols have a leading underscore") },
- {"ident", &flag_no_ident, 0,
+ {"ident", &flag_dummy, 0,
N_("Process #ident directives") },
- { "peephole2", &flag_peephole2, 1,
+ { "peephole2", &flag_dummy, 1,
N_("Enables an rtl peephole pass run before sched2") },
- {"finite-math-only", &flag_finite_math_only, 1,
+ {"finite-math-only", &flag_dummy, 1,
N_("Assume no NaNs or +-Infs are generated") },
- { "guess-branch-probability", &flag_guess_branch_prob, 1,
+ { "guess-branch-probability", &flag_dummy, 1,
N_("Enables guessing of branch probabilities") },
- {"math-errno", &flag_errno_math, 1,
+ {"math-errno", &flag_dummy, 1,
N_("Set errno after built-in math functions") },
- {"trapping-math", &flag_trapping_math, 1,
+ {"trapping-math", &flag_dummy, 1,
N_("Floating-point operations can trap") },
- {"unsafe-math-optimizations", &flag_unsafe_math_optimizations, 1,
+ {"unsafe-math-optimizations", &flag_dummy, 1,
N_("Allow math optimizations that may violate IEEE or ANSI standards") },
- {"signaling-nans", &flag_signaling_nans, 1,
+ {"signaling-nans", &flag_dummy, 1,
N_("Disable optimizations observable by IEEE signaling NaNs") },
- {"bounds-check", &flag_bounds_check, 1,
+ {"bounds-check", &flag_dummy, 1,
N_("Generate code to check bounds before indexing arrays") },
- {"single-precision-constant", &flag_single_precision_constant, 1,
+ {"single-precision-constant", &flag_dummy, 1,
N_("Convert floating point constant to single precision constant") },
- {"time-report", &time_report, 1,
+ {"time-report", &flag_dummy, 1,
N_("Report time taken by each compiler pass at end of run") },
- {"mem-report", &mem_report, 1,
+ {"mem-report", &flag_dummy, 1,
N_("Report on permanent memory allocation at end of run") },
- { "trapv", &flag_trapv, 1,
+ { "trapv", &flag_dummy, 1,
N_("Trap for signed overflow in addition / subtraction / multiplication") },
- { "wrapv", &flag_wrapv, 1,
+ { "wrapv", &flag_dummy, 1,
N_("Assume signed arithmetic overflow wraps around") },
- { "new-ra", &flag_new_regalloc, 1,
+ { "new-ra", &flag_dummy, 1,
N_("Use graph coloring register allocation.") },
};
static int
decode_f_option (const char *arg)
{
- int j;
- const char *option_value = NULL;
-
- /* Search for the option in the table of binary f options. */
- for (j = ARRAY_SIZE (f_options); j--;)
- {
- if (!strcmp (arg, f_options[j].string))
- {
- *f_options[j].variable = f_options[j].on_value;
- return 1;
- }
-
- if (arg[0] == 'n' && arg[1] == 'o' && arg[2] == '-'
- && ! strcmp (arg + 3, f_options[j].string))
- {
- *f_options[j].variable = ! f_options[j].on_value;
- return 1;
- }
- }
+ const char *option_value;
if ((option_value = skip_leading_substring (arg, "inline-limit-"))
|| (option_value = skip_leading_substring (arg, "inline-limit=")))