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