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 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 "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 65typedef const char *const_char_p; /* For DEF_VEC_P. */ 66 67static vec<const_char_p> ignored_options; 68 69/* Input file names. */ 70const char **in_fnames; 71unsigned num_in_fnames; 72 73/* Return a malloced slash-separated list of languages in MASK. */ 74 75static char * 76write_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 105static void 106complain_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 144static void 145postpone_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 152void 153print_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 168static bool 169unknown_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 188static bool 189lang_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 207static void 208add_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 221static void 222read_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. */ 259static unsigned int initial_lang_mask; 260 261/* Initialize global options-related settings at start-up. */ 262 263void 264init_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 281void 282decode_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). */ 294void 295set_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. */ 312void 313decode_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 341void 342handle_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_fdump_: 384 if (!g->get_dumps ()->dump_switch_p (opt->arg)) 385 error ("unrecognized command line option %<-fdump-%s%>", opt->arg); 386 break; 387 388 case OPT_fopt_info_: 389 if (!opt_info_switch_p (opt->arg)) 390 error ("unrecognized command line option %<-fopt-info-%s%>", 391 opt->arg); 392 break; 393 394 case OPT_fenable_: 395 case OPT_fdisable_: 396 if (opt->opt_index == OPT_fenable_) 397 enable_pass (opt->arg); 398 else 399 disable_pass (opt->arg); 400 break; 401 402 case OPT_ffixed_: 403 /* Deferred. */ 404 fix_register (opt->arg, 1, 1); 405 break; 406 407 case OPT_fplugin_: 408#ifdef ENABLE_PLUGIN 409 add_new_plugin (opt->arg); 410#else 411 error ("plugin support is disabled; configure with --enable-plugin"); 412#endif 413 break; 414 415 case OPT_fplugin_arg_: 416#ifdef ENABLE_PLUGIN 417 parse_plugin_arg_opt (opt->arg); 418#else 419 error ("plugin support is disabled; configure with --enable-plugin"); 420#endif 421 break; 422 423 case OPT_frandom_seed: 424 /* The real switch is -fno-random-seed. */ 425 if (!opt->value) 426 set_random_seed (NULL); 427 break; 428 429 case OPT_frandom_seed_: 430 set_random_seed (opt->arg); 431 break; 432 433 case OPT_fstack_limit: 434 /* The real switch is -fno-stack-limit. */ 435 if (!opt->value) 436 stack_limit_rtx = NULL_RTX; 437 break; 438 439 case OPT_fstack_limit_register_: 440 { 441 int reg = decode_reg_name (opt->arg); 442 if (reg < 0) 443 error ("unrecognized register name %qs", opt->arg); 444 else 445 stack_limit_rtx = gen_rtx_REG (Pmode, reg); 446 } 447 break; 448 449 case OPT_fstack_limit_symbol_: 450 stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (opt->arg)); 451 break; 452 453 case OPT_fasan_shadow_offset_: 454 if (!(flag_sanitize & SANITIZE_KERNEL_ADDRESS)) 455 error ("-fasan-shadow-offset should only be used " 456 "with -fsanitize=kernel-address"); 457 if (!set_asan_shadow_offset (opt->arg)) 458 error ("unrecognized shadow offset %qs", opt->arg); 459 break; 460 461 default: 462 gcc_unreachable (); 463 } 464 } 465} 466