/* Command line option handling.
|
/* Command line option handling.
|
Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
|
Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
|
Free Software Foundation, Inc.
|
Free Software Foundation, Inc.
|
Contributed by Neil Booth.
|
Contributed by Neil Booth.
|
|
|
This file is part of GCC.
|
This file is part of GCC.
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
GCC is free software; you can redistribute it and/or modify it under
|
the terms of the GNU General Public License as published by the Free
|
the terms of the GNU General Public License as published by the Free
|
Software Foundation; either version 3, or (at your option) any later
|
Software Foundation; either version 3, or (at your option) any later
|
version.
|
version.
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
for more details.
|
for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with GCC; see the file COPYING3. If not see
|
along with GCC; see the file COPYING3. If not see
|
<http://www.gnu.org/licenses/>. */
|
<http://www.gnu.org/licenses/>. */
|
|
|
#include "config.h"
|
#include "config.h"
|
#include "system.h"
|
#include "system.h"
|
#include "intl.h"
|
#include "intl.h"
|
#include "coretypes.h"
|
#include "coretypes.h"
|
#include "tm.h" /* For STACK_CHECK_BUILTIN,
|
#include "tm.h" /* For STACK_CHECK_BUILTIN,
|
STACK_CHECK_STATIC_BUILTIN, DEFAULT_GDB_EXTENSIONS,
|
STACK_CHECK_STATIC_BUILTIN, DEFAULT_GDB_EXTENSIONS,
|
DWARF2_DEBUGGING_INFO and DBX_DEBUGGING_INFO. */
|
DWARF2_DEBUGGING_INFO and DBX_DEBUGGING_INFO. */
|
#include "opts.h"
|
#include "opts.h"
|
#include "options.h"
|
#include "options.h"
|
#include "flags.h"
|
#include "flags.h"
|
#include "params.h"
|
#include "params.h"
|
#include "diagnostic.h"
|
#include "diagnostic.h"
|
#include "opts-diagnostic.h"
|
#include "opts-diagnostic.h"
|
#include "insn-attr-common.h"
|
#include "insn-attr-common.h"
|
#include "common/common-target.h"
|
#include "common/common-target.h"
|
|
|
/* Indexed by enum debug_info_type. */
|
/* Indexed by enum debug_info_type. */
|
const char *const debug_type_names[] =
|
const char *const debug_type_names[] =
|
{
|
{
|
"none", "stabs", "coff", "dwarf-2", "xcoff", "vms"
|
"none", "stabs", "coff", "dwarf-2", "xcoff", "vms"
|
};
|
};
|
|
|
/* Parse the -femit-struct-debug-detailed option value
|
/* Parse the -femit-struct-debug-detailed option value
|
and set the flag variables. */
|
and set the flag variables. */
|
|
|
#define MATCH( prefix, string ) \
|
#define MATCH( prefix, string ) \
|
((strncmp (prefix, string, sizeof prefix - 1) == 0) \
|
((strncmp (prefix, string, sizeof prefix - 1) == 0) \
|
? ((string += sizeof prefix - 1), 1) : 0)
|
? ((string += sizeof prefix - 1), 1) : 0)
|
|
|
void
|
void
|
set_struct_debug_option (struct gcc_options *opts, location_t loc,
|
set_struct_debug_option (struct gcc_options *opts, location_t loc,
|
const char *spec)
|
const char *spec)
|
{
|
{
|
/* various labels for comparison */
|
/* various labels for comparison */
|
static const char dfn_lbl[] = "dfn:", dir_lbl[] = "dir:", ind_lbl[] = "ind:";
|
static const char dfn_lbl[] = "dfn:", dir_lbl[] = "dir:", ind_lbl[] = "ind:";
|
static const char ord_lbl[] = "ord:", gen_lbl[] = "gen:";
|
static const char ord_lbl[] = "ord:", gen_lbl[] = "gen:";
|
static const char none_lbl[] = "none", any_lbl[] = "any";
|
static const char none_lbl[] = "none", any_lbl[] = "any";
|
static const char base_lbl[] = "base", sys_lbl[] = "sys";
|
static const char base_lbl[] = "base", sys_lbl[] = "sys";
|
|
|
enum debug_struct_file files = DINFO_STRUCT_FILE_ANY;
|
enum debug_struct_file files = DINFO_STRUCT_FILE_ANY;
|
/* Default is to apply to as much as possible. */
|
/* Default is to apply to as much as possible. */
|
enum debug_info_usage usage = DINFO_USAGE_NUM_ENUMS;
|
enum debug_info_usage usage = DINFO_USAGE_NUM_ENUMS;
|
int ord = 1, gen = 1;
|
int ord = 1, gen = 1;
|
|
|
/* What usage? */
|
/* What usage? */
|
if (MATCH (dfn_lbl, spec))
|
if (MATCH (dfn_lbl, spec))
|
usage = DINFO_USAGE_DFN;
|
usage = DINFO_USAGE_DFN;
|
else if (MATCH (dir_lbl, spec))
|
else if (MATCH (dir_lbl, spec))
|
usage = DINFO_USAGE_DIR_USE;
|
usage = DINFO_USAGE_DIR_USE;
|
else if (MATCH (ind_lbl, spec))
|
else if (MATCH (ind_lbl, spec))
|
usage = DINFO_USAGE_IND_USE;
|
usage = DINFO_USAGE_IND_USE;
|
|
|
/* Generics or not? */
|
/* Generics or not? */
|
if (MATCH (ord_lbl, spec))
|
if (MATCH (ord_lbl, spec))
|
gen = 0;
|
gen = 0;
|
else if (MATCH (gen_lbl, spec))
|
else if (MATCH (gen_lbl, spec))
|
ord = 0;
|
ord = 0;
|
|
|
/* What allowable environment? */
|
/* What allowable environment? */
|
if (MATCH (none_lbl, spec))
|
if (MATCH (none_lbl, spec))
|
files = DINFO_STRUCT_FILE_NONE;
|
files = DINFO_STRUCT_FILE_NONE;
|
else if (MATCH (any_lbl, spec))
|
else if (MATCH (any_lbl, spec))
|
files = DINFO_STRUCT_FILE_ANY;
|
files = DINFO_STRUCT_FILE_ANY;
|
else if (MATCH (sys_lbl, spec))
|
else if (MATCH (sys_lbl, spec))
|
files = DINFO_STRUCT_FILE_SYS;
|
files = DINFO_STRUCT_FILE_SYS;
|
else if (MATCH (base_lbl, spec))
|
else if (MATCH (base_lbl, spec))
|
files = DINFO_STRUCT_FILE_BASE;
|
files = DINFO_STRUCT_FILE_BASE;
|
else
|
else
|
error_at (loc,
|
error_at (loc,
|
"argument %qs to %<-femit-struct-debug-detailed%> "
|
"argument %qs to %<-femit-struct-debug-detailed%> "
|
"not recognized",
|
"not recognized",
|
spec);
|
spec);
|
|
|
/* Effect the specification. */
|
/* Effect the specification. */
|
if (usage == DINFO_USAGE_NUM_ENUMS)
|
if (usage == DINFO_USAGE_NUM_ENUMS)
|
{
|
{
|
if (ord)
|
if (ord)
|
{
|
{
|
opts->x_debug_struct_ordinary[DINFO_USAGE_DFN] = files;
|
opts->x_debug_struct_ordinary[DINFO_USAGE_DFN] = files;
|
opts->x_debug_struct_ordinary[DINFO_USAGE_DIR_USE] = files;
|
opts->x_debug_struct_ordinary[DINFO_USAGE_DIR_USE] = files;
|
opts->x_debug_struct_ordinary[DINFO_USAGE_IND_USE] = files;
|
opts->x_debug_struct_ordinary[DINFO_USAGE_IND_USE] = files;
|
}
|
}
|
if (gen)
|
if (gen)
|
{
|
{
|
opts->x_debug_struct_generic[DINFO_USAGE_DFN] = files;
|
opts->x_debug_struct_generic[DINFO_USAGE_DFN] = files;
|
opts->x_debug_struct_generic[DINFO_USAGE_DIR_USE] = files;
|
opts->x_debug_struct_generic[DINFO_USAGE_DIR_USE] = files;
|
opts->x_debug_struct_generic[DINFO_USAGE_IND_USE] = files;
|
opts->x_debug_struct_generic[DINFO_USAGE_IND_USE] = files;
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
if (ord)
|
if (ord)
|
opts->x_debug_struct_ordinary[usage] = files;
|
opts->x_debug_struct_ordinary[usage] = files;
|
if (gen)
|
if (gen)
|
opts->x_debug_struct_generic[usage] = files;
|
opts->x_debug_struct_generic[usage] = files;
|
}
|
}
|
|
|
if (*spec == ',')
|
if (*spec == ',')
|
set_struct_debug_option (opts, loc, spec+1);
|
set_struct_debug_option (opts, loc, spec+1);
|
else
|
else
|
{
|
{
|
/* No more -femit-struct-debug-detailed specifications.
|
/* No more -femit-struct-debug-detailed specifications.
|
Do final checks. */
|
Do final checks. */
|
if (*spec != '\0')
|
if (*spec != '\0')
|
error_at (loc,
|
error_at (loc,
|
"argument %qs to %<-femit-struct-debug-detailed%> unknown",
|
"argument %qs to %<-femit-struct-debug-detailed%> unknown",
|
spec);
|
spec);
|
if (opts->x_debug_struct_ordinary[DINFO_USAGE_DIR_USE]
|
if (opts->x_debug_struct_ordinary[DINFO_USAGE_DIR_USE]
|
< opts->x_debug_struct_ordinary[DINFO_USAGE_IND_USE]
|
< opts->x_debug_struct_ordinary[DINFO_USAGE_IND_USE]
|
|| opts->x_debug_struct_generic[DINFO_USAGE_DIR_USE]
|
|| opts->x_debug_struct_generic[DINFO_USAGE_DIR_USE]
|
< opts->x_debug_struct_generic[DINFO_USAGE_IND_USE])
|
< opts->x_debug_struct_generic[DINFO_USAGE_IND_USE])
|
error_at (loc,
|
error_at (loc,
|
"%<-femit-struct-debug-detailed=dir:...%> must allow "
|
"%<-femit-struct-debug-detailed=dir:...%> must allow "
|
"at least as much as "
|
"at least as much as "
|
"%<-femit-struct-debug-detailed=ind:...%>");
|
"%<-femit-struct-debug-detailed=ind:...%>");
|
}
|
}
|
}
|
}
|
|
|
/* Handle -ftree-vectorizer-verbose=VAL for options OPTS. */
|
/* Handle -ftree-vectorizer-verbose=VAL for options OPTS. */
|
|
|
static void
|
static void
|
vect_set_verbosity_level (struct gcc_options *opts, int val)
|
vect_set_verbosity_level (struct gcc_options *opts, int val)
|
{
|
{
|
if (val < MAX_VERBOSITY_LEVEL)
|
if (val < MAX_VERBOSITY_LEVEL)
|
opts->x_user_vect_verbosity_level = (enum vect_verbosity_levels) val;
|
opts->x_user_vect_verbosity_level = (enum vect_verbosity_levels) val;
|
else
|
else
|
opts->x_user_vect_verbosity_level
|
opts->x_user_vect_verbosity_level
|
= (enum vect_verbosity_levels) (MAX_VERBOSITY_LEVEL - 1);
|
= (enum vect_verbosity_levels) (MAX_VERBOSITY_LEVEL - 1);
|
}
|
}
|
|
|
|
|
/* Strip off a legitimate source ending from the input string NAME of
|
/* 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
|
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
|
our front ends, we strip off an ending of a period followed by
|
up to five characters. (Java uses ".class".) */
|
up to five characters. (Java uses ".class".) */
|
|
|
void
|
void
|
strip_off_ending (char *name, int len)
|
strip_off_ending (char *name, int len)
|
{
|
{
|
int i;
|
int i;
|
for (i = 2; i < 6 && len > i; i++)
|
for (i = 2; i < 6 && len > i; i++)
|
{
|
{
|
if (name[len - i] == '.')
|
if (name[len - i] == '.')
|
{
|
{
|
name[len - i] = '\0';
|
name[len - i] = '\0';
|
break;
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Find the base name of a path, stripping off both directories and
|
/* Find the base name of a path, stripping off both directories and
|
a single final extension. */
|
a single final extension. */
|
int
|
int
|
base_of_path (const char *path, const char **base_out)
|
base_of_path (const char *path, const char **base_out)
|
{
|
{
|
const char *base = path;
|
const char *base = path;
|
const char *dot = 0;
|
const char *dot = 0;
|
const char *p = path;
|
const char *p = path;
|
char c = *p;
|
char c = *p;
|
while (c)
|
while (c)
|
{
|
{
|
if (IS_DIR_SEPARATOR(c))
|
if (IS_DIR_SEPARATOR(c))
|
{
|
{
|
base = p + 1;
|
base = p + 1;
|
dot = 0;
|
dot = 0;
|
}
|
}
|
else if (c == '.')
|
else if (c == '.')
|
dot = p;
|
dot = p;
|
c = *++p;
|
c = *++p;
|
}
|
}
|
if (!dot)
|
if (!dot)
|
dot = p;
|
dot = p;
|
*base_out = base;
|
*base_out = base;
|
return dot - base;
|
return dot - base;
|
}
|
}
|
|
|
/* What to print when a switch has no documentation. */
|
/* What to print when a switch has no documentation. */
|
static const char undocumented_msg[] = N_("This switch lacks documentation");
|
static const char undocumented_msg[] = N_("This switch lacks documentation");
|
|
|
typedef char *char_p; /* For DEF_VEC_P. */
|
typedef char *char_p; /* For DEF_VEC_P. */
|
DEF_VEC_P(char_p);
|
DEF_VEC_P(char_p);
|
DEF_VEC_ALLOC_P(char_p,heap);
|
DEF_VEC_ALLOC_P(char_p,heap);
|
|
|
static void handle_param (struct gcc_options *opts,
|
static void handle_param (struct gcc_options *opts,
|
struct gcc_options *opts_set, location_t loc,
|
struct gcc_options *opts_set, location_t loc,
|
const char *carg);
|
const char *carg);
|
static void set_debug_level (enum debug_info_type type, int extended,
|
static void set_debug_level (enum debug_info_type type, int extended,
|
const char *arg, struct gcc_options *opts,
|
const char *arg, struct gcc_options *opts,
|
struct gcc_options *opts_set,
|
struct gcc_options *opts_set,
|
location_t loc);
|
location_t loc);
|
static void set_fast_math_flags (struct gcc_options *opts, int set);
|
static void set_fast_math_flags (struct gcc_options *opts, int set);
|
static void decode_d_option (const char *arg, struct gcc_options *opts,
|
static void decode_d_option (const char *arg, struct gcc_options *opts,
|
location_t loc, diagnostic_context *dc);
|
location_t loc, diagnostic_context *dc);
|
static void set_unsafe_math_optimizations_flags (struct gcc_options *opts,
|
static void set_unsafe_math_optimizations_flags (struct gcc_options *opts,
|
int set);
|
int set);
|
static void enable_warning_as_error (const char *arg, int value,
|
static void enable_warning_as_error (const char *arg, int value,
|
unsigned int lang_mask,
|
unsigned int lang_mask,
|
const struct cl_option_handlers *handlers,
|
const struct cl_option_handlers *handlers,
|
struct gcc_options *opts,
|
struct gcc_options *opts,
|
struct gcc_options *opts_set,
|
struct gcc_options *opts_set,
|
location_t loc,
|
location_t loc,
|
diagnostic_context *dc);
|
diagnostic_context *dc);
|
|
|
/* Handle a back-end option; arguments and return value as for
|
/* Handle a back-end option; arguments and return value as for
|
handle_option. */
|
handle_option. */
|
|
|
bool
|
bool
|
target_handle_option (struct gcc_options *opts,
|
target_handle_option (struct gcc_options *opts,
|
struct gcc_options *opts_set,
|
struct gcc_options *opts_set,
|
const struct cl_decoded_option *decoded,
|
const struct cl_decoded_option *decoded,
|
unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
|
unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
|
location_t loc,
|
location_t loc,
|
const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED,
|
const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED,
|
diagnostic_context *dc)
|
diagnostic_context *dc)
|
{
|
{
|
gcc_assert (dc == global_dc);
|
gcc_assert (dc == global_dc);
|
gcc_assert (kind == DK_UNSPECIFIED);
|
gcc_assert (kind == DK_UNSPECIFIED);
|
return targetm_common.handle_option (opts, opts_set, decoded, loc);
|
return targetm_common.handle_option (opts, opts_set, decoded, loc);
|
}
|
}
|
|
|
/* Add comma-separated strings to a char_p vector. */
|
/* Add comma-separated strings to a char_p vector. */
|
|
|
static void
|
static void
|
add_comma_separated_to_vector (void **pvec, const char *arg)
|
add_comma_separated_to_vector (void **pvec, const char *arg)
|
{
|
{
|
char *tmp;
|
char *tmp;
|
char *r;
|
char *r;
|
char *w;
|
char *w;
|
char *token_start;
|
char *token_start;
|
VEC(char_p,heap) *vec = (VEC(char_p,heap) *) *pvec;
|
VEC(char_p,heap) *vec = (VEC(char_p,heap) *) *pvec;
|
|
|
/* We never free this string. */
|
/* We never free this string. */
|
tmp = xstrdup (arg);
|
tmp = xstrdup (arg);
|
|
|
r = tmp;
|
r = tmp;
|
w = tmp;
|
w = tmp;
|
token_start = tmp;
|
token_start = tmp;
|
|
|
while (*r != '\0')
|
while (*r != '\0')
|
{
|
{
|
if (*r == ',')
|
if (*r == ',')
|
{
|
{
|
*w++ = '\0';
|
*w++ = '\0';
|
++r;
|
++r;
|
VEC_safe_push (char_p, heap, vec, token_start);
|
VEC_safe_push (char_p, heap, vec, token_start);
|
token_start = w;
|
token_start = w;
|
}
|
}
|
if (*r == '\\' && r[1] == ',')
|
if (*r == '\\' && r[1] == ',')
|
{
|
{
|
*w++ = ',';
|
*w++ = ',';
|
r += 2;
|
r += 2;
|
}
|
}
|
else
|
else
|
*w++ = *r++;
|
*w++ = *r++;
|
}
|
}
|
if (*token_start != '\0')
|
if (*token_start != '\0')
|
VEC_safe_push (char_p, heap, vec, token_start);
|
VEC_safe_push (char_p, heap, vec, token_start);
|
|
|
*pvec = vec;
|
*pvec = vec;
|
}
|
}
|
|
|
/* Initialize OPTS and OPTS_SET before using them in parsing options. */
|
/* Initialize OPTS and OPTS_SET before using them in parsing options. */
|
|
|
void
|
void
|
init_options_struct (struct gcc_options *opts, struct gcc_options *opts_set)
|
init_options_struct (struct gcc_options *opts, struct gcc_options *opts_set)
|
{
|
{
|
size_t num_params = get_num_compiler_params ();
|
size_t num_params = get_num_compiler_params ();
|
|
|
*opts = global_options_init;
|
*opts = global_options_init;
|
memset (opts_set, 0, sizeof (*opts_set));
|
memset (opts_set, 0, sizeof (*opts_set));
|
|
|
opts->x_param_values = XNEWVEC (int, num_params);
|
opts->x_param_values = XNEWVEC (int, num_params);
|
opts_set->x_param_values = XCNEWVEC (int, num_params);
|
opts_set->x_param_values = XCNEWVEC (int, num_params);
|
init_param_values (opts->x_param_values);
|
init_param_values (opts->x_param_values);
|
|
|
/* Initialize whether `char' is signed. */
|
/* Initialize whether `char' is signed. */
|
opts->x_flag_signed_char = DEFAULT_SIGNED_CHAR;
|
opts->x_flag_signed_char = DEFAULT_SIGNED_CHAR;
|
/* Set this to a special "uninitialized" value. The actual default
|
/* Set this to a special "uninitialized" value. The actual default
|
is set after target options have been processed. */
|
is set after target options have been processed. */
|
opts->x_flag_short_enums = 2;
|
opts->x_flag_short_enums = 2;
|
|
|
/* Initialize target_flags before default_options_optimization
|
/* Initialize target_flags before default_options_optimization
|
so the latter can modify it. */
|
so the latter can modify it. */
|
opts->x_target_flags = targetm_common.default_target_flags;
|
opts->x_target_flags = targetm_common.default_target_flags;
|
|
|
/* Some targets have ABI-specified unwind tables. */
|
/* Some targets have ABI-specified unwind tables. */
|
opts->x_flag_unwind_tables = targetm_common.unwind_tables_default;
|
opts->x_flag_unwind_tables = targetm_common.unwind_tables_default;
|
|
|
/* Some targets have other target-specific initialization. */
|
/* Some targets have other target-specific initialization. */
|
targetm_common.option_init_struct (opts);
|
targetm_common.option_init_struct (opts);
|
}
|
}
|
|
|
/* If indicated by the optimization level LEVEL (-Os if SIZE is set,
|
/* 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
|
-Ofast if FAST is set), apply the option DEFAULT_OPT to OPTS and
|
OPTS_SET, diagnostic context DC, location LOC, with language mask
|
OPTS_SET, diagnostic context DC, location LOC, with language mask
|
LANG_MASK and option handlers HANDLERS. */
|
LANG_MASK and option handlers HANDLERS. */
|
|
|
static void
|
static void
|
maybe_default_option (struct gcc_options *opts,
|
maybe_default_option (struct gcc_options *opts,
|
struct gcc_options *opts_set,
|
struct gcc_options *opts_set,
|
const struct default_options *default_opt,
|
const struct default_options *default_opt,
|
int level, bool size, bool fast,
|
int level, bool size, bool fast,
|
unsigned int lang_mask,
|
unsigned int lang_mask,
|
const struct cl_option_handlers *handlers,
|
const struct cl_option_handlers *handlers,
|
location_t loc,
|
location_t loc,
|
diagnostic_context *dc)
|
diagnostic_context *dc)
|
{
|
{
|
const struct cl_option *option = &cl_options[default_opt->opt_index];
|
const struct cl_option *option = &cl_options[default_opt->opt_index];
|
bool enabled;
|
bool enabled;
|
|
|
if (size)
|
if (size)
|
gcc_assert (level == 2);
|
gcc_assert (level == 2);
|
if (fast)
|
if (fast)
|
gcc_assert (level == 3);
|
gcc_assert (level == 3);
|
|
|
switch (default_opt->levels)
|
switch (default_opt->levels)
|
{
|
{
|
case OPT_LEVELS_ALL:
|
case OPT_LEVELS_ALL:
|
enabled = true;
|
enabled = true;
|
break;
|
break;
|
|
|
case OPT_LEVELS_0_ONLY:
|
case OPT_LEVELS_0_ONLY:
|
enabled = (level == 0);
|
enabled = (level == 0);
|
break;
|
break;
|
|
|
case OPT_LEVELS_1_PLUS:
|
case OPT_LEVELS_1_PLUS:
|
enabled = (level >= 1);
|
enabled = (level >= 1);
|
break;
|
break;
|
|
|
case OPT_LEVELS_1_PLUS_SPEED_ONLY:
|
case OPT_LEVELS_1_PLUS_SPEED_ONLY:
|
enabled = (level >= 1 && !size);
|
enabled = (level >= 1 && !size);
|
break;
|
break;
|
|
|
case OPT_LEVELS_2_PLUS:
|
case OPT_LEVELS_2_PLUS:
|
enabled = (level >= 2);
|
enabled = (level >= 2);
|
break;
|
break;
|
|
|
case OPT_LEVELS_2_PLUS_SPEED_ONLY:
|
case OPT_LEVELS_2_PLUS_SPEED_ONLY:
|
enabled = (level >= 2 && !size);
|
enabled = (level >= 2 && !size);
|
break;
|
break;
|
|
|
case OPT_LEVELS_3_PLUS:
|
case OPT_LEVELS_3_PLUS:
|
enabled = (level >= 3);
|
enabled = (level >= 3);
|
break;
|
break;
|
|
|
case OPT_LEVELS_3_PLUS_AND_SIZE:
|
case OPT_LEVELS_3_PLUS_AND_SIZE:
|
enabled = (level >= 3 || size);
|
enabled = (level >= 3 || size);
|
break;
|
break;
|
|
|
case OPT_LEVELS_SIZE:
|
case OPT_LEVELS_SIZE:
|
enabled = size;
|
enabled = size;
|
break;
|
break;
|
|
|
case OPT_LEVELS_FAST:
|
case OPT_LEVELS_FAST:
|
enabled = fast;
|
enabled = fast;
|
break;
|
break;
|
|
|
case OPT_LEVELS_NONE:
|
case OPT_LEVELS_NONE:
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
if (enabled)
|
if (enabled)
|
handle_generated_option (opts, opts_set, default_opt->opt_index,
|
handle_generated_option (opts, opts_set, default_opt->opt_index,
|
default_opt->arg, default_opt->value,
|
default_opt->arg, default_opt->value,
|
lang_mask, DK_UNSPECIFIED, loc,
|
lang_mask, DK_UNSPECIFIED, loc,
|
handlers, dc);
|
handlers, dc);
|
else if (default_opt->arg == NULL
|
else if (default_opt->arg == NULL
|
&& !option->cl_reject_negative)
|
&& !option->cl_reject_negative)
|
handle_generated_option (opts, opts_set, default_opt->opt_index,
|
handle_generated_option (opts, opts_set, default_opt->opt_index,
|
default_opt->arg, !default_opt->value,
|
default_opt->arg, !default_opt->value,
|
lang_mask, DK_UNSPECIFIED, loc,
|
lang_mask, DK_UNSPECIFIED, loc,
|
handlers, dc);
|
handlers, dc);
|
}
|
}
|
|
|
/* As indicated by the optimization level LEVEL (-Os if SIZE is set,
|
/* 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
|
-Ofast if FAST is set), apply the options in array DEFAULT_OPTS to
|
OPTS and OPTS_SET, diagnostic context DC, location LOC, with
|
OPTS and OPTS_SET, diagnostic context DC, location LOC, with
|
language mask LANG_MASK and option handlers HANDLERS. */
|
language mask LANG_MASK and option handlers HANDLERS. */
|
|
|
static void
|
static void
|
maybe_default_options (struct gcc_options *opts,
|
maybe_default_options (struct gcc_options *opts,
|
struct gcc_options *opts_set,
|
struct gcc_options *opts_set,
|
const struct default_options *default_opts,
|
const struct default_options *default_opts,
|
int level, bool size, bool fast,
|
int level, bool size, bool fast,
|
unsigned int lang_mask,
|
unsigned int lang_mask,
|
const struct cl_option_handlers *handlers,
|
const struct cl_option_handlers *handlers,
|
location_t loc,
|
location_t loc,
|
diagnostic_context *dc)
|
diagnostic_context *dc)
|
{
|
{
|
size_t i;
|
size_t i;
|
|
|
for (i = 0; default_opts[i].levels != OPT_LEVELS_NONE; i++)
|
for (i = 0; default_opts[i].levels != OPT_LEVELS_NONE; i++)
|
maybe_default_option (opts, opts_set, &default_opts[i],
|
maybe_default_option (opts, opts_set, &default_opts[i],
|
level, size, fast, lang_mask, handlers, loc, dc);
|
level, size, fast, lang_mask, handlers, loc, dc);
|
}
|
}
|
|
|
/* Table of options enabled by default at different levels. */
|
/* Table of options enabled by default at different levels. */
|
|
|
static const struct default_options default_options_table[] =
|
static const struct default_options default_options_table[] =
|
{
|
{
|
/* -O1 optimizations. */
|
/* -O1 optimizations. */
|
{ OPT_LEVELS_1_PLUS, OPT_fdefer_pop, NULL, 1 },
|
{ OPT_LEVELS_1_PLUS, OPT_fdefer_pop, NULL, 1 },
|
#ifdef DELAY_SLOTS
|
#ifdef DELAY_SLOTS
|
{ OPT_LEVELS_1_PLUS, OPT_fdelayed_branch, NULL, 1 },
|
{ OPT_LEVELS_1_PLUS, OPT_fdelayed_branch, NULL, 1 },
|
#endif
|
#endif
|
{ OPT_LEVELS_1_PLUS, OPT_fguess_branch_probability, NULL, 1 },
|
{ OPT_LEVELS_1_PLUS, OPT_fguess_branch_probability, NULL, 1 },
|
{ OPT_LEVELS_1_PLUS, OPT_fcprop_registers, 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_fforward_propagate, NULL, 1 },
|
{ OPT_LEVELS_1_PLUS, OPT_fif_conversion, 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_fif_conversion2, NULL, 1 },
|
{ OPT_LEVELS_1_PLUS, OPT_fipa_pure_const, 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_reference, NULL, 1 },
|
{ OPT_LEVELS_1_PLUS, OPT_fipa_profile, 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_fmerge_constants, NULL, 1 },
|
{ OPT_LEVELS_1_PLUS, OPT_fshrink_wrap, 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_fsplit_wide_types, NULL, 1 },
|
{ OPT_LEVELS_1_PLUS, OPT_ftree_ccp, 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_bit_ccp, NULL, 1 },
|
{ OPT_LEVELS_1_PLUS, OPT_ftree_dce, 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_dominator_opts, NULL, 1 },
|
{ OPT_LEVELS_1_PLUS, OPT_ftree_dse, 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_ter, NULL, 1 },
|
{ OPT_LEVELS_1_PLUS, OPT_ftree_sra, 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_copyrename, NULL, 1 },
|
{ OPT_LEVELS_1_PLUS, OPT_ftree_fre, 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_copy_prop, NULL, 1 },
|
{ OPT_LEVELS_1_PLUS, OPT_ftree_sink, 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_ftree_ch, NULL, 1 },
|
{ OPT_LEVELS_1_PLUS, OPT_fcombine_stack_adjustments, 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_fcompare_elim, NULL, 1 },
|
|
|
/* -O2 optimizations. */
|
/* -O2 optimizations. */
|
{ OPT_LEVELS_2_PLUS, OPT_finline_small_functions, NULL, 1 },
|
{ OPT_LEVELS_2_PLUS, OPT_finline_small_functions, NULL, 1 },
|
{ OPT_LEVELS_2_PLUS, OPT_findirect_inlining, 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_fpartial_inlining, NULL, 1 },
|
{ OPT_LEVELS_2_PLUS, OPT_fthread_jumps, NULL, 1 },
|
{ OPT_LEVELS_2_PLUS, OPT_fthread_jumps, NULL, 1 },
|
{ OPT_LEVELS_2_PLUS, OPT_fcrossjumping, 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_foptimize_sibling_calls, NULL, 1 },
|
{ OPT_LEVELS_2_PLUS, OPT_fcse_follow_jumps, 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_fgcse, NULL, 1 },
|
{ OPT_LEVELS_2_PLUS, OPT_fexpensive_optimizations, 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_frerun_cse_after_loop, NULL, 1 },
|
{ OPT_LEVELS_2_PLUS, OPT_fcaller_saves, NULL, 1 },
|
{ OPT_LEVELS_2_PLUS, OPT_fcaller_saves, NULL, 1 },
|
{ OPT_LEVELS_2_PLUS, OPT_fpeephole2, NULL, 1 },
|
{ OPT_LEVELS_2_PLUS, OPT_fpeephole2, NULL, 1 },
|
#ifdef INSN_SCHEDULING
|
#ifdef INSN_SCHEDULING
|
/* Only run the pre-regalloc scheduling pass if optimizing for speed. */
|
/* 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_SPEED_ONLY, OPT_fschedule_insns, NULL, 1 },
|
{ OPT_LEVELS_2_PLUS, OPT_fschedule_insns2, NULL, 1 },
|
{ OPT_LEVELS_2_PLUS, OPT_fschedule_insns2, NULL, 1 },
|
#endif
|
#endif
|
{ OPT_LEVELS_2_PLUS, OPT_fregmove, NULL, 1 },
|
{ OPT_LEVELS_2_PLUS, OPT_fregmove, NULL, 1 },
|
{ OPT_LEVELS_2_PLUS, OPT_fstrict_aliasing, 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_fstrict_overflow, NULL, 1 },
|
{ OPT_LEVELS_2_PLUS, OPT_freorder_blocks, 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_freorder_functions, NULL, 1 },
|
{ OPT_LEVELS_2_PLUS, OPT_ftree_vrp, 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_builtin_call_dce, NULL, 1 },
|
{ OPT_LEVELS_2_PLUS, OPT_ftree_pre, 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_ftree_switch_conversion, NULL, 1 },
|
{ OPT_LEVELS_2_PLUS, OPT_fipa_cp, 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, NULL, 1 },
|
{ OPT_LEVELS_2_PLUS, OPT_fipa_sra, 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_loops, NULL, 1 },
|
{ OPT_LEVELS_2_PLUS, OPT_falign_jumps, 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_labels, NULL, 1 },
|
{ OPT_LEVELS_2_PLUS, OPT_falign_functions, 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_ftree_tail_merge, NULL, 1 },
|
{ OPT_LEVELS_2_PLUS_SPEED_ONLY, OPT_foptimize_strlen, NULL, 1 },
|
{ OPT_LEVELS_2_PLUS_SPEED_ONLY, OPT_foptimize_strlen, NULL, 1 },
|
|
|
/* -O3 optimizations. */
|
/* -O3 optimizations. */
|
{ OPT_LEVELS_3_PLUS, OPT_ftree_loop_distribute_patterns, NULL, 1 },
|
{ OPT_LEVELS_3_PLUS, OPT_ftree_loop_distribute_patterns, NULL, 1 },
|
{ OPT_LEVELS_3_PLUS, OPT_fpredictive_commoning, NULL, 1 },
|
{ OPT_LEVELS_3_PLUS, OPT_fpredictive_commoning, NULL, 1 },
|
/* Inlining of functions reducing size is a good idea with -Os
|
/* Inlining of functions reducing size is a good idea with -Os
|
regardless of them being declared inline. */
|
regardless of them being declared inline. */
|
{ OPT_LEVELS_3_PLUS_AND_SIZE, OPT_finline_functions, NULL, 1 },
|
{ 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, OPT_finline_functions_called_once, NULL, 1 },
|
{ OPT_LEVELS_3_PLUS, OPT_funswitch_loops, 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_fgcse_after_reload, NULL, 1 },
|
{ OPT_LEVELS_3_PLUS, OPT_ftree_vectorize, NULL, 1 },
|
{ OPT_LEVELS_3_PLUS, OPT_ftree_vectorize, NULL, 1 },
|
{ OPT_LEVELS_3_PLUS, OPT_fipa_cp_clone, NULL, 1 },
|
{ OPT_LEVELS_3_PLUS, OPT_fipa_cp_clone, NULL, 1 },
|
|
|
/* -Ofast adds optimizations to -O3. */
|
/* -Ofast adds optimizations to -O3. */
|
{ OPT_LEVELS_FAST, OPT_ffast_math, NULL, 1 },
|
{ OPT_LEVELS_FAST, OPT_ffast_math, NULL, 1 },
|
|
|
{ OPT_LEVELS_NONE, 0, NULL, 0 }
|
{ OPT_LEVELS_NONE, 0, NULL, 0 }
|
};
|
};
|
|
|
/* Default the options in OPTS and OPTS_SET based on the optimization
|
/* Default the options in OPTS and OPTS_SET based on the optimization
|
settings in DECODED_OPTIONS and DECODED_OPTIONS_COUNT. */
|
settings in DECODED_OPTIONS and DECODED_OPTIONS_COUNT. */
|
void
|
void
|
default_options_optimization (struct gcc_options *opts,
|
default_options_optimization (struct gcc_options *opts,
|
struct gcc_options *opts_set,
|
struct gcc_options *opts_set,
|
struct cl_decoded_option *decoded_options,
|
struct cl_decoded_option *decoded_options,
|
unsigned int decoded_options_count,
|
unsigned int decoded_options_count,
|
location_t loc,
|
location_t loc,
|
unsigned int lang_mask,
|
unsigned int lang_mask,
|
const struct cl_option_handlers *handlers,
|
const struct cl_option_handlers *handlers,
|
diagnostic_context *dc)
|
diagnostic_context *dc)
|
{
|
{
|
unsigned int i;
|
unsigned int i;
|
int opt2;
|
int opt2;
|
|
|
/* Scan to see what optimization level has been specified. That will
|
/* Scan to see what optimization level has been specified. That will
|
determine the default value of many flags. */
|
determine the default value of many flags. */
|
for (i = 1; i < decoded_options_count; i++)
|
for (i = 1; i < decoded_options_count; i++)
|
{
|
{
|
struct cl_decoded_option *opt = &decoded_options[i];
|
struct cl_decoded_option *opt = &decoded_options[i];
|
switch (opt->opt_index)
|
switch (opt->opt_index)
|
{
|
{
|
case OPT_O:
|
case OPT_O:
|
if (*opt->arg == '\0')
|
if (*opt->arg == '\0')
|
{
|
{
|
opts->x_optimize = 1;
|
opts->x_optimize = 1;
|
opts->x_optimize_size = 0;
|
opts->x_optimize_size = 0;
|
opts->x_optimize_fast = 0;
|
opts->x_optimize_fast = 0;
|
}
|
}
|
else
|
else
|
{
|
{
|
const int optimize_val = integral_argument (opt->arg);
|
const int optimize_val = integral_argument (opt->arg);
|
if (optimize_val == -1)
|
if (optimize_val == -1)
|
error_at (loc,
|
error_at (loc,
|
"argument to %qs should be a non-negative integer",
|
"argument to %qs should be a non-negative integer",
|
"-O");
|
"-O");
|
else
|
else
|
{
|
{
|
opts->x_optimize = optimize_val;
|
opts->x_optimize = optimize_val;
|
if ((unsigned int) opts->x_optimize > 255)
|
if ((unsigned int) opts->x_optimize > 255)
|
opts->x_optimize = 255;
|
opts->x_optimize = 255;
|
opts->x_optimize_size = 0;
|
opts->x_optimize_size = 0;
|
opts->x_optimize_fast = 0;
|
opts->x_optimize_fast = 0;
|
}
|
}
|
}
|
}
|
break;
|
break;
|
|
|
case OPT_Os:
|
case OPT_Os:
|
opts->x_optimize_size = 1;
|
opts->x_optimize_size = 1;
|
|
|
/* Optimizing for size forces optimize to be 2. */
|
/* Optimizing for size forces optimize to be 2. */
|
opts->x_optimize = 2;
|
opts->x_optimize = 2;
|
opts->x_optimize_fast = 0;
|
opts->x_optimize_fast = 0;
|
break;
|
break;
|
|
|
case OPT_Ofast:
|
case OPT_Ofast:
|
/* -Ofast only adds flags to -O3. */
|
/* -Ofast only adds flags to -O3. */
|
opts->x_optimize_size = 0;
|
opts->x_optimize_size = 0;
|
opts->x_optimize = 3;
|
opts->x_optimize = 3;
|
opts->x_optimize_fast = 1;
|
opts->x_optimize_fast = 1;
|
break;
|
break;
|
|
|
default:
|
default:
|
/* Ignore other options in this prescan. */
|
/* Ignore other options in this prescan. */
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
maybe_default_options (opts, opts_set, default_options_table,
|
maybe_default_options (opts, opts_set, default_options_table,
|
opts->x_optimize, opts->x_optimize_size,
|
opts->x_optimize, opts->x_optimize_size,
|
opts->x_optimize_fast, lang_mask, handlers, loc, dc);
|
opts->x_optimize_fast, lang_mask, handlers, loc, dc);
|
|
|
/* -O2 param settings. */
|
/* -O2 param settings. */
|
opt2 = (opts->x_optimize >= 2);
|
opt2 = (opts->x_optimize >= 2);
|
|
|
/* Track fields in field-sensitive alias analysis. */
|
/* Track fields in field-sensitive alias analysis. */
|
maybe_set_param_value
|
maybe_set_param_value
|
(PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE,
|
(PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE,
|
opt2 ? 100 : default_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);
|
opts->x_param_values, opts_set->x_param_values);
|
|
|
/* For -O1 only do loop invariant motion for very small loops. */
|
/* For -O1 only do loop invariant motion for very small loops. */
|
maybe_set_param_value
|
maybe_set_param_value
|
(PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP,
|
(PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP,
|
opt2 ? default_param_value (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP) : 1000,
|
opt2 ? default_param_value (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP) : 1000,
|
opts->x_param_values, opts_set->x_param_values);
|
opts->x_param_values, opts_set->x_param_values);
|
|
|
if (opts->x_optimize_size)
|
if (opts->x_optimize_size)
|
/* We want to crossjump as much as possible. */
|
/* We want to crossjump as much as possible. */
|
maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS, 1,
|
maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS, 1,
|
opts->x_param_values, opts_set->x_param_values);
|
opts->x_param_values, opts_set->x_param_values);
|
else
|
else
|
maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS,
|
maybe_set_param_value (PARAM_MIN_CROSSJUMP_INSNS,
|
default_param_value (PARAM_MIN_CROSSJUMP_INSNS),
|
default_param_value (PARAM_MIN_CROSSJUMP_INSNS),
|
opts->x_param_values, opts_set->x_param_values);
|
opts->x_param_values, opts_set->x_param_values);
|
|
|
/* Allow default optimizations to be specified on a per-machine basis. */
|
/* Allow default optimizations to be specified on a per-machine basis. */
|
maybe_default_options (opts, opts_set,
|
maybe_default_options (opts, opts_set,
|
targetm_common.option_optimization_table,
|
targetm_common.option_optimization_table,
|
opts->x_optimize, opts->x_optimize_size,
|
opts->x_optimize, opts->x_optimize_size,
|
opts->x_optimize_fast, lang_mask, handlers, loc, dc);
|
opts->x_optimize_fast, lang_mask, handlers, loc, dc);
|
}
|
}
|
|
|
/* After all options at LOC have been read into OPTS and OPTS_SET,
|
/* After all options at LOC have been read into OPTS and OPTS_SET,
|
finalize settings of those options and diagnose incompatible
|
finalize settings of those options and diagnose incompatible
|
combinations. */
|
combinations. */
|
void
|
void
|
finish_options (struct gcc_options *opts, struct gcc_options *opts_set,
|
finish_options (struct gcc_options *opts, struct gcc_options *opts_set,
|
location_t loc)
|
location_t loc)
|
{
|
{
|
enum unwind_info_type ui_except;
|
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))
|
{
|
{
|
/* First try to make OPTS->X_DUMP_BASE_NAME relative to the
|
/* 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_DIR_NAME directory. Then try to make
|
OPTS->X_DUMP_BASE_NAME relative to the OPTS->X_AUX_BASE_NAME
|
OPTS->X_DUMP_BASE_NAME relative to the OPTS->X_AUX_BASE_NAME
|
directory, typically the directory to contain the object
|
directory, typically the directory to contain the object
|
file. */
|
file. */
|
if (opts->x_dump_dir_name)
|
if (opts->x_dump_dir_name)
|
opts->x_dump_base_name = concat (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, NULL);
|
else if (opts->x_aux_base_name
|
else if (opts->x_aux_base_name
|
&& strcmp (opts->x_aux_base_name, HOST_BIT_BUCKET) != 0)
|
&& strcmp (opts->x_aux_base_name, HOST_BIT_BUCKET) != 0)
|
{
|
{
|
const char *aux_base;
|
const char *aux_base;
|
|
|
base_of_path (opts->x_aux_base_name, &aux_base);
|
base_of_path (opts->x_aux_base_name, &aux_base);
|
if (opts->x_aux_base_name != aux_base)
|
if (opts->x_aux_base_name != aux_base)
|
{
|
{
|
int dir_len = aux_base - opts->x_aux_base_name;
|
int dir_len = aux_base - opts->x_aux_base_name;
|
char *new_dump_base_name =
|
char *new_dump_base_name =
|
XNEWVEC (char, strlen (opts->x_dump_base_name) + dir_len + 1);
|
XNEWVEC (char, strlen (opts->x_dump_base_name) + dir_len + 1);
|
|
|
/* Copy directory component from OPTS->X_AUX_BASE_NAME. */
|
/* Copy directory component from OPTS->X_AUX_BASE_NAME. */
|
memcpy (new_dump_base_name, opts->x_aux_base_name, dir_len);
|
memcpy (new_dump_base_name, opts->x_aux_base_name, dir_len);
|
/* Append existing OPTS->X_DUMP_BASE_NAME. */
|
/* Append existing OPTS->X_DUMP_BASE_NAME. */
|
strcpy (new_dump_base_name + dir_len, 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;
|
opts->x_dump_base_name = new_dump_base_name;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Handle related options for unit-at-a-time, toplevel-reorder, and
|
/* Handle related options for unit-at-a-time, toplevel-reorder, and
|
section-anchors. */
|
section-anchors. */
|
if (!opts->x_flag_unit_at_a_time)
|
if (!opts->x_flag_unit_at_a_time)
|
{
|
{
|
if (opts->x_flag_section_anchors && opts_set->x_flag_section_anchors)
|
if (opts->x_flag_section_anchors && opts_set->x_flag_section_anchors)
|
error_at (loc, "section anchors must be disabled when unit-at-a-time "
|
error_at (loc, "section anchors must be disabled when unit-at-a-time "
|
"is disabled");
|
"is disabled");
|
opts->x_flag_section_anchors = 0;
|
opts->x_flag_section_anchors = 0;
|
if (opts->x_flag_toplevel_reorder == 1)
|
if (opts->x_flag_toplevel_reorder == 1)
|
error_at (loc, "toplevel reorder must be disabled when unit-at-a-time "
|
error_at (loc, "toplevel reorder must be disabled when unit-at-a-time "
|
"is disabled");
|
"is disabled");
|
opts->x_flag_toplevel_reorder = 0;
|
opts->x_flag_toplevel_reorder = 0;
|
}
|
}
|
|
|
if (opts->x_flag_tm && opts->x_flag_non_call_exceptions)
|
if (opts->x_flag_tm && opts->x_flag_non_call_exceptions)
|
sorry ("transactional memory is not supported with non-call exceptions");
|
sorry ("transactional memory is not supported with non-call exceptions");
|
|
|
/* -Wmissing-noreturn is alias for -Wsuggest-attribute=noreturn. */
|
/* -Wmissing-noreturn is alias for -Wsuggest-attribute=noreturn. */
|
if (opts->x_warn_missing_noreturn)
|
if (opts->x_warn_missing_noreturn)
|
opts->x_warn_suggest_attribute_noreturn = true;
|
opts->x_warn_suggest_attribute_noreturn = true;
|
|
|
/* Unless the user has asked for section anchors, we disable toplevel
|
/* Unless the user has asked for section anchors, we disable toplevel
|
reordering at -O0 to disable transformations that might be surprising
|
reordering at -O0 to disable transformations that might be surprising
|
to end users and to get -fno-toplevel-reorder tested. */
|
to end users and to get -fno-toplevel-reorder tested. */
|
if (!opts->x_optimize
|
if (!opts->x_optimize
|
&& opts->x_flag_toplevel_reorder == 2
|
&& opts->x_flag_toplevel_reorder == 2
|
&& !(opts->x_flag_section_anchors && opts_set->x_flag_section_anchors))
|
&& !(opts->x_flag_section_anchors && opts_set->x_flag_section_anchors))
|
{
|
{
|
opts->x_flag_toplevel_reorder = 0;
|
opts->x_flag_toplevel_reorder = 0;
|
opts->x_flag_section_anchors = 0;
|
opts->x_flag_section_anchors = 0;
|
}
|
}
|
if (!opts->x_flag_toplevel_reorder)
|
if (!opts->x_flag_toplevel_reorder)
|
{
|
{
|
if (opts->x_flag_section_anchors && opts_set->x_flag_section_anchors)
|
if (opts->x_flag_section_anchors && opts_set->x_flag_section_anchors)
|
error_at (loc, "section anchors must be disabled when toplevel reorder"
|
error_at (loc, "section anchors must be disabled when toplevel reorder"
|
" is disabled");
|
" is disabled");
|
opts->x_flag_section_anchors = 0;
|
opts->x_flag_section_anchors = 0;
|
}
|
}
|
|
|
if (!opts->x_flag_opts_finished)
|
if (!opts->x_flag_opts_finished)
|
{
|
{
|
if (opts->x_flag_pie)
|
if (opts->x_flag_pie)
|
opts->x_flag_pic = opts->x_flag_pie;
|
opts->x_flag_pic = opts->x_flag_pie;
|
if (opts->x_flag_pic && !opts->x_flag_pie)
|
if (opts->x_flag_pic && !opts->x_flag_pie)
|
opts->x_flag_shlib = 1;
|
opts->x_flag_shlib = 1;
|
opts->x_flag_opts_finished = true;
|
opts->x_flag_opts_finished = true;
|
}
|
}
|
|
|
if (opts->x_optimize == 0)
|
if (opts->x_optimize == 0)
|
{
|
{
|
/* Inlining does not work if not optimizing,
|
/* Inlining does not work if not optimizing,
|
so force it not to be done. */
|
so force it not to be done. */
|
opts->x_warn_inline = 0;
|
opts->x_warn_inline = 0;
|
opts->x_flag_no_inline = 1;
|
opts->x_flag_no_inline = 1;
|
}
|
}
|
|
|
/* The optimization to partition hot and cold basic blocks into separate
|
/* The optimization to partition hot and cold basic blocks into separate
|
sections of the .o and executable files does not work (currently)
|
sections of the .o and executable files does not work (currently)
|
with exception handling. This is because there is no support for
|
with exception handling. This is because there is no support for
|
generating unwind info. If opts->x_flag_exceptions is turned on
|
generating unwind info. If opts->x_flag_exceptions is turned on
|
we need to turn off the partitioning optimization. */
|
we need to turn off the partitioning optimization. */
|
|
|
ui_except = targetm_common.except_unwind_info (opts);
|
ui_except = targetm_common.except_unwind_info (opts);
|
|
|
if (opts->x_flag_exceptions
|
if (opts->x_flag_exceptions
|
&& opts->x_flag_reorder_blocks_and_partition
|
&& 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,
|
inform (loc,
|
"-freorder-blocks-and-partition does not work "
|
"-freorder-blocks-and-partition does not work "
|
"with exceptions on this architecture");
|
"with exceptions on this architecture");
|
opts->x_flag_reorder_blocks_and_partition = 0;
|
opts->x_flag_reorder_blocks_and_partition = 0;
|
opts->x_flag_reorder_blocks = 1;
|
opts->x_flag_reorder_blocks = 1;
|
}
|
}
|
|
|
/* If user requested unwind info, then turn off the partitioning
|
/* If user requested unwind info, then turn off the partitioning
|
optimization. */
|
optimization. */
|
|
|
if (opts->x_flag_unwind_tables
|
if (opts->x_flag_unwind_tables
|
&& !targetm_common.unwind_tables_default
|
&& !targetm_common.unwind_tables_default
|
&& opts->x_flag_reorder_blocks_and_partition
|
&& 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,
|
inform (loc,
|
"-freorder-blocks-and-partition does not support "
|
"-freorder-blocks-and-partition does not support "
|
"unwind info on this architecture");
|
"unwind info on this architecture");
|
opts->x_flag_reorder_blocks_and_partition = 0;
|
opts->x_flag_reorder_blocks_and_partition = 0;
|
opts->x_flag_reorder_blocks = 1;
|
opts->x_flag_reorder_blocks = 1;
|
}
|
}
|
|
|
/* If the target requested unwind info, then turn off the partitioning
|
/* If the target requested unwind info, then turn off the partitioning
|
optimization with a different message. Likewise, if the target does not
|
optimization with a different message. Likewise, if the target does not
|
support named sections. */
|
support named sections. */
|
|
|
if (opts->x_flag_reorder_blocks_and_partition
|
if (opts->x_flag_reorder_blocks_and_partition
|
&& (!targetm_common.have_named_sections
|
&& (!targetm_common.have_named_sections
|
|| (opts->x_flag_unwind_tables
|
|| (opts->x_flag_unwind_tables
|
&& targetm_common.unwind_tables_default
|
&& targetm_common.unwind_tables_default
|
&& (ui_except == UI_SJLJ || ui_except == UI_TARGET))))
|
&& (ui_except == UI_SJLJ || ui_except == UI_TARGET))))
|
{
|
{
|
inform (loc,
|
inform (loc,
|
"-freorder-blocks-and-partition does not work "
|
"-freorder-blocks-and-partition does not work "
|
"on this architecture");
|
"on this architecture");
|
opts->x_flag_reorder_blocks_and_partition = 0;
|
opts->x_flag_reorder_blocks_and_partition = 0;
|
opts->x_flag_reorder_blocks = 1;
|
opts->x_flag_reorder_blocks = 1;
|
}
|
}
|
|
|
if (opts->x_flag_reorder_blocks_and_partition
|
if (opts->x_flag_reorder_blocks_and_partition
|
&& !opts_set->x_flag_reorder_functions)
|
&& !opts_set->x_flag_reorder_functions)
|
opts->x_flag_reorder_functions = 1;
|
opts->x_flag_reorder_functions = 1;
|
|
|
/* Pipelining of outer loops is only possible when general pipelining
|
/* Pipelining of outer loops is only possible when general pipelining
|
capabilities are requested. */
|
capabilities are requested. */
|
if (!opts->x_flag_sel_sched_pipelining)
|
if (!opts->x_flag_sel_sched_pipelining)
|
opts->x_flag_sel_sched_pipelining_outer_loops = 0;
|
opts->x_flag_sel_sched_pipelining_outer_loops = 0;
|
|
|
if (opts->x_flag_conserve_stack)
|
if (opts->x_flag_conserve_stack)
|
{
|
{
|
maybe_set_param_value (PARAM_LARGE_STACK_FRAME, 100,
|
maybe_set_param_value (PARAM_LARGE_STACK_FRAME, 100,
|
opts->x_param_values, opts_set->x_param_values);
|
opts->x_param_values, opts_set->x_param_values);
|
maybe_set_param_value (PARAM_STACK_FRAME_GROWTH, 40,
|
maybe_set_param_value (PARAM_STACK_FRAME_GROWTH, 40,
|
opts->x_param_values, opts_set->x_param_values);
|
opts->x_param_values, opts_set->x_param_values);
|
}
|
}
|
|
|
if (opts->x_flag_lto)
|
if (opts->x_flag_lto)
|
{
|
{
|
#ifdef ENABLE_LTO
|
#ifdef ENABLE_LTO
|
opts->x_flag_generate_lto = 1;
|
opts->x_flag_generate_lto = 1;
|
|
|
/* When generating IL, do not operate in whole-program mode.
|
/* When generating IL, do not operate in whole-program mode.
|
Otherwise, symbols will be privatized too early, causing link
|
Otherwise, symbols will be privatized too early, causing link
|
errors later. */
|
errors later. */
|
opts->x_flag_whole_program = 0;
|
opts->x_flag_whole_program = 0;
|
#else
|
#else
|
error_at (loc, "LTO support has not been enabled in this configuration");
|
error_at (loc, "LTO support has not been enabled in this configuration");
|
#endif
|
#endif
|
if (!opts->x_flag_fat_lto_objects && !HAVE_LTO_PLUGIN)
|
if (!opts->x_flag_fat_lto_objects && !HAVE_LTO_PLUGIN)
|
error_at (loc, "-fno-fat-lto-objects are supported only with linker plugin.");
|
error_at (loc, "-fno-fat-lto-objects are supported only with linker plugin.");
|
}
|
}
|
if ((opts->x_flag_lto_partition_balanced != 0) + (opts->x_flag_lto_partition_1to1 != 0)
|
if ((opts->x_flag_lto_partition_balanced != 0) + (opts->x_flag_lto_partition_1to1 != 0)
|
+ (opts->x_flag_lto_partition_none != 0) >= 1)
|
+ (opts->x_flag_lto_partition_none != 0) >= 1)
|
{
|
{
|
if ((opts->x_flag_lto_partition_balanced != 0)
|
if ((opts->x_flag_lto_partition_balanced != 0)
|
+ (opts->x_flag_lto_partition_1to1 != 0)
|
+ (opts->x_flag_lto_partition_1to1 != 0)
|
+ (opts->x_flag_lto_partition_none != 0) > 1)
|
+ (opts->x_flag_lto_partition_none != 0) > 1)
|
error_at (loc, "only one -flto-partition value can be specified");
|
error_at (loc, "only one -flto-partition value can be specified");
|
}
|
}
|
|
|
/* We initialize opts->x_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. */
|
default value if they choose based on other options. */
|
if (opts->x_flag_split_stack == -1)
|
if (opts->x_flag_split_stack == -1)
|
opts->x_flag_split_stack = 0;
|
opts->x_flag_split_stack = 0;
|
else if (opts->x_flag_split_stack)
|
else if (opts->x_flag_split_stack)
|
{
|
{
|
if (!targetm_common.supports_split_stack (true, opts))
|
if (!targetm_common.supports_split_stack (true, opts))
|
{
|
{
|
error_at (loc, "%<-fsplit-stack%> is not supported by "
|
error_at (loc, "%<-fsplit-stack%> is not supported by "
|
"this compiler configuration");
|
"this compiler configuration");
|
opts->x_flag_split_stack = 0;
|
opts->x_flag_split_stack = 0;
|
}
|
}
|
}
|
}
|
|
|
/* Set PARAM_MAX_STORES_TO_SINK to 0 if either vectorization or if-conversion
|
/* Set PARAM_MAX_STORES_TO_SINK to 0 if either vectorization or if-conversion
|
is disabled. */
|
is disabled. */
|
if (!opts->x_flag_tree_vectorize || !opts->x_flag_tree_loop_if_convert)
|
if (!opts->x_flag_tree_vectorize || !opts->x_flag_tree_loop_if_convert)
|
maybe_set_param_value (PARAM_MAX_STORES_TO_SINK, 0,
|
maybe_set_param_value (PARAM_MAX_STORES_TO_SINK, 0,
|
opts->x_param_values, opts_set->x_param_values);
|
opts->x_param_values, opts_set->x_param_values);
|
|
|
/* This replaces set_Wunused. */
|
/* This replaces set_Wunused. */
|
if (opts->x_warn_unused_function == -1)
|
if (opts->x_warn_unused_function == -1)
|
opts->x_warn_unused_function = opts->x_warn_unused;
|
opts->x_warn_unused_function = opts->x_warn_unused;
|
if (opts->x_warn_unused_label == -1)
|
if (opts->x_warn_unused_label == -1)
|
opts->x_warn_unused_label = opts->x_warn_unused;
|
opts->x_warn_unused_label = opts->x_warn_unused;
|
/* Wunused-parameter is enabled if both -Wunused -Wextra are enabled. */
|
/* Wunused-parameter is enabled if both -Wunused -Wextra are enabled. */
|
if (opts->x_warn_unused_parameter == -1)
|
if (opts->x_warn_unused_parameter == -1)
|
opts->x_warn_unused_parameter = (opts->x_warn_unused
|
opts->x_warn_unused_parameter = (opts->x_warn_unused
|
&& opts->x_extra_warnings);
|
&& opts->x_extra_warnings);
|
if (opts->x_warn_unused_variable == -1)
|
if (opts->x_warn_unused_variable == -1)
|
opts->x_warn_unused_variable = opts->x_warn_unused;
|
opts->x_warn_unused_variable = opts->x_warn_unused;
|
/* Wunused-but-set-parameter is enabled if both -Wunused -Wextra are
|
/* Wunused-but-set-parameter is enabled if both -Wunused -Wextra are
|
enabled. */
|
enabled. */
|
if (opts->x_warn_unused_but_set_parameter == -1)
|
if (opts->x_warn_unused_but_set_parameter == -1)
|
opts->x_warn_unused_but_set_parameter = (opts->x_warn_unused
|
opts->x_warn_unused_but_set_parameter = (opts->x_warn_unused
|
&& opts->x_extra_warnings);
|
&& opts->x_extra_warnings);
|
if (opts->x_warn_unused_but_set_variable == -1)
|
if (opts->x_warn_unused_but_set_variable == -1)
|
opts->x_warn_unused_but_set_variable = opts->x_warn_unused;
|
opts->x_warn_unused_but_set_variable = opts->x_warn_unused;
|
if (opts->x_warn_unused_value == -1)
|
if (opts->x_warn_unused_value == -1)
|
opts->x_warn_unused_value = opts->x_warn_unused;
|
opts->x_warn_unused_value = opts->x_warn_unused;
|
|
|
/* This replaces set_Wextra. */
|
/* This replaces set_Wextra. */
|
if (opts->x_warn_uninitialized == -1)
|
if (opts->x_warn_uninitialized == -1)
|
opts->x_warn_uninitialized = opts->x_extra_warnings;
|
opts->x_warn_uninitialized = opts->x_extra_warnings;
|
}
|
}
|
|
|
#define LEFT_COLUMN 27
|
#define LEFT_COLUMN 27
|
|
|
/* Output ITEM, of length ITEM_WIDTH, in the left column,
|
/* Output ITEM, of length ITEM_WIDTH, in the left column,
|
followed by word-wrapped HELP in a second column. */
|
followed by word-wrapped HELP in a second column. */
|
static void
|
static void
|
wrap_help (const char *help,
|
wrap_help (const char *help,
|
const char *item,
|
const char *item,
|
unsigned int item_width,
|
unsigned int item_width,
|
unsigned int columns)
|
unsigned int columns)
|
{
|
{
|
unsigned int col_width = LEFT_COLUMN;
|
unsigned int col_width = LEFT_COLUMN;
|
unsigned int remaining, room, len;
|
unsigned int remaining, room, len;
|
|
|
remaining = strlen (help);
|
remaining = strlen (help);
|
|
|
do
|
do
|
{
|
{
|
room = columns - 3 - MAX (col_width, item_width);
|
room = columns - 3 - MAX (col_width, item_width);
|
if (room > columns)
|
if (room > columns)
|
room = 0;
|
room = 0;
|
len = remaining;
|
len = remaining;
|
|
|
if (room < len)
|
if (room < len)
|
{
|
{
|
unsigned int i;
|
unsigned int i;
|
|
|
for (i = 0; help[i]; i++)
|
for (i = 0; help[i]; i++)
|
{
|
{
|
if (i >= room && len != remaining)
|
if (i >= room && len != remaining)
|
break;
|
break;
|
if (help[i] == ' ')
|
if (help[i] == ' ')
|
len = i;
|
len = i;
|
else if ((help[i] == '-' || help[i] == '/')
|
else if ((help[i] == '-' || help[i] == '/')
|
&& help[i + 1] != ' '
|
&& help[i + 1] != ' '
|
&& i > 0 && ISALPHA (help[i - 1]))
|
&& i > 0 && ISALPHA (help[i - 1]))
|
len = i + 1;
|
len = i + 1;
|
}
|
}
|
}
|
}
|
|
|
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;
|
item_width = 0;
|
while (help[len] == ' ')
|
while (help[len] == ' ')
|
len++;
|
len++;
|
help += len;
|
help += len;
|
remaining -= len;
|
remaining -= len;
|
}
|
}
|
while (remaining);
|
while (remaining);
|
}
|
}
|
|
|
/* Print help for a specific front-end, etc. */
|
/* Print help for a specific front-end, etc. */
|
static void
|
static void
|
print_filtered_help (unsigned int include_flags,
|
print_filtered_help (unsigned int include_flags,
|
unsigned int exclude_flags,
|
unsigned int exclude_flags,
|
unsigned int any_flags,
|
unsigned int any_flags,
|
unsigned int columns,
|
unsigned int columns,
|
struct gcc_options *opts,
|
struct gcc_options *opts,
|
unsigned int lang_mask)
|
unsigned int lang_mask)
|
{
|
{
|
unsigned int i;
|
unsigned int i;
|
const char *help;
|
const char *help;
|
bool found = false;
|
bool found = false;
|
bool displayed = false;
|
bool displayed = false;
|
|
|
if (include_flags == CL_PARAMS)
|
if (include_flags == CL_PARAMS)
|
{
|
{
|
for (i = 0; i < LAST_PARAM; i++)
|
for (i = 0; i < LAST_PARAM; i++)
|
{
|
{
|
const char *param = compiler_params[i].option;
|
const char *param = compiler_params[i].option;
|
|
|
help = compiler_params[i].help;
|
help = compiler_params[i].help;
|
if (help == NULL || *help == '\0')
|
if (help == NULL || *help == '\0')
|
{
|
{
|
if (exclude_flags & CL_UNDOCUMENTED)
|
if (exclude_flags & CL_UNDOCUMENTED)
|
continue;
|
continue;
|
help = undocumented_msg;
|
help = undocumented_msg;
|
}
|
}
|
|
|
/* Get the translation. */
|
/* Get the translation. */
|
help = _(help);
|
help = _(help);
|
|
|
wrap_help (help, param, strlen (param), columns);
|
wrap_help (help, param, strlen (param), columns);
|
}
|
}
|
putchar ('\n');
|
putchar ('\n');
|
return;
|
return;
|
}
|
}
|
|
|
if (!opts->x_help_printed)
|
if (!opts->x_help_printed)
|
opts->x_help_printed = XCNEWVAR (char, cl_options_count);
|
opts->x_help_printed = XCNEWVAR (char, cl_options_count);
|
|
|
if (!opts->x_help_enum_printed)
|
if (!opts->x_help_enum_printed)
|
opts->x_help_enum_printed = XCNEWVAR (char, cl_enums_count);
|
opts->x_help_enum_printed = XCNEWVAR (char, cl_enums_count);
|
|
|
for (i = 0; i < cl_options_count; i++)
|
for (i = 0; i < cl_options_count; i++)
|
{
|
{
|
char new_help[128];
|
char new_help[128];
|
const struct cl_option *option = cl_options + i;
|
const struct cl_option *option = cl_options + i;
|
unsigned int len;
|
unsigned int len;
|
const char *opt;
|
const char *opt;
|
const char *tab;
|
const char *tab;
|
|
|
if (include_flags == 0
|
if (include_flags == 0
|
|| ((option->flags & include_flags) != include_flags))
|
|| ((option->flags & include_flags) != include_flags))
|
{
|
{
|
if ((option->flags & any_flags) == 0)
|
if ((option->flags & any_flags) == 0)
|
continue;
|
continue;
|
}
|
}
|
|
|
/* Skip unwanted switches. */
|
/* Skip unwanted switches. */
|
if ((option->flags & exclude_flags) != 0)
|
if ((option->flags & exclude_flags) != 0)
|
continue;
|
continue;
|
|
|
/* The driver currently prints its own help text. */
|
/* The driver currently prints its own help text. */
|
if ((option->flags & CL_DRIVER) != 0
|
if ((option->flags & CL_DRIVER) != 0
|
&& (option->flags & (((1U << cl_lang_count) - 1)
|
&& (option->flags & (((1U << cl_lang_count) - 1)
|
| CL_COMMON | CL_TARGET)) == 0)
|
| CL_COMMON | CL_TARGET)) == 0)
|
continue;
|
continue;
|
|
|
found = true;
|
found = true;
|
/* Skip switches that have already been printed. */
|
/* Skip switches that have already been printed. */
|
if (opts->x_help_printed[i])
|
if (opts->x_help_printed[i])
|
continue;
|
continue;
|
|
|
opts->x_help_printed[i] = true;
|
opts->x_help_printed[i] = true;
|
|
|
help = option->help;
|
help = option->help;
|
if (help == NULL)
|
if (help == NULL)
|
{
|
{
|
if (exclude_flags & CL_UNDOCUMENTED)
|
if (exclude_flags & CL_UNDOCUMENTED)
|
continue;
|
continue;
|
help = undocumented_msg;
|
help = undocumented_msg;
|
}
|
}
|
|
|
/* Get the translation. */
|
/* Get the translation. */
|
help = _(help);
|
help = _(help);
|
|
|
/* Find the gap between the name of the
|
/* Find the gap between the name of the
|
option and its descriptive text. */
|
option and its descriptive text. */
|
tab = strchr (help, '\t');
|
tab = strchr (help, '\t');
|
if (tab)
|
if (tab)
|
{
|
{
|
len = tab - help;
|
len = tab - help;
|
opt = help;
|
opt = help;
|
help = tab + 1;
|
help = tab + 1;
|
}
|
}
|
else
|
else
|
{
|
{
|
opt = option->opt_text;
|
opt = option->opt_text;
|
len = strlen (opt);
|
len = strlen (opt);
|
}
|
}
|
|
|
/* With the -Q option enabled we change the descriptive text associated
|
/* With the -Q option enabled we change the descriptive text associated
|
with an option to be an indication of its current setting. */
|
with an option to be an indication of its current setting. */
|
if (!opts->x_quiet_flag)
|
if (!opts->x_quiet_flag)
|
{
|
{
|
void *flag_var = option_flag_var (i, opts);
|
void *flag_var = option_flag_var (i, opts);
|
|
|
if (len < (LEFT_COLUMN + 2))
|
if (len < (LEFT_COLUMN + 2))
|
strcpy (new_help, "\t\t");
|
strcpy (new_help, "\t\t");
|
else
|
else
|
strcpy (new_help, "\t");
|
strcpy (new_help, "\t");
|
|
|
if (flag_var != NULL
|
if (flag_var != NULL
|
&& option->var_type != CLVC_DEFER)
|
&& option->var_type != CLVC_DEFER)
|
{
|
{
|
if (option->flags & CL_JOINED)
|
if (option->flags & CL_JOINED)
|
{
|
{
|
if (option->var_type == CLVC_STRING)
|
if (option->var_type == CLVC_STRING)
|
{
|
{
|
if (* (const char **) flag_var != NULL)
|
if (* (const char **) flag_var != NULL)
|
snprintf (new_help + strlen (new_help),
|
snprintf (new_help + strlen (new_help),
|
sizeof (new_help) - strlen (new_help),
|
sizeof (new_help) - strlen (new_help),
|
* (const char **) flag_var);
|
* (const char **) flag_var);
|
}
|
}
|
else if (option->var_type == CLVC_ENUM)
|
else if (option->var_type == CLVC_ENUM)
|
{
|
{
|
const struct cl_enum *e = &cl_enums[option->var_enum];
|
const struct cl_enum *e = &cl_enums[option->var_enum];
|
int value;
|
int value;
|
const char *arg = NULL;
|
const char *arg = NULL;
|
|
|
value = e->get (flag_var);
|
value = e->get (flag_var);
|
enum_value_to_arg (e->values, &arg, value, lang_mask);
|
enum_value_to_arg (e->values, &arg, value, lang_mask);
|
if (arg == NULL)
|
if (arg == NULL)
|
arg = _("[default]");
|
arg = _("[default]");
|
snprintf (new_help + strlen (new_help),
|
snprintf (new_help + strlen (new_help),
|
sizeof (new_help) - strlen (new_help),
|
sizeof (new_help) - strlen (new_help),
|
arg);
|
arg);
|
}
|
}
|
else
|
else
|
sprintf (new_help + strlen (new_help),
|
sprintf (new_help + strlen (new_help),
|
"%#x", * (int *) flag_var);
|
"%#x", * (int *) flag_var);
|
}
|
}
|
else
|
else
|
strcat (new_help, option_enabled (i, opts)
|
strcat (new_help, option_enabled (i, opts)
|
? _("[enabled]") : _("[disabled]"));
|
? _("[enabled]") : _("[disabled]"));
|
}
|
}
|
|
|
help = new_help;
|
help = new_help;
|
}
|
}
|
|
|
wrap_help (help, opt, len, columns);
|
wrap_help (help, opt, len, columns);
|
displayed = true;
|
displayed = true;
|
|
|
if (option->var_type == CLVC_ENUM
|
if (option->var_type == CLVC_ENUM
|
&& opts->x_help_enum_printed[option->var_enum] != 2)
|
&& opts->x_help_enum_printed[option->var_enum] != 2)
|
opts->x_help_enum_printed[option->var_enum] = 1;
|
opts->x_help_enum_printed[option->var_enum] = 1;
|
}
|
}
|
|
|
if (! found)
|
if (! found)
|
{
|
{
|
unsigned int langs = include_flags & CL_LANG_ALL;
|
unsigned int langs = include_flags & CL_LANG_ALL;
|
|
|
if (langs == 0)
|
if (langs == 0)
|
printf (_(" No options with the desired characteristics were found\n"));
|
printf (_(" No options with the desired characteristics were found\n"));
|
else
|
else
|
{
|
{
|
unsigned int i;
|
unsigned int i;
|
|
|
/* PR 31349: Tell the user how to see all of the
|
/* PR 31349: Tell the user how to see all of the
|
options supported by a specific front end. */
|
options supported by a specific front end. */
|
for (i = 0; (1U << i) < CL_LANG_ALL; i ++)
|
for (i = 0; (1U << i) < CL_LANG_ALL; i ++)
|
if ((1U << i) & langs)
|
if ((1U << i) & langs)
|
printf (_(" None found. Use --help=%s to show *all* the options supported by the %s front-end\n"),
|
printf (_(" None found. Use --help=%s to show *all* the options supported by the %s front-end\n"),
|
lang_names[i], lang_names[i]);
|
lang_names[i], lang_names[i]);
|
}
|
}
|
|
|
}
|
}
|
else if (! displayed)
|
else if (! displayed)
|
printf (_(" All options with the desired characteristics have already been displayed\n"));
|
printf (_(" All options with the desired characteristics have already been displayed\n"));
|
|
|
putchar ('\n');
|
putchar ('\n');
|
|
|
/* Print details of enumerated option arguments, if those
|
/* Print details of enumerated option arguments, if those
|
enumerations have help text headings provided. If no help text
|
enumerations have help text headings provided. If no help text
|
is provided, presume that the possible values are listed in the
|
is provided, presume that the possible values are listed in the
|
help text for the relevant options. */
|
help text for the relevant options. */
|
for (i = 0; i < cl_enums_count; i++)
|
for (i = 0; i < cl_enums_count; i++)
|
{
|
{
|
unsigned int j, pos;
|
unsigned int j, pos;
|
|
|
if (opts->x_help_enum_printed[i] != 1)
|
if (opts->x_help_enum_printed[i] != 1)
|
continue;
|
continue;
|
if (cl_enums[i].help == NULL)
|
if (cl_enums[i].help == NULL)
|
continue;
|
continue;
|
printf (" %s\n ", _(cl_enums[i].help));
|
printf (" %s\n ", _(cl_enums[i].help));
|
pos = 4;
|
pos = 4;
|
for (j = 0; cl_enums[i].values[j].arg != NULL; j++)
|
for (j = 0; cl_enums[i].values[j].arg != NULL; j++)
|
{
|
{
|
unsigned int len = strlen (cl_enums[i].values[j].arg);
|
unsigned int len = strlen (cl_enums[i].values[j].arg);
|
|
|
if (pos > 4 && pos + 1 + len <= columns)
|
if (pos > 4 && pos + 1 + len <= columns)
|
{
|
{
|
printf (" %s", cl_enums[i].values[j].arg);
|
printf (" %s", cl_enums[i].values[j].arg);
|
pos += 1 + len;
|
pos += 1 + len;
|
}
|
}
|
else
|
else
|
{
|
{
|
if (pos > 4)
|
if (pos > 4)
|
{
|
{
|
printf ("\n ");
|
printf ("\n ");
|
pos = 4;
|
pos = 4;
|
}
|
}
|
printf ("%s", cl_enums[i].values[j].arg);
|
printf ("%s", cl_enums[i].values[j].arg);
|
pos += len;
|
pos += len;
|
}
|
}
|
}
|
}
|
printf ("\n\n");
|
printf ("\n\n");
|
opts->x_help_enum_printed[i] = 2;
|
opts->x_help_enum_printed[i] = 2;
|
}
|
}
|
}
|
}
|
|
|
/* Display help for a specified type of option.
|
/* Display help for a specified type of option.
|
The options must have ALL of the INCLUDE_FLAGS set
|
The options must have ALL of the INCLUDE_FLAGS set
|
ANY of the flags in the ANY_FLAGS set
|
ANY of the flags in the ANY_FLAGS set
|
and NONE of the EXCLUDE_FLAGS set. The current option state is in
|
and NONE of the EXCLUDE_FLAGS set. The current option state is in
|
OPTS; LANG_MASK is used for interpreting enumerated option state. */
|
OPTS; LANG_MASK is used for interpreting enumerated option state. */
|
static void
|
static void
|
print_specific_help (unsigned int include_flags,
|
print_specific_help (unsigned int include_flags,
|
unsigned int exclude_flags,
|
unsigned int exclude_flags,
|
unsigned int any_flags,
|
unsigned int any_flags,
|
struct gcc_options *opts,
|
struct gcc_options *opts,
|
unsigned int lang_mask)
|
unsigned int lang_mask)
|
{
|
{
|
unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
|
unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
|
const char * description = NULL;
|
const char * description = NULL;
|
const char * descrip_extra = "";
|
const char * descrip_extra = "";
|
size_t i;
|
size_t i;
|
unsigned int flag;
|
unsigned int flag;
|
|
|
/* Sanity check: Make sure that we do not have more
|
/* Sanity check: Make sure that we do not have more
|
languages than we have bits available to enumerate them. */
|
languages than we have bits available to enumerate them. */
|
gcc_assert ((1U << cl_lang_count) <= CL_MIN_OPTION_CLASS);
|
gcc_assert ((1U << cl_lang_count) <= CL_MIN_OPTION_CLASS);
|
|
|
/* If we have not done so already, obtain
|
/* If we have not done so already, obtain
|
the desired maximum width of the output. */
|
the desired maximum width of the output. */
|
if (opts->x_help_columns == 0)
|
if (opts->x_help_columns == 0)
|
{
|
{
|
const char *p;
|
const char *p;
|
|
|
p = getenv ("COLUMNS");
|
p = getenv ("COLUMNS");
|
if (p != NULL)
|
if (p != NULL)
|
{
|
{
|
int value = atoi (p);
|
int value = atoi (p);
|
|
|
if (value > 0)
|
if (value > 0)
|
opts->x_help_columns = value;
|
opts->x_help_columns = value;
|
}
|
}
|
|
|
if (opts->x_help_columns == 0)
|
if (opts->x_help_columns == 0)
|
/* Use a reasonable default. */
|
/* Use a reasonable default. */
|
opts->x_help_columns = 80;
|
opts->x_help_columns = 80;
|
}
|
}
|
|
|
/* Decide upon the title for the options that we are going to display. */
|
/* Decide upon the title for the options that we are going to display. */
|
for (i = 0, flag = 1; flag <= CL_MAX_OPTION_CLASS; flag <<= 1, i ++)
|
for (i = 0, flag = 1; flag <= CL_MAX_OPTION_CLASS; flag <<= 1, i ++)
|
{
|
{
|
switch (flag & include_flags)
|
switch (flag & include_flags)
|
{
|
{
|
case 0:
|
case 0:
|
case CL_DRIVER:
|
case CL_DRIVER:
|
break;
|
break;
|
|
|
case CL_TARGET:
|
case CL_TARGET:
|
description = _("The following options are target specific");
|
description = _("The following options are target specific");
|
break;
|
break;
|
case CL_WARNING:
|
case CL_WARNING:
|
description = _("The following options control compiler warning messages");
|
description = _("The following options control compiler warning messages");
|
break;
|
break;
|
case CL_OPTIMIZATION:
|
case CL_OPTIMIZATION:
|
description = _("The following options control optimizations");
|
description = _("The following options control optimizations");
|
break;
|
break;
|
case CL_COMMON:
|
case CL_COMMON:
|
description = _("The following options are language-independent");
|
description = _("The following options are language-independent");
|
break;
|
break;
|
case CL_PARAMS:
|
case CL_PARAMS:
|
description = _("The --param option recognizes the following as parameters");
|
description = _("The --param option recognizes the following as parameters");
|
break;
|
break;
|
default:
|
default:
|
if (i >= cl_lang_count)
|
if (i >= cl_lang_count)
|
break;
|
break;
|
if (exclude_flags & all_langs_mask)
|
if (exclude_flags & all_langs_mask)
|
description = _("The following options are specific to just the language ");
|
description = _("The following options are specific to just the language ");
|
else
|
else
|
description = _("The following options are supported by the language ");
|
description = _("The following options are supported by the language ");
|
descrip_extra = lang_names [i];
|
descrip_extra = lang_names [i];
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
if (description == NULL)
|
if (description == NULL)
|
{
|
{
|
if (any_flags == 0)
|
if (any_flags == 0)
|
{
|
{
|
if (include_flags & CL_UNDOCUMENTED)
|
if (include_flags & CL_UNDOCUMENTED)
|
description = _("The following options are not documented");
|
description = _("The following options are not documented");
|
else if (include_flags & CL_SEPARATE)
|
else if (include_flags & CL_SEPARATE)
|
description = _("The following options take separate arguments");
|
description = _("The following options take separate arguments");
|
else if (include_flags & CL_JOINED)
|
else if (include_flags & CL_JOINED)
|
description = _("The following options take joined arguments");
|
description = _("The following options take joined arguments");
|
else
|
else
|
{
|
{
|
internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
|
internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
|
include_flags);
|
include_flags);
|
return;
|
return;
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
if (any_flags & all_langs_mask)
|
if (any_flags & all_langs_mask)
|
description = _("The following options are language-related");
|
description = _("The following options are language-related");
|
else
|
else
|
description = _("The following options are language-independent");
|
description = _("The following options are language-independent");
|
}
|
}
|
}
|
}
|
|
|
printf ("%s%s:\n", description, descrip_extra);
|
printf ("%s%s:\n", description, descrip_extra);
|
print_filtered_help (include_flags, exclude_flags, any_flags,
|
print_filtered_help (include_flags, exclude_flags, any_flags,
|
opts->x_help_columns, opts, lang_mask);
|
opts->x_help_columns, opts, lang_mask);
|
}
|
}
|
|
|
/* Handle target- and language-independent options. Return zero to
|
/* Handle target- and language-independent options. Return zero to
|
generate an "unknown option" message. Only options that need
|
generate an "unknown option" message. Only options that need
|
extra handling need to be listed here; if you simply want
|
extra handling need to be listed here; if you simply want
|
DECODED->value assigned to a variable, it happens automatically. */
|
DECODED->value assigned to a variable, it happens automatically. */
|
|
|
bool
|
bool
|
common_handle_option (struct gcc_options *opts,
|
common_handle_option (struct gcc_options *opts,
|
struct gcc_options *opts_set,
|
struct gcc_options *opts_set,
|
const struct cl_decoded_option *decoded,
|
const struct cl_decoded_option *decoded,
|
unsigned int lang_mask, int kind ATTRIBUTE_UNUSED,
|
unsigned int lang_mask, int kind ATTRIBUTE_UNUSED,
|
location_t loc,
|
location_t loc,
|
const struct cl_option_handlers *handlers,
|
const struct cl_option_handlers *handlers,
|
diagnostic_context *dc)
|
diagnostic_context *dc)
|
{
|
{
|
size_t scode = decoded->opt_index;
|
size_t scode = decoded->opt_index;
|
const char *arg = decoded->arg;
|
const char *arg = decoded->arg;
|
int value = decoded->value;
|
int value = decoded->value;
|
enum opt_code code = (enum opt_code) scode;
|
enum opt_code code = (enum opt_code) scode;
|
|
|
gcc_assert (decoded->canonical_option_num_elements <= 2);
|
gcc_assert (decoded->canonical_option_num_elements <= 2);
|
|
|
switch (code)
|
switch (code)
|
{
|
{
|
case OPT__param:
|
case OPT__param:
|
handle_param (opts, opts_set, loc, arg);
|
handle_param (opts, opts_set, loc, arg);
|
break;
|
break;
|
|
|
case OPT__help:
|
case OPT__help:
|
{
|
{
|
unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
|
unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
|
unsigned int undoc_mask;
|
unsigned int undoc_mask;
|
unsigned int i;
|
unsigned int i;
|
|
|
if (lang_mask == CL_DRIVER)
|
if (lang_mask == CL_DRIVER)
|
break;;
|
break;;
|
|
|
undoc_mask = ((opts->x_verbose_flag | opts->x_extra_warnings)
|
undoc_mask = ((opts->x_verbose_flag | opts->x_extra_warnings)
|
? 0
|
? 0
|
: CL_UNDOCUMENTED);
|
: CL_UNDOCUMENTED);
|
/* First display any single language specific options. */
|
/* First display any single language specific options. */
|
for (i = 0; i < cl_lang_count; i++)
|
for (i = 0; i < cl_lang_count; i++)
|
print_specific_help
|
print_specific_help
|
(1U << i, (all_langs_mask & (~ (1U << i))) | undoc_mask, 0, opts,
|
(1U << i, (all_langs_mask & (~ (1U << i))) | undoc_mask, 0, opts,
|
lang_mask);
|
lang_mask);
|
/* Next display any multi language specific options. */
|
/* Next display any multi language specific options. */
|
print_specific_help (0, undoc_mask, all_langs_mask, opts, lang_mask);
|
print_specific_help (0, undoc_mask, all_langs_mask, opts, lang_mask);
|
/* Then display any remaining, non-language options. */
|
/* Then display any remaining, non-language options. */
|
for (i = CL_MIN_OPTION_CLASS; i <= CL_MAX_OPTION_CLASS; i <<= 1)
|
for (i = CL_MIN_OPTION_CLASS; i <= CL_MAX_OPTION_CLASS; i <<= 1)
|
if (i != CL_DRIVER)
|
if (i != CL_DRIVER)
|
print_specific_help (i, undoc_mask, 0, opts, lang_mask);
|
print_specific_help (i, undoc_mask, 0, opts, lang_mask);
|
opts->x_exit_after_options = true;
|
opts->x_exit_after_options = true;
|
break;
|
break;
|
}
|
}
|
|
|
case OPT__target_help:
|
case OPT__target_help:
|
if (lang_mask == CL_DRIVER)
|
if (lang_mask == CL_DRIVER)
|
break;
|
break;
|
|
|
print_specific_help (CL_TARGET, CL_UNDOCUMENTED, 0, opts, lang_mask);
|
print_specific_help (CL_TARGET, CL_UNDOCUMENTED, 0, opts, lang_mask);
|
opts->x_exit_after_options = true;
|
opts->x_exit_after_options = true;
|
break;
|
break;
|
|
|
case OPT__help_:
|
case OPT__help_:
|
{
|
{
|
const char * a = arg;
|
const char * a = arg;
|
unsigned int include_flags = 0;
|
unsigned int include_flags = 0;
|
/* Note - by default we include undocumented options when listing
|
/* Note - by default we include undocumented options when listing
|
specific classes. If you only want to see documented options
|
specific classes. If you only want to see documented options
|
then add ",^undocumented" to the --help= option. E.g.:
|
then add ",^undocumented" to the --help= option. E.g.:
|
|
|
--help=target,^undocumented */
|
--help=target,^undocumented */
|
unsigned int exclude_flags = 0;
|
unsigned int exclude_flags = 0;
|
|
|
if (lang_mask == CL_DRIVER)
|
if (lang_mask == CL_DRIVER)
|
break;
|
break;
|
|
|
/* Walk along the argument string, parsing each word in turn.
|
/* Walk along the argument string, parsing each word in turn.
|
The format is:
|
The format is:
|
arg = [^]{word}[,{arg}]
|
arg = [^]{word}[,{arg}]
|
word = {optimizers|target|warnings|undocumented|
|
word = {optimizers|target|warnings|undocumented|
|
params|common|<language>} */
|
params|common|<language>} */
|
while (* a != 0)
|
while (* a != 0)
|
{
|
{
|
static const struct
|
static const struct
|
{
|
{
|
const char * string;
|
const char * string;
|
unsigned int flag;
|
unsigned int flag;
|
}
|
}
|
specifics[] =
|
specifics[] =
|
{
|
{
|
{ "optimizers", CL_OPTIMIZATION },
|
{ "optimizers", CL_OPTIMIZATION },
|
{ "target", CL_TARGET },
|
{ "target", CL_TARGET },
|
{ "warnings", CL_WARNING },
|
{ "warnings", CL_WARNING },
|
{ "undocumented", CL_UNDOCUMENTED },
|
{ "undocumented", CL_UNDOCUMENTED },
|
{ "params", CL_PARAMS },
|
{ "params", CL_PARAMS },
|
{ "joined", CL_JOINED },
|
{ "joined", CL_JOINED },
|
{ "separate", CL_SEPARATE },
|
{ "separate", CL_SEPARATE },
|
{ "common", CL_COMMON },
|
{ "common", CL_COMMON },
|
{ NULL, 0 }
|
{ NULL, 0 }
|
};
|
};
|
unsigned int * pflags;
|
unsigned int * pflags;
|
const char * comma;
|
const char * comma;
|
unsigned int lang_flag, specific_flag;
|
unsigned int lang_flag, specific_flag;
|
unsigned int len;
|
unsigned int len;
|
unsigned int i;
|
unsigned int i;
|
|
|
if (* a == '^')
|
if (* a == '^')
|
{
|
{
|
++ a;
|
++ a;
|
pflags = & exclude_flags;
|
pflags = & exclude_flags;
|
}
|
}
|
else
|
else
|
pflags = & include_flags;
|
pflags = & include_flags;
|
|
|
comma = strchr (a, ',');
|
comma = strchr (a, ',');
|
if (comma == NULL)
|
if (comma == NULL)
|
len = strlen (a);
|
len = strlen (a);
|
else
|
else
|
len = comma - a;
|
len = comma - a;
|
if (len == 0)
|
if (len == 0)
|
{
|
{
|
a = comma + 1;
|
a = comma + 1;
|
continue;
|
continue;
|
}
|
}
|
|
|
/* Check to see if the string matches an option class name. */
|
/* Check to see if the string matches an option class name. */
|
for (i = 0, specific_flag = 0; specifics[i].string != NULL; i++)
|
for (i = 0, specific_flag = 0; specifics[i].string != NULL; i++)
|
if (strncasecmp (a, specifics[i].string, len) == 0)
|
if (strncasecmp (a, specifics[i].string, len) == 0)
|
{
|
{
|
specific_flag = specifics[i].flag;
|
specific_flag = specifics[i].flag;
|
break;
|
break;
|
}
|
}
|
|
|
/* Check to see if the string matches a language name.
|
/* Check to see if the string matches a language name.
|
Note - we rely upon the alpha-sorted nature of the entries in
|
Note - we rely upon the alpha-sorted nature of the entries in
|
the lang_names array, specifically that shorter names appear
|
the lang_names array, specifically that shorter names appear
|
before their longer variants. (i.e. C before C++). That way
|
before their longer variants. (i.e. C before C++). That way
|
when we are attempting to match --help=c for example we will
|
when we are attempting to match --help=c for example we will
|
match with C first and not C++. */
|
match with C first and not C++. */
|
for (i = 0, lang_flag = 0; i < cl_lang_count; i++)
|
for (i = 0, lang_flag = 0; i < cl_lang_count; i++)
|
if (strncasecmp (a, lang_names[i], len) == 0)
|
if (strncasecmp (a, lang_names[i], len) == 0)
|
{
|
{
|
lang_flag = 1U << i;
|
lang_flag = 1U << i;
|
break;
|
break;
|
}
|
}
|
|
|
if (specific_flag != 0)
|
if (specific_flag != 0)
|
{
|
{
|
if (lang_flag == 0)
|
if (lang_flag == 0)
|
* pflags |= specific_flag;
|
* pflags |= specific_flag;
|
else
|
else
|
{
|
{
|
/* The option's argument matches both the start of a
|
/* The option's argument matches both the start of a
|
language name and the start of an option class name.
|
language name and the start of an option class name.
|
We have a special case for when the user has
|
We have a special case for when the user has
|
specified "--help=c", but otherwise we have to issue
|
specified "--help=c", but otherwise we have to issue
|
a warning. */
|
a warning. */
|
if (strncasecmp (a, "c", len) == 0)
|
if (strncasecmp (a, "c", len) == 0)
|
* pflags |= lang_flag;
|
* pflags |= lang_flag;
|
else
|
else
|
warning_at (loc, 0,
|
warning_at (loc, 0,
|
"--help argument %q.*s is ambiguous, "
|
"--help argument %q.*s is ambiguous, "
|
"please be more specific",
|
"please be more specific",
|
len, a);
|
len, a);
|
}
|
}
|
}
|
}
|
else if (lang_flag != 0)
|
else if (lang_flag != 0)
|
* pflags |= lang_flag;
|
* pflags |= lang_flag;
|
else
|
else
|
warning_at (loc, 0,
|
warning_at (loc, 0,
|
"unrecognized argument to --help= option: %q.*s",
|
"unrecognized argument to --help= option: %q.*s",
|
len, a);
|
len, a);
|
|
|
if (comma == NULL)
|
if (comma == NULL)
|
break;
|
break;
|
a = comma + 1;
|
a = comma + 1;
|
}
|
}
|
|
|
if (include_flags)
|
if (include_flags)
|
print_specific_help (include_flags, exclude_flags, 0, opts,
|
print_specific_help (include_flags, exclude_flags, 0, opts,
|
lang_mask);
|
lang_mask);
|
opts->x_exit_after_options = true;
|
opts->x_exit_after_options = true;
|
break;
|
break;
|
}
|
}
|
|
|
case OPT__version:
|
case OPT__version:
|
if (lang_mask == CL_DRIVER)
|
if (lang_mask == CL_DRIVER)
|
break;
|
break;
|
|
|
opts->x_exit_after_options = true;
|
opts->x_exit_after_options = true;
|
break;
|
break;
|
|
|
case OPT_O:
|
case OPT_O:
|
case OPT_Os:
|
case OPT_Os:
|
case OPT_Ofast:
|
case OPT_Ofast:
|
/* Currently handled in a prescan. */
|
/* Currently handled in a prescan. */
|
break;
|
break;
|
|
|
case OPT_Werror:
|
case OPT_Werror:
|
dc->warning_as_error_requested = value;
|
dc->warning_as_error_requested = value;
|
break;
|
break;
|
|
|
case OPT_Werror_:
|
case OPT_Werror_:
|
if (lang_mask == CL_DRIVER)
|
if (lang_mask == CL_DRIVER)
|
break;
|
break;
|
|
|
enable_warning_as_error (arg, value, lang_mask, handlers,
|
enable_warning_as_error (arg, value, lang_mask, handlers,
|
opts, opts_set, loc, dc);
|
opts, opts_set, loc, dc);
|
break;
|
break;
|
|
|
case OPT_Wlarger_than_:
|
case OPT_Wlarger_than_:
|
opts->x_larger_than_size = value;
|
opts->x_larger_than_size = value;
|
opts->x_warn_larger_than = value != -1;
|
opts->x_warn_larger_than = value != -1;
|
break;
|
break;
|
|
|
case OPT_Wfatal_errors:
|
case OPT_Wfatal_errors:
|
dc->fatal_errors = value;
|
dc->fatal_errors = value;
|
break;
|
break;
|
|
|
case OPT_Wframe_larger_than_:
|
case OPT_Wframe_larger_than_:
|
opts->x_frame_larger_than_size = value;
|
opts->x_frame_larger_than_size = value;
|
opts->x_warn_frame_larger_than = value != -1;
|
opts->x_warn_frame_larger_than = value != -1;
|
break;
|
break;
|
|
|
case OPT_Wstack_usage_:
|
case OPT_Wstack_usage_:
|
opts->x_warn_stack_usage = value;
|
opts->x_warn_stack_usage = value;
|
opts->x_flag_stack_usage_info = value != -1;
|
opts->x_flag_stack_usage_info = value != -1;
|
break;
|
break;
|
|
|
case OPT_Wstrict_aliasing:
|
case OPT_Wstrict_aliasing:
|
set_Wstrict_aliasing (opts, value);
|
set_Wstrict_aliasing (opts, value);
|
break;
|
break;
|
|
|
case OPT_Wstrict_overflow:
|
case OPT_Wstrict_overflow:
|
opts->x_warn_strict_overflow = (value
|
opts->x_warn_strict_overflow = (value
|
? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
|
? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
|
: 0);
|
: 0);
|
break;
|
break;
|
|
|
case OPT_Wsystem_headers:
|
case OPT_Wsystem_headers:
|
dc->dc_warn_system_headers = value;
|
dc->dc_warn_system_headers = value;
|
break;
|
break;
|
|
|
case OPT_aux_info:
|
case OPT_aux_info:
|
opts->x_flag_gen_aux_info = 1;
|
opts->x_flag_gen_aux_info = 1;
|
break;
|
break;
|
|
|
case OPT_auxbase_strip:
|
case OPT_auxbase_strip:
|
{
|
{
|
char *tmp = xstrdup (arg);
|
char *tmp = xstrdup (arg);
|
strip_off_ending (tmp, strlen (tmp));
|
strip_off_ending (tmp, strlen (tmp));
|
if (tmp[0])
|
if (tmp[0])
|
opts->x_aux_base_name = tmp;
|
opts->x_aux_base_name = tmp;
|
}
|
}
|
break;
|
break;
|
|
|
case OPT_d:
|
case OPT_d:
|
decode_d_option (arg, opts, loc, dc);
|
decode_d_option (arg, opts, loc, dc);
|
break;
|
break;
|
|
|
case OPT_fcall_used_:
|
case OPT_fcall_used_:
|
case OPT_fcall_saved_:
|
case OPT_fcall_saved_:
|
/* Deferred. */
|
/* Deferred. */
|
break;
|
break;
|
|
|
case OPT_fdbg_cnt_:
|
case OPT_fdbg_cnt_:
|
case OPT_fdbg_cnt_list:
|
case OPT_fdbg_cnt_list:
|
/* Deferred. */
|
/* Deferred. */
|
break;
|
break;
|
|
|
case OPT_fdebug_prefix_map_:
|
case OPT_fdebug_prefix_map_:
|
/* Deferred. */
|
/* Deferred. */
|
break;
|
break;
|
|
|
case OPT_fdiagnostics_show_location_:
|
case OPT_fdiagnostics_show_location_:
|
diagnostic_prefixing_rule (dc) = (diagnostic_prefixing_rule_t) value;
|
diagnostic_prefixing_rule (dc) = (diagnostic_prefixing_rule_t) value;
|
break;
|
break;
|
|
|
case OPT_fdiagnostics_show_option:
|
case OPT_fdiagnostics_show_option:
|
dc->show_option_requested = value;
|
dc->show_option_requested = value;
|
break;
|
break;
|
|
|
case OPT_fdump_:
|
case OPT_fdump_:
|
/* Deferred. */
|
/* Deferred. */
|
break;
|
break;
|
|
|
case OPT_ffast_math:
|
case OPT_ffast_math:
|
set_fast_math_flags (opts, value);
|
set_fast_math_flags (opts, value);
|
break;
|
break;
|
|
|
case OPT_funsafe_math_optimizations:
|
case OPT_funsafe_math_optimizations:
|
set_unsafe_math_optimizations_flags (opts, value);
|
set_unsafe_math_optimizations_flags (opts, value);
|
break;
|
break;
|
|
|
case OPT_ffixed_:
|
case OPT_ffixed_:
|
/* Deferred. */
|
/* Deferred. */
|
break;
|
break;
|
|
|
case OPT_finline_limit_:
|
case OPT_finline_limit_:
|
set_param_value ("max-inline-insns-single", value / 2,
|
set_param_value ("max-inline-insns-single", value / 2,
|
opts->x_param_values, opts_set->x_param_values);
|
opts->x_param_values, opts_set->x_param_values);
|
set_param_value ("max-inline-insns-auto", value / 2,
|
set_param_value ("max-inline-insns-auto", value / 2,
|
opts->x_param_values, opts_set->x_param_values);
|
opts->x_param_values, opts_set->x_param_values);
|
break;
|
break;
|
|
|
case OPT_finstrument_functions_exclude_function_list_:
|
case OPT_finstrument_functions_exclude_function_list_:
|
add_comma_separated_to_vector
|
add_comma_separated_to_vector
|
(&opts->x_flag_instrument_functions_exclude_functions, arg);
|
(&opts->x_flag_instrument_functions_exclude_functions, arg);
|
break;
|
break;
|
|
|
case OPT_finstrument_functions_exclude_file_list_:
|
case OPT_finstrument_functions_exclude_file_list_:
|
add_comma_separated_to_vector
|
add_comma_separated_to_vector
|
(&opts->x_flag_instrument_functions_exclude_files, arg);
|
(&opts->x_flag_instrument_functions_exclude_files, arg);
|
break;
|
break;
|
|
|
case OPT_fmessage_length_:
|
case OPT_fmessage_length_:
|
pp_set_line_maximum_length (dc->printer, value);
|
pp_set_line_maximum_length (dc->printer, value);
|
break;
|
break;
|
|
|
case OPT_fpack_struct_:
|
case OPT_fpack_struct_:
|
if (value <= 0 || (value & (value - 1)) || value > 16)
|
if (value <= 0 || (value & (value - 1)) || value > 16)
|
error_at (loc,
|
error_at (loc,
|
"structure alignment must be a small power of two, not %d",
|
"structure alignment must be a small power of two, not %d",
|
value);
|
value);
|
else
|
else
|
opts->x_initial_max_fld_align = value;
|
opts->x_initial_max_fld_align = value;
|
break;
|
break;
|
|
|
case OPT_fplugin_:
|
case OPT_fplugin_:
|
case OPT_fplugin_arg_:
|
case OPT_fplugin_arg_:
|
/* Deferred. */
|
/* Deferred. */
|
break;
|
break;
|
|
|
case OPT_fprofile_use_:
|
case OPT_fprofile_use_:
|
opts->x_profile_data_prefix = xstrdup (arg);
|
opts->x_profile_data_prefix = xstrdup (arg);
|
opts->x_flag_profile_use = true;
|
opts->x_flag_profile_use = true;
|
value = true;
|
value = true;
|
/* No break here - do -fprofile-use processing. */
|
/* No break here - do -fprofile-use processing. */
|
case OPT_fprofile_use:
|
case OPT_fprofile_use:
|
if (!opts_set->x_flag_branch_probabilities)
|
if (!opts_set->x_flag_branch_probabilities)
|
opts->x_flag_branch_probabilities = value;
|
opts->x_flag_branch_probabilities = value;
|
if (!opts_set->x_flag_profile_values)
|
if (!opts_set->x_flag_profile_values)
|
opts->x_flag_profile_values = value;
|
opts->x_flag_profile_values = value;
|
if (!opts_set->x_flag_unroll_loops)
|
if (!opts_set->x_flag_unroll_loops)
|
opts->x_flag_unroll_loops = value;
|
opts->x_flag_unroll_loops = value;
|
if (!opts_set->x_flag_peel_loops)
|
if (!opts_set->x_flag_peel_loops)
|
opts->x_flag_peel_loops = value;
|
opts->x_flag_peel_loops = value;
|
if (!opts_set->x_flag_tracer)
|
if (!opts_set->x_flag_tracer)
|
opts->x_flag_tracer = value;
|
opts->x_flag_tracer = value;
|
if (!opts_set->x_flag_value_profile_transformations)
|
if (!opts_set->x_flag_value_profile_transformations)
|
opts->x_flag_value_profile_transformations = value;
|
opts->x_flag_value_profile_transformations = value;
|
if (!opts_set->x_flag_inline_functions)
|
if (!opts_set->x_flag_inline_functions)
|
opts->x_flag_inline_functions = value;
|
opts->x_flag_inline_functions = value;
|
if (!opts_set->x_flag_ipa_cp)
|
if (!opts_set->x_flag_ipa_cp)
|
opts->x_flag_ipa_cp = value;
|
opts->x_flag_ipa_cp = value;
|
if (!opts_set->x_flag_ipa_cp_clone
|
if (!opts_set->x_flag_ipa_cp_clone
|
&& value && opts->x_flag_ipa_cp)
|
&& value && opts->x_flag_ipa_cp)
|
opts->x_flag_ipa_cp_clone = value;
|
opts->x_flag_ipa_cp_clone = value;
|
if (!opts_set->x_flag_predictive_commoning)
|
if (!opts_set->x_flag_predictive_commoning)
|
opts->x_flag_predictive_commoning = value;
|
opts->x_flag_predictive_commoning = value;
|
if (!opts_set->x_flag_unswitch_loops)
|
if (!opts_set->x_flag_unswitch_loops)
|
opts->x_flag_unswitch_loops = value;
|
opts->x_flag_unswitch_loops = value;
|
if (!opts_set->x_flag_gcse_after_reload)
|
if (!opts_set->x_flag_gcse_after_reload)
|
opts->x_flag_gcse_after_reload = value;
|
opts->x_flag_gcse_after_reload = value;
|
break;
|
break;
|
|
|
case OPT_fprofile_generate_:
|
case OPT_fprofile_generate_:
|
opts->x_profile_data_prefix = xstrdup (arg);
|
opts->x_profile_data_prefix = xstrdup (arg);
|
value = true;
|
value = true;
|
/* No break here - do -fprofile-generate processing. */
|
/* No break here - do -fprofile-generate processing. */
|
case OPT_fprofile_generate:
|
case OPT_fprofile_generate:
|
if (!opts_set->x_profile_arc_flag)
|
if (!opts_set->x_profile_arc_flag)
|
opts->x_profile_arc_flag = value;
|
opts->x_profile_arc_flag = value;
|
if (!opts_set->x_flag_profile_values)
|
if (!opts_set->x_flag_profile_values)
|
opts->x_flag_profile_values = value;
|
opts->x_flag_profile_values = value;
|
if (!opts_set->x_flag_value_profile_transformations)
|
if (!opts_set->x_flag_value_profile_transformations)
|
opts->x_flag_value_profile_transformations = value;
|
opts->x_flag_value_profile_transformations = value;
|
if (!opts_set->x_flag_inline_functions)
|
if (!opts_set->x_flag_inline_functions)
|
opts->x_flag_inline_functions = value;
|
opts->x_flag_inline_functions = value;
|
/* FIXME: Instrumentation we insert makes ipa-reference bitmaps
|
/* FIXME: Instrumentation we insert makes ipa-reference bitmaps
|
quadratic. Disable the pass until better memory representation
|
quadratic. Disable the pass until better memory representation
|
is done. */
|
is done. */
|
if (!opts_set->x_flag_ipa_reference && opts->x_in_lto_p)
|
if (!opts_set->x_flag_ipa_reference && opts->x_in_lto_p)
|
opts->x_flag_ipa_reference = false;
|
opts->x_flag_ipa_reference = false;
|
break;
|
break;
|
|
|
case OPT_fshow_column:
|
case OPT_fshow_column:
|
dc->show_column = value;
|
dc->show_column = value;
|
break;
|
break;
|
|
|
case OPT_frandom_seed:
|
case OPT_frandom_seed:
|
/* The real switch is -fno-random-seed. */
|
/* The real switch is -fno-random-seed. */
|
if (value)
|
if (value)
|
return false;
|
return false;
|
/* Deferred. */
|
/* Deferred. */
|
break;
|
break;
|
|
|
case OPT_frandom_seed_:
|
case OPT_frandom_seed_:
|
/* Deferred. */
|
/* Deferred. */
|
break;
|
break;
|
|
|
case OPT_fsched_verbose_:
|
case OPT_fsched_verbose_:
|
#ifdef INSN_SCHEDULING
|
#ifdef INSN_SCHEDULING
|
/* Handled with Var in common.opt. */
|
/* Handled with Var in common.opt. */
|
break;
|
break;
|
#else
|
#else
|
return false;
|
return false;
|
#endif
|
#endif
|
|
|
case OPT_fsched_stalled_insns_:
|
case OPT_fsched_stalled_insns_:
|
opts->x_flag_sched_stalled_insns = value;
|
opts->x_flag_sched_stalled_insns = value;
|
if (opts->x_flag_sched_stalled_insns == 0)
|
if (opts->x_flag_sched_stalled_insns == 0)
|
opts->x_flag_sched_stalled_insns = -1;
|
opts->x_flag_sched_stalled_insns = -1;
|
break;
|
break;
|
|
|
case OPT_fsched_stalled_insns_dep_:
|
case OPT_fsched_stalled_insns_dep_:
|
opts->x_flag_sched_stalled_insns_dep = value;
|
opts->x_flag_sched_stalled_insns_dep = value;
|
break;
|
break;
|
|
|
case OPT_fstack_check_:
|
case OPT_fstack_check_:
|
if (!strcmp (arg, "no"))
|
if (!strcmp (arg, "no"))
|
opts->x_flag_stack_check = NO_STACK_CHECK;
|
opts->x_flag_stack_check = NO_STACK_CHECK;
|
else if (!strcmp (arg, "generic"))
|
else if (!strcmp (arg, "generic"))
|
/* This is the old stack checking method. */
|
/* This is the old stack checking method. */
|
opts->x_flag_stack_check = STACK_CHECK_BUILTIN
|
opts->x_flag_stack_check = STACK_CHECK_BUILTIN
|
? FULL_BUILTIN_STACK_CHECK
|
? FULL_BUILTIN_STACK_CHECK
|
: GENERIC_STACK_CHECK;
|
: GENERIC_STACK_CHECK;
|
else if (!strcmp (arg, "specific"))
|
else if (!strcmp (arg, "specific"))
|
/* This is the new stack checking method. */
|
/* This is the new stack checking method. */
|
opts->x_flag_stack_check = STACK_CHECK_BUILTIN
|
opts->x_flag_stack_check = STACK_CHECK_BUILTIN
|
? FULL_BUILTIN_STACK_CHECK
|
? FULL_BUILTIN_STACK_CHECK
|
: STACK_CHECK_STATIC_BUILTIN
|
: STACK_CHECK_STATIC_BUILTIN
|
? STATIC_BUILTIN_STACK_CHECK
|
? STATIC_BUILTIN_STACK_CHECK
|
: GENERIC_STACK_CHECK;
|
: GENERIC_STACK_CHECK;
|
else
|
else
|
warning_at (loc, 0, "unknown stack check parameter \"%s\"", arg);
|
warning_at (loc, 0, "unknown stack check parameter \"%s\"", arg);
|
break;
|
break;
|
|
|
case OPT_fstack_limit:
|
case OPT_fstack_limit:
|
/* The real switch is -fno-stack-limit. */
|
/* The real switch is -fno-stack-limit. */
|
if (value)
|
if (value)
|
return false;
|
return false;
|
/* Deferred. */
|
/* Deferred. */
|
break;
|
break;
|
|
|
case OPT_fstack_limit_register_:
|
case OPT_fstack_limit_register_:
|
case OPT_fstack_limit_symbol_:
|
case OPT_fstack_limit_symbol_:
|
/* Deferred. */
|
/* Deferred. */
|
break;
|
break;
|
|
|
case OPT_fstack_usage:
|
case OPT_fstack_usage:
|
opts->x_flag_stack_usage = value;
|
opts->x_flag_stack_usage = value;
|
opts->x_flag_stack_usage_info = value != 0;
|
opts->x_flag_stack_usage_info = value != 0;
|
break;
|
break;
|
|
|
case OPT_ftree_vectorizer_verbose_:
|
case OPT_ftree_vectorizer_verbose_:
|
vect_set_verbosity_level (opts, value);
|
vect_set_verbosity_level (opts, value);
|
break;
|
break;
|
|
|
case OPT_g:
|
case OPT_g:
|
set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg, opts, opts_set,
|
set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg, opts, opts_set,
|
loc);
|
loc);
|
break;
|
break;
|
|
|
case OPT_gcoff:
|
case OPT_gcoff:
|
set_debug_level (SDB_DEBUG, false, arg, opts, opts_set, loc);
|
set_debug_level (SDB_DEBUG, false, arg, opts, opts_set, loc);
|
break;
|
break;
|
|
|
case OPT_gdwarf_:
|
case OPT_gdwarf_:
|
if (value < 2 || value > 4)
|
if (value < 2 || value > 4)
|
error_at (loc, "dwarf version %d is not supported", value);
|
error_at (loc, "dwarf version %d is not supported", value);
|
else
|
else
|
opts->x_dwarf_version = value;
|
opts->x_dwarf_version = value;
|
set_debug_level (DWARF2_DEBUG, false, "", opts, opts_set, loc);
|
set_debug_level (DWARF2_DEBUG, false, "", opts, opts_set, loc);
|
break;
|
break;
|
|
|
case OPT_ggdb:
|
case OPT_ggdb:
|
set_debug_level (NO_DEBUG, 2, arg, opts, opts_set, loc);
|
set_debug_level (NO_DEBUG, 2, arg, opts, opts_set, loc);
|
break;
|
break;
|
|
|
case OPT_gstabs:
|
case OPT_gstabs:
|
case OPT_gstabs_:
|
case OPT_gstabs_:
|
set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg, opts, opts_set,
|
set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg, opts, opts_set,
|
loc);
|
loc);
|
break;
|
break;
|
|
|
case OPT_gvms:
|
case OPT_gvms:
|
set_debug_level (VMS_DEBUG, false, arg, opts, opts_set, loc);
|
set_debug_level (VMS_DEBUG, false, arg, opts, opts_set, loc);
|
break;
|
break;
|
|
|
case OPT_gxcoff:
|
case OPT_gxcoff:
|
case OPT_gxcoff_:
|
case OPT_gxcoff_:
|
set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg, opts, opts_set,
|
set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg, opts, opts_set,
|
loc);
|
loc);
|
break;
|
break;
|
|
|
case OPT_pedantic_errors:
|
case OPT_pedantic_errors:
|
opts->x_pedantic = 1;
|
opts->x_pedantic = 1;
|
dc->pedantic_errors = 1;
|
dc->pedantic_errors = 1;
|
break;
|
break;
|
|
|
case OPT_flto:
|
case OPT_flto:
|
opts->x_flag_lto = value ? "" : NULL;
|
opts->x_flag_lto = value ? "" : NULL;
|
break;
|
break;
|
|
|
case OPT_w:
|
case OPT_w:
|
dc->dc_inhibit_warnings = true;
|
dc->dc_inhibit_warnings = true;
|
break;
|
break;
|
|
|
case OPT_fmax_errors_:
|
case OPT_fmax_errors_:
|
dc->max_errors = value;
|
dc->max_errors = value;
|
break;
|
break;
|
|
|
case OPT_fuse_linker_plugin:
|
case OPT_fuse_linker_plugin:
|
/* No-op. Used by the driver and passed to us because it starts with f.*/
|
/* No-op. Used by the driver and passed to us because it starts with f.*/
|
break;
|
break;
|
|
|
case OPT_Wuninitialized:
|
case OPT_Wuninitialized:
|
/* Also turn on maybe uninitialized warning. */
|
/* Also turn on maybe uninitialized warning. */
|
opts->x_warn_maybe_uninitialized = value;
|
opts->x_warn_maybe_uninitialized = value;
|
break;
|
break;
|
|
|
default:
|
default:
|
/* If the flag was handled in a standard way, assume the lack of
|
/* If the flag was handled in a standard way, assume the lack of
|
processing here is intentional. */
|
processing here is intentional. */
|
gcc_assert (option_flag_var (scode, opts));
|
gcc_assert (option_flag_var (scode, opts));
|
break;
|
break;
|
}
|
}
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Handle --param NAME=VALUE. */
|
/* Handle --param NAME=VALUE. */
|
static void
|
static void
|
handle_param (struct gcc_options *opts, struct gcc_options *opts_set,
|
handle_param (struct gcc_options *opts, struct gcc_options *opts_set,
|
location_t loc, const char *carg)
|
location_t loc, const char *carg)
|
{
|
{
|
char *equal, *arg;
|
char *equal, *arg;
|
int value;
|
int value;
|
|
|
arg = xstrdup (carg);
|
arg = xstrdup (carg);
|
equal = strchr (arg, '=');
|
equal = strchr (arg, '=');
|
if (!equal)
|
if (!equal)
|
error_at (loc, "%s: --param arguments should be of the form NAME=VALUE",
|
error_at (loc, "%s: --param arguments should be of the form NAME=VALUE",
|
arg);
|
arg);
|
else
|
else
|
{
|
{
|
value = integral_argument (equal + 1);
|
value = integral_argument (equal + 1);
|
if (value == -1)
|
if (value == -1)
|
error_at (loc, "invalid --param value %qs", equal + 1);
|
error_at (loc, "invalid --param value %qs", equal + 1);
|
else
|
else
|
{
|
{
|
*equal = '\0';
|
*equal = '\0';
|
set_param_value (arg, value,
|
set_param_value (arg, value,
|
opts->x_param_values, opts_set->x_param_values);
|
opts->x_param_values, opts_set->x_param_values);
|
}
|
}
|
}
|
}
|
|
|
free (arg);
|
free (arg);
|
}
|
}
|
|
|
/* Used to set the level of strict aliasing warnings in OPTS,
|
/* Used to set the level of strict aliasing warnings in OPTS,
|
when no level is specified (i.e., when -Wstrict-aliasing, and not
|
when no level is specified (i.e., when -Wstrict-aliasing, and not
|
-Wstrict-aliasing=level was given).
|
-Wstrict-aliasing=level was given).
|
ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
|
ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
|
and 0 otherwise. After calling this function, wstrict_aliasing will be
|
and 0 otherwise. After calling this function, wstrict_aliasing will be
|
set to the default value of -Wstrict_aliasing=level, currently 3. */
|
set to the default value of -Wstrict_aliasing=level, currently 3. */
|
void
|
void
|
set_Wstrict_aliasing (struct gcc_options *opts, int onoff)
|
set_Wstrict_aliasing (struct gcc_options *opts, int onoff)
|
{
|
{
|
gcc_assert (onoff == 0 || onoff == 1);
|
gcc_assert (onoff == 0 || onoff == 1);
|
if (onoff != 0)
|
if (onoff != 0)
|
opts->x_warn_strict_aliasing = 3;
|
opts->x_warn_strict_aliasing = 3;
|
else
|
else
|
opts->x_warn_strict_aliasing = 0;
|
opts->x_warn_strict_aliasing = 0;
|
}
|
}
|
|
|
/* The following routines are useful in setting all the flags that
|
/* The following routines are useful in setting all the flags that
|
-ffast-math and -fno-fast-math imply. */
|
-ffast-math and -fno-fast-math imply. */
|
static void
|
static void
|
set_fast_math_flags (struct gcc_options *opts, int set)
|
set_fast_math_flags (struct gcc_options *opts, int set)
|
{
|
{
|
if (!opts->frontend_set_flag_unsafe_math_optimizations)
|
if (!opts->frontend_set_flag_unsafe_math_optimizations)
|
{
|
{
|
opts->x_flag_unsafe_math_optimizations = set;
|
opts->x_flag_unsafe_math_optimizations = set;
|
set_unsafe_math_optimizations_flags (opts, set);
|
set_unsafe_math_optimizations_flags (opts, set);
|
}
|
}
|
if (!opts->frontend_set_flag_finite_math_only)
|
if (!opts->frontend_set_flag_finite_math_only)
|
opts->x_flag_finite_math_only = set;
|
opts->x_flag_finite_math_only = set;
|
if (!opts->frontend_set_flag_errno_math)
|
if (!opts->frontend_set_flag_errno_math)
|
opts->x_flag_errno_math = !set;
|
opts->x_flag_errno_math = !set;
|
if (set)
|
if (set)
|
{
|
{
|
if (!opts->frontend_set_flag_signaling_nans)
|
if (!opts->frontend_set_flag_signaling_nans)
|
opts->x_flag_signaling_nans = 0;
|
opts->x_flag_signaling_nans = 0;
|
if (!opts->frontend_set_flag_rounding_math)
|
if (!opts->frontend_set_flag_rounding_math)
|
opts->x_flag_rounding_math = 0;
|
opts->x_flag_rounding_math = 0;
|
if (!opts->frontend_set_flag_cx_limited_range)
|
if (!opts->frontend_set_flag_cx_limited_range)
|
opts->x_flag_cx_limited_range = 1;
|
opts->x_flag_cx_limited_range = 1;
|
}
|
}
|
}
|
}
|
|
|
/* When -funsafe-math-optimizations is set the following
|
/* When -funsafe-math-optimizations is set the following
|
flags are set as well. */
|
flags are set as well. */
|
static void
|
static void
|
set_unsafe_math_optimizations_flags (struct gcc_options *opts, int set)
|
set_unsafe_math_optimizations_flags (struct gcc_options *opts, int set)
|
{
|
{
|
if (!opts->frontend_set_flag_trapping_math)
|
if (!opts->frontend_set_flag_trapping_math)
|
opts->x_flag_trapping_math = !set;
|
opts->x_flag_trapping_math = !set;
|
if (!opts->frontend_set_flag_signed_zeros)
|
if (!opts->frontend_set_flag_signed_zeros)
|
opts->x_flag_signed_zeros = !set;
|
opts->x_flag_signed_zeros = !set;
|
if (!opts->frontend_set_flag_associative_math)
|
if (!opts->frontend_set_flag_associative_math)
|
opts->x_flag_associative_math = set;
|
opts->x_flag_associative_math = set;
|
if (!opts->frontend_set_flag_reciprocal_math)
|
if (!opts->frontend_set_flag_reciprocal_math)
|
opts->x_flag_reciprocal_math = set;
|
opts->x_flag_reciprocal_math = set;
|
}
|
}
|
|
|
/* Return true iff flags in OPTS are set as if -ffast-math. */
|
/* Return true iff flags in OPTS are set as if -ffast-math. */
|
bool
|
bool
|
fast_math_flags_set_p (const struct gcc_options *opts)
|
fast_math_flags_set_p (const struct gcc_options *opts)
|
{
|
{
|
return (!opts->x_flag_trapping_math
|
return (!opts->x_flag_trapping_math
|
&& opts->x_flag_unsafe_math_optimizations
|
&& opts->x_flag_unsafe_math_optimizations
|
&& opts->x_flag_finite_math_only
|
&& opts->x_flag_finite_math_only
|
&& !opts->x_flag_signed_zeros
|
&& !opts->x_flag_signed_zeros
|
&& !opts->x_flag_errno_math);
|
&& !opts->x_flag_errno_math);
|
}
|
}
|
|
|
/* Return true iff flags are set as if -ffast-math but using the flags stored
|
/* Return true iff flags are set as if -ffast-math but using the flags stored
|
in the struct cl_optimization structure. */
|
in the struct cl_optimization structure. */
|
bool
|
bool
|
fast_math_flags_struct_set_p (struct cl_optimization *opt)
|
fast_math_flags_struct_set_p (struct cl_optimization *opt)
|
{
|
{
|
return (!opt->x_flag_trapping_math
|
return (!opt->x_flag_trapping_math
|
&& opt->x_flag_unsafe_math_optimizations
|
&& opt->x_flag_unsafe_math_optimizations
|
&& opt->x_flag_finite_math_only
|
&& opt->x_flag_finite_math_only
|
&& !opt->x_flag_signed_zeros
|
&& !opt->x_flag_signed_zeros
|
&& !opt->x_flag_errno_math);
|
&& !opt->x_flag_errno_math);
|
}
|
}
|
|
|
/* Handle a debug output -g switch for options OPTS
|
/* Handle a debug output -g switch for options OPTS
|
(OPTS_SET->x_write_symbols storing whether a debug type was passed
|
(OPTS_SET->x_write_symbols storing whether a debug type was passed
|
explicitly), location LOC. EXTENDED is true or false to support
|
explicitly), location LOC. EXTENDED is true or false to support
|
extended output (2 is special and means "-ggdb" was given). */
|
extended output (2 is special and means "-ggdb" was given). */
|
static void
|
static void
|
set_debug_level (enum debug_info_type type, int extended, const char *arg,
|
set_debug_level (enum debug_info_type type, int extended, const char *arg,
|
struct gcc_options *opts, struct gcc_options *opts_set,
|
struct gcc_options *opts, struct gcc_options *opts_set,
|
location_t loc)
|
location_t loc)
|
{
|
{
|
opts->x_use_gnu_debug_info_extensions = extended;
|
opts->x_use_gnu_debug_info_extensions = extended;
|
|
|
if (type == NO_DEBUG)
|
if (type == NO_DEBUG)
|
{
|
{
|
if (opts->x_write_symbols == NO_DEBUG)
|
if (opts->x_write_symbols == NO_DEBUG)
|
{
|
{
|
opts->x_write_symbols = PREFERRED_DEBUGGING_TYPE;
|
opts->x_write_symbols = PREFERRED_DEBUGGING_TYPE;
|
|
|
if (extended == 2)
|
if (extended == 2)
|
{
|
{
|
#ifdef DWARF2_DEBUGGING_INFO
|
#ifdef DWARF2_DEBUGGING_INFO
|
opts->x_write_symbols = DWARF2_DEBUG;
|
opts->x_write_symbols = DWARF2_DEBUG;
|
#elif defined DBX_DEBUGGING_INFO
|
#elif defined DBX_DEBUGGING_INFO
|
opts->x_write_symbols = DBX_DEBUG;
|
opts->x_write_symbols = DBX_DEBUG;
|
#endif
|
#endif
|
}
|
}
|
|
|
if (opts->x_write_symbols == NO_DEBUG)
|
if (opts->x_write_symbols == NO_DEBUG)
|
warning_at (loc, 0, "target system does not support debug output");
|
warning_at (loc, 0, "target system does not support debug output");
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Does it conflict with an already selected type? */
|
/* Does it conflict with an already selected type? */
|
if (opts_set->x_write_symbols != NO_DEBUG
|
if (opts_set->x_write_symbols != NO_DEBUG
|
&& opts->x_write_symbols != NO_DEBUG
|
&& opts->x_write_symbols != NO_DEBUG
|
&& type != opts->x_write_symbols)
|
&& type != opts->x_write_symbols)
|
error_at (loc, "debug format \"%s\" conflicts with prior selection",
|
error_at (loc, "debug format \"%s\" conflicts with prior selection",
|
debug_type_names[type]);
|
debug_type_names[type]);
|
opts->x_write_symbols = type;
|
opts->x_write_symbols = type;
|
opts_set->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 (*arg == '\0')
|
if (*arg == '\0')
|
{
|
{
|
if (!opts->x_debug_info_level)
|
if (!opts->x_debug_info_level)
|
opts->x_debug_info_level = DINFO_LEVEL_NORMAL;
|
opts->x_debug_info_level = DINFO_LEVEL_NORMAL;
|
}
|
}
|
else
|
else
|
{
|
{
|
int argval = integral_argument (arg);
|
int argval = integral_argument (arg);
|
if (argval == -1)
|
if (argval == -1)
|
error_at (loc, "unrecognised debug output level \"%s\"", arg);
|
error_at (loc, "unrecognised debug output level \"%s\"", arg);
|
else if (argval > 3)
|
else if (argval > 3)
|
error_at (loc, "debug output level %s is too high", arg);
|
error_at (loc, "debug output level %s is too high", arg);
|
else
|
else
|
opts->x_debug_info_level = (enum debug_info_levels) argval;
|
opts->x_debug_info_level = (enum debug_info_levels) argval;
|
}
|
}
|
}
|
}
|
|
|
/* Arrange to dump core on error for diagnostic context DC. (The
|
/* Arrange to dump core on error for diagnostic context DC. (The
|
regular error message is still printed first, except in the case of
|
regular error message is still printed first, except in the case of
|
abort ().) */
|
abort ().) */
|
|
|
static void
|
static void
|
setup_core_dumping (diagnostic_context *dc)
|
setup_core_dumping (diagnostic_context *dc)
|
{
|
{
|
#ifdef SIGABRT
|
#ifdef SIGABRT
|
signal (SIGABRT, SIG_DFL);
|
signal (SIGABRT, SIG_DFL);
|
#endif
|
#endif
|
#if defined(HAVE_SETRLIMIT)
|
#if defined(HAVE_SETRLIMIT)
|
{
|
{
|
struct rlimit rlim;
|
struct rlimit rlim;
|
if (getrlimit (RLIMIT_CORE, &rlim) != 0)
|
if (getrlimit (RLIMIT_CORE, &rlim) != 0)
|
fatal_error ("getting core file size maximum limit: %m");
|
fatal_error ("getting core file size maximum limit: %m");
|
rlim.rlim_cur = rlim.rlim_max;
|
rlim.rlim_cur = rlim.rlim_max;
|
if (setrlimit (RLIMIT_CORE, &rlim) != 0)
|
if (setrlimit (RLIMIT_CORE, &rlim) != 0)
|
fatal_error ("setting core file size limit to maximum: %m");
|
fatal_error ("setting core file size limit to maximum: %m");
|
}
|
}
|
#endif
|
#endif
|
diagnostic_abort_on_error (dc);
|
diagnostic_abort_on_error (dc);
|
}
|
}
|
|
|
/* Parse a -d<ARG> command line switch for OPTS, location LOC,
|
/* Parse a -d<ARG> command line switch for OPTS, location LOC,
|
diagnostic context DC. */
|
diagnostic context DC. */
|
|
|
static void
|
static void
|
decode_d_option (const char *arg, struct gcc_options *opts,
|
decode_d_option (const char *arg, struct gcc_options *opts,
|
location_t loc, diagnostic_context *dc)
|
location_t loc, diagnostic_context *dc)
|
{
|
{
|
int c;
|
int c;
|
|
|
while (*arg)
|
while (*arg)
|
switch (c = *arg++)
|
switch (c = *arg++)
|
{
|
{
|
case 'A':
|
case 'A':
|
opts->x_flag_debug_asm = 1;
|
opts->x_flag_debug_asm = 1;
|
break;
|
break;
|
case 'p':
|
case 'p':
|
opts->x_flag_print_asm_name = 1;
|
opts->x_flag_print_asm_name = 1;
|
break;
|
break;
|
case 'P':
|
case 'P':
|
opts->x_flag_dump_rtl_in_asm = 1;
|
opts->x_flag_dump_rtl_in_asm = 1;
|
opts->x_flag_print_asm_name = 1;
|
opts->x_flag_print_asm_name = 1;
|
break;
|
break;
|
case 'v':
|
case 'v':
|
opts->x_graph_dump_format = vcg;
|
opts->x_graph_dump_format = vcg;
|
break;
|
break;
|
case 'x':
|
case 'x':
|
opts->x_rtl_dump_and_exit = 1;
|
opts->x_rtl_dump_and_exit = 1;
|
break;
|
break;
|
case 'D': /* These are handled by the preprocessor. */
|
case 'D': /* These are handled by the preprocessor. */
|
case 'I':
|
case 'I':
|
case 'M':
|
case 'M':
|
case 'N':
|
case 'N':
|
case 'U':
|
case 'U':
|
break;
|
break;
|
case 'H':
|
case 'H':
|
setup_core_dumping (dc);
|
setup_core_dumping (dc);
|
break;
|
break;
|
case 'a':
|
case 'a':
|
opts->x_flag_dump_all_passed = true;
|
opts->x_flag_dump_all_passed = true;
|
break;
|
break;
|
|
|
default:
|
default:
|
warning_at (loc, 0, "unrecognized gcc debugging option: %c", c);
|
warning_at (loc, 0, "unrecognized gcc debugging option: %c", c);
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
/* Enable (or disable if VALUE is 0) a warning option ARG (language
|
/* Enable (or disable if VALUE is 0) a warning option ARG (language
|
mask LANG_MASK, option handlers HANDLERS) as an error for option
|
mask LANG_MASK, option handlers HANDLERS) as an error for option
|
structures OPTS and OPTS_SET, diagnostic context DC (possibly
|
structures OPTS and OPTS_SET, diagnostic context DC (possibly
|
NULL), location LOC. This is used by -Werror=. */
|
NULL), location LOC. This is used by -Werror=. */
|
|
|
static void
|
static void
|
enable_warning_as_error (const char *arg, int value, unsigned int lang_mask,
|
enable_warning_as_error (const char *arg, int value, unsigned int lang_mask,
|
const struct cl_option_handlers *handlers,
|
const struct cl_option_handlers *handlers,
|
struct gcc_options *opts,
|
struct gcc_options *opts,
|
struct gcc_options *opts_set,
|
struct gcc_options *opts_set,
|
location_t loc, diagnostic_context *dc)
|
location_t loc, diagnostic_context *dc)
|
{
|
{
|
char *new_option;
|
char *new_option;
|
int option_index;
|
int option_index;
|
|
|
new_option = XNEWVEC (char, strlen (arg) + 2);
|
new_option = XNEWVEC (char, strlen (arg) + 2);
|
new_option[0] = 'W';
|
new_option[0] = 'W';
|
strcpy (new_option + 1, arg);
|
strcpy (new_option + 1, arg);
|
option_index = find_opt (new_option, lang_mask);
|
option_index = find_opt (new_option, lang_mask);
|
if (option_index == OPT_SPECIAL_unknown)
|
if (option_index == OPT_SPECIAL_unknown)
|
{
|
{
|
error_at (loc, "-Werror=%s: no option -%s", arg, new_option);
|
error_at (loc, "-Werror=%s: no option -%s", arg, new_option);
|
}
|
}
|
else
|
else
|
{
|
{
|
const diagnostic_t kind = value ? DK_ERROR : DK_WARNING;
|
const diagnostic_t kind = value ? DK_ERROR : DK_WARNING;
|
|
|
control_warning_option (option_index, (int) kind, value,
|
control_warning_option (option_index, (int) kind, value,
|
loc, lang_mask,
|
loc, lang_mask,
|
handlers, opts, opts_set, dc);
|
handlers, opts, opts_set, dc);
|
if (option_index == OPT_Wuninitialized)
|
if (option_index == OPT_Wuninitialized)
|
enable_warning_as_error ("maybe-uninitialized", value, lang_mask,
|
enable_warning_as_error ("maybe-uninitialized", value, lang_mask,
|
handlers, opts, opts_set, loc, dc);
|
handlers, opts, opts_set, loc, dc);
|
}
|
}
|
free (new_option);
|
free (new_option);
|
}
|
}
|
|
|
/* Return malloced memory for the name of the option OPTION_INDEX
|
/* Return malloced memory for the name of the option OPTION_INDEX
|
which enabled a diagnostic (context CONTEXT), originally of type
|
which enabled a diagnostic (context CONTEXT), originally of type
|
ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
|
ORIG_DIAG_KIND but possibly converted to DIAG_KIND by options such
|
as -Werror. */
|
as -Werror. */
|
|
|
char *
|
char *
|
option_name (diagnostic_context *context, int option_index,
|
option_name (diagnostic_context *context, int option_index,
|
diagnostic_t orig_diag_kind, diagnostic_t diag_kind)
|
diagnostic_t orig_diag_kind, diagnostic_t diag_kind)
|
{
|
{
|
if (option_index)
|
if (option_index)
|
{
|
{
|
/* A warning classified as an error. */
|
/* A warning classified as an error. */
|
if ((orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN)
|
if ((orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN)
|
&& diag_kind == DK_ERROR)
|
&& diag_kind == DK_ERROR)
|
return concat (cl_options[OPT_Werror_].opt_text,
|
return concat (cl_options[OPT_Werror_].opt_text,
|
/* Skip over "-W". */
|
/* Skip over "-W". */
|
cl_options[option_index].opt_text + 2,
|
cl_options[option_index].opt_text + 2,
|
NULL);
|
NULL);
|
/* A warning with option. */
|
/* A warning with option. */
|
else
|
else
|
return xstrdup (cl_options[option_index].opt_text);
|
return xstrdup (cl_options[option_index].opt_text);
|
}
|
}
|
/* A warning without option classified as an error. */
|
/* A warning without option classified as an error. */
|
else if (orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN
|
else if (orig_diag_kind == DK_WARNING || orig_diag_kind == DK_PEDWARN
|
|| diag_kind == DK_WARNING)
|
|| diag_kind == DK_WARNING)
|
{
|
{
|
if (context->warning_as_error_requested)
|
if (context->warning_as_error_requested)
|
return xstrdup (cl_options[OPT_Werror].opt_text);
|
return xstrdup (cl_options[OPT_Werror].opt_text);
|
else
|
else
|
return xstrdup (_("enabled by default"));
|
return xstrdup (_("enabled by default"));
|
}
|
}
|
else
|
else
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
