OSDN Git Service

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