OSDN Git Service

2009-04-10 H.J. Lu <hongjiu.lu@intel.com>
[pf3gnuchains/gcc-fork.git] / gcc / opts.c
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_min_crossjump_insns;
781   static int initial_max_fields_for_field_sensitive;
782   static int initial_loop_invariant_max_bbs_in_loop;
783   static unsigned int initial_lang_mask;
784
785   unsigned int i, lang_mask;
786   int opt1;
787   int opt2;
788   int opt3;
789   int opt1_max;
790
791   if (first_time_p)
792     {
793       /* Perform language-specific options initialization.  */
794       initial_lang_mask = lang_mask = lang_hooks.init_options (argc, argv);
795
796       lang_hooks.initialize_diagnostics (global_dc);
797
798       /* Save initial values of parameters we reset.  */
799       initial_min_crossjump_insns
800         = compiler_params[PARAM_MIN_CROSSJUMP_INSNS].value;
801       initial_max_fields_for_field_sensitive
802         = compiler_params[PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE].value;
803       initial_loop_invariant_max_bbs_in_loop
804         = compiler_params[PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP].value;
805     }
806   else
807     lang_mask = initial_lang_mask;
808
809   /* Scan to see what optimization level has been specified.  That will
810      determine the default value of many flags.  */
811   for (i = 1; i < argc; i++)
812     {
813       if (!strcmp (argv[i], "-O"))
814         {
815           optimize = 1;
816           optimize_size = 0;
817         }
818       else if (argv[i][0] == '-' && argv[i][1] == 'O')
819         {
820           /* Handle -Os, -O2, -O3, -O69, ...  */
821           const char *p = &argv[i][2];
822
823           if ((p[0] == 's') && (p[1] == 0))
824             {
825               optimize_size = 1;
826
827               /* Optimizing for size forces optimize to be 2.  */
828               optimize = 2;
829             }
830           else
831             {
832               const int optimize_val = read_integral_parameter (p, p - 2, -1);
833               if (optimize_val != -1)
834                 {
835                   optimize = optimize_val;
836                   optimize_size = 0;
837                 }
838             }
839         }
840     }
841   
842   /* Use priority coloring if cover classes is not defined for the
843      target.  */
844   if (targetm.ira_cover_classes == NULL)
845     flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
846
847   /* -O1 optimizations.  */
848   opt1 = (optimize >= 1);
849   flag_defer_pop = opt1;
850 #ifdef DELAY_SLOTS
851   flag_delayed_branch = opt1;
852 #endif
853 #ifdef CAN_DEBUG_WITHOUT_FP
854   flag_omit_frame_pointer = opt1;
855 #endif
856   flag_guess_branch_prob = opt1;
857   flag_cprop_registers = opt1;
858   flag_if_conversion = opt1;
859   flag_if_conversion2 = opt1;
860   flag_ipa_pure_const = opt1;
861   flag_ipa_reference = opt1;
862   flag_merge_constants = opt1;
863   flag_split_wide_types = opt1;
864   flag_tree_ccp = opt1;
865   flag_tree_dce = opt1;
866   flag_tree_dom = opt1;
867   flag_tree_dse = opt1;
868   flag_tree_ter = opt1;
869   flag_tree_sra = opt1;
870   flag_tree_copyrename = opt1;
871   flag_tree_fre = opt1;
872   flag_tree_copy_prop = opt1;
873   flag_tree_sink = opt1;
874   flag_tree_ch = opt1;
875
876   /* -O2 optimizations.  */
877   opt2 = (optimize >= 2);
878   flag_inline_small_functions = opt2;
879   flag_indirect_inlining = opt2;
880   flag_thread_jumps = opt2;
881   flag_crossjumping = opt2;
882   flag_optimize_sibling_calls = opt2;
883   flag_forward_propagate = opt2;
884   flag_cse_follow_jumps = opt2;
885   flag_gcse = opt2;
886   flag_expensive_optimizations = opt2;
887   flag_rerun_cse_after_loop = opt2;
888   flag_caller_saves = opt2;
889   flag_peephole2 = opt2;
890 #ifdef INSN_SCHEDULING
891   flag_schedule_insns = opt2;
892   flag_schedule_insns_after_reload = opt2;
893 #endif
894   flag_regmove = opt2;
895   flag_strict_aliasing = opt2;
896   flag_strict_overflow = opt2;
897   flag_reorder_blocks = opt2;
898   flag_reorder_functions = opt2;
899   flag_tree_vrp = opt2;
900   flag_tree_builtin_call_dce = opt2;
901   flag_tree_pre = opt2;
902   flag_tree_switch_conversion = 1;
903   flag_ipa_cp = opt2;
904
905   /* Track fields in field-sensitive alias analysis.  */
906   set_param_value ("max-fields-for-field-sensitive",
907                    (opt2) ? 100 : initial_max_fields_for_field_sensitive);
908
909   /* For -O1 only do loop invariant motion for very small loops.  */
910   set_param_value ("loop-invariant-max-bbs-in-loop",
911                    (opt2) ? initial_loop_invariant_max_bbs_in_loop : 1000);
912
913   /* -O3 optimizations.  */
914   opt3 = (optimize >= 3);
915   flag_predictive_commoning = opt3;
916   flag_inline_functions = opt3;
917   flag_unswitch_loops = opt3;
918   flag_gcse_after_reload = opt3;
919   flag_tree_vectorize = opt3;
920   flag_ipa_cp_clone = opt3;
921   if (flag_ipa_cp_clone)
922     flag_ipa_cp = 1;
923
924   /* Just -O1/-O0 optimizations.  */
925   opt1_max = (optimize <= 1);
926   align_loops = opt1_max;
927   align_jumps = opt1_max;
928   align_labels = opt1_max;
929   align_functions = opt1_max;
930
931   if (optimize_size)
932     {
933       /* Inlining of functions reducing size is a good idea regardless of them
934          being declared inline.  */
935       flag_inline_functions = 1;
936
937       /* Basic optimization options.  */
938       optimize_size = 1;
939       if (optimize > 2)
940         optimize = 2;
941
942       /* We want to crossjump as much as possible.  */
943       set_param_value ("min-crossjump-insns", 1);
944     }
945   else
946     set_param_value ("min-crossjump-insns", initial_min_crossjump_insns);
947
948   if (first_time_p)
949     {
950       /* Initialize whether `char' is signed.  */
951       flag_signed_char = DEFAULT_SIGNED_CHAR;
952       /* Set this to a special "uninitialized" value.  The actual default is
953          set after target options have been processed.  */
954       flag_short_enums = 2;
955
956       /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
957          modify it.  */
958       target_flags = targetm.default_target_flags;
959
960       /* Some targets have ABI-specified unwind tables.  */
961       flag_unwind_tables = targetm.unwind_tables_default;
962     }
963
964 #ifdef OPTIMIZATION_OPTIONS
965   /* Allow default optimizations to be specified on a per-machine basis.  */
966   OPTIMIZATION_OPTIONS (optimize, optimize_size);
967 #endif
968
969   handle_options (argc, argv, lang_mask);
970
971   /* Handle related options for unit-at-a-time, toplevel-reorder, and
972      section-anchors.  */
973   if (!flag_unit_at_a_time)
974     {
975       if (flag_section_anchors == 1)
976         error ("Section anchors must be disabled when unit-at-a-time "
977                "is disabled.");
978       flag_section_anchors = 0;
979       if (flag_toplevel_reorder == 1)
980         error ("Toplevel reorder must be disabled when unit-at-a-time "
981                "is disabled.");
982       flag_toplevel_reorder = 0;
983     }
984   /* Unless the user has asked for section anchors, we disable toplevel
985      reordering at -O0 to disable transformations that might be surprising
986      to end users and to get -fno-toplevel-reorder tested.  */
987   if (!optimize && flag_toplevel_reorder == 2 && flag_section_anchors != 1)
988     {
989       flag_toplevel_reorder = 0;
990       flag_section_anchors = 0;
991     }
992   if (!flag_toplevel_reorder)
993     {
994       if (flag_section_anchors == 1)
995         error ("section anchors must be disabled when toplevel reorder"
996                " is disabled");
997       flag_section_anchors = 0;
998     }
999
1000   if (first_time_p)
1001     {
1002       if (flag_pie)
1003         flag_pic = flag_pie;
1004       if (flag_pic && !flag_pie)
1005         flag_shlib = 1;
1006     }
1007
1008   if (optimize == 0)
1009     {
1010       /* Inlining does not work if not optimizing,
1011          so force it not to be done.  */
1012       warn_inline = 0;
1013       flag_no_inline = 1;
1014     }
1015
1016   /* The optimization to partition hot and cold basic blocks into separate
1017      sections of the .o and executable files does not work (currently)
1018      with exception handling.  This is because there is no support for
1019      generating unwind info.  If flag_exceptions is turned on we need to
1020      turn off the partitioning optimization.  */
1021
1022   if (flag_exceptions && flag_reorder_blocks_and_partition)
1023     {
1024       inform (input_location, 
1025               "-freorder-blocks-and-partition does not work with exceptions");
1026       flag_reorder_blocks_and_partition = 0;
1027       flag_reorder_blocks = 1;
1028     }
1029
1030   /* If user requested unwind info, then turn off the partitioning
1031      optimization.  */
1032
1033   if (flag_unwind_tables && ! targetm.unwind_tables_default
1034       && flag_reorder_blocks_and_partition)
1035     {
1036       inform (input_location, "-freorder-blocks-and-partition does not support unwind info");
1037       flag_reorder_blocks_and_partition = 0;
1038       flag_reorder_blocks = 1;
1039     }
1040
1041   /* If the target requested unwind info, then turn off the partitioning
1042      optimization with a different message.  Likewise, if the target does not
1043      support named sections.  */
1044
1045   if (flag_reorder_blocks_and_partition
1046       && (!targetm.have_named_sections
1047           || (flag_unwind_tables && targetm.unwind_tables_default)))
1048     {
1049       inform (input_location,
1050               "-freorder-blocks-and-partition does not work on this architecture");
1051       flag_reorder_blocks_and_partition = 0;
1052       flag_reorder_blocks = 1;
1053     }
1054
1055   /* Pipelining of outer loops is only possible when general pipelining
1056      capabilities are requested.  */
1057   if (!flag_sel_sched_pipelining)
1058     flag_sel_sched_pipelining_outer_loops = 0;
1059
1060   if (!targetm.ira_cover_classes
1061       && flag_ira_algorithm == IRA_ALGORITHM_CB)
1062     {
1063       inform (input_location,
1064               "-fira-algorithm=CB does not work on this architecture");
1065       flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
1066     }
1067
1068   /* Save the current optimization options if this is the first call.  */
1069   if (first_time_p)
1070     {
1071       optimization_default_node = build_optimization_node ();
1072       optimization_current_node = optimization_default_node;
1073       first_time_p = false;
1074     }
1075   if (flag_conserve_stack)
1076     {
1077       if (!PARAM_SET_P (PARAM_LARGE_STACK_FRAME))
1078         PARAM_VALUE (PARAM_LARGE_STACK_FRAME) = 100;
1079       if (!PARAM_SET_P (PARAM_STACK_FRAME_GROWTH))
1080         PARAM_VALUE (PARAM_STACK_FRAME_GROWTH) = 40;
1081     }
1082
1083 }
1084
1085 #define LEFT_COLUMN     27
1086
1087 /* Output ITEM, of length ITEM_WIDTH, in the left column,
1088    followed by word-wrapped HELP in a second column.  */
1089 static void
1090 wrap_help (const char *help,
1091            const char *item,
1092            unsigned int item_width,
1093            unsigned int columns)
1094 {
1095   unsigned int col_width = LEFT_COLUMN;
1096   unsigned int remaining, room, len;
1097
1098   remaining = strlen (help);
1099
1100   do
1101     {
1102       room = columns - 3 - MAX (col_width, item_width);
1103       if (room > columns)
1104         room = 0;
1105       len = remaining;
1106
1107       if (room < len)
1108         {
1109           unsigned int i;
1110
1111           for (i = 0; help[i]; i++)
1112             {
1113               if (i >= room && len != remaining)
1114                 break;
1115               if (help[i] == ' ')
1116                 len = i;
1117               else if ((help[i] == '-' || help[i] == '/')
1118                        && help[i + 1] != ' '
1119                        && i > 0 && ISALPHA (help[i - 1]))
1120                 len = i + 1;
1121             }
1122         }
1123
1124       printf( "  %-*.*s %.*s\n", col_width, item_width, item, len, help);
1125       item_width = 0;
1126       while (help[len] == ' ')
1127         len++;
1128       help += len;
1129       remaining -= len;
1130     }
1131   while (remaining);
1132 }
1133
1134 /* Print help for a specific front-end, etc.  */
1135 static void
1136 print_filtered_help (unsigned int include_flags,
1137                      unsigned int exclude_flags,
1138                      unsigned int any_flags,
1139                      unsigned int columns)
1140 {
1141   unsigned int i;
1142   const char *help;
1143   static char *printed = NULL;
1144   bool found = false;
1145   bool displayed = false;
1146
1147   if (include_flags == CL_PARAMS)
1148     {
1149       for (i = 0; i < LAST_PARAM; i++)
1150         {
1151           const char *param = compiler_params[i].option;
1152
1153           help = compiler_params[i].help;
1154           if (help == NULL || *help == '\0')
1155             {
1156               if (exclude_flags & CL_UNDOCUMENTED)
1157                 continue;
1158               help = undocumented_msg;
1159             }
1160
1161           /* Get the translation.  */
1162           help = _(help);
1163
1164           wrap_help (help, param, strlen (param), columns);
1165         }
1166       putchar ('\n');
1167       return;
1168     }
1169
1170   if (!printed)
1171     printed = XCNEWVAR (char, cl_options_count);
1172
1173   for (i = 0; i < cl_options_count; i++)
1174     {
1175       static char new_help[128];
1176       const struct cl_option *option = cl_options + i;
1177       unsigned int len;
1178       const char *opt;
1179       const char *tab;
1180
1181       if (include_flags == 0
1182           || ((option->flags & include_flags) != include_flags))
1183         {
1184           if ((option->flags & any_flags) == 0)
1185             continue;
1186         }
1187
1188       /* Skip unwanted switches.  */
1189       if ((option->flags & exclude_flags) != 0)
1190         continue;
1191
1192       found = true;
1193       /* Skip switches that have already been printed.  */
1194       if (printed[i])
1195         continue;
1196
1197       printed[i] = true;
1198
1199       help = option->help;
1200       if (help == NULL)
1201         {
1202           if (exclude_flags & CL_UNDOCUMENTED)
1203             continue;
1204           help = undocumented_msg;
1205         }
1206
1207       /* Get the translation.  */
1208       help = _(help);
1209
1210       /* Find the gap between the name of the
1211          option and its descriptive text.  */
1212       tab = strchr (help, '\t');
1213       if (tab)
1214         {
1215           len = tab - help;
1216           opt = help;
1217           help = tab + 1;
1218         }
1219       else
1220         {
1221           opt = option->opt_text;
1222           len = strlen (opt);
1223         }
1224
1225       /* With the -Q option enabled we change the descriptive text associated
1226          with an option to be an indication of its current setting.  */
1227       if (!quiet_flag)
1228         {
1229           if (len < (LEFT_COLUMN + 2))
1230             strcpy (new_help, "\t\t");
1231           else
1232             strcpy (new_help, "\t");
1233
1234           if (option->flag_var != NULL)
1235             {
1236               if (option->flags & CL_JOINED)
1237                 {
1238                   if (option->var_type == CLVC_STRING)
1239                     {
1240                       if (* (const char **) option->flag_var != NULL)
1241                         snprintf (new_help + strlen (new_help),
1242                                   sizeof (new_help) - strlen (new_help),
1243                                   * (const char **) option->flag_var);
1244                     }
1245                   else
1246                     sprintf (new_help + strlen (new_help),
1247                              "%#x", * (int *) option->flag_var);
1248                 }
1249               else
1250                 strcat (new_help, option_enabled (i)
1251                         ? _("[enabled]") : _("[disabled]"));
1252             }
1253
1254           help = new_help;
1255         }
1256
1257       wrap_help (help, opt, len, columns);
1258       displayed = true;
1259     }
1260
1261   if (! found)
1262     {
1263       unsigned int langs = include_flags & CL_LANG_ALL;
1264
1265       if (langs == 0)
1266         printf (_(" No options with the desired characteristics were found\n"));
1267       else
1268         {
1269           unsigned int i;
1270
1271           /* PR 31349: Tell the user how to see all of the
1272              options supported by a specific front end.  */
1273           for (i = 0; (1U << i) < CL_LANG_ALL; i ++)
1274             if ((1U << i) & langs)
1275               printf (_(" None found.  Use --help=%s to show *all* the options supported by the %s front-end\n"),
1276                       lang_names[i], lang_names[i]);
1277         }
1278         
1279     }
1280   else if (! displayed)
1281     printf (_(" All options with the desired characteristics have already been displayed\n"));
1282
1283   putchar ('\n');
1284 }
1285
1286 /* Display help for a specified type of option.
1287    The options must have ALL of the INCLUDE_FLAGS set
1288    ANY of the flags in the ANY_FLAGS set
1289    and NONE of the EXCLUDE_FLAGS set.  */
1290 static void
1291 print_specific_help (unsigned int include_flags,
1292                      unsigned int exclude_flags,
1293                      unsigned int any_flags)
1294 {
1295   unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1296   const char * description = NULL;
1297   const char * descrip_extra = "";
1298   size_t i;
1299   unsigned int flag;
1300   static unsigned int columns = 0;
1301
1302   /* Sanity check: Make sure that we do not have more
1303      languages than we have bits available to enumerate them.  */
1304   gcc_assert ((1U << cl_lang_count) < CL_MIN_OPTION_CLASS);
1305
1306   /* If we have not done so already, obtain
1307      the desired maximum width of the output.  */
1308   if (columns == 0)
1309     {
1310       const char *p;
1311
1312       GET_ENVIRONMENT (p, "COLUMNS");
1313       if (p != NULL)
1314         {
1315           int value = atoi (p);
1316
1317           if (value > 0)
1318             columns = value;
1319         }
1320
1321       if (columns == 0)
1322         /* Use a reasonable default.  */
1323         columns = 80;
1324     }
1325
1326   /* Decide upon the title for the options that we are going to display.  */
1327   for (i = 0, flag = 1; flag <= CL_MAX_OPTION_CLASS; flag <<= 1, i ++)
1328     {
1329       switch (flag & include_flags)
1330         {
1331         case 0:
1332           break;
1333
1334         case CL_TARGET:
1335           description = _("The following options are target specific");
1336           break;
1337         case CL_WARNING:
1338           description = _("The following options control compiler warning messages");
1339           break;
1340         case CL_OPTIMIZATION:
1341           description = _("The following options control optimizations");
1342           break;
1343         case CL_COMMON:
1344           description = _("The following options are language-independent");
1345           break;
1346         case CL_PARAMS:
1347           description = _("The --param option recognizes the following as parameters");
1348           break;
1349         default:
1350           if (i >= cl_lang_count)
1351             break;
1352           if (exclude_flags & all_langs_mask)
1353             description = _("The following options are specific to just the language ");
1354           else
1355             description = _("The following options are supported by the language ");
1356           descrip_extra = lang_names [i];
1357           break;
1358         }
1359     }
1360
1361   if (description == NULL)
1362     {
1363       if (any_flags == 0)
1364         {
1365           if (include_flags & CL_UNDOCUMENTED)
1366             description = _("The following options are not documented");
1367           else if (include_flags & CL_SEPARATE)
1368             description = _("The following options take separate arguments");
1369           else if (include_flags & CL_JOINED)
1370             description = _("The following options take joined arguments");
1371           else
1372             {
1373               internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
1374                               include_flags);
1375               return;
1376             }
1377         }
1378       else
1379         {
1380           if (any_flags & all_langs_mask)
1381             description = _("The following options are language-related");
1382           else
1383             description = _("The following options are language-independent");
1384         }
1385     }
1386
1387   printf ("%s%s:\n", description, descrip_extra);
1388   print_filtered_help (include_flags, exclude_flags, any_flags, columns);
1389 }
1390
1391 /* Handle target- and language-independent options.  Return zero to
1392    generate an "unknown option" message.  Only options that need
1393    extra handling need to be listed here; if you simply want
1394    VALUE assigned to a variable, it happens automatically.  */
1395
1396 static int
1397 common_handle_option (size_t scode, const char *arg, int value,
1398                       unsigned int lang_mask)
1399 {
1400   static bool verbose = false;
1401   enum opt_code code = (enum opt_code) scode;
1402
1403   switch (code)
1404     {
1405     case OPT__param:
1406       handle_param (arg);
1407       break;
1408
1409     case OPT_v:
1410       verbose = true;
1411       break;
1412
1413     case OPT_fhelp:
1414     case OPT__help:
1415       {
1416         unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1417         unsigned int undoc_mask;
1418         unsigned int i;
1419
1420         undoc_mask = (verbose | extra_warnings) ? 0 : CL_UNDOCUMENTED;
1421         /* First display any single language specific options.  */
1422         for (i = 0; i < cl_lang_count; i++)
1423           print_specific_help
1424             (1U << i, (all_langs_mask & (~ (1U << i))) | undoc_mask, 0);
1425         /* Next display any multi language specific options.  */
1426         print_specific_help (0, undoc_mask, all_langs_mask);
1427         /* Then display any remaining, non-language options.  */
1428         for (i = CL_MIN_OPTION_CLASS; i <= CL_MAX_OPTION_CLASS; i <<= 1)
1429           print_specific_help (i, undoc_mask, 0);
1430         exit_after_options = true;
1431         break;
1432       }
1433
1434     case OPT_ftarget_help:
1435     case OPT__target_help:
1436       print_specific_help (CL_TARGET, CL_UNDOCUMENTED, 0);
1437       exit_after_options = true;
1438
1439       /* Allow the target a chance to give the user some additional information.  */
1440       if (targetm.target_help)
1441         targetm.target_help ();
1442       break;
1443
1444     case OPT_fhelp_:
1445     case OPT__help_:
1446       {
1447         const char * a = arg;
1448         unsigned int include_flags = 0;
1449         /* Note - by default we include undocumented options when listing
1450            specific classes.  If you only want to see documented options
1451            then add ",^undocumented" to the --help= option.  E.g.:
1452
1453            --help=target,^undocumented  */
1454         unsigned int exclude_flags = 0;
1455
1456         /* Walk along the argument string, parsing each word in turn.
1457            The format is:
1458            arg = [^]{word}[,{arg}]
1459            word = {optimizers|target|warnings|undocumented|
1460                    params|common|<language>}  */
1461         while (* a != 0)
1462           {
1463             static struct
1464             {
1465               const char * string;
1466               unsigned int flag;
1467             }
1468             specifics[] =
1469             {
1470               { "optimizers", CL_OPTIMIZATION },
1471               { "target", CL_TARGET },
1472               { "warnings", CL_WARNING },
1473               { "undocumented", CL_UNDOCUMENTED },
1474               { "params", CL_PARAMS },
1475               { "joined", CL_JOINED },
1476               { "separate", CL_SEPARATE },
1477               { "common", CL_COMMON },
1478               { NULL, 0 }
1479             };
1480             unsigned int * pflags;
1481             char * comma;
1482             unsigned int lang_flag, specific_flag;
1483             unsigned int len;
1484             unsigned int i;
1485
1486             if (* a == '^')
1487               {
1488                 ++ a;
1489                 pflags = & exclude_flags;
1490               }
1491             else
1492               pflags = & include_flags;
1493
1494             comma = strchr (a, ',');
1495             if (comma == NULL)
1496               len = strlen (a);
1497             else
1498               len = comma - a;
1499             if (len == 0)
1500               {
1501                 a = comma + 1;
1502                 continue;
1503               }
1504
1505             /* Check to see if the string matches an option class name.  */
1506             for (i = 0, specific_flag = 0; specifics[i].string != NULL; i++)
1507               if (strncasecmp (a, specifics[i].string, len) == 0)
1508                 {
1509                   specific_flag = specifics[i].flag;
1510                   break;
1511                 }
1512
1513             /* Check to see if the string matches a language name.
1514                Note - we rely upon the alpha-sorted nature of the entries in
1515                the lang_names array, specifically that shorter names appear
1516                before their longer variants.  (i.e. C before C++).  That way
1517                when we are attempting to match --help=c for example we will
1518                match with C first and not C++.  */
1519             for (i = 0, lang_flag = 0; i < cl_lang_count; i++)
1520               if (strncasecmp (a, lang_names[i], len) == 0)
1521                 {
1522                   lang_flag = 1U << i;
1523                   break;
1524                 }
1525
1526             if (specific_flag != 0)
1527               {
1528                 if (lang_flag == 0)
1529                   * pflags |= specific_flag;
1530                 else
1531                   {
1532                     /* The option's argument matches both the start of a
1533                        language name and the start of an option class name.
1534                        We have a special case for when the user has
1535                        specified "--help=c", but otherwise we have to issue
1536                        a warning.  */
1537                     if (strncasecmp (a, "c", len) == 0)
1538                       * pflags |= lang_flag;
1539                     else
1540                       fnotice (stderr,
1541                                "warning: --help argument %.*s is ambiguous, please be more specific\n",
1542                                len, a);
1543                   }
1544               }
1545             else if (lang_flag != 0)
1546               * pflags |= lang_flag;
1547             else
1548               fnotice (stderr,
1549                        "warning: unrecognized argument to --help= option: %.*s\n",
1550                        len, a);
1551
1552             if (comma == NULL)
1553               break;
1554             a = comma + 1;
1555           }
1556
1557         if (include_flags)
1558           print_specific_help (include_flags, exclude_flags, 0);
1559         exit_after_options = true;
1560         break;
1561       }
1562
1563     case OPT__version:
1564       print_version (stderr, "");
1565       exit_after_options = true;
1566       break;
1567
1568     case OPT_G:
1569       g_switch_value = value;
1570       g_switch_set = true;
1571       break;
1572
1573     case OPT_O:
1574     case OPT_Os:
1575       /* Currently handled in a prescan.  */
1576       break;
1577
1578     case OPT_W:
1579       /* For backward compatibility, -W is the same as -Wextra.  */
1580       set_Wextra (value);
1581       break;
1582
1583     case OPT_Werror_:
1584       enable_warning_as_error (arg, value, lang_mask);
1585       break;
1586
1587     case OPT_Wextra:
1588       set_Wextra (value);
1589       break;
1590
1591     case OPT_Wlarger_than_:
1592       /* This form corresponds to -Wlarger-than-.  
1593          Kept for backward compatibility. 
1594          Don't use it as the first argument of warning().  */
1595
1596     case OPT_Wlarger_than_eq:
1597       larger_than_size = value;
1598       warn_larger_than = value != -1;
1599       break;
1600
1601     case OPT_Wframe_larger_than_:
1602       frame_larger_than_size = value;
1603       warn_frame_larger_than = value != -1;
1604       break;
1605
1606     case OPT_Wstrict_aliasing:
1607       set_Wstrict_aliasing (value);
1608       break;
1609
1610     case OPT_Wstrict_aliasing_:
1611       warn_strict_aliasing = value;
1612       break;
1613
1614     case OPT_Wstrict_overflow:
1615       warn_strict_overflow = (value
1616                               ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
1617                               : 0);
1618       break;
1619
1620     case OPT_Wstrict_overflow_:
1621       warn_strict_overflow = value;
1622       break;
1623
1624     case OPT_Wunused:
1625       warn_unused = value;
1626       break;
1627
1628     case OPT_aux_info:
1629     case OPT_aux_info_:
1630       aux_info_file_name = arg;
1631       flag_gen_aux_info = 1;
1632       break;
1633
1634     case OPT_auxbase:
1635       aux_base_name = arg;
1636       break;
1637
1638     case OPT_auxbase_strip:
1639       {
1640         char *tmp = xstrdup (arg);
1641         strip_off_ending (tmp, strlen (tmp));
1642         if (tmp[0])
1643           aux_base_name = tmp;
1644       }
1645       break;
1646
1647     case OPT_d:
1648       decode_d_option (arg);
1649       break;
1650
1651     case OPT_dumpbase:
1652       dump_base_name = arg;
1653       break;
1654
1655     case OPT_falign_functions_:
1656       align_functions = value;
1657       break;
1658
1659     case OPT_falign_jumps_:
1660       align_jumps = value;
1661       break;
1662
1663     case OPT_falign_labels_:
1664       align_labels = value;
1665       break;
1666
1667     case OPT_falign_loops_:
1668       align_loops = value;
1669       break;
1670
1671     case OPT_fbranch_probabilities:
1672       flag_branch_probabilities_set = true;
1673       break;
1674
1675     case OPT_fcall_used_:
1676       fix_register (arg, 0, 1);
1677       break;
1678
1679     case OPT_fcall_saved_:
1680       fix_register (arg, 0, 0);
1681       break;
1682
1683     case OPT_fdbg_cnt_:
1684       dbg_cnt_process_opt (arg);
1685       break;
1686
1687     case OPT_fdbg_cnt_list:
1688       dbg_cnt_list_all_counters ();
1689       break;
1690
1691     case OPT_fdebug_prefix_map_:
1692       add_debug_prefix_map (arg);
1693       break;
1694
1695     case OPT_fdiagnostics_show_location_:
1696       if (!strcmp (arg, "once"))
1697         diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
1698       else if (!strcmp (arg, "every-line"))
1699         diagnostic_prefixing_rule (global_dc)
1700           = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
1701       else
1702         return 0;
1703       break;
1704
1705     case OPT_fdiagnostics_show_option:
1706       global_dc->show_option_requested = true;
1707       break;
1708
1709     case OPT_fdump_:
1710       if (!dump_switch_p (arg))
1711         return 0;
1712       break;
1713
1714     case OPT_fexcess_precision_:
1715       if (!strcmp (arg, "fast"))
1716         flag_excess_precision_cmdline = EXCESS_PRECISION_FAST;
1717       else if (!strcmp (arg, "standard"))
1718         flag_excess_precision_cmdline = EXCESS_PRECISION_STANDARD;
1719       else
1720         error ("unknown excess precision style \"%s\"", arg);
1721       break;
1722
1723     case OPT_ffast_math:
1724       set_fast_math_flags (value);
1725       break;
1726
1727     case OPT_funsafe_math_optimizations:
1728       set_unsafe_math_optimizations_flags (value);
1729       break;
1730
1731     case OPT_ffixed_:
1732       fix_register (arg, 1, 1);
1733       break;
1734
1735     case OPT_finline_limit_:
1736     case OPT_finline_limit_eq:
1737       set_param_value ("max-inline-insns-single", value / 2);
1738       set_param_value ("max-inline-insns-auto", value / 2);
1739       break;
1740
1741     case OPT_finstrument_functions_exclude_function_list_:
1742       add_comma_separated_to_vector
1743         (&flag_instrument_functions_exclude_functions, arg);
1744       break;
1745
1746     case OPT_finstrument_functions_exclude_file_list_:
1747       add_comma_separated_to_vector
1748         (&flag_instrument_functions_exclude_files, arg);
1749       break;
1750
1751     case OPT_fmessage_length_:
1752       pp_set_line_maximum_length (global_dc->printer, value);
1753       break;
1754
1755     case OPT_fpack_struct_:
1756       if (value <= 0 || (value & (value - 1)) || value > 16)
1757         error ("structure alignment must be a small power of two, not %d", value);
1758       else
1759         {
1760           initial_max_fld_align = value;
1761           maximum_field_alignment = value * BITS_PER_UNIT;
1762         }
1763       break;
1764
1765     case OPT_fpeel_loops:
1766       flag_peel_loops_set = true;
1767       break;
1768
1769     case OPT_fprofile_arcs:
1770       profile_arc_flag_set = true;
1771       break;
1772
1773     case OPT_finline_functions:
1774       flag_inline_functions_set = true;
1775       break;
1776
1777     case OPT_fprofile_dir_:
1778       profile_data_prefix = xstrdup (arg);
1779       break;
1780
1781     case OPT_fprofile_use_:
1782       profile_data_prefix = xstrdup (arg);
1783       flag_profile_use = true;
1784       value = true;
1785       /* No break here - do -fprofile-use processing. */
1786     case OPT_fprofile_use:
1787       if (!flag_branch_probabilities_set)
1788         flag_branch_probabilities = value;
1789       if (!flag_profile_values_set)
1790         flag_profile_values = value;
1791       if (!flag_unroll_loops_set)
1792         flag_unroll_loops = value;
1793       if (!flag_peel_loops_set)
1794         flag_peel_loops = value;
1795       if (!flag_tracer_set)
1796         flag_tracer = value;
1797       if (!flag_value_profile_transformations_set)
1798         flag_value_profile_transformations = value;
1799       if (!flag_inline_functions_set)
1800         flag_inline_functions = value;
1801       if (!flag_ipa_cp_set)
1802         flag_ipa_cp = value;
1803       if (!flag_ipa_cp_clone_set
1804           && value && flag_ipa_cp)
1805         flag_ipa_cp_clone = value;
1806       if (!flag_predictive_commoning_set)
1807         flag_predictive_commoning = value;
1808       if (!flag_unswitch_loops_set)
1809         flag_unswitch_loops = value;
1810       if (!flag_gcse_after_reload_set)
1811         flag_gcse_after_reload = value;
1812       break;
1813
1814     case OPT_fprofile_generate_:
1815       profile_data_prefix = xstrdup (arg);
1816       value = true;
1817       /* No break here - do -fprofile-generate processing. */
1818     case OPT_fprofile_generate:
1819       if (!profile_arc_flag_set)
1820         profile_arc_flag = value;
1821       if (!flag_profile_values_set)
1822         flag_profile_values = value;
1823       if (!flag_value_profile_transformations_set)
1824         flag_value_profile_transformations = value;
1825       if (!flag_inline_functions_set)
1826         flag_inline_functions = value;
1827       break;
1828
1829     case OPT_fprofile_values:
1830       flag_profile_values_set = true;
1831       break;
1832
1833     case OPT_fvisibility_:
1834       {
1835         if (!strcmp(arg, "default"))
1836           default_visibility = VISIBILITY_DEFAULT;
1837         else if (!strcmp(arg, "internal"))
1838           default_visibility = VISIBILITY_INTERNAL;
1839         else if (!strcmp(arg, "hidden"))
1840           default_visibility = VISIBILITY_HIDDEN;
1841         else if (!strcmp(arg, "protected"))
1842           default_visibility = VISIBILITY_PROTECTED;
1843         else
1844           error ("unrecognized visibility value \"%s\"", arg);
1845       }
1846       break;
1847
1848     case OPT_fvpt:
1849       flag_value_profile_transformations_set = true;
1850       break;
1851
1852     case OPT_frandom_seed:
1853       /* The real switch is -fno-random-seed.  */
1854       if (value)
1855         return 0;
1856       set_random_seed (NULL);
1857       break;
1858
1859     case OPT_frandom_seed_:
1860       set_random_seed (arg);
1861       break;
1862
1863     case OPT_fselective_scheduling:
1864     case OPT_fselective_scheduling2:
1865       sel_sched_switch_set = true;
1866       break;
1867
1868     case OPT_fsched_verbose_:
1869 #ifdef INSN_SCHEDULING
1870       fix_sched_param ("verbose", arg);
1871       break;
1872 #else
1873       return 0;
1874 #endif
1875
1876     case OPT_fsched_stalled_insns_:
1877       flag_sched_stalled_insns = value;
1878       if (flag_sched_stalled_insns == 0)
1879         flag_sched_stalled_insns = -1;
1880       break;
1881
1882     case OPT_fsched_stalled_insns_dep_:
1883       flag_sched_stalled_insns_dep = value;
1884       break;
1885
1886     case OPT_fstack_check_:
1887       if (!strcmp (arg, "no"))
1888         flag_stack_check = NO_STACK_CHECK;
1889       else if (!strcmp (arg, "generic"))
1890         /* This is the old stack checking method.  */
1891         flag_stack_check = STACK_CHECK_BUILTIN
1892                            ? FULL_BUILTIN_STACK_CHECK
1893                            : GENERIC_STACK_CHECK;
1894       else if (!strcmp (arg, "specific"))
1895         /* This is the new stack checking method.  */
1896         flag_stack_check = STACK_CHECK_BUILTIN
1897                            ? FULL_BUILTIN_STACK_CHECK
1898                            : STACK_CHECK_STATIC_BUILTIN
1899                              ? STATIC_BUILTIN_STACK_CHECK
1900                              : GENERIC_STACK_CHECK;
1901       else
1902         warning (0, "unknown stack check parameter \"%s\"", arg);
1903       break;
1904
1905     case OPT_fstack_check:
1906       /* This is the same as the "specific" mode above.  */
1907       if (value)
1908         flag_stack_check = STACK_CHECK_BUILTIN
1909                            ? FULL_BUILTIN_STACK_CHECK
1910                            : STACK_CHECK_STATIC_BUILTIN
1911                              ? STATIC_BUILTIN_STACK_CHECK
1912                              : GENERIC_STACK_CHECK;
1913       else
1914         flag_stack_check = NO_STACK_CHECK;
1915       break;
1916
1917     case OPT_fstack_limit:
1918       /* The real switch is -fno-stack-limit.  */
1919       if (value)
1920         return 0;
1921       stack_limit_rtx = NULL_RTX;
1922       break;
1923
1924     case OPT_fstack_limit_register_:
1925       {
1926         int reg = decode_reg_name (arg);
1927         if (reg < 0)
1928           error ("unrecognized register name \"%s\"", arg);
1929         else
1930           stack_limit_rtx = gen_rtx_REG (Pmode, reg);
1931       }
1932       break;
1933
1934     case OPT_fstack_limit_symbol_:
1935       stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
1936       break;
1937
1938     case OPT_ftree_vectorizer_verbose_:
1939       vect_set_verbosity_level (arg);
1940       break;
1941
1942     case OPT_ftls_model_:
1943       if (!strcmp (arg, "global-dynamic"))
1944         flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
1945       else if (!strcmp (arg, "local-dynamic"))
1946         flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
1947       else if (!strcmp (arg, "initial-exec"))
1948         flag_tls_default = TLS_MODEL_INITIAL_EXEC;
1949       else if (!strcmp (arg, "local-exec"))
1950         flag_tls_default = TLS_MODEL_LOCAL_EXEC;
1951       else
1952         warning (0, "unknown tls-model \"%s\"", arg);
1953       break;
1954
1955     case OPT_fira_algorithm_:
1956       if (!strcmp (arg, "CB"))
1957         flag_ira_algorithm = IRA_ALGORITHM_CB;
1958       else if (!strcmp (arg, "priority"))
1959         flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
1960       else
1961         warning (0, "unknown ira algorithm \"%s\"", arg);
1962       break;
1963
1964     case OPT_fira_region_:
1965       if (!strcmp (arg, "one"))
1966         flag_ira_region = IRA_REGION_ONE;
1967       else if (!strcmp (arg, "all"))
1968         flag_ira_region = IRA_REGION_ALL;
1969       else if (!strcmp (arg, "mixed"))
1970         flag_ira_region = IRA_REGION_MIXED;
1971       else
1972         warning (0, "unknown ira region \"%s\"", arg);
1973       break;
1974
1975     case OPT_fira_verbose_:
1976       flag_ira_verbose = value;
1977       break;
1978
1979     case OPT_ftracer:
1980       flag_tracer_set = true;
1981       break;
1982
1983     case OPT_fipa_cp:
1984       flag_ipa_cp_set = true;
1985       break;
1986
1987     case OPT_fipa_cp_clone:
1988       flag_ipa_cp_clone_set = true;
1989       break;
1990
1991     case OPT_fpredictive_commoning:
1992       flag_predictive_commoning_set = true;
1993       break;
1994
1995     case OPT_funswitch_loops:
1996       flag_unswitch_loops_set = true;
1997       break;
1998
1999     case OPT_fgcse_after_reload:
2000       flag_gcse_after_reload_set = true;
2001       break;
2002
2003     case OPT_funroll_loops:
2004       flag_unroll_loops_set = true;
2005       break;
2006
2007     case OPT_g:
2008       set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg);
2009       break;
2010
2011     case OPT_gcoff:
2012       set_debug_level (SDB_DEBUG, false, arg);
2013       break;
2014
2015     case OPT_gdwarf_2:
2016       set_debug_level (DWARF2_DEBUG, false, arg);
2017       break;
2018
2019     case OPT_ggdb:
2020       set_debug_level (NO_DEBUG, 2, arg);
2021       break;
2022
2023     case OPT_gstabs:
2024     case OPT_gstabs_:
2025       set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg);
2026       break;
2027
2028     case OPT_gvms:
2029       set_debug_level (VMS_DEBUG, false, arg);
2030       break;
2031
2032     case OPT_gxcoff:
2033     case OPT_gxcoff_:
2034       set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
2035       break;
2036
2037     case OPT_o:
2038       asm_file_name = arg;
2039       break;
2040
2041     case OPT_pedantic_errors:
2042       flag_pedantic_errors = pedantic = 1;
2043       break;
2044
2045     case OPT_floop_optimize:
2046     case OPT_frerun_loop_opt:
2047     case OPT_fstrength_reduce:
2048     case OPT_ftree_store_copy_prop:
2049     case OPT_fforce_addr:
2050     case OPT_ftree_salias:
2051     case OPT_ftree_store_ccp:
2052       /* These are no-ops, preserved for backward compatibility.  */
2053       break;
2054
2055     default:
2056       /* If the flag was handled in a standard way, assume the lack of
2057          processing here is intentional.  */
2058       gcc_assert (cl_options[scode].flag_var);
2059       break;
2060     }
2061
2062   return 1;
2063 }
2064
2065 /* Handle --param NAME=VALUE.  */
2066 static void
2067 handle_param (const char *carg)
2068 {
2069   char *equal, *arg;
2070   int value;
2071
2072   arg = xstrdup (carg);
2073   equal = strchr (arg, '=');
2074   if (!equal)
2075     error ("%s: --param arguments should be of the form NAME=VALUE", arg);
2076   else
2077     {
2078       value = integral_argument (equal + 1);
2079       if (value == -1)
2080         error ("invalid --param value %qs", equal + 1);
2081       else
2082         {
2083           *equal = '\0';
2084           set_param_value (arg, value);
2085         }
2086     }
2087
2088   free (arg);
2089 }
2090
2091 /* Handle -W and -Wextra.  */
2092 static void
2093 set_Wextra (int setting)
2094 {
2095   extra_warnings = setting;
2096
2097   /* We save the value of warn_uninitialized, since if they put
2098      -Wuninitialized on the command line, we need to generate a
2099      warning about not using it without also specifying -O.  */
2100   if (setting == 0)
2101     warn_uninitialized = 0;
2102   else if (warn_uninitialized != 1)
2103     warn_uninitialized = 2;
2104 }
2105
2106 /* Used to set the level of strict aliasing warnings, 
2107    when no level is specified (i.e., when -Wstrict-aliasing, and not
2108    -Wstrict-aliasing=level was given).
2109    ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
2110    and 0 otherwise.  After calling this function, wstrict_aliasing will be
2111    set to the default value of -Wstrict_aliasing=level, currently 3.  */
2112 void
2113 set_Wstrict_aliasing (int onoff)
2114 {
2115   gcc_assert (onoff == 0 || onoff == 1);
2116   if (onoff != 0)
2117     warn_strict_aliasing = 3;
2118   else
2119     warn_strict_aliasing = 0;
2120 }
2121
2122 /* The following routines are useful in setting all the flags that
2123    -ffast-math and -fno-fast-math imply.  */
2124 void
2125 set_fast_math_flags (int set)
2126 {
2127   flag_unsafe_math_optimizations = set;
2128   set_unsafe_math_optimizations_flags (set);
2129   flag_finite_math_only = set;
2130   flag_errno_math = !set;
2131   if (set)
2132     {
2133       flag_signaling_nans = 0;
2134       flag_rounding_math = 0;
2135       flag_cx_limited_range = 1;
2136     }
2137 }
2138
2139 /* When -funsafe-math-optimizations is set the following 
2140    flags are set as well.  */ 
2141 void
2142 set_unsafe_math_optimizations_flags (int set)
2143 {
2144   flag_trapping_math = !set;
2145   flag_signed_zeros = !set;
2146   flag_associative_math = set;
2147   flag_reciprocal_math = set;
2148 }
2149
2150 /* Return true iff flags are set as if -ffast-math.  */
2151 bool
2152 fast_math_flags_set_p (void)
2153 {
2154   return (!flag_trapping_math
2155           && flag_unsafe_math_optimizations
2156           && flag_finite_math_only
2157           && !flag_signed_zeros
2158           && !flag_errno_math);
2159 }
2160
2161 /* Return true iff flags are set as if -ffast-math but using the flags stored
2162    in the struct cl_optimization structure.  */
2163 bool
2164 fast_math_flags_struct_set_p (struct cl_optimization *opt)
2165 {
2166   return (!opt->flag_trapping_math
2167           && opt->flag_unsafe_math_optimizations
2168           && opt->flag_finite_math_only
2169           && !opt->flag_signed_zeros
2170           && !opt->flag_errno_math);
2171 }
2172
2173 /* Handle a debug output -g switch.  EXTENDED is true or false to support
2174    extended output (2 is special and means "-ggdb" was given).  */
2175 static void
2176 set_debug_level (enum debug_info_type type, int extended, const char *arg)
2177 {
2178   static bool type_explicit;
2179
2180   use_gnu_debug_info_extensions = extended;
2181
2182   if (type == NO_DEBUG)
2183     {
2184       if (write_symbols == NO_DEBUG)
2185         {
2186           write_symbols = PREFERRED_DEBUGGING_TYPE;
2187
2188           if (extended == 2)
2189             {
2190 #ifdef DWARF2_DEBUGGING_INFO
2191               write_symbols = DWARF2_DEBUG;
2192 #elif defined DBX_DEBUGGING_INFO
2193               write_symbols = DBX_DEBUG;
2194 #endif
2195             }
2196
2197           if (write_symbols == NO_DEBUG)
2198             warning (0, "target system does not support debug output");
2199         }
2200     }
2201   else
2202     {
2203       /* Does it conflict with an already selected type?  */
2204       if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols)
2205         error ("debug format \"%s\" conflicts with prior selection",
2206                debug_type_names[type]);
2207       write_symbols = type;
2208       type_explicit = true;
2209     }
2210
2211   /* A debug flag without a level defaults to level 2.  */
2212   if (*arg == '\0')
2213     {
2214       if (!debug_info_level)
2215         debug_info_level = 2;
2216     }
2217   else
2218     {
2219       debug_info_level = integral_argument (arg);
2220       if (debug_info_level == (unsigned int) -1)
2221         error ("unrecognised debug output level \"%s\"", arg);
2222       else if (debug_info_level > 3)
2223         error ("debug output level %s is too high", arg);
2224     }
2225 }
2226
2227 /* Return 1 if OPTION is enabled, 0 if it is disabled, or -1 if it isn't
2228    a simple on-off switch.  */
2229
2230 int
2231 option_enabled (int opt_idx)
2232 {
2233   const struct cl_option *option = &(cl_options[opt_idx]);
2234
2235   if (option->flag_var)
2236     switch (option->var_type)
2237       {
2238       case CLVC_BOOLEAN:
2239         return *(int *) option->flag_var != 0;
2240
2241       case CLVC_EQUAL:
2242         return *(int *) option->flag_var == option->var_value;
2243
2244       case CLVC_BIT_CLEAR:
2245         return (*(int *) option->flag_var & option->var_value) == 0;
2246
2247       case CLVC_BIT_SET:
2248         return (*(int *) option->flag_var & option->var_value) != 0;
2249
2250       case CLVC_STRING:
2251         break;
2252       }
2253   return -1;
2254 }
2255
2256 /* Fill STATE with the current state of option OPTION.  Return true if
2257    there is some state to store.  */
2258
2259 bool
2260 get_option_state (int option, struct cl_option_state *state)
2261 {
2262   if (cl_options[option].flag_var == 0)
2263     return false;
2264
2265   switch (cl_options[option].var_type)
2266     {
2267     case CLVC_BOOLEAN:
2268     case CLVC_EQUAL:
2269       state->data = cl_options[option].flag_var;
2270       state->size = sizeof (int);
2271       break;
2272
2273     case CLVC_BIT_CLEAR:
2274     case CLVC_BIT_SET:
2275       state->ch = option_enabled (option);
2276       state->data = &state->ch;
2277       state->size = 1;
2278       break;
2279
2280     case CLVC_STRING:
2281       state->data = *(const char **) cl_options[option].flag_var;
2282       if (state->data == 0)
2283         state->data = "";
2284       state->size = strlen ((const char *) state->data) + 1;
2285       break;
2286     }
2287   return true;
2288 }
2289
2290 /* Enable a warning option as an error.  This is used by -Werror= and
2291    also by legacy Werror-implicit-function-declaration.  */
2292
2293 void
2294 enable_warning_as_error (const char *arg, int value, unsigned int lang_mask)
2295 {
2296   char *new_option;
2297   int option_index;
2298
2299   new_option = XNEWVEC (char, strlen (arg) + 2);
2300   new_option[0] = 'W';
2301   strcpy (new_option + 1, arg);
2302   option_index = find_opt (new_option, lang_mask);
2303   if (option_index == N_OPTS)
2304     {
2305       error ("-Werror=%s: No option -%s", arg, new_option);
2306     }
2307   else
2308     {
2309       int kind = value ? DK_ERROR : DK_WARNING;
2310       diagnostic_classify_diagnostic (global_dc, option_index, kind);
2311       
2312       /* -Werror=foo implies -Wfoo.  */
2313       if (cl_options[option_index].var_type == CLVC_BOOLEAN
2314           && cl_options[option_index].flag_var
2315           && kind == DK_ERROR)
2316         *(int *) cl_options[option_index].flag_var = 1;
2317     }
2318   free (new_option);
2319 }