Mercurial > hg > CbC > CbC_gcc

comparison gcc/opts.c @ 0:a06113de4d67

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
first commit
author kent <kent@cr.ie.u-ryukyu.ac.jp>
date Fri, 17 Jul 2009 14:47:48 +0900
parents
children 3bfb6c00c1e0
comparison
equal deleted inserted replaced
-1:000000000000 0:a06113de4d67
1 /* Command line option handling.
2 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
3 Free Software Foundation, Inc.
4 Contributed by Neil Booth.
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
12
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
21
22 #include "config.h"
23 #include "system.h"
24 #include "intl.h"
25 #include "coretypes.h"
26 #include "tm.h"
27 #include "tree.h"
28 #include "rtl.h"
29 #include "expr.h"
30 #include "ggc.h"
31 #include "output.h"
32 #include "langhooks.h"
33 #include "opts.h"
34 #include "options.h"
35 #include "flags.h"
36 #include "toplev.h"
37 #include "params.h"
38 #include "diagnostic.h"
39 #include "tm_p.h" /* For OPTIMIZATION_OPTIONS. */
40 #include "insn-attr.h" /* For INSN_SCHEDULING. */
41 #include "target.h"
42 #include "tree-pass.h"
43 #include "dbgcnt.h"
44 #include "debug.h"
45
46 /* Value of the -G xx switch, and whether it was passed or not. */
47 unsigned HOST_WIDE_INT g_switch_value;
48 bool g_switch_set;
49
50 /* Same for selective scheduling. */
51 bool sel_sched_switch_set;
52
53 /* True if we should exit after parsing options. */
54 bool exit_after_options;
55
56 /* Print various extra warnings. -W/-Wextra. */
57 bool extra_warnings;
58
59 /* True to warn about any objects definitions whose size is larger
60 than N bytes. Also want about function definitions whose returned
61 values are larger than N bytes, where N is `larger_than_size'. */
62 bool warn_larger_than;
63 HOST_WIDE_INT larger_than_size;
64
65 /* True to warn about any function whose frame size is larger
66 * than N bytes. */
67 bool warn_frame_larger_than;
68 HOST_WIDE_INT frame_larger_than_size;
69
70 /* Type(s) of debugging information we are producing (if any). See
71 flags.h for the definitions of the different possible types of
72 debugging information. */
73 enum debug_info_type write_symbols = NO_DEBUG;
74
75 /* Level of debugging information we are producing. See flags.h for
76 the definitions of the different possible levels. */
77 enum debug_info_level debug_info_level = DINFO_LEVEL_NONE;
78
79 /* A major contribution to object and executable size is debug
80 information size. A major contribution to debug information size
81 is struct descriptions replicated in several object files. The
82 following flags attempt to reduce this information. The basic
83 idea is to not emit struct debugging information in the current
84 compilation unit when that information will be generated by
85 another compilation unit.
86
87 Debug information for a struct defined in the current source
88 file should be generated in the object file. Likewise the
89 debug information for a struct defined in a header should be
90 generated in the object file of the corresponding source file.
91 Both of these case are handled when the base name of the file of
92 the struct definition matches the base name of the source file
93 of the current compilation unit. This matching emits minimal
94 struct debugging information.
95
96 The base file name matching rule above will fail to emit debug
97 information for structs defined in system headers. So a second
98 category of files includes system headers in addition to files
99 with matching bases.
100
101 The remaining types of files are library headers and application
102 headers. We cannot currently distinguish these two types. */
103
104 enum debug_struct_file
105 {
106 DINFO_STRUCT_FILE_NONE, /* Debug no structs. */
107 DINFO_STRUCT_FILE_BASE, /* Debug structs defined in files with the
108 same base name as the compilation unit. */
109 DINFO_STRUCT_FILE_SYS, /* Also debug structs defined in system
110 header files. */
111 DINFO_STRUCT_FILE_ANY /* Debug structs defined in all files. */
112 };
113
114 /* Generic structs (e.g. templates not explicitly specialized)
115 may not have a compilation unit associated with them, and so
116 may need to be treated differently from ordinary structs.
117
118 Structs only handled by reference (indirectly), will also usually
119 not need as much debugging information. */
120
121 static enum debug_struct_file debug_struct_ordinary[DINFO_USAGE_NUM_ENUMS]
122 = { DINFO_STRUCT_FILE_ANY, DINFO_STRUCT_FILE_ANY, DINFO_STRUCT_FILE_ANY };
123 static enum debug_struct_file debug_struct_generic[DINFO_USAGE_NUM_ENUMS]
124 = { DINFO_STRUCT_FILE_ANY, DINFO_STRUCT_FILE_ANY, DINFO_STRUCT_FILE_ANY };
125
126 /* Parse the -femit-struct-debug-detailed option value
127 and set the flag variables. */
128
129 #define MATCH( prefix, string ) \
130 ((strncmp (prefix, string, sizeof prefix - 1) == 0) \
131 ? ((string += sizeof prefix - 1), 1) : 0)
132
133 void
134 set_struct_debug_option (const char *spec)
135 {
136 /* various labels for comparison */
137 static char dfn_lbl[] = "dfn:", dir_lbl[] = "dir:", ind_lbl[] = "ind:";
138 static char ord_lbl[] = "ord:", gen_lbl[] = "gen:";
139 static char none_lbl[] = "none", any_lbl[] = "any";
140 static char base_lbl[] = "base", sys_lbl[] = "sys";
141
142 enum debug_struct_file files = DINFO_STRUCT_FILE_ANY;
143 /* Default is to apply to as much as possible. */
144 enum debug_info_usage usage = DINFO_USAGE_NUM_ENUMS;
145 int ord = 1, gen = 1;
146
147 /* What usage? */
148 if (MATCH (dfn_lbl, spec))
149 usage = DINFO_USAGE_DFN;
150 else if (MATCH (dir_lbl, spec))
151 usage = DINFO_USAGE_DIR_USE;
152 else if (MATCH (ind_lbl, spec))
153 usage = DINFO_USAGE_IND_USE;
154
155 /* Generics or not? */
156 if (MATCH (ord_lbl, spec))
157 gen = 0;
158 else if (MATCH (gen_lbl, spec))
159 ord = 0;
160
161 /* What allowable environment? */
162 if (MATCH (none_lbl, spec))
163 files = DINFO_STRUCT_FILE_NONE;
164 else if (MATCH (any_lbl, spec))
165 files = DINFO_STRUCT_FILE_ANY;
166 else if (MATCH (sys_lbl, spec))
167 files = DINFO_STRUCT_FILE_SYS;
168 else if (MATCH (base_lbl, spec))
169 files = DINFO_STRUCT_FILE_BASE;
170 else
171 error ("argument %qs to %<-femit-struct-debug-detailed%> not recognized",
172 spec);
173
174 /* Effect the specification. */
175 if (usage == DINFO_USAGE_NUM_ENUMS)
176 {
177 if (ord)
178 {
179 debug_struct_ordinary[DINFO_USAGE_DFN] = files;
180 debug_struct_ordinary[DINFO_USAGE_DIR_USE] = files;
181 debug_struct_ordinary[DINFO_USAGE_IND_USE] = files;
182 }
183 if (gen)
184 {
185 debug_struct_generic[DINFO_USAGE_DFN] = files;
186 debug_struct_generic[DINFO_USAGE_DIR_USE] = files;
187 debug_struct_generic[DINFO_USAGE_IND_USE] = files;
188 }
189 }
190 else
191 {
192 if (ord)
193 debug_struct_ordinary[usage] = files;
194 if (gen)
195 debug_struct_generic[usage] = files;
196 }
197
198 if (*spec == ',')
199 set_struct_debug_option (spec+1);
200 else
201 {
202 /* No more -femit-struct-debug-detailed specifications.
203 Do final checks. */
204 if (*spec != '\0')
205 error ("argument %qs to %<-femit-struct-debug-detailed%> unknown",
206 spec);
207 if (debug_struct_ordinary[DINFO_USAGE_DIR_USE]
208 < debug_struct_ordinary[DINFO_USAGE_IND_USE]
209 || debug_struct_generic[DINFO_USAGE_DIR_USE]
210 < debug_struct_generic[DINFO_USAGE_IND_USE])
211 error ("%<-femit-struct-debug-detailed=dir:...%> must allow at least"
212 " as much as %<-femit-struct-debug-detailed=ind:...%>");
213 }
214 }
215
216 /* Find the base name of a path, stripping off both directories and
217 a single final extension. */
218 static int
219 base_of_path (const char *path, const char **base_out)
220 {
221 const char *base = path;
222 const char *dot = 0;
223 const char *p = path;
224 char c = *p;
225 while (c)
226 {
227 if (IS_DIR_SEPARATOR(c))
228 {
229 base = p + 1;
230 dot = 0;
231 }
232 else if (c == '.')
233 dot = p;
234 c = *++p;
235 }
236 if (!dot)
237 dot = p;
238 *base_out = base;
239 return dot - base;
240 }
241
242 /* Match the base name of a file to the base name of a compilation unit. */
243
244 static const char *main_input_basename;
245 static int main_input_baselength;
246
247 static int
248 matches_main_base (const char *path)
249 {
250 /* Cache the last query. */
251 static const char *last_path = NULL;
252 static int last_match = 0;
253 if (path != last_path)
254 {
255 const char *base;
256 int length = base_of_path (path, &base);
257 last_path = path;
258 last_match = (length == main_input_baselength
259 && memcmp (base, main_input_basename, length) == 0);
260 }
261 return last_match;
262 }
263
264 #ifdef DEBUG_DEBUG_STRUCT
265
266 static int
267 dump_struct_debug (tree type, enum debug_info_usage usage,
268 enum debug_struct_file criterion, int generic,
269 int matches, int result)
270 {
271 /* Find the type name. */
272 tree type_decl = TYPE_STUB_DECL (type);
273 tree t = type_decl;
274 const char *name = 0;
275 if (TREE_CODE (t) == TYPE_DECL)
276 t = DECL_NAME (t);
277 if (t)
278 name = IDENTIFIER_POINTER (t);
279
280 fprintf (stderr, " struct %d %s %s %s %s %d %p %s\n",
281 criterion,
282 DECL_IN_SYSTEM_HEADER (type_decl) ? "sys" : "usr",
283 matches ? "bas" : "hdr",
284 generic ? "gen" : "ord",
285 usage == DINFO_USAGE_DFN ? ";" :
286 usage == DINFO_USAGE_DIR_USE ? "." : "*",
287 result,
288 (void*) type_decl, name);
289 return result;
290 }
291 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
292 dump_struct_debug (type, usage, criterion, generic, matches, result)
293
294 #else
295
296 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
297 (result)
298
299 #endif
300
301
302 bool
303 should_emit_struct_debug (tree type, enum debug_info_usage usage)
304 {
305 enum debug_struct_file criterion;
306 tree type_decl;
307 bool generic = lang_hooks.types.generic_p (type);
308
309 if (generic)
310 criterion = debug_struct_generic[usage];
311 else
312 criterion = debug_struct_ordinary[usage];
313
314 if (criterion == DINFO_STRUCT_FILE_NONE)
315 return DUMP_GSTRUCT (type, usage, criterion, generic, false, false);
316 if (criterion == DINFO_STRUCT_FILE_ANY)
317 return DUMP_GSTRUCT (type, usage, criterion, generic, false, true);
318
319 type_decl = TYPE_STUB_DECL (type);
320
321 if (criterion == DINFO_STRUCT_FILE_SYS && DECL_IN_SYSTEM_HEADER (type_decl))
322 return DUMP_GSTRUCT (type, usage, criterion, generic, false, true);
323
324 if (matches_main_base (DECL_SOURCE_FILE (type_decl)))
325 return DUMP_GSTRUCT (type, usage, criterion, generic, true, true);
326 return DUMP_GSTRUCT (type, usage, criterion, generic, false, false);
327 }
328
329 /* Nonzero means use GNU-only extensions in the generated symbolic
330 debugging information. Currently, this only has an effect when
331 write_symbols is set to DBX_DEBUG, XCOFF_DEBUG, or DWARF_DEBUG. */
332 bool use_gnu_debug_info_extensions;
333
334 /* The default visibility for all symbols (unless overridden) */
335 enum symbol_visibility default_visibility = VISIBILITY_DEFAULT;
336
337 /* Global visibility options. */
338 struct visibility_flags visibility_options;
339
340 /* What to print when a switch has no documentation. */
341 #ifdef ENABLE_CHECKING
342 static const char undocumented_msg[] = N_("This switch lacks documentation");
343 #else
344 static const char undocumented_msg[] = "";
345 #endif
346
347 /* Used for bookkeeping on whether user set these flags so
348 -fprofile-use/-fprofile-generate does not use them. */
349 static bool profile_arc_flag_set, flag_profile_values_set;
350 static bool flag_unroll_loops_set, flag_tracer_set;
351 static bool flag_value_profile_transformations_set;
352 static bool flag_peel_loops_set, flag_branch_probabilities_set;
353 static bool flag_inline_functions_set, flag_ipa_cp_set, flag_ipa_cp_clone_set;
354 static bool flag_predictive_commoning_set, flag_unswitch_loops_set, flag_gcse_after_reload_set;
355
356 /* Functions excluded from profiling. */
357
358 typedef char *char_p; /* For DEF_VEC_P. */
359 DEF_VEC_P(char_p);
360 DEF_VEC_ALLOC_P(char_p,heap);
361
362 static VEC(char_p,heap) *flag_instrument_functions_exclude_functions;
363 static VEC(char_p,heap) *flag_instrument_functions_exclude_files;
364
365 typedef const char *const_char_p; /* For DEF_VEC_P. */
366 DEF_VEC_P(const_char_p);
367 DEF_VEC_ALLOC_P(const_char_p,heap);
368
369 static VEC(const_char_p,heap) *ignored_options;
370
371 /* Input file names. */
372 const char **in_fnames;
373 unsigned num_in_fnames;
374
375 static int common_handle_option (size_t scode, const char *arg, int value,
376 unsigned int lang_mask);
377 static void handle_param (const char *);
378 static void set_Wextra (int);
379 static unsigned int handle_option (const char **argv, unsigned int lang_mask);
380 static char *write_langs (unsigned int lang_mask);
381 static void complain_wrong_lang (const char *, const struct cl_option *,
382 unsigned int lang_mask);
383 static void handle_options (unsigned int, const char **, unsigned int);
384 static void set_debug_level (enum debug_info_type type, int extended,
385 const char *arg);
386
387 /* If ARG is a non-negative integer made up solely of digits, return its
388 value, otherwise return -1. */
389 static int
390 integral_argument (const char *arg)
391 {
392 const char *p = arg;
393
394 while (*p && ISDIGIT (*p))
395 p++;
396
397 if (*p == '\0')
398 return atoi (arg);
399
400 return -1;
401 }
402
403 /* Return a malloced slash-separated list of languages in MASK. */
404 static char *
405 write_langs (unsigned int mask)
406 {
407 unsigned int n = 0, len = 0;
408 const char *lang_name;
409 char *result;
410
411 for (n = 0; (lang_name = lang_names[n]) != 0; n++)
412 if (mask & (1U << n))
413 len += strlen (lang_name) + 1;
414
415 result = XNEWVEC (char, len);
416 len = 0;
417 for (n = 0; (lang_name = lang_names[n]) != 0; n++)
418 if (mask & (1U << n))
419 {
420 if (len)
421 result[len++] = '/';
422 strcpy (result + len, lang_name);
423 len += strlen (lang_name);
424 }
425
426 result[len] = 0;
427
428 return result;
429 }
430
431 /* Complain that switch OPT_INDEX does not apply to this front end. */
432 static void
433 complain_wrong_lang (const char *text, const struct cl_option *option,
434 unsigned int lang_mask)
435 {
436 char *ok_langs, *bad_lang;
437
438 ok_langs = write_langs (option->flags);
439 bad_lang = write_langs (lang_mask);
440
441 /* Eventually this should become a hard error IMO. */
442 warning (0, "command line option \"%s\" is valid for %s but not for %s",
443 text, ok_langs, bad_lang);
444
445 free (ok_langs);
446 free (bad_lang);
447 }
448
449 /* Buffer the unknown option described by the string OPT. Currently,
450 we only complain about unknown -Wno-* options if they may have
451 prevented a diagnostic. Otherwise, we just ignore them.
452 Note that if we do complain, it is only as a warning, not an error;
453 passing the compiler an unrecognised -Wno-* option should never
454 change whether the compilation succeeds or fails. */
455
456 static void postpone_unknown_option_warning(const char *opt)
457 {
458 VEC_safe_push (const_char_p, heap, ignored_options, opt);
459 }
460
461 /* Produce a warning for each option previously buffered. */
462
463 void print_ignored_options (void)
464 {
465 location_t saved_loc = input_location;
466
467 input_location = 0;
468
469 while (!VEC_empty (const_char_p, ignored_options))
470 {
471 const char *opt;
472 opt = VEC_pop (const_char_p, ignored_options);
473 warning (0, "unrecognized command line option \"%s\"", opt);
474 }
475
476 input_location = saved_loc;
477 }
478
479 /* Handle the switch beginning at ARGV for the language indicated by
480 LANG_MASK. Returns the number of switches consumed. */
481 static unsigned int
482 handle_option (const char **argv, unsigned int lang_mask)
483 {
484 size_t opt_index;
485 const char *opt, *arg = 0;
486 char *dup = 0;
487 int value = 1;
488 unsigned int result = 0;
489 const struct cl_option *option;
490
491 opt = argv[0];
492
493 opt_index = find_opt (opt + 1, lang_mask | CL_COMMON | CL_TARGET);
494 if (opt_index == cl_options_count
495 && (opt[1] == 'W' || opt[1] == 'f' || opt[1] == 'm')
496 && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-')
497 {
498 /* Drop the "no-" from negative switches. */
499 size_t len = strlen (opt) - 3;
500
501 dup = XNEWVEC (char, len + 1);
502 dup[0] = '-';
503 dup[1] = opt[1];
504 memcpy (dup + 2, opt + 5, len - 2 + 1);
505 opt = dup;
506 value = 0;
507 opt_index = find_opt (opt + 1, lang_mask | CL_COMMON | CL_TARGET);
508 if (opt_index == cl_options_count && opt[1] == 'W')
509 {
510 /* We don't generate warnings for unknown -Wno-* options
511 unless we issue diagnostics. */
512 postpone_unknown_option_warning (argv[0]);
513 result = 1;
514 goto done;
515 }
516 }
517
518 if (opt_index == cl_options_count)
519 goto done;
520
521 option = &cl_options[opt_index];
522
523 /* Reject negative form of switches that don't take negatives as
524 unrecognized. */
525 if (!value && (option->flags & CL_REJECT_NEGATIVE))
526 goto done;
527
528 /* We've recognized this switch. */
529 result = 1;
530
531 /* Check to see if the option is disabled for this configuration. */
532 if (option->flags & CL_DISABLED)
533 {
534 error ("command line option %qs"
535 " is not supported by this configuration", opt);
536 goto done;
537 }
538
539 /* Sort out any argument the switch takes. */
540 if (option->flags & CL_JOINED)
541 {
542 /* Have arg point to the original switch. This is because
543 some code, such as disable_builtin_function, expects its
544 argument to be persistent until the program exits. */
545 arg = argv[0] + cl_options[opt_index].opt_len + 1;
546 if (!value)
547 arg += strlen ("no-");
548
549 if (*arg == '\0' && !(option->flags & CL_MISSING_OK))
550 {
551 if (option->flags & CL_SEPARATE)
552 {
553 arg = argv[1];
554 result = 2;
555 }
556 else
557 /* Missing argument. */
558 arg = NULL;
559 }
560 }
561 else if (option->flags & CL_SEPARATE)
562 {
563 arg = argv[1];
564 result = 2;
565 }
566
567 /* Now we've swallowed any potential argument, complain if this
568 is a switch for a different front end. */
569 if (!(option->flags & (lang_mask | CL_COMMON | CL_TARGET)))
570 {
571 complain_wrong_lang (argv[0], option, lang_mask);
572 goto done;
573 }
574 else if ((option->flags & CL_TARGET)
575 && (option->flags & CL_LANG_ALL)
576 && !(option->flags & lang_mask))
577 {
578 /* Complain for target flag language mismatches if any languages
579 are specified. */
580 complain_wrong_lang (argv[0], option, lang_mask);
581 goto done;
582 }
583
584 if (arg == NULL && (option->flags & (CL_JOINED | CL_SEPARATE)))
585 {
586 if (!lang_hooks.missing_argument (opt, opt_index))
587 error ("missing argument to \"%s\"", opt);
588 goto done;
589 }
590
591 /* If the switch takes an integer, convert it. */
592 if (arg && (option->flags & CL_UINTEGER))
593 {
594 value = integral_argument (arg);
595 if (value == -1)
596 {
597 error ("argument to \"%s\" should be a non-negative integer",
598 option->opt_text);
599 goto done;
600 }
601 }
602
603 if (option->flag_var)
604 switch (option->var_type)
605 {
606 case CLVC_BOOLEAN:
607 *(int *) option->flag_var = value;
608 break;
609
610 case CLVC_EQUAL:
611 *(int *) option->flag_var = (value
612 ? option->var_value
613 : !option->var_value);
614 break;
615
616 case CLVC_BIT_CLEAR:
617 case CLVC_BIT_SET:
618 if ((value != 0) == (option->var_type == CLVC_BIT_SET))
619 *(int *) option->flag_var |= option->var_value;
620 else
621 *(int *) option->flag_var &= ~option->var_value;
622 if (option->flag_var == &target_flags)
623 target_flags_explicit |= option->var_value;
624 break;
625
626 case CLVC_STRING:
627 *(const char **) option->flag_var = arg;
628 break;
629 }
630
631 if (option->flags & lang_mask)
632 if (lang_hooks.handle_option (opt_index, arg, value) == 0)
633 result = 0;
634
635 if (result && (option->flags & CL_COMMON))
636 if (common_handle_option (opt_index, arg, value, lang_mask) == 0)
637 result = 0;
638
639 if (result && (option->flags & CL_TARGET))
640 if (!targetm.handle_option (opt_index, arg, value))
641 result = 0;
642
643 done:
644 if (dup)
645 free (dup);
646 return result;
647 }
648
649 /* Handle FILENAME from the command line. */
650 static void
651 add_input_filename (const char *filename)
652 {
653 num_in_fnames++;
654 in_fnames = XRESIZEVEC (const char *, in_fnames, num_in_fnames);
655 in_fnames[num_in_fnames - 1] = filename;
656 }
657
658 /* Add comma-separated strings to a char_p vector. */
659
660 static void
661 add_comma_separated_to_vector (VEC(char_p,heap) **pvec, const char* arg)
662 {
663 char *tmp;
664 char *r;
665 char *w;
666 char *token_start;
667
668 /* We never free this string. */
669 tmp = xstrdup (arg);
670
671 r = tmp;
672 w = tmp;
673 token_start = tmp;
674
675 while (*r != '\0')
676 {
677 if (*r == ',')
678 {
679 *w++ = '\0';
680 ++r;
681 VEC_safe_push (char_p, heap, *pvec, token_start);
682 token_start = w;
683 }
684 if (*r == '\\' && r[1] == ',')
685 {
686 *w++ = ',';
687 r += 2;
688 }
689 else
690 *w++ = *r++;
691 }
692 if (*token_start != '\0')
693 VEC_safe_push (char_p, heap, *pvec, token_start);
694 }
695
696 /* Return whether we should exclude FNDECL from instrumentation. */
697
698 bool
699 flag_instrument_functions_exclude_p (tree fndecl)
700 {
701 if (VEC_length (char_p, flag_instrument_functions_exclude_functions) > 0)
702 {
703 const char *name;
704 int i;
705 char *s;
706
707 name = lang_hooks.decl_printable_name (fndecl, 0);
708 for (i = 0;
709 VEC_iterate (char_p, flag_instrument_functions_exclude_functions,
710 i, s);
711 ++i)
712 {
713 if (strstr (name, s) != NULL)
714 return true;
715 }
716 }
717
718 if (VEC_length (char_p, flag_instrument_functions_exclude_files) > 0)
719 {
720 const char *name;
721 int i;
722 char *s;
723
724 name = DECL_SOURCE_FILE (fndecl);
725 for (i = 0;
726 VEC_iterate (char_p, flag_instrument_functions_exclude_files, i, s);
727 ++i)
728 {
729 if (strstr (name, s) != NULL)
730 return true;
731 }
732 }
733
734 return false;
735 }
736
737
738 /* Decode and handle the vector of command line options. LANG_MASK
739 contains has a single bit set representing the current
740 language. */
741 static void
742 handle_options (unsigned int argc, const char **argv, unsigned int lang_mask)
743 {
744 unsigned int n, i;
745
746 for (i = 1; i < argc; i += n)
747 {
748 const char *opt = argv[i];
749
750 /* Interpret "-" or a non-switch as a file name. */
751 if (opt[0] != '-' || opt[1] == '\0')
752 {
753 if (main_input_filename == NULL)
754 {
755 main_input_filename = opt;
756 main_input_baselength
757 = base_of_path (main_input_filename, &main_input_basename);
758 }
759 add_input_filename (opt);
760 n = 1;
761 continue;
762 }
763
764 n = handle_option (argv + i, lang_mask);
765
766 if (!n)
767 {
768 n = 1;
769 error ("unrecognized command line option \"%s\"", opt);
770 }
771 }
772 }
773
774 /* Parse command line options and set default flag values. Do minimal
775 options processing. */
776 void
777 decode_options (unsigned int argc, const char **argv)
778 {
779 static bool first_time_p = true;
780 static int initial_max_aliased_vops;
781 static int initial_avg_aliased_vops;
782 static int initial_min_crossjump_insns;
783 static int initial_max_fields_for_field_sensitive;
784 static int initial_loop_invariant_max_bbs_in_loop;
785 static unsigned int initial_lang_mask;
786
787 unsigned int i, lang_mask;
788 int opt1;
789 int opt2;
790 int opt3;
791 int opt1_max;
792
793 if (first_time_p)
794 {
795 /* Perform language-specific options initialization. */
796 initial_lang_mask = lang_mask = lang_hooks.init_options (argc, argv);
797
798 lang_hooks.initialize_diagnostics (global_dc);
799
800 /* Save initial values of parameters we reset. */
801 initial_max_aliased_vops = MAX_ALIASED_VOPS;
802 initial_avg_aliased_vops = AVG_ALIASED_VOPS;
803 initial_min_crossjump_insns
804 = compiler_params[PARAM_MIN_CROSSJUMP_INSNS].value;
805 initial_max_fields_for_field_sensitive
806 = compiler_params[PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE].value;
807 initial_loop_invariant_max_bbs_in_loop
808 = compiler_params[PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP].value;
809 }
810 else
811 lang_mask = initial_lang_mask;
812
813 /* Scan to see what optimization level has been specified. That will
814 determine the default value of many flags. */
815 for (i = 1; i < argc; i++)
816 {
817 if (!strcmp (argv[i], "-O"))
818 {
819 optimize = 1;
820 optimize_size = 0;
821 }
822 else if (argv[i][0] == '-' && argv[i][1] == 'O')
823 {
824 /* Handle -Os, -O2, -O3, -O69, ... */
825 const char *p = &argv[i][2];
826
827 if ((p[0] == 's') && (p[1] == 0))
828 {
829 optimize_size = 1;
830
831 /* Optimizing for size forces optimize to be 2. */
832 optimize = 2;
833 }
834 else
835 {
836 const int optimize_val = read_integral_parameter (p, p - 2, -1);
837 if (optimize_val != -1)
838 {
839 optimize = optimize_val;
840 optimize_size = 0;
841 }
842 }
843 }
844 }
845
846 /* Use priority coloring if cover classes is not defined for the
847 target. */
848 if (targetm.ira_cover_classes == NULL)
849 flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
850
851 /* -O1 optimizations. */
852 opt1 = (optimize >= 1);
853 flag_defer_pop = opt1;
854 #ifdef DELAY_SLOTS
855 flag_delayed_branch = opt1;
856 #endif
857 #ifdef CAN_DEBUG_WITHOUT_FP
858 flag_omit_frame_pointer = opt1;
859 #endif
860 flag_guess_branch_prob = opt1;
861 flag_cprop_registers = opt1;
862 flag_if_conversion = opt1;
863 flag_if_conversion2 = opt1;
864 flag_ipa_pure_const = opt1;
865 flag_ipa_reference = opt1;
866 flag_merge_constants = opt1;
867 flag_split_wide_types = opt1;
868 flag_tree_ccp = opt1;
869 flag_tree_dce = opt1;
870 flag_tree_dom = opt1;
871 flag_tree_dse = opt1;
872 flag_tree_ter = opt1;
873 flag_tree_sra = opt1;
874 flag_tree_copyrename = opt1;
875 flag_tree_fre = opt1;
876 flag_tree_copy_prop = opt1;
877 flag_tree_sink = opt1;
878 flag_tree_ch = opt1;
879
880 /* -O2 optimizations. */
881 opt2 = (optimize >= 2);
882 flag_inline_small_functions = opt2;
883 flag_indirect_inlining = opt2;
884 flag_thread_jumps = opt2;
885 flag_crossjumping = opt2;
886 flag_optimize_sibling_calls = opt2;
887 flag_forward_propagate = opt2;
888 flag_cse_follow_jumps = opt2;
889 flag_gcse = opt2;
890 flag_expensive_optimizations = opt2;
891 flag_rerun_cse_after_loop = opt2;
892 flag_caller_saves = opt2;
893 flag_peephole2 = opt2;
894 #ifdef INSN_SCHEDULING
895 flag_schedule_insns = opt2;
896 flag_schedule_insns_after_reload = opt2;
897 #endif
898 flag_regmove = opt2;
899 flag_strict_aliasing = opt2;
900 flag_strict_overflow = opt2;
901 flag_delete_null_pointer_checks = opt2;
902 flag_reorder_blocks = opt2;
903 flag_reorder_functions = opt2;
904 flag_tree_vrp = opt2;
905 flag_tree_builtin_call_dce = opt2;
906 flag_tree_pre = opt2;
907 flag_tree_switch_conversion = 1;
908 flag_ipa_cp = opt2;
909
910 /* Allow more virtual operators to increase alias precision. */
911
912 set_param_value ("max-aliased-vops",
913 (opt2) ? 500 : initial_max_aliased_vops);
914
915 /* Track fields in field-sensitive alias analysis. */
916 set_param_value ("max-fields-for-field-sensitive",
917 (opt2) ? 100 : initial_max_fields_for_field_sensitive);
918
919 /* For -O1 only do loop invariant motion for very small loops. */
920 set_param_value ("loop-invariant-max-bbs-in-loop",
921 (opt2) ? initial_loop_invariant_max_bbs_in_loop : 1000);
922
923 /* -O3 optimizations. */
924 opt3 = (optimize >= 3);
925 flag_predictive_commoning = opt3;
926 flag_inline_functions = opt3;
927 flag_unswitch_loops = opt3;
928 flag_gcse_after_reload = opt3;
929 flag_tree_vectorize = opt3;
930 flag_ipa_cp_clone = opt3;
931 if (flag_ipa_cp_clone)
932 flag_ipa_cp = 1;
933
934 /* Allow even more virtual operators. Max-aliased-vops was set above for
935 -O2, so don't reset it unless we are at -O3. */
936 if (opt3)
937 set_param_value ("max-aliased-vops", 1000);
938
939 set_param_value ("avg-aliased-vops", (opt3) ? 3 : initial_avg_aliased_vops);
940
941 /* Just -O1/-O0 optimizations. */
942 opt1_max = (optimize <= 1);
943 align_loops = opt1_max;
944 align_jumps = opt1_max;
945 align_labels = opt1_max;
946 align_functions = opt1_max;
947
948 if (optimize_size)
949 {
950 /* Inlining of functions reducing size is a good idea regardless of them
951 being declared inline. */
952 flag_inline_functions = 1;
953
954 /* Basic optimization options. */
955 optimize_size = 1;
956 if (optimize > 2)
957 optimize = 2;
958
959 /* We want to crossjump as much as possible. */
960 set_param_value ("min-crossjump-insns", 1);
961 }
962 else
963 set_param_value ("min-crossjump-insns", initial_min_crossjump_insns);
964
965 if (first_time_p)
966 {
967 /* Initialize whether `char' is signed. */
968 flag_signed_char = DEFAULT_SIGNED_CHAR;
969 /* Set this to a special "uninitialized" value. The actual default is
970 set after target options have been processed. */
971 flag_short_enums = 2;
972
973 /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
974 modify it. */
975 target_flags = targetm.default_target_flags;
976
977 /* Some targets have ABI-specified unwind tables. */
978 flag_unwind_tables = targetm.unwind_tables_default;
979 }
980
981 #ifdef OPTIMIZATION_OPTIONS
982 /* Allow default optimizations to be specified on a per-machine basis. */
983 OPTIMIZATION_OPTIONS (optimize, optimize_size);
984 #endif
985
986 handle_options (argc, argv, lang_mask);
987
988 /* Handle related options for unit-at-a-time, toplevel-reorder, and
989 section-anchors. */
990 if (!flag_unit_at_a_time)
991 {
992 if (flag_section_anchors == 1)
993 error ("Section anchors must be disabled when unit-at-a-time "
994 "is disabled.");
995 flag_section_anchors = 0;
996 if (flag_toplevel_reorder == 1)
997 error ("Toplevel reorder must be disabled when unit-at-a-time "
998 "is disabled.");
999 flag_toplevel_reorder = 0;
1000 }
1001 /* Unless the user has asked for section anchors, we disable toplevel
1002 reordering at -O0 to disable transformations that might be surprising
1003 to end users and to get -fno-toplevel-reorder tested. */
1004 if (!optimize && flag_toplevel_reorder == 2 && flag_section_anchors != 1)
1005 {
1006 flag_toplevel_reorder = 0;
1007 flag_section_anchors = 0;
1008 }
1009 if (!flag_toplevel_reorder)
1010 {
1011 if (flag_section_anchors == 1)
1012 error ("section anchors must be disabled when toplevel reorder"
1013 " is disabled");
1014 flag_section_anchors = 0;
1015 }
1016
1017 if (first_time_p)
1018 {
1019 if (flag_pie)
1020 flag_pic = flag_pie;
1021 if (flag_pic && !flag_pie)
1022 flag_shlib = 1;
1023 }
1024
1025 if (optimize == 0)
1026 {
1027 /* Inlining does not work if not optimizing,
1028 so force it not to be done. */
1029 warn_inline = 0;
1030 flag_no_inline = 1;
1031 }
1032
1033 /* The optimization to partition hot and cold basic blocks into separate
1034 sections of the .o and executable files does not work (currently)
1035 with exception handling. This is because there is no support for
1036 generating unwind info. If flag_exceptions is turned on we need to
1037 turn off the partitioning optimization. */
1038
1039 if (flag_exceptions && flag_reorder_blocks_and_partition)
1040 {
1041 inform (input_location,
1042 "-freorder-blocks-and-partition does not work with exceptions");
1043 flag_reorder_blocks_and_partition = 0;
1044 flag_reorder_blocks = 1;
1045 }
1046
1047 /* If user requested unwind info, then turn off the partitioning
1048 optimization. */
1049
1050 if (flag_unwind_tables && ! targetm.unwind_tables_default
1051 && flag_reorder_blocks_and_partition)
1052 {
1053 inform (input_location, "-freorder-blocks-and-partition does not support unwind info");
1054 flag_reorder_blocks_and_partition = 0;
1055 flag_reorder_blocks = 1;
1056 }
1057
1058 /* If the target requested unwind info, then turn off the partitioning
1059 optimization with a different message. Likewise, if the target does not
1060 support named sections. */
1061
1062 if (flag_reorder_blocks_and_partition
1063 && (!targetm.have_named_sections
1064 || (flag_unwind_tables && targetm.unwind_tables_default)))
1065 {
1066 inform (input_location,
1067 "-freorder-blocks-and-partition does not work on this architecture");
1068 flag_reorder_blocks_and_partition = 0;
1069 flag_reorder_blocks = 1;
1070 }
1071
1072 /* Pipelining of outer loops is only possible when general pipelining
1073 capabilities are requested. */
1074 if (!flag_sel_sched_pipelining)
1075 flag_sel_sched_pipelining_outer_loops = 0;
1076
1077 if (!targetm.ira_cover_classes
1078 && flag_ira_algorithm == IRA_ALGORITHM_CB)
1079 {
1080 inform (input_location,
1081 "-fira-algorithm=CB does not work on this architecture");
1082 flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
1083 }
1084
1085 /* Save the current optimization options if this is the first call. */
1086 if (first_time_p)
1087 {
1088 optimization_default_node = build_optimization_node ();
1089 optimization_current_node = optimization_default_node;
1090 first_time_p = false;
1091 }
1092 if (flag_conserve_stack)
1093 {
1094 if (!PARAM_SET_P (PARAM_LARGE_STACK_FRAME))
1095 PARAM_VALUE (PARAM_LARGE_STACK_FRAME) = 100;
1096 if (!PARAM_SET_P (PARAM_STACK_FRAME_GROWTH))
1097 PARAM_VALUE (PARAM_STACK_FRAME_GROWTH) = 40;
1098 }
1099
1100 }
1101
1102 #define LEFT_COLUMN 27
1103
1104 /* Output ITEM, of length ITEM_WIDTH, in the left column,
1105 followed by word-wrapped HELP in a second column. */
1106 static void
1107 wrap_help (const char *help,
1108 const char *item,
1109 unsigned int item_width,
1110 unsigned int columns)
1111 {
1112 unsigned int col_width = LEFT_COLUMN;
1113 unsigned int remaining, room, len;
1114
1115 remaining = strlen (help);
1116
1117 do
1118 {
1119 room = columns - 3 - MAX (col_width, item_width);
1120 if (room > columns)
1121 room = 0;
1122 len = remaining;
1123
1124 if (room < len)
1125 {
1126 unsigned int i;
1127
1128 for (i = 0; help[i]; i++)
1129 {
1130 if (i >= room && len != remaining)
1131 break;
1132 if (help[i] == ' ')
1133 len = i;
1134 else if ((help[i] == '-' || help[i] == '/')
1135 && help[i + 1] != ' '
1136 && i > 0 && ISALPHA (help[i - 1]))
1137 len = i + 1;
1138 }
1139 }
1140
1141 printf( " %-*.*s %.*s\n", col_width, item_width, item, len, help);
1142 item_width = 0;
1143 while (help[len] == ' ')
1144 len++;
1145 help += len;
1146 remaining -= len;
1147 }
1148 while (remaining);
1149 }
1150
1151 /* Print help for a specific front-end, etc. */
1152 static void
1153 print_filtered_help (unsigned int include_flags,
1154 unsigned int exclude_flags,
1155 unsigned int any_flags,
1156 unsigned int columns)
1157 {
1158 unsigned int i;
1159 const char *help;
1160 static char *printed = NULL;
1161 bool found = false;
1162 bool displayed = false;
1163
1164 if (include_flags == CL_PARAMS)
1165 {
1166 for (i = 0; i < LAST_PARAM; i++)
1167 {
1168 const char *param = compiler_params[i].option;
1169
1170 help = compiler_params[i].help;
1171 if (help == NULL || *help == '\0')
1172 {
1173 if (exclude_flags & CL_UNDOCUMENTED)
1174 continue;
1175 help = undocumented_msg;
1176 }
1177
1178 /* Get the translation. */
1179 help = _(help);
1180
1181 wrap_help (help, param, strlen (param), columns);
1182 }
1183 putchar ('\n');
1184 return;
1185 }
1186
1187 if (!printed)
1188 printed = XCNEWVAR (char, cl_options_count);
1189
1190 for (i = 0; i < cl_options_count; i++)
1191 {
1192 static char new_help[128];
1193 const struct cl_option *option = cl_options + i;
1194 unsigned int len;
1195 const char *opt;
1196 const char *tab;
1197
1198 if (include_flags == 0
1199 || ((option->flags & include_flags) != include_flags))
1200 {
1201 if ((option->flags & any_flags) == 0)
1202 continue;
1203 }
1204
1205 /* Skip unwanted switches. */
1206 if ((option->flags & exclude_flags) != 0)
1207 continue;
1208
1209 found = true;
1210 /* Skip switches that have already been printed. */
1211 if (printed[i])
1212 continue;
1213
1214 printed[i] = true;
1215
1216 help = option->help;
1217 if (help == NULL)
1218 {
1219 if (exclude_flags & CL_UNDOCUMENTED)
1220 continue;
1221 help = undocumented_msg;
1222 }
1223
1224 /* Get the translation. */
1225 help = _(help);
1226
1227 /* Find the gap between the name of the
1228 option and its descriptive text. */
1229 tab = strchr (help, '\t');
1230 if (tab)
1231 {
1232 len = tab - help;
1233 opt = help;
1234 help = tab + 1;
1235 }
1236 else
1237 {
1238 opt = option->opt_text;
1239 len = strlen (opt);
1240 }
1241
1242 /* With the -Q option enabled we change the descriptive text associated
1243 with an option to be an indication of its current setting. */
1244 if (!quiet_flag)
1245 {
1246 if (len < (LEFT_COLUMN + 2))
1247 strcpy (new_help, "\t\t");
1248 else
1249 strcpy (new_help, "\t");
1250
1251 if (option->flag_var != NULL)
1252 {
1253 if (option->flags & CL_JOINED)
1254 {
1255 if (option->var_type == CLVC_STRING)
1256 {
1257 if (* (const char **) option->flag_var != NULL)
1258 snprintf (new_help + strlen (new_help),
1259 sizeof (new_help) - strlen (new_help),
1260 * (const char **) option->flag_var);
1261 }
1262 else
1263 sprintf (new_help + strlen (new_help),
1264 "%#x", * (int *) option->flag_var);
1265 }
1266 else
1267 strcat (new_help, option_enabled (i)
1268 ? _("[enabled]") : _("[disabled]"));
1269 }
1270
1271 help = new_help;
1272 }
1273
1274 wrap_help (help, opt, len, columns);
1275 displayed = true;
1276 }
1277
1278 if (! found)
1279 {
1280 unsigned int langs = include_flags & CL_LANG_ALL;
1281
1282 if (langs == 0)
1283 printf (_(" No options with the desired characteristics were found\n"));
1284 else
1285 {
1286 unsigned int i;
1287
1288 /* PR 31349: Tell the user how to see all of the
1289 options supported by a specific front end. */
1290 for (i = 0; (1U << i) < CL_LANG_ALL; i ++)
1291 if ((1U << i) & langs)
1292 printf (_(" None found. Use --help=%s to show *all* the options supported by the %s front-end\n"),
1293 lang_names[i], lang_names[i]);
1294 }
1295
1296 }
1297 else if (! displayed)
1298 printf (_(" All options with the desired characteristics have already been displayed\n"));
1299
1300 putchar ('\n');
1301 }
1302
1303 /* Display help for a specified type of option.
1304 The options must have ALL of the INCLUDE_FLAGS set
1305 ANY of the flags in the ANY_FLAGS set
1306 and NONE of the EXCLUDE_FLAGS set. */
1307 static void
1308 print_specific_help (unsigned int include_flags,
1309 unsigned int exclude_flags,
1310 unsigned int any_flags)
1311 {
1312 unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1313 const char * description = NULL;
1314 const char * descrip_extra = "";
1315 size_t i;
1316 unsigned int flag;
1317 static unsigned int columns = 0;
1318
1319 /* Sanity check: Make sure that we do not have more
1320 languages than we have bits available to enumerate them. */
1321 gcc_assert ((1U << cl_lang_count) < CL_MIN_OPTION_CLASS);
1322
1323 /* If we have not done so already, obtain
1324 the desired maximum width of the output. */
1325 if (columns == 0)
1326 {
1327 const char *p;
1328
1329 GET_ENVIRONMENT (p, "COLUMNS");
1330 if (p != NULL)
1331 {
1332 int value = atoi (p);
1333
1334 if (value > 0)
1335 columns = value;
1336 }
1337
1338 if (columns == 0)
1339 /* Use a reasonable default. */
1340 columns = 80;
1341 }
1342
1343 /* Decide upon the title for the options that we are going to display. */
1344 for (i = 0, flag = 1; flag <= CL_MAX_OPTION_CLASS; flag <<= 1, i ++)
1345 {
1346 switch (flag & include_flags)
1347 {
1348 case 0:
1349 break;
1350
1351 case CL_TARGET:
1352 description = _("The following options are target specific");
1353 break;
1354 case CL_WARNING:
1355 description = _("The following options control compiler warning messages");
1356 break;
1357 case CL_OPTIMIZATION:
1358 description = _("The following options control optimizations");
1359 break;
1360 case CL_COMMON:
1361 description = _("The following options are language-independent");
1362 break;
1363 case CL_PARAMS:
1364 description = _("The --param option recognizes the following as parameters");
1365 break;
1366 default:
1367 if (i >= cl_lang_count)
1368 break;
1369 if (exclude_flags & all_langs_mask)
1370 description = _("The following options are specific to just the language ");
1371 else
1372 description = _("The following options are supported by the language ");
1373 descrip_extra = lang_names [i];
1374 break;
1375 }
1376 }
1377
1378 if (description == NULL)
1379 {
1380 if (any_flags == 0)
1381 {
1382 if (include_flags & CL_UNDOCUMENTED)
1383 description = _("The following options are not documented");
1384 else if (include_flags & CL_SEPARATE)
1385 description = _("The following options take separate arguments");
1386 else if (include_flags & CL_JOINED)
1387 description = _("The following options take joined arguments");
1388 else
1389 {
1390 internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
1391 include_flags);
1392 return;
1393 }
1394 }
1395 else
1396 {
1397 if (any_flags & all_langs_mask)
1398 description = _("The following options are language-related");
1399 else
1400 description = _("The following options are language-independent");
1401 }
1402 }
1403
1404 printf ("%s%s:\n", description, descrip_extra);
1405 print_filtered_help (include_flags, exclude_flags, any_flags, columns);
1406 }
1407
1408 /* Handle target- and language-independent options. Return zero to
1409 generate an "unknown option" message. Only options that need
1410 extra handling need to be listed here; if you simply want
1411 VALUE assigned to a variable, it happens automatically. */
1412
1413 static int
1414 common_handle_option (size_t scode, const char *arg, int value,
1415 unsigned int lang_mask)
1416 {
1417 static bool verbose = false;
1418 enum opt_code code = (enum opt_code) scode;
1419
1420 switch (code)
1421 {
1422 case OPT__param:
1423 handle_param (arg);
1424 break;
1425
1426 case OPT_v:
1427 verbose = true;
1428 break;
1429
1430 case OPT_fhelp:
1431 case OPT__help:
1432 {
1433 unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1434 unsigned int undoc_mask;
1435 unsigned int i;
1436
1437 undoc_mask = (verbose | extra_warnings) ? 0 : CL_UNDOCUMENTED;
1438 /* First display any single language specific options. */
1439 for (i = 0; i < cl_lang_count; i++)
1440 print_specific_help
1441 (1U << i, (all_langs_mask & (~ (1U << i))) | undoc_mask, 0);
1442 /* Next display any multi language specific options. */
1443 print_specific_help (0, undoc_mask, all_langs_mask);
1444 /* Then display any remaining, non-language options. */
1445 for (i = CL_MIN_OPTION_CLASS; i <= CL_MAX_OPTION_CLASS; i <<= 1)
1446 print_specific_help (i, undoc_mask, 0);
1447 exit_after_options = true;
1448 break;
1449 }
1450
1451 case OPT_ftarget_help:
1452 case OPT__target_help:
1453 print_specific_help (CL_TARGET, CL_UNDOCUMENTED, 0);
1454 exit_after_options = true;
1455
1456 /* Allow the target a chance to give the user some additional information. */
1457 if (targetm.target_help)
1458 targetm.target_help ();
1459 break;
1460
1461 case OPT_fhelp_:
1462 case OPT__help_:
1463 {
1464 const char * a = arg;
1465 unsigned int include_flags = 0;
1466 /* Note - by default we include undocumented options when listing
1467 specific classes. If you only want to see documented options
1468 then add ",^undocumented" to the --help= option. E.g.:
1469
1470 --help=target,^undocumented */
1471 unsigned int exclude_flags = 0;
1472
1473 /* Walk along the argument string, parsing each word in turn.
1474 The format is:
1475 arg = [^]{word}[,{arg}]
1476 word = {optimizers|target|warnings|undocumented|
1477 params|common|<language>} */
1478 while (* a != 0)
1479 {
1480 static struct
1481 {
1482 const char * string;
1483 unsigned int flag;
1484 }
1485 specifics[] =
1486 {
1487 { "optimizers", CL_OPTIMIZATION },
1488 { "target", CL_TARGET },
1489 { "warnings", CL_WARNING },
1490 { "undocumented", CL_UNDOCUMENTED },
1491 { "params", CL_PARAMS },
1492 { "joined", CL_JOINED },
1493 { "separate", CL_SEPARATE },
1494 { "common", CL_COMMON },
1495 { NULL, 0 }
1496 };
1497 unsigned int * pflags;
1498 char * comma;
1499 unsigned int lang_flag, specific_flag;
1500 unsigned int len;
1501 unsigned int i;
1502
1503 if (* a == '^')
1504 {
1505 ++ a;
1506 pflags = & exclude_flags;
1507 }
1508 else
1509 pflags = & include_flags;
1510
1511 comma = strchr (a, ',');
1512 if (comma == NULL)
1513 len = strlen (a);
1514 else
1515 len = comma - a;
1516 if (len == 0)
1517 {
1518 a = comma + 1;
1519 continue;
1520 }
1521
1522 /* Check to see if the string matches an option class name. */
1523 for (i = 0, specific_flag = 0; specifics[i].string != NULL; i++)
1524 if (strncasecmp (a, specifics[i].string, len) == 0)
1525 {
1526 specific_flag = specifics[i].flag;
1527 break;
1528 }
1529
1530 /* Check to see if the string matches a language name.
1531 Note - we rely upon the alpha-sorted nature of the entries in
1532 the lang_names array, specifically that shorter names appear
1533 before their longer variants. (i.e. C before C++). That way
1534 when we are attempting to match --help=c for example we will
1535 match with C first and not C++. */
1536 for (i = 0, lang_flag = 0; i < cl_lang_count; i++)
1537 if (strncasecmp (a, lang_names[i], len) == 0)
1538 {
1539 lang_flag = 1U << i;
1540 break;
1541 }
1542
1543 if (specific_flag != 0)
1544 {
1545 if (lang_flag == 0)
1546 * pflags |= specific_flag;
1547 else
1548 {
1549 /* The option's argument matches both the start of a
1550 language name and the start of an option class name.
1551 We have a special case for when the user has
1552 specified "--help=c", but otherwise we have to issue
1553 a warning. */
1554 if (strncasecmp (a, "c", len) == 0)
1555 * pflags |= lang_flag;
1556 else
1557 fnotice (stderr,
1558 "warning: --help argument %.*s is ambiguous, please be more specific\n",
1559 len, a);
1560 }
1561 }
1562 else if (lang_flag != 0)
1563 * pflags |= lang_flag;
1564 else
1565 fnotice (stderr,
1566 "warning: unrecognized argument to --help= option: %.*s\n",
1567 len, a);
1568
1569 if (comma == NULL)
1570 break;
1571 a = comma + 1;
1572 }
1573
1574 if (include_flags)
1575 print_specific_help (include_flags, exclude_flags, 0);
1576 exit_after_options = true;
1577 break;
1578 }
1579
1580 case OPT__version:
1581 print_version (stderr, "");
1582 exit_after_options = true;
1583 break;
1584
1585 case OPT_G:
1586 g_switch_value = value;
1587 g_switch_set = true;
1588 break;
1589
1590 case OPT_O:
1591 case OPT_Os:
1592 /* Currently handled in a prescan. */
1593 break;
1594
1595 case OPT_W:
1596 /* For backward compatibility, -W is the same as -Wextra. */
1597 set_Wextra (value);
1598 break;
1599
1600 case OPT_Werror_:
1601 enable_warning_as_error (arg, value, lang_mask);
1602 break;
1603
1604 case OPT_Wextra:
1605 set_Wextra (value);
1606 break;
1607
1608 case OPT_Wlarger_than_:
1609 /* This form corresponds to -Wlarger-than-.
1610 Kept for backward compatibility.
1611 Don't use it as the first argument of warning(). */
1612
1613 case OPT_Wlarger_than_eq:
1614 larger_than_size = value;
1615 warn_larger_than = value != -1;
1616 break;
1617
1618 case OPT_Wframe_larger_than_:
1619 frame_larger_than_size = value;
1620 warn_frame_larger_than = value != -1;
1621 break;
1622
1623 case OPT_Wstrict_aliasing:
1624 set_Wstrict_aliasing (value);
1625 break;
1626
1627 case OPT_Wstrict_aliasing_:
1628 warn_strict_aliasing = value;
1629 break;
1630
1631 case OPT_Wstrict_overflow:
1632 warn_strict_overflow = (value
1633 ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
1634 : 0);
1635 break;
1636
1637 case OPT_Wstrict_overflow_:
1638 warn_strict_overflow = value;
1639 break;
1640
1641 case OPT_Wunused:
1642 warn_unused = value;
1643 break;
1644
1645 case OPT_aux_info:
1646 case OPT_aux_info_:
1647 aux_info_file_name = arg;
1648 flag_gen_aux_info = 1;
1649 break;
1650
1651 case OPT_auxbase:
1652 aux_base_name = arg;
1653 break;
1654
1655 case OPT_auxbase_strip:
1656 {
1657 char *tmp = xstrdup (arg);
1658 strip_off_ending (tmp, strlen (tmp));
1659 if (tmp[0])
1660 aux_base_name = tmp;
1661 }
1662 break;
1663
1664 case OPT_d:
1665 decode_d_option (arg);
1666 break;
1667
1668 case OPT_dumpbase:
1669 dump_base_name = arg;
1670 break;
1671
1672 case OPT_falign_functions_:
1673 align_functions = value;
1674 break;
1675
1676 case OPT_falign_jumps_:
1677 align_jumps = value;
1678 break;
1679
1680 case OPT_falign_labels_:
1681 align_labels = value;
1682 break;
1683
1684 case OPT_falign_loops_:
1685 align_loops = value;
1686 break;
1687
1688 case OPT_fbranch_probabilities:
1689 flag_branch_probabilities_set = true;
1690 break;
1691
1692 case OPT_fcall_used_:
1693 fix_register (arg, 0, 1);
1694 break;
1695
1696 case OPT_fcall_saved_:
1697 fix_register (arg, 0, 0);
1698 break;
1699
1700 case OPT_fdbg_cnt_:
1701 dbg_cnt_process_opt (arg);
1702 break;
1703
1704 case OPT_fdbg_cnt_list:
1705 dbg_cnt_list_all_counters ();
1706 break;
1707
1708 case OPT_fdebug_prefix_map_:
1709 add_debug_prefix_map (arg);
1710 break;
1711
1712 case OPT_fdiagnostics_show_location_:
1713 if (!strcmp (arg, "once"))
1714 diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
1715 else if (!strcmp (arg, "every-line"))
1716 diagnostic_prefixing_rule (global_dc)
1717 = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
1718 else
1719 return 0;
1720 break;
1721
1722 case OPT_fdiagnostics_show_option:
1723 global_dc->show_option_requested = true;
1724 break;
1725
1726 case OPT_fdump_:
1727 if (!dump_switch_p (arg))
1728 return 0;
1729 break;
1730
1731 case OPT_ffast_math:
1732 set_fast_math_flags (value);
1733 break;
1734
1735 case OPT_funsafe_math_optimizations:
1736 set_unsafe_math_optimizations_flags (value);
1737 break;
1738
1739 case OPT_ffixed_:
1740 fix_register (arg, 1, 1);
1741 break;
1742
1743 case OPT_finline_limit_:
1744 case OPT_finline_limit_eq:
1745 set_param_value ("max-inline-insns-single", value / 2);
1746 set_param_value ("max-inline-insns-auto", value / 2);
1747 break;
1748
1749 case OPT_finstrument_functions_exclude_function_list_:
1750 add_comma_separated_to_vector
1751 (&flag_instrument_functions_exclude_functions, arg);
1752 break;
1753
1754 case OPT_finstrument_functions_exclude_file_list_:
1755 add_comma_separated_to_vector
1756 (&flag_instrument_functions_exclude_files, arg);
1757 break;
1758
1759 case OPT_fmessage_length_:
1760 pp_set_line_maximum_length (global_dc->printer, value);
1761 break;
1762
1763 case OPT_fpack_struct_:
1764 if (value <= 0 || (value & (value - 1)) || value > 16)
1765 error ("structure alignment must be a small power of two, not %d", value);
1766 else
1767 {
1768 initial_max_fld_align = value;
1769 maximum_field_alignment = value * BITS_PER_UNIT;
1770 }
1771 break;
1772
1773 case OPT_fpeel_loops:
1774 flag_peel_loops_set = true;
1775 break;
1776
1777 case OPT_fprofile_arcs:
1778 profile_arc_flag_set = true;
1779 break;
1780
1781 case OPT_finline_functions:
1782 flag_inline_functions_set = true;
1783 break;
1784
1785 case OPT_fprofile_dir_:
1786 profile_data_prefix = xstrdup (arg);
1787 break;
1788
1789 case OPT_fprofile_use_:
1790 profile_data_prefix = xstrdup (arg);
1791 flag_profile_use = true;
1792 value = true;
1793 /* No break here - do -fprofile-use processing. */
1794 case OPT_fprofile_use:
1795 if (!flag_branch_probabilities_set)
1796 flag_branch_probabilities = value;
1797 if (!flag_profile_values_set)
1798 flag_profile_values = value;
1799 if (!flag_unroll_loops_set)
1800 flag_unroll_loops = value;
1801 if (!flag_peel_loops_set)
1802 flag_peel_loops = value;
1803 if (!flag_tracer_set)
1804 flag_tracer = value;
1805 if (!flag_value_profile_transformations_set)
1806 flag_value_profile_transformations = value;
1807 if (!flag_inline_functions_set)
1808 flag_inline_functions = value;
1809 if (!flag_ipa_cp_set)
1810 flag_ipa_cp = value;
1811 if (!flag_ipa_cp_clone_set
1812 && value && flag_ipa_cp)
1813 flag_ipa_cp_clone = value;
1814 if (!flag_predictive_commoning_set)
1815 flag_predictive_commoning = value;
1816 if (!flag_unswitch_loops_set)
1817 flag_unswitch_loops = value;
1818 if (!flag_gcse_after_reload_set)
1819 flag_gcse_after_reload = value;
1820 break;
1821
1822 case OPT_fprofile_generate_:
1823 profile_data_prefix = xstrdup (arg);
1824 value = true;
1825 /* No break here - do -fprofile-generate processing. */
1826 case OPT_fprofile_generate:
1827 if (!profile_arc_flag_set)
1828 profile_arc_flag = value;
1829 if (!flag_profile_values_set)
1830 flag_profile_values = value;
1831 if (!flag_value_profile_transformations_set)
1832 flag_value_profile_transformations = value;
1833 if (!flag_inline_functions_set)
1834 flag_inline_functions = value;
1835 break;
1836
1837 case OPT_fprofile_values:
1838 flag_profile_values_set = true;
1839 break;
1840
1841 case OPT_fvisibility_:
1842 {
1843 if (!strcmp(arg, "default"))
1844 default_visibility = VISIBILITY_DEFAULT;
1845 else if (!strcmp(arg, "internal"))
1846 default_visibility = VISIBILITY_INTERNAL;
1847 else if (!strcmp(arg, "hidden"))
1848 default_visibility = VISIBILITY_HIDDEN;
1849 else if (!strcmp(arg, "protected"))
1850 default_visibility = VISIBILITY_PROTECTED;
1851 else
1852 error ("unrecognized visibility value \"%s\"", arg);
1853 }
1854 break;
1855
1856 case OPT_fvpt:
1857 flag_value_profile_transformations_set = true;
1858 break;
1859
1860 case OPT_frandom_seed:
1861 /* The real switch is -fno-random-seed. */
1862 if (value)
1863 return 0;
1864 set_random_seed (NULL);
1865 break;
1866
1867 case OPT_frandom_seed_:
1868 set_random_seed (arg);
1869 break;
1870
1871 case OPT_fselective_scheduling:
1872 case OPT_fselective_scheduling2:
1873 sel_sched_switch_set = true;
1874 break;
1875
1876 case OPT_fsched_verbose_:
1877 #ifdef INSN_SCHEDULING
1878 fix_sched_param ("verbose", arg);
1879 break;
1880 #else
1881 return 0;
1882 #endif
1883
1884 case OPT_fsched_stalled_insns_:
1885 flag_sched_stalled_insns = value;
1886 if (flag_sched_stalled_insns == 0)
1887 flag_sched_stalled_insns = -1;
1888 break;
1889
1890 case OPT_fsched_stalled_insns_dep_:
1891 flag_sched_stalled_insns_dep = value;
1892 break;
1893
1894 case OPT_fstack_check_:
1895 if (!strcmp (arg, "no"))
1896 flag_stack_check = NO_STACK_CHECK;
1897 else if (!strcmp (arg, "generic"))
1898 /* This is the old stack checking method. */
1899 flag_stack_check = STACK_CHECK_BUILTIN
1900 ? FULL_BUILTIN_STACK_CHECK
1901 : GENERIC_STACK_CHECK;
1902 else if (!strcmp (arg, "specific"))
1903 /* This is the new stack checking method. */
1904 flag_stack_check = STACK_CHECK_BUILTIN
1905 ? FULL_BUILTIN_STACK_CHECK
1906 : STACK_CHECK_STATIC_BUILTIN
1907 ? STATIC_BUILTIN_STACK_CHECK
1908 : GENERIC_STACK_CHECK;
1909 else
1910 warning (0, "unknown stack check parameter \"%s\"", arg);
1911 break;
1912
1913 case OPT_fstack_check:
1914 /* This is the same as the "specific" mode above. */
1915 if (value)
1916 flag_stack_check = STACK_CHECK_BUILTIN
1917 ? FULL_BUILTIN_STACK_CHECK
1918 : STACK_CHECK_STATIC_BUILTIN
1919 ? STATIC_BUILTIN_STACK_CHECK
1920 : GENERIC_STACK_CHECK;
1921 else
1922 flag_stack_check = NO_STACK_CHECK;
1923 break;
1924
1925 case OPT_fstack_limit:
1926 /* The real switch is -fno-stack-limit. */
1927 if (value)
1928 return 0;
1929 stack_limit_rtx = NULL_RTX;
1930 break;
1931
1932 case OPT_fstack_limit_register_:
1933 {
1934 int reg = decode_reg_name (arg);
1935 if (reg < 0)
1936 error ("unrecognized register name \"%s\"", arg);
1937 else
1938 stack_limit_rtx = gen_rtx_REG (Pmode, reg);
1939 }
1940 break;
1941
1942 case OPT_fstack_limit_symbol_:
1943 stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
1944 break;
1945
1946 case OPT_ftree_vectorizer_verbose_:
1947 vect_set_verbosity_level (arg);
1948 break;
1949
1950 case OPT_ftls_model_:
1951 if (!strcmp (arg, "global-dynamic"))
1952 flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
1953 else if (!strcmp (arg, "local-dynamic"))
1954 flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
1955 else if (!strcmp (arg, "initial-exec"))
1956 flag_tls_default = TLS_MODEL_INITIAL_EXEC;
1957 else if (!strcmp (arg, "local-exec"))
1958 flag_tls_default = TLS_MODEL_LOCAL_EXEC;
1959 else
1960 warning (0, "unknown tls-model \"%s\"", arg);
1961 break;
1962
1963 case OPT_fira_algorithm_:
1964 if (!strcmp (arg, "CB"))
1965 flag_ira_algorithm = IRA_ALGORITHM_CB;
1966 else if (!strcmp (arg, "priority"))
1967 flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
1968 else
1969 warning (0, "unknown ira algorithm \"%s\"", arg);
1970 break;
1971
1972 case OPT_fira_region_:
1973 if (!strcmp (arg, "one"))
1974 flag_ira_region = IRA_REGION_ONE;
1975 else if (!strcmp (arg, "all"))
1976 flag_ira_region = IRA_REGION_ALL;
1977 else if (!strcmp (arg, "mixed"))
1978 flag_ira_region = IRA_REGION_MIXED;
1979 else
1980 warning (0, "unknown ira region \"%s\"", arg);
1981 break;
1982
1983 case OPT_fira_verbose_:
1984 flag_ira_verbose = value;
1985 break;
1986
1987 case OPT_ftracer:
1988 flag_tracer_set = true;
1989 break;
1990
1991 case OPT_fipa_cp:
1992 flag_ipa_cp_set = true;
1993 break;
1994
1995 case OPT_fipa_cp_clone:
1996 flag_ipa_cp_clone_set = true;
1997 break;
1998
1999 case OPT_fpredictive_commoning:
2000 flag_predictive_commoning_set = true;
2001 break;
2002
2003 case OPT_funswitch_loops:
2004 flag_unswitch_loops_set = true;
2005 break;
2006
2007 case OPT_fgcse_after_reload:
2008 flag_gcse_after_reload_set = true;
2009 break;
2010
2011 case OPT_funroll_loops:
2012 flag_unroll_loops_set = true;
2013 break;
2014
2015 case OPT_g:
2016 set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg);
2017 break;
2018
2019 case OPT_gcoff:
2020 set_debug_level (SDB_DEBUG, false, arg);
2021 break;
2022
2023 case OPT_gdwarf_2:
2024 set_debug_level (DWARF2_DEBUG, false, arg);
2025 break;
2026
2027 case OPT_ggdb:
2028 set_debug_level (NO_DEBUG, 2, arg);
2029 break;
2030
2031 case OPT_gstabs:
2032 case OPT_gstabs_:
2033 set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg);
2034 break;
2035
2036 case OPT_gvms:
2037 set_debug_level (VMS_DEBUG, false, arg);
2038 break;
2039
2040 case OPT_gxcoff:
2041 case OPT_gxcoff_:
2042 set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
2043 break;
2044
2045 case OPT_o:
2046 asm_file_name = arg;
2047 break;
2048
2049 case OPT_pedantic_errors:
2050 flag_pedantic_errors = pedantic = 1;
2051 break;
2052
2053 case OPT_floop_optimize:
2054 case OPT_frerun_loop_opt:
2055 case OPT_fstrength_reduce:
2056 case OPT_ftree_store_copy_prop:
2057 case OPT_fforce_addr:
2058 case OPT_ftree_salias:
2059 case OPT_ftree_store_ccp:
2060 /* These are no-ops, preserved for backward compatibility. */
2061 break;
2062
2063 default:
2064 /* If the flag was handled in a standard way, assume the lack of
2065 processing here is intentional. */
2066 gcc_assert (cl_options[scode].flag_var);
2067 break;
2068 }
2069
2070 return 1;
2071 }
2072
2073 /* Handle --param NAME=VALUE. */
2074 static void
2075 handle_param (const char *carg)
2076 {
2077 char *equal, *arg;
2078 int value;
2079
2080 arg = xstrdup (carg);
2081 equal = strchr (arg, '=');
2082 if (!equal)
2083 error ("%s: --param arguments should be of the form NAME=VALUE", arg);
2084 else
2085 {
2086 value = integral_argument (equal + 1);
2087 if (value == -1)
2088 error ("invalid --param value %qs", equal + 1);
2089 else
2090 {
2091 *equal = '\0';
2092 set_param_value (arg, value);
2093 }
2094 }
2095
2096 free (arg);
2097 }
2098
2099 /* Handle -W and -Wextra. */
2100 static void
2101 set_Wextra (int setting)
2102 {
2103 extra_warnings = setting;
2104
2105 /* We save the value of warn_uninitialized, since if they put
2106 -Wuninitialized on the command line, we need to generate a
2107 warning about not using it without also specifying -O. */
2108 if (setting == 0)
2109 warn_uninitialized = 0;
2110 else if (warn_uninitialized != 1)
2111 warn_uninitialized = 2;
2112 }
2113
2114 /* Used to set the level of strict aliasing warnings,
2115 when no level is specified (i.e., when -Wstrict-aliasing, and not
2116 -Wstrict-aliasing=level was given).
2117 ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
2118 and 0 otherwise. After calling this function, wstrict_aliasing will be
2119 set to the default value of -Wstrict_aliasing=level, currently 3. */
2120 void
2121 set_Wstrict_aliasing (int onoff)
2122 {
2123 gcc_assert (onoff == 0 || onoff == 1);
2124 if (onoff != 0)
2125 warn_strict_aliasing = 3;
2126 else
2127 warn_strict_aliasing = 0;
2128 }
2129
2130 /* The following routines are useful in setting all the flags that
2131 -ffast-math and -fno-fast-math imply. */
2132 void
2133 set_fast_math_flags (int set)
2134 {
2135 flag_unsafe_math_optimizations = set;
2136 set_unsafe_math_optimizations_flags (set);
2137 flag_finite_math_only = set;
2138 flag_errno_math = !set;
2139 if (set)
2140 {
2141 flag_signaling_nans = 0;
2142 flag_rounding_math = 0;
2143 flag_cx_limited_range = 1;
2144 }
2145 }
2146
2147 /* When -funsafe-math-optimizations is set the following
2148 flags are set as well. */
2149 void
2150 set_unsafe_math_optimizations_flags (int set)
2151 {
2152 flag_trapping_math = !set;
2153 flag_signed_zeros = !set;
2154 flag_associative_math = set;
2155 flag_reciprocal_math = set;
2156 }
2157
2158 /* Return true iff flags are set as if -ffast-math. */
2159 bool
2160 fast_math_flags_set_p (void)
2161 {
2162 return (!flag_trapping_math
2163 && flag_unsafe_math_optimizations
2164 && flag_finite_math_only
2165 && !flag_signed_zeros
2166 && !flag_errno_math);
2167 }
2168
2169 /* Return true iff flags are set as if -ffast-math but using the flags stored
2170 in the struct cl_optimization structure. */
2171 bool
2172 fast_math_flags_struct_set_p (struct cl_optimization *opt)
2173 {
2174 return (!opt->flag_trapping_math
2175 && opt->flag_unsafe_math_optimizations
2176 && opt->flag_finite_math_only
2177 && !opt->flag_signed_zeros
2178 && !opt->flag_errno_math);
2179 }
2180
2181 /* Handle a debug output -g switch. EXTENDED is true or false to support
2182 extended output (2 is special and means "-ggdb" was given). */
2183 static void
2184 set_debug_level (enum debug_info_type type, int extended, const char *arg)
2185 {
2186 static bool type_explicit;
2187
2188 use_gnu_debug_info_extensions = extended;
2189
2190 if (type == NO_DEBUG)
2191 {
2192 if (write_symbols == NO_DEBUG)
2193 {
2194 write_symbols = PREFERRED_DEBUGGING_TYPE;
2195
2196 if (extended == 2)
2197 {
2198 #ifdef DWARF2_DEBUGGING_INFO
2199 write_symbols = DWARF2_DEBUG;
2200 #elif defined DBX_DEBUGGING_INFO
2201 write_symbols = DBX_DEBUG;
2202 #endif
2203 }
2204
2205 if (write_symbols == NO_DEBUG)
2206 warning (0, "target system does not support debug output");
2207 }
2208 }
2209 else
2210 {
2211 /* Does it conflict with an already selected type? */
2212 if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols)
2213 error ("debug format \"%s\" conflicts with prior selection",
2214 debug_type_names[type]);
2215 write_symbols = type;
2216 type_explicit = true;
2217 }
2218
2219 /* A debug flag without a level defaults to level 2. */
2220 if (*arg == '\0')
2221 {
2222 if (!debug_info_level)
2223 debug_info_level = 2;
2224 }
2225 else
2226 {
2227 debug_info_level = integral_argument (arg);
2228 if (debug_info_level == (unsigned int) -1)
2229 error ("unrecognised debug output level \"%s\"", arg);
2230 else if (debug_info_level > 3)
2231 error ("debug output level %s is too high", arg);
2232 }
2233 }
2234
2235 /* Return 1 if OPTION is enabled, 0 if it is disabled, or -1 if it isn't
2236 a simple on-off switch. */
2237
2238 int
2239 option_enabled (int opt_idx)
2240 {
2241 const struct cl_option *option = &(cl_options[opt_idx]);
2242
2243 if (option->flag_var)
2244 switch (option->var_type)
2245 {
2246 case CLVC_BOOLEAN:
2247 return *(int *) option->flag_var != 0;
2248
2249 case CLVC_EQUAL:
2250 return *(int *) option->flag_var == option->var_value;
2251
2252 case CLVC_BIT_CLEAR:
2253 return (*(int *) option->flag_var & option->var_value) == 0;
2254
2255 case CLVC_BIT_SET:
2256 return (*(int *) option->flag_var & option->var_value) != 0;
2257
2258 case CLVC_STRING:
2259 break;
2260 }
2261 return -1;
2262 }
2263
2264 /* Fill STATE with the current state of option OPTION. Return true if
2265 there is some state to store. */
2266
2267 bool
2268 get_option_state (int option, struct cl_option_state *state)
2269 {
2270 if (cl_options[option].flag_var == 0)
2271 return false;
2272
2273 switch (cl_options[option].var_type)
2274 {
2275 case CLVC_BOOLEAN:
2276 case CLVC_EQUAL:
2277 state->data = cl_options[option].flag_var;
2278 state->size = sizeof (int);
2279 break;
2280
2281 case CLVC_BIT_CLEAR:
2282 case CLVC_BIT_SET:
2283 state->ch = option_enabled (option);
2284 state->data = &state->ch;
2285 state->size = 1;
2286 break;
2287
2288 case CLVC_STRING:
2289 state->data = *(const char **) cl_options[option].flag_var;
2290 if (state->data == 0)
2291 state->data = "";
2292 state->size = strlen ((const char *) state->data) + 1;
2293 break;
2294 }
2295 return true;
2296 }
2297
2298 /* Enable a warning option as an error. This is used by -Werror= and
2299 also by legacy Werror-implicit-function-declaration. */
2300
2301 void
2302 enable_warning_as_error (const char *arg, int value, unsigned int lang_mask)
2303 {
2304 char *new_option;
2305 int option_index;
2306
2307 new_option = XNEWVEC (char, strlen (arg) + 2);
2308 new_option[0] = 'W';
2309 strcpy (new_option + 1, arg);
2310 option_index = find_opt (new_option, lang_mask);
2311 if (option_index == N_OPTS)
2312 {
2313 error ("-Werror=%s: No option -%s", arg, new_option);
2314 }
2315 else
2316 {
2317 int kind = value ? DK_ERROR : DK_WARNING;
2318 diagnostic_classify_diagnostic (global_dc, option_index, kind);
2319
2320 /* -Werror=foo implies -Wfoo. */
2321 if (cl_options[option_index].var_type == CLVC_BOOLEAN
2322 && cl_options[option_index].flag_var
2323 && kind == DK_ERROR)
2324 *(int *) cl_options[option_index].flag_var = 1;
2325 }
2326 free (new_option);
2327 }