/* 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. */
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;
struct gcc_options *opts_set,
const struct cl_decoded_option *decoded,
unsigned int lang_mask, int kind,
- const struct cl_option_handlers *handlers);
+ 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);
unsigned int lang_mask);
static void set_debug_level (enum debug_info_type type, int extended,
const char *arg);
-static void set_fast_math_flags (int set);
-static void set_unsafe_math_optimizations_flags (int set);
+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 *
struct gcc_options *opts_set,
const struct cl_decoded_option *decoded,
unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
- const struct cl_option_handlers *handlers)
+ 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, handlers);
+ decoded->value, kind, loc, handlers);
}
/* Handle a back-end option; arguments and return value as for
struct gcc_options *opts_set,
const struct cl_decoded_option *decoded,
unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
- const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED)
+ 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 the vector of command line options, storing the results of
- processing DECODED_OPTIONS and DECODED_OPTIONS_COUNT in OPTS and
- OPTS_SET. LANG_MASK contains has a single bit set representing the
- current language. HANDLERS describes what functions to call for
- the options. */
+/* 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
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)
+ const struct cl_option_handlers *handlers,
+ diagnostic_context *dc)
{
unsigned int i;
}
read_cmdline_option (opts, opts_set,
- decoded_options + i, lang_mask, handlers,
- global_dc);
+ decoded_options + i, loc, lang_mask, handlers,
+ dc);
}
}
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)
+ {
+ 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 ();
+ }
+
+ 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)
+ 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 opt1;
int opt2;
- int opt3;
- int opt1_max;
int ofast = 0;
- gcc_assert (opts == &global_options);
- gcc_assert (opts_set = &global_options_set);
-
/* Scan to see what optimization level has been specified. That will
determine the default value of many flags. */
for (i = 1; i < decoded_options_count; i++)
case OPT_O:
if (*opt->arg == '\0')
{
- optimize = 1;
- optimize_size = 0;
+ opts->x_optimize = 1;
+ opts->x_optimize_size = 0;
ofast = 0;
}
else
"-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:
- optimize_size = 1;
+ opts->x_optimize_size = 1;
/* Optimizing for size forces optimize to be 2. */
- optimize = 2;
+ opts->x_optimize = 2;
ofast = 0;
break;
case OPT_Ofast:
/* -Ofast only adds flags to -O3. */
- optimize_size = 0;
- optimize = 3;
+ opts->x_optimize_size = 0;
+ opts->x_optimize = 3;
ofast = 1;
break;
}
}
- /* -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_ipa_profile = opt1;
- flag_merge_constants = opt1;
- flag_split_wide_types = opt1;
- flag_tree_ccp = opt1;
- flag_tree_bit_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;
- flag_combine_stack_adjustments = opt1;
-
- /* -O2 optimizations. */
- opt2 = (optimize >= 2);
- flag_inline_small_functions = opt2;
- flag_indirect_inlining = opt2;
- flag_partial_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 = opt2;
- flag_ipa_cp = opt2;
- flag_ipa_sra = opt2;
+ maybe_default_options (opts, opts_set, default_options_table,
+ opts->x_optimize, opts->x_optimize_size,
+ ofast, lang_mask, handlers, loc, dc);
+
+ /* -O2 param settings. */
+ opt2 = (opts->x_optimize >= 2);
/* Track fields in field-sensitive alias analysis. */
maybe_set_param_value
opt2 ? default_param_value (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP) : 1000,
opts->x_param_values, opts_set->x_param_values);
- /* -O3 optimizations. */
- opt3 = (optimize >= 3);
- flag_tree_loop_distribute_patterns = opt3;
- 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;
-
- /* Basic optimization options. */
- optimize_size = 1;
- if (optimize > 2)
- optimize = 2;
-
- /* 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);
- }
+ 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);
- /* -Ofast adds optimizations to -O3. */
- if (ofast)
- {
- /* Which is -ffast-math for now. */
- set_fast_math_flags (1);
- /* Allow targets to enable extra options with -Ofast
- before general options processing so disabling them
- again afterwards works. */
- targetm.handle_ofast ();
- }
-
/* Allow default optimizations to be specified on a per-machine basis. */
- targetm.target_option.optimization (optimize, optimize_size);
+ maybe_default_options (opts, opts_set,
+ targetm.target_option.optimization_table,
+ opts->x_optimize, opts->x_optimize_size,
+ ofast, lang_mask, handlers, loc, dc);
}
static void finish_options (struct gcc_options *, struct gcc_options *);
+/* 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. */
+ 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)
+ unsigned int decoded_options_count,
+ location_t loc, diagnostic_context *dc)
{
struct cl_option_handlers handlers;
lang_mask = initial_lang_mask;
- 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 = 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;
-
- /* Enable -Werror=coverage-mismatch by default */
- enable_warning_as_error ("coverage-mismatch", 1, lang_mask, &handlers,
- global_dc);
+ 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);
+ decoded_options, decoded_options_count,
+ loc, lang_mask, &handlers, dc);
#ifdef ENABLE_LTO
/* Clear any options currently held for LTO. */
#endif
read_cmdline_options (opts, opts_set,
- decoded_options, decoded_options_count, lang_mask,
- &handlers);
+ decoded_options, decoded_options_count,
+ loc, lang_mask,
+ &handlers, dc);
finish_options (opts, opts_set);
}
gcc_assert (opts == &global_options);
gcc_assert (opts_set = &global_options_set);
- if (dump_base_name && ! IS_ABSOLUTE_PATH (dump_base_name))
+ 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 && opts_set->x_flag_section_anchors)
- 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 (warn_missing_noreturn)
- warn_suggest_attribute_noreturn = true;
+ 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 && opts_set->x_flag_section_anchors))
+ && 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 && opts_set->x_flag_section_anchors)
+ 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;
}
{
/* 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. */
ui_except = targetm.except_unwind_info ();
- if (flag_exceptions
- && flag_reorder_blocks_and_partition
+ 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;
+ 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
+ if (opts->x_flag_unwind_tables
&& !targetm.unwind_tables_default
- && flag_reorder_blocks_and_partition
+ && 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;
+ 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
+ || (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;
+ 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;
}
- if (flag_conserve_stack)
+ if (opts->x_flag_conserve_stack)
{
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_wpa || flag_ltrans)
+ if (opts->x_flag_wpa || opts->x_flag_ltrans)
{
/* These passes are not WHOPR compatible yet. */
- flag_ipa_pta = 0;
- flag_ipa_struct_reorg = 0;
+ 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 (flag_lto_partition_balanced || flag_lto_partition_1to1)
+ if ((opts->x_flag_lto_partition_balanced != 0) + (opts->x_flag_lto_partition_1to1 != 0)
+ + (opts->x_flag_lto_partition_none != 0) >= 1)
{
- if (flag_lto_partition_balanced && flag_lto_partition_1to1)
- error ("Only one -flto-partitoin value can be specified");
- if (!flag_whopr)
- error ("-flto-partitoin has effect only with -fwhopr");
+ 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 flag_split_stack to -1 so that targets can set a
+ /* 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 (flag_split_stack == -1)
- flag_split_stack = 0;
- else if (flag_split_stack)
+ 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");
- flag_split_stack = 0;
+ opts->x_flag_split_stack = 0;
}
}
}
struct gcc_options *opts_set,
const struct cl_decoded_option *decoded,
unsigned int lang_mask, int kind ATTRIBUTE_UNUSED,
- const struct cl_option_handlers *handlers)
+ location_t loc,
+ const struct cl_option_handlers *handlers,
+ diagnostic_context *dc)
{
size_t scode = decoded->opt_index;
const char *arg = decoded->arg;
int value = decoded->value;
- static bool verbose = false;
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)
handle_param (opts, opts_set, arg);
break;
- case OPT_v:
- verbose = true;
- break;
-
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
break;
case OPT_Werror_:
- enable_warning_as_error (arg, value, lang_mask, handlers, global_dc);
+ enable_warning_as_error (arg, value, lang_mask, handlers,
+ opts, opts_set, loc, dc);
break;
case OPT_Wlarger_than_:
- larger_than_size = value;
- warn_larger_than = value != -1;
+ opts->x_larger_than_size = value;
+ opts->x_warn_larger_than = value != -1;
break;
case OPT_Wfatal_errors:
- global_dc->fatal_errors = value;
+ 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_Wsystem_headers:
- global_dc->dc_warn_system_headers = value;
- break;
-
- case OPT_Wunused:
- warn_unused = value;
+ dc->dc_warn_system_headers = value;
break;
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_fcall_used_:
fix_register (arg, 0, 1);
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 false;
break;
case OPT_fdiagnostics_show_option:
- global_dc->show_option_requested = value;
+ dc->show_option_requested = value;
break;
case OPT_fdump_:
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_fmessage_length_:
- pp_set_line_maximum_length (global_dc->printer, value);
+ pp_set_line_maximum_length (dc->printer, value);
break;
case OPT_fpack_struct_:
#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_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 (!opts_set->x_flag_branch_probabilities)
- flag_branch_probabilities = value;
+ opts->x_flag_branch_probabilities = value;
if (!opts_set->x_flag_profile_values)
- flag_profile_values = value;
+ opts->x_flag_profile_values = value;
if (!opts_set->x_flag_unroll_loops)
- flag_unroll_loops = value;
+ opts->x_flag_unroll_loops = value;
if (!opts_set->x_flag_peel_loops)
- flag_peel_loops = value;
+ opts->x_flag_peel_loops = value;
if (!opts_set->x_flag_tracer)
- flag_tracer = value;
+ opts->x_flag_tracer = value;
if (!opts_set->x_flag_value_profile_transformations)
- flag_value_profile_transformations = value;
+ opts->x_flag_value_profile_transformations = value;
if (!opts_set->x_flag_inline_functions)
- flag_inline_functions = value;
+ opts->x_flag_inline_functions = value;
if (!opts_set->x_flag_ipa_cp)
- flag_ipa_cp = value;
+ opts->x_flag_ipa_cp = value;
if (!opts_set->x_flag_ipa_cp_clone
- && value && flag_ipa_cp)
- flag_ipa_cp_clone = value;
+ && value && opts->x_flag_ipa_cp)
+ opts->x_flag_ipa_cp_clone = value;
if (!opts_set->x_flag_predictive_commoning)
- flag_predictive_commoning = value;
+ opts->x_flag_predictive_commoning = value;
if (!opts_set->x_flag_unswitch_loops)
- flag_unswitch_loops = value;
+ opts->x_flag_unswitch_loops = value;
if (!opts_set->x_flag_gcse_after_reload)
- flag_gcse_after_reload = value;
+ opts->x_flag_gcse_after_reload = value;
break;
case OPT_fprofile_generate_:
/* No break here - do -fprofile-generate processing. */
case OPT_fprofile_generate:
if (!opts_set->x_profile_arc_flag)
- profile_arc_flag = value;
+ opts->x_profile_arc_flag = value;
if (!opts_set->x_flag_profile_values)
- flag_profile_values = value;
+ opts->x_flag_profile_values = value;
if (!opts_set->x_flag_value_profile_transformations)
- flag_value_profile_transformations = value;
+ opts->x_flag_value_profile_transformations = value;
if (!opts_set->x_flag_inline_functions)
- flag_inline_functions = value;
+ opts->x_flag_inline_functions = value;
break;
case OPT_fshow_column:
- global_dc->show_column = value;
+ 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);
}
#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_:
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_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;
- break;
-
case OPT_pedantic_errors:
- flag_pedantic_errors = pedantic = 1;
- global_dc->pedantic_errors = 1;
+ opts->x_pedantic = 1;
+ dc->pedantic_errors = 1;
break;
- case OPT_fwhopr_:
- flag_whopr = arg;
+ case OPT_flto:
+ opts->x_flag_lto = "";
break;
- case OPT_fwhopr:
- flag_whopr = "";
+ case OPT_w:
+ dc->dc_inhibit_warnings = true;
break;
- case OPT_w:
- global_dc->dc_inhibit_warnings = true;
+ case OPT_fmax_errors_:
+ dc->max_errors = value;
break;
case OPT_fuse_linker_plugin:
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. */
static void
-set_fast_math_flags (int set)
+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. */
static void
-set_unsafe_math_optimizations_flags (int set)
+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. */
return true;
}
-/* Callback function, called when -Werror= enables a warning. */
-
-static void (*warning_as_error_callback) (int) = NULL;
-
-/* Register a callback for enable_warning_as_error calls. */
-
-void
-register_warning_as_error_callback (void (*callback) (int))
-{
- gcc_assert (warning_as_error_callback == NULL || callback == NULL);
- warning_as_error_callback = callback;
-}
-
/* Enable (or disable if VALUE is 0) a warning option ARG (language
- mask LANG_MASK, option handlers HANDLERS) as an error for
- diagnostic context DC (possibly NULL). This is used by
- -Werror=. */
+ 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=. */
-void
+static void
enable_warning_as_error (const char *arg, int value, unsigned int lang_mask,
const struct cl_option_handlers *handlers,
- diagnostic_context *dc)
+ struct gcc_options *opts,
+ struct gcc_options *opts_set,
+ location_t loc, diagnostic_context *dc)
{
char *new_option;
int option_index;
option_index = find_opt (new_option, lang_mask);
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
{
- const struct cl_option *option = &cl_options[option_index];
const diagnostic_t kind = value ? DK_ERROR : DK_WARNING;
- if (option->alias_target != N_OPTS)
- option_index = option->alias_target;
- if (option_index == OPT_SPECIAL_ignore)
- return;
- if (dc)
- diagnostic_classify_diagnostic (dc, option_index, kind,
- UNKNOWN_LOCATION);
- if (kind == DK_ERROR)
- {
- const struct cl_option * const option = cl_options + option_index;
-
- /* -Werror=foo implies -Wfoo. */
- if (option->var_type == CLVC_BOOLEAN)
- handle_generated_option (&global_options, &global_options_set,
- option_index, NULL, value, lang_mask,
- (int)kind, handlers,
- dc);
-
- if (warning_as_error_callback)
- warning_as_error_callback (option_index);
- }
+ control_warning_option (option_index, (int) kind, value,
+ loc, lang_mask,
+ handlers, opts, opts_set, dc);
}
free (new_option);
}
OSDN Git Service
