1 /* Command line option handling. Code involving global state that
2 should not be shared with the driver.
3 Copyright (C) 2002-2018 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 warning_at (UNKNOWN_LOCATION, 0,
143 "unrecognized command line option %qs", opt);
144 }
145 }
146
147 /* Handle an unknown option DECODED, returning true if an error should
148 be given. */
149
150 static bool
unknown_option_callback(const struct cl_decoded_option * decoded)151 unknown_option_callback (const struct cl_decoded_option *decoded)
152 {
153 const char *opt = decoded->arg;
154
155 if (opt[1] == 'W' && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-'
156 && !(decoded->errors & CL_ERR_NEGATIVE))
157 {
158 /* We don't generate warnings for unknown -Wno-* options unless
159 we issue diagnostics. */
160 postpone_unknown_option_warning (opt);
161 return false;
162 }
163 else
164 return true;
165 }
166
167 /* Handle a front-end option; arguments and return value as for
168 handle_option. */
169
170 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))171 lang_handle_option (struct gcc_options *opts,
172 struct gcc_options *opts_set,
173 const struct cl_decoded_option *decoded,
174 unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
175 location_t loc,
176 const struct cl_option_handlers *handlers,
177 diagnostic_context *dc,
178 void (*) (void))
179 {
180 gcc_assert (opts == &global_options);
181 gcc_assert (opts_set == &global_options_set);
182 gcc_assert (dc == global_dc);
183 gcc_assert (decoded->canonical_option_num_elements <= 2);
184 return lang_hooks.handle_option (decoded->opt_index, decoded->arg,
185 decoded->value, kind, loc, handlers);
186 }
187
188 /* Handle FILENAME from the command line. */
189
190 static void
add_input_filename(const char * filename)191 add_input_filename (const char *filename)
192 {
193 num_in_fnames++;
194 in_fnames = XRESIZEVEC (const char *, in_fnames, num_in_fnames);
195 in_fnames[num_in_fnames - 1] = filename;
196 }
197
198 /* Handle the vector of command line options (located at LOC), storing
199 the results of processing DECODED_OPTIONS and DECODED_OPTIONS_COUNT
200 in OPTS and OPTS_SET and using DC for diagnostic state. LANG_MASK
201 contains has a single bit set representing the current language.
202 HANDLERS describes what functions to call for the options. */
203
204 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)205 read_cmdline_options (struct gcc_options *opts, struct gcc_options *opts_set,
206 struct cl_decoded_option *decoded_options,
207 unsigned int decoded_options_count,
208 location_t loc,
209 unsigned int lang_mask,
210 const struct cl_option_handlers *handlers,
211 diagnostic_context *dc)
212 {
213 unsigned int i;
214
215 for (i = 1; i < decoded_options_count; i++)
216 {
217 if (decoded_options[i].opt_index == OPT_SPECIAL_input_file)
218 {
219 /* Input files should only ever appear on the main command
220 line. */
221 gcc_assert (opts == &global_options);
222 gcc_assert (opts_set == &global_options_set);
223
224 if (opts->x_main_input_filename == NULL)
225 {
226 opts->x_main_input_filename = decoded_options[i].arg;
227 opts->x_main_input_baselength
228 = base_of_path (opts->x_main_input_filename,
229 &opts->x_main_input_basename);
230 }
231 add_input_filename (decoded_options[i].arg);
232 continue;
233 }
234
235 read_cmdline_option (opts, opts_set,
236 decoded_options + i, loc, lang_mask, handlers,
237 dc);
238 }
239 }
240
241 /* Language mask determined at initialization. */
242 static unsigned int initial_lang_mask;
243
244 /* Initialize global options-related settings at start-up. */
245
246 void
init_options_once(void)247 init_options_once (void)
248 {
249 /* Perform language-specific options initialization. */
250 initial_lang_mask = lang_hooks.option_lang_mask ();
251
252 lang_hooks.initialize_diagnostics (global_dc);
253 /* ??? Ideally, we should do this earlier and the FEs will override
254 it if desired (none do it so far). However, the way the FEs
255 construct their pretty-printers means that all previous settings
256 are overriden. */
257 diagnostic_color_init (global_dc);
258 }
259
260 /* Decode command-line options to an array, like
261 decode_cmdline_options_to_array and with the same arguments but
262 using the default lang_mask. */
263
264 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)265 decode_cmdline_options_to_array_default_mask (unsigned int argc,
266 const char **argv,
267 struct cl_decoded_option **decoded_options,
268 unsigned int *decoded_options_count)
269 {
270 decode_cmdline_options_to_array (argc, argv,
271 initial_lang_mask | CL_COMMON | CL_TARGET,
272 decoded_options, decoded_options_count);
273 }
274
275 /* Set *HANDLERS to the default set of option handlers for use in the
276 compilers proper (not the driver). */
277 void
set_default_handlers(struct cl_option_handlers * handlers,void (* target_option_override_hook)(void))278 set_default_handlers (struct cl_option_handlers *handlers,
279 void (*target_option_override_hook) (void))
280 {
281 handlers->unknown_option_callback = unknown_option_callback;
282 handlers->wrong_lang_callback = complain_wrong_lang;
283 handlers->target_option_override_hook = target_option_override_hook;
284 handlers->num_handlers = 3;
285 handlers->handlers[0].handler = lang_handle_option;
286 handlers->handlers[0].mask = initial_lang_mask;
287 handlers->handlers[1].handler = common_handle_option;
288 handlers->handlers[1].mask = CL_COMMON;
289 handlers->handlers[2].handler = target_handle_option;
290 handlers->handlers[2].mask = CL_TARGET;
291 }
292
293 /* Parse command line options and set default flag values. Do minimal
294 options processing. The decoded options are in *DECODED_OPTIONS
295 and *DECODED_OPTIONS_COUNT; settings go in OPTS, OPTS_SET and DC;
296 the options are located at LOC. */
297 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))298 decode_options (struct gcc_options *opts, struct gcc_options *opts_set,
299 struct cl_decoded_option *decoded_options,
300 unsigned int decoded_options_count,
301 location_t loc, diagnostic_context *dc,
302 void (*target_option_override_hook) (void))
303 {
304 struct cl_option_handlers handlers;
305
306 unsigned int lang_mask;
307
308 lang_mask = initial_lang_mask;
309
310 set_default_handlers (&handlers, target_option_override_hook);
311
312 default_options_optimization (opts, opts_set,
313 decoded_options, decoded_options_count,
314 loc, lang_mask, &handlers, dc);
315
316 read_cmdline_options (opts, opts_set,
317 decoded_options, decoded_options_count,
318 loc, lang_mask,
319 &handlers, dc);
320
321 finish_options (opts, opts_set, loc);
322 }
323
324 /* Hold command-line options associated with stack limitation. */
325 const char *opt_fstack_limit_symbol_arg = NULL;
326 int opt_fstack_limit_register_no = -1;
327
328 /* Process common options that have been deferred until after the
329 handlers have been called for all options. */
330
331 void
handle_common_deferred_options(void)332 handle_common_deferred_options (void)
333 {
334 unsigned int i;
335 cl_deferred_option *opt;
336 vec<cl_deferred_option> v;
337
338 if (common_deferred_options)
339 v = *((vec<cl_deferred_option> *) common_deferred_options);
340 else
341 v = vNULL;
342
343 if (flag_dump_all_passed)
344 enable_rtl_dump_file ();
345
346 if (flag_opt_info)
347 opt_info_switch_p (NULL);
348
349 FOR_EACH_VEC_ELT (v, i, opt)
350 {
351 switch (opt->opt_index)
352 {
353 case OPT_fcall_used_:
354 fix_register (opt->arg, 0, 1);
355 break;
356
357 case OPT_fcall_saved_:
358 fix_register (opt->arg, 0, 0);
359 break;
360
361 case OPT_fdbg_cnt_:
362 dbg_cnt_process_opt (opt->arg);
363 break;
364
365 case OPT_fdbg_cnt_list:
366 dbg_cnt_list_all_counters ();
367 break;
368
369 case OPT_fdebug_prefix_map_:
370 add_debug_prefix_map (opt->arg);
371 break;
372
373 case OPT_ffile_prefix_map_:
374 add_file_prefix_map (opt->arg);
375 break;
376
377 case OPT_fdump_:
378 if (!g->get_dumps ()->dump_switch_p (opt->arg))
379 error ("unrecognized command line option %<-fdump-%s%>", opt->arg);
380 break;
381
382 case OPT_fopt_info_:
383 if (!opt_info_switch_p (opt->arg))
384 error ("unrecognized command line option %<-fopt-info-%s%>",
385 opt->arg);
386 break;
387
388 case OPT_fenable_:
389 case OPT_fdisable_:
390 if (opt->opt_index == OPT_fenable_)
391 enable_pass (opt->arg);
392 else
393 disable_pass (opt->arg);
394 break;
395
396 case OPT_ffixed_:
397 /* Deferred. */
398 fix_register (opt->arg, 1, 1);
399 break;
400
401 case OPT_fplugin_:
402 #ifdef ENABLE_PLUGIN
403 add_new_plugin (opt->arg);
404 #else
405 error ("plugin support is disabled; configure with --enable-plugin");
406 #endif
407 break;
408
409 case OPT_fplugin_arg_:
410 #ifdef ENABLE_PLUGIN
411 parse_plugin_arg_opt (opt->arg);
412 #else
413 error ("plugin support is disabled; configure with --enable-plugin");
414 #endif
415 break;
416
417 case OPT_frandom_seed:
418 /* The real switch is -fno-random-seed. */
419 if (!opt->value)
420 set_random_seed (NULL);
421 break;
422
423 case OPT_frandom_seed_:
424 set_random_seed (opt->arg);
425 break;
426
427 case OPT_fstack_limit:
428 /* The real switch is -fno-stack-limit. */
429 if (!opt->value)
430 stack_limit_rtx = NULL_RTX;
431 break;
432
433 case OPT_fstack_limit_register_:
434 {
435 int reg = decode_reg_name (opt->arg);
436 if (reg < 0)
437 error ("unrecognized register name %qs", opt->arg);
438 else
439 {
440 /* Deactivate previous OPT_fstack_limit_symbol_ options. */
441 opt_fstack_limit_symbol_arg = NULL;
442 opt_fstack_limit_register_no = reg;
443 }
444 }
445 break;
446
447 case OPT_fstack_limit_symbol_:
448 /* Deactivate previous OPT_fstack_limit_register_ options. */
449 opt_fstack_limit_register_no = -1;
450 opt_fstack_limit_symbol_arg = 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 case OPT_fsanitize_sections_:
462 set_sanitized_sections (opt->arg);
463 break;
464
465 default:
466 gcc_unreachable ();
467 }
468 }
469 }
470