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