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