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 : 598 : write_langs (unsigned int mask)
55 : : {
56 : 598 : unsigned int n = 0, len = 0;
57 : 598 : const char *lang_name;
58 : 598 : char *result;
59 : :
60 : 8970 : for (n = 0; (lang_name = lang_names[n]) != 0; n++)
61 : 8372 : if (mask & (1U << n))
62 : 666 : 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 : 598 : result = XNEWVEC (char, MAX (1, len));
67 : 598 : len = 0;
68 : 9568 : for (n = 0; (lang_name = lang_names[n]) != 0; n++)
69 : 8372 : if (mask & (1U << n))
70 : : {
71 : 666 : if (len)
72 : 69 : result[len++] = '/';
73 : 666 : strcpy (result + len, lang_name);
74 : 666 : len += strlen (lang_name);
75 : : }
76 : :
77 : 598 : result[len] = 0;
78 : :
79 : 598 : 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 : 492 : complain_wrong_lang (const struct cl_decoded_option *decoded,
87 : : unsigned int lang_mask)
88 : : {
89 : 492 : const struct cl_option *option = &cl_options[decoded->opt_index];
90 : 492 : const char *text = decoded->orig_option_with_args_text;
91 : 492 : char *ok_langs = NULL, *bad_lang = NULL;
92 : 492 : unsigned int opt_flags = option->flags;
93 : :
94 : 492 : if (!warn_complain_wrong_lang)
95 : : return;
96 : :
97 : 304 : if (!lang_hooks.complain_wrong_lang_p (option))
98 : : return;
99 : :
100 : 298 : opt_flags &= ((1U << cl_lang_count) - 1) | CL_DRIVER;
101 : 298 : if (opt_flags != CL_DRIVER)
102 : 298 : ok_langs = write_langs (opt_flags);
103 : 298 : if (lang_mask != CL_DRIVER)
104 : 298 : bad_lang = write_langs (lang_mask);
105 : :
106 : 298 : 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 : 298 : else if (lang_mask == CL_DRIVER)
110 : 0 : gcc_unreachable ();
111 : 298 : else if (ok_langs[0] != '\0')
112 : : /* Eventually this should become a hard error IMO. */
113 : 297 : 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 : 298 : free (ok_langs);
121 : 298 : 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 : 88 : 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 : 37171 : print_ignored_options (void)
141 : : {
142 : 37194 : 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 : 37171 : }
153 : :
154 : : /* Handle an unknown option DECODED, returning true if an error should
155 : : be given. */
156 : :
157 : : static bool
158 : 88 : unknown_option_callback (const struct cl_decoded_option *decoded)
159 : : {
160 : 88 : const char *opt = decoded->arg;
161 : :
162 : 88 : if (opt[1] == 'W' && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-'
163 : 88 : && !(decoded->errors & CL_ERR_NEGATIVE))
164 : : {
165 : : /* We don't generate warnings for unknown -Wno-* options unless
166 : : we issue diagnostics. */
167 : 88 : postpone_unknown_option_warning (opt);
168 : 88 : 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 : 4022479 : 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 : 4022479 : gcc_assert (opts == &global_options);
188 : 4022479 : gcc_assert (opts_set == &global_options_set);
189 : 4022479 : gcc_assert (dc == global_dc);
190 : 4022479 : gcc_assert (decoded->canonical_option_num_elements <= 2);
191 : 4022479 : return lang_hooks.handle_option (decoded->opt_index, decoded->arg,
192 : 4022479 : decoded->value, kind, loc, handlers);
193 : : }
194 : :
195 : : /* Handle FILENAME from the command line. */
196 : :
197 : : static void
198 : 283884 : add_input_filename (const char *filename)
199 : : {
200 : 283884 : num_in_fnames++;
201 : 283884 : in_fnames = XRESIZEVEC (const char *, in_fnames, num_in_fnames);
202 : 283884 : in_fnames[num_in_fnames - 1] = filename;
203 : 283884 : }
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 : 535347 : 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 : 535347 : unsigned int i;
221 : :
222 : 9501693 : for (i = 1; i < decoded_options_count; i++)
223 : : {
224 : 8966346 : 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 : 283884 : gcc_assert (opts == &global_options);
229 : 283884 : gcc_assert (opts_set == &global_options_set);
230 : :
231 : 283884 : if (opts->x_main_input_filename == NULL)
232 : : {
233 : 273196 : opts->x_main_input_filename = decoded_options[i].arg;
234 : 273196 : opts->x_main_input_baselength
235 : 273196 : = base_of_path (opts->x_main_input_filename,
236 : : &opts->x_main_input_basename);
237 : : }
238 : 283884 : add_input_filename (decoded_options[i].arg);
239 : 283884 : continue;
240 : : }
241 : :
242 : 8682462 : read_cmdline_option (opts, opts_set,
243 : : decoded_options + i, loc, lang_mask, handlers,
244 : : dc);
245 : : }
246 : 535347 : }
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 : 273196 : init_options_once (void)
255 : : {
256 : : /* Perform language-specific options initialization. */
257 : 273196 : initial_lang_mask = lang_hooks.option_lang_mask ();
258 : :
259 : 273196 : const bool show_highlight_colors
260 : 273196 : = pp_show_highlight_colors (global_dc->m_printer);
261 : :
262 : 273196 : 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 : 273196 : global_dc->set_show_highlight_colors (show_highlight_colors);
268 : :
269 : 273196 : diagnostic_color_init (global_dc);
270 : 273196 : diagnostic_urls_init (global_dc);
271 : 273196 : }
272 : :
273 : : /* Decode command-line options to an array, like
274 : : decode_cmdline_options_to_array and with the same arguments but
275 : : using the default lang_mask. */
276 : :
277 : : void
278 : 535347 : decode_cmdline_options_to_array_default_mask (unsigned int argc,
279 : : const char **argv,
280 : : struct cl_decoded_option **decoded_options,
281 : : unsigned int *decoded_options_count)
282 : : {
283 : 535347 : decode_cmdline_options_to_array (argc, argv,
284 : : initial_lang_mask | CL_COMMON | CL_TARGET,
285 : : decoded_options, decoded_options_count);
286 : 535347 : }
287 : :
288 : : /* Set *HANDLERS to the default set of option handlers for use in the
289 : : compilers proper (not the driver). */
290 : : void
291 : 2671327 : set_default_handlers (struct cl_option_handlers *handlers,
292 : : void (*target_option_override_hook) (void))
293 : : {
294 : 2671327 : handlers->unknown_option_callback = unknown_option_callback;
295 : 2671327 : handlers->wrong_lang_callback = complain_wrong_lang;
296 : 2671327 : handlers->target_option_override_hook = target_option_override_hook;
297 : 2671327 : handlers->num_handlers = 3;
298 : 2671327 : handlers->handlers[0].handler = lang_handle_option;
299 : 2671327 : handlers->handlers[0].mask = initial_lang_mask;
300 : 2671327 : handlers->handlers[1].handler = common_handle_option;
301 : 2671327 : handlers->handlers[1].mask = CL_COMMON;
302 : 2671327 : handlers->handlers[2].handler = target_handle_option;
303 : 2671327 : handlers->handlers[2].mask = CL_TARGET;
304 : 2671327 : }
305 : :
306 : : /* Parse command line options and set default flag values. Do minimal
307 : : options processing. The decoded options are in *DECODED_OPTIONS
308 : : and *DECODED_OPTIONS_COUNT; settings go in OPTS, OPTS_SET and DC;
309 : : the options are located at LOC. */
310 : : void
311 : 535347 : decode_options (struct gcc_options *opts, struct gcc_options *opts_set,
312 : : struct cl_decoded_option *decoded_options,
313 : : unsigned int decoded_options_count,
314 : : location_t loc, diagnostic_context *dc,
315 : : void (*target_option_override_hook) (void))
316 : : {
317 : 535347 : struct cl_option_handlers handlers;
318 : :
319 : 535347 : unsigned int lang_mask;
320 : :
321 : 535347 : lang_mask = initial_lang_mask;
322 : :
323 : 535347 : set_default_handlers (&handlers, target_option_override_hook);
324 : :
325 : 535347 : default_options_optimization (opts, opts_set,
326 : : decoded_options, decoded_options_count,
327 : : loc, lang_mask, &handlers, dc);
328 : :
329 : 535347 : read_cmdline_options (opts, opts_set,
330 : : decoded_options, decoded_options_count,
331 : : loc, lang_mask,
332 : : &handlers, dc);
333 : :
334 : 535347 : finish_options (opts, opts_set, loc);
335 : :
336 : : /* Print --help=* if used. */
337 : 535347 : unsigned i;
338 : 535347 : const char *arg;
339 : :
340 : 535347 : if (!help_option_arguments.is_empty ())
341 : : {
342 : : /* Make sure --help=* sees the overridden values. */
343 : 72 : target_option_override_hook ();
344 : :
345 : 218 : FOR_EACH_VEC_ELT (help_option_arguments, i, arg)
346 : 74 : print_help (opts, lang_mask, arg);
347 : : }
348 : 535347 : }
349 : :
350 : : /* Hold command-line options associated with stack limitation. */
351 : : const char *opt_fstack_limit_symbol_arg = NULL;
352 : : int opt_fstack_limit_register_no = -1;
353 : :
354 : : /* Process common options that have been deferred until after the
355 : : handlers have been called for all options. */
356 : :
357 : : void
358 : 273196 : handle_common_deferred_options (void)
359 : : {
360 : 273196 : unsigned int i;
361 : 273196 : cl_deferred_option *opt;
362 : 273196 : vec<cl_deferred_option> v;
363 : :
364 : 273196 : if (common_deferred_options)
365 : 20954 : v = *((vec<cl_deferred_option> *) common_deferred_options);
366 : : else
367 : : v = vNULL;
368 : :
369 : 273196 : if (flag_dump_all_passed)
370 : 4 : enable_rtl_dump_file ();
371 : :
372 : 273196 : if (flag_opt_info)
373 : 1 : opt_info_switch_p (NULL);
374 : :
375 : 273196 : flag_canon_prefix_map = false;
376 : 296673 : FOR_EACH_VEC_ELT (v, i, opt)
377 : : {
378 : 23481 : switch (opt->opt_index)
379 : : {
380 : 0 : case OPT_fcall_used_:
381 : 0 : fix_register (opt->arg, 0, 1);
382 : 0 : break;
383 : :
384 : 0 : case OPT_fcall_saved_:
385 : 0 : fix_register (opt->arg, 0, 0);
386 : 0 : break;
387 : :
388 : 3 : case OPT_fdbg_cnt_:
389 : 3 : dbg_cnt_process_opt (opt->arg);
390 : 3 : break;
391 : :
392 : 551 : case OPT_fdebug_prefix_map_:
393 : 551 : add_debug_prefix_map (opt->arg);
394 : 551 : break;
395 : :
396 : 220 : case OPT_ffile_prefix_map_:
397 : 220 : add_file_prefix_map (opt->arg);
398 : 220 : break;
399 : :
400 : 0 : case OPT_fprofile_prefix_map_:
401 : 0 : add_profile_prefix_map (opt->arg);
402 : 0 : break;
403 : :
404 : 0 : case OPT_fcanon_prefix_map:
405 : 0 : flag_canon_prefix_map = opt->value;
406 : 0 : break;
407 : :
408 : : case OPT_fdump_:
409 : : /* Deferred until plugins initialized. */
410 : : break;
411 : :
412 : 676 : case OPT_fopt_info_:
413 : 676 : if (!opt_info_switch_p (opt->arg))
414 : 0 : error ("unrecognized command-line option %<-fopt-info-%s%>",
415 : : opt->arg);
416 : : break;
417 : :
418 : 195 : case OPT_fenable_:
419 : 195 : case OPT_fdisable_:
420 : 195 : if (opt->opt_index == OPT_fenable_)
421 : 4 : enable_pass (opt->arg);
422 : : else
423 : 191 : disable_pass (opt->arg);
424 : : break;
425 : :
426 : 93 : case OPT_ffixed_:
427 : : /* Deferred. */
428 : 93 : fix_register (opt->arg, 1, 1);
429 : 93 : break;
430 : :
431 : 239 : case OPT_fplugin_:
432 : : #ifdef ENABLE_PLUGIN
433 : 239 : add_new_plugin (opt->arg);
434 : : #else
435 : : error ("plugin support is disabled; configure with "
436 : : "%<--enable-plugin%>");
437 : : #endif
438 : 239 : break;
439 : :
440 : 12 : case OPT_fplugin_arg_:
441 : : #ifdef ENABLE_PLUGIN
442 : 12 : parse_plugin_arg_opt (opt->arg);
443 : : #else
444 : : error ("plugin support is disabled; configure with "
445 : : "%<--enable-plugin%>");
446 : : #endif
447 : 12 : break;
448 : :
449 : 0 : case OPT_frandom_seed:
450 : : /* The real switch is -fno-random-seed. */
451 : 0 : if (!opt->value)
452 : 0 : set_random_seed (NULL);
453 : : break;
454 : :
455 : 1744 : case OPT_frandom_seed_:
456 : 1744 : set_random_seed (opt->arg);
457 : 1744 : break;
458 : :
459 : 1 : case OPT_fstack_limit:
460 : : /* The real switch is -fno-stack-limit. */
461 : 1 : if (!opt->value)
462 : 0 : stack_limit_rtx = NULL_RTX;
463 : : break;
464 : :
465 : 0 : case OPT_fstack_limit_register_:
466 : 0 : {
467 : 0 : int reg = decode_reg_name (opt->arg);
468 : 0 : if (reg < 0)
469 : 0 : error ("unrecognized register name %qs", opt->arg);
470 : : else
471 : : {
472 : : /* Deactivate previous OPT_fstack_limit_symbol_ options. */
473 : 0 : opt_fstack_limit_symbol_arg = NULL;
474 : 0 : opt_fstack_limit_register_no = reg;
475 : : }
476 : : }
477 : : break;
478 : :
479 : 0 : case OPT_fstack_limit_symbol_:
480 : : /* Deactivate previous OPT_fstack_limit_register_ options. */
481 : 0 : opt_fstack_limit_register_no = -1;
482 : 0 : opt_fstack_limit_symbol_arg = opt->arg;
483 : 0 : break;
484 : :
485 : 10 : case OPT_fasan_shadow_offset_:
486 : 10 : if (!(flag_sanitize & SANITIZE_KERNEL_ADDRESS))
487 : 0 : error ("%<-fasan-shadow-offset%> should only be used "
488 : : "with %<-fsanitize=kernel-address%>");
489 : 10 : if (!set_asan_shadow_offset (opt->arg))
490 : 0 : error ("unrecognized shadow offset %qs", opt->arg);
491 : : break;
492 : :
493 : 40 : case OPT_fsanitize_sections_:
494 : 40 : set_sanitized_sections (opt->arg);
495 : 40 : break;
496 : :
497 : 0 : default:
498 : 0 : gcc_unreachable ();
499 : : }
500 : : }
501 : 273192 : }
502 : :
503 : : /* Handle deferred dump options. */
504 : :
505 : : void
506 : 273192 : handle_deferred_dump_options (void)
507 : : {
508 : 273192 : unsigned int i;
509 : 273192 : cl_deferred_option *opt;
510 : 273192 : vec<cl_deferred_option> v;
511 : :
512 : 273192 : if (common_deferred_options)
513 : 20950 : v = *((vec<cl_deferred_option> *) common_deferred_options);
514 : : else
515 : : v = vNULL;
516 : 296669 : FOR_EACH_VEC_ELT (v, i, opt)
517 : 23477 : if (opt->opt_index == OPT_fdump_)
518 : 19697 : g->get_dumps ()->dump_switch_p (opt->arg);
519 : 273192 : }
|
