From patchwork Wed Jun 23 00:50:35 2010 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Joseph Myers X-Patchwork-Id: 56580 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) by ozlabs.org (Postfix) with SMTP id B9C3BB6EF1 for ; Wed, 23 Jun 2010 10:51:05 +1000 (EST) Received: (qmail 24773 invoked by alias); 23 Jun 2010 00:51:01 -0000 Received: (qmail 24652 invoked by uid 22791); 23 Jun 2010 00:50:50 -0000 X-SWARE-Spam-Status: No, hits=-1.8 required=5.0 tests=AWL, BAYES_00, TW_YY, T_RP_MATCHES_RCVD X-Spam-Check-By: sourceware.org Received: from mail.codesourcery.com (HELO mail.codesourcery.com) (38.113.113.100) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Wed, 23 Jun 2010 00:50:38 +0000 Received: (qmail 13422 invoked from network); 23 Jun 2010 00:50:36 -0000 Received: from unknown (HELO digraph.polyomino.org.uk) (joseph@127.0.0.2) by mail.codesourcery.com with ESMTPA; 23 Jun 2010 00:50:36 -0000 Received: from jsm28 (helo=localhost) by digraph.polyomino.org.uk with local-esmtp (Exim 4.69) (envelope-from ) id 1OREAl-0006Pn-6l; Wed, 23 Jun 2010 00:50:35 +0000 Date: Wed, 23 Jun 2010 00:50:35 +0000 (UTC) From: "Joseph S. Myers" To: gcc-patches@gcc.gnu.org cc: fortran@gcc.gnu.org, java-patches@gcc.gnu.org Subject: Move handle_option and read_cmdline_option to opts-common.c Message-ID: MIME-Version: 1.0 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org This patch is relative to a tree with and applied. The former needs C++ and Ada pieces approved; the latter needs C++ pieces approved. Continuing the work towards sharing option processing code between the driver and the compiler proper, this patch moves handle_option and read_cmdline_option, and the set_option function they use, into opts-common.c. In various places where these functions do things that may not be appropriate in the driver at least initially, appropriate callbacks are provided, and a cl_option_handlers structure is used to describe these callbacks. The set of callbacks is needed by recursive handle_option calls (from options enabling other options) and so some prototypes, including for the handle_option langhook, are adjusted to pass the handlers pointer. The handle_option langhook is also adjusted to have a boolean return value; the comments suggested a tristate return value but nothing used or acted on a negative return value as was suggested in the comments. The Ada hook had useless checks for missing option arguments (erroneous options don't get passed to these handlers), which I removed. The argument order of the handle_option function is adjusted to match that of various related functions, by swapping the arg and value operands. Bootstrapped with no regressions on x86_64-unknown-linux-gnu. OK to commit? 2010-06-22 Joseph Myers * coretypes.h (struct cl_option_handlers): Declare. * hooks.c (hook_int_size_t_constcharptr_int_0): Remove. * hooks.h (hook_int_size_t_constcharptr_int_0): Remove. * langhooks-def.h (lhd_handle_option): Declare. (LANG_HOOKS_HANDLE_OPTION): Use lhd_handle_option. * langhooks.c (lhd_handle_option): New. * langhooks.h (struct lang_hooks): Update prototype and return value type of handle_option hook. * optc-gen.awk: Generate target_flags_explicit definition for the driver. * opts-common.c: Include diagnostic.h. (handle_option): Move from opts.c. Update prototype and return value type. Use handlers structure. (read_cmdline_option): Move from opts.c. Update prototype. Use handlers structure. (set_option): Move from opts.c. * opts.c (common_handle_option): Update prototype and return value type. Update calls to handle_option and enable_warning_as_error. (unknown_option_callback, post_handling_callback, lang_handle_option, target_handle_option): New. (handle_option, read_cmdline_option): Move to opts-common.c. (read_cmdline_options): Update prototype. Update call to read_cmdline_option. (decode_options): Initialize and use handlers structure. (set_option): Move to opts-common.c. (enable_warning_as_error): Update prototype. Update call to handle_option. * opts.h (struct cl_option_handler_func, struct cl_option_handlers): New. (handle_option, enable_warning_as_error): Update prototypes. (read_cmdline_option): Declare. * Makefile.in (opts-common.o): Update dependencies. ada: 2010-06-22 Joseph Myers * gcc-interface/misc.c (gnat_handle_option): Update prototype and return value type. Don't check for missing arguments here. c-family: 2010-06-22 Joseph Myers * c-common.h (c_common_handle_option): Update prototype and return value type. * c-opts.c (c_common_handle_option): Update prototype and return value type. Update calls to handle_option and enable_warning_as_error. fortran: 2010-06-22 Joseph Myers * gfortran.h (gfc_handle_option): Update prototype and return value type. * options.c (gfc_handle_option): Update prototype and return value type. java: 2010-06-22 Joseph Myers * lang.c (java_handle_option): Update prototype and return value type. lto: 2010-06-22 Joseph Myers * lto-lang.c (lto_handle_option): Update prototype and return value type. Remove duplicate assignment to result. 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