1 /* Command line option handling. Code involving global state that 2 should not be shared with the driver. 3 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 4 Free Software Foundation, Inc. 5 6 This file is part of GCC. 7 8 GCC is free software; you can redistribute it and/or modify it under 9 the terms of the GNU General Public License as published by the Free 10 Software Foundation; either version 3, or (at your option) any later 11 version. 12 13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 14 WARRANTY; without even the implied warranty of MERCHANTABILITY or 15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 16 for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with GCC; see the file COPYING3. If not see 20 <http://www.gnu.org/licenses/>. */ 21 22 #include "config.h" 23 #include "system.h" 24 #include "coretypes.h" 25 #include "diagnostic.h" 26 #include "opts.h" 27 #include "flags.h" 28 #include "ggc.h" 29 #include "tree.h" /* Required by langhooks.h. */ 30 #include "langhooks.h" 31 #include "tm.h" /* Required by rtl.h. */ 32 #include "rtl.h" 33 #include "dbgcnt.h" 34 #include "debug.h" 35 #include "lto-streamer.h" 36 #include "output.h" 37 #include "plugin.h" 38 #include "toplev.h" 39 #include "tree-pass.h" 40 41 typedef const char *const_char_p; /* For DEF_VEC_P. */ 42 DEF_VEC_P(const_char_p); 43 DEF_VEC_ALLOC_P(const_char_p,heap); 44 45 static VEC(const_char_p,heap) *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 static 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 unrecognised -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 VEC_safe_push (const_char_p, heap, ignored_options, opt); 126 } 127 128 /* Produce a warning for each option previously buffered. */ 129 130 void 131 print_ignored_options (void) 132 { 133 while (!VEC_empty (const_char_p, ignored_options)) 134 { 135 const char *opt; 136 137 opt = VEC_pop (const_char_p, ignored_options); 138 warning_at (UNKNOWN_LOCATION, 0, 139 "unrecognized command line option \"%s\"", 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 { 175 gcc_assert (opts == &global_options); 176 gcc_assert (opts_set == &global_options_set); 177 gcc_assert (dc == global_dc); 178 gcc_assert (decoded->canonical_option_num_elements <= 2); 179 return lang_hooks.handle_option (decoded->opt_index, decoded->arg, 180 decoded->value, kind, loc, handlers); 181 } 182 183 /* Handle FILENAME from the command line. */ 184 185 static void 186 add_input_filename (const char *filename) 187 { 188 num_in_fnames++; 189 in_fnames = XRESIZEVEC (const char *, in_fnames, num_in_fnames); 190 in_fnames[num_in_fnames - 1] = filename; 191 } 192 193 /* Handle the vector of command line options (located at LOC), storing 194 the results of processing DECODED_OPTIONS and DECODED_OPTIONS_COUNT 195 in OPTS and OPTS_SET and using DC for diagnostic state. LANG_MASK 196 contains has a single bit set representing the current language. 197 HANDLERS describes what functions to call for the options. */ 198 199 static void 200 read_cmdline_options (struct gcc_options *opts, struct gcc_options *opts_set, 201 struct cl_decoded_option *decoded_options, 202 unsigned int decoded_options_count, 203 location_t loc, 204 unsigned int lang_mask, 205 const struct cl_option_handlers *handlers, 206 diagnostic_context *dc) 207 { 208 unsigned int i; 209 210 for (i = 1; i < decoded_options_count; i++) 211 { 212 if (decoded_options[i].opt_index == OPT_SPECIAL_input_file) 213 { 214 /* Input files should only ever appear on the main command 215 line. */ 216 gcc_assert (opts == &global_options); 217 gcc_assert (opts_set == &global_options_set); 218 219 if (opts->x_main_input_filename == NULL) 220 { 221 opts->x_main_input_filename = decoded_options[i].arg; 222 opts->x_main_input_baselength 223 = base_of_path (opts->x_main_input_filename, 224 &opts->x_main_input_basename); 225 } 226 add_input_filename (decoded_options[i].arg); 227 continue; 228 } 229 230 read_cmdline_option (opts, opts_set, 231 decoded_options + i, loc, lang_mask, handlers, 232 dc); 233 } 234 } 235 236 /* Language mask determined at initialization. */ 237 static unsigned int initial_lang_mask; 238 239 /* Initialize global options-related settings at start-up. */ 240 241 void 242 init_options_once (void) 243 { 244 /* Perform language-specific options initialization. */ 245 initial_lang_mask = lang_hooks.option_lang_mask (); 246 247 lang_hooks.initialize_diagnostics (global_dc); 248 } 249 250 /* Decode command-line options to an array, like 251 decode_cmdline_options_to_array and with the same arguments but 252 using the default lang_mask. */ 253 254 void 255 decode_cmdline_options_to_array_default_mask (unsigned int argc, 256 const char **argv, 257 struct cl_decoded_option **decoded_options, 258 unsigned int *decoded_options_count) 259 { 260 decode_cmdline_options_to_array (argc, argv, 261 initial_lang_mask | CL_COMMON | CL_TARGET, 262 decoded_options, decoded_options_count); 263 } 264 265 /* Set *HANDLERS to the default set of option handlers for use in the 266 compilers proper (not the driver). */ 267 void 268 set_default_handlers (struct cl_option_handlers *handlers) 269 { 270 handlers->unknown_option_callback = unknown_option_callback; 271 handlers->wrong_lang_callback = complain_wrong_lang; 272 handlers->num_handlers = 3; 273 handlers->handlers[0].handler = lang_handle_option; 274 handlers->handlers[0].mask = initial_lang_mask; 275 handlers->handlers[1].handler = common_handle_option; 276 handlers->handlers[1].mask = CL_COMMON; 277 handlers->handlers[2].handler = target_handle_option; 278 handlers->handlers[2].mask = CL_TARGET; 279 } 280 281 /* Parse command line options and set default flag values. Do minimal 282 options processing. The decoded options are in *DECODED_OPTIONS 283 and *DECODED_OPTIONS_COUNT; settings go in OPTS, OPTS_SET and DC; 284 the options are located at LOC. */ 285 void 286 decode_options (struct gcc_options *opts, struct gcc_options *opts_set, 287 struct cl_decoded_option *decoded_options, 288 unsigned int decoded_options_count, 289 location_t loc, diagnostic_context *dc) 290 { 291 struct cl_option_handlers handlers; 292 293 unsigned int lang_mask; 294 295 lang_mask = initial_lang_mask; 296 297 set_default_handlers (&handlers); 298 299 default_options_optimization (opts, opts_set, 300 decoded_options, decoded_options_count, 301 loc, lang_mask, &handlers, dc); 302 303 read_cmdline_options (opts, opts_set, 304 decoded_options, decoded_options_count, 305 loc, lang_mask, 306 &handlers, dc); 307 308 finish_options (opts, opts_set, loc); 309 } 310 311 /* Process common options that have been deferred until after the 312 handlers have been called for all options. */ 313 314 void 315 handle_common_deferred_options (void) 316 { 317 unsigned int i; 318 cl_deferred_option *opt; 319 VEC(cl_deferred_option,heap) *vec 320 = (VEC(cl_deferred_option,heap) *) common_deferred_options; 321 322 if (flag_dump_all_passed) 323 enable_rtl_dump_file (); 324 325 FOR_EACH_VEC_ELT (cl_deferred_option, vec, i, opt) 326 { 327 switch (opt->opt_index) 328 { 329 case OPT_fcall_used_: 330 fix_register (opt->arg, 0, 1); 331 break; 332 333 case OPT_fcall_saved_: 334 fix_register (opt->arg, 0, 0); 335 break; 336 337 case OPT_fdbg_cnt_: 338 dbg_cnt_process_opt (opt->arg); 339 break; 340 341 case OPT_fdbg_cnt_list: 342 dbg_cnt_list_all_counters (); 343 break; 344 345 case OPT_fdebug_prefix_map_: 346 add_debug_prefix_map (opt->arg); 347 break; 348 349 case OPT_fdump_: 350 if (!dump_switch_p (opt->arg)) 351 error ("unrecognized command line option %<-fdump-%s%>", opt->arg); 352 break; 353 354 case OPT_fenable_: 355 case OPT_fdisable_: 356 if (opt->opt_index == OPT_fenable_) 357 enable_pass (opt->arg); 358 else 359 disable_pass (opt->arg); 360 break; 361 362 case OPT_ffixed_: 363 /* Deferred. */ 364 fix_register (opt->arg, 1, 1); 365 break; 366 367 case OPT_fplugin_: 368 #ifdef ENABLE_PLUGIN 369 add_new_plugin (opt->arg); 370 #else 371 error ("plugin support is disabled; configure with --enable-plugin"); 372 #endif 373 break; 374 375 case OPT_fplugin_arg_: 376 #ifdef ENABLE_PLUGIN 377 parse_plugin_arg_opt (opt->arg); 378 #else 379 error ("plugin support is disabled; configure with --enable-plugin"); 380 #endif 381 break; 382 383 case OPT_frandom_seed: 384 /* The real switch is -fno-random-seed. */ 385 if (!opt->value) 386 set_random_seed (NULL); 387 break; 388 389 case OPT_frandom_seed_: 390 set_random_seed (opt->arg); 391 break; 392 393 case OPT_fstack_limit: 394 /* The real switch is -fno-stack-limit. */ 395 if (!opt->value) 396 stack_limit_rtx = NULL_RTX; 397 break; 398 399 case OPT_fstack_limit_register_: 400 { 401 int reg = decode_reg_name (opt->arg); 402 if (reg < 0) 403 error ("unrecognized register name %qs", opt->arg); 404 else 405 stack_limit_rtx = gen_rtx_REG (Pmode, reg); 406 } 407 break; 408 409 case OPT_fstack_limit_symbol_: 410 stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (opt->arg)); 411 break; 412 413 default: 414 gcc_unreachable (); 415 } 416 } 417 } 418