LCOV - code coverage report
Current view: top level - gcc - opts-global.cc (source / functions) Coverage Total Hit
Test: gcc.info Lines: 82.9 % 210 174
Test Date: 2024-09-28 13:20:55 Functions: 92.9 % 14 13
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: - 0 0

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

Generated by: LCOV version 2.1-beta

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto,rust,m2 --enable-host-shared. GCC test suite is run with the built compiler.