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 * 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 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 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 111 free (ok_langs); 112 free (bad_lang); 113 } 114 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. */ 121 122 static void 123 postpone_unknown_option_warning (const char *opt) 124 { 125 ignored_options.safe_push (opt); 126 } 127 128 /* Produce a warning for each option previously buffered. */ 129 130 void 131 print_ignored_options (void) 132 { 133 while (!ignored_options.is_empty ()) 134 { 135 const char *opt; 136 137 opt = ignored_options.pop (); 138 warning_at (UNKNOWN_LOCATION, 0, 139 "unrecognized command line option %qs", opt); 140 } 141 } 142 143 /* Handle an unknown option DECODED, returning true if an error should 144 be given. */ 145 146 static bool 147 unknown_option_callback (const struct cl_decoded_option *decoded) 148 { 149 const char *opt = decoded->arg; 150 151 if (opt[1] == 'W' && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-' 152 && !(decoded->errors & CL_ERR_NEGATIVE)) 153 { 154 /* We don't generate warnings for unknown -Wno-* options unless 155 we issue diagnostics. */ 156 postpone_unknown_option_warning (opt); 157 return false; 158 } 159 else 160 return true; 161 } 162 163 /* Handle a front-end option; arguments and return value as for 164 handle_option. */ 165 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)) 175 { 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); 182 } 183 184 /* Handle FILENAME from the command line. */ 185 186 static void 187 add_input_filename (const char *filename) 188 { 189 num_in_fnames++; 190 in_fnames = XRESIZEVEC (const char *, in_fnames, num_in_fnames); 191 in_fnames[num_in_fnames - 1] = filename; 192 } 193 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. */ 199 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) 208 { 209 unsigned int i; 210 211 for (i = 1; i < decoded_options_count; i++) 212 { 213 if (decoded_options[i].opt_index == OPT_SPECIAL_input_file) 214 { 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); 219 220 if (opts->x_main_input_filename == NULL) 221 { 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); 226 } 227 add_input_filename (decoded_options[i].arg); 228 continue; 229 } 230 231 read_cmdline_option (opts, opts_set, 232 decoded_options + i, loc, lang_mask, handlers, 233 dc); 234 } 235 } 236 237 /* Language mask determined at initialization. */ 238 static unsigned int initial_lang_mask; 239 240 /* Initialize global options-related settings at start-up. */ 241 242 void 243 init_options_once (void) 244 { 245 /* Perform language-specific options initialization. */ 246 initial_lang_mask = lang_hooks.option_lang_mask (); 247 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); 254 } 255 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. */ 259 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) 265 { 266 decode_cmdline_options_to_array (argc, argv, 267 initial_lang_mask | CL_COMMON | CL_TARGET, 268 decoded_options, decoded_options_count); 269 } 270 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)) 276 { 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; 287 } 288 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)) 299 { 300 struct cl_option_handlers handlers; 301 302 unsigned int lang_mask; 303 304 lang_mask = initial_lang_mask; 305 306 set_default_handlers (&handlers, target_option_override_hook); 307 308 default_options_optimization (opts, opts_set, 309 decoded_options, decoded_options_count, 310 loc, lang_mask, &handlers, dc); 311 312 read_cmdline_options (opts, opts_set, 313 decoded_options, decoded_options_count, 314 loc, lang_mask, 315 &handlers, dc); 316 317 finish_options (opts, opts_set, loc); 318 } 319 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; 323 324 /* Process common options that have been deferred until after the 325 handlers have been called for all options. */ 326 327 void 328 handle_common_deferred_options (void) 329 { 330 unsigned int i; 331 cl_deferred_option *opt; 332 vec<cl_deferred_option> v; 333 334 if (common_deferred_options) 335 v = *((vec<cl_deferred_option> *) common_deferred_options); 336 else 337 v = vNULL; 338 339 if (flag_dump_all_passed) 340 enable_rtl_dump_file (); 341 342 if (flag_opt_info) 343 opt_info_switch_p (NULL); 344 345 FOR_EACH_VEC_ELT (v, i, opt) 346 { 347 switch (opt->opt_index) 348 { 349 case OPT_fcall_used_: 350 fix_register (opt->arg, 0, 1); 351 break; 352 353 case OPT_fcall_saved_: 354 fix_register (opt->arg, 0, 0); 355 break; 356 357 case OPT_fdbg_cnt_: 358 dbg_cnt_process_opt (opt->arg); 359 break; 360 361 case OPT_fdbg_cnt_list: 362 dbg_cnt_list_all_counters (); 363 break; 364 365 case OPT_fdebug_prefix_map_: 366 add_debug_prefix_map (opt->arg); 367 break; 368 369 case OPT_ffile_prefix_map_: 370 add_file_prefix_map (opt->arg); 371 break; 372 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; 377 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; 383 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; 391 392 case OPT_ffixed_: 393 /* Deferred. */ 394 fix_register (opt->arg, 1, 1); 395 break; 396 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; 404 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; 412 413 case OPT_frandom_seed: 414 /* The real switch is -fno-random-seed. */ 415 if (!opt->value) 416 set_random_seed (NULL); 417 break; 418 419 case OPT_frandom_seed_: 420 set_random_seed (opt->arg); 421 break; 422 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; 428 429 case OPT_fstack_limit_register_: 430 { 431 int reg = decode_reg_name (opt->arg); 432 if (reg < 0) 433 error ("unrecognized register name %qs", opt->arg); 434 else 435 { 436 /* Deactivate previous OPT_fstack_limit_symbol_ options. */ 437 opt_fstack_limit_symbol_arg = NULL; 438 opt_fstack_limit_register_no = reg; 439 } 440 } 441 break; 442 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; 448 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; 456 457 case OPT_fsanitize_sections_: 458 set_sanitized_sections (opt->arg); 459 break; 460 461 default: 462 gcc_unreachable (); 463 } 464 } 465 } 466