gcc/gcc/opts-global.c
Joseph Myers a803773f0e common.opt (main_input_filename, [...]): New Variable entries.
* common.opt (main_input_filename, main_input_basename,
	main_input_baselength): New Variable entries.  From toplev.c.
	* final.c (output_quoted_string): Move from toplev.c.
	* output.h (output_quoted_string): Move from toplev.h.
	* opts-global.c (read_cmdline_options): Use gcc_options pointer to
	access main_input_filename, main_input_baselength and
	main_input_basename.
	* targhooks.c: Include intl.h and opts.h.
	(option_affects_pch_p, default_get_pch_validity): Move from
	toplev.c.
	* targhooks.h (option_affects_pch_p, default_get_pch_validity):
	Move from toplev.h.
	* toplev.c (main_input_filename, main_input_basename,
	main_input_baselength): Move to common.opt.
	(output_quoted_string): Move to final.c.
	(warn_deprecated_use): Move to tree.c.
	(option_affects_pch_p, default_get_pch_validity,
	pch_option_mismatch, default_pch_valid_p): Move to targhooks.c.
	* toplev.h (skip_leading_substring): Move to tree-dump.c.
	(warn_deprecated_use): Move to tree.h.
	(output_quoted_string): Move to output.h.
	(main_input_filename, main_input_basename, main_input_baselength):
	Move to common.opt.
	(default_get_pch_validity, default_pch_valid_p): Move to
	targhooks.c.
	* tree-dump.c (skip_leading_substring): Move from toplev.h.
	* tree.c (warn_deprecated_use): Move from toplev.c.
	* tree.h (warn_deprecated_use): Move from toplev.h.
	* c-typeck.c, config/alpha/alpha.c, config/arc/arc.c,
	config/arm/arm.c, config/avr/avr.c, config/bfin/bfin.c,
	config/cris/cris.c, config/crx/crx.c, config/fr30/fr30.c,
	config/frv/frv.c, config/h8300/h8300.c, config/ia64/ia64.c,
	config/iq2000/iq2000.c, config/lm32/lm32.c, config/m32c/m32c.c,
	config/m32r/m32r.c, config/m68hc11/m68hc11.c, config/m68k/m68k.c,
	config/mcore/mcore.c, config/mep/mep.c,
	config/microblaze/microblaze.c, config/mips/mips.c,
	config/mmix/mmix.c, config/mn10300/mn10300.c,
	config/moxie/moxie.c, config/pa/pa.c, config/pdp11/pdp11.c,
	config/picochip/picochip.c, config/s390/s390.c,
	config/score/score.c, config/sh/sh.c, config/sparc/sparc.c,
	config/spu/spu.c, config/stormy16/stormy16.c, config/v850/v850.c,
	config/vax/vax.c, config/xtensa/xtensa.c, gimple-low.c,
	graphite-sese-to-poly.c, plugin.c, tree-cfg.c, tree-inline.c,
	varasm.c, xcoffout.c: Don't include toplev.h.
	* Makefile.in (c-typeck.o, tree-inline.o, tree-cfg.o,
	gimple-low.o, graphite-sese-to-poly.o, targhooks.o, plugin.o,
	varasm.o, xcoffout.o): Update dependencies.
	* config/arm/t-arm (arm.o): Update dependencies.
	* config/spu/t-spu-elf (spu.o): Update dependencies.

cp:
	* cp-objcp-common.c, lex.c, typeck.c: Don't include toplev.h.
	* Make-lang.in (cp/lex.o, cp/cp-objcp-common.o, cp/typeck2.o):
	Update dependencies.

java:
	* jcf-parse.c: Don't include toplev.h.
	* Make-lang.in (java/jcf-parse.o): Don't depend on toplev.h.

From-SVN: r167329
2010-12-01 13:46:36 +00:00

434 lines
12 KiB
C

/* 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;
}
/* Note that an option DECODED has been successfully handled with a
handler for mask MASK. */
static void
post_handling_callback (const struct cl_decoded_option *decoded ATTRIBUTE_UNUSED,
unsigned int mask ATTRIBUTE_UNUSED)
{
#ifdef ENABLE_LTO
lto_register_user_option (decoded->opt_index, decoded->arg,
decoded->value, mask);
#endif
}
/* Handle a front-end option; arguments and return value as for
handle_option. */
static bool
lang_handle_option (struct gcc_options *opts,
struct gcc_options *opts_set,
const struct cl_decoded_option *decoded,
unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
location_t loc,
const struct cl_option_handlers *handlers,
diagnostic_context *dc)
{
gcc_assert (opts == &global_options);
gcc_assert (opts_set == &global_options_set);
gcc_assert (dc == global_dc);
gcc_assert (decoded->canonical_option_num_elements <= 2);
return lang_hooks.handle_option (decoded->opt_index, decoded->arg,
decoded->value, kind, loc, handlers);
}
/* Handle FILENAME from the command line. */
static void
add_input_filename (const char *filename)
{
num_in_fnames++;
in_fnames = XRESIZEVEC (const char *, in_fnames, num_in_fnames);
in_fnames[num_in_fnames - 1] = filename;
}
/* Handle the vector of command line options (located at LOC), storing
the results of processing DECODED_OPTIONS and DECODED_OPTIONS_COUNT
in OPTS and OPTS_SET and using DC for diagnostic state. LANG_MASK
contains has a single bit set representing the current language.
HANDLERS describes what functions to call for the options. */
static void
read_cmdline_options (struct gcc_options *opts, struct gcc_options *opts_set,
struct cl_decoded_option *decoded_options,
unsigned int decoded_options_count,
location_t loc,
unsigned int lang_mask,
const struct cl_option_handlers *handlers,
diagnostic_context *dc)
{
unsigned int i;
for (i = 1; i < decoded_options_count; i++)
{
if (decoded_options[i].opt_index == OPT_SPECIAL_input_file)
{
/* Input files should only ever appear on the main command
line. */
gcc_assert (opts == &global_options);
gcc_assert (opts_set == &global_options_set);
if (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->post_handling_callback = post_handling_callback;
handlers->num_handlers = 3;
handlers->handlers[0].handler = lang_handle_option;
handlers->handlers[0].mask = initial_lang_mask;
handlers->handlers[1].handler = common_handle_option;
handlers->handlers[1].mask = CL_COMMON;
handlers->handlers[2].handler = target_handle_option;
handlers->handlers[2].mask = CL_TARGET;
}
/* Parse command line options and set default flag values. Do minimal
options processing. The decoded options are in *DECODED_OPTIONS
and *DECODED_OPTIONS_COUNT; settings go in OPTS, OPTS_SET and DC;
the options are located at LOC. */
void
decode_options (struct gcc_options *opts, struct gcc_options *opts_set,
struct cl_decoded_option *decoded_options,
unsigned int decoded_options_count,
location_t loc, diagnostic_context *dc)
{
struct cl_option_handlers handlers;
unsigned int lang_mask;
lang_mask = initial_lang_mask;
set_default_handlers (&handlers);
/* Enable -Werror=coverage-mismatch by default. */
control_warning_option (OPT_Wcoverage_mismatch, (int) DK_ERROR, true,
loc, lang_mask,
&handlers, opts, opts_set, dc);
default_options_optimization (opts, opts_set,
decoded_options, decoded_options_count,
loc, lang_mask, &handlers, dc);
#ifdef ENABLE_LTO
/* Clear any options currently held for LTO. */
lto_clear_user_options ();
#endif
read_cmdline_options (opts, opts_set,
decoded_options, decoded_options_count,
loc, lang_mask,
&handlers, dc);
finish_options (opts, opts_set, 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_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 ();
}
}
}