OSDN Git Service

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