1 /* Command line option handling.
2 Copyright (C) 2006, 2007, 2008, 2010, 2011 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
26 #include "diagnostic.h"
28 static void prune_options (struct cl_decoded_option
**, unsigned int *);
30 /* Perform a binary search to find which option the command-line INPUT
31 matches. Returns its index in the option array, and
32 OPT_SPECIAL_unknown on failure.
34 This routine is quite subtle. A normal binary search is not good
35 enough because some options can be suffixed with an argument, and
36 multiple sub-matches can occur, e.g. input of "-pedantic" matching
37 the initial substring of "-pedantic-errors".
39 A more complicated example is -gstabs. It should match "-g" with
40 an argument of "stabs". Suppose, however, that the number and list
41 of switches are such that the binary search tests "-gen-decls"
42 before having tested "-g". This doesn't match, and as "-gen-decls"
43 is less than "-gstabs", it will become the lower bound of the
44 binary search range, and "-g" will never be seen. To resolve this
45 issue, 'optc-gen.awk' makes "-gen-decls" point, via the back_chain member,
46 to "-g" so that failed searches that end between "-gen-decls" and
47 the lexicographically subsequent switch know to go back and see if
48 "-g" causes a match (which it does in this example).
50 This search is done in such a way that the longest match for the
51 front end in question wins. If there is no match for the current
52 front end, the longest match for a different front end is returned
53 (or N_OPTS if none) and the caller emits an error message. */
55 find_opt (const char *input
, unsigned int lang_mask
)
57 size_t mn
, mn_orig
, mx
, md
, opt_len
;
58 size_t match_wrong_lang
;
62 mx
= cl_options_count
;
64 /* Find mn such this lexicographical inequality holds:
65 cl_options[mn] <= input < cl_options[mn + 1]. */
69 opt_len
= cl_options
[md
].opt_len
;
70 comp
= strncmp (input
, cl_options
[md
].opt_text
+ 1, opt_len
);
80 /* This is the switch that is the best match but for a different
81 front end, or OPT_SPECIAL_unknown if there is no match at all. */
82 match_wrong_lang
= OPT_SPECIAL_unknown
;
84 /* Backtrace the chain of possible matches, returning the longest
85 one, if any, that fits best. With current GCC switches, this
86 loop executes at most twice. */
89 const struct cl_option
*opt
= &cl_options
[mn
];
91 /* Is the input either an exact match or a prefix that takes a
93 if (!strncmp (input
, opt
->opt_text
+ 1, opt
->opt_len
)
94 && (input
[opt
->opt_len
] == '\0' || (opt
->flags
& CL_JOINED
)))
96 /* If language is OK, return it. */
97 if (opt
->flags
& lang_mask
)
100 /* If we haven't remembered a prior match, remember this
101 one. Any prior match is necessarily better. */
102 if (match_wrong_lang
== OPT_SPECIAL_unknown
)
103 match_wrong_lang
= mn
;
106 /* Try the next possibility. This is cl_options_count if there
108 mn
= opt
->back_chain
;
110 while (mn
!= cl_options_count
);
112 if (match_wrong_lang
== OPT_SPECIAL_unknown
&& input
[0] == '-')
114 /* Long options, starting "--", may be abbreviated if the
115 abbreviation is unambiguous. This only applies to options
116 not taking a joined argument, and abbreviations of "--option"
117 are permitted even if there is a variant "--option=". */
118 size_t mnc
= mn_orig
+ 1;
119 size_t cmp_len
= strlen (input
);
120 while (mnc
< cl_options_count
121 && strncmp (input
, cl_options
[mnc
].opt_text
+ 1, cmp_len
) == 0)
123 /* Option matching this abbreviation. OK if it is the first
124 match and that does not take a joined argument, or the
125 second match, taking a joined argument and with only '='
126 added to the first match; otherwise considered
128 if (mnc
== mn_orig
+ 1
129 && !(cl_options
[mnc
].flags
& CL_JOINED
))
130 match_wrong_lang
= mnc
;
131 else if (mnc
== mn_orig
+ 2
132 && match_wrong_lang
== mn_orig
+ 1
133 && (cl_options
[mnc
].flags
& CL_JOINED
)
134 && (cl_options
[mnc
].opt_len
135 == cl_options
[mn_orig
+ 1].opt_len
+ 1)
136 && strncmp (cl_options
[mnc
].opt_text
+ 1,
137 cl_options
[mn_orig
+ 1].opt_text
+ 1,
138 cl_options
[mn_orig
+ 1].opt_len
) == 0)
139 ; /* OK, as long as there are no more matches. */
141 return OPT_SPECIAL_unknown
;
146 /* Return the best wrong match, or OPT_SPECIAL_unknown if none. */
147 return match_wrong_lang
;
150 /* If ARG is a non-negative integer made up solely of digits, return its
151 value, otherwise return -1. */
154 integral_argument (const char *arg
)
158 while (*p
&& ISDIGIT (*p
))
167 /* Return whether OPTION is OK for the language given by
170 option_ok_for_language (const struct cl_option
*option
,
171 unsigned int lang_mask
)
173 if (!(option
->flags
& lang_mask
))
175 else if ((option
->flags
& CL_TARGET
)
176 && (option
->flags
& (CL_LANG_ALL
| CL_DRIVER
))
177 && !(option
->flags
& (lang_mask
& ~CL_COMMON
& ~CL_TARGET
)))
178 /* Complain for target flag language mismatches if any languages
184 /* Return whether ENUM_ARG is OK for the language given by
188 enum_arg_ok_for_language (const struct cl_enum_arg
*enum_arg
,
189 unsigned int lang_mask
)
191 return (lang_mask
& CL_DRIVER
) || !(enum_arg
->flags
& CL_ENUM_DRIVER_ONLY
);
194 /* Look up ARG in ENUM_ARGS for language LANG_MASK, returning true and
195 storing the value in *VALUE if found, and returning false without
196 modifying *VALUE if not found. */
199 enum_arg_to_value (const struct cl_enum_arg
*enum_args
,
200 const char *arg
, int *value
, unsigned int lang_mask
)
204 for (i
= 0; enum_args
[i
].arg
!= NULL
; i
++)
205 if (strcmp (arg
, enum_args
[i
].arg
) == 0
206 && enum_arg_ok_for_language (&enum_args
[i
], lang_mask
))
208 *value
= enum_args
[i
].value
;
215 /* Look of VALUE in ENUM_ARGS for language LANG_MASK and store the
216 corresponding string in *ARGP, returning true if the found string
217 was marked as canonical, false otherwise. If VALUE is not found
218 (which may be the case for uninitialized values if the relevant
219 option has not been passed), set *ARGP to NULL and return
223 enum_value_to_arg (const struct cl_enum_arg
*enum_args
,
224 const char **argp
, int value
, unsigned int lang_mask
)
228 for (i
= 0; enum_args
[i
].arg
!= NULL
; i
++)
229 if (enum_args
[i
].value
== value
230 && (enum_args
[i
].flags
& CL_ENUM_CANONICAL
)
231 && enum_arg_ok_for_language (&enum_args
[i
], lang_mask
))
233 *argp
= enum_args
[i
].arg
;
237 for (i
= 0; enum_args
[i
].arg
!= NULL
; i
++)
238 if (enum_args
[i
].value
== value
239 && enum_arg_ok_for_language (&enum_args
[i
], lang_mask
))
241 *argp
= enum_args
[i
].arg
;
249 /* Fill in the canonical option part of *DECODED with an option
250 described by OPT_INDEX, ARG and VALUE. */
253 generate_canonical_option (size_t opt_index
, const char *arg
, int value
,
254 struct cl_decoded_option
*decoded
)
256 const struct cl_option
*option
= &cl_options
[opt_index
];
257 const char *opt_text
= option
->opt_text
;
260 && !option
->cl_reject_negative
261 && (opt_text
[1] == 'W' || opt_text
[1] == 'f' || opt_text
[1] == 'm'))
263 char *t
= XNEWVEC (char, option
->opt_len
+ 5);
269 memcpy (t
+ 5, opt_text
+ 2, option
->opt_len
);
273 decoded
->canonical_option
[2] = NULL
;
274 decoded
->canonical_option
[3] = NULL
;
278 if ((option
->flags
& CL_SEPARATE
)
279 && !option
->cl_separate_alias
)
281 decoded
->canonical_option
[0] = opt_text
;
282 decoded
->canonical_option
[1] = arg
;
283 decoded
->canonical_option_num_elements
= 2;
287 gcc_assert (option
->flags
& CL_JOINED
);
288 decoded
->canonical_option
[0] = concat (opt_text
, arg
, NULL
);
289 decoded
->canonical_option
[1] = NULL
;
290 decoded
->canonical_option_num_elements
= 1;
295 decoded
->canonical_option
[0] = opt_text
;
296 decoded
->canonical_option
[1] = NULL
;
297 decoded
->canonical_option_num_elements
= 1;
301 /* Structure describing mappings from options on the command line to
302 options to look up with find_opt. */
305 /* Prefix of the option on the command line. */
307 /* If two argv elements are considered to be merged into one option,
308 prefix for the second element, otherwise NULL. */
310 /* The new prefix to map to. */
311 const char *new_prefix
;
312 /* Whether at least one character is needed following opt1 or opt0
313 for this mapping to be used. (--optimize= is valid for -O, but
314 --warn- is not valid for -W.) */
315 bool another_char_needed
;
316 /* Whether the original option is a negated form of the option
317 resulting from this map. */
320 static const struct option_map option_map
[] =
322 { "-Wno-", NULL
, "-W", false, true },
323 { "-fno-", NULL
, "-f", false, true },
324 { "-mno-", NULL
, "-m", false, true },
325 { "--debug=", NULL
, "-g", false, false },
326 { "--machine-", NULL
, "-m", true, false },
327 { "--machine-no-", NULL
, "-m", false, true },
328 { "--machine=", NULL
, "-m", false, false },
329 { "--machine=no-", NULL
, "-m", false, true },
330 { "--machine", "", "-m", false, false },
331 { "--machine", "no-", "-m", false, true },
332 { "--optimize=", NULL
, "-O", false, false },
333 { "--std=", NULL
, "-std=", false, false },
334 { "--std", "", "-std=", false, false },
335 { "--warn-", NULL
, "-W", true, false },
336 { "--warn-no-", NULL
, "-W", false, true },
337 { "--", NULL
, "-f", true, false },
338 { "--no-", NULL
, "-f", false, true }
341 /* Decode the switch beginning at ARGV for the language indicated by
342 LANG_MASK (including CL_COMMON and CL_TARGET if applicable), into
343 the structure *DECODED. Returns the number of switches
347 decode_cmdline_option (const char **argv
, unsigned int lang_mask
,
348 struct cl_decoded_option
*decoded
)
353 unsigned int result
= 1, i
, extra_args
, separate_args
= 0;
357 const struct cl_option
*option
;
359 const char *warn_message
= NULL
;
360 bool separate_arg_flag
;
361 bool joined_arg_flag
;
362 bool have_separate_arg
= false;
366 opt_index
= find_opt (argv
[0] + 1, lang_mask
);
368 while (opt_index
== OPT_SPECIAL_unknown
369 && i
< ARRAY_SIZE (option_map
))
371 const char *opt0
= option_map
[i
].opt0
;
372 const char *opt1
= option_map
[i
].opt1
;
373 const char *new_prefix
= option_map
[i
].new_prefix
;
374 bool another_char_needed
= option_map
[i
].another_char_needed
;
375 size_t opt0_len
= strlen (opt0
);
376 size_t opt1_len
= (opt1
== NULL
? 0 : strlen (opt1
));
377 size_t optn_len
= (opt1
== NULL
? opt0_len
: opt1_len
);
378 size_t new_prefix_len
= strlen (new_prefix
);
380 extra_args
= (opt1
== NULL
? 0 : 1);
381 value
= !option_map
[i
].negated
;
383 if (strncmp (argv
[0], opt0
, opt0_len
) == 0
385 || (argv
[1] != NULL
&& strncmp (argv
[1], opt1
, opt1_len
) == 0))
386 && (!another_char_needed
387 || argv
[extra_args
][optn_len
] != 0))
389 size_t arglen
= strlen (argv
[extra_args
]);
392 adjust_len
= (int) optn_len
- (int) new_prefix_len
;
393 dup
= XNEWVEC (char, arglen
+ 1 - adjust_len
);
394 memcpy (dup
, new_prefix
, new_prefix_len
);
395 memcpy (dup
+ new_prefix_len
, argv
[extra_args
] + optn_len
,
396 arglen
- optn_len
+ 1);
397 opt_index
= find_opt (dup
+ 1, lang_mask
);
403 if (opt_index
== OPT_SPECIAL_unknown
)
411 option
= &cl_options
[opt_index
];
413 /* Reject negative form of switches that don't take negatives as
415 if (!value
&& option
->cl_reject_negative
)
417 opt_index
= OPT_SPECIAL_unknown
;
418 errors
|= CL_ERR_NEGATIVE
;
423 result
= extra_args
+ 1;
424 warn_message
= option
->warn_message
;
426 /* Check to see if the option is disabled for this configuration. */
427 if (option
->cl_disabled
)
428 errors
|= CL_ERR_DISABLED
;
430 /* Determine whether there may be a separate argument based on
431 whether this option is being processed for the driver, and, if
432 so, how many such arguments. */
433 separate_arg_flag
= ((option
->flags
& CL_SEPARATE
)
434 && !(option
->cl_no_driver_arg
435 && (lang_mask
& CL_DRIVER
)));
436 separate_args
= (separate_arg_flag
437 ? option
->cl_separate_nargs
+ 1
439 joined_arg_flag
= (option
->flags
& CL_JOINED
) != 0;
441 /* Sort out any argument the switch takes. */
444 /* Have arg point to the original switch. This is because
445 some code, such as disable_builtin_function, expects its
446 argument to be persistent until the program exits. */
447 arg
= argv
[extra_args
] + cl_options
[opt_index
].opt_len
+ 1 + adjust_len
;
449 if (*arg
== '\0' && !option
->cl_missing_ok
)
451 if (separate_arg_flag
)
453 arg
= argv
[extra_args
+ 1];
454 result
= extra_args
+ 2;
456 result
= extra_args
+ 1;
458 have_separate_arg
= true;
461 /* Missing argument. */
465 else if (separate_arg_flag
)
467 arg
= argv
[extra_args
+ 1];
468 for (i
= 0; i
< separate_args
; i
++)
469 if (argv
[extra_args
+ 1 + i
] == NULL
)
471 errors
|= CL_ERR_MISSING_ARG
;
474 result
= extra_args
+ 1 + i
;
476 have_separate_arg
= true;
479 if (arg
== NULL
&& (separate_arg_flag
|| joined_arg_flag
))
480 errors
|= CL_ERR_MISSING_ARG
;
482 /* Is this option an alias (or an ignored option, marked as an alias
483 of OPT_SPECIAL_ignore)? */
484 if (option
->alias_target
!= N_OPTS
485 && (!option
->cl_separate_alias
|| have_separate_arg
))
487 size_t new_opt_index
= option
->alias_target
;
489 if (new_opt_index
== OPT_SPECIAL_ignore
)
491 gcc_assert (option
->alias_arg
== NULL
);
492 gcc_assert (option
->neg_alias_arg
== NULL
);
493 opt_index
= new_opt_index
;
499 const struct cl_option
*new_option
= &cl_options
[new_opt_index
];
501 /* The new option must not be an alias itself. */
502 gcc_assert (new_option
->alias_target
== N_OPTS
503 || new_option
->cl_separate_alias
);
505 if (option
->neg_alias_arg
)
507 gcc_assert (option
->alias_arg
!= NULL
);
508 gcc_assert (arg
== NULL
);
509 gcc_assert (!option
->cl_negative_alias
);
511 arg
= option
->alias_arg
;
513 arg
= option
->neg_alias_arg
;
516 else if (option
->alias_arg
)
518 gcc_assert (value
== 1);
519 gcc_assert (arg
== NULL
);
520 gcc_assert (!option
->cl_negative_alias
);
521 arg
= option
->alias_arg
;
524 if (option
->cl_negative_alias
)
527 opt_index
= new_opt_index
;
531 gcc_assert (!option
->cl_reject_negative
);
533 /* Recompute what arguments are allowed. */
534 separate_arg_flag
= ((option
->flags
& CL_SEPARATE
)
535 && !(option
->cl_no_driver_arg
536 && (lang_mask
& CL_DRIVER
)));
537 joined_arg_flag
= (option
->flags
& CL_JOINED
) != 0;
539 if (separate_args
> 1 || option
->cl_separate_nargs
)
540 gcc_assert (separate_args
541 == (unsigned int) option
->cl_separate_nargs
+ 1);
543 if (!(errors
& CL_ERR_MISSING_ARG
))
545 if (separate_arg_flag
|| joined_arg_flag
)
547 if (option
->cl_missing_ok
&& arg
== NULL
)
549 gcc_assert (arg
!= NULL
);
552 gcc_assert (arg
== NULL
);
555 /* Recheck for warnings and disabled options. */
556 if (option
->warn_message
)
558 gcc_assert (warn_message
== NULL
);
559 warn_message
= option
->warn_message
;
561 if (option
->cl_disabled
)
562 errors
|= CL_ERR_DISABLED
;
566 /* Check if this is a switch for a different front end. */
567 if (!option_ok_for_language (option
, lang_mask
))
568 errors
|= CL_ERR_WRONG_LANG
;
570 /* If the switch takes an integer, convert it. */
571 if (arg
&& option
->cl_uinteger
)
573 value
= integral_argument (arg
);
575 errors
|= CL_ERR_UINT_ARG
;
578 /* If the switch takes an enumerated argument, convert it. */
579 if (arg
&& (option
->var_type
== CLVC_ENUM
))
581 const struct cl_enum
*e
= &cl_enums
[option
->var_enum
];
583 gcc_assert (value
== 1);
584 if (enum_arg_to_value (e
->values
, arg
, &value
, lang_mask
))
586 const char *carg
= NULL
;
588 if (enum_value_to_arg (e
->values
, &carg
, value
, lang_mask
))
590 gcc_assert (carg
!= NULL
);
593 errors
|= CL_ERR_ENUM_ARG
;
597 decoded
->opt_index
= opt_index
;
599 decoded
->value
= value
;
600 decoded
->errors
= errors
;
601 decoded
->warn_message
= warn_message
;
603 if (opt_index
== OPT_SPECIAL_unknown
)
604 gcc_assert (result
== 1);
606 gcc_assert (result
>= 1 && result
<= ARRAY_SIZE (decoded
->canonical_option
));
607 decoded
->canonical_option_num_elements
= result
;
609 for (i
= 0; i
< ARRAY_SIZE (decoded
->canonical_option
); i
++)
614 if (opt_index
== OPT_SPECIAL_unknown
)
615 decoded
->canonical_option
[i
] = argv
[i
];
617 decoded
->canonical_option
[i
] = NULL
;
618 len
= strlen (argv
[i
]);
619 /* If the argument is an empty string, we will print it as "" in
620 orig_option_with_args_text. */
621 total_len
+= (len
!= 0 ? len
: 2) + 1;
624 decoded
->canonical_option
[i
] = NULL
;
626 if (opt_index
!= OPT_SPECIAL_unknown
&& opt_index
!= OPT_SPECIAL_ignore
)
628 generate_canonical_option (opt_index
, arg
, value
, decoded
);
629 if (separate_args
> 1)
631 for (i
= 0; i
< separate_args
; i
++)
633 if (argv
[extra_args
+ 1 + i
] == NULL
)
636 decoded
->canonical_option
[1 + i
] = argv
[extra_args
+ 1 + i
];
638 gcc_assert (result
== 1 + i
);
639 decoded
->canonical_option_num_elements
= result
;
642 decoded
->orig_option_with_args_text
= p
= XNEWVEC (char, total_len
);
643 for (i
= 0; i
< result
; i
++)
645 size_t len
= strlen (argv
[i
]);
647 /* Print the empty string verbally. */
654 memcpy (p
, argv
[i
], len
);
665 /* Decode command-line options (ARGC and ARGV being the arguments of
666 main) into an array, setting *DECODED_OPTIONS to a pointer to that
667 array and *DECODED_OPTIONS_COUNT to the number of entries in the
668 array. The first entry in the array is always one for the program
669 name (OPT_SPECIAL_program_name). LANG_MASK indicates the language
670 flags applicable for decoding (including CL_COMMON and CL_TARGET if
671 those options should be considered applicable). Do not produce any
672 diagnostics or set state outside of these variables. */
675 decode_cmdline_options_to_array (unsigned int argc
, const char **argv
,
676 unsigned int lang_mask
,
677 struct cl_decoded_option
**decoded_options
,
678 unsigned int *decoded_options_count
)
681 struct cl_decoded_option
*opt_array
;
682 unsigned int num_decoded_options
;
683 bool argv_copied
= false;
685 opt_array
= XNEWVEC (struct cl_decoded_option
, argc
);
687 opt_array
[0].opt_index
= OPT_SPECIAL_program_name
;
688 opt_array
[0].warn_message
= NULL
;
689 opt_array
[0].arg
= argv
[0];
690 opt_array
[0].orig_option_with_args_text
= argv
[0];
691 opt_array
[0].canonical_option_num_elements
= 1;
692 opt_array
[0].canonical_option
[0] = argv
[0];
693 opt_array
[0].canonical_option
[1] = NULL
;
694 opt_array
[0].canonical_option
[2] = NULL
;
695 opt_array
[0].canonical_option
[3] = NULL
;
696 opt_array
[0].value
= 1;
697 opt_array
[0].errors
= 0;
698 num_decoded_options
= 1;
700 for (i
= 1; i
< argc
; i
+= n
)
702 const char *opt
= argv
[i
];
704 /* Interpret "-" or a non-switch as a file name. */
705 if (opt
[0] != '-' || opt
[1] == '\0')
707 generate_option_input_file (opt
, &opt_array
[num_decoded_options
]);
708 num_decoded_options
++;
713 n
= decode_cmdline_option (argv
+ i
, lang_mask
,
714 &opt_array
[num_decoded_options
]);
715 num_decoded_options
++;
720 *decoded_options
= opt_array
;
721 *decoded_options_count
= num_decoded_options
;
722 prune_options (decoded_options
, decoded_options_count
);
725 /* Return true if NEXT_OPT_IDX cancels OPT_IDX. Return false if the
726 next one is the same as ORIG_NEXT_OPT_IDX. */
729 cancel_option (int opt_idx
, int next_opt_idx
, int orig_next_opt_idx
)
731 /* An option can be canceled by the same option or an option with
733 if (cl_options
[next_opt_idx
].neg_index
== opt_idx
)
736 if (cl_options
[next_opt_idx
].neg_index
!= orig_next_opt_idx
)
737 return cancel_option (opt_idx
, cl_options
[next_opt_idx
].neg_index
,
743 /* Filter out options canceled by the ones after them. */
746 prune_options (struct cl_decoded_option
**decoded_options
,
747 unsigned int *decoded_options_count
)
749 unsigned int old_decoded_options_count
= *decoded_options_count
;
750 struct cl_decoded_option
*old_decoded_options
= *decoded_options
;
751 unsigned int new_decoded_options_count
;
752 struct cl_decoded_option
*new_decoded_options
753 = XNEWVEC (struct cl_decoded_option
, old_decoded_options_count
);
755 const struct cl_option
*option
;
757 /* Remove arguments which are negated by others after them. */
758 new_decoded_options_count
= 0;
759 for (i
= 0; i
< old_decoded_options_count
; i
++)
761 unsigned int j
, opt_idx
, next_opt_idx
;
763 if (old_decoded_options
[i
].errors
& ~CL_ERR_WRONG_LANG
)
766 opt_idx
= old_decoded_options
[i
].opt_index
;
769 case OPT_SPECIAL_unknown
:
770 case OPT_SPECIAL_ignore
:
771 case OPT_SPECIAL_program_name
:
772 case OPT_SPECIAL_input_file
:
776 gcc_assert (opt_idx
< cl_options_count
);
777 option
= &cl_options
[opt_idx
];
778 if (option
->neg_index
< 0)
781 /* Skip joined switches. */
782 if ((option
->flags
& CL_JOINED
))
785 for (j
= i
+ 1; j
< old_decoded_options_count
; j
++)
787 if (old_decoded_options
[j
].errors
& ~CL_ERR_WRONG_LANG
)
789 next_opt_idx
= old_decoded_options
[j
].opt_index
;
790 if (next_opt_idx
>= cl_options_count
)
792 if (cl_options
[next_opt_idx
].neg_index
< 0)
794 if ((cl_options
[next_opt_idx
].flags
& CL_JOINED
))
796 if (cancel_option (opt_idx
, next_opt_idx
, next_opt_idx
))
799 if (j
== old_decoded_options_count
)
802 new_decoded_options
[new_decoded_options_count
]
803 = old_decoded_options
[i
];
804 new_decoded_options_count
++;
810 free (old_decoded_options
);
811 new_decoded_options
= XRESIZEVEC (struct cl_decoded_option
,
813 new_decoded_options_count
);
814 *decoded_options
= new_decoded_options
;
815 *decoded_options_count
= new_decoded_options_count
;
818 /* Handle option DECODED for the language indicated by LANG_MASK,
819 using the handlers in HANDLERS and setting fields in OPTS and
820 OPTS_SET. KIND is the diagnostic_t if this is a diagnostics
821 option, DK_UNSPECIFIED otherwise, and LOC is the location of the
822 option for options from the source file, UNKNOWN_LOCATION
823 otherwise. GENERATED_P is true for an option generated as part of
824 processing another option or otherwise generated internally, false
825 for one explicitly passed by the user. Returns false if the switch
826 was invalid. DC is the diagnostic context for options affecting
827 diagnostics state, or NULL. */
830 handle_option (struct gcc_options
*opts
,
831 struct gcc_options
*opts_set
,
832 const struct cl_decoded_option
*decoded
,
833 unsigned int lang_mask
, int kind
, location_t loc
,
834 const struct cl_option_handlers
*handlers
,
835 bool generated_p
, diagnostic_context
*dc
)
837 size_t opt_index
= decoded
->opt_index
;
838 const char *arg
= decoded
->arg
;
839 int value
= decoded
->value
;
840 const struct cl_option
*option
= &cl_options
[opt_index
];
841 void *flag_var
= option_flag_var (opt_index
, opts
);
845 set_option (opts
, (generated_p
? NULL
: opts_set
),
846 opt_index
, value
, arg
, kind
, loc
, dc
);
848 for (i
= 0; i
< handlers
->num_handlers
; i
++)
849 if (option
->flags
& handlers
->handlers
[i
].mask
)
851 if (!handlers
->handlers
[i
].handler (opts
, opts_set
, decoded
,
852 lang_mask
, kind
, loc
,
856 handlers
->post_handling_callback (decoded
,
857 handlers
->handlers
[i
].mask
);
863 /* Like handle_option, but OPT_INDEX, ARG and VALUE describe the
864 option instead of DECODED. This is used for callbacks when one
865 option implies another instead of an option being decoded from the
869 handle_generated_option (struct gcc_options
*opts
,
870 struct gcc_options
*opts_set
,
871 size_t opt_index
, const char *arg
, int value
,
872 unsigned int lang_mask
, int kind
, location_t loc
,
873 const struct cl_option_handlers
*handlers
,
874 diagnostic_context
*dc
)
876 struct cl_decoded_option decoded
;
878 generate_option (opt_index
, arg
, value
, lang_mask
, &decoded
);
879 return handle_option (opts
, opts_set
, &decoded
, lang_mask
, kind
, loc
,
883 /* Fill in *DECODED with an option described by OPT_INDEX, ARG and
884 VALUE for a front end using LANG_MASK. This is used when the
885 compiler generates options internally. */
888 generate_option (size_t opt_index
, const char *arg
, int value
,
889 unsigned int lang_mask
, struct cl_decoded_option
*decoded
)
891 const struct cl_option
*option
= &cl_options
[opt_index
];
893 decoded
->opt_index
= opt_index
;
894 decoded
->warn_message
= NULL
;
896 decoded
->value
= value
;
897 decoded
->errors
= (option_ok_for_language (option
, lang_mask
)
899 : CL_ERR_WRONG_LANG
);
901 generate_canonical_option (opt_index
, arg
, value
, decoded
);
902 switch (decoded
->canonical_option_num_elements
)
905 decoded
->orig_option_with_args_text
= decoded
->canonical_option
[0];
909 decoded
->orig_option_with_args_text
910 = concat (decoded
->canonical_option
[0], " ",
911 decoded
->canonical_option
[1], NULL
);
919 /* Fill in *DECODED with an option for input file FILE. */
922 generate_option_input_file (const char *file
,
923 struct cl_decoded_option
*decoded
)
925 decoded
->opt_index
= OPT_SPECIAL_input_file
;
926 decoded
->warn_message
= NULL
;
928 decoded
->orig_option_with_args_text
= file
;
929 decoded
->canonical_option_num_elements
= 1;
930 decoded
->canonical_option
[0] = file
;
931 decoded
->canonical_option
[1] = NULL
;
932 decoded
->canonical_option
[2] = NULL
;
933 decoded
->canonical_option
[3] = NULL
;
938 /* Handle the switch DECODED (location LOC) for the language indicated
939 by LANG_MASK, using the handlers in *HANDLERS and setting fields in
940 OPTS and OPTS_SET and using diagnostic context DC (if not NULL) for
941 diagnostic options. */
944 read_cmdline_option (struct gcc_options
*opts
,
945 struct gcc_options
*opts_set
,
946 struct cl_decoded_option
*decoded
,
948 unsigned int lang_mask
,
949 const struct cl_option_handlers
*handlers
,
950 diagnostic_context
*dc
)
952 const struct cl_option
*option
;
953 const char *opt
= decoded
->orig_option_with_args_text
;
955 if (decoded
->warn_message
)
956 warning_at (loc
, 0, decoded
->warn_message
, opt
);
958 if (decoded
->opt_index
== OPT_SPECIAL_unknown
)
960 if (handlers
->unknown_option_callback (decoded
))
961 error_at (loc
, "unrecognized command line option %qs", decoded
->arg
);
965 if (decoded
->opt_index
== OPT_SPECIAL_ignore
)
968 option
= &cl_options
[decoded
->opt_index
];
970 if (decoded
->errors
& CL_ERR_DISABLED
)
972 error_at (loc
, "command line option %qs"
973 " is not supported by this configuration", opt
);
977 if (decoded
->errors
& CL_ERR_MISSING_ARG
)
979 if (option
->missing_argument_error
)
980 error_at (loc
, option
->missing_argument_error
, opt
);
982 error_at (loc
, "missing argument to %qs", opt
);
986 if (decoded
->errors
& CL_ERR_UINT_ARG
)
988 error_at (loc
, "argument to %qs should be a non-negative integer",
993 if (decoded
->errors
& CL_ERR_ENUM_ARG
)
995 const struct cl_enum
*e
= &cl_enums
[option
->var_enum
];
1000 if (e
->unknown_error
)
1001 error_at (loc
, e
->unknown_error
, decoded
->arg
);
1003 error_at (loc
, "unrecognized argument in option %qs", opt
);
1006 for (i
= 0; e
->values
[i
].arg
!= NULL
; i
++)
1007 len
+= strlen (e
->values
[i
].arg
) + 1;
1009 s
= XALLOCAVEC (char, len
);
1011 for (i
= 0; e
->values
[i
].arg
!= NULL
; i
++)
1013 size_t arglen
= strlen (e
->values
[i
].arg
);
1014 memcpy (p
, e
->values
[i
].arg
, arglen
);
1019 inform (loc
, "valid arguments to %qs are: %s", option
->opt_text
, s
);
1023 if (decoded
->errors
& CL_ERR_WRONG_LANG
)
1025 handlers
->wrong_lang_callback (decoded
, lang_mask
);
1029 gcc_assert (!decoded
->errors
);
1031 if (!handle_option (opts
, opts_set
, decoded
, lang_mask
, DK_UNSPECIFIED
,
1032 loc
, handlers
, false, dc
))
1033 error_at (loc
, "unrecognized command line option %qs", opt
);
1036 /* Set any field in OPTS, and OPTS_SET if not NULL, for option
1037 OPT_INDEX according to VALUE and ARG, diagnostic kind KIND,
1038 location LOC, using diagnostic context DC if not NULL for
1039 diagnostic classification. */
1042 set_option (struct gcc_options
*opts
, struct gcc_options
*opts_set
,
1043 int opt_index
, int value
, const char *arg
, int kind
,
1044 location_t loc
, diagnostic_context
*dc
)
1046 const struct cl_option
*option
= &cl_options
[opt_index
];
1047 void *flag_var
= option_flag_var (opt_index
, opts
);
1048 void *set_flag_var
= NULL
;
1053 if (opts_set
!= NULL
)
1054 set_flag_var
= option_flag_var (opt_index
, opts_set
);
1056 switch (option
->var_type
)
1059 *(int *) flag_var
= value
;
1061 *(int *) set_flag_var
= 1;
1065 *(int *) flag_var
= (value
1067 : !option
->var_value
);
1069 *(int *) set_flag_var
= 1;
1072 case CLVC_BIT_CLEAR
:
1074 if ((value
!= 0) == (option
->var_type
== CLVC_BIT_SET
))
1075 *(int *) flag_var
|= option
->var_value
;
1077 *(int *) flag_var
&= ~option
->var_value
;
1079 *(int *) set_flag_var
|= option
->var_value
;
1083 *(const char **) flag_var
= arg
;
1085 *(const char **) set_flag_var
= "";
1090 const struct cl_enum
*e
= &cl_enums
[option
->var_enum
];
1092 e
->set (flag_var
, value
);
1094 e
->set (set_flag_var
, 1);
1100 VEC(cl_deferred_option
,heap
) *vec
1101 = (VEC(cl_deferred_option
,heap
) *) *(void **) flag_var
;
1102 cl_deferred_option
*p
;
1104 p
= VEC_safe_push (cl_deferred_option
, heap
, vec
, NULL
);
1105 p
->opt_index
= opt_index
;
1108 *(void **) flag_var
= vec
;
1110 *(void **) set_flag_var
= vec
;
1115 if ((diagnostic_t
) kind
!= DK_UNSPECIFIED
1117 diagnostic_classify_diagnostic (dc
, opt_index
, (diagnostic_t
) kind
, loc
);
1120 /* Return the address of the flag variable for option OPT_INDEX in
1121 options structure OPTS, or NULL if there is no flag variable. */
1124 option_flag_var (int opt_index
, struct gcc_options
*opts
)
1126 const struct cl_option
*option
= &cl_options
[opt_index
];
1128 if (option
->flag_var_offset
== (unsigned short) -1)
1130 return (void *)(((char *) opts
) + option
->flag_var_offset
);
1133 /* Return 1 if option OPT_IDX is enabled in OPTS, 0 if it is disabled,
1134 or -1 if it isn't a simple on-off switch. */
1137 option_enabled (int opt_idx
, void *opts
)
1139 const struct cl_option
*option
= &(cl_options
[opt_idx
]);
1140 struct gcc_options
*optsg
= (struct gcc_options
*) opts
;
1141 void *flag_var
= option_flag_var (opt_idx
, optsg
);
1144 switch (option
->var_type
)
1147 return *(int *) flag_var
!= 0;
1150 return *(int *) flag_var
== option
->var_value
;
1152 case CLVC_BIT_CLEAR
:
1153 return (*(int *) flag_var
& option
->var_value
) == 0;
1156 return (*(int *) flag_var
& option
->var_value
) != 0;
1166 /* Fill STATE with the current state of option OPTION in OPTS. Return
1167 true if there is some state to store. */
1170 get_option_state (struct gcc_options
*opts
, int option
,
1171 struct cl_option_state
*state
)
1173 void *flag_var
= option_flag_var (option
, opts
);
1178 switch (cl_options
[option
].var_type
)
1182 state
->data
= flag_var
;
1183 state
->size
= sizeof (int);
1186 case CLVC_BIT_CLEAR
:
1188 state
->ch
= option_enabled (option
, opts
);
1189 state
->data
= &state
->ch
;
1194 state
->data
= *(const char **) flag_var
;
1195 if (state
->data
== 0)
1197 state
->size
= strlen ((const char *) state
->data
) + 1;
1201 state
->data
= flag_var
;
1202 state
->size
= cl_enums
[cl_options
[option
].var_enum
].var_size
;
1211 /* Set a warning option OPT_INDEX (language mask LANG_MASK, option
1212 handlers HANDLERS) to have diagnostic kind KIND for option
1213 structures OPTS and OPTS_SET and diagnostic context DC (possibly
1214 NULL), at location LOC (UNKNOWN_LOCATION for -Werror=). If IMPLY,
1215 the warning option in question is implied at this point. This is
1216 used by -Werror= and #pragma GCC diagnostic. */
1219 control_warning_option (unsigned int opt_index
, int kind
, bool imply
,
1220 location_t loc
, unsigned int lang_mask
,
1221 const struct cl_option_handlers
*handlers
,
1222 struct gcc_options
*opts
,
1223 struct gcc_options
*opts_set
,
1224 diagnostic_context
*dc
)
1226 if (cl_options
[opt_index
].alias_target
!= N_OPTS
)
1227 opt_index
= cl_options
[opt_index
].alias_target
;
1228 if (opt_index
== OPT_SPECIAL_ignore
)
1231 diagnostic_classify_diagnostic (dc
, opt_index
, (diagnostic_t
) kind
, loc
);
1234 /* -Werror=foo implies -Wfoo. */
1235 if (cl_options
[opt_index
].var_type
== CLVC_BOOLEAN
)
1236 handle_generated_option (opts
, opts_set
,
1237 opt_index
, NULL
, 1, lang_mask
,
1238 kind
, loc
, handlers
, dc
);