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