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