URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [opts-global.c] - Rev 758
Go to most recent revision | Compare with Previous | Blame | View Log
/* Command line option handling. Code involving global state that should not be shared with the driver. Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. This file is part of GCC. GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version. GCC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see <http://www.gnu.org/licenses/>. */ #include "config.h" #include "system.h" #include "coretypes.h" #include "diagnostic.h" #include "opts.h" #include "flags.h" #include "ggc.h" #include "tree.h" /* Required by langhooks.h. */ #include "langhooks.h" #include "tm.h" /* Required by rtl.h. */ #include "rtl.h" #include "dbgcnt.h" #include "debug.h" #include "lto-streamer.h" #include "output.h" #include "plugin.h" #include "toplev.h" #include "tree-pass.h" typedef const char *const_char_p; /* For DEF_VEC_P. */ DEF_VEC_P(const_char_p); DEF_VEC_ALLOC_P(const_char_p,heap); static VEC(const_char_p,heap) *ignored_options; /* Input file names. */ const char **in_fnames; unsigned num_in_fnames; /* Return a malloced slash-separated list of languages in MASK. */ static char * write_langs (unsigned int mask) { unsigned int n = 0, len = 0; const char *lang_name; char *result; for (n = 0; (lang_name = lang_names[n]) != 0; n++) if (mask & (1U << n)) len += strlen (lang_name) + 1; result = XNEWVEC (char, len); len = 0; for (n = 0; (lang_name = lang_names[n]) != 0; n++) if (mask & (1U << n)) { if (len) result[len++] = '/'; strcpy (result + len, lang_name); len += strlen (lang_name); } result[len] = 0; return result; } /* Complain that switch DECODED does not apply to this front end (mask LANG_MASK). */ static void complain_wrong_lang (const struct cl_decoded_option *decoded, unsigned int lang_mask) { const struct cl_option *option = &cl_options[decoded->opt_index]; const char *text = decoded->orig_option_with_args_text; char *ok_langs = NULL, *bad_lang = NULL; unsigned int opt_flags = option->flags; if (!lang_hooks.complain_wrong_lang_p (option)) return; opt_flags &= ((1U << cl_lang_count) - 1) | CL_DRIVER; if (opt_flags != CL_DRIVER) ok_langs = write_langs (opt_flags); if (lang_mask != CL_DRIVER) bad_lang = write_langs (lang_mask); if (opt_flags == CL_DRIVER) error ("command line option %qs is valid for the driver but not for %s", text, bad_lang); else if (lang_mask == CL_DRIVER) gcc_unreachable (); else /* Eventually this should become a hard error IMO. */ warning (0, "command line option %qs is valid for %s but not for %s", text, ok_langs, bad_lang); free (ok_langs); free (bad_lang); } /* Buffer the unknown option described by the string OPT. Currently, we only complain about unknown -Wno-* options if they may have prevented a diagnostic. Otherwise, we just ignore them. Note that if we do complain, it is only as a warning, not an error; passing the compiler an unrecognised -Wno-* option should never change whether the compilation succeeds or fails. */ static void postpone_unknown_option_warning (const char *opt) { VEC_safe_push (const_char_p, heap, ignored_options, opt); } /* Produce a warning for each option previously buffered. */ void print_ignored_options (void) { while (!VEC_empty (const_char_p, ignored_options)) { const char *opt; opt = VEC_pop (const_char_p, ignored_options); warning_at (UNKNOWN_LOCATION, 0, "unrecognized command line option \"%s\"", opt); } } /* Handle an unknown option DECODED, returning true if an error should be given. */ static bool unknown_option_callback (const struct cl_decoded_option *decoded) { const char *opt = decoded->arg; if (opt[1] == 'W' && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-' && !(decoded->errors & CL_ERR_NEGATIVE)) { /* We don't generate warnings for unknown -Wno-* options unless we issue diagnostics. */ postpone_unknown_option_warning (opt); return false; } else return true; } /* Handle a front-end option; arguments and return value as for handle_option. */ static bool lang_handle_option (struct gcc_options *opts, struct gcc_options *opts_set, const struct cl_decoded_option *decoded, unsigned int lang_mask ATTRIBUTE_UNUSED, int kind, location_t loc, const struct cl_option_handlers *handlers, diagnostic_context *dc) { gcc_assert (opts == &global_options); gcc_assert (opts_set == &global_options_set); gcc_assert (dc == global_dc); gcc_assert (decoded->canonical_option_num_elements <= 2); return lang_hooks.handle_option (decoded->opt_index, decoded->arg, decoded->value, kind, loc, handlers); } /* Handle FILENAME from the command line. */ static void add_input_filename (const char *filename) { num_in_fnames++; in_fnames = XRESIZEVEC (const char *, in_fnames, num_in_fnames); in_fnames[num_in_fnames - 1] = filename; } /* Handle the vector of command line options (located at LOC), storing the results of processing DECODED_OPTIONS and DECODED_OPTIONS_COUNT in OPTS and OPTS_SET and using DC for diagnostic state. LANG_MASK contains has a single bit set representing the current language. HANDLERS describes what functions to call for the options. */ static void read_cmdline_options (struct gcc_options *opts, struct gcc_options *opts_set, struct cl_decoded_option *decoded_options, unsigned int decoded_options_count, location_t loc, unsigned int lang_mask, const struct cl_option_handlers *handlers, diagnostic_context *dc) { unsigned int i; for (i = 1; i < decoded_options_count; i++) { if (decoded_options[i].opt_index == OPT_SPECIAL_input_file) { /* Input files should only ever appear on the main command line. */ gcc_assert (opts == &global_options); gcc_assert (opts_set == &global_options_set); if (opts->x_main_input_filename == NULL) { opts->x_main_input_filename = decoded_options[i].arg; opts->x_main_input_baselength = base_of_path (opts->x_main_input_filename, &opts->x_main_input_basename); } add_input_filename (decoded_options[i].arg); continue; } read_cmdline_option (opts, opts_set, decoded_options + i, loc, lang_mask, handlers, dc); } } /* Language mask determined at initialization. */ static unsigned int initial_lang_mask; /* Initialize global options-related settings at start-up. */ void init_options_once (void) { /* Perform language-specific options initialization. */ initial_lang_mask = lang_hooks.option_lang_mask (); lang_hooks.initialize_diagnostics (global_dc); } /* Decode command-line options to an array, like decode_cmdline_options_to_array and with the same arguments but using the default lang_mask. */ void decode_cmdline_options_to_array_default_mask (unsigned int argc, const char **argv, struct cl_decoded_option **decoded_options, unsigned int *decoded_options_count) { decode_cmdline_options_to_array (argc, argv, initial_lang_mask | CL_COMMON | CL_TARGET, decoded_options, decoded_options_count); } /* Set *HANDLERS to the default set of option handlers for use in the compilers proper (not the driver). */ void set_default_handlers (struct cl_option_handlers *handlers) { handlers->unknown_option_callback = unknown_option_callback; handlers->wrong_lang_callback = complain_wrong_lang; handlers->num_handlers = 3; handlers->handlers[0].handler = lang_handle_option; handlers->handlers[0].mask = initial_lang_mask; handlers->handlers[1].handler = common_handle_option; handlers->handlers[1].mask = CL_COMMON; handlers->handlers[2].handler = target_handle_option; handlers->handlers[2].mask = CL_TARGET; } /* Parse command line options and set default flag values. Do minimal options processing. The decoded options are in *DECODED_OPTIONS and *DECODED_OPTIONS_COUNT; settings go in OPTS, OPTS_SET and DC; the options are located at LOC. */ void decode_options (struct gcc_options *opts, struct gcc_options *opts_set, struct cl_decoded_option *decoded_options, unsigned int decoded_options_count, location_t loc, diagnostic_context *dc) { struct cl_option_handlers handlers; unsigned int lang_mask; lang_mask = initial_lang_mask; set_default_handlers (&handlers); default_options_optimization (opts, opts_set, decoded_options, decoded_options_count, loc, lang_mask, &handlers, dc); read_cmdline_options (opts, opts_set, decoded_options, decoded_options_count, loc, lang_mask, &handlers, dc); finish_options (opts, opts_set, loc); } /* Process common options that have been deferred until after the handlers have been called for all options. */ void handle_common_deferred_options (void) { unsigned int i; cl_deferred_option *opt; VEC(cl_deferred_option,heap) *vec = (VEC(cl_deferred_option,heap) *) common_deferred_options; if (flag_dump_all_passed) enable_rtl_dump_file (); FOR_EACH_VEC_ELT (cl_deferred_option, vec, i, opt) { switch (opt->opt_index) { case OPT_fcall_used_: fix_register (opt->arg, 0, 1); break; case OPT_fcall_saved_: fix_register (opt->arg, 0, 0); break; case OPT_fdbg_cnt_: dbg_cnt_process_opt (opt->arg); break; case OPT_fdbg_cnt_list: dbg_cnt_list_all_counters (); break; case OPT_fdebug_prefix_map_: add_debug_prefix_map (opt->arg); break; case OPT_fdump_: if (!dump_switch_p (opt->arg)) error ("unrecognized command line option %<-fdump-%s%>", opt->arg); break; case OPT_fenable_: case OPT_fdisable_: if (opt->opt_index == OPT_fenable_) enable_pass (opt->arg); else disable_pass (opt->arg); break; case OPT_ffixed_: /* Deferred. */ fix_register (opt->arg, 1, 1); break; case OPT_fplugin_: #ifdef ENABLE_PLUGIN add_new_plugin (opt->arg); #else error ("plugin support is disabled; configure with --enable-plugin"); #endif break; case OPT_fplugin_arg_: #ifdef ENABLE_PLUGIN parse_plugin_arg_opt (opt->arg); #else error ("plugin support is disabled; configure with --enable-plugin"); #endif break; case OPT_frandom_seed: /* The real switch is -fno-random-seed. */ if (!opt->value) set_random_seed (NULL); break; case OPT_frandom_seed_: set_random_seed (opt->arg); break; case OPT_fstack_limit: /* The real switch is -fno-stack-limit. */ if (!opt->value) stack_limit_rtx = NULL_RTX; break; case OPT_fstack_limit_register_: { int reg = decode_reg_name (opt->arg); if (reg < 0) error ("unrecognized register name %qs", opt->arg); else stack_limit_rtx = gen_rtx_REG (Pmode, reg); } break; case OPT_fstack_limit_symbol_: stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (opt->arg)); break; default: gcc_unreachable (); } } }
Go to most recent revision | Compare with Previous | Blame | View Log