1 /* Command line option handling.
2 Copyright (C) 2006-2020 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 /* An option that is undocumented, that takes a joined argument, and
32 that doesn't fit any of the classes of uses (language/common,
33 driver, target) is assumed to be a prefix used to catch
34 e.g. negated options, and stop them from being further shortened to
35 a prefix that could use the negated option as an argument. For
36 example, we want -gno-statement-frontiers to be taken as a negation
37 of -gstatement-frontiers, but without catching the gno- prefix and
38 signaling it's to be used for option remapping, it would end up
39 backtracked to g with no-statemnet-frontiers as the debug level. */
42 remapping_prefix_p (const struct cl_option
*opt
)
44 return opt
->flags
& CL_UNDOCUMENTED
45 && opt
->flags
& CL_JOINED
46 && !(opt
->flags
& (CL_DRIVER
| CL_TARGET
| CL_COMMON
| CL_LANG_ALL
));
49 /* Perform a binary search to find which option the command-line INPUT
50 matches. Returns its index in the option array, and
51 OPT_SPECIAL_unknown on failure.
53 This routine is quite subtle. A normal binary search is not good
54 enough because some options can be suffixed with an argument, and
55 multiple sub-matches can occur, e.g. input of "-pedantic" matching
56 the initial substring of "-pedantic-errors".
58 A more complicated example is -gstabs. It should match "-g" with
59 an argument of "stabs". Suppose, however, that the number and list
60 of switches are such that the binary search tests "-gen-decls"
61 before having tested "-g". This doesn't match, and as "-gen-decls"
62 is less than "-gstabs", it will become the lower bound of the
63 binary search range, and "-g" will never be seen. To resolve this
64 issue, 'optc-gen.awk' makes "-gen-decls" point, via the back_chain member,
65 to "-g" so that failed searches that end between "-gen-decls" and
66 the lexicographically subsequent switch know to go back and see if
67 "-g" causes a match (which it does in this example).
69 This search is done in such a way that the longest match for the
70 front end in question wins. If there is no match for the current
71 front end, the longest match for a different front end is returned
72 (or N_OPTS if none) and the caller emits an error message. */
74 find_opt (const char *input
, unsigned int lang_mask
)
76 size_t mn
, mn_orig
, mx
, md
, opt_len
;
77 size_t match_wrong_lang
;
81 mx
= cl_options_count
;
83 /* Find mn such this lexicographical inequality holds:
84 cl_options[mn] <= input < cl_options[mn + 1]. */
88 opt_len
= cl_options
[md
].opt_len
;
89 comp
= strncmp (input
, cl_options
[md
].opt_text
+ 1, opt_len
);
99 /* This is the switch that is the best match but for a different
100 front end, or OPT_SPECIAL_unknown if there is no match at all. */
101 match_wrong_lang
= OPT_SPECIAL_unknown
;
103 /* Backtrace the chain of possible matches, returning the longest
104 one, if any, that fits best. With current GCC switches, this
105 loop executes at most twice. */
108 const struct cl_option
*opt
= &cl_options
[mn
];
110 /* Is the input either an exact match or a prefix that takes a
112 if (!strncmp (input
, opt
->opt_text
+ 1, opt
->opt_len
)
113 && (input
[opt
->opt_len
] == '\0' || (opt
->flags
& CL_JOINED
)))
115 /* If language is OK, return it. */
116 if (opt
->flags
& lang_mask
)
119 if (remapping_prefix_p (opt
))
120 return OPT_SPECIAL_unknown
;
122 /* If we haven't remembered a prior match, remember this
123 one. Any prior match is necessarily better. */
124 if (match_wrong_lang
== OPT_SPECIAL_unknown
)
125 match_wrong_lang
= mn
;
128 /* Try the next possibility. This is cl_options_count if there
130 mn
= opt
->back_chain
;
132 while (mn
!= cl_options_count
);
134 if (match_wrong_lang
== OPT_SPECIAL_unknown
&& input
[0] == '-')
136 /* Long options, starting "--", may be abbreviated if the
137 abbreviation is unambiguous. This only applies to options
138 not taking a joined argument, and abbreviations of "--option"
139 are permitted even if there is a variant "--option=". */
140 size_t mnc
= mn_orig
+ 1;
141 size_t cmp_len
= strlen (input
);
142 while (mnc
< cl_options_count
143 && strncmp (input
, cl_options
[mnc
].opt_text
+ 1, cmp_len
) == 0)
145 /* Option matching this abbreviation. OK if it is the first
146 match and that does not take a joined argument, or the
147 second match, taking a joined argument and with only '='
148 added to the first match; otherwise considered
150 if (mnc
== mn_orig
+ 1
151 && !(cl_options
[mnc
].flags
& CL_JOINED
))
152 match_wrong_lang
= mnc
;
153 else if (mnc
== mn_orig
+ 2
154 && match_wrong_lang
== mn_orig
+ 1
155 && (cl_options
[mnc
].flags
& CL_JOINED
)
156 && (cl_options
[mnc
].opt_len
157 == cl_options
[mn_orig
+ 1].opt_len
+ 1)
158 && strncmp (cl_options
[mnc
].opt_text
+ 1,
159 cl_options
[mn_orig
+ 1].opt_text
+ 1,
160 cl_options
[mn_orig
+ 1].opt_len
) == 0)
161 ; /* OK, as long as there are no more matches. */
163 return OPT_SPECIAL_unknown
;
168 /* Return the best wrong match, or OPT_SPECIAL_unknown if none. */
169 return match_wrong_lang
;
172 /* If ARG is a non-negative decimal or hexadecimal integer representable
173 in HOST_WIDE_INT return its value, otherwise return -1. If ERR is not
174 null set *ERR to zero on success or to EINVAL or to the value of errno
178 integral_argument (const char *arg
, int *err
, bool byte_size_suffix
)
193 unsigned HOST_WIDE_INT unit
= 1;
194 unsigned HOST_WIDE_INT value
= strtoull (arg
, &end
, 10);
196 /* If the value is too large to be represented use the maximum
197 representable value that strtoull sets VALUE to (setting
202 if (!byte_size_suffix
)
205 value
= strtoull (arg
, &end
, 0);
218 /* Numeric option arguments are at most INT_MAX. Make it
219 possible to specify a larger value by accepting common
221 if (!strcmp (end
, "kB"))
223 else if (!strcasecmp (end
, "KiB") || !strcmp (end
, "KB"))
225 else if (!strcmp (end
, "MB"))
226 unit
= HOST_WIDE_INT_UC (1000) * 1000;
227 else if (!strcasecmp (end
, "MiB"))
228 unit
= HOST_WIDE_INT_UC (1024) * 1024;
229 else if (!strcasecmp (end
, "GB"))
230 unit
= HOST_WIDE_INT_UC (1000) * 1000 * 1000;
231 else if (!strcasecmp (end
, "GiB"))
232 unit
= HOST_WIDE_INT_UC (1024) * 1024 * 1024;
233 else if (!strcasecmp (end
, "TB"))
234 unit
= HOST_WIDE_INT_UC (1000) * 1000 * 1000 * 1000;
235 else if (!strcasecmp (end
, "TiB"))
236 unit
= HOST_WIDE_INT_UC (1024) * 1024 * 1024 * 1024;
237 else if (!strcasecmp (end
, "PB"))
238 unit
= HOST_WIDE_INT_UC (1000) * 1000 * 1000 * 1000 * 1000;
239 else if (!strcasecmp (end
, "PiB"))
240 unit
= HOST_WIDE_INT_UC (1024) * 1024 * 1024 * 1024 * 1024;
241 else if (!strcasecmp (end
, "EB"))
242 unit
= HOST_WIDE_INT_UC (1000) * 1000 * 1000 * 1000 * 1000
244 else if (!strcasecmp (end
, "EiB"))
245 unit
= HOST_WIDE_INT_UC (1024) * 1024 * 1024 * 1024 * 1024
249 /* This could mean an unknown suffix or a bad prefix, like
258 unsigned HOST_WIDE_INT prod
= value
* unit
;
259 value
= prod
< value
? HOST_WIDE_INT_M1U
: prod
;
265 /* Return whether OPTION is OK for the language given by
268 option_ok_for_language (const struct cl_option
*option
,
269 unsigned int lang_mask
)
271 if (!(option
->flags
& lang_mask
))
273 else if ((option
->flags
& CL_TARGET
)
274 && (option
->flags
& (CL_LANG_ALL
| CL_DRIVER
))
275 && !(option
->flags
& (lang_mask
& ~CL_COMMON
& ~CL_TARGET
)))
276 /* Complain for target flag language mismatches if any languages
282 /* Return whether ENUM_ARG is OK for the language given by
286 enum_arg_ok_for_language (const struct cl_enum_arg
*enum_arg
,
287 unsigned int lang_mask
)
289 return (lang_mask
& CL_DRIVER
) || !(enum_arg
->flags
& CL_ENUM_DRIVER_ONLY
);
292 /* Look up ARG in ENUM_ARGS for language LANG_MASK, returning true and
293 storing the value in *VALUE if found, and returning false without
294 modifying *VALUE if not found. */
297 enum_arg_to_value (const struct cl_enum_arg
*enum_args
,
298 const char *arg
, HOST_WIDE_INT
*value
,
299 unsigned int lang_mask
)
303 for (i
= 0; enum_args
[i
].arg
!= NULL
; i
++)
304 if (strcmp (arg
, enum_args
[i
].arg
) == 0
305 && enum_arg_ok_for_language (&enum_args
[i
], lang_mask
))
307 *value
= enum_args
[i
].value
;
314 /* Look up ARG in the enum used by option OPT_INDEX for language
315 LANG_MASK, returning true and storing the value in *VALUE if found,
316 and returning false without modifying *VALUE if not found. */
319 opt_enum_arg_to_value (size_t opt_index
, const char *arg
,
320 int *value
, unsigned int lang_mask
)
322 const struct cl_option
*option
= &cl_options
[opt_index
];
324 gcc_assert (option
->var_type
== CLVC_ENUM
);
326 HOST_WIDE_INT wideval
;
327 if (enum_arg_to_value (cl_enums
[option
->var_enum
].values
, arg
,
328 &wideval
, lang_mask
))
337 /* Look of VALUE in ENUM_ARGS for language LANG_MASK and store the
338 corresponding string in *ARGP, returning true if the found string
339 was marked as canonical, false otherwise. If VALUE is not found
340 (which may be the case for uninitialized values if the relevant
341 option has not been passed), set *ARGP to NULL and return
345 enum_value_to_arg (const struct cl_enum_arg
*enum_args
,
346 const char **argp
, int value
, unsigned int lang_mask
)
350 for (i
= 0; enum_args
[i
].arg
!= NULL
; i
++)
351 if (enum_args
[i
].value
== value
352 && (enum_args
[i
].flags
& CL_ENUM_CANONICAL
)
353 && enum_arg_ok_for_language (&enum_args
[i
], lang_mask
))
355 *argp
= enum_args
[i
].arg
;
359 for (i
= 0; enum_args
[i
].arg
!= NULL
; i
++)
360 if (enum_args
[i
].value
== value
361 && enum_arg_ok_for_language (&enum_args
[i
], lang_mask
))
363 *argp
= enum_args
[i
].arg
;
371 /* Fill in the canonical option part of *DECODED with an option
372 described by OPT_INDEX, ARG and VALUE. */
375 generate_canonical_option (size_t opt_index
, const char *arg
,
377 struct cl_decoded_option
*decoded
)
379 const struct cl_option
*option
= &cl_options
[opt_index
];
380 const char *opt_text
= option
->opt_text
;
383 && !option
->cl_reject_negative
384 && (opt_text
[1] == 'W' || opt_text
[1] == 'f'
385 || opt_text
[1] == 'g' || opt_text
[1] == 'm'))
387 char *t
= XOBNEWVEC (&opts_obstack
, char, option
->opt_len
+ 5);
393 memcpy (t
+ 5, opt_text
+ 2, option
->opt_len
);
397 decoded
->canonical_option
[2] = NULL
;
398 decoded
->canonical_option
[3] = NULL
;
402 if ((option
->flags
& CL_SEPARATE
)
403 && !option
->cl_separate_alias
)
405 decoded
->canonical_option
[0] = opt_text
;
406 decoded
->canonical_option
[1] = arg
;
407 decoded
->canonical_option_num_elements
= 2;
411 gcc_assert (option
->flags
& CL_JOINED
);
412 decoded
->canonical_option
[0] = opts_concat (opt_text
, arg
, NULL
);
413 decoded
->canonical_option
[1] = NULL
;
414 decoded
->canonical_option_num_elements
= 1;
419 decoded
->canonical_option
[0] = opt_text
;
420 decoded
->canonical_option
[1] = NULL
;
421 decoded
->canonical_option_num_elements
= 1;
425 /* Structure describing mappings from options on the command line to
426 options to look up with find_opt. */
429 /* Prefix of the option on the command line. */
431 /* If two argv elements are considered to be merged into one option,
432 prefix for the second element, otherwise NULL. */
434 /* The new prefix to map to. */
435 const char *new_prefix
;
436 /* Whether at least one character is needed following opt1 or opt0
437 for this mapping to be used. (--optimize= is valid for -O, but
438 --warn- is not valid for -W.) */
439 bool another_char_needed
;
440 /* Whether the original option is a negated form of the option
441 resulting from this map. */
444 static const struct option_map option_map
[] =
446 { "-Wno-", NULL
, "-W", false, true },
447 { "-fno-", NULL
, "-f", false, true },
448 { "-gno-", NULL
, "-g", false, true },
449 { "-mno-", NULL
, "-m", false, true },
450 { "--debug=", NULL
, "-g", false, false },
451 { "--machine-", NULL
, "-m", true, false },
452 { "--machine-no-", NULL
, "-m", false, true },
453 { "--machine=", NULL
, "-m", false, false },
454 { "--machine=no-", NULL
, "-m", false, true },
455 { "--machine", "", "-m", false, false },
456 { "--machine", "no-", "-m", false, true },
457 { "--optimize=", NULL
, "-O", false, false },
458 { "--std=", NULL
, "-std=", false, false },
459 { "--std", "", "-std=", false, false },
460 { "--warn-", NULL
, "-W", true, false },
461 { "--warn-no-", NULL
, "-W", false, true },
462 { "--", NULL
, "-f", true, false },
463 { "--no-", NULL
, "-f", false, true }
466 /* Helper function for gcc.c's driver::suggest_option, for populating the
467 vec of suggestions for misspelled options.
469 option_map above provides various prefixes for spelling command-line
470 options, which decode_cmdline_option uses to map spellings of options
471 to specific options. We want to do the reverse: to find all the ways
472 that a user could validly spell an option.
474 Given valid OPT_TEXT (with a leading dash) for OPTION, add it and all
475 of its valid variant spellings to CANDIDATES, each without a leading
478 For example, given "-Wabi-tag", the following are added to CANDIDATES:
484 The added strings must be freed using free. */
487 add_misspelling_candidates (auto_vec
<char *> *candidates
,
488 const struct cl_option
*option
,
489 const char *opt_text
)
491 gcc_assert (candidates
);
493 gcc_assert (opt_text
);
494 if (remapping_prefix_p (option
))
496 candidates
->safe_push (xstrdup (opt_text
+ 1));
497 for (unsigned i
= 0; i
< ARRAY_SIZE (option_map
); i
++)
499 const char *opt0
= option_map
[i
].opt0
;
500 const char *new_prefix
= option_map
[i
].new_prefix
;
501 size_t new_prefix_len
= strlen (new_prefix
);
503 if (option
->cl_reject_negative
&& option_map
[i
].negated
)
506 if (strncmp (opt_text
, new_prefix
, new_prefix_len
) == 0)
508 char *alternative
= concat (opt0
+ 1, opt_text
+ new_prefix_len
,
510 candidates
->safe_push (alternative
);
514 /* For all params (e.g. --param=key=value),
515 include also '--param key=value'. */
516 const char *prefix
= "--param=";
517 if (strstr (opt_text
, prefix
) == opt_text
)
519 char *param
= xstrdup (opt_text
+ 1);
520 gcc_assert (param
[6] == '=');
522 candidates
->safe_push (param
);
526 /* Decode the switch beginning at ARGV for the language indicated by
527 LANG_MASK (including CL_COMMON and CL_TARGET if applicable), into
528 the structure *DECODED. Returns the number of switches
532 decode_cmdline_option (const char **argv
, unsigned int lang_mask
,
533 struct cl_decoded_option
*decoded
)
537 HOST_WIDE_INT value
= 1;
538 unsigned int result
= 1, i
, extra_args
, separate_args
= 0;
542 const struct cl_option
*option
;
544 const char *warn_message
= NULL
;
545 bool separate_arg_flag
;
546 bool joined_arg_flag
;
547 bool have_separate_arg
= false;
551 const char *opt_value
= argv
[0] + 1;
552 opt_index
= find_opt (opt_value
, lang_mask
);
554 while (opt_index
== OPT_SPECIAL_unknown
555 && i
< ARRAY_SIZE (option_map
))
557 const char *opt0
= option_map
[i
].opt0
;
558 const char *opt1
= option_map
[i
].opt1
;
559 const char *new_prefix
= option_map
[i
].new_prefix
;
560 bool another_char_needed
= option_map
[i
].another_char_needed
;
561 size_t opt0_len
= strlen (opt0
);
562 size_t opt1_len
= (opt1
== NULL
? 0 : strlen (opt1
));
563 size_t optn_len
= (opt1
== NULL
? opt0_len
: opt1_len
);
564 size_t new_prefix_len
= strlen (new_prefix
);
566 extra_args
= (opt1
== NULL
? 0 : 1);
567 value
= !option_map
[i
].negated
;
569 if (strncmp (argv
[0], opt0
, opt0_len
) == 0
571 || (argv
[1] != NULL
&& strncmp (argv
[1], opt1
, opt1_len
) == 0))
572 && (!another_char_needed
573 || argv
[extra_args
][optn_len
] != 0))
575 size_t arglen
= strlen (argv
[extra_args
]);
578 adjust_len
= (int) optn_len
- (int) new_prefix_len
;
579 dup
= XNEWVEC (char, arglen
+ 1 - adjust_len
);
580 memcpy (dup
, new_prefix
, new_prefix_len
);
581 memcpy (dup
+ new_prefix_len
, argv
[extra_args
] + optn_len
,
582 arglen
- optn_len
+ 1);
583 opt_index
= find_opt (dup
+ 1, lang_mask
);
589 if (opt_index
== OPT_SPECIAL_unknown
)
597 option
= &cl_options
[opt_index
];
599 /* Reject negative form of switches that don't take negatives as
601 if (!value
&& option
->cl_reject_negative
)
603 opt_index
= OPT_SPECIAL_unknown
;
604 errors
|= CL_ERR_NEGATIVE
;
609 /* Clear the initial value for size options (it will be overwritten
610 later based on the Init(value) specification in the opt file. */
611 if (option
->var_type
== CLVC_SIZE
)
614 result
= extra_args
+ 1;
615 warn_message
= option
->warn_message
;
617 /* Check to see if the option is disabled for this configuration. */
618 if (option
->cl_disabled
)
619 errors
|= CL_ERR_DISABLED
;
621 /* Determine whether there may be a separate argument based on
622 whether this option is being processed for the driver, and, if
623 so, how many such arguments. */
624 separate_arg_flag
= ((option
->flags
& CL_SEPARATE
)
625 && !(option
->cl_no_driver_arg
626 && (lang_mask
& CL_DRIVER
)));
627 separate_args
= (separate_arg_flag
628 ? option
->cl_separate_nargs
+ 1
630 joined_arg_flag
= (option
->flags
& CL_JOINED
) != 0;
632 /* Sort out any argument the switch takes. */
635 /* Have arg point to the original switch. This is because
636 some code, such as disable_builtin_function, expects its
637 argument to be persistent until the program exits. */
638 arg
= argv
[extra_args
] + cl_options
[opt_index
].opt_len
+ 1 + adjust_len
;
640 if (*arg
== '\0' && !option
->cl_missing_ok
)
642 if (separate_arg_flag
)
644 arg
= argv
[extra_args
+ 1];
645 result
= extra_args
+ 2;
647 result
= extra_args
+ 1;
649 have_separate_arg
= true;
652 /* Missing argument. */
656 else if (separate_arg_flag
)
658 arg
= argv
[extra_args
+ 1];
659 for (i
= 0; i
< separate_args
; i
++)
660 if (argv
[extra_args
+ 1 + i
] == NULL
)
662 errors
|= CL_ERR_MISSING_ARG
;
665 result
= extra_args
+ 1 + i
;
667 have_separate_arg
= true;
670 if (arg
== NULL
&& (separate_arg_flag
|| joined_arg_flag
))
671 errors
|= CL_ERR_MISSING_ARG
;
673 /* Is this option an alias (or an ignored option, marked as an alias
674 of OPT_SPECIAL_ignore)? */
675 if (option
->alias_target
!= N_OPTS
676 && (!option
->cl_separate_alias
|| have_separate_arg
))
678 size_t new_opt_index
= option
->alias_target
;
680 if (new_opt_index
== OPT_SPECIAL_ignore
681 || new_opt_index
== OPT_SPECIAL_warn_removed
)
683 gcc_assert (option
->alias_arg
== NULL
);
684 gcc_assert (option
->neg_alias_arg
== NULL
);
685 opt_index
= new_opt_index
;
690 const struct cl_option
*new_option
= &cl_options
[new_opt_index
];
692 /* The new option must not be an alias itself. */
693 gcc_assert (new_option
->alias_target
== N_OPTS
694 || new_option
->cl_separate_alias
);
696 if (option
->neg_alias_arg
)
698 gcc_assert (option
->alias_arg
!= NULL
);
699 gcc_assert (arg
== NULL
);
700 gcc_assert (!option
->cl_negative_alias
);
702 arg
= option
->alias_arg
;
704 arg
= option
->neg_alias_arg
;
707 else if (option
->alias_arg
)
709 gcc_assert (value
== 1);
710 gcc_assert (arg
== NULL
);
711 gcc_assert (!option
->cl_negative_alias
);
712 arg
= option
->alias_arg
;
715 if (option
->cl_negative_alias
)
718 opt_index
= new_opt_index
;
722 gcc_assert (!option
->cl_reject_negative
);
724 /* Recompute what arguments are allowed. */
725 separate_arg_flag
= ((option
->flags
& CL_SEPARATE
)
726 && !(option
->cl_no_driver_arg
727 && (lang_mask
& CL_DRIVER
)));
728 joined_arg_flag
= (option
->flags
& CL_JOINED
) != 0;
730 if (separate_args
> 1 || option
->cl_separate_nargs
)
731 gcc_assert (separate_args
732 == (unsigned int) option
->cl_separate_nargs
+ 1);
734 if (!(errors
& CL_ERR_MISSING_ARG
))
736 if (separate_arg_flag
|| joined_arg_flag
)
738 if (option
->cl_missing_ok
&& arg
== NULL
)
740 gcc_assert (arg
!= NULL
);
743 gcc_assert (arg
== NULL
);
746 /* Recheck for warnings and disabled options. */
747 if (option
->warn_message
)
749 gcc_assert (warn_message
== NULL
);
750 warn_message
= option
->warn_message
;
752 if (option
->cl_disabled
)
753 errors
|= CL_ERR_DISABLED
;
757 /* Check if this is a switch for a different front end. */
758 if (!option_ok_for_language (option
, lang_mask
))
759 errors
|= CL_ERR_WRONG_LANG
;
760 else if (strcmp (option
->opt_text
, "-Werror=") == 0
761 && strchr (opt_value
, ',') == NULL
)
763 /* Verify that -Werror argument is a valid warning
765 char *werror_arg
= xstrdup (opt_value
+ 6);
768 size_t warning_index
= find_opt (werror_arg
, lang_mask
);
769 if (warning_index
!= OPT_SPECIAL_unknown
)
771 const struct cl_option
*warning_option
772 = &cl_options
[warning_index
];
773 if (!option_ok_for_language (warning_option
, lang_mask
))
774 errors
|= CL_ERR_WRONG_LANG
;
778 /* Convert the argument to lowercase if appropriate. */
779 if (arg
&& option
->cl_tolower
)
782 size_t len
= strlen (arg
);
783 char *arg_lower
= XOBNEWVEC (&opts_obstack
, char, len
+ 1);
785 for (j
= 0; j
< len
; j
++)
786 arg_lower
[j
] = TOLOWER ((unsigned char) arg
[j
]);
791 /* If the switch takes an integer argument, convert it. */
792 if (arg
&& (option
->cl_uinteger
|| option
->cl_host_wide_int
))
795 value
= *arg
? integral_argument (arg
, &error
, option
->cl_byte_size
) : 0;
797 errors
|= CL_ERR_UINT_ARG
;
799 /* Reject value out of a range. */
800 if (option
->range_max
!= -1
801 && (value
< option
->range_min
|| value
> option
->range_max
))
802 errors
|= CL_ERR_INT_RANGE_ARG
;
805 /* If the switch takes an enumerated argument, convert it. */
806 if (arg
&& (option
->var_type
== CLVC_ENUM
))
808 const struct cl_enum
*e
= &cl_enums
[option
->var_enum
];
810 gcc_assert (value
== 1);
811 if (enum_arg_to_value (e
->values
, arg
, &value
, lang_mask
))
813 const char *carg
= NULL
;
815 if (enum_value_to_arg (e
->values
, &carg
, value
, lang_mask
))
817 gcc_assert (carg
!= NULL
);
820 errors
|= CL_ERR_ENUM_ARG
;
824 decoded
->opt_index
= opt_index
;
826 decoded
->value
= value
;
827 decoded
->errors
= errors
;
828 decoded
->warn_message
= warn_message
;
830 if (opt_index
== OPT_SPECIAL_unknown
)
831 gcc_assert (result
== 1);
833 gcc_assert (result
>= 1 && result
<= ARRAY_SIZE (decoded
->canonical_option
));
834 decoded
->canonical_option_num_elements
= result
;
836 for (i
= 0; i
< ARRAY_SIZE (decoded
->canonical_option
); i
++)
841 if (opt_index
== OPT_SPECIAL_unknown
)
842 decoded
->canonical_option
[i
] = argv
[i
];
844 decoded
->canonical_option
[i
] = NULL
;
845 len
= strlen (argv
[i
]);
846 /* If the argument is an empty string, we will print it as "" in
847 orig_option_with_args_text. */
848 total_len
+= (len
!= 0 ? len
: 2) + 1;
851 decoded
->canonical_option
[i
] = NULL
;
853 if (opt_index
!= OPT_SPECIAL_unknown
&& opt_index
!= OPT_SPECIAL_ignore
854 && opt_index
!= OPT_SPECIAL_warn_removed
)
856 generate_canonical_option (opt_index
, arg
, value
, decoded
);
857 if (separate_args
> 1)
859 for (i
= 0; i
< separate_args
; i
++)
861 if (argv
[extra_args
+ 1 + i
] == NULL
)
864 decoded
->canonical_option
[1 + i
] = argv
[extra_args
+ 1 + i
];
866 gcc_assert (result
== 1 + i
);
867 decoded
->canonical_option_num_elements
= result
;
870 decoded
->orig_option_with_args_text
871 = p
= XOBNEWVEC (&opts_obstack
, char, total_len
);
872 for (i
= 0; i
< result
; i
++)
874 size_t len
= strlen (argv
[i
]);
876 /* Print the empty string verbally. */
883 memcpy (p
, argv
[i
], len
);
894 /* Obstack for option strings. */
896 struct obstack opts_obstack
;
898 /* Like libiberty concat, but allocate using opts_obstack. */
901 opts_concat (const char *first
, ...)
908 /* First compute the size of the result and get sufficient memory. */
909 va_start (ap
, first
);
910 for (arg
= first
; arg
; arg
= va_arg (ap
, const char *))
911 length
+= strlen (arg
);
912 newstr
= XOBNEWVEC (&opts_obstack
, char, length
+ 1);
915 /* Now copy the individual pieces to the result string. */
916 va_start (ap
, first
);
917 for (arg
= first
, end
= newstr
; arg
; arg
= va_arg (ap
, const char *))
919 length
= strlen (arg
);
920 memcpy (end
, arg
, length
);
928 /* Decode command-line options (ARGC and ARGV being the arguments of
929 main) into an array, setting *DECODED_OPTIONS to a pointer to that
930 array and *DECODED_OPTIONS_COUNT to the number of entries in the
931 array. The first entry in the array is always one for the program
932 name (OPT_SPECIAL_program_name). LANG_MASK indicates the language
933 flags applicable for decoding (including CL_COMMON and CL_TARGET if
934 those options should be considered applicable). Do not produce any
935 diagnostics or set state outside of these variables. */
938 decode_cmdline_options_to_array (unsigned int argc
, const char **argv
,
939 unsigned int lang_mask
,
940 struct cl_decoded_option
**decoded_options
,
941 unsigned int *decoded_options_count
)
944 struct cl_decoded_option
*opt_array
;
945 unsigned int num_decoded_options
;
947 opt_array
= XNEWVEC (struct cl_decoded_option
, argc
);
949 opt_array
[0].opt_index
= OPT_SPECIAL_program_name
;
950 opt_array
[0].warn_message
= NULL
;
951 opt_array
[0].arg
= argv
[0];
952 opt_array
[0].orig_option_with_args_text
= argv
[0];
953 opt_array
[0].canonical_option_num_elements
= 1;
954 opt_array
[0].canonical_option
[0] = argv
[0];
955 opt_array
[0].canonical_option
[1] = NULL
;
956 opt_array
[0].canonical_option
[2] = NULL
;
957 opt_array
[0].canonical_option
[3] = NULL
;
958 opt_array
[0].value
= 1;
959 opt_array
[0].errors
= 0;
960 num_decoded_options
= 1;
962 for (i
= 1; i
< argc
; i
+= n
)
964 const char *opt
= argv
[i
];
966 /* Interpret "-" or a non-switch as a file name. */
967 if (opt
[0] != '-' || opt
[1] == '\0')
969 generate_option_input_file (opt
, &opt_array
[num_decoded_options
]);
970 num_decoded_options
++;
975 /* Interpret "--param" "key=name" as "--param=key=name". */
976 const char *needle
= "--param";
977 if (i
+ 1 < argc
&& strcmp (opt
, needle
) == 0)
979 const char *replacement
980 = opts_concat (needle
, "=", argv
[i
+ 1], NULL
);
981 argv
[++i
] = replacement
;
984 n
= decode_cmdline_option (argv
+ i
, lang_mask
,
985 &opt_array
[num_decoded_options
]);
986 num_decoded_options
++;
989 *decoded_options
= opt_array
;
990 *decoded_options_count
= num_decoded_options
;
991 prune_options (decoded_options
, decoded_options_count
);
994 /* Return true if NEXT_OPT_IDX cancels OPT_IDX. Return false if the
995 next one is the same as ORIG_NEXT_OPT_IDX. */
998 cancel_option (int opt_idx
, int next_opt_idx
, int orig_next_opt_idx
)
1000 /* An option can be canceled by the same option or an option with
1002 if (cl_options
[next_opt_idx
].neg_index
== opt_idx
)
1005 if (cl_options
[next_opt_idx
].neg_index
!= orig_next_opt_idx
)
1006 return cancel_option (opt_idx
, cl_options
[next_opt_idx
].neg_index
,
1012 /* Filter out options canceled by the ones after them. */
1015 prune_options (struct cl_decoded_option
**decoded_options
,
1016 unsigned int *decoded_options_count
)
1018 unsigned int old_decoded_options_count
= *decoded_options_count
;
1019 struct cl_decoded_option
*old_decoded_options
= *decoded_options
;
1020 unsigned int new_decoded_options_count
;
1021 struct cl_decoded_option
*new_decoded_options
1022 = XNEWVEC (struct cl_decoded_option
, old_decoded_options_count
);
1024 const struct cl_option
*option
;
1025 unsigned int fdiagnostics_color_idx
= 0;
1027 /* Remove arguments which are negated by others after them. */
1028 new_decoded_options_count
= 0;
1029 for (i
= 0; i
< old_decoded_options_count
; i
++)
1031 unsigned int j
, opt_idx
, next_opt_idx
;
1033 if (old_decoded_options
[i
].errors
& ~CL_ERR_WRONG_LANG
)
1036 opt_idx
= old_decoded_options
[i
].opt_index
;
1039 case OPT_SPECIAL_unknown
:
1040 case OPT_SPECIAL_ignore
:
1041 case OPT_SPECIAL_warn_removed
:
1042 case OPT_SPECIAL_program_name
:
1043 case OPT_SPECIAL_input_file
:
1046 /* Do not save OPT_fdiagnostics_color_, just remember the last one. */
1047 case OPT_fdiagnostics_color_
:
1048 fdiagnostics_color_idx
= i
;
1052 gcc_assert (opt_idx
< cl_options_count
);
1053 option
= &cl_options
[opt_idx
];
1054 if (option
->neg_index
< 0)
1057 /* Skip joined switches. */
1058 if ((option
->flags
& CL_JOINED
)
1059 && (!option
->cl_reject_negative
1060 || (unsigned int) option
->neg_index
!= opt_idx
))
1063 for (j
= i
+ 1; j
< old_decoded_options_count
; j
++)
1065 if (old_decoded_options
[j
].errors
& ~CL_ERR_WRONG_LANG
)
1067 next_opt_idx
= old_decoded_options
[j
].opt_index
;
1068 if (next_opt_idx
>= cl_options_count
)
1070 if (cl_options
[next_opt_idx
].neg_index
< 0)
1072 if ((cl_options
[next_opt_idx
].flags
& CL_JOINED
)
1073 && (!cl_options
[next_opt_idx
].cl_reject_negative
1074 || ((unsigned int) cl_options
[next_opt_idx
].neg_index
1077 if (cancel_option (opt_idx
, next_opt_idx
, next_opt_idx
))
1080 if (j
== old_decoded_options_count
)
1083 new_decoded_options
[new_decoded_options_count
]
1084 = old_decoded_options
[i
];
1085 new_decoded_options_count
++;
1091 if (fdiagnostics_color_idx
>= 1)
1093 /* We put the last -fdiagnostics-color= at the first position
1094 after argv[0] so it can take effect immediately. */
1095 memmove (new_decoded_options
+ 2, new_decoded_options
+ 1,
1096 sizeof (struct cl_decoded_option
)
1097 * (new_decoded_options_count
- 1));
1098 new_decoded_options
[1] = old_decoded_options
[fdiagnostics_color_idx
];
1099 new_decoded_options_count
++;
1102 free (old_decoded_options
);
1103 new_decoded_options
= XRESIZEVEC (struct cl_decoded_option
,
1104 new_decoded_options
,
1105 new_decoded_options_count
);
1106 *decoded_options
= new_decoded_options
;
1107 *decoded_options_count
= new_decoded_options_count
;
1110 /* Handle option DECODED for the language indicated by LANG_MASK,
1111 using the handlers in HANDLERS and setting fields in OPTS and
1112 OPTS_SET. KIND is the diagnostic_t if this is a diagnostics
1113 option, DK_UNSPECIFIED otherwise, and LOC is the location of the
1114 option for options from the source file, UNKNOWN_LOCATION
1115 otherwise. GENERATED_P is true for an option generated as part of
1116 processing another option or otherwise generated internally, false
1117 for one explicitly passed by the user. control_warning_option
1118 generated options are considered explicitly passed by the user.
1119 Returns false if the switch was invalid. DC is the diagnostic
1120 context for options affecting diagnostics state, or NULL. */
1123 handle_option (struct gcc_options
*opts
,
1124 struct gcc_options
*opts_set
,
1125 const struct cl_decoded_option
*decoded
,
1126 unsigned int lang_mask
, int kind
, location_t loc
,
1127 const struct cl_option_handlers
*handlers
,
1128 bool generated_p
, diagnostic_context
*dc
)
1130 size_t opt_index
= decoded
->opt_index
;
1131 const char *arg
= decoded
->arg
;
1132 HOST_WIDE_INT value
= decoded
->value
;
1133 const struct cl_option
*option
= &cl_options
[opt_index
];
1134 void *flag_var
= option_flag_var (opt_index
, opts
);
1138 set_option (opts
, (generated_p
? NULL
: opts_set
),
1139 opt_index
, value
, arg
, kind
, loc
, dc
);
1141 for (i
= 0; i
< handlers
->num_handlers
; i
++)
1142 if (option
->flags
& handlers
->handlers
[i
].mask
)
1144 if (!handlers
->handlers
[i
].handler (opts
, opts_set
, decoded
,
1145 lang_mask
, kind
, loc
,
1147 handlers
->target_option_override_hook
))
1154 /* Like handle_option, but OPT_INDEX, ARG and VALUE describe the
1155 option instead of DECODED. This is used for callbacks when one
1156 option implies another instead of an option being decoded from the
1160 handle_generated_option (struct gcc_options
*opts
,
1161 struct gcc_options
*opts_set
,
1162 size_t opt_index
, const char *arg
, HOST_WIDE_INT value
,
1163 unsigned int lang_mask
, int kind
, location_t loc
,
1164 const struct cl_option_handlers
*handlers
,
1165 bool generated_p
, diagnostic_context
*dc
)
1167 struct cl_decoded_option decoded
;
1169 generate_option (opt_index
, arg
, value
, lang_mask
, &decoded
);
1170 return handle_option (opts
, opts_set
, &decoded
, lang_mask
, kind
, loc
,
1171 handlers
, generated_p
, dc
);
1174 /* Fill in *DECODED with an option described by OPT_INDEX, ARG and
1175 VALUE for a front end using LANG_MASK. This is used when the
1176 compiler generates options internally. */
1179 generate_option (size_t opt_index
, const char *arg
, HOST_WIDE_INT value
,
1180 unsigned int lang_mask
, struct cl_decoded_option
*decoded
)
1182 const struct cl_option
*option
= &cl_options
[opt_index
];
1184 decoded
->opt_index
= opt_index
;
1185 decoded
->warn_message
= NULL
;
1187 decoded
->value
= value
;
1188 decoded
->errors
= (option_ok_for_language (option
, lang_mask
)
1190 : CL_ERR_WRONG_LANG
);
1192 generate_canonical_option (opt_index
, arg
, value
, decoded
);
1193 switch (decoded
->canonical_option_num_elements
)
1196 decoded
->orig_option_with_args_text
= decoded
->canonical_option
[0];
1200 decoded
->orig_option_with_args_text
1201 = opts_concat (decoded
->canonical_option
[0], " ",
1202 decoded
->canonical_option
[1], NULL
);
1210 /* Fill in *DECODED with an option for input file FILE. */
1213 generate_option_input_file (const char *file
,
1214 struct cl_decoded_option
*decoded
)
1216 decoded
->opt_index
= OPT_SPECIAL_input_file
;
1217 decoded
->warn_message
= NULL
;
1218 decoded
->arg
= file
;
1219 decoded
->orig_option_with_args_text
= file
;
1220 decoded
->canonical_option_num_elements
= 1;
1221 decoded
->canonical_option
[0] = file
;
1222 decoded
->canonical_option
[1] = NULL
;
1223 decoded
->canonical_option
[2] = NULL
;
1224 decoded
->canonical_option
[3] = NULL
;
1226 decoded
->errors
= 0;
1229 /* Helper function for listing valid choices and hint for misspelled
1230 value. CANDIDATES is a vector containing all valid strings,
1231 STR is set to a heap allocated string that contains all those
1232 strings concatenated, separated by spaces, and the return value
1233 is the closest string from those to ARG, or NULL if nothing is
1234 close enough. Callers should XDELETEVEC (STR) after using it
1235 to avoid memory leaks. */
1238 candidates_list_and_hint (const char *arg
, char *&str
,
1239 const auto_vec
<const char *> &candidates
)
1243 const char *candidate
;
1246 FOR_EACH_VEC_ELT (candidates
, i
, candidate
)
1247 len
+= strlen (candidate
) + 1;
1249 str
= p
= XNEWVEC (char, len
);
1250 FOR_EACH_VEC_ELT (candidates
, i
, candidate
)
1252 len
= strlen (candidate
);
1253 memcpy (p
, candidate
, len
);
1258 return find_closest_string (arg
, &candidates
);
1261 /* Perform diagnostics for read_cmdline_option and control_warning_option
1262 functions. Returns true if an error has been diagnosed.
1263 LOC and LANG_MASK arguments like in read_cmdline_option.
1264 OPTION is the option to report diagnostics for, OPT the name
1265 of the option as text, ARG the argument of the option (for joined
1266 options), ERRORS is bitmask of CL_ERR_* values. */
1269 cmdline_handle_error (location_t loc
, const struct cl_option
*option
,
1270 const char *opt
, const char *arg
, int errors
,
1271 unsigned int lang_mask
)
1273 if (errors
& CL_ERR_DISABLED
)
1275 error_at (loc
, "command-line option %qs"
1276 " is not supported by this configuration", opt
);
1280 if (errors
& CL_ERR_MISSING_ARG
)
1282 if (option
->missing_argument_error
)
1283 error_at (loc
, option
->missing_argument_error
, opt
);
1285 error_at (loc
, "missing argument to %qs", opt
);
1289 if (errors
& CL_ERR_UINT_ARG
)
1291 if (option
->cl_byte_size
)
1292 error_at (loc
, "argument to %qs should be a non-negative integer "
1293 "optionally followed by a size unit",
1296 error_at (loc
, "argument to %qs should be a non-negative integer",
1301 if (errors
& CL_ERR_INT_RANGE_ARG
)
1303 error_at (loc
, "argument to %qs is not between %d and %d",
1304 option
->opt_text
, option
->range_min
, option
->range_max
);
1308 if (errors
& CL_ERR_ENUM_ARG
)
1310 const struct cl_enum
*e
= &cl_enums
[option
->var_enum
];
1314 auto_diagnostic_group d
;
1315 if (e
->unknown_error
)
1316 error_at (loc
, e
->unknown_error
, arg
);
1318 error_at (loc
, "unrecognized argument in option %qs", opt
);
1320 auto_vec
<const char *> candidates
;
1321 for (i
= 0; e
->values
[i
].arg
!= NULL
; i
++)
1323 if (!enum_arg_ok_for_language (&e
->values
[i
], lang_mask
))
1325 candidates
.safe_push (e
->values
[i
].arg
);
1327 const char *hint
= candidates_list_and_hint (arg
, s
, candidates
);
1329 inform (loc
, "valid arguments to %qs are: %s; did you mean %qs?",
1330 option
->opt_text
, s
, hint
);
1332 inform (loc
, "valid arguments to %qs are: %s", option
->opt_text
, s
);
1341 /* Handle the switch DECODED (location LOC) for the language indicated
1342 by LANG_MASK, using the handlers in *HANDLERS and setting fields in
1343 OPTS and OPTS_SET and using diagnostic context DC (if not NULL) for
1344 diagnostic options. */
1347 read_cmdline_option (struct gcc_options
*opts
,
1348 struct gcc_options
*opts_set
,
1349 struct cl_decoded_option
*decoded
,
1351 unsigned int lang_mask
,
1352 const struct cl_option_handlers
*handlers
,
1353 diagnostic_context
*dc
)
1355 const struct cl_option
*option
;
1356 const char *opt
= decoded
->orig_option_with_args_text
;
1358 if (decoded
->warn_message
)
1359 warning_at (loc
, 0, decoded
->warn_message
, opt
);
1361 if (decoded
->opt_index
== OPT_SPECIAL_unknown
)
1363 if (handlers
->unknown_option_callback (decoded
))
1364 error_at (loc
, "unrecognized command-line option %qs", decoded
->arg
);
1368 if (decoded
->opt_index
== OPT_SPECIAL_ignore
)
1371 if (decoded
->opt_index
== OPT_SPECIAL_warn_removed
)
1373 /* Warn only about positive ignored options. */
1375 warning_at (loc
, 0, "switch %qs is no longer supported", opt
);
1379 option
= &cl_options
[decoded
->opt_index
];
1382 && cmdline_handle_error (loc
, option
, opt
, decoded
->arg
,
1383 decoded
->errors
, lang_mask
))
1386 if (decoded
->errors
& CL_ERR_WRONG_LANG
)
1388 handlers
->wrong_lang_callback (decoded
, lang_mask
);
1392 gcc_assert (!decoded
->errors
);
1394 if (!handle_option (opts
, opts_set
, decoded
, lang_mask
, DK_UNSPECIFIED
,
1395 loc
, handlers
, false, dc
))
1396 error_at (loc
, "unrecognized command-line option %qs", opt
);
1399 /* Set any field in OPTS, and OPTS_SET if not NULL, for option
1400 OPT_INDEX according to VALUE and ARG, diagnostic kind KIND,
1401 location LOC, using diagnostic context DC if not NULL for
1402 diagnostic classification. */
1405 set_option (struct gcc_options
*opts
, struct gcc_options
*opts_set
,
1406 int opt_index
, HOST_WIDE_INT value
, const char *arg
, int kind
,
1407 location_t loc
, diagnostic_context
*dc
)
1409 const struct cl_option
*option
= &cl_options
[opt_index
];
1410 void *flag_var
= option_flag_var (opt_index
, opts
);
1411 void *set_flag_var
= NULL
;
1416 if ((diagnostic_t
) kind
!= DK_UNSPECIFIED
&& dc
!= NULL
)
1417 diagnostic_classify_diagnostic (dc
, opt_index
, (diagnostic_t
) kind
, loc
);
1419 if (opts_set
!= NULL
)
1420 set_flag_var
= option_flag_var (opt_index
, opts_set
);
1422 switch (option
->var_type
)
1425 if (option
->cl_host_wide_int
)
1427 *(HOST_WIDE_INT
*) flag_var
= value
;
1429 *(HOST_WIDE_INT
*) set_flag_var
= 1;
1433 *(int *) flag_var
= value
;
1435 *(int *) set_flag_var
= 1;
1441 if (option
->cl_host_wide_int
)
1443 *(HOST_WIDE_INT
*) flag_var
= value
;
1445 *(HOST_WIDE_INT
*) set_flag_var
= value
;
1449 *(int *) flag_var
= value
;
1451 *(int *) set_flag_var
= value
;
1457 if (option
->cl_host_wide_int
)
1459 *(HOST_WIDE_INT
*) flag_var
= (value
1461 : !option
->var_value
);
1463 *(HOST_WIDE_INT
*) set_flag_var
= 1;
1467 *(int *) flag_var
= (value
1469 : !option
->var_value
);
1471 *(int *) set_flag_var
= 1;
1475 case CLVC_BIT_CLEAR
:
1477 if ((value
!= 0) == (option
->var_type
== CLVC_BIT_SET
))
1479 if (option
->cl_host_wide_int
)
1480 *(HOST_WIDE_INT
*) flag_var
|= option
->var_value
;
1482 *(int *) flag_var
|= option
->var_value
;
1486 if (option
->cl_host_wide_int
)
1487 *(HOST_WIDE_INT
*) flag_var
&= ~option
->var_value
;
1489 *(int *) flag_var
&= ~option
->var_value
;
1493 if (option
->cl_host_wide_int
)
1494 *(HOST_WIDE_INT
*) set_flag_var
|= option
->var_value
;
1496 *(int *) set_flag_var
|= option
->var_value
;
1501 *(const char **) flag_var
= arg
;
1503 *(const char **) set_flag_var
= "";
1508 const struct cl_enum
*e
= &cl_enums
[option
->var_enum
];
1510 e
->set (flag_var
, value
);
1512 e
->set (set_flag_var
, 1);
1518 vec
<cl_deferred_option
> *v
1519 = (vec
<cl_deferred_option
> *) *(void **) flag_var
;
1520 cl_deferred_option p
= {opt_index
, arg
, value
};
1522 v
= XCNEW (vec
<cl_deferred_option
>);
1524 *(void **) flag_var
= v
;
1526 *(void **) set_flag_var
= v
;
1532 /* Return the address of the flag variable for option OPT_INDEX in
1533 options structure OPTS, or NULL if there is no flag variable. */
1536 option_flag_var (int opt_index
, struct gcc_options
*opts
)
1538 const struct cl_option
*option
= &cl_options
[opt_index
];
1540 if (option
->flag_var_offset
== (unsigned short) -1)
1542 return (void *)(((char *) opts
) + option
->flag_var_offset
);
1545 /* Return 1 if option OPT_IDX is enabled in OPTS, 0 if it is disabled,
1546 or -1 if it isn't a simple on-off switch. */
1549 option_enabled (int opt_idx
, unsigned lang_mask
, void *opts
)
1551 const struct cl_option
*option
= &(cl_options
[opt_idx
]);
1553 /* A language-specific option can only be considered enabled when it's
1554 valid for the current language. */
1555 if (!(option
->flags
& CL_COMMON
)
1556 && (option
->flags
& CL_LANG_ALL
)
1557 && !(option
->flags
& lang_mask
))
1560 struct gcc_options
*optsg
= (struct gcc_options
*) opts
;
1561 void *flag_var
= option_flag_var (opt_idx
, optsg
);
1564 switch (option
->var_type
)
1567 if (option
->cl_host_wide_int
)
1568 return *(HOST_WIDE_INT
*) flag_var
!= 0;
1570 return *(int *) flag_var
!= 0;
1573 if (option
->cl_host_wide_int
)
1574 return *(HOST_WIDE_INT
*) flag_var
== option
->var_value
;
1576 return *(int *) flag_var
== option
->var_value
;
1578 case CLVC_BIT_CLEAR
:
1579 if (option
->cl_host_wide_int
)
1580 return (*(HOST_WIDE_INT
*) flag_var
& option
->var_value
) == 0;
1582 return (*(int *) flag_var
& option
->var_value
) == 0;
1585 if (option
->cl_host_wide_int
)
1586 return (*(HOST_WIDE_INT
*) flag_var
& option
->var_value
) != 0;
1588 return (*(int *) flag_var
& option
->var_value
) != 0;
1591 if (option
->cl_host_wide_int
)
1592 return *(HOST_WIDE_INT
*) flag_var
!= -1;
1594 return *(int *) flag_var
!= -1;
1604 /* Fill STATE with the current state of option OPTION in OPTS. Return
1605 true if there is some state to store. */
1608 get_option_state (struct gcc_options
*opts
, int option
,
1609 struct cl_option_state
*state
)
1611 void *flag_var
= option_flag_var (option
, opts
);
1616 switch (cl_options
[option
].var_type
)
1621 state
->data
= flag_var
;
1622 state
->size
= (cl_options
[option
].cl_host_wide_int
1623 ? sizeof (HOST_WIDE_INT
)
1627 case CLVC_BIT_CLEAR
:
1629 state
->ch
= option_enabled (option
, -1, opts
);
1630 state
->data
= &state
->ch
;
1635 state
->data
= *(const char **) flag_var
;
1636 if (state
->data
== 0)
1638 state
->size
= strlen ((const char *) state
->data
) + 1;
1642 state
->data
= flag_var
;
1643 state
->size
= cl_enums
[cl_options
[option
].var_enum
].var_size
;
1652 /* Set a warning option OPT_INDEX (language mask LANG_MASK, option
1653 handlers HANDLERS) to have diagnostic kind KIND for option
1654 structures OPTS and OPTS_SET and diagnostic context DC (possibly
1655 NULL), at location LOC (UNKNOWN_LOCATION for -Werror=). ARG is the
1656 argument of the option for joined options, or NULL otherwise. If IMPLY,
1657 the warning option in question is implied at this point. This is
1658 used by -Werror= and #pragma GCC diagnostic. */
1661 control_warning_option (unsigned int opt_index
, int kind
, const char *arg
,
1662 bool imply
, location_t loc
, unsigned int lang_mask
,
1663 const struct cl_option_handlers
*handlers
,
1664 struct gcc_options
*opts
,
1665 struct gcc_options
*opts_set
,
1666 diagnostic_context
*dc
)
1668 if (cl_options
[opt_index
].alias_target
!= N_OPTS
)
1670 gcc_assert (!cl_options
[opt_index
].cl_separate_alias
1671 && !cl_options
[opt_index
].cl_negative_alias
);
1672 if (cl_options
[opt_index
].alias_arg
)
1673 arg
= cl_options
[opt_index
].alias_arg
;
1674 opt_index
= cl_options
[opt_index
].alias_target
;
1676 if (opt_index
== OPT_SPECIAL_ignore
|| opt_index
== OPT_SPECIAL_warn_removed
)
1679 diagnostic_classify_diagnostic (dc
, opt_index
, (diagnostic_t
) kind
, loc
);
1682 const struct cl_option
*option
= &cl_options
[opt_index
];
1684 /* -Werror=foo implies -Wfoo. */
1685 if (option
->var_type
== CLVC_BOOLEAN
1686 || option
->var_type
== CLVC_ENUM
1687 || option
->var_type
== CLVC_SIZE
)
1689 HOST_WIDE_INT value
= 1;
1691 if (arg
&& *arg
== '\0' && !option
->cl_missing_ok
)
1694 if ((option
->flags
& CL_JOINED
) && arg
== NULL
)
1696 cmdline_handle_error (loc
, option
, option
->opt_text
, arg
,
1697 CL_ERR_MISSING_ARG
, lang_mask
);
1701 /* If the switch takes an integer argument, convert it. */
1702 if (arg
&& (option
->cl_uinteger
|| option
->cl_host_wide_int
))
1705 value
= *arg
? integral_argument (arg
, &error
,
1706 option
->cl_byte_size
) : 0;
1709 cmdline_handle_error (loc
, option
, option
->opt_text
, arg
,
1710 CL_ERR_UINT_ARG
, lang_mask
);
1715 /* If the switch takes an enumerated argument, convert it. */
1716 if (arg
&& option
->var_type
== CLVC_ENUM
)
1718 const struct cl_enum
*e
= &cl_enums
[option
->var_enum
];
1720 if (enum_arg_to_value (e
->values
, arg
, &value
, lang_mask
))
1722 const char *carg
= NULL
;
1724 if (enum_value_to_arg (e
->values
, &carg
, value
, lang_mask
))
1726 gcc_assert (carg
!= NULL
);
1730 cmdline_handle_error (loc
, option
, option
->opt_text
, arg
,
1731 CL_ERR_ENUM_ARG
, lang_mask
);
1736 handle_generated_option (opts
, opts_set
,
1737 opt_index
, arg
, value
, lang_mask
,
1738 kind
, loc
, handlers
, false, dc
);