X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fopts.c;h=e264b4abcc3324fcbd6ce96883ec5c0ad3b27fd9;hb=f9c6f14d623ddb87a40b7815a3b052d57a1f2c38;hp=de39e5c6c8da3c848e39e24a46b663f9ebd93995;hpb=dcfa26d9a6f914b73171fa3b6f28726a427b347a;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/opts.c b/gcc/opts.c index de39e5c6c8d..e264b4abcc3 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, 2005 Free Software Foundation, Inc. Contributed by Neil Booth. This file is part of GCC. @@ -16,8 +16,8 @@ for more details. You should have received a copy of the GNU General Public License along with GCC; see the file COPYING. If not, write to the Free -Software Foundation, 59 Temple Place - Suite 330, Boston, MA -02111-1307, USA. */ +Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301, USA. */ #include "config.h" #include "system.h" @@ -37,6 +37,8 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #include "diagnostic.h" #include "tm_p.h" /* For OPTIMIZATION_OPTIONS. */ #include "insn-attr.h" /* For INSN_SCHEDULING. */ +#include "target.h" +#include "tree-pass.h" /* Value of the -G xx switch, and whether it was passed or not. */ unsigned HOST_WIDE_INT g_switch_value; @@ -45,88 +47,41 @@ bool g_switch_set; /* True if we should exit after parsing options. */ bool exit_after_options; -/* If -version. */ -bool version_flag; - /* Print various extra warnings. -W/-Wextra. */ bool extra_warnings; -/* Don't print warning messages. -w. */ -bool inhibit_warnings; - -/* Treat warnings as errors. -Werror. */ -bool warnings_are_errors; - -/* Warn if a function returns an aggregate, since there are often - incompatible calling conventions for doing this. */ -bool warn_aggregate_return; - -/* Nonzero means warn about pointer casts that increase the required - alignment of the target type (and might therefore lead to a crash - due to a misaligned access). */ -bool warn_cast_align; - -/* Nonzero means warn about uses of __attribute__((deprecated)) - declarations. */ -bool warn_deprecated_decl = true; - -/* Warn when an optimization pass is disabled. */ -bool warn_disabled_optimization; - -/* Nonzero means warn if inline function is too large. */ -bool warn_inline; - /* True to warn about any objects definitions whose size is larger than N bytes. Also want about function definitions whose returned values are larger than N bytes, where N is `larger_than_size'. */ bool warn_larger_than; HOST_WIDE_INT larger_than_size; -/* Warn about functions which might be candidates for attribute noreturn. */ -bool warn_missing_noreturn; - -/* True to warn about code which is never reached. */ -bool warn_notreached; - -/* Warn if packed attribute on struct is unnecessary and inefficient. */ -bool warn_packed; - -/* Warn when gcc pads a structure to an alignment boundary. */ -bool warn_padded; - -/* True means warn about all declarations which shadow others. */ -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. */ -bool warn_switch; - -/* Warn if a switch does not have a default case. */ -bool warn_switch_default; +/* Hack for cooperation between set_Wunused and set_Wextra. */ +static bool maybe_warn_unused_parameter; -/* Warn if a switch on an enum fails to have a case for every enum - value (regardless of the presence or otherwise of a default case). */ -bool warn_switch_enum; +/* 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; -/* Don't suppress warnings from system headers. -Wsystem-headers. */ -bool warn_system_headers; +/* 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; -/* True to warn about variables used before they are initialized. */ -int warn_uninitialized; +/* 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; -/* True to warn about unused variables, functions et.al. */ -bool warn_unused_function; -bool warn_unused_label; -bool warn_unused_parameter; -bool warn_unused_variable; -bool warn_unused_value; +/* The default visibility for all symbols (unless overridden) */ +enum symbol_visibility default_visibility = VISIBILITY_DEFAULT; -/* Hack for cooperation between set_Wunused and set_Wextra. */ -static bool maybe_warn_unused_parameter; +/* Global visibility options. */ +struct visibility_flags visibility_options; /* Columns of --help display. */ static unsigned int columns = 80; @@ -134,7 +89,15 @@ static unsigned int columns = 80; /* What to print when a switch has no documentation. */ static const char undocumented_msg[] = N_("This switch lacks documentation"); -/* Input file names. */ +/* 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; +static bool flag_loop_optimize_set; + +/* Input file names. */ const char **in_fnames; unsigned num_in_fnames; @@ -148,10 +111,13 @@ 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_target_help (void); static void print_help (void); static void print_param_help (void); -static void print_filtered_help (unsigned int flag); +static void print_filtered_help (unsigned int); 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 @@ -212,13 +178,13 @@ 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 + 1, opt->opt_len)) + /* Is the input either an exact match or a prefix that takes a + joined argument? */ + if (!strncmp (input, opt->opt_text + 1, opt->opt_len) + && (input[opt->opt_len] == '\0' || (opt->flags & CL_JOINED))) { - /* If language is OK, and the match is exact or the switch - takes a joined argument, return it. */ - if ((opt->flags & lang_mask) - && (input[opt->opt_len] == '\0' || (opt->flags & CL_JOINED))) + /* If language is OK, return it. */ + if (opt->flags & lang_mask) return mn; /* If we haven't remembered a prior match, remember this @@ -292,7 +258,7 @@ complain_wrong_lang (const char *text, const struct cl_option *option, 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", + warning (0, "command line option \"%s\" is valid for %s but not for %s", text, ok_langs, bad_lang); free (ok_langs); @@ -313,10 +279,12 @@ handle_option (const char **argv, unsigned int lang_mask) opt = argv[0]; - /* Drop the "no-" from negative switches. */ - if ((opt[1] == 'W' || opt[1] == 'f') + opt_index = find_opt (opt + 1, lang_mask | CL_COMMON | CL_TARGET); + if (opt_index == cl_options_count + && (opt[1] == 'W' || opt[1] == 'f' || opt[1] == 'm') && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-') { + /* Drop the "no-" from negative switches. */ size_t len = strlen (opt) - 3; dup = xmalloc (len + 1); @@ -325,9 +293,9 @@ handle_option (const char **argv, unsigned int lang_mask) memcpy (dup + 2, opt + 5, len - 2 + 1); opt = dup; value = 0; + opt_index = find_opt (opt + 1, lang_mask | CL_COMMON | CL_TARGET); } - opt_index = find_opt (opt + 1, lang_mask | CL_COMMON); if (opt_index == cl_options_count) goto done; @@ -341,6 +309,14 @@ handle_option (const char **argv, unsigned int lang_mask) /* We've recognized this switch. */ result = 1; + /* Check to see if the option is disabled for this configuration. */ + if (option->flags & CL_DISABLED) + { + error ("command line option %qs" + " is not supported by this configuration", opt); + goto done; + } + /* Sort out any argument the switch takes. */ if (option->flags & CL_JOINED) { @@ -371,7 +347,7 @@ handle_option (const char **argv, unsigned int lang_mask) /* 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))) + if (!(option->flags & (lang_mask | CL_COMMON | CL_TARGET))) { complain_wrong_lang (argv[0], option, lang_mask); goto done; @@ -379,7 +355,7 @@ handle_option (const char **argv, unsigned int lang_mask) if (arg == NULL && (option->flags & (CL_JOINED | CL_SEPARATE))) { - if (!(*lang_hooks.missing_argument) (opt, opt_index)) + if (!lang_hooks.missing_argument (opt, opt_index)) error ("missing argument to \"%s\"", opt); goto done; } @@ -396,20 +372,61 @@ handle_option (const char **argv, unsigned int lang_mask) } } + if (option->flag_var) + switch (option->var_type) + { + case CLVC_BOOLEAN: + *(int *) option->flag_var = value; + break; + + case CLVC_EQUAL: + *(int *) option->flag_var = (value + ? option->var_value + : !option->var_value); + break; + + case CLVC_BIT_CLEAR: + case CLVC_BIT_SET: + if ((value != 0) == (option->var_type == CLVC_BIT_SET)) + *(int *) option->flag_var |= option->var_value; + else + *(int *) option->flag_var &= ~option->var_value; + if (option->flag_var == &target_flags) + target_flags_explicit |= option->var_value; + break; + + case CLVC_STRING: + *(const char **) option->flag_var = arg; + break; + } + if (option->flags & lang_mask) - if ((*lang_hooks.handle_option) (opt_index, arg, value) == 0) + if (lang_hooks.handle_option (opt_index, arg, value) == 0) result = 0; if (result && (option->flags & CL_COMMON)) if (common_handle_option (opt_index, arg, value) == 0) result = 0; + if (result && (option->flags & CL_TARGET)) + if (!targetm.handle_option (opt_index, arg, value)) + result = 0; + done: if (dup) free (dup); return result; } +/* Handle FILENAME from the command line. */ +static 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; +} + /* Decode and handle the vector of command line options. LANG_MASK contains has a single bit set representing the current language. */ @@ -425,7 +442,8 @@ handle_options (unsigned int argc, const char **argv, unsigned int lang_mask) /* Interpret "-" or a non-switch as a file name. */ if (opt[0] != '-' || opt[1] == '\0') { - main_input_filename = opt; + if (main_input_filename == NULL) + main_input_filename = opt; add_input_filename (opt); n = 1; continue; @@ -441,15 +459,6 @@ handle_options (unsigned int argc, const char **argv, unsigned int lang_mask) } } -/* 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 @@ -458,7 +467,9 @@ 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_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. */ @@ -501,7 +512,6 @@ decode_options (unsigned int argc, const char **argv) if (optimize >= 1) { flag_defer_pop = 1; - flag_thread_jumps = 1; #ifdef DELAY_SLOTS flag_delayed_branch = 1; #endif @@ -511,23 +521,48 @@ decode_options (unsigned int argc, const char **argv) flag_guess_branch_prob = 1; flag_cprop_registers = 1; flag_loop_optimize = 1; - flag_crossjumping = 1; flag_if_conversion = 1; flag_if_conversion2 = 1; + flag_ipa_pure_const = 1; + flag_ipa_reference = 1; + flag_tree_ccp = 1; + flag_tree_dce = 1; + flag_tree_dom = 1; + flag_tree_dse = 1; + flag_tree_ter = 1; + flag_tree_live_range_split = 1; + flag_tree_sra = 1; + flag_tree_copyrename = 1; + flag_tree_fre = 1; + flag_tree_copy_prop = 1; + flag_tree_sink = 1; + flag_tree_salias = 1; + flag_unit_at_a_time = 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_thread_jumps = 1; + 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_ipa_type_escape = 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; @@ -538,14 +573,22 @@ decode_options (unsigned int argc, const char **argv) flag_delete_null_pointer_checks = 1; flag_reorder_blocks = 1; flag_reorder_functions = 1; + flag_tree_store_ccp = 1; + flag_tree_store_copy_prop = 1; + flag_tree_vrp = 1; + + if (!optimize_size) + { + /* PRE tends to generate bigger code. */ + flag_tree_pre = 1; + } } if (optimize >= 3) { flag_inline_functions = 1; - flag_rename_registers = 1; flag_unswitch_loops = 1; - flag_unit_at_a_time = 1; + flag_gcse_after_reload = 1; } if (optimize < 2 || optimize_size) @@ -563,25 +606,32 @@ decode_options (unsigned int argc, const char **argv) 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; + } + + 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); + flag_inline_functions = 1; + + /* We want to crossjump as much as possible. */ + set_param_value ("min-crossjump-insns", 1); } /* Initialize whether `char' is signed. */ flag_signed_char = DEFAULT_SIGNED_CHAR; -#ifdef DEFAULT_SHORT_ENUMS - /* Initialize how much space enums occupy, by default. */ - flag_short_enums = DEFAULT_SHORT_ENUMS; -#endif + /* 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 (""); + target_flags = targetm.default_target_flags; - /* 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 + /* Some tagets have ABI-specified unwind tables. */ + flag_unwind_tables = targetm.unwind_tables_default; #ifdef OPTIMIZATION_OPTIONS /* Allow default optimizations to be specified on a per-machine basis. */ @@ -616,26 +666,65 @@ decode_options (unsigned int argc, const char **argv) 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"); + warning (OPT_Wuninitialized, + "-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. This is because there is no support for + generating unwind info. If flag_exceptions is turned on we need to + turn off the partitioning optimization. */ + + if (flag_exceptions && flag_reorder_blocks_and_partition) + { + inform + ("-freorder-blocks-and-partition does not work with exceptions"); + flag_reorder_blocks_and_partition = 0; + flag_reorder_blocks = 1; + } + + /* If user requested unwind info, then turn off the partitioning + optimization. */ + + if (flag_unwind_tables && ! targetm.unwind_tables_default + && flag_reorder_blocks_and_partition) + { + inform ("-freorder-blocks-and-partition does not support unwind info"); + flag_reorder_blocks_and_partition = 0; + flag_reorder_blocks = 1; + } + + /* If the target requested unwind info, then turn off the partitioning + optimization with a different message. Likewise, if the target does not + support named sections. */ + + if (flag_reorder_blocks_and_partition + && (!targetm.have_named_sections + || (flag_unwind_tables && targetm.unwind_tables_default))) + { + inform + ("-freorder-blocks-and-partition does not work on this architecture"); + flag_reorder_blocks_and_partition = 0; + flag_reorder_blocks = 1; + } } /* Handle target- and language-independent options. Return zero to - generate an "unknown option" message. */ + generate an "unknown option" message. Only options that need + extra handling need to be listed here; if you simply want + VALUE assigned to a variable, it happens automatically. */ + static int -common_handle_option (size_t scode, const char *arg, - int value ATTRIBUTE_UNUSED) +common_handle_option (size_t scode, const char *arg, int value) { enum opt_code code = (enum opt_code) scode; switch (code) { - default: - abort (); - case OPT__help: print_help (); exit_after_options = true; @@ -646,7 +735,7 @@ common_handle_option (size_t scode, const char *arg, break; case OPT__target_help: - display_target_options (); + print_target_help (); exit_after_options = true; break; @@ -670,107 +759,24 @@ common_handle_option (size_t scode, const char *arg, set_Wextra (value); break; - case OPT_Waggregate_return: - warn_aggregate_return = value; - break; - - case OPT_Wcast_align: - warn_cast_align = value; - break; - - case OPT_Wdeprecated_declarations: - warn_deprecated_decl = value; - break; - - case OPT_Wdisabled_optimization: - warn_disabled_optimization = value; - break; - - case OPT_Werror: - warnings_are_errors = value; - break; - case OPT_Wextra: set_Wextra (value); break; - case OPT_Winline: - warn_inline = value; - break; - case OPT_Wlarger_than_: larger_than_size = value; warn_larger_than = value != -1; break; - case OPT_Wmissing_noreturn: - warn_missing_noreturn = value; - break; - - case OPT_Wpacked: - warn_packed = value; - break; - - case OPT_Wpadded: - warn_padded = value; - break; - - case OPT_Wshadow: - warn_shadow = value; - break; - case OPT_Wstrict_aliasing: + case OPT_Wstrict_aliasing_: warn_strict_aliasing = value; break; - case OPT_Wswitch: - warn_switch = value; - break; - - case OPT_Wswitch_default: - warn_switch_default = value; - break; - - case OPT_Wswitch_enum: - warn_switch_enum = value; - break; - - case OPT_Wsystem_headers: - warn_system_headers = value; - break; - - case OPT_Wuninitialized: - warn_uninitialized = value; - break; - - case OPT_Wunreachable_code: - warn_notreached = value; - break; - case OPT_Wunused: set_Wunused (value); break; - case OPT_Wunused_function: - warn_unused_function = value; - break; - - case OPT_Wunused_label: - warn_unused_label = value; - break; - - case OPT_Wunused_parameter: - warn_unused_parameter = value; - break; - - case OPT_Wunused_value: - warn_unused_value = value; - break; - - case OPT_Wunused_variable: - warn_unused_variable = value; - break; - case OPT_aux_info: case OPT_aux_info_: aux_info_file_name = arg; @@ -798,80 +804,28 @@ common_handle_option (size_t scode, const char *arg, 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: - 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; - 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; + flag_branch_probabilities_set = true; break; - case OPT_fbranch_target_load_optimize: - flag_branch_target_load_optimize = value; - break; - - case OPT_fbranch_target_load_optimize2: - flag_branch_target_load_optimize2 = value; + case OPT_floop_optimize: + flag_loop_optimize_set = true; break; case OPT_fcall_used_: @@ -882,46 +836,6 @@ common_handle_option (size_t scode, const char *arg, fix_register (arg, 0, 0); break; - case OPT_fcaller_saves: - 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; - - case OPT_fcse_follow_jumps: - flag_cse_follow_jumps = value; - break; - - case OPT_fcse_skip_blocks: - flag_cse_skip_blocks = value; - break; - - case OPT_fdata_sections: - flag_data_sections = value; - break; - - case OPT_fdefer_pop: - flag_defer_pop = value; - break; - - case OPT_fdelayed_branch: - flag_delayed_branch = value; - break; - - case OPT_fdelete_null_pointer_checks: - flag_delete_null_pointer_checks = value; - break; - case OPT_fdiagnostics_show_location_: if (!strcmp (arg, "once")) diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE; @@ -932,231 +846,99 @@ common_handle_option (size_t scode, const char *arg, return 0; break; - case OPT_fdump_unnumbered: - flag_dump_unnumbered = value; - break; - - case OPT_feliminate_dwarf2_dups: - flag_eliminate_dwarf2_dups = value; + case OPT_fdiagnostics_show_option: + global_dc->show_option_requested = true; break; - case OPT_feliminate_unused_debug_types: - 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; - - case OPT_fexpensive_optimizations: - flag_expensive_optimizations = value; + case OPT_fdump_: + if (!dump_switch_p (arg)) + return 0; break; case OPT_ffast_math: 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; - case OPT_ffunction_cse: - flag_no_function_cse = !value; - break; - - case OPT_ffloat_store: - flag_float_store = value; - break; - - case OPT_fforce_addr: - flag_force_addr = value; - break; - - case OPT_fforce_mem: - flag_force_mem = value; - break; - - case OPT_ffunction_sections: - flag_function_sections = value; - break; - - case OPT_fgcse: - flag_gcse = value; - break; - - case OPT_fgcse_lm: - flag_gcse_lm = value; - break; - - case OPT_fgcse_sm: - 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; - - case OPT_fif_conversion2: - flag_if_conversion2 = value; - break; - - case OPT_finhibit_size_directive: - flag_inhibit_size_directive = value; - break; - - case OPT_finline: - flag_no_inline = !value; - break; - - case OPT_finline_functions: - flag_inline_functions = value; - break; - 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: - flag_instrument_function_entry_exit = value; - break; - - case OPT_fkeep_inline_functions: - flag_keep_inline_functions =value; - break; - - case OPT_fkeep_static_consts: - 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_: pp_set_line_maximum_length (global_dc->printer, value); break; - case OPT_fmove_all_movables: - 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; - - case OPT_fold_unroll_loops: - flag_old_unroll_loops = value; - break; - - case OPT_fomit_frame_pointer: - 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; + case OPT_fpack_struct_: + if (value <= 0 || (value & (value - 1)) || value > 16) + error("structure alignment must be a small power of two, not %d", value); + else + { + initial_max_fld_align = value; + maximum_field_alignment = value * BITS_PER_UNIT; + } break; case OPT_fpeel_loops: - flag_peel_loops = value; - break; - - case OPT_fpcc_struct_return: - flag_pcc_struct_return = value; - break; - - case OPT_fpeephole: - flag_no_peephole = !value; + flag_peel_loops_set = true; break; - case OPT_fpeephole2: - flag_peephole2 = value; + case OPT_fprofile_arcs: + profile_arc_flag_set = true; break; - case OPT_fpic: - flag_pic = value; + 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; + /* Old loop optimizer is incompatible with tree profiling. */ + if (!flag_loop_optimize_set) + flag_loop_optimize = 0; break; - case OPT_fpie: - flag_pie = value; + 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_fprefetch_loop_arrays: - flag_prefetch_loop_arrays = value; + case OPT_fprofile_values: + flag_profile_values_set = true; break; - case OPT_fprofile: - profile_flag = value; + case OPT_fvisibility_: + { + if (!strcmp(arg, "default")) + default_visibility = VISIBILITY_DEFAULT; + else if (!strcmp(arg, "internal")) + default_visibility = VISIBILITY_INTERNAL; + else if (!strcmp(arg, "hidden")) + default_visibility = VISIBILITY_HIDDEN; + else if (!strcmp(arg, "protected")) + default_visibility = VISIBILITY_PROTECTED; + else + error ("unrecognized visibility value \"%s\"", arg); + } break; - case OPT_fprofile_arcs: - profile_arc_flag = value; + case OPT_fvpt: + flag_value_profile_transformations_set = true; break; case OPT_frandom_seed: @@ -1170,54 +952,6 @@ common_handle_option (size_t scode, const char *arg, flag_random_seed = arg; break; - case OPT_freduce_all_givs: - flag_reduce_all_givs = value; - break; - - case OPT_freg_struct_return: - 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; - - case OPT_frerun_loop_opt: - 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); @@ -1226,48 +960,14 @@ common_handle_option (size_t scode, const char *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; - - case OPT_fschedule_insns2: - flag_schedule_insns_after_reload = 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_fshared_data: - 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; + case OPT_fsched_stalled_insns_dep_: + flag_sched_stalled_insns_dep = value; break; case OPT_fstack_limit: @@ -1291,28 +991,8 @@ common_handle_option (size_t scode, const char *arg, stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg)); break; - case OPT_fstrength_reduce: - 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_ftree_vectorizer_verbose_: + vect_set_verbosity_level (arg); break; case OPT_ftls_model_: @@ -1325,96 +1005,64 @@ common_handle_option (size_t scode, const char *arg, else if (!strcmp (arg, "local-exec")) flag_tls_default = TLS_MODEL_LOCAL_EXEC; else - warning ("unknown tls-model \"%s\"", arg); + warning (0, "unknown tls-model \"%s\"", arg); break; case OPT_ftracer: - 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; - - case OPT_funroll_all_loops: - flag_unroll_all_loops = value; + flag_tracer_set = true; break; case OPT_funroll_loops: - flag_unroll_loops = value; - break; - - case OPT_funsafe_math_optimizations: - flag_unsafe_math_optimizations = value; + flag_unroll_loops_set = true; break; - case OPT_funswitch_loops: - flag_unswitch_loops = value; + case OPT_g: + set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg); break; - case OPT_funwind_tables: - flag_unwind_tables = value; + case OPT_gcoff: + set_debug_level (SDB_DEBUG, false, arg); break; - case OPT_fverbose_asm: - flag_verbose_asm = value; - break; - - case OPT_fwrapv: - flag_wrapv = value; + case OPT_gdwarf_2: + set_debug_level (DWARF2_DEBUG, false, arg); break; - case OPT_fwritable_strings: - flag_writable_strings = value; + case OPT_ggdb: + set_debug_level (NO_DEBUG, 2, arg); break; - case OPT_fzero_initialized_in_bss: - flag_zero_initialized_in_bss = value; + case OPT_gstabs: + case OPT_gstabs_: + set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg); break; - case OPT_g: - decode_g_option (arg); + case OPT_gvms: + set_debug_level (VMS_DEBUG, false, arg); break; - case OPT_m: - set_target_switch (arg); + case OPT_gxcoff: + case OPT_gxcoff_: + set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg); break; case OPT_o: asm_file_name = arg; break; - case OPT_p: - profile_flag = 1; - break; - - case OPT_pedantic: - pedantic = 1; - break; - case OPT_pedantic_errors: flag_pedantic_errors = pedantic = 1; break; - case OPT_quiet: - quiet_flag = 1; + case OPT_fforce_mem: + warning (0, "-f[no-]force-mem is nop and option will be removed in 4.2"); break; - case OPT_version: - version_flag = 1; + default: + /* If the flag was handled in a standard way, assume the lack of + processing here is intentional. */ + gcc_assert (cl_options[scode].flag_var); break; - - case OPT_w: - inhibit_warnings = true; - break; } return 1; @@ -1435,7 +1083,7 @@ handle_param (const char *carg) { value = integral_argument (equal + 1); if (value == -1) - error ("invalid --param value `%s'", equal + 1); + error ("invalid --param value %qs", equal + 1); else { *equal = '\0'; @@ -1490,7 +1138,11 @@ 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; + flag_cx_limited_range = 1; + } } /* Return true iff flags are set as if -ffast-math. */ @@ -1503,6 +1155,81 @@ fast_math_flags_set_p (void) && !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 (0, "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); + } +} + +/* Display help for target options. */ +static void +print_target_help (void) +{ + unsigned int i; + static bool displayed = false; + + /* Avoid double printing for --help --target-help. */ + if (displayed) + return; + + displayed = true; + for (i = 0; i < cl_options_count; i++) + if ((cl_options[i].flags & (CL_TARGET | CL_UNDOCUMENTED)) == CL_TARGET) + { + printf (_("\nTarget specific options:\n")); + print_filtered_help (CL_TARGET); + break; + } +} + /* Output --help text. */ static void print_help (void) @@ -1529,8 +1256,7 @@ print_help (void) lang_names[i]); print_filtered_help (1U << i); } - - display_help (); + print_target_help (); } /* Print the help for --param. */ @@ -1567,7 +1293,7 @@ print_filtered_help (unsigned int flag) const char *help, *opt, *tab; static char *printed; - if (flag == CL_COMMON) + if (flag == CL_COMMON || flag == CL_TARGET) { filter = flag; if (!printed) @@ -1700,7 +1426,7 @@ wrap_help (const char *help, const char *item, unsigned int item_width) len = i; else if ((help[i] == '-' || help[i] == '/') && help[i + 1] != ' ' - && ISALPHA (help[i - 1])) + && i > 0 && ISALPHA (help[i - 1])) len = i + 1; } } @@ -1714,3 +1440,65 @@ wrap_help (const char *help, const char *item, unsigned int item_width) } while (remaining); } + +/* Return 1 if OPTION is enabled, 0 if it is disabled, or -1 if it isn't + a simple on-off switch. */ + +int +option_enabled (int opt_idx) +{ + const struct cl_option *option = &(cl_options[opt_idx]); + if (option->flag_var) + switch (option->var_type) + { + case CLVC_BOOLEAN: + return *(int *) option->flag_var != 0; + + case CLVC_EQUAL: + return *(int *) option->flag_var == option->var_value; + + case CLVC_BIT_CLEAR: + return (*(int *) option->flag_var & option->var_value) == 0; + + case CLVC_BIT_SET: + return (*(int *) option->flag_var & option->var_value) != 0; + + case CLVC_STRING: + break; + } + return -1; +} + +/* Fill STATE with the current state of option OPTION. Return true if + there is some state to store. */ + +bool +get_option_state (int option, struct cl_option_state *state) +{ + if (cl_options[option].flag_var == 0) + return false; + + switch (cl_options[option].var_type) + { + case CLVC_BOOLEAN: + case CLVC_EQUAL: + state->data = cl_options[option].flag_var; + state->size = sizeof (int); + break; + + case CLVC_BIT_CLEAR: + case CLVC_BIT_SET: + state->ch = option_enabled (option); + state->data = &state->ch; + state->size = 1; + break; + + case CLVC_STRING: + state->data = *(const char **) cl_options[option].flag_var; + if (state->data == 0) + state->data = ""; + state->size = strlen (state->data) + 1; + break; + } + return true; +}