[thirdparty/gcc.git] / gcc / opts-global.c

/* Command line option handling.  Code involving global state that
   should not be shared with the driver.
   Copyright (C) 2002-2019 Free Software Foundation, Inc.

This file is part of GCC.

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
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.  */

#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "backend.h"
#include "rtl.h"
#include "tree.h"
#include "tree-pass.h"
#include "diagnostic.h"
#include "opts.h"
#include "flags.h"
#include "langhooks.h"
#include "dbgcnt.h"
#include "debug.h"
#include "output.h"
#include "plugin.h"
#include "toplev.h"
#include "context.h"
#include "stringpool.h"
#include "attribs.h"
#include "asan.h"
#include "file-prefix-map.h" /* add_*_prefix_map()  */

typedef const char *const_char_p; /* For DEF_VEC_P.  */

static vec<const_char_p> ignored_options;

/* Input file names.  */
const char **in_fnames;
unsigned num_in_fnames;

/* Return a malloced slash-separated list of languages in MASK.  */

char *
write_langs (unsigned int mask)
{
  unsigned int n = 0, len = 0;
  const char *lang_name;
  char *result;

  for (n = 0; (lang_name = lang_names[n]) != 0; n++)
    if (mask & (1U << n))
      len += strlen (lang_name) + 1;

  result = XNEWVEC (char, len);
  len = 0;
  for (n = 0; (lang_name = lang_names[n]) != 0; n++)
    if (mask & (1U << n))
      {
	if (len)
	  result[len++] = '/';
	strcpy (result + len, lang_name);
	len += strlen (lang_name);
      }

  result[len] = 0;

  return result;
}

/* Complain that switch DECODED does not apply to this front end (mask
   LANG_MASK).  */

static void
complain_wrong_lang (const struct cl_decoded_option *decoded,
		     unsigned int lang_mask)
{
  const struct cl_option *option = &cl_options[decoded->opt_index];
  const char *text = decoded->orig_option_with_args_text;
  char *ok_langs = NULL, *bad_lang = NULL;
  unsigned int opt_flags = option->flags;

  if (!lang_hooks.complain_wrong_lang_p (option))
    return;

  opt_flags &= ((1U << cl_lang_count) - 1) | CL_DRIVER;
  if (opt_flags != CL_DRIVER)
    ok_langs = write_langs (opt_flags);
  if (lang_mask != CL_DRIVER)
    bad_lang = write_langs (lang_mask);

  if (opt_flags == CL_DRIVER)
    error ("command line option %qs is valid for the driver but not for %s",
	   text, bad_lang);
  else if (lang_mask == CL_DRIVER)
    gcc_unreachable ();
  else
    /* Eventually this should become a hard error IMO.  */
    warning (0, "command line option %qs is valid for %s but not for %s",
	     text, ok_langs, bad_lang);

  free (ok_langs);
  free (bad_lang);
}

/* Buffer the unknown option described by the string OPT.  Currently,
   we only complain about unknown -Wno-* options if they may have
   prevented a diagnostic. Otherwise, we just ignore them.  Note that
   if we do complain, it is only as a warning, not an error; passing
   the compiler an unrecognized -Wno-* option should never change
   whether the compilation succeeds or fails.  */

static void
postpone_unknown_option_warning (const char *opt)
{
  ignored_options.safe_push (opt);
}

/* Produce a warning for each option previously buffered.  */

void
print_ignored_options (void)
{
  while (!ignored_options.is_empty ())
    {
      const char *opt;

      opt = ignored_options.pop ();
      warning_at (UNKNOWN_LOCATION, 0,
		  "unrecognized command line option %qs", opt);
    }
}

/* Handle an unknown option DECODED, returning true if an error should
   be given.  */

static bool
unknown_option_callback (const struct cl_decoded_option *decoded)
{
  const char *opt = decoded->arg;

  if (opt[1] == 'W' && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-'
      && !(decoded->errors & CL_ERR_NEGATIVE))
    {
      /* We don't generate warnings for unknown -Wno-* options unless
	 we issue diagnostics.  */
      postpone_unknown_option_warning (opt);
      return false;
    }
  else
    return true;
}

/* Handle a front-end option; arguments and return value as for
   handle_option.  */

static bool
lang_handle_option (struct gcc_options *opts,
		    struct gcc_options *opts_set,
		    const struct cl_decoded_option *decoded,
		    unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
		    location_t loc,
		    const struct cl_option_handlers *handlers,
		    diagnostic_context *dc,
		    void (*) (void))
{
  gcc_assert (opts == &global_options);
  gcc_assert (opts_set == &global_options_set);
  gcc_assert (dc == global_dc);
  gcc_assert (decoded->canonical_option_num_elements <= 2);
  return lang_hooks.handle_option (decoded->opt_index, decoded->arg,
				   decoded->value, kind, loc, handlers);
}

/* Handle FILENAME from the command line.  */

static void
add_input_filename (const char *filename)
{
  num_in_fnames++;
  in_fnames = XRESIZEVEC (const char *, in_fnames, num_in_fnames);
  in_fnames[num_in_fnames - 1] = filename;
}

/* Handle the vector of command line options (located at LOC), storing
   the results of processing DECODED_OPTIONS and DECODED_OPTIONS_COUNT
   in OPTS and OPTS_SET and using DC for diagnostic state.  LANG_MASK
   contains has a single bit set representing the current language.
   HANDLERS describes what functions to call for the options.  */

static void
read_cmdline_options (struct gcc_options *opts, struct gcc_options *opts_set,
		      struct cl_decoded_option *decoded_options,
		      unsigned int decoded_options_count,
		      location_t loc,
		      unsigned int lang_mask,
		      const struct cl_option_handlers *handlers,
		      diagnostic_context *dc)
{
  unsigned int i;

  for (i = 1; i < decoded_options_count; i++)
    {
      if (decoded_options[i].opt_index == OPT_SPECIAL_input_file)
	{
	  /* Input files should only ever appear on the main command
	     line.  */
	  gcc_assert (opts == &global_options);
	  gcc_assert (opts_set == &global_options_set);

	  if (opts->x_main_input_filename == NULL)
	    {
	      opts->x_main_input_filename = decoded_options[i].arg;
	      opts->x_main_input_baselength
		= base_of_path (opts->x_main_input_filename,
				&opts->x_main_input_basename);
	    }
	  add_input_filename (decoded_options[i].arg);
	  continue;
	}

      read_cmdline_option (opts, opts_set,
			   decoded_options + i, loc, lang_mask, handlers,
			   dc);
    }
}

/* Language mask determined at initialization.  */
static unsigned int initial_lang_mask;

/* Initialize global options-related settings at start-up.  */

void
init_options_once (void)
{
  /* Perform language-specific options initialization.  */
  initial_lang_mask = lang_hooks.option_lang_mask ();

  lang_hooks.initialize_diagnostics (global_dc);
  /* ??? Ideally, we should do this earlier and the FEs will override
     it if desired (none do it so far).  However, the way the FEs
     construct their pretty-printers means that all previous settings
     are overriden.  */
  diagnostic_color_init (global_dc);
}

/* Decode command-line options to an array, like
   decode_cmdline_options_to_array and with the same arguments but
   using the default lang_mask.  */

void
decode_cmdline_options_to_array_default_mask (unsigned int argc,
					      const char **argv, 
					      struct cl_decoded_option **decoded_options,
					      unsigned int *decoded_options_count)
{
  decode_cmdline_options_to_array (argc, argv,
				   initial_lang_mask | CL_COMMON | CL_TARGET,
				   decoded_options, decoded_options_count);
}

/* Set *HANDLERS to the default set of option handlers for use in the
   compilers proper (not the driver).  */
void
set_default_handlers (struct cl_option_handlers *handlers,
		      void (*target_option_override_hook) (void))
{
  handlers->unknown_option_callback = unknown_option_callback;
  handlers->wrong_lang_callback = complain_wrong_lang;
  handlers->target_option_override_hook = target_option_override_hook;
  handlers->num_handlers = 3;
  handlers->handlers[0].handler = lang_handle_option;
  handlers->handlers[0].mask = initial_lang_mask;
  handlers->handlers[1].handler = common_handle_option;
  handlers->handlers[1].mask = CL_COMMON;
  handlers->handlers[2].handler = target_handle_option;
  handlers->handlers[2].mask = CL_TARGET;
}

/* Parse command line options and set default flag values.  Do minimal
   options processing.  The decoded options are in *DECODED_OPTIONS
   and *DECODED_OPTIONS_COUNT; settings go in OPTS, OPTS_SET and DC;
   the options are located at LOC.  */
void
decode_options (struct gcc_options *opts, struct gcc_options *opts_set,
		struct cl_decoded_option *decoded_options,
		unsigned int decoded_options_count,
		location_t loc, diagnostic_context *dc,
		void (*target_option_override_hook) (void))
{
  struct cl_option_handlers handlers;

  unsigned int lang_mask;

  lang_mask = initial_lang_mask;

  set_default_handlers (&handlers, target_option_override_hook);

  default_options_optimization (opts, opts_set,
				decoded_options, decoded_options_count,
				loc, lang_mask, &handlers, dc);

  read_cmdline_options (opts, opts_set,
			decoded_options, decoded_options_count,
			loc, lang_mask,
			&handlers, dc);

  finish_options (opts, opts_set, loc, lang_mask);
}

/* Hold command-line options associated with stack limitation.  */
const char *opt_fstack_limit_symbol_arg = NULL;
int opt_fstack_limit_register_no = -1;

/* Process common options that have been deferred until after the
   handlers have been called for all options.  */

void
handle_common_deferred_options (void)
{
  unsigned int i;
  cl_deferred_option *opt;
  vec<cl_deferred_option> v;

  if (common_deferred_options)
    v = *((vec<cl_deferred_option> *) common_deferred_options);
  else
    v = vNULL;

  if (flag_dump_all_passed)
    enable_rtl_dump_file ();

  if (flag_opt_info)
    opt_info_switch_p (NULL);

  FOR_EACH_VEC_ELT (v, i, opt)
    {
      switch (opt->opt_index)
	{
	case OPT_fcall_used_:
	  fix_register (opt->arg, 0, 1);
	  break;

	case OPT_fcall_saved_:
	  fix_register (opt->arg, 0, 0);
	  break;

	case OPT_fdbg_cnt_:
	  dbg_cnt_process_opt (opt->arg);
	  break;

	case OPT_fdbg_cnt_list:
	  dbg_cnt_list_all_counters ();
	  break;

	case OPT_fdebug_prefix_map_:
	  add_debug_prefix_map (opt->arg);
	  break;

	case OPT_ffile_prefix_map_:
	  add_file_prefix_map (opt->arg);
	  break;

	case OPT_fdump_:
	  if (!g->get_dumps ()->dump_switch_p (opt->arg))
	    error ("unrecognized command line option %<-fdump-%s%>", opt->arg);
	  break;

        case OPT_fopt_info_:
	  if (!opt_info_switch_p (opt->arg))
	    error ("unrecognized command line option %<-fopt-info-%s%>",
                   opt->arg);
          break;

	case OPT_fenable_:
	case OPT_fdisable_:
	  if (opt->opt_index == OPT_fenable_)
	    enable_pass (opt->arg);
          else
	    disable_pass (opt->arg);
          break;

	case OPT_ffixed_:
	  /* Deferred.  */
	  fix_register (opt->arg, 1, 1);
	  break;

	case OPT_fplugin_:
#ifdef ENABLE_PLUGIN
	  add_new_plugin (opt->arg);
#else
	  error ("plugin support is disabled; configure with --enable-plugin");
#endif
	  break;

	case OPT_fplugin_arg_:
#ifdef ENABLE_PLUGIN
	  parse_plugin_arg_opt (opt->arg);
#else
	  error ("plugin support is disabled; configure with --enable-plugin");
#endif
	  break;

	case OPT_frandom_seed:
	  /* The real switch is -fno-random-seed.  */
	  if (!opt->value)
	    set_random_seed (NULL);
	  break;

	case OPT_frandom_seed_:
	  set_random_seed (opt->arg);
	  break;

	case OPT_fstack_limit:
	  /* The real switch is -fno-stack-limit.  */
	  if (!opt->value)
	    stack_limit_rtx = NULL_RTX;
	  break;

	case OPT_fstack_limit_register_:
	  {
	    int reg = decode_reg_name (opt->arg);
	    if (reg < 0)
	      error ("unrecognized register name %qs", opt->arg);
	    else
	      {
		/* Deactivate previous OPT_fstack_limit_symbol_ options.  */
		opt_fstack_limit_symbol_arg = NULL;
		opt_fstack_limit_register_no = reg;
	      }
	  }
	  break;

	case OPT_fstack_limit_symbol_:
	  /* Deactivate previous OPT_fstack_limit_register_ options.  */
	  opt_fstack_limit_register_no = -1;
	  opt_fstack_limit_symbol_arg = opt->arg;
	  break;

	case OPT_fasan_shadow_offset_:
	  if (!(flag_sanitize & SANITIZE_KERNEL_ADDRESS))
	    error ("%<-fasan-shadow-offset%> should only be used "
		   "with %<-fsanitize=kernel-address%>");
	  if (!set_asan_shadow_offset (opt->arg))
	     error ("unrecognized shadow offset %qs", opt->arg);
	  break;

	case OPT_fsanitize_sections_:
	  set_sanitized_sections (opt->arg);
	  break;

	default:
	  gcc_unreachable ();
	}
    }
}
Commit	Line	Data
21bf1558 JM	1	/* Command line option handling. Code involving global state that
21bf1558 JM	2	should not be shared with the driver.
a5544970	3	Copyright (C) 2002-2019 Free Software Foundation, Inc.
21bf1558 JM	4
	5	This file is part of GCC.
	6
	7	GCC is free software; you can redistribute it and/or modify it under
	8	the terms of the GNU General Public License as published by the Free
	9	Software Foundation; either version 3, or (at your option) any later
	10	version.
	11
	12	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
	13	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	14	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	15	for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with GCC; see the file COPYING3. If not see
	19	<http://www.gnu.org/licenses/>. */
	20
	21	#include "config.h"
	22	#include "system.h"
	23	#include "coretypes.h"
957060b5	24	#include "backend.h"
957060b5 AM	25	#include "rtl.h"
957060b5 AM	26	#include "tree.h"
957060b5	27	#include "tree-pass.h"
c98cd5bf	28	#include "diagnostic.h"
21bf1558 JM	29	#include "opts.h"
21bf1558 JM	30	#include "flags.h"
c98cd5bf	31	#include "langhooks.h"
299404a1 JM	32	#include "dbgcnt.h"
299404a1 JM	33	#include "debug.h"
21bf1558 JM	34	#include "output.h"
21bf1558 JM	35	#include "plugin.h"
c98cd5bf	36	#include "toplev.h"
47e0da37	37	#include "context.h"
314e6352 ML	38	#include "stringpool.h"
314e6352 ML	39	#include "attribs.h"
fd960af2	40	#include "asan.h"
7365279f	41	#include "file-prefix-map.h" /* add__prefix_map() /
21bf1558	42
c98cd5bf	43	typedef const char const_char_p; / For DEF_VEC_P. */
c98cd5bf	44
9771b263	45	static vec<const_char_p> ignored_options;
c98cd5bf JM	46
	47	/* Input file names. */
	48	const char **in_fnames;
	49	unsigned num_in_fnames;
	50
	51	/* Return a malloced slash-separated list of languages in MASK. */
	52
c1822f9c	53	char *
c98cd5bf JM	54	write_langs (unsigned int mask)
	55	{
	56	unsigned int n = 0, len = 0;
	57	const char *lang_name;
	58	char *result;
	59
	60	for (n = 0; (lang_name = lang_names[n]) != 0; n++)
	61	if (mask & (1U << n))
	62	len += strlen (lang_name) + 1;
	63
	64	result = XNEWVEC (char, len);
	65	len = 0;
	66	for (n = 0; (lang_name = lang_names[n]) != 0; n++)
	67	if (mask & (1U << n))
	68	{
	69	if (len)
	70	result[len++] = '/';
	71	strcpy (result + len, lang_name);
	72	len += strlen (lang_name);
	73	}
	74
	75	result[len] = 0;
	76
	77	return result;
	78	}
	79
	80	/* Complain that switch DECODED does not apply to this front end (mask
	81	LANG_MASK). */
	82
	83	static void
	84	complain_wrong_lang (const struct cl_decoded_option *decoded,
	85	unsigned int lang_mask)
	86	{
	87	const struct cl_option *option = &cl_options[decoded->opt_index];
	88	const char *text = decoded->orig_option_with_args_text;
	89	char ok_langs = NULL, bad_lang = NULL;
	90	unsigned int opt_flags = option->flags;
	91
	92	if (!lang_hooks.complain_wrong_lang_p (option))
	93	return;
	94
	95	opt_flags &= ((1U << cl_lang_count) - 1) \| CL_DRIVER;
	96	if (opt_flags != CL_DRIVER)
	97	ok_langs = write_langs (opt_flags);
	98	if (lang_mask != CL_DRIVER)
	99	bad_lang = write_langs (lang_mask);
	100
	101	if (opt_flags == CL_DRIVER)
	102	error ("command line option %qs is valid for the driver but not for %s",
	103	text, bad_lang);
	104	else if (lang_mask == CL_DRIVER)
	105	gcc_unreachable ();
	106	else
	107	/* Eventually this should become a hard error IMO. */
	108	warning (0, "command line option %qs is valid for %s but not for %s",
	109	text, ok_langs, bad_lang);
	110
	111	free (ok_langs);
	112	free (bad_lang);
	113	}
	114
	115	/* Buffer the unknown option described by the string OPT. Currently,
	116	we only complain about unknown -Wno-* options if they may have
	117	prevented a diagnostic. Otherwise, we just ignore them. Note that
118	if we do complain, it is only as a warning, not an error; passing
778e02fd	119	the compiler an unrecognized -Wno-* option should never change
c98cd5bf JM	120	whether the compilation succeeds or fails. */
	121
	122	static void
	123	postpone_unknown_option_warning (const char *opt)
	124	{
9771b263	125	ignored_options.safe_push (opt);
c98cd5bf JM	126	}
	127
	128	/* Produce a warning for each option previously buffered. */
	129
	130	void
	131	print_ignored_options (void)
	132	{
9771b263	133	while (!ignored_options.is_empty ())
c98cd5bf JM	134	{
	135	const char *opt;
	136
9771b263	137	opt = ignored_options.pop ();
c98cd5bf	138	warning_at (UNKNOWN_LOCATION, 0,
778e02fd	139	"unrecognized command line option %qs", opt);
c98cd5bf JM	140	}
	141	}
	142
	143	/* Handle an unknown option DECODED, returning true if an error should
	144	be given. */
	145
	146	static bool
	147	unknown_option_callback (const struct cl_decoded_option *decoded)
	148	{
	149	const char *opt = decoded->arg;
	150
	151	if (opt[1] == 'W' && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-'
	152	&& !(decoded->errors & CL_ERR_NEGATIVE))
	153	{
	154	/* We don't generate warnings for unknown -Wno-* options unless
	155	we issue diagnostics. */
	156	postpone_unknown_option_warning (opt);
	157	return false;
	158	}
	159	else
	160	return true;
	161	}
	162
c98cd5bf JM	163	/* Handle a front-end option; arguments and return value as for
	164	handle_option. */
	165
	166	static bool
	167	lang_handle_option (struct gcc_options *opts,
	168	struct gcc_options *opts_set,
	169	const struct cl_decoded_option *decoded,
	170	unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
	171	location_t loc,
	172	const struct cl_option_handlers *handlers,
130fcab0 ML	173	diagnostic_context *dc,
130fcab0 ML	174	void (*) (void))
c98cd5bf JM	175	{
	176	gcc_assert (opts == &global_options);
	177	gcc_assert (opts_set == &global_options_set);
	178	gcc_assert (dc == global_dc);
	179	gcc_assert (decoded->canonical_option_num_elements <= 2);
	180	return lang_hooks.handle_option (decoded->opt_index, decoded->arg,
	181	decoded->value, kind, loc, handlers);
	182	}
	183
	184	/* Handle FILENAME from the command line. */
	185
	186	static void
	187	add_input_filename (const char *filename)
	188	{
	189	num_in_fnames++;
	190	in_fnames = XRESIZEVEC (const char *, in_fnames, num_in_fnames);
	191	in_fnames[num_in_fnames - 1] = filename;
	192	}
	193
	194	/* Handle the vector of command line options (located at LOC), storing
	195	the results of processing DECODED_OPTIONS and DECODED_OPTIONS_COUNT
	196	in OPTS and OPTS_SET and using DC for diagnostic state. LANG_MASK
	197	contains has a single bit set representing the current language.
	198	HANDLERS describes what functions to call for the options. */
	199
	200	static void
	201	read_cmdline_options (struct gcc_options opts, struct gcc_options opts_set,
	202	struct cl_decoded_option *decoded_options,
	203	unsigned int decoded_options_count,
	204	location_t loc,
	205	unsigned int lang_mask,
	206	const struct cl_option_handlers *handlers,
	207	diagnostic_context *dc)
	208	{
	209	unsigned int i;
	210
	211	for (i = 1; i < decoded_options_count; i++)
	212	{
	213	if (decoded_options[i].opt_index == OPT_SPECIAL_input_file)
	214	{
	215	/* Input files should only ever appear on the main command
	216	line. */
	217	gcc_assert (opts == &global_options);
	218	gcc_assert (opts_set == &global_options_set);
	219
a803773f	220	if (opts->x_main_input_filename == NULL)
c98cd5bf	221	{
a803773f JM	222	opts->x_main_input_filename = decoded_options[i].arg;
	223	opts->x_main_input_baselength
	224	= base_of_path (opts->x_main_input_filename,
	225	&opts->x_main_input_basename);
c98cd5bf JM	226	}
	227	add_input_filename (decoded_options[i].arg);
	228	continue;
	229	}
	230
	231	read_cmdline_option (opts, opts_set,
	232	decoded_options + i, loc, lang_mask, handlers,
	233	dc);
	234	}
	235	}
	236
	237	/* Language mask determined at initialization. */
	238	static unsigned int initial_lang_mask;
	239
	240	/* Initialize global options-related settings at start-up. */
	241
	242	void
	243	init_options_once (void)
	244	{
	245	/* Perform language-specific options initialization. */
	246	initial_lang_mask = lang_hooks.option_lang_mask ();
	247
	248	lang_hooks.initialize_diagnostics (global_dc);
97aa8bb6 MLI	249	/* ??? Ideally, we should do this earlier and the FEs will override
	250	it if desired (none do it so far). However, the way the FEs
	251	construct their pretty-printers means that all previous settings
	252	are overriden. */
	253	diagnostic_color_init (global_dc);
c98cd5bf JM	254	}
	255
	256	/* Decode command-line options to an array, like
	257	decode_cmdline_options_to_array and with the same arguments but
	258	using the default lang_mask. */
	259
	260	void
	261	decode_cmdline_options_to_array_default_mask (unsigned int argc,
	262	const char **argv,
	263	struct cl_decoded_option **decoded_options,
	264	unsigned int *decoded_options_count)
	265	{
	266	decode_cmdline_options_to_array (argc, argv,
	267	initial_lang_mask \| CL_COMMON \| CL_TARGET,
	268	decoded_options, decoded_options_count);
	269	}
	270
	271	/* Set *HANDLERS to the default set of option handlers for use in the
	272	compilers proper (not the driver). */
	273	void
130fcab0 ML	274	set_default_handlers (struct cl_option_handlers *handlers,
130fcab0 ML	275	void (*target_option_override_hook) (void))
c98cd5bf JM	276	{
	277	handlers->unknown_option_callback = unknown_option_callback;
	278	handlers->wrong_lang_callback = complain_wrong_lang;
130fcab0	279	handlers->target_option_override_hook = target_option_override_hook;
c98cd5bf JM	280	handlers->num_handlers = 3;
	281	handlers->handlers[0].handler = lang_handle_option;
	282	handlers->handlers[0].mask = initial_lang_mask;
	283	handlers->handlers[1].handler = common_handle_option;
	284	handlers->handlers[1].mask = CL_COMMON;
	285	handlers->handlers[2].handler = target_handle_option;
	286	handlers->handlers[2].mask = CL_TARGET;
	287	}
	288
	289	/* Parse command line options and set default flag values. Do minimal
	290	options processing. The decoded options are in *DECODED_OPTIONS
	291	and *DECODED_OPTIONS_COUNT; settings go in OPTS, OPTS_SET and DC;
	292	the options are located at LOC. */
	293	void
	294	decode_options (struct gcc_options opts, struct gcc_options opts_set,
	295	struct cl_decoded_option *decoded_options,
	296	unsigned int decoded_options_count,
130fcab0 ML	297	location_t loc, diagnostic_context *dc,
130fcab0 ML	298	void (*target_option_override_hook) (void))
c98cd5bf JM	299	{
	300	struct cl_option_handlers handlers;
	301
	302	unsigned int lang_mask;
	303
	304	lang_mask = initial_lang_mask;
	305
130fcab0	306	set_default_handlers (&handlers, target_option_override_hook);
c98cd5bf	307
c98cd5bf JM	308	default_options_optimization (opts, opts_set,
	309	decoded_options, decoded_options_count,
	310	loc, lang_mask, &handlers, dc);
	311
c98cd5bf JM	312	read_cmdline_options (opts, opts_set,
	313	decoded_options, decoded_options_count,
	314	loc, lang_mask,
	315	&handlers, dc);
	316
2dcfc872	317	finish_options (opts, opts_set, loc, lang_mask);
c98cd5bf JM	318	}
c98cd5bf JM	319
ecf835e9 KN	320	/* Hold command-line options associated with stack limitation. */
	321	const char *opt_fstack_limit_symbol_arg = NULL;
	322	int opt_fstack_limit_register_no = -1;
	323
c98cd5bf JM	324	/* Process common options that have been deferred until after the
	325	handlers have been called for all options. */
	326
21bf1558 JM	327	void
	328	handle_common_deferred_options (void)
	329	{
	330	unsigned int i;
	331	cl_deferred_option *opt;
9771b263 DN	332	vec<cl_deferred_option> v;
	333
	334	if (common_deferred_options)
	335	v = ((vec<cl_deferred_option> ) common_deferred_options);
	336	else
6e1aa848	337	v = vNULL;
21bf1558	338
299404a1 JM	339	if (flag_dump_all_passed)
	340	enable_rtl_dump_file ();
	341
78c60e3d SS	342	if (flag_opt_info)
	343	opt_info_switch_p (NULL);
	344
9771b263	345	FOR_EACH_VEC_ELT (v, i, opt)
21bf1558 JM	346	{
	347	switch (opt->opt_index)
	348	{
	349	case OPT_fcall_used_:
	350	fix_register (opt->arg, 0, 1);
	351	break;
	352
	353	case OPT_fcall_saved_:
	354	fix_register (opt->arg, 0, 0);
	355	break;
	356
299404a1 JM	357	case OPT_fdbg_cnt_:
	358	dbg_cnt_process_opt (opt->arg);
	359	break;
	360
	361	case OPT_fdbg_cnt_list:
	362	dbg_cnt_list_all_counters ();
	363	break;
	364
	365	case OPT_fdebug_prefix_map_:
	366	add_debug_prefix_map (opt->arg);
	367	break;
	368
7365279f BK	369	case OPT_ffile_prefix_map_:
	370	add_file_prefix_map (opt->arg);
	371	break;
	372
21bf1558	373	case OPT_fdump_:
47e0da37	374	if (!g->get_dumps ()->dump_switch_p (opt->arg))
21bf1558 JM	375	error ("unrecognized command line option %<-fdump-%s%>", opt->arg);
	376	break;
	377
78c60e3d SS	378	case OPT_fopt_info_:
78c60e3d SS	379	if (!opt_info_switch_p (opt->arg))
2b4e6bf1	380	error ("unrecognized command line option %<-fopt-info-%s%>",
78c60e3d SS	381	opt->arg);
	382	break;
	383
226c52aa XDL	384	case OPT_fenable_:
	385	case OPT_fdisable_:
	386	if (opt->opt_index == OPT_fenable_)
	387	enable_pass (opt->arg);
	388	else
	389	disable_pass (opt->arg);
	390	break;
	391
21bf1558 JM	392	case OPT_ffixed_:
	393	/* Deferred. */
	394	fix_register (opt->arg, 1, 1);
	395	break;
	396
	397	case OPT_fplugin_:
	398	#ifdef ENABLE_PLUGIN
	399	add_new_plugin (opt->arg);
	400	#else
	401	error ("plugin support is disabled; configure with --enable-plugin");
	402	#endif
	403	break;
	404
	405	case OPT_fplugin_arg_:
	406	#ifdef ENABLE_PLUGIN
	407	parse_plugin_arg_opt (opt->arg);
	408	#else
	409	error ("plugin support is disabled; configure with --enable-plugin");
	410	#endif
	411	break;
	412
299404a1 JM	413	case OPT_frandom_seed:
	414	/* The real switch is -fno-random-seed. */
	415	if (!opt->value)
	416	set_random_seed (NULL);
	417	break;
	418
	419	case OPT_frandom_seed_:
	420	set_random_seed (opt->arg);
	421	break;
	422
21bf1558 JM	423	case OPT_fstack_limit:
21bf1558 JM	424	/* The real switch is -fno-stack-limit. */
299404a1 JM	425	if (!opt->value)
299404a1 JM	426	stack_limit_rtx = NULL_RTX;
21bf1558 JM	427	break;
	428
	429	case OPT_fstack_limit_register_:
	430	{
	431	int reg = decode_reg_name (opt->arg);
	432	if (reg < 0)
	433	error ("unrecognized register name %qs", opt->arg);
	434	else
ecf835e9 KN	435	{
	436	/* Deactivate previous OPT_fstack_limit_symbol_ options. */
	437	opt_fstack_limit_symbol_arg = NULL;
	438	opt_fstack_limit_register_no = reg;
	439	}
21bf1558 JM	440	}
	441	break;
	442
	443	case OPT_fstack_limit_symbol_:
ecf835e9 KN	444	/* Deactivate previous OPT_fstack_limit_register_ options. */
	445	opt_fstack_limit_register_no = -1;
	446	opt_fstack_limit_symbol_arg = opt->arg;
21bf1558 JM	447	break;
21bf1558 JM	448
fd960af2 YG	449	case OPT_fasan_shadow_offset_:
fd960af2 YG	450	if (!(flag_sanitize & SANITIZE_KERNEL_ADDRESS))
a3f9f006 ML	451	error ("%<-fasan-shadow-offset%> should only be used "
a3f9f006 ML	452	"with %<-fsanitize=kernel-address%>");
fd960af2 YG	453	if (!set_asan_shadow_offset (opt->arg))
	454	error ("unrecognized shadow offset %qs", opt->arg);
	455	break;
	456
18af8d16 YG	457	case OPT_fsanitize_sections_:
	458	set_sanitized_sections (opt->arg);
	459	break;
	460
21bf1558 JM	461	default:
	462	gcc_unreachable ();
	463	}
	464	}
	465	}