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
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify it under
8the terms of the GNU General Public License as published by the Free
9Software Foundation; either version 3, or (at your option) any later
10version.
11
12GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13WARRANTY; without even the implied warranty of MERCHANTABILITY or
14FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15for more details.
16
17You should have received a copy of the GNU General Public License
18along 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
43typedef const char *const_char_p; /* For DEF_VEC_P.  */
44
45static vec<const_char_p> ignored_options;
46
47/* Input file names.  */
48const char **in_fnames;
49unsigned num_in_fnames;
50
51/* Return a malloced slash-separated list of languages in MASK.  */
52
53char *
54write_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
83static void
84complain_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
126static void
127postpone_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
134void
135print_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
152static bool
153unknown_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
172static bool
173lang_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
192static void
193add_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
206static void
207read_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.  */
244static unsigned int initial_lang_mask;
245
246/* Initialize global options-related settings at start-up.  */
247
248void
249init_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
267void
268decode_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).  */
280void
281set_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.  */
300void
301decode_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.  */
341const char *opt_fstack_limit_symbol_arg = NULL;
342int 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
347void
348handle_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