1 /* Command line option handling. Code involving global state that
2 should not be shared with the driver.
3 Copyright (C) 2002-2022 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
27 #include "tree-pass.h"
28 #include "diagnostic.h"
31 #include "langhooks.h"
38 #include "stringpool.h"
41 #include "file-prefix-map.h" /* add_*_prefix_map() */
43 typedef const char *const_char_p; /* For DEF_VEC_P. */
45 static vec<const_char_p> 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 /* Allocate at least one character as we'll terminate the string
65 at the very end of this function. */
66 result = XNEWVEC (char, MAX (1, len));
68 for (n = 0; (lang_name = lang_names[n]) != 0; n++)
73 strcpy (result + len, lang_name);
74 len += strlen (lang_name);
82 /* Complain that switch DECODED does not apply to this front end (mask
86 complain_wrong_lang (const struct cl_decoded_option *decoded,
87 unsigned int lang_mask)
89 const struct cl_option *option = &cl_options[decoded->opt_index];
90 const char *text = decoded->orig_option_with_args_text;
91 char *ok_langs = NULL, *bad_lang = NULL;
92 unsigned int opt_flags = option->flags;
94 if (!lang_hooks.complain_wrong_lang_p (option))
97 opt_flags &= ((1U << cl_lang_count) - 1) | CL_DRIVER;
98 if (opt_flags != CL_DRIVER)
99 ok_langs = write_langs (opt_flags);
100 if (lang_mask != CL_DRIVER)
101 bad_lang = write_langs (lang_mask);
103 if (opt_flags == CL_DRIVER)
104 error ("command-line option %qs is valid for the driver but not for %s",
106 else if (lang_mask == CL_DRIVER)
108 else if (ok_langs[0] != '\0')
109 /* Eventually this should become a hard error IMO. */
110 warning (0, "command-line option %qs is valid for %s but not for %s",
111 text, ok_langs, bad_lang);
113 /* Happens for -Werror=warning_name. */
114 warning (0, "%<-Werror=%> argument %qs is not valid for %s",
121 /* Buffer the unknown option described by the string OPT. Currently,
122 we only complain about unknown -Wno-* options if they may have
123 prevented a diagnostic. Otherwise, we just ignore them. Note that
124 if we do complain, it is only as a warning, not an error; passing
125 the compiler an unrecognized -Wno-* option should never change
126 whether the compilation succeeds or fails. */
129 postpone_unknown_option_warning (const char *opt)
131 ignored_options.safe_push (opt);
134 /* Produce a warning for each option previously buffered. */
137 print_ignored_options (void)
139 while (!ignored_options.is_empty ())
143 opt = ignored_options.pop ();
144 /* Use inform, not warning_at, to avoid promoting these to errors. */
145 inform (UNKNOWN_LOCATION,
146 "unrecognized command-line option %qs may have been intended "
147 "to silence earlier diagnostics", opt);
151 /* Handle an unknown option DECODED, returning true if an error should
155 unknown_option_callback (const struct cl_decoded_option *decoded)
157 const char *opt = decoded->arg;
159 if (opt[1] == 'W' && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-'
160 && !(decoded->errors & CL_ERR_NEGATIVE))
162 /* We don't generate warnings for unknown -Wno-* options unless
163 we issue diagnostics. */
164 postpone_unknown_option_warning (opt);
171 /* Handle a front-end option; arguments and return value as for
175 lang_handle_option (struct gcc_options *opts,
176 struct gcc_options *opts_set,
177 const struct cl_decoded_option *decoded,
178 unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
180 const struct cl_option_handlers *handlers,
181 diagnostic_context *dc,
184 gcc_assert (opts == &global_options);
185 gcc_assert (opts_set == &global_options_set);
186 gcc_assert (dc == global_dc);
187 gcc_assert (decoded->canonical_option_num_elements <= 2);
188 return lang_hooks.handle_option (decoded->opt_index, decoded->arg,
189 decoded->value, kind, loc, handlers);
192 /* Handle FILENAME from the command line. */
195 add_input_filename (const char *filename)
198 in_fnames = XRESIZEVEC (const char *, in_fnames, num_in_fnames);
199 in_fnames[num_in_fnames - 1] = filename;
202 /* Handle the vector of command line options (located at LOC), storing
203 the results of processing DECODED_OPTIONS and DECODED_OPTIONS_COUNT
204 in OPTS and OPTS_SET and using DC for diagnostic state. LANG_MASK
205 contains has a single bit set representing the current language.
206 HANDLERS describes what functions to call for the options. */
209 read_cmdline_options (struct gcc_options *opts, struct gcc_options *opts_set,
210 struct cl_decoded_option *decoded_options,
211 unsigned int decoded_options_count,
213 unsigned int lang_mask,
214 const struct cl_option_handlers *handlers,
215 diagnostic_context *dc)
219 for (i = 1; i < decoded_options_count; i++)
221 if (decoded_options[i].opt_index == OPT_SPECIAL_input_file)
223 /* Input files should only ever appear on the main command
225 gcc_assert (opts == &global_options);
226 gcc_assert (opts_set == &global_options_set);
228 if (opts->x_main_input_filename == NULL)
230 opts->x_main_input_filename = decoded_options[i].arg;
231 opts->x_main_input_baselength
232 = base_of_path (opts->x_main_input_filename,
233 &opts->x_main_input_basename);
235 add_input_filename (decoded_options[i].arg);
239 read_cmdline_option (opts, opts_set,
240 decoded_options + i, loc, lang_mask, handlers,
245 /* Language mask determined at initialization. */
246 static unsigned int initial_lang_mask;
248 /* Initialize global options-related settings at start-up. */
251 init_options_once (void)
253 /* Perform language-specific options initialization. */
254 initial_lang_mask = lang_hooks.option_lang_mask ();
256 lang_hooks.initialize_diagnostics (global_dc);
257 /* ??? Ideally, we should do this earlier and the FEs will override
258 it if desired (none do it so far). However, the way the FEs
259 construct their pretty-printers means that all previous settings
261 diagnostic_color_init (global_dc);
262 diagnostic_urls_init (global_dc);
265 /* Decode command-line options to an array, like
266 decode_cmdline_options_to_array and with the same arguments but
267 using the default lang_mask. */
270 decode_cmdline_options_to_array_default_mask (unsigned int argc,
272 struct cl_decoded_option **decoded_options,
273 unsigned int *decoded_options_count)
275 decode_cmdline_options_to_array (argc, argv,
276 initial_lang_mask | CL_COMMON | CL_TARGET,
277 decoded_options, decoded_options_count);
280 /* Set *HANDLERS to the default set of option handlers for use in the
281 compilers proper (not the driver). */
283 set_default_handlers (struct cl_option_handlers *handlers,
284 void (*target_option_override_hook) (void))
286 handlers->unknown_option_callback = unknown_option_callback;
287 handlers->wrong_lang_callback = complain_wrong_lang;
288 handlers->target_option_override_hook = target_option_override_hook;
289 handlers->num_handlers = 3;
290 handlers->handlers[0].handler = lang_handle_option;
291 handlers->handlers[0].mask = initial_lang_mask;
292 handlers->handlers[1].handler = common_handle_option;
293 handlers->handlers[1].mask = CL_COMMON;
294 handlers->handlers[2].handler = target_handle_option;
295 handlers->handlers[2].mask = CL_TARGET;
298 /* Parse command line options and set default flag values. Do minimal
299 options processing. The decoded options are in *DECODED_OPTIONS
300 and *DECODED_OPTIONS_COUNT; settings go in OPTS, OPTS_SET and DC;
301 the options are located at LOC. */
303 decode_options (struct gcc_options *opts, struct gcc_options *opts_set,
304 struct cl_decoded_option *decoded_options,
305 unsigned int decoded_options_count,
306 location_t loc, diagnostic_context *dc,
307 void (*target_option_override_hook) (void))
309 struct cl_option_handlers handlers;
311 unsigned int lang_mask;
313 lang_mask = initial_lang_mask;
315 set_default_handlers (&handlers, target_option_override_hook);
317 default_options_optimization (opts, opts_set,
318 decoded_options, decoded_options_count,
319 loc, lang_mask, &handlers, dc);
321 read_cmdline_options (opts, opts_set,
322 decoded_options, decoded_options_count,
326 finish_options (opts, opts_set, loc);
328 /* Print --help=* if used. */
332 if (!help_option_arguments.is_empty ())
334 /* Make sure --help=* sees the overridden values. */
335 target_option_override_hook ();
337 FOR_EACH_VEC_ELT (help_option_arguments, i, arg)
338 print_help (opts, lang_mask, arg);
342 /* Hold command-line options associated with stack limitation. */
343 const char *opt_fstack_limit_symbol_arg = NULL;
344 int opt_fstack_limit_register_no = -1;
346 /* Process common options that have been deferred until after the
347 handlers have been called for all options. */
350 handle_common_deferred_options (void)
353 cl_deferred_option *opt;
354 vec<cl_deferred_option> v;
356 if (common_deferred_options)
357 v = *((vec<cl_deferred_option> *) common_deferred_options);
361 if (flag_dump_all_passed)
362 enable_rtl_dump_file ();
365 opt_info_switch_p (NULL);
367 FOR_EACH_VEC_ELT (v, i, opt)
369 switch (opt->opt_index)
371 case OPT_fcall_used_:
372 fix_register (opt->arg, 0, 1);
375 case OPT_fcall_saved_:
376 fix_register (opt->arg, 0, 0);
380 dbg_cnt_process_opt (opt->arg);
383 case OPT_fdebug_prefix_map_:
384 add_debug_prefix_map (opt->arg);
387 case OPT_ffile_prefix_map_:
388 add_file_prefix_map (opt->arg);
391 case OPT_fprofile_prefix_map_:
392 add_profile_prefix_map (opt->arg);
396 g->get_dumps ()->dump_switch_p (opt->arg);
400 if (!opt_info_switch_p (opt->arg))
401 error ("unrecognized command-line option %<-fopt-info-%s%>",
407 if (opt->opt_index == OPT_fenable_)
408 enable_pass (opt->arg);
410 disable_pass (opt->arg);
415 fix_register (opt->arg, 1, 1);
420 add_new_plugin (opt->arg);
422 error ("plugin support is disabled; configure with "
423 "%<--enable-plugin%>");
427 case OPT_fplugin_arg_:
429 parse_plugin_arg_opt (opt->arg);
431 error ("plugin support is disabled; configure with "
432 "%<--enable-plugin%>");
436 case OPT_frandom_seed:
437 /* The real switch is -fno-random-seed. */
439 set_random_seed (NULL);
442 case OPT_frandom_seed_:
443 set_random_seed (opt->arg);
446 case OPT_fstack_limit:
447 /* The real switch is -fno-stack-limit. */
449 stack_limit_rtx = NULL_RTX;
452 case OPT_fstack_limit_register_:
454 int reg = decode_reg_name (opt->arg);
456 error ("unrecognized register name %qs", opt->arg);
459 /* Deactivate previous OPT_fstack_limit_symbol_ options. */
460 opt_fstack_limit_symbol_arg = NULL;
461 opt_fstack_limit_register_no = reg;
466 case OPT_fstack_limit_symbol_:
467 /* Deactivate previous OPT_fstack_limit_register_ options. */
468 opt_fstack_limit_register_no = -1;
469 opt_fstack_limit_symbol_arg = opt->arg;
472 case OPT_fasan_shadow_offset_:
473 if (!(flag_sanitize & SANITIZE_KERNEL_ADDRESS))
474 error ("%<-fasan-shadow-offset%> should only be used "
475 "with %<-fsanitize=kernel-address%>");
476 if (!set_asan_shadow_offset (opt->arg))
477 error ("unrecognized shadow offset %qs", opt->arg);
480 case OPT_fsanitize_sections_:
481 set_sanitized_sections (opt->arg);