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