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

Generated by: LCOV version 1.0

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 --enable-host-shared. GCC test suite is run with the built compiler.