LCOV - code coverage report
Current view: top level - gcc - opts-common.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 755 823 91.7 %
Date: 2020-05-30 12:51:24 Functions: 25 29 86.2 %
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.
       2                 :            :    Copyright (C) 2006-2020 Free Software Foundation, Inc.
       3                 :            : 
       4                 :            : This file is part of GCC.
       5                 :            : 
       6                 :            : GCC is free software; you can redistribute it and/or modify it under
       7                 :            : the terms of the GNU General Public License as published by the Free
       8                 :            : Software Foundation; either version 3, or (at your option) any later
       9                 :            : version.
      10                 :            : 
      11                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      12                 :            : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      13                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      14                 :            : for more details.
      15                 :            : 
      16                 :            : You should have received a copy of the GNU General Public License
      17                 :            : along with GCC; see the file COPYING3.  If not see
      18                 :            : <http://www.gnu.org/licenses/>.  */
      19                 :            : 
      20                 :            : #include "config.h"
      21                 :            : #include "system.h"
      22                 :            : #include "intl.h"
      23                 :            : #include "coretypes.h"
      24                 :            : #include "opts.h"
      25                 :            : #include "options.h"
      26                 :            : #include "diagnostic.h"
      27                 :            : #include "spellcheck.h"
      28                 :            : 
      29                 :            : static void prune_options (struct cl_decoded_option **, unsigned int *);
      30                 :            : 
      31                 :            : /* An option that is undocumented, that takes a joined argument, and
      32                 :            :    that doesn't fit any of the classes of uses (language/common,
      33                 :            :    driver, target) is assumed to be a prefix used to catch
      34                 :            :    e.g. negated options, and stop them from being further shortened to
      35                 :            :    a prefix that could use the negated option as an argument.  For
      36                 :            :    example, we want -gno-statement-frontiers to be taken as a negation
      37                 :            :    of -gstatement-frontiers, but without catching the gno- prefix and
      38                 :            :    signaling it's to be used for option remapping, it would end up
      39                 :            :    backtracked to g with no-statemnet-frontiers as the debug level.  */
      40                 :            : 
      41                 :            : static bool
      42                 :    3413130 : remapping_prefix_p (const struct cl_option *opt)
      43                 :            : {
      44                 :    3413130 :   return opt->flags & CL_UNDOCUMENTED
      45                 :            :     && opt->flags & CL_JOINED
      46                 :    3413130 :     && !(opt->flags & (CL_DRIVER | CL_TARGET | CL_COMMON | CL_LANG_ALL));
      47                 :            : }
      48                 :            : 
      49                 :            : /* Perform a binary search to find which option the command-line INPUT
      50                 :            :    matches.  Returns its index in the option array, and
      51                 :            :    OPT_SPECIAL_unknown on failure.
      52                 :            : 
      53                 :            :    This routine is quite subtle.  A normal binary search is not good
      54                 :            :    enough because some options can be suffixed with an argument, and
      55                 :            :    multiple sub-matches can occur, e.g. input of "-pedantic" matching
      56                 :            :    the initial substring of "-pedantic-errors".
      57                 :            : 
      58                 :            :    A more complicated example is -gstabs.  It should match "-g" with
      59                 :            :    an argument of "stabs".  Suppose, however, that the number and list
      60                 :            :    of switches are such that the binary search tests "-gen-decls"
      61                 :            :    before having tested "-g".  This doesn't match, and as "-gen-decls"
      62                 :            :    is less than "-gstabs", it will become the lower bound of the
      63                 :            :    binary search range, and "-g" will never be seen.  To resolve this
      64                 :            :    issue, 'optc-gen.awk' makes "-gen-decls" point, via the back_chain member,
      65                 :            :    to "-g" so that failed searches that end between "-gen-decls" and
      66                 :            :    the lexicographically subsequent switch know to go back and see if
      67                 :            :    "-g" causes a match (which it does in this example).
      68                 :            : 
      69                 :            :    This search is done in such a way that the longest match for the
      70                 :            :    front end in question wins.  If there is no match for the current
      71                 :            :    front end, the longest match for a different front end is returned
      72                 :            :    (or N_OPTS if none) and the caller emits an error message.  */
      73                 :            : size_t
      74                 :    9971760 : find_opt (const char *input, unsigned int lang_mask)
      75                 :            : {
      76                 :    9971760 :   size_t mn, mn_orig, mx, md, opt_len;
      77                 :    9971760 :   size_t match_wrong_lang;
      78                 :    9971760 :   int comp;
      79                 :            : 
      80                 :    9971760 :   mn = 0;
      81                 :    9971760 :   mx = cl_options_count;
      82                 :            : 
      83                 :            :   /* Find mn such this lexicographical inequality holds:
      84                 :            :      cl_options[mn] <= input < cl_options[mn + 1].  */
      85                 :  119106000 :   while (mx - mn > 1)
      86                 :            :     {
      87                 :  109135000 :       md = (mn + mx) / 2;
      88                 :  109135000 :       opt_len = cl_options[md].opt_len;
      89                 :  109135000 :       comp = strncmp (input, cl_options[md].opt_text + 1, opt_len);
      90                 :            : 
      91                 :  109135000 :       if (comp < 0)
      92                 :            :         mx = md;
      93                 :            :       else
      94                 :   73203500 :         mn = md;
      95                 :            :     }
      96                 :            : 
      97                 :   10091800 :   mn_orig = mn;
      98                 :            : 
      99                 :            :   /* This is the switch that is the best match but for a different
     100                 :            :      front end, or OPT_SPECIAL_unknown if there is no match at all.  */
     101                 :            :   match_wrong_lang = OPT_SPECIAL_unknown;
     102                 :            : 
     103                 :            :   /* Backtrace the chain of possible matches, returning the longest
     104                 :            :      one, if any, that fits best.  With current GCC switches, this
     105                 :            :      loop executes at most twice.  */
     106                 :   10091800 :   do
     107                 :            :     {
     108                 :   10091800 :       const struct cl_option *opt = &cl_options[mn];
     109                 :            : 
     110                 :            :       /* Is the input either an exact match or a prefix that takes a
     111                 :            :          joined argument?  */
     112                 :   10091800 :       if (!strncmp (input, opt->opt_text + 1, opt->opt_len)
     113                 :    8783310 :           && (input[opt->opt_len] == '\0' || (opt->flags & CL_JOINED)))
     114                 :            :         {
     115                 :            :           /* If language is OK, return it.  */
     116                 :    8783270 :           if (opt->flags & lang_mask)
     117                 :    6169010 :             return mn;
     118                 :            : 
     119                 :    2614260 :           if (remapping_prefix_p (opt))
     120                 :            :             return OPT_SPECIAL_unknown;
     121                 :            : 
     122                 :            :           /* If we haven't remembered a prior match, remember this
     123                 :            :              one.  Any prior match is necessarily better.  */
     124                 :    2612980 :           if (match_wrong_lang == OPT_SPECIAL_unknown)
     125                 :    2601200 :             match_wrong_lang = mn;
     126                 :            :         }
     127                 :            : 
     128                 :            :       /* Try the next possibility.  This is cl_options_count if there
     129                 :            :          are no more.  */
     130                 :    3921540 :       mn = opt->back_chain;
     131                 :            :     }
     132                 :    3921540 :   while (mn != cl_options_count);
     133                 :            : 
     134                 :    3801470 :   if (match_wrong_lang == OPT_SPECIAL_unknown && input[0] == '-')
     135                 :            :     {
     136                 :            :       /* Long options, starting "--", may be abbreviated if the
     137                 :            :          abbreviation is unambiguous.  This only applies to options
     138                 :            :          not taking a joined argument, and abbreviations of "--option"
     139                 :            :          are permitted even if there is a variant "--option=".  */
     140                 :          8 :       size_t mnc = mn_orig + 1;
     141                 :          8 :       size_t cmp_len = strlen (input);
     142                 :          8 :       while (mnc < cl_options_count
     143                 :          8 :              && strncmp (input, cl_options[mnc].opt_text + 1, cmp_len) == 0)
     144                 :            :         {
     145                 :            :           /* Option matching this abbreviation.  OK if it is the first
     146                 :            :              match and that does not take a joined argument, or the
     147                 :            :              second match, taking a joined argument and with only '='
     148                 :            :              added to the first match; otherwise considered
     149                 :            :              ambiguous.  */
     150                 :          0 :           if (mnc == mn_orig + 1
     151                 :          0 :               && !(cl_options[mnc].flags & CL_JOINED))
     152                 :            :             match_wrong_lang = mnc;
     153                 :          0 :           else if (mnc == mn_orig + 2
     154                 :          0 :                    && match_wrong_lang == mn_orig + 1
     155                 :          0 :                    && (cl_options[mnc].flags & CL_JOINED)
     156                 :          0 :                    && (cl_options[mnc].opt_len
     157                 :          0 :                        == cl_options[mn_orig + 1].opt_len + 1)
     158                 :          0 :                    && strncmp (cl_options[mnc].opt_text + 1,
     159                 :          0 :                                cl_options[mn_orig + 1].opt_text + 1,
     160                 :            :                                cl_options[mn_orig + 1].opt_len) == 0)
     161                 :            :             ; /* OK, as long as there are no more matches.  */
     162                 :            :           else
     163                 :            :             return OPT_SPECIAL_unknown;
     164                 :          0 :           mnc++;
     165                 :            :         }
     166                 :            :     }
     167                 :            : 
     168                 :            :   /* Return the best wrong match, or OPT_SPECIAL_unknown if none.  */
     169                 :            :   return match_wrong_lang;
     170                 :            : }
     171                 :            : 
     172                 :            : /* If ARG is a non-negative decimal or hexadecimal integer representable
     173                 :            :    in HOST_WIDE_INT return its value, otherwise return -1.  If ERR is not
     174                 :            :    null set *ERR to zero on success or to EINVAL or to the value of errno
     175                 :            :    otherwise.  */
     176                 :            : 
     177                 :            : HOST_WIDE_INT
     178                 :     331178 : integral_argument (const char *arg, int *err, bool byte_size_suffix)
     179                 :            : {
     180                 :     331178 :   if (!err)
     181                 :     144000 :     err = &errno;
     182                 :            : 
     183                 :     331178 :   if (!ISDIGIT (*arg))
     184                 :            :     {
     185                 :          0 :       *err = EINVAL;
     186                 :          0 :       return -1;
     187                 :            :     }
     188                 :            : 
     189                 :     331178 :   *err = 0;
     190                 :     331178 :   errno = 0;
     191                 :            : 
     192                 :     331178 :   char *end = NULL;
     193                 :     331178 :   unsigned HOST_WIDE_INT unit = 1;
     194                 :     331178 :   unsigned HOST_WIDE_INT value = strtoull (arg, &end, 10);
     195                 :            : 
     196                 :            :   /* If the value is too large to be represented use the maximum
     197                 :            :      representable value that strtoull sets VALUE to (setting
     198                 :            :      errno to ERANGE).  */
     199                 :            : 
     200                 :     331178 :   if (end && *end)
     201                 :            :     {
     202                 :         48 :       if (!byte_size_suffix)
     203                 :            :         {
     204                 :          2 :           errno = 0;
     205                 :          2 :           value = strtoull (arg, &end, 0);
     206                 :          2 :           if (*end)
     207                 :            :             {
     208                 :          2 :               if (errno)
     209                 :          0 :                 *err = errno;
     210                 :            :               else
     211                 :          2 :                 *err = EINVAL;
     212                 :          2 :               return -1;
     213                 :            :             }
     214                 :            : 
     215                 :          0 :           return value;
     216                 :            :         }
     217                 :            : 
     218                 :            :       /* Numeric option arguments are at most INT_MAX.  Make it
     219                 :            :          possible to specify a larger value by accepting common
     220                 :            :          suffixes.  */
     221                 :         46 :       if (!strcmp (end, "kB"))
     222                 :            :         unit = 1000;
     223                 :         44 :       else if (!strcasecmp (end, "KiB") || !strcmp (end, "KB"))
     224                 :            :         unit = 1024;
     225                 :         38 :       else if (!strcmp (end, "MB"))
     226                 :            :         unit = HOST_WIDE_INT_UC (1000) * 1000;
     227                 :         36 :       else if (!strcasecmp (end, "MiB"))
     228                 :            :         unit = HOST_WIDE_INT_UC (1024) * 1024;
     229                 :         32 :       else if (!strcasecmp (end, "GB"))
     230                 :            :         unit = HOST_WIDE_INT_UC (1000) * 1000 * 1000;
     231                 :         28 :       else if (!strcasecmp (end, "GiB"))
     232                 :            :         unit = HOST_WIDE_INT_UC (1024) * 1024 * 1024;
     233                 :         26 :       else if (!strcasecmp (end, "TB"))
     234                 :            :         unit = HOST_WIDE_INT_UC (1000) * 1000 * 1000 * 1000;
     235                 :         24 :       else if (!strcasecmp (end, "TiB"))
     236                 :            :         unit = HOST_WIDE_INT_UC (1024) * 1024 * 1024 * 1024;
     237                 :         22 :       else if (!strcasecmp (end, "PB"))
     238                 :            :         unit = HOST_WIDE_INT_UC (1000) * 1000 * 1000 * 1000 * 1000;
     239                 :         20 :       else if (!strcasecmp (end, "PiB"))
     240                 :            :         unit = HOST_WIDE_INT_UC (1024) * 1024 * 1024 * 1024 * 1024;
     241                 :         18 :       else if (!strcasecmp (end, "EB"))
     242                 :            :         unit = HOST_WIDE_INT_UC (1000) * 1000 * 1000 * 1000 * 1000
     243                 :            :           * 1000;
     244                 :         16 :       else if (!strcasecmp (end, "EiB"))
     245                 :            :         unit = HOST_WIDE_INT_UC (1024) * 1024 * 1024 * 1024 * 1024
     246                 :            :           * 1024;
     247                 :            :       else
     248                 :            :         {
     249                 :            :           /* This could mean an unknown suffix or a bad prefix, like
     250                 :            :              "+-1".  */
     251                 :          3 :           *err = EINVAL;
     252                 :          3 :           return -1;
     253                 :            :         }
     254                 :            :     }
     255                 :            : 
     256                 :            :   if (unit)
     257                 :            :     {
     258                 :     331173 :       unsigned HOST_WIDE_INT prod = value * unit;
     259                 :     331173 :       value = prod < value ? HOST_WIDE_INT_M1U : prod;
     260                 :            :     }
     261                 :            : 
     262                 :     331173 :   return value;
     263                 :            : }
     264                 :            : 
     265                 :            : /* Return whether OPTION is OK for the language given by
     266                 :            :    LANG_MASK.  */
     267                 :            : static bool
     268                 :   63592600 : option_ok_for_language (const struct cl_option *option,
     269                 :            :                         unsigned int lang_mask)
     270                 :            : {
     271                 :          0 :   if (!(option->flags & lang_mask))
     272                 :            :     return false;
     273                 :   40672600 :   else if ((option->flags & CL_TARGET)
     274                 :   33963500 :            && (option->flags & (CL_LANG_ALL | CL_DRIVER))
     275                 :          0 :            && !(option->flags & (lang_mask & ~CL_COMMON & ~CL_TARGET)))
     276                 :            :     /* Complain for target flag language mismatches if any languages
     277                 :            :        are specified.  */
     278                 :          0 :     return false;
     279                 :            :   return true;
     280                 :            : }
     281                 :            : 
     282                 :            : /* Return whether ENUM_ARG is OK for the language given by
     283                 :            :    LANG_MASK.  */
     284                 :            : 
     285                 :            : static bool
     286                 :    1826520 : enum_arg_ok_for_language (const struct cl_enum_arg *enum_arg,
     287                 :            :                           unsigned int lang_mask)
     288                 :            : {
     289                 :     867735 :   return (lang_mask & CL_DRIVER) || !(enum_arg->flags & CL_ENUM_DRIVER_ONLY);
     290                 :            : }
     291                 :            : 
     292                 :            : /* Look up ARG in ENUM_ARGS for language LANG_MASK, returning true and
     293                 :            :    storing the value in *VALUE if found, and returning false without
     294                 :            :    modifying *VALUE if not found.  */
     295                 :            : 
     296                 :            : static bool
     297                 :     913345 : enum_arg_to_value (const struct cl_enum_arg *enum_args,
     298                 :            :                    const char *arg, HOST_WIDE_INT *value,
     299                 :            :                    unsigned int lang_mask)
     300                 :            : {
     301                 :     913345 :   unsigned int i;
     302                 :            : 
     303                 :    2715140 :   for (i = 0; enum_args[i].arg != NULL; i++)
     304                 :    2715140 :     if (strcmp (arg, enum_args[i].arg) == 0
     305                 :    2715140 :         && enum_arg_ok_for_language (&enum_args[i], lang_mask))
     306                 :            :       {
     307                 :     913344 :         *value = enum_args[i].value;
     308                 :     913344 :         return true;
     309                 :            :       }
     310                 :            : 
     311                 :            :   return false;
     312                 :            : }
     313                 :            : 
     314                 :            : /* Look up ARG in the enum used by option OPT_INDEX for language
     315                 :            :    LANG_MASK, returning true and storing the value in *VALUE if found,
     316                 :            :    and returning false without modifying *VALUE if not found.  */
     317                 :            : 
     318                 :            : bool
     319                 :        188 : opt_enum_arg_to_value (size_t opt_index, const char *arg,
     320                 :            :                        int *value, unsigned int lang_mask)
     321                 :            : {
     322                 :        188 :   const struct cl_option *option = &cl_options[opt_index];
     323                 :            : 
     324                 :        188 :   gcc_assert (option->var_type == CLVC_ENUM);
     325                 :            : 
     326                 :        188 :   HOST_WIDE_INT wideval;
     327                 :        188 :   if (enum_arg_to_value (cl_enums[option->var_enum].values, arg,
     328                 :            :                          &wideval, lang_mask))
     329                 :            :     {
     330                 :        188 :       *value = wideval;
     331                 :        188 :       return true;
     332                 :            :     }
     333                 :            : 
     334                 :            :   return false;
     335                 :            : }
     336                 :            : 
     337                 :            : /* Look of VALUE in ENUM_ARGS for language LANG_MASK and store the
     338                 :            :    corresponding string in *ARGP, returning true if the found string
     339                 :            :    was marked as canonical, false otherwise.  If VALUE is not found
     340                 :            :    (which may be the case for uninitialized values if the relevant
     341                 :            :    option has not been passed), set *ARGP to NULL and return
     342                 :            :    false.  */
     343                 :            : 
     344                 :            : bool
     345                 :     913179 : enum_value_to_arg (const struct cl_enum_arg *enum_args,
     346                 :            :                    const char **argp, int value, unsigned int lang_mask)
     347                 :            : {
     348                 :     913179 :   unsigned int i;
     349                 :            : 
     350                 :    3787980 :   for (i = 0; enum_args[i].arg != NULL; i++)
     351                 :    2874800 :     if (enum_args[i].value == value
     352                 :     913895 :         && (enum_args[i].flags & CL_ENUM_CANONICAL)
     353                 :    3788690 :         && enum_arg_ok_for_language (&enum_args[i], lang_mask))
     354                 :            :       {
     355                 :          0 :         *argp = enum_args[i].arg;
     356                 :          0 :         return true;
     357                 :            :       }
     358                 :            : 
     359                 :    2713740 :   for (i = 0; enum_args[i].arg != NULL; i++)
     360                 :    2713740 :     if (enum_args[i].value == value
     361                 :    2713740 :         && enum_arg_ok_for_language (&enum_args[i], lang_mask))
     362                 :            :       {
     363                 :     913173 :         *argp = enum_args[i].arg;
     364                 :     913173 :         return false;
     365                 :            :       }
     366                 :            : 
     367                 :          6 :   *argp = NULL;
     368                 :          6 :   return false;
     369                 :            : }
     370                 :            : 
     371                 :            : /* Fill in the canonical option part of *DECODED with an option
     372                 :            :    described by OPT_INDEX, ARG and VALUE.  */
     373                 :            : 
     374                 :            : static void
     375                 :   63587900 : generate_canonical_option (size_t opt_index, const char *arg,
     376                 :            :                            HOST_WIDE_INT value,
     377                 :            :                            struct cl_decoded_option *decoded)
     378                 :            : {
     379                 :   63587900 :   const struct cl_option *option = &cl_options[opt_index];
     380                 :   63587900 :   const char *opt_text = option->opt_text;
     381                 :            : 
     382                 :   63587900 :   if (value == 0
     383                 :   12364400 :       && !option->cl_reject_negative
     384                 :   11335700 :       && (opt_text[1] == 'W' || opt_text[1] == 'f'
     385                 :      10160 :           || opt_text[1] == 'g' || opt_text[1] == 'm'))
     386                 :            :     {
     387                 :   11332900 :       char *t = XOBNEWVEC (&opts_obstack, char, option->opt_len + 5);
     388                 :   11332900 :       t[0] = '-';
     389                 :   11332900 :       t[1] = opt_text[1];
     390                 :   11332900 :       t[2] = 'n';
     391                 :   11332900 :       t[3] = 'o';
     392                 :   11332900 :       t[4] = '-';
     393                 :   11332900 :       memcpy (t + 5, opt_text + 2, option->opt_len);
     394                 :   11332900 :       opt_text = t;
     395                 :            :     }
     396                 :            : 
     397                 :   63587900 :   decoded->canonical_option[2] = NULL;
     398                 :   63587900 :   decoded->canonical_option[3] = NULL;
     399                 :            : 
     400                 :   63587900 :   if (arg)
     401                 :            :     {
     402                 :    5959660 :       if ((option->flags & CL_SEPARATE)
     403                 :    3441200 :           && !option->cl_separate_alias)
     404                 :            :         {
     405                 :    3441200 :           decoded->canonical_option[0] = opt_text;
     406                 :    3441200 :           decoded->canonical_option[1] = arg;
     407                 :    3441200 :           decoded->canonical_option_num_elements = 2;
     408                 :            :         }
     409                 :            :       else
     410                 :            :         {
     411                 :    2518460 :           gcc_assert (option->flags & CL_JOINED);
     412                 :    2518460 :           decoded->canonical_option[0] = opts_concat (opt_text, arg, NULL);
     413                 :    2518460 :           decoded->canonical_option[1] = NULL;
     414                 :    2518460 :           decoded->canonical_option_num_elements = 1;
     415                 :            :         }
     416                 :            :     }
     417                 :            :   else
     418                 :            :     {
     419                 :   57628300 :       decoded->canonical_option[0] = opt_text;
     420                 :   57628300 :       decoded->canonical_option[1] = NULL;
     421                 :   57628300 :       decoded->canonical_option_num_elements = 1;
     422                 :            :     }
     423                 :   63587900 : }
     424                 :            : 
     425                 :            : /* Structure describing mappings from options on the command line to
     426                 :            :    options to look up with find_opt.  */
     427                 :            : struct option_map
     428                 :            : {
     429                 :            :   /* Prefix of the option on the command line.  */
     430                 :            :   const char *opt0;
     431                 :            :   /* If two argv elements are considered to be merged into one option,
     432                 :            :      prefix for the second element, otherwise NULL.  */
     433                 :            :   const char *opt1;
     434                 :            :   /* The new prefix to map to.  */
     435                 :            :   const char *new_prefix;
     436                 :            :   /* Whether at least one character is needed following opt1 or opt0
     437                 :            :      for this mapping to be used.  (--optimize= is valid for -O, but
     438                 :            :      --warn- is not valid for -W.)  */
     439                 :            :   bool another_char_needed;
     440                 :            :   /* Whether the original option is a negated form of the option
     441                 :            :      resulting from this map.  */
     442                 :            :   bool negated;
     443                 :            : };
     444                 :            : static const struct option_map option_map[] =
     445                 :            :   {
     446                 :            :     { "-Wno-", NULL, "-W", false, true },
     447                 :            :     { "-fno-", NULL, "-f", false, true },
     448                 :            :     { "-gno-", NULL, "-g", false, true },
     449                 :            :     { "-mno-", NULL, "-m", false, true },
     450                 :            :     { "--debug=", NULL, "-g", false, false },
     451                 :            :     { "--machine-", NULL, "-m", true, false },
     452                 :            :     { "--machine-no-", NULL, "-m", false, true },
     453                 :            :     { "--machine=", NULL, "-m", false, false },
     454                 :            :     { "--machine=no-", NULL, "-m", false, true },
     455                 :            :     { "--machine", "", "-m", false, false },
     456                 :            :     { "--machine", "no-", "-m", false, true },
     457                 :            :     { "--optimize=", NULL, "-O", false, false },
     458                 :            :     { "--std=", NULL, "-std=", false, false },
     459                 :            :     { "--std", "", "-std=", false, false },
     460                 :            :     { "--warn-", NULL, "-W", true, false },
     461                 :            :     { "--warn-no-", NULL, "-W", false, true },
     462                 :            :     { "--", NULL, "-f", true, false },
     463                 :            :     { "--no-", NULL, "-f", false, true }
     464                 :            :   };
     465                 :            : 
     466                 :            : /* Helper function for gcc.c's driver::suggest_option, for populating the
     467                 :            :    vec of suggestions for misspelled options.
     468                 :            : 
     469                 :            :    option_map above provides various prefixes for spelling command-line
     470                 :            :    options, which decode_cmdline_option uses to map spellings of options
     471                 :            :    to specific options.  We want to do the reverse: to find all the ways
     472                 :            :    that a user could validly spell an option.
     473                 :            : 
     474                 :            :    Given valid OPT_TEXT (with a leading dash) for OPTION, add it and all
     475                 :            :    of its valid variant spellings to CANDIDATES, each without a leading
     476                 :            :    dash.
     477                 :            : 
     478                 :            :    For example, given "-Wabi-tag", the following are added to CANDIDATES:
     479                 :            :      "Wabi-tag"
     480                 :            :      "Wno-abi-tag"
     481                 :            :      "-warn-abi-tag"
     482                 :            :      "-warn-no-abi-tag".
     483                 :            : 
     484                 :            :    The added strings must be freed using free.  */
     485                 :            : 
     486                 :            : void
     487                 :     798876 : add_misspelling_candidates (auto_vec<char *> *candidates,
     488                 :            :                             const struct cl_option *option,
     489                 :            :                             const char *opt_text)
     490                 :            : {
     491                 :     798876 :   gcc_assert (candidates);
     492                 :     798876 :   gcc_assert (option);
     493                 :     798876 :   gcc_assert (opt_text);
     494                 :     798876 :   if (remapping_prefix_p (option))
     495                 :            :     return;
     496                 :     798525 :   candidates->safe_push (xstrdup (opt_text + 1));
     497                 :   15172000 :   for (unsigned i = 0; i < ARRAY_SIZE (option_map); i++)
     498                 :            :     {
     499                 :   14373400 :       const char *opt0 = option_map[i].opt0;
     500                 :   14373400 :       const char *new_prefix = option_map[i].new_prefix;
     501                 :   14373400 :       size_t new_prefix_len = strlen (new_prefix);
     502                 :            : 
     503                 :   14373400 :       if (option->cl_reject_negative && option_map[i].negated)
     504                 :    1851170 :         continue;
     505                 :            : 
     506                 :   12522300 :       if (strncmp (opt_text, new_prefix, new_prefix_len) == 0)
     507                 :            :         {
     508                 :    1760970 :           char *alternative = concat (opt0 + 1, opt_text + new_prefix_len,
     509                 :    1760970 :                                       NULL);
     510                 :    1760970 :           candidates->safe_push (alternative);
     511                 :            :         }
     512                 :            :     }
     513                 :            : 
     514                 :            :   /* For all params (e.g. --param=key=value),
     515                 :            :      include also '--param key=value'.  */
     516                 :     798525 :   const char *prefix = "--param=";
     517                 :     798525 :   if (strstr (opt_text, prefix) == opt_text)
     518                 :            :     {
     519                 :      84240 :       char *param = xstrdup (opt_text + 1);
     520                 :      84240 :       gcc_assert (param[6] == '=');
     521                 :      84240 :       param[6] = ' ';
     522                 :      84240 :       candidates->safe_push (param);
     523                 :            :     }
     524                 :            : }
     525                 :            : 
     526                 :            : /* Decode the switch beginning at ARGV for the language indicated by
     527                 :            :    LANG_MASK (including CL_COMMON and CL_TARGET if applicable), into
     528                 :            :    the structure *DECODED.  Returns the number of switches
     529                 :            :    consumed.  */
     530                 :            : 
     531                 :            : static unsigned int
     532                 :    8615140 : decode_cmdline_option (const char **argv, unsigned int lang_mask,
     533                 :            :                        struct cl_decoded_option *decoded)
     534                 :            : {
     535                 :    8615140 :   size_t opt_index;
     536                 :    8615140 :   const char *arg = 0;
     537                 :    8615140 :   HOST_WIDE_INT value = 1;
     538                 :    8615140 :   unsigned int result = 1, i, extra_args, separate_args = 0;
     539                 :    8615140 :   int adjust_len = 0;
     540                 :    8615140 :   size_t total_len;
     541                 :    8615140 :   char *p;
     542                 :    8615140 :   const struct cl_option *option;
     543                 :    8615140 :   int errors = 0;
     544                 :    8615140 :   const char *warn_message = NULL;
     545                 :    8615140 :   bool separate_arg_flag;
     546                 :    8615140 :   bool joined_arg_flag;
     547                 :    8615140 :   bool have_separate_arg = false;
     548                 :            : 
     549                 :    8615140 :   extra_args = 0;
     550                 :            : 
     551                 :    8615140 :   const char *opt_value = argv[0] + 1;
     552                 :    8615140 :   opt_index = find_opt (opt_value, lang_mask);
     553                 :    8615140 :   i = 0;
     554                 :   10936000 :   while (opt_index == OPT_SPECIAL_unknown
     555                 :   10936000 :          && i < ARRAY_SIZE (option_map))
     556                 :            :     {
     557                 :    2320840 :       const char *opt0 = option_map[i].opt0;
     558                 :    2320840 :       const char *opt1 = option_map[i].opt1;
     559                 :    2320840 :       const char *new_prefix = option_map[i].new_prefix;
     560                 :    2320840 :       bool another_char_needed = option_map[i].another_char_needed;
     561                 :    2320840 :       size_t opt0_len = strlen (opt0);
     562                 :    2320840 :       size_t opt1_len = (opt1 == NULL ? 0 : strlen (opt1));
     563                 :    2320840 :       size_t optn_len = (opt1 == NULL ? opt0_len : opt1_len);
     564                 :    2320840 :       size_t new_prefix_len = strlen (new_prefix);
     565                 :            : 
     566                 :    2320840 :       extra_args = (opt1 == NULL ? 0 : 1);
     567                 :    2320840 :       value = !option_map[i].negated;
     568                 :            : 
     569                 :    2320840 :       if (strncmp (argv[0], opt0, opt0_len) == 0
     570                 :    1201120 :           && (opt1 == NULL
     571                 :          0 :               || (argv[1] != NULL && strncmp (argv[1], opt1, opt1_len) == 0))
     572                 :    1201120 :           && (!another_char_needed
     573                 :          4 :               || argv[extra_args][optn_len] != 0))
     574                 :            :         {
     575                 :    1201120 :           size_t arglen = strlen (argv[extra_args]);
     576                 :    1201120 :           char *dup;
     577                 :            : 
     578                 :    1201120 :           adjust_len = (int) optn_len - (int) new_prefix_len;
     579                 :    1201120 :           dup = XNEWVEC (char, arglen + 1 - adjust_len);
     580                 :    1201120 :           memcpy (dup, new_prefix, new_prefix_len);
     581                 :    1201120 :           memcpy (dup + new_prefix_len, argv[extra_args] + optn_len,
     582                 :    1201120 :                   arglen - optn_len + 1);
     583                 :    1201120 :           opt_index = find_opt (dup + 1, lang_mask);
     584                 :    1201120 :           free (dup);
     585                 :            :         }
     586                 :    2320840 :       i++;
     587                 :            :     }
     588                 :            : 
     589                 :    8615140 :   if (opt_index == OPT_SPECIAL_unknown)
     590                 :            :     {
     591                 :        343 :       arg = argv[0];
     592                 :        343 :       extra_args = 0;
     593                 :        343 :       value = 1;
     594                 :        343 :       goto done;
     595                 :            :     }
     596                 :            : 
     597                 :    8614800 :   option = &cl_options[opt_index];
     598                 :            : 
     599                 :            :   /* Reject negative form of switches that don't take negatives as
     600                 :            :      unrecognized.  */
     601                 :    8614800 :   if (!value && option->cl_reject_negative)
     602                 :            :     {
     603                 :          7 :       opt_index = OPT_SPECIAL_unknown;
     604                 :          7 :       errors |= CL_ERR_NEGATIVE;
     605                 :          7 :       arg = argv[0];
     606                 :          7 :       goto done;
     607                 :            :     }
     608                 :            : 
     609                 :            :   /* Clear the initial value for size options (it will be overwritten
     610                 :            :      later based on the Init(value) specification in the opt file.  */
     611                 :    8614790 :   if (option->var_type == CLVC_SIZE)
     612                 :        179 :     value = 0;
     613                 :            : 
     614                 :    8614790 :   result = extra_args + 1;
     615                 :    8614790 :   warn_message = option->warn_message;
     616                 :            : 
     617                 :            :   /* Check to see if the option is disabled for this configuration.  */
     618                 :    8614790 :   if (option->cl_disabled)
     619                 :            :     errors |= CL_ERR_DISABLED;
     620                 :            : 
     621                 :            :   /* Determine whether there may be a separate argument based on
     622                 :            :      whether this option is being processed for the driver, and, if
     623                 :            :      so, how many such arguments.  */
     624                 :   20583600 :   separate_arg_flag = ((option->flags & CL_SEPARATE)
     625                 :    8614790 :                        && !(option->cl_no_driver_arg
     626                 :    3358890 :                             && (lang_mask & CL_DRIVER)));
     627                 :    8614790 :   separate_args = (separate_arg_flag
     628                 :    3354030 :                    ? option->cl_separate_nargs + 1
     629                 :            :                    : 0);
     630                 :    8614790 :   joined_arg_flag = (option->flags & CL_JOINED) != 0;
     631                 :            : 
     632                 :            :   /* Sort out any argument the switch takes.  */
     633                 :    8614790 :   if (joined_arg_flag)
     634                 :            :     {
     635                 :            :       /* Have arg point to the original switch.  This is because
     636                 :            :          some code, such as disable_builtin_function, expects its
     637                 :            :          argument to be persistent until the program exits.  */
     638                 :    5325410 :       arg = argv[extra_args] + cl_options[opt_index].opt_len + 1 + adjust_len;
     639                 :            : 
     640                 :    5325410 :       if (*arg == '\0' && !option->cl_missing_ok)
     641                 :            :         {
     642                 :    1587220 :           if (separate_arg_flag)
     643                 :            :             {
     644                 :    1587220 :               arg = argv[extra_args + 1];
     645                 :    1587220 :               result = extra_args + 2;
     646                 :    1587220 :               if (arg == NULL)
     647                 :          0 :                 result = extra_args + 1;
     648                 :            :               else
     649                 :            :                 have_separate_arg = true;
     650                 :            :             }
     651                 :            :           else
     652                 :            :             /* Missing argument.  */
     653                 :            :             arg = NULL;
     654                 :            :         }
     655                 :            :     }
     656                 :    3289380 :   else if (separate_arg_flag)
     657                 :            :     {
     658                 :     527455 :       arg = argv[extra_args + 1];
     659                 :    1054910 :       for (i = 0; i < separate_args; i++)
     660                 :     527455 :         if (argv[extra_args + 1 + i] == NULL)
     661                 :            :           {
     662                 :          0 :             errors |= CL_ERR_MISSING_ARG;
     663                 :          0 :             break;
     664                 :            :           }
     665                 :     527455 :       result = extra_args + 1 + i;
     666                 :     527455 :       if (arg != NULL)
     667                 :     527455 :         have_separate_arg = true;
     668                 :            :     }
     669                 :            : 
     670                 :    8614790 :   if (arg == NULL && (separate_arg_flag || joined_arg_flag))
     671                 :          1 :     errors |= CL_ERR_MISSING_ARG;
     672                 :            : 
     673                 :            :   /* Is this option an alias (or an ignored option, marked as an alias
     674                 :            :      of OPT_SPECIAL_ignore)?  */
     675                 :    8614790 :   if (option->alias_target != N_OPTS
     676                 :      40979 :       && (!option->cl_separate_alias || have_separate_arg))
     677                 :            :     {
     678                 :      40979 :       size_t new_opt_index = option->alias_target;
     679                 :            : 
     680                 :      40979 :       if (new_opt_index == OPT_SPECIAL_ignore
     681                 :      40979 :           || new_opt_index == OPT_SPECIAL_warn_removed)
     682                 :            :         {
     683                 :         13 :           gcc_assert (option->alias_arg == NULL);
     684                 :         13 :           gcc_assert (option->neg_alias_arg == NULL);
     685                 :            :           opt_index = new_opt_index;
     686                 :            :           arg = NULL;
     687                 :            :         }
     688                 :            :       else
     689                 :            :         {
     690                 :      40966 :           const struct cl_option *new_option = &cl_options[new_opt_index];
     691                 :            : 
     692                 :            :           /* The new option must not be an alias itself.  */
     693                 :      40966 :           gcc_assert (new_option->alias_target == N_OPTS
     694                 :            :                       || new_option->cl_separate_alias);
     695                 :            : 
     696                 :      40966 :           if (option->neg_alias_arg)
     697                 :            :             {
     698                 :       3409 :               gcc_assert (option->alias_arg != NULL);
     699                 :       3409 :               gcc_assert (arg == NULL);
     700                 :       3409 :               gcc_assert (!option->cl_negative_alias);
     701                 :       3409 :               if (value)
     702                 :            :                 arg = option->alias_arg;
     703                 :            :               else
     704                 :       2738 :                 arg = option->neg_alias_arg;
     705                 :       3409 :               value = 1;
     706                 :            :             }
     707                 :      37557 :           else if (option->alias_arg)
     708                 :            :             {
     709                 :      16159 :               gcc_assert (value == 1);
     710                 :      16159 :               gcc_assert (arg == NULL);
     711                 :      16159 :               gcc_assert (!option->cl_negative_alias);
     712                 :            :               arg = option->alias_arg;
     713                 :            :             }
     714                 :            : 
     715                 :      40966 :           if (option->cl_negative_alias)
     716                 :          0 :             value = !value;
     717                 :            : 
     718                 :      40966 :           opt_index = new_opt_index;
     719                 :      40966 :           option = new_option;
     720                 :            : 
     721                 :      40966 :           if (value == 0)
     722                 :         34 :             gcc_assert (!option->cl_reject_negative);
     723                 :            : 
     724                 :            :           /* Recompute what arguments are allowed.  */
     725                 :      81932 :           separate_arg_flag = ((option->flags & CL_SEPARATE)
     726                 :      40966 :                                && !(option->cl_no_driver_arg
     727                 :          0 :                                     && (lang_mask & CL_DRIVER)));
     728                 :      40966 :           joined_arg_flag = (option->flags & CL_JOINED) != 0;
     729                 :            : 
     730                 :      40966 :           if (separate_args > 1 || option->cl_separate_nargs)
     731                 :          0 :             gcc_assert (separate_args
     732                 :            :                         == (unsigned int) option->cl_separate_nargs + 1);
     733                 :            : 
     734                 :      40966 :           if (!(errors & CL_ERR_MISSING_ARG))
     735                 :            :             {
     736                 :      40966 :               if (separate_arg_flag || joined_arg_flag)
     737                 :            :                 {
     738                 :      19595 :                   if (option->cl_missing_ok && arg == NULL)
     739                 :          0 :                     arg = "";
     740                 :      19595 :                   gcc_assert (arg != NULL);
     741                 :            :                 }
     742                 :            :               else
     743                 :      21371 :                 gcc_assert (arg == NULL);
     744                 :            :             }
     745                 :            : 
     746                 :            :           /* Recheck for warnings and disabled options.  */
     747                 :      40966 :           if (option->warn_message)
     748                 :            :             {
     749                 :          0 :               gcc_assert (warn_message == NULL);
     750                 :            :               warn_message = option->warn_message;
     751                 :            :             }
     752                 :      40966 :           if (option->cl_disabled)
     753                 :          0 :             errors |= CL_ERR_DISABLED;
     754                 :            :         }
     755                 :            :     }
     756                 :            : 
     757                 :            :   /* Check if this is a switch for a different front end.  */
     758                 :    8614790 :   if (!option_ok_for_language (option, lang_mask))
     759                 :    2601160 :     errors |= CL_ERR_WRONG_LANG;
     760                 :    6013630 :   else if (strcmp (option->opt_text, "-Werror=") == 0
     761                 :       4732 :            && strchr (opt_value, ',') == NULL)
     762                 :            :     {
     763                 :            :       /* Verify that -Werror argument is a valid warning
     764                 :            :          for a language.  */
     765                 :       4730 :       char *werror_arg = xstrdup (opt_value + 6);
     766                 :       4730 :       werror_arg[0] = 'W';
     767                 :            : 
     768                 :       4730 :       size_t warning_index = find_opt (werror_arg, lang_mask);
     769                 :       4730 :       if (warning_index != OPT_SPECIAL_unknown)
     770                 :            :         {
     771                 :       4648 :           const struct cl_option *warning_option
     772                 :            :             = &cl_options[warning_index];
     773                 :       4648 :           if (!option_ok_for_language (warning_option, lang_mask))
     774                 :          1 :             errors |= CL_ERR_WRONG_LANG;
     775                 :            :         }
     776                 :            :     }
     777                 :            : 
     778                 :            :   /* Convert the argument to lowercase if appropriate.  */
     779                 :    8614790 :   if (arg && option->cl_tolower)
     780                 :            :     {
     781                 :         74 :       size_t j;
     782                 :         74 :       size_t len = strlen (arg);
     783                 :         74 :       char *arg_lower = XOBNEWVEC (&opts_obstack, char, len + 1);
     784                 :            : 
     785                 :        320 :       for (j = 0; j < len; j++)
     786                 :        246 :         arg_lower[j] = TOLOWER ((unsigned char) arg[j]);
     787                 :         74 :       arg_lower[len] = 0;
     788                 :         74 :       arg = arg_lower;
     789                 :            :     }
     790                 :            : 
     791                 :            :   /* If the switch takes an integer argument, convert it.  */
     792                 :    8614790 :   if (arg && (option->cl_uinteger || option->cl_host_wide_int))
     793                 :            :     {
     794                 :     187148 :       int error = 0;
     795                 :     187148 :       value = *arg ? integral_argument (arg, &error, option->cl_byte_size) : 0;
     796                 :     187148 :       if (error)
     797                 :          5 :         errors |= CL_ERR_UINT_ARG;
     798                 :            : 
     799                 :            :       /* Reject value out of a range.  */
     800                 :     187148 :       if (option->range_max != -1
     801                 :       3702 :           && (value < option->range_min || value > option->range_max))
     802                 :          6 :         errors |= CL_ERR_INT_RANGE_ARG;
     803                 :            :     }
     804                 :            : 
     805                 :            :   /* If the switch takes an enumerated argument, convert it.  */
     806                 :    8614790 :   if (arg && (option->var_type == CLVC_ENUM))
     807                 :            :     {
     808                 :     913151 :       const struct cl_enum *e = &cl_enums[option->var_enum];
     809                 :            : 
     810                 :     913151 :       gcc_assert (value == 1);
     811                 :     913151 :       if (enum_arg_to_value (e->values, arg, &value, lang_mask))
     812                 :            :         {
     813                 :     913150 :           const char *carg = NULL;
     814                 :            : 
     815                 :     913150 :           if (enum_value_to_arg (e->values, &carg, value, lang_mask))
     816                 :          0 :             arg = carg;
     817                 :     913150 :           gcc_assert (carg != NULL);
     818                 :            :         }
     819                 :            :       else
     820                 :          1 :         errors |= CL_ERR_ENUM_ARG;
     821                 :            :     }
     822                 :            : 
     823                 :    7701640 :  done:
     824                 :    8615140 :   decoded->opt_index = opt_index;
     825                 :    8615140 :   decoded->arg = arg;
     826                 :    8615140 :   decoded->value = value;
     827                 :    8615140 :   decoded->errors = errors;
     828                 :    8615140 :   decoded->warn_message = warn_message;
     829                 :            : 
     830                 :    8615140 :   if (opt_index == OPT_SPECIAL_unknown)
     831                 :        350 :     gcc_assert (result == 1);
     832                 :            : 
     833                 :    8615140 :   gcc_assert (result >= 1 && result <= ARRAY_SIZE (decoded->canonical_option));
     834                 :    8615140 :   decoded->canonical_option_num_elements = result;
     835                 :    8615140 :   total_len = 0;
     836                 :   43075700 :   for (i = 0; i < ARRAY_SIZE (decoded->canonical_option); i++)
     837                 :            :     {
     838                 :   34460600 :       if (i < result)
     839                 :            :         {
     840                 :   10729800 :           size_t len;
     841                 :   10729800 :           if (opt_index == OPT_SPECIAL_unknown)
     842                 :        350 :             decoded->canonical_option[i] = argv[i];
     843                 :            :           else
     844                 :   10729500 :             decoded->canonical_option[i] = NULL;
     845                 :   10729800 :           len = strlen (argv[i]);
     846                 :            :           /* If the argument is an empty string, we will print it as "" in
     847                 :            :              orig_option_with_args_text.  */
     848                 :   10729800 :           total_len += (len != 0 ? len : 2) + 1;
     849                 :            :         }
     850                 :            :       else
     851                 :   23730800 :         decoded->canonical_option[i] = NULL;
     852                 :            :     }
     853                 :    8615140 :   if (opt_index != OPT_SPECIAL_unknown && opt_index != OPT_SPECIAL_ignore
     854                 :    8615140 :       && opt_index != OPT_SPECIAL_warn_removed)
     855                 :            :     {
     856                 :    8614780 :       generate_canonical_option (opt_index, arg, value, decoded);
     857                 :    8614780 :       if (separate_args > 1)
     858                 :            :         {
     859                 :          0 :           for (i = 0; i < separate_args; i++)
     860                 :            :             {
     861                 :          0 :               if (argv[extra_args + 1 + i] == NULL)
     862                 :            :                   break;
     863                 :            :               else
     864                 :          0 :                 decoded->canonical_option[1 + i] = argv[extra_args + 1 + i];
     865                 :            :             }
     866                 :          0 :           gcc_assert (result == 1 + i);
     867                 :          0 :           decoded->canonical_option_num_elements = result;
     868                 :            :         }
     869                 :            :     }
     870                 :    8615140 :   decoded->orig_option_with_args_text
     871                 :    8615140 :     = p = XOBNEWVEC (&opts_obstack, char, total_len);
     872                 :   19345000 :   for (i = 0; i < result; i++)
     873                 :            :     {
     874                 :   10729800 :       size_t len = strlen (argv[i]);
     875                 :            : 
     876                 :            :       /* Print the empty string verbally.  */
     877                 :   10729800 :       if (len == 0)
     878                 :            :         {
     879                 :        899 :           *p++ = '"';
     880                 :        899 :           *p++ = '"';
     881                 :            :         }
     882                 :            :       else
     883                 :   10728900 :         memcpy (p, argv[i], len);
     884                 :   10729800 :       p += len;
     885                 :   10729800 :       if (i == result - 1)
     886                 :    8615140 :         *p++ = 0;
     887                 :            :       else
     888                 :    2114670 :         *p++ = ' ';
     889                 :            :     }
     890                 :            : 
     891                 :    8615140 :   return result;
     892                 :            : }
     893                 :            : 
     894                 :            : /* Obstack for option strings.  */
     895                 :            : 
     896                 :            : struct obstack opts_obstack;
     897                 :            : 
     898                 :            : /* Like libiberty concat, but allocate using opts_obstack.  */
     899                 :            : 
     900                 :            : char *
     901                 :    2681030 : opts_concat (const char *first, ...)
     902                 :            : {
     903                 :    2681030 :   char *newstr, *end;
     904                 :    2681030 :   size_t length = 0;
     905                 :    2681030 :   const char *arg;
     906                 :    2681030 :   va_list ap;
     907                 :            : 
     908                 :            :   /* First compute the size of the result and get sufficient memory.  */
     909                 :    2681030 :   va_start (ap, first);
     910                 :    8131560 :   for (arg = first; arg; arg = va_arg (ap, const char *))
     911                 :    5450530 :     length += strlen (arg);
     912                 :    2681030 :   newstr = XOBNEWVEC (&opts_obstack, char, length + 1);
     913                 :    2681030 :   va_end (ap);
     914                 :            : 
     915                 :            :   /* Now copy the individual pieces to the result string. */
     916                 :    2681030 :   va_start (ap, first);
     917                 :    8131560 :   for (arg = first, end = newstr; arg; arg = va_arg (ap, const char *))
     918                 :            :     {
     919                 :    5450530 :       length = strlen (arg);
     920                 :    5450530 :       memcpy (end, arg, length);
     921                 :    5450530 :       end += length;
     922                 :            :     }
     923                 :    2681030 :   *end = '\0';
     924                 :    2681030 :   va_end (ap);
     925                 :    2681030 :   return newstr;
     926                 :            : }
     927                 :            : 
     928                 :            : /* Decode command-line options (ARGC and ARGV being the arguments of
     929                 :            :    main) into an array, setting *DECODED_OPTIONS to a pointer to that
     930                 :            :    array and *DECODED_OPTIONS_COUNT to the number of entries in the
     931                 :            :    array.  The first entry in the array is always one for the program
     932                 :            :    name (OPT_SPECIAL_program_name).  LANG_MASK indicates the language
     933                 :            :    flags applicable for decoding (including CL_COMMON and CL_TARGET if
     934                 :            :    those options should be considered applicable).  Do not produce any
     935                 :            :    diagnostics or set state outside of these variables.  */
     936                 :            : 
     937                 :            : void
     938                 :     812908 : decode_cmdline_options_to_array (unsigned int argc, const char **argv, 
     939                 :            :                                  unsigned int lang_mask,
     940                 :            :                                  struct cl_decoded_option **decoded_options,
     941                 :            :                                  unsigned int *decoded_options_count)
     942                 :            : {
     943                 :     812908 :   unsigned int n, i;
     944                 :     812908 :   struct cl_decoded_option *opt_array;
     945                 :     812908 :   unsigned int num_decoded_options;
     946                 :            : 
     947                 :     812908 :   opt_array = XNEWVEC (struct cl_decoded_option, argc);
     948                 :            : 
     949                 :     812908 :   opt_array[0].opt_index = OPT_SPECIAL_program_name;
     950                 :     812908 :   opt_array[0].warn_message = NULL;
     951                 :     812908 :   opt_array[0].arg = argv[0];
     952                 :     812908 :   opt_array[0].orig_option_with_args_text = argv[0];
     953                 :     812908 :   opt_array[0].canonical_option_num_elements = 1;
     954                 :     812908 :   opt_array[0].canonical_option[0] = argv[0];
     955                 :     812908 :   opt_array[0].canonical_option[1] = NULL;
     956                 :     812908 :   opt_array[0].canonical_option[2] = NULL;
     957                 :     812908 :   opt_array[0].canonical_option[3] = NULL;
     958                 :     812908 :   opt_array[0].value = 1;
     959                 :     812908 :   opt_array[0].errors = 0;
     960                 :     812908 :   num_decoded_options = 1;
     961                 :            : 
     962                 :    9858970 :   for (i = 1; i < argc; i += n)
     963                 :            :     {
     964                 :    9046060 :       const char *opt = argv[i];
     965                 :            : 
     966                 :            :       /* Interpret "-" or a non-switch as a file name.  */
     967                 :    9046060 :       if (opt[0] != '-' || opt[1] == '\0')
     968                 :            :         {
     969                 :     430921 :           generate_option_input_file (opt, &opt_array[num_decoded_options]);
     970                 :     430921 :           num_decoded_options++;
     971                 :     430921 :           n = 1;
     972                 :     430921 :           continue;
     973                 :            :         }
     974                 :            : 
     975                 :            :       /* Interpret "--param" "key=name" as "--param=key=name".  */
     976                 :    8615140 :       const char *needle = "--param";
     977                 :    8615140 :       if (i + 1 < argc && strcmp (opt, needle) == 0)
     978                 :            :         {
     979                 :       1292 :           const char *replacement
     980                 :       1292 :             = opts_concat (needle, "=", argv[i + 1], NULL);
     981                 :       1292 :           argv[++i] = replacement;
     982                 :            :         }
     983                 :            : 
     984                 :   17230300 :       n = decode_cmdline_option (argv + i, lang_mask,
     985                 :    8615140 :                                  &opt_array[num_decoded_options]);
     986                 :    8615140 :       num_decoded_options++;
     987                 :            :     }
     988                 :            : 
     989                 :     812908 :   *decoded_options = opt_array;
     990                 :     812908 :   *decoded_options_count = num_decoded_options;
     991                 :     812908 :   prune_options (decoded_options, decoded_options_count);
     992                 :     812908 : }
     993                 :            : 
     994                 :            : /* Return true if NEXT_OPT_IDX cancels OPT_IDX.  Return false if the
     995                 :            :    next one is the same as ORIG_NEXT_OPT_IDX.  */
     996                 :            : 
     997                 :            : static bool
     998                 :          0 : cancel_option (int opt_idx, int next_opt_idx, int orig_next_opt_idx)
     999                 :            : {
    1000                 :            :   /* An option can be canceled by the same option or an option with
    1001                 :            :      Negative.  */
    1002                 :    6972210 :   if (cl_options [next_opt_idx].neg_index == opt_idx)
    1003                 :            :     return true;
    1004                 :            : 
    1005                 :    6862890 :   if (cl_options [next_opt_idx].neg_index != orig_next_opt_idx)
    1006                 :            :     return cancel_option (opt_idx, cl_options [next_opt_idx].neg_index,
    1007                 :            :                           orig_next_opt_idx);
    1008                 :            : 
    1009                 :            :   return false;
    1010                 :            : }
    1011                 :            : 
    1012                 :            : /* Filter out options canceled by the ones after them.  */
    1013                 :            : 
    1014                 :            : static void
    1015                 :     812908 : prune_options (struct cl_decoded_option **decoded_options,
    1016                 :            :                unsigned int *decoded_options_count)
    1017                 :            : {
    1018                 :     812908 :   unsigned int old_decoded_options_count = *decoded_options_count;
    1019                 :     812908 :   struct cl_decoded_option *old_decoded_options = *decoded_options;
    1020                 :     812908 :   unsigned int new_decoded_options_count;
    1021                 :     812908 :   struct cl_decoded_option *new_decoded_options
    1022                 :     812908 :     = XNEWVEC (struct cl_decoded_option, old_decoded_options_count);
    1023                 :     812908 :   unsigned int i;
    1024                 :     812908 :   const struct cl_option *option;
    1025                 :     812908 :   unsigned int fdiagnostics_color_idx = 0;
    1026                 :            : 
    1027                 :            :   /* Remove arguments which are negated by others after them.  */
    1028                 :     812908 :   new_decoded_options_count = 0;
    1029                 :   10671900 :   for (i = 0; i < old_decoded_options_count; i++)
    1030                 :            :     {
    1031                 :    9858970 :       unsigned int j, opt_idx, next_opt_idx;
    1032                 :            : 
    1033                 :    9858970 :       if (old_decoded_options[i].errors & ~CL_ERR_WRONG_LANG)
    1034                 :         19 :         goto keep;
    1035                 :            : 
    1036                 :    9858950 :       opt_idx = old_decoded_options[i].opt_index;
    1037                 :    9858950 :       switch (opt_idx)
    1038                 :            :         {
    1039                 :    1244180 :         case OPT_SPECIAL_unknown:
    1040                 :    1244180 :         case OPT_SPECIAL_ignore:
    1041                 :    1244180 :         case OPT_SPECIAL_warn_removed:
    1042                 :    1244180 :         case OPT_SPECIAL_program_name:
    1043                 :    1244180 :         case OPT_SPECIAL_input_file:
    1044                 :    1244180 :           goto keep;
    1045                 :            : 
    1046                 :            :         /* Do not save OPT_fdiagnostics_color_, just remember the last one.  */
    1047                 :     402699 :         case OPT_fdiagnostics_color_:
    1048                 :     402699 :           fdiagnostics_color_idx = i;
    1049                 :     402699 :           continue;
    1050                 :            : 
    1051                 :    8212070 :         default:
    1052                 :    8212070 :           gcc_assert (opt_idx < cl_options_count);
    1053                 :    8212070 :           option = &cl_options[opt_idx];
    1054                 :    8212070 :           if (option->neg_index < 0)
    1055                 :    5595810 :             goto keep;
    1056                 :            : 
    1057                 :            :           /* Skip joined switches.  */
    1058                 :    2616260 :           if ((option->flags & CL_JOINED)
    1059                 :     936188 :               && (!option->cl_reject_negative
    1060                 :     870842 :                   || (unsigned int) option->neg_index != opt_idx))
    1061                 :      65346 :             goto keep;
    1062                 :            : 
    1063                 :   21339700 :           for (j = i + 1; j < old_decoded_options_count; j++)
    1064                 :            :             {
    1065                 :   18898100 :               if (old_decoded_options[j].errors & ~CL_ERR_WRONG_LANG)
    1066                 :         39 :                 continue;
    1067                 :   18898100 :               next_opt_idx = old_decoded_options[j].opt_index;
    1068                 :   18898100 :               if (next_opt_idx >= cl_options_count)
    1069                 :     517818 :                 continue;
    1070                 :   18380300 :               if (cl_options[next_opt_idx].neg_index < 0)
    1071                 :   11814900 :                 continue;
    1072                 :    6565360 :               if ((cl_options[next_opt_idx].flags & CL_JOINED)
    1073                 :    1178780 :                   && (!cl_options[next_opt_idx].cl_reject_negative
    1074                 :     799981 :                       || ((unsigned int) cl_options[next_opt_idx].neg_index
    1075                 :            :                           != next_opt_idx)))
    1076                 :     378802 :                 continue;
    1077                 :   12373100 :               if (cancel_option (opt_idx, next_opt_idx, next_opt_idx))
    1078                 :            :                 break;
    1079                 :            :             }
    1080                 :    2550910 :           if (j == old_decoded_options_count)
    1081                 :            :             {
    1082                 :    2441580 : keep:
    1083                 :    9346950 :               new_decoded_options[new_decoded_options_count]
    1084                 :    9346950 :                 = old_decoded_options[i];
    1085                 :    9346950 :               new_decoded_options_count++;
    1086                 :            :             }
    1087                 :            :           break;
    1088                 :            :         }
    1089                 :            :     }
    1090                 :            : 
    1091                 :     812908 :   if (fdiagnostics_color_idx >= 1)
    1092                 :            :     {
    1093                 :            :       /* We put the last -fdiagnostics-color= at the first position
    1094                 :            :          after argv[0] so it can take effect immediately.  */
    1095                 :     380367 :       memmove (new_decoded_options + 2, new_decoded_options + 1,
    1096                 :            :                sizeof (struct cl_decoded_option) 
    1097                 :     380367 :                * (new_decoded_options_count - 1));
    1098                 :     380367 :       new_decoded_options[1] = old_decoded_options[fdiagnostics_color_idx];
    1099                 :     380367 :       new_decoded_options_count++;
    1100                 :            :     }
    1101                 :            : 
    1102                 :     812908 :   free (old_decoded_options);
    1103                 :     812908 :   new_decoded_options = XRESIZEVEC (struct cl_decoded_option,
    1104                 :            :                                     new_decoded_options,
    1105                 :            :                                     new_decoded_options_count);
    1106                 :     812908 :   *decoded_options = new_decoded_options;
    1107                 :     812908 :   *decoded_options_count = new_decoded_options_count;
    1108                 :     812908 : }
    1109                 :            : 
    1110                 :            : /* Handle option DECODED for the language indicated by LANG_MASK,
    1111                 :            :    using the handlers in HANDLERS and setting fields in OPTS and
    1112                 :            :    OPTS_SET.  KIND is the diagnostic_t if this is a diagnostics
    1113                 :            :    option, DK_UNSPECIFIED otherwise, and LOC is the location of the
    1114                 :            :    option for options from the source file, UNKNOWN_LOCATION
    1115                 :            :    otherwise.  GENERATED_P is true for an option generated as part of
    1116                 :            :    processing another option or otherwise generated internally, false
    1117                 :            :    for one explicitly passed by the user.  control_warning_option
    1118                 :            :    generated options are considered explicitly passed by the user.
    1119                 :            :    Returns false if the switch was invalid.  DC is the diagnostic
    1120                 :            :    context for options affecting diagnostics state, or NULL.  */
    1121                 :            : 
    1122                 :            : static bool
    1123                 :   27389500 : handle_option (struct gcc_options *opts,
    1124                 :            :                struct gcc_options *opts_set,
    1125                 :            :                const struct cl_decoded_option *decoded,
    1126                 :            :                unsigned int lang_mask, int kind, location_t loc,
    1127                 :            :                const struct cl_option_handlers *handlers,
    1128                 :            :                bool generated_p, diagnostic_context *dc)
    1129                 :            : {
    1130                 :   27389500 :   size_t opt_index = decoded->opt_index;
    1131                 :   27389500 :   const char *arg = decoded->arg;
    1132                 :   27389500 :   HOST_WIDE_INT value = decoded->value;
    1133                 :   27389500 :   const struct cl_option *option = &cl_options[opt_index];
    1134                 :   27389500 :   void *flag_var = option_flag_var (opt_index, opts);
    1135                 :   27389500 :   size_t i;
    1136                 :            : 
    1137                 :   27389500 :   if (flag_var)
    1138                 :   27811300 :     set_option (opts, (generated_p ? NULL : opts_set),
    1139                 :            :                 opt_index, value, arg, kind, loc, dc);
    1140                 :            : 
    1141                 :  109557000 :   for (i = 0; i < handlers->num_handlers; i++)
    1142                 :   82168000 :     if (option->flags & handlers->handlers[i].mask)
    1143                 :            :       {
    1144                 :   28404800 :         if (!handlers->handlers[i].handler (opts, opts_set, decoded,
    1145                 :            :                                             lang_mask, kind, loc,
    1146                 :            :                                             handlers, dc,
    1147                 :   28405100 :                                             handlers->target_option_override_hook))
    1148                 :            :           return false;
    1149                 :            :       }
    1150                 :            :   
    1151                 :            :   return true;
    1152                 :            : }
    1153                 :            : 
    1154                 :            : /* Like handle_option, but OPT_INDEX, ARG and VALUE describe the
    1155                 :            :    option instead of DECODED.  This is used for callbacks when one
    1156                 :            :    option implies another instead of an option being decoded from the
    1157                 :            :    command line.  */
    1158                 :            : 
    1159                 :            : bool
    1160                 :   21267200 : handle_generated_option (struct gcc_options *opts,
    1161                 :            :                          struct gcc_options *opts_set,
    1162                 :            :                          size_t opt_index, const char *arg, HOST_WIDE_INT value,
    1163                 :            :                          unsigned int lang_mask, int kind, location_t loc,
    1164                 :            :                          const struct cl_option_handlers *handlers,
    1165                 :            :                          bool generated_p, diagnostic_context *dc)
    1166                 :            : {
    1167                 :   21267200 :   struct cl_decoded_option decoded;
    1168                 :            : 
    1169                 :   21267200 :   generate_option (opt_index, arg, value, lang_mask, &decoded);
    1170                 :   21267200 :   return handle_option (opts, opts_set, &decoded, lang_mask, kind, loc,
    1171                 :   21267200 :                         handlers, generated_p, dc);
    1172                 :            : }
    1173                 :            : 
    1174                 :            : /* Fill in *DECODED with an option described by OPT_INDEX, ARG and
    1175                 :            :    VALUE for a front end using LANG_MASK.  This is used when the
    1176                 :            :    compiler generates options internally.  */
    1177                 :            : 
    1178                 :            : void
    1179                 :   54973100 : generate_option (size_t opt_index, const char *arg, HOST_WIDE_INT value,
    1180                 :            :                  unsigned int lang_mask, struct cl_decoded_option *decoded)
    1181                 :            : {
    1182                 :   54973100 :   const struct cl_option *option = &cl_options[opt_index];
    1183                 :            : 
    1184                 :   54973100 :   decoded->opt_index = opt_index;
    1185                 :   54973100 :   decoded->warn_message = NULL;
    1186                 :   54973100 :   decoded->arg = arg;
    1187                 :   54973100 :   decoded->value = value;
    1188                 :   54973100 :   decoded->errors = (option_ok_for_language (option, lang_mask)
    1189                 :            :                      ? 0
    1190                 :            :                      : CL_ERR_WRONG_LANG);
    1191                 :            : 
    1192                 :   54973100 :   generate_canonical_option (opt_index, arg, value, decoded);
    1193                 :   54973100 :   switch (decoded->canonical_option_num_elements)
    1194                 :            :     {
    1195                 :   54886000 :     case 1:
    1196                 :   54886000 :       decoded->orig_option_with_args_text = decoded->canonical_option[0];
    1197                 :   54886000 :       break;
    1198                 :            : 
    1199                 :      87177 :     case 2:
    1200                 :      87177 :       decoded->orig_option_with_args_text
    1201                 :      87177 :         = opts_concat (decoded->canonical_option[0], " ",
    1202                 :            :                        decoded->canonical_option[1], NULL);
    1203                 :      87177 :       break;
    1204                 :            : 
    1205                 :          0 :     default:
    1206                 :          0 :       gcc_unreachable ();
    1207                 :            :     }
    1208                 :   54973100 : }
    1209                 :            : 
    1210                 :            : /* Fill in *DECODED with an option for input file FILE.  */
    1211                 :            : 
    1212                 :            : void
    1213                 :     430921 : generate_option_input_file (const char *file,
    1214                 :            :                             struct cl_decoded_option *decoded)
    1215                 :            : {
    1216                 :     430921 :   decoded->opt_index = OPT_SPECIAL_input_file;
    1217                 :     430921 :   decoded->warn_message = NULL;
    1218                 :     430921 :   decoded->arg = file;
    1219                 :     430921 :   decoded->orig_option_with_args_text = file;
    1220                 :     430921 :   decoded->canonical_option_num_elements = 1;
    1221                 :     430921 :   decoded->canonical_option[0] = file;
    1222                 :     430921 :   decoded->canonical_option[1] = NULL;
    1223                 :     430921 :   decoded->canonical_option[2] = NULL;
    1224                 :     430921 :   decoded->canonical_option[3] = NULL;
    1225                 :     430921 :   decoded->value = 1;
    1226                 :     430921 :   decoded->errors = 0;
    1227                 :     430921 : }
    1228                 :            : 
    1229                 :            : /* Helper function for listing valid choices and hint for misspelled
    1230                 :            :    value.  CANDIDATES is a vector containing all valid strings,
    1231                 :            :    STR is set to a heap allocated string that contains all those
    1232                 :            :    strings concatenated, separated by spaces, and the return value
    1233                 :            :    is the closest string from those to ARG, or NULL if nothing is
    1234                 :            :    close enough.  Callers should XDELETEVEC (STR) after using it
    1235                 :            :    to avoid memory leaks.  */
    1236                 :            : 
    1237                 :            : const char *
    1238                 :         10 : candidates_list_and_hint (const char *arg, char *&str,
    1239                 :            :                           const auto_vec <const char *> &candidates)
    1240                 :            : {
    1241                 :         10 :   size_t len = 0;
    1242                 :         10 :   int i;
    1243                 :         10 :   const char *candidate;
    1244                 :         10 :   char *p;
    1245                 :            : 
    1246                 :        479 :   FOR_EACH_VEC_ELT (candidates, i, candidate)
    1247                 :        469 :     len += strlen (candidate) + 1;
    1248                 :            : 
    1249                 :         10 :   str = p = XNEWVEC (char, len);
    1250                 :        479 :   FOR_EACH_VEC_ELT (candidates, i, candidate)
    1251                 :            :     {
    1252                 :        469 :       len = strlen (candidate);
    1253                 :        469 :       memcpy (p, candidate, len);
    1254                 :        469 :       p[len] = ' ';
    1255                 :        469 :       p += len + 1;
    1256                 :            :     }
    1257                 :         10 :   p[-1] = '\0';
    1258                 :         10 :   return find_closest_string (arg, &candidates);
    1259                 :            : }
    1260                 :            : 
    1261                 :            : /* Perform diagnostics for read_cmdline_option and control_warning_option
    1262                 :            :    functions.  Returns true if an error has been diagnosed.
    1263                 :            :    LOC and LANG_MASK arguments like in read_cmdline_option.
    1264                 :            :    OPTION is the option to report diagnostics for, OPT the name
    1265                 :            :    of the option as text, ARG the argument of the option (for joined
    1266                 :            :    options), ERRORS is bitmask of CL_ERR_* values.  */
    1267                 :            : 
    1268                 :            : static bool
    1269                 :    2291070 : cmdline_handle_error (location_t loc, const struct cl_option *option,
    1270                 :            :                       const char *opt, const char *arg, int errors,
    1271                 :            :                       unsigned int lang_mask)
    1272                 :            : {
    1273                 :    2291070 :   if (errors & CL_ERR_DISABLED)
    1274                 :            :     {
    1275                 :          0 :       error_at (loc, "command-line option %qs"
    1276                 :            :                      " is not supported by this configuration", opt);
    1277                 :          0 :       return true;
    1278                 :            :     }
    1279                 :            : 
    1280                 :    2291070 :   if (errors & CL_ERR_MISSING_ARG)
    1281                 :            :     {
    1282                 :          1 :       if (option->missing_argument_error)
    1283                 :          0 :         error_at (loc, option->missing_argument_error, opt);
    1284                 :            :       else
    1285                 :          1 :         error_at (loc, "missing argument to %qs", opt);
    1286                 :          1 :       return true;
    1287                 :            :     }
    1288                 :            : 
    1289                 :    2291070 :   if (errors & CL_ERR_UINT_ARG)
    1290                 :            :     {
    1291                 :          5 :       if (option->cl_byte_size)
    1292                 :          3 :         error_at (loc, "argument to %qs should be a non-negative integer "
    1293                 :            :                   "optionally followed by a size unit",
    1294                 :          3 :                   option->opt_text);
    1295                 :            :       else
    1296                 :          2 :         error_at (loc, "argument to %qs should be a non-negative integer",
    1297                 :          2 :                   option->opt_text);
    1298                 :          5 :       return true;
    1299                 :            :     }
    1300                 :            : 
    1301                 :    2291060 :   if (errors & CL_ERR_INT_RANGE_ARG)
    1302                 :            :     {
    1303                 :          5 :       error_at (loc, "argument to %qs is not between %d and %d",
    1304                 :          5 :                 option->opt_text, option->range_min, option->range_max);
    1305                 :          5 :       return true;
    1306                 :            :     }
    1307                 :            : 
    1308                 :    2291060 :   if (errors & CL_ERR_ENUM_ARG)
    1309                 :            :     {
    1310                 :          1 :       const struct cl_enum *e = &cl_enums[option->var_enum];
    1311                 :          1 :       unsigned int i;
    1312                 :          1 :       char *s;
    1313                 :            : 
    1314                 :          1 :       auto_diagnostic_group d;
    1315                 :          1 :       if (e->unknown_error)
    1316                 :          1 :         error_at (loc, e->unknown_error, arg);
    1317                 :            :       else
    1318                 :          0 :         error_at (loc, "unrecognized argument in option %qs", opt);
    1319                 :            : 
    1320                 :          2 :       auto_vec <const char *> candidates;
    1321                 :          5 :       for (i = 0; e->values[i].arg != NULL; i++)
    1322                 :            :         {
    1323                 :          4 :           if (!enum_arg_ok_for_language (&e->values[i], lang_mask))
    1324                 :          0 :             continue;
    1325                 :          4 :           candidates.safe_push (e->values[i].arg);
    1326                 :            :         }
    1327                 :          1 :       const char *hint = candidates_list_and_hint (arg, s, candidates);
    1328                 :          1 :       if (hint)
    1329                 :          1 :         inform (loc, "valid arguments to %qs are: %s; did you mean %qs?",
    1330                 :          1 :                 option->opt_text, s, hint);
    1331                 :            :       else
    1332                 :          0 :         inform (loc, "valid arguments to %qs are: %s", option->opt_text, s);
    1333                 :          1 :       XDELETEVEC (s);
    1334                 :            : 
    1335                 :          1 :       return true;
    1336                 :            :     }
    1337                 :            : 
    1338                 :            :   return false;
    1339                 :            : }
    1340                 :            : 
    1341                 :            : /* Handle the switch DECODED (location LOC) for the language indicated
    1342                 :            :    by LANG_MASK, using the handlers in *HANDLERS and setting fields in
    1343                 :            :    OPTS and OPTS_SET and using diagnostic context DC (if not NULL) for
    1344                 :            :    diagnostic options.  */
    1345                 :            : 
    1346                 :            : void
    1347                 :    8413710 : read_cmdline_option (struct gcc_options *opts,
    1348                 :            :                      struct gcc_options *opts_set,
    1349                 :            :                      struct cl_decoded_option *decoded,
    1350                 :            :                      location_t loc,
    1351                 :            :                      unsigned int lang_mask,
    1352                 :            :                      const struct cl_option_handlers *handlers,
    1353                 :            :                      diagnostic_context *dc)
    1354                 :            : {
    1355                 :    8413710 :   const struct cl_option *option;
    1356                 :    8413710 :   const char *opt = decoded->orig_option_with_args_text;
    1357                 :            : 
    1358                 :    8413710 :   if (decoded->warn_message)
    1359                 :          0 :     warning_at (loc, 0, decoded->warn_message, opt);
    1360                 :            : 
    1361                 :    8413710 :   if (decoded->opt_index == OPT_SPECIAL_unknown)
    1362                 :            :     {
    1363                 :        350 :       if (handlers->unknown_option_callback (decoded))
    1364                 :          0 :         error_at (loc, "unrecognized command-line option %qs", decoded->arg);
    1365                 :        350 :       return;
    1366                 :            :     }
    1367                 :            : 
    1368                 :    8413360 :   if (decoded->opt_index == OPT_SPECIAL_ignore)
    1369                 :            :     return;
    1370                 :            : 
    1371                 :    8413360 :   if (decoded->opt_index == OPT_SPECIAL_warn_removed)
    1372                 :            :     {
    1373                 :            :       /* Warn only about positive ignored options.  */
    1374                 :          9 :       if (decoded->value)
    1375                 :          9 :         warning_at (loc, 0, "switch %qs is no longer supported", opt);
    1376                 :          9 :       return;
    1377                 :            :     }
    1378                 :            : 
    1379                 :    8413350 :   option = &cl_options[decoded->opt_index];
    1380                 :            : 
    1381                 :    8413350 :   if (decoded->errors
    1382                 :    8413350 :       && cmdline_handle_error (loc, option, opt, decoded->arg,
    1383                 :            :                                decoded->errors, lang_mask))
    1384                 :            :     return;
    1385                 :            : 
    1386                 :    8413340 :   if (decoded->errors & CL_ERR_WRONG_LANG)
    1387                 :            :     {
    1388                 :    2291060 :       handlers->wrong_lang_callback (decoded, lang_mask);
    1389                 :    2291060 :       return;
    1390                 :            :     }
    1391                 :            : 
    1392                 :    6122280 :   gcc_assert (!decoded->errors);
    1393                 :            : 
    1394                 :    6122280 :   if (!handle_option (opts, opts_set, decoded, lang_mask, DK_UNSPECIFIED,
    1395                 :            :                       loc, handlers, false, dc))
    1396                 :          1 :     error_at (loc, "unrecognized command-line option %qs", opt);
    1397                 :            : }
    1398                 :            : 
    1399                 :            : /* Set any field in OPTS, and OPTS_SET if not NULL, for option
    1400                 :            :    OPT_INDEX according to VALUE and ARG, diagnostic kind KIND,
    1401                 :            :    location LOC, using diagnostic context DC if not NULL for
    1402                 :            :    diagnostic classification.  */
    1403                 :            : 
    1404                 :            : void
    1405                 :   24408100 : set_option (struct gcc_options *opts, struct gcc_options *opts_set,
    1406                 :            :             int opt_index, HOST_WIDE_INT value, const char *arg, int kind,
    1407                 :            :             location_t loc, diagnostic_context *dc)
    1408                 :            : {
    1409                 :   24408100 :   const struct cl_option *option = &cl_options[opt_index];
    1410                 :   24408100 :   void *flag_var = option_flag_var (opt_index, opts);
    1411                 :   24408100 :   void *set_flag_var = NULL;
    1412                 :            : 
    1413                 :   24408100 :   if (!flag_var)
    1414                 :            :     return;
    1415                 :            : 
    1416                 :   24408100 :   if ((diagnostic_t) kind != DK_UNSPECIFIED && dc != NULL)
    1417                 :     328920 :     diagnostic_classify_diagnostic (dc, opt_index, (diagnostic_t) kind, loc);
    1418                 :            : 
    1419                 :   24408100 :   if (opts_set != NULL)
    1420                 :    3403530 :     set_flag_var = option_flag_var (opt_index, opts_set);
    1421                 :            : 
    1422                 :   24408100 :   switch (option->var_type)
    1423                 :            :     {
    1424                 :   21620400 :     case CLVC_BOOLEAN:
    1425                 :   21620400 :         if (option->cl_host_wide_int)
    1426                 :            :           {
    1427                 :          3 :             *(HOST_WIDE_INT *) flag_var = value;
    1428                 :          3 :             if (set_flag_var)
    1429                 :          3 :               *(HOST_WIDE_INT *) set_flag_var = 1;
    1430                 :            :           }
    1431                 :            :         else
    1432                 :            :           {
    1433                 :   21620400 :             *(int *) flag_var = value;
    1434                 :   21620400 :             if (set_flag_var)
    1435                 :    1165030 :               *(int *) set_flag_var = 1;
    1436                 :            :           }
    1437                 :            : 
    1438                 :            :         break;
    1439                 :            : 
    1440                 :        116 :     case CLVC_SIZE:
    1441                 :        116 :         if (option->cl_host_wide_int)
    1442                 :            :           {
    1443                 :        116 :             *(HOST_WIDE_INT *) flag_var = value;
    1444                 :        116 :             if (set_flag_var)
    1445                 :        116 :               *(HOST_WIDE_INT *) set_flag_var = value;
    1446                 :            :           }
    1447                 :            :         else
    1448                 :            :           {
    1449                 :          0 :             *(int *) flag_var = value;
    1450                 :          0 :             if (set_flag_var)
    1451                 :          0 :               *(int *) set_flag_var = value;
    1452                 :            :           }
    1453                 :            : 
    1454                 :            :         break;
    1455                 :            : 
    1456                 :     239046 :     case CLVC_EQUAL:
    1457                 :     239046 :         if (option->cl_host_wide_int)
    1458                 :            :           {
    1459                 :          0 :             *(HOST_WIDE_INT *) flag_var = (value
    1460                 :          0 :                                            ? option->var_value
    1461                 :          0 :                                            : !option->var_value);
    1462                 :          0 :             if (set_flag_var)
    1463                 :          0 :               *(HOST_WIDE_INT *) set_flag_var = 1;
    1464                 :            :           }
    1465                 :            :         else
    1466                 :            :           {
    1467                 :     239046 :             *(int *) flag_var = (value
    1468                 :     137928 :                                  ? option->var_value
    1469                 :     101118 :                                  : !option->var_value);
    1470                 :     239046 :             if (set_flag_var)
    1471                 :      33274 :               *(int *) set_flag_var = 1;
    1472                 :            :           }
    1473                 :            :         break;
    1474                 :            : 
    1475                 :      39934 :     case CLVC_BIT_CLEAR:
    1476                 :      39934 :     case CLVC_BIT_SET:
    1477                 :      39934 :         if ((value != 0) == (option->var_type == CLVC_BIT_SET))
    1478                 :            :           {
    1479                 :      30951 :             if (option->cl_host_wide_int) 
    1480                 :      29392 :               *(HOST_WIDE_INT *) flag_var |= option->var_value;
    1481                 :            :             else 
    1482                 :       1559 :               *(int *) flag_var |= option->var_value;
    1483                 :            :           }
    1484                 :            :         else
    1485                 :            :           {
    1486                 :       8983 :             if (option->cl_host_wide_int) 
    1487                 :       8040 :               *(HOST_WIDE_INT *) flag_var &= ~option->var_value;
    1488                 :            :             else 
    1489                 :        943 :               *(int *) flag_var &= ~option->var_value;
    1490                 :            :           }
    1491                 :      39934 :         if (set_flag_var)
    1492                 :            :           {
    1493                 :      39934 :             if (option->cl_host_wide_int) 
    1494                 :      37432 :               *(HOST_WIDE_INT *) set_flag_var |= option->var_value;
    1495                 :            :             else
    1496                 :       2502 :               *(int *) set_flag_var |= option->var_value;
    1497                 :            :           }
    1498                 :            :         break;
    1499                 :            : 
    1500                 :    1322430 :     case CLVC_STRING:
    1501                 :    1322430 :         *(const char **) flag_var = arg;
    1502                 :    1322430 :         if (set_flag_var)
    1503                 :    1322430 :           *(const char **) set_flag_var = "";
    1504                 :            :         break;
    1505                 :            : 
    1506                 :    1170700 :     case CLVC_ENUM:
    1507                 :    1170700 :       {
    1508                 :    1170700 :         const struct cl_enum *e = &cl_enums[option->var_enum];
    1509                 :            : 
    1510                 :    1170700 :         e->set (flag_var, value);
    1511                 :    1170700 :         if (set_flag_var)
    1512                 :     827286 :           e->set (set_flag_var, 1);
    1513                 :            :       }
    1514                 :            :       break;
    1515                 :            : 
    1516                 :      15455 :     case CLVC_DEFER:
    1517                 :      15455 :         {
    1518                 :      15455 :           vec<cl_deferred_option> *v
    1519                 :            :             = (vec<cl_deferred_option> *) *(void **) flag_var;
    1520                 :      15455 :           cl_deferred_option p = {opt_index, arg, value};
    1521                 :      15455 :           if (!v)
    1522                 :      14232 :             v = XCNEW (vec<cl_deferred_option>);
    1523                 :      15455 :           v->safe_push (p);
    1524                 :      15455 :           *(void **) flag_var = v;
    1525                 :      15455 :           if (set_flag_var)
    1526                 :      15455 :             *(void **) set_flag_var = v;
    1527                 :            :         }
    1528                 :      15455 :         break;
    1529                 :            :     }
    1530                 :            : }
    1531                 :            : 
    1532                 :            : /* Return the address of the flag variable for option OPT_INDEX in
    1533                 :            :    options structure OPTS, or NULL if there is no flag variable.  */
    1534                 :            : 
    1535                 :            : void *
    1536                 :   88213600 : option_flag_var (int opt_index, struct gcc_options *opts)
    1537                 :            : {
    1538                 :   88213600 :   const struct cl_option *option = &cl_options[opt_index];
    1539                 :            : 
    1540                 :   88213600 :   if (option->flag_var_offset == (unsigned short) -1)
    1541                 :            :     return NULL;
    1542                 :   85123200 :   return (void *)(((char *) opts) + option->flag_var_offset);
    1543                 :            : }
    1544                 :            : 
    1545                 :            : /* Return 1 if option OPT_IDX is enabled in OPTS, 0 if it is disabled,
    1546                 :            :    or -1 if it isn't a simple on-off switch.  */
    1547                 :            : 
    1548                 :            : int
    1549                 :    5991390 : option_enabled (int opt_idx, unsigned lang_mask, void *opts)
    1550                 :            : {
    1551                 :    5991390 :   const struct cl_option *option = &(cl_options[opt_idx]);
    1552                 :            : 
    1553                 :            :   /* A language-specific option can only be considered enabled when it's
    1554                 :            :      valid for the current language.  */
    1555                 :    5991390 :   if (!(option->flags & CL_COMMON)
    1556                 :    4649670 :       && (option->flags & CL_LANG_ALL)
    1557                 :    3292020 :       && !(option->flags & lang_mask))
    1558                 :            :     return 0;
    1559                 :            : 
    1560                 :    5754440 :   struct gcc_options *optsg = (struct gcc_options *) opts;
    1561                 :    5754440 :   void *flag_var = option_flag_var (opt_idx, optsg);
    1562                 :            : 
    1563                 :    5754440 :   if (flag_var)
    1564                 :    5754150 :     switch (option->var_type)
    1565                 :            :       {
    1566                 :    4396020 :       case CLVC_BOOLEAN:
    1567                 :    4396020 :         if (option->cl_host_wide_int)
    1568                 :          0 :           return *(HOST_WIDE_INT *) flag_var != 0;
    1569                 :            :         else
    1570                 :    4396020 :           return *(int *) flag_var != 0;
    1571                 :            : 
    1572                 :        293 :       case CLVC_EQUAL:
    1573                 :        293 :         if (option->cl_host_wide_int) 
    1574                 :          0 :           return *(HOST_WIDE_INT *) flag_var == option->var_value;
    1575                 :            :         else
    1576                 :        293 :           return *(int *) flag_var == option->var_value;
    1577                 :            : 
    1578                 :     107422 :       case CLVC_BIT_CLEAR:
    1579                 :     107422 :         if (option->cl_host_wide_int) 
    1580                 :      26608 :           return (*(HOST_WIDE_INT *) flag_var & option->var_value) == 0;
    1581                 :            :         else
    1582                 :      80814 :           return (*(int *) flag_var & option->var_value) == 0;
    1583                 :            : 
    1584                 :    1249970 :       case CLVC_BIT_SET:
    1585                 :    1249970 :         if (option->cl_host_wide_int) 
    1586                 :     884780 :           return (*(HOST_WIDE_INT *) flag_var & option->var_value) != 0;
    1587                 :            :         else 
    1588                 :     365192 :           return (*(int *) flag_var & option->var_value) != 0;
    1589                 :            : 
    1590                 :        255 :       case CLVC_SIZE:
    1591                 :        255 :         if (option->cl_host_wide_int)
    1592                 :        255 :           return *(HOST_WIDE_INT *) flag_var != -1;
    1593                 :            :         else
    1594                 :          0 :           return *(int *) flag_var != -1;
    1595                 :            : 
    1596                 :            :       case CLVC_STRING:
    1597                 :            :       case CLVC_ENUM:
    1598                 :            :       case CLVC_DEFER:
    1599                 :            :         break;
    1600                 :            :       }
    1601                 :            :   return -1;
    1602                 :            : }
    1603                 :            : 
    1604                 :            : /* Fill STATE with the current state of option OPTION in OPTS.  Return
    1605                 :            :    true if there is some state to store.  */
    1606                 :            : 
    1607                 :            : bool
    1608                 :    2021250 : get_option_state (struct gcc_options *opts, int option,
    1609                 :            :                   struct cl_option_state *state)
    1610                 :            : {
    1611                 :    2021250 :   void *flag_var = option_flag_var (option, opts);
    1612                 :            : 
    1613                 :    2021250 :   if (flag_var == 0)
    1614                 :            :     return false;
    1615                 :            : 
    1616                 :    1967080 :   switch (cl_options[option].var_type)
    1617                 :            :     {
    1618                 :     389457 :     case CLVC_BOOLEAN:
    1619                 :     389457 :     case CLVC_EQUAL:
    1620                 :     389457 :     case CLVC_SIZE:
    1621                 :     389457 :       state->data = flag_var;
    1622                 :     778914 :       state->size = (cl_options[option].cl_host_wide_int
    1623                 :     389457 :                      ? sizeof (HOST_WIDE_INT)
    1624                 :            :                      : sizeof (int));
    1625                 :     389457 :       break;
    1626                 :            : 
    1627                 :    1356030 :     case CLVC_BIT_CLEAR:
    1628                 :    1356030 :     case CLVC_BIT_SET:
    1629                 :    1356030 :       state->ch = option_enabled (option, -1, opts);
    1630                 :    1356030 :       state->data = &state->ch;
    1631                 :    1356030 :       state->size = 1;
    1632                 :    1356030 :       break;
    1633                 :            : 
    1634                 :      84708 :     case CLVC_STRING:
    1635                 :      84708 :       state->data = *(const char **) flag_var;
    1636                 :      84708 :       if (state->data == 0)
    1637                 :      70425 :         state->data = "";
    1638                 :      84708 :       state->size = strlen ((const char *) state->data) + 1;
    1639                 :      84708 :       break;
    1640                 :            : 
    1641                 :     136890 :     case CLVC_ENUM:
    1642                 :     136890 :       state->data = flag_var;
    1643                 :     136890 :       state->size = cl_enums[cl_options[option].var_enum].var_size;
    1644                 :     136890 :       break;
    1645                 :            : 
    1646                 :            :     case CLVC_DEFER:
    1647                 :            :       return false;
    1648                 :            :     }
    1649                 :            :   return true;
    1650                 :            : }
    1651                 :            : 
    1652                 :            : /* Set a warning option OPT_INDEX (language mask LANG_MASK, option
    1653                 :            :    handlers HANDLERS) to have diagnostic kind KIND for option
    1654                 :            :    structures OPTS and OPTS_SET and diagnostic context DC (possibly
    1655                 :            :    NULL), at location LOC (UNKNOWN_LOCATION for -Werror=).  ARG is the
    1656                 :            :    argument of the option for joined options, or NULL otherwise.  If IMPLY,
    1657                 :            :    the warning option in question is implied at this point.  This is
    1658                 :            :    used by -Werror= and #pragma GCC diagnostic.  */
    1659                 :            : 
    1660                 :            : void
    1661                 :     202918 : control_warning_option (unsigned int opt_index, int kind, const char *arg,
    1662                 :            :                         bool imply, location_t loc, unsigned int lang_mask,
    1663                 :            :                         const struct cl_option_handlers *handlers,
    1664                 :            :                         struct gcc_options *opts,
    1665                 :            :                         struct gcc_options *opts_set,
    1666                 :            :                         diagnostic_context *dc)
    1667                 :            : {
    1668                 :     202918 :   if (cl_options[opt_index].alias_target != N_OPTS)
    1669                 :            :     {
    1670                 :         32 :       gcc_assert (!cl_options[opt_index].cl_separate_alias
    1671                 :            :                   && !cl_options[opt_index].cl_negative_alias);
    1672                 :         32 :       if (cl_options[opt_index].alias_arg)
    1673                 :         13 :         arg = cl_options[opt_index].alias_arg;
    1674                 :         32 :       opt_index = cl_options[opt_index].alias_target;
    1675                 :            :     }
    1676                 :     202918 :   if (opt_index == OPT_SPECIAL_ignore || opt_index == OPT_SPECIAL_warn_removed)
    1677                 :            :     return;
    1678                 :     202915 :   if (dc)
    1679                 :     202915 :     diagnostic_classify_diagnostic (dc, opt_index, (diagnostic_t) kind, loc);
    1680                 :     202915 :   if (imply)
    1681                 :            :     {
    1682                 :      56850 :       const struct cl_option *option = &cl_options[opt_index];
    1683                 :            : 
    1684                 :            :       /* -Werror=foo implies -Wfoo.  */
    1685                 :      56850 :       if (option->var_type == CLVC_BOOLEAN
    1686                 :         31 :           || option->var_type == CLVC_ENUM
    1687                 :         25 :           || option->var_type == CLVC_SIZE)
    1688                 :            :         {
    1689                 :      56850 :           HOST_WIDE_INT value = 1;
    1690                 :            : 
    1691                 :      56850 :           if (arg && *arg == '\0' && !option->cl_missing_ok)
    1692                 :          0 :             arg = NULL;
    1693                 :            : 
    1694                 :      56850 :           if ((option->flags & CL_JOINED) && arg == NULL)
    1695                 :            :             {
    1696                 :          0 :               cmdline_handle_error (loc, option, option->opt_text, arg,
    1697                 :            :                                     CL_ERR_MISSING_ARG, lang_mask);
    1698                 :          0 :               return;
    1699                 :            :             }
    1700                 :            : 
    1701                 :            :           /* If the switch takes an integer argument, convert it.  */
    1702                 :      56850 :           if (arg && (option->cl_uinteger || option->cl_host_wide_int))
    1703                 :            :             {
    1704                 :         32 :               int error = 0;
    1705                 :         32 :               value = *arg ? integral_argument (arg, &error,
    1706                 :            :                                                 option->cl_byte_size) : 0;
    1707                 :         32 :               if (error)
    1708                 :            :                 {
    1709                 :          0 :                   cmdline_handle_error (loc, option, option->opt_text, arg,
    1710                 :            :                                         CL_ERR_UINT_ARG, lang_mask);
    1711                 :          0 :                   return;
    1712                 :            :                 }
    1713                 :            :             }
    1714                 :            : 
    1715                 :            :           /* If the switch takes an enumerated argument, convert it.  */
    1716                 :      56850 :           if (arg && option->var_type == CLVC_ENUM)
    1717                 :            :             {
    1718                 :          6 :               const struct cl_enum *e = &cl_enums[option->var_enum];
    1719                 :            : 
    1720                 :          6 :               if (enum_arg_to_value (e->values, arg, &value, lang_mask))
    1721                 :            :                 {
    1722                 :          6 :                   const char *carg = NULL;
    1723                 :            : 
    1724                 :          6 :                   if (enum_value_to_arg (e->values, &carg, value, lang_mask))
    1725                 :          0 :                     arg = carg;
    1726                 :          6 :                   gcc_assert (carg != NULL);
    1727                 :            :                 }
    1728                 :            :               else
    1729                 :            :                 {
    1730                 :          0 :                   cmdline_handle_error (loc, option, option->opt_text, arg,
    1731                 :            :                                         CL_ERR_ENUM_ARG, lang_mask);
    1732                 :          0 :                   return;
    1733                 :            :                 }
    1734                 :            :             }
    1735                 :            : 
    1736                 :      56850 :           handle_generated_option (opts, opts_set,
    1737                 :            :                                    opt_index, arg, value, lang_mask,
    1738                 :            :                                    kind, loc, handlers, false, dc);
    1739                 :            :         }
    1740                 :            :     }
    1741                 :            : }
    1742                 :            : 
    1743                 :            : /* Parse options in COLLECT_GCC_OPTIONS and push them on ARGV_OBSTACK.
    1744                 :            :    Store number of arguments into ARGC_P.  */
    1745                 :            : 
    1746                 :            : void
    1747                 :      17734 : parse_options_from_collect_gcc_options (const char *collect_gcc_options,
    1748                 :            :                                         obstack *argv_obstack,
    1749                 :            :                                         int *argc_p)
    1750                 :            : {
    1751                 :      17734 :   char *argv_storage = xstrdup (collect_gcc_options);
    1752                 :      17734 :   int j, k;
    1753                 :            : 
    1754                 :     587362 :   for (j = 0, k = 0; argv_storage[j] != '\0'; ++j)
    1755                 :            :     {
    1756                 :     569628 :       if (argv_storage[j] == '\'')
    1757                 :            :         {
    1758                 :     293598 :           obstack_ptr_grow (argv_obstack, &argv_storage[k]);
    1759                 :     293598 :           ++j;
    1760                 :    6449980 :           do
    1761                 :            :             {
    1762                 :    6449980 :               if (argv_storage[j] == '\0')
    1763                 :          0 :                 fatal_error (input_location,
    1764                 :            :                              "malformed %<COLLECT_GCC_OPTIONS%>");
    1765                 :    6449980 :               else if (strncmp (&argv_storage[j], "'\\''", 4) == 0)
    1766                 :            :                 {
    1767                 :          0 :                   argv_storage[k++] = '\'';
    1768                 :          0 :                   j += 4;
    1769                 :            :                 }
    1770                 :    6449980 :               else if (argv_storage[j] == '\'')
    1771                 :            :                 break;
    1772                 :            :               else
    1773                 :    6156380 :                 argv_storage[k++] = argv_storage[j++];
    1774                 :            :             }
    1775                 :            :           while (1);
    1776                 :     293598 :           argv_storage[k++] = '\0';
    1777                 :            :         }
    1778                 :            :     }
    1779                 :            : 
    1780                 :      17734 :   obstack_ptr_grow (argv_obstack, NULL);
    1781                 :      17734 :   *argc_p = obstack_object_size (argv_obstack) / sizeof (void *) - 1;
    1782                 :      17734 : }
    1783                 :            : 
    1784                 :            : /* Prepend -Xassembler for each option in COLLECT_AS_OPTIONS,
    1785                 :            :    and push on O.  */
    1786                 :            : 
    1787                 :          3 : void prepend_xassembler_to_collect_as_options (const char *collect_as_options,
    1788                 :            :                                                obstack *o)
    1789                 :            : {
    1790                 :          3 :   obstack opts_obstack;
    1791                 :          3 :   int opts_count;
    1792                 :            : 
    1793                 :          3 :   obstack_init (&opts_obstack);
    1794                 :          3 :   parse_options_from_collect_gcc_options (collect_as_options,
    1795                 :            :                                           &opts_obstack, &opts_count);
    1796                 :          3 :   const char **assembler_opts = XOBFINISH (&opts_obstack, const char **);
    1797                 :            : 
    1798                 :         67 :   for (int i = 0; i < opts_count; i++)
    1799                 :            :     {
    1800                 :         64 :       obstack_grow (o, " '-Xassembler' ",
    1801                 :            :                     strlen (" '-Xassembler' "));
    1802                 :         64 :       const char *opt = assembler_opts[i];
    1803                 :         64 :       obstack_1grow (o, '\'');
    1804                 :         64 :       obstack_grow (o, opt, strlen (opt));
    1805                 :         64 :       obstack_1grow (o, '\'');
    1806                 :            :     }
    1807                 :          3 : }

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.