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 *const *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 int opt_array_len
= argc
;
948 opt_array
= XNEWVEC (struct cl_decoded_option
, opt_array_len
);
950 opt_array
[0].opt_index
= OPT_SPECIAL_program_name
;
951 opt_array
[0].warn_message
= NULL
;
952 opt_array
[0].arg
= argv
[0];
953 opt_array
[0].orig_option_with_args_text
= argv
[0];
954 opt_array
[0].canonical_option_num_elements
= 1;
955 opt_array
[0].canonical_option
[0] = argv
[0];
956 opt_array
[0].canonical_option
[1] = NULL
;
957 opt_array
[0].canonical_option
[2] = NULL
;
958 opt_array
[0].canonical_option
[3] = NULL
;
959 opt_array
[0].value
= 1;
960 opt_array
[0].errors
= 0;
961 num_decoded_options
= 1;
963 for (i
= 1; i
< argc
; i
+= n
)
965 const char *opt
= argv
[i
];
967 /* Interpret "-" or a non-switch as a file name. */
968 if (opt
[0] != '-' || opt
[1] == '\0')
970 generate_option_input_file (opt
, &opt_array
[num_decoded_options
]);
971 num_decoded_options
++;
976 /* Interpret "--param" "key=name" as "--param=key=name". */
977 const char *needle
= "--param";
978 if (i
+ 1 < argc
&& strcmp (opt
, needle
) == 0)
980 const char *replacement
981 = opts_concat (needle
, "=", argv
[i
+ 1], NULL
);
982 argv
[++i
] = replacement
;
985 /* Expand -fdiagnostics-plain-output to its constituents. This needs
986 to happen here so that prune_options can handle -fdiagnostics-color
988 if (!strcmp (opt
, "-fdiagnostics-plain-output"))
990 /* If you have changed the default diagnostics output, and this new
991 output is not appropriately "plain" (e.g., the change needs to be
992 undone in order for the testsuite to work properly), then please do
994 1. Add the necessary option to undo the new behavior to
996 2. Update the documentation for -fdiagnostics-plain-output
998 const char *const expanded_args
[] = {
999 "-fno-diagnostics-show-caret",
1000 "-fno-diagnostics-show-line-numbers",
1001 "-fdiagnostics-color=never",
1002 "-fdiagnostics-urls=never",
1003 "-fdiagnostics-path-format=separate-events",
1005 const int num_expanded
= ARRAY_SIZE (expanded_args
);
1006 opt_array_len
+= num_expanded
- 1;
1007 opt_array
= XRESIZEVEC (struct cl_decoded_option
,
1008 opt_array
, opt_array_len
);
1009 for (int j
= 0, nj
; j
< num_expanded
; j
+= nj
)
1011 nj
= decode_cmdline_option (expanded_args
+ j
, lang_mask
,
1012 &opt_array
[num_decoded_options
]);
1013 num_decoded_options
++;
1020 n
= decode_cmdline_option (argv
+ i
, lang_mask
,
1021 &opt_array
[num_decoded_options
]);
1022 num_decoded_options
++;
1025 *decoded_options
= opt_array
;
1026 *decoded_options_count
= num_decoded_options
;
1027 prune_options (decoded_options
, decoded_options_count
);
1030 /* Return true if NEXT_OPT_IDX cancels OPT_IDX. Return false if the
1031 next one is the same as ORIG_NEXT_OPT_IDX. */
1034 cancel_option (int opt_idx
, int next_opt_idx
, int orig_next_opt_idx
)
1036 /* An option can be canceled by the same option or an option with
1038 if (cl_options
[next_opt_idx
].neg_index
== opt_idx
)
1041 if (cl_options
[next_opt_idx
].neg_index
!= orig_next_opt_idx
)
1042 return cancel_option (opt_idx
, cl_options
[next_opt_idx
].neg_index
,
1048 /* Filter out options canceled by the ones after them. */
1051 prune_options (struct cl_decoded_option
**decoded_options
,
1052 unsigned int *decoded_options_count
)
1054 unsigned int old_decoded_options_count
= *decoded_options_count
;
1055 struct cl_decoded_option
*old_decoded_options
= *decoded_options
;
1056 unsigned int new_decoded_options_count
;
1057 struct cl_decoded_option
*new_decoded_options
1058 = XNEWVEC (struct cl_decoded_option
, old_decoded_options_count
);
1060 const struct cl_option
*option
;
1061 unsigned int fdiagnostics_color_idx
= 0;
1063 /* Remove arguments which are negated by others after them. */
1064 new_decoded_options_count
= 0;
1065 for (i
= 0; i
< old_decoded_options_count
; i
++)
1067 unsigned int j
, opt_idx
, next_opt_idx
;
1069 if (old_decoded_options
[i
].errors
& ~CL_ERR_WRONG_LANG
)
1072 opt_idx
= old_decoded_options
[i
].opt_index
;
1075 case OPT_SPECIAL_unknown
:
1076 case OPT_SPECIAL_ignore
:
1077 case OPT_SPECIAL_warn_removed
:
1078 case OPT_SPECIAL_program_name
:
1079 case OPT_SPECIAL_input_file
:
1082 /* Do not save OPT_fdiagnostics_color_, just remember the last one. */
1083 case OPT_fdiagnostics_color_
:
1084 fdiagnostics_color_idx
= i
;
1088 gcc_assert (opt_idx
< cl_options_count
);
1089 option
= &cl_options
[opt_idx
];
1090 if (option
->neg_index
< 0)
1093 /* Skip joined switches. */
1094 if ((option
->flags
& CL_JOINED
)
1095 && (!option
->cl_reject_negative
1096 || (unsigned int) option
->neg_index
!= opt_idx
))
1099 for (j
= i
+ 1; j
< old_decoded_options_count
; j
++)
1101 if (old_decoded_options
[j
].errors
& ~CL_ERR_WRONG_LANG
)
1103 next_opt_idx
= old_decoded_options
[j
].opt_index
;
1104 if (next_opt_idx
>= cl_options_count
)
1106 if (cl_options
[next_opt_idx
].neg_index
< 0)
1108 if ((cl_options
[next_opt_idx
].flags
& CL_JOINED
)
1109 && (!cl_options
[next_opt_idx
].cl_reject_negative
1110 || ((unsigned int) cl_options
[next_opt_idx
].neg_index
1113 if (cancel_option (opt_idx
, next_opt_idx
, next_opt_idx
))
1116 if (j
== old_decoded_options_count
)
1119 new_decoded_options
[new_decoded_options_count
]
1120 = old_decoded_options
[i
];
1121 new_decoded_options_count
++;
1127 if (fdiagnostics_color_idx
>= 1)
1129 /* We put the last -fdiagnostics-color= at the first position
1130 after argv[0] so it can take effect immediately. */
1131 memmove (new_decoded_options
+ 2, new_decoded_options
+ 1,
1132 sizeof (struct cl_decoded_option
)
1133 * (new_decoded_options_count
- 1));
1134 new_decoded_options
[1] = old_decoded_options
[fdiagnostics_color_idx
];
1135 new_decoded_options_count
++;
1138 free (old_decoded_options
);
1139 new_decoded_options
= XRESIZEVEC (struct cl_decoded_option
,
1140 new_decoded_options
,
1141 new_decoded_options_count
);
1142 *decoded_options
= new_decoded_options
;
1143 *decoded_options_count
= new_decoded_options_count
;
1146 /* Handle option DECODED for the language indicated by LANG_MASK,
1147 using the handlers in HANDLERS and setting fields in OPTS and
1148 OPTS_SET. KIND is the diagnostic_t if this is a diagnostics
1149 option, DK_UNSPECIFIED otherwise, and LOC is the location of the
1150 option for options from the source file, UNKNOWN_LOCATION
1151 otherwise. GENERATED_P is true for an option generated as part of
1152 processing another option or otherwise generated internally, false
1153 for one explicitly passed by the user. control_warning_option
1154 generated options are considered explicitly passed by the user.
1155 Returns false if the switch was invalid. DC is the diagnostic
1156 context for options affecting diagnostics state, or NULL. */
1159 handle_option (struct gcc_options
*opts
,
1160 struct gcc_options
*opts_set
,
1161 const struct cl_decoded_option
*decoded
,
1162 unsigned int lang_mask
, int kind
, location_t loc
,
1163 const struct cl_option_handlers
*handlers
,
1164 bool generated_p
, diagnostic_context
*dc
)
1166 size_t opt_index
= decoded
->opt_index
;
1167 const char *arg
= decoded
->arg
;
1168 HOST_WIDE_INT value
= decoded
->value
;
1169 const struct cl_option
*option
= &cl_options
[opt_index
];
1170 void *flag_var
= option_flag_var (opt_index
, opts
);
1174 set_option (opts
, (generated_p
? NULL
: opts_set
),
1175 opt_index
, value
, arg
, kind
, loc
, dc
);
1177 for (i
= 0; i
< handlers
->num_handlers
; i
++)
1178 if (option
->flags
& handlers
->handlers
[i
].mask
)
1180 if (!handlers
->handlers
[i
].handler (opts
, opts_set
, decoded
,
1181 lang_mask
, kind
, loc
,
1183 handlers
->target_option_override_hook
))
1190 /* Like handle_option, but OPT_INDEX, ARG and VALUE describe the
1191 option instead of DECODED. This is used for callbacks when one
1192 option implies another instead of an option being decoded from the
1196 handle_generated_option (struct gcc_options
*opts
,
1197 struct gcc_options
*opts_set
,
1198 size_t opt_index
, const char *arg
, HOST_WIDE_INT value
,
1199 unsigned int lang_mask
, int kind
, location_t loc
,
1200 const struct cl_option_handlers
*handlers
,
1201 bool generated_p
, diagnostic_context
*dc
)
1203 struct cl_decoded_option decoded
;
1205 generate_option (opt_index
, arg
, value
, lang_mask
, &decoded
);
1206 return handle_option (opts
, opts_set
, &decoded
, lang_mask
, kind
, loc
,
1207 handlers
, generated_p
, dc
);
1210 /* Fill in *DECODED with an option described by OPT_INDEX, ARG and
1211 VALUE for a front end using LANG_MASK. This is used when the
1212 compiler generates options internally. */
1215 generate_option (size_t opt_index
, const char *arg
, HOST_WIDE_INT value
,
1216 unsigned int lang_mask
, struct cl_decoded_option
*decoded
)
1218 const struct cl_option
*option
= &cl_options
[opt_index
];
1220 decoded
->opt_index
= opt_index
;
1221 decoded
->warn_message
= NULL
;
1223 decoded
->value
= value
;
1224 decoded
->errors
= (option_ok_for_language (option
, lang_mask
)
1226 : CL_ERR_WRONG_LANG
);
1228 generate_canonical_option (opt_index
, arg
, value
, decoded
);
1229 switch (decoded
->canonical_option_num_elements
)
1232 decoded
->orig_option_with_args_text
= decoded
->canonical_option
[0];
1236 decoded
->orig_option_with_args_text
1237 = opts_concat (decoded
->canonical_option
[0], " ",
1238 decoded
->canonical_option
[1], NULL
);
1246 /* Fill in *DECODED with an option for input file FILE. */
1249 generate_option_input_file (const char *file
,
1250 struct cl_decoded_option
*decoded
)
1252 decoded
->opt_index
= OPT_SPECIAL_input_file
;
1253 decoded
->warn_message
= NULL
;
1254 decoded
->arg
= file
;
1255 decoded
->orig_option_with_args_text
= file
;
1256 decoded
->canonical_option_num_elements
= 1;
1257 decoded
->canonical_option
[0] = file
;
1258 decoded
->canonical_option
[1] = NULL
;
1259 decoded
->canonical_option
[2] = NULL
;
1260 decoded
->canonical_option
[3] = NULL
;
1262 decoded
->errors
= 0;
1265 /* Helper function for listing valid choices and hint for misspelled
1266 value. CANDIDATES is a vector containing all valid strings,
1267 STR is set to a heap allocated string that contains all those
1268 strings concatenated, separated by spaces, and the return value
1269 is the closest string from those to ARG, or NULL if nothing is
1270 close enough. Callers should XDELETEVEC (STR) after using it
1271 to avoid memory leaks. */
1274 candidates_list_and_hint (const char *arg
, char *&str
,
1275 const auto_vec
<const char *> &candidates
)
1279 const char *candidate
;
1282 FOR_EACH_VEC_ELT (candidates
, i
, candidate
)
1283 len
+= strlen (candidate
) + 1;
1285 str
= p
= XNEWVEC (char, len
);
1286 FOR_EACH_VEC_ELT (candidates
, i
, candidate
)
1288 len
= strlen (candidate
);
1289 memcpy (p
, candidate
, len
);
1294 return find_closest_string (arg
, &candidates
);
1297 /* Perform diagnostics for read_cmdline_option and control_warning_option
1298 functions. Returns true if an error has been diagnosed.
1299 LOC and LANG_MASK arguments like in read_cmdline_option.
1300 OPTION is the option to report diagnostics for, OPT the name
1301 of the option as text, ARG the argument of the option (for joined
1302 options), ERRORS is bitmask of CL_ERR_* values. */
1305 cmdline_handle_error (location_t loc
, const struct cl_option
*option
,
1306 const char *opt
, const char *arg
, int errors
,
1307 unsigned int lang_mask
)
1309 if (errors
& CL_ERR_DISABLED
)
1311 error_at (loc
, "command-line option %qs"
1312 " is not supported by this configuration", opt
);
1316 if (errors
& CL_ERR_MISSING_ARG
)
1318 if (option
->missing_argument_error
)
1319 error_at (loc
, option
->missing_argument_error
, opt
);
1321 error_at (loc
, "missing argument to %qs", opt
);
1325 if (errors
& CL_ERR_UINT_ARG
)
1327 if (option
->cl_byte_size
)
1328 error_at (loc
, "argument to %qs should be a non-negative integer "
1329 "optionally followed by a size unit",
1332 error_at (loc
, "argument to %qs should be a non-negative integer",
1337 if (errors
& CL_ERR_INT_RANGE_ARG
)
1339 error_at (loc
, "argument to %qs is not between %d and %d",
1340 option
->opt_text
, option
->range_min
, option
->range_max
);
1344 if (errors
& CL_ERR_ENUM_ARG
)
1346 const struct cl_enum
*e
= &cl_enums
[option
->var_enum
];
1350 auto_diagnostic_group d
;
1351 if (e
->unknown_error
)
1352 error_at (loc
, e
->unknown_error
, arg
);
1354 error_at (loc
, "unrecognized argument in option %qs", opt
);
1356 auto_vec
<const char *> candidates
;
1357 for (i
= 0; e
->values
[i
].arg
!= NULL
; i
++)
1359 if (!enum_arg_ok_for_language (&e
->values
[i
], lang_mask
))
1361 candidates
.safe_push (e
->values
[i
].arg
);
1363 const char *hint
= candidates_list_and_hint (arg
, s
, candidates
);
1365 inform (loc
, "valid arguments to %qs are: %s; did you mean %qs?",
1366 option
->opt_text
, s
, hint
);
1368 inform (loc
, "valid arguments to %qs are: %s", option
->opt_text
, s
);
1377 /* Handle the switch DECODED (location LOC) for the language indicated
1378 by LANG_MASK, using the handlers in *HANDLERS and setting fields in
1379 OPTS and OPTS_SET and using diagnostic context DC (if not NULL) for
1380 diagnostic options. */
1383 read_cmdline_option (struct gcc_options
*opts
,
1384 struct gcc_options
*opts_set
,
1385 struct cl_decoded_option
*decoded
,
1387 unsigned int lang_mask
,
1388 const struct cl_option_handlers
*handlers
,
1389 diagnostic_context
*dc
)
1391 const struct cl_option
*option
;
1392 const char *opt
= decoded
->orig_option_with_args_text
;
1394 if (decoded
->warn_message
)
1395 warning_at (loc
, 0, decoded
->warn_message
, opt
);
1397 if (decoded
->opt_index
== OPT_SPECIAL_unknown
)
1399 if (handlers
->unknown_option_callback (decoded
))
1400 error_at (loc
, "unrecognized command-line option %qs", decoded
->arg
);
1404 if (decoded
->opt_index
== OPT_SPECIAL_ignore
)
1407 if (decoded
->opt_index
== OPT_SPECIAL_warn_removed
)
1409 /* Warn only about positive ignored options. */
1411 warning_at (loc
, 0, "switch %qs is no longer supported", opt
);
1415 option
= &cl_options
[decoded
->opt_index
];
1418 && cmdline_handle_error (loc
, option
, opt
, decoded
->arg
,
1419 decoded
->errors
, lang_mask
))
1422 if (decoded
->errors
& CL_ERR_WRONG_LANG
)
1424 handlers
->wrong_lang_callback (decoded
, lang_mask
);
1428 gcc_assert (!decoded
->errors
);
1430 if (!handle_option (opts
, opts_set
, decoded
, lang_mask
, DK_UNSPECIFIED
,
1431 loc
, handlers
, false, dc
))
1432 error_at (loc
, "unrecognized command-line option %qs", opt
);
1435 /* Set any field in OPTS, and OPTS_SET if not NULL, for option
1436 OPT_INDEX according to VALUE and ARG, diagnostic kind KIND,
1437 location LOC, using diagnostic context DC if not NULL for
1438 diagnostic classification. */
1441 set_option (struct gcc_options
*opts
, struct gcc_options
*opts_set
,
1442 int opt_index
, HOST_WIDE_INT value
, const char *arg
, int kind
,
1443 location_t loc
, diagnostic_context
*dc
)
1445 const struct cl_option
*option
= &cl_options
[opt_index
];
1446 void *flag_var
= option_flag_var (opt_index
, opts
);
1447 void *set_flag_var
= NULL
;
1452 if ((diagnostic_t
) kind
!= DK_UNSPECIFIED
&& dc
!= NULL
)
1453 diagnostic_classify_diagnostic (dc
, opt_index
, (diagnostic_t
) kind
, loc
);
1455 if (opts_set
!= NULL
)
1456 set_flag_var
= option_flag_var (opt_index
, opts_set
);
1458 switch (option
->var_type
)
1461 if (option
->cl_host_wide_int
)
1463 *(HOST_WIDE_INT
*) flag_var
= value
;
1465 *(HOST_WIDE_INT
*) set_flag_var
= 1;
1469 *(int *) flag_var
= value
;
1471 *(int *) set_flag_var
= 1;
1477 if (option
->cl_host_wide_int
)
1479 *(HOST_WIDE_INT
*) flag_var
= value
;
1481 *(HOST_WIDE_INT
*) set_flag_var
= value
;
1485 *(int *) flag_var
= value
;
1487 *(int *) set_flag_var
= value
;
1493 if (option
->cl_host_wide_int
)
1495 *(HOST_WIDE_INT
*) flag_var
= (value
1497 : !option
->var_value
);
1499 *(HOST_WIDE_INT
*) set_flag_var
= 1;
1503 *(int *) flag_var
= (value
1505 : !option
->var_value
);
1507 *(int *) set_flag_var
= 1;
1511 case CLVC_BIT_CLEAR
:
1513 if ((value
!= 0) == (option
->var_type
== CLVC_BIT_SET
))
1515 if (option
->cl_host_wide_int
)
1516 *(HOST_WIDE_INT
*) flag_var
|= option
->var_value
;
1518 *(int *) flag_var
|= option
->var_value
;
1522 if (option
->cl_host_wide_int
)
1523 *(HOST_WIDE_INT
*) flag_var
&= ~option
->var_value
;
1525 *(int *) flag_var
&= ~option
->var_value
;
1529 if (option
->cl_host_wide_int
)
1530 *(HOST_WIDE_INT
*) set_flag_var
|= option
->var_value
;
1532 *(int *) set_flag_var
|= option
->var_value
;
1537 *(const char **) flag_var
= arg
;
1539 *(const char **) set_flag_var
= "";
1544 const struct cl_enum
*e
= &cl_enums
[option
->var_enum
];
1546 e
->set (flag_var
, value
);
1548 e
->set (set_flag_var
, 1);
1554 vec
<cl_deferred_option
> *v
1555 = (vec
<cl_deferred_option
> *) *(void **) flag_var
;
1556 cl_deferred_option p
= {opt_index
, arg
, value
};
1558 v
= XCNEW (vec
<cl_deferred_option
>);
1560 *(void **) flag_var
= v
;
1562 *(void **) set_flag_var
= v
;
1568 /* Return the address of the flag variable for option OPT_INDEX in
1569 options structure OPTS, or NULL if there is no flag variable. */
1572 option_flag_var (int opt_index
, struct gcc_options
*opts
)
1574 const struct cl_option
*option
= &cl_options
[opt_index
];
1576 if (option
->flag_var_offset
== (unsigned short) -1)
1578 return (void *)(((char *) opts
) + option
->flag_var_offset
);
1581 /* Return 1 if option OPT_IDX is enabled in OPTS, 0 if it is disabled,
1582 or -1 if it isn't a simple on-off switch. */
1585 option_enabled (int opt_idx
, unsigned lang_mask
, void *opts
)
1587 const struct cl_option
*option
= &(cl_options
[opt_idx
]);
1589 /* A language-specific option can only be considered enabled when it's
1590 valid for the current language. */
1591 if (!(option
->flags
& CL_COMMON
)
1592 && (option
->flags
& CL_LANG_ALL
)
1593 && !(option
->flags
& lang_mask
))
1596 struct gcc_options
*optsg
= (struct gcc_options
*) opts
;
1597 void *flag_var
= option_flag_var (opt_idx
, optsg
);
1600 switch (option
->var_type
)
1603 if (option
->cl_host_wide_int
)
1604 return *(HOST_WIDE_INT
*) flag_var
!= 0;
1606 return *(int *) flag_var
!= 0;
1609 if (option
->cl_host_wide_int
)
1610 return *(HOST_WIDE_INT
*) flag_var
== option
->var_value
;
1612 return *(int *) flag_var
== option
->var_value
;
1614 case CLVC_BIT_CLEAR
:
1615 if (option
->cl_host_wide_int
)
1616 return (*(HOST_WIDE_INT
*) flag_var
& option
->var_value
) == 0;
1618 return (*(int *) flag_var
& option
->var_value
) == 0;
1621 if (option
->cl_host_wide_int
)
1622 return (*(HOST_WIDE_INT
*) flag_var
& option
->var_value
) != 0;
1624 return (*(int *) flag_var
& option
->var_value
) != 0;
1627 if (option
->cl_host_wide_int
)
1628 return *(HOST_WIDE_INT
*) flag_var
!= -1;
1630 return *(int *) flag_var
!= -1;
1640 /* Fill STATE with the current state of option OPTION in OPTS. Return
1641 true if there is some state to store. */
1644 get_option_state (struct gcc_options
*opts
, int option
,
1645 struct cl_option_state
*state
)
1647 void *flag_var
= option_flag_var (option
, opts
);
1652 switch (cl_options
[option
].var_type
)
1657 state
->data
= flag_var
;
1658 state
->size
= (cl_options
[option
].cl_host_wide_int
1659 ? sizeof (HOST_WIDE_INT
)
1663 case CLVC_BIT_CLEAR
:
1665 state
->ch
= option_enabled (option
, -1, opts
);
1666 state
->data
= &state
->ch
;
1671 state
->data
= *(const char **) flag_var
;
1672 if (state
->data
== 0)
1674 state
->size
= strlen ((const char *) state
->data
) + 1;
1678 state
->data
= flag_var
;
1679 state
->size
= cl_enums
[cl_options
[option
].var_enum
].var_size
;
1688 /* Set a warning option OPT_INDEX (language mask LANG_MASK, option
1689 handlers HANDLERS) to have diagnostic kind KIND for option
1690 structures OPTS and OPTS_SET and diagnostic context DC (possibly
1691 NULL), at location LOC (UNKNOWN_LOCATION for -Werror=). ARG is the
1692 argument of the option for joined options, or NULL otherwise. If IMPLY,
1693 the warning option in question is implied at this point. This is
1694 used by -Werror= and #pragma GCC diagnostic. */
1697 control_warning_option (unsigned int opt_index
, int kind
, const char *arg
,
1698 bool imply
, location_t loc
, unsigned int lang_mask
,
1699 const struct cl_option_handlers
*handlers
,
1700 struct gcc_options
*opts
,
1701 struct gcc_options
*opts_set
,
1702 diagnostic_context
*dc
)
1704 if (cl_options
[opt_index
].alias_target
!= N_OPTS
)
1706 gcc_assert (!cl_options
[opt_index
].cl_separate_alias
1707 && !cl_options
[opt_index
].cl_negative_alias
);
1708 if (cl_options
[opt_index
].alias_arg
)
1709 arg
= cl_options
[opt_index
].alias_arg
;
1710 opt_index
= cl_options
[opt_index
].alias_target
;
1712 if (opt_index
== OPT_SPECIAL_ignore
|| opt_index
== OPT_SPECIAL_warn_removed
)
1715 diagnostic_classify_diagnostic (dc
, opt_index
, (diagnostic_t
) kind
, loc
);
1718 const struct cl_option
*option
= &cl_options
[opt_index
];
1720 /* -Werror=foo implies -Wfoo. */
1721 if (option
->var_type
== CLVC_BOOLEAN
1722 || option
->var_type
== CLVC_ENUM
1723 || option
->var_type
== CLVC_SIZE
)
1725 HOST_WIDE_INT value
= 1;
1727 if (arg
&& *arg
== '\0' && !option
->cl_missing_ok
)
1730 if ((option
->flags
& CL_JOINED
) && arg
== NULL
)
1732 cmdline_handle_error (loc
, option
, option
->opt_text
, arg
,
1733 CL_ERR_MISSING_ARG
, lang_mask
);
1737 /* If the switch takes an integer argument, convert it. */
1738 if (arg
&& (option
->cl_uinteger
|| option
->cl_host_wide_int
))
1741 value
= *arg
? integral_argument (arg
, &error
,
1742 option
->cl_byte_size
) : 0;
1745 cmdline_handle_error (loc
, option
, option
->opt_text
, arg
,
1746 CL_ERR_UINT_ARG
, lang_mask
);
1751 /* If the switch takes an enumerated argument, convert it. */
1752 if (arg
&& option
->var_type
== CLVC_ENUM
)
1754 const struct cl_enum
*e
= &cl_enums
[option
->var_enum
];
1756 if (enum_arg_to_value (e
->values
, arg
, &value
, lang_mask
))
1758 const char *carg
= NULL
;
1760 if (enum_value_to_arg (e
->values
, &carg
, value
, lang_mask
))
1762 gcc_assert (carg
!= NULL
);
1766 cmdline_handle_error (loc
, option
, option
->opt_text
, arg
,
1767 CL_ERR_ENUM_ARG
, lang_mask
);
1772 handle_generated_option (opts
, opts_set
,
1773 opt_index
, arg
, value
, lang_mask
,
1774 kind
, loc
, handlers
, false, dc
);
1779 /* Parse options in COLLECT_GCC_OPTIONS and push them on ARGV_OBSTACK.
1780 Store number of arguments into ARGC_P. */
1783 parse_options_from_collect_gcc_options (const char *collect_gcc_options
,
1784 obstack
*argv_obstack
,
1787 char *argv_storage
= xstrdup (collect_gcc_options
);
1790 for (j
= 0, k
= 0; argv_storage
[j
] != '\0'; ++j
)
1792 if (argv_storage
[j
] == '\'')
1794 obstack_ptr_grow (argv_obstack
, &argv_storage
[k
]);
1798 if (argv_storage
[j
] == '\0')
1799 fatal_error (input_location
,
1800 "malformed %<COLLECT_GCC_OPTIONS%>");
1801 else if (strncmp (&argv_storage
[j
], "'\\''", 4) == 0)
1803 argv_storage
[k
++] = '\'';
1806 else if (argv_storage
[j
] == '\'')
1809 argv_storage
[k
++] = argv_storage
[j
++];
1812 argv_storage
[k
++] = '\0';
1816 obstack_ptr_grow (argv_obstack
, NULL
);
1817 *argc_p
= obstack_object_size (argv_obstack
) / sizeof (void *) - 1;
1820 /* Prepend -Xassembler for each option in COLLECT_AS_OPTIONS,
1823 void prepend_xassembler_to_collect_as_options (const char *collect_as_options
,
1826 obstack opts_obstack
;
1829 obstack_init (&opts_obstack
);
1830 parse_options_from_collect_gcc_options (collect_as_options
,
1831 &opts_obstack
, &opts_count
);
1832 const char **assembler_opts
= XOBFINISH (&opts_obstack
, const char **);
1834 for (int i
= 0; i
< opts_count
; i
++)
1836 obstack_grow (o
, " '-Xassembler' ",
1837 strlen (" '-Xassembler' "));
1838 const char *opt
= assembler_opts
[i
];
1839 obstack_1grow (o
, '\'');
1840 obstack_grow (o
, opt
, strlen (opt
));
1841 obstack_1grow (o
, '\'');