1 /* Command line option handling.
2 Copyright (C) 2006-2019 Free Software Foundation, Inc.
3
4 This file is part of GCC.
5
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
9 version.
10
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
14 for more details.
15
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/>. */
19
20 #include "config.h"
21 #include "system.h"
22 #include "intl.h"
23 #include "coretypes.h"
24 #include "opts.h"
25 #include "options.h"
26 #include "diagnostic.h"
27 #include "spellcheck.h"
28
29 static void prune_options (struct cl_decoded_option **, unsigned int *);
30
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. */
40
41 static bool
remapping_prefix_p(const struct cl_option * opt)42 remapping_prefix_p (const struct cl_option *opt)
43 {
44 return opt->flags & CL_UNDOCUMENTED
45 && opt->flags & CL_JOINED
46 && !(opt->flags & (CL_DRIVER | CL_TARGET | CL_COMMON | CL_LANG_ALL));
47 }
48
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.
52
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".
57
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).
68
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. */
73 size_t
find_opt(const char * input,unsigned int lang_mask)74 find_opt (const char *input, unsigned int lang_mask)
75 {
76 size_t mn, mn_orig, mx, md, opt_len;
77 size_t match_wrong_lang;
78 int comp;
79
80 mn = 0;
81 mx = cl_options_count;
82
83 /* Find mn such this lexicographical inequality holds:
84 cl_options[mn] <= input < cl_options[mn + 1]. */
85 while (mx - mn > 1)
86 {
87 md = (mn + mx) / 2;
88 opt_len = cl_options[md].opt_len;
89 comp = strncmp (input, cl_options[md].opt_text + 1, opt_len);
90
91 if (comp < 0)
92 mx = md;
93 else
94 mn = md;
95 }
96
97 mn_orig = mn;
98
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;
102
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. */
106 do
107 {
108 const struct cl_option *opt = &cl_options[mn];
109
110 /* Is the input either an exact match or a prefix that takes a
111 joined argument? */
112 if (!strncmp (input, opt->opt_text + 1, opt->opt_len)
113 && (input[opt->opt_len] == '\0' || (opt->flags & CL_JOINED)))
114 {
115 /* If language is OK, return it. */
116 if (opt->flags & lang_mask)
117 return mn;
118
119 if (remapping_prefix_p (opt))
120 return OPT_SPECIAL_unknown;
121
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;
126 }
127
128 /* Try the next possibility. This is cl_options_count if there
129 are no more. */
130 mn = opt->back_chain;
131 }
132 while (mn != cl_options_count);
133
134 if (match_wrong_lang == OPT_SPECIAL_unknown && input[0] == '-')
135 {
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)
144 {
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
149 ambiguous. */
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. */
162 else
163 return OPT_SPECIAL_unknown;
164 mnc++;
165 }
166 }
167
168 /* Return the best wrong match, or OPT_SPECIAL_unknown if none. */
169 return match_wrong_lang;
170 }
171
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
175 otherwise. */
176
177 HOST_WIDE_INT
integral_argument(const char * arg,int * err,bool byte_size_suffix)178 integral_argument (const char *arg, int *err, bool byte_size_suffix)
179 {
180 if (!err)
181 err = &errno;
182
183 if (!ISDIGIT (*arg))
184 {
185 *err = EINVAL;
186 return -1;
187 }
188
189 *err = 0;
190 errno = 0;
191
192 char *end = NULL;
193 unsigned HOST_WIDE_INT unit = 1;
194 unsigned HOST_WIDE_INT value = strtoull (arg, &end, 10);
195
196 /* If the value is too large to be represented use the maximum
197 representable value that strtoull sets VALUE to (setting
198 errno to ERANGE). */
199
200 if (end && *end)
201 {
202 if (!byte_size_suffix)
203 {
204 errno = 0;
205 value = strtoull (arg, &end, 0);
206 if (*end)
207 {
208 if (errno)
209 *err = errno;
210 else
211 *err = EINVAL;
212 return -1;
213 }
214
215 return value;
216 }
217
218 /* Numeric option arguments are at most INT_MAX. Make it
219 possible to specify a larger value by accepting common
220 suffixes. */
221 if (!strcmp (end, "kB"))
222 unit = 1000;
223 else if (!strcasecmp (end, "KiB") || !strcmp (end, "KB"))
224 unit = 1024;
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
243 * 1000;
244 else if (!strcasecmp (end, "EiB"))
245 unit = HOST_WIDE_INT_UC (1024) * 1024 * 1024 * 1024 * 1024
246 * 1024;
247 else
248 {
249 /* This could mean an unknown suffix or a bad prefix, like
250 "+-1". */
251 *err = EINVAL;
252 return -1;
253 }
254 }
255
256 if (unit)
257 {
258 unsigned HOST_WIDE_INT prod = value * unit;
259 value = prod < value ? HOST_WIDE_INT_M1U : prod;
260 }
261
262 return value;
263 }
264
265 /* Return whether OPTION is OK for the language given by
266 LANG_MASK. */
267 static bool
option_ok_for_language(const struct cl_option * option,unsigned int lang_mask)268 option_ok_for_language (const struct cl_option *option,
269 unsigned int lang_mask)
270 {
271 if (!(option->flags & lang_mask))
272 return false;
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
277 are specified. */
278 return false;
279 return true;
280 }
281
282 /* Return whether ENUM_ARG is OK for the language given by
283 LANG_MASK. */
284
285 static bool
enum_arg_ok_for_language(const struct cl_enum_arg * enum_arg,unsigned int lang_mask)286 enum_arg_ok_for_language (const struct cl_enum_arg *enum_arg,
287 unsigned int lang_mask)
288 {
289 return (lang_mask & CL_DRIVER) || !(enum_arg->flags & CL_ENUM_DRIVER_ONLY);
290 }
291
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. */
295
296 static bool
enum_arg_to_value(const struct cl_enum_arg * enum_args,const char * arg,HOST_WIDE_INT * value,unsigned int lang_mask)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)
300 {
301 unsigned int i;
302
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))
306 {
307 *value = enum_args[i].value;
308 return true;
309 }
310
311 return false;
312 }
313
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. */
317
318 bool
opt_enum_arg_to_value(size_t opt_index,const char * arg,int * value,unsigned int lang_mask)319 opt_enum_arg_to_value (size_t opt_index, const char *arg,
320 int *value, unsigned int lang_mask)
321 {
322 const struct cl_option *option = &cl_options[opt_index];
323
324 gcc_assert (option->var_type == CLVC_ENUM);
325
326 HOST_WIDE_INT wideval;
327 if (enum_arg_to_value (cl_enums[option->var_enum].values, arg,
328 &wideval, lang_mask))
329 {
330 *value = wideval;
331 return true;
332 }
333
334 return false;
335 }
336
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
342 false. */
343
344 bool
enum_value_to_arg(const struct cl_enum_arg * enum_args,const char ** argp,int value,unsigned int lang_mask)345 enum_value_to_arg (const struct cl_enum_arg *enum_args,
346 const char **argp, int value, unsigned int lang_mask)
347 {
348 unsigned int i;
349
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))
354 {
355 *argp = enum_args[i].arg;
356 return true;
357 }
358
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))
362 {
363 *argp = enum_args[i].arg;
364 return false;
365 }
366
367 *argp = NULL;
368 return false;
369 }
370
371 /* Fill in the canonical option part of *DECODED with an option
372 described by OPT_INDEX, ARG and VALUE. */
373
374 static void
generate_canonical_option(size_t opt_index,const char * arg,HOST_WIDE_INT value,struct cl_decoded_option * decoded)375 generate_canonical_option (size_t opt_index, const char *arg,
376 HOST_WIDE_INT value,
377 struct cl_decoded_option *decoded)
378 {
379 const struct cl_option *option = &cl_options[opt_index];
380 const char *opt_text = option->opt_text;
381
382 if (value == 0
383 && !option->cl_reject_negative
384 && (opt_text[1] == 'W' || opt_text[1] == 'f'
385 || opt_text[1] == 'g' || opt_text[1] == 'm'))
386 {
387 char *t = XOBNEWVEC (&opts_obstack, char, option->opt_len + 5);
388 t[0] = '-';
389 t[1] = opt_text[1];
390 t[2] = 'n';
391 t[3] = 'o';
392 t[4] = '-';
393 memcpy (t + 5, opt_text + 2, option->opt_len);
394 opt_text = t;
395 }
396
397 decoded->canonical_option[2] = NULL;
398 decoded->canonical_option[3] = NULL;
399
400 if (arg)
401 {
402 if ((option->flags & CL_SEPARATE)
403 && !option->cl_separate_alias)
404 {
405 decoded->canonical_option[0] = opt_text;
406 decoded->canonical_option[1] = arg;
407 decoded->canonical_option_num_elements = 2;
408 }
409 else
410 {
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;
415 }
416 }
417 else
418 {
419 decoded->canonical_option[0] = opt_text;
420 decoded->canonical_option[1] = NULL;
421 decoded->canonical_option_num_elements = 1;
422 }
423 }
424
425 /* Structure describing mappings from options on the command line to
426 options to look up with find_opt. */
427 struct option_map
428 {
429 /* Prefix of the option on the command line. */
430 const char *opt0;
431 /* If two argv elements are considered to be merged into one option,
432 prefix for the second element, otherwise NULL. */
433 const char *opt1;
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. */
442 bool negated;
443 };
444 static const struct option_map option_map[] =
445 {
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 }
464 };
465
466 /* Helper function for gcc.c's driver::suggest_option, for populating the
467 vec of suggestions for misspelled options.
468
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.
473
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
476 dash.
477
478 For example, given "-Wabi-tag", the following are added to CANDIDATES:
479 "Wabi-tag"
480 "Wno-abi-tag"
481 "-warn-abi-tag"
482 "-warn-no-abi-tag".
483
484 The added strings must be freed using free. */
485
486 void
add_misspelling_candidates(auto_vec<char * > * candidates,const struct cl_option * option,const char * opt_text)487 add_misspelling_candidates (auto_vec<char *> *candidates,
488 const struct cl_option *option,
489 const char *opt_text)
490 {
491 gcc_assert (candidates);
492 gcc_assert (option);
493 gcc_assert (opt_text);
494 if (remapping_prefix_p (option))
495 return;
496 candidates->safe_push (xstrdup (opt_text + 1));
497 for (unsigned i = 0; i < ARRAY_SIZE (option_map); i++)
498 {
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);
502
503 if (option->cl_reject_negative && option_map[i].negated)
504 continue;
505
506 if (strncmp (opt_text, new_prefix, new_prefix_len) == 0)
507 {
508 char *alternative = concat (opt0 + 1, opt_text + new_prefix_len,
509 NULL);
510 candidates->safe_push (alternative);
511 }
512 }
513 }
514
515 /* Decode the switch beginning at ARGV for the language indicated by
516 LANG_MASK (including CL_COMMON and CL_TARGET if applicable), into
517 the structure *DECODED. Returns the number of switches
518 consumed. */
519
520 static unsigned int
decode_cmdline_option(const char ** argv,unsigned int lang_mask,struct cl_decoded_option * decoded)521 decode_cmdline_option (const char **argv, unsigned int lang_mask,
522 struct cl_decoded_option *decoded)
523 {
524 size_t opt_index;
525 const char *arg = 0;
526 HOST_WIDE_INT value = 1;
527 unsigned int result = 1, i, extra_args, separate_args = 0;
528 int adjust_len = 0;
529 size_t total_len;
530 char *p;
531 const struct cl_option *option;
532 int errors = 0;
533 const char *warn_message = NULL;
534 bool separate_arg_flag;
535 bool joined_arg_flag;
536 bool have_separate_arg = false;
537
538 extra_args = 0;
539
540 opt_index = find_opt (argv[0] + 1, lang_mask);
541 i = 0;
542 while (opt_index == OPT_SPECIAL_unknown
543 && i < ARRAY_SIZE (option_map))
544 {
545 const char *opt0 = option_map[i].opt0;
546 const char *opt1 = option_map[i].opt1;
547 const char *new_prefix = option_map[i].new_prefix;
548 bool another_char_needed = option_map[i].another_char_needed;
549 size_t opt0_len = strlen (opt0);
550 size_t opt1_len = (opt1 == NULL ? 0 : strlen (opt1));
551 size_t optn_len = (opt1 == NULL ? opt0_len : opt1_len);
552 size_t new_prefix_len = strlen (new_prefix);
553
554 extra_args = (opt1 == NULL ? 0 : 1);
555 value = !option_map[i].negated;
556
557 if (strncmp (argv[0], opt0, opt0_len) == 0
558 && (opt1 == NULL
559 || (argv[1] != NULL && strncmp (argv[1], opt1, opt1_len) == 0))
560 && (!another_char_needed
561 || argv[extra_args][optn_len] != 0))
562 {
563 size_t arglen = strlen (argv[extra_args]);
564 char *dup;
565
566 adjust_len = (int) optn_len - (int) new_prefix_len;
567 dup = XNEWVEC (char, arglen + 1 - adjust_len);
568 memcpy (dup, new_prefix, new_prefix_len);
569 memcpy (dup + new_prefix_len, argv[extra_args] + optn_len,
570 arglen - optn_len + 1);
571 opt_index = find_opt (dup + 1, lang_mask);
572 free (dup);
573 }
574 i++;
575 }
576
577 if (opt_index == OPT_SPECIAL_unknown)
578 {
579 arg = argv[0];
580 extra_args = 0;
581 value = 1;
582 goto done;
583 }
584
585 option = &cl_options[opt_index];
586
587 /* Reject negative form of switches that don't take negatives as
588 unrecognized. */
589 if (!value && option->cl_reject_negative)
590 {
591 opt_index = OPT_SPECIAL_unknown;
592 errors |= CL_ERR_NEGATIVE;
593 arg = argv[0];
594 goto done;
595 }
596
597 /* Clear the initial value for size options (it will be overwritten
598 later based on the Init(value) specification in the opt file. */
599 if (option->var_type == CLVC_SIZE)
600 value = 0;
601
602 result = extra_args + 1;
603 warn_message = option->warn_message;
604
605 /* Check to see if the option is disabled for this configuration. */
606 if (option->cl_disabled)
607 errors |= CL_ERR_DISABLED;
608
609 /* Determine whether there may be a separate argument based on
610 whether this option is being processed for the driver, and, if
611 so, how many such arguments. */
612 separate_arg_flag = ((option->flags & CL_SEPARATE)
613 && !(option->cl_no_driver_arg
614 && (lang_mask & CL_DRIVER)));
615 separate_args = (separate_arg_flag
616 ? option->cl_separate_nargs + 1
617 : 0);
618 joined_arg_flag = (option->flags & CL_JOINED) != 0;
619
620 /* Sort out any argument the switch takes. */
621 if (joined_arg_flag)
622 {
623 /* Have arg point to the original switch. This is because
624 some code, such as disable_builtin_function, expects its
625 argument to be persistent until the program exits. */
626 arg = argv[extra_args] + cl_options[opt_index].opt_len + 1 + adjust_len;
627
628 if (*arg == '\0' && !option->cl_missing_ok)
629 {
630 if (separate_arg_flag)
631 {
632 arg = argv[extra_args + 1];
633 result = extra_args + 2;
634 if (arg == NULL)
635 result = extra_args + 1;
636 else
637 have_separate_arg = true;
638 }
639 else
640 /* Missing argument. */
641 arg = NULL;
642 }
643 }
644 else if (separate_arg_flag)
645 {
646 arg = argv[extra_args + 1];
647 for (i = 0; i < separate_args; i++)
648 if (argv[extra_args + 1 + i] == NULL)
649 {
650 errors |= CL_ERR_MISSING_ARG;
651 break;
652 }
653 result = extra_args + 1 + i;
654 if (arg != NULL)
655 have_separate_arg = true;
656 }
657
658 if (arg == NULL && (separate_arg_flag || joined_arg_flag))
659 errors |= CL_ERR_MISSING_ARG;
660
661 /* Is this option an alias (or an ignored option, marked as an alias
662 of OPT_SPECIAL_ignore)? */
663 if (option->alias_target != N_OPTS
664 && (!option->cl_separate_alias || have_separate_arg))
665 {
666 size_t new_opt_index = option->alias_target;
667
668 if (new_opt_index == OPT_SPECIAL_ignore
669 || new_opt_index == OPT_SPECIAL_deprecated)
670 {
671 gcc_assert (option->alias_arg == NULL);
672 gcc_assert (option->neg_alias_arg == NULL);
673 opt_index = new_opt_index;
674 arg = NULL;
675 }
676 else
677 {
678 const struct cl_option *new_option = &cl_options[new_opt_index];
679
680 /* The new option must not be an alias itself. */
681 gcc_assert (new_option->alias_target == N_OPTS
682 || new_option->cl_separate_alias);
683
684 if (option->neg_alias_arg)
685 {
686 gcc_assert (option->alias_arg != NULL);
687 gcc_assert (arg == NULL);
688 gcc_assert (!option->cl_negative_alias);
689 if (value)
690 arg = option->alias_arg;
691 else
692 arg = option->neg_alias_arg;
693 value = 1;
694 }
695 else if (option->alias_arg)
696 {
697 gcc_assert (value == 1);
698 gcc_assert (arg == NULL);
699 gcc_assert (!option->cl_negative_alias);
700 arg = option->alias_arg;
701 }
702
703 if (option->cl_negative_alias)
704 value = !value;
705
706 opt_index = new_opt_index;
707 option = new_option;
708
709 if (value == 0)
710 gcc_assert (!option->cl_reject_negative);
711
712 /* Recompute what arguments are allowed. */
713 separate_arg_flag = ((option->flags & CL_SEPARATE)
714 && !(option->cl_no_driver_arg
715 && (lang_mask & CL_DRIVER)));
716 joined_arg_flag = (option->flags & CL_JOINED) != 0;
717
718 if (separate_args > 1 || option->cl_separate_nargs)
719 gcc_assert (separate_args
720 == (unsigned int) option->cl_separate_nargs + 1);
721
722 if (!(errors & CL_ERR_MISSING_ARG))
723 {
724 if (separate_arg_flag || joined_arg_flag)
725 {
726 if (option->cl_missing_ok && arg == NULL)
727 arg = "";
728 gcc_assert (arg != NULL);
729 }
730 else
731 gcc_assert (arg == NULL);
732 }
733
734 /* Recheck for warnings and disabled options. */
735 if (option->warn_message)
736 {
737 gcc_assert (warn_message == NULL);
738 warn_message = option->warn_message;
739 }
740 if (option->cl_disabled)
741 errors |= CL_ERR_DISABLED;
742 }
743 }
744
745 /* Check if this is a switch for a different front end. */
746 if (!option_ok_for_language (option, lang_mask))
747 errors |= CL_ERR_WRONG_LANG;
748
749 /* Convert the argument to lowercase if appropriate. */
750 if (arg && option->cl_tolower)
751 {
752 size_t j;
753 size_t len = strlen (arg);
754 char *arg_lower = XOBNEWVEC (&opts_obstack, char, len + 1);
755
756 for (j = 0; j < len; j++)
757 arg_lower[j] = TOLOWER ((unsigned char) arg[j]);
758 arg_lower[len] = 0;
759 arg = arg_lower;
760 }
761
762 /* If the switch takes an integer argument, convert it. */
763 if (arg && (option->cl_uinteger || option->cl_host_wide_int))
764 {
765 int error = 0;
766 value = *arg ? integral_argument (arg, &error, option->cl_byte_size) : 0;
767 if (error)
768 errors |= CL_ERR_UINT_ARG;
769
770 /* Reject value out of a range. */
771 if (option->range_max != -1
772 && (value < option->range_min || value > option->range_max))
773 errors |= CL_ERR_INT_RANGE_ARG;
774 }
775
776 /* If the switch takes an enumerated argument, convert it. */
777 if (arg && (option->var_type == CLVC_ENUM))
778 {
779 const struct cl_enum *e = &cl_enums[option->var_enum];
780
781 gcc_assert (value == 1);
782 if (enum_arg_to_value (e->values, arg, &value, lang_mask))
783 {
784 const char *carg = NULL;
785
786 if (enum_value_to_arg (e->values, &carg, value, lang_mask))
787 arg = carg;
788 gcc_assert (carg != NULL);
789 }
790 else
791 errors |= CL_ERR_ENUM_ARG;
792 }
793
794 done:
795 decoded->opt_index = opt_index;
796 decoded->arg = arg;
797 decoded->value = value;
798 decoded->errors = errors;
799 decoded->warn_message = warn_message;
800
801 if (opt_index == OPT_SPECIAL_unknown)
802 gcc_assert (result == 1);
803
804 gcc_assert (result >= 1 && result <= ARRAY_SIZE (decoded->canonical_option));
805 decoded->canonical_option_num_elements = result;
806 total_len = 0;
807 for (i = 0; i < ARRAY_SIZE (decoded->canonical_option); i++)
808 {
809 if (i < result)
810 {
811 size_t len;
812 if (opt_index == OPT_SPECIAL_unknown)
813 decoded->canonical_option[i] = argv[i];
814 else
815 decoded->canonical_option[i] = NULL;
816 len = strlen (argv[i]);
817 /* If the argument is an empty string, we will print it as "" in
818 orig_option_with_args_text. */
819 total_len += (len != 0 ? len : 2) + 1;
820 }
821 else
822 decoded->canonical_option[i] = NULL;
823 }
824 if (opt_index != OPT_SPECIAL_unknown && opt_index != OPT_SPECIAL_ignore
825 && opt_index != OPT_SPECIAL_deprecated)
826 {
827 generate_canonical_option (opt_index, arg, value, decoded);
828 if (separate_args > 1)
829 {
830 for (i = 0; i < separate_args; i++)
831 {
832 if (argv[extra_args + 1 + i] == NULL)
833 break;
834 else
835 decoded->canonical_option[1 + i] = argv[extra_args + 1 + i];
836 }
837 gcc_assert (result == 1 + i);
838 decoded->canonical_option_num_elements = result;
839 }
840 }
841 decoded->orig_option_with_args_text
842 = p = XOBNEWVEC (&opts_obstack, char, total_len);
843 for (i = 0; i < result; i++)
844 {
845 size_t len = strlen (argv[i]);
846
847 /* Print the empty string verbally. */
848 if (len == 0)
849 {
850 *p++ = '"';
851 *p++ = '"';
852 }
853 else
854 memcpy (p, argv[i], len);
855 p += len;
856 if (i == result - 1)
857 *p++ = 0;
858 else
859 *p++ = ' ';
860 }
861
862 return result;
863 }
864
865 /* Obstack for option strings. */
866
867 struct obstack opts_obstack;
868
869 /* Like libiberty concat, but allocate using opts_obstack. */
870
871 char *
opts_concat(const char * first,...)872 opts_concat (const char *first, ...)
873 {
874 char *newstr, *end;
875 size_t length = 0;
876 const char *arg;
877 va_list ap;
878
879 /* First compute the size of the result and get sufficient memory. */
880 va_start (ap, first);
881 for (arg = first; arg; arg = va_arg (ap, const char *))
882 length += strlen (arg);
883 newstr = XOBNEWVEC (&opts_obstack, char, length + 1);
884 va_end (ap);
885
886 /* Now copy the individual pieces to the result string. */
887 va_start (ap, first);
888 for (arg = first, end = newstr; arg; arg = va_arg (ap, const char *))
889 {
890 length = strlen (arg);
891 memcpy (end, arg, length);
892 end += length;
893 }
894 *end = '\0';
895 va_end (ap);
896 return newstr;
897 }
898
899 /* Decode command-line options (ARGC and ARGV being the arguments of
900 main) into an array, setting *DECODED_OPTIONS to a pointer to that
901 array and *DECODED_OPTIONS_COUNT to the number of entries in the
902 array. The first entry in the array is always one for the program
903 name (OPT_SPECIAL_program_name). LANG_MASK indicates the language
904 flags applicable for decoding (including CL_COMMON and CL_TARGET if
905 those options should be considered applicable). Do not produce any
906 diagnostics or set state outside of these variables. */
907
908 void
decode_cmdline_options_to_array(unsigned int argc,const char ** argv,unsigned int lang_mask,struct cl_decoded_option ** decoded_options,unsigned int * decoded_options_count)909 decode_cmdline_options_to_array (unsigned int argc, const char **argv,
910 unsigned int lang_mask,
911 struct cl_decoded_option **decoded_options,
912 unsigned int *decoded_options_count)
913 {
914 unsigned int n, i;
915 struct cl_decoded_option *opt_array;
916 unsigned int num_decoded_options;
917
918 opt_array = XNEWVEC (struct cl_decoded_option, argc);
919
920 opt_array[0].opt_index = OPT_SPECIAL_program_name;
921 opt_array[0].warn_message = NULL;
922 opt_array[0].arg = argv[0];
923 opt_array[0].orig_option_with_args_text = argv[0];
924 opt_array[0].canonical_option_num_elements = 1;
925 opt_array[0].canonical_option[0] = argv[0];
926 opt_array[0].canonical_option[1] = NULL;
927 opt_array[0].canonical_option[2] = NULL;
928 opt_array[0].canonical_option[3] = NULL;
929 opt_array[0].value = 1;
930 opt_array[0].errors = 0;
931 num_decoded_options = 1;
932
933 for (i = 1; i < argc; i += n)
934 {
935 const char *opt = argv[i];
936
937 /* Interpret "-" or a non-switch as a file name. */
938 if (opt[0] != '-' || opt[1] == '\0')
939 {
940 generate_option_input_file (opt, &opt_array[num_decoded_options]);
941 num_decoded_options++;
942 n = 1;
943 continue;
944 }
945
946 n = decode_cmdline_option (argv + i, lang_mask,
947 &opt_array[num_decoded_options]);
948 num_decoded_options++;
949 }
950
951 *decoded_options = opt_array;
952 *decoded_options_count = num_decoded_options;
953 prune_options (decoded_options, decoded_options_count);
954 }
955
956 /* Return true if NEXT_OPT_IDX cancels OPT_IDX. Return false if the
957 next one is the same as ORIG_NEXT_OPT_IDX. */
958
959 static bool
cancel_option(int opt_idx,int next_opt_idx,int orig_next_opt_idx)960 cancel_option (int opt_idx, int next_opt_idx, int orig_next_opt_idx)
961 {
962 /* An option can be canceled by the same option or an option with
963 Negative. */
964 if (cl_options [next_opt_idx].neg_index == opt_idx)
965 return true;
966
967 if (cl_options [next_opt_idx].neg_index != orig_next_opt_idx)
968 return cancel_option (opt_idx, cl_options [next_opt_idx].neg_index,
969 orig_next_opt_idx);
970
971 return false;
972 }
973
974 /* Filter out options canceled by the ones after them. */
975
976 static void
prune_options(struct cl_decoded_option ** decoded_options,unsigned int * decoded_options_count)977 prune_options (struct cl_decoded_option **decoded_options,
978 unsigned int *decoded_options_count)
979 {
980 unsigned int old_decoded_options_count = *decoded_options_count;
981 struct cl_decoded_option *old_decoded_options = *decoded_options;
982 unsigned int new_decoded_options_count;
983 struct cl_decoded_option *new_decoded_options
984 = XNEWVEC (struct cl_decoded_option, old_decoded_options_count);
985 unsigned int i;
986 const struct cl_option *option;
987 unsigned int fdiagnostics_color_idx = 0;
988
989 /* Remove arguments which are negated by others after them. */
990 new_decoded_options_count = 0;
991 for (i = 0; i < old_decoded_options_count; i++)
992 {
993 unsigned int j, opt_idx, next_opt_idx;
994
995 if (old_decoded_options[i].errors & ~CL_ERR_WRONG_LANG)
996 goto keep;
997
998 opt_idx = old_decoded_options[i].opt_index;
999 switch (opt_idx)
1000 {
1001 case OPT_SPECIAL_unknown:
1002 case OPT_SPECIAL_ignore:
1003 case OPT_SPECIAL_deprecated:
1004 case OPT_SPECIAL_program_name:
1005 case OPT_SPECIAL_input_file:
1006 goto keep;
1007
1008 /* Do not save OPT_fdiagnostics_color_, just remember the last one. */
1009 case OPT_fdiagnostics_color_:
1010 fdiagnostics_color_idx = i;
1011 continue;
1012
1013 default:
1014 gcc_assert (opt_idx < cl_options_count);
1015 option = &cl_options[opt_idx];
1016 if (option->neg_index < 0)
1017 goto keep;
1018
1019 /* Skip joined switches. */
1020 if ((option->flags & CL_JOINED)
1021 && (!option->cl_reject_negative
1022 || (unsigned int) option->neg_index != opt_idx))
1023 goto keep;
1024
1025 for (j = i + 1; j < old_decoded_options_count; j++)
1026 {
1027 if (old_decoded_options[j].errors & ~CL_ERR_WRONG_LANG)
1028 continue;
1029 next_opt_idx = old_decoded_options[j].opt_index;
1030 if (next_opt_idx >= cl_options_count)
1031 continue;
1032 if (cl_options[next_opt_idx].neg_index < 0)
1033 continue;
1034 if ((cl_options[next_opt_idx].flags & CL_JOINED)
1035 && (!cl_options[next_opt_idx].cl_reject_negative
1036 || ((unsigned int) cl_options[next_opt_idx].neg_index
1037 != next_opt_idx)))
1038 continue;
1039 if (cancel_option (opt_idx, next_opt_idx, next_opt_idx))
1040 break;
1041 }
1042 if (j == old_decoded_options_count)
1043 {
1044 keep:
1045 new_decoded_options[new_decoded_options_count]
1046 = old_decoded_options[i];
1047 new_decoded_options_count++;
1048 }
1049 break;
1050 }
1051 }
1052
1053 if (fdiagnostics_color_idx >= 1)
1054 {
1055 /* We put the last -fdiagnostics-color= at the first position
1056 after argv[0] so it can take effect immediately. */
1057 memmove (new_decoded_options + 2, new_decoded_options + 1,
1058 sizeof (struct cl_decoded_option)
1059 * (new_decoded_options_count - 1));
1060 new_decoded_options[1] = old_decoded_options[fdiagnostics_color_idx];
1061 new_decoded_options_count++;
1062 }
1063
1064 free (old_decoded_options);
1065 new_decoded_options = XRESIZEVEC (struct cl_decoded_option,
1066 new_decoded_options,
1067 new_decoded_options_count);
1068 *decoded_options = new_decoded_options;
1069 *decoded_options_count = new_decoded_options_count;
1070 }
1071
1072 /* Handle option DECODED for the language indicated by LANG_MASK,
1073 using the handlers in HANDLERS and setting fields in OPTS and
1074 OPTS_SET. KIND is the diagnostic_t if this is a diagnostics
1075 option, DK_UNSPECIFIED otherwise, and LOC is the location of the
1076 option for options from the source file, UNKNOWN_LOCATION
1077 otherwise. GENERATED_P is true for an option generated as part of
1078 processing another option or otherwise generated internally, false
1079 for one explicitly passed by the user. control_warning_option
1080 generated options are considered explicitly passed by the user.
1081 Returns false if the switch was invalid. DC is the diagnostic
1082 context for options affecting diagnostics state, or NULL. */
1083
1084 static bool
handle_option(struct gcc_options * opts,struct gcc_options * opts_set,const struct cl_decoded_option * decoded,unsigned int lang_mask,int kind,location_t loc,const struct cl_option_handlers * handlers,bool generated_p,diagnostic_context * dc)1085 handle_option (struct gcc_options *opts,
1086 struct gcc_options *opts_set,
1087 const struct cl_decoded_option *decoded,
1088 unsigned int lang_mask, int kind, location_t loc,
1089 const struct cl_option_handlers *handlers,
1090 bool generated_p, diagnostic_context *dc)
1091 {
1092 size_t opt_index = decoded->opt_index;
1093 const char *arg = decoded->arg;
1094 HOST_WIDE_INT value = decoded->value;
1095 const struct cl_option *option = &cl_options[opt_index];
1096 void *flag_var = option_flag_var (opt_index, opts);
1097 size_t i;
1098
1099 if (flag_var)
1100 set_option (opts, (generated_p ? NULL : opts_set),
1101 opt_index, value, arg, kind, loc, dc);
1102
1103 for (i = 0; i < handlers->num_handlers; i++)
1104 if (option->flags & handlers->handlers[i].mask)
1105 {
1106 if (!handlers->handlers[i].handler (opts, opts_set, decoded,
1107 lang_mask, kind, loc,
1108 handlers, dc,
1109 handlers->target_option_override_hook))
1110 return false;
1111 }
1112
1113 return true;
1114 }
1115
1116 /* Like handle_option, but OPT_INDEX, ARG and VALUE describe the
1117 option instead of DECODED. This is used for callbacks when one
1118 option implies another instead of an option being decoded from the
1119 command line. */
1120
1121 bool
handle_generated_option(struct gcc_options * opts,struct gcc_options * opts_set,size_t opt_index,const char * arg,HOST_WIDE_INT value,unsigned int lang_mask,int kind,location_t loc,const struct cl_option_handlers * handlers,bool generated_p,diagnostic_context * dc)1122 handle_generated_option (struct gcc_options *opts,
1123 struct gcc_options *opts_set,
1124 size_t opt_index, const char *arg, HOST_WIDE_INT value,
1125 unsigned int lang_mask, int kind, location_t loc,
1126 const struct cl_option_handlers *handlers,
1127 bool generated_p, diagnostic_context *dc)
1128 {
1129 struct cl_decoded_option decoded;
1130
1131 generate_option (opt_index, arg, value, lang_mask, &decoded);
1132 return handle_option (opts, opts_set, &decoded, lang_mask, kind, loc,
1133 handlers, generated_p, dc);
1134 }
1135
1136 /* Fill in *DECODED with an option described by OPT_INDEX, ARG and
1137 VALUE for a front end using LANG_MASK. This is used when the
1138 compiler generates options internally. */
1139
1140 void
generate_option(size_t opt_index,const char * arg,HOST_WIDE_INT value,unsigned int lang_mask,struct cl_decoded_option * decoded)1141 generate_option (size_t opt_index, const char *arg, HOST_WIDE_INT value,
1142 unsigned int lang_mask, struct cl_decoded_option *decoded)
1143 {
1144 const struct cl_option *option = &cl_options[opt_index];
1145
1146 decoded->opt_index = opt_index;
1147 decoded->warn_message = NULL;
1148 decoded->arg = arg;
1149 decoded->value = value;
1150 decoded->errors = (option_ok_for_language (option, lang_mask)
1151 ? 0
1152 : CL_ERR_WRONG_LANG);
1153
1154 generate_canonical_option (opt_index, arg, value, decoded);
1155 switch (decoded->canonical_option_num_elements)
1156 {
1157 case 1:
1158 decoded->orig_option_with_args_text = decoded->canonical_option[0];
1159 break;
1160
1161 case 2:
1162 decoded->orig_option_with_args_text
1163 = opts_concat (decoded->canonical_option[0], " ",
1164 decoded->canonical_option[1], NULL);
1165 break;
1166
1167 default:
1168 gcc_unreachable ();
1169 }
1170 }
1171
1172 /* Fill in *DECODED with an option for input file FILE. */
1173
1174 void
generate_option_input_file(const char * file,struct cl_decoded_option * decoded)1175 generate_option_input_file (const char *file,
1176 struct cl_decoded_option *decoded)
1177 {
1178 decoded->opt_index = OPT_SPECIAL_input_file;
1179 decoded->warn_message = NULL;
1180 decoded->arg = file;
1181 decoded->orig_option_with_args_text = file;
1182 decoded->canonical_option_num_elements = 1;
1183 decoded->canonical_option[0] = file;
1184 decoded->canonical_option[1] = NULL;
1185 decoded->canonical_option[2] = NULL;
1186 decoded->canonical_option[3] = NULL;
1187 decoded->value = 1;
1188 decoded->errors = 0;
1189 }
1190
1191 /* Helper function for listing valid choices and hint for misspelled
1192 value. CANDIDATES is a vector containing all valid strings,
1193 STR is set to a heap allocated string that contains all those
1194 strings concatenated, separated by spaces, and the return value
1195 is the closest string from those to ARG, or NULL if nothing is
1196 close enough. Callers should XDELETEVEC (STR) after using it
1197 to avoid memory leaks. */
1198
1199 const char *
candidates_list_and_hint(const char * arg,char * & str,const auto_vec<const char * > & candidates)1200 candidates_list_and_hint (const char *arg, char *&str,
1201 const auto_vec <const char *> &candidates)
1202 {
1203 size_t len = 0;
1204 int i;
1205 const char *candidate;
1206 char *p;
1207
1208 FOR_EACH_VEC_ELT (candidates, i, candidate)
1209 len += strlen (candidate) + 1;
1210
1211 str = p = XNEWVEC (char, len);
1212 FOR_EACH_VEC_ELT (candidates, i, candidate)
1213 {
1214 len = strlen (candidate);
1215 memcpy (p, candidate, len);
1216 p[len] = ' ';
1217 p += len + 1;
1218 }
1219 p[-1] = '\0';
1220 return find_closest_string (arg, &candidates);
1221 }
1222
1223 /* Perform diagnostics for read_cmdline_option and control_warning_option
1224 functions. Returns true if an error has been diagnosed.
1225 LOC and LANG_MASK arguments like in read_cmdline_option.
1226 OPTION is the option to report diagnostics for, OPT the name
1227 of the option as text, ARG the argument of the option (for joined
1228 options), ERRORS is bitmask of CL_ERR_* values. */
1229
1230 static bool
cmdline_handle_error(location_t loc,const struct cl_option * option,const char * opt,const char * arg,int errors,unsigned int lang_mask)1231 cmdline_handle_error (location_t loc, const struct cl_option *option,
1232 const char *opt, const char *arg, int errors,
1233 unsigned int lang_mask)
1234 {
1235 if (errors & CL_ERR_DISABLED)
1236 {
1237 error_at (loc, "command line option %qs"
1238 " is not supported by this configuration", opt);
1239 return true;
1240 }
1241
1242 if (errors & CL_ERR_MISSING_ARG)
1243 {
1244 if (option->missing_argument_error)
1245 error_at (loc, option->missing_argument_error, opt);
1246 else
1247 error_at (loc, "missing argument to %qs", opt);
1248 return true;
1249 }
1250
1251 if (errors & CL_ERR_UINT_ARG)
1252 {
1253 if (option->cl_byte_size)
1254 error_at (loc, "argument to %qs should be a non-negative integer "
1255 "optionally followed by a size unit",
1256 option->opt_text);
1257 else
1258 error_at (loc, "argument to %qs should be a non-negative integer",
1259 option->opt_text);
1260 return true;
1261 }
1262
1263 if (errors & CL_ERR_INT_RANGE_ARG)
1264 {
1265 error_at (loc, "argument to %qs is not between %d and %d",
1266 option->opt_text, option->range_min, option->range_max);
1267 return true;
1268 }
1269
1270 if (errors & CL_ERR_ENUM_ARG)
1271 {
1272 const struct cl_enum *e = &cl_enums[option->var_enum];
1273 unsigned int i;
1274 char *s;
1275
1276 auto_diagnostic_group d;
1277 if (e->unknown_error)
1278 error_at (loc, e->unknown_error, arg);
1279 else
1280 error_at (loc, "unrecognized argument in option %qs", opt);
1281
1282 auto_vec <const char *> candidates;
1283 for (i = 0; e->values[i].arg != NULL; i++)
1284 {
1285 if (!enum_arg_ok_for_language (&e->values[i], lang_mask))
1286 continue;
1287 candidates.safe_push (e->values[i].arg);
1288 }
1289 const char *hint = candidates_list_and_hint (arg, s, candidates);
1290 if (hint)
1291 inform (loc, "valid arguments to %qs are: %s; did you mean %qs?",
1292 option->opt_text, s, hint);
1293 else
1294 inform (loc, "valid arguments to %qs are: %s", option->opt_text, s);
1295 XDELETEVEC (s);
1296
1297 return true;
1298 }
1299
1300 return false;
1301 }
1302
1303 /* Handle the switch DECODED (location LOC) for the language indicated
1304 by LANG_MASK, using the handlers in *HANDLERS and setting fields in
1305 OPTS and OPTS_SET and using diagnostic context DC (if not NULL) for
1306 diagnostic options. */
1307
1308 void
read_cmdline_option(struct gcc_options * opts,struct gcc_options * opts_set,struct cl_decoded_option * decoded,location_t loc,unsigned int lang_mask,const struct cl_option_handlers * handlers,diagnostic_context * dc)1309 read_cmdline_option (struct gcc_options *opts,
1310 struct gcc_options *opts_set,
1311 struct cl_decoded_option *decoded,
1312 location_t loc,
1313 unsigned int lang_mask,
1314 const struct cl_option_handlers *handlers,
1315 diagnostic_context *dc)
1316 {
1317 const struct cl_option *option;
1318 const char *opt = decoded->orig_option_with_args_text;
1319
1320 if (decoded->warn_message)
1321 warning_at (loc, 0, decoded->warn_message, opt);
1322
1323 if (decoded->opt_index == OPT_SPECIAL_unknown)
1324 {
1325 if (handlers->unknown_option_callback (decoded))
1326 error_at (loc, "unrecognized command line option %qs", decoded->arg);
1327 return;
1328 }
1329
1330 if (decoded->opt_index == OPT_SPECIAL_ignore)
1331 return;
1332
1333 if (decoded->opt_index == OPT_SPECIAL_deprecated)
1334 {
1335 /* Warn only about positive ignored options. */
1336 if (decoded->value)
1337 warning_at (loc, 0, "switch %qs is no longer supported", opt);
1338 return;
1339 }
1340
1341 option = &cl_options[decoded->opt_index];
1342
1343 if (decoded->errors
1344 && cmdline_handle_error (loc, option, opt, decoded->arg,
1345 decoded->errors, lang_mask))
1346 return;
1347
1348 if (decoded->errors & CL_ERR_WRONG_LANG)
1349 {
1350 handlers->wrong_lang_callback (decoded, lang_mask);
1351 return;
1352 }
1353
1354 gcc_assert (!decoded->errors);
1355
1356 if (!handle_option (opts, opts_set, decoded, lang_mask, DK_UNSPECIFIED,
1357 loc, handlers, false, dc))
1358 error_at (loc, "unrecognized command line option %qs", opt);
1359 }
1360
1361 /* Set any field in OPTS, and OPTS_SET if not NULL, for option
1362 OPT_INDEX according to VALUE and ARG, diagnostic kind KIND,
1363 location LOC, using diagnostic context DC if not NULL for
1364 diagnostic classification. */
1365
1366 void
set_option(struct gcc_options * opts,struct gcc_options * opts_set,int opt_index,HOST_WIDE_INT value,const char * arg,int kind,location_t loc,diagnostic_context * dc)1367 set_option (struct gcc_options *opts, struct gcc_options *opts_set,
1368 int opt_index, HOST_WIDE_INT value, const char *arg, int kind,
1369 location_t loc, diagnostic_context *dc)
1370 {
1371 const struct cl_option *option = &cl_options[opt_index];
1372 void *flag_var = option_flag_var (opt_index, opts);
1373 void *set_flag_var = NULL;
1374
1375 if (!flag_var)
1376 return;
1377
1378 if ((diagnostic_t) kind != DK_UNSPECIFIED && dc != NULL)
1379 diagnostic_classify_diagnostic (dc, opt_index, (diagnostic_t) kind, loc);
1380
1381 if (opts_set != NULL)
1382 set_flag_var = option_flag_var (opt_index, opts_set);
1383
1384 switch (option->var_type)
1385 {
1386 case CLVC_BOOLEAN:
1387 if (option->cl_host_wide_int)
1388 {
1389 *(HOST_WIDE_INT *) flag_var = value;
1390 if (set_flag_var)
1391 *(HOST_WIDE_INT *) set_flag_var = 1;
1392 }
1393 else
1394 {
1395 *(int *) flag_var = value;
1396 if (set_flag_var)
1397 *(int *) set_flag_var = 1;
1398 }
1399
1400 break;
1401
1402 case CLVC_SIZE:
1403 if (option->cl_host_wide_int)
1404 {
1405 *(HOST_WIDE_INT *) flag_var = value;
1406 if (set_flag_var)
1407 *(HOST_WIDE_INT *) set_flag_var = value;
1408 }
1409 else
1410 {
1411 *(int *) flag_var = value;
1412 if (set_flag_var)
1413 *(int *) set_flag_var = value;
1414 }
1415
1416 break;
1417
1418 case CLVC_EQUAL:
1419 if (option->cl_host_wide_int)
1420 {
1421 *(HOST_WIDE_INT *) flag_var = (value
1422 ? option->var_value
1423 : !option->var_value);
1424 if (set_flag_var)
1425 *(HOST_WIDE_INT *) set_flag_var = 1;
1426 }
1427 else
1428 {
1429 *(int *) flag_var = (value
1430 ? option->var_value
1431 : !option->var_value);
1432 if (set_flag_var)
1433 *(int *) set_flag_var = 1;
1434 }
1435 break;
1436
1437 case CLVC_BIT_CLEAR:
1438 case CLVC_BIT_SET:
1439 if ((value != 0) == (option->var_type == CLVC_BIT_SET))
1440 {
1441 if (option->cl_host_wide_int)
1442 *(HOST_WIDE_INT *) flag_var |= option->var_value;
1443 else
1444 *(int *) flag_var |= option->var_value;
1445 }
1446 else
1447 {
1448 if (option->cl_host_wide_int)
1449 *(HOST_WIDE_INT *) flag_var &= ~option->var_value;
1450 else
1451 *(int *) flag_var &= ~option->var_value;
1452 }
1453 if (set_flag_var)
1454 {
1455 if (option->cl_host_wide_int)
1456 *(HOST_WIDE_INT *) set_flag_var |= option->var_value;
1457 else
1458 *(int *) set_flag_var |= option->var_value;
1459 }
1460 break;
1461
1462 case CLVC_STRING:
1463 *(const char **) flag_var = arg;
1464 if (set_flag_var)
1465 *(const char **) set_flag_var = "";
1466 break;
1467
1468 case CLVC_ENUM:
1469 {
1470 const struct cl_enum *e = &cl_enums[option->var_enum];
1471
1472 e->set (flag_var, value);
1473 if (set_flag_var)
1474 e->set (set_flag_var, 1);
1475 }
1476 break;
1477
1478 case CLVC_DEFER:
1479 {
1480 vec<cl_deferred_option> *v
1481 = (vec<cl_deferred_option> *) *(void **) flag_var;
1482 cl_deferred_option p = {opt_index, arg, value};
1483 if (!v)
1484 v = XCNEW (vec<cl_deferred_option>);
1485 v->safe_push (p);
1486 *(void **) flag_var = v;
1487 if (set_flag_var)
1488 *(void **) set_flag_var = v;
1489 }
1490 break;
1491 }
1492 }
1493
1494 /* Return the address of the flag variable for option OPT_INDEX in
1495 options structure OPTS, or NULL if there is no flag variable. */
1496
1497 void *
option_flag_var(int opt_index,struct gcc_options * opts)1498 option_flag_var (int opt_index, struct gcc_options *opts)
1499 {
1500 const struct cl_option *option = &cl_options[opt_index];
1501
1502 if (option->flag_var_offset == (unsigned short) -1)
1503 return NULL;
1504 return (void *)(((char *) opts) + option->flag_var_offset);
1505 }
1506
1507 /* Return 1 if option OPT_IDX is enabled in OPTS, 0 if it is disabled,
1508 or -1 if it isn't a simple on-off switch. */
1509
1510 int
option_enabled(int opt_idx,void * opts)1511 option_enabled (int opt_idx, void *opts)
1512 {
1513 const struct cl_option *option = &(cl_options[opt_idx]);
1514 struct gcc_options *optsg = (struct gcc_options *) opts;
1515 void *flag_var = option_flag_var (opt_idx, optsg);
1516
1517 if (flag_var)
1518 switch (option->var_type)
1519 {
1520 case CLVC_BOOLEAN:
1521 if (option->cl_host_wide_int)
1522 return *(HOST_WIDE_INT *) flag_var != 0;
1523 else
1524 return *(int *) flag_var != 0;
1525
1526 case CLVC_EQUAL:
1527 if (option->cl_host_wide_int)
1528 return *(HOST_WIDE_INT *) flag_var == option->var_value;
1529 else
1530 return *(int *) flag_var == option->var_value;
1531
1532 case CLVC_BIT_CLEAR:
1533 if (option->cl_host_wide_int)
1534 return (*(HOST_WIDE_INT *) flag_var & option->var_value) == 0;
1535 else
1536 return (*(int *) flag_var & option->var_value) == 0;
1537
1538 case CLVC_BIT_SET:
1539 if (option->cl_host_wide_int)
1540 return (*(HOST_WIDE_INT *) flag_var & option->var_value) != 0;
1541 else
1542 return (*(int *) flag_var & option->var_value) != 0;
1543
1544 case CLVC_SIZE:
1545 if (option->cl_host_wide_int)
1546 return *(HOST_WIDE_INT *) flag_var != -1;
1547 else
1548 return *(int *) flag_var != -1;
1549
1550 case CLVC_STRING:
1551 case CLVC_ENUM:
1552 case CLVC_DEFER:
1553 break;
1554 }
1555 return -1;
1556 }
1557
1558 /* Fill STATE with the current state of option OPTION in OPTS. Return
1559 true if there is some state to store. */
1560
1561 bool
get_option_state(struct gcc_options * opts,int option,struct cl_option_state * state)1562 get_option_state (struct gcc_options *opts, int option,
1563 struct cl_option_state *state)
1564 {
1565 void *flag_var = option_flag_var (option, opts);
1566
1567 if (flag_var == 0)
1568 return false;
1569
1570 switch (cl_options[option].var_type)
1571 {
1572 case CLVC_BOOLEAN:
1573 case CLVC_EQUAL:
1574 case CLVC_SIZE:
1575 state->data = flag_var;
1576 state->size = (cl_options[option].cl_host_wide_int
1577 ? sizeof (HOST_WIDE_INT)
1578 : sizeof (int));
1579 break;
1580
1581 case CLVC_BIT_CLEAR:
1582 case CLVC_BIT_SET:
1583 state->ch = option_enabled (option, opts);
1584 state->data = &state->ch;
1585 state->size = 1;
1586 break;
1587
1588 case CLVC_STRING:
1589 state->data = *(const char **) flag_var;
1590 if (state->data == 0)
1591 state->data = "";
1592 state->size = strlen ((const char *) state->data) + 1;
1593 break;
1594
1595 case CLVC_ENUM:
1596 state->data = flag_var;
1597 state->size = cl_enums[cl_options[option].var_enum].var_size;
1598 break;
1599
1600 case CLVC_DEFER:
1601 return false;
1602 }
1603 return true;
1604 }
1605
1606 /* Set a warning option OPT_INDEX (language mask LANG_MASK, option
1607 handlers HANDLERS) to have diagnostic kind KIND for option
1608 structures OPTS and OPTS_SET and diagnostic context DC (possibly
1609 NULL), at location LOC (UNKNOWN_LOCATION for -Werror=). ARG is the
1610 argument of the option for joined options, or NULL otherwise. If IMPLY,
1611 the warning option in question is implied at this point. This is
1612 used by -Werror= and #pragma GCC diagnostic. */
1613
1614 void
control_warning_option(unsigned int opt_index,int kind,const char * arg,bool imply,location_t loc,unsigned int lang_mask,const struct cl_option_handlers * handlers,struct gcc_options * opts,struct gcc_options * opts_set,diagnostic_context * dc)1615 control_warning_option (unsigned int opt_index, int kind, const char *arg,
1616 bool imply, location_t loc, unsigned int lang_mask,
1617 const struct cl_option_handlers *handlers,
1618 struct gcc_options *opts,
1619 struct gcc_options *opts_set,
1620 diagnostic_context *dc)
1621 {
1622 if (cl_options[opt_index].alias_target != N_OPTS)
1623 {
1624 gcc_assert (!cl_options[opt_index].cl_separate_alias
1625 && !cl_options[opt_index].cl_negative_alias);
1626 if (cl_options[opt_index].alias_arg)
1627 arg = cl_options[opt_index].alias_arg;
1628 opt_index = cl_options[opt_index].alias_target;
1629 }
1630 if (opt_index == OPT_SPECIAL_ignore || opt_index == OPT_SPECIAL_deprecated)
1631 return;
1632 if (dc)
1633 diagnostic_classify_diagnostic (dc, opt_index, (diagnostic_t) kind, loc);
1634 if (imply)
1635 {
1636 const struct cl_option *option = &cl_options[opt_index];
1637
1638 /* -Werror=foo implies -Wfoo. */
1639 if (option->var_type == CLVC_BOOLEAN
1640 || option->var_type == CLVC_ENUM
1641 || option->var_type == CLVC_SIZE)
1642 {
1643 HOST_WIDE_INT value = 1;
1644
1645 if (arg && *arg == '\0' && !option->cl_missing_ok)
1646 arg = NULL;
1647
1648 if ((option->flags & CL_JOINED) && arg == NULL)
1649 {
1650 cmdline_handle_error (loc, option, option->opt_text, arg,
1651 CL_ERR_MISSING_ARG, lang_mask);
1652 return;
1653 }
1654
1655 /* If the switch takes an integer argument, convert it. */
1656 if (arg && (option->cl_uinteger || option->cl_host_wide_int))
1657 {
1658 int error = 0;
1659 value = *arg ? integral_argument (arg, &error,
1660 option->cl_byte_size) : 0;
1661 if (error)
1662 {
1663 cmdline_handle_error (loc, option, option->opt_text, arg,
1664 CL_ERR_UINT_ARG, lang_mask);
1665 return;
1666 }
1667 }
1668
1669 /* If the switch takes an enumerated argument, convert it. */
1670 if (arg && option->var_type == CLVC_ENUM)
1671 {
1672 const struct cl_enum *e = &cl_enums[option->var_enum];
1673
1674 if (enum_arg_to_value (e->values, arg, &value, lang_mask))
1675 {
1676 const char *carg = NULL;
1677
1678 if (enum_value_to_arg (e->values, &carg, value, lang_mask))
1679 arg = carg;
1680 gcc_assert (carg != NULL);
1681 }
1682 else
1683 {
1684 cmdline_handle_error (loc, option, option->opt_text, arg,
1685 CL_ERR_ENUM_ARG, lang_mask);
1686 return;
1687 }
1688 }
1689
1690 handle_generated_option (opts, opts_set,
1691 opt_index, arg, value, lang_mask,
1692 kind, loc, handlers, false, dc);
1693 }
1694 }
1695 }
1696