gcc/opts-common.c

   1 /* Command line option handling.
   2    Copyright (C) 2006, 2007, 2008, 2010, 2011 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 "flags.h"
  26 #include "diagnostic.h"
  27
  28 static void prune_options (struct cl_decoded_option **, unsigned int *);
  29
  30 /* Perform a binary search to find which option the command-line INPUT
  31    matches.  Returns its index in the option array, and
  32    OPT_SPECIAL_unknown on failure.
  33
  34    This routine is quite subtle.  A normal binary search is not good
  35    enough because some options can be suffixed with an argument, and
  36    multiple sub-matches can occur, e.g. input of "-pedantic" matching
  37    the initial substring of "-pedantic-errors".
  38
  39    A more complicated example is -gstabs.  It should match "-g" with
  40    an argument of "stabs".  Suppose, however, that the number and list
  41    of switches are such that the binary search tests "-gen-decls"
  42    before having tested "-g".  This doesn't match, and as "-gen-decls"
  43    is less than "-gstabs", it will become the lower bound of the
  44    binary search range, and "-g" will never be seen.  To resolve this
  45    issue, 'optc-gen.awk' makes "-gen-decls" point, via the back_chain member,
  46    to "-g" so that failed searches that end between "-gen-decls" and
  47    the lexicographically subsequent switch know to go back and see if
  48    "-g" causes a match (which it does in this example).
  49
  50    This search is done in such a way that the longest match for the
  51    front end in question wins.  If there is no match for the current
  52    front end, the longest match for a different front end is returned
  53    (or N_OPTS if none) and the caller emits an error message.  */
  54 size_t
  55 find_opt (const char *input, unsigned int lang_mask)
  56 {
  57   size_t mn, mn_orig, mx, md, opt_len;
  58   size_t match_wrong_lang;
  59   int comp;
  60
  61   mn = 0;
  62   mx = cl_options_count;
  63
  64   /* Find mn such this lexicographical inequality holds:
  65      cl_options[mn] <= input < cl_options[mn + 1].  */
  66   while (mx - mn > 1)
  67     {
  68       md = (mn + mx) / 2;
  69       opt_len = cl_options[md].opt_len;
  70       comp = strncmp (input, cl_options[md].opt_text + 1, opt_len);
  71
  72       if (comp < 0)
  73         mx = md;
  74       else
  75         mn = md;
  76     }
  77
  78   mn_orig = mn;
  79
  80   /* This is the switch that is the best match but for a different
  81      front end, or OPT_SPECIAL_unknown if there is no match at all.  */
  82   match_wrong_lang = OPT_SPECIAL_unknown;
  83
  84   /* Backtrace the chain of possible matches, returning the longest
  85      one, if any, that fits best.  With current GCC switches, this
  86      loop executes at most twice.  */
  87   do
  88     {
  89       const struct cl_option *opt = &cl_options[mn];
  90
  91       /* Is the input either an exact match or a prefix that takes a
  92          joined argument?  */
  93       if (!strncmp (input, opt->opt_text + 1, opt->opt_len)
  94           && (input[opt->opt_len] == '\0' || (opt->flags & CL_JOINED)))
  95         {
  96           /* If language is OK, return it.  */
  97           if (opt->flags & lang_mask)
  98             return mn;
  99
 100           /* If we haven't remembered a prior match, remember this
 101              one.  Any prior match is necessarily better.  */
 102           if (match_wrong_lang == OPT_SPECIAL_unknown)
 103             match_wrong_lang = mn;
 104         }
 105
 106       /* Try the next possibility.  This is cl_options_count if there
 107          are no more.  */
 108       mn = opt->back_chain;
 109     }
 110   while (mn != cl_options_count);
 111
 112   if (match_wrong_lang == OPT_SPECIAL_unknown && input[0] == '-')
 113     {
 114       /* Long options, starting "--", may be abbreviated if the
 115          abbreviation is unambiguous.  This only applies to options
 116          not taking a joined argument, and abbreviations of "--option"
 117          are permitted even if there is a variant "--option=".  */
 118       size_t mnc = mn_orig + 1;
 119       size_t cmp_len = strlen (input);
 120       while (mnc < cl_options_count
 121              && strncmp (input, cl_options[mnc].opt_text + 1, cmp_len) == 0)
 122         {
 123           /* Option matching this abbreviation.  OK if it is the first
 124              match and that does not take a joined argument, or the
 125              second match, taking a joined argument and with only '='
 126              added to the first match; otherwise considered
 127              ambiguous.  */
 128           if (mnc == mn_orig + 1
 129               && !(cl_options[mnc].flags & CL_JOINED))
 130             match_wrong_lang = mnc;
 131           else if (mnc == mn_orig + 2
 132                    && match_wrong_lang == mn_orig + 1
 133                    && (cl_options[mnc].flags & CL_JOINED)
 134                    && (cl_options[mnc].opt_len
 135                        == cl_options[mn_orig + 1].opt_len + 1)
 136                    && strncmp (cl_options[mnc].opt_text + 1,
 137                                cl_options[mn_orig + 1].opt_text + 1,
 138                                cl_options[mn_orig + 1].opt_len) == 0)
 139             ; /* OK, as long as there are no more matches.  */
 140           else
 141             return OPT_SPECIAL_unknown;
 142           mnc++;
 143         }
 144     }
 145
 146   /* Return the best wrong match, or OPT_SPECIAL_unknown if none.  */
 147   return match_wrong_lang;
 148 }
 149
 150 /* If ARG is a non-negative integer made up solely of digits, return its
 151    value, otherwise return -1.  */
 152
 153 int
 154 integral_argument (const char *arg)
 155 {
 156   const char *p = arg;
 157
 158   while (*p && ISDIGIT (*p))
 159     p++;
 160
 161   if (*p == '\0')
 162     return atoi (arg);
 163
 164   return -1;
 165 }
 166
 167 /* Return whether OPTION is OK for the language given by
 168    LANG_MASK.  */
 169 static bool
 170 option_ok_for_language (const struct cl_option *option,
 171                         unsigned int lang_mask)
 172 {
 173   if (!(option->flags & lang_mask))
 174     return false;
 175   else if ((option->flags & CL_TARGET)
 176            && (option->flags & (CL_LANG_ALL | CL_DRIVER))
 177            && !(option->flags & (lang_mask & ~CL_COMMON & ~CL_TARGET)))
 178     /* Complain for target flag language mismatches if any languages
 179        are specified.  */
 180     return false;
 181   return true;
 182 }
 183
 184 /* Return whether ENUM_ARG is OK for the language given by
 185    LANG_MASK.  */
 186
 187 static bool
 188 enum_arg_ok_for_language (const struct cl_enum_arg *enum_arg,
 189                           unsigned int lang_mask)
 190 {
 191   return (lang_mask & CL_DRIVER) || !(enum_arg->flags & CL_ENUM_DRIVER_ONLY);
 192 }
 193
 194 /* Look up ARG in ENUM_ARGS for language LANG_MASK, returning true and
 195    storing the value in *VALUE if found, and returning false without
 196    modifying *VALUE if not found.  */
 197
 198 static bool
 199 enum_arg_to_value (const struct cl_enum_arg *enum_args,
 200                    const char *arg, int *value, unsigned int lang_mask)
 201 {
 202   unsigned int i;
 203
 204   for (i = 0; enum_args[i].arg != NULL; i++)
 205     if (strcmp (arg, enum_args[i].arg) == 0
 206         && enum_arg_ok_for_language (&enum_args[i], lang_mask))
 207       {
 208         *value = enum_args[i].value;
 209         return true;
 210       }
 211
 212   return false;
 213 }
 214
 215 /* Look up ARG in the enum used by option OPT_INDEX for language
 216    LANG_MASK, returning true and storing the value in *VALUE if found,
 217    and returning false without modifying *VALUE if not found.  */
 218
 219 bool
 220 opt_enum_arg_to_value (size_t opt_index, const char *arg, int *value,
 221                        unsigned int lang_mask)
 222 {
 223   const struct cl_option *option = &cl_options[opt_index];
 224
 225   gcc_assert (option->var_type == CLVC_ENUM);
 226
 227   return enum_arg_to_value (cl_enums[option->var_enum].values, arg,
 228                             value, lang_mask);
 229 }
 230
 231 /* Look of VALUE in ENUM_ARGS for language LANG_MASK and store the
 232    corresponding string in *ARGP, returning true if the found string
 233    was marked as canonical, false otherwise.  If VALUE is not found
 234    (which may be the case for uninitialized values if the relevant
 235    option has not been passed), set *ARGP to NULL and return
 236    false.  */
 237
 238 bool
 239 enum_value_to_arg (const struct cl_enum_arg *enum_args,
 240                    const char **argp, int value, unsigned int lang_mask)
 241 {
 242   unsigned int i;
 243
 244   for (i = 0; enum_args[i].arg != NULL; i++)
 245     if (enum_args[i].value == value
 246         && (enum_args[i].flags & CL_ENUM_CANONICAL)
 247         && enum_arg_ok_for_language (&enum_args[i], lang_mask))
 248       {
 249         *argp = enum_args[i].arg;
 250         return true;
 251       }
 252
 253   for (i = 0; enum_args[i].arg != NULL; i++)
 254     if (enum_args[i].value == value
 255         && enum_arg_ok_for_language (&enum_args[i], lang_mask))
 256       {
 257         *argp = enum_args[i].arg;
 258         return false;
 259       }
 260
 261   *argp = NULL;
 262   return false;
 263 }
 264
 265 /* Fill in the canonical option part of *DECODED with an option
 266    described by OPT_INDEX, ARG and VALUE.  */
 267
 268 static void
 269 generate_canonical_option (size_t opt_index, const char *arg, int value,
 270                            struct cl_decoded_option *decoded)
 271 {
 272   const struct cl_option *option = &cl_options[opt_index];
 273   const char *opt_text = option->opt_text;
 274
 275   if (value == 0
 276       && !option->cl_reject_negative
 277       && (opt_text[1] == 'W' || opt_text[1] == 'f' || opt_text[1] == 'm'))
 278     {
 279       char *t = XNEWVEC (char, option->opt_len + 5);
 280       t[0] = '-';
 281       t[1] = opt_text[1];
 282       t[2] = 'n';
 283       t[3] = 'o';
 284       t[4] = '-';
 285       memcpy (t + 5, opt_text + 2, option->opt_len);
 286       opt_text = t;
 287     }
 288
 289   decoded->canonical_option[2] = NULL;
 290   decoded->canonical_option[3] = NULL;
 291
 292   if (arg)
 293     {
 294       if ((option->flags & CL_SEPARATE)
 295           && !option->cl_separate_alias)
 296         {
 297           decoded->canonical_option[0] = opt_text;
 298           decoded->canonical_option[1] = arg;
 299           decoded->canonical_option_num_elements = 2;
 300         }
 301       else
 302         {
 303           gcc_assert (option->flags & CL_JOINED);
 304           decoded->canonical_option[0] = concat (opt_text, arg, NULL);
 305           decoded->canonical_option[1] = NULL;
 306           decoded->canonical_option_num_elements = 1;
 307           if (opt_text != option->opt_text)
 308             free (CONST_CAST (char *, opt_text));
 309         }
 310     }
 311   else
 312     {
 313       decoded->canonical_option[0] = opt_text;
 314       decoded->canonical_option[1] = NULL;
 315       decoded->canonical_option_num_elements = 1;
 316     }
 317 }
 318
 319 /* Structure describing mappings from options on the command line to
 320    options to look up with find_opt.  */
 321 struct option_map
 322 {
 323   /* Prefix of the option on the command line.  */
 324   const char *opt0;
 325   /* If two argv elements are considered to be merged into one option,
 326      prefix for the second element, otherwise NULL.  */
 327   const char *opt1;
 328   /* The new prefix to map to.  */
 329   const char *new_prefix;
 330   /* Whether at least one character is needed following opt1 or opt0
 331      for this mapping to be used.  (--optimize= is valid for -O, but
 332      --warn- is not valid for -W.)  */
 333   bool another_char_needed;
 334   /* Whether the original option is a negated form of the option
 335      resulting from this map.  */
 336   bool negated;
 337 };
 338 static const struct option_map option_map[] =
 339   {
 340     { "-Wno-", NULL, "-W", false, true },
 341     { "-fno-", NULL, "-f", false, true },
 342     { "-mno-", NULL, "-m", false, true },
 343     { "--debug=", NULL, "-g", false, false },
 344     { "--machine-", NULL, "-m", true, false },
 345     { "--machine-no-", NULL, "-m", false, true },
 346     { "--machine=", NULL, "-m", false, false },
 347     { "--machine=no-", NULL, "-m", false, true },
 348     { "--machine", "", "-m", false, false },
 349     { "--machine", "no-", "-m", false, true },
 350     { "--optimize=", NULL, "-O", false, false },
 351     { "--std=", NULL, "-std=", false, false },
 352     { "--std", "", "-std=", false, false },
 353     { "--warn-", NULL, "-W", true, false },
 354     { "--warn-no-", NULL, "-W", false, true },
 355     { "--", NULL, "-f", true, false },
 356     { "--no-", NULL, "-f", false, true }
 357   };
 358
 359 /* Decode the switch beginning at ARGV for the language indicated by
 360    LANG_MASK (including CL_COMMON and CL_TARGET if applicable), into
 361    the structure *DECODED.  Returns the number of switches
 362    consumed.  */
 363
 364 static unsigned int
 365 decode_cmdline_option (const char **argv, unsigned int lang_mask,
 366                        struct cl_decoded_option *decoded)
 367 {
 368   size_t opt_index;
 369   const char *arg = 0;
 370   int value = 1;
 371   unsigned int result = 1, i, extra_args, separate_args = 0;
 372   int adjust_len = 0;
 373   size_t total_len;
 374   char *p;
 375   const struct cl_option *option;
 376   int errors = 0;
 377   const char *warn_message = NULL;
 378   bool separate_arg_flag;
 379   bool joined_arg_flag;
 380   bool have_separate_arg = false;
 381
 382   extra_args = 0;
 383
 384   opt_index = find_opt (argv[0] + 1, lang_mask);
 385   i = 0;
 386   while (opt_index == OPT_SPECIAL_unknown
 387          && i < ARRAY_SIZE (option_map))
 388     {
 389       const char *opt0 = option_map[i].opt0;
 390       const char *opt1 = option_map[i].opt1;
 391       const char *new_prefix = option_map[i].new_prefix;
 392       bool another_char_needed = option_map[i].another_char_needed;
 393       size_t opt0_len = strlen (opt0);
 394       size_t opt1_len = (opt1 == NULL ? 0 : strlen (opt1));
 395       size_t optn_len = (opt1 == NULL ? opt0_len : opt1_len);
 396       size_t new_prefix_len = strlen (new_prefix);
 397
 398       extra_args = (opt1 == NULL ? 0 : 1);
 399       value = !option_map[i].negated;
 400
 401       if (strncmp (argv[0], opt0, opt0_len) == 0
 402           && (opt1 == NULL
 403               || (argv[1] != NULL && strncmp (argv[1], opt1, opt1_len) == 0))
 404           && (!another_char_needed
 405               || argv[extra_args][optn_len] != 0))
 406         {
 407           size_t arglen = strlen (argv[extra_args]);
 408           char *dup;
 409
 410           adjust_len = (int) optn_len - (int) new_prefix_len;
 411           dup = XNEWVEC (char, arglen + 1 - adjust_len);
 412           memcpy (dup, new_prefix, new_prefix_len);
 413           memcpy (dup + new_prefix_len, argv[extra_args] + optn_len,
 414                   arglen - optn_len + 1);
 415           opt_index = find_opt (dup + 1, lang_mask);
 416           free (dup);
 417         }
 418       i++;
 419     }
 420
 421   if (opt_index == OPT_SPECIAL_unknown)
 422     {
 423       arg = argv[0];
 424       extra_args = 0;
 425       value = 1;
 426       goto done;
 427     }
 428
 429   option = &cl_options[opt_index];
 430
 431   /* Reject negative form of switches that don't take negatives as
 432      unrecognized.  */
 433   if (!value && option->cl_reject_negative)
 434     {
 435       opt_index = OPT_SPECIAL_unknown;
 436       errors |= CL_ERR_NEGATIVE;
 437       arg = argv[0];
 438       goto done;
 439     }
 440
 441   result = extra_args + 1;
 442   warn_message = option->warn_message;
 443
 444   /* Check to see if the option is disabled for this configuration.  */
 445   if (option->cl_disabled)
 446     errors |= CL_ERR_DISABLED;
 447
 448   /* Determine whether there may be a separate argument based on
 449      whether this option is being processed for the driver, and, if
 450      so, how many such arguments.  */
 451   separate_arg_flag = ((option->flags & CL_SEPARATE)
 452                        && !(option->cl_no_driver_arg
 453                             && (lang_mask & CL_DRIVER)));
 454   separate_args = (separate_arg_flag
 455                    ? option->cl_separate_nargs + 1
 456                    : 0);
 457   joined_arg_flag = (option->flags & CL_JOINED) != 0;
 458
 459   /* Sort out any argument the switch takes.  */
 460   if (joined_arg_flag)
 461     {
 462       /* Have arg point to the original switch.  This is because
 463          some code, such as disable_builtin_function, expects its
 464          argument to be persistent until the program exits.  */
 465       arg = argv[extra_args] + cl_options[opt_index].opt_len + 1 + adjust_len;
 466
 467       if (*arg == '\0' && !option->cl_missing_ok)
 468         {
 469           if (separate_arg_flag)
 470             {
 471               arg = argv[extra_args + 1];
 472               result = extra_args + 2;
 473               if (arg == NULL)
 474                 result = extra_args + 1;
 475               else
 476                 have_separate_arg = true;
 477             }
 478           else
 479             /* Missing argument.  */
 480             arg = NULL;
 481         }
 482     }
 483   else if (separate_arg_flag)
 484     {
 485       arg = argv[extra_args + 1];
 486       for (i = 0; i < separate_args; i++)
 487         if (argv[extra_args + 1 + i] == NULL)
 488           {
 489             errors |= CL_ERR_MISSING_ARG;
 490             break;
 491           }
 492       result = extra_args + 1 + i;
 493       if (arg != NULL)
 494         have_separate_arg = true;
 495     }
 496
 497   if (arg == NULL && (separate_arg_flag || joined_arg_flag))
 498     errors |= CL_ERR_MISSING_ARG;
 499
 500   /* Is this option an alias (or an ignored option, marked as an alias
 501      of OPT_SPECIAL_ignore)?  */
 502   if (option->alias_target != N_OPTS
 503       && (!option->cl_separate_alias || have_separate_arg))
 504     {
 505       size_t new_opt_index = option->alias_target;
 506
 507       if (new_opt_index == OPT_SPECIAL_ignore)
 508         {
 509           gcc_assert (option->alias_arg == NULL);
 510           gcc_assert (option->neg_alias_arg == NULL);
 511           opt_index = new_opt_index;
 512           arg = NULL;
 513           value = 1;
 514         }
 515       else
 516         {
 517           const struct cl_option *new_option = &cl_options[new_opt_index];
 518
 519           /* The new option must not be an alias itself.  */
 520           gcc_assert (new_option->alias_target == N_OPTS
 521                       || new_option->cl_separate_alias);
 522
 523           if (option->neg_alias_arg)
 524             {
 525               gcc_assert (option->alias_arg != NULL);
 526               gcc_assert (arg == NULL);
 527               gcc_assert (!option->cl_negative_alias);
 528               if (value)
 529                 arg = option->alias_arg;
 530               else
 531                 arg = option->neg_alias_arg;
 532               value = 1;
 533             }
 534           else if (option->alias_arg)
 535             {
 536               gcc_assert (value == 1);
 537               gcc_assert (arg == NULL);
 538               gcc_assert (!option->cl_negative_alias);
 539               arg = option->alias_arg;
 540             }
 541
 542           if (option->cl_negative_alias)
 543             value = !value;
 544
 545           opt_index = new_opt_index;
 546           option = new_option;
 547
 548           if (value == 0)
 549             gcc_assert (!option->cl_reject_negative);
 550
 551           /* Recompute what arguments are allowed.  */
 552           separate_arg_flag = ((option->flags & CL_SEPARATE)
 553                                && !(option->cl_no_driver_arg
 554                                     && (lang_mask & CL_DRIVER)));
 555           joined_arg_flag = (option->flags & CL_JOINED) != 0;
 556
 557           if (separate_args > 1 || option->cl_separate_nargs)
 558             gcc_assert (separate_args
 559                         == (unsigned int) option->cl_separate_nargs + 1);
 560
 561           if (!(errors & CL_ERR_MISSING_ARG))
 562             {
 563               if (separate_arg_flag || joined_arg_flag)
 564                 {
 565                   if (option->cl_missing_ok && arg == NULL)
 566                     arg = "";
 567                   gcc_assert (arg != NULL);
 568                 }
 569               else
 570                 gcc_assert (arg == NULL);
 571             }
 572
 573           /* Recheck for warnings and disabled options.  */
 574           if (option->warn_message)
 575             {
 576               gcc_assert (warn_message == NULL);
 577               warn_message = option->warn_message;
 578             }
 579           if (option->cl_disabled)
 580             errors |= CL_ERR_DISABLED;
 581         }
 582     }
 583
 584   /* Check if this is a switch for a different front end.  */
 585   if (!option_ok_for_language (option, lang_mask))
 586     errors |= CL_ERR_WRONG_LANG;
 587
 588   /* Convert the argument to lowercase if appropriate.  */
 589   if (arg && option->cl_tolower)
 590     {
 591       size_t j;
 592       size_t len = strlen (arg);
 593       char *arg_lower = XNEWVEC (char, len + 1);
 594
 595       for (j = 0; j < len; j++)
 596         arg_lower[j] = TOLOWER ((unsigned char) arg[j]);
 597       arg_lower[len] = 0;
 598       arg = arg_lower;
 599     }
 600
 601   /* If the switch takes an integer, convert it.  */
 602   if (arg && option->cl_uinteger)
 603     {
 604       value = integral_argument (arg);
 605       if (value == -1)
 606         errors |= CL_ERR_UINT_ARG;
 607     }
 608
 609   /* If the switch takes an enumerated argument, convert it.  */
 610   if (arg && (option->var_type == CLVC_ENUM))
 611     {
 612       const struct cl_enum *e = &cl_enums[option->var_enum];
 613
 614       gcc_assert (value == 1);
 615       if (enum_arg_to_value (e->values, arg, &value, lang_mask))
 616         {
 617           const char *carg = NULL;
 618
 619           if (enum_value_to_arg (e->values, &carg, value, lang_mask))
 620             arg = carg;
 621           gcc_assert (carg != NULL);
 622         }
 623       else
 624         errors |= CL_ERR_ENUM_ARG;
 625     }
 626
 627  done:
 628   decoded->opt_index = opt_index;
 629   decoded->arg = arg;
 630   decoded->value = value;
 631   decoded->errors = errors;
 632   decoded->warn_message = warn_message;
 633
 634   if (opt_index == OPT_SPECIAL_unknown)
 635     gcc_assert (result == 1);
 636
 637   gcc_assert (result >= 1 && result <= ARRAY_SIZE (decoded->canonical_option));
 638   decoded->canonical_option_num_elements = result;
 639   total_len = 0;
 640   for (i = 0; i < ARRAY_SIZE (decoded->canonical_option); i++)
 641     {
 642       if (i < result)
 643         {
 644           size_t len;
 645           if (opt_index == OPT_SPECIAL_unknown)
 646             decoded->canonical_option[i] = argv[i];
 647           else
 648             decoded->canonical_option[i] = NULL;
 649           len = strlen (argv[i]);
 650           /* If the argument is an empty string, we will print it as "" in
 651              orig_option_with_args_text.  */
 652           total_len += (len != 0 ? len : 2) + 1;
 653         }
 654       else
 655         decoded->canonical_option[i] = NULL;
 656     }
 657   if (opt_index != OPT_SPECIAL_unknown && opt_index != OPT_SPECIAL_ignore)
 658     {
 659       generate_canonical_option (opt_index, arg, value, decoded);
 660       if (separate_args > 1)
 661         {
 662           for (i = 0; i < separate_args; i++)
 663             {
 664               if (argv[extra_args + 1 + i] == NULL)
 665                   break;
 666               else
 667                 decoded->canonical_option[1 + i] = argv[extra_args + 1 + i];
 668             }
 669           gcc_assert (result == 1 + i);
 670           decoded->canonical_option_num_elements = result;
 671         }
 672     }
 673   decoded->orig_option_with_args_text = p = XNEWVEC (char, total_len);
 674   for (i = 0; i < result; i++)
 675     {
 676       size_t len = strlen (argv[i]);
 677
 678       /* Print the empty string verbally.  */
 679       if (len == 0)
 680         {
 681           *p++ = '"';
 682           *p++ = '"';
 683         }
 684       else
 685         memcpy (p, argv[i], len);
 686       p += len;
 687       if (i == result - 1)
 688         *p++ = 0;
 689       else
 690         *p++ = ' ';
 691     }
 692
 693   return result;
 694 }
 695
 696 /* Decode command-line options (ARGC and ARGV being the arguments of
 697    main) into an array, setting *DECODED_OPTIONS to a pointer to that
 698    array and *DECODED_OPTIONS_COUNT to the number of entries in the
 699    array.  The first entry in the array is always one for the program
 700    name (OPT_SPECIAL_program_name).  LANG_MASK indicates the language
 701    flags applicable for decoding (including CL_COMMON and CL_TARGET if
 702    those options should be considered applicable).  Do not produce any
 703    diagnostics or set state outside of these variables.  */
 704
 705 void
 706 decode_cmdline_options_to_array (unsigned int argc, const char **argv,
 707                                  unsigned int lang_mask,
 708                                  struct cl_decoded_option **decoded_options,
 709                                  unsigned int *decoded_options_count)
 710 {
 711   unsigned int n, i;
 712   struct cl_decoded_option *opt_array;
 713   unsigned int num_decoded_options;
 714
 715   opt_array = XNEWVEC (struct cl_decoded_option, argc);
 716
 717   opt_array[0].opt_index = OPT_SPECIAL_program_name;
 718   opt_array[0].warn_message = NULL;
 719   opt_array[0].arg = argv[0];
 720   opt_array[0].orig_option_with_args_text = argv[0];
 721   opt_array[0].canonical_option_num_elements = 1;
 722   opt_array[0].canonical_option[0] = argv[0];
 723   opt_array[0].canonical_option[1] = NULL;
 724   opt_array[0].canonical_option[2] = NULL;
 725   opt_array[0].canonical_option[3] = NULL;
 726   opt_array[0].value = 1;
 727   opt_array[0].errors = 0;
 728   num_decoded_options = 1;
 729
 730   for (i = 1; i < argc; i += n)
 731     {
 732       const char *opt = argv[i];
 733
 734       /* Interpret "-" or a non-switch as a file name.  */
 735       if (opt[0] != '-' || opt[1] == '\0')
 736         {
 737           generate_option_input_file (opt, &opt_array[num_decoded_options]);
 738           num_decoded_options++;
 739           n = 1;
 740           continue;
 741         }
 742
 743       n = decode_cmdline_option (argv + i, lang_mask,
 744                                  &opt_array[num_decoded_options]);
 745       num_decoded_options++;
 746     }
 747
 748   *decoded_options = opt_array;
 749   *decoded_options_count = num_decoded_options;
 750   prune_options (decoded_options, decoded_options_count);
 751 }
 752
 753 /* Return true if NEXT_OPT_IDX cancels OPT_IDX.  Return false if the
 754    next one is the same as ORIG_NEXT_OPT_IDX.  */
 755
 756 static bool
 757 cancel_option (int opt_idx, int next_opt_idx, int orig_next_opt_idx)
 758 {
 759   /* An option can be canceled by the same option or an option with
 760      Negative.  */
 761   if (cl_options [next_opt_idx].neg_index == opt_idx)
 762     return true;
 763
 764   if (cl_options [next_opt_idx].neg_index != orig_next_opt_idx)
 765     return cancel_option (opt_idx, cl_options [next_opt_idx].neg_index,
 766                           orig_next_opt_idx);
 767
 768   return false;
 769 }
 770
 771 /* Filter out options canceled by the ones after them.  */
 772
 773 static void
 774 prune_options (struct cl_decoded_option **decoded_options,
 775                unsigned int *decoded_options_count)
 776 {
 777   unsigned int old_decoded_options_count = *decoded_options_count;
 778   struct cl_decoded_option *old_decoded_options = *decoded_options;
 779   unsigned int new_decoded_options_count;
 780   struct cl_decoded_option *new_decoded_options
 781     = XNEWVEC (struct cl_decoded_option, old_decoded_options_count);
 782   unsigned int i;
 783   const struct cl_option *option;
 784
 785   /* Remove arguments which are negated by others after them.  */
 786   new_decoded_options_count = 0;
 787   for (i = 0; i < old_decoded_options_count; i++)
 788     {
 789       unsigned int j, opt_idx, next_opt_idx;
 790
 791       if (old_decoded_options[i].errors & ~CL_ERR_WRONG_LANG)
 792         goto keep;
 793
 794       opt_idx = old_decoded_options[i].opt_index;
 795       switch (opt_idx)
 796         {
 797         case OPT_SPECIAL_unknown:
 798         case OPT_SPECIAL_ignore:
 799         case OPT_SPECIAL_program_name:
 800         case OPT_SPECIAL_input_file:
 801           goto keep;
 802
 803         default:
 804           gcc_assert (opt_idx < cl_options_count);
 805           option = &cl_options[opt_idx];
 806           if (option->neg_index < 0)
 807             goto keep;
 808
 809           /* Skip joined switches.  */
 810           if ((option->flags & CL_JOINED))
 811             goto keep;
 812
 813           for (j = i + 1; j < old_decoded_options_count; j++)
 814             {
 815               if (old_decoded_options[j].errors & ~CL_ERR_WRONG_LANG)
 816                 continue;
 817               next_opt_idx = old_decoded_options[j].opt_index;
 818               if (next_opt_idx >= cl_options_count)
 819                 continue;
 820               if (cl_options[next_opt_idx].neg_index < 0)
 821                 continue;
 822               if ((cl_options[next_opt_idx].flags & CL_JOINED))
 823                   continue;
 824               if (cancel_option (opt_idx, next_opt_idx, next_opt_idx))
 825                 break;
 826             }
 827           if (j == old_decoded_options_count)
 828             {
 829 keep:
 830               new_decoded_options[new_decoded_options_count]
 831                 = old_decoded_options[i];
 832               new_decoded_options_count++;
 833             }
 834           break;
 835         }
 836     }
 837
 838   free (old_decoded_options);
 839   new_decoded_options = XRESIZEVEC (struct cl_decoded_option,
 840                                     new_decoded_options,
 841                                     new_decoded_options_count);
 842   *decoded_options = new_decoded_options;
 843   *decoded_options_count = new_decoded_options_count;
 844 }
 845
 846 /* Handle option DECODED for the language indicated by LANG_MASK,
 847    using the handlers in HANDLERS and setting fields in OPTS and
 848    OPTS_SET.  KIND is the diagnostic_t if this is a diagnostics
 849    option, DK_UNSPECIFIED otherwise, and LOC is the location of the
 850    option for options from the source file, UNKNOWN_LOCATION
 851    otherwise.  GENERATED_P is true for an option generated as part of
 852    processing another option or otherwise generated internally, false
 853    for one explicitly passed by the user.  Returns false if the switch
 854    was invalid.  DC is the diagnostic context for options affecting
 855    diagnostics state, or NULL.  */
 856
 857 static bool
 858 handle_option (struct gcc_options *opts,
 859                struct gcc_options *opts_set,
 860                const struct cl_decoded_option *decoded,
 861                unsigned int lang_mask, int kind, location_t loc,
 862                const struct cl_option_handlers *handlers,
 863                bool generated_p, diagnostic_context *dc)
 864 {
 865   size_t opt_index = decoded->opt_index;
 866   const char *arg = decoded->arg;
 867   int value = decoded->value;
 868   const struct cl_option *option = &cl_options[opt_index];
 869   void *flag_var = option_flag_var (opt_index, opts);
 870   size_t i;
 871
 872   if (flag_var)
 873     set_option (opts, (generated_p ? NULL : opts_set),
 874                 opt_index, value, arg, kind, loc, dc);
 875
 876   for (i = 0; i < handlers->num_handlers; i++)
 877     if (option->flags & handlers->handlers[i].mask)
 878       {
 879         if (!handlers->handlers[i].handler (opts, opts_set, decoded,
 880                                             lang_mask, kind, loc,
 881                                             handlers, dc))
 882           return false;
 883       }
 884
 885   return true;
 886 }
 887
 888 /* Like handle_option, but OPT_INDEX, ARG and VALUE describe the
 889    option instead of DECODED.  This is used for callbacks when one
 890    option implies another instead of an option being decoded from the
 891    command line.  */
 892
 893 bool
 894 handle_generated_option (struct gcc_options *opts,
 895                          struct gcc_options *opts_set,
 896                          size_t opt_index, const char *arg, int value,
 897                          unsigned int lang_mask, int kind, location_t loc,
 898                          const struct cl_option_handlers *handlers,
 899                          diagnostic_context *dc)
 900 {
 901   struct cl_decoded_option decoded;
 902
 903   generate_option (opt_index, arg, value, lang_mask, &decoded);
 904   return handle_option (opts, opts_set, &decoded, lang_mask, kind, loc,
 905                         handlers, true, dc);
 906 }
 907
 908 /* Fill in *DECODED with an option described by OPT_INDEX, ARG and
 909    VALUE for a front end using LANG_MASK.  This is used when the
 910    compiler generates options internally.  */
 911
 912 void
 913 generate_option (size_t opt_index, const char *arg, int value,
 914                  unsigned int lang_mask, struct cl_decoded_option *decoded)
 915 {
 916   const struct cl_option *option = &cl_options[opt_index];
 917
 918   decoded->opt_index = opt_index;
 919   decoded->warn_message = NULL;
 920   decoded->arg = arg;
 921   decoded->value = value;
 922   decoded->errors = (option_ok_for_language (option, lang_mask)
 923                      ? 0
 924                      : CL_ERR_WRONG_LANG);
 925
 926   generate_canonical_option (opt_index, arg, value, decoded);
 927   switch (decoded->canonical_option_num_elements)
 928     {
 929     case 1:
 930       decoded->orig_option_with_args_text = decoded->canonical_option[0];
 931       break;
 932
 933     case 2:
 934       decoded->orig_option_with_args_text
 935         = concat (decoded->canonical_option[0], " ",
 936                   decoded->canonical_option[1], NULL);
 937       break;
 938
 939     default:
 940       gcc_unreachable ();
 941     }
 942 }
 943
 944 /* Fill in *DECODED with an option for input file FILE.  */
 945
 946 void
 947 generate_option_input_file (const char *file,
 948                             struct cl_decoded_option *decoded)
 949 {
 950   decoded->opt_index = OPT_SPECIAL_input_file;
 951   decoded->warn_message = NULL;
 952   decoded->arg = file;
 953   decoded->orig_option_with_args_text = file;
 954   decoded->canonical_option_num_elements = 1;
 955   decoded->canonical_option[0] = file;
 956   decoded->canonical_option[1] = NULL;
 957   decoded->canonical_option[2] = NULL;
 958   decoded->canonical_option[3] = NULL;
 959   decoded->value = 1;
 960   decoded->errors = 0;
 961 }
 962
 963 /* Handle the switch DECODED (location LOC) for the language indicated
 964    by LANG_MASK, using the handlers in *HANDLERS and setting fields in
 965    OPTS and OPTS_SET and using diagnostic context DC (if not NULL) for
 966    diagnostic options.  */
 967
 968 void
 969 read_cmdline_option (struct gcc_options *opts,
 970                      struct gcc_options *opts_set,
 971                      struct cl_decoded_option *decoded,
 972                      location_t loc,
 973                      unsigned int lang_mask,
 974                      const struct cl_option_handlers *handlers,
 975                      diagnostic_context *dc)
 976 {
 977   const struct cl_option *option;
 978   const char *opt = decoded->orig_option_with_args_text;
 979
 980   if (decoded->warn_message)
 981     warning_at (loc, 0, decoded->warn_message, opt);
 982
 983   if (decoded->opt_index == OPT_SPECIAL_unknown)
 984     {
 985       if (handlers->unknown_option_callback (decoded))
 986         error_at (loc, "unrecognized command line option %qs", decoded->arg);
 987       return;
 988     }
 989
 990   if (decoded->opt_index == OPT_SPECIAL_ignore)
 991     return;
 992
 993   option = &cl_options[decoded->opt_index];
 994
 995   if (decoded->errors & CL_ERR_DISABLED)
 996     {
 997       error_at (loc, "command line option %qs"
 998                 " is not supported by this configuration", opt);
 999       return;
1000     }
1001
1002   if (decoded->errors & CL_ERR_MISSING_ARG)
1003     {
1004       if (option->missing_argument_error)
1005         error_at (loc, option->missing_argument_error, opt);
1006       else
1007         error_at (loc, "missing argument to %qs", opt);
1008       return;
1009     }
1010
1011   if (decoded->errors & CL_ERR_UINT_ARG)
1012     {
1013       error_at (loc, "argument to %qs should be a non-negative integer",
1014                 option->opt_text);
1015       return;
1016     }
1017
1018   if (decoded->errors & CL_ERR_ENUM_ARG)
1019     {
1020       const struct cl_enum *e = &cl_enums[option->var_enum];
1021       unsigned int i;
1022       size_t len;
1023       char *s, *p;
1024
1025       if (e->unknown_error)
1026         error_at (loc, e->unknown_error, decoded->arg);
1027       else
1028         error_at (loc, "unrecognized argument in option %qs", opt);
1029
1030       len = 0;
1031       for (i = 0; e->values[i].arg != NULL; i++)
1032         len += strlen (e->values[i].arg) + 1;
1033
1034       s = XALLOCAVEC (char, len);
1035       p = s;
1036       for (i = 0; e->values[i].arg != NULL; i++)
1037         {
1038           size_t arglen = strlen (e->values[i].arg);
1039           memcpy (p, e->values[i].arg, arglen);
1040           p[arglen] = ' ';
1041           p += arglen + 1;
1042         }
1043       p[-1] = 0;
1044       inform (loc, "valid arguments to %qs are: %s", option->opt_text, s);
1045       return;
1046     }
1047
1048   if (decoded->errors & CL_ERR_WRONG_LANG)
1049     {
1050       handlers->wrong_lang_callback (decoded, lang_mask);
1051       return;
1052     }
1053
1054   gcc_assert (!decoded->errors);
1055
1056   if (!handle_option (opts, opts_set, decoded, lang_mask, DK_UNSPECIFIED,
1057                       loc, handlers, false, dc))
1058     error_at (loc, "unrecognized command line option %qs", opt);
1059 }
1060
1061 /* Set any field in OPTS, and OPTS_SET if not NULL, for option
1062    OPT_INDEX according to VALUE and ARG, diagnostic kind KIND,
1063    location LOC, using diagnostic context DC if not NULL for
1064    diagnostic classification.  */
1065
1066 void
1067 set_option (struct gcc_options *opts, struct gcc_options *opts_set,
1068             int opt_index, int value, const char *arg, int kind,
1069             location_t loc, diagnostic_context *dc)
1070 {
1071   const struct cl_option *option = &cl_options[opt_index];
1072   void *flag_var = option_flag_var (opt_index, opts);
1073   void *set_flag_var = NULL;
1074
1075   if (!flag_var)
1076     return;
1077
1078   if (opts_set != NULL)
1079     set_flag_var = option_flag_var (opt_index, opts_set);
1080
1081   switch (option->var_type)
1082     {
1083     case CLVC_BOOLEAN:
1084         *(int *) flag_var = value;
1085         if (set_flag_var)
1086           *(int *) set_flag_var = 1;
1087         break;
1088
1089     case CLVC_EQUAL:
1090         if (option->cl_host_wide_int)
1091           *(HOST_WIDE_INT *) flag_var = (value
1092                                          ? option->var_value
1093                                          : !option->var_value);
1094         else
1095           *(int *) flag_var = (value
1096                                ? option->var_value
1097                                : !option->var_value);
1098         if (set_flag_var)
1099           *(int *) set_flag_var = 1;
1100         break;
1101
1102     case CLVC_BIT_CLEAR:
1103     case CLVC_BIT_SET:
1104         if ((value != 0) == (option->var_type == CLVC_BIT_SET))
1105           {
1106             if (option->cl_host_wide_int)
1107               *(HOST_WIDE_INT *) flag_var |= option->var_value;
1108             else
1109               *(int *) flag_var |= option->var_value;
1110           }
1111         else
1112           {
1113             if (option->cl_host_wide_int)
1114               *(HOST_WIDE_INT *) flag_var &= ~option->var_value;
1115             else
1116               *(int *) flag_var &= ~option->var_value;
1117           }
1118         if (set_flag_var)
1119           {
1120             if (option->cl_host_wide_int)
1121               *(HOST_WIDE_INT *) set_flag_var |= option->var_value;
1122             else
1123               *(int *) set_flag_var |= option->var_value;
1124           }
1125         break;
1126
1127     case CLVC_STRING:
1128         *(const char **) flag_var = arg;
1129         if (set_flag_var)
1130           *(const char **) set_flag_var = "";
1131         break;
1132
1133     case CLVC_ENUM:
1134       {
1135         const struct cl_enum *e = &cl_enums[option->var_enum];
1136
1137         e->set (flag_var, value);
1138         if (set_flag_var)
1139           e->set (set_flag_var, 1);
1140       }
1141       break;
1142
1143     case CLVC_DEFER:
1144         {
1145           VEC(cl_deferred_option,heap) *vec
1146             = (VEC(cl_deferred_option,heap) *) *(void **) flag_var;
1147           cl_deferred_option *p;
1148
1149           p = VEC_safe_push (cl_deferred_option, heap, vec, NULL);
1150           p->opt_index = opt_index;
1151           p->arg = arg;
1152           p->value = value;
1153           *(void **) flag_var = vec;
1154           if (set_flag_var)
1155             *(void **) set_flag_var = vec;
1156         }
1157         break;
1158     }
1159
1160   if ((diagnostic_t) kind != DK_UNSPECIFIED
1161       && dc != NULL)
1162     diagnostic_classify_diagnostic (dc, opt_index, (diagnostic_t) kind, loc);
1163 }
1164
1165 /* Return the address of the flag variable for option OPT_INDEX in
1166    options structure OPTS, or NULL if there is no flag variable.  */
1167
1168 void *
1169 option_flag_var (int opt_index, struct gcc_options *opts)
1170 {
1171   const struct cl_option *option = &cl_options[opt_index];
1172
1173   if (option->flag_var_offset == (unsigned short) -1)
1174     return NULL;
1175   return (void *)(((char *) opts) + option->flag_var_offset);
1176 }
1177
1178 /* Return 1 if option OPT_IDX is enabled in OPTS, 0 if it is disabled,
1179    or -1 if it isn't a simple on-off switch.  */
1180
1181 int
1182 option_enabled (int opt_idx, void *opts)
1183 {
1184   const struct cl_option *option = &(cl_options[opt_idx]);
1185   struct gcc_options *optsg = (struct gcc_options *) opts;
1186   void *flag_var = option_flag_var (opt_idx, optsg);
1187
1188   if (flag_var)
1189     switch (option->var_type)
1190       {
1191       case CLVC_BOOLEAN:
1192         return *(int *) flag_var != 0;
1193
1194       case CLVC_EQUAL:
1195         if (option->cl_host_wide_int)
1196           return *(HOST_WIDE_INT *) flag_var == option->var_value;
1197         else
1198           return *(int *) flag_var == option->var_value;
1199
1200       case CLVC_BIT_CLEAR:
1201         if (option->cl_host_wide_int)
1202           return (*(HOST_WIDE_INT *) flag_var & option->var_value) == 0;
1203         else
1204           return (*(int *) flag_var & option->var_value) == 0;
1205
1206       case CLVC_BIT_SET:
1207         if (option->cl_host_wide_int)
1208           return (*(HOST_WIDE_INT *) flag_var & option->var_value) != 0;
1209         else
1210           return (*(int *) flag_var & option->var_value) != 0;
1211
1212       case CLVC_STRING:
1213       case CLVC_ENUM:
1214       case CLVC_DEFER:
1215         break;
1216       }
1217   return -1;
1218 }
1219
1220 /* Fill STATE with the current state of option OPTION in OPTS.  Return
1221    true if there is some state to store.  */
1222
1223 bool
1224 get_option_state (struct gcc_options *opts, int option,
1225                   struct cl_option_state *state)
1226 {
1227   void *flag_var = option_flag_var (option, opts);
1228
1229   if (flag_var == 0)
1230     return false;
1231
1232   switch (cl_options[option].var_type)
1233     {
1234     case CLVC_BOOLEAN:
1235     case CLVC_EQUAL:
1236       state->data = flag_var;
1237       state->size = (cl_options[option].cl_host_wide_int
1238                      ? sizeof (HOST_WIDE_INT)
1239                      : sizeof (int));
1240       break;
1241
1242     case CLVC_BIT_CLEAR:
1243     case CLVC_BIT_SET:
1244       state->ch = option_enabled (option, opts);
1245       state->data = &state->ch;
1246       state->size = 1;
1247       break;
1248
1249     case CLVC_STRING:
1250       state->data = *(const char **) flag_var;
1251       if (state->data == 0)
1252         state->data = "";
1253       state->size = strlen ((const char *) state->data) + 1;
1254       break;
1255
1256     case CLVC_ENUM:
1257       state->data = flag_var;
1258       state->size = cl_enums[cl_options[option].var_enum].var_size;
1259       break;
1260
1261     case CLVC_DEFER:
1262       return false;
1263     }
1264   return true;
1265 }
1266
1267 /* Set a warning option OPT_INDEX (language mask LANG_MASK, option
1268    handlers HANDLERS) to have diagnostic kind KIND for option
1269    structures OPTS and OPTS_SET and diagnostic context DC (possibly
1270    NULL), at location LOC (UNKNOWN_LOCATION for -Werror=).  If IMPLY,
1271    the warning option in question is implied at this point.  This is
1272    used by -Werror= and #pragma GCC diagnostic.  */
1273
1274 void
1275 control_warning_option (unsigned int opt_index, int kind, bool imply,
1276                         location_t loc, unsigned int lang_mask,
1277                         const struct cl_option_handlers *handlers,
1278                         struct gcc_options *opts,
1279                         struct gcc_options *opts_set,
1280                         diagnostic_context *dc)
1281 {
1282   if (cl_options[opt_index].alias_target != N_OPTS)
1283     opt_index = cl_options[opt_index].alias_target;
1284   if (opt_index == OPT_SPECIAL_ignore)
1285     return;
1286   if (dc)
1287     diagnostic_classify_diagnostic (dc, opt_index, (diagnostic_t) kind, loc);
1288   if (imply)
1289     {
1290       /* -Werror=foo implies -Wfoo.  */
1291       if (cl_options[opt_index].var_type == CLVC_BOOLEAN)
1292         handle_generated_option (opts, opts_set,
1293                                  opt_index, NULL, 1, lang_mask,
1294                                  kind, loc, handlers, dc);
1295     }
1296 }