OSDN Git Service

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