diff -rupN --exclude=.svn gcc-mainline-opt2/gcc/Makefile.in gcc-mainline/gcc/Makefile.in
--- gcc-mainline-opt2/gcc/Makefile.in	2010-06-21 09:57:36.000000000 -0700
+++ gcc-mainline/gcc/Makefile.in	2010-06-22 15:24:00.000000000 -0700
@@ -2796,7 +2796,7 @@ opts.o : opts.c opts.h options.h $(TOPLE
    $(FLAGS_H) $(PARAMS_H) $(TREE_PASS_H) $(DBGCNT_H) debug.h \
    $(PLUGIN_H) $(EXCEPT_H) $(LTO_STREAMER_H) opts-diagnostic.h
 opts-common.o : opts-common.c opts.h $(CONFIG_H) $(SYSTEM_H) \
-   coretypes.h intl.h
+   coretypes.h intl.h $(DIAGNOSTIC_H)
 targhooks.o : targhooks.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TREE_H) \
    $(EXPR_H) $(TM_H) $(RTL_H) $(TM_P_H) $(FUNCTION_H) output.h $(TOPLEV_H) \
    $(MACHMODE_H) $(TARGET_DEF_H) $(TARGET_H) $(GGC_H) gt-targhooks.h \
diff -rupN --exclude=.svn gcc-mainline-opt2/gcc/ada/gcc-interface/misc.c gcc-mainline/gcc/ada/gcc-interface/misc.c
--- gcc-mainline-opt2/gcc/ada/gcc-interface/misc.c	2010-06-21 10:02:42.000000000 -0700
+++ gcc-mainline/gcc/ada/gcc-interface/misc.c	2010-06-22 16:02:04.000000000 -0700
@@ -65,7 +65,8 @@ static bool gnat_init			(void);
 static unsigned int gnat_option_lang_mask (void);
 static void gnat_init_options		(unsigned int,
 					 struct cl_decoded_option *);
-static int gnat_handle_option		(size_t, const char *, int, int);
+static bool gnat_handle_option		(size_t, const char *, int, int,
+					 const struct cl_option_handlers *);
 static bool gnat_post_options		(const char **);
 static alias_set_type gnat_get_alias_set (tree);
 static void gnat_print_decl		(FILE *, tree, int);
@@ -187,23 +188,16 @@ gnat_parse_file (int set_yydebug ATTRIBU
 
 /* Decode all the language specific options that cannot be decoded by GCC.
    The option decoding phase of GCC calls this routine on the flags that
-   it cannot decode.  Return the number of consecutive arguments from ARGV
-   that have been successfully decoded or 0 on failure.  */
+   are marked as Ada-specific.  Return true on success or false on failure.  */
 
-static int
+static bool
 gnat_handle_option (size_t scode, const char *arg, int value,
-		    int kind ATTRIBUTE_UNUSED)
+		    int kind ATTRIBUTE_UNUSED,
+		    const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED)
 {
-  const struct cl_option *option = &cl_options[scode];
   enum opt_code code = (enum opt_code) scode;
   char *q;
 
-  if (arg == NULL && (option->flags & (CL_JOINED | CL_SEPARATE)))
-    {
-      error ("missing argument to \"-%s\"", option->opt_text);
-      return 1;
-    }
-
   switch (code)
     {
     case OPT_I:
@@ -280,7 +274,7 @@ gnat_handle_option (size_t scode, const 
       gcc_unreachable ();
     }
 
-  return 1;
+  return true;
 }
 
 /* Return language mask for option processing.  */
diff -rupN --exclude=.svn gcc-mainline-opt2/gcc/c-family/c-common.h gcc-mainline/gcc/c-family/c-common.h
--- gcc-mainline-opt2/gcc/c-family/c-common.h	2010-06-21 14:38:50.000000000 -0700
+++ gcc-mainline/gcc/c-family/c-common.h	2010-06-22 15:08:11.000000000 -0700
@@ -652,7 +652,8 @@ extern void set_Wformat (int);
 extern tree handle_format_attribute (tree *, tree, tree, int, bool *);
 extern tree handle_format_arg_attribute (tree *, tree, tree, int, bool *);
 extern bool attribute_takes_identifier_p (const_tree);
-extern int c_common_handle_option (size_t code, const char *arg, int value, int kind);
+extern bool c_common_handle_option (size_t, const char *, int, int,
+				    const struct cl_option_handlers *);
 extern tree c_common_type_for_mode (enum machine_mode, int);
 extern tree c_common_type_for_size (unsigned int, int);
 extern tree c_common_fixed_point_type_for_size (unsigned int, unsigned int,
diff -rupN --exclude=.svn gcc-mainline-opt2/gcc/c-family/c-opts.c gcc-mainline/gcc/c-family/c-opts.c
--- gcc-mainline-opt2/gcc/c-family/c-opts.c	2010-06-21 14:53:58.000000000 -0700
+++ gcc-mainline/gcc/c-family/c-opts.c	2010-06-22 15:08:05.000000000 -0700
@@ -319,16 +319,15 @@ c_common_init_options (unsigned int deco
 }
 
 /* Handle switch SCODE with argument ARG.  VALUE is true, unless no-
-   form of an -f or -W option was given.  Returns 0 if the switch was
-   invalid, a negative number to prevent language-independent
-   processing in toplev.c (a hack necessary for the short-term).  */
-int
+   form of an -f or -W option was given.  Returns false if the switch was
+   invalid, true if valid.  Use HANDLERS in recursive handle_option calls.  */
+bool
 c_common_handle_option (size_t scode, const char *arg, int value,
-			int kind)
+			int kind, const struct cl_option_handlers *handlers)
 {
   const struct cl_option *option = &cl_options[scode];
   enum opt_code code = (enum opt_code) scode;
-  int result = 1;
+  bool result = true;
 
   /* Prevent resetting the language standard to a C dialect when the driver
      has already determined that we're looking at assembler input.  */
@@ -341,10 +340,10 @@ c_common_handle_option (size_t scode, co
 	{
 	  if ((option->flags & CL_TARGET)
 	      && ! targetcm.handle_c_option (scode, arg, value))
-	    result = 0;
+	    result = false;
 	  break;
 	}
-      result = 0;
+      result = false;
       break;
 
     case OPT__output_pch_:
@@ -438,7 +437,8 @@ c_common_handle_option (size_t scode, co
     case OPT_Wall:
       warn_unused = value;
       set_Wformat (value);
-      handle_option (OPT_Wimplicit, value, NULL, c_family_lang_mask, kind);
+      handle_option (OPT_Wimplicit, NULL, value, c_family_lang_mask, kind,
+		     handlers);
       warn_char_subscripts = value;
       warn_missing_braces = value;
       warn_parentheses = value;
@@ -524,7 +524,8 @@ c_common_handle_option (size_t scode, co
     case OPT_Werror_implicit_function_declaration:
       /* For backward compatibility, this is the same as
 	 -Werror=implicit-function-declaration.  */
-      enable_warning_as_error ("implicit-function-declaration", value, CL_C | CL_ObjC);
+      enable_warning_as_error ("implicit-function-declaration", value,
+			       CL_C | CL_ObjC, handlers);
       break;
 
     case OPT_Wformat:
@@ -538,11 +539,11 @@ c_common_handle_option (size_t scode, co
     case OPT_Wimplicit:
       gcc_assert (value == 0 || value == 1);
       if (warn_implicit_int == -1)
-	handle_option (OPT_Wimplicit_int, value, NULL,
-		       c_family_lang_mask, kind);
+	handle_option (OPT_Wimplicit_int, NULL, value,
+		       c_family_lang_mask, kind, handlers);
       if (warn_implicit_function_declaration == -1)
-	handle_option (OPT_Wimplicit_function_declaration, value, NULL,
-		       c_family_lang_mask, kind);
+	handle_option (OPT_Wimplicit_function_declaration, NULL, value,
+		       c_family_lang_mask, kind, handlers);
       break;
 
     case OPT_Wimport:
@@ -655,7 +656,7 @@ c_common_handle_option (size_t scode, co
 
     case OPT_fbuiltin_:
       if (value)
-	result = 0;
+	result = false;
       else
 	disable_builtin_function (arg);
       break;
diff -rupN --exclude=.svn gcc-mainline-opt2/gcc/coretypes.h gcc-mainline/gcc/coretypes.h
--- gcc-mainline-opt2/gcc/coretypes.h	2010-06-21 10:02:42.000000000 -0700
+++ gcc-mainline/gcc/coretypes.h	2010-06-22 14:34:22.000000000 -0700
@@ -68,6 +68,7 @@ struct cl_target_option;
 struct cl_optimization;
 struct cl_option;
 struct cl_decoded_option;
+struct cl_option_handlers;
 struct gimple_seq_d;
 typedef struct gimple_seq_d *gimple_seq;
 typedef const struct gimple_seq_d *const_gimple_seq;
diff -rupN --exclude=.svn gcc-mainline-opt2/gcc/fortran/gfortran.h gcc-mainline/gcc/fortran/gfortran.h
--- gcc-mainline-opt2/gcc/fortran/gfortran.h	2010-06-21 10:02:42.000000000 -0700
+++ gcc-mainline/gcc/fortran/gfortran.h	2010-06-22 15:08:23.000000000 -0700
@@ -2346,7 +2346,8 @@ int get_c_kind (const char *, CInteropKi
 unsigned int gfc_option_lang_mask (void);
 void gfc_init_options (unsigned int,
 		       struct cl_decoded_option *);
-int gfc_handle_option (size_t, const char *, int, int);
+bool gfc_handle_option (size_t, const char *, int, int,
+			const struct cl_option_handlers *);
 bool gfc_post_options (const char **);
 
 /* f95-lang.c */
diff -rupN --exclude=.svn gcc-mainline-opt2/gcc/fortran/options.c gcc-mainline/gcc/fortran/options.c
--- gcc-mainline-opt2/gcc/fortran/options.c	2010-06-21 10:02:42.000000000 -0700
+++ gcc-mainline/gcc/fortran/options.c	2010-06-22 15:08:27.000000000 -0700
@@ -542,20 +542,21 @@ gfc_handle_runtime_check_option (const c
 /* Handle command-line options.  Returns 0 if unrecognized, 1 if
    recognized and handled.  */
 
-int
+bool
 gfc_handle_option (size_t scode, const char *arg, int value,
-		   int kind ATTRIBUTE_UNUSED)
+		   int kind ATTRIBUTE_UNUSED,
+		   const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED)
 {
-  int result = 1;
+  bool result = true;
   enum opt_code code = (enum opt_code) scode;
 
   if (gfc_cpp_handle_option (scode, arg, value) == 1)
-    return 1;
+    return true;
 
   switch (code)
     {
     default:
-      result = 0;
+      result = false;
       break;
 
     case OPT_Wall:
diff -rupN --exclude=.svn gcc-mainline-opt2/gcc/hooks.c gcc-mainline/gcc/hooks.c
--- gcc-mainline-opt2/gcc/hooks.c	2010-06-21 14:38:03.000000000 -0700
+++ gcc-mainline/gcc/hooks.c	2010-06-22 14:31:06.000000000 -0700
@@ -160,14 +160,6 @@ hook_int_rtx_bool_0 (rtx a ATTRIBUTE_UNU
   return 0;
 }
 
-int
-hook_int_size_t_constcharptr_int_0 (size_t a ATTRIBUTE_UNUSED,
-				    const char *b ATTRIBUTE_UNUSED,
-				    int c ATTRIBUTE_UNUSED)
-{
-  return 0;
-}
-
 unsigned int
 hook_uint_void_0 (void)
 {
diff -rupN --exclude=.svn gcc-mainline-opt2/gcc/hooks.h gcc-mainline/gcc/hooks.h
--- gcc-mainline-opt2/gcc/hooks.h	2010-06-21 14:38:18.000000000 -0700
+++ gcc-mainline/gcc/hooks.h	2010-06-22 14:31:17.000000000 -0700
@@ -63,7 +63,6 @@ extern int hook_int_const_tree_0 (const_
 extern int hook_int_const_tree_const_tree_1 (const_tree, const_tree);
 extern int hook_int_rtx_0 (rtx);
 extern int hook_int_rtx_bool_0 (rtx, bool);
-extern int hook_int_size_t_constcharptr_int_0 (size_t, const char *, int);
 
 extern tree hook_tree_const_tree_null (const_tree);
 
diff -rupN --exclude=.svn gcc-mainline-opt2/gcc/java/lang.c gcc-mainline/gcc/java/lang.c
--- gcc-mainline-opt2/gcc/java/lang.c	2010-06-21 10:02:42.000000000 -0700
+++ gcc-mainline/gcc/java/lang.c	2010-06-22 15:08:40.000000000 -0700
@@ -51,7 +51,8 @@ static unsigned int java_option_lang_mas
 static void java_init_options (unsigned int, struct cl_decoded_option *);
 static bool java_post_options (const char **);
 
-static int java_handle_option (size_t scode, const char *arg, int value, int kind);
+static bool java_handle_option (size_t, const char *, int, int,
+				const struct cl_option_handlers *);
 static void put_decl_string (const char *, int);
 static void put_decl_node (tree, int);
 static void java_print_error_function (diagnostic_context *, const char *,
@@ -175,11 +176,12 @@ struct lang_hooks lang_hooks = LANG_HOOK
 
 /*
  * process java-specific compiler command-line options
- * return 0, but do not complain if the option is not recognized.
+ * return false, but do not complain if the option is not recognized.
  */
-static int
+static bool
 java_handle_option (size_t scode, const char *arg, int value,
-		    int kind ATTRIBUTE_UNUSED)
+		    int kind ATTRIBUTE_UNUSED,
+		    const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED)
 {
   enum opt_code code = (enum opt_code) scode;
 
@@ -270,7 +272,7 @@ java_handle_option (size_t scode, const 
 
     case OPT_fdump_:
       if (!dump_switch_p (arg))
-	return 0;
+	return false;
       break;
 
     case OPT_fencoding_:
@@ -299,7 +301,7 @@ java_handle_option (size_t scode, const 
       gcc_unreachable ();
     }
 
-  return 1;
+  return true;
 }
 
 /* Global open file.  */
diff -rupN --exclude=.svn gcc-mainline-opt2/gcc/langhooks-def.h gcc-mainline/gcc/langhooks-def.h
--- gcc-mainline-opt2/gcc/langhooks-def.h	2010-06-21 14:39:18.000000000 -0700
+++ gcc-mainline/gcc/langhooks-def.h	2010-06-22 15:13:56.000000000 -0700
@@ -69,6 +69,8 @@ extern void lhd_initialize_diagnostics (
 extern void lhd_init_options (unsigned int,
 			      struct cl_decoded_option *);
 extern bool lhd_complain_wrong_lang_p (const struct cl_option *);
+extern bool lhd_handle_option (size_t, const char *, int, int,
+			       const struct cl_option_handlers *);
 extern tree lhd_callgraph_analyze_expr (tree *, int *);
 
 
@@ -89,7 +91,7 @@ extern void lhd_omp_firstprivatize_type_
 #define LANG_HOOKS_INIT_OPTIONS		lhd_init_options
 #define LANG_HOOKS_INITIALIZE_DIAGNOSTICS lhd_initialize_diagnostics
 #define LANG_HOOKS_COMPLAIN_WRONG_LANG_P lhd_complain_wrong_lang_p
-#define LANG_HOOKS_HANDLE_OPTION	hook_int_size_t_constcharptr_int_0
+#define LANG_HOOKS_HANDLE_OPTION	lhd_handle_option
 #define LANG_HOOKS_POST_OPTIONS		lhd_post_options
 #define LANG_HOOKS_MISSING_NORETURN_OK_P hook_bool_tree_true
 #define LANG_HOOKS_GET_ALIAS_SET	lhd_get_alias_set
diff -rupN --exclude=.svn gcc-mainline-opt2/gcc/langhooks.c gcc-mainline/gcc/langhooks.c
--- gcc-mainline-opt2/gcc/langhooks.c	2010-06-21 10:02:42.000000000 -0700
+++ gcc-mainline/gcc/langhooks.c	2010-06-22 15:08:49.000000000 -0700
@@ -351,6 +351,16 @@ lhd_complain_wrong_lang_p (const struct 
   return true;
 }
 
+/* By default, no language-specific options are valid.  */
+bool
+lhd_handle_option (size_t code ATTRIBUTE_UNUSED,
+		   const char *arg ATTRIBUTE_UNUSED,
+		   int value ATTRIBUTE_UNUSED, int kind ATTRIBUTE_UNUSED,
+		   const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED)
+{
+  return false;
+}
+
 /* The default function to print out name of current function that caused
    an error.  */
 void
diff -rupN --exclude=.svn gcc-mainline-opt2/gcc/langhooks.h gcc-mainline/gcc/langhooks.h
--- gcc-mainline-opt2/gcc/langhooks.h	2010-06-21 14:39:04.000000000 -0700
+++ gcc-mainline/gcc/langhooks.h	2010-06-22 15:08:54.000000000 -0700
@@ -292,11 +292,12 @@ struct lang_hooks
      which points to permanent storage.  The handler is responsible for
      checking whether ARG is NULL, which indicates that no argument
      was in fact supplied.  For -f and -W switches, VALUE is 1 or 0
-     for the positive and negative forms respectively.
+     for the positive and negative forms respectively.  HANDLERS should
+     be passed to any recursive handle_option calls.
 
-     Return 1 if the switch is valid, 0 if invalid, and -1 if it's
-     valid and should not be treated as language-independent too.  */
-  int (*handle_option) (size_t code, const char *arg, int value, int kind);
+     Return true if the switch is valid, false if invalid.  */
+  bool (*handle_option) (size_t code, const char *arg, int value, int kind,
+			 const struct cl_option_handlers *handlers);
 
   /* Called when all command line options have been parsed to allow
      further processing and initialization
diff -rupN --exclude=.svn gcc-mainline-opt2/gcc/lto/lto-lang.c gcc-mainline/gcc/lto/lto-lang.c
--- gcc-mainline-opt2/gcc/lto/lto-lang.c	2010-06-21 10:02:42.000000000 -0700
+++ gcc-mainline/gcc/lto/lto-lang.c	2010-06-22 15:09:02.000000000 -0700
@@ -630,18 +630,18 @@ lto_init_options (unsigned int decoded_o
    of the option was supplied.  */
 
 const char *resolution_file_name;
-static int
+static bool
 lto_handle_option (size_t scode, const char *arg,
-		   int value ATTRIBUTE_UNUSED, int kind ATTRIBUTE_UNUSED)
+		   int value ATTRIBUTE_UNUSED, int kind ATTRIBUTE_UNUSED,
+		   const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED)
 {
   enum opt_code code = (enum opt_code) scode;
-  int result = 1;
+  bool result = true;
 
   switch (code)
     {
     case OPT_fresolution_:
       resolution_file_name = arg;
-      result = 1;
       break;
 
     case OPT_Wabi:
diff -rupN --exclude=.svn gcc-mainline-opt2/gcc/optc-gen.awk gcc-mainline/gcc/optc-gen.awk
--- gcc-mainline-opt2/gcc/optc-gen.awk	2010-06-21 14:56:03.000000000 -0700
+++ gcc-mainline/gcc/optc-gen.awk	2010-06-22 15:25:22.000000000 -0700
@@ -73,6 +73,7 @@ print "#include " quote "intl.h" quote
 print ""
 print "#ifdef GCC_DRIVER"
 print "int target_flags;"
+print "int target_flags_explicit;"
 print "#else"
 print "#include " quote "flags.h" quote
 print "#include " quote "target.h" quote
diff -rupN --exclude=.svn gcc-mainline-opt2/gcc/opts-common.c gcc-mainline/gcc/opts-common.c
--- gcc-mainline-opt2/gcc/opts-common.c	2010-06-21 10:02:42.000000000 -0700
+++ gcc-mainline/gcc/opts-common.c	2010-06-22 15:23:48.000000000 -0700
@@ -23,6 +23,7 @@ along with GCC; see the file COPYING3.  
 #include "coretypes.h"
 #include "opts.h"
 #include "options.h"
+#include "diagnostic.h"
 
 /* Perform a binary search to find which option the command-line INPUT
    matches.  Returns its index in the option array, and
@@ -453,3 +454,135 @@ done:
 
   free (options);
 }
+
+/* Handle option OPT_INDEX, and argument ARG, for the language
+   indicated by LANG_MASK, using the handlers in HANDLERS.  VALUE is
+   the option value as for the value field of cl_decoded_option.  KIND
+   is the diagnostic_t if this is a diagnostics option, DK_UNSPECIFIED
+   otherwise.  Returns false if the switch was invalid.  */
+
+bool
+handle_option (size_t opt_index, const char *arg, int value,
+	       unsigned int lang_mask, int kind,
+	       const struct cl_option_handlers *handlers)
+{
+  const struct cl_option *option = &cl_options[opt_index];
+  size_t i;
+
+  if (option->flag_var)
+    set_option (opt_index, value, arg, kind);
+
+  for (i = 0; i < handlers->num_handlers; i++)
+    if (option->flags & handlers->handlers[i].mask)
+      {
+	if (!handlers->handlers[i].handler (opt_index, arg, value,
+					    lang_mask, kind, handlers))
+	  return false;
+	else
+	  handlers->post_handling_callback (opt_index, arg, value,
+					    handlers->handlers[i].mask);
+      }
+  
+  return true;
+}
+
+/* Handle the switch DECODED for the language indicated by LANG_MASK,
+   using the handlers in *HANDLERS.  */
+
+void
+read_cmdline_option (struct cl_decoded_option *decoded,
+		     unsigned int lang_mask,
+		     const struct cl_option_handlers *handlers)
+{
+  const struct cl_option *option;
+  const char *opt;
+
+  if (decoded->opt_index == OPT_SPECIAL_unknown)
+    {
+      opt = decoded->arg;
+
+      if (handlers->unknown_option_callback (opt))
+	error ("unrecognized command line option %qs", opt);
+      return;
+    }
+
+  option = &cl_options[decoded->opt_index];
+  opt = decoded->orig_option_with_args_text;
+
+  if (decoded->errors & CL_ERR_DISABLED)
+    {
+      error ("command line option %qs"
+	     " is not supported by this configuration", opt);
+      return;
+    }
+
+  if (decoded->errors & CL_ERR_WRONG_LANG)
+    {
+      handlers->wrong_lang_callback (opt, option, lang_mask);
+      return;
+    }
+
+  if (decoded->errors & CL_ERR_MISSING_ARG)
+    {
+      if (option->missing_argument_error)
+	error (option->missing_argument_error, opt);
+      else
+	error ("missing argument to %qs", opt);
+      return;
+    }
+
+  if (decoded->errors & CL_ERR_UINT_ARG)
+    {
+      error ("argument to %qs should be a non-negative integer",
+	     option->opt_text);
+      return;
+    }
+
+  gcc_assert (!decoded->errors);
+
+  if (!handle_option (decoded->opt_index, decoded->arg, decoded->value,
+		      lang_mask, DK_UNSPECIFIED, handlers))
+    error ("unrecognized command line option %qs", opt);
+}
+
+/* Set any variable for option OPT_INDEX according to VALUE and ARG,
+   diagnostic kind KIND.  */
+
+void
+set_option (int opt_index, int value, const char *arg, int kind)
+{
+  const struct cl_option *option = &cl_options[opt_index];
+
+  if (!option->flag_var)
+    return;
+
+  switch (option->var_type)
+    {
+    case CLVC_BOOLEAN:
+	*(int *) option->flag_var = value;
+	break;
+
+    case CLVC_EQUAL:
+	*(int *) option->flag_var = (value
+				     ? option->var_value
+				     : !option->var_value);
+	break;
+
+    case CLVC_BIT_CLEAR:
+    case CLVC_BIT_SET:
+	if ((value != 0) == (option->var_type == CLVC_BIT_SET))
+	  *(int *) option->flag_var |= option->var_value;
+	else
+	  *(int *) option->flag_var &= ~option->var_value;
+	if (option->flag_var == &target_flags)
+	  target_flags_explicit |= option->var_value;
+	break;
+
+    case CLVC_STRING:
+	*(const char **) option->flag_var = arg;
+	break;
+    }
+
+  if ((diagnostic_t) kind != DK_UNSPECIFIED)
+    diagnostic_classify_diagnostic (global_dc, opt_index, (diagnostic_t) kind);
+}
diff -rupN --exclude=.svn gcc-mainline-opt2/gcc/opts.c gcc-mainline/gcc/opts.c
--- gcc-mainline-opt2/gcc/opts.c	2010-06-21 14:40:58.000000000 -0700
+++ gcc-mainline/gcc/opts.c	2010-06-22 15:22:33.000000000 -0700
@@ -372,8 +372,9 @@ bool flag_warn_unused_result = false;
 const char **in_fnames;
 unsigned num_in_fnames;
 
-static int common_handle_option (size_t scode, const char *arg, int value,
-				 unsigned int lang_mask, int kind);
+static bool common_handle_option (size_t scode, const char *arg, int value,
+				  unsigned int lang_mask, int kind,
+				  const struct cl_option_handlers *handlers);
 static void handle_param (const char *);
 static char *write_langs (unsigned int lang_mask);
 static void complain_wrong_lang (const char *, const struct cl_option *,
@@ -460,112 +461,58 @@ void print_ignored_options (void)
   input_location = saved_loc;
 }
 
+/* Handle an unknown option ARG, returning true if an error should be
+   given.  */
 
-/* Handle option OPT_INDEX, and argument ARG, for the language
-   indicated by LANG_MASK.  VALUE is true, unless no- form of an -f or
-   -W option was given.  KIND is the diagnostic_t if this is a
-   diagnostics option, DK_UNSPECIFIED otherwise.  Returns false if the
-   switch was invalid.  */
-bool
-handle_option (int opt_index, int value, const char *arg,
-		unsigned int lang_mask, int kind)
+static bool
+unknown_option_callback (const char *opt)
 {
-  const struct cl_option *option = &cl_options[opt_index];
-
-  if (option->flag_var)
-    set_option (opt_index, value, arg, kind);
-  
-  if (option->flags & lang_mask)
+  if (opt[1] == 'W' && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-')
     {
-      if (lang_hooks.handle_option (opt_index, arg, value, kind) == 0)
-	return false;
-#ifdef ENABLE_LTO
-      else
-	lto_register_user_option (opt_index, arg, value, lang_mask);
- #endif
+      /* We don't generate warnings for unknown -Wno-* options unless
+	 we issue diagnostics.  */
+      postpone_unknown_option_warning (opt);
+      return false;
     }
+  else
+    return true;
+}
 
-  if (option->flags & CL_COMMON)
-    {
-      if (common_handle_option (opt_index, arg, value, lang_mask, kind) == 0)
-	return false;
-#ifdef ENABLE_LTO
-      else
-	lto_register_user_option (opt_index, arg, value, CL_COMMON);
-#endif
-    }
+/* Note that an option (index OPT_INDEX, argument ARG, value VALUE)
+   has been successfully handled with a handler for mask MASK.  */
 
-  if (option->flags & CL_TARGET)
-    {
-      if (!targetm.handle_option (opt_index, arg, value))
-	return false;
+static void
+post_handling_callback (size_t opt_index ATTRIBUTE_UNUSED,
+			const char *arg ATTRIBUTE_UNUSED,
+			int value ATTRIBUTE_UNUSED,
+			unsigned int mask ATTRIBUTE_UNUSED)
+{
 #ifdef ENABLE_LTO
-      else
-	lto_register_user_option (opt_index, arg, value, CL_TARGET);
+  lto_register_user_option (opt_index, arg, value, mask);
 #endif
-    }
-  return true;
 }
 
-/* Handle the switch DECODED for the language indicated by
-   LANG_MASK.  */
-static void
-read_cmdline_option (struct cl_decoded_option *decoded,
-		     unsigned int lang_mask)
-{
-  const struct cl_option *option;
-  const char *opt;
-
-  if (decoded->opt_index == OPT_SPECIAL_unknown)
-    {
-      opt = decoded->arg;
-
-      if (opt[1] == 'W' && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-')
-	/* We don't generate warnings for unknown -Wno-* options
-	   unless we issue diagnostics.  */
-	  postpone_unknown_option_warning (opt);
-      else
-	error ("unrecognized command line option %qs", opt);
-      return;
-    }
-
-  option = &cl_options[decoded->opt_index];
-  opt = decoded->orig_option_with_args_text;
+/* Handle a front-end option; arguments and return value as for
+   handle_option.  */
 
-  if (decoded->errors & CL_ERR_DISABLED)
-    {
-      error ("command line option %qs"
-	     " is not supported by this configuration", opt);
-      return;
-    }
-
-  if (decoded->errors & CL_ERR_WRONG_LANG)
-    {
-      complain_wrong_lang (opt, option, lang_mask);
-      return;
-    }
-
-  if (decoded->errors & CL_ERR_MISSING_ARG)
-    {
-      if (option->missing_argument_error)
-	error (option->missing_argument_error, opt);
-      else
-	error ("missing argument to %qs", opt);
-      return;
-    }
-
-  if (decoded->errors & CL_ERR_UINT_ARG)
-    {
-      error ("argument to %qs should be a non-negative integer",
-	     option->opt_text);
-      return;
-    }
+static bool
+lang_handle_option (size_t opt_index, const char *arg, int value,
+		    unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
+		    const struct cl_option_handlers *handlers)
+{
+  return lang_hooks.handle_option (opt_index, arg, value, kind, handlers);
+}
 
-  gcc_assert (!decoded->errors);
+/* Handle a back-end option; arguments and return value as for
+   handle_option.  */
 
-  if (!handle_option (decoded->opt_index, decoded->value, decoded->arg,
-		      lang_mask, DK_UNSPECIFIED))
-    error ("unrecognized command line option %qs", opt);
+static bool
+target_handle_option (size_t opt_index, const char *arg, int value,
+		    unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
+		    const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED)
+{
+  gcc_assert (kind == DK_UNSPECIFIED);
+  return targetm.handle_option (opt_index, arg, value);
 }
 
 /* Handle FILENAME from the command line.  */
@@ -659,11 +606,12 @@ flag_instrument_functions_exclude_p (tre
 
 /* Handle the vector of command line options.  LANG_MASK
    contains has a single bit set representing the current
-   language.  */
+   language.  HANDLERS describes what functions to call for the options.  */
 static void
 read_cmdline_options (struct cl_decoded_option *decoded_options,
 		      unsigned int decoded_options_count,
-		      unsigned int lang_mask)
+		      unsigned int lang_mask,
+		      const struct cl_option_handlers *handlers)
 {
   unsigned int i;
 
@@ -681,7 +629,7 @@ read_cmdline_options (struct cl_decoded_
 	  continue;
 	}
 
-      read_cmdline_option (decoded_options + i, lang_mask);
+      read_cmdline_option (decoded_options + i, lang_mask, handlers);
     }
 }
 
@@ -698,6 +646,7 @@ decode_options (unsigned int argc, const
   static int initial_max_fields_for_field_sensitive;
   static int initial_loop_invariant_max_bbs_in_loop;
   static unsigned int initial_lang_mask;
+  struct cl_option_handlers handlers;
 
   unsigned int i, lang_mask;
   int opt1;
@@ -730,6 +679,17 @@ decode_options (unsigned int argc, const
     /* Perform language-specific options initialization.  */
     lang_hooks.init_options (*decoded_options_count, *decoded_options);
 
+  handlers.unknown_option_callback = unknown_option_callback;
+  handlers.wrong_lang_callback = complain_wrong_lang;
+  handlers.post_handling_callback = post_handling_callback;
+  handlers.num_handlers = 3;
+  handlers.handlers[0].handler = lang_handle_option;
+  handlers.handlers[0].mask = lang_mask;
+  handlers.handlers[1].handler = common_handle_option;
+  handlers.handlers[1].mask = CL_COMMON;
+  handlers.handlers[2].handler = target_handle_option;
+  handlers.handlers[2].mask = CL_TARGET;
+
   /* Scan to see what optimization level has been specified.  That will
      determine the default value of many flags.  */
   for (i = 1; i < *decoded_options_count; i++)
@@ -903,7 +863,7 @@ decode_options (unsigned int argc, const
     }
 
   /* Enable -Werror=coverage-mismatch by default */
-  enable_warning_as_error("coverage-mismatch", 1, lang_mask);
+  enable_warning_as_error ("coverage-mismatch", 1, lang_mask, &handlers);
 
   if (first_time_p)
     {
@@ -931,7 +891,8 @@ decode_options (unsigned int argc, const
   OPTIMIZATION_OPTIONS (optimize, optimize_size);
 #endif
 
-  read_cmdline_options (*decoded_options, *decoded_options_count, lang_mask);
+  read_cmdline_options (*decoded_options, *decoded_options_count, lang_mask,
+			&handlers);
 
   if (dump_base_name && ! IS_ABSOLUTE_PATH (dump_base_name))
     {
@@ -1425,9 +1386,10 @@ print_specific_help (unsigned int includ
    extra handling need to be listed here; if you simply want
    VALUE assigned to a variable, it happens automatically.  */
 
-static int
+static bool
 common_handle_option (size_t scode, const char *arg, int value,
-		      unsigned int lang_mask, int kind ATTRIBUTE_UNUSED)
+		      unsigned int lang_mask, int kind ATTRIBUTE_UNUSED,
+		      const struct cl_option_handlers *handlers)
 {
   static bool verbose = false;
   enum opt_code code = (enum opt_code) scode;
@@ -1609,7 +1571,7 @@ common_handle_option (size_t scode, cons
       break;
 
     case OPT_Werror_:
-      enable_warning_as_error (arg, value, lang_mask);
+      enable_warning_as_error (arg, value, lang_mask, handlers);
       break;
 
     case OPT_Wlarger_than_:
@@ -1735,7 +1697,7 @@ common_handle_option (size_t scode, cons
 	diagnostic_prefixing_rule (global_dc)
 	  = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
       else
-	return 0;
+	return false;
       break;
 
     case OPT_fdiagnostics_show_option:
@@ -1744,7 +1706,7 @@ common_handle_option (size_t scode, cons
 
     case OPT_fdump_:
       if (!dump_switch_p (arg))
-	return 0;
+	return false;
       break;
 
     case OPT_fexcess_precision_:
@@ -1908,7 +1870,7 @@ common_handle_option (size_t scode, cons
     case OPT_frandom_seed:
       /* The real switch is -fno-random-seed.  */
       if (value)
-	return 0;
+	return false;
       set_random_seed (NULL);
       break;
 
@@ -1926,7 +1888,7 @@ common_handle_option (size_t scode, cons
       fix_sched_param ("verbose", arg);
       break;
 #else
-      return 0;
+      return false;
 #endif
 
     case OPT_fsched_stalled_insns_:
@@ -1973,7 +1935,7 @@ common_handle_option (size_t scode, cons
     case OPT_fstack_limit:
       /* The real switch is -fno-stack-limit.  */
       if (value)
-	return 0;
+	return false;
       stack_limit_rtx = NULL_RTX;
       break;
 
@@ -2140,7 +2102,7 @@ common_handle_option (size_t scode, cons
       break;
     }
 
-  return 1;
+  return true;
 }
 
 /* Handle --param NAME=VALUE.  */
@@ -2355,48 +2317,6 @@ get_option_state (int option, struct cl_
   return true;
 }
 
-/* Set *OPTION according to VALUE and ARG.  */
-
-void
-set_option (int opt_index, int value, const char *arg, int kind)
-{
-  const struct cl_option *option = &cl_options[opt_index];
-
-  if (!option->flag_var)
-    return;
-
-  switch (option->var_type)
-    {
-    case CLVC_BOOLEAN:
-	*(int *) option->flag_var = value;
-	break;
-
-    case CLVC_EQUAL:
-	*(int *) option->flag_var = (value
-				     ? option->var_value
-				     : !option->var_value);
-	break;
-
-    case CLVC_BIT_CLEAR:
-    case CLVC_BIT_SET:
-	if ((value != 0) == (option->var_type == CLVC_BIT_SET))
-	  *(int *) option->flag_var |= option->var_value;
-	else
-	  *(int *) option->flag_var &= ~option->var_value;
-	if (option->flag_var == &target_flags)
-	  target_flags_explicit |= option->var_value;
-	break;
-
-    case CLVC_STRING:
-	*(const char **) option->flag_var = arg;
-	break;
-    }
-
-  if ((diagnostic_t)kind != DK_UNSPECIFIED)
-    diagnostic_classify_diagnostic (global_dc, opt_index, (diagnostic_t)kind);
-}
-
-
 /* Callback function, called when -Werror= enables a warning.  */
 
 static void (*warning_as_error_callback) (int) = NULL;
@@ -2414,7 +2334,8 @@ register_warning_as_error_callback (void
    also by legacy Werror-implicit-function-declaration.  */
 
 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)
 {
   char *new_option;
   int option_index;
@@ -2438,7 +2359,8 @@ enable_warning_as_error (const char *arg
 
 	  /* -Werror=foo implies -Wfoo.  */
 	  if (option->var_type == CLVC_BOOLEAN)
-	    handle_option (option_index, value, arg, lang_mask, (int)kind);
+	    handle_option (option_index, arg, value, lang_mask, (int)kind,
+			   handlers);
 
 	  if (warning_as_error_callback)
 	    warning_as_error_callback (option_index);
diff -rupN --exclude=.svn gcc-mainline-opt2/gcc/opts.h gcc-mainline/gcc/opts.h
--- gcc-mainline-opt2/gcc/opts.h	2010-06-21 15:24:55.000000000 -0700
+++ gcc-mainline/gcc/opts.h	2010-06-22 15:15:44.000000000 -0700
@@ -135,6 +135,47 @@ struct cl_decoded_option
   int errors;
 };
 
+/* Structure describing a single option-handling callback.  */
+
+struct cl_option_handler_func
+{
+  /* The function called to handle the option.  */
+  bool (*handler) (size_t opt_index, const char *arg, int value,
+		   unsigned int lang_mask, int kind,
+		   const struct cl_option_handlers *handlers);
+
+  /* The mask that must have some bit in common with the flags for the
+     option for this particular handler to be used.  */
+  unsigned int mask;
+};
+
+/* Structure describing the callbacks used in handling options.  */
+
+struct cl_option_handlers
+{
+  /* Callback for an unknown option to determine whether to give an
+     error for it, and possibly store information to diagnose the
+     option at a later point.  Return true if an error should be
+     given, false otherwise.  */
+  bool (*unknown_option_callback) (const char *opt);
+
+  /* Callback to handle, and possibly diagnose, an option for another
+     language.  */
+  void (*wrong_lang_callback) (const char *text,
+			       const struct cl_option *option,
+			       unsigned int lang_mask);
+
+  /* Callback to call after the successful handling of any option.  */
+  void (*post_handling_callback) (size_t opt_index, const char *arg,
+				  int value, unsigned int mask);
+
+  /* The number of individual handlers.  */
+  size_t num_handlers;
+
+  /* The handlers themselves.  */
+  struct cl_option_handler_func handlers[3];
+};
+
 /* Input file names.  */
 
 extern const char **in_fnames;
@@ -157,10 +198,15 @@ extern void decode_options (unsigned int
 extern int option_enabled (int opt_idx);
 extern bool get_option_state (int, struct cl_option_state *);
 extern void set_option (int opt_index, int value, const char *arg, int);
-bool handle_option (int opt_index, int value, const char *arg,
-		    unsigned int lang_mask, int kind);
+bool handle_option (size_t opt_index, const char *arg, int value,
+		    unsigned int lang_mask, int kind,
+		    const struct cl_option_handlers *handlers);
+extern void read_cmdline_option (struct cl_decoded_option *decoded,
+				 unsigned int lang_mask,
+				 const struct cl_option_handlers *handlers);
 extern void register_warning_as_error_callback (void (*callback) (int));
 extern void enable_warning_as_error (const char *arg, int value,
-				     unsigned int lang_mask);
+				     unsigned int lang_mask,
+				     const struct cl_option_handlers *handlers);
 extern void print_ignored_options (void);
 #endif
