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