1 /* Command line option handling.
2 Copyright (C) 2006-2017 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"
27 #include "spellcheck.h"
29 static void prune_options (struct cl_decoded_option
**, unsigned int *);
31 /* Perform a binary search to find which option the command-line INPUT
32 matches. Returns its index in the option array, and
33 OPT_SPECIAL_unknown on failure.
35 This routine is quite subtle. A normal binary search is not good
36 enough because some options can be suffixed with an argument, and
37 multiple sub-matches can occur, e.g. input of "-pedantic" matching
38 the initial substring of "-pedantic-errors".
40 A more complicated example is -gstabs. It should match "-g" with
41 an argument of "stabs". Suppose, however, that the number and list
42 of switches are such that the binary search tests "-gen-decls"
43 before having tested "-g". This doesn't match, and as "-gen-decls"
44 is less than "-gstabs", it will become the lower bound of the
45 binary search range, and "-g" will never be seen. To resolve this
46 issue, 'optc-gen.awk' makes "-gen-decls" point, via the back_chain member,
47 to "-g" so that failed searches that end between "-gen-decls" and
48 the lexicographically subsequent switch know to go back and see if
49 "-g" causes a match (which it does in this example).
51 This search is done in such a way that the longest match for the
52 front end in question wins. If there is no match for the current
53 front end, the longest match for a different front end is returned
54 (or N_OPTS if none) and the caller emits an error message. */
56 find_opt (const char *input
, unsigned int lang_mask
)
58 size_t mn
, mn_orig
, mx
, md
, opt_len
;
59 size_t match_wrong_lang
;
63 mx
= cl_options_count
;
65 /* Find mn such this lexicographical inequality holds:
66 cl_options[mn] <= input < cl_options[mn + 1]. */
70 opt_len
= cl_options
[md
].opt_len
;
71 comp
= strncmp (input
, cl_options
[md
].opt_text
+ 1, opt_len
);
81 /* This is the switch that is the best match but for a different
82 front end, or OPT_SPECIAL_unknown if there is no match at all. */
83 match_wrong_lang
= OPT_SPECIAL_unknown
;
85 /* Backtrace the chain of possible matches, returning the longest
86 one, if any, that fits best. With current GCC switches, this
87 loop executes at most twice. */
90 const struct cl_option
*opt
= &cl_options
[mn
];
92 /* Is the input either an exact match or a prefix that takes a
94 if (!strncmp (input
, opt
->opt_text
+ 1, opt
->opt_len
)
95 && (input
[opt
->opt_len
] == '\0' || (opt
->flags
& CL_JOINED
)))
97 /* If language is OK, return it. */
98 if (opt
->flags
& lang_mask
)
101 /* If we haven't remembered a prior match, remember this
102 one. Any prior match is necessarily better. */
103 if (match_wrong_lang
== OPT_SPECIAL_unknown
)
104 match_wrong_lang
= mn
;
107 /* Try the next possibility. This is cl_options_count if there
109 mn
= opt
->back_chain
;
111 while (mn
!= cl_options_count
);
113 if (match_wrong_lang
== OPT_SPECIAL_unknown
&& input
[0] == '-')
115 /* Long options, starting "--", may be abbreviated if the
116 abbreviation is unambiguous. This only applies to options
117 not taking a joined argument, and abbreviations of "--option"
118 are permitted even if there is a variant "--option=". */
119 size_t mnc
= mn_orig
+ 1;
120 size_t cmp_len
= strlen (input
);
121 while (mnc
< cl_options_count
122 && strncmp (input
, cl_options
[mnc
].opt_text
+ 1, cmp_len
) == 0)
124 /* Option matching this abbreviation. OK if it is the first
125 match and that does not take a joined argument, or the
126 second match, taking a joined argument and with only '='
127 added to the first match; otherwise considered
129 if (mnc
== mn_orig
+ 1
130 && !(cl_options
[mnc
].flags
& CL_JOINED
))
131 match_wrong_lang
= mnc
;
132 else if (mnc
== mn_orig
+ 2
133 && match_wrong_lang
== mn_orig
+ 1
134 && (cl_options
[mnc
].flags
& CL_JOINED
)
135 && (cl_options
[mnc
].opt_len
136 == cl_options
[mn_orig
+ 1].opt_len
+ 1)
137 && strncmp (cl_options
[mnc
].opt_text
+ 1,
138 cl_options
[mn_orig
+ 1].opt_text
+ 1,
139 cl_options
[mn_orig
+ 1].opt_len
) == 0)
140 ; /* OK, as long as there are no more matches. */
142 return OPT_SPECIAL_unknown
;
147 /* Return the best wrong match, or OPT_SPECIAL_unknown if none. */
148 return match_wrong_lang
;
151 /* If ARG is a non-negative decimal or hexadecimal integer, return its
152 value, otherwise return -1. */
155 integral_argument (const char *arg
)
159 while (*p
&& ISDIGIT (*p
))
165 /* It wasn't a decimal number - try hexadecimal. */
166 if (arg
[0] == '0' && (arg
[1] == 'x' || arg
[1] == 'X'))
169 while (*p
&& ISXDIGIT (*p
))
172 if (p
!= arg
+ 2 && *p
== '\0')
173 return strtol (arg
, NULL
, 16);
179 /* Return whether OPTION is OK for the language given by
182 option_ok_for_language (const struct cl_option
*option
,
183 unsigned int lang_mask
)
185 if (!(option
->flags
& lang_mask
))
187 else if ((option
->flags
& CL_TARGET
)
188 && (option
->flags
& (CL_LANG_ALL
| CL_DRIVER
))
189 && !(option
->flags
& (lang_mask
& ~CL_COMMON
& ~CL_TARGET
)))
190 /* Complain for target flag language mismatches if any languages
196 /* Return whether ENUM_ARG is OK for the language given by
200 enum_arg_ok_for_language (const struct cl_enum_arg
*enum_arg
,
201 unsigned int lang_mask
)
203 return (lang_mask
& CL_DRIVER
) || !(enum_arg
->flags
& CL_ENUM_DRIVER_ONLY
);
206 /* Look up ARG in ENUM_ARGS for language LANG_MASK, returning true and
207 storing the value in *VALUE if found, and returning false without
208 modifying *VALUE if not found. */
211 enum_arg_to_value (const struct cl_enum_arg
*enum_args
,
212 const char *arg
, int *value
, unsigned int lang_mask
)
216 for (i
= 0; enum_args
[i
].arg
!= NULL
; i
++)
217 if (strcmp (arg
, enum_args
[i
].arg
) == 0
218 && enum_arg_ok_for_language (&enum_args
[i
], lang_mask
))
220 *value
= enum_args
[i
].value
;
227 /* Look up ARG in the enum used by option OPT_INDEX for language
228 LANG_MASK, returning true and storing the value in *VALUE if found,
229 and returning false without modifying *VALUE if not found. */
232 opt_enum_arg_to_value (size_t opt_index
, const char *arg
, int *value
,
233 unsigned int lang_mask
)
235 const struct cl_option
*option
= &cl_options
[opt_index
];
237 gcc_assert (option
->var_type
== CLVC_ENUM
);
239 return enum_arg_to_value (cl_enums
[option
->var_enum
].values
, arg
,
243 /* Look of VALUE in ENUM_ARGS for language LANG_MASK and store the
244 corresponding string in *ARGP, returning true if the found string
245 was marked as canonical, false otherwise. If VALUE is not found
246 (which may be the case for uninitialized values if the relevant
247 option has not been passed), set *ARGP to NULL and return
251 enum_value_to_arg (const struct cl_enum_arg
*enum_args
,
252 const char **argp
, int value
, unsigned int lang_mask
)
256 for (i
= 0; enum_args
[i
].arg
!= NULL
; i
++)
257 if (enum_args
[i
].value
== value
258 && (enum_args
[i
].flags
& CL_ENUM_CANONICAL
)
259 && enum_arg_ok_for_language (&enum_args
[i
], lang_mask
))
261 *argp
= enum_args
[i
].arg
;
265 for (i
= 0; enum_args
[i
].arg
!= NULL
; i
++)
266 if (enum_args
[i
].value
== value
267 && enum_arg_ok_for_language (&enum_args
[i
], lang_mask
))
269 *argp
= enum_args
[i
].arg
;
277 /* Fill in the canonical option part of *DECODED with an option
278 described by OPT_INDEX, ARG and VALUE. */
281 generate_canonical_option (size_t opt_index
, const char *arg
, int value
,
282 struct cl_decoded_option
*decoded
)
284 const struct cl_option
*option
= &cl_options
[opt_index
];
285 const char *opt_text
= option
->opt_text
;
288 && !option
->cl_reject_negative
289 && (opt_text
[1] == 'W' || opt_text
[1] == 'f' || opt_text
[1] == 'm'))
291 char *t
= XOBNEWVEC (&opts_obstack
, char, option
->opt_len
+ 5);
297 memcpy (t
+ 5, opt_text
+ 2, option
->opt_len
);
301 decoded
->canonical_option
[2] = NULL
;
302 decoded
->canonical_option
[3] = NULL
;
306 if ((option
->flags
& CL_SEPARATE
)
307 && !option
->cl_separate_alias
)
309 decoded
->canonical_option
[0] = opt_text
;
310 decoded
->canonical_option
[1] = arg
;
311 decoded
->canonical_option_num_elements
= 2;
315 gcc_assert (option
->flags
& CL_JOINED
);
316 decoded
->canonical_option
[0] = opts_concat (opt_text
, arg
, NULL
);
317 decoded
->canonical_option
[1] = NULL
;
318 decoded
->canonical_option_num_elements
= 1;
323 decoded
->canonical_option
[0] = opt_text
;
324 decoded
->canonical_option
[1] = NULL
;
325 decoded
->canonical_option_num_elements
= 1;
329 /* Structure describing mappings from options on the command line to
330 options to look up with find_opt. */
333 /* Prefix of the option on the command line. */
335 /* If two argv elements are considered to be merged into one option,
336 prefix for the second element, otherwise NULL. */
338 /* The new prefix to map to. */
339 const char *new_prefix
;
340 /* Whether at least one character is needed following opt1 or opt0
341 for this mapping to be used. (--optimize= is valid for -O, but
342 --warn- is not valid for -W.) */
343 bool another_char_needed
;
344 /* Whether the original option is a negated form of the option
345 resulting from this map. */
348 static const struct option_map option_map
[] =
350 { "-Wno-", NULL
, "-W", false, true },
351 { "-fno-", NULL
, "-f", false, true },
352 { "-mno-", NULL
, "-m", false, true },
353 { "--debug=", NULL
, "-g", false, false },
354 { "--machine-", NULL
, "-m", true, false },
355 { "--machine-no-", NULL
, "-m", false, true },
356 { "--machine=", NULL
, "-m", false, false },
357 { "--machine=no-", NULL
, "-m", false, true },
358 { "--machine", "", "-m", false, false },
359 { "--machine", "no-", "-m", false, true },
360 { "--optimize=", NULL
, "-O", false, false },
361 { "--std=", NULL
, "-std=", false, false },
362 { "--std", "", "-std=", false, false },
363 { "--warn-", NULL
, "-W", true, false },
364 { "--warn-no-", NULL
, "-W", false, true },
365 { "--", NULL
, "-f", true, false },
366 { "--no-", NULL
, "-f", false, true }
369 /* Helper function for gcc.c's driver::suggest_option, for populating the
370 vec of suggestions for misspelled options.
372 option_map above provides various prefixes for spelling command-line
373 options, which decode_cmdline_option uses to map spellings of options
374 to specific options. We want to do the reverse: to find all the ways
375 that a user could validly spell an option.
377 Given valid OPT_TEXT (with a leading dash) for OPTION, add it and all
378 of its valid variant spellings to CANDIDATES, each without a leading
381 For example, given "-Wabi-tag", the following are added to CANDIDATES:
387 The added strings must be freed using free. */
390 add_misspelling_candidates (auto_vec
<char *> *candidates
,
391 const struct cl_option
*option
,
392 const char *opt_text
)
394 gcc_assert (candidates
);
396 gcc_assert (opt_text
);
397 candidates
->safe_push (xstrdup (opt_text
+ 1));
398 for (unsigned i
= 0; i
< ARRAY_SIZE (option_map
); i
++)
400 const char *opt0
= option_map
[i
].opt0
;
401 const char *new_prefix
= option_map
[i
].new_prefix
;
402 size_t new_prefix_len
= strlen (new_prefix
);
404 if (option
->cl_reject_negative
&& option_map
[i
].negated
)
407 if (strncmp (opt_text
, new_prefix
, new_prefix_len
) == 0)
409 char *alternative
= concat (opt0
+ 1, opt_text
+ new_prefix_len
,
411 candidates
->safe_push (alternative
);
416 /* Decode the switch beginning at ARGV for the language indicated by
417 LANG_MASK (including CL_COMMON and CL_TARGET if applicable), into
418 the structure *DECODED. Returns the number of switches
422 decode_cmdline_option (const char **argv
, unsigned int lang_mask
,
423 struct cl_decoded_option
*decoded
)
428 unsigned int result
= 1, i
, extra_args
, separate_args
= 0;
432 const struct cl_option
*option
;
434 const char *warn_message
= NULL
;
435 bool separate_arg_flag
;
436 bool joined_arg_flag
;
437 bool have_separate_arg
= false;
441 opt_index
= find_opt (argv
[0] + 1, lang_mask
);
443 while (opt_index
== OPT_SPECIAL_unknown
444 && i
< ARRAY_SIZE (option_map
))
446 const char *opt0
= option_map
[i
].opt0
;
447 const char *opt1
= option_map
[i
].opt1
;
448 const char *new_prefix
= option_map
[i
].new_prefix
;
449 bool another_char_needed
= option_map
[i
].another_char_needed
;
450 size_t opt0_len
= strlen (opt0
);
451 size_t opt1_len
= (opt1
== NULL
? 0 : strlen (opt1
));
452 size_t optn_len
= (opt1
== NULL
? opt0_len
: opt1_len
);
453 size_t new_prefix_len
= strlen (new_prefix
);
455 extra_args
= (opt1
== NULL
? 0 : 1);
456 value
= !option_map
[i
].negated
;
458 if (strncmp (argv
[0], opt0
, opt0_len
) == 0
460 || (argv
[1] != NULL
&& strncmp (argv
[1], opt1
, opt1_len
) == 0))
461 && (!another_char_needed
462 || argv
[extra_args
][optn_len
] != 0))
464 size_t arglen
= strlen (argv
[extra_args
]);
467 adjust_len
= (int) optn_len
- (int) new_prefix_len
;
468 dup
= XNEWVEC (char, arglen
+ 1 - adjust_len
);
469 memcpy (dup
, new_prefix
, new_prefix_len
);
470 memcpy (dup
+ new_prefix_len
, argv
[extra_args
] + optn_len
,
471 arglen
- optn_len
+ 1);
472 opt_index
= find_opt (dup
+ 1, lang_mask
);
478 if (opt_index
== OPT_SPECIAL_unknown
)
486 option
= &cl_options
[opt_index
];
488 /* Reject negative form of switches that don't take negatives as
490 if (!value
&& option
->cl_reject_negative
)
492 opt_index
= OPT_SPECIAL_unknown
;
493 errors
|= CL_ERR_NEGATIVE
;
498 result
= extra_args
+ 1;
499 warn_message
= option
->warn_message
;
501 /* Check to see if the option is disabled for this configuration. */
502 if (option
->cl_disabled
)
503 errors
|= CL_ERR_DISABLED
;
505 /* Determine whether there may be a separate argument based on
506 whether this option is being processed for the driver, and, if
507 so, how many such arguments. */
508 separate_arg_flag
= ((option
->flags
& CL_SEPARATE
)
509 && !(option
->cl_no_driver_arg
510 && (lang_mask
& CL_DRIVER
)));
511 separate_args
= (separate_arg_flag
512 ? option
->cl_separate_nargs
+ 1
514 joined_arg_flag
= (option
->flags
& CL_JOINED
) != 0;
516 /* Sort out any argument the switch takes. */
519 /* Have arg point to the original switch. This is because
520 some code, such as disable_builtin_function, expects its
521 argument to be persistent until the program exits. */
522 arg
= argv
[extra_args
] + cl_options
[opt_index
].opt_len
+ 1 + adjust_len
;
524 if (*arg
== '\0' && !option
->cl_missing_ok
)
526 if (separate_arg_flag
)
528 arg
= argv
[extra_args
+ 1];
529 result
= extra_args
+ 2;
531 result
= extra_args
+ 1;
533 have_separate_arg
= true;
536 /* Missing argument. */
540 else if (separate_arg_flag
)
542 arg
= argv
[extra_args
+ 1];
543 for (i
= 0; i
< separate_args
; i
++)
544 if (argv
[extra_args
+ 1 + i
] == NULL
)
546 errors
|= CL_ERR_MISSING_ARG
;
549 result
= extra_args
+ 1 + i
;
551 have_separate_arg
= true;
554 if (arg
== NULL
&& (separate_arg_flag
|| joined_arg_flag
))
555 errors
|= CL_ERR_MISSING_ARG
;
557 /* Is this option an alias (or an ignored option, marked as an alias
558 of OPT_SPECIAL_ignore)? */
559 if (option
->alias_target
!= N_OPTS
560 && (!option
->cl_separate_alias
|| have_separate_arg
))
562 size_t new_opt_index
= option
->alias_target
;
564 if (new_opt_index
== OPT_SPECIAL_ignore
)
566 gcc_assert (option
->alias_arg
== NULL
);
567 gcc_assert (option
->neg_alias_arg
== NULL
);
568 opt_index
= new_opt_index
;
574 const struct cl_option
*new_option
= &cl_options
[new_opt_index
];
576 /* The new option must not be an alias itself. */
577 gcc_assert (new_option
->alias_target
== N_OPTS
578 || new_option
->cl_separate_alias
);
580 if (option
->neg_alias_arg
)
582 gcc_assert (option
->alias_arg
!= NULL
);
583 gcc_assert (arg
== NULL
);
584 gcc_assert (!option
->cl_negative_alias
);
586 arg
= option
->alias_arg
;
588 arg
= option
->neg_alias_arg
;
591 else if (option
->alias_arg
)
593 gcc_assert (value
== 1);
594 gcc_assert (arg
== NULL
);
595 gcc_assert (!option
->cl_negative_alias
);
596 arg
= option
->alias_arg
;
599 if (option
->cl_negative_alias
)
602 opt_index
= new_opt_index
;
606 gcc_assert (!option
->cl_reject_negative
);
608 /* Recompute what arguments are allowed. */
609 separate_arg_flag
= ((option
->flags
& CL_SEPARATE
)
610 && !(option
->cl_no_driver_arg
611 && (lang_mask
& CL_DRIVER
)));
612 joined_arg_flag
= (option
->flags
& CL_JOINED
) != 0;
614 if (separate_args
> 1 || option
->cl_separate_nargs
)
615 gcc_assert (separate_args
616 == (unsigned int) option
->cl_separate_nargs
+ 1);
618 if (!(errors
& CL_ERR_MISSING_ARG
))
620 if (separate_arg_flag
|| joined_arg_flag
)
622 if (option
->cl_missing_ok
&& arg
== NULL
)
624 gcc_assert (arg
!= NULL
);
627 gcc_assert (arg
== NULL
);
630 /* Recheck for warnings and disabled options. */
631 if (option
->warn_message
)
633 gcc_assert (warn_message
== NULL
);
634 warn_message
= option
->warn_message
;
636 if (option
->cl_disabled
)
637 errors
|= CL_ERR_DISABLED
;
641 /* Check if this is a switch for a different front end. */
642 if (!option_ok_for_language (option
, lang_mask
))
643 errors
|= CL_ERR_WRONG_LANG
;
645 /* Convert the argument to lowercase if appropriate. */
646 if (arg
&& option
->cl_tolower
)
649 size_t len
= strlen (arg
);
650 char *arg_lower
= XOBNEWVEC (&opts_obstack
, char, len
+ 1);
652 for (j
= 0; j
< len
; j
++)
653 arg_lower
[j
] = TOLOWER ((unsigned char) arg
[j
]);
658 /* If the switch takes an integer, convert it. */
659 if (arg
&& option
->cl_uinteger
)
661 value
= integral_argument (arg
);
663 errors
|= CL_ERR_UINT_ARG
;
666 /* If the switch takes an enumerated argument, convert it. */
667 if (arg
&& (option
->var_type
== CLVC_ENUM
))
669 const struct cl_enum
*e
= &cl_enums
[option
->var_enum
];
671 gcc_assert (value
== 1);
672 if (enum_arg_to_value (e
->values
, arg
, &value
, lang_mask
))
674 const char *carg
= NULL
;
676 if (enum_value_to_arg (e
->values
, &carg
, value
, lang_mask
))
678 gcc_assert (carg
!= NULL
);
681 errors
|= CL_ERR_ENUM_ARG
;
685 decoded
->opt_index
= opt_index
;
687 decoded
->value
= value
;
688 decoded
->errors
= errors
;
689 decoded
->warn_message
= warn_message
;
691 if (opt_index
== OPT_SPECIAL_unknown
)
692 gcc_assert (result
== 1);
694 gcc_assert (result
>= 1 && result
<= ARRAY_SIZE (decoded
->canonical_option
));
695 decoded
->canonical_option_num_elements
= result
;
697 for (i
= 0; i
< ARRAY_SIZE (decoded
->canonical_option
); i
++)
702 if (opt_index
== OPT_SPECIAL_unknown
)
703 decoded
->canonical_option
[i
] = argv
[i
];
705 decoded
->canonical_option
[i
] = NULL
;
706 len
= strlen (argv
[i
]);
707 /* If the argument is an empty string, we will print it as "" in
708 orig_option_with_args_text. */
709 total_len
+= (len
!= 0 ? len
: 2) + 1;
712 decoded
->canonical_option
[i
] = NULL
;
714 if (opt_index
!= OPT_SPECIAL_unknown
&& opt_index
!= OPT_SPECIAL_ignore
)
716 generate_canonical_option (opt_index
, arg
, value
, decoded
);
717 if (separate_args
> 1)
719 for (i
= 0; i
< separate_args
; i
++)
721 if (argv
[extra_args
+ 1 + i
] == NULL
)
724 decoded
->canonical_option
[1 + i
] = argv
[extra_args
+ 1 + i
];
726 gcc_assert (result
== 1 + i
);
727 decoded
->canonical_option_num_elements
= result
;
730 decoded
->orig_option_with_args_text
731 = p
= XOBNEWVEC (&opts_obstack
, char, total_len
);
732 for (i
= 0; i
< result
; i
++)
734 size_t len
= strlen (argv
[i
]);
736 /* Print the empty string verbally. */
743 memcpy (p
, argv
[i
], len
);
754 /* Obstack for option strings. */
756 struct obstack opts_obstack
;
758 /* Like libiberty concat, but allocate using opts_obstack. */
761 opts_concat (const char *first
, ...)
768 /* First compute the size of the result and get sufficient memory. */
769 va_start (ap
, first
);
770 for (arg
= first
; arg
; arg
= va_arg (ap
, const char *))
771 length
+= strlen (arg
);
772 newstr
= XOBNEWVEC (&opts_obstack
, char, length
+ 1);
775 /* Now copy the individual pieces to the result string. */
776 va_start (ap
, first
);
777 for (arg
= first
, end
= newstr
; arg
; arg
= va_arg (ap
, const char *))
779 length
= strlen (arg
);
780 memcpy (end
, arg
, length
);
788 /* Decode command-line options (ARGC and ARGV being the arguments of
789 main) into an array, setting *DECODED_OPTIONS to a pointer to that
790 array and *DECODED_OPTIONS_COUNT to the number of entries in the
791 array. The first entry in the array is always one for the program
792 name (OPT_SPECIAL_program_name). LANG_MASK indicates the language
793 flags applicable for decoding (including CL_COMMON and CL_TARGET if
794 those options should be considered applicable). Do not produce any
795 diagnostics or set state outside of these variables. */
798 decode_cmdline_options_to_array (unsigned int argc
, const char **argv
,
799 unsigned int lang_mask
,
800 struct cl_decoded_option
**decoded_options
,
801 unsigned int *decoded_options_count
)
804 struct cl_decoded_option
*opt_array
;
805 unsigned int num_decoded_options
;
807 opt_array
= XNEWVEC (struct cl_decoded_option
, argc
);
809 opt_array
[0].opt_index
= OPT_SPECIAL_program_name
;
810 opt_array
[0].warn_message
= NULL
;
811 opt_array
[0].arg
= argv
[0];
812 opt_array
[0].orig_option_with_args_text
= argv
[0];
813 opt_array
[0].canonical_option_num_elements
= 1;
814 opt_array
[0].canonical_option
[0] = argv
[0];
815 opt_array
[0].canonical_option
[1] = NULL
;
816 opt_array
[0].canonical_option
[2] = NULL
;
817 opt_array
[0].canonical_option
[3] = NULL
;
818 opt_array
[0].value
= 1;
819 opt_array
[0].errors
= 0;
820 num_decoded_options
= 1;
822 for (i
= 1; i
< argc
; i
+= n
)
824 const char *opt
= argv
[i
];
826 /* Interpret "-" or a non-switch as a file name. */
827 if (opt
[0] != '-' || opt
[1] == '\0')
829 generate_option_input_file (opt
, &opt_array
[num_decoded_options
]);
830 num_decoded_options
++;
835 n
= decode_cmdline_option (argv
+ i
, lang_mask
,
836 &opt_array
[num_decoded_options
]);
837 num_decoded_options
++;
840 *decoded_options
= opt_array
;
841 *decoded_options_count
= num_decoded_options
;
842 prune_options (decoded_options
, decoded_options_count
);
845 /* Return true if NEXT_OPT_IDX cancels OPT_IDX. Return false if the
846 next one is the same as ORIG_NEXT_OPT_IDX. */
849 cancel_option (int opt_idx
, int next_opt_idx
, int orig_next_opt_idx
)
851 /* An option can be canceled by the same option or an option with
853 if (cl_options
[next_opt_idx
].neg_index
== opt_idx
)
856 if (cl_options
[next_opt_idx
].neg_index
!= orig_next_opt_idx
)
857 return cancel_option (opt_idx
, cl_options
[next_opt_idx
].neg_index
,
863 /* Filter out options canceled by the ones after them. */
866 prune_options (struct cl_decoded_option
**decoded_options
,
867 unsigned int *decoded_options_count
)
869 unsigned int old_decoded_options_count
= *decoded_options_count
;
870 struct cl_decoded_option
*old_decoded_options
= *decoded_options
;
871 unsigned int new_decoded_options_count
;
872 struct cl_decoded_option
*new_decoded_options
873 = XNEWVEC (struct cl_decoded_option
, old_decoded_options_count
);
875 const struct cl_option
*option
;
876 unsigned int fdiagnostics_color_idx
= 0;
878 /* Remove arguments which are negated by others after them. */
879 new_decoded_options_count
= 0;
880 for (i
= 0; i
< old_decoded_options_count
; i
++)
882 unsigned int j
, opt_idx
, next_opt_idx
;
884 if (old_decoded_options
[i
].errors
& ~CL_ERR_WRONG_LANG
)
887 opt_idx
= old_decoded_options
[i
].opt_index
;
890 case OPT_SPECIAL_unknown
:
891 case OPT_SPECIAL_ignore
:
892 case OPT_SPECIAL_program_name
:
893 case OPT_SPECIAL_input_file
:
896 /* Do not save OPT_fdiagnostics_color_, just remember the last one. */
897 case OPT_fdiagnostics_color_
:
898 fdiagnostics_color_idx
= i
;
902 gcc_assert (opt_idx
< cl_options_count
);
903 option
= &cl_options
[opt_idx
];
904 if (option
->neg_index
< 0)
907 /* Skip joined switches. */
908 if ((option
->flags
& CL_JOINED
))
911 for (j
= i
+ 1; j
< old_decoded_options_count
; j
++)
913 if (old_decoded_options
[j
].errors
& ~CL_ERR_WRONG_LANG
)
915 next_opt_idx
= old_decoded_options
[j
].opt_index
;
916 if (next_opt_idx
>= cl_options_count
)
918 if (cl_options
[next_opt_idx
].neg_index
< 0)
920 if ((cl_options
[next_opt_idx
].flags
& CL_JOINED
))
922 if (cancel_option (opt_idx
, next_opt_idx
, next_opt_idx
))
925 if (j
== old_decoded_options_count
)
928 new_decoded_options
[new_decoded_options_count
]
929 = old_decoded_options
[i
];
930 new_decoded_options_count
++;
936 if (fdiagnostics_color_idx
>= 1)
938 /* We put the last -fdiagnostics-color= at the first position
939 after argv[0] so it can take effect immediately. */
940 memmove (new_decoded_options
+ 2, new_decoded_options
+ 1,
941 sizeof (struct cl_decoded_option
)
942 * (new_decoded_options_count
- 1));
943 new_decoded_options
[1] = old_decoded_options
[fdiagnostics_color_idx
];
944 new_decoded_options_count
++;
947 free (old_decoded_options
);
948 new_decoded_options
= XRESIZEVEC (struct cl_decoded_option
,
950 new_decoded_options_count
);
951 *decoded_options
= new_decoded_options
;
952 *decoded_options_count
= new_decoded_options_count
;
955 /* Handle option DECODED for the language indicated by LANG_MASK,
956 using the handlers in HANDLERS and setting fields in OPTS and
957 OPTS_SET. KIND is the diagnostic_t if this is a diagnostics
958 option, DK_UNSPECIFIED otherwise, and LOC is the location of the
959 option for options from the source file, UNKNOWN_LOCATION
960 otherwise. GENERATED_P is true for an option generated as part of
961 processing another option or otherwise generated internally, false
962 for one explicitly passed by the user. control_warning_option
963 generated options are considered explicitly passed by the user.
964 Returns false if the switch was invalid. DC is the diagnostic
965 context for options affecting diagnostics state, or NULL. */
968 handle_option (struct gcc_options
*opts
,
969 struct gcc_options
*opts_set
,
970 const struct cl_decoded_option
*decoded
,
971 unsigned int lang_mask
, int kind
, location_t loc
,
972 const struct cl_option_handlers
*handlers
,
973 bool generated_p
, diagnostic_context
*dc
)
975 size_t opt_index
= decoded
->opt_index
;
976 const char *arg
= decoded
->arg
;
977 int value
= decoded
->value
;
978 const struct cl_option
*option
= &cl_options
[opt_index
];
979 void *flag_var
= option_flag_var (opt_index
, opts
);
983 set_option (opts
, (generated_p
? NULL
: opts_set
),
984 opt_index
, value
, arg
, kind
, loc
, dc
);
986 for (i
= 0; i
< handlers
->num_handlers
; i
++)
987 if (option
->flags
& handlers
->handlers
[i
].mask
)
989 if (!handlers
->handlers
[i
].handler (opts
, opts_set
, decoded
,
990 lang_mask
, kind
, loc
,
998 /* Like handle_option, but OPT_INDEX, ARG and VALUE describe the
999 option instead of DECODED. This is used for callbacks when one
1000 option implies another instead of an option being decoded from the
1004 handle_generated_option (struct gcc_options
*opts
,
1005 struct gcc_options
*opts_set
,
1006 size_t opt_index
, const char *arg
, int value
,
1007 unsigned int lang_mask
, int kind
, location_t loc
,
1008 const struct cl_option_handlers
*handlers
,
1009 bool generated_p
, diagnostic_context
*dc
)
1011 struct cl_decoded_option decoded
;
1013 generate_option (opt_index
, arg
, value
, lang_mask
, &decoded
);
1014 return handle_option (opts
, opts_set
, &decoded
, lang_mask
, kind
, loc
,
1015 handlers
, generated_p
, dc
);
1018 /* Fill in *DECODED with an option described by OPT_INDEX, ARG and
1019 VALUE for a front end using LANG_MASK. This is used when the
1020 compiler generates options internally. */
1023 generate_option (size_t opt_index
, const char *arg
, int value
,
1024 unsigned int lang_mask
, struct cl_decoded_option
*decoded
)
1026 const struct cl_option
*option
= &cl_options
[opt_index
];
1028 decoded
->opt_index
= opt_index
;
1029 decoded
->warn_message
= NULL
;
1031 decoded
->value
= value
;
1032 decoded
->errors
= (option_ok_for_language (option
, lang_mask
)
1034 : CL_ERR_WRONG_LANG
);
1036 generate_canonical_option (opt_index
, arg
, value
, decoded
);
1037 switch (decoded
->canonical_option_num_elements
)
1040 decoded
->orig_option_with_args_text
= decoded
->canonical_option
[0];
1044 decoded
->orig_option_with_args_text
1045 = opts_concat (decoded
->canonical_option
[0], " ",
1046 decoded
->canonical_option
[1], NULL
);
1054 /* Fill in *DECODED with an option for input file FILE. */
1057 generate_option_input_file (const char *file
,
1058 struct cl_decoded_option
*decoded
)
1060 decoded
->opt_index
= OPT_SPECIAL_input_file
;
1061 decoded
->warn_message
= NULL
;
1062 decoded
->arg
= file
;
1063 decoded
->orig_option_with_args_text
= file
;
1064 decoded
->canonical_option_num_elements
= 1;
1065 decoded
->canonical_option
[0] = file
;
1066 decoded
->canonical_option
[1] = NULL
;
1067 decoded
->canonical_option
[2] = NULL
;
1068 decoded
->canonical_option
[3] = NULL
;
1070 decoded
->errors
= 0;
1073 /* Helper function for listing valid choices and hint for misspelled
1074 value. CANDIDATES is a vector containing all valid strings,
1075 STR is set to a heap allocated string that contains all those
1076 strings concatenated, separated by spaces, and the return value
1077 is the closest string from those to ARG, or NULL if nothing is
1078 close enough. Callers should XDELETEVEC (STR) after using it
1079 to avoid memory leaks. */
1082 candidates_list_and_hint (const char *arg
, char *&str
,
1083 const auto_vec
<const char *> &candidates
)
1087 const char *candidate
;
1090 FOR_EACH_VEC_ELT (candidates
, i
, candidate
)
1091 len
+= strlen (candidate
) + 1;
1093 str
= p
= XNEWVEC (char, len
);
1094 FOR_EACH_VEC_ELT (candidates
, i
, candidate
)
1096 len
= strlen (candidate
);
1097 memcpy (p
, candidate
, len
);
1102 return find_closest_string (arg
, &candidates
);
1105 /* Perform diagnostics for read_cmdline_option and control_warning_option
1106 functions. Returns true if an error has been diagnosed.
1107 LOC and LANG_MASK arguments like in read_cmdline_option.
1108 OPTION is the option to report diagnostics for, OPT the name
1109 of the option as text, ARG the argument of the option (for joined
1110 options), ERRORS is bitmask of CL_ERR_* values. */
1113 cmdline_handle_error (location_t loc
, const struct cl_option
*option
,
1114 const char *opt
, const char *arg
, int errors
,
1115 unsigned int lang_mask
)
1117 if (errors
& CL_ERR_DISABLED
)
1119 error_at (loc
, "command line option %qs"
1120 " is not supported by this configuration", opt
);
1124 if (errors
& CL_ERR_MISSING_ARG
)
1126 if (option
->missing_argument_error
)
1127 error_at (loc
, option
->missing_argument_error
, opt
);
1129 error_at (loc
, "missing argument to %qs", opt
);
1133 if (errors
& CL_ERR_UINT_ARG
)
1135 error_at (loc
, "argument to %qs should be a non-negative integer",
1140 if (errors
& CL_ERR_ENUM_ARG
)
1142 const struct cl_enum
*e
= &cl_enums
[option
->var_enum
];
1146 if (e
->unknown_error
)
1147 error_at (loc
, e
->unknown_error
, arg
);
1149 error_at (loc
, "unrecognized argument in option %qs", opt
);
1151 auto_vec
<const char *> candidates
;
1152 for (i
= 0; e
->values
[i
].arg
!= NULL
; i
++)
1154 if (!enum_arg_ok_for_language (&e
->values
[i
], lang_mask
))
1156 candidates
.safe_push (e
->values
[i
].arg
);
1158 const char *hint
= candidates_list_and_hint (arg
, s
, candidates
);
1160 inform (loc
, "valid arguments to %qs are: %s; did you mean %qs?",
1161 option
->opt_text
, s
, hint
);
1163 inform (loc
, "valid arguments to %qs are: %s", option
->opt_text
, s
);
1172 /* Handle the switch DECODED (location LOC) for the language indicated
1173 by LANG_MASK, using the handlers in *HANDLERS and setting fields in
1174 OPTS and OPTS_SET and using diagnostic context DC (if not NULL) for
1175 diagnostic options. */
1178 read_cmdline_option (struct gcc_options
*opts
,
1179 struct gcc_options
*opts_set
,
1180 struct cl_decoded_option
*decoded
,
1182 unsigned int lang_mask
,
1183 const struct cl_option_handlers
*handlers
,
1184 diagnostic_context
*dc
)
1186 const struct cl_option
*option
;
1187 const char *opt
= decoded
->orig_option_with_args_text
;
1189 if (decoded
->warn_message
)
1190 warning_at (loc
, 0, decoded
->warn_message
, opt
);
1192 if (decoded
->opt_index
== OPT_SPECIAL_unknown
)
1194 if (handlers
->unknown_option_callback (decoded
))
1195 error_at (loc
, "unrecognized command line option %qs", decoded
->arg
);
1199 if (decoded
->opt_index
== OPT_SPECIAL_ignore
)
1202 option
= &cl_options
[decoded
->opt_index
];
1205 && cmdline_handle_error (loc
, option
, opt
, decoded
->arg
,
1206 decoded
->errors
, lang_mask
))
1209 if (decoded
->errors
& CL_ERR_WRONG_LANG
)
1211 handlers
->wrong_lang_callback (decoded
, lang_mask
);
1215 gcc_assert (!decoded
->errors
);
1217 if (!handle_option (opts
, opts_set
, decoded
, lang_mask
, DK_UNSPECIFIED
,
1218 loc
, handlers
, false, dc
))
1219 error_at (loc
, "unrecognized command line option %qs", opt
);
1222 /* Set any field in OPTS, and OPTS_SET if not NULL, for option
1223 OPT_INDEX according to VALUE and ARG, diagnostic kind KIND,
1224 location LOC, using diagnostic context DC if not NULL for
1225 diagnostic classification. */
1228 set_option (struct gcc_options
*opts
, struct gcc_options
*opts_set
,
1229 int opt_index
, int value
, const char *arg
, int kind
,
1230 location_t loc
, diagnostic_context
*dc
)
1232 const struct cl_option
*option
= &cl_options
[opt_index
];
1233 void *flag_var
= option_flag_var (opt_index
, opts
);
1234 void *set_flag_var
= NULL
;
1239 if ((diagnostic_t
) kind
!= DK_UNSPECIFIED
&& dc
!= NULL
)
1240 diagnostic_classify_diagnostic (dc
, opt_index
, (diagnostic_t
) kind
, loc
);
1242 if (opts_set
!= NULL
)
1243 set_flag_var
= option_flag_var (opt_index
, opts_set
);
1245 switch (option
->var_type
)
1248 *(int *) flag_var
= value
;
1250 *(int *) set_flag_var
= 1;
1254 if (option
->cl_host_wide_int
)
1255 *(HOST_WIDE_INT
*) flag_var
= (value
1257 : !option
->var_value
);
1259 *(int *) flag_var
= (value
1261 : !option
->var_value
);
1263 *(int *) set_flag_var
= 1;
1266 case CLVC_BIT_CLEAR
:
1268 if ((value
!= 0) == (option
->var_type
== CLVC_BIT_SET
))
1270 if (option
->cl_host_wide_int
)
1271 *(HOST_WIDE_INT
*) flag_var
|= option
->var_value
;
1273 *(int *) flag_var
|= option
->var_value
;
1277 if (option
->cl_host_wide_int
)
1278 *(HOST_WIDE_INT
*) flag_var
&= ~option
->var_value
;
1280 *(int *) flag_var
&= ~option
->var_value
;
1284 if (option
->cl_host_wide_int
)
1285 *(HOST_WIDE_INT
*) set_flag_var
|= option
->var_value
;
1287 *(int *) set_flag_var
|= option
->var_value
;
1292 *(const char **) flag_var
= arg
;
1294 *(const char **) set_flag_var
= "";
1299 const struct cl_enum
*e
= &cl_enums
[option
->var_enum
];
1301 e
->set (flag_var
, value
);
1303 e
->set (set_flag_var
, 1);
1309 vec
<cl_deferred_option
> *v
1310 = (vec
<cl_deferred_option
> *) *(void **) flag_var
;
1311 cl_deferred_option p
= {opt_index
, arg
, value
};
1313 v
= XCNEW (vec
<cl_deferred_option
>);
1315 *(void **) flag_var
= v
;
1317 *(void **) set_flag_var
= v
;
1323 /* Return the address of the flag variable for option OPT_INDEX in
1324 options structure OPTS, or NULL if there is no flag variable. */
1327 option_flag_var (int opt_index
, struct gcc_options
*opts
)
1329 const struct cl_option
*option
= &cl_options
[opt_index
];
1331 if (option
->flag_var_offset
== (unsigned short) -1)
1333 return (void *)(((char *) opts
) + option
->flag_var_offset
);
1336 /* Return 1 if option OPT_IDX is enabled in OPTS, 0 if it is disabled,
1337 or -1 if it isn't a simple on-off switch. */
1340 option_enabled (int opt_idx
, void *opts
)
1342 const struct cl_option
*option
= &(cl_options
[opt_idx
]);
1343 struct gcc_options
*optsg
= (struct gcc_options
*) opts
;
1344 void *flag_var
= option_flag_var (opt_idx
, optsg
);
1347 switch (option
->var_type
)
1350 return *(int *) flag_var
!= 0;
1353 if (option
->cl_host_wide_int
)
1354 return *(HOST_WIDE_INT
*) flag_var
== option
->var_value
;
1356 return *(int *) flag_var
== option
->var_value
;
1358 case CLVC_BIT_CLEAR
:
1359 if (option
->cl_host_wide_int
)
1360 return (*(HOST_WIDE_INT
*) flag_var
& option
->var_value
) == 0;
1362 return (*(int *) flag_var
& option
->var_value
) == 0;
1365 if (option
->cl_host_wide_int
)
1366 return (*(HOST_WIDE_INT
*) flag_var
& option
->var_value
) != 0;
1368 return (*(int *) flag_var
& option
->var_value
) != 0;
1378 /* Fill STATE with the current state of option OPTION in OPTS. Return
1379 true if there is some state to store. */
1382 get_option_state (struct gcc_options
*opts
, int option
,
1383 struct cl_option_state
*state
)
1385 void *flag_var
= option_flag_var (option
, opts
);
1390 switch (cl_options
[option
].var_type
)
1394 state
->data
= flag_var
;
1395 state
->size
= (cl_options
[option
].cl_host_wide_int
1396 ? sizeof (HOST_WIDE_INT
)
1400 case CLVC_BIT_CLEAR
:
1402 state
->ch
= option_enabled (option
, opts
);
1403 state
->data
= &state
->ch
;
1408 state
->data
= *(const char **) flag_var
;
1409 if (state
->data
== 0)
1411 state
->size
= strlen ((const char *) state
->data
) + 1;
1415 state
->data
= flag_var
;
1416 state
->size
= cl_enums
[cl_options
[option
].var_enum
].var_size
;
1425 /* Set a warning option OPT_INDEX (language mask LANG_MASK, option
1426 handlers HANDLERS) to have diagnostic kind KIND for option
1427 structures OPTS and OPTS_SET and diagnostic context DC (possibly
1428 NULL), at location LOC (UNKNOWN_LOCATION for -Werror=). ARG is the
1429 argument of the option for joined options, or NULL otherwise. If IMPLY,
1430 the warning option in question is implied at this point. This is
1431 used by -Werror= and #pragma GCC diagnostic. */
1434 control_warning_option (unsigned int opt_index
, int kind
, const char *arg
,
1435 bool imply
, location_t loc
, unsigned int lang_mask
,
1436 const struct cl_option_handlers
*handlers
,
1437 struct gcc_options
*opts
,
1438 struct gcc_options
*opts_set
,
1439 diagnostic_context
*dc
)
1441 if (cl_options
[opt_index
].alias_target
!= N_OPTS
)
1443 gcc_assert (!cl_options
[opt_index
].cl_separate_alias
1444 && !cl_options
[opt_index
].cl_negative_alias
);
1445 if (cl_options
[opt_index
].alias_arg
)
1446 arg
= cl_options
[opt_index
].alias_arg
;
1447 opt_index
= cl_options
[opt_index
].alias_target
;
1449 if (opt_index
== OPT_SPECIAL_ignore
)
1452 diagnostic_classify_diagnostic (dc
, opt_index
, (diagnostic_t
) kind
, loc
);
1455 const struct cl_option
*option
= &cl_options
[opt_index
];
1457 /* -Werror=foo implies -Wfoo. */
1458 if (option
->var_type
== CLVC_BOOLEAN
|| option
->var_type
== CLVC_ENUM
)
1462 if (arg
&& *arg
== '\0' && !option
->cl_missing_ok
)
1465 if ((option
->flags
& CL_JOINED
) && arg
== NULL
)
1467 cmdline_handle_error (loc
, option
, option
->opt_text
, arg
,
1468 CL_ERR_MISSING_ARG
, lang_mask
);
1472 /* If the switch takes an integer, convert it. */
1473 if (arg
&& option
->cl_uinteger
)
1475 value
= integral_argument (arg
);
1478 cmdline_handle_error (loc
, option
, option
->opt_text
, arg
,
1479 CL_ERR_UINT_ARG
, lang_mask
);
1484 /* If the switch takes an enumerated argument, convert it. */
1485 if (arg
&& option
->var_type
== CLVC_ENUM
)
1487 const struct cl_enum
*e
= &cl_enums
[option
->var_enum
];
1489 if (enum_arg_to_value (e
->values
, arg
, &value
, lang_mask
))
1491 const char *carg
= NULL
;
1493 if (enum_value_to_arg (e
->values
, &carg
, value
, lang_mask
))
1495 gcc_assert (carg
!= NULL
);
1499 cmdline_handle_error (loc
, option
, option
->opt_text
, arg
,
1500 CL_ERR_ENUM_ARG
, lang_mask
);
1505 handle_generated_option (opts
, opts_set
,
1506 opt_index
, arg
, value
, lang_mask
,
1507 kind
, loc
, handlers
, false, dc
);