contrib/gcc-5.0/gcc/opts-common.c

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