X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fopts.c;h=cd9e8e3db72acce449c740112b146605026c450b;hb=911eca6f674f32320415982ed992ae6ab191d08a;hp=2712346149f09f1833ab6b6c343bbf059f94d3c7;hpb=39470ac3d71a90889a3d4105a1a1ad7dc8380169;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/opts.c b/gcc/opts.c index 2712346149f..cd9e8e3db72 100644 --- a/gcc/opts.c +++ b/gcc/opts.c @@ -1,5 +1,5 @@ /* Command line option handling. - Copyright (C) 2002, 2003 Free Software Foundation, Inc. + Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc. Contributed by Neil Booth. This file is part of GCC. @@ -21,6 +21,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #include "config.h" #include "system.h" +#include "intl.h" #include "coretypes.h" #include "tm.h" #include "tree.h" @@ -34,6 +35,9 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #include "toplev.h" #include "params.h" #include "diagnostic.h" +#include "tm_p.h" /* For OPTIMIZATION_OPTIONS. */ +#include "insn-attr.h" /* For INSN_SCHEDULING. */ +#include "target.h" /* Value of the -G xx switch, and whether it was passed or not. */ unsigned HOST_WIDE_INT g_switch_value; @@ -96,7 +100,7 @@ bool warn_shadow; /* Nonzero means warn about constructs which might not be strict-aliasing safe. */ -bool warn_strict_aliasing; +int warn_strict_aliasing; /* True to warn if a switch on an enum, that does not have a default case, fails to have a case for every enum value. */ @@ -125,10 +129,53 @@ bool warn_unused_value; /* Hack for cooperation between set_Wunused and set_Wextra. */ static bool maybe_warn_unused_parameter; +/* Type(s) of debugging information we are producing (if any). See + flags.h for the definitions of the different possible types of + debugging information. */ +enum debug_info_type write_symbols = NO_DEBUG; + +/* Level of debugging information we are producing. See flags.h for + the definitions of the different possible levels. */ +enum debug_info_level debug_info_level = DINFO_LEVEL_NONE; + +/* Nonzero means use GNU-only extensions in the generated symbolic + debugging information. Currently, this only has an effect when + write_symbols is set to DBX_DEBUG, XCOFF_DEBUG, or DWARF_DEBUG. */ +bool use_gnu_debug_info_extensions; + +/* Columns of --help display. */ +static unsigned int columns = 80; + +/* What to print when a switch has no documentation. */ +static const char undocumented_msg[] = N_("This switch lacks documentation"); + +/* Used for bookkeeping on whether user set these flags so + -fprofile-use/-fprofile-generate does not use them. */ +static bool profile_arc_flag_set, flag_profile_values_set; +static bool flag_unroll_loops_set, flag_tracer_set; +static bool flag_value_profile_transformations_set; +static bool flag_peel_loops_set, flag_branch_probabilities_set; + +/* Input file names. */ +const char **in_fnames; +unsigned num_in_fnames; + static size_t find_opt (const char *, int); static int common_handle_option (size_t scode, const char *arg, int value); static void handle_param (const char *); static void set_Wextra (int); +static unsigned int handle_option (const char **argv, unsigned int lang_mask); +static char *write_langs (unsigned int lang_mask); +static void complain_wrong_lang (const char *, const struct cl_option *, + unsigned int lang_mask); +static void handle_options (unsigned int, const char **, unsigned int); +static void wrap_help (const char *help, const char *item, unsigned int); +static void print_help (void); +static void print_param_help (void); +static void print_filtered_help (unsigned int flag); +static unsigned int print_switch (const char *text, unsigned int indent); +static void set_debug_level (enum debug_info_type type, int extended, + const char *arg); /* Perform a binary search to find which option the command-line INPUT matches. Returns its index in the option array, and N_OPTS @@ -170,7 +217,7 @@ find_opt (const char *input, int lang_mask) { md = (mn + mx) / 2; opt_len = cl_options[md].opt_len; - comp = strncmp (input, cl_options[md].opt_text, opt_len); + comp = strncmp (input, cl_options[md].opt_text + 1, opt_len); if (comp < 0) mx = md; @@ -190,7 +237,7 @@ find_opt (const char *input, int lang_mask) const struct cl_option *opt = &cl_options[mn]; /* Is this switch a prefix of the input? */ - if (!strncmp (input, opt->opt_text, opt->opt_len)) + if (!strncmp (input, opt->opt_text + 1, opt->opt_len)) { /* If language is OK, and the match is exact or the switch takes a joined argument, return it. */ @@ -200,7 +247,7 @@ find_opt (const char *input, int lang_mask) /* If we haven't remembered a prior match, remember this one. Any prior match is necessarily better. */ - if (match_wrong_lang != cl_options_count) + if (match_wrong_lang == cl_options_count) match_wrong_lang = mn; } @@ -230,109 +277,417 @@ integral_argument (const char *arg) return -1; } -/* Handle the switch beginning at ARGV, with ARGC remaining. */ -int -handle_option (int argc ATTRIBUTE_UNUSED, char **argv, int lang_mask) +/* Return a malloced slash-separated list of languages in MASK. */ +static char * +write_langs (unsigned int mask) +{ + unsigned int n = 0, len = 0; + const char *lang_name; + char *result; + + for (n = 0; (lang_name = lang_names[n]) != 0; n++) + if (mask & (1U << n)) + len += strlen (lang_name) + 1; + + result = xmalloc (len); + len = 0; + for (n = 0; (lang_name = lang_names[n]) != 0; n++) + if (mask & (1U << n)) + { + if (len) + result[len++] = '/'; + strcpy (result + len, lang_name); + len += strlen (lang_name); + } + + result[len] = 0; + + return result; +} + +/* Complain that switch OPT_INDEX does not apply to this front end. */ +static void +complain_wrong_lang (const char *text, const struct cl_option *option, + unsigned int lang_mask) +{ + char *ok_langs, *bad_lang; + + ok_langs = write_langs (option->flags); + bad_lang = write_langs (lang_mask); + + /* Eventually this should become a hard error IMO. */ + warning ("command line option \"%s\" is valid for %s but not for %s", + text, ok_langs, bad_lang); + + free (ok_langs); + free (bad_lang); +} + +/* Handle the switch beginning at ARGV for the language indicated by + LANG_MASK. Returns the number of switches consumed. */ +static unsigned int +handle_option (const char **argv, unsigned int lang_mask) { size_t opt_index; const char *opt, *arg = 0; char *dup = 0; int value = 1; - int result = 0; + unsigned int result = 0; const struct cl_option *option; opt = argv[0]; - /* Interpret "-" or a non-switch as a file name. */ - if (opt[0] != '-' || opt[1] == '\0') + /* Drop the "no-" from negative switches. */ + if ((opt[1] == 'W' || opt[1] == 'f') + && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-') { - opt_index = cl_options_count; - arg = opt; - main_input_filename = opt; - result = (*lang_hooks.handle_option) (opt_index, arg, value); + size_t len = strlen (opt) - 3; + + dup = xmalloc (len + 1); + dup[0] = '-'; + dup[1] = opt[1]; + memcpy (dup + 2, opt + 5, len - 2 + 1); + opt = dup; + value = 0; } - else + + opt_index = find_opt (opt + 1, lang_mask | CL_COMMON); + if (opt_index == cl_options_count) + goto done; + + option = &cl_options[opt_index]; + + /* Reject negative form of switches that don't take negatives as + unrecognized. */ + if (!value && (option->flags & CL_REJECT_NEGATIVE)) + goto done; + + /* We've recognized this switch. */ + result = 1; + + /* Sort out any argument the switch takes. */ + if (option->flags & CL_JOINED) { - /* Drop the "no-" from negative switches. */ - if ((opt[1] == 'W' || opt[1] == 'f') - && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-') + /* Have arg point to the original switch. This is because + some code, such as disable_builtin_function, expects its + argument to be persistent until the program exits. */ + arg = argv[0] + cl_options[opt_index].opt_len + 1; + if (!value) + arg += strlen ("no-"); + + if (*arg == '\0' && !(option->flags & CL_MISSING_OK)) { - size_t len = strlen (opt) - 3; - - dup = xmalloc (len + 1); - dup[0] = '-'; - dup[1] = opt[1]; - memcpy (dup + 2, opt + 5, len - 2 + 1); - opt = dup; - value = 0; + if (option->flags & CL_SEPARATE) + { + arg = argv[1]; + result = 2; + } + else + /* Missing argument. */ + arg = NULL; } + } + else if (option->flags & CL_SEPARATE) + { + arg = argv[1]; + result = 2; + } - opt_index = find_opt (opt + 1, lang_mask | CL_COMMON); - if (opt_index == cl_options_count) - goto done; + /* Now we've swallowed any potential argument, complain if this + is a switch for a different front end. */ + if (!(option->flags & (lang_mask | CL_COMMON))) + { + complain_wrong_lang (argv[0], option, lang_mask); + goto done; + } - option = &cl_options[opt_index]; + if (arg == NULL && (option->flags & (CL_JOINED | CL_SEPARATE))) + { + if (!lang_hooks.missing_argument (opt, opt_index)) + error ("missing argument to \"%s\"", opt); + goto done; + } - /* Reject negative form of switches that don't take negatives. */ - if (!value && (option->flags & CL_REJECT_NEGATIVE)) - goto done; + /* If the switch takes an integer, convert it. */ + if (arg && (option->flags & CL_UINTEGER)) + { + value = integral_argument (arg); + if (value == -1) + { + error ("argument to \"%s\" should be a non-negative integer", + option->opt_text); + goto done; + } + } - /* We've recognized this switch. */ - result = 1; + if (option->flags & lang_mask) + if (lang_hooks.handle_option (opt_index, arg, value) == 0) + result = 0; - /* Sort out any argument the switch takes. */ - if (option->flags & CL_JOINED) + if (result && (option->flags & CL_COMMON)) + if (common_handle_option (opt_index, arg, value) == 0) + result = 0; + + done: + if (dup) + free (dup); + return result; +} + +/* Decode and handle the vector of command line options. LANG_MASK + contains has a single bit set representing the current + language. */ +static void +handle_options (unsigned int argc, const char **argv, unsigned int lang_mask) +{ + unsigned int n, i; + + for (i = 1; i < argc; i += n) + { + const char *opt = argv[i]; + + /* Interpret "-" or a non-switch as a file name. */ + if (opt[0] != '-' || opt[1] == '\0') { - /* Have arg point to the original switch. This is because - some code, such as disable_builtin_function, expects its - argument to be persistent until the program exits. */ - arg = argv[0] + cl_options[opt_index].opt_len + 1; - if (!value) - arg += strlen ("no-"); - - if (*arg == '\0' && !(option->flags & CL_MISSING_OK)) - { - if (option->flags & CL_SEPARATE) - { - arg = argv[1]; - result = 2; - } - else - /* Missing argument. */ - arg = NULL; - } + if (main_input_filename == NULL) + main_input_filename = opt; + add_input_filename (opt); + n = 1; + continue; } - else if (option->flags & CL_SEPARATE) + + n = handle_option (argv + i, lang_mask); + + if (!n) { - arg = argv[1]; - result = 2; + n = 1; + error ("unrecognized command line option \"%s\"", opt); } + } +} - /* If the switch takes an integer, convert it. */ - if (arg && (option->flags & CL_UINTEGER)) +/* Handle FILENAME from the command line. */ +void +add_input_filename (const char *filename) +{ + num_in_fnames++; + in_fnames = xrealloc (in_fnames, num_in_fnames * sizeof (in_fnames[0])); + in_fnames[num_in_fnames - 1] = filename; +} + +/* Parse command line options and set default flag values. Do minimal + options processing. */ +void +decode_options (unsigned int argc, const char **argv) +{ + unsigned int i, lang_mask; + + /* Perform language-specific options initialization. */ + lang_mask = lang_hooks.init_options (argc, argv); + + lang_hooks.initialize_diagnostics (global_dc); + + /* Scan to see what optimization level has been specified. That will + determine the default value of many flags. */ + for (i = 1; i < argc; i++) + { + if (!strcmp (argv[i], "-O")) { - value = integral_argument (arg); - if (value == -1) + optimize = 1; + optimize_size = 0; + } + else if (argv[i][0] == '-' && argv[i][1] == 'O') + { + /* Handle -Os, -O2, -O3, -O69, ... */ + const char *p = &argv[i][2]; + + if ((p[0] == 's') && (p[1] == 0)) { - error ("argument to \"-%s\" should be a non-negative integer", - option->opt_text); - goto done; + optimize_size = 1; + + /* Optimizing for size forces optimize to be 2. */ + optimize = 2; + } + else + { + const int optimize_val = read_integral_parameter (p, p - 2, -1); + if (optimize_val != -1) + { + optimize = optimize_val; + optimize_size = 0; + } } } + } + + if (!optimize) + { + flag_merge_constants = 0; + } + + if (optimize >= 1) + { + flag_defer_pop = 1; + flag_thread_jumps = 1; +#ifdef DELAY_SLOTS + flag_delayed_branch = 1; +#endif +#ifdef CAN_DEBUG_WITHOUT_FP + flag_omit_frame_pointer = 1; +#endif + flag_guess_branch_prob = 1; + flag_cprop_registers = 1; + flag_loop_optimize = 1; + flag_if_conversion = 1; + flag_if_conversion2 = 1; + flag_tree_ccp = 1; + flag_tree_dce = 1; + flag_tree_dom = 1; + flag_tree_dse = 1; + flag_tree_pre = 1; + flag_tree_ter = 1; + flag_tree_live_range_split = 1; + flag_tree_sra = 1; + flag_tree_copyrename = 1; + + if (!optimize_size) + { + /* Loop header copying usually increases size of the code. This used + not to be true, since quite often it is possible to verify that + the condition is satisfied in the first iteration and therefore + to eliminate it. Jump threading handles these cases now. */ + flag_tree_ch = 1; + } + } + + if (optimize >= 2) + { + flag_crossjumping = 1; + flag_optimize_sibling_calls = 1; + flag_cse_follow_jumps = 1; + flag_cse_skip_blocks = 1; + flag_gcse = 1; + flag_expensive_optimizations = 1; + flag_strength_reduce = 1; + flag_rerun_cse_after_loop = 1; + flag_rerun_loop_opt = 1; + flag_caller_saves = 1; + flag_force_mem = 1; + flag_peephole2 = 1; +#ifdef INSN_SCHEDULING + flag_schedule_insns = 1; + flag_schedule_insns_after_reload = 1; +#endif + flag_regmove = 1; + flag_strict_aliasing = 1; + flag_delete_null_pointer_checks = 1; + flag_reorder_blocks = 1; + flag_reorder_functions = 1; + flag_unit_at_a_time = 1; + } - if (option->flags & lang_mask) - if ((*lang_hooks.handle_option) (opt_index, arg, value) == 0) - result = 0; + if (optimize >= 3) + { + flag_inline_functions = 1; + flag_unswitch_loops = 1; + flag_gcse_after_reload = 1; + } - if (result && (option->flags & CL_COMMON)) - if (common_handle_option (opt_index, arg, value) == 0) - result = 0; + if (optimize < 2 || optimize_size) + { + align_loops = 1; + align_jumps = 1; + align_labels = 1; + align_functions = 1; + + /* Don't reorder blocks when optimizing for size because extra + jump insns may be created; also barrier may create extra padding. + + More correctly we should have a block reordering mode that tried + to minimize the combined size of all the jumps. This would more + or less automatically remove extra jumps, but would also try to + use more short jumps instead of long jumps. */ + flag_reorder_blocks = 0; + flag_reorder_blocks_and_partition = 0; } - done: - if (dup) - free (dup); - return result; + if (optimize_size) + { + /* Inlining of very small functions usually reduces total size. */ + set_param_value ("max-inline-insns-single", 5); + set_param_value ("max-inline-insns-auto", 5); + set_param_value ("max-inline-insns-rtl", 10); + flag_inline_functions = 1; + } + + /* Initialize whether `char' is signed. */ + flag_signed_char = DEFAULT_SIGNED_CHAR; + /* Set this to a special "uninitialized" value. The actual default is set + after target options have been processed. */ + flag_short_enums = 2; + + /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can + modify it. */ + target_flags = 0; + set_target_switch (""); + + /* Unwind tables are always present in an ABI-conformant IA-64 + object file, so the default should be ON. */ +#ifdef IA64_UNWIND_INFO + flag_unwind_tables = IA64_UNWIND_INFO; +#endif + +#ifdef OPTIMIZATION_OPTIONS + /* Allow default optimizations to be specified on a per-machine basis. */ + OPTIMIZATION_OPTIONS (optimize, optimize_size); +#endif + + handle_options (argc, argv, lang_mask); + + if (flag_pie) + flag_pic = flag_pie; + if (flag_pic && !flag_pie) + flag_shlib = 1; + + if (flag_no_inline == 2) + flag_no_inline = 0; + else + flag_really_no_inline = flag_no_inline; + + /* Set flag_no_inline before the post_options () hook. The C front + ends use it to determine tree inlining defaults. FIXME: such + code should be lang-independent when all front ends use tree + inlining, in which case it, and this condition, should be moved + to the top of process_options() instead. */ + if (optimize == 0) + { + /* Inlining does not work if not optimizing, + so force it not to be done. */ + flag_no_inline = 1; + warn_inline = 0; + + /* The c_decode_option function and decode_option hook set + this to `2' if -Wall is used, so we can avoid giving out + lots of errors for people who don't realize what -Wall does. */ + if (warn_uninitialized == 1) + warning ("-Wuninitialized is not supported without -O"); + } + + if (flag_really_no_inline == 2) + flag_really_no_inline = flag_no_inline; + + /* The optimization to partition hot and cold basic blocks into separate + sections of the .o and executable files does not work (currently) + with exception handling. If flag_exceptions is turned on we need to + turn off the partitioning optimization. */ + + if (flag_exceptions && flag_reorder_blocks_and_partition) + { + warning + ("-freorder-blocks-and-partition does not work with exceptions"); + flag_reorder_blocks_and_partition = 0; + flag_reorder_blocks = 1; + } } /* Handle target- and language-independent options. Return zero to @@ -341,22 +696,15 @@ static int common_handle_option (size_t scode, const char *arg, int value ATTRIBUTE_UNUSED) { - const struct cl_option *option = &cl_options[scode]; enum opt_code code = (enum opt_code) scode; - if (arg == NULL && (option->flags & (CL_JOINED | CL_SEPARATE))) - { - error ("missing argument to \"-%s\"", option->opt_text); - return 1; - } - switch (code) { default: abort (); case OPT__help: - display_help (); + print_help (); exit_after_options = true; break; @@ -399,6 +747,7 @@ common_handle_option (size_t scode, const char *arg, case OPT_Wdeprecated_declarations: warn_deprecated_decl = value; + break; case OPT_Wdisabled_optimization: warn_disabled_optimization = value; @@ -412,6 +761,10 @@ common_handle_option (size_t scode, const char *arg, set_Wextra (value); break; + case OPT_Wfatal_errors: + flag_fatal_errors = value; + break; + case OPT_Winline: warn_inline = value; break; @@ -438,6 +791,7 @@ common_handle_option (size_t scode, const char *arg, break; case OPT_Wstrict_aliasing: + case OPT_Wstrict_aliasing_: warn_strict_aliasing = value; break; @@ -524,22 +878,38 @@ common_handle_option (size_t scode, const char *arg, flag_pie = value + value; break; + case OPT_fabi_version_: + flag_abi_version = value; + break; + case OPT_falign_functions: + align_functions = !value; + break; + case OPT_falign_functions_: align_functions = value; break; case OPT_falign_jumps: + align_jumps = !value; + break; + case OPT_falign_jumps_: align_jumps = value; break; case OPT_falign_labels: + align_labels = !value; + break; + case OPT_falign_labels_: align_labels = value; break; case OPT_falign_loops: + align_loops = !value; + break; + case OPT_falign_loops_: align_loops = value; break; @@ -569,6 +939,7 @@ common_handle_option (size_t scode, const char *arg, break; case OPT_fbranch_probabilities: + flag_branch_probabilities_set = true; flag_branch_probabilities = value; break; @@ -580,6 +951,10 @@ common_handle_option (size_t scode, const char *arg, flag_branch_target_load_optimize2 = value; break; + case OPT_fbtr_bb_exclusive: + flag_btr_bb_exclusive = value; + break; + case OPT_fcall_used_: fix_register (arg, 0, 1); break; @@ -638,6 +1013,11 @@ common_handle_option (size_t scode, const char *arg, return 0; break; + case OPT_fdump_: + if (!dump_switch_p (arg)) + return 0; + break; + case OPT_fdump_unnumbered: flag_dump_unnumbered = value; break; @@ -650,6 +1030,10 @@ common_handle_option (size_t scode, const char *arg, flag_eliminate_unused_debug_types = value; break; + case OPT_feliminate_unused_debug_symbols: + flag_debug_only_used_symbols = value; + break; + case OPT_fexceptions: flag_exceptions = value; break; @@ -702,8 +1086,12 @@ common_handle_option (size_t scode, const char *arg, flag_gcse_sm = value; break; - case OPT_fgnu_linker: - flag_gnu_linker = value; + case OPT_fgcse_after_reload: + flag_gcse_after_reload = value; + break; + + case OPT_fgcse_las: + flag_gcse_las = value; break; case OPT_fguess_branch_probability: @@ -736,17 +1124,9 @@ common_handle_option (size_t scode, const char *arg, case OPT_finline_limit_: case OPT_finline_limit_eq: - set_param_value ("max-inline-insns", value); set_param_value ("max-inline-insns-single", value / 2); set_param_value ("max-inline-insns-auto", value / 2); set_param_value ("max-inline-insns-rtl", value); - if (value / 4 < MIN_INLINE_INSNS) - { - if (value / 4 > 10) - set_param_value ("min-inline-insns", value / 4); - else - set_param_value ("min-inline-insns", 10); - } break; case OPT_finstrument_functions: @@ -786,13 +1166,26 @@ common_handle_option (size_t scode, const char *arg, break; case OPT_fmessage_length_: - output_set_maximum_length (&global_dc->buffer, value); + pp_set_line_maximum_length (global_dc->printer, value); break; case OPT_fmove_all_movables: flag_move_all_movables = value; break; + case OPT_fmudflap: + flag_mudflap = value; + break; + + case OPT_fmudflapth: + flag_mudflap = value; + flag_mudflap_threads = value; + break; + + case OPT_fmudflapir: + flag_mudflap_ignore_reads = value; + break; + case OPT_fnew_ra: flag_new_regalloc = value; break; @@ -826,6 +1219,7 @@ common_handle_option (size_t scode, const char *arg, break; case OPT_fpeel_loops: + flag_peel_loops_set = true; flag_peel_loops = value; break; @@ -858,9 +1252,44 @@ common_handle_option (size_t scode, const char *arg, break; case OPT_fprofile_arcs: + profile_arc_flag_set = true; profile_arc_flag = value; break; + case OPT_fprofile_use: + if (!flag_branch_probabilities_set) + flag_branch_probabilities = value; + if (!flag_profile_values_set) + flag_profile_values = value; + if (!flag_unroll_loops_set) + flag_unroll_loops = value; + if (!flag_peel_loops_set) + flag_peel_loops = value; + if (!flag_tracer_set) + flag_tracer = value; + if (!flag_value_profile_transformations_set) + flag_value_profile_transformations = value; + break; + + case OPT_fprofile_generate: + if (!profile_arc_flag_set) + profile_arc_flag = value; + if (!flag_profile_values_set) + flag_profile_values = value; + if (!flag_value_profile_transformations_set) + flag_value_profile_transformations = value; + break; + + case OPT_fprofile_values: + flag_profile_values_set = true; + flag_profile_values = value; + break; + + case OPT_fvpt: + flag_value_profile_transformations_set = value; + flag_value_profile_transformations = value; + break; + case OPT_frandom_seed: /* The real switch is -fno-random-seed. */ if (value) @@ -892,6 +1321,10 @@ common_handle_option (size_t scode, const char *arg, flag_reorder_blocks = value; break; + case OPT_freorder_blocks_and_partition: + flag_reorder_blocks_and_partition = value; + break; + case OPT_freorder_functions: flag_reorder_functions = value; break; @@ -904,8 +1337,12 @@ common_handle_option (size_t scode, const char *arg, flag_rerun_loop_opt = value; break; + case OPT_frounding_math: + flag_rounding_math = value; + break; + case OPT_fsched_interblock: - flag_schedule_interblock= value; + flag_schedule_interblock = value; break; case OPT_fsched_spec: @@ -944,28 +1381,36 @@ common_handle_option (size_t scode, const char *arg, flag_schedule_insns_after_reload = value; break; - case OPT_fshared_data: - flag_shared_data = value; + case OPT_fsched_stalled_insns: + flag_sched_stalled_insns = value; break; - case OPT_fsignaling_nans: - flag_signaling_nans = value; + case OPT_fsched_stalled_insns_: + flag_sched_stalled_insns = value; + if (flag_sched_stalled_insns == 0) + flag_sched_stalled_insns = -1; break; - case OPT_fsingle_precision_constant: - flag_single_precision_constant = value; + case OPT_fsched_stalled_insns_dep: + flag_sched_stalled_insns_dep = 1; break; - case OPT_fssa: - flag_ssa = value; + case OPT_fsched_stalled_insns_dep_: + flag_sched_stalled_insns_dep = value; + break; + case OPT_fmodulo_sched: + flag_modulo_sched = 1; + break; + case OPT_fshared_data: + flag_shared_data = value; break; - case OPT_fssa_ccp: - flag_ssa_ccp = value; + case OPT_fsignaling_nans: + flag_signaling_nans = value; break; - case OPT_fssa_dce: - flag_ssa_dce = value; + case OPT_fsingle_precision_constant: + flag_single_precision_constant = value; break; case OPT_fstack_check: @@ -1015,6 +1460,7 @@ common_handle_option (size_t scode, const char *arg, case OPT_ftime_report: time_report = value; + break; case OPT_ftls_model_: if (!strcmp (arg, "global-dynamic")) @@ -1030,6 +1476,7 @@ common_handle_option (size_t scode, const char *arg, break; case OPT_ftracer: + flag_tracer_set = true; flag_tracer = value; break; @@ -1041,6 +1488,70 @@ common_handle_option (size_t scode, const char *arg, flag_trapv = value; break; + case OPT_ftree_based_profiling: + flag_tree_based_profiling = value; + break; + + case OPT_ftree_ccp: + flag_tree_ccp = value; + break; + + case OPT_ftree_dce: + flag_tree_dce = value; + break; + + case OPT_ftree_combine_temps: + flag_tree_combine_temps = value; + break; + + case OPT_ftree_ter: + flag_tree_ter = value; + break; + + case OPT_ftree_lrs: + flag_tree_live_range_split = value; + break; + + case OPT_ftree_dominator_opts: + flag_tree_dom = value; + break; + + case OPT_ftree_copyrename: + flag_tree_copyrename = value; + break; + + case OPT_ftree_ch: + flag_tree_ch = value; + break; + + case OPT_ftree_dse: + flag_tree_dse = value; + break; + + case OPT_ftree_sra: + flag_tree_sra = value; + break; + + case OPT_ftree_points_to_: + if (!strcmp (arg, "andersen")) +#ifdef HAVE_BANSHEE + flag_tree_points_to = PTA_ANDERSEN; +#else + warning ("Andersen's PTA not available - libbanshee not compiled."); +#endif + else if (!strcmp (arg, "none")) + flag_tree_points_to = PTA_NONE; + else + { + warning ("`%s`: unknown points-to analysis algorithm", arg); + return 0; + } + break; + + case OPT_ftree_pre: + flag_tree_pre = value; + break; + case OPT_funit_at_a_time: flag_unit_at_a_time = value; break; @@ -1050,6 +1561,7 @@ common_handle_option (size_t scode, const char *arg, break; case OPT_funroll_loops: + flag_unroll_loops_set = true; flag_unroll_loops = value; break; @@ -1065,24 +1577,54 @@ common_handle_option (size_t scode, const char *arg, flag_unwind_tables = value; break; + case OPT_fvar_tracking: + flag_var_tracking = value; + break; + case OPT_fverbose_asm: flag_verbose_asm = value; break; + + case OPT_fweb: + flag_web = 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); + set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg); + break; + + case OPT_gcoff: + set_debug_level (SDB_DEBUG, false, arg); + break; + + case OPT_gdwarf_2: + set_debug_level (DWARF2_DEBUG, false, arg); + break; + + case OPT_ggdb: + set_debug_level (NO_DEBUG, 2, arg); + break; + + case OPT_gstabs: + case OPT_gstabs_: + set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg); + break; + + case OPT_gvms: + set_debug_level (VMS_DEBUG, false, arg); + break; + + case OPT_gxcoff: + case OPT_gxcoff_: + set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg); break; case OPT_m: @@ -1191,7 +1733,10 @@ set_fast_math_flags (int set) flag_finite_math_only = set; flag_errno_math = !set; if (set) - flag_signaling_nans = 0; + { + flag_signaling_nans = 0; + flag_rounding_math = 0; + } } /* Return true iff flags are set as if -ffast-math. */ @@ -1203,3 +1748,269 @@ fast_math_flags_set_p (void) && flag_finite_math_only && !flag_errno_math); } + +/* Handle a debug output -g switch. EXTENDED is true or false to support + extended output (2 is special and means "-ggdb" was given). */ +static void +set_debug_level (enum debug_info_type type, int extended, const char *arg) +{ + static bool type_explicit; + + use_gnu_debug_info_extensions = extended; + + if (type == NO_DEBUG) + { + if (write_symbols == NO_DEBUG) + { + write_symbols = PREFERRED_DEBUGGING_TYPE; + + if (extended == 2) + { +#ifdef DWARF2_DEBUGGING_INFO + write_symbols = DWARF2_DEBUG; +#elif defined DBX_DEBUGGING_INFO + write_symbols = DBX_DEBUG; +#endif + } + + if (write_symbols == NO_DEBUG) + warning ("target system does not support debug output"); + } + } + else + { + /* Does it conflict with an already selected type? */ + if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols) + error ("debug format \"%s\" conflicts with prior selection", + debug_type_names[type]); + write_symbols = type; + type_explicit = true; + } + + /* A debug flag without a level defaults to level 2. */ + if (*arg == '\0') + { + if (!debug_info_level) + debug_info_level = 2; + } + else + { + debug_info_level = integral_argument (arg); + if (debug_info_level == (unsigned int) -1) + error ("unrecognised debug output level \"%s\"", arg); + else if (debug_info_level > 3) + error ("debug output level %s is too high", arg); + } +} + +/* Output --help text. */ +static void +print_help (void) +{ + size_t i; + const char *p; + + GET_ENVIRONMENT (p, "COLUMNS"); + if (p) + { + int value = atoi (p); + if (value > 0) + columns = value; + } + + puts (_("The following options are language-independent:\n")); + + print_filtered_help (CL_COMMON); + print_param_help (); + + for (i = 0; lang_names[i]; i++) + { + printf (_("The %s front end recognizes the following options:\n\n"), + lang_names[i]); + print_filtered_help (1U << i); + } + + display_target_options (); +} + +/* Print the help for --param. */ +static void +print_param_help (void) +{ + size_t i; + + puts (_("The --param option recognizes the following as parameters:\n")); + + for (i = 0; i < LAST_PARAM; i++) + { + const char *help = compiler_params[i].help; + const char *param = compiler_params[i].option; + + if (help == NULL || *help == '\0') + help = undocumented_msg; + + /* Get the translation. */ + help = _(help); + + wrap_help (help, param, strlen (param)); + } + + putchar ('\n'); +} + +/* Print help for a specific front-end, etc. */ +static void +print_filtered_help (unsigned int flag) +{ + unsigned int i, len, filter, indent = 0; + bool duplicates = false; + const char *help, *opt, *tab; + static char *printed; + + if (flag == CL_COMMON) + { + filter = flag; + if (!printed) + printed = xmalloc (cl_options_count); + memset (printed, 0, cl_options_count); + } + else + { + /* Don't print COMMON options twice. */ + filter = flag | CL_COMMON; + + for (i = 0; i < cl_options_count; i++) + { + if ((cl_options[i].flags & filter) != flag) + continue; + + /* Skip help for internal switches. */ + if (cl_options[i].flags & CL_UNDOCUMENTED) + continue; + + /* Skip switches that have already been printed, mark them to be + listed later. */ + if (printed[i]) + { + duplicates = true; + indent = print_switch (cl_options[i].opt_text, indent); + } + } + + if (duplicates) + { + putchar ('\n'); + putchar ('\n'); + } + } + + for (i = 0; i < cl_options_count; i++) + { + if ((cl_options[i].flags & filter) != flag) + continue; + + /* Skip help for internal switches. */ + if (cl_options[i].flags & CL_UNDOCUMENTED) + continue; + + /* Skip switches that have already been printed. */ + if (printed[i]) + continue; + + printed[i] = true; + + help = cl_options[i].help; + if (!help) + help = undocumented_msg; + + /* Get the translation. */ + help = _(help); + + tab = strchr (help, '\t'); + if (tab) + { + len = tab - help; + opt = help; + help = tab + 1; + } + else + { + opt = cl_options[i].opt_text; + len = strlen (opt); + } + + wrap_help (help, opt, len); + } + + putchar ('\n'); +} + +/* Output ITEM, of length ITEM_WIDTH, in the left column, followed by + word-wrapped HELP in a second column. */ +static unsigned int +print_switch (const char *text, unsigned int indent) +{ + unsigned int len = strlen (text) + 1; /* trailing comma */ + + if (indent) + { + putchar (','); + if (indent + len > columns) + { + putchar ('\n'); + putchar (' '); + indent = 1; + } + } + else + putchar (' '); + + putchar (' '); + fputs (text, stdout); + + return indent + len + 1; +} + +/* Output ITEM, of length ITEM_WIDTH, in the left column, followed by + word-wrapped HELP in a second column. */ +static void +wrap_help (const char *help, const char *item, unsigned int item_width) +{ + unsigned int col_width = 27; + unsigned int remaining, room, len; + + remaining = strlen (help); + + do + { + room = columns - 3 - MAX (col_width, item_width); + if (room > columns) + room = 0; + len = remaining; + + if (room < len) + { + unsigned int i; + + for (i = 0; help[i]; i++) + { + if (i >= room && len != remaining) + break; + if (help[i] == ' ') + len = i; + else if ((help[i] == '-' || help[i] == '/') + && help[i + 1] != ' ' + && i > 0 && ISALPHA (help[i - 1])) + len = i + 1; + } + } + + printf( " %-*.*s %.*s\n", col_width, item_width, item, len, help); + item_width = 0; + while (help[len] == ' ') + len++; + help += len; + remaining -= len; + } + while (remaining); +}