Branch data Line data Source code
1 : : /* Command line option handling. Code involving global state that
2 : : should not be shared with the driver.
3 : : Copyright (C) 2002-2024 Free Software Foundation, Inc.
4 : :
5 : : This file is part of GCC.
6 : :
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
10 : : version.
11 : :
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
15 : : for more details.
16 : :
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/>. */
20 : :
21 : : #include "config.h"
22 : : #include "system.h"
23 : : #include "coretypes.h"
24 : : #include "backend.h"
25 : : #include "rtl.h"
26 : : #include "tree.h"
27 : : #include "tree-pass.h"
28 : : #include "diagnostic.h"
29 : : #include "opts.h"
30 : : #include "flags.h"
31 : : #include "langhooks.h"
32 : : #include "dbgcnt.h"
33 : : #include "debug.h"
34 : : #include "output.h"
35 : : #include "plugin.h"
36 : : #include "toplev.h"
37 : : #include "context.h"
38 : : #include "stringpool.h"
39 : : #include "attribs.h"
40 : : #include "asan.h"
41 : : #include "file-prefix-map.h" /* add_*_prefix_map() */
42 : :
43 : : typedef const char *const_char_p; /* For DEF_VEC_P. */
44 : :
45 : : static vec<const_char_p> ignored_options;
46 : :
47 : : /* Input file names. */
48 : : const char **in_fnames;
49 : : unsigned num_in_fnames;
50 : :
51 : : /* Return a malloced slash-separated list of languages in MASK. */
52 : :
53 : : char *
54 : 606 : write_langs (unsigned int mask)
55 : : {
56 : 606 : unsigned int n = 0, len = 0;
57 : 606 : const char *lang_name;
58 : 606 : char *result;
59 : :
60 : 9090 : for (n = 0; (lang_name = lang_names[n]) != 0; n++)
61 : 8484 : if (mask & (1U << n))
62 : 678 : len += strlen (lang_name) + 1;
63 : :
64 : : /* Allocate at least one character as we'll terminate the string
65 : : at the very end of this function. */
66 : 606 : result = XNEWVEC (char, MAX (1, len));
67 : 606 : len = 0;
68 : 9696 : for (n = 0; (lang_name = lang_names[n]) != 0; n++)
69 : 8484 : if (mask & (1U << n))
70 : : {
71 : 678 : if (len)
72 : 73 : result[len++] = '/';
73 : 678 : strcpy (result + len, lang_name);
74 : 678 : len += strlen (lang_name);
75 : : }
76 : :
77 : 606 : result[len] = 0;
78 : :
79 : 606 : return result;
80 : : }
81 : :
82 : : /* Complain that switch DECODED does not apply to this front end (mask
83 : : LANG_MASK). */
84 : :
85 : : static void
86 : 467 : complain_wrong_lang (const struct cl_decoded_option *decoded,
87 : : unsigned int lang_mask)
88 : : {
89 : 467 : const struct cl_option *option = &cl_options[decoded->opt_index];
90 : 467 : const char *text = decoded->orig_option_with_args_text;
91 : 467 : char *ok_langs = NULL, *bad_lang = NULL;
92 : 467 : unsigned int opt_flags = option->flags;
93 : :
94 : 467 : if (!warn_complain_wrong_lang)
95 : : return;
96 : :
97 : 308 : if (!lang_hooks.complain_wrong_lang_p (option))
98 : : return;
99 : :
100 : 302 : opt_flags &= ((1U << cl_lang_count) - 1) | CL_DRIVER;
101 : 302 : if (opt_flags != CL_DRIVER)
102 : 302 : ok_langs = write_langs (opt_flags);
103 : 302 : if (lang_mask != CL_DRIVER)
104 : 302 : bad_lang = write_langs (lang_mask);
105 : :
106 : 302 : if (opt_flags == CL_DRIVER)
107 : 0 : error ("command-line option %qs is valid for the driver but not for %s",
108 : : text, bad_lang);
109 : 302 : else if (lang_mask == CL_DRIVER)
110 : 0 : gcc_unreachable ();
111 : 302 : else if (ok_langs[0] != '\0')
112 : : /* Eventually this should become a hard error IMO. */
113 : 301 : warning (0, "command-line option %qs is valid for %s but not for %s",
114 : : text, ok_langs, bad_lang);
115 : : else
116 : : /* Happens for -Werror=warning_name. */
117 : 1 : warning (0, "%<-Werror=%> argument %qs is not valid for %s",
118 : : text, bad_lang);
119 : :
120 : 302 : free (ok_langs);
121 : 302 : free (bad_lang);
122 : : }
123 : :
124 : : /* Buffer the unknown option described by the string OPT. Currently,
125 : : we only complain about unknown -Wno-* options if they may have
126 : : prevented a diagnostic. Otherwise, we just ignore them. Note that
127 : : if we do complain, it is only as a warning, not an error; passing
128 : : the compiler an unrecognized -Wno-* option should never change
129 : : whether the compilation succeeds or fails. */
130 : :
131 : : static void
132 : 91 : postpone_unknown_option_warning (const char *opt)
133 : : {
134 : 0 : ignored_options.safe_push (opt);
135 : 0 : }
136 : :
137 : : /* Produce a warning for each option previously buffered. */
138 : :
139 : : void
140 : 37786 : print_ignored_options (void)
141 : : {
142 : 37809 : while (!ignored_options.is_empty ())
143 : : {
144 : 23 : const char *opt;
145 : :
146 : 23 : opt = ignored_options.pop ();
147 : : /* Use inform, not warning_at, to avoid promoting these to errors. */
148 : 23 : inform (UNKNOWN_LOCATION,
149 : : "unrecognized command-line option %qs may have been intended "
150 : : "to silence earlier diagnostics", opt);
151 : : }
152 : 37786 : }
153 : :
154 : : /* Handle an unknown option DECODED, returning true if an error should
155 : : be given. */
156 : :
157 : : static bool
158 : 91 : unknown_option_callback (const struct cl_decoded_option *decoded)
159 : : {
160 : 91 : const char *opt = decoded->arg;
161 : :
162 : 91 : if (opt[1] == 'W' && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-'
163 : 91 : && !(decoded->errors & CL_ERR_NEGATIVE))
164 : : {
165 : : /* We don't generate warnings for unknown -Wno-* options unless
166 : : we issue diagnostics. */
167 : 91 : postpone_unknown_option_warning (opt);
168 : 91 : return false;
169 : : }
170 : : else
171 : : return true;
172 : : }
173 : :
174 : : /* Handle a front-end option; arguments and return value as for
175 : : handle_option. */
176 : :
177 : : static bool
178 : 4078839 : lang_handle_option (struct gcc_options *opts,
179 : : struct gcc_options *opts_set,
180 : : const struct cl_decoded_option *decoded,
181 : : unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
182 : : location_t loc,
183 : : const struct cl_option_handlers *handlers,
184 : : diagnostic_context *dc,
185 : : void (*) (void))
186 : : {
187 : 4078839 : gcc_assert (opts == &global_options);
188 : 4078839 : gcc_assert (opts_set == &global_options_set);
189 : 4078839 : gcc_assert (dc == global_dc);
190 : 4078839 : gcc_assert (decoded->canonical_option_num_elements <= 2);
191 : 4078839 : return lang_hooks.handle_option (decoded->opt_index, decoded->arg,
192 : 4078839 : decoded->value, kind, loc, handlers);
193 : : }
194 : :
195 : : /* Handle FILENAME from the command line. */
196 : :
197 : : static void
198 : 290138 : add_input_filename (const char *filename)
199 : : {
200 : 290138 : num_in_fnames++;
201 : 290138 : in_fnames = XRESIZEVEC (const char *, in_fnames, num_in_fnames);
202 : 290138 : in_fnames[num_in_fnames - 1] = filename;
203 : 290138 : }
204 : :
205 : : /* Handle the vector of command line options (located at LOC), storing
206 : : the results of processing DECODED_OPTIONS and DECODED_OPTIONS_COUNT
207 : : in OPTS and OPTS_SET and using DC for diagnostic state. LANG_MASK
208 : : contains has a single bit set representing the current language.
209 : : HANDLERS describes what functions to call for the options. */
210 : :
211 : : static void
212 : 590892 : read_cmdline_options (struct gcc_options *opts, struct gcc_options *opts_set,
213 : : struct cl_decoded_option *decoded_options,
214 : : unsigned int decoded_options_count,
215 : : location_t loc,
216 : : unsigned int lang_mask,
217 : : const struct cl_option_handlers *handlers,
218 : : diagnostic_context *dc)
219 : : {
220 : 590892 : unsigned int i;
221 : :
222 : 9983215 : for (i = 1; i < decoded_options_count; i++)
223 : : {
224 : 9392323 : if (decoded_options[i].opt_index == OPT_SPECIAL_input_file)
225 : : {
226 : : /* Input files should only ever appear on the main command
227 : : line. */
228 : 290138 : gcc_assert (opts == &global_options);
229 : 290138 : gcc_assert (opts_set == &global_options_set);
230 : :
231 : 290138 : if (opts->x_main_input_filename == NULL)
232 : : {
233 : 279404 : opts->x_main_input_filename = decoded_options[i].arg;
234 : 279404 : opts->x_main_input_baselength
235 : 279404 : = base_of_path (opts->x_main_input_filename,
236 : : &opts->x_main_input_basename);
237 : : }
238 : 290138 : add_input_filename (decoded_options[i].arg);
239 : 290138 : continue;
240 : : }
241 : :
242 : 9102185 : read_cmdline_option (opts, opts_set,
243 : : decoded_options + i, loc, lang_mask, handlers,
244 : : dc);
245 : : }
246 : 590892 : }
247 : :
248 : : /* Language mask determined at initialization. */
249 : : static unsigned int initial_lang_mask;
250 : :
251 : : /* Initialize global options-related settings at start-up. */
252 : :
253 : : void
254 : 279404 : init_options_once (void)
255 : : {
256 : : /* Perform language-specific options initialization. */
257 : 279404 : initial_lang_mask = lang_hooks.option_lang_mask ();
258 : :
259 : 279404 : const bool show_highlight_colors
260 : 279404 : = pp_show_highlight_colors (global_dc->get_reference_printer ());
261 : :
262 : 279404 : lang_hooks.initialize_diagnostics (global_dc);
263 : : /* ??? Ideally, we should do this earlier and the FEs will override
264 : : it if desired (none do it so far). However, the way the FEs
265 : : construct their pretty-printers means that all previous settings
266 : : are overriden. */
267 : 279404 : global_dc->set_show_highlight_colors (show_highlight_colors);
268 : :
269 : 279404 : diagnostic_color_init (global_dc);
270 : 279404 : diagnostic_urls_init (global_dc);
271 : 279404 : global_dc->refresh_output_sinks ();
272 : 279404 : }
273 : :
274 : : /* Decode command-line options to an array, like
275 : : decode_cmdline_options_to_array and with the same arguments but
276 : : using the default lang_mask. */
277 : :
278 : : void
279 : 590892 : decode_cmdline_options_to_array_default_mask (unsigned int argc,
280 : : const char **argv,
281 : : struct cl_decoded_option **decoded_options,
282 : : unsigned int *decoded_options_count)
283 : : {
284 : 590892 : decode_cmdline_options_to_array (argc, argv,
285 : : initial_lang_mask | CL_COMMON | CL_TARGET,
286 : : decoded_options, decoded_options_count);
287 : 590892 : }
288 : :
289 : : /* Set *HANDLERS to the default set of option handlers for use in the
290 : : compilers proper (not the driver). */
291 : : void
292 : 3395670 : set_default_handlers (struct cl_option_handlers *handlers,
293 : : void (*target_option_override_hook) (void))
294 : : {
295 : 3395670 : handlers->unknown_option_callback = unknown_option_callback;
296 : 3395670 : handlers->wrong_lang_callback = complain_wrong_lang;
297 : 3395670 : handlers->target_option_override_hook = target_option_override_hook;
298 : 3395670 : handlers->num_handlers = 3;
299 : 3395670 : handlers->handlers[0].handler = lang_handle_option;
300 : 3395670 : handlers->handlers[0].mask = initial_lang_mask;
301 : 3395670 : handlers->handlers[1].handler = common_handle_option;
302 : 3395670 : handlers->handlers[1].mask = CL_COMMON;
303 : 3395670 : handlers->handlers[2].handler = target_handle_option;
304 : 3395670 : handlers->handlers[2].mask = CL_TARGET;
305 : 3395670 : }
306 : :
307 : : /* Parse command line options and set default flag values. Do minimal
308 : : options processing. The decoded options are in *DECODED_OPTIONS
309 : : and *DECODED_OPTIONS_COUNT; settings go in OPTS, OPTS_SET and DC;
310 : : the options are located at LOC. */
311 : : void
312 : 590892 : decode_options (struct gcc_options *opts, struct gcc_options *opts_set,
313 : : struct cl_decoded_option *decoded_options,
314 : : unsigned int decoded_options_count,
315 : : location_t loc, diagnostic_context *dc,
316 : : void (*target_option_override_hook) (void))
317 : : {
318 : 590892 : struct cl_option_handlers handlers;
319 : :
320 : 590892 : unsigned int lang_mask;
321 : :
322 : 590892 : lang_mask = initial_lang_mask;
323 : :
324 : 590892 : set_default_handlers (&handlers, target_option_override_hook);
325 : :
326 : 590892 : default_options_optimization (opts, opts_set,
327 : : decoded_options, decoded_options_count,
328 : : loc, lang_mask, &handlers, dc);
329 : :
330 : 590892 : read_cmdline_options (opts, opts_set,
331 : : decoded_options, decoded_options_count,
332 : : loc, lang_mask,
333 : : &handlers, dc);
334 : :
335 : 590892 : finish_options (opts, opts_set, loc);
336 : :
337 : : /* Print --help=* if used. */
338 : 590892 : unsigned i;
339 : 590892 : const char *arg;
340 : :
341 : 590892 : if (!help_option_arguments.is_empty ())
342 : : {
343 : : /* Make sure --help=* sees the overridden values. */
344 : 92 : target_option_override_hook ();
345 : :
346 : 278 : FOR_EACH_VEC_ELT (help_option_arguments, i, arg)
347 : 94 : print_help (opts, lang_mask, arg);
348 : : }
349 : 590892 : }
350 : :
351 : : /* Hold command-line options associated with stack limitation. */
352 : : const char *opt_fstack_limit_symbol_arg = NULL;
353 : : int opt_fstack_limit_register_no = -1;
354 : :
355 : : /* Process common options that have been deferred until after the
356 : : handlers have been called for all options. */
357 : :
358 : : void
359 : 279404 : handle_common_deferred_options (void)
360 : : {
361 : 279404 : unsigned int i;
362 : 279404 : cl_deferred_option *opt;
363 : 279404 : vec<cl_deferred_option> v;
364 : :
365 : 279404 : if (common_deferred_options)
366 : 21625 : v = *((vec<cl_deferred_option> *) common_deferred_options);
367 : : else
368 : : v = vNULL;
369 : :
370 : 279404 : if (flag_dump_all_passed)
371 : 4 : enable_rtl_dump_file ();
372 : :
373 : 279404 : if (flag_opt_info)
374 : 1 : opt_info_switch_p (NULL);
375 : :
376 : 279404 : flag_canon_prefix_map = false;
377 : 303584 : FOR_EACH_VEC_ELT (v, i, opt)
378 : : {
379 : 24184 : switch (opt->opt_index)
380 : : {
381 : 0 : case OPT_fcall_used_:
382 : 0 : fix_register (opt->arg, 0, 1);
383 : 0 : break;
384 : :
385 : 0 : case OPT_fcall_saved_:
386 : 0 : fix_register (opt->arg, 0, 0);
387 : 0 : break;
388 : :
389 : 3 : case OPT_fdbg_cnt_:
390 : 3 : dbg_cnt_process_opt (opt->arg);
391 : 3 : break;
392 : :
393 : 552 : case OPT_fdebug_prefix_map_:
394 : 552 : add_debug_prefix_map (opt->arg);
395 : 552 : break;
396 : :
397 : 220 : case OPT_ffile_prefix_map_:
398 : 220 : add_file_prefix_map (opt->arg);
399 : 220 : break;
400 : :
401 : 0 : case OPT_fprofile_prefix_map_:
402 : 0 : add_profile_prefix_map (opt->arg);
403 : 0 : break;
404 : :
405 : 0 : case OPT_fcanon_prefix_map:
406 : 0 : flag_canon_prefix_map = opt->value;
407 : 0 : break;
408 : :
409 : : case OPT_fdump_:
410 : : /* Deferred until plugins initialized. */
411 : : break;
412 : :
413 : 684 : case OPT_fopt_info_:
414 : 684 : if (!opt_info_switch_p (opt->arg))
415 : 0 : error ("unrecognized command-line option %<-fopt-info-%s%>",
416 : : opt->arg);
417 : : break;
418 : :
419 : 207 : case OPT_fenable_:
420 : 207 : case OPT_fdisable_:
421 : 207 : if (opt->opt_index == OPT_fenable_)
422 : 4 : enable_pass (opt->arg);
423 : : else
424 : 203 : disable_pass (opt->arg);
425 : : break;
426 : :
427 : 93 : case OPT_ffixed_:
428 : : /* Deferred. */
429 : 93 : fix_register (opt->arg, 1, 1);
430 : 93 : break;
431 : :
432 : 246 : case OPT_fplugin_:
433 : : #ifdef ENABLE_PLUGIN
434 : 246 : add_new_plugin (opt->arg);
435 : : #else
436 : : error ("plugin support is disabled; configure with "
437 : : "%<--enable-plugin%>");
438 : : #endif
439 : 246 : break;
440 : :
441 : 12 : case OPT_fplugin_arg_:
442 : : #ifdef ENABLE_PLUGIN
443 : 12 : parse_plugin_arg_opt (opt->arg);
444 : : #else
445 : : error ("plugin support is disabled; configure with "
446 : : "%<--enable-plugin%>");
447 : : #endif
448 : 12 : break;
449 : :
450 : 0 : case OPT_frandom_seed:
451 : : /* The real switch is -fno-random-seed. */
452 : 0 : if (!opt->value)
453 : 0 : set_random_seed (NULL);
454 : : break;
455 : :
456 : 1748 : case OPT_frandom_seed_:
457 : 1748 : set_random_seed (opt->arg);
458 : 1748 : break;
459 : :
460 : 1 : case OPT_fstack_limit:
461 : : /* The real switch is -fno-stack-limit. */
462 : 1 : if (!opt->value)
463 : 0 : stack_limit_rtx = NULL_RTX;
464 : : break;
465 : :
466 : 0 : case OPT_fstack_limit_register_:
467 : 0 : {
468 : 0 : int reg = decode_reg_name (opt->arg);
469 : 0 : if (reg < 0)
470 : 0 : error ("unrecognized register name %qs", opt->arg);
471 : : else
472 : : {
473 : : /* Deactivate previous OPT_fstack_limit_symbol_ options. */
474 : 0 : opt_fstack_limit_symbol_arg = NULL;
475 : 0 : opt_fstack_limit_register_no = reg;
476 : : }
477 : : }
478 : : break;
479 : :
480 : 0 : case OPT_fstack_limit_symbol_:
481 : : /* Deactivate previous OPT_fstack_limit_register_ options. */
482 : 0 : opt_fstack_limit_register_no = -1;
483 : 0 : opt_fstack_limit_symbol_arg = opt->arg;
484 : 0 : break;
485 : :
486 : 10 : case OPT_fasan_shadow_offset_:
487 : 10 : if (!(flag_sanitize & SANITIZE_KERNEL_ADDRESS))
488 : 0 : error ("%<-fasan-shadow-offset%> should only be used "
489 : : "with %<-fsanitize=kernel-address%>");
490 : 10 : if (!set_asan_shadow_offset (opt->arg))
491 : 0 : error ("unrecognized shadow offset %qs", opt->arg);
492 : : break;
493 : :
494 : 40 : case OPT_fsanitize_sections_:
495 : 40 : set_sanitized_sections (opt->arg);
496 : 40 : break;
497 : :
498 : 0 : default:
499 : 0 : gcc_unreachable ();
500 : : }
501 : : }
502 : 279400 : }
503 : :
504 : : /* Handle deferred dump options. */
505 : :
506 : : void
507 : 279400 : handle_deferred_dump_options (void)
508 : : {
509 : 279400 : unsigned int i;
510 : 279400 : cl_deferred_option *opt;
511 : 279400 : vec<cl_deferred_option> v;
512 : :
513 : 279400 : if (common_deferred_options)
514 : 21621 : v = *((vec<cl_deferred_option> *) common_deferred_options);
515 : : else
516 : : v = vNULL;
517 : 303580 : FOR_EACH_VEC_ELT (v, i, opt)
518 : 24180 : if (opt->opt_index == OPT_fdump_)
519 : 20368 : g->get_dumps ()->dump_switch_p (opt->arg);
520 : 279400 : }
|
