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-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_fdump_:
 388           if (!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_ftree_vectorizer_verbose_:
 458           dump_remap_tree_vectorizer_verbose (opt->arg);
 459           break;
 460
 461         default:
 462           gcc_unreachable ();
 463         }
 464     }
 465 }