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