1 /* Command line option handling.
2 Copyright (C) 2006-2016 Free Software Foundation, Inc.
4 This file is part of GCC.
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
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
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/>. */
23 #include "coretypes.h"
26 #include "diagnostic.h"
28 static void prune_options (struct cl_decoded_option **, unsigned int *);
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.
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".
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).
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. */
55 find_opt (const char *input, unsigned int lang_mask)
57 size_t mn, mn_orig, mx, md, opt_len;
58 size_t match_wrong_lang;
62 mx = cl_options_count;
64 /* Find mn such this lexicographical inequality holds:
65 cl_options[mn] <= input < cl_options[mn + 1]. */
69 opt_len = cl_options[md].opt_len;
70 comp = strncmp (input, cl_options[md].opt_text + 1, opt_len);
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;
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. */
89 const struct cl_option *opt = &cl_options[mn];
91 /* Is the input either an exact match or a prefix that takes a
93 if (!strncmp (input, opt->opt_text + 1, opt->opt_len)
94 && (input[opt->opt_len] == '\0' || (opt->flags & CL_JOINED)))
96 /* If language is OK, return it. */
97 if (opt->flags & lang_mask)
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;
106 /* Try the next possibility. This is cl_options_count if there
108 mn = opt->back_chain;
110 while (mn != cl_options_count);
112 if (match_wrong_lang == OPT_SPECIAL_unknown && input[0] == '-')
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)
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
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. */
141 return OPT_SPECIAL_unknown;
146 /* Return the best wrong match, or OPT_SPECIAL_unknown if none. */
147 return match_wrong_lang;
150 /* If ARG is a non-negative decimal or hexadecimal integer, return its
151 value, otherwise return -1. */
154 integral_argument (const char *arg)
158 while (*p && ISDIGIT (*p))
164 /* It wasn't a decimal number - try hexadecimal. */
165 if (arg[0] == '0' && (arg[1] == 'x' || arg[1] == 'X'))
168 while (*p && ISXDIGIT (*p))
171 if (p != arg + 2 && *p == '\0')
172 return strtol (arg, NULL, 16);
178 /* Return whether OPTION is OK for the language given by
181 option_ok_for_language (const struct cl_option *option,
182 unsigned int lang_mask)
184 if (!(option->flags & lang_mask))
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
195 /* Return whether ENUM_ARG is OK for the language given by
199 enum_arg_ok_for_language (const struct cl_enum_arg *enum_arg,
200 unsigned int lang_mask)
202 return (lang_mask & CL_DRIVER) || !(enum_arg->flags & CL_ENUM_DRIVER_ONLY);
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. */
210 enum_arg_to_value (const struct cl_enum_arg *enum_args,
211 const char *arg, int *value, unsigned int lang_mask)
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))
219 *value = enum_args[i].value;
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. */
231 opt_enum_arg_to_value (size_t opt_index, const char *arg, int *value,
232 unsigned int lang_mask)
234 const struct cl_option *option = &cl_options[opt_index];
236 gcc_assert (option->var_type == CLVC_ENUM);
238 return enum_arg_to_value (cl_enums[option->var_enum].values, arg,
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
250 enum_value_to_arg (const struct cl_enum_arg *enum_args,
251 const char **argp, int value, unsigned int lang_mask)
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))
260 *argp = enum_args[i].arg;
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))
268 *argp = enum_args[i].arg;
276 /* Fill in the canonical option part of *DECODED with an option
277 described by OPT_INDEX, ARG and VALUE. */
280 generate_canonical_option (size_t opt_index, const char *arg, int value,
281 struct cl_decoded_option *decoded)
283 const struct cl_option *option = &cl_options[opt_index];
284 const char *opt_text = option->opt_text;
287 && !option->cl_reject_negative
288 && (opt_text[1] == 'W' || opt_text[1] == 'f' || opt_text[1] == 'm'))
290 char *t = XOBNEWVEC (&opts_obstack, char, option->opt_len + 5);
296 memcpy (t + 5, opt_text + 2, option->opt_len);
300 decoded->canonical_option[2] = NULL;
301 decoded->canonical_option[3] = NULL;
305 if ((option->flags & CL_SEPARATE)
306 && !option->cl_separate_alias)
308 decoded->canonical_option[0] = opt_text;
309 decoded->canonical_option[1] = arg;
310 decoded->canonical_option_num_elements = 2;
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;
322 decoded->canonical_option[0] = opt_text;
323 decoded->canonical_option[1] = NULL;
324 decoded->canonical_option_num_elements = 1;
328 /* Structure describing mappings from options on the command line to
329 options to look up with find_opt. */
332 /* Prefix of the option on the command line. */
334 /* If two argv elements are considered to be merged into one option,
335 prefix for the second element, otherwise NULL. */
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. */
347 static const struct option_map option_map[] =
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 }
368 /* Helper function for gcc.c's driver::suggest_option, for populating the
369 vec of suggestions for misspelled options.
371 option_map above provides various prefixes for spelling command-line
372 options, which decode_cmdline_option uses to map spellings of options
373 to specific options. We want to do the reverse: to find all the ways
374 that a user could validly spell an option.
376 Given valid OPT_TEXT (with a leading dash) for OPTION, add it and all
377 of its valid variant spellings to CANDIDATES, each without a leading
380 For example, given "-Wabi-tag", the following are added to CANDIDATES:
386 The added strings must be freed using free. */
389 add_misspelling_candidates (auto_vec<char *> *candidates,
390 const struct cl_option *option,
391 const char *opt_text)
393 gcc_assert (candidates);
395 gcc_assert (opt_text);
396 candidates->safe_push (xstrdup (opt_text + 1));
397 for (unsigned i = 0; i < ARRAY_SIZE (option_map); i++)
399 const char *opt0 = option_map[i].opt0;
400 const char *new_prefix = option_map[i].new_prefix;
401 size_t new_prefix_len = strlen (new_prefix);
403 if (option->cl_reject_negative && option_map[i].negated)
406 if (strncmp (opt_text, new_prefix, new_prefix_len) == 0)
408 char *alternative = concat (opt0 + 1, opt_text + new_prefix_len,
410 candidates->safe_push (alternative);
415 /* Decode the switch beginning at ARGV for the language indicated by
416 LANG_MASK (including CL_COMMON and CL_TARGET if applicable), into
417 the structure *DECODED. Returns the number of switches
421 decode_cmdline_option (const char **argv, unsigned int lang_mask,
422 struct cl_decoded_option *decoded)
427 unsigned int result = 1, i, extra_args, separate_args = 0;
431 const struct cl_option *option;
433 const char *warn_message = NULL;
434 bool separate_arg_flag;
435 bool joined_arg_flag;
436 bool have_separate_arg = false;
440 opt_index = find_opt (argv[0] + 1, lang_mask);
442 while (opt_index == OPT_SPECIAL_unknown
443 && i < ARRAY_SIZE (option_map))
445 const char *opt0 = option_map[i].opt0;
446 const char *opt1 = option_map[i].opt1;
447 const char *new_prefix = option_map[i].new_prefix;
448 bool another_char_needed = option_map[i].another_char_needed;
449 size_t opt0_len = strlen (opt0);
450 size_t opt1_len = (opt1 == NULL ? 0 : strlen (opt1));
451 size_t optn_len = (opt1 == NULL ? opt0_len : opt1_len);
452 size_t new_prefix_len = strlen (new_prefix);
454 extra_args = (opt1 == NULL ? 0 : 1);
455 value = !option_map[i].negated;
457 if (strncmp (argv[0], opt0, opt0_len) == 0
459 || (argv[1] != NULL && strncmp (argv[1], opt1, opt1_len) == 0))
460 && (!another_char_needed
461 || argv[extra_args][optn_len] != 0))
463 size_t arglen = strlen (argv[extra_args]);
466 adjust_len = (int) optn_len - (int) new_prefix_len;
467 dup = XNEWVEC (char, arglen + 1 - adjust_len);
468 memcpy (dup, new_prefix, new_prefix_len);
469 memcpy (dup + new_prefix_len, argv[extra_args] + optn_len,
470 arglen - optn_len + 1);
471 opt_index = find_opt (dup + 1, lang_mask);
477 if (opt_index == OPT_SPECIAL_unknown)
485 option = &cl_options[opt_index];
487 /* Reject negative form of switches that don't take negatives as
489 if (!value && option->cl_reject_negative)
491 opt_index = OPT_SPECIAL_unknown;
492 errors |= CL_ERR_NEGATIVE;
497 result = extra_args + 1;
498 warn_message = option->warn_message;
500 /* Check to see if the option is disabled for this configuration. */
501 if (option->cl_disabled)
502 errors |= CL_ERR_DISABLED;
504 /* Determine whether there may be a separate argument based on
505 whether this option is being processed for the driver, and, if
506 so, how many such arguments. */
507 separate_arg_flag = ((option->flags & CL_SEPARATE)
508 && !(option->cl_no_driver_arg
509 && (lang_mask & CL_DRIVER)));
510 separate_args = (separate_arg_flag
511 ? option->cl_separate_nargs + 1
513 joined_arg_flag = (option->flags & CL_JOINED) != 0;
515 /* Sort out any argument the switch takes. */
518 /* Have arg point to the original switch. This is because
519 some code, such as disable_builtin_function, expects its
520 argument to be persistent until the program exits. */
521 arg = argv[extra_args] + cl_options[opt_index].opt_len + 1 + adjust_len;
523 if (*arg == '\0' && !option->cl_missing_ok)
525 if (separate_arg_flag)
527 arg = argv[extra_args + 1];
528 result = extra_args + 2;
530 result = extra_args + 1;
532 have_separate_arg = true;
535 /* Missing argument. */
539 else if (separate_arg_flag)
541 arg = argv[extra_args + 1];
542 for (i = 0; i < separate_args; i++)
543 if (argv[extra_args + 1 + i] == NULL)
545 errors |= CL_ERR_MISSING_ARG;
548 result = extra_args + 1 + i;
550 have_separate_arg = true;
553 if (arg == NULL && (separate_arg_flag || joined_arg_flag))
554 errors |= CL_ERR_MISSING_ARG;
556 /* Is this option an alias (or an ignored option, marked as an alias
557 of OPT_SPECIAL_ignore)? */
558 if (option->alias_target != N_OPTS
559 && (!option->cl_separate_alias || have_separate_arg))
561 size_t new_opt_index = option->alias_target;
563 if (new_opt_index == OPT_SPECIAL_ignore)
565 gcc_assert (option->alias_arg == NULL);
566 gcc_assert (option->neg_alias_arg == NULL);
567 opt_index = new_opt_index;
573 const struct cl_option *new_option = &cl_options[new_opt_index];
575 /* The new option must not be an alias itself. */
576 gcc_assert (new_option->alias_target == N_OPTS
577 || new_option->cl_separate_alias);
579 if (option->neg_alias_arg)
581 gcc_assert (option->alias_arg != NULL);
582 gcc_assert (arg == NULL);
583 gcc_assert (!option->cl_negative_alias);
585 arg = option->alias_arg;
587 arg = option->neg_alias_arg;
590 else if (option->alias_arg)
592 gcc_assert (value == 1);
593 gcc_assert (arg == NULL);
594 gcc_assert (!option->cl_negative_alias);
595 arg = option->alias_arg;
598 if (option->cl_negative_alias)
601 opt_index = new_opt_index;
605 gcc_assert (!option->cl_reject_negative);
607 /* Recompute what arguments are allowed. */
608 separate_arg_flag = ((option->flags & CL_SEPARATE)
609 && !(option->cl_no_driver_arg
610 && (lang_mask & CL_DRIVER)));
611 joined_arg_flag = (option->flags & CL_JOINED) != 0;
613 if (separate_args > 1 || option->cl_separate_nargs)
614 gcc_assert (separate_args
615 == (unsigned int) option->cl_separate_nargs + 1);
617 if (!(errors & CL_ERR_MISSING_ARG))
619 if (separate_arg_flag || joined_arg_flag)
621 if (option->cl_missing_ok && arg == NULL)
623 gcc_assert (arg != NULL);
626 gcc_assert (arg == NULL);
629 /* Recheck for warnings and disabled options. */
630 if (option->warn_message)
632 gcc_assert (warn_message == NULL);
633 warn_message = option->warn_message;
635 if (option->cl_disabled)
636 errors |= CL_ERR_DISABLED;
640 /* Check if this is a switch for a different front end. */
641 if (!option_ok_for_language (option, lang_mask))
642 errors |= CL_ERR_WRONG_LANG;
644 /* Convert the argument to lowercase if appropriate. */
645 if (arg && option->cl_tolower)
648 size_t len = strlen (arg);
649 char *arg_lower = XOBNEWVEC (&opts_obstack, char, len + 1);
651 for (j = 0; j < len; j++)
652 arg_lower[j] = TOLOWER ((unsigned char) arg[j]);
657 /* If the switch takes an integer, convert it. */
658 if (arg && option->cl_uinteger)
660 value = integral_argument (arg);
662 errors |= CL_ERR_UINT_ARG;
665 /* If the switch takes an enumerated argument, convert it. */
666 if (arg && (option->var_type == CLVC_ENUM))
668 const struct cl_enum *e = &cl_enums[option->var_enum];
670 gcc_assert (value == 1);
671 if (enum_arg_to_value (e->values, arg, &value, lang_mask))
673 const char *carg = NULL;
675 if (enum_value_to_arg (e->values, &carg, value, lang_mask))
677 gcc_assert (carg != NULL);
680 errors |= CL_ERR_ENUM_ARG;
684 decoded->opt_index = opt_index;
686 decoded->value = value;
687 decoded->errors = errors;
688 decoded->warn_message = warn_message;
690 if (opt_index == OPT_SPECIAL_unknown)
691 gcc_assert (result == 1);
693 gcc_assert (result >= 1 && result <= ARRAY_SIZE (decoded->canonical_option));
694 decoded->canonical_option_num_elements = result;
696 for (i = 0; i < ARRAY_SIZE (decoded->canonical_option); i++)
701 if (opt_index == OPT_SPECIAL_unknown)
702 decoded->canonical_option[i] = argv[i];
704 decoded->canonical_option[i] = NULL;
705 len = strlen (argv[i]);
706 /* If the argument is an empty string, we will print it as "" in
707 orig_option_with_args_text. */
708 total_len += (len != 0 ? len : 2) + 1;
711 decoded->canonical_option[i] = NULL;
713 if (opt_index != OPT_SPECIAL_unknown && opt_index != OPT_SPECIAL_ignore)
715 generate_canonical_option (opt_index, arg, value, decoded);
716 if (separate_args > 1)
718 for (i = 0; i < separate_args; i++)
720 if (argv[extra_args + 1 + i] == NULL)
723 decoded->canonical_option[1 + i] = argv[extra_args + 1 + i];
725 gcc_assert (result == 1 + i);
726 decoded->canonical_option_num_elements = result;
729 decoded->orig_option_with_args_text
730 = p = XOBNEWVEC (&opts_obstack, char, total_len);
731 for (i = 0; i < result; i++)
733 size_t len = strlen (argv[i]);
735 /* Print the empty string verbally. */
742 memcpy (p, argv[i], len);
753 /* Obstack for option strings. */
755 struct obstack opts_obstack;
757 /* Like libiberty concat, but allocate using opts_obstack. */
760 opts_concat (const char *first, ...)
767 /* First compute the size of the result and get sufficient memory. */
768 va_start (ap, first);
769 for (arg = first; arg; arg = va_arg (ap, const char *))
770 length += strlen (arg);
771 newstr = XOBNEWVEC (&opts_obstack, char, length + 1);
774 /* Now copy the individual pieces to the result string. */
775 va_start (ap, first);
776 for (arg = first, end = newstr; arg; arg = va_arg (ap, const char *))
778 length = strlen (arg);
779 memcpy (end, arg, length);
787 /* Decode command-line options (ARGC and ARGV being the arguments of
788 main) into an array, setting *DECODED_OPTIONS to a pointer to that
789 array and *DECODED_OPTIONS_COUNT to the number of entries in the
790 array. The first entry in the array is always one for the program
791 name (OPT_SPECIAL_program_name). LANG_MASK indicates the language
792 flags applicable for decoding (including CL_COMMON and CL_TARGET if
793 those options should be considered applicable). Do not produce any
794 diagnostics or set state outside of these variables. */
797 decode_cmdline_options_to_array (unsigned int argc, const char **argv,
798 unsigned int lang_mask,
799 struct cl_decoded_option **decoded_options,
800 unsigned int *decoded_options_count)
803 struct cl_decoded_option *opt_array;
804 unsigned int num_decoded_options;
806 opt_array = XNEWVEC (struct cl_decoded_option, argc);
808 opt_array[0].opt_index = OPT_SPECIAL_program_name;
809 opt_array[0].warn_message = NULL;
810 opt_array[0].arg = argv[0];
811 opt_array[0].orig_option_with_args_text = argv[0];
812 opt_array[0].canonical_option_num_elements = 1;
813 opt_array[0].canonical_option[0] = argv[0];
814 opt_array[0].canonical_option[1] = NULL;
815 opt_array[0].canonical_option[2] = NULL;
816 opt_array[0].canonical_option[3] = NULL;
817 opt_array[0].value = 1;
818 opt_array[0].errors = 0;
819 num_decoded_options = 1;
821 for (i = 1; i < argc; i += n)
823 const char *opt = argv[i];
825 /* Interpret "-" or a non-switch as a file name. */
826 if (opt[0] != '-' || opt[1] == '\0')
828 generate_option_input_file (opt, &opt_array[num_decoded_options]);
829 num_decoded_options++;
834 n = decode_cmdline_option (argv + i, lang_mask,
835 &opt_array[num_decoded_options]);
836 num_decoded_options++;
839 *decoded_options = opt_array;
840 *decoded_options_count = num_decoded_options;
841 prune_options (decoded_options, decoded_options_count);
844 /* Return true if NEXT_OPT_IDX cancels OPT_IDX. Return false if the
845 next one is the same as ORIG_NEXT_OPT_IDX. */
848 cancel_option (int opt_idx, int next_opt_idx, int orig_next_opt_idx)
850 /* An option can be canceled by the same option or an option with
852 if (cl_options [next_opt_idx].neg_index == opt_idx)
855 if (cl_options [next_opt_idx].neg_index != orig_next_opt_idx)
856 return cancel_option (opt_idx, cl_options [next_opt_idx].neg_index,
862 /* Filter out options canceled by the ones after them. */
865 prune_options (struct cl_decoded_option **decoded_options,
866 unsigned int *decoded_options_count)
868 unsigned int old_decoded_options_count = *decoded_options_count;
869 struct cl_decoded_option *old_decoded_options = *decoded_options;
870 unsigned int new_decoded_options_count;
871 struct cl_decoded_option *new_decoded_options
872 = XNEWVEC (struct cl_decoded_option, old_decoded_options_count);
874 const struct cl_option *option;
875 unsigned int fdiagnostics_color_idx = 0;
877 /* Remove arguments which are negated by others after them. */
878 new_decoded_options_count = 0;
879 for (i = 0; i < old_decoded_options_count; i++)
881 unsigned int j, opt_idx, next_opt_idx;
883 if (old_decoded_options[i].errors & ~CL_ERR_WRONG_LANG)
886 opt_idx = old_decoded_options[i].opt_index;
889 case OPT_SPECIAL_unknown:
890 case OPT_SPECIAL_ignore:
891 case OPT_SPECIAL_program_name:
892 case OPT_SPECIAL_input_file:
895 /* Do not save OPT_fdiagnostics_color_, just remember the last one. */
896 case OPT_fdiagnostics_color_:
897 fdiagnostics_color_idx = i;
901 gcc_assert (opt_idx < cl_options_count);
902 option = &cl_options[opt_idx];
903 if (option->neg_index < 0)
906 /* Skip joined switches. */
907 if ((option->flags & CL_JOINED))
910 for (j = i + 1; j < old_decoded_options_count; j++)
912 if (old_decoded_options[j].errors & ~CL_ERR_WRONG_LANG)
914 next_opt_idx = old_decoded_options[j].opt_index;
915 if (next_opt_idx >= cl_options_count)
917 if (cl_options[next_opt_idx].neg_index < 0)
919 if ((cl_options[next_opt_idx].flags & CL_JOINED))
921 if (cancel_option (opt_idx, next_opt_idx, next_opt_idx))
924 if (j == old_decoded_options_count)
927 new_decoded_options[new_decoded_options_count]
928 = old_decoded_options[i];
929 new_decoded_options_count++;
935 if (fdiagnostics_color_idx >= 1)
937 /* We put the last -fdiagnostics-color= at the first position
938 after argv[0] so it can take effect immediately. */
939 memmove (new_decoded_options + 2, new_decoded_options + 1,
940 sizeof (struct cl_decoded_option)
941 * (new_decoded_options_count - 1));
942 new_decoded_options[1] = old_decoded_options[fdiagnostics_color_idx];
943 new_decoded_options_count++;
946 free (old_decoded_options);
947 new_decoded_options = XRESIZEVEC (struct cl_decoded_option,
949 new_decoded_options_count);
950 *decoded_options = new_decoded_options;
951 *decoded_options_count = new_decoded_options_count;
954 /* Handle option DECODED for the language indicated by LANG_MASK,
955 using the handlers in HANDLERS and setting fields in OPTS and
956 OPTS_SET. KIND is the diagnostic_t if this is a diagnostics
957 option, DK_UNSPECIFIED otherwise, and LOC is the location of the
958 option for options from the source file, UNKNOWN_LOCATION
959 otherwise. GENERATED_P is true for an option generated as part of
960 processing another option or otherwise generated internally, false
961 for one explicitly passed by the user. Returns false if the switch
962 was invalid. DC is the diagnostic context for options affecting
963 diagnostics state, or NULL. */
966 handle_option (struct gcc_options *opts,
967 struct gcc_options *opts_set,
968 const struct cl_decoded_option *decoded,
969 unsigned int lang_mask, int kind, location_t loc,
970 const struct cl_option_handlers *handlers,
971 bool generated_p, diagnostic_context *dc)
973 size_t opt_index = decoded->opt_index;
974 const char *arg = decoded->arg;
975 int value = decoded->value;
976 const struct cl_option *option = &cl_options[opt_index];
977 void *flag_var = option_flag_var (opt_index, opts);
981 set_option (opts, (generated_p ? NULL : opts_set),
982 opt_index, value, arg, kind, loc, dc);
984 for (i = 0; i < handlers->num_handlers; i++)
985 if (option->flags & handlers->handlers[i].mask)
987 if (!handlers->handlers[i].handler (opts, opts_set, decoded,
988 lang_mask, kind, loc,
996 /* Like handle_option, but OPT_INDEX, ARG and VALUE describe the
997 option instead of DECODED. This is used for callbacks when one
998 option implies another instead of an option being decoded from the
1002 handle_generated_option (struct gcc_options *opts,
1003 struct gcc_options *opts_set,
1004 size_t opt_index, const char *arg, int value,
1005 unsigned int lang_mask, int kind, location_t loc,
1006 const struct cl_option_handlers *handlers,
1007 diagnostic_context *dc)
1009 struct cl_decoded_option decoded;
1011 generate_option (opt_index, arg, value, lang_mask, &decoded);
1012 return handle_option (opts, opts_set, &decoded, lang_mask, kind, loc,
1013 handlers, true, dc);
1016 /* Fill in *DECODED with an option described by OPT_INDEX, ARG and
1017 VALUE for a front end using LANG_MASK. This is used when the
1018 compiler generates options internally. */
1021 generate_option (size_t opt_index, const char *arg, int value,
1022 unsigned int lang_mask, struct cl_decoded_option *decoded)
1024 const struct cl_option *option = &cl_options[opt_index];
1026 decoded->opt_index = opt_index;
1027 decoded->warn_message = NULL;
1029 decoded->value = value;
1030 decoded->errors = (option_ok_for_language (option, lang_mask)
1032 : CL_ERR_WRONG_LANG);
1034 generate_canonical_option (opt_index, arg, value, decoded);
1035 switch (decoded->canonical_option_num_elements)
1038 decoded->orig_option_with_args_text = decoded->canonical_option[0];
1042 decoded->orig_option_with_args_text
1043 = opts_concat (decoded->canonical_option[0], " ",
1044 decoded->canonical_option[1], NULL);
1052 /* Fill in *DECODED with an option for input file FILE. */
1055 generate_option_input_file (const char *file,
1056 struct cl_decoded_option *decoded)
1058 decoded->opt_index = OPT_SPECIAL_input_file;
1059 decoded->warn_message = NULL;
1060 decoded->arg = file;
1061 decoded->orig_option_with_args_text = file;
1062 decoded->canonical_option_num_elements = 1;
1063 decoded->canonical_option[0] = file;
1064 decoded->canonical_option[1] = NULL;
1065 decoded->canonical_option[2] = NULL;
1066 decoded->canonical_option[3] = NULL;
1068 decoded->errors = 0;
1071 /* Perform diagnostics for read_cmdline_option and control_warning_option
1072 functions. Returns true if an error has been diagnosed.
1073 LOC and LANG_MASK arguments like in read_cmdline_option.
1074 OPTION is the option to report diagnostics for, OPT the name
1075 of the option as text, ARG the argument of the option (for joined
1076 options), ERRORS is bitmask of CL_ERR_* values. */
1079 cmdline_handle_error (location_t loc, const struct cl_option *option,
1080 const char *opt, const char *arg, int errors,
1081 unsigned int lang_mask)
1083 if (errors & CL_ERR_DISABLED)
1085 error_at (loc, "command line option %qs"
1086 " is not supported by this configuration", opt);
1090 if (errors & CL_ERR_MISSING_ARG)
1092 if (option->missing_argument_error)
1093 error_at (loc, option->missing_argument_error, opt);
1095 error_at (loc, "missing argument to %qs", opt);
1099 if (errors & CL_ERR_UINT_ARG)
1101 error_at (loc, "argument to %qs should be a non-negative integer",
1106 if (errors & CL_ERR_ENUM_ARG)
1108 const struct cl_enum *e = &cl_enums[option->var_enum];
1113 if (e->unknown_error)
1114 error_at (loc, e->unknown_error, arg);
1116 error_at (loc, "unrecognized argument in option %qs", opt);
1119 for (i = 0; e->values[i].arg != NULL; i++)
1120 len += strlen (e->values[i].arg) + 1;
1122 s = XALLOCAVEC (char, len);
1124 for (i = 0; e->values[i].arg != NULL; i++)
1126 if (!enum_arg_ok_for_language (&e->values[i], lang_mask))
1128 size_t arglen = strlen (e->values[i].arg);
1129 memcpy (p, e->values[i].arg, arglen);
1134 inform (loc, "valid arguments to %qs are: %s", option->opt_text, s);
1141 /* Handle the switch DECODED (location LOC) for the language indicated
1142 by LANG_MASK, using the handlers in *HANDLERS and setting fields in
1143 OPTS and OPTS_SET and using diagnostic context DC (if not NULL) for
1144 diagnostic options. */
1147 read_cmdline_option (struct gcc_options *opts,
1148 struct gcc_options *opts_set,
1149 struct cl_decoded_option *decoded,
1151 unsigned int lang_mask,
1152 const struct cl_option_handlers *handlers,
1153 diagnostic_context *dc)
1155 const struct cl_option *option;
1156 const char *opt = decoded->orig_option_with_args_text;
1158 if (decoded->warn_message)
1159 warning_at (loc, 0, decoded->warn_message, opt);
1161 if (decoded->opt_index == OPT_SPECIAL_unknown)
1163 if (handlers->unknown_option_callback (decoded))
1164 error_at (loc, "unrecognized command line option %qs", decoded->arg);
1168 if (decoded->opt_index == OPT_SPECIAL_ignore)
1171 option = &cl_options[decoded->opt_index];
1174 && cmdline_handle_error (loc, option, opt, decoded->arg,
1175 decoded->errors, lang_mask))
1178 if (decoded->errors & CL_ERR_WRONG_LANG)
1180 handlers->wrong_lang_callback (decoded, lang_mask);
1184 gcc_assert (!decoded->errors);
1186 if (!handle_option (opts, opts_set, decoded, lang_mask, DK_UNSPECIFIED,
1187 loc, handlers, false, dc))
1188 error_at (loc, "unrecognized command line option %qs", opt);
1191 /* Set any field in OPTS, and OPTS_SET if not NULL, for option
1192 OPT_INDEX according to VALUE and ARG, diagnostic kind KIND,
1193 location LOC, using diagnostic context DC if not NULL for
1194 diagnostic classification. */
1197 set_option (struct gcc_options *opts, struct gcc_options *opts_set,
1198 int opt_index, int value, const char *arg, int kind,
1199 location_t loc, diagnostic_context *dc)
1201 const struct cl_option *option = &cl_options[opt_index];
1202 void *flag_var = option_flag_var (opt_index, opts);
1203 void *set_flag_var = NULL;
1208 if ((diagnostic_t) kind != DK_UNSPECIFIED && dc != NULL)
1209 diagnostic_classify_diagnostic (dc, opt_index, (diagnostic_t) kind, loc);
1211 if (opts_set != NULL)
1212 set_flag_var = option_flag_var (opt_index, opts_set);
1214 switch (option->var_type)
1217 *(int *) flag_var = value;
1219 *(int *) set_flag_var = 1;
1223 if (option->cl_host_wide_int)
1224 *(HOST_WIDE_INT *) flag_var = (value
1226 : !option->var_value);
1228 *(int *) flag_var = (value
1230 : !option->var_value);
1232 *(int *) set_flag_var = 1;
1235 case CLVC_BIT_CLEAR:
1237 if ((value != 0) == (option->var_type == CLVC_BIT_SET))
1239 if (option->cl_host_wide_int)
1240 *(HOST_WIDE_INT *) flag_var |= option->var_value;
1242 *(int *) flag_var |= option->var_value;
1246 if (option->cl_host_wide_int)
1247 *(HOST_WIDE_INT *) flag_var &= ~option->var_value;
1249 *(int *) flag_var &= ~option->var_value;
1253 if (option->cl_host_wide_int)
1254 *(HOST_WIDE_INT *) set_flag_var |= option->var_value;
1256 *(int *) set_flag_var |= option->var_value;
1261 *(const char **) flag_var = arg;
1263 *(const char **) set_flag_var = "";
1268 const struct cl_enum *e = &cl_enums[option->var_enum];
1270 e->set (flag_var, value);
1272 e->set (set_flag_var, 1);
1278 vec<cl_deferred_option> *v
1279 = (vec<cl_deferred_option> *) *(void **) flag_var;
1280 cl_deferred_option p = {opt_index, arg, value};
1282 v = XCNEW (vec<cl_deferred_option>);
1284 *(void **) flag_var = v;
1286 *(void **) set_flag_var = v;
1292 /* Return the address of the flag variable for option OPT_INDEX in
1293 options structure OPTS, or NULL if there is no flag variable. */
1296 option_flag_var (int opt_index, struct gcc_options *opts)
1298 const struct cl_option *option = &cl_options[opt_index];
1300 if (option->flag_var_offset == (unsigned short) -1)
1302 return (void *)(((char *) opts) + option->flag_var_offset);
1305 /* Return 1 if option OPT_IDX is enabled in OPTS, 0 if it is disabled,
1306 or -1 if it isn't a simple on-off switch. */
1309 option_enabled (int opt_idx, void *opts)
1311 const struct cl_option *option = &(cl_options[opt_idx]);
1312 struct gcc_options *optsg = (struct gcc_options *) opts;
1313 void *flag_var = option_flag_var (opt_idx, optsg);
1316 switch (option->var_type)
1319 return *(int *) flag_var != 0;
1322 if (option->cl_host_wide_int)
1323 return *(HOST_WIDE_INT *) flag_var == option->var_value;
1325 return *(int *) flag_var == option->var_value;
1327 case CLVC_BIT_CLEAR:
1328 if (option->cl_host_wide_int)
1329 return (*(HOST_WIDE_INT *) flag_var & option->var_value) == 0;
1331 return (*(int *) flag_var & option->var_value) == 0;
1334 if (option->cl_host_wide_int)
1335 return (*(HOST_WIDE_INT *) flag_var & option->var_value) != 0;
1337 return (*(int *) flag_var & option->var_value) != 0;
1347 /* Fill STATE with the current state of option OPTION in OPTS. Return
1348 true if there is some state to store. */
1351 get_option_state (struct gcc_options *opts, int option,
1352 struct cl_option_state *state)
1354 void *flag_var = option_flag_var (option, opts);
1359 switch (cl_options[option].var_type)
1363 state->data = flag_var;
1364 state->size = (cl_options[option].cl_host_wide_int
1365 ? sizeof (HOST_WIDE_INT)
1369 case CLVC_BIT_CLEAR:
1371 state->ch = option_enabled (option, opts);
1372 state->data = &state->ch;
1377 state->data = *(const char **) flag_var;
1378 if (state->data == 0)
1380 state->size = strlen ((const char *) state->data) + 1;
1384 state->data = flag_var;
1385 state->size = cl_enums[cl_options[option].var_enum].var_size;
1394 /* Set a warning option OPT_INDEX (language mask LANG_MASK, option
1395 handlers HANDLERS) to have diagnostic kind KIND for option
1396 structures OPTS and OPTS_SET and diagnostic context DC (possibly
1397 NULL), at location LOC (UNKNOWN_LOCATION for -Werror=). ARG is the
1398 argument of the option for joined options, or NULL otherwise. If IMPLY,
1399 the warning option in question is implied at this point. This is
1400 used by -Werror= and #pragma GCC diagnostic. */
1403 control_warning_option (unsigned int opt_index, int kind, const char *arg,
1404 bool imply, location_t loc, unsigned int lang_mask,
1405 const struct cl_option_handlers *handlers,
1406 struct gcc_options *opts,
1407 struct gcc_options *opts_set,
1408 diagnostic_context *dc)
1410 if (cl_options[opt_index].alias_target != N_OPTS)
1412 gcc_assert (!cl_options[opt_index].cl_separate_alias
1413 && !cl_options[opt_index].cl_negative_alias);
1414 if (cl_options[opt_index].alias_arg)
1415 arg = cl_options[opt_index].alias_arg;
1416 opt_index = cl_options[opt_index].alias_target;
1418 if (opt_index == OPT_SPECIAL_ignore)
1421 diagnostic_classify_diagnostic (dc, opt_index, (diagnostic_t) kind, loc);
1424 const struct cl_option *option = &cl_options[opt_index];
1426 /* -Werror=foo implies -Wfoo. */
1427 if (option->var_type == CLVC_BOOLEAN || option->var_type == CLVC_ENUM)
1431 if (arg && *arg == '\0' && !option->cl_missing_ok)
1434 if ((option->flags & CL_JOINED) && arg == NULL)
1436 cmdline_handle_error (loc, option, option->opt_text, arg,
1437 CL_ERR_MISSING_ARG, lang_mask);
1441 /* If the switch takes an integer, convert it. */
1442 if (arg && option->cl_uinteger)
1444 value = integral_argument (arg);
1447 cmdline_handle_error (loc, option, option->opt_text, arg,
1448 CL_ERR_UINT_ARG, lang_mask);
1453 /* If the switch takes an enumerated argument, convert it. */
1454 if (arg && option->var_type == CLVC_ENUM)
1456 const struct cl_enum *e = &cl_enums[option->var_enum];
1458 if (enum_arg_to_value (e->values, arg, &value, lang_mask))
1460 const char *carg = NULL;
1462 if (enum_value_to_arg (e->values, &carg, value, lang_mask))
1464 gcc_assert (carg != NULL);
1468 cmdline_handle_error (loc, option, option->opt_text, arg,
1469 CL_ERR_ENUM_ARG, lang_mask);
1474 handle_generated_option (opts, opts_set,
1475 opt_index, arg, value, lang_mask,
1476 kind, loc, handlers, dc);