gcc/opts-global.c

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