OSDN Git Service

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