/* Command line option handling.
- Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
- Free Software Foundation, Inc.
+ Copyright (C) 2002-2014 Free Software Foundation, Inc.
Contributed by Neil Booth.
This file is part of GCC.
#include "system.h"
#include "intl.h"
#include "coretypes.h"
+#include "opts.h"
+#include "options.h"
#include "tm.h" /* For STACK_CHECK_BUILTIN,
STACK_CHECK_STATIC_BUILTIN, DEFAULT_GDB_EXTENSIONS,
DWARF2_DEBUGGING_INFO and DBX_DEBUGGING_INFO. */
-#include "opts.h"
-#include "options.h"
#include "flags.h"
#include "params.h"
#include "diagnostic.h"
+#include "diagnostic-color.h"
#include "opts-diagnostic.h"
#include "insn-attr-common.h"
#include "common/common-target.h"
+static void set_Wstrict_aliasing (struct gcc_options *opts, int onoff);
+
/* Indexed by enum debug_info_type. */
const char *const debug_type_names[] =
{
}
}
-/* Handle -ftree-vectorizer-verbose=VAL for options OPTS. */
-
-static void
-vect_set_verbosity_level (struct gcc_options *opts, int val)
-{
- if (val < MAX_VERBOSITY_LEVEL)
- opts->x_user_vect_verbosity_level = (enum vect_verbosity_levels) val;
- else
- opts->x_user_vect_verbosity_level
- = (enum vect_verbosity_levels) (MAX_VERBOSITY_LEVEL - 1);
-}
-
-
/* Strip off a legitimate source ending from the input string NAME of
length LEN. Rather than having to know the names used by all of
our front ends, we strip off an ending of a period followed by
char c = *p;
while (c)
{
- if (IS_DIR_SEPARATOR(c))
+ if (IS_DIR_SEPARATOR (c))
{
base = p + 1;
dot = 0;
static const char undocumented_msg[] = N_("This switch lacks documentation");
typedef char *char_p; /* For DEF_VEC_P. */
-DEF_VEC_P(char_p);
-DEF_VEC_ALLOC_P(char_p,heap);
static void handle_param (struct gcc_options *opts,
struct gcc_options *opts_set, location_t loc,
char *r;
char *w;
char *token_start;
- VEC(char_p,heap) *vec = (VEC(char_p,heap) *) *pvec;
+ vec<char_p> *v = (vec<char_p> *) *pvec;
+
+ vec_check_alloc (v, 1);
/* We never free this string. */
tmp = xstrdup (arg);
{
*w++ = '\0';
++r;
- VEC_safe_push (char_p, heap, vec, token_start);
+ v->safe_push (token_start);
token_start = w;
}
if (*r == '\\' && r[1] == ',')
*w++ = *r++;
}
if (*token_start != '\0')
- VEC_safe_push (char_p, heap, vec, token_start);
+ v->safe_push (token_start);
- *pvec = vec;
+ *pvec = v;
}
/* Initialize OPTS and OPTS_SET before using them in parsing options. */
{
size_t num_params = get_num_compiler_params ();
+ gcc_obstack_init (&opts_obstack);
+
*opts = global_options_init;
- memset (opts_set, 0, sizeof (*opts_set));
+
+ if (opts_set)
+ memset (opts_set, 0, sizeof (*opts_set));
opts->x_param_values = XNEWVEC (int, num_params);
- opts_set->x_param_values = XCNEWVEC (int, num_params);
+
+ if (opts_set)
+ opts_set->x_param_values = XCNEWVEC (int, num_params);
+
init_param_values (opts->x_param_values);
/* Initialize whether `char' is signed. */
}
/* 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. */
+ -Ofast if FAST is set, -Og if DEBUG 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,
+ int level, bool size, bool fast, bool debug,
unsigned int lang_mask,
const struct cl_option_handlers *handlers,
location_t loc,
gcc_assert (level == 2);
if (fast)
gcc_assert (level == 3);
+ if (debug)
+ gcc_assert (level == 1);
switch (default_opt->levels)
{
break;
case OPT_LEVELS_1_PLUS_SPEED_ONLY:
- enabled = (level >= 1 && !size);
+ enabled = (level >= 1 && !size && !debug);
+ break;
+
+ case OPT_LEVELS_1_PLUS_NOT_DEBUG:
+ enabled = (level >= 1 && !debug);
break;
case OPT_LEVELS_2_PLUS:
break;
case OPT_LEVELS_2_PLUS_SPEED_ONLY:
- enabled = (level >= 2 && !size);
+ enabled = (level >= 2 && !size && !debug);
break;
case OPT_LEVELS_3_PLUS:
maybe_default_options (struct gcc_options *opts,
struct gcc_options *opts_set,
const struct default_options *default_opts,
- int level, bool size, bool fast,
+ int level, bool size, bool fast, bool debug,
unsigned int lang_mask,
const struct cl_option_handlers *handlers,
location_t loc,
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);
+ level, size, fast, debug,
+ lang_mask, handlers, loc, dc);
}
/* Table of options enabled by default at different levels. */
{ 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_NOT_DEBUG, OPT_fif_conversion, NULL, 1 },
+ { OPT_LEVELS_1_PLUS_NOT_DEBUG, 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_fshrink_wrap, 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_NOT_DEBUG, 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_NOT_DEBUG, 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_ch, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_fcombine_stack_adjustments, NULL, 1 },
{ OPT_LEVELS_1_PLUS, OPT_fcompare_elim, NULL, 1 },
+ { OPT_LEVELS_1_PLUS, OPT_ftree_slsr, NULL, 1 },
+ { OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_fbranch_count_reg, NULL, 1 },
+ { OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_fmove_loop_invariants, NULL, 1 },
+ { OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_ftree_pta, NULL, 1 },
+ { OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_fssa_phiopt, NULL, 1 },
/* -O2 optimizations. */
{ OPT_LEVELS_2_PLUS, OPT_finline_small_functions, NULL, 1 },
{ 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_ftree_switch_conversion, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_fipa_cp, NULL, 1 },
{ OPT_LEVELS_2_PLUS, OPT_fdevirtualize, NULL, 1 },
+ { OPT_LEVELS_2_PLUS, OPT_fdevirtualize_speculatively, 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 },
+ { OPT_LEVELS_2_PLUS, OPT_ftree_tail_merge, NULL, 1 },
+ { OPT_LEVELS_2_PLUS, OPT_fvect_cost_model_, NULL, VECT_COST_MODEL_CHEAP },
+ { OPT_LEVELS_2_PLUS_SPEED_ONLY, OPT_foptimize_strlen, NULL, 1 },
+ { OPT_LEVELS_2_PLUS, OPT_fhoist_adjacent_loads, NULL, 1 },
+ { OPT_LEVELS_2_PLUS, OPT_fipa_icf, NULL, 1 },
+ { OPT_LEVELS_2_PLUS, OPT_fisolate_erroneous_paths_dereference, NULL, 1 },
+ { OPT_LEVELS_2_PLUS, OPT_fuse_caller_save, NULL, 1 },
+ { OPT_LEVELS_2_PLUS, OPT_flra_remat, NULL, 1 },
/* -O3 optimizations. */
{ OPT_LEVELS_3_PLUS, OPT_ftree_loop_distribute_patterns, 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_1_PLUS, OPT_finline_functions_called_once, NULL, 1 },
+ { OPT_LEVELS_1_PLUS_NOT_DEBUG, OPT_finline_functions_called_once, 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_ftree_loop_vectorize, NULL, 1 },
+ { OPT_LEVELS_3_PLUS, OPT_ftree_slp_vectorize, NULL, 1 },
+ { OPT_LEVELS_3_PLUS, OPT_fvect_cost_model_, NULL, VECT_COST_MODEL_DYNAMIC },
{ OPT_LEVELS_3_PLUS, OPT_fipa_cp_clone, NULL, 1 },
+ { OPT_LEVELS_3_PLUS, OPT_ftree_partial_pre, NULL, 1 },
/* -Ofast adds optimizations to -O3. */
{ OPT_LEVELS_FAST, OPT_ffast_math, NULL, 1 },
opts->x_optimize = 1;
opts->x_optimize_size = 0;
opts->x_optimize_fast = 0;
+ opts->x_optimize_debug = 0;
}
else
{
const int optimize_val = integral_argument (opt->arg);
if (optimize_val == -1)
- error_at (loc,
- "argument to %qs should be a non-negative integer",
- "-O");
+ error_at (loc, "argument to %<-O%> should be a non-negative "
+ "integer, %<g%>, %<s%> or %<fast%>");
else
{
opts->x_optimize = optimize_val;
opts->x_optimize = 255;
opts->x_optimize_size = 0;
opts->x_optimize_fast = 0;
+ opts->x_optimize_debug = 0;
}
}
break;
/* Optimizing for size forces optimize to be 2. */
opts->x_optimize = 2;
opts->x_optimize_fast = 0;
+ opts->x_optimize_debug = 0;
break;
case OPT_Ofast:
opts->x_optimize_size = 0;
opts->x_optimize = 3;
opts->x_optimize_fast = 1;
+ opts->x_optimize_debug = 0;
+ break;
+
+ case OPT_Og:
+ /* -Og selects optimization level 1. */
+ opts->x_optimize_size = 0;
+ opts->x_optimize = 1;
+ opts->x_optimize_fast = 0;
+ opts->x_optimize_debug = 1;
break;
default:
maybe_default_options (opts, opts_set, default_options_table,
opts->x_optimize, opts->x_optimize_size,
- opts->x_optimize_fast, lang_mask, handlers, loc, dc);
+ opts->x_optimize_fast, opts->x_optimize_debug,
+ lang_mask, handlers, loc, dc);
/* -O2 param settings. */
opt2 = (opts->x_optimize >= 2);
opt2 ? default_param_value (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP) : 1000,
opts->x_param_values, opts_set->x_param_values);
+ /* At -Ofast, allow store motion to introduce potential race conditions. */
+ maybe_set_param_value
+ (PARAM_ALLOW_STORE_DATA_RACES,
+ opts->x_optimize_fast ? 1
+ : default_param_value (PARAM_ALLOW_STORE_DATA_RACES),
+ 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,
default_param_value (PARAM_MIN_CROSSJUMP_INSNS),
opts->x_param_values, opts_set->x_param_values);
+ /* Restrict the amount of work combine does at -Og while retaining
+ most of its useful transforms. */
+ if (opts->x_optimize_debug)
+ maybe_set_param_value (PARAM_MAX_COMBINE_INSNS, 2,
+ opts->x_param_values, opts_set->x_param_values);
+
/* Allow default optimizations to be specified on a per-machine basis. */
maybe_default_options (opts, opts_set,
targetm_common.option_optimization_table,
opts->x_optimize, opts->x_optimize_size,
- opts->x_optimize_fast, lang_mask, handlers, loc, dc);
+ opts->x_optimize_fast, opts->x_optimize_debug,
+ lang_mask, handlers, loc, dc);
}
/* After all options at LOC have been read into OPTS and OPTS_SET,
{
enum unwind_info_type ui_except;
- if (opts->x_dump_base_name && ! IS_ABSOLUTE_PATH (opts->x_dump_base_name))
+ if (opts->x_dump_base_name
+ && ! IS_ABSOLUTE_PATH (opts->x_dump_base_name)
+ && ! opts->x_dump_base_name_prefixed)
{
/* First try to make OPTS->X_DUMP_BASE_NAME relative to the
OPTS->X_DUMP_DIR_NAME directory. Then try to make
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);
+ opts->x_dump_base_name = opts_concat (opts->x_dump_dir_name,
+ opts->x_dump_base_name, NULL);
else if (opts->x_aux_base_name
&& strcmp (opts->x_aux_base_name, HOST_BIT_BUCKET) != 0)
{
if (opts->x_aux_base_name != aux_base)
{
int dir_len = aux_base - opts->x_aux_base_name;
- char *new_dump_base_name =
- XNEWVEC (char, strlen (opts->x_dump_base_name) + dir_len + 1);
+ char *new_dump_base_name
+ = XOBNEWVEC (&opts_obstack, char,
+ strlen (opts->x_dump_base_name) + dir_len + 1);
/* Copy directory component from OPTS->X_AUX_BASE_NAME. */
memcpy (new_dump_base_name, opts->x_aux_base_name, dir_len);
opts->x_dump_base_name = new_dump_base_name;
}
}
+ opts->x_dump_base_name_prefixed = true;
}
/* Handle related options for unit-at-a-time, toplevel-reorder, and
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;
-
+ if (opts->x_flag_tm && opts->x_flag_non_call_exceptions)
+ sorry ("transactional memory is not supported with non-call exceptions");
+
/* 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 (opts->x_flag_exceptions
&& opts->x_flag_reorder_blocks_and_partition
- && (ui_except == UI_SJLJ || ui_except == UI_TARGET))
+ && (ui_except == UI_SJLJ || ui_except >= UI_TARGET))
{
- inform (loc,
- "-freorder-blocks-and-partition does not work "
- "with exceptions on this architecture");
+ if (opts_set->x_flag_reorder_blocks_and_partition)
+ inform (loc,
+ "-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 (opts->x_flag_unwind_tables
&& !targetm_common.unwind_tables_default
&& opts->x_flag_reorder_blocks_and_partition
- && (ui_except == UI_SJLJ || ui_except == UI_TARGET))
+ && (ui_except == UI_SJLJ || ui_except >= UI_TARGET))
{
- inform (loc,
- "-freorder-blocks-and-partition does not support "
- "unwind info on this architecture");
+ if (opts_set->x_flag_reorder_blocks_and_partition)
+ inform (loc,
+ "-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;
}
&& (!targetm_common.have_named_sections
|| (opts->x_flag_unwind_tables
&& targetm_common.unwind_tables_default
- && (ui_except == UI_SJLJ || ui_except == UI_TARGET))))
+ && (ui_except == UI_SJLJ || ui_except >= UI_TARGET))))
{
- inform (loc,
- "-freorder-blocks-and-partition does not work "
- "on this architecture");
+ if (opts_set->x_flag_reorder_blocks_and_partition)
+ inform (loc,
+ "-freorder-blocks-and-partition does not work "
+ "on this architecture");
opts->x_flag_reorder_blocks_and_partition = 0;
opts->x_flag_reorder_blocks = 1;
}
#else
error_at (loc, "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_at (loc, "only one -flto-partition value can be specified");
+ if (!opts->x_flag_fat_lto_objects
+ && (!HAVE_LTO_PLUGIN
+ || (opts_set->x_flag_use_linker_plugin
+ && !opts->x_flag_use_linker_plugin)))
+ {
+ if (opts_set->x_flag_fat_lto_objects)
+ error_at (loc, "-fno-fat-lto-objects are supported only with linker plugin");
+ opts->x_flag_fat_lto_objects = 1;
+ }
}
/* We initialize opts->x_flag_split_stack to -1 so that targets can set a
}
}
+ /* Tune vectorization related parametees according to cost model. */
+ if (opts->x_flag_vect_cost_model == VECT_COST_MODEL_CHEAP)
+ {
+ maybe_set_param_value (PARAM_VECT_MAX_VERSION_FOR_ALIAS_CHECKS,
+ 6, opts->x_param_values, opts_set->x_param_values);
+ maybe_set_param_value (PARAM_VECT_MAX_VERSION_FOR_ALIGNMENT_CHECKS,
+ 0, opts->x_param_values, opts_set->x_param_values);
+ maybe_set_param_value (PARAM_VECT_MAX_PEELING_FOR_ALIGNMENT,
+ 0, opts->x_param_values, opts_set->x_param_values);
+ }
+
/* Set PARAM_MAX_STORES_TO_SINK to 0 if either vectorization or if-conversion
is disabled. */
- if (!opts->x_flag_tree_vectorize || !opts->x_flag_tree_loop_if_convert)
+ if ((!opts->x_flag_tree_loop_vectorize && !opts->x_flag_tree_slp_vectorize)
+ || !opts->x_flag_tree_loop_if_convert)
maybe_set_param_value (PARAM_MAX_STORES_TO_SINK, 0,
opts->x_param_values, opts_set->x_param_values);
- /* This replaces set_Wunused. */
- if (opts->x_warn_unused_function == -1)
- opts->x_warn_unused_function = opts->x_warn_unused;
- if (opts->x_warn_unused_label == -1)
- opts->x_warn_unused_label = opts->x_warn_unused;
- /* Wunused-parameter is enabled if both -Wunused -Wextra are enabled. */
- if (opts->x_warn_unused_parameter == -1)
- opts->x_warn_unused_parameter = (opts->x_warn_unused
- && opts->x_extra_warnings);
- if (opts->x_warn_unused_variable == -1)
- opts->x_warn_unused_variable = opts->x_warn_unused;
- /* Wunused-but-set-parameter is enabled if both -Wunused -Wextra are
- enabled. */
- if (opts->x_warn_unused_but_set_parameter == -1)
- opts->x_warn_unused_but_set_parameter = (opts->x_warn_unused
- && opts->x_extra_warnings);
- if (opts->x_warn_unused_but_set_variable == -1)
- opts->x_warn_unused_but_set_variable = opts->x_warn_unused;
- if (opts->x_warn_unused_value == -1)
- opts->x_warn_unused_value = opts->x_warn_unused;
-
- /* This replaces set_Wextra. */
- if (opts->x_warn_uninitialized == -1)
- opts->x_warn_uninitialized = opts->x_extra_warnings;
+ /* The -gsplit-dwarf option requires -ggnu-pubnames. */
+ if (opts->x_dwarf_split_debug_info)
+ opts->x_debug_generate_pub_sections = 2;
+
+ /* Userspace and kernel ASan conflict with each other. */
+
+ if ((opts->x_flag_sanitize & SANITIZE_USER_ADDRESS)
+ && (opts->x_flag_sanitize & SANITIZE_KERNEL_ADDRESS))
+ error_at (loc,
+ "-fsanitize=address is incompatible with "
+ "-fsanitize=kernel-address");
+
+ /* And with TSan. */
+
+ if ((opts->x_flag_sanitize & SANITIZE_ADDRESS)
+ && (opts->x_flag_sanitize & SANITIZE_THREAD))
+ error_at (loc,
+ "-fsanitize=address and -fsanitize=kernel-address "
+ "are incompatible with -fsanitize=thread");
+
+ /* Error recovery is not allowed for ASan and TSan. */
+
+ if (opts->x_flag_sanitize_recover & SANITIZE_USER_ADDRESS)
+ error_at (loc, "-fsanitize-recover=address is not supported");
+
+ if (opts->x_flag_sanitize_recover & SANITIZE_THREAD)
+ error_at (loc, "-fsanitize-recover=thread is not supported");
+
+ if (opts->x_flag_sanitize_recover & SANITIZE_LEAK)
+ error_at (loc, "-fsanitize-recover=leak is not supported");
+
+ /* When instrumenting the pointers, we don't want to remove
+ the null pointer checks. */
+ if (opts->x_flag_sanitize & (SANITIZE_NULL | SANITIZE_NONNULL_ATTRIBUTE
+ | SANITIZE_RETURNS_NONNULL_ATTRIBUTE))
+ opts->x_flag_delete_null_pointer_checks = 0;
+
+ /* Aggressive compiler optimizations may cause false negatives. */
+ if (opts->x_flag_sanitize)
+ {
+ opts->x_flag_aggressive_loop_optimizations = 0;
+ opts->x_flag_strict_overflow = 0;
+ }
}
#define LEFT_COLUMN 27
}
}
- printf( " %-*.*s %.*s\n", col_width, item_width, item, len, help);
+ printf (" %-*.*s %.*s\n", col_width, item_width, item, len, help);
item_width = 0;
while (help[len] == ' ')
len++;
const char *help;
bool found = false;
bool displayed = false;
+ char new_help[128];
if (include_flags == CL_PARAMS)
{
/* Get the translation. */
help = _(help);
+ if (!opts->x_quiet_flag)
+ {
+ snprintf (new_help, sizeof (new_help),
+ _("default %d minimum %d maximum %d"),
+ compiler_params[i].default_value,
+ compiler_params[i].min_value,
+ compiler_params[i].max_value);
+ help = new_help;
+ }
wrap_help (help, param, strlen (param), columns);
}
putchar ('\n');
for (i = 0; i < cl_options_count; i++)
{
- char new_help[128];
const struct cl_option *option = cl_options + i;
unsigned int len;
const char *opt;
opts->x_help_columns, opts, lang_mask);
}
+/* Enable FDO-related flags. */
+
+static void
+enable_fdo_optimizations (struct gcc_options *opts,
+ struct gcc_options *opts_set,
+ int 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;
+ if (!opts_set->x_flag_tree_loop_vectorize
+ && !opts_set->x_flag_tree_vectorize)
+ opts->x_flag_tree_loop_vectorize = value;
+ if (!opts_set->x_flag_tree_slp_vectorize
+ && !opts_set->x_flag_tree_vectorize)
+ opts->x_flag_tree_slp_vectorize = value;
+ if (!opts_set->x_flag_vect_cost_model)
+ opts->x_flag_vect_cost_model = VECT_COST_MODEL_DYNAMIC;
+ if (!opts_set->x_flag_tree_loop_distribute_patterns)
+ opts->x_flag_tree_loop_distribute_patterns = value;
+}
+
/* 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
opts->x_exit_after_options = true;
break;
+ case OPT_fsanitize_:
+ case OPT_fsanitize_recover_:
+ {
+ const char *p = arg;
+ unsigned int *flag
+ = code == OPT_fsanitize_ ? &opts->x_flag_sanitize
+ : &opts->x_flag_sanitize_recover;
+ while (*p != 0)
+ {
+ static const struct
+ {
+ const char *const name;
+ unsigned int flag;
+ size_t len;
+ } spec[] =
+ {
+ { "address", SANITIZE_ADDRESS | SANITIZE_USER_ADDRESS,
+ sizeof "address" - 1 },
+ { "kernel-address", SANITIZE_ADDRESS | SANITIZE_KERNEL_ADDRESS,
+ sizeof "kernel-address" - 1 },
+ { "thread", SANITIZE_THREAD, sizeof "thread" - 1 },
+ { "leak", SANITIZE_LEAK, sizeof "leak" - 1 },
+ { "shift", SANITIZE_SHIFT, sizeof "shift" - 1 },
+ { "integer-divide-by-zero", SANITIZE_DIVIDE,
+ sizeof "integer-divide-by-zero" - 1 },
+ { "undefined", SANITIZE_UNDEFINED, sizeof "undefined" - 1 },
+ { "unreachable", SANITIZE_UNREACHABLE,
+ sizeof "unreachable" - 1 },
+ { "vla-bound", SANITIZE_VLA, sizeof "vla-bound" - 1 },
+ { "return", SANITIZE_RETURN, sizeof "return" - 1 },
+ { "null", SANITIZE_NULL, sizeof "null" - 1 },
+ { "signed-integer-overflow", SANITIZE_SI_OVERFLOW,
+ sizeof "signed-integer-overflow" -1 },
+ { "bool", SANITIZE_BOOL, sizeof "bool" - 1 },
+ { "enum", SANITIZE_ENUM, sizeof "enum" - 1 },
+ { "float-divide-by-zero", SANITIZE_FLOAT_DIVIDE,
+ sizeof "float-divide-by-zero" - 1 },
+ { "float-cast-overflow", SANITIZE_FLOAT_CAST,
+ sizeof "float-cast-overflow" - 1 },
+ { "bounds", SANITIZE_BOUNDS, sizeof "bounds" - 1 },
+ { "alignment", SANITIZE_ALIGNMENT, sizeof "alignment" - 1 },
+ { "nonnull-attribute", SANITIZE_NONNULL_ATTRIBUTE,
+ sizeof "nonnull-attribute" - 1 },
+ { "returns-nonnull-attribute",
+ SANITIZE_RETURNS_NONNULL_ATTRIBUTE,
+ sizeof "returns-nonnull-attribute" - 1 },
+ { "object-size", SANITIZE_OBJECT_SIZE,
+ sizeof "object-size" - 1 },
+ { NULL, 0, 0 }
+ };
+ const char *comma;
+ size_t len, i;
+ bool found = false;
+
+ comma = strchr (p, ',');
+ if (comma == NULL)
+ len = strlen (p);
+ else
+ len = comma - p;
+ if (len == 0)
+ {
+ p = comma + 1;
+ continue;
+ }
+
+ /* Check to see if the string matches an option class name. */
+ for (i = 0; spec[i].name != NULL; ++i)
+ if (len == spec[i].len
+ && memcmp (p, spec[i].name, len) == 0)
+ {
+ /* Handle both -fsanitize and -fno-sanitize cases. */
+ if (value)
+ *flag |= spec[i].flag;
+ else
+ *flag &= ~spec[i].flag;
+ found = true;
+ break;
+ }
+
+ if (! found)
+ error_at (loc,
+ "unrecognized argument to -fsanitize%s= option: %q.*s",
+ code == OPT_fsanitize_ ? "" : "-recover", (int) len, p);
+
+ if (comma == NULL)
+ break;
+ p = comma + 1;
+ }
+
+ if (code != OPT_fsanitize_)
+ break;
+
+ /* Kernel ASan implies normal ASan but does not yet support
+ all features. */
+ if (opts->x_flag_sanitize & SANITIZE_KERNEL_ADDRESS)
+ {
+ maybe_set_param_value (PARAM_ASAN_INSTRUMENTATION_WITH_CALL_THRESHOLD, 0,
+ opts->x_param_values,
+ opts_set->x_param_values);
+ maybe_set_param_value (PARAM_ASAN_GLOBALS, 0,
+ opts->x_param_values,
+ opts_set->x_param_values);
+ maybe_set_param_value (PARAM_ASAN_STACK, 0,
+ opts->x_param_values,
+ opts_set->x_param_values);
+ maybe_set_param_value (PARAM_ASAN_USE_AFTER_RETURN, 0,
+ opts->x_param_values,
+ opts_set->x_param_values);
+ }
+
+ break;
+ }
+
+ case OPT_fasan_shadow_offset_:
+ /* Deferred. */
+ break;
+
+ case OPT_fsanitize_recover:
+ if (value)
+ opts->x_flag_sanitize_recover
+ |= SANITIZE_UNDEFINED | SANITIZE_NONDEFAULT;
+ else
+ opts->x_flag_sanitize_recover
+ &= ~(SANITIZE_UNDEFINED | SANITIZE_NONDEFAULT);
+ break;
+
case OPT_O:
case OPT_Os:
case OPT_Ofast:
+ case OPT_Og:
/* Currently handled in a prescan. */
break;
+ case OPT_Werror:
+ dc->warning_as_error_requested = value;
+ break;
+
case OPT_Werror_:
if (lang_mask == CL_DRIVER)
break;
strip_off_ending (tmp, strlen (tmp));
if (tmp[0])
opts->x_aux_base_name = tmp;
+ else
+ free (tmp);
}
break;
case OPT_fdiagnostics_show_location_:
diagnostic_prefixing_rule (dc) = (diagnostic_prefixing_rule_t) value;
break;
+
+ case OPT_fdiagnostics_show_caret:
+ dc->show_caret = value;
+ break;
+
+ case OPT_fdiagnostics_color_:
+ pp_show_color (dc->printer)
+ = colorize_init ((diagnostic_color_rule_t) value);
+ break;
case OPT_fdiagnostics_show_option:
dc->show_option_requested = value;
case OPT_fmessage_length_:
pp_set_line_maximum_length (dc->printer, value);
+ diagnostic_set_caret_max_width (dc, value);
+ break;
+
+ case OPT_fopt_info:
+ case OPT_fopt_info_:
+ /* Deferred. */
+ break;
+
+ case OPT_foffload_:
+ /* Deferred. */
break;
+#ifndef ACCEL_COMPILER
+ case OPT_foffload_abi_:
+ error_at (loc, "-foffload-abi option can be specified only for "
+ "offload compiler");
+ break;
+#endif
+
case OPT_fpack_struct_:
if (value <= 0 || (value & (value - 1)) || value > 16)
error_at (loc,
value = true;
/* No break here - do -fprofile-use processing. */
case OPT_fprofile_use:
- 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;
+ enable_fdo_optimizations (opts, opts_set, value);
+ if (!opts_set->x_flag_profile_reorder_functions)
+ opts->x_flag_profile_reorder_functions = value;
+ /* Indirect call profiling should do all useful transformations
+ speculative devirtualization does. */
+ if (!opts_set->x_flag_devirtualize_speculatively
+ && opts->x_flag_value_profile_transformations)
+ opts->x_flag_devirtualize_speculatively = false;
+ break;
+
+ case OPT_fauto_profile_:
+ opts->x_auto_profile_file = xstrdup (arg);
+ opts->x_flag_auto_profile = true;
+ value = true;
+ /* No break here - do -fauto-profile processing. */
+ case OPT_fauto_profile:
+ enable_fdo_optimizations (opts, opts_set, value);
+ if (!opts_set->x_flag_profile_correction)
+ opts->x_flag_profile_correction = value;
+ maybe_set_param_value (
+ PARAM_EARLY_INLINER_MAX_ITERATIONS, 10,
+ opts->x_param_values, opts_set->x_param_values);
break;
case OPT_fprofile_generate_:
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;
/* FIXME: Instrumentation we insert makes ipa-reference bitmaps
quadratic. Disable the pass until better memory representation
is done. */
- if (!opts_set->x_flag_ipa_reference && opts->x_in_lto_p)
+ if (!opts_set->x_flag_ipa_reference)
opts->x_flag_ipa_reference = false;
break;
+ case OPT_ftree_vectorize:
+ if (!opts_set->x_flag_tree_loop_vectorize)
+ opts->x_flag_tree_loop_vectorize = value;
+ if (!opts_set->x_flag_tree_slp_vectorize)
+ opts->x_flag_tree_slp_vectorize = value;
+ break;
case OPT_fshow_column:
dc->show_column = value;
break;
? STATIC_BUILTIN_STACK_CHECK
: GENERIC_STACK_CHECK;
else
- warning_at (loc, 0, "unknown stack check parameter \"%s\"", arg);
+ warning_at (loc, 0, "unknown stack check parameter %qs", arg);
break;
case OPT_fstack_limit:
opts->x_flag_stack_usage_info = value != 0;
break;
- case OPT_ftree_vectorizer_verbose_:
- vect_set_verbosity_level (opts, value);
- break;
-
case OPT_g:
set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg, opts, opts_set,
- loc);
+ loc);
break;
case OPT_gcoff:
set_debug_level (SDB_DEBUG, false, arg, opts, opts_set, loc);
break;
+ case OPT_gdwarf:
+ if (arg && strlen (arg) != 0)
+ {
+ error_at (loc, "%<-gdwarf%s%> is ambiguous; "
+ "use %<-gdwarf-%s%> for DWARF version "
+ "or %<-gdwarf -g%s%> for debug level", arg, arg, arg);
+ break;
+ }
+ else
+ value = opts->x_dwarf_version;
+
+ /* FALLTHRU */
case OPT_gdwarf_:
if (value < 2 || value > 4)
error_at (loc, "dwarf version %d is not supported", value);
set_debug_level (DWARF2_DEBUG, false, "", opts, opts_set, loc);
break;
+ case OPT_gsplit_dwarf:
+ set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, "", opts, opts_set,
+ loc);
+ break;
+
case OPT_ggdb:
set_debug_level (NO_DEBUG, 2, arg, opts, opts_set, loc);
break;
loc);
break;
+ case OPT_gz:
+ case OPT_gz_:
+ /* Handled completely via specs. */
+ break;
+
case OPT_pedantic_errors:
- opts->x_pedantic = 1;
dc->pedantic_errors = 1;
+ control_warning_option (OPT_Wpedantic, DK_ERROR, value,
+ loc, lang_mask,
+ handlers, opts, opts_set,
+ dc);
break;
case OPT_flto:
dc->max_errors = value;
break;
+ case OPT_fuse_ld_bfd:
+ case OPT_fuse_ld_gold:
case OPT_fuse_linker_plugin:
/* No-op. Used by the driver and passed to us because it starts with f.*/
break;
- case OPT_Wuninitialized:
- /* Also turn on maybe uninitialized warning. */
- opts->x_warn_maybe_uninitialized = value;
+ case OPT_fwrapv:
+ if (value)
+ opts->x_flag_trapv = 0;
+ break;
+
+ case OPT_ftrapv:
+ if (value)
+ opts->x_flag_wrapv = 0;
+ break;
+
+ case OPT_fipa_icf:
+ opts->x_flag_ipa_icf_functions = value;
+ opts->x_flag_ipa_icf_variables = value;
break;
default:
break;
}
+ common_handle_option_auto (opts, opts_set, decoded, lang_mask, kind,
+ loc, handlers, dc);
return true;
}
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
+static void
set_Wstrict_aliasing (struct gcc_options *opts, int onoff)
{
gcc_assert (onoff == 0 || onoff == 1);
if (opts_set->x_write_symbols != NO_DEBUG
&& opts->x_write_symbols != NO_DEBUG
&& type != opts->x_write_symbols)
- error_at (loc, "debug format \"%s\" conflicts with prior selection",
+ error_at (loc, "debug format %qs conflicts with prior selection",
debug_type_names[type]);
opts->x_write_symbols = type;
opts_set->x_write_symbols = type;
}
- /* A debug flag without a level defaults to level 2. */
+ /* A debug flag without a level defaults to level 2.
+ If off or at level 1, set it to level 2, but if already
+ at level 3, don't lower it. */
if (*arg == '\0')
{
- if (!opts->x_debug_info_level)
+ if (opts->x_debug_info_level < DINFO_LEVEL_NORMAL)
opts->x_debug_info_level = DINFO_LEVEL_NORMAL;
}
else
{
int argval = integral_argument (arg);
if (argval == -1)
- error_at (loc, "unrecognised debug output level \"%s\"", arg);
+ error_at (loc, "unrecognised debug output level %qs", arg);
else if (argval > 3)
- error_at (loc, "debug output level %s is too high", arg);
+ error_at (loc, "debug output level %qs is too high", arg);
else
opts->x_debug_info_level = (enum debug_info_levels) argval;
}
opts->x_flag_dump_rtl_in_asm = 1;
opts->x_flag_print_asm_name = 1;
break;
- case 'v':
- opts->x_graph_dump_format = vcg;
- break;
case 'x':
opts->x_rtl_dump_and_exit = 1;
break;
control_warning_option (option_index, (int) kind, value,
loc, lang_mask,
handlers, opts, opts_set, dc);
- if (option_index == OPT_Wuninitialized)
- enable_warning_as_error ("maybe-uninitialized", value, lang_mask,
- handlers, opts, opts_set, loc, dc);
}
free (new_option);
}
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 if ((orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN
+ || diag_kind == DK_WARNING)
+ && context->warning_as_error_requested)
+ return xstrdup (cl_options[OPT_Werror].opt_text);
else
return NULL;
}