+2010-07-27 Joseph Myers <joseph@codesourcery.com>
+
+ * 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.
+
2010-07-27 Maxim Kuvyrkov <maxim@codesourcery.com>
* config/arm/arm.c (params.h): Include.
$(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 options.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) $(DIAGNOSTIC_CORE_H) \
$(MACHMODE_H) $(TARGET_DEF_H) $(TARGET_H) $(GGC_H) gt-targhooks.h \
+2010-07-27 Joseph Myers <joseph@codesourcery.com>
+
+ * gcc-interface/misc.c (gnat_handle_option): Update prototype and
+ return value type. Don't check for missing arguments here.
+
2010-07-27 Joseph Myers <joseph@codesourcery.com>
* gcc-interface/misc.c (gnat_option_lang_mask): New.
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);
/* 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
-gnat_handle_option (size_t scode, const char *arg, int value,
- int kind ATTRIBUTE_UNUSED)
+static bool
+gnat_handle_option (size_t scode, const char *arg ATTRIBUTE_UNUSED, int value,
+ 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;
- if (arg == NULL && (option->flags & (CL_JOINED | CL_SEPARATE)))
- {
- error ("missing argument to \"-%s\"", option->opt_text);
- return 1;
- }
-
switch (code)
{
case OPT_Wall:
gcc_unreachable ();
}
- return 1;
+ return true;
}
/* Return language mask for option processing. */
+2010-07-27 Joseph Myers <joseph@codesourcery.com>
+
+ * 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.
+
2010-07-27 Jakub Jelinek <jakub@redhat.com>
PR c/45079
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,
}
/* 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. */
{
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_:
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;
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:
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:
case OPT_fbuiltin_:
if (value)
- result = 0;
+ result = false;
else
disable_builtin_function (arg);
break;
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;
+2010-07-27 Joseph Myers <joseph@codesourcery.com>
+
+ * gfortran.h (gfc_handle_option): Update prototype and return
+ value type.
+ * options.c (gfc_handle_option): Update prototype and return value
+ type.
+
2010-07-27 Joseph Myers <joseph@codesourcery.com>
* cpp.c (gfc_cpp_init_options): Update prototype. Use number of
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 */
/* 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:
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)
{
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);
+2010-07-27 Joseph Myers <joseph@codesourcery.com>
+
+ * lang.c (java_handle_option): Update prototype and return value
+ type.
+
2010-07-27 Joseph Myers <joseph@codesourcery.com>
* lang.c (java_option_lang_mask): New.
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 *,
/*
* 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;
case OPT_fdump_:
if (!dump_switch_p (arg))
- return 0;
+ return false;
break;
case OPT_fencoding_:
gcc_unreachable ();
}
- return 1;
+ return true;
}
/* Global open file. */
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 *);
#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
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
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
+2010-07-27 Joseph Myers <joseph@codesourcery.com>
+
+ * lto-lang.c (lto_handle_option): Update prototype and return
+ value type. Remove duplicate assignment to result.
+
2010-07-27 Joseph Myers <joseph@codesourcery.com>
* lto-lang.c (lto_option_lang_mask, lto_complain_wrong_lang_p):
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:
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
#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
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,
+ UNKNOWN_LOCATION);
+}
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 *,
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;
-
- 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;
- }
+/* Handle a front-end option; arguments and return value as for
+ handle_option. */
- 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. */
/* 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;
continue;
}
- read_cmdline_option (decoded_options + i, lang_mask);
+ read_cmdline_option (decoded_options + i, lang_mask, handlers);
}
}
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;
/* 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++)
}
/* 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)
{
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))
{
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;
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_:
diagnostic_prefixing_rule (global_dc)
= DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
else
- return 0;
+ return false;
break;
case OPT_fdiagnostics_show_option:
case OPT_fdump_:
if (!dump_switch_p (arg))
- return 0;
+ return false;
break;
case OPT_fexcess_precision_:
case OPT_frandom_seed:
/* The real switch is -fno-random-seed. */
if (value)
- return 0;
+ return false;
set_random_seed (NULL);
break;
fix_sched_param ("verbose", arg);
break;
#else
- return 0;
+ return false;
#endif
case OPT_fsched_stalled_insns_:
case OPT_fstack_limit:
/* The real switch is -fno-stack-limit. */
if (value)
- return 0;
+ return false;
stack_limit_rtx = NULL_RTX;
break;
break;
}
- return 1;
+ return true;
}
/* Handle --param NAME=VALUE. */
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,
- UNKNOWN_LOCATION);
-}
-
-
/* Callback function, called when -Werror= enables a warning. */
static void (*warning_as_error_callback) (int) = NULL;
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;
/* -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);
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;
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
projects / thirdparty / gcc.git / commitdiff
