flag-types.h (struct visibility_flags): Don't declare here.

	* flag-types.h (struct visibility_flags): Don't declare here.
	* flags.h (strip_off_ending, fast_math_flags_set_p,
	fast_math_flags_struct_set_p): Declare here.
	(visibility_options): Don't declare here.
	* opts-common.c (option_enabled, get_option_state): Move from
	opts.c.
	* opts-global.c: Include diagnostic.h instead of
	diagnostic-core.h.  Include tree.h, langhooks.h, lto-streamer.h
	and toplev.h.
	(const_char_p, ignored_options, in_fnames, num_in_fnames,
	write_langs, complain_wrong_lang, postpone_unknown_option_warning,
	print_ignored_options, unknown_option_callback,
	post_handling_callback, lang_handle_option, add_input_filename,
	read_cmdline_options, initial_lang_mask, init_options_once,
	decode_cmdline_options_to_array_default_mask,
	set_default_handlers, decode_options): Move from opts.c.
	(print_ignored_options): Use warning_at instead of saving and
	restoring input_location.
	* opts.c: Include <signal.h> and <sys/resource.h>.  Include rtl.h
	instead of expr.h.  Don't include langhooks.h, except.h or
	lto-streamer.h.  Add more comments on includes.
	(strip_off_ending, setup_core_dumping, decode_d_option): Move from
	toplev.c.
	(visibility_options): Move to c-family/c-common.c.
	(const_char_p, ignored_options, in_fnames, num_in_fnames,
	write_langs, complain_wrong_lang, postpone_unknown_option_warning,
	print_ignored_options, unknown_option_callback,
	post_handling_callback, lang_handle_option, add_input_filename,
	read_cmdline_options, initial_lang_mask, init_options_once,
	decode_cmdline_options_to_array_default_mask,
	set_default_handlers, decode_options): Move to opts-global.c.
	(target_handle_option, default_options_optimization,
	finish_options, common_handle_option): Remove static.
	(option_enabled, get_option_state): Move to opts-common.c.
	* opts.h (common_handle_option, target_handle_option,
	finish_options, default_options_optimization): Declare.
	* toplev.c: Don't include <signal.h> or <sys/resource.h>.
	(setup_core_dumping, strip_off_ending, decode_d_option): Move to
	opts.c.
	* toplev.h (strip_off_ending, decode_d_option,
	fast_math_flags_set_p, fast_math_flags_struct_set_p): Don't
	declare here.
	* Makefile.in (opts.o, opts-global.o): Update dependencies.

c-family:
	* c-common.c (visibility_options): Move from ../opts.c.
	* c-common.h (struct visibility_flags, visibility_options):
	Declare here.
	* c-opts.c (finish_options): Rename to c_finish_options.
	(c_common_init): Update call to finish_options.

From-SVN: r167105

1 files changed, 301 insertions, 1 deletions

diff --git a/gcc/opts-global.c b/gcc/opts-global.c
index e4e62dbc36f..3ed562d465f 100644
--- a/gcc/opts-global.c
+++ b/gcc/opts-global.c
@@ -22,16 +22,316 @@ along with GCC; see the file COPYING3.  If not see
 #include "config.h"
 #include "system.h"
 #include "coretypes.h"
-#include "diagnostic-core.h"
+#include "diagnostic.h"
 #include "opts.h"
 #include "flags.h"
 #include "ggc.h"
+#include "tree.h" /* Required by langhooks.h.  */
+#include "langhooks.h"
 #include "tm.h" /* Required by rtl.h.  */
 #include "rtl.h"
+#include "lto-streamer.h"
 #include "output.h"
 #include "plugin.h"
+#include "toplev.h"
 #include "tree-pass.h"
 
+typedef const char *const_char_p; /* For DEF_VEC_P.  */
+DEF_VEC_P(const_char_p);
+DEF_VEC_ALLOC_P(const_char_p,heap);
+
+static VEC(const_char_p,heap) *ignored_options;
+
+/* Input file names.  */
+const char **in_fnames;
+unsigned num_in_fnames;
+
+/* Return a malloced slash-separated list of languages in MASK.  */
+
+static 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 unrecognised -Wno-* option should never change
+   whether the compilation succeeds or fails.  */
+
+static void
+postpone_unknown_option_warning (const char *opt)
+{
+  VEC_safe_push (const_char_p, heap, ignored_options, opt);
+}
+
+/* Produce a warning for each option previously buffered.  */
+
+void
+print_ignored_options (void)
+{
+  while (!VEC_empty (const_char_p, ignored_options))
+    {
+      const char *opt;
+
+      opt = VEC_pop (const_char_p, ignored_options);
+      warning_at (UNKNOWN_LOCATION, 0,
+		  "unrecognized command line option \"%s\"", 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;
+}
+
+/* Note that an option DECODED has been successfully handled with a
+   handler for mask MASK.  */
+
+static void
+post_handling_callback (const struct cl_decoded_option *decoded ATTRIBUTE_UNUSED,
+			unsigned int mask ATTRIBUTE_UNUSED)
+{
+#ifdef ENABLE_LTO
+  lto_register_user_option (decoded->opt_index, decoded->arg,
+			    decoded->value, mask);
+#endif
+}
+
+/* Handle a front-end option; arguments and return value as for
+   handle_option.  */
+
+static bool
+lang_handle_option (struct gcc_options *opts,
+		    struct gcc_options *opts_set,
+		    const struct cl_decoded_option *decoded,
+		    unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
+		    location_t loc,
+		    const struct cl_option_handlers *handlers,
+		    diagnostic_context *dc)
+{
+  gcc_assert (opts == &global_options);
+  gcc_assert (opts_set == &global_options_set);
+  gcc_assert (dc == global_dc);
+  gcc_assert (decoded->canonical_option_num_elements <= 2);
+  return lang_hooks.handle_option (decoded->opt_index, decoded->arg,
+				   decoded->value, kind, loc, handlers);
+}
+
+/* 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 (main_input_filename == NULL)
+	    {
+	      main_input_filename = decoded_options[i].arg;
+	      main_input_baselength
+		= base_of_path (main_input_filename, &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);
+}
+
+/* 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)
+{
+  handlers->unknown_option_callback = unknown_option_callback;
+  handlers->wrong_lang_callback = complain_wrong_lang;
+  handlers->post_handling_callback = post_handling_callback;
+  handlers->num_handlers = 3;
+  handlers->handlers[0].handler = lang_handle_option;
+  handlers->handlers[0].mask = initial_lang_mask;
+  handlers->handlers[1].handler = common_handle_option;
+  handlers->handlers[1].mask = CL_COMMON;
+  handlers->handlers[2].handler = target_handle_option;
+  handlers->handlers[2].mask = CL_TARGET;
+}
+
+/* Parse command line options and set default flag values.  Do minimal
+   options processing.  The decoded options are in *DECODED_OPTIONS
+   and *DECODED_OPTIONS_COUNT; settings go in OPTS, OPTS_SET and DC;
+   the options are located at LOC.  */
+void
+decode_options (struct gcc_options *opts, struct gcc_options *opts_set,
+		struct cl_decoded_option *decoded_options,
+		unsigned int decoded_options_count,
+		location_t loc, diagnostic_context *dc)
+{
+  struct cl_option_handlers handlers;
+
+  unsigned int lang_mask;
+
+  lang_mask = initial_lang_mask;
+
+  set_default_handlers (&handlers);
+
+  /* Enable -Werror=coverage-mismatch by default.  */
+  control_warning_option (OPT_Wcoverage_mismatch, (int) DK_ERROR, true,
+			  loc, lang_mask,
+			  &handlers, opts, opts_set, dc);
+
+  default_options_optimization (opts, opts_set,
+				decoded_options, decoded_options_count,
+				loc, lang_mask, &handlers, dc);
+
+#ifdef ENABLE_LTO
+  /* Clear any options currently held for LTO.  */
+  lto_clear_user_options ();
+#endif
+
+  read_cmdline_options (opts, opts_set,
+			decoded_options, decoded_options_count,
+			loc, lang_mask,
+			&handlers, dc);
+
+  finish_options (opts, opts_set);
+}
+
+/* Process common options that have been deferred until after the
+   handlers have been called for all options.  */
+
 void
 handle_common_deferred_options (void)
 {