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         }
 308     }
 309   else
 310     {
 311       decoded->canonical_option[0] = opt_text;
 312       decoded->canonical_option[1] = NULL;
 313       decoded->canonical_option_num_elements = 1;
 314     }
 315 }
 316
 317 /* Structure describing mappings from options on the command line to
 318    options to look up with find_opt.  */
 319 struct option_map
 320 {
 321   /* Prefix of the option on the command line.  */
 322   const char *opt0;
 323   /* If two argv elements are considered to be merged into one option,
 324      prefix for the second element, otherwise NULL.  */
 325   const char *opt1;
 326   /* The new prefix to map to.  */
 327   const char *new_prefix;
 328   /* Whether at least one character is needed following opt1 or opt0
 329      for this mapping to be used.  (--optimize= is valid for -O, but
 330      --warn- is not valid for -W.)  */
 331   bool another_char_needed;
 332   /* Whether the original option is a negated form of the option
 333      resulting from this map.  */
 334   bool negated;
 335 };
 336 static const struct option_map option_map[] =
 337   {
 338     { "-Wno-", NULL, "-W", false, true },
 339     { "-fno-", NULL, "-f", false, true },
 340     { "-mno-", NULL, "-m", false, true },
 341     { "--debug=", NULL, "-g", false, false },
 342     { "--machine-", NULL, "-m", true, false },
 343     { "--machine-no-", NULL, "-m", false, true },
 344     { "--machine=", NULL, "-m", false, false },
 345     { "--machine=no-", NULL, "-m", false, true },
 346     { "--machine", "", "-m", false, false },
 347     { "--machine", "no-", "-m", false, true },
 348     { "--optimize=", NULL, "-O", false, false },
 349     { "--std=", NULL, "-std=", false, false },
 350     { "--std", "", "-std=", false, false },
 351     { "--warn-", NULL, "-W", true, false },
 352     { "--warn-no-", NULL, "-W", false, true },
 353     { "--", NULL, "-f", true, false },
 354     { "--no-", NULL, "-f", false, true }
 355   };
 356
 357 /* Decode the switch beginning at ARGV for the language indicated by
 358    LANG_MASK (including CL_COMMON and CL_TARGET if applicable), into
 359    the structure *DECODED.  Returns the number of switches
 360    consumed.  */
 361
 362 static unsigned int
 363 decode_cmdline_option (const char **argv, unsigned int lang_mask,
 364                        struct cl_decoded_option *decoded)
 365 {
 366   size_t opt_index;
 367   const char *arg = 0;
 368   int value = 1;
 369   unsigned int result = 1, i, extra_args, separate_args = 0;
 370   int adjust_len = 0;
 371   size_t total_len;
 372   char *p;
 373   const struct cl_option *option;
 374   int errors = 0;
 375   const char *warn_message = NULL;
 376   bool separate_arg_flag;
 377   bool joined_arg_flag;
 378   bool have_separate_arg = false;
 379
 380   extra_args = 0;
 381
 382   opt_index = find_opt (argv[0] + 1, lang_mask);
 383   i = 0;
 384   while (opt_index == OPT_SPECIAL_unknown
 385          && i < ARRAY_SIZE (option_map))
 386     {
 387       const char *opt0 = option_map[i].opt0;
 388       const char *opt1 = option_map[i].opt1;
 389       const char *new_prefix = option_map[i].new_prefix;
 390       bool another_char_needed = option_map[i].another_char_needed;
 391       size_t opt0_len = strlen (opt0);
 392       size_t opt1_len = (opt1 == NULL ? 0 : strlen (opt1));
 393       size_t optn_len = (opt1 == NULL ? opt0_len : opt1_len);
 394       size_t new_prefix_len = strlen (new_prefix);
 395
 396       extra_args = (opt1 == NULL ? 0 : 1);
 397       value = !option_map[i].negated;
 398
 399       if (strncmp (argv[0], opt0, opt0_len) == 0
 400           && (opt1 == NULL
 401               || (argv[1] != NULL && strncmp (argv[1], opt1, opt1_len) == 0))
 402           && (!another_char_needed
 403               || argv[extra_args][optn_len] != 0))
 404         {
 405           size_t arglen = strlen (argv[extra_args]);
 406           char *dup;
 407
 408           adjust_len = (int) optn_len - (int) new_prefix_len;
 409           dup = XNEWVEC (char, arglen + 1 - adjust_len);
 410           memcpy (dup, new_prefix, new_prefix_len);
 411           memcpy (dup + new_prefix_len, argv[extra_args] + optn_len,
 412                   arglen - optn_len + 1);
 413           opt_index = find_opt (dup + 1, lang_mask);
 414           free (dup);
 415         }
 416       i++;
 417     }
 418
 419   if (opt_index == OPT_SPECIAL_unknown)
 420     {
 421       arg = argv[0];
 422       extra_args = 0;
 423       value = 1;
 424       goto done;
 425     }
 426
 427   option = &cl_options[opt_index];
 428
 429   /* Reject negative form of switches that don't take negatives as
 430      unrecognized.  */
 431   if (!value && option->cl_reject_negative)
 432     {
 433       opt_index = OPT_SPECIAL_unknown;
 434       errors |= CL_ERR_NEGATIVE;
 435       arg = argv[0];
 436       goto done;
 437     }
 438
 439   result = extra_args + 1;
 440   warn_message = option->warn_message;
 441
 442   /* Check to see if the option is disabled for this configuration.  */
 443   if (option->cl_disabled)
 444     errors |= CL_ERR_DISABLED;
 445
 446   /* Determine whether there may be a separate argument based on
 447      whether this option is being processed for the driver, and, if
 448      so, how many such arguments.  */
 449   separate_arg_flag = ((option->flags & CL_SEPARATE)
 450                        && !(option->cl_no_driver_arg
 451                             && (lang_mask & CL_DRIVER)));
 452   separate_args = (separate_arg_flag
 453                    ? option->cl_separate_nargs + 1
 454                    : 0);
 455   joined_arg_flag = (option->flags & CL_JOINED) != 0;
 456
 457   /* Sort out any argument the switch takes.  */
 458   if (joined_arg_flag)
 459     {
 460       /* Have arg point to the original switch.  This is because
 461          some code, such as disable_builtin_function, expects its
 462          argument to be persistent until the program exits.  */
 463       arg = argv[extra_args] + cl_options[opt_index].opt_len + 1 + adjust_len;
 464
 465       if (*arg == '\0' && !option->cl_missing_ok)
 466         {
 467           if (separate_arg_flag)
 468             {
 469               arg = argv[extra_args + 1];
 470               result = extra_args + 2;
 471               if (arg == NULL)
 472                 result = extra_args + 1;
 473               else
 474                 have_separate_arg = true;
 475             }
 476           else
 477             /* Missing argument.  */
 478             arg = NULL;
 479         }
 480     }
 481   else if (separate_arg_flag)
 482     {
 483       arg = argv[extra_args + 1];
 484       for (i = 0; i < separate_args; i++)
 485         if (argv[extra_args + 1 + i] == NULL)
 486           {
 487             errors |= CL_ERR_MISSING_ARG;
 488             break;
 489           }
 490       result = extra_args + 1 + i;
 491       if (arg != NULL)
 492         have_separate_arg = true;
 493     }
 494
 495   if (arg == NULL && (separate_arg_flag || joined_arg_flag))
 496     errors |= CL_ERR_MISSING_ARG;
 497
 498   /* Is this option an alias (or an ignored option, marked as an alias
 499      of OPT_SPECIAL_ignore)?  */
 500   if (option->alias_target != N_OPTS
 501       && (!option->cl_separate_alias || have_separate_arg))
 502     {
 503       size_t new_opt_index = option->alias_target;
 504
 505       if (new_opt_index == OPT_SPECIAL_ignore)
 506         {
 507           gcc_assert (option->alias_arg == NULL);
 508           gcc_assert (option->neg_alias_arg == NULL);
 509           opt_index = new_opt_index;
 510           arg = NULL;
 511           value = 1;
 512         }
 513       else
 514         {
 515           const struct cl_option *new_option = &cl_options[new_opt_index];
 516
 517           /* The new option must not be an alias itself.  */
 518           gcc_assert (new_option->alias_target == N_OPTS
 519                       || new_option->cl_separate_alias);
 520
 521           if (option->neg_alias_arg)
 522             {
 523               gcc_assert (option->alias_arg != NULL);
 524               gcc_assert (arg == NULL);
 525               gcc_assert (!option->cl_negative_alias);
 526               if (value)
 527                 arg = option->alias_arg;
 528               else
 529                 arg = option->neg_alias_arg;
 530               value = 1;
 531             }
 532           else if (option->alias_arg)
 533             {
 534               gcc_assert (value == 1);
 535               gcc_assert (arg == NULL);
 536               gcc_assert (!option->cl_negative_alias);
 537               arg = option->alias_arg;
 538             }
 539
 540           if (option->cl_negative_alias)
 541             value = !value;
 542
 543           opt_index = new_opt_index;
 544           option = new_option;
 545
 546           if (value == 0)
 547             gcc_assert (!option->cl_reject_negative);
 548
 549           /* Recompute what arguments are allowed.  */
 550           separate_arg_flag = ((option->flags & CL_SEPARATE)
 551                                && !(option->cl_no_driver_arg
 552                                     && (lang_mask & CL_DRIVER)));
 553           joined_arg_flag = (option->flags & CL_JOINED) != 0;
 554
 555           if (separate_args > 1 || option->cl_separate_nargs)
 556             gcc_assert (separate_args
 557                         == (unsigned int) option->cl_separate_nargs + 1);
 558
 559           if (!(errors & CL_ERR_MISSING_ARG))
 560             {
 561               if (separate_arg_flag || joined_arg_flag)
 562                 {
 563                   if (option->cl_missing_ok && arg == NULL)
 564                     arg = "";
 565                   gcc_assert (arg != NULL);
 566                 }
 567               else
 568                 gcc_assert (arg == NULL);
 569             }
 570
 571           /* Recheck for warnings and disabled options.  */
 572           if (option->warn_message)
 573             {
 574               gcc_assert (warn_message == NULL);
 575               warn_message = option->warn_message;
 576             }
 577           if (option->cl_disabled)
 578             errors |= CL_ERR_DISABLED;
 579         }
 580     }
 581
 582   /* Check if this is a switch for a different front end.  */
 583   if (!option_ok_for_language (option, lang_mask))
 584     errors |= CL_ERR_WRONG_LANG;
 585
 586   /* Convert the argument to lowercase if appropriate.  */
 587   if (arg && option->cl_tolower)
 588     {
 589       size_t j;
 590       size_t len = strlen (arg);
 591       char *arg_lower = XNEWVEC (char, len + 1);
 592
 593       for (j = 0; j < len; j++)
 594         arg_lower[j] = TOLOWER ((unsigned char) arg[j]);
 595       arg_lower[len] = 0;
 596       arg = arg_lower;
 597     }
 598
 599   /* If the switch takes an integer, convert it.  */
 600   if (arg && option->cl_uinteger)
 601     {
 602       value = integral_argument (arg);
 603       if (value == -1)
 604         errors |= CL_ERR_UINT_ARG;
 605     }
 606
 607   /* If the switch takes an enumerated argument, convert it.  */
 608   if (arg && (option->var_type == CLVC_ENUM))
 609     {
 610       const struct cl_enum *e = &cl_enums[option->var_enum];
 611
 612       gcc_assert (value == 1);
 613       if (enum_arg_to_value (e->values, arg, &value, lang_mask))
 614         {
 615           const char *carg = NULL;
 616
 617           if (enum_value_to_arg (e->values, &carg, value, lang_mask))
 618             arg = carg;
 619           gcc_assert (carg != NULL);
 620         }
 621       else
 622         errors |= CL_ERR_ENUM_ARG;
 623     }
 624
 625  done:
 626   decoded->opt_index = opt_index;
 627   decoded->arg = arg;
 628   decoded->value = value;
 629   decoded->errors = errors;
 630   decoded->warn_message = warn_message;
 631
 632   if (opt_index == OPT_SPECIAL_unknown)
 633     gcc_assert (result == 1);
 634
 635   gcc_assert (result >= 1 && result <= ARRAY_SIZE (decoded->canonical_option));
 636   decoded->canonical_option_num_elements = result;
 637   total_len = 0;
 638   for (i = 0; i < ARRAY_SIZE (decoded->canonical_option); i++)
 639     {
 640       if (i < result)
 641         {
 642           size_t len;
 643           if (opt_index == OPT_SPECIAL_unknown)
 644             decoded->canonical_option[i] = argv[i];
 645           else
 646             decoded->canonical_option[i] = NULL;
 647           len = strlen (argv[i]);
 648           /* If the argument is an empty string, we will print it as "" in
 649              orig_option_with_args_text.  */
 650           total_len += (len != 0 ? len : 2) + 1;
 651         }
 652       else
 653         decoded->canonical_option[i] = NULL;
 654     }
 655   if (opt_index != OPT_SPECIAL_unknown && opt_index != OPT_SPECIAL_ignore)
 656     {
 657       generate_canonical_option (opt_index, arg, value, decoded);
 658       if (separate_args > 1)
 659         {
 660           for (i = 0; i < separate_args; i++)
 661             {
 662               if (argv[extra_args + 1 + i] == NULL)
 663                   break;
 664               else
 665                 decoded->canonical_option[1 + i] = argv[extra_args + 1 + i];
 666             }
 667           gcc_assert (result == 1 + i);
 668           decoded->canonical_option_num_elements = result;
 669         }
 670     }
 671   decoded->orig_option_with_args_text = p = XNEWVEC (char, total_len);
 672   for (i = 0; i < result; i++)
 673     {
 674       size_t len = strlen (argv[i]);
 675
 676       /* Print the empty string verbally.  */
 677       if (len == 0)
 678         {
 679           *p++ = '"';
 680           *p++ = '"';
 681         }
 682       else
 683         memcpy (p, argv[i], len);
 684       p += len;
 685       if (i == result - 1)
 686         *p++ = 0;
 687       else
 688         *p++ = ' ';
 689     }
 690
 691   return result;
 692 }
 693
 694 /* Decode command-line options (ARGC and ARGV being the arguments of
 695    main) into an array, setting *DECODED_OPTIONS to a pointer to that
 696    array and *DECODED_OPTIONS_COUNT to the number of entries in the
 697    array.  The first entry in the array is always one for the program
 698    name (OPT_SPECIAL_program_name).  LANG_MASK indicates the language
 699    flags applicable for decoding (including CL_COMMON and CL_TARGET if
 700    those options should be considered applicable).  Do not produce any
 701    diagnostics or set state outside of these variables.  */
 702
 703 void
 704 decode_cmdline_options_to_array (unsigned int argc, const char **argv,
 705                                  unsigned int lang_mask,
 706                                  struct cl_decoded_option **decoded_options,
 707                                  unsigned int *decoded_options_count)
 708 {
 709   unsigned int n, i;
 710   struct cl_decoded_option *opt_array;
 711   unsigned int num_decoded_options;
 712
 713   opt_array = XNEWVEC (struct cl_decoded_option, argc);
 714
 715   opt_array[0].opt_index = OPT_SPECIAL_program_name;
 716   opt_array[0].warn_message = NULL;
 717   opt_array[0].arg = argv[0];
 718   opt_array[0].orig_option_with_args_text = argv[0];
 719   opt_array[0].canonical_option_num_elements = 1;
 720   opt_array[0].canonical_option[0] = argv[0];
 721   opt_array[0].canonical_option[1] = NULL;
 722   opt_array[0].canonical_option[2] = NULL;
 723   opt_array[0].canonical_option[3] = NULL;
 724   opt_array[0].value = 1;
 725   opt_array[0].errors = 0;
 726   num_decoded_options = 1;
 727
 728   for (i = 1; i < argc; i += n)
 729     {
 730       const char *opt = argv[i];
 731
 732       /* Interpret "-" or a non-switch as a file name.  */
 733       if (opt[0] != '-' || opt[1] == '\0')
 734         {
 735           generate_option_input_file (opt, &opt_array[num_decoded_options]);
 736           num_decoded_options++;
 737           n = 1;
 738           continue;
 739         }
 740
 741       n = decode_cmdline_option (argv + i, lang_mask,
 742                                  &opt_array[num_decoded_options]);
 743       num_decoded_options++;
 744     }
 745
 746   *decoded_options = opt_array;
 747   *decoded_options_count = num_decoded_options;
 748   prune_options (decoded_options, decoded_options_count);
 749 }
 750
 751 /* Return true if NEXT_OPT_IDX cancels OPT_IDX.  Return false if the
 752    next one is the same as ORIG_NEXT_OPT_IDX.  */
 753
 754 static bool
 755 cancel_option (int opt_idx, int next_opt_idx, int orig_next_opt_idx)
 756 {
 757   /* An option can be canceled by the same option or an option with
 758      Negative.  */
 759   if (cl_options [next_opt_idx].neg_index == opt_idx)
 760     return true;
 761
 762   if (cl_options [next_opt_idx].neg_index != orig_next_opt_idx)
 763     return cancel_option (opt_idx, cl_options [next_opt_idx].neg_index,
 764                           orig_next_opt_idx);
 765
 766   return false;
 767 }
 768
 769 /* Filter out options canceled by the ones after them.  */
 770
 771 static void
 772 prune_options (struct cl_decoded_option **decoded_options,
 773                unsigned int *decoded_options_count)
 774 {
 775   unsigned int old_decoded_options_count = *decoded_options_count;
 776   struct cl_decoded_option *old_decoded_options = *decoded_options;
 777   unsigned int new_decoded_options_count;
 778   struct cl_decoded_option *new_decoded_options
 779     = XNEWVEC (struct cl_decoded_option, old_decoded_options_count);
 780   unsigned int i;
 781   const struct cl_option *option;
 782
 783   /* Remove arguments which are negated by others after them.  */
 784   new_decoded_options_count = 0;
 785   for (i = 0; i < old_decoded_options_count; i++)
 786     {
 787       unsigned int j, opt_idx, next_opt_idx;
 788
 789       if (old_decoded_options[i].errors & ~CL_ERR_WRONG_LANG)
 790         goto keep;
 791
 792       opt_idx = old_decoded_options[i].opt_index;
 793       switch (opt_idx)
 794         {
 795         case OPT_SPECIAL_unknown:
 796         case OPT_SPECIAL_ignore:
 797         case OPT_SPECIAL_program_name:
 798         case OPT_SPECIAL_input_file:
 799           goto keep;
 800
 801         default:
 802           gcc_assert (opt_idx < cl_options_count);
 803           option = &cl_options[opt_idx];
 804           if (option->neg_index < 0)
 805             goto keep;
 806
 807           /* Skip joined switches.  */
 808           if ((option->flags & CL_JOINED))
 809             goto keep;
 810
 811           for (j = i + 1; j < old_decoded_options_count; j++)
 812             {
 813               if (old_decoded_options[j].errors & ~CL_ERR_WRONG_LANG)
 814                 continue;
 815               next_opt_idx = old_decoded_options[j].opt_index;
 816               if (next_opt_idx >= cl_options_count)
 817                 continue;
 818               if (cl_options[next_opt_idx].neg_index < 0)
 819                 continue;
 820               if ((cl_options[next_opt_idx].flags & CL_JOINED))
 821                   continue;
 822               if (cancel_option (opt_idx, next_opt_idx, next_opt_idx))
 823                 break;
 824             }
 825           if (j == old_decoded_options_count)
 826             {
 827 keep:
 828               new_decoded_options[new_decoded_options_count]
 829                 = old_decoded_options[i];
 830               new_decoded_options_count++;
 831             }
 832           break;
 833         }
 834     }
 835
 836   free (old_decoded_options);
 837   new_decoded_options = XRESIZEVEC (struct cl_decoded_option,
 838                                     new_decoded_options,
 839                                     new_decoded_options_count);
 840   *decoded_options = new_decoded_options;
 841   *decoded_options_count = new_decoded_options_count;
 842 }
 843
 844 /* Handle option DECODED for the language indicated by LANG_MASK,
 845    using the handlers in HANDLERS and setting fields in OPTS and
 846    OPTS_SET.  KIND is the diagnostic_t if this is a diagnostics
 847    option, DK_UNSPECIFIED otherwise, and LOC is the location of the
 848    option for options from the source file, UNKNOWN_LOCATION
 849    otherwise.  GENERATED_P is true for an option generated as part of
 850    processing another option or otherwise generated internally, false
 851    for one explicitly passed by the user.  Returns false if the switch
 852    was invalid.  DC is the diagnostic context for options affecting
 853    diagnostics state, or NULL.  */
 854
 855 static bool
 856 handle_option (struct gcc_options *opts,
 857                struct gcc_options *opts_set,
 858                const struct cl_decoded_option *decoded,
 859                unsigned int lang_mask, int kind, location_t loc,
 860                const struct cl_option_handlers *handlers,
 861                bool generated_p, diagnostic_context *dc)
 862 {
 863   size_t opt_index = decoded->opt_index;
 864   const char *arg = decoded->arg;
 865   int value = decoded->value;
 866   const struct cl_option *option = &cl_options[opt_index];
 867   void *flag_var = option_flag_var (opt_index, opts);
 868   size_t i;
 869
 870   if (flag_var)
 871     set_option (opts, (generated_p ? NULL : opts_set),
 872                 opt_index, value, arg, kind, loc, dc);
 873
 874   for (i = 0; i < handlers->num_handlers; i++)
 875     if (option->flags & handlers->handlers[i].mask)
 876       {
 877         if (!handlers->handlers[i].handler (opts, opts_set, decoded,
 878                                             lang_mask, kind, loc,
 879                                             handlers, dc))
 880           return false;
 881       }
 882
 883   return true;
 884 }
 885
 886 /* Like handle_option, but OPT_INDEX, ARG and VALUE describe the
 887    option instead of DECODED.  This is used for callbacks when one
 888    option implies another instead of an option being decoded from the
 889    command line.  */
 890
 891 bool
 892 handle_generated_option (struct gcc_options *opts,
 893                          struct gcc_options *opts_set,
 894                          size_t opt_index, const char *arg, int value,
 895                          unsigned int lang_mask, int kind, location_t loc,
 896                          const struct cl_option_handlers *handlers,
 897                          diagnostic_context *dc)
 898 {
 899   struct cl_decoded_option decoded;
 900
 901   generate_option (opt_index, arg, value, lang_mask, &decoded);
 902   return handle_option (opts, opts_set, &decoded, lang_mask, kind, loc,
 903                         handlers, true, dc);
 904 }
 905
 906 /* Fill in *DECODED with an option described by OPT_INDEX, ARG and
 907    VALUE for a front end using LANG_MASK.  This is used when the
 908    compiler generates options internally.  */
 909
 910 void
 911 generate_option (size_t opt_index, const char *arg, int value,
 912                  unsigned int lang_mask, struct cl_decoded_option *decoded)
 913 {
 914   const struct cl_option *option = &cl_options[opt_index];
 915
 916   decoded->opt_index = opt_index;
 917   decoded->warn_message = NULL;
 918   decoded->arg = arg;
 919   decoded->value = value;
 920   decoded->errors = (option_ok_for_language (option, lang_mask)
 921                      ? 0
 922                      : CL_ERR_WRONG_LANG);
 923
 924   generate_canonical_option (opt_index, arg, value, decoded);
 925   switch (decoded->canonical_option_num_elements)
 926     {
 927     case 1:
 928       decoded->orig_option_with_args_text = decoded->canonical_option[0];
 929       break;
 930
 931     case 2:
 932       decoded->orig_option_with_args_text
 933         = concat (decoded->canonical_option[0], " ",
 934                   decoded->canonical_option[1], NULL);
 935       break;
 936
 937     default:
 938       gcc_unreachable ();
 939     }
 940 }
 941
 942 /* Fill in *DECODED with an option for input file FILE.  */
 943
 944 void
 945 generate_option_input_file (const char *file,
 946                             struct cl_decoded_option *decoded)
 947 {
 948   decoded->opt_index = OPT_SPECIAL_input_file;
 949   decoded->warn_message = NULL;
 950   decoded->arg = file;
 951   decoded->orig_option_with_args_text = file;
 952   decoded->canonical_option_num_elements = 1;
 953   decoded->canonical_option[0] = file;
 954   decoded->canonical_option[1] = NULL;
 955   decoded->canonical_option[2] = NULL;
 956   decoded->canonical_option[3] = NULL;
 957   decoded->value = 1;
 958   decoded->errors = 0;
 959 }
 960
 961 /* Handle the switch DECODED (location LOC) for the language indicated
 962    by LANG_MASK, using the handlers in *HANDLERS and setting fields in
 963    OPTS and OPTS_SET and using diagnostic context DC (if not NULL) for
 964    diagnostic options.  */
 965
 966 void
 967 read_cmdline_option (struct gcc_options *opts,
 968                      struct gcc_options *opts_set,
 969                      struct cl_decoded_option *decoded,
 970                      location_t loc,
 971                      unsigned int lang_mask,
 972                      const struct cl_option_handlers *handlers,
 973                      diagnostic_context *dc)
 974 {
 975   const struct cl_option *option;
 976   const char *opt = decoded->orig_option_with_args_text;
 977
 978   if (decoded->warn_message)
 979     warning_at (loc, 0, decoded->warn_message, opt);
 980
 981   if (decoded->opt_index == OPT_SPECIAL_unknown)
 982     {
 983       if (handlers->unknown_option_callback (decoded))
 984         error_at (loc, "unrecognized command line option %qs", decoded->arg);
 985       return;
 986     }
 987
 988   if (decoded->opt_index == OPT_SPECIAL_ignore)
 989     return;
 990
 991   option = &cl_options[decoded->opt_index];
 992
 993   if (decoded->errors & CL_ERR_DISABLED)
 994     {
 995       error_at (loc, "command line option %qs"
 996                 " is not supported by this configuration", opt);
 997       return;
 998     }
 999
1000   if (decoded->errors & CL_ERR_MISSING_ARG)
1001     {
1002       if (option->missing_argument_error)
1003         error_at (loc, option->missing_argument_error, opt);
1004       else
1005         error_at (loc, "missing argument to %qs", opt);
1006       return;
1007     }
1008
1009   if (decoded->errors & CL_ERR_UINT_ARG)
1010     {
1011       error_at (loc, "argument to %qs should be a non-negative integer",
1012                 option->opt_text);
1013       return;
1014     }
1015
1016   if (decoded->errors & CL_ERR_ENUM_ARG)
1017     {
1018       const struct cl_enum *e = &cl_enums[option->var_enum];
1019       unsigned int i;
1020       size_t len;
1021       char *s, *p;
1022
1023       if (e->unknown_error)
1024         error_at (loc, e->unknown_error, decoded->arg);
1025       else
1026         error_at (loc, "unrecognized argument in option %qs", opt);
1027
1028       len = 0;
1029       for (i = 0; e->values[i].arg != NULL; i++)
1030         len += strlen (e->values[i].arg) + 1;
1031
1032       s = XALLOCAVEC (char, len);
1033       p = s;
1034       for (i = 0; e->values[i].arg != NULL; i++)
1035         {
1036           size_t arglen = strlen (e->values[i].arg);
1037           memcpy (p, e->values[i].arg, arglen);
1038           p[arglen] = ' ';
1039           p += arglen + 1;
1040         }
1041       p[-1] = 0;
1042       inform (loc, "valid arguments to %qs are: %s", option->opt_text, s);
1043       return;
1044     }
1045
1046   if (decoded->errors & CL_ERR_WRONG_LANG)
1047     {
1048       handlers->wrong_lang_callback (decoded, lang_mask);
1049       return;
1050     }
1051
1052   gcc_assert (!decoded->errors);
1053
1054   if (!handle_option (opts, opts_set, decoded, lang_mask, DK_UNSPECIFIED,
1055                       loc, handlers, false, dc))
1056     error_at (loc, "unrecognized command line option %qs", opt);
1057 }
1058
1059 /* Set any field in OPTS, and OPTS_SET if not NULL, for option
1060    OPT_INDEX according to VALUE and ARG, diagnostic kind KIND,
1061    location LOC, using diagnostic context DC if not NULL for
1062    diagnostic classification.  */
1063
1064 void
1065 set_option (struct gcc_options *opts, struct gcc_options *opts_set,
1066             int opt_index, int value, const char *arg, int kind,
1067             location_t loc, diagnostic_context *dc)
1068 {
1069   const struct cl_option *option = &cl_options[opt_index];
1070   void *flag_var = option_flag_var (opt_index, opts);
1071   void *set_flag_var = NULL;
1072
1073   if (!flag_var)
1074     return;
1075
1076   if (opts_set != NULL)
1077     set_flag_var = option_flag_var (opt_index, opts_set);
1078
1079   switch (option->var_type)
1080     {
1081     case CLVC_BOOLEAN:
1082         *(int *) flag_var = value;
1083         if (set_flag_var)
1084           *(int *) set_flag_var = 1;
1085         break;
1086
1087     case CLVC_EQUAL:
1088         if (option->cl_host_wide_int)
1089           *(HOST_WIDE_INT *) flag_var = (value
1090                                          ? option->var_value
1091                                          : !option->var_value);
1092         else
1093           *(int *) flag_var = (value
1094                                ? option->var_value
1095                                : !option->var_value);
1096         if (set_flag_var)
1097           *(int *) set_flag_var = 1;
1098         break;
1099
1100     case CLVC_BIT_CLEAR:
1101     case CLVC_BIT_SET:
1102         if ((value != 0) == (option->var_type == CLVC_BIT_SET))
1103           {
1104             if (option->cl_host_wide_int)
1105               *(HOST_WIDE_INT *) flag_var |= option->var_value;
1106             else
1107               *(int *) flag_var |= option->var_value;
1108           }
1109         else
1110           {
1111             if (option->cl_host_wide_int)
1112               *(HOST_WIDE_INT *) flag_var &= ~option->var_value;
1113             else
1114               *(int *) flag_var &= ~option->var_value;
1115           }
1116         if (set_flag_var)
1117           {
1118             if (option->cl_host_wide_int)
1119               *(HOST_WIDE_INT *) set_flag_var |= option->var_value;
1120             else
1121               *(int *) set_flag_var |= option->var_value;
1122           }
1123         break;
1124
1125     case CLVC_STRING:
1126         *(const char **) flag_var = arg;
1127         if (set_flag_var)
1128           *(const char **) set_flag_var = "";
1129         break;
1130
1131     case CLVC_ENUM:
1132       {
1133         const struct cl_enum *e = &cl_enums[option->var_enum];
1134
1135         e->set (flag_var, value);
1136         if (set_flag_var)
1137           e->set (set_flag_var, 1);
1138       }
1139       break;
1140
1141     case CLVC_DEFER:
1142         {
1143           VEC(cl_deferred_option,heap) *vec
1144             = (VEC(cl_deferred_option,heap) *) *(void **) flag_var;
1145           cl_deferred_option *p;
1146
1147           p = VEC_safe_push (cl_deferred_option, heap, vec, NULL);
1148           p->opt_index = opt_index;
1149           p->arg = arg;
1150           p->value = value;
1151           *(void **) flag_var = vec;
1152           if (set_flag_var)
1153             *(void **) set_flag_var = vec;
1154         }
1155         break;
1156     }
1157
1158   if ((diagnostic_t) kind != DK_UNSPECIFIED
1159       && dc != NULL)
1160     diagnostic_classify_diagnostic (dc, opt_index, (diagnostic_t) kind, loc);
1161 }
1162
1163 /* Return the address of the flag variable for option OPT_INDEX in
1164    options structure OPTS, or NULL if there is no flag variable.  */
1165
1166 void *
1167 option_flag_var (int opt_index, struct gcc_options *opts)
1168 {
1169   const struct cl_option *option = &cl_options[opt_index];
1170
1171   if (option->flag_var_offset == (unsigned short) -1)
1172     return NULL;
1173   return (void *)(((char *) opts) + option->flag_var_offset);
1174 }
1175
1176 /* Return 1 if option OPT_IDX is enabled in OPTS, 0 if it is disabled,
1177    or -1 if it isn't a simple on-off switch.  */
1178
1179 int
1180 option_enabled (int opt_idx, void *opts)
1181 {
1182   const struct cl_option *option = &(cl_options[opt_idx]);
1183   struct gcc_options *optsg = (struct gcc_options *) opts;
1184   void *flag_var = option_flag_var (opt_idx, optsg);
1185
1186   if (flag_var)
1187     switch (option->var_type)
1188       {
1189       case CLVC_BOOLEAN:
1190         return *(int *) flag_var != 0;
1191
1192       case CLVC_EQUAL:
1193         if (option->cl_host_wide_int)
1194           return *(HOST_WIDE_INT *) flag_var == option->var_value;
1195         else
1196           return *(int *) flag_var == option->var_value;
1197
1198       case CLVC_BIT_CLEAR:
1199         if (option->cl_host_wide_int)
1200           return (*(HOST_WIDE_INT *) flag_var & option->var_value) == 0;
1201         else
1202           return (*(int *) flag_var & option->var_value) == 0;
1203
1204       case CLVC_BIT_SET:
1205         if (option->cl_host_wide_int)
1206           return (*(HOST_WIDE_INT *) flag_var & option->var_value) != 0;
1207         else
1208           return (*(int *) flag_var & option->var_value) != 0;
1209
1210       case CLVC_STRING:
1211       case CLVC_ENUM:
1212       case CLVC_DEFER:
1213         break;
1214       }
1215   return -1;
1216 }
1217
1218 /* Fill STATE with the current state of option OPTION in OPTS.  Return
1219    true if there is some state to store.  */
1220
1221 bool
1222 get_option_state (struct gcc_options *opts, int option,
1223                   struct cl_option_state *state)
1224 {
1225   void *flag_var = option_flag_var (option, opts);
1226
1227   if (flag_var == 0)
1228     return false;
1229
1230   switch (cl_options[option].var_type)
1231     {
1232     case CLVC_BOOLEAN:
1233     case CLVC_EQUAL:
1234       state->data = flag_var;
1235       state->size = (cl_options[option].cl_host_wide_int
1236                      ? sizeof (HOST_WIDE_INT)
1237                      : sizeof (int));
1238       break;
1239
1240     case CLVC_BIT_CLEAR:
1241     case CLVC_BIT_SET:
1242       state->ch = option_enabled (option, opts);
1243       state->data = &state->ch;
1244       state->size = 1;
1245       break;
1246
1247     case CLVC_STRING:
1248       state->data = *(const char **) flag_var;
1249       if (state->data == 0)
1250         state->data = "";
1251       state->size = strlen ((const char *) state->data) + 1;
1252       break;
1253
1254     case CLVC_ENUM:
1255       state->data = flag_var;
1256       state->size = cl_enums[cl_options[option].var_enum].var_size;
1257       break;
1258
1259     case CLVC_DEFER:
1260       return false;
1261     }
1262   return true;
1263 }
1264
1265 /* Set a warning option OPT_INDEX (language mask LANG_MASK, option
1266    handlers HANDLERS) to have diagnostic kind KIND for option
1267    structures OPTS and OPTS_SET and diagnostic context DC (possibly
1268    NULL), at location LOC (UNKNOWN_LOCATION for -Werror=).  If IMPLY,
1269    the warning option in question is implied at this point.  This is
1270    used by -Werror= and #pragma GCC diagnostic.  */
1271
1272 void
1273 control_warning_option (unsigned int opt_index, int kind, bool imply,
1274                         location_t loc, unsigned int lang_mask,
1275                         const struct cl_option_handlers *handlers,
1276                         struct gcc_options *opts,
1277                         struct gcc_options *opts_set,
1278                         diagnostic_context *dc)
1279 {
1280   if (cl_options[opt_index].alias_target != N_OPTS)
1281     opt_index = cl_options[opt_index].alias_target;
1282   if (opt_index == OPT_SPECIAL_ignore)
1283     return;
1284   if (dc)
1285     diagnostic_classify_diagnostic (dc, opt_index, (diagnostic_t) kind, loc);
1286   if (imply)
1287     {
1288       /* -Werror=foo implies -Wfoo.  */
1289       if (cl_options[opt_index].var_type == CLVC_BOOLEAN)
1290         handle_generated_option (opts, opts_set,
1291                                  opt_index, NULL, 1, lang_mask,
1292                                  kind, loc, handlers, dc);
1293     }
1294 }