1 /* Command line option handling. Code involving global state that
2 should not be shared with the driver.
3 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
25 #include "diagnostic.h"
29 #include "tree.h" /* Required by langhooks.h. */
30 #include "langhooks.h"
31 #include "tm.h" /* Required by rtl.h. */
35 #include "lto-streamer.h"
39 #include "tree-pass.h"
41 typedef const char *const_char_p; /* For DEF_VEC_P. */
42 DEF_VEC_P(const_char_p);
43 DEF_VEC_ALLOC_P(const_char_p,heap);
45 static VEC(const_char_p,heap) *ignored_options;
47 /* Input file names. */
48 const char **in_fnames;
49 unsigned num_in_fnames;
51 /* Return a malloced slash-separated list of languages in MASK. */
54 write_langs (unsigned int mask)
56 unsigned int n = 0, len = 0;
57 const char *lang_name;
60 for (n = 0; (lang_name = lang_names[n]) != 0; n++)
62 len += strlen (lang_name) + 1;
64 result = XNEWVEC (char, len);
66 for (n = 0; (lang_name = lang_names[n]) != 0; n++)
71 strcpy (result + len, lang_name);
72 len += strlen (lang_name);
80 /* Complain that switch DECODED does not apply to this front end (mask
84 complain_wrong_lang (const struct cl_decoded_option *decoded,
85 unsigned int lang_mask)
87 const struct cl_option *option = &cl_options[decoded->opt_index];
88 const char *text = decoded->orig_option_with_args_text;
89 char *ok_langs = NULL, *bad_lang = NULL;
90 unsigned int opt_flags = option->flags;
92 if (!lang_hooks.complain_wrong_lang_p (option))
95 opt_flags &= ((1U << cl_lang_count) - 1) | CL_DRIVER;
96 if (opt_flags != CL_DRIVER)
97 ok_langs = write_langs (opt_flags);
98 if (lang_mask != CL_DRIVER)
99 bad_lang = write_langs (lang_mask);
101 if (opt_flags == CL_DRIVER)
102 error ("command line option %qs is valid for the driver but not for %s",
104 else if (lang_mask == CL_DRIVER)
107 /* Eventually this should become a hard error IMO. */
108 warning (0, "command line option %qs is valid for %s but not for %s",
109 text, ok_langs, bad_lang);
115 /* Buffer the unknown option described by the string OPT. Currently,
116 we only complain about unknown -Wno-* options if they may have
117 prevented a diagnostic. Otherwise, we just ignore them. Note that
118 if we do complain, it is only as a warning, not an error; passing
119 the compiler an unrecognised -Wno-* option should never change
120 whether the compilation succeeds or fails. */
123 postpone_unknown_option_warning (const char *opt)
125 VEC_safe_push (const_char_p, heap, ignored_options, opt);
128 /* Produce a warning for each option previously buffered. */
131 print_ignored_options (void)
133 while (!VEC_empty (const_char_p, ignored_options))
137 opt = VEC_pop (const_char_p, ignored_options);
138 warning_at (UNKNOWN_LOCATION, 0,
139 "unrecognized command line option \"%s\"", opt);
143 /* Handle an unknown option DECODED, returning true if an error should
147 unknown_option_callback (const struct cl_decoded_option *decoded)
149 const char *opt = decoded->arg;
151 if (opt[1] == 'W' && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-'
152 && !(decoded->errors & CL_ERR_NEGATIVE))
154 /* We don't generate warnings for unknown -Wno-* options unless
155 we issue diagnostics. */
156 postpone_unknown_option_warning (opt);
163 /* Handle a front-end option; arguments and return value as for
167 lang_handle_option (struct gcc_options *opts,
168 struct gcc_options *opts_set,
169 const struct cl_decoded_option *decoded,
170 unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
172 const struct cl_option_handlers *handlers,
173 diagnostic_context *dc)
175 gcc_assert (opts == &global_options);
176 gcc_assert (opts_set == &global_options_set);
177 gcc_assert (dc == global_dc);
178 gcc_assert (decoded->canonical_option_num_elements <= 2);
179 return lang_hooks.handle_option (decoded->opt_index, decoded->arg,
180 decoded->value, kind, loc, handlers);
183 /* Handle FILENAME from the command line. */
186 add_input_filename (const char *filename)
189 in_fnames = XRESIZEVEC (const char *, in_fnames, num_in_fnames);
190 in_fnames[num_in_fnames - 1] = filename;
193 /* Handle the vector of command line options (located at LOC), storing
194 the results of processing DECODED_OPTIONS and DECODED_OPTIONS_COUNT
195 in OPTS and OPTS_SET and using DC for diagnostic state. LANG_MASK
196 contains has a single bit set representing the current language.
197 HANDLERS describes what functions to call for the options. */
200 read_cmdline_options (struct gcc_options *opts, struct gcc_options *opts_set,
201 struct cl_decoded_option *decoded_options,
202 unsigned int decoded_options_count,
204 unsigned int lang_mask,
205 const struct cl_option_handlers *handlers,
206 diagnostic_context *dc)
210 for (i = 1; i < decoded_options_count; i++)
212 if (decoded_options[i].opt_index == OPT_SPECIAL_input_file)
214 /* Input files should only ever appear on the main command
216 gcc_assert (opts == &global_options);
217 gcc_assert (opts_set == &global_options_set);
219 if (opts->x_main_input_filename == NULL)
221 opts->x_main_input_filename = decoded_options[i].arg;
222 opts->x_main_input_baselength
223 = base_of_path (opts->x_main_input_filename,
224 &opts->x_main_input_basename);
226 add_input_filename (decoded_options[i].arg);
230 read_cmdline_option (opts, opts_set,
231 decoded_options + i, loc, lang_mask, handlers,
236 /* Language mask determined at initialization. */
237 static unsigned int initial_lang_mask;
239 /* Initialize global options-related settings at start-up. */
242 init_options_once (void)
244 /* Perform language-specific options initialization. */
245 initial_lang_mask = lang_hooks.option_lang_mask ();
247 lang_hooks.initialize_diagnostics (global_dc);
250 /* Decode command-line options to an array, like
251 decode_cmdline_options_to_array and with the same arguments but
252 using the default lang_mask. */
255 decode_cmdline_options_to_array_default_mask (unsigned int argc,
257 struct cl_decoded_option **decoded_options,
258 unsigned int *decoded_options_count)
260 decode_cmdline_options_to_array (argc, argv,
261 initial_lang_mask | CL_COMMON | CL_TARGET,
262 decoded_options, decoded_options_count);
265 /* Set *HANDLERS to the default set of option handlers for use in the
266 compilers proper (not the driver). */
268 set_default_handlers (struct cl_option_handlers *handlers)
270 handlers->unknown_option_callback = unknown_option_callback;
271 handlers->wrong_lang_callback = complain_wrong_lang;
272 handlers->num_handlers = 3;
273 handlers->handlers[0].handler = lang_handle_option;
274 handlers->handlers[0].mask = initial_lang_mask;
275 handlers->handlers[1].handler = common_handle_option;
276 handlers->handlers[1].mask = CL_COMMON;
277 handlers->handlers[2].handler = target_handle_option;
278 handlers->handlers[2].mask = CL_TARGET;
281 /* Parse command line options and set default flag values. Do minimal
282 options processing. The decoded options are in *DECODED_OPTIONS
283 and *DECODED_OPTIONS_COUNT; settings go in OPTS, OPTS_SET and DC;
284 the options are located at LOC. */
286 decode_options (struct gcc_options *opts, struct gcc_options *opts_set,
287 struct cl_decoded_option *decoded_options,
288 unsigned int decoded_options_count,
289 location_t loc, diagnostic_context *dc)
291 struct cl_option_handlers handlers;
293 unsigned int lang_mask;
295 lang_mask = initial_lang_mask;
297 set_default_handlers (&handlers);
299 default_options_optimization (opts, opts_set,
300 decoded_options, decoded_options_count,
301 loc, lang_mask, &handlers, dc);
303 read_cmdline_options (opts, opts_set,
304 decoded_options, decoded_options_count,
308 finish_options (opts, opts_set, loc);
311 /* Process common options that have been deferred until after the
312 handlers have been called for all options. */
315 handle_common_deferred_options (void)
318 cl_deferred_option *opt;
319 VEC(cl_deferred_option,heap) *vec
320 = (VEC(cl_deferred_option,heap) *) common_deferred_options;
322 if (flag_dump_all_passed)
323 enable_rtl_dump_file ();
325 FOR_EACH_VEC_ELT (cl_deferred_option, vec, i, opt)
327 switch (opt->opt_index)
329 case OPT_fcall_used_:
330 fix_register (opt->arg, 0, 1);
333 case OPT_fcall_saved_:
334 fix_register (opt->arg, 0, 0);
338 dbg_cnt_process_opt (opt->arg);
341 case OPT_fdbg_cnt_list:
342 dbg_cnt_list_all_counters ();
345 case OPT_fdebug_prefix_map_:
346 add_debug_prefix_map (opt->arg);
350 if (!dump_switch_p (opt->arg))
351 error ("unrecognized command line option %<-fdump-%s%>", opt->arg);
356 if (opt->opt_index == OPT_fenable_)
357 enable_pass (opt->arg);
359 disable_pass (opt->arg);
364 fix_register (opt->arg, 1, 1);
369 add_new_plugin (opt->arg);
371 error ("plugin support is disabled; configure with --enable-plugin");
375 case OPT_fplugin_arg_:
377 parse_plugin_arg_opt (opt->arg);
379 error ("plugin support is disabled; configure with --enable-plugin");
383 case OPT_frandom_seed:
384 /* The real switch is -fno-random-seed. */
386 set_random_seed (NULL);
389 case OPT_frandom_seed_:
390 set_random_seed (opt->arg);
393 case OPT_fstack_limit:
394 /* The real switch is -fno-stack-limit. */
396 stack_limit_rtx = NULL_RTX;
399 case OPT_fstack_limit_register_:
401 int reg = decode_reg_name (opt->arg);
403 error ("unrecognized register name %qs", opt->arg);
405 stack_limit_rtx = gen_rtx_REG (Pmode, reg);
409 case OPT_fstack_limit_symbol_:
410 stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (opt->arg));