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