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