sdcc/support/cpp/gcc/opts-global.cc

   1 /* Command line option handling.  Code involving global state that
   2    should not be shared with the driver.
   3    Copyright (C) 2002-2022 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
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "backend.h"
  26 #include "rtl.h"
  27 #include "tree.h"
  28 #include "tree-pass.h"
  29 #include "diagnostic.h"
  30 #include "opts.h"
  31 #include "flags.h"
  32 #include "langhooks.h"
  33 #include "dbgcnt.h"
  34 #include "debug.h"
  35 #include "output.h"
  36 #include "plugin.h"
  37 #include "toplev.h"
  38 #include "context.h"
  39 #include "stringpool.h"
  40 #include "attribs.h"
  41 #include "asan.h"
  42 #include "file-prefix-map.h" /* add_*_prefix_map()  */
  43
  44 #define untested() { fprintf (stderr, "@@#\n@@@:%s:%d:%s\n", __FILE__, __LINE__, __func__); }
  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 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 if (ok_langs[0] != '\0')
 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   else
 114     /* Happens for -Werror=warning_name.  */
 115     warning (0, "%<-Werror=%> argument %qs is not valid for %s",
 116              text, bad_lang);
 117
 118   free (ok_langs);
 119   free (bad_lang);
 120 }
 121
 122 /* Buffer the unknown option described by the string OPT.  Currently,
 123    we only complain about unknown -Wno-* options if they may have
 124    prevented a diagnostic. Otherwise, we just ignore them.  Note that
 125    if we do complain, it is only as a warning, not an error; passing
 126    the compiler an unrecognized -Wno-* option should never change
 127    whether the compilation succeeds or fails.  */
 128
 129 static void
 130 postpone_unknown_option_warning (const char *opt)
 131 {
 132   ignored_options.safe_push (opt);
 133 }
 134
 135 /* Produce a warning for each option previously buffered.  */
 136
 137 void
 138 print_ignored_options (void)
 139 {
 140   while (!ignored_options.is_empty ())
 141     {
 142       const char *opt;
 143
 144       opt = ignored_options.pop ();
 145       /* Use inform, not warning_at, to avoid promoting these to errors.  */
 146       inform (UNKNOWN_LOCATION,
 147               "unrecognized command-line option %qs may have been intended "
 148               "to silence earlier diagnostics", opt);
 149     }
 150 }
 151
 152 /* Handle an unknown option DECODED, returning true if an error should
 153    be given.  */
 154
 155 static bool
 156 unknown_option_callback (const struct cl_decoded_option *decoded)
 157 {
 158   const char *opt = decoded->arg;
 159
 160   if (opt[1] == 'W' && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-'
 161       && !(decoded->errors & CL_ERR_NEGATIVE))
 162     {
 163       /* We don't generate warnings for unknown -Wno-* options unless
 164          we issue diagnostics.  */
 165       postpone_unknown_option_warning (opt);
 166       return false;
 167     }
 168   else
 169     return true;
 170 }
 171
 172 /* Handle a front-end option; arguments and return value as for
 173    handle_option.  */
 174
 175 static bool
 176 lang_handle_option (struct gcc_options *opts,
 177                     struct gcc_options *opts_set,
 178                     const struct cl_decoded_option *decoded,
 179                     unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
 180                     location_t loc,
 181                     const struct cl_option_handlers *handlers,
 182                     diagnostic_context *dc,
 183                     void (*) (void))
 184 {
 185   gcc_assert (opts == &global_options);
 186   gcc_assert (opts_set == &global_options_set);
 187   gcc_assert (dc == global_dc);
 188   gcc_assert (decoded->canonical_option_num_elements <= 2);
 189   return lang_hooks.handle_option (decoded->opt_index, decoded->arg,
 190                                    decoded->value, kind, loc, handlers);
 191 }
 192
 193 /* Handle FILENAME from the command line.  */
 194
 195 static void
 196 add_input_filename (const char *filename)
 197 {
 198   num_in_fnames++;
 199   in_fnames = XRESIZEVEC (const char *, in_fnames, num_in_fnames);
 200   in_fnames[num_in_fnames - 1] = filename;
 201 }
 202
 203 /* Handle the vector of command line options (located at LOC), storing
 204    the results of processing DECODED_OPTIONS and DECODED_OPTIONS_COUNT
 205    in OPTS and OPTS_SET and using DC for diagnostic state.  LANG_MASK
 206    contains has a single bit set representing the current language.
 207    HANDLERS describes what functions to call for the options.  */
 208
 209 static void
 210 read_cmdline_options (struct gcc_options *opts, struct gcc_options *opts_set,
 211                       struct cl_decoded_option *decoded_options,
 212                       unsigned int decoded_options_count,
 213                       location_t loc,
 214                       unsigned int lang_mask,
 215                       const struct cl_option_handlers *handlers,
 216                       diagnostic_context *dc)
 217 {
 218   unsigned int i;
 219
 220   for (i = 1; i < decoded_options_count; i++)
 221     {
 222       if (decoded_options[i].opt_index == OPT_SPECIAL_input_file)
 223         {
 224           /* Input files should only ever appear on the main command
 225              line.  */
 226           gcc_assert (opts == &global_options);
 227           gcc_assert (opts_set == &global_options_set);
 228
 229           if (opts->x_main_input_filename == NULL)
 230             {
 231               opts->x_main_input_filename = decoded_options[i].arg;
 232               opts->x_main_input_baselength
 233                 = base_of_path (opts->x_main_input_filename,
 234                                 &opts->x_main_input_basename);
 235             }
 236           add_input_filename (decoded_options[i].arg);
 237           continue;
 238         }
 239
 240       read_cmdline_option (opts, opts_set,
 241                            decoded_options + i, loc, lang_mask, handlers,
 242                            dc);
 243     }
 244 }
 245
 246 /* Language mask determined at initialization.  */
 247 static unsigned int initial_lang_mask;
 248
 249 /* Initialize global options-related settings at start-up.  */
 250
 251 void
 252 init_options_once (void)
 253 {
 254   /* Perform language-specific options initialization.  */
 255   initial_lang_mask = lang_hooks.option_lang_mask ();
 256
 257   lang_hooks.initialize_diagnostics (global_dc);
 258   /* ??? Ideally, we should do this earlier and the FEs will override
 259      it if desired (none do it so far).  However, the way the FEs
 260      construct their pretty-printers means that all previous settings
 261      are overriden.  */
 262   diagnostic_color_init (global_dc);
 263   diagnostic_urls_init (global_dc);
 264 }
 265
 266 /* Decode command-line options to an array, like
 267    decode_cmdline_options_to_array and with the same arguments but
 268    using the default lang_mask.  */
 269
 270 void
 271 decode_cmdline_options_to_array_default_mask (unsigned int argc,
 272                                               const char **argv,
 273                                               struct cl_decoded_option **decoded_options,
 274                                               unsigned int *decoded_options_count)
 275 {
 276   decode_cmdline_options_to_array (argc, argv,
 277                                    initial_lang_mask | CL_COMMON | CL_TARGET,
 278                                    decoded_options, decoded_options_count);
 279 }
 280
 281 /* Set *HANDLERS to the default set of option handlers for use in the
 282    compilers proper (not the driver).  */
 283 void
 284 set_default_handlers (struct cl_option_handlers *handlers,
 285                       void (*target_option_override_hook) (void))
 286 {
 287   handlers->unknown_option_callback = unknown_option_callback;
 288   handlers->wrong_lang_callback = complain_wrong_lang;
 289   gcc_assert(target_option_override_hook);
 290   handlers->target_option_override_hook = target_option_override_hook;
 291   handlers->num_handlers = 3;
 292   handlers->handlers[0].handler = lang_handle_option;
 293   handlers->handlers[0].mask = initial_lang_mask;
 294   handlers->handlers[1].handler = common_handle_option;
 295   handlers->handlers[1].mask = CL_COMMON;
 296   handlers->handlers[2].handler = NULL; // sdcpp target_handle_option;
 297   handlers->handlers[2].mask = CL_TARGET;
 298 }
 299
 300 /* Parse command line options and set default flag values.  Do minimal
 301    options processing.  The decoded options are in *DECODED_OPTIONS
 302    and *DECODED_OPTIONS_COUNT; settings go in OPTS, OPTS_SET and DC;
 303    the options are located at LOC.  */
 304 void
 305 decode_options (struct gcc_options *opts, struct gcc_options *opts_set,
 306                 struct cl_decoded_option *decoded_options,
 307                 unsigned int decoded_options_count,
 308                 location_t loc, diagnostic_context *dc,
 309                 void (*target_option_override_hook) (void))
 310 {
 311   struct cl_option_handlers handlers;
 312
 313   unsigned int lang_mask;
 314
 315   lang_mask = initial_lang_mask;
 316
 317   gcc_assert(target_option_override_hook);
 318   set_default_handlers (&handlers, target_option_override_hook);
 319
 320   default_options_optimization (opts, opts_set,
 321                                 decoded_options, decoded_options_count,
 322                                 loc, lang_mask, &handlers, dc);
 323
 324   read_cmdline_options (opts, opts_set,
 325                         decoded_options, decoded_options_count,
 326                         loc, lang_mask,
 327                         &handlers, dc);
 328
 329   finish_options (opts, opts_set, loc);
 330
 331   /* Print --help=* if used.  */
 332   unsigned i;
 333   const char *arg;
 334
 335   if (!help_option_arguments.is_empty ())
 336     {
 337       /* Make sure --help=* sees the overridden values.  */
 338       target_option_override_hook ();
 339
 340       FOR_EACH_VEC_ELT (help_option_arguments, i, arg)
 341         print_help (opts, lang_mask, arg);
 342     }
 343 }
 344
 345 /* Hold command-line options associated with stack limitation.  */
 346 const char *opt_fstack_limit_symbol_arg = NULL;
 347 int opt_fstack_limit_register_no = -1;
 348
 349 /* Process common options that have been deferred until after the
 350    handlers have been called for all options.  */
 351
 352 void
 353 handle_common_deferred_options (void)
 354 {
 355         // TODO
 356         // gcc_assert(0 && "handle_common_deferred_options");
 357 #if 0 // sdcpp
 358   unsigned int i;
 359   cl_deferred_option *opt;
 360   vec<cl_deferred_option> v;
 361
 362   if (common_deferred_options)
 363     v = *((vec<cl_deferred_option> *) common_deferred_options);
 364   else
 365     v = vNULL;
 366
 367   if (flag_dump_all_passed)
 368     enable_rtl_dump_file ();
 369
 370   if (flag_opt_info)
 371     opt_info_switch_p (NULL);
 372
 373   FOR_EACH_VEC_ELT (v, i, opt)
 374     {
 375       switch (opt->opt_index)
 376         {
 377         case OPT_fcall_used_:
 378           fix_register (opt->arg, 0, 1);
 379           break;
 380
 381         case OPT_fcall_saved_:
 382           fix_register (opt->arg, 0, 0);
 383           break;
 384
 385         case OPT_fdbg_cnt_:
 386           dbg_cnt_process_opt (opt->arg);
 387           break;
 388
 389         case OPT_fdebug_prefix_map_:
 390           add_debug_prefix_map (opt->arg);
 391           break;
 392
 393         case OPT_ffile_prefix_map_:
 394           add_file_prefix_map (opt->arg);
 395           break;
 396
 397         case OPT_fprofile_prefix_map_:
 398           add_profile_prefix_map (opt->arg);
 399           break;
 400
 401         case OPT_fdump_:
 402           g->get_dumps ()->dump_switch_p (opt->arg);
 403           break;
 404
 405         case OPT_fopt_info_:
 406           if (!opt_info_switch_p (opt->arg))
 407             error ("unrecognized command-line option %<-fopt-info-%s%>",
 408                    opt->arg);
 409           break;
 410
 411         case OPT_fenable_:
 412         case OPT_fdisable_:
 413           if (opt->opt_index == OPT_fenable_)
 414             enable_pass (opt->arg);
 415           else
 416             disable_pass (opt->arg);
 417           break;
 418
 419         case OPT_ffixed_:
 420           /* Deferred.  */
 421           fix_register (opt->arg, 1, 1);
 422           break;
 423
 424         case OPT_fplugin_:
 425 #ifdef ENABLE_PLUGIN
 426           add_new_plugin (opt->arg);
 427 #else
 428           error ("plugin support is disabled; configure with "
 429                  "%<--enable-plugin%>");
 430 #endif
 431           break;
 432
 433         case OPT_fplugin_arg_:
 434 #ifdef ENABLE_PLUGIN
 435           parse_plugin_arg_opt (opt->arg);
 436 #else
 437           error ("plugin support is disabled; configure with "
 438                  "%<--enable-plugin%>");
 439 #endif
 440           break;
 441
 442         case OPT_frandom_seed:
 443           /* The real switch is -fno-random-seed.  */
 444           if (!opt->value)
 445             set_random_seed (NULL);
 446           break;
 447
 448         case OPT_frandom_seed_:
 449           set_random_seed (opt->arg);
 450           break;
 451
 452         case OPT_fstack_limit:
 453           /* The real switch is -fno-stack-limit.  */
 454           if (!opt->value)
 455             stack_limit_rtx = NULL_RTX;
 456           break;
 457
 458         case OPT_fstack_limit_register_:
 459           {
 460             int reg = decode_reg_name (opt->arg);
 461             if (reg < 0)
 462               error ("unrecognized register name %qs", opt->arg);
 463             else
 464               {
 465                 /* Deactivate previous OPT_fstack_limit_symbol_ options.  */
 466                 opt_fstack_limit_symbol_arg = NULL;
 467                 opt_fstack_limit_register_no = reg;
 468               }
 469           }
 470           break;
 471
 472         case OPT_fstack_limit_symbol_:
 473           /* Deactivate previous OPT_fstack_limit_register_ options.  */
 474           opt_fstack_limit_register_no = -1;
 475           opt_fstack_limit_symbol_arg = opt->arg;
 476           break;
 477
 478         case OPT_fasan_shadow_offset_:
 479           if (!(flag_sanitize & SANITIZE_KERNEL_ADDRESS))
 480             error ("%<-fasan-shadow-offset%> should only be used "
 481                    "with %<-fsanitize=kernel-address%>");
 482           if (!set_asan_shadow_offset (opt->arg))
 483              error ("unrecognized shadow offset %qs", opt->arg);
 484           break;
 485
 486         case OPT_fsanitize_sections_:
 487           set_sanitized_sections (opt->arg);
 488           break;
 489
 490         default:
 491           gcc_unreachable ();
 492         }
 493     }
 494 #endif
 495 }