[AArch64] Fix gcc.target/aarch64/subs_compare_[12].c
[official-gcc.git] / gcc / opts-global.c
blobf33c9da4c3fec21f707e1e71d2c4d3b70c92289f
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.
5 This file is part of GCC.
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.
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.
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/>. */
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() */
43 typedef const char *const_char_p; /* For DEF_VEC_P. */
45 static vec<const_char_p> ignored_options;
47 /* Input file names. */
48 const char **in_fnames;
49 unsigned num_in_fnames;
51 /* Return a malloced slash-separated list of languages in MASK. */
53 char *
54 write_langs (unsigned int mask)
56 unsigned int n = 0, len = 0;
57 const char *lang_name;
58 char *result;
60 for (n = 0; (lang_name = lang_names[n]) != 0; n++)
61 if (mask & (1U << n))
62 len += strlen (lang_name) + 1;
64 result = XNEWVEC (char, len);
65 len = 0;
66 for (n = 0; (lang_name = lang_names[n]) != 0; n++)
67 if (mask & (1U << n))
69 if (len)
70 result[len++] = '/';
71 strcpy (result + len, lang_name);
72 len += strlen (lang_name);
75 result[len] = 0;
77 return result;
80 /* Complain that switch DECODED does not apply to this front end (mask
81 LANG_MASK). */
83 static void
84 complain_wrong_lang (const struct cl_decoded_option *decoded,
85 unsigned int lang_mask)
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;
92 if (!lang_hooks.complain_wrong_lang_p (option))
93 return;
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);
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
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);
111 free (ok_langs);
112 free (bad_lang);
115 /* Buffer the unknown option described by the string OPT. Currently,
116 we only complain about unknown -Wno-* options if they may have
117 prevented a diagnostic. Otherwise, we just ignore them. Note that
118 if we do complain, it is only as a warning, not an error; passing
119 the compiler an unrecognized -Wno-* option should never change
120 whether the compilation succeeds or fails. */
122 static void
123 postpone_unknown_option_warning (const char *opt)
125 ignored_options.safe_push (opt);
128 /* Produce a warning for each option previously buffered. */
130 void
131 print_ignored_options (void)
133 while (!ignored_options.is_empty ())
135 const char *opt;
137 opt = ignored_options.pop ();
138 warning_at (UNKNOWN_LOCATION, 0,
139 "unrecognized command line option %qs", opt);
143 /* Handle an unknown option DECODED, returning true if an error should
144 be given. */
146 static bool
147 unknown_option_callback (const struct cl_decoded_option *decoded)
149 const char *opt = decoded->arg;
151 if (opt[1] == 'W' && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-'
152 && !(decoded->errors & CL_ERR_NEGATIVE))
154 /* We don't generate warnings for unknown -Wno-* options unless
155 we issue diagnostics. */
156 postpone_unknown_option_warning (opt);
157 return false;
159 else
160 return true;
163 /* Handle a front-end option; arguments and return value as for
164 handle_option. */
166 static bool
167 lang_handle_option (struct gcc_options *opts,
168 struct gcc_options *opts_set,
169 const struct cl_decoded_option *decoded,
170 unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
171 location_t loc,
172 const struct cl_option_handlers *handlers,
173 diagnostic_context *dc,
174 void (*) (void))
176 gcc_assert (opts == &global_options);
177 gcc_assert (opts_set == &global_options_set);
178 gcc_assert (dc == global_dc);
179 gcc_assert (decoded->canonical_option_num_elements <= 2);
180 return lang_hooks.handle_option (decoded->opt_index, decoded->arg,
181 decoded->value, kind, loc, handlers);
184 /* Handle FILENAME from the command line. */
186 static void
187 add_input_filename (const char *filename)
189 num_in_fnames++;
190 in_fnames = XRESIZEVEC (const char *, in_fnames, num_in_fnames);
191 in_fnames[num_in_fnames - 1] = filename;
194 /* Handle the vector of command line options (located at LOC), storing
195 the results of processing DECODED_OPTIONS and DECODED_OPTIONS_COUNT
196 in OPTS and OPTS_SET and using DC for diagnostic state. LANG_MASK
197 contains has a single bit set representing the current language.
198 HANDLERS describes what functions to call for the options. */
200 static void
201 read_cmdline_options (struct gcc_options *opts, struct gcc_options *opts_set,
202 struct cl_decoded_option *decoded_options,
203 unsigned int decoded_options_count,
204 location_t loc,
205 unsigned int lang_mask,
206 const struct cl_option_handlers *handlers,
207 diagnostic_context *dc)
209 unsigned int i;
211 for (i = 1; i < decoded_options_count; i++)
213 if (decoded_options[i].opt_index == OPT_SPECIAL_input_file)
215 /* Input files should only ever appear on the main command
216 line. */
217 gcc_assert (opts == &global_options);
218 gcc_assert (opts_set == &global_options_set);
220 if (opts->x_main_input_filename == NULL)
222 opts->x_main_input_filename = decoded_options[i].arg;
223 opts->x_main_input_baselength
224 = base_of_path (opts->x_main_input_filename,
225 &opts->x_main_input_basename);
227 add_input_filename (decoded_options[i].arg);
228 continue;
231 read_cmdline_option (opts, opts_set,
232 decoded_options + i, loc, lang_mask, handlers,
233 dc);
237 /* Language mask determined at initialization. */
238 static unsigned int initial_lang_mask;
240 /* Initialize global options-related settings at start-up. */
242 void
243 init_options_once (void)
245 /* Perform language-specific options initialization. */
246 initial_lang_mask = lang_hooks.option_lang_mask ();
248 lang_hooks.initialize_diagnostics (global_dc);
249 /* ??? Ideally, we should do this earlier and the FEs will override
250 it if desired (none do it so far). However, the way the FEs
251 construct their pretty-printers means that all previous settings
252 are overriden. */
253 diagnostic_color_init (global_dc);
256 /* Decode command-line options to an array, like
257 decode_cmdline_options_to_array and with the same arguments but
258 using the default lang_mask. */
260 void
261 decode_cmdline_options_to_array_default_mask (unsigned int argc,
262 const char **argv,
263 struct cl_decoded_option **decoded_options,
264 unsigned int *decoded_options_count)
266 decode_cmdline_options_to_array (argc, argv,
267 initial_lang_mask | CL_COMMON | CL_TARGET,
268 decoded_options, decoded_options_count);
271 /* Set *HANDLERS to the default set of option handlers for use in the
272 compilers proper (not the driver). */
273 void
274 set_default_handlers (struct cl_option_handlers *handlers,
275 void (*target_option_override_hook) (void))
277 handlers->unknown_option_callback = unknown_option_callback;
278 handlers->wrong_lang_callback = complain_wrong_lang;
279 handlers->target_option_override_hook = target_option_override_hook;
280 handlers->num_handlers = 3;
281 handlers->handlers[0].handler = lang_handle_option;
282 handlers->handlers[0].mask = initial_lang_mask;
283 handlers->handlers[1].handler = common_handle_option;
284 handlers->handlers[1].mask = CL_COMMON;
285 handlers->handlers[2].handler = target_handle_option;
286 handlers->handlers[2].mask = CL_TARGET;
289 /* Parse command line options and set default flag values. Do minimal
290 options processing. The decoded options are in *DECODED_OPTIONS
291 and *DECODED_OPTIONS_COUNT; settings go in OPTS, OPTS_SET and DC;
292 the options are located at LOC. */
293 void
294 decode_options (struct gcc_options *opts, struct gcc_options *opts_set,
295 struct cl_decoded_option *decoded_options,
296 unsigned int decoded_options_count,
297 location_t loc, diagnostic_context *dc,
298 void (*target_option_override_hook) (void))
300 struct cl_option_handlers handlers;
302 unsigned int lang_mask;
304 lang_mask = initial_lang_mask;
306 set_default_handlers (&handlers, target_option_override_hook);
308 default_options_optimization (opts, opts_set,
309 decoded_options, decoded_options_count,
310 loc, lang_mask, &handlers, dc);
312 read_cmdline_options (opts, opts_set,
313 decoded_options, decoded_options_count,
314 loc, lang_mask,
315 &handlers, dc);
317 finish_options (opts, opts_set, loc);
320 /* Hold command-line options associated with stack limitation. */
321 const char *opt_fstack_limit_symbol_arg = NULL;
322 int opt_fstack_limit_register_no = -1;
324 /* Process common options that have been deferred until after the
325 handlers have been called for all options. */
327 void
328 handle_common_deferred_options (void)
330 unsigned int i;
331 cl_deferred_option *opt;
332 vec<cl_deferred_option> v;
334 if (common_deferred_options)
335 v = *((vec<cl_deferred_option> *) common_deferred_options);
336 else
337 v = vNULL;
339 if (flag_dump_all_passed)
340 enable_rtl_dump_file ();
342 if (flag_opt_info)
343 opt_info_switch_p (NULL);
345 FOR_EACH_VEC_ELT (v, i, opt)
347 switch (opt->opt_index)
349 case OPT_fcall_used_:
350 fix_register (opt->arg, 0, 1);
351 break;
353 case OPT_fcall_saved_:
354 fix_register (opt->arg, 0, 0);
355 break;
357 case OPT_fdbg_cnt_:
358 dbg_cnt_process_opt (opt->arg);
359 break;
361 case OPT_fdbg_cnt_list:
362 dbg_cnt_list_all_counters ();
363 break;
365 case OPT_fdebug_prefix_map_:
366 add_debug_prefix_map (opt->arg);
367 break;
369 case OPT_ffile_prefix_map_:
370 add_file_prefix_map (opt->arg);
371 break;
373 case OPT_fdump_:
374 if (!g->get_dumps ()->dump_switch_p (opt->arg))
375 error ("unrecognized command line option %<-fdump-%s%>", opt->arg);
376 break;
378 case OPT_fopt_info_:
379 if (!opt_info_switch_p (opt->arg))
380 error ("unrecognized command line option %<-fopt-info-%s%>",
381 opt->arg);
382 break;
384 case OPT_fenable_:
385 case OPT_fdisable_:
386 if (opt->opt_index == OPT_fenable_)
387 enable_pass (opt->arg);
388 else
389 disable_pass (opt->arg);
390 break;
392 case OPT_ffixed_:
393 /* Deferred. */
394 fix_register (opt->arg, 1, 1);
395 break;
397 case OPT_fplugin_:
398 #ifdef ENABLE_PLUGIN
399 add_new_plugin (opt->arg);
400 #else
401 error ("plugin support is disabled; configure with --enable-plugin");
402 #endif
403 break;
405 case OPT_fplugin_arg_:
406 #ifdef ENABLE_PLUGIN
407 parse_plugin_arg_opt (opt->arg);
408 #else
409 error ("plugin support is disabled; configure with --enable-plugin");
410 #endif
411 break;
413 case OPT_frandom_seed:
414 /* The real switch is -fno-random-seed. */
415 if (!opt->value)
416 set_random_seed (NULL);
417 break;
419 case OPT_frandom_seed_:
420 set_random_seed (opt->arg);
421 break;
423 case OPT_fstack_limit:
424 /* The real switch is -fno-stack-limit. */
425 if (!opt->value)
426 stack_limit_rtx = NULL_RTX;
427 break;
429 case OPT_fstack_limit_register_:
431 int reg = decode_reg_name (opt->arg);
432 if (reg < 0)
433 error ("unrecognized register name %qs", opt->arg);
434 else
436 /* Deactivate previous OPT_fstack_limit_symbol_ options. */
437 opt_fstack_limit_symbol_arg = NULL;
438 opt_fstack_limit_register_no = reg;
441 break;
443 case OPT_fstack_limit_symbol_:
444 /* Deactivate previous OPT_fstack_limit_register_ options. */
445 opt_fstack_limit_register_no = -1;
446 opt_fstack_limit_symbol_arg = opt->arg;
447 break;
449 case OPT_fasan_shadow_offset_:
450 if (!(flag_sanitize & SANITIZE_KERNEL_ADDRESS))
451 error ("-fasan-shadow-offset should only be used "
452 "with -fsanitize=kernel-address");
453 if (!set_asan_shadow_offset (opt->arg))
454 error ("unrecognized shadow offset %qs", opt->arg);
455 break;
457 case OPT_fsanitize_sections_:
458 set_sanitized_sections (opt->arg);
459 break;
461 default:
462 gcc_unreachable ();