OSDN Git Service

* builtins.c, c-pragma.h, c-typeck.c, cgraph.c, cgraphunit.c,
[pf3gnuchains/gcc-fork.git] / gcc / opts.c
1 /* Command line option handling.
2    Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
3    Contributed by Neil Booth.
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
10 version.
11
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING.  If not, write to the Free
19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
20 02110-1301, USA.  */
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 "ggc.h"
30 #include "output.h"
31 #include "langhooks.h"
32 #include "opts.h"
33 #include "options.h"
34 #include "flags.h"
35 #include "toplev.h"
36 #include "params.h"
37 #include "diagnostic.h"
38 #include "tm_p.h"               /* For OPTIMIZATION_OPTIONS.  */
39 #include "insn-attr.h"          /* For INSN_SCHEDULING.  */
40 #include "target.h"
41 #include "tree-pass.h"
42
43 /* Value of the -G xx switch, and whether it was passed or not.  */
44 unsigned HOST_WIDE_INT g_switch_value;
45 bool g_switch_set;
46
47 /* True if we should exit after parsing options.  */
48 bool exit_after_options;
49
50 /* Print various extra warnings.  -W/-Wextra.  */
51 bool extra_warnings;
52
53 /* True to warn about any objects definitions whose size is larger
54    than N bytes.  Also want about function definitions whose returned
55    values are larger than N bytes, where N is `larger_than_size'.  */
56 bool warn_larger_than;
57 HOST_WIDE_INT larger_than_size;
58
59 /* Nonzero means warn about constructs which might not be
60    strict-aliasing safe.  */
61 int warn_strict_aliasing;
62
63 /* Hack for cooperation between set_Wunused and set_Wextra.  */
64 static bool maybe_warn_unused_parameter;
65
66 /* Type(s) of debugging information we are producing (if any).  See
67    flags.h for the definitions of the different possible types of
68    debugging information.  */
69 enum debug_info_type write_symbols = NO_DEBUG;
70
71 /* Level of debugging information we are producing.  See flags.h for
72    the definitions of the different possible levels.  */
73 enum debug_info_level debug_info_level = DINFO_LEVEL_NONE;
74
75 /* Nonzero means use GNU-only extensions in the generated symbolic
76    debugging information.  Currently, this only has an effect when
77    write_symbols is set to DBX_DEBUG, XCOFF_DEBUG, or DWARF_DEBUG.  */
78 bool use_gnu_debug_info_extensions;
79
80 /* The default visibility for all symbols (unless overridden) */
81 enum symbol_visibility default_visibility = VISIBILITY_DEFAULT;
82
83 /* Disable unit-at-a-time for frontends that might be still broken in this
84    respect.  */
85   
86 bool no_unit_at_a_time_default;
87
88 /* Global visibility options.  */
89 struct visibility_flags visibility_options;
90
91 /* Columns of --help display.  */
92 static unsigned int columns = 80;
93
94 /* What to print when a switch has no documentation.  */
95 static const char undocumented_msg[] = N_("This switch lacks documentation");
96
97 /* Used for bookkeeping on whether user set these flags so
98    -fprofile-use/-fprofile-generate does not use them.  */
99 static bool profile_arc_flag_set, flag_profile_values_set;
100 static bool flag_unroll_loops_set, flag_tracer_set;
101 static bool flag_value_profile_transformations_set;
102 static bool flag_peel_loops_set, flag_branch_probabilities_set;
103
104 /* Input file names.  */
105 const char **in_fnames;
106 unsigned num_in_fnames;
107
108 static size_t find_opt (const char *, int);
109 static int common_handle_option (size_t scode, const char *arg, int value,
110                                  unsigned int lang_mask);
111 static void handle_param (const char *);
112 static void set_Wextra (int);
113 static unsigned int handle_option (const char **argv, unsigned int lang_mask);
114 static char *write_langs (unsigned int lang_mask);
115 static void complain_wrong_lang (const char *, const struct cl_option *,
116                                  unsigned int lang_mask);
117 static void handle_options (unsigned int, const char **, unsigned int);
118 static void wrap_help (const char *help, const char *item, unsigned int);
119 static void print_target_help (void);
120 static void print_help (void);
121 static void print_param_help (void);
122 static void print_filtered_help (unsigned int);
123 static unsigned int print_switch (const char *text, unsigned int indent);
124 static void set_debug_level (enum debug_info_type type, int extended,
125                              const char *arg);
126
127 /* Perform a binary search to find which option the command-line INPUT
128    matches.  Returns its index in the option array, and N_OPTS
129    (cl_options_count) on failure.
130
131    This routine is quite subtle.  A normal binary search is not good
132    enough because some options can be suffixed with an argument, and
133    multiple sub-matches can occur, e.g. input of "-pedantic" matching
134    the initial substring of "-pedantic-errors".
135
136    A more complicated example is -gstabs.  It should match "-g" with
137    an argument of "stabs".  Suppose, however, that the number and list
138    of switches are such that the binary search tests "-gen-decls"
139    before having tested "-g".  This doesn't match, and as "-gen-decls"
140    is less than "-gstabs", it will become the lower bound of the
141    binary search range, and "-g" will never be seen.  To resolve this
142    issue, opts.sh makes "-gen-decls" point, via the back_chain member,
143    to "-g" so that failed searches that end between "-gen-decls" and
144    the lexicographically subsequent switch know to go back and see if
145    "-g" causes a match (which it does in this example).
146
147    This search is done in such a way that the longest match for the
148    front end in question wins.  If there is no match for the current
149    front end, the longest match for a different front end is returned
150    (or N_OPTS if none) and the caller emits an error message.  */
151 static size_t
152 find_opt (const char *input, int lang_mask)
153 {
154   size_t mn, mx, md, opt_len;
155   size_t match_wrong_lang;
156   int comp;
157
158   mn = 0;
159   mx = cl_options_count;
160
161   /* Find mn such this lexicographical inequality holds:
162      cl_options[mn] <= input < cl_options[mn + 1].  */
163   while (mx - mn > 1)
164     {
165       md = (mn + mx) / 2;
166       opt_len = cl_options[md].opt_len;
167       comp = strncmp (input, cl_options[md].opt_text + 1, opt_len);
168
169       if (comp < 0)
170         mx = md;
171       else
172         mn = md;
173     }
174
175   /* This is the switch that is the best match but for a different
176      front end, or cl_options_count if there is no match at all.  */
177   match_wrong_lang = cl_options_count;
178
179   /* Backtrace the chain of possible matches, returning the longest
180      one, if any, that fits best.  With current GCC switches, this
181      loop executes at most twice.  */
182   do
183     {
184       const struct cl_option *opt = &cl_options[mn];
185
186       /* Is the input either an exact match or a prefix that takes a
187          joined argument?  */
188       if (!strncmp (input, opt->opt_text + 1, opt->opt_len)
189           && (input[opt->opt_len] == '\0' || (opt->flags & CL_JOINED)))
190         {
191           /* If language is OK, return it.  */
192           if (opt->flags & lang_mask)
193             return mn;
194
195           /* If we haven't remembered a prior match, remember this
196              one.  Any prior match is necessarily better.  */
197           if (match_wrong_lang == cl_options_count)
198             match_wrong_lang = mn;
199         }
200
201       /* Try the next possibility.  This is cl_options_count if there
202          are no more.  */
203       mn = opt->back_chain;
204     }
205   while (mn != cl_options_count);
206
207   /* Return the best wrong match, or cl_options_count if none.  */
208   return match_wrong_lang;
209 }
210
211 /* If ARG is a non-negative integer made up solely of digits, return its
212    value, otherwise return -1.  */
213 static int
214 integral_argument (const char *arg)
215 {
216   const char *p = arg;
217
218   while (*p && ISDIGIT (*p))
219     p++;
220
221   if (*p == '\0')
222     return atoi (arg);
223
224   return -1;
225 }
226
227 /* Return a malloced slash-separated list of languages in MASK.  */
228 static char *
229 write_langs (unsigned int mask)
230 {
231   unsigned int n = 0, len = 0;
232   const char *lang_name;
233   char *result;
234
235   for (n = 0; (lang_name = lang_names[n]) != 0; n++)
236     if (mask & (1U << n))
237       len += strlen (lang_name) + 1;
238
239   result = XNEWVEC (char, len);
240   len = 0;
241   for (n = 0; (lang_name = lang_names[n]) != 0; n++)
242     if (mask & (1U << n))
243       {
244         if (len)
245           result[len++] = '/';
246         strcpy (result + len, lang_name);
247         len += strlen (lang_name);
248       }
249
250   result[len] = 0;
251
252   return result;
253 }
254
255 /* Complain that switch OPT_INDEX does not apply to this front end.  */
256 static void
257 complain_wrong_lang (const char *text, const struct cl_option *option,
258                      unsigned int lang_mask)
259 {
260   char *ok_langs, *bad_lang;
261
262   ok_langs = write_langs (option->flags);
263   bad_lang = write_langs (lang_mask);
264
265   /* Eventually this should become a hard error IMO.  */
266   warning (0, "command line option \"%s\" is valid for %s but not for %s",
267            text, ok_langs, bad_lang);
268
269   free (ok_langs);
270   free (bad_lang);
271 }
272
273 /* Handle the switch beginning at ARGV for the language indicated by
274    LANG_MASK.  Returns the number of switches consumed.  */
275 static unsigned int
276 handle_option (const char **argv, unsigned int lang_mask)
277 {
278   size_t opt_index;
279   const char *opt, *arg = 0;
280   char *dup = 0;
281   int value = 1;
282   unsigned int result = 0;
283   const struct cl_option *option;
284
285   opt = argv[0];
286
287   opt_index = find_opt (opt + 1, lang_mask | CL_COMMON | CL_TARGET);
288   if (opt_index == cl_options_count
289       && (opt[1] == 'W' || opt[1] == 'f' || opt[1] == 'm')
290       && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-')
291     {
292       /* Drop the "no-" from negative switches.  */
293       size_t len = strlen (opt) - 3;
294
295       dup = XNEWVEC (char, len + 1);
296       dup[0] = '-';
297       dup[1] = opt[1];
298       memcpy (dup + 2, opt + 5, len - 2 + 1);
299       opt = dup;
300       value = 0;
301       opt_index = find_opt (opt + 1, lang_mask | CL_COMMON | CL_TARGET);
302     }
303
304   if (opt_index == cl_options_count)
305     goto done;
306
307   option = &cl_options[opt_index];
308
309   /* Reject negative form of switches that don't take negatives as
310      unrecognized.  */
311   if (!value && (option->flags & CL_REJECT_NEGATIVE))
312     goto done;
313
314   /* We've recognized this switch.  */
315   result = 1;
316
317   /* Check to see if the option is disabled for this configuration.  */
318   if (option->flags & CL_DISABLED)
319     {
320       error ("command line option %qs"
321              " is not supported by this configuration", opt);
322       goto done;
323     }
324
325   /* Sort out any argument the switch takes.  */
326   if (option->flags & CL_JOINED)
327     {
328       /* Have arg point to the original switch.  This is because
329          some code, such as disable_builtin_function, expects its
330          argument to be persistent until the program exits.  */
331       arg = argv[0] + cl_options[opt_index].opt_len + 1;
332       if (!value)
333         arg += strlen ("no-");
334
335       if (*arg == '\0' && !(option->flags & CL_MISSING_OK))
336         {
337           if (option->flags & CL_SEPARATE)
338             {
339               arg = argv[1];
340               result = 2;
341             }
342           else
343             /* Missing argument.  */
344             arg = NULL;
345         }
346     }
347   else if (option->flags & CL_SEPARATE)
348     {
349       arg = argv[1];
350       result = 2;
351     }
352
353   /* Now we've swallowed any potential argument, complain if this
354      is a switch for a different front end.  */
355   if (!(option->flags & (lang_mask | CL_COMMON | CL_TARGET)))
356     {
357       complain_wrong_lang (argv[0], option, lang_mask);
358       goto done;
359     }
360
361   if (arg == NULL && (option->flags & (CL_JOINED | CL_SEPARATE)))
362     {
363       if (!lang_hooks.missing_argument (opt, opt_index))
364         error ("missing argument to \"%s\"", opt);
365       goto done;
366     }
367
368   /* If the switch takes an integer, convert it.  */
369   if (arg && (option->flags & CL_UINTEGER))
370     {
371       value = integral_argument (arg);
372       if (value == -1)
373         {
374           error ("argument to \"%s\" should be a non-negative integer",
375                  option->opt_text);
376           goto done;
377         }
378     }
379
380   if (option->flag_var)
381     switch (option->var_type)
382       {
383       case CLVC_BOOLEAN:
384         *(int *) option->flag_var = value;
385         break;
386
387       case CLVC_EQUAL:
388         *(int *) option->flag_var = (value
389                                      ? option->var_value
390                                      : !option->var_value);
391         break;
392
393       case CLVC_BIT_CLEAR:
394       case CLVC_BIT_SET:
395         if ((value != 0) == (option->var_type == CLVC_BIT_SET))
396           *(int *) option->flag_var |= option->var_value;
397         else
398           *(int *) option->flag_var &= ~option->var_value;
399         if (option->flag_var == &target_flags)
400           target_flags_explicit |= option->var_value;
401         break;
402
403       case CLVC_STRING:
404         *(const char **) option->flag_var = arg;
405         break;
406       }
407   
408   if (option->flags & lang_mask)
409     if (lang_hooks.handle_option (opt_index, arg, value) == 0)
410       result = 0;
411
412   if (result && (option->flags & CL_COMMON))
413     if (common_handle_option (opt_index, arg, value, lang_mask) == 0)
414       result = 0;
415
416   if (result && (option->flags & CL_TARGET))
417     if (!targetm.handle_option (opt_index, arg, value))
418       result = 0;
419
420  done:
421   if (dup)
422     free (dup);
423   return result;
424 }
425
426 /* Handle FILENAME from the command line.  */
427 static void
428 add_input_filename (const char *filename)
429 {
430   num_in_fnames++;
431   in_fnames = xrealloc (in_fnames, num_in_fnames * sizeof (in_fnames[0]));
432   in_fnames[num_in_fnames - 1] = filename;
433 }
434
435 /* Decode and handle the vector of command line options.  LANG_MASK
436    contains has a single bit set representing the current
437    language.  */
438 static void
439 handle_options (unsigned int argc, const char **argv, unsigned int lang_mask)
440 {
441   unsigned int n, i;
442
443   for (i = 1; i < argc; i += n)
444     {
445       const char *opt = argv[i];
446
447       /* Interpret "-" or a non-switch as a file name.  */
448       if (opt[0] != '-' || opt[1] == '\0')
449         {
450           if (main_input_filename == NULL)
451             main_input_filename = opt;
452           add_input_filename (opt);
453           n = 1;
454           continue;
455         }
456
457       n = handle_option (argv + i, lang_mask);
458
459       if (!n)
460         {
461           n = 1;
462           error ("unrecognized command line option \"%s\"", opt);
463         }
464     }
465 }
466
467 /* Parse command line options and set default flag values.  Do minimal
468    options processing.  */
469 void
470 decode_options (unsigned int argc, const char **argv)
471 {
472   unsigned int i, lang_mask;
473
474   /* Perform language-specific options initialization.  */
475   lang_mask = lang_hooks.init_options (argc, argv);
476
477   lang_hooks.initialize_diagnostics (global_dc);
478
479   /* Scan to see what optimization level has been specified.  That will
480      determine the default value of many flags.  */
481   for (i = 1; i < argc; i++)
482     {
483       if (!strcmp (argv[i], "-O"))
484         {
485           optimize = 1;
486           optimize_size = 0;
487         }
488       else if (argv[i][0] == '-' && argv[i][1] == 'O')
489         {
490           /* Handle -Os, -O2, -O3, -O69, ...  */
491           const char *p = &argv[i][2];
492
493           if ((p[0] == 's') && (p[1] == 0))
494             {
495               optimize_size = 1;
496
497               /* Optimizing for size forces optimize to be 2.  */
498               optimize = 2;
499             }
500           else
501             {
502               const int optimize_val = read_integral_parameter (p, p - 2, -1);
503               if (optimize_val != -1)
504                 {
505                   optimize = optimize_val;
506                   optimize_size = 0;
507                 }
508             }
509         }
510     }
511
512   if (!optimize)
513     {
514       flag_merge_constants = 0;
515     }
516
517   if (optimize >= 1)
518     {
519       flag_defer_pop = 1;
520 #ifdef DELAY_SLOTS
521       flag_delayed_branch = 1;
522 #endif
523 #ifdef CAN_DEBUG_WITHOUT_FP
524       flag_omit_frame_pointer = 1;
525 #endif
526       flag_guess_branch_prob = 1;
527       flag_cprop_registers = 1;
528       flag_if_conversion = 1;
529       flag_if_conversion2 = 1;
530       flag_ipa_pure_const = 1;
531       flag_ipa_reference = 1;
532       flag_tree_ccp = 1;
533       flag_tree_dce = 1;
534       flag_tree_dom = 1;
535       flag_tree_dse = 1;
536       flag_tree_ter = 1;
537       flag_tree_live_range_split = 1;
538       flag_tree_sra = 1;
539       flag_tree_copyrename = 1;
540       flag_tree_fre = 1;
541       flag_tree_copy_prop = 1;
542       flag_tree_sink = 1;
543       flag_tree_salias = 1;
544       if (!no_unit_at_a_time_default)
545         flag_unit_at_a_time = 1;
546
547       if (!optimize_size)
548         {
549           /* Loop header copying usually increases size of the code.  This used
550              not to be true, since quite often it is possible to verify that
551              the condition is satisfied in the first iteration and therefore
552              to eliminate it.  Jump threading handles these cases now.  */
553           flag_tree_ch = 1;
554         }
555     }
556
557   if (optimize >= 2)
558     {
559       flag_thread_jumps = 1;
560       flag_crossjumping = 1;
561       flag_optimize_sibling_calls = 1;
562       flag_cse_follow_jumps = 1;
563       flag_cse_skip_blocks = 1;
564       flag_gcse = 1;
565       flag_expensive_optimizations = 1;
566       flag_ipa_type_escape = 1;
567       flag_rerun_cse_after_loop = 1;
568       flag_caller_saves = 1;
569       flag_peephole2 = 1;
570 #ifdef INSN_SCHEDULING
571       flag_schedule_insns = 1;
572       flag_schedule_insns_after_reload = 1;
573 #endif
574       flag_regmove = 1;
575       flag_strict_aliasing = 1;
576       flag_delete_null_pointer_checks = 1;
577       flag_reorder_blocks = 1;
578       flag_reorder_functions = 1;
579       flag_tree_store_ccp = 1;
580       flag_tree_store_copy_prop = 1;
581       flag_tree_vrp = 1;
582
583       if (!optimize_size)
584         {
585           /* PRE tends to generate bigger code.  */
586           flag_tree_pre = 1;
587         }
588     }
589
590   if (optimize >= 3)
591     {
592       flag_inline_functions = 1;
593       flag_unswitch_loops = 1;
594       flag_gcse_after_reload = 1;
595     }
596
597   if (optimize < 2 || optimize_size)
598     {
599       align_loops = 1;
600       align_jumps = 1;
601       align_labels = 1;
602       align_functions = 1;
603
604       /* Don't reorder blocks when optimizing for size because extra
605          jump insns may be created; also barrier may create extra padding.
606
607          More correctly we should have a block reordering mode that tried
608          to minimize the combined size of all the jumps.  This would more
609          or less automatically remove extra jumps, but would also try to
610          use more short jumps instead of long jumps.  */
611       flag_reorder_blocks = 0;
612       flag_reorder_blocks_and_partition = 0;
613     }
614
615   if (optimize_size)
616     {
617       /* Inlining of very small functions usually reduces total size.  */
618       set_param_value ("max-inline-insns-single", 5);
619       set_param_value ("max-inline-insns-auto", 5);
620       flag_inline_functions = 1;
621
622       /* We want to crossjump as much as possible.  */
623       set_param_value ("min-crossjump-insns", 1);
624     }
625
626   /* Initialize whether `char' is signed.  */
627   flag_signed_char = DEFAULT_SIGNED_CHAR;
628   /* Set this to a special "uninitialized" value.  The actual default is set
629      after target options have been processed.  */
630   flag_short_enums = 2;
631
632   /* Initialize target_flags before OPTIMIZATION_OPTIONS so the latter can
633      modify it.  */
634   target_flags = targetm.default_target_flags;
635
636   /* Some tagets have ABI-specified unwind tables.  */
637   flag_unwind_tables = targetm.unwind_tables_default;
638
639 #ifdef OPTIMIZATION_OPTIONS
640   /* Allow default optimizations to be specified on a per-machine basis.  */
641   OPTIMIZATION_OPTIONS (optimize, optimize_size);
642 #endif
643
644   handle_options (argc, argv, lang_mask);
645
646   if (flag_pie)
647     flag_pic = flag_pie;
648   if (flag_pic && !flag_pie)
649     flag_shlib = 1;
650
651   if (flag_no_inline == 2)
652     flag_no_inline = 0;
653   else
654     flag_really_no_inline = flag_no_inline;
655
656   /* Set flag_no_inline before the post_options () hook.  The C front
657      ends use it to determine tree inlining defaults.  FIXME: such
658      code should be lang-independent when all front ends use tree
659      inlining, in which case it, and this condition, should be moved
660      to the top of process_options() instead.  */
661   if (optimize == 0)
662     {
663       /* Inlining does not work if not optimizing,
664          so force it not to be done.  */
665       flag_no_inline = 1;
666       warn_inline = 0;
667
668       /* The c_decode_option function and decode_option hook set
669          this to `2' if -Wall is used, so we can avoid giving out
670          lots of errors for people who don't realize what -Wall does.  */
671       if (warn_uninitialized == 1)
672         warning (OPT_Wuninitialized,
673                  "-Wuninitialized is not supported without -O");
674     }
675
676   if (flag_really_no_inline == 2)
677     flag_really_no_inline = flag_no_inline;
678
679   /* The optimization to partition hot and cold basic blocks into separate
680      sections of the .o and executable files does not work (currently)
681      with exception handling.  This is because there is no support for
682      generating unwind info.  If flag_exceptions is turned on we need to
683      turn off the partitioning optimization.  */
684
685   if (flag_exceptions && flag_reorder_blocks_and_partition)
686     {
687       inform 
688             ("-freorder-blocks-and-partition does not work with exceptions");
689       flag_reorder_blocks_and_partition = 0;
690       flag_reorder_blocks = 1;
691     }
692
693   /* If user requested unwind info, then turn off the partitioning
694      optimization.  */
695
696   if (flag_unwind_tables && ! targetm.unwind_tables_default
697       && flag_reorder_blocks_and_partition)
698     {
699       inform ("-freorder-blocks-and-partition does not support unwind info");
700       flag_reorder_blocks_and_partition = 0;
701       flag_reorder_blocks = 1;
702     }
703
704   /* If the target requested unwind info, then turn off the partitioning
705      optimization with a different message.  Likewise, if the target does not
706      support named sections.  */
707
708   if (flag_reorder_blocks_and_partition
709       && (!targetm.have_named_sections
710           || (flag_unwind_tables && targetm.unwind_tables_default)))
711     {
712       inform 
713        ("-freorder-blocks-and-partition does not work on this architecture");
714       flag_reorder_blocks_and_partition = 0;
715       flag_reorder_blocks = 1;
716     }
717 }
718
719 /* Handle target- and language-independent options.  Return zero to
720    generate an "unknown option" message.  Only options that need
721    extra handling need to be listed here; if you simply want
722    VALUE assigned to a variable, it happens automatically.  */
723
724 static int
725 common_handle_option (size_t scode, const char *arg, int value,
726                       unsigned int lang_mask)
727 {
728   enum opt_code code = (enum opt_code) scode;
729
730   switch (code)
731     {
732     case OPT__help:
733       print_help ();
734       exit_after_options = true;
735       break;
736
737     case OPT__param:
738       handle_param (arg);
739       break;
740
741     case OPT__target_help:
742       print_target_help ();
743       exit_after_options = true;
744       break;
745
746     case OPT__version:
747       print_version (stderr, "");
748       exit_after_options = true;
749       break;
750
751     case OPT_G:
752       g_switch_value = value;
753       g_switch_set = true;
754       break;
755
756     case OPT_O:
757     case OPT_Os:
758       /* Currently handled in a prescan.  */
759       break;
760
761     case OPT_W:
762       /* For backward compatibility, -W is the same as -Wextra.  */
763       set_Wextra (value);
764       break;
765
766     case OPT_Werror_:
767       {
768         char *new_option;
769         int option_index;
770         new_option = XNEWVEC (char, strlen (arg) + 2);
771         new_option[0] = 'W';
772         strcpy (new_option+1, arg);
773         option_index = find_opt (new_option, lang_mask);
774         if (option_index == N_OPTS)
775           {
776             error ("-Werror-%s: No option -%s", arg, new_option);
777           }
778         else
779           {
780             int kind = value ? DK_ERROR : DK_WARNING;
781             diagnostic_classify_diagnostic (global_dc, option_index, kind);
782
783             /* -Werror=foo implies -Wfoo.  */
784             if (cl_options[option_index].var_type == CLVC_BOOLEAN
785                 && cl_options[option_index].flag_var
786                 && kind == DK_ERROR)
787               *(int *) cl_options[option_index].flag_var = 1;
788             free (new_option);
789           }
790       }
791       break;
792
793     case OPT_Wextra:
794       set_Wextra (value);
795       break;
796
797     case OPT_Wlarger_than_:
798       larger_than_size = value;
799       warn_larger_than = value != -1;
800       break;
801
802     case OPT_Wstrict_aliasing:
803     case OPT_Wstrict_aliasing_:
804       warn_strict_aliasing = value;
805       break;
806
807     case OPT_Wunused:
808       set_Wunused (value);
809       break;
810
811     case OPT_aux_info:
812     case OPT_aux_info_:
813       aux_info_file_name = arg;
814       flag_gen_aux_info = 1;
815       break;
816
817     case OPT_auxbase:
818       aux_base_name = arg;
819       break;
820
821     case OPT_auxbase_strip:
822       {
823         char *tmp = xstrdup (arg);
824         strip_off_ending (tmp, strlen (tmp));
825         if (tmp[0])
826           aux_base_name = tmp;
827       }
828       break;
829
830     case OPT_d:
831       decode_d_option (arg);
832       break;
833
834     case OPT_dumpbase:
835       dump_base_name = arg;
836       break;
837
838     case OPT_falign_functions_:
839       align_functions = value;
840       break;
841
842     case OPT_falign_jumps_:
843       align_jumps = value;
844       break;
845
846     case OPT_falign_labels_:
847       align_labels = value;
848       break;
849
850     case OPT_falign_loops_:
851       align_loops = value;
852       break;
853
854     case OPT_fbranch_probabilities:
855       flag_branch_probabilities_set = true;
856       break;
857
858     case OPT_fcall_used_:
859       fix_register (arg, 0, 1);
860       break;
861
862     case OPT_fcall_saved_:
863       fix_register (arg, 0, 0);
864       break;
865
866     case OPT_fdiagnostics_show_location_:
867       if (!strcmp (arg, "once"))
868         diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
869       else if (!strcmp (arg, "every-line"))
870         diagnostic_prefixing_rule (global_dc)
871           = DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE;
872       else
873         return 0;
874       break;
875
876     case OPT_fdiagnostics_show_option:
877       global_dc->show_option_requested = true;
878       break;
879
880     case OPT_fdump_:
881       if (!dump_switch_p (arg))
882         return 0;
883       break;
884
885     case OPT_ffast_math:
886       set_fast_math_flags (value);
887       break;
888
889     case OPT_ffixed_:
890       fix_register (arg, 1, 1);
891       break;
892
893     case OPT_finline_limit_:
894     case OPT_finline_limit_eq:
895       set_param_value ("max-inline-insns-single", value / 2);
896       set_param_value ("max-inline-insns-auto", value / 2);
897       break;
898
899     case OPT_fmessage_length_:
900       pp_set_line_maximum_length (global_dc->printer, value);
901       break;
902
903     case OPT_fpack_struct_:
904       if (value <= 0 || (value & (value - 1)) || value > 16)
905         error("structure alignment must be a small power of two, not %d", value);
906       else
907         {
908           initial_max_fld_align = value;
909           maximum_field_alignment = value * BITS_PER_UNIT;
910         }
911       break;
912
913     case OPT_fpeel_loops:
914       flag_peel_loops_set = true;
915       break;
916
917     case OPT_fprofile_arcs:
918       profile_arc_flag_set = true;
919       break;
920
921     case OPT_fprofile_use:
922       if (!flag_branch_probabilities_set)
923         flag_branch_probabilities = value;
924       if (!flag_profile_values_set)
925         flag_profile_values = value;
926       if (!flag_unroll_loops_set)
927         flag_unroll_loops = value;
928       if (!flag_peel_loops_set)
929         flag_peel_loops = value;
930       if (!flag_tracer_set)
931         flag_tracer = value;
932       if (!flag_value_profile_transformations_set)
933         flag_value_profile_transformations = value;
934       break;
935
936     case OPT_fprofile_generate:
937       if (!profile_arc_flag_set)
938         profile_arc_flag = value;
939       if (!flag_profile_values_set)
940         flag_profile_values = value;
941       if (!flag_value_profile_transformations_set)
942         flag_value_profile_transformations = value;
943       break;
944
945     case OPT_fprofile_values:
946       flag_profile_values_set = true;
947       break;
948
949     case OPT_fvisibility_:
950       {
951         if (!strcmp(arg, "default"))
952           default_visibility = VISIBILITY_DEFAULT;
953         else if (!strcmp(arg, "internal"))
954           default_visibility = VISIBILITY_INTERNAL;
955         else if (!strcmp(arg, "hidden"))
956           default_visibility = VISIBILITY_HIDDEN;
957         else if (!strcmp(arg, "protected"))
958           default_visibility = VISIBILITY_PROTECTED;
959         else
960           error ("unrecognized visibility value \"%s\"", arg);
961       }
962       break;
963
964     case OPT_fvpt:
965       flag_value_profile_transformations_set = true;
966       break;
967
968     case OPT_frandom_seed:
969       /* The real switch is -fno-random-seed.  */
970       if (value)
971         return 0;
972       flag_random_seed = NULL;
973       break;
974
975     case OPT_frandom_seed_:
976       flag_random_seed = arg;
977       break;
978
979     case OPT_fsched_verbose_:
980 #ifdef INSN_SCHEDULING
981       fix_sched_param ("verbose", arg);
982       break;
983 #else
984       return 0;
985 #endif
986
987     case OPT_fsched_stalled_insns_:
988       flag_sched_stalled_insns = value;
989       if (flag_sched_stalled_insns == 0)
990         flag_sched_stalled_insns = -1;
991       break;
992
993     case OPT_fsched_stalled_insns_dep_:
994       flag_sched_stalled_insns_dep = value;
995       break;
996
997     case OPT_fstack_limit:
998       /* The real switch is -fno-stack-limit.  */
999       if (value)
1000         return 0;
1001       stack_limit_rtx = NULL_RTX;
1002       break;
1003
1004     case OPT_fstack_limit_register_:
1005       {
1006         int reg = decode_reg_name (arg);
1007         if (reg < 0)
1008           error ("unrecognized register name \"%s\"", arg);
1009         else
1010           stack_limit_rtx = gen_rtx_REG (Pmode, reg);
1011       }
1012       break;
1013
1014     case OPT_fstack_limit_symbol_:
1015       stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
1016       break;
1017
1018     case OPT_ftree_vectorizer_verbose_:
1019       vect_set_verbosity_level (arg);
1020       break;
1021
1022     case OPT_ftls_model_:
1023       if (!strcmp (arg, "global-dynamic"))
1024         flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
1025       else if (!strcmp (arg, "local-dynamic"))
1026         flag_tls_default = TLS_MODEL_LOCAL_DYNAMIC;
1027       else if (!strcmp (arg, "initial-exec"))
1028         flag_tls_default = TLS_MODEL_INITIAL_EXEC;
1029       else if (!strcmp (arg, "local-exec"))
1030         flag_tls_default = TLS_MODEL_LOCAL_EXEC;
1031       else
1032         warning (0, "unknown tls-model \"%s\"", arg);
1033       break;
1034
1035     case OPT_ftracer:
1036       flag_tracer_set = true;
1037       break;
1038
1039     case OPT_funroll_loops:
1040       flag_unroll_loops_set = true;
1041       break;
1042
1043     case OPT_g:
1044       set_debug_level (NO_DEBUG, DEFAULT_GDB_EXTENSIONS, arg);
1045       break;
1046
1047     case OPT_gcoff:
1048       set_debug_level (SDB_DEBUG, false, arg);
1049       break;
1050
1051     case OPT_gdwarf_2:
1052       set_debug_level (DWARF2_DEBUG, false, arg);
1053       break;
1054
1055     case OPT_ggdb:
1056       set_debug_level (NO_DEBUG, 2, arg);
1057       break;
1058
1059     case OPT_gstabs:
1060     case OPT_gstabs_:
1061       set_debug_level (DBX_DEBUG, code == OPT_gstabs_, arg);
1062       break;
1063
1064     case OPT_gvms:
1065       set_debug_level (VMS_DEBUG, false, arg);
1066       break;
1067
1068     case OPT_gxcoff:
1069     case OPT_gxcoff_:
1070       set_debug_level (XCOFF_DEBUG, code == OPT_gxcoff_, arg);
1071       break;
1072
1073     case OPT_o:
1074       asm_file_name = arg;
1075       break;
1076
1077     case OPT_pedantic_errors:
1078       flag_pedantic_errors = pedantic = 1;
1079       break;
1080
1081     case OPT_fforce_mem:
1082       warning (0, "-f[no-]force-mem is nop and option will be removed in 4.2");
1083       break;
1084
1085     case OPT_floop_optimize:
1086     case OPT_frerun_loop_opt:
1087     case OPT_fstrength_reduce:
1088       /* These are no-ops, preserved for backward compatibility.  */
1089       break;
1090
1091     default:
1092       /* If the flag was handled in a standard way, assume the lack of
1093          processing here is intentional.  */
1094       gcc_assert (cl_options[scode].flag_var);
1095       break;
1096     }
1097
1098   return 1;
1099 }
1100
1101 /* Handle --param NAME=VALUE.  */
1102 static void
1103 handle_param (const char *carg)
1104 {
1105   char *equal, *arg;
1106   int value;
1107
1108   arg = xstrdup (carg);
1109   equal = strchr (arg, '=');
1110   if (!equal)
1111     error ("%s: --param arguments should be of the form NAME=VALUE", arg);
1112   else
1113     {
1114       value = integral_argument (equal + 1);
1115       if (value == -1)
1116         error ("invalid --param value %qs", equal + 1);
1117       else
1118         {
1119           *equal = '\0';
1120           set_param_value (arg, value);
1121         }
1122     }
1123
1124   free (arg);
1125 }
1126
1127 /* Handle -W and -Wextra.  */
1128 static void
1129 set_Wextra (int setting)
1130 {
1131   extra_warnings = setting;
1132   warn_unused_value = setting;
1133   warn_unused_parameter = (setting && maybe_warn_unused_parameter);
1134
1135   /* We save the value of warn_uninitialized, since if they put
1136      -Wuninitialized on the command line, we need to generate a
1137      warning about not using it without also specifying -O.  */
1138   if (setting == 0)
1139     warn_uninitialized = 0;
1140   else if (warn_uninitialized != 1)
1141     warn_uninitialized = 2;
1142 }
1143
1144 /* Initialize unused warning flags.  */
1145 void
1146 set_Wunused (int setting)
1147 {
1148   warn_unused_function = setting;
1149   warn_unused_label = setting;
1150   /* Unused function parameter warnings are reported when either
1151      ``-Wextra -Wunused'' or ``-Wunused-parameter'' is specified.
1152      Thus, if -Wextra has already been seen, set warn_unused_parameter;
1153      otherwise set maybe_warn_extra_parameter, which will be picked up
1154      by set_Wextra.  */
1155   maybe_warn_unused_parameter = setting;
1156   warn_unused_parameter = (setting && extra_warnings);
1157   warn_unused_variable = setting;
1158   warn_unused_value = setting;
1159 }
1160
1161 /* The following routines are useful in setting all the flags that
1162    -ffast-math and -fno-fast-math imply.  */
1163 void
1164 set_fast_math_flags (int set)
1165 {
1166   flag_trapping_math = !set;
1167   flag_unsafe_math_optimizations = set;
1168   flag_finite_math_only = set;
1169   flag_errno_math = !set;
1170   if (set)
1171     {
1172       flag_signaling_nans = 0;
1173       flag_rounding_math = 0;
1174       flag_cx_limited_range = 1;
1175     }
1176 }
1177
1178 /* Return true iff flags are set as if -ffast-math.  */
1179 bool
1180 fast_math_flags_set_p (void)
1181 {
1182   return (!flag_trapping_math
1183           && flag_unsafe_math_optimizations
1184           && flag_finite_math_only
1185           && !flag_errno_math);
1186 }
1187
1188 /* Handle a debug output -g switch.  EXTENDED is true or false to support
1189    extended output (2 is special and means "-ggdb" was given).  */
1190 static void
1191 set_debug_level (enum debug_info_type type, int extended, const char *arg)
1192 {
1193   static bool type_explicit;
1194
1195   use_gnu_debug_info_extensions = extended;
1196
1197   if (type == NO_DEBUG)
1198     {
1199       if (write_symbols == NO_DEBUG)
1200         {
1201           write_symbols = PREFERRED_DEBUGGING_TYPE;
1202
1203           if (extended == 2)
1204             {
1205 #ifdef DWARF2_DEBUGGING_INFO
1206               write_symbols = DWARF2_DEBUG;
1207 #elif defined DBX_DEBUGGING_INFO
1208               write_symbols = DBX_DEBUG;
1209 #endif
1210             }
1211
1212           if (write_symbols == NO_DEBUG)
1213             warning (0, "target system does not support debug output");
1214         }
1215     }
1216   else
1217     {
1218       /* Does it conflict with an already selected type?  */
1219       if (type_explicit && write_symbols != NO_DEBUG && type != write_symbols)
1220         error ("debug format \"%s\" conflicts with prior selection",
1221                debug_type_names[type]);
1222       write_symbols = type;
1223       type_explicit = true;
1224     }
1225
1226   /* A debug flag without a level defaults to level 2.  */
1227   if (*arg == '\0')
1228     {
1229       if (!debug_info_level)
1230         debug_info_level = 2;
1231     }
1232   else
1233     {
1234       debug_info_level = integral_argument (arg);
1235       if (debug_info_level == (unsigned int) -1)
1236         error ("unrecognised debug output level \"%s\"", arg);
1237       else if (debug_info_level > 3)
1238         error ("debug output level %s is too high", arg);
1239     }
1240 }
1241
1242 /* Display help for target options.  */
1243 static void
1244 print_target_help (void)
1245 {
1246   unsigned int i;
1247   static bool displayed = false;
1248
1249   /* Avoid double printing for --help --target-help.  */
1250   if (displayed)
1251     return;
1252
1253   displayed = true;
1254   for (i = 0; i < cl_options_count; i++)
1255     if ((cl_options[i].flags & (CL_TARGET | CL_UNDOCUMENTED)) == CL_TARGET)
1256       {
1257         printf (_("\nTarget specific options:\n"));
1258         print_filtered_help (CL_TARGET);
1259         break;
1260       }
1261 }
1262
1263 /* Output --help text.  */
1264 static void
1265 print_help (void)
1266 {
1267   size_t i;
1268   const char *p;
1269
1270   GET_ENVIRONMENT (p, "COLUMNS");
1271   if (p)
1272     {
1273       int value = atoi (p);
1274       if (value > 0)
1275         columns = value;
1276     }
1277
1278   puts (_("The following options are language-independent:\n"));
1279
1280   print_filtered_help (CL_COMMON);
1281   print_param_help ();
1282
1283   for (i = 0; lang_names[i]; i++)
1284     {
1285       printf (_("The %s front end recognizes the following options:\n\n"),
1286               lang_names[i]);
1287       print_filtered_help (1U << i);
1288     }
1289   print_target_help ();
1290 }
1291
1292 /* Print the help for --param.  */
1293 static void
1294 print_param_help (void)
1295 {
1296   size_t i;
1297
1298   puts (_("The --param option recognizes the following as parameters:\n"));
1299
1300   for (i = 0; i < LAST_PARAM; i++)
1301     {
1302       const char *help = compiler_params[i].help;
1303       const char *param = compiler_params[i].option;
1304
1305       if (help == NULL || *help == '\0')
1306         help = undocumented_msg;
1307
1308       /* Get the translation.  */
1309       help = _(help);
1310
1311       wrap_help (help, param, strlen (param));
1312     }
1313
1314   putchar ('\n');
1315 }
1316
1317 /* Print help for a specific front-end, etc.  */
1318 static void
1319 print_filtered_help (unsigned int flag)
1320 {
1321   unsigned int i, len, filter, indent = 0;
1322   bool duplicates = false;
1323   const char *help, *opt, *tab;
1324   static char *printed;
1325
1326   if (flag == CL_COMMON || flag == CL_TARGET)
1327     {
1328       filter = flag;
1329       if (!printed)
1330         printed = xmalloc (cl_options_count);
1331       memset (printed, 0, cl_options_count);
1332     }
1333   else
1334     {
1335       /* Don't print COMMON options twice.  */
1336       filter = flag | CL_COMMON;
1337
1338       for (i = 0; i < cl_options_count; i++)
1339         {
1340           if ((cl_options[i].flags & filter) != flag)
1341             continue;
1342
1343           /* Skip help for internal switches.  */
1344           if (cl_options[i].flags & CL_UNDOCUMENTED)
1345             continue;
1346
1347           /* Skip switches that have already been printed, mark them to be
1348              listed later.  */
1349           if (printed[i])
1350             {
1351               duplicates = true;
1352               indent = print_switch (cl_options[i].opt_text, indent);
1353             }
1354         }
1355
1356       if (duplicates)
1357         {
1358           putchar ('\n');
1359           putchar ('\n');
1360         }
1361     }
1362
1363   for (i = 0; i < cl_options_count; i++)
1364     {
1365       if ((cl_options[i].flags & filter) != flag)
1366         continue;
1367
1368       /* Skip help for internal switches.  */
1369       if (cl_options[i].flags & CL_UNDOCUMENTED)
1370         continue;
1371
1372       /* Skip switches that have already been printed.  */
1373       if (printed[i])
1374         continue;
1375
1376       printed[i] = true;
1377
1378       help = cl_options[i].help;
1379       if (!help)
1380         help = undocumented_msg;
1381
1382       /* Get the translation.  */
1383       help = _(help);
1384
1385       tab = strchr (help, '\t');
1386       if (tab)
1387         {
1388           len = tab - help;
1389           opt = help;
1390           help = tab + 1;
1391         }
1392       else
1393         {
1394           opt = cl_options[i].opt_text;
1395           len = strlen (opt);
1396         }
1397
1398       wrap_help (help, opt, len);
1399     }
1400
1401   putchar ('\n');
1402 }
1403
1404 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1405    word-wrapped HELP in a second column.  */
1406 static unsigned int
1407 print_switch (const char *text, unsigned int indent)
1408 {
1409   unsigned int len = strlen (text) + 1; /* trailing comma */
1410
1411   if (indent)
1412     {
1413       putchar (',');
1414       if (indent + len > columns)
1415         {
1416           putchar ('\n');
1417           putchar (' ');
1418           indent = 1;
1419         }
1420     }
1421   else
1422     putchar (' ');
1423
1424   putchar (' ');
1425   fputs (text, stdout);
1426
1427   return indent + len + 1;
1428 }
1429
1430 /* Output ITEM, of length ITEM_WIDTH, in the left column, followed by
1431    word-wrapped HELP in a second column.  */
1432 static void
1433 wrap_help (const char *help, const char *item, unsigned int item_width)
1434 {
1435   unsigned int col_width = 27;
1436   unsigned int remaining, room, len;
1437
1438   remaining = strlen (help);
1439
1440   do
1441     {
1442       room = columns - 3 - MAX (col_width, item_width);
1443       if (room > columns)
1444         room = 0;
1445       len = remaining;
1446
1447       if (room < len)
1448         {
1449           unsigned int i;
1450
1451           for (i = 0; help[i]; i++)
1452             {
1453               if (i >= room && len != remaining)
1454                 break;
1455               if (help[i] == ' ')
1456                 len = i;
1457               else if ((help[i] == '-' || help[i] == '/')
1458                        && help[i + 1] != ' '
1459                        && i > 0 && ISALPHA (help[i - 1]))
1460                 len = i + 1;
1461             }
1462         }
1463
1464       printf( "  %-*.*s %.*s\n", col_width, item_width, item, len, help);
1465       item_width = 0;
1466       while (help[len] == ' ')
1467         len++;
1468       help += len;
1469       remaining -= len;
1470     }
1471   while (remaining);
1472 }
1473
1474 /* Return 1 if OPTION is enabled, 0 if it is disabled, or -1 if it isn't
1475    a simple on-off switch.  */
1476
1477 int
1478 option_enabled (int opt_idx)
1479 {
1480   const struct cl_option *option = &(cl_options[opt_idx]);
1481   if (option->flag_var)
1482     switch (option->var_type)
1483       {
1484       case CLVC_BOOLEAN:
1485         return *(int *) option->flag_var != 0;
1486
1487       case CLVC_EQUAL:
1488         return *(int *) option->flag_var == option->var_value;
1489
1490       case CLVC_BIT_CLEAR:
1491         return (*(int *) option->flag_var & option->var_value) == 0;
1492
1493       case CLVC_BIT_SET:
1494         return (*(int *) option->flag_var & option->var_value) != 0;
1495
1496       case CLVC_STRING:
1497         break;
1498       }
1499   return -1;
1500 }
1501
1502 /* Fill STATE with the current state of option OPTION.  Return true if
1503    there is some state to store.  */
1504
1505 bool
1506 get_option_state (int option, struct cl_option_state *state)
1507 {
1508   if (cl_options[option].flag_var == 0)
1509     return false;
1510
1511   switch (cl_options[option].var_type)
1512     {
1513     case CLVC_BOOLEAN:
1514     case CLVC_EQUAL:
1515       state->data = cl_options[option].flag_var;
1516       state->size = sizeof (int);
1517       break;
1518
1519     case CLVC_BIT_CLEAR:
1520     case CLVC_BIT_SET:
1521       state->ch = option_enabled (option);
1522       state->data = &state->ch;
1523       state->size = 1;
1524       break;
1525
1526     case CLVC_STRING:
1527       state->data = *(const char **) cl_options[option].flag_var;
1528       if (state->data == 0)
1529         state->data = "";
1530       state->size = strlen (state->data) + 1;
1531       break;
1532     }
1533   return true;
1534 }