OSDN Git Service

0009a749daee1ec6180ed52c17e800b0ff0c04e2
[pf3gnuchains/gcc-fork.git] / gcc / opts.c
1 /* Command line option handling.
2    Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
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 #include "plugin.h"
46 #include "except.h"
47 #include "lto-streamer.h"
48
49 /* Value of the -G xx switch, and whether it was passed or not.  */
50 unsigned HOST_WIDE_INT g_switch_value;
51 bool g_switch_set;
52
53 /* Same for selective scheduling.  */
54 bool sel_sched_switch_set;
55
56 /* True if we should exit after parsing options.  */
57 bool exit_after_options;
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 static const char undocumented_msg[] = N_("This switch lacks documentation");
342
343 /* Used for bookkeeping on whether user set these flags so
344    -fprofile-use/-fprofile-generate does not use them.  */
345 static bool profile_arc_flag_set, flag_profile_values_set;
346 static bool flag_unroll_loops_set, flag_tracer_set;
347 static bool flag_value_profile_transformations_set;
348 static bool flag_peel_loops_set, flag_branch_probabilities_set;
349 static bool flag_inline_functions_set, flag_ipa_cp_set, flag_ipa_cp_clone_set;
350 static bool flag_predictive_commoning_set, flag_unswitch_loops_set, flag_gcse_after_reload_set;
351
352 /* Functions excluded from profiling.  */
353
354 typedef char *char_p; /* For DEF_VEC_P.  */
355 DEF_VEC_P(char_p);
356 DEF_VEC_ALLOC_P(char_p,heap);
357
358 static VEC(char_p,heap) *flag_instrument_functions_exclude_functions;
359 static VEC(char_p,heap) *flag_instrument_functions_exclude_files;
360
361 typedef const char *const_char_p; /* For DEF_VEC_P.  */
362 DEF_VEC_P(const_char_p);
363 DEF_VEC_ALLOC_P(const_char_p,heap);
364
365 static VEC(const_char_p,heap) *ignored_options;
366
367 /* Language specific warning pass for unused results.  */
368 bool flag_warn_unused_result = false;
369
370 /* Input file names.  */
371 const char **in_fnames;
372 unsigned num_in_fnames;
373
374 static int common_handle_option (size_t scode, const char *arg, int value,
375                                  unsigned int lang_mask);
376 static void handle_param (const char *);
377 static unsigned int handle_option (const char **argv, unsigned int lang_mask);
378 static char *write_langs (unsigned int lang_mask);
379 static void complain_wrong_lang (const char *, const struct cl_option *,
380                                  unsigned int lang_mask);
381 static void handle_options (unsigned int, const char **, unsigned int);
382 static void set_debug_level (enum debug_info_type type, int extended,
383                              const char *arg);
384
385 /* If ARG is a non-negative integer made up solely of digits, return its
386    value, otherwise return -1.  */
387 static int
388 integral_argument (const char *arg)
389 {
390   const char *p = arg;
391
392   while (*p && ISDIGIT (*p))
393     p++;
394
395   if (*p == '\0')
396     return atoi (arg);
397
398   return -1;
399 }
400
401 /* Return a malloced slash-separated list of languages in MASK.  */
402 static char *
403 write_langs (unsigned int mask)
404 {
405   unsigned int n = 0, len = 0;
406   const char *lang_name;
407   char *result;
408
409   for (n = 0; (lang_name = lang_names[n]) != 0; n++)
410     if (mask & (1U << n))
411       len += strlen (lang_name) + 1;
412
413   result = XNEWVEC (char, len);
414   len = 0;
415   for (n = 0; (lang_name = lang_names[n]) != 0; n++)
416     if (mask & (1U << n))
417       {
418         if (len)
419           result[len++] = '/';
420         strcpy (result + len, lang_name);
421         len += strlen (lang_name);
422       }
423
424   result[len] = 0;
425
426   return result;
427 }
428
429 /* Complain that switch OPT_INDEX does not apply to this front end.  */
430 static void
431 complain_wrong_lang (const char *text, const struct cl_option *option,
432                      unsigned int lang_mask)
433 {
434   char *ok_langs, *bad_lang;
435
436   /* The LTO front end inherits all the options from the first front
437      end that was used.  However, not all the original front end
438      options make sense in LTO.
439
440      A real solution would be to filter this in collect2, but collect2
441      does not have access to all the option attributes to know what to
442      filter.  So, in lto1 we silently accept inherited flags and do
443      nothing about it.  */
444   if (lang_mask & CL_LTO)
445     return;
446
447   ok_langs = write_langs (option->flags);
448   bad_lang = write_langs (lang_mask);
449
450   /* Eventually this should become a hard error IMO.  */
451   warning (0, "command line option \"%s\" is valid for %s but not for %s",
452            text, ok_langs, bad_lang);
453
454   free (ok_langs);
455   free (bad_lang);
456 }
457
458 /* Buffer the unknown option described by the string OPT.  Currently,
459    we only complain about unknown -Wno-* options if they may have
460    prevented a diagnostic. Otherwise, we just ignore them.
461    Note that if we do complain, it is only as a warning, not an error;
462    passing the compiler an unrecognised -Wno-* option should never
463    change whether the compilation succeeds or fails.  */
464
465 static void postpone_unknown_option_warning(const char *opt)
466 {
467   VEC_safe_push (const_char_p, heap, ignored_options, opt);
468 }
469
470 /* Produce a warning for each option previously buffered.  */
471
472 void print_ignored_options (void)
473 {
474   location_t saved_loc = input_location;
475
476   input_location = 0;
477
478   while (!VEC_empty (const_char_p, ignored_options))
479     {
480       const char *opt;
481       opt = VEC_pop (const_char_p, ignored_options);
482       warning (0, "unrecognized command line option \"%s\"", opt);
483     }
484
485   input_location = saved_loc;
486 }
487
488 /* Handle the switch beginning at ARGV for the language indicated by
489    LANG_MASK.  Returns the number of switches consumed.  */
490 static unsigned int
491 handle_option (const char **argv, unsigned int lang_mask)
492 {
493   size_t opt_index;
494   const char *opt, *arg = 0;
495   char *dup = 0;
496   int value = 1;
497   unsigned int result = 0;
498   const struct cl_option *option;
499
500   opt = argv[0];
501
502   opt_index = find_opt (opt + 1, lang_mask | CL_COMMON | CL_TARGET);
503   if (opt_index == cl_options_count
504       && (opt[1] == 'W' || opt[1] == 'f' || opt[1] == 'm')
505       && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-')
506     {
507       /* Drop the "no-" from negative switches.  */
508       size_t len = strlen (opt) - 3;
509
510       dup = XNEWVEC (char, len + 1);
511       dup[0] = '-';
512       dup[1] = opt[1];
513       memcpy (dup + 2, opt + 5, len - 2 + 1);
514       opt = dup;
515       value = 0;
516       opt_index = find_opt (opt + 1, lang_mask | CL_COMMON | CL_TARGET);
517       if (opt_index == cl_options_count && opt[1] == 'W')
518         {
519           /* We don't generate warnings for unknown -Wno-* options
520              unless we issue diagnostics.  */
521           postpone_unknown_option_warning (argv[0]);
522           result = 1;
523           goto done;
524         }
525     }
526
527   if (opt_index == cl_options_count)
528     goto done;
529
530   option = &cl_options[opt_index];
531
532   /* Reject negative form of switches that don't take negatives as
533      unrecognized.  */
534   if (!value && (option->flags & CL_REJECT_NEGATIVE))
535     goto done;
536
537   /* We've recognized this switch.  */
538   result = 1;
539
540   /* Check to see if the option is disabled for this configuration.  */
541   if (option->flags & CL_DISABLED)
542     {
543       error ("command line option %qs"
544              " is not supported by this configuration", opt);
545       goto done;
546     }
547
548   /* Sort out any argument the switch takes.  */
549   if (option->flags & CL_JOINED)
550     {
551       /* Have arg point to the original switch.  This is because
552          some code, such as disable_builtin_function, expects its
553          argument to be persistent until the program exits.  */
554       arg = argv[0] + cl_options[opt_index].opt_len + 1;
555       if (!value)
556         arg += strlen ("no-");
557
558       if (*arg == '\0' && !(option->flags & CL_MISSING_OK))
559         {
560           if (option->flags & CL_SEPARATE)
561             {
562               arg = argv[1];
563               result = 2;
564             }
565           else
566             /* Missing argument.  */
567             arg = NULL;
568         }
569     }
570   else if (option->flags & CL_SEPARATE)
571     {
572       arg = argv[1];
573       result = 2;
574     }
575
576   /* Now we've swallowed any potential argument, complain if this
577      is a switch for a different front end.  */
578   if (!(option->flags & (lang_mask | CL_COMMON | CL_TARGET)))
579     {
580       complain_wrong_lang (argv[0], option, lang_mask);
581       goto done;
582     }
583   else if ((option->flags & CL_TARGET)
584            && (option->flags & CL_LANG_ALL)
585            && !(option->flags & lang_mask))
586     {
587       /* Complain for target flag language mismatches if any languages
588          are specified.  */
589       complain_wrong_lang (argv[0], option, lang_mask);
590       goto done;
591     }
592
593   if (arg == NULL && (option->flags & (CL_JOINED | CL_SEPARATE)))
594     {
595       if (!lang_hooks.missing_argument (opt, opt_index))
596         error ("missing argument to \"%s\"", opt);
597       goto done;
598     }
599
600   /* If the switch takes an integer, convert it.  */
601   if (arg && (option->flags & CL_UINTEGER))
602     {
603       value = integral_argument (arg);
604       if (value == -1)
605         {
606           error ("argument to \"%s\" should be a non-negative integer",
607                  option->opt_text);
608           goto done;
609         }
610     }
611
612   if (option->flag_var)
613     set_option (option, value, arg);
614
615   if (option->flags & lang_mask)
616     {
617       if (lang_hooks.handle_option (opt_index, arg, value) == 0)
618         result = 0;
619       else
620         lto_register_user_option (opt_index, arg, value, lang_mask);
621     }
622
623   if (result && (option->flags & CL_COMMON))
624     {
625       if (common_handle_option (opt_index, arg, value, lang_mask) == 0)
626         result = 0;
627       else
628         lto_register_user_option (opt_index, arg, value, CL_COMMON);
629     }
630
631   if (result && (option->flags & CL_TARGET))
632     {
633       if (!targetm.handle_option (opt_index, arg, value))
634         result = 0;
635       else
636         lto_register_user_option (opt_index, arg, value, CL_TARGET);
637     }
638
639  done:
640   if (dup)
641     free (dup);
642   return result;
643 }
644
645 /* Handle FILENAME from the command line.  */
646 static void
647 add_input_filename (const char *filename)
648 {
649   num_in_fnames++;
650   in_fnames = XRESIZEVEC (const char *, in_fnames, num_in_fnames);
651   in_fnames[num_in_fnames - 1] = filename;
652 }
653
654 /* Add comma-separated strings to a char_p vector.  */
655
656 static void
657 add_comma_separated_to_vector (VEC(char_p,heap) **pvec, const char* arg)
658 {
659   char *tmp;
660   char *r;
661   char *w;
662   char *token_start;
663
664   /* We never free this string.  */
665   tmp = xstrdup (arg);
666
667   r = tmp;
668   w = tmp;
669   token_start = tmp;
670
671   while (*r != '\0')
672     {
673       if (*r == ',')
674         {
675           *w++ = '\0';
676           ++r;
677           VEC_safe_push (char_p, heap, *pvec, token_start);
678           token_start = w;
679         }
680       if (*r == '\\' && r[1] == ',')
681         {
682           *w++ = ',';
683           r += 2;
684         }
685       else
686         *w++ = *r++;
687     }
688   if (*token_start != '\0')
689     VEC_safe_push (char_p, heap, *pvec, token_start);
690 }
691
692 /* Return whether we should exclude FNDECL from instrumentation.  */
693
694 bool
695 flag_instrument_functions_exclude_p (tree fndecl)
696 {
697   if (VEC_length (char_p, flag_instrument_functions_exclude_functions) > 0)
698     {
699       const char *name;
700       int i;
701       char *s;
702
703       name = lang_hooks.decl_printable_name (fndecl, 0);
704       for (i = 0;
705            VEC_iterate (char_p, flag_instrument_functions_exclude_functions,
706                         i, s);
707            ++i)
708         {
709           if (strstr (name, s) != NULL)
710             return true;
711         }
712     }
713
714   if (VEC_length (char_p, flag_instrument_functions_exclude_files) > 0)
715     {
716       const char *name;
717       int i;
718       char *s;
719
720       name = DECL_SOURCE_FILE (fndecl);
721       for (i = 0;
722            VEC_iterate (char_p, flag_instrument_functions_exclude_files, i, s);
723            ++i)
724         {
725           if (strstr (name, s) != NULL)
726             return true;
727         }
728     }
729
730   return false;
731 }
732
733
734 /* Decode and handle the vector of command line options.  LANG_MASK
735    contains has a single bit set representing the current
736    language.  */
737 static void
738 handle_options (unsigned int argc, const char **argv, unsigned int lang_mask)
739 {
740   unsigned int n, i;
741
742   for (i = 1; i < argc; i += n)
743     {
744       const char *opt = argv[i];
745
746       /* Interpret "-" or a non-switch as a file name.  */
747       if (opt[0] != '-' || opt[1] == '\0')
748         {
749           if (main_input_filename == NULL)
750             {
751               main_input_filename = opt;
752               main_input_baselength
753                 = base_of_path (main_input_filename, &main_input_basename);
754             }
755           add_input_filename (opt);
756           n = 1;
757           continue;
758         }
759
760       n = handle_option (argv + i, lang_mask);
761
762       if (!n)
763         {
764           n = 1;
765           error ("unrecognized command line option \"%s\"", opt);
766         }
767     }
768 }
769
770 /* Parse command line options and set default flag values.  Do minimal
771    options processing.  */
772 void
773 decode_options (unsigned int argc, const char **argv)
774 {
775   static bool first_time_p = true;
776   static int initial_min_crossjump_insns;
777   static int initial_max_fields_for_field_sensitive;
778   static int initial_loop_invariant_max_bbs_in_loop;
779   static unsigned int initial_lang_mask;
780
781   unsigned int i, lang_mask;
782   int opt1;
783   int opt2;
784   int opt3;
785   int opt1_max;
786
787   if (first_time_p)
788     {
789       /* Perform language-specific options initialization.  */
790       initial_lang_mask = lang_mask = lang_hooks.init_options (argc, argv);
791
792       lang_hooks.initialize_diagnostics (global_dc);
793
794       /* Save initial values of parameters we reset.  */
795       initial_min_crossjump_insns
796         = compiler_params[PARAM_MIN_CROSSJUMP_INSNS].value;
797       initial_max_fields_for_field_sensitive
798         = compiler_params[PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE].value;
799       initial_loop_invariant_max_bbs_in_loop
800         = compiler_params[PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP].value;
801     }
802   else
803     lang_mask = initial_lang_mask;
804
805   /* Scan to see what optimization level has been specified.  That will
806      determine the default value of many flags.  */
807   for (i = 1; i < argc; i++)
808     {
809       if (!strcmp (argv[i], "-O"))
810         {
811           optimize = 1;
812           optimize_size = 0;
813         }
814       else if (argv[i][0] == '-' && argv[i][1] == 'O')
815         {
816           /* Handle -Os, -O2, -O3, -O69, ...  */
817           const char *p = &argv[i][2];
818
819           if ((p[0] == 's') && (p[1] == 0))
820             {
821               optimize_size = 1;
822
823               /* Optimizing for size forces optimize to be 2.  */
824               optimize = 2;
825             }
826           else
827             {
828               const int optimize_val = read_integral_parameter (p, p - 2, -1);
829               if (optimize_val != -1)
830                 {
831                   optimize = optimize_val;
832                   if ((unsigned int) optimize > 255)
833                     optimize = 255;
834                   optimize_size = 0;
835                 }
836             }
837         }
838     }
839
840   /* Use priority coloring if cover classes is not defined for the
841      target.  */
842   if (targetm.ira_cover_classes == NULL)
843     flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
844
845   /* -O1 optimizations.  */
846   opt1 = (optimize >= 1);
847   flag_defer_pop = opt1;
848 #ifdef DELAY_SLOTS
849   flag_delayed_branch = opt1;
850 #endif
851 #ifdef CAN_DEBUG_WITHOUT_FP
852   flag_omit_frame_pointer = opt1;
853 #endif
854   flag_guess_branch_prob = opt1;
855   flag_cprop_registers = opt1;
856   flag_forward_propagate = opt1;
857   flag_if_conversion = opt1;
858   flag_if_conversion2 = opt1;
859   flag_ipa_pure_const = opt1;
860   flag_ipa_reference = opt1;
861   flag_merge_constants = opt1;
862   flag_split_wide_types = opt1;
863   flag_tree_ccp = opt1;
864   flag_tree_dce = opt1;
865   flag_tree_dom = opt1;
866   flag_tree_dse = opt1;
867   flag_tree_ter = opt1;
868   flag_tree_sra = opt1;
869   flag_tree_copyrename = opt1;
870   flag_tree_fre = opt1;
871   flag_tree_copy_prop = opt1;
872   flag_tree_sink = opt1;
873   flag_tree_ch = opt1;
874
875   /* -O2 optimizations.  */
876   opt2 = (optimize >= 2);
877   flag_inline_small_functions = opt2;
878   flag_indirect_inlining = opt2;
879   flag_thread_jumps = opt2;
880   flag_crossjumping = opt2;
881   flag_optimize_sibling_calls = opt2;
882   flag_cse_follow_jumps = opt2;
883   flag_gcse = opt2;
884   flag_expensive_optimizations = opt2;
885   flag_rerun_cse_after_loop = opt2;
886   flag_caller_saves = opt2;
887   flag_peephole2 = opt2;
888 #ifdef INSN_SCHEDULING
889   /* Only run the pre-regalloc scheduling pass if optimizing for speed.  */
890   flag_schedule_insns = opt2 && ! optimize_size;
891   flag_schedule_insns_after_reload = opt2;
892 #endif
893   flag_regmove = opt2;
894   flag_strict_aliasing = opt2;
895   flag_strict_overflow = opt2;
896   flag_reorder_blocks = opt2;
897   flag_reorder_functions = opt2;
898   flag_tree_vrp = opt2;
899   flag_tree_builtin_call_dce = opt2;
900   flag_tree_pre = opt2;
901   flag_tree_switch_conversion = opt2;
902   flag_ipa_cp = opt2;
903   flag_ipa_sra = 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   /* Clear any options currently held for LTO.  */
965   lto_clear_user_options ();
966
967 #ifdef OPTIMIZATION_OPTIONS
968   /* Allow default optimizations to be specified on a per-machine basis.  */
969   OPTIMIZATION_OPTIONS (optimize, optimize_size);
970 #endif
971
972   handle_options (argc, argv, lang_mask);
973
974   if (dump_base_name && ! IS_ABSOLUTE_PATH (dump_base_name))
975     {
976       /* First try to make DUMP_BASE_NAME relative to the DUMP_DIR_NAME
977          directory.  Then try to make DUMP_BASE_NAME relative to the
978          AUX_BASE_NAME directory, typically the directory to contain
979          the object file.  */
980       if (dump_dir_name)
981         dump_base_name = concat (dump_dir_name, dump_base_name, NULL);
982       else if (aux_base_name)
983         {
984           const char *aux_base;
985
986           base_of_path (aux_base_name, &aux_base);
987           if (aux_base_name != aux_base)
988             {
989               int dir_len = aux_base - aux_base_name;
990               char *new_dump_base_name =
991                 XNEWVEC (char, strlen(dump_base_name) + dir_len + 1);
992
993               /* Copy directory component from AUX_BASE_NAME.  */
994               memcpy (new_dump_base_name, aux_base_name, dir_len);
995               /* Append existing DUMP_BASE_NAME.  */
996               strcpy (new_dump_base_name + dir_len, dump_base_name);
997               dump_base_name = new_dump_base_name;
998             }
999         }
1000     }
1001
1002   /* Handle related options for unit-at-a-time, toplevel-reorder, and
1003      section-anchors.  */
1004   if (!flag_unit_at_a_time)
1005     {
1006       if (flag_section_anchors == 1)
1007         error ("Section anchors must be disabled when unit-at-a-time "
1008                "is disabled.");
1009       flag_section_anchors = 0;
1010       if (flag_toplevel_reorder == 1)
1011         error ("Toplevel reorder must be disabled when unit-at-a-time "
1012                "is disabled.");
1013       flag_toplevel_reorder = 0;
1014     }
1015   /* Unless the user has asked for section anchors, we disable toplevel
1016      reordering at -O0 to disable transformations that might be surprising
1017      to end users and to get -fno-toplevel-reorder tested.  */
1018   if (!optimize && flag_toplevel_reorder == 2 && flag_section_anchors != 1)
1019     {
1020       flag_toplevel_reorder = 0;
1021       flag_section_anchors = 0;
1022     }
1023   if (!flag_toplevel_reorder)
1024     {
1025       if (flag_section_anchors == 1)
1026         error ("section anchors must be disabled when toplevel reorder"
1027                " is disabled");
1028       flag_section_anchors = 0;
1029     }
1030
1031   if (first_time_p)
1032     {
1033       if (flag_pie)
1034         flag_pic = flag_pie;
1035       if (flag_pic && !flag_pie)
1036         flag_shlib = 1;
1037       first_time_p = false;
1038     }
1039
1040   if (optimize == 0)
1041     {
1042       /* Inlining does not work if not optimizing,
1043          so force it not to be done.  */
1044       warn_inline = 0;
1045       flag_no_inline = 1;
1046     }
1047
1048   /* The optimization to partition hot and cold basic blocks into separate
1049      sections of the .o and executable files does not work (currently)
1050      with exception handling.  This is because there is no support for
1051      generating unwind info.  If flag_exceptions is turned on we need to
1052      turn off the partitioning optimization.  */
1053
1054   if (flag_exceptions && flag_reorder_blocks_and_partition
1055       && (USING_SJLJ_EXCEPTIONS
1056 #ifdef TARGET_UNWIND_INFO
1057           || 1
1058 #endif
1059          ))
1060     {
1061       inform (input_location,
1062               "-freorder-blocks-and-partition does not work with exceptions on this architecture");
1063       flag_reorder_blocks_and_partition = 0;
1064       flag_reorder_blocks = 1;
1065     }
1066
1067   /* If user requested unwind info, then turn off the partitioning
1068      optimization.  */
1069
1070   if (flag_unwind_tables && ! targetm.unwind_tables_default
1071       && flag_reorder_blocks_and_partition
1072       && (USING_SJLJ_EXCEPTIONS
1073 #ifdef TARGET_UNWIND_INFO
1074           || 1
1075 #endif
1076          ))
1077     {
1078       inform (input_location,
1079               "-freorder-blocks-and-partition does not support unwind info on this architecture");
1080       flag_reorder_blocks_and_partition = 0;
1081       flag_reorder_blocks = 1;
1082     }
1083
1084   /* If the target requested unwind info, then turn off the partitioning
1085      optimization with a different message.  Likewise, if the target does not
1086      support named sections.  */
1087
1088   if (flag_reorder_blocks_and_partition
1089       && (!targetm.have_named_sections
1090           || (flag_unwind_tables && targetm.unwind_tables_default
1091               && (USING_SJLJ_EXCEPTIONS
1092 #ifdef TARGET_UNWIND_INFO
1093                   || 1
1094 #endif
1095                  ))))
1096     {
1097       inform (input_location,
1098               "-freorder-blocks-and-partition does not work on this architecture");
1099       flag_reorder_blocks_and_partition = 0;
1100       flag_reorder_blocks = 1;
1101     }
1102
1103   /* Pipelining of outer loops is only possible when general pipelining
1104      capabilities are requested.  */
1105   if (!flag_sel_sched_pipelining)
1106     flag_sel_sched_pipelining_outer_loops = 0;
1107
1108   if (!targetm.ira_cover_classes
1109       && flag_ira_algorithm == IRA_ALGORITHM_CB)
1110     {
1111       inform (input_location,
1112               "-fira-algorithm=CB does not work on this architecture");
1113       flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
1114     }
1115
1116   if (flag_conserve_stack)
1117     {
1118       if (!PARAM_SET_P (PARAM_LARGE_STACK_FRAME))
1119         PARAM_VALUE (PARAM_LARGE_STACK_FRAME) = 100;
1120       if (!PARAM_SET_P (PARAM_STACK_FRAME_GROWTH))
1121         PARAM_VALUE (PARAM_STACK_FRAME_GROWTH) = 40;
1122     }
1123   if (flag_wpa || flag_ltrans)
1124     {
1125       /* These passes are not WHOPR compatible yet.  */
1126       flag_ipa_cp = 0;
1127       flag_ipa_reference = 0;
1128       flag_ipa_type_escape = 0;
1129       flag_ipa_pta = 0;
1130       flag_ipa_struct_reorg = 0;
1131     }
1132
1133   if (flag_lto || flag_whopr)
1134     {
1135 #ifdef ENABLE_LTO
1136       flag_generate_lto = 1;
1137
1138       /* When generating IL, do not operate in whole-program mode.
1139          Otherwise, symbols will be privatized too early, causing link
1140          errors later.  */
1141       flag_whole_program = 0;
1142 #else
1143       error ("LTO support has not been enabled in this configuration");
1144 #endif
1145     }
1146
1147   /* Reconcile -flto and -fwhopr.  Set additional flags as appropriate and
1148      check option consistency.  */
1149   if (flag_lto && flag_whopr)
1150     error ("-flto and -fwhopr are mutually exclusive");
1151 }
1152
1153 #define LEFT_COLUMN     27
1154
1155 /* Output ITEM, of length ITEM_WIDTH, in the left column,
1156    followed by word-wrapped HELP in a second column.  */
1157 static void
1158 wrap_help (const char *help,
1159            const char *item,
1160            unsigned int item_width,
1161            unsigned int columns)
1162 {
1163   unsigned int col_width = LEFT_COLUMN;
1164   unsigned int remaining, room, len;
1165
1166   remaining = strlen (help);
1167
1168   do
1169     {
1170       room = columns - 3 - MAX (col_width, item_width);
1171       if (room > columns)
1172         room = 0;
1173       len = remaining;
1174
1175       if (room < len)
1176         {
1177           unsigned int i;
1178
1179           for (i = 0; help[i]; i++)
1180             {
1181               if (i >= room && len != remaining)
1182                 break;
1183               if (help[i] == ' ')
1184                 len = i;
1185               else if ((help[i] == '-' || help[i] == '/')
1186                        && help[i + 1] != ' '
1187                        && i > 0 && ISALPHA (help[i - 1]))
1188                 len = i + 1;
1189             }
1190         }
1191
1192       printf( "  %-*.*s %.*s\n", col_width, item_width, item, len, help);
1193       item_width = 0;
1194       while (help[len] == ' ')
1195         len++;
1196       help += len;
1197       remaining -= len;
1198     }
1199   while (remaining);
1200 }
1201
1202 /* Print help for a specific front-end, etc.  */
1203 static void
1204 print_filtered_help (unsigned int include_flags,
1205                      unsigned int exclude_flags,
1206                      unsigned int any_flags,
1207                      unsigned int columns)
1208 {
1209   unsigned int i;
1210   const char *help;
1211   static char *printed = NULL;
1212   bool found = false;
1213   bool displayed = false;
1214
1215   if (include_flags == CL_PARAMS)
1216     {
1217       for (i = 0; i < LAST_PARAM; i++)
1218         {
1219           const char *param = compiler_params[i].option;
1220
1221           help = compiler_params[i].help;
1222           if (help == NULL || *help == '\0')
1223             {
1224               if (exclude_flags & CL_UNDOCUMENTED)
1225                 continue;
1226               help = undocumented_msg;
1227             }
1228
1229           /* Get the translation.  */
1230           help = _(help);
1231
1232           wrap_help (help, param, strlen (param), columns);
1233         }
1234       putchar ('\n');
1235       return;
1236     }
1237
1238   if (!printed)
1239     printed = XCNEWVAR (char, cl_options_count);
1240
1241   for (i = 0; i < cl_options_count; i++)
1242     {
1243       static char new_help[128];
1244       const struct cl_option *option = cl_options + i;
1245       unsigned int len;
1246       const char *opt;
1247       const char *tab;
1248
1249       if (include_flags == 0
1250           || ((option->flags & include_flags) != include_flags))
1251         {
1252           if ((option->flags & any_flags) == 0)
1253             continue;
1254         }
1255
1256       /* Skip unwanted switches.  */
1257       if ((option->flags & exclude_flags) != 0)
1258         continue;
1259
1260       found = true;
1261       /* Skip switches that have already been printed.  */
1262       if (printed[i])
1263         continue;
1264
1265       printed[i] = true;
1266
1267       help = option->help;
1268       if (help == NULL)
1269         {
1270           if (exclude_flags & CL_UNDOCUMENTED)
1271             continue;
1272           help = undocumented_msg;
1273         }
1274
1275       /* Get the translation.  */
1276       help = _(help);
1277
1278       /* Find the gap between the name of the
1279          option and its descriptive text.  */
1280       tab = strchr (help, '\t');
1281       if (tab)
1282         {
1283           len = tab - help;
1284           opt = help;
1285           help = tab + 1;
1286         }
1287       else
1288         {
1289           opt = option->opt_text;
1290           len = strlen (opt);
1291         }
1292
1293       /* With the -Q option enabled we change the descriptive text associated
1294          with an option to be an indication of its current setting.  */
1295       if (!quiet_flag)
1296         {
1297           if (len < (LEFT_COLUMN + 2))
1298             strcpy (new_help, "\t\t");
1299           else
1300             strcpy (new_help, "\t");
1301
1302           if (option->flag_var != NULL)
1303             {
1304               if (option->flags & CL_JOINED)
1305                 {
1306                   if (option->var_type == CLVC_STRING)
1307                     {
1308                       if (* (const char **) option->flag_var != NULL)
1309                         snprintf (new_help + strlen (new_help),
1310                                   sizeof (new_help) - strlen (new_help),
1311                                   * (const char **) option->flag_var);
1312                     }
1313                   else
1314                     sprintf (new_help + strlen (new_help),
1315                              "%#x", * (int *) option->flag_var);
1316                 }
1317               else
1318                 strcat (new_help, option_enabled (i)
1319                         ? _("[enabled]") : _("[disabled]"));
1320             }
1321
1322           help = new_help;
1323         }
1324
1325       wrap_help (help, opt, len, columns);
1326       displayed = true;
1327     }
1328
1329   if (! found)
1330     {
1331       unsigned int langs = include_flags & CL_LANG_ALL;
1332
1333       if (langs == 0)
1334         printf (_(" No options with the desired characteristics were found\n"));
1335       else
1336         {
1337           unsigned int i;
1338
1339           /* PR 31349: Tell the user how to see all of the
1340              options supported by a specific front end.  */
1341           for (i = 0; (1U << i) < CL_LANG_ALL; i ++)
1342             if ((1U << i) & langs)
1343               printf (_(" None found.  Use --help=%s to show *all* the options supported by the %s front-end\n"),
1344                       lang_names[i], lang_names[i]);
1345         }
1346
1347     }
1348   else if (! displayed)
1349     printf (_(" All options with the desired characteristics have already been displayed\n"));
1350
1351   putchar ('\n');
1352 }
1353
1354 /* Display help for a specified type of option.
1355    The options must have ALL of the INCLUDE_FLAGS set
1356    ANY of the flags in the ANY_FLAGS set
1357    and NONE of the EXCLUDE_FLAGS set.  */
1358 static void
1359 print_specific_help (unsigned int include_flags,
1360                      unsigned int exclude_flags,
1361                      unsigned int any_flags)
1362 {
1363   unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1364   const char * description = NULL;
1365   const char * descrip_extra = "";
1366   size_t i;
1367   unsigned int flag;
1368   static unsigned int columns = 0;
1369
1370   /* Sanity check: Make sure that we do not have more
1371      languages than we have bits available to enumerate them.  */
1372   gcc_assert ((1U << cl_lang_count) < CL_MIN_OPTION_CLASS);
1373
1374   /* If we have not done so already, obtain
1375      the desired maximum width of the output.  */
1376   if (columns == 0)
1377     {
1378       const char *p;
1379
1380       GET_ENVIRONMENT (p, "COLUMNS");
1381       if (p != NULL)
1382         {
1383           int value = atoi (p);
1384
1385           if (value > 0)
1386             columns = value;
1387         }
1388
1389       if (columns == 0)
1390         /* Use a reasonable default.  */
1391         columns = 80;
1392     }
1393
1394   /* Decide upon the title for the options that we are going to display.  */
1395   for (i = 0, flag = 1; flag <= CL_MAX_OPTION_CLASS; flag <<= 1, i ++)
1396     {
1397       switch (flag & include_flags)
1398         {
1399         case 0:
1400           break;
1401
1402         case CL_TARGET:
1403           description = _("The following options are target specific");
1404           break;
1405         case CL_WARNING:
1406           description = _("The following options control compiler warning messages");
1407           break;
1408         case CL_OPTIMIZATION:
1409           description = _("The following options control optimizations");
1410           break;
1411         case CL_COMMON:
1412           description = _("The following options are language-independent");
1413           break;
1414         case CL_PARAMS:
1415           description = _("The --param option recognizes the following as parameters");
1416           break;
1417         default:
1418           if (i >= cl_lang_count)
1419             break;
1420           if (exclude_flags & all_langs_mask)
1421             description = _("The following options are specific to just the language ");
1422           else
1423             description = _("The following options are supported by the language ");
1424           descrip_extra = lang_names [i];
1425           break;
1426         }
1427     }
1428
1429   if (description == NULL)
1430     {
1431       if (any_flags == 0)
1432         {
1433           if (include_flags & CL_UNDOCUMENTED)
1434             description = _("The following options are not documented");
1435           else if (include_flags & CL_SEPARATE)
1436             description = _("The following options take separate arguments");
1437           else if (include_flags & CL_JOINED)
1438             description = _("The following options take joined arguments");
1439           else
1440             {
1441               internal_error ("unrecognized include_flags 0x%x passed to print_specific_help",
1442                               include_flags);
1443               return;
1444             }
1445         }
1446       else
1447         {
1448           if (any_flags & all_langs_mask)
1449             description = _("The following options are language-related");
1450           else
1451             description = _("The following options are language-independent");
1452         }
1453     }
1454
1455   printf ("%s%s:\n", description, descrip_extra);
1456   print_filtered_help (include_flags, exclude_flags, any_flags, columns);
1457 }
1458
1459 /* Handle target- and language-independent options.  Return zero to
1460    generate an "unknown option" message.  Only options that need
1461    extra handling need to be listed here; if you simply want
1462    VALUE assigned to a variable, it happens automatically.  */
1463
1464 static int
1465 common_handle_option (size_t scode, const char *arg, int value,
1466                       unsigned int lang_mask)
1467 {
1468   static bool verbose = false;
1469   enum opt_code code = (enum opt_code) scode;
1470
1471   switch (code)
1472     {
1473     case OPT__param:
1474       handle_param (arg);
1475       break;
1476
1477     case OPT_v:
1478       verbose = true;
1479       break;
1480
1481     case OPT_fhelp:
1482     case OPT__help:
1483       {
1484         unsigned int all_langs_mask = (1U << cl_lang_count) - 1;
1485         unsigned int undoc_mask;
1486         unsigned int i;
1487
1488         undoc_mask = (verbose | extra_warnings) ? 0 : CL_UNDOCUMENTED;
1489         /* First display any single language specific options.  */
1490         for (i = 0; i < cl_lang_count; i++)
1491           print_specific_help
1492             (1U << i, (all_langs_mask & (~ (1U << i))) | undoc_mask, 0);
1493         /* Next display any multi language specific options.  */
1494         print_specific_help (0, undoc_mask, all_langs_mask);
1495         /* Then display any remaining, non-language options.  */
1496         for (i = CL_MIN_OPTION_CLASS; i <= CL_MAX_OPTION_CLASS; i <<= 1)
1497           print_specific_help (i, undoc_mask, 0);
1498         exit_after_options = true;
1499         break;
1500       }
1501
1502     case OPT_ftarget_help:
1503     case OPT__target_help:
1504       print_specific_help (CL_TARGET, CL_UNDOCUMENTED, 0);
1505       exit_after_options = true;
1506
1507       /* Allow the target a chance to give the user some additional information.  */
1508       if (targetm.target_help)
1509         targetm.target_help ();
1510       break;
1511
1512     case OPT_fhelp_:
1513     case OPT__help_:
1514       {
1515         const char * a = arg;
1516         unsigned int include_flags = 0;
1517         /* Note - by default we include undocumented options when listing
1518            specific classes.  If you only want to see documented options
1519            then add ",^undocumented" to the --help= option.  E.g.:
1520
1521            --help=target,^undocumented  */
1522         unsigned int exclude_flags = 0;
1523
1524         /* Walk along the argument string, parsing each word in turn.
1525            The format is:
1526            arg = [^]{word}[,{arg}]
1527            word = {optimizers|target|warnings|undocumented|
1528                    params|common|<language>}  */
1529         while (* a != 0)
1530           {
1531             static struct
1532             {
1533               const char * string;
1534               unsigned int flag;
1535             }
1536             specifics[] =
1537             {
1538               { "optimizers", CL_OPTIMIZATION },
1539               { "target", CL_TARGET },
1540               { "warnings", CL_WARNING },
1541               { "undocumented", CL_UNDOCUMENTED },
1542               { "params", CL_PARAMS },
1543               { "joined", CL_JOINED },
1544               { "separate", CL_SEPARATE },
1545               { "common", CL_COMMON },
1546               { NULL, 0 }
1547             };
1548             unsigned int * pflags;
1549             const char * comma;
1550             unsigned int lang_flag, specific_flag;
1551             unsigned int len;
1552             unsigned int i;
1553
1554             if (* a == '^')
1555               {
1556                 ++ a;
1557                 pflags = & exclude_flags;
1558               }
1559             else
1560               pflags = & include_flags;
1561
1562             comma = strchr (a, ',');
1563             if (comma == NULL)
1564               len = strlen (a);
1565             else
1566               len = comma - a;
1567             if (len == 0)
1568               {
1569                 a = comma + 1;
1570                 continue;
1571               }
1572
1573             /* Check to see if the string matches an option class name.  */
1574             for (i = 0, specific_flag = 0; specifics[i].string != NULL; i++)
1575               if (strncasecmp (a, specifics[i].string, len) == 0)
1576                 {
1577                   specific_flag = specifics[i].flag;
1578                   break;
1579                 }
1580
1581             /* Check to see if the string matches a language name.
1582                Note - we rely upon the alpha-sorted nature of the entries in
1583                the lang_names array, specifically that shorter names appear
1584                before their longer variants.  (i.e. C before C++).  That way
1585                when we are attempting to match --help=c for example we will
1586                match with C first and not C++.  */
1587             for (i = 0, lang_flag = 0; i < cl_lang_count; i++)
1588               if (strncasecmp (a, lang_names[i], len) == 0)
1589                 {
1590                   lang_flag = 1U << i;
1591                   break;
1592                 }
1593
1594             if (specific_flag != 0)
1595               {
1596                 if (lang_flag == 0)
1597                   * pflags |= specific_flag;
1598                 else
1599                   {
1600                     /* The option's argument matches both the start of a
1601                        language name and the start of an option class name.
1602                        We have a special case for when the user has
1603                        specified "--help=c", but otherwise we have to issue
1604                        a warning.  */
1605                     if (strncasecmp (a, "c", len) == 0)
1606                       * pflags |= lang_flag;
1607                     else
1608                       fnotice (stderr,
1609                                "warning: --help argument %.*s is ambiguous, please be more specific\n",
1610                                len, a);
1611                   }
1612               }
1613             else if (lang_flag != 0)
1614               * pflags |= lang_flag;
1615             else
1616               fnotice (stderr,
1617                        "warning: unrecognized argument to --help= option: %.*s\n",
1618                        len, a);
1619
1620             if (comma == NULL)
1621               break;
1622             a = comma + 1;
1623           }
1624
1625         if (include_flags)
1626           print_specific_help (include_flags, exclude_flags, 0);
1627         exit_after_options = true;
1628         break;
1629       }
1630
1631     case OPT_fversion:
1632     case OPT__version:
1633       exit_after_options = true;
1634       break;
1635
1636     case OPT_G:
1637       g_switch_value = value;
1638       g_switch_set = true;
1639       break;
1640
1641     case OPT_O:
1642     case OPT_Os:
1643       /* Currently handled in a prescan.  */
1644       break;
1645
1646     case OPT_Werror_:
1647       enable_warning_as_error (arg, value, lang_mask);
1648       break;
1649
1650     case OPT_Wlarger_than_:
1651       /* This form corresponds to -Wlarger-than-.
1652          Kept for backward compatibility.
1653          Don't use it as the first argument of warning().  */
1654
1655     case OPT_Wlarger_than_eq:
1656       larger_than_size = value;
1657       warn_larger_than = value != -1;
1658       break;
1659
1660     case OPT_Wframe_larger_than_:
1661       frame_larger_than_size = value;
1662       warn_frame_larger_than = value != -1;
1663       break;
1664
1665     case OPT_Wstrict_aliasing:
1666       set_Wstrict_aliasing (value);
1667       break;
1668
1669     case OPT_Wstrict_aliasing_:
1670       warn_strict_aliasing = value;
1671       break;
1672
1673     case OPT_Wstrict_overflow:
1674       warn_strict_overflow = (value
1675                               ? (int) WARN_STRICT_OVERFLOW_CONDITIONAL
1676                               : 0);
1677       break;
1678
1679     case OPT_Wstrict_overflow_:
1680       warn_strict_overflow = value;
1681       break;
1682
1683     case OPT_Wunused:
1684       warn_unused = value;
1685       break;
1686
1687     case OPT_aux_info:
1688     case OPT_aux_info_:
1689       aux_info_file_name = arg;
1690       flag_gen_aux_info = 1;
1691       break;
1692
1693     case OPT_auxbase:
1694       aux_base_name = arg;
1695       break;
1696
1697     case OPT_auxbase_strip:
1698       {
1699         char *tmp = xstrdup (arg);
1700         strip_off_ending (tmp, strlen (tmp));
1701         if (tmp[0])
1702           aux_base_name = tmp;
1703       }
1704       break;
1705
1706     case OPT_d:
1707       decode_d_option (arg);
1708       break;
1709
1710     case OPT_dumpbase:
1711       dump_base_name = arg;
1712       break;
1713
1714     case OPT_dumpdir:
1715       dump_dir_name = arg;
1716       break;
1717
1718     case OPT_falign_functions_:
1719       align_functions = value;
1720       break;
1721
1722     case OPT_falign_jumps_:
1723       align_jumps = value;
1724       break;
1725
1726     case OPT_falign_labels_:
1727       align_labels = value;
1728       break;
1729
1730     case OPT_falign_loops_:
1731       align_loops = value;
1732       break;
1733
1734     case OPT_fbranch_probabilities:
1735       flag_branch_probabilities_set = true;
1736       break;
1737
1738     case OPT_fcall_used_:
1739       fix_register (arg, 0, 1);
1740       break;
1741
1742     case OPT_fcall_saved_:
1743       fix_register (arg, 0, 0);
1744       break;
1745
1746     case OPT_fdbg_cnt_:
1747       dbg_cnt_process_opt (arg);
1748       break;
1749
1750     case OPT_fdbg_cnt_list:
1751       dbg_cnt_list_all_counters ();
1752       break;
1753
1754     case OPT_fdebug_prefix_map_:
1755       add_debug_prefix_map (arg);
1756       break;
1757
1758     case OPT_fdiagnostics_show_location_:
1759       if (!strcmp (arg, "once"))
1760         diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
1761       else if (!strcmp (arg, "every-line"))
1762         diagnostic_prefixing_rule (global_dc)
1763           = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
1764       else
1765         return 0;
1766       break;
1767
1768     case OPT_fdiagnostics_show_option:
1769       global_dc->show_option_requested = value;
1770       break;
1771
1772     case OPT_fdump_:
1773       if (!dump_switch_p (arg))
1774         return 0;
1775       break;
1776
1777     case OPT_fexcess_precision_:
1778       if (!strcmp (arg, "fast"))
1779         flag_excess_precision_cmdline = EXCESS_PRECISION_FAST;
1780       else if (!strcmp (arg, "standard"))
1781         flag_excess_precision_cmdline = EXCESS_PRECISION_STANDARD;
1782       else
1783         error ("unknown excess precision style \"%s\"", arg);
1784       break;
1785
1786     case OPT_ffast_math:
1787       set_fast_math_flags (value);
1788       break;
1789
1790     case OPT_funsafe_math_optimizations:
1791       set_unsafe_math_optimizations_flags (value);
1792       break;
1793
1794     case OPT_ffixed_:
1795       fix_register (arg, 1, 1);
1796       break;
1797
1798     case OPT_finline_limit_:
1799     case OPT_finline_limit_eq:
1800       set_param_value ("max-inline-insns-single", value / 2);
1801       set_param_value ("max-inline-insns-auto", value / 2);
1802       break;
1803
1804     case OPT_finstrument_functions_exclude_function_list_:
1805       add_comma_separated_to_vector
1806         (&flag_instrument_functions_exclude_functions, arg);
1807       break;
1808
1809     case OPT_finstrument_functions_exclude_file_list_:
1810       add_comma_separated_to_vector
1811         (&flag_instrument_functions_exclude_files, arg);
1812       break;
1813
1814     case OPT_fmessage_length_:
1815       pp_set_line_maximum_length (global_dc->printer, value);
1816       break;
1817
1818     case OPT_fpack_struct_:
1819       if (value <= 0 || (value & (value - 1)) || value > 16)
1820         error ("structure alignment must be a small power of two, not %d", value);
1821       else
1822         {
1823           initial_max_fld_align = value;
1824           maximum_field_alignment = value * BITS_PER_UNIT;
1825         }
1826       break;
1827
1828     case OPT_fpeel_loops:
1829       flag_peel_loops_set = true;
1830       break;
1831
1832     case OPT_fplugin_:
1833 #ifdef ENABLE_PLUGIN
1834       add_new_plugin (arg);
1835 #else
1836       error ("Plugin support is disabled.  Configure with --enable-plugin.");
1837 #endif
1838       break;
1839
1840     case OPT_fplugin_arg_:
1841 #ifdef ENABLE_PLUGIN
1842       parse_plugin_arg_opt (arg);
1843 #else
1844       error ("Plugin support is disabled.  Configure with --enable-plugin.");
1845 #endif
1846       break;
1847
1848     case OPT_fprofile_arcs:
1849       profile_arc_flag_set = true;
1850       break;
1851
1852     case OPT_finline_functions:
1853       flag_inline_functions_set = true;
1854       break;
1855
1856     case OPT_fprofile_dir_:
1857       profile_data_prefix = xstrdup (arg);
1858       break;
1859
1860     case OPT_fprofile_use_:
1861       profile_data_prefix = xstrdup (arg);
1862       flag_profile_use = true;
1863       value = true;
1864       /* No break here - do -fprofile-use processing. */
1865     case OPT_fprofile_use:
1866       if (!flag_branch_probabilities_set)
1867         flag_branch_probabilities = value;
1868       if (!flag_profile_values_set)
1869         flag_profile_values = value;
1870       if (!flag_unroll_loops_set)
1871         flag_unroll_loops = value;
1872       if (!flag_peel_loops_set)
1873         flag_peel_loops = value;
1874       if (!flag_tracer_set)
1875         flag_tracer = value;
1876       if (!flag_value_profile_transformations_set)
1877         flag_value_profile_transformations = value;
1878       if (!flag_inline_functions_set)
1879         flag_inline_functions = value;
1880       if (!flag_ipa_cp_set)
1881         flag_ipa_cp = value;
1882       if (!flag_ipa_cp_clone_set
1883           && value && flag_ipa_cp)
1884         flag_ipa_cp_clone = value;
1885       if (!flag_predictive_commoning_set)
1886         flag_predictive_commoning = value;
1887       if (!flag_unswitch_loops_set)
1888         flag_unswitch_loops = value;
1889       if (!flag_gcse_after_reload_set)
1890         flag_gcse_after_reload = value;
1891       break;
1892
1893     case OPT_fprofile_generate_:
1894       profile_data_prefix = xstrdup (arg);
1895       value = true;
1896       /* No break here - do -fprofile-generate processing. */
1897     case OPT_fprofile_generate:
1898       if (!profile_arc_flag_set)
1899         profile_arc_flag = value;
1900       if (!flag_profile_values_set)
1901         flag_profile_values = value;
1902       if (!flag_value_profile_transformations_set)
1903         flag_value_profile_transformations = value;
1904       if (!flag_inline_functions_set)
1905         flag_inline_functions = value;
1906       break;
1907
1908     case OPT_fprofile_values:
1909       flag_profile_values_set = true;
1910       break;
1911
1912     case OPT_fvisibility_:
1913       {
1914         if (!strcmp(arg, "default"))
1915           default_visibility = VISIBILITY_DEFAULT;
1916         else if (!strcmp(arg, "internal"))
1917           default_visibility = VISIBILITY_INTERNAL;
1918         else if (!strcmp(arg, "hidden"))
1919           default_visibility = VISIBILITY_HIDDEN;
1920         else if (!strcmp(arg, "protected"))
1921           default_visibility = VISIBILITY_PROTECTED;
1922         else
1923           error ("unrecognized visibility value \"%s\"", arg);
1924       }
1925       break;
1926
1927     case OPT_fvpt:
1928       flag_value_profile_transformations_set = true;
1929       break;
1930
1931     case OPT_frandom_seed:
1932       /* The real switch is -fno-random-seed.  */
1933       if (value)
1934         return 0;
1935       set_random_seed (NULL);
1936       break;
1937
1938     case OPT_frandom_seed_:
1939       set_random_seed (arg);
1940       break;
1941
1942     case OPT_fselective_scheduling:
1943     case OPT_fselective_scheduling2:
1944       sel_sched_switch_set = true;
1945       break;
1946
1947     case OPT_fsched_verbose_:
1948 #ifdef INSN_SCHEDULING
1949       fix_sched_param ("verbose", arg);
1950       break;
1951 #else
1952       return 0;
1953 #endif
1954
1955     case OPT_fsched_stalled_insns_:
1956       flag_sched_stalled_insns = value;
1957       if (flag_sched_stalled_insns == 0)
1958         flag_sched_stalled_insns = -1;
1959       break;
1960
1961     case OPT_fsched_stalled_insns_dep_:
1962       flag_sched_stalled_insns_dep = value;
1963       break;
1964
1965     case OPT_fstack_check_:
1966       if (!strcmp (arg, "no"))
1967         flag_stack_check = NO_STACK_CHECK;
1968       else if (!strcmp (arg, "generic"))
1969         /* This is the old stack checking method.  */
1970         flag_stack_check = STACK_CHECK_BUILTIN
1971                            ? FULL_BUILTIN_STACK_CHECK
1972                            : GENERIC_STACK_CHECK;
1973       else if (!strcmp (arg, "specific"))
1974         /* This is the new stack checking method.  */
1975         flag_stack_check = STACK_CHECK_BUILTIN
1976                            ? FULL_BUILTIN_STACK_CHECK
1977                            : STACK_CHECK_STATIC_BUILTIN
1978                              ? STATIC_BUILTIN_STACK_CHECK
1979                              : GENERIC_STACK_CHECK;
1980       else
1981         warning (0, "unknown stack check parameter \"%s\"", arg);
1982       break;
1983
1984     case OPT_fstack_check:
1985       /* This is the same as the "specific" mode above.  */
1986       if (value)
1987         flag_stack_check = STACK_CHECK_BUILTIN
1988                            ? FULL_BUILTIN_STACK_CHECK
1989                            : STACK_CHECK_STATIC_BUILTIN
1990                              ? STATIC_BUILTIN_STACK_CHECK
1991                              : GENERIC_STACK_CHECK;
1992       else
1993         flag_stack_check = NO_STACK_CHECK;
1994       break;
1995
1996     case OPT_fstack_limit:
1997       /* The real switch is -fno-stack-limit.  */
1998       if (value)
1999         return 0;
2000       stack_limit_rtx = NULL_RTX;
2001       break;
2002
2003     case OPT_fstack_limit_register_:
2004       {
2005         int reg = decode_reg_name (arg);
2006         if (reg < 0)
2007           error ("unrecognized register name \"%s\"", arg);
2008         else
2009           stack_limit_rtx = gen_rtx_REG (Pmode, reg);
2010       }
2011       break;
2012
2013     case OPT_fstack_limit_symbol_:
2014       stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
2015       break;
2016
2017     case OPT_ftree_vectorizer_verbose_:
2018       vect_set_verbosity_level (arg);
2019       break;
2020
2021     case OPT_ftls_model_:
2022       if (!strcmp (arg, "global-dynamic"))
2023         flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
2024       else if (!strcmp (arg, "local-dynamic"))
2025         flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
2026       else if (!strcmp (arg, "initial-exec"))
2027         flag_tls_default = TLS_MODEL_INITIAL_EXEC;
2028       else if (!strcmp (arg, "local-exec"))
2029         flag_tls_default = TLS_MODEL_LOCAL_EXEC;
2030       else
2031         warning (0, "unknown tls-model \"%s\"", arg);
2032       break;
2033
2034     case OPT_fira_algorithm_:
2035       if (!strcmp (arg, "CB"))
2036         flag_ira_algorithm = IRA_ALGORITHM_CB;
2037       else if (!strcmp (arg, "priority"))
2038         flag_ira_algorithm = IRA_ALGORITHM_PRIORITY;
2039       else
2040         warning (0, "unknown ira algorithm \"%s\"", arg);
2041       break;
2042
2043     case OPT_fira_region_:
2044       if (!strcmp (arg, "one"))
2045         flag_ira_region = IRA_REGION_ONE;
2046       else if (!strcmp (arg, "all"))
2047         flag_ira_region = IRA_REGION_ALL;
2048       else if (!strcmp (arg, "mixed"))
2049         flag_ira_region = IRA_REGION_MIXED;
2050       else
2051         warning (0, "unknown ira region \"%s\"", arg);
2052       break;
2053
2054     case OPT_fira_verbose_:
2055       flag_ira_verbose = value;
2056       break;
2057
2058     case OPT_ftracer:
2059       flag_tracer_set = true;
2060       break;
2061
2062     case OPT_fipa_cp:
2063       flag_ipa_cp_set = true;
2064       break;
2065
2066     case OPT_fipa_cp_clone:
2067       flag_ipa_cp_clone_set = true;
2068       break;
2069
2070     case OPT_fpredictive_commoning:
2071       flag_predictive_commoning_set = true;
2072       break;
2073
2074     case OPT_funswitch_loops:
2075       flag_unswitch_loops_set = true;
2076       break;
2077
2078     case OPT_fgcse_after_reload:
2079       flag_gcse_after_reload_set = true;
2080       break;
2081
2082     case OPT_funroll_loops:
2083       flag_unroll_loops_set = true;
2084       break;
2085
2086     case OPT_g:
2087       set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg);
2088       break;
2089
2090     case OPT_gcoff:
2091       set_debug_level (SDB_DEBUG, false, arg);
2092       break;
2093
2094     case OPT_gdwarf_:
2095       if (value < 2 || value > 4)
2096         error ("dwarf version %d is not supported", value);
2097       else
2098         dwarf_version = value;
2099       set_debug_level (DWARF2_DEBUG, false, "");
2100       break;
2101
2102     case OPT_ggdb:
2103       set_debug_level (NO_DEBUG, 2, arg);
2104       break;
2105
2106     case OPT_gstabs:
2107     case OPT_gstabs_:
2108       set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg);
2109       break;
2110
2111     case OPT_gvms:
2112       set_debug_level (VMS_DEBUG, false, arg);
2113       break;
2114
2115     case OPT_gxcoff:
2116     case OPT_gxcoff_:
2117       set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
2118       break;
2119
2120     case OPT_o:
2121       asm_file_name = arg;
2122       break;
2123
2124     case OPT_pedantic_errors:
2125       flag_pedantic_errors = pedantic = 1;
2126       break;
2127
2128     case OPT_fsee:
2129     case OPT_fcse_skip_blocks:
2130     case OPT_floop_optimize:
2131     case OPT_frerun_loop_opt:
2132     case OPT_fsched2_use_traces:
2133     case OPT_fstrength_reduce:
2134     case OPT_ftree_store_copy_prop:
2135     case OPT_fforce_addr:
2136     case OPT_ftree_salias:
2137     case OPT_ftree_store_ccp:
2138     case OPT_Wunreachable_code:
2139     case OPT_fargument_alias:
2140     case OPT_fargument_noalias:
2141     case OPT_fargument_noalias_anything:
2142     case OPT_fargument_noalias_global:
2143       /* These are no-ops, preserved for backward compatibility.  */
2144       break;
2145
2146     case OPT_fuse_linker_plugin:
2147       /* No-op. Used by the driver and passed to us because it starts with f.*/
2148       break;
2149
2150     default:
2151       /* If the flag was handled in a standard way, assume the lack of
2152          processing here is intentional.  */
2153       gcc_assert (cl_options[scode].flag_var);
2154       break;
2155     }
2156
2157   return 1;
2158 }
2159
2160 /* Handle --param NAME=VALUE.  */
2161 static void
2162 handle_param (const char *carg)
2163 {
2164   char *equal, *arg;
2165   int value;
2166
2167   arg = xstrdup (carg);
2168   equal = strchr (arg, '=');
2169   if (!equal)
2170     error ("%s: --param arguments should be of the form NAME=VALUE", arg);
2171   else
2172     {
2173       value = integral_argument (equal + 1);
2174       if (value == -1)
2175         error ("invalid --param value %qs", equal + 1);
2176       else
2177         {
2178           *equal = '\0';
2179           set_param_value (arg, value);
2180         }
2181     }
2182
2183   free (arg);
2184 }
2185
2186 /* Used to set the level of strict aliasing warnings,
2187    when no level is specified (i.e., when -Wstrict-aliasing, and not
2188    -Wstrict-aliasing=level was given).
2189    ONOFF is assumed to take value 1 when -Wstrict-aliasing is specified,
2190    and 0 otherwise.  After calling this function, wstrict_aliasing will be
2191    set to the default value of -Wstrict_aliasing=level, currently 3.  */
2192 void
2193 set_Wstrict_aliasing (int onoff)
2194 {
2195   gcc_assert (onoff == 0 || onoff == 1);
2196   if (onoff != 0)
2197     warn_strict_aliasing = 3;
2198   else
2199     warn_strict_aliasing = 0;
2200 }
2201
2202 /* The following routines are useful in setting all the flags that
2203    -ffast-math and -fno-fast-math imply.  */
2204 void
2205 set_fast_math_flags (int set)
2206 {
2207   flag_unsafe_math_optimizations = set;
2208   set_unsafe_math_optimizations_flags (set);
2209   flag_finite_math_only = set;
2210   flag_errno_math = !set;
2211   if (set)
2212     {
2213       flag_signaling_nans = 0;
2214       flag_rounding_math = 0;
2215       flag_cx_limited_range = 1;
2216     }
2217 }
2218
2219 /* When -funsafe-math-optimizations is set the following
2220    flags are set as well.  */
2221 void
2222 set_unsafe_math_optimizations_flags (int set)
2223 {
2224   flag_trapping_math = !set;
2225   flag_signed_zeros = !set;
2226   flag_associative_math = set;
2227   flag_reciprocal_math = set;
2228 }
2229
2230 /* Return true iff flags are set as if -ffast-math.  */
2231 bool
2232 fast_math_flags_set_p (void)
2233 {
2234   return (!flag_trapping_math
2235           && flag_unsafe_math_optimizations
2236           && flag_finite_math_only
2237           && !flag_signed_zeros
2238           && !flag_errno_math);
2239 }
2240
2241 /* Return true iff flags are set as if -ffast-math but using the flags stored
2242    in the struct cl_optimization structure.  */
2243 bool
2244 fast_math_flags_struct_set_p (struct cl_optimization *opt)
2245 {
2246   return (!opt->flag_trapping_math
2247           && opt->flag_unsafe_math_optimizations
2248           && opt->flag_finite_math_only
2249           && !opt->flag_signed_zeros
2250           && !opt->flag_errno_math);
2251 }
2252
2253 /* Handle a debug output -g switch.  EXTENDED is true or false to support
2254    extended output (2 is special and means "-ggdb" was given).  */
2255 static void
2256 set_debug_level (enum debug_info_type type, int extended, const char *arg)
2257 {
2258   static bool type_explicit;
2259
2260   use_gnu_debug_info_extensions = extended;
2261
2262   if (type == NO_DEBUG)
2263     {
2264       if (write_symbols == NO_DEBUG)
2265         {
2266           write_symbols = PREFERRED_DEBUGGING_TYPE;
2267
2268           if (extended == 2)
2269             {
2270 #ifdef DWARF2_DEBUGGING_INFO
2271               write_symbols = DWARF2_DEBUG;
2272 #elif defined DBX_DEBUGGING_INFO
2273               write_symbols = DBX_DEBUG;
2274 #endif
2275             }
2276
2277           if (write_symbols == NO_DEBUG)
2278             warning (0, "target system does not support debug output");
2279         }
2280     }
2281   else
2282     {
2283       /* Does it conflict with an already selected type?  */
2284       if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols)
2285         error ("debug format \"%s\" conflicts with prior selection",
2286                debug_type_names[type]);
2287       write_symbols = type;
2288       type_explicit = true;
2289     }
2290
2291   /* A debug flag without a level defaults to level 2.  */
2292   if (*arg == '\0')
2293     {
2294       if (!debug_info_level)
2295         debug_info_level = DINFO_LEVEL_NORMAL;
2296     }
2297   else
2298     {
2299       int argval = integral_argument (arg);
2300       if (argval == -1)
2301         error ("unrecognised debug output level \"%s\"", arg);
2302       else if (argval > 3)
2303         error ("debug output level %s is too high", arg);
2304       else
2305         debug_info_level = (enum debug_info_level) argval;
2306     }
2307 }
2308
2309 /* Return 1 if OPTION is enabled, 0 if it is disabled, or -1 if it isn't
2310    a simple on-off switch.  */
2311
2312 int
2313 option_enabled (int opt_idx)
2314 {
2315   const struct cl_option *option = &(cl_options[opt_idx]);
2316
2317   if (option->flag_var)
2318     switch (option->var_type)
2319       {
2320       case CLVC_BOOLEAN:
2321         return *(int *) option->flag_var != 0;
2322
2323       case CLVC_EQUAL:
2324         return *(int *) option->flag_var == option->var_value;
2325
2326       case CLVC_BIT_CLEAR:
2327         return (*(int *) option->flag_var & option->var_value) == 0;
2328
2329       case CLVC_BIT_SET:
2330         return (*(int *) option->flag_var & option->var_value) != 0;
2331
2332       case CLVC_STRING:
2333         break;
2334       }
2335   return -1;
2336 }
2337
2338 /* Fill STATE with the current state of option OPTION.  Return true if
2339    there is some state to store.  */
2340
2341 bool
2342 get_option_state (int option, struct cl_option_state *state)
2343 {
2344   if (cl_options[option].flag_var == 0)
2345     return false;
2346
2347   switch (cl_options[option].var_type)
2348     {
2349     case CLVC_BOOLEAN:
2350     case CLVC_EQUAL:
2351       state->data = cl_options[option].flag_var;
2352       state->size = sizeof (int);
2353       break;
2354
2355     case CLVC_BIT_CLEAR:
2356     case CLVC_BIT_SET:
2357       state->ch = option_enabled (option);
2358       state->data = &state->ch;
2359       state->size = 1;
2360       break;
2361
2362     case CLVC_STRING:
2363       state->data = *(const char **) cl_options[option].flag_var;
2364       if (state->data == 0)
2365         state->data = "";
2366       state->size = strlen ((const char *) state->data) + 1;
2367       break;
2368     }
2369   return true;
2370 }
2371
2372 /* Set *OPTION according to VALUE and ARG.  */
2373
2374 void
2375 set_option (const struct cl_option *option, int value, const char *arg)
2376 {
2377   if (!option->flag_var)
2378     return;
2379
2380   switch (option->var_type)
2381     {
2382     case CLVC_BOOLEAN:
2383         *(int *) option->flag_var = value;
2384         break;
2385
2386     case CLVC_EQUAL:
2387         *(int *) option->flag_var = (value
2388                                      ? option->var_value
2389                                      : !option->var_value);
2390         break;
2391
2392     case CLVC_BIT_CLEAR:
2393     case CLVC_BIT_SET:
2394         if ((value != 0) == (option->var_type == CLVC_BIT_SET))
2395           *(int *) option->flag_var |= option->var_value;
2396         else
2397           *(int *) option->flag_var &= ~option->var_value;
2398         if (option->flag_var == &target_flags)
2399           target_flags_explicit |= option->var_value;
2400         break;
2401
2402     case CLVC_STRING:
2403         *(const char **) option->flag_var = arg;
2404         break;
2405     }
2406 }
2407
2408
2409 /* Callback function, called when -Werror= enables a warning.  */
2410
2411 static void (*warning_as_error_callback) (int) = NULL;
2412
2413 /* Register a callback for enable_warning_as_error calls.  */
2414
2415 void
2416 register_warning_as_error_callback (void (*callback) (int))
2417 {
2418   gcc_assert (warning_as_error_callback == NULL || callback == NULL);
2419   warning_as_error_callback = callback;
2420 }
2421
2422 /* Enable a warning option as an error.  This is used by -Werror= and
2423    also by legacy Werror-implicit-function-declaration.  */
2424
2425 void
2426 enable_warning_as_error (const char *arg, int value, unsigned int lang_mask)
2427 {
2428   char *new_option;
2429   int option_index;
2430
2431   new_option = XNEWVEC (char, strlen (arg) + 2);
2432   new_option[0] = 'W';
2433   strcpy (new_option + 1, arg);
2434   option_index = find_opt (new_option, lang_mask);
2435   if (option_index == N_OPTS)
2436     {
2437       error ("-Werror=%s: No option -%s", arg, new_option);
2438     }
2439   else
2440     {
2441       const diagnostic_t kind = value ? DK_ERROR : DK_WARNING;
2442
2443       diagnostic_classify_diagnostic (global_dc, option_index, kind);
2444       if (kind == DK_ERROR)
2445         {
2446           const struct cl_option * const option = cl_options + option_index;
2447
2448           /* -Werror=foo implies -Wfoo.  */
2449           if (option->var_type == CLVC_BOOLEAN && option->flag_var)
2450             *(int *) option->flag_var = 1;
2451
2452           if (warning_as_error_callback)
2453             warning_as_error_callback (option_index);
2454         }
2455     }
2456   free (new_option);
2457 }