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