#include "toplev.h"
#include "params.h"
#include "diagnostic.h"
-#include "tm_p.h" /* For OPTIMIZATION_OPTIONS. */
+#include "opts-diagnostic.h"
#include "insn-attr.h" /* For INSN_SCHEDULING. */
#include "target.h"
#include "tree-pass.h"
#include "except.h"
#include "lto-streamer.h"
-/* Value of the -G xx switch, and whether it was passed or not. */
-unsigned HOST_WIDE_INT g_switch_value;
-bool g_switch_set;
-
-/* Same for selective scheduling. */
-bool sel_sched_switch_set;
-
/* True if we should exit after parsing options. */
bool exit_after_options;
-/* 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;
-
-/* True to warn about any function whose frame size is larger
- * than N bytes. */
-bool warn_frame_larger_than;
-HOST_WIDE_INT frame_larger_than_size;
-
/* Type(s) of debugging information we are producing (if any). See
flags.h for the definitions of the different possible types of
debugging information. */
static enum debug_struct_file debug_struct_generic[DINFO_USAGE_NUM_ENUMS]
= { DINFO_STRUCT_FILE_ANY, DINFO_STRUCT_FILE_ANY, DINFO_STRUCT_FILE_ANY };
+/* Run the second compilation of -fcompare-debug. Not defined using
+ Var in common.opt because this is used in Ada code and so must be
+ an actual variable not a macro. */
+int flag_compare_debug;
+
/* Parse the -femit-struct-debug-detailed option value
and set the flag variables. */
write_symbols is set to DBX_DEBUG, XCOFF_DEBUG, or DWARF_DEBUG. */
bool use_gnu_debug_info_extensions;
-/* The default visibility for all symbols (unless overridden) */
-enum symbol_visibility default_visibility = VISIBILITY_DEFAULT;
-
/* Global visibility options. */
struct visibility_flags visibility_options;
/* 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;
-static bool flag_inline_functions_set, flag_ipa_cp_set, flag_ipa_cp_clone_set;
-static bool flag_predictive_commoning_set, flag_unswitch_loops_set, flag_gcse_after_reload_set;
-
/* Functions excluded from profiling. */
typedef char *char_p; /* For DEF_VEC_P. */
static VEC(const_char_p,heap) *ignored_options;
-/* Language specific warning pass for unused results. */
-bool flag_warn_unused_result = false;
-
/* Input file names. */
const char **in_fnames;
unsigned num_in_fnames;
-static int common_handle_option (size_t scode, const char *arg, int value,
- unsigned int lang_mask);
-static void handle_param (const char *);
-static unsigned int handle_option (const char **argv, unsigned int lang_mask);
+static bool common_handle_option (struct gcc_options *opts,
+ struct gcc_options *opts_set,
+ const struct cl_decoded_option *decoded,
+ unsigned int lang_mask, int kind,
+ location_t loc,
+ const struct cl_option_handlers *handlers,
+ diagnostic_context *dc);
+static void handle_param (struct gcc_options *opts,
+ struct gcc_options *opts_set, const char *carg);
static char *write_langs (unsigned int lang_mask);
-static void complain_wrong_lang (const char *, const struct cl_option *,
+static void complain_wrong_lang (const struct cl_decoded_option *,
unsigned int lang_mask);
-static void handle_options (unsigned int, const char **, unsigned int);
static void set_debug_level (enum debug_info_type type, int extended,
const char *arg);
-
-/* If ARG is a non-negative integer made up solely of digits, return its
- value, otherwise return -1. */
-static int
-integral_argument (const char *arg)
-{
- const char *p = arg;
-
- while (*p && ISDIGIT (*p))
- p++;
-
- if (*p == '\0')
- return atoi (arg);
-
- return -1;
-}
+static void set_fast_math_flags (struct gcc_options *opts, int set);
+static void set_unsafe_math_optimizations_flags (struct gcc_options *opts,
+ int set);
+static void enable_warning_as_error (const char *arg, int value,
+ unsigned int lang_mask,
+ const struct cl_option_handlers *handlers,
+ struct gcc_options *opts,
+ struct gcc_options *opts_set,
+ location_t loc,
+ diagnostic_context *dc);
/* Return a malloced slash-separated list of languages in MASK. */
static char *
return result;
}
-/* Complain that switch OPT_INDEX does not apply to this front end. */
+/* Complain that switch DECODED does not apply to this front end (mask
+ LANG_MASK). */
static void
-complain_wrong_lang (const char *text, const struct cl_option *option,
+complain_wrong_lang (const struct cl_decoded_option *decoded,
unsigned int lang_mask)
{
- char *ok_langs, *bad_lang;
+ const struct cl_option *option = &cl_options[decoded->opt_index];
+ const char *text = decoded->orig_option_with_args_text;
+ char *ok_langs = NULL, *bad_lang = NULL;
+ unsigned int opt_flags = option->flags;
- /* The LTO front end inherits all the options from the first front
- end that was used. However, not all the original front end
- options make sense in LTO.
-
- A real solution would be to filter this in collect2, but collect2
- does not have access to all the option attributes to know what to
- filter. So, in lto1 we silently accept inherited flags and do
- nothing about it. */
- if (lang_mask & CL_LTO)
+ if (!lang_hooks.complain_wrong_lang_p (option))
return;
- ok_langs = write_langs (option->flags);
- bad_lang = write_langs (lang_mask);
-
- /* Eventually this should become a hard error IMO. */
- warning (0, "command line option \"%s\" is valid for %s but not for %s",
- text, ok_langs, bad_lang);
+ opt_flags &= ((1U << cl_lang_count) - 1) | CL_DRIVER;
+ if (opt_flags != CL_DRIVER)
+ ok_langs = write_langs (opt_flags);
+ if (lang_mask != CL_DRIVER)
+ bad_lang = write_langs (lang_mask);
+
+ if (opt_flags == CL_DRIVER)
+ error ("command line option %qs is valid for the driver but not for %s",
+ text, bad_lang);
+ else if (lang_mask == CL_DRIVER)
+ gcc_unreachable ();
+ else
+ /* Eventually this should become a hard error IMO. */
+ warning (0, "command line option %qs is valid for %s but not for %s",
+ text, ok_langs, bad_lang);
free (ok_langs);
free (bad_lang);
input_location = saved_loc;
}
-/* 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;
- unsigned int result = 0;
- const struct cl_option *option;
-
- opt = argv[0];
-
- 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 = XNEWVEC (char, len + 1);
- dup[0] = '-';
- dup[1] = opt[1];
- memcpy (dup + 2, opt + 5, len - 2 + 1);
- opt = dup;
- value = 0;
- opt_index = find_opt (opt + 1, lang_mask | CL_COMMON | CL_TARGET);
- if (opt_index == cl_options_count && opt[1] == 'W')
- {
- /* We don't generate warnings for unknown -Wno-* options
- unless we issue diagnostics. */
- postpone_unknown_option_warning (argv[0]);
- result = 1;
- goto done;
- }
- }
-
- 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;
-
- /* 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)
- {
- /* 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;
- }
- }
- else if (option->flags & CL_SEPARATE)
- {
- arg = argv[1];
- result = 2;
- }
-
- /* 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 | CL_TARGET)))
- {
- complain_wrong_lang (argv[0], option, lang_mask);
- goto done;
- }
- else if ((option->flags & CL_TARGET)
- && (option->flags & CL_LANG_ALL)
- && !(option->flags & lang_mask))
- {
- /* Complain for target flag language mismatches if any languages
- are specified. */
- complain_wrong_lang (argv[0], option, lang_mask);
- goto done;
- }
+/* Handle an unknown option DECODED, returning true if an error should be
+ given. */
- 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;
- }
+static bool
+unknown_option_callback (const struct cl_decoded_option *decoded)
+{
+ const char *opt = decoded->arg;
- /* If the switch takes an integer, convert it. */
- if (arg && (option->flags & CL_UINTEGER))
+ if (opt[1] == 'W' && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-'
+ && !(decoded->errors & CL_ERR_NEGATIVE))
{
- value = integral_argument (arg);
- if (value == -1)
- {
- error ("argument to \"%s\" should be a non-negative integer",
- option->opt_text);
- goto done;
- }
+ /* We don't generate warnings for unknown -Wno-* options unless
+ we issue diagnostics. */
+ postpone_unknown_option_warning (opt);
+ return false;
}
+ else
+ return true;
+}
- if (option->flag_var)
- set_option (option, value, arg);
-
- if (option->flags & lang_mask)
- {
- if (lang_hooks.handle_option (opt_index, arg, value) == 0)
- result = 0;
- else
- lto_register_user_option (opt_index, arg, value, lang_mask);
- }
+/* Note that an option DECODED has been successfully handled with a
+ handler for mask MASK. */
- if (result && (option->flags & CL_COMMON))
- {
- if (common_handle_option (opt_index, arg, value, lang_mask) == 0)
- result = 0;
- else
- lto_register_user_option (opt_index, arg, value, CL_COMMON);
- }
+static void
+post_handling_callback (const struct cl_decoded_option *decoded ATTRIBUTE_UNUSED,
+ unsigned int mask ATTRIBUTE_UNUSED)
+{
+#ifdef ENABLE_LTO
+ lto_register_user_option (decoded->opt_index, decoded->arg,
+ decoded->value, mask);
+#endif
+}
- if (result && (option->flags & CL_TARGET))
- {
- if (!targetm.handle_option (opt_index, arg, value))
- result = 0;
- else
- lto_register_user_option (opt_index, arg, value, CL_TARGET);
- }
+/* Handle a front-end option; arguments and return value as for
+ handle_option. */
+
+static bool
+lang_handle_option (struct gcc_options *opts,
+ struct gcc_options *opts_set,
+ const struct cl_decoded_option *decoded,
+ unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
+ location_t loc,
+ const struct cl_option_handlers *handlers,
+ diagnostic_context *dc)
+{
+ gcc_assert (opts == &global_options);
+ gcc_assert (opts_set == &global_options_set);
+ gcc_assert (dc == global_dc);
+ gcc_assert (decoded->canonical_option_num_elements <= 2);
+ return lang_hooks.handle_option (decoded->opt_index, decoded->arg,
+ decoded->value, kind, loc, handlers);
+}
- done:
- if (dup)
- free (dup);
- return result;
+/* Handle a back-end option; arguments and return value as for
+ handle_option. */
+
+static bool
+target_handle_option (struct gcc_options *opts,
+ struct gcc_options *opts_set,
+ const struct cl_decoded_option *decoded,
+ unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
+ location_t loc,
+ const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED,
+ diagnostic_context *dc)
+{
+ gcc_assert (opts == &global_options);
+ gcc_assert (opts_set == &global_options_set);
+ gcc_assert (dc == global_dc);
+ gcc_assert (decoded->canonical_option_num_elements <= 2);
+ gcc_assert (kind == DK_UNSPECIFIED);
+ gcc_assert (loc == UNKNOWN_LOCATION);
+ return targetm.handle_option (decoded->opt_index, decoded->arg,
+ decoded->value);
}
/* Handle FILENAME from the command line. */
char *s;
name = lang_hooks.decl_printable_name (fndecl, 0);
- for (i = 0;
- VEC_iterate (char_p, flag_instrument_functions_exclude_functions,
- i, s);
- ++i)
- {
- if (strstr (name, s) != NULL)
- return true;
- }
+ FOR_EACH_VEC_ELT (char_p, flag_instrument_functions_exclude_functions,
+ i, s)
+ if (strstr (name, s) != NULL)
+ return true;
}
if (VEC_length (char_p, flag_instrument_functions_exclude_files) > 0)
char *s;
name = DECL_SOURCE_FILE (fndecl);
- for (i = 0;
- VEC_iterate (char_p, flag_instrument_functions_exclude_files, i, s);
- ++i)
- {
- if (strstr (name, s) != NULL)
- return true;
- }
+ FOR_EACH_VEC_ELT (char_p, flag_instrument_functions_exclude_files, i, s)
+ if (strstr (name, s) != NULL)
+ return true;
}
return false;
}
-/* Decode and handle the vector of command line options. LANG_MASK
- contains has a single bit set representing the current
- language. */
+/* Handle the vector of command line options (located at LOC), storing
+ the results of processing DECODED_OPTIONS and DECODED_OPTIONS_COUNT
+ in OPTS and OPTS_SET and using DC for diagnostic state. LANG_MASK
+ contains has a single bit set representing the current language.
+ HANDLERS describes what functions to call for the options. */
static void
-handle_options (unsigned int argc, const char **argv, unsigned int lang_mask)
+read_cmdline_options (struct gcc_options *opts, struct gcc_options *opts_set,
+ struct cl_decoded_option *decoded_options,
+ unsigned int decoded_options_count,
+ location_t loc,
+ unsigned int lang_mask,
+ const struct cl_option_handlers *handlers,
+ diagnostic_context *dc)
{
- unsigned int n, i;
+ unsigned int i;
- for (i = 1; i < argc; i += n)
+ for (i = 1; i < decoded_options_count; i++)
{
- const char *opt = argv[i];
-
- /* Interpret "-" or a non-switch as a file name. */
- if (opt[0] != '-' || opt[1] == '\0')
+ if (decoded_options[i].opt_index == OPT_SPECIAL_input_file)
{
+ /* Input files should only ever appear on the main command
+ line. */
+ gcc_assert (opts == &global_options);
+ gcc_assert (opts_set == &global_options_set);
+
if (main_input_filename == NULL)
{
- main_input_filename = opt;
+ main_input_filename = decoded_options[i].arg;
main_input_baselength
= base_of_path (main_input_filename, &main_input_basename);
}
- add_input_filename (opt);
- n = 1;
+ add_input_filename (decoded_options[i].arg);
continue;
}
- n = handle_option (argv + i, lang_mask);
-
- if (!n)
- {
- n = 1;
- error ("unrecognized command line option \"%s\"", opt);
- }
+ read_cmdline_option (opts, opts_set,
+ decoded_options + i, loc, lang_mask, handlers,
+ dc);
}
}
-/* Parse command line options and set default flag values. Do minimal
- options processing. */
+/* Language mask determined at initialization. */
+static unsigned int initial_lang_mask;
+
+/* Initialize global options-related settings at start-up. */
+
void
-decode_options (unsigned int argc, const char **argv)
+init_options_once (void)
{
- static bool first_time_p = true;
- static int initial_min_crossjump_insns;
- static int initial_max_fields_for_field_sensitive;
- static int initial_loop_invariant_max_bbs_in_loop;
- static unsigned int initial_lang_mask;
+ /* Perform language-specific options initialization. */
+ initial_lang_mask = lang_hooks.option_lang_mask ();
- unsigned int i, lang_mask;
- int opt1;
- int opt2;
- int opt3;
- int opt1_max;
+ lang_hooks.initialize_diagnostics (global_dc);
+}
- if (first_time_p)
+/* Initialize OPTS and OPTS_SET before using them in parsing options. */
+
+void
+init_options_struct (struct gcc_options *opts, struct gcc_options *opts_set)
+{
+ size_t num_params = get_num_compiler_params ();
+
+ *opts = global_options_init;
+ memset (opts_set, 0, sizeof (*opts_set));
+
+ opts->x_param_values = XNEWVEC (int, num_params);
+ opts_set->x_param_values = XCNEWVEC (int, num_params);
+ init_param_values (opts->x_param_values);
+
+ /* Use priority coloring if cover classes is not defined for the
+ target. */
+ if (targetm.ira_cover_classes == NULL)
+ opts->x_flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
+
+ /* Initialize whether `char' is signed. */
+ opts->x_flag_signed_char = DEFAULT_SIGNED_CHAR;
+ /* Set this to a special "uninitialized" value. The actual default
+ is set after target options have been processed. */
+ opts->x_flag_short_enums = 2;
+
+ /* Initialize target_flags before targetm.target_option.optimization
+ so the latter can modify it. */
+ opts->x_target_flags = targetm.default_target_flags;
+
+ /* Some targets have ABI-specified unwind tables. */
+ opts->x_flag_unwind_tables = targetm.unwind_tables_default;
+
+ /* Some targets have other target-specific initialization. */
+ targetm.target_option.init_struct (opts);
+}
+
+/* Decode command-line options to an array, like
+ decode_cmdline_options_to_array and with the same arguments but
+ using the default lang_mask. */
+
+void
+decode_cmdline_options_to_array_default_mask (unsigned int argc,
+ const char **argv,
+ struct cl_decoded_option **decoded_options,
+ unsigned int *decoded_options_count)
+{
+ decode_cmdline_options_to_array (argc, argv,
+ initial_lang_mask | CL_COMMON | CL_TARGET,
+ decoded_options, decoded_options_count);
+}
+
+/* If indicated by the optimization level LEVEL (-Os if SIZE is set,
+ -Ofast if FAST is set), apply the option DEFAULT_OPT to OPTS and
+ OPTS_SET, diagnostic context DC, location LOC, with language mask
+ LANG_MASK and option handlers HANDLERS. */
+
+static void
+maybe_default_option (struct gcc_options *opts,
+ struct gcc_options *opts_set,
+ const struct default_options *default_opt,
+ int level, bool size, bool fast,
+ unsigned int lang_mask,
+ const struct cl_option_handlers *handlers,
+ location_t loc,
+ diagnostic_context *dc)
+{
+ const struct cl_option *option = &cl_options[default_opt->opt_index];
+ bool enabled;
+
+ if (size)
+ gcc_assert (level == 2);
+ if (fast)
+ gcc_assert (level == 3);
+
+ switch (default_opt->levels)
{
- /* Perform language-specific options initialization. */
- initial_lang_mask = lang_mask = lang_hooks.init_options (argc, argv);
-
- lang_hooks.initialize_diagnostics (global_dc);
-
- /* Save initial values of parameters we reset. */
- initial_min_crossjump_insns
- = compiler_params[PARAM_MIN_CROSSJUMP_INSNS].value;
- initial_max_fields_for_field_sensitive
- = compiler_params[PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE].value;
- initial_loop_invariant_max_bbs_in_loop
- = compiler_params[PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP].value;
+ case OPT_LEVELS_ALL:
+ enabled = true;
+ break;
+
+ case OPT_LEVELS_0_ONLY:
+ enabled = (level == 0);
+ break;
+
+ case OPT_LEVELS_1_PLUS:
+ enabled = (level >= 1);
+ break;
+
+ case OPT_LEVELS_1_PLUS_SPEED_ONLY:
+ enabled = (level >= 1 && !size);
+ break;
+
+ case OPT_LEVELS_2_PLUS:
+ enabled = (level >= 2);
+ break;
+
+ case OPT_LEVELS_2_PLUS_SPEED_ONLY:
+ enabled = (level >= 2 && !size);
+ break;
+
+ case OPT_LEVELS_3_PLUS:
+ enabled = (level >= 3);
+ break;
+
+ case OPT_LEVELS_3_PLUS_AND_SIZE:
+ enabled = (level >= 3 || size);
+ break;
+
+ case OPT_LEVELS_SIZE:
+ enabled = size;
+ break;
+
+ case OPT_LEVELS_FAST:
+ enabled = fast;
+ break;
+
+ case OPT_LEVELS_NONE:
+ default:
+ gcc_unreachable ();
}
- else
- lang_mask = initial_lang_mask;
+
+ if (enabled)
+ handle_generated_option (opts, opts_set, default_opt->opt_index,
+ default_opt->arg, default_opt->value,
+ lang_mask, DK_UNSPECIFIED, loc,
+ handlers, dc);
+ else if (default_opt->arg == NULL
+ && !(option->flags & CL_REJECT_NEGATIVE))
+ handle_generated_option (opts, opts_set, default_opt->opt_index,
+ default_opt->arg, !default_opt->value,
+ lang_mask, DK_UNSPECIFIED, loc,
+ handlers, dc);
+}
+
+/* As indicated by the optimization level LEVEL (-Os if SIZE is set,
+ -Ofast if FAST is set), apply the options in array DEFAULT_OPTS to
+ OPTS and OPTS_SET, diagnostic context DC, location LOC, with
+ language mask LANG_MASK and option handlers HANDLERS. */
+
+static void
+maybe_default_options (struct gcc_options *opts,
+ struct gcc_options *opts_set,
+ const struct default_options *default_opts,
+ int level, bool size, bool fast,
+ unsigned int lang_mask,
+ const struct cl_option_handlers *handlers,
+ location_t loc,
+ diagnostic_context *dc)
+{
+ size_t i;
+
+ for (i = 0; default_opts[i].levels != OPT_LEVELS_NONE; i++)
+ maybe_default_option (opts, opts_set, &default_opts[i],
+ level, size, fast, lang_mask, handlers, loc, dc);
+}
+
+/* Table of options enabled by default at different levels. */
+
+static const struct default_options default_options_table[] =
+ {
+ /* -O1 optimizations. */
+ { OPT_LEVELS_1_PLUS, OPT_fdefer_pop, NULL, 1 },
+#ifdef DELAY_SLOTS
+ { OPT_LEVELS_1_PLUS, OPT_fdelayed_branch, NULL, 1 },
+#endif
+ { OPT_LEVELS_1_PLUS, OPT_fguess_branch_probability, NULL, 1 },
+ { OPT_LEVELS_1_PLUS, OPT_fcprop_registers, NULL, 1 },
+ { OPT_LEVELS_1_PLUS, OPT_fforward_propagate, NULL, 1 },
+ { OPT_LEVELS_1_PLUS, OPT_fif_conversion, NULL, 1 },
+ { OPT_LEVELS_1_PLUS, OPT_fif_conversion2, NULL, 1 },
+ { OPT_LEVELS_1_PLUS, OPT_fipa_pure_const, NULL, 1 },
+ { OPT_LEVELS_1_PLUS, OPT_fipa_reference, NULL, 1 },
+ { OPT_LEVELS_1_PLUS, OPT_fipa_profile, NULL, 1 },
+ { OPT_LEVELS_1_PLUS, OPT_fmerge_constants, NULL, 1 },
+ { OPT_LEVELS_1_PLUS, OPT_fsplit_wide_types, NULL, 1 },
+ { OPT_LEVELS_1_PLUS, OPT_ftree_ccp, NULL, 1 },
+ { OPT_LEVELS_1_PLUS, OPT_ftree_bit_ccp, NULL, 1 },
+ { OPT_LEVELS_1_PLUS, OPT_ftree_dce, NULL, 1 },
+ { OPT_LEVELS_1_PLUS, OPT_ftree_dominator_opts, NULL, 1 },
+ { OPT_LEVELS_1_PLUS, OPT_ftree_dse, NULL, 1 },
+ { OPT_LEVELS_1_PLUS, OPT_ftree_ter, NULL, 1 },
+ { OPT_LEVELS_1_PLUS, OPT_ftree_sra, NULL, 1 },
+ { OPT_LEVELS_1_PLUS, OPT_ftree_copyrename, NULL, 1 },
+ { OPT_LEVELS_1_PLUS, OPT_ftree_fre, NULL, 1 },
+ { OPT_LEVELS_1_PLUS, OPT_ftree_copy_prop, NULL, 1 },
+ { OPT_LEVELS_1_PLUS, OPT_ftree_sink, NULL, 1 },
+ { OPT_LEVELS_1_PLUS, OPT_ftree_ch, NULL, 1 },
+ { OPT_LEVELS_1_PLUS, OPT_fcombine_stack_adjustments, NULL, 1 },
+
+ /* -O2 optimizations. */
+ { OPT_LEVELS_2_PLUS, OPT_finline_small_functions, NULL, 1 },
+ { OPT_LEVELS_2_PLUS, OPT_findirect_inlining, NULL, 1 },
+ { OPT_LEVELS_2_PLUS, OPT_fpartial_inlining, NULL, 1 },
+ { OPT_LEVELS_2_PLUS, OPT_fthread_jumps, NULL, 1 },
+ { OPT_LEVELS_2_PLUS, OPT_fcrossjumping, NULL, 1 },
+ { OPT_LEVELS_2_PLUS, OPT_foptimize_sibling_calls, NULL, 1 },
+ { OPT_LEVELS_2_PLUS, OPT_fcse_follow_jumps, NULL, 1 },
+ { OPT_LEVELS_2_PLUS, OPT_fgcse, NULL, 1 },
+ { OPT_LEVELS_2_PLUS, OPT_fexpensive_optimizations, NULL, 1 },
+ { OPT_LEVELS_2_PLUS, OPT_frerun_cse_after_loop, NULL, 1 },
+ { OPT_LEVELS_2_PLUS, OPT_fcaller_saves, NULL, 1 },
+ { OPT_LEVELS_2_PLUS, OPT_fpeephole2, NULL, 1 },
+#ifdef INSN_SCHEDULING
+ /* Only run the pre-regalloc scheduling pass if optimizing for speed. */
+ { OPT_LEVELS_2_PLUS_SPEED_ONLY, OPT_fschedule_insns, NULL, 1 },
+ { OPT_LEVELS_2_PLUS, OPT_fschedule_insns2, NULL, 1 },
+#endif
+ { OPT_LEVELS_2_PLUS, OPT_fregmove, NULL, 1 },
+ { OPT_LEVELS_2_PLUS, OPT_fstrict_aliasing, NULL, 1 },
+ { OPT_LEVELS_2_PLUS, OPT_fstrict_overflow, NULL, 1 },
+ { OPT_LEVELS_2_PLUS, OPT_freorder_blocks, NULL, 1 },
+ { OPT_LEVELS_2_PLUS, OPT_freorder_functions, NULL, 1 },
+ { OPT_LEVELS_2_PLUS, OPT_ftree_vrp, NULL, 1 },
+ { OPT_LEVELS_2_PLUS, OPT_ftree_builtin_call_dce, NULL, 1 },
+ { OPT_LEVELS_2_PLUS, OPT_ftree_pre, NULL, 1 },
+ { OPT_LEVELS_2_PLUS, OPT_ftree_switch_conversion, NULL, 1 },
+ { OPT_LEVELS_2_PLUS, OPT_fipa_cp, NULL, 1 },
+ { OPT_LEVELS_2_PLUS, OPT_fipa_sra, NULL, 1 },
+ { OPT_LEVELS_2_PLUS, OPT_falign_loops, NULL, 1 },
+ { OPT_LEVELS_2_PLUS, OPT_falign_jumps, NULL, 1 },
+ { OPT_LEVELS_2_PLUS, OPT_falign_labels, NULL, 1 },
+ { OPT_LEVELS_2_PLUS, OPT_falign_functions, NULL, 1 },
+
+ /* -O3 optimizations. */
+ { OPT_LEVELS_3_PLUS, OPT_ftree_loop_distribute_patterns, NULL, 1 },
+ { OPT_LEVELS_3_PLUS, OPT_fpredictive_commoning, NULL, 1 },
+ /* Inlining of functions reducing size is a good idea with -Os
+ regardless of them being declared inline. */
+ { OPT_LEVELS_3_PLUS_AND_SIZE, OPT_finline_functions, NULL, 1 },
+ { OPT_LEVELS_3_PLUS, OPT_funswitch_loops, NULL, 1 },
+ { OPT_LEVELS_3_PLUS, OPT_fgcse_after_reload, NULL, 1 },
+ { OPT_LEVELS_3_PLUS, OPT_ftree_vectorize, NULL, 1 },
+ { OPT_LEVELS_3_PLUS, OPT_fipa_cp_clone, NULL, 1 },
+
+ /* -Ofast adds optimizations to -O3. */
+ { OPT_LEVELS_FAST, OPT_ffast_math, NULL, 1 },
+
+ { OPT_LEVELS_NONE, 0, NULL, 0 }
+ };
+
+/* Default the options in OPTS and OPTS_SET based on the optimization
+ settings in DECODED_OPTIONS and DECODED_OPTIONS_COUNT. */
+static void
+default_options_optimization (struct gcc_options *opts,
+ struct gcc_options *opts_set,
+ struct cl_decoded_option *decoded_options,
+ unsigned int decoded_options_count,
+ location_t loc,
+ unsigned int lang_mask,
+ const struct cl_option_handlers *handlers,
+ diagnostic_context *dc)
+{
+ unsigned int i;
+ int opt2;
+ int ofast = 0;
/* Scan to see what optimization level has been specified. That will
determine the default value of many flags. */
- for (i = 1; i < argc; i++)
+ for (i = 1; i < decoded_options_count; i++)
{
- if (!strcmp (argv[i], "-O"))
- {
- optimize = 1;
- optimize_size = 0;
- }
- else if (argv[i][0] == '-' && argv[i][1] == 'O')
+ struct cl_decoded_option *opt = &decoded_options[i];
+ switch (opt->opt_index)
{
- /* Handle -Os, -O2, -O3, -O69, ... */
- const char *p = &argv[i][2];
-
- if ((p[0] == 's') && (p[1] == 0))
+ case OPT_O:
+ if (*opt->arg == '\0')
{
- optimize_size = 1;
-
- /* Optimizing for size forces optimize to be 2. */
- optimize = 2;
+ opts->x_optimize = 1;
+ opts->x_optimize_size = 0;
+ ofast = 0;
}
else
{
- const int optimize_val = read_integral_parameter (p, p - 2, -1);
- if (optimize_val != -1)
+ const int optimize_val = integral_argument (opt->arg);
+ if (optimize_val == -1)
+ error ("argument to %qs should be a non-negative integer",
+ "-O");
+ else
{
- optimize = optimize_val;
- if ((unsigned int) optimize > 255)
- optimize = 255;
- optimize_size = 0;
+ opts->x_optimize = optimize_val;
+ if ((unsigned int) opts->x_optimize > 255)
+ opts->x_optimize = 255;
+ opts->x_optimize_size = 0;
+ ofast = 0;
}
}
+ break;
+
+ case OPT_Os:
+ opts->x_optimize_size = 1;
+
+ /* Optimizing for size forces optimize to be 2. */
+ opts->x_optimize = 2;
+ ofast = 0;
+ break;
+
+ case OPT_Ofast:
+ /* -Ofast only adds flags to -O3. */
+ opts->x_optimize_size = 0;
+ opts->x_optimize = 3;
+ ofast = 1;
+ break;
+
+ default:
+ /* Ignore other options in this prescan. */
+ break;
}
}
- /* Use priority coloring if cover classes is not defined for the
- target. */
- if (targetm.ira_cover_classes == NULL)
- flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
+ maybe_default_options (opts, opts_set, default_options_table,
+ opts->x_optimize, opts->x_optimize_size,
+ ofast, lang_mask, handlers, loc, dc);
- /* -O1 optimizations. */
- opt1 = (optimize >= 1);
- flag_defer_pop = opt1;
-#ifdef DELAY_SLOTS
- flag_delayed_branch = opt1;
-#endif
-#ifdef CAN_DEBUG_WITHOUT_FP
- flag_omit_frame_pointer = opt1;
-#endif
- flag_guess_branch_prob = opt1;
- flag_cprop_registers = opt1;
- flag_forward_propagate = opt1;
- flag_if_conversion = opt1;
- flag_if_conversion2 = opt1;
- flag_ipa_pure_const = opt1;
- flag_ipa_reference = opt1;
- flag_merge_constants = opt1;
- flag_split_wide_types = opt1;
- flag_tree_ccp = opt1;
- flag_tree_dce = opt1;
- flag_tree_dom = opt1;
- flag_tree_dse = opt1;
- flag_tree_ter = opt1;
- flag_tree_sra = opt1;
- flag_tree_copyrename = opt1;
- flag_tree_fre = opt1;
- flag_tree_copy_prop = opt1;
- flag_tree_sink = opt1;
- flag_tree_ch = opt1;
-
- /* -O2 optimizations. */
- opt2 = (optimize >= 2);
- flag_inline_small_functions = opt2;
- flag_indirect_inlining = opt2;
- flag_thread_jumps = opt2;
- flag_crossjumping = opt2;
- flag_optimize_sibling_calls = opt2;
- flag_cse_follow_jumps = opt2;
- flag_gcse = opt2;
- flag_expensive_optimizations = opt2;
- flag_rerun_cse_after_loop = opt2;
- flag_caller_saves = opt2;
- flag_peephole2 = opt2;
-#ifdef INSN_SCHEDULING
- /* Only run the pre-regalloc scheduling pass if optimizing for speed. */
- flag_schedule_insns = opt2 && ! optimize_size;
- flag_schedule_insns_after_reload = opt2;
-#endif
- flag_regmove = opt2;
- flag_strict_aliasing = opt2;
- flag_strict_overflow = opt2;
- flag_reorder_blocks = opt2;
- flag_reorder_functions = opt2;
- flag_tree_vrp = opt2;
- flag_tree_builtin_call_dce = opt2;
- flag_tree_pre = opt2;
- flag_tree_switch_conversion = 1;
- flag_ipa_cp = opt2;
- flag_ipa_sra = opt2;
+ /* -O2 param settings. */
+ opt2 = (opts->x_optimize >= 2);
/* Track fields in field-sensitive alias analysis. */
- set_param_value ("max-fields-for-field-sensitive",
- (opt2) ? 100 : initial_max_fields_for_field_sensitive);
+ maybe_set_param_value
+ (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE,
+ opt2 ? 100 : default_param_value (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE),
+ opts->x_param_values, opts_set->x_param_values);
/* For -O1 only do loop invariant motion for very small loops. */
- set_param_value ("loop-invariant-max-bbs-in-loop",
- (opt2) ? initial_loop_invariant_max_bbs_in_loop : 1000);
-
- /* -O3 optimizations. */
- opt3 = (optimize >= 3);
- flag_predictive_commoning = opt3;
- flag_inline_functions = opt3;
- flag_unswitch_loops = opt3;
- flag_gcse_after_reload = opt3;
- flag_tree_vectorize = opt3;
- flag_ipa_cp_clone = opt3;
- if (flag_ipa_cp_clone)
- flag_ipa_cp = 1;
-
- /* Just -O1/-O0 optimizations. */
- opt1_max = (optimize <= 1);
- align_loops = opt1_max;
- align_jumps = opt1_max;
- align_labels = opt1_max;
- align_functions = opt1_max;
-
- if (optimize_size)
- {
- /* Inlining of functions reducing size is a good idea regardless of them
- being declared inline. */
- flag_inline_functions = 1;
+ maybe_set_param_value
+ (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP,
+ opt2 ? default_param_value (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP) : 1000,
+ opts->x_param_values, opts_set->x_param_values);
+
+ if (opts->x_optimize_size)
+ /* We want to crossjump as much as possible. */
+ maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS, 1,
+ opts->x_param_values, opts_set->x_param_values);
+ else
+ maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS,
+ default_param_value (PARAM_MIN_CROSSJUMP_INSNS),
+ opts->x_param_values, opts_set->x_param_values);
- /* Basic optimization options. */
- optimize_size = 1;
- if (optimize > 2)
- optimize = 2;
+ /* Allow default optimizations to be specified on a per-machine basis. */
+ maybe_default_options (opts, opts_set,
+ targetm.target_option.optimization_table,
+ opts->x_optimize, opts->x_optimize_size,
+ ofast, lang_mask, handlers, loc, dc);
+}
- /* We want to crossjump as much as possible. */
- set_param_value ("min-crossjump-insns", 1);
- }
- else
- set_param_value ("min-crossjump-insns", initial_min_crossjump_insns);
+static void finish_options (struct gcc_options *, struct gcc_options *);
- if (first_time_p)
- {
- /* 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 = targetm.default_target_flags;
-
- /* Some targets have ABI-specified unwind tables. */
- flag_unwind_tables = targetm.unwind_tables_default;
- }
+/* Set *HANDLERS to the default set of option handlers for use in the
+ compilers proper (not the driver). */
+void
+set_default_handlers (struct cl_option_handlers *handlers)
+{
+ handlers->unknown_option_callback = unknown_option_callback;
+ handlers->wrong_lang_callback = complain_wrong_lang;
+ handlers->post_handling_callback = post_handling_callback;
+ handlers->num_handlers = 3;
+ handlers->handlers[0].handler = lang_handle_option;
+ handlers->handlers[0].mask = initial_lang_mask;
+ handlers->handlers[1].handler = common_handle_option;
+ handlers->handlers[1].mask = CL_COMMON;
+ handlers->handlers[2].handler = target_handle_option;
+ handlers->handlers[2].mask = CL_TARGET;
+}
+/* Parse command line options and set default flag values. Do minimal
+ options processing. The decoded options are in *DECODED_OPTIONS
+ and *DECODED_OPTIONS_COUNT; settings go in OPTS, OPTS_SET and DC;
+ the options are located at LOC. */
+void
+decode_options (struct gcc_options *opts, struct gcc_options *opts_set,
+ struct cl_decoded_option *decoded_options,
+ unsigned int decoded_options_count,
+ location_t loc, diagnostic_context *dc)
+{
+ struct cl_option_handlers handlers;
+
+ unsigned int lang_mask;
+
+ lang_mask = initial_lang_mask;
+
+ set_default_handlers (&handlers);
+
+ /* Enable -Werror=coverage-mismatch by default. */
+ control_warning_option (OPT_Wcoverage_mismatch, (int) DK_ERROR, true,
+ loc, lang_mask,
+ &handlers, opts, opts_set, dc);
+
+ default_options_optimization (opts, opts_set,
+ decoded_options, decoded_options_count,
+ loc, lang_mask, &handlers, dc);
+
+#ifdef ENABLE_LTO
/* Clear any options currently held for LTO. */
lto_clear_user_options ();
-
-#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);
+ read_cmdline_options (opts, opts_set,
+ decoded_options, decoded_options_count,
+ loc, lang_mask,
+ &handlers, dc);
- if (dump_base_name && ! IS_ABSOLUTE_PATH (dump_base_name))
+ finish_options (opts, opts_set);
+}
+
+/* After all options have been read into OPTS and OPTS_SET, finalize
+ settings of those options and diagnose incompatible
+ combinations. */
+static void
+finish_options (struct gcc_options *opts, struct gcc_options *opts_set)
+{
+ static bool first_time_p = true;
+ enum unwind_info_type ui_except;
+
+ gcc_assert (opts == &global_options);
+ gcc_assert (opts_set = &global_options_set);
+
+ if (opts->x_dump_base_name && ! IS_ABSOLUTE_PATH (opts->x_dump_base_name))
{
- /* First try to make DUMP_BASE_NAME relative to the DUMP_DIR_NAME
- directory. Then try to make DUMP_BASE_NAME relative to the
- AUX_BASE_NAME directory, typically the directory to contain
- the object file. */
- if (dump_dir_name)
- dump_base_name = concat (dump_dir_name, dump_base_name, NULL);
- else if (aux_base_name)
+ /* First try to make OPTS->X_DUMP_BASE_NAME relative to the
+ OPTS->X_DUMP_DIR_NAME directory. Then try to make
+ OPTS->X_DUMP_BASE_NAME relative to the OPTS->X_AUX_BASE_NAME
+ directory, typically the directory to contain the object
+ file. */
+ if (opts->x_dump_dir_name)
+ opts->x_dump_base_name = concat (opts->x_dump_dir_name,
+ opts->x_dump_base_name, NULL);
+ else if (opts->x_aux_base_name)
{
const char *aux_base;
- base_of_path (aux_base_name, &aux_base);
- if (aux_base_name != aux_base)
+ base_of_path (opts->x_aux_base_name, &aux_base);
+ if (opts->x_aux_base_name != aux_base)
{
- int dir_len = aux_base - aux_base_name;
+ int dir_len = aux_base - opts->x_aux_base_name;
char *new_dump_base_name =
- XNEWVEC (char, strlen(dump_base_name) + dir_len + 1);
+ XNEWVEC (char, strlen (opts->x_dump_base_name) + dir_len + 1);
- /* Copy directory component from AUX_BASE_NAME. */
- memcpy (new_dump_base_name, aux_base_name, dir_len);
- /* Append existing DUMP_BASE_NAME. */
- strcpy (new_dump_base_name + dir_len, dump_base_name);
- dump_base_name = new_dump_base_name;
+ /* Copy directory component from OPTS->X_AUX_BASE_NAME. */
+ memcpy (new_dump_base_name, opts->x_aux_base_name, dir_len);
+ /* Append existing OPTS->X_DUMP_BASE_NAME. */
+ strcpy (new_dump_base_name + dir_len, opts->x_dump_base_name);
+ opts->x_dump_base_name = new_dump_base_name;
}
}
}
/* Handle related options for unit-at-a-time, toplevel-reorder, and
section-anchors. */
- if (!flag_unit_at_a_time)
+ if (!opts->x_flag_unit_at_a_time)
{
- if (flag_section_anchors == 1)
- error ("Section anchors must be disabled when unit-at-a-time "
- "is disabled.");
- flag_section_anchors = 0;
- if (flag_toplevel_reorder == 1)
- error ("Toplevel reorder must be disabled when unit-at-a-time "
- "is disabled.");
- flag_toplevel_reorder = 0;
+ if (opts->x_flag_section_anchors && opts_set->x_flag_section_anchors)
+ error ("section anchors must be disabled when unit-at-a-time "
+ "is disabled");
+ opts->x_flag_section_anchors = 0;
+ if (opts->x_flag_toplevel_reorder == 1)
+ error ("toplevel reorder must be disabled when unit-at-a-time "
+ "is disabled");
+ opts->x_flag_toplevel_reorder = 0;
}
+
+ /* -Wmissing-noreturn is alias for -Wsuggest-attribute=noreturn. */
+ if (opts->x_warn_missing_noreturn)
+ opts->x_warn_suggest_attribute_noreturn = true;
+
/* Unless the user has asked for section anchors, we disable toplevel
reordering at -O0 to disable transformations that might be surprising
to end users and to get -fno-toplevel-reorder tested. */
- if (!optimize && flag_toplevel_reorder == 2 && flag_section_anchors != 1)
+ if (!optimize
+ && opts->x_flag_toplevel_reorder == 2
+ && !(opts->x_flag_section_anchors && opts_set->x_flag_section_anchors))
{
- flag_toplevel_reorder = 0;
- flag_section_anchors = 0;
+ opts->x_flag_toplevel_reorder = 0;
+ opts->x_flag_section_anchors = 0;
}
- if (!flag_toplevel_reorder)
+ if (!opts->x_flag_toplevel_reorder)
{
- if (flag_section_anchors == 1)
+ if (opts->x_flag_section_anchors && opts_set->x_flag_section_anchors)
error ("section anchors must be disabled when toplevel reorder"
" is disabled");
- flag_section_anchors = 0;
+ opts->x_flag_section_anchors = 0;
}
if (first_time_p)
{
- if (flag_pie)
- flag_pic = flag_pie;
- if (flag_pic && !flag_pie)
- flag_shlib = 1;
+ if (opts->x_flag_pie)
+ opts->x_flag_pic = opts->x_flag_pie;
+ if (opts->x_flag_pic && !opts->x_flag_pie)
+ opts->x_flag_shlib = 1;
+ first_time_p = false;
}
if (optimize == 0)
{
/* Inlining does not work if not optimizing,
so force it not to be done. */
- warn_inline = 0;
- flag_no_inline = 1;
+ opts->x_warn_inline = 0;
+ opts->x_flag_no_inline = 1;
}
/* 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. */
+ generating unwind info. If opts->x_flag_exceptions is turned on
+ we need to turn off the partitioning optimization. */
- if (flag_exceptions && flag_reorder_blocks_and_partition
- && (USING_SJLJ_EXCEPTIONS
-#ifdef TARGET_UNWIND_INFO
- || 1
-#endif
- ))
+ ui_except = targetm.except_unwind_info ();
+
+ if (opts->x_flag_exceptions
+ && opts->x_flag_reorder_blocks_and_partition
+ && (ui_except == UI_SJLJ || ui_except == UI_TARGET))
{
inform (input_location,
- "-freorder-blocks-and-partition does not work with exceptions on this architecture");
- flag_reorder_blocks_and_partition = 0;
- flag_reorder_blocks = 1;
+ "-freorder-blocks-and-partition does not work "
+ "with exceptions on this architecture");
+ opts->x_flag_reorder_blocks_and_partition = 0;
+ opts->x_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
- && (USING_SJLJ_EXCEPTIONS
-#ifdef TARGET_UNWIND_INFO
- || 1
-#endif
- ))
+ if (opts->x_flag_unwind_tables
+ && !targetm.unwind_tables_default
+ && opts->x_flag_reorder_blocks_and_partition
+ && (ui_except == UI_SJLJ || ui_except == UI_TARGET))
{
inform (input_location,
- "-freorder-blocks-and-partition does not support unwind info on this architecture");
- flag_reorder_blocks_and_partition = 0;
- flag_reorder_blocks = 1;
+ "-freorder-blocks-and-partition does not support "
+ "unwind info on this architecture");
+ opts->x_flag_reorder_blocks_and_partition = 0;
+ opts->x_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
+ if (opts->x_flag_reorder_blocks_and_partition
&& (!targetm.have_named_sections
- || (flag_unwind_tables && targetm.unwind_tables_default
- && (USING_SJLJ_EXCEPTIONS
-#ifdef TARGET_UNWIND_INFO
- || 1
-#endif
- ))))
+ || (opts->x_flag_unwind_tables
+ && targetm.unwind_tables_default
+ && (ui_except == UI_SJLJ || ui_except == UI_TARGET))))
{
inform (input_location,
- "-freorder-blocks-and-partition does not work on this architecture");
- flag_reorder_blocks_and_partition = 0;
- flag_reorder_blocks = 1;
+ "-freorder-blocks-and-partition does not work "
+ "on this architecture");
+ opts->x_flag_reorder_blocks_and_partition = 0;
+ opts->x_flag_reorder_blocks = 1;
}
/* Pipelining of outer loops is only possible when general pipelining
capabilities are requested. */
- if (!flag_sel_sched_pipelining)
- flag_sel_sched_pipelining_outer_loops = 0;
+ if (!opts->x_flag_sel_sched_pipelining)
+ opts->x_flag_sel_sched_pipelining_outer_loops = 0;
if (!targetm.ira_cover_classes
- && flag_ira_algorithm == IRA_ALGORITHM_CB)
+ && opts->x_flag_ira_algorithm == IRA_ALGORITHM_CB)
{
inform (input_location,
"-fira-algorithm=CB does not work on this architecture");
- flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
+ opts->x_flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
}
- /* Save the current optimization options if this is the first call. */
- if (first_time_p)
+ if (opts->x_flag_conserve_stack)
{
- optimization_default_node = build_optimization_node ();
- optimization_current_node = optimization_default_node;
- first_time_p = false;
+ maybe_set_param_value (PARAM_LARGE_STACK_FRAME, 100,
+ opts->x_param_values, opts_set->x_param_values);
+ maybe_set_param_value (PARAM_STACK_FRAME_GROWTH, 40,
+ opts->x_param_values, opts_set->x_param_values);
}
- if (flag_conserve_stack)
+ if (opts->x_flag_wpa || opts->x_flag_ltrans)
{
- if (!PARAM_SET_P (PARAM_LARGE_STACK_FRAME))
- PARAM_VALUE (PARAM_LARGE_STACK_FRAME) = 100;
- if (!PARAM_SET_P (PARAM_STACK_FRAME_GROWTH))
- PARAM_VALUE (PARAM_STACK_FRAME_GROWTH) = 40;
+ /* These passes are not WHOPR compatible yet. */
+ opts->x_flag_ipa_pta = 0;
+ opts->x_flag_ipa_struct_reorg = 0;
}
- if (flag_lto || flag_whopr)
+ if (opts->x_flag_lto)
{
#ifdef ENABLE_LTO
- flag_generate_lto = 1;
+ opts->x_flag_generate_lto = 1;
/* When generating IL, do not operate in whole-program mode.
Otherwise, symbols will be privatized too early, causing link
errors later. */
- flag_whole_program = 0;
+ opts->x_flag_whole_program = 0;
#else
error ("LTO support has not been enabled in this configuration");
#endif
}
+ if ((opts->x_flag_lto_partition_balanced != 0) + (opts->x_flag_lto_partition_1to1 != 0)
+ + (opts->x_flag_lto_partition_none != 0) >= 1)
+ {
+ if ((opts->x_flag_lto_partition_balanced != 0)
+ + (opts->x_flag_lto_partition_1to1 != 0)
+ + (opts->x_flag_lto_partition_none != 0) > 1)
+ error ("only one -flto-partition value can be specified");
+ }
- /* Reconcile -flto and -fwhopr. Set additional flags as appropriate and
- check option consistency. */
- if (flag_lto && flag_whopr)
- error ("-flto and -fwhopr are mutually exclusive");
+ /* We initialize opts->x_flag_split_stack to -1 so that targets can set a
+ default value if they choose based on other options. */
+ if (opts->x_flag_split_stack == -1)
+ opts->x_flag_split_stack = 0;
+ else if (opts->x_flag_split_stack)
+ {
+ if (!targetm.supports_split_stack (true))
+ {
+ error ("%<-fsplit-stack%> is not supported by "
+ "this compiler configuration");
+ opts->x_flag_split_stack = 0;
+ }
+ }
}
#define LEFT_COLUMN 27
if ((option->flags & exclude_flags) != 0)
continue;
+ /* The driver currently prints its own help text. */
+ if ((option->flags & CL_DRIVER) != 0
+ && (option->flags & (((1U << cl_lang_count) - 1)
+ | CL_COMMON | CL_TARGET)) == 0)
+ continue;
+
found = true;
/* Skip switches that have already been printed. */
if (printed[i])
with an option to be an indication of its current setting. */
if (!quiet_flag)
{
+ void *flag_var = option_flag_var (i, &global_options);
+
if (len < (LEFT_COLUMN + 2))
strcpy (new_help, "\t\t");
else
strcpy (new_help, "\t");
- if (option->flag_var != NULL)
+ if (flag_var != NULL)
{
if (option->flags & CL_JOINED)
{
if (option->var_type == CLVC_STRING)
{
- if (* (const char **) option->flag_var != NULL)
+ if (* (const char **) flag_var != NULL)
snprintf (new_help + strlen (new_help),
sizeof (new_help) - strlen (new_help),
- * (const char **) option->flag_var);
+ * (const char **) flag_var);
}
else
sprintf (new_help + strlen (new_help),
- "%#x", * (int *) option->flag_var);
+ "%#x", * (int *) flag_var);
}
else
- strcat (new_help, option_enabled (i)
+ strcat (new_help, option_enabled (i, &global_options)
? _("[enabled]") : _("[disabled]"));
}
switch (flag & include_flags)
{
case 0:
+ case CL_DRIVER:
break;
case CL_TARGET:
/* Handle target- and language-independent options. Return zero to
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,
- unsigned int lang_mask)
+ DECODED->value assigned to a variable, it happens automatically. */
+
+static bool
+common_handle_option (struct gcc_options *opts,
+ struct gcc_options *opts_set,
+ const struct cl_decoded_option *decoded,
+ unsigned int lang_mask, int kind ATTRIBUTE_UNUSED,
+ location_t loc,
+ const struct cl_option_handlers *handlers,
+ diagnostic_context *dc)
{
- static bool verbose = false;
+ size_t scode = decoded->opt_index;
+ const char *arg = decoded->arg;
+ int value = decoded->value;
enum opt_code code = (enum opt_code) scode;
+ gcc_assert (opts == &global_options);
+ gcc_assert (opts_set == &global_options_set);
+ gcc_assert (dc == global_dc);
+ gcc_assert (decoded->canonical_option_num_elements <= 2);
+
switch (code)
{
case OPT__param:
- handle_param (arg);
+ handle_param (opts, opts_set, arg);
break;
- case OPT_v:
- verbose = true;
- break;
-
- case OPT_fhelp:
case OPT__help:
{
unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
unsigned int undoc_mask;
unsigned int i;
- undoc_mask = (verbose | extra_warnings) ? 0 : CL_UNDOCUMENTED;
+ undoc_mask = ((opts->x_verbose_flag | opts->x_extra_warnings)
+ ? 0
+ : CL_UNDOCUMENTED);
/* First display any single language specific options. */
for (i = 0; i < cl_lang_count; i++)
print_specific_help
print_specific_help (0, undoc_mask, all_langs_mask);
/* Then display any remaining, non-language options. */
for (i = CL_MIN_OPTION_CLASS; i <= CL_MAX_OPTION_CLASS; i <<= 1)
- print_specific_help (i, undoc_mask, 0);
+ if (i != CL_DRIVER)
+ print_specific_help (i, undoc_mask, 0);
exit_after_options = true;
break;
}
- case OPT_ftarget_help:
case OPT__target_help:
print_specific_help (CL_TARGET, CL_UNDOCUMENTED, 0);
exit_after_options = true;
/* Allow the target a chance to give the user some additional information. */
- if (targetm.target_help)
- targetm.target_help ();
+ if (targetm.help)
+ targetm.help ();
break;
- case OPT_fhelp_:
case OPT__help_:
{
const char * a = arg;
break;
}
- case OPT_fversion:
case OPT__version:
exit_after_options = true;
break;
- case OPT_G:
- g_switch_value = value;
- g_switch_set = true;
- break;
-
case OPT_O:
case OPT_Os:
+ case OPT_Ofast:
/* Currently handled in a prescan. */
break;
case OPT_Werror_:
- enable_warning_as_error (arg, value, lang_mask);
+ enable_warning_as_error (arg, value, lang_mask, handlers,
+ opts, opts_set, loc, dc);
break;
case OPT_Wlarger_than_:
- /* This form corresponds to -Wlarger-than-.
- Kept for backward compatibility.
- Don't use it as the first argument of warning(). */
+ opts->x_larger_than_size = value;
+ opts->x_warn_larger_than = value != -1;
+ break;
- case OPT_Wlarger_than_eq:
- larger_than_size = value;
- warn_larger_than = value != -1;
+ case OPT_Wfatal_errors:
+ dc->fatal_errors = value;
break;
case OPT_Wframe_larger_than_:
- frame_larger_than_size = value;
- warn_frame_larger_than = value != -1;
+ opts->x_frame_larger_than_size = value;
+ opts->x_warn_frame_larger_than = value != -1;
break;
case OPT_Wstrict_aliasing:
- set_Wstrict_aliasing (value);
- break;
-
- case OPT_Wstrict_aliasing_:
- warn_strict_aliasing = value;
+ set_Wstrict_aliasing (opts, value);
break;
case OPT_Wstrict_overflow:
- warn_strict_overflow = (value
- ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
- : 0);
- break;
-
- case OPT_Wstrict_overflow_:
- warn_strict_overflow = value;
+ opts->x_warn_strict_overflow = (value
+ ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
+ : 0);
break;
- case OPT_Wunused:
- warn_unused = value;
+ case OPT_Wsystem_headers:
+ dc->dc_warn_system_headers = value;
break;
case OPT_aux_info:
- case OPT_aux_info_:
- aux_info_file_name = arg;
- flag_gen_aux_info = 1;
- break;
-
- case OPT_auxbase:
- aux_base_name = arg;
+ opts->x_flag_gen_aux_info = 1;
break;
case OPT_auxbase_strip:
char *tmp = xstrdup (arg);
strip_off_ending (tmp, strlen (tmp));
if (tmp[0])
- aux_base_name = tmp;
+ opts->x_aux_base_name = tmp;
}
break;
decode_d_option (arg);
break;
- case OPT_dumpbase:
- dump_base_name = arg;
- break;
-
- case OPT_dumpdir:
- dump_dir_name = arg;
- break;
-
- case OPT_falign_functions_:
- align_functions = value;
- break;
-
- case OPT_falign_jumps_:
- align_jumps = value;
- break;
-
- case OPT_falign_labels_:
- align_labels = value;
- break;
-
- case OPT_falign_loops_:
- align_loops = value;
- break;
-
- case OPT_fbranch_probabilities:
- flag_branch_probabilities_set = true;
- break;
-
case OPT_fcall_used_:
fix_register (arg, 0, 1);
break;
fix_register (arg, 0, 0);
break;
+ case OPT_fcompare_debug_second:
+ flag_compare_debug = value;
+ break;
+
case OPT_fdbg_cnt_:
dbg_cnt_process_opt (arg);
break;
case OPT_fdiagnostics_show_location_:
if (!strcmp (arg, "once"))
- diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
+ diagnostic_prefixing_rule (dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
else if (!strcmp (arg, "every-line"))
- diagnostic_prefixing_rule (global_dc)
+ diagnostic_prefixing_rule (dc)
= DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
else
- return 0;
+ return false;
break;
case OPT_fdiagnostics_show_option:
- global_dc->show_option_requested = true;
+ dc->show_option_requested = value;
break;
case OPT_fdump_:
if (!dump_switch_p (arg))
- return 0;
+ return false;
+ break;
+
+ case OPT_ffp_contract_:
+ if (!strcmp (arg, "on"))
+ /* Not implemented, fall back to conservative FP_CONTRACT_OFF. */
+ opts->x_flag_fp_contract_mode = FP_CONTRACT_OFF;
+ else if (!strcmp (arg, "off"))
+ opts->x_flag_fp_contract_mode = FP_CONTRACT_OFF;
+ else if (!strcmp (arg, "fast"))
+ opts->x_flag_fp_contract_mode = FP_CONTRACT_FAST;
+ else
+ error ("unknown floating point contraction style \"%s\"", arg);
break;
case OPT_fexcess_precision_:
if (!strcmp (arg, "fast"))
- flag_excess_precision_cmdline = EXCESS_PRECISION_FAST;
+ opts->x_flag_excess_precision_cmdline = EXCESS_PRECISION_FAST;
else if (!strcmp (arg, "standard"))
- flag_excess_precision_cmdline = EXCESS_PRECISION_STANDARD;
+ opts->x_flag_excess_precision_cmdline = EXCESS_PRECISION_STANDARD;
else
error ("unknown excess precision style \"%s\"", arg);
break;
case OPT_ffast_math:
- set_fast_math_flags (value);
+ set_fast_math_flags (opts, value);
break;
case OPT_funsafe_math_optimizations:
- set_unsafe_math_optimizations_flags (value);
+ set_unsafe_math_optimizations_flags (opts, value);
break;
case OPT_ffixed_:
break;
case OPT_finline_limit_:
- case OPT_finline_limit_eq:
- set_param_value ("max-inline-insns-single", value / 2);
- set_param_value ("max-inline-insns-auto", value / 2);
+ set_param_value ("max-inline-insns-single", value / 2,
+ opts->x_param_values, opts_set->x_param_values);
+ set_param_value ("max-inline-insns-auto", value / 2,
+ opts->x_param_values, opts_set->x_param_values);
break;
case OPT_finstrument_functions_exclude_function_list_:
break;
case OPT_fmessage_length_:
- pp_set_line_maximum_length (global_dc->printer, value);
+ pp_set_line_maximum_length (dc->printer, value);
break;
case OPT_fpack_struct_:
}
break;
- case OPT_fpeel_loops:
- flag_peel_loops_set = true;
- break;
-
case OPT_fplugin_:
#ifdef ENABLE_PLUGIN
add_new_plugin (arg);
#else
- error ("Plugin support is disabled. Configure with --enable-plugin.");
+ error ("plugin support is disabled; configure with --enable-plugin");
#endif
break;
#ifdef ENABLE_PLUGIN
parse_plugin_arg_opt (arg);
#else
- error ("Plugin support is disabled. Configure with --enable-plugin.");
+ error ("plugin support is disabled; configure with --enable-plugin");
#endif
break;
- case OPT_fprofile_arcs:
- profile_arc_flag_set = true;
- break;
-
- case OPT_finline_functions:
- flag_inline_functions_set = true;
- break;
-
case OPT_fprofile_dir_:
profile_data_prefix = xstrdup (arg);
break;
case OPT_fprofile_use_:
profile_data_prefix = xstrdup (arg);
- flag_profile_use = true;
+ opts->x_flag_profile_use = true;
value = true;
/* No break here - do -fprofile-use processing. */
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;
- if (!flag_inline_functions_set)
- flag_inline_functions = value;
- if (!flag_ipa_cp_set)
- flag_ipa_cp = value;
- if (!flag_ipa_cp_clone_set
- && value && flag_ipa_cp)
- flag_ipa_cp_clone = value;
- if (!flag_predictive_commoning_set)
- flag_predictive_commoning = value;
- if (!flag_unswitch_loops_set)
- flag_unswitch_loops = value;
- if (!flag_gcse_after_reload_set)
- flag_gcse_after_reload = value;
+ if (!opts_set->x_flag_branch_probabilities)
+ opts->x_flag_branch_probabilities = value;
+ if (!opts_set->x_flag_profile_values)
+ opts->x_flag_profile_values = value;
+ if (!opts_set->x_flag_unroll_loops)
+ opts->x_flag_unroll_loops = value;
+ if (!opts_set->x_flag_peel_loops)
+ opts->x_flag_peel_loops = value;
+ if (!opts_set->x_flag_tracer)
+ opts->x_flag_tracer = value;
+ if (!opts_set->x_flag_value_profile_transformations)
+ opts->x_flag_value_profile_transformations = value;
+ if (!opts_set->x_flag_inline_functions)
+ opts->x_flag_inline_functions = value;
+ if (!opts_set->x_flag_ipa_cp)
+ opts->x_flag_ipa_cp = value;
+ if (!opts_set->x_flag_ipa_cp_clone
+ && value && opts->x_flag_ipa_cp)
+ opts->x_flag_ipa_cp_clone = value;
+ if (!opts_set->x_flag_predictive_commoning)
+ opts->x_flag_predictive_commoning = value;
+ if (!opts_set->x_flag_unswitch_loops)
+ opts->x_flag_unswitch_loops = value;
+ if (!opts_set->x_flag_gcse_after_reload)
+ opts->x_flag_gcse_after_reload = value;
break;
case OPT_fprofile_generate_:
value = true;
/* No break here - do -fprofile-generate processing. */
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;
- if (!flag_inline_functions_set)
- flag_inline_functions = value;
+ if (!opts_set->x_profile_arc_flag)
+ opts->x_profile_arc_flag = value;
+ if (!opts_set->x_flag_profile_values)
+ opts->x_flag_profile_values = value;
+ if (!opts_set->x_flag_value_profile_transformations)
+ opts->x_flag_value_profile_transformations = value;
+ if (!opts_set->x_flag_inline_functions)
+ opts->x_flag_inline_functions = value;
break;
- case OPT_fprofile_values:
- flag_profile_values_set = true;
+ case OPT_fshow_column:
+ dc->show_column = value;
break;
case OPT_fvisibility_:
{
if (!strcmp(arg, "default"))
- default_visibility = VISIBILITY_DEFAULT;
+ opts->x_default_visibility = VISIBILITY_DEFAULT;
else if (!strcmp(arg, "internal"))
- default_visibility = VISIBILITY_INTERNAL;
+ opts->x_default_visibility = VISIBILITY_INTERNAL;
else if (!strcmp(arg, "hidden"))
- default_visibility = VISIBILITY_HIDDEN;
+ opts->x_default_visibility = VISIBILITY_HIDDEN;
else if (!strcmp(arg, "protected"))
- default_visibility = VISIBILITY_PROTECTED;
+ opts->x_default_visibility = VISIBILITY_PROTECTED;
else
error ("unrecognized visibility value \"%s\"", arg);
}
break;
- case OPT_fvpt:
- flag_value_profile_transformations_set = true;
- break;
-
case OPT_frandom_seed:
/* The real switch is -fno-random-seed. */
if (value)
- return 0;
+ return false;
set_random_seed (NULL);
break;
set_random_seed (arg);
break;
- case OPT_fselective_scheduling:
- case OPT_fselective_scheduling2:
- sel_sched_switch_set = true;
- break;
-
case OPT_fsched_verbose_:
#ifdef INSN_SCHEDULING
fix_sched_param ("verbose", arg);
break;
#else
- return 0;
+ return false;
#endif
case OPT_fsched_stalled_insns_:
- flag_sched_stalled_insns = value;
- if (flag_sched_stalled_insns == 0)
- flag_sched_stalled_insns = -1;
+ opts->x_flag_sched_stalled_insns = value;
+ if (opts->x_flag_sched_stalled_insns == 0)
+ opts->x_flag_sched_stalled_insns = -1;
break;
case OPT_fsched_stalled_insns_dep_:
- flag_sched_stalled_insns_dep = value;
+ opts->x_flag_sched_stalled_insns_dep = value;
break;
case OPT_fstack_check_:
warning (0, "unknown stack check parameter \"%s\"", arg);
break;
- case OPT_fstack_check:
- /* This is the same as the "specific" mode above. */
- if (value)
- flag_stack_check = STACK_CHECK_BUILTIN
- ? FULL_BUILTIN_STACK_CHECK
- : STACK_CHECK_STATIC_BUILTIN
- ? STATIC_BUILTIN_STACK_CHECK
- : GENERIC_STACK_CHECK;
- else
- flag_stack_check = NO_STACK_CHECK;
- break;
-
case OPT_fstack_limit:
/* The real switch is -fno-stack-limit. */
if (value)
- return 0;
+ return false;
stack_limit_rtx = NULL_RTX;
break;
case OPT_ftls_model_:
if (!strcmp (arg, "global-dynamic"))
- flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
+ opts->x_flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
else if (!strcmp (arg, "local-dynamic"))
- flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
+ opts->x_flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
else if (!strcmp (arg, "initial-exec"))
- flag_tls_default = TLS_MODEL_INITIAL_EXEC;
+ opts->x_flag_tls_default = TLS_MODEL_INITIAL_EXEC;
else if (!strcmp (arg, "local-exec"))
- flag_tls_default = TLS_MODEL_LOCAL_EXEC;
+ opts->x_flag_tls_default = TLS_MODEL_LOCAL_EXEC;
else
warning (0, "unknown tls-model \"%s\"", arg);
break;
case OPT_fira_algorithm_:
if (!strcmp (arg, "CB"))
- flag_ira_algorithm = IRA_ALGORITHM_CB;
+ opts->x_flag_ira_algorithm = IRA_ALGORITHM_CB;
else if (!strcmp (arg, "priority"))
- flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
+ opts->x_flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
else
warning (0, "unknown ira algorithm \"%s\"", arg);
break;
case OPT_fira_region_:
if (!strcmp (arg, "one"))
- flag_ira_region = IRA_REGION_ONE;
+ opts->x_flag_ira_region = IRA_REGION_ONE;
else if (!strcmp (arg, "all"))
- flag_ira_region = IRA_REGION_ALL;
+ opts->x_flag_ira_region = IRA_REGION_ALL;
else if (!strcmp (arg, "mixed"))
- flag_ira_region = IRA_REGION_MIXED;
+ opts->x_flag_ira_region = IRA_REGION_MIXED;
else
warning (0, "unknown ira region \"%s\"", arg);
break;
- case OPT_fira_verbose_:
- flag_ira_verbose = value;
- break;
-
- case OPT_ftracer:
- flag_tracer_set = true;
- break;
-
- case OPT_fipa_cp:
- flag_ipa_cp_set = true;
- break;
-
- case OPT_fipa_cp_clone:
- flag_ipa_cp_clone_set = true;
- break;
-
- case OPT_fpredictive_commoning:
- flag_predictive_commoning_set = true;
- break;
-
- case OPT_funswitch_loops:
- flag_unswitch_loops_set = true;
- break;
-
- case OPT_fgcse_after_reload:
- flag_gcse_after_reload_set = true;
- break;
-
- case OPT_funroll_loops:
- flag_unroll_loops_set = true;
- break;
-
case OPT_g:
set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg);
break;
set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
break;
- case OPT_o:
- asm_file_name = arg;
+ case OPT_pedantic_errors:
+ opts->x_pedantic = 1;
+ dc->pedantic_errors = 1;
break;
- case OPT_pedantic_errors:
- flag_pedantic_errors = pedantic = 1;
+ case OPT_flto:
+ opts->x_flag_lto = "";
+ break;
+
+ case OPT_w:
+ dc->dc_inhibit_warnings = true;
break;
- case OPT_fsee:
- case OPT_fcse_skip_blocks:
- case OPT_floop_optimize:
- case OPT_frerun_loop_opt:
- case OPT_fstrength_reduce:
- case OPT_ftree_store_copy_prop:
- case OPT_fforce_addr:
- case OPT_ftree_salias:
- case OPT_ftree_store_ccp:
- case OPT_Wunreachable_code:
- /* These are no-ops, preserved for backward compatibility. */
+ case OPT_fmax_errors_:
+ dc->max_errors = value;
break;
case OPT_fuse_linker_plugin:
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);
+ gcc_assert (option_flag_var (scode, opts));
break;
}
- return 1;
+ return true;
}
/* Handle --param NAME=VALUE. */
static void
-handle_param (const char *carg)
+handle_param (struct gcc_options *opts, struct gcc_options *opts_set,
+ const char *carg)
{
char *equal, *arg;
int value;
else
{
*equal = '\0';
- set_param_value (arg, value);
+ set_param_value (arg, value,
+ opts->x_param_values, opts_set->x_param_values);
}
}
free (arg);
}
-/* Used to set the level of strict aliasing warnings,
+/* Used to set the level of strict aliasing warnings in OPTS,
when no level is specified (i.e., when -Wstrict-aliasing, and not
-Wstrict-aliasing=level was given).
ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
and 0 otherwise. After calling this function, wstrict_aliasing will be
set to the default value of -Wstrict_aliasing=level, currently 3. */
void
-set_Wstrict_aliasing (int onoff)
+set_Wstrict_aliasing (struct gcc_options *opts, int onoff)
{
gcc_assert (onoff == 0 || onoff == 1);
if (onoff != 0)
- warn_strict_aliasing = 3;
+ opts->x_warn_strict_aliasing = 3;
else
- warn_strict_aliasing = 0;
+ opts->x_warn_strict_aliasing = 0;
}
/* The following routines are useful in setting all the flags that
-ffast-math and -fno-fast-math imply. */
-void
-set_fast_math_flags (int set)
+static void
+set_fast_math_flags (struct gcc_options *opts, int set)
{
- flag_unsafe_math_optimizations = set;
- set_unsafe_math_optimizations_flags (set);
- flag_finite_math_only = set;
- flag_errno_math = !set;
+ opts->x_flag_unsafe_math_optimizations = set;
+ set_unsafe_math_optimizations_flags (opts, set);
+ opts->x_flag_finite_math_only = set;
+ opts->x_flag_errno_math = !set;
if (set)
{
- flag_signaling_nans = 0;
- flag_rounding_math = 0;
- flag_cx_limited_range = 1;
+ opts->x_flag_signaling_nans = 0;
+ opts->x_flag_rounding_math = 0;
+ opts->x_flag_cx_limited_range = 1;
}
}
/* When -funsafe-math-optimizations is set the following
flags are set as well. */
-void
-set_unsafe_math_optimizations_flags (int set)
+static void
+set_unsafe_math_optimizations_flags (struct gcc_options *opts, int set)
{
- flag_trapping_math = !set;
- flag_signed_zeros = !set;
- flag_associative_math = set;
- flag_reciprocal_math = set;
+ opts->x_flag_trapping_math = !set;
+ opts->x_flag_signed_zeros = !set;
+ opts->x_flag_associative_math = set;
+ opts->x_flag_reciprocal_math = set;
}
/* Return true iff flags are set as if -ffast-math. */
bool
fast_math_flags_struct_set_p (struct cl_optimization *opt)
{
- return (!opt->flag_trapping_math
- && opt->flag_unsafe_math_optimizations
- && opt->flag_finite_math_only
- && !opt->flag_signed_zeros
- && !opt->flag_errno_math);
+ return (!opt->x_flag_trapping_math
+ && opt->x_flag_unsafe_math_optimizations
+ && opt->x_flag_finite_math_only
+ && !opt->x_flag_signed_zeros
+ && !opt->x_flag_errno_math);
}
/* Handle a debug output -g switch. EXTENDED is true or false to support
}
}
-/* Return 1 if OPTION is enabled, 0 if it is disabled, or -1 if it isn't
- a simple on-off switch. */
+/* Return 1 if option OPT_IDX is enabled in OPTS, 0 if it is disabled,
+ or -1 if it isn't a simple on-off switch. */
int
-option_enabled (int opt_idx)
+option_enabled (int opt_idx, void *opts)
{
const struct cl_option *option = &(cl_options[opt_idx]);
+ struct gcc_options *optsg = (struct gcc_options *) opts;
+ void *flag_var = option_flag_var (opt_idx, optsg);
- if (option->flag_var)
+ if (flag_var)
switch (option->var_type)
{
case CLVC_BOOLEAN:
- return *(int *) option->flag_var != 0;
+ return *(int *) flag_var != 0;
case CLVC_EQUAL:
- return *(int *) option->flag_var == option->var_value;
+ return *(int *) flag_var == option->var_value;
case CLVC_BIT_CLEAR:
- return (*(int *) option->flag_var & option->var_value) == 0;
+ return (*(int *) flag_var & option->var_value) == 0;
case CLVC_BIT_SET:
- return (*(int *) option->flag_var & option->var_value) != 0;
+ return (*(int *) 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. */
+/* Fill STATE with the current state of option OPTION in OPTS. Return
+ true if there is some state to store. */
bool
-get_option_state (int option, struct cl_option_state *state)
+get_option_state (struct gcc_options *opts, int option,
+ struct cl_option_state *state)
{
- if (cl_options[option].flag_var == 0)
+ void *flag_var = option_flag_var (option, opts);
+
+ if (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->data = flag_var;
state->size = sizeof (int);
break;
case CLVC_BIT_CLEAR:
case CLVC_BIT_SET:
- state->ch = option_enabled (option);
+ state->ch = option_enabled (option, opts);
state->data = &state->ch;
state->size = 1;
break;
case CLVC_STRING:
- state->data = *(const char **) cl_options[option].flag_var;
+ state->data = *(const char **) flag_var;
if (state->data == 0)
state->data = "";
state->size = strlen ((const char *) state->data) + 1;
return true;
}
-/* Set *OPTION according to VALUE and ARG. */
-
-void
-set_option (const struct cl_option *option, int value, const char *arg)
-{
- if (!option->flag_var)
- return;
-
- switch (option->var_type)
- {
- case CLVC_BOOLEAN:
- *(int *) option->flag_var = value;
- break;
+/* Enable (or disable if VALUE is 0) a warning option ARG (language
+ mask LANG_MASK, option handlers HANDLERS) as an error for option
+ structures OPTS and OPTS_SET, diagnostic context DC (possibly
+ NULL), location LOC. This is used by -Werror=. */
- 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;
- }
-}
-
-/* Enable a warning option as an error. This is used by -Werror= and
- also by legacy Werror-implicit-function-declaration. */
-
-void
-enable_warning_as_error (const char *arg, int value, unsigned int lang_mask)
+static void
+enable_warning_as_error (const char *arg, int value, unsigned int lang_mask,
+ const struct cl_option_handlers *handlers,
+ struct gcc_options *opts,
+ struct gcc_options *opts_set,
+ location_t loc, diagnostic_context *dc)
{
char *new_option;
int option_index;
new_option[0] = 'W';
strcpy (new_option + 1, arg);
option_index = find_opt (new_option, lang_mask);
- if (option_index == N_OPTS)
+ if (option_index == OPT_SPECIAL_unknown)
{
- error ("-Werror=%s: No option -%s", arg, new_option);
+ error ("-Werror=%s: no option -%s", arg, new_option);
}
else
{
- diagnostic_t kind = value ? DK_ERROR : DK_WARNING;
- diagnostic_classify_diagnostic (global_dc, option_index, kind);
-
- /* -Werror=foo implies -Wfoo. */
- if (cl_options[option_index].var_type == CLVC_BOOLEAN
- && cl_options[option_index].flag_var
- && kind == DK_ERROR)
- *(int *) cl_options[option_index].flag_var = 1;
+ const diagnostic_t kind = value ? DK_ERROR : DK_WARNING;
+
+ control_warning_option (option_index, (int) kind, value,
+ loc, lang_mask,
+ handlers, opts, opts_set, dc);
}
free (new_option);
}
+
+/* Return malloced memory for the name of the option OPTION_INDEX
+ which enabled a diagnostic (context CONTEXT), originally of type
+ ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
+ as -Werror. */
+
+char *
+option_name (diagnostic_context *context, int option_index,
+ diagnostic_t orig_diag_kind, diagnostic_t diag_kind)
+{
+ if (option_index)
+ {
+ /* A warning classified as an error. */
+ if ((orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN)
+ && diag_kind == DK_ERROR)
+ return concat (cl_options[OPT_Werror_].opt_text,
+ /* Skip over "-W". */
+ cl_options[option_index].opt_text + 2,
+ NULL);
+ /* A warning with option. */
+ else
+ return xstrdup (cl_options[option_index].opt_text);
+ }
+ /* A warning without option classified as an error. */
+ else if (orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN
+ || diag_kind == DK_WARNING)
+ {
+ if (context->warning_as_error_requested)
+ return xstrdup (cl_options[OPT_Werror].opt_text);
+ else
+ return xstrdup (_("enabled by default"));
+ }
+ else
+ return NULL;
+}
OSDN Git Service
